### Sample Ritual Recipe Configuration

Source: https://github.com/klikli-dev/occultism/blob/version/26.1/src/main/resources/data/occultism/recipe/ritual/00_readme.md

A comprehensive example of a ritual recipe JSON definition, including various ritual types, activation requirements, and conditional logic.

```json
{
  "type": "occultism:ritual",
  "ritual_type": "occultism:summon",
  "ritual_type": "occultism:summon_tamed",
  "ritual_type": "occultism:summon_spirit_with_job",
  "ritual_type": "occultism:summon_wild_hunt",
  "ritual_type": "occultism:familiar",
  "ritual_type": "occultism:craft",
  "ritual_type": "occultism:craft_with_spirit_name",
  "ritual_type": "occultism:craft_miner_spirit",
  "ritual_type": "occultism:execute_command",
  "activation_item": {
    "item": "occultism:book_of_binding_bound_foliot"
  },
  "pentacle_id": "occultism:summon_foliot",
  "duration": 60,
  "spirit_max_age": 86400,
  "spirit_job_type": "occultism:crush_tier1",
  "item_to_use": {
    "item": "minecraft:egg"
  },
  "entity_to_sacrifice": {
    "tag": "c:cows",
    "display_name": "ritual.occultism.sacrifice.cows"
  },
  "entity_to_summon": "minecraft:sheep",
  "entity_nbt": {
    "RabbitType": 99
  },
  "ritual_dummy": {
    "id": "occultism:ritual_dummy/custom_ritual"
  },
  "ingredients": [
    {
      "tag": "c:ores/iron"
    },
    {
      "item": "minecraft:egg"
    }
  ],
  "result": {
    "id": "occultism:jei_dummy/none"
  },
  "command": "execute run say hi",
  "condition": {
    "type": "neoforge:or",
    "values": [
      {
        "type": "occultism:is_in_dimension_type",
        "dimension_type": "minecraft:the_nether"
      },
      {
        "type": "occultism:is_in_biome_with_tag",
        "tag": "minecraft:has_structure/nether_fortress"
      }
    ]
  }
}
```

--------------------------------

### Configure Spirit Entity Behavior

Source: https://context7.com/klikli-dev/occultism/llms.txt

Java example for configuring spirit worker parameters such as work areas, deposit/extract positions, and item filters.

```java
import com.klikli_dev.occultism.common.entity.spirit.SpiritEntity;
import com.klikli_dev.occultism.common.entity.job.SpiritJob;
import com.klikli_dev.occultism.api.common.data.WorkAreaSize;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;

public class SpiritInteractionExample {

    public void configureSpiritWorker(SpiritEntity spirit) {
        // Set work area center and size
        BlockPos workCenter = new BlockPos(100, 64, 200);
        spirit.setWorkAreaPosition(workCenter);
        spirit.setWorkAreaSize(WorkAreaSize.MEDIUM); // SMALL, MEDIUM, LARGE

        // Configure deposit location (where spirit puts items)
        BlockPos chestPos = new BlockPos(95, 64, 200);
        spirit.setDepositPosition(chestPos);
        spirit.setDepositFacing(Direction.UP);

        // Configure extract location (where spirit gets items)
        BlockPos inputChestPos = new BlockPos(105, 64, 200);
        spirit.setExtractPosition(inputChestPos);
        spirit.setExtractFacing(Direction.DOWN);

        // Get spirit's current job
        spirit.getJob().ifPresent(job -> {
            System.out.println("Spirit job: " + job.getFactoryID());
        });

        // Check spirit age (for timed spirits)
        int age = spirit.getSpiritAge();
        int maxAge = spirit.getSpiritMaxAge();
        if (maxAge > 0) {
            System.out.println("Spirit age: " + age + "/" + maxAge + " seconds");
        }

        // Configure item filter
        spirit.setFilterBlacklist(false); // whitelist mode
        ItemStackHandler filterHandler = spirit.getFilterItems();
        filterHandler.setStackInSlot(0, new ItemStack(Items.IRON_ORE));

        // Set tag filter (comma-separated tags)
        spirit.setTagFilter("c:ores/iron,c:ores/gold");
    }
}
```

--------------------------------

### Interact with Occultism Spirits

Source: https://context7.com/klikli-dev/occultism/llms.txt

Use OccultismAPI to get the API instance and query spirit capabilities. Check what items a spirit can pick up based on its assigned jobs, or if it can pick up a specific item.

```java
import com.klikli_dev.occultism.api.OccultismAPI;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.item.crafting.Ingredient;
import java.util.List;
import java.util.Optional;

// Get the API instance
OccultismAPI api = OccultismAPI.get();

// Check what items a spirit entity can pick up based on its job
Entity spiritEntity = /* your spirit entity */;
Optional<List<Ingredient>> itemsToPickUp = api.getItemsToPickUp(spiritEntity);

itemsToPickUp.ifPresent(ingredients -> {
    System.out.println("Spirit can pick up " + ingredients.size() + " ingredient types");
});

// Check if a spirit can pick up a specific item
ItemEntity droppedItem = /* item on ground */;
Optional<Boolean> canPickup = api.canPickupItem(spiritEntity, droppedItem);

canPickup.ifPresent(result -> {
    if (result) {
        System.out.println("Spirit will pick up this item");
    }
});
```

--------------------------------

### Execute and Validate Rituals

Source: https://context7.com/klikli-dev/occultism/llms.txt

Shows how to find and validate ritual recipes, check requirements, and access ritual constants.

```java
import com.klikli_dev.occultism.common.ritual.Ritual;
import com.klikli_dev.occultism.crafting.recipe.RitualRecipe;
import net.minecraft.core.BlockPos;
import net.minecraft.world.level.Level;
import net.minecraft.world.item.ItemStack;

// Ritual types available:
// - CraftRitual: Creates items
// - SummonRitual: Summons entities
// - SummonSpiritWithJobRitual: Summons working spirits
// - FamiliarRitual: Summons familiars
// - CommandRitual: Executes commands

// Ritual identification and validation
public void performRitual(Level level, BlockPos goldenBowlPos, ItemStack activationItem) {
    // Find matching ritual recipe
    RecipeManager recipes = level.getRecipeManager();
    List<RecipeHolder<RitualRecipe>> rituals = recipes.getAllRecipesFor(OccultismRecipes.RITUAL_TYPE.get());

    for (RecipeHolder<RitualRecipe> holder : rituals) {
        RitualRecipe recipe = holder.value();

        // Check if ritual matches current setup
        if (recipe.matches(level, goldenBowlPos, activationItem)) {
            Ritual ritual = recipe.getRitual();

            // Validate pentacle pattern
            if (ritual.identify(level, goldenBowlPos, activationItem)) {
                // Check sacrifice requirements
                if (recipe.requiresSacrifice()) {
                    System.out.println("Requires sacrifice: " + recipe.getEntityToSacrificeDisplayName());
                }

                // Check item use requirements
                if (recipe.requiresItemUse()) {
                    System.out.println("Requires item use during ritual");
                }

                // Get ritual duration
                int duration = recipe.getDuration();
                float perIngredient = recipe.getDurationPerIngredient();

                System.out.println("Ritual found: " + holder.id());
                break;
            }
        }
    }
}

// Ritual constants
int sacrificialBowlRange = Ritual.SACRIFICIAL_BOWL_RANGE; // 8 blocks
int sacrificeDetectionRange = Ritual.SACRIFICE_DETECTION_RANGE; // 8 blocks
int itemUseDetectionRange = Ritual.ITEM_USE_DETECTION_RANGE; // 16 blocks
```

--------------------------------

### Implement and Assign Spirit Jobs

Source: https://context7.com/klikli-dev/occultism/llms.txt

Demonstrates how to instantiate a SpiritJob from NBT, assign it to an entity, and implement a custom job class by extending SpiritJob.

```java
import com.klikli_dev.occultism.common.entity.job.SpiritJob;
import com.klikli_dev.occultism.common.entity.spirit.SpiritEntity;
import com.klikli_dev.occultism.registry.OccultismSpiritJobs;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.resources.Identifier;

// Available spirit job types:
// - occultism:crush_tier1, crush_tier2, crush_tier3, crush_tier4 (ore processing)
// - occultism:lumberjack (tree farming)
// - occultism:farmer (crop farming)
// - occultism:transport_items (item transportation)
// - occultism:cleaner (pickup items)
// - occultism:trade_trader (trading)
// - occultism:manage_machine (autocrafting)
// - occultism:clear_weather, occultism:rain_weather, occultism:thunder_weather
// - occultism:day_time, occultism:night_time

// Create a job from NBT (factory pattern)
CompoundTag jobNbt = new CompoundTag();
jobNbt.putString("factoryId", "occultism:crush_tier2");
SpiritJob crushJob = SpiritJob.from(spiritEntity, jobNbt);

// Assign job to spirit
spiritEntity.setJob(crushJob);

// Custom job implementation example
public class CustomJob extends SpiritJob {

    public CustomJob(SpiritEntity entity) {
        super(entity);
    }

    @Override
    protected void onInit() {
        // Setup job-specific brain memories
    }

    @Override
    public void cleanup() {
        // Clean up when job is removed
    }

    @Override
    public void update() {
        // Called every tick while job is active
    }

    @Override
    public boolean canPickupItem(ItemEntity itemEntity) {
        // Define what items this job allows picking up
        return itemEntity.getItem().is(Items.COAL);
    }

    @Override
    public List<Ingredient> getItemsToPickUp() {
        return List.of(Ingredient.of(Items.COAL));
    }
}
```

--------------------------------

### Interact with FamiliarEntity in Java

Source: https://context7.com/klikli-dev/occultism/llms.txt

Demonstrates how to interact with a FamiliarEntity, checking ownership, toggling sitting state, and checking for upgrades. Familiars provide passive bonuses and can be stored in rings.

```java
import com.klikli_dev.occultism.common.entity.familiar.FamiliarEntity;
import com.klikli_dev.occultism.common.entity.familiar.IFamiliar;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.player.Player;

// Available familiar types:
// - BatFamiliar, BeaverFamiliar, BeholderFamiliar
// - BlacksmithFamiliar (repairs equipment)
// - ChimeraFamiliar, CthulhuFamiliar
// - DeerFamiliar, DevilFamiliar, DragonFamiliar
// - FairyFamiliar (night vision)
// - GoatFamiliar, GreedyFamiliar (item pickup)
// - GuardianFamiliar (protection)
// - HeadlessFamiliar, MummyFamiliar
// - OtherworldBirdFamiliar (draconic familiar variant)
// - ShubNiggurathFamiliar

public class FamiliarInteractionExample {

    public void interactWithFamiliar(FamiliarEntity familiar, Player player) {
        // Check if familiar belongs to player
        LivingEntity owner = familiar.getFamiliarOwner();
        if (owner == player) {
            // Toggle sitting
            boolean isSitting = familiar.isSitting();
            familiar.setFamiliarSitting(!isSitting);

            // Check for blacksmith upgrade
            if (familiar.hasBlacksmithUpgrade()) {
                System.out.println("Familiar has blacksmith upgrade");
            }

            // Store in familiar ring
            ItemStack familiarRing = new ItemStack(OccultismItems.FAMILIAR_RING.get());
            // Use ring on familiar to capture

            // Familiars provide effects when near owner
            float maxBoostDistance = 8.0f; // MAX_BOOST_DISTANCE
        }
    }
}
```

--------------------------------

### Manage Occultism Storage Network

Source: https://context7.com/klikli-dev/occultism/llms.txt

Implement storage controller functionality using IStorageController. Insert and extract items, check capacity, link machines for autocrafting, and create deposit orders for spirits.

```java
import com.klikli_dev.occultism.api.common.blockentity.IStorageController;
import com.klikli_dev.occultism.api.common.container.IItemStackComparator;
import com.klikli_dev.occultism.api.common.data.GlobalBlockPos;
import com.klikli_dev.occultism.api.common.data.MachineReference;
import net.minecraft.world.item.ItemStack;
import java.util.List;
import java.util.function.Predicate;

public class StorageControllerExample {

    public void demonstrateStorageController(IStorageController controller) {
        // Get all stacks in the storage network
        List<ItemStack> allItems = controller.getStacks();
        System.out.println("Storage contains " + allItems.size() + " different item types");

        // Check storage capacity
        int maxTypes = controller.getMaxItemTypes();
        int usedTypes = controller.getUsedItemTypes();
        System.out.println("Using " + usedTypes + "/" + maxTypes + " item type slots");

        // Insert an item into the network
        ItemStack toInsert = new ItemStack(Items.DIAMOND, 64);
        int remaining = controller.insertStack(toInsert, false); // false = not simulating
        if (remaining == 0) {
            System.out.println("All items inserted successfully");
        }

        // Extract items matching a predicate
        Predicate<ItemStack> isDiamond = stack -> stack.is(Items.DIAMOND);
        ItemStack extracted = controller.getItemStack(isDiamond, 32, false);
        System.out.println("Extracted: " + extracted.getCount() + " diamonds");

        // Get the most common matching item (useful for autocrafting)
        ItemStack mostCommon = controller.getOneOfMostCommonItem(isDiamond, false);

        // Check item availability
        int available = controller.getAvailableAmount(myComparator);

        // Link a machine for autocrafting
        MachineReference machineRef = new MachineReference(machinePos, machineBlockEntity);
        controller.linkMachine(machineRef);

        // Create a deposit order for spirits to fulfill
        controller.addDepositOrder(linkedMachinePos, itemComparator, 64);
        controller.addDepositOrderSpirit(linkedMachinePos, spiritUUID);
    }
}
```

--------------------------------

### Register Custom Recipe Types in Java

Source: https://context7.com/klikli-dev/occultism/llms.txt

Shows how to register custom recipe types and serializers for Occultism's crafting systems. Use DeferredRegister for custom recipes.

```java
import com.klikli_dev.occultism.registry.OccultismRecipes;
import net.minecraft.world.item.crafting.RecipeType;
import net.minecraft.world.item.crafting.RecipeSerializer;
import net.neoforged.neoforge.registries.DeferredRegister;

// Occultism recipe types available:
public class RecipeTypesExample {

    // Access existing recipe types
    RecipeType<?> spiritTrade = OccultismRecipes.SPIRIT_TRADE_TYPE.get();
    RecipeType<?> spiritFire = OccultismRecipes.SPIRIT_FIRE_TYPE.get();
    RecipeType<?> crushing = OccultismRecipes.CRUSHING_TYPE.get();
    RecipeType<?> crystallize = OccultismRecipes.CRYSTALLIZE_TYPE.get();
    RecipeType<?> miner = OccultismRecipes.MINER_TYPE.get();
    RecipeType<?> ritual = OccultismRecipes.RITUAL_TYPE.get();

    // Register custom recipes in your mod
    public static final DeferredRegister<RecipeType<?>> RECIPE_TYPES =
        DeferredRegister.create(BuiltInRegistries.RECIPE_TYPE, "yourmod");

    public static final DeferredRegister<RecipeSerializer<?>> SERIALIZERS =
        DeferredRegister.create(BuiltInRegistries.RECIPE_SERIALIZER, "yourmod");
}
```

--------------------------------

### IStorageController - Storage Network Interface

Source: https://context7.com/klikli-dev/occultism/llms.txt

Interface for implementing storage controller functionality. Provides methods for inserting and extracting items from the dimensional storage network, managing linked machines for autocrafting, and handling deposit orders.

```APIDOC
## IStorageController - Storage Network Interface

### Description
Interface for implementing storage controller functionality. Provides methods for inserting and extracting items from the dimensional storage network, managing linked machines for autocrafting, and handling deposit orders.

### Method
N/A (This is an in-game API, not a REST endpoint)

### Endpoint
N/A (This is an in-game API, not a REST endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import com.klikli_dev.occultism.api.common.blockentity.IStorageController;
import com.klikli_dev.occultism.api.common.container.IItemStackComparator;
import com.klikli_dev.occultism.api.common.data.GlobalBlockPos;
import com.klikli_dev.occultism.api.common.data.MachineReference;
import net.minecraft.world.item.ItemStack;
import java.util.List;
import java.util.function.Predicate;

public class StorageControllerExample {

    public void demonstrateStorageController(IStorageController controller) {
        // Get all stacks in the storage network
        List<ItemStack> allItems = controller.getStacks();
        System.out.println("Storage contains " + allItems.size() + " different item types");

        // Check storage capacity
        int maxTypes = controller.getMaxItemTypes();
        int usedTypes = controller.getUsedItemTypes();
        System.out.println("Using " + usedTypes + "/" + maxTypes + " item type slots");

        // Insert an item into the network
        ItemStack toInsert = new ItemStack(Items.DIAMOND, 64);
        int remaining = controller.insertStack(toInsert, false); // false = not simulating
        if (remaining == 0) {
            System.out.println("All items inserted successfully");
        }

        // Extract items matching a predicate
        Predicate<ItemStack> isDiamond = stack -> stack.is(Items.DIAMOND);
        ItemStack extracted = controller.getItemStack(isDiamond, 32, false);
        System.out.println("Extracted: " + extracted.getCount() + " diamonds");

        // Get the most common matching item (useful for autocrafting)
        ItemStack mostCommon = controller.getOneOfMostCommonItem(isDiamond, false);

        // Check item availability
        int available = controller.getAvailableAmount(myComparator);

        // Link a machine for autocrafting
        MachineReference machineRef = new MachineReference(machinePos, machineBlockEntity);
        controller.linkMachine(machineRef);

        // Create a deposit order for spirits to fulfill
        controller.addDepositOrder(linkedMachinePos, itemComparator, 64);
        controller.addDepositOrderSpirit(linkedMachinePos, spiritUUID);
    }
}
```

### Response
#### Success Response (200)
- **getStacks()**: Returns a List of ItemStack representing all items in the storage network.
- **getMaxItemTypes()**: Returns an integer for the maximum number of item types the storage can hold.
- **getUsedItemTypes()**: Returns an integer for the current number of item types stored.
- **insertStack(ItemStack stack, boolean simulate)**: Inserts an ItemStack into the network. Returns the number of items that could not be inserted. `simulate` (boolean) if true, the operation is only simulated.
- **getItemStack(Predicate<ItemStack> predicate, int count, boolean simulate)**: Extracts a specified count of items matching the predicate. Returns the extracted ItemStack. `simulate` (boolean) if true, the operation is only simulated.
- **getOneOfMostCommonItem(Predicate<ItemStack> predicate, boolean simulate)**: Returns one of the most common items matching the predicate. `simulate` (boolean) if true, the operation is only simulated.
- **getAvailableAmount(IItemStackComparator comparator)**: Returns the available amount of items matching the comparator.
- **linkMachine(MachineReference machineRef)**: Links a machine to the storage controller for autocrafting.
- **addDepositOrder(GlobalBlockPos pos, IItemStackComparator comparator, int count)**: Adds a deposit order for spirits to fulfill.
- **addDepositOrderSpirit(GlobalBlockPos pos, UUID spiritUUID)**: Adds a deposit order specifically for a spirit.

#### Response Example
```json
{
  "getStacks": [
    {
      "item": "minecraft:diamond",
      "count": 64
    }
  ],
  "getMaxItemTypes": 1000,
  "getUsedItemTypes": 500,
  "insertStack": 0,
  "getItemStack": {
    "item": "minecraft:diamond",
    "count": 32
  },
  "getOneOfMostCommonItem": {
    "item": "minecraft:diamond",
    "count": 1
  },
  "getAvailableAmount": 128
}
```
```

--------------------------------

### Sample Crushing Recipe JSON

Source: https://github.com/klikli-dev/occultism/blob/version/26.1/src/main/resources/data/occultism/recipe/crushing/00_readme.md

This JSON defines a sample crushing recipe. It specifies the ingredient (copper ore tag), the required tier for the crusher spirit (tier 3), the output item (copper dust with a count of 2), the crushing time in ticks, and whether to ignore the crushing multiplier.

```json
{
  "type": "occultism:crushing",
  "ingredient": {
    "tag": "c:ores/copper"
  },
  "min_tier": 3,
  "max_tier": 3,
  "result": {
    "item": "occultism:copper_dust",
    "count": 2
  },
  "crushing_time": 200,
  "ignore_crushing_multiplier": false
}
```

--------------------------------

### Configure Maven Repository for Occultism

Source: https://github.com/klikli-dev/occultism/blob/version/26.1/README.md

Add the Cloudsmith repository to your Gradle build file to access Occultism artifacts.

```gradle
repositories {

  ...

  maven {
    url "https://dl.cloudsmith.io/public/klikli-dev/mods/maven/"
    content {
        includeGroup "com.klikli_dev"
    }
  }
  
  ...
  
}
```

--------------------------------

### Define Spirit Fire Transformation Recipes

Source: https://context7.com/klikli-dev/occultism/llms.txt

JSON recipes for transforming items via Spirit Fire. Requires the occultism:spirit_fire type.

```json
// Example: Transform andesite into otherstone
// File: data/occultism/recipe/spirit_fire/otherstone.json
{
  "type": "occultism:spirit_fire",
  "ingredient": "minecraft:andesite",
  "result": {
    "id": "occultism:otherstone"
  }
}
```

```json
// Example: Create chalk from colored dye
// File: data/occultism/recipe/spirit_fire/chalk_gold.json
{
  "type": "occultism:spirit_fire",
  "ingredient": "#c:dyes/yellow",
  "result": {
    "id": "occultism:chalk_gold"
  }
}
```

```json
// Example: Create book of binding
// File: data/occultism/recipe/spirit_fire/book_of_binding_empty.json
{
  "type": "occultism:spirit_fire",
  "ingredient": "occultism:taboo_book",
  "result": {
    "id": "occultism:book_of_binding_empty"
  }
}
```

--------------------------------

### Define Dimensional Miner Recipes

Source: https://context7.com/klikli-dev/occultism/llms.txt

JSON recipes for configuring dimensional miner outputs. Uses weighted results to determine item extraction probability.

```json
// Example: Mine iron ore with weight
// File: data/occultism/recipe/miner/ores/iron_ore.json
{
  "type": "occultism:miner",
  "ingredient": "#occultism:miners/ores",
  "result": {
    "type": "occultism:weighted_tag",
    "count": 1,
    "tag": "c:ores/iron",
    "weight": 750
  }
}
```

```json
// Example: Master miner - rare ancient debris
// File: data/occultism/recipe/miner/master/ancient_debris.json
{
  "type": "occultism:miner",
  "ingredient": "#occultism:miners/master",
  "result": {
    "type": "occultism:weighted",
    "count": 1,
    "item": "minecraft:ancient_debris",
    "weight": 15
  }
}
```

```json
// Example: Basic resources mining
// File: data/occultism/recipe/miner/basic_resources/stone.json
{
  "type": "occultism:miner",
  "ingredient": "#occultism:miners/basic_resources",
  "result": {
    "type": "occultism:weighted",
    "count": 1,
    "item": "minecraft:stone",
    "weight": 600
  }
}
```

--------------------------------

### CrushingRecipe - Diamond Dust with Tier Restrictions

Source: https://context7.com/klikli-dev/occultism/llms.txt

Defines a spirit crusher recipe for diamond dust from ore, with specific tier restrictions and crushing time. This recipe demonstrates how to set a minimum spirit tier and a custom crushing duration, while ignoring the global crushing multiplier.

```json
// Example: Crush with tier restrictions
// File: data/occultism/recipe/crushing/diamond_dust_from_ore.json
{
  "type": "occultism:crushing",
  "ingredient": "#c:ores/diamond",
  "min_tier": 2,
  "crushing_time": 400,
  "ignore_crushing_multiplier": false,
  "result": {
    "type": "occultism:tag",
    "count": 3,
    "tag": "c:dusts/diamond"
  }
}
```

--------------------------------

### GlobalBlockPos - Cross-Dimensional Position Utility

Source: https://context7.com/klikli-dev/occultism/llms.txt

Use GlobalBlockPos to store block positions that can span multiple dimensions. It supports creation from a position and level, or directly from a block entity. Serialization and deserialization to NBT, as well as usage with network buffers, are also supported.

```java
import com.klikli_dev.occultism.api.common.data.GlobalBlockPos;
import net.minecraft.core.BlockPos;
import net.minecraft.resources.ResourceKey;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.BlockEntity;

// Create from position and level
BlockPos pos = new BlockPos(100, 64, 200);
Level level = /* your level */;
GlobalBlockPos globalPos = new GlobalBlockPos(pos, level);

// Create from a block entity
BlockEntity blockEntity = /* your block entity */;
GlobalBlockPos fromEntity = GlobalBlockPos.from(blockEntity);

// Access the position and dimension
BlockPos blockPos = globalPos.getPos();
ResourceKey<Level> dimension = globalPos.getDimensionKey();

System.out.println("Position: " + globalPos.toString());
// Output: [minecraft:overworld, x=100, y=64, z=200]

// Serialize to NBT for network/storage
HolderLookup.Provider provider = /* registry provider */;
CompoundTag tag = new CompoundTag();
GlobalBlockPos.CODEC.encode(globalPos, provider.createSerializationContext(NbtOps.INSTANCE), tag);

// Deserialize from NBT
GlobalBlockPos restored = GlobalBlockPos.from(provider, tag);

// Use with network buffers
RegistryFriendlyByteBuf buf = /* network buffer */;
GlobalBlockPos.STREAM_CODEC.encode(buf, globalPos);
GlobalBlockPos decoded = GlobalBlockPos.STREAM_CODEC.decode(buf);
```

--------------------------------

### CrushingRecipe - Iron Dust from Ore

Source: https://context7.com/klikli-dev/occultism/llms.txt

Defines a spirit crusher recipe to convert iron ore into iron dust. This recipe includes conditions to ensure the ore and dust tags are not empty and specifies a 2x output count. It is intended for use with the Occultism mod's spirit crushing system.

```json
// Example: Crush iron ore into iron dust (2x output)
// File: data/occultism/recipe/crushing/iron_dust_from_ore.json
{
  "neoforge:conditions": [
    {
      "type": "neoforge:not",
      "value": { "type": "neoforge:tag_empty", "tag": "c:ores/iron" }
    },
    {
      "type": "neoforge:not",
      "value": { "type": "neoforge:tag_empty", "tag": "c:dusts/iron" }
    }
  ],
  "type": "occultism:crushing",
  "ingredient": "#c:ores/iron",
  "result": {
    "type": "occultism:tag",
    "count": 2,
    "tag": "c:dusts/iron"
  }
}
```

--------------------------------

### Declare Occultism Dependency

Source: https://github.com/klikli-dev/occultism/blob/version/26.1/README.md

Include the Occultism mod as a deobfuscated dependency in your project's dependencies block.

```gradle
dependencies {
 
    ...
    
    implementation fg.deobf("com.klikli_dev:occultism-${minecraft_version}:${occultism_version}")
    
    ...
    
}
```

--------------------------------

### RitualRecipe - Summon Djinni Crusher Spirit

Source: https://context7.com/klikli-dev/occultism/llms.txt

Defines a ritual to summon a Djinni Crusher spirit. Requires specific pentacle, activation item, and ingredients. The result is a spawn egg for the Djinni.

```json
// Example: Summon a Djinni Crusher spirit
// File: data/occultism/recipe/ritual/summon_djinni_crusher.json
{
  "type": "occultism:ritual",
  "ritual_type": "occultism:summon_spirit_with_job",
  "pentacle_id": "occultism:summon_djinni",
  "activation_item": "occultism:book_of_binding_bound_djinni",
  "duration": 120,
  "entity_to_summon": "occultism:djinni",
  "spirit_job_type": "occultism:crush_tier2",
  "ingredients": [
    "#c:dusts/iron",
    "#c:dusts/gold",
    "#c:dusts/copper",
    "#c:dusts/silver"
  ],
  "ritual_dummy": {
    "id": "occultism:ritual_dummy/summon_djinni_crusher"
  },
  "result": {
    "id": "occultism:spawn_egg/djinni",
    "components": {
      "minecraft:item_name": {
        "translate": "item.occultism.ritual_dummy.summon_djinni_crusher"
      }
    }
  }
}
```

--------------------------------

### OccultismAPI - Spirit Interaction API

Source: https://context7.com/klikli-dev/occultism/llms.txt

Interact with summoned spirits to query their capabilities, such as what items they can pick up based on their assigned jobs.

```APIDOC
## OccultismAPI - Spirit Interaction API

### Description
Provides methods to query what items spirits can pick up based on their assigned jobs.

### Method
GET (Implied by API usage)

### Endpoint
N/A (This is an in-game API, not a REST endpoint)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import com.klikli_dev.occultism.api.OccultismAPI;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.item.crafting.Ingredient;
import java.util.List;
import java.util.Optional;

// Get the API instance
OccultismAPI api = OccultismAPI.get();

// Check what items a spirit entity can pick up based on its job
Entity spiritEntity = /* your spirit entity */;
Optional<List<Ingredient>> itemsToPickUp = api.getItemsToPickUp(spiritEntity);

itemsToPickUp.ifPresent(ingredients -> {
    System.out.println("Spirit can pick up " + ingredients.size() + " ingredient types");
});

// Check if a spirit can pick up a specific item
ItemEntity droppedItem = /* item on ground */;
Optional<Boolean> canPickup = api.canPickupItem(spiritEntity, droppedItem);

canPickup.ifPresent(result -> {
    if (result) {
        System.out.println("Spirit will pick up this item");
    }
});
```

### Response
#### Success Response (200)
- **itemsToPickUp** (Optional<List<Ingredient>>) - A list of ingredients representing item types the spirit can pick up.
- **canPickupItem** (Optional<Boolean>) - A boolean indicating if the spirit can pick up the specified item.

#### Response Example
```json
{
  "itemsToPickUp": [
    {
      "item": "minecraft:iron_ingot",
      "count": 1
    }
  ]
}
```
```json
{
  "canPickupItem": true
}
```
```

--------------------------------

### RitualRecipe - Summon Tamed Dragon Familiar

Source: https://context7.com/klikli-dev/occultism/llms.txt

Defines a ritual to summon a tamed Dragon Familiar. This ritual requires a sacrifice of horses, specific pentacle, activation item, and various ingredients. The result is a spawn egg for the Dragon Familiar.

```json
// Example: Summon a Dragon Familiar (requires sacrifice)
// File: data/occultism/recipe/ritual/familiar_dragon.json
{
  "type": "occultism:ritual",
  "ritual_type": "occultism:summon_tamed",
  "pentacle_id": "occultism:possess_djinni",
  "activation_item": "occultism:book_of_binding_bound_djinni",
  "duration": 90,
  "entity_to_summon": "occultism:dragon_familiar",
  "entity_to_sacrifice": {
    "tag": "c:horses",
    "display_name": "ritual.occultism.sacrifice.horses"
  },
  "ingredients": [
    "minecraft:lava_bucket",
    "minecraft:flint_and_steel",
    "#minecraft:coals",
    "minecraft:quartz_block",
    "#c:storage_blocks/gold",
    "#c:gunpowders",
    "minecraft:obsidian",
    "minecraft:obsidian"
  ],
  "ritual_dummy": {
    "id": "occultism:ritual_dummy/familiar_dragon"
  },
  "result": {
    "id": "occultism:spawn_egg/familiar_dragon"
  }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.