block and sacrifice removal upon successful summoning

gradle.properties

@@ -26,7 +26,7 @@ group = dev.hytalemodding
 manifest_group = HytaleModding
 
 # Human-readable mod name.
-mod_name = Replace Me
+mod_name = Ritual Mod
 
 # Fully-qualified plugin entry point class.
 main_class = dev.hytalemodding.RitualPlugin

src/main/java/dev/hytalemodding/RitualSetupState.java

@@ -0,0 +1,7 @@
+package dev.hytalemodding;
+
+public enum RitualSetupState {
+    INCOMPLETE,
+    COMPLETE,
+    CHANGED
+}

src/main/java/dev/hytalemodding/RitualSpawner.java

@@ -1,82 +1,317 @@
 package dev.hytalemodding;
 
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.RemoveReason;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.math.vector.Rotation3f;
 import com.hypixel.hytale.protocol.SoundCategory;
+import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
 import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
 import com.hypixel.hytale.server.core.universe.world.SoundUtil;
 import com.hypixel.hytale.server.core.universe.world.World;
-import dev.hytalemodding.definitions.RitualDefinitions;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
-import dev.hytalemodding.definitions.RitualPattern;
+import com.hypixel.hytale.server.npc.NPCPlugin;
-import dev.hytalemodding.definitions.RitualTypes;
+import dev.hytalemodding.definitions.*;
 import org.joml.Vector3d;
 import org.joml.Vector3i;
+
+import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class RitualSpawner {
     RitualDefinitions ritualDefinitions = new RitualDefinitions();
 
-    public void blockChangeEvent(String itemId, Vector3i targetPosition, World world) {
+    public void blockChangeEvent(String blockId, Vector3i targetPosition, World world, boolean gotPlaced) {
-        String blockId = Objects.requireNonNull(world.getBlockType(targetPosition)).getId();
+        String placedRemovedString;
+        if (gotPlaced) {
+            placedRemovedString = "placed";
+        } else {
+            placedRemovedString = "removed";
+        }
         RitualPlugin.LOGGER.atInfo().log(
-                "a block got placed or removed at the position: %d - %d - %d with the block id: %s and with the item id in hand: %s",
+                "a block got %s at the position: %d, %d, %d with the block id: %s",
-                targetPosition.x, targetPosition.y, targetPosition.z, blockId, itemId);
+                placedRemovedString, targetPosition.x, targetPosition.y, targetPosition.z, blockId);
-        /* if (itemId.compareTo("Soil_Snow") == 0 && blockId.compareTo("Empty") == 0) {
+        Vector3i ritualCenter = new Vector3i(targetPosition);
-            RitualPlugin.LOGGER.atInfo().log("Ritual complete");
+        RitualTypes ritualType = getRitualTypeFromBlock(blockId, ritualCenter, world, true);
-            world.execute(() -> {
-                NPCPlugin.get().spawnNPC(world.getEntityStore().getStore(), "Yeti", null, blockPosToEntityPos(targetPosition), new Rotation3f(0, 0, 0));
-            });
-        } */
-        RitualTypes ritualType = checkSetups(ritualDefinitions.containsCenterBlock(itemId), targetPosition, world);
         if(!ritualType.equals(RitualTypes.NONE)) {
             RitualPlugin.LOGGER.atInfo().log(
                     "a ritual pattern got completed"
             );
-            int soundIndex = SoundEvent.getAssetMap().getIndex("SFX_Skeleton_Praetorian_Alerted");
+            String soundId;
+            if (gotPlaced) {
+                soundId = "SFX_Skeleton_Praetorian_Alerted";
+            } else {
+                soundId = "SFX_Torch_Off";
+            }
+            int soundIndex = SoundEvent.getAssetMap().getIndex(soundId);
             world.execute(() -> {
                 // Play sound
-                SoundUtil.playSoundEvent3d(soundIndex, SoundCategory.SFX, blockToEntityPos(targetPosition), world.getEntityStore().getStore());
+                SoundUtil.playSoundEvent3d(soundIndex, SoundCategory.SFX, blockToEntityPos(ritualCenter), world.getEntityStore().getStore());
             });
         }
     }
 
-    public void sacrificeDropEvent(String itemId, Vector3d targetPosition, World world) {
+    public void sacrificeDropEvent(String itemId, Vector3d targetPosition, World world, Store<EntityStore> store, Ref<EntityStore> ref) {
         Vector3i blockPosition = entityToBlockPos(targetPosition);
+        /*RitualPlugin.LOGGER.atInfo().log(
+                "an item got thrown at the position: %f, %f, %f with the item id: %s",
+                targetPosition.x, targetPosition.y, targetPosition.z, itemId);*/
         RitualPlugin.LOGGER.atInfo().log(
-                "an item got thrown at the position: %f - %f - %f with the item id: %s",
+                "an item got thrown at the position: %d, %d, %d with the item id: %s",
                 blockPosition.x, blockPosition.y, blockPosition.z, itemId);
+        AtomicInteger setupIndex = new AtomicInteger(-1);
+        RitualTypes ritualType = getRitualTypeFromSacrifice(itemId, blockPosition, world, setupIndex);
+        if (!ritualType.equals(RitualTypes.NONE)) {
+            RitualPlugin.LOGGER.atInfo().log("Ritual complete");
+            if (ritualType.equals(RitualTypes.SKELETON)) {
+                world.execute(() -> {
+                    NPCPlugin.get().spawnNPC(world.getEntityStore().getStore(), "Skeleton", null, blockToEntityPos(blockPosition), new Rotation3f(0, 0, 0));
+                });
+            } else if (ritualType.equals(RitualTypes.YEDI)) {
+                world.execute(() -> {
+                    NPCPlugin.get().spawnNPC(world.getEntityStore().getStore(), "Yeti", null, blockToEntityPos(blockPosition), new Rotation3f(0, 0, 0));
+                });
+            }
+            if (setupIndex.get() >= 0) {
+                removeUsedBlocks(setupIndex.get(), blockPosition, world);
+            }
+            if (ritualDefinitions.getSacrifices(setupIndex.get()).getFirst().shouldConsume() && ref.isValid()) {
+                store.removeEntity(ref, RemoveReason.REMOVE);   // Only supports one sacrifice for now
+            }
+        }
     }
 
-    RitualTypes checkSetups(List<Integer> ritualSetups, Vector3i centerPosition, World world) {
+    RitualTypes getRitualTypeFromSacrifice(String itemId, Vector3i centerPosition, World world, AtomicInteger setupIndex) {
-        for (Integer ritualSetup : ritualSetups) {
+        List<Integer> possibleSetups = getFullRitualSetupRange();
-            List<RitualPattern> ritualPatterns = ritualDefinitions.getPatterns(ritualSetup);
+        checkSacrificePalette(possibleSetups, itemId);
-            boolean isSetupValid = true;
+        int radius = getMaxSacrificeRadius(possibleSetups);
-            for (RitualPattern ritualPattern : ritualPatterns) {
+        for (int ix = centerPosition.x - radius; ix <= centerPosition.x + radius; ix++) {
-                if(!checkPattern(ritualPattern, centerPosition, world)) {
+            for (int iy = centerPosition.y - radius; iy <= centerPosition.y + radius; iy++) {
-                    isSetupValid = false;
+                for (int iz = centerPosition.z - radius; iz <= centerPosition.z + radius; iz++) {
+                    Vector3i samplePosition = new Vector3i(ix, iy, iz);
+                    String blockId = getBlockId(samplePosition, world);
+                    List<Integer> setupsAtPosition = new ArrayList<>(possibleSetups);
+                    checkCenterBlock(setupsAtPosition, blockId);
+                    if (!setupsAtPosition.isEmpty()) {
+                        checkPatterns(setupsAtPosition, samplePosition, world, samplePosition, "Empty");
+                        if (!setupsAtPosition.isEmpty()) {
+                            centerPosition.set(samplePosition);
+                            setupIndex.set(setupsAtPosition.getFirst());
+                            return ritualDefinitions.getRitualType(setupsAtPosition.getFirst());
+                        }
                     }
                 }
-            if (isSetupValid) {
-                return ritualDefinitions.getRitualType(ritualSetup);
             }
         }
         return RitualTypes.NONE;
     }
 
-    boolean checkPattern(RitualPattern ritualPattern, Vector3i centerPosition, World world) {
+    RitualTypes getRitualTypeFromBlock(String blockId, Vector3i blockPosition, World world, boolean onlyShowChanges) {
+        List<Integer> possibleSetups = getFullRitualSetupRange();
+        checkCenterBlock(possibleSetups, blockId);
+        if (!possibleSetups.isEmpty()) {
+            checkPatterns(possibleSetups, blockPosition, world, blockPosition, blockId);
+            if (!possibleSetups.isEmpty()) {
+                return ritualDefinitions.getRitualType(possibleSetups.getFirst());
+            }
+        }
+        possibleSetups = getFullRitualSetupRange();
+        checkPatternPalette(possibleSetups, blockId);
+        if (possibleSetups.size() <= 0) {
+            return RitualTypes.NONE;
+        }
+        int radius = getMaxPatternRadius(possibleSetups);
+        for (int ix = blockPosition.x - radius; ix <= blockPosition.x + radius; ix++) {
+            for (int iy = blockPosition.y - radius; iy <= blockPosition.y + radius; iy++) {
+                for (int iz = blockPosition.z - radius; iz <= blockPosition.z + radius; iz++) {
+                    Vector3i samplePosition = new Vector3i(ix, iy, iz);
+                    List<Integer> setupsAtPosition = new ArrayList<>(possibleSetups);
+                    checkCenterBlock(setupsAtPosition, getBlockId(samplePosition, world));
+                    if (!setupsAtPosition.isEmpty()) {
+                        boolean didChange = checkPatterns(setupsAtPosition, samplePosition, world, blockPosition, blockId);
+                        // one setup needs to be valid and either a change happened or no changes are required
+                        if (!setupsAtPosition.isEmpty() && (didChange || !onlyShowChanges)) {
+                            blockPosition.set(samplePosition);
+                            return ritualDefinitions.getRitualType(setupsAtPosition.getFirst());
+                        }
+                    }
+                }
+            }
+        }
+        return RitualTypes.NONE;
+    }
+
+    void checkCenterBlock(List<Integer> ritualSetups, String blockId) {
+        ritualSetups.removeIf(ritualSetup -> !ritualDefinitions.getCenterBlockId(ritualSetup).equals(blockId));
+    }
+
+    void checkPatternPalette(List<Integer> ritualSetups, String blockId) {
+        List<Integer> possibleSetups = new ArrayList<>(ritualSetups);
+        for (Integer possibleSetup : possibleSetups) {
+            boolean isPossibleSetup = false;
+            List<RitualPattern> ritualPatterns = ritualDefinitions.getPatterns(possibleSetup);
+            for (RitualPattern ritualPattern : ritualPatterns) {
+                if (ritualPattern.blockId().equals(blockId)) {
+                    isPossibleSetup = true;
+                    break;
+                }
+            }
+            if (!isPossibleSetup) {
+                ritualSetups.remove(possibleSetup);
+            }
+        }
+    }
+
+    void checkSacrificePalette(List<Integer> ritualSetups, String itemId) {
+        List<Integer> possibleSetups = new ArrayList<>(ritualSetups);
+        for (Integer possibleSetup : possibleSetups) {
+            boolean isPossibleSetup = false;
+            List<RitualSacrifice> ritualSacrifices = ritualDefinitions.getSacrifices(possibleSetup);
+            for (RitualSacrifice ritualSacrifice : ritualSacrifices) {
+                if (ritualSacrifice.itemId().equals(itemId)) {
+                    isPossibleSetup = true;
+                    break;
+                }
+            }
+            if (!isPossibleSetup) {
+                ritualSetups.remove(possibleSetup);
+            }
+        }
+    }
+
+    boolean checkPatterns(List<Integer> ritualSetups, Vector3i centerPosition, World world, Vector3i placedBlockPosition, String placedBlockId) {
+        List<Integer> possibleSetups = new ArrayList<>(ritualSetups);
+        boolean didChange = false;
+        for (Integer possibleSetup : possibleSetups) {
+            List<RitualPattern> ritualPatterns = ritualDefinitions.getPatterns(possibleSetup);
+            boolean didChangeThisSetup = false;
+            for (RitualPattern ritualPattern : ritualPatterns) {
+                RitualSetupState state = checkPattern(ritualPattern, centerPosition, world, placedBlockPosition, placedBlockId);
+                if(state.equals(RitualSetupState.INCOMPLETE)) {
+                    ritualSetups.remove(possibleSetup);
+                    didChangeThisSetup = false;
+                    break;
+                } else if (state.equals(RitualSetupState.CHANGED)) {
+                    didChangeThisSetup = true;
+                }
+            }
+            didChange |= didChangeThisSetup;
+        }
+        return didChange;
+    }
+
+    RitualSetupState checkPattern(RitualPattern ritualPattern, Vector3i centerPosition, World world, Vector3i placedBlockPosition, String placedBlockId) {
         int countMatches = 0;
         int radius = ritualPattern.radius();
+        boolean validBlockChanged = false;
         for (int ix = centerPosition.x - radius; ix <= centerPosition.x + radius; ix++) {
             for (int iy = centerPosition.y - radius; iy <= centerPosition.y + radius; iy++) {
                 for (int iz = centerPosition.z - radius; iz <= centerPosition.z + radius; iz++) {
                     Vector3i samplePosition = new Vector3i(ix, iy, iz);
-                    String blockId = Objects.requireNonNull(world.getBlockType(samplePosition)).getId();
+                    String blockId;
+                    boolean blockChanged;
+                    if (samplePosition.equals(placedBlockPosition)) {
+                        blockId = placedBlockId;
+                        blockChanged = true;
+                    } else {
+                        blockId = getBlockId(samplePosition, world);
+                        blockChanged = false;
+                    }
                     if (blockId.equals(ritualPattern.blockId())) {
                         countMatches++;
+                        validBlockChanged |= blockChanged;
                     }
                 }
             }
         }
-        return countMatches >= ritualPattern.amount();
+        // the pattern now just has enough or not enough matching blocks
+        if (countMatches == ritualPattern.amount() && validBlockChanged) {
+            return RitualSetupState.CHANGED;
+        // the pattern state stayed the same
+        } else if (countMatches >= ritualPattern.amount()) {
+            return RitualSetupState.COMPLETE;
+        } else {
+            return RitualSetupState.INCOMPLETE;
+        }
+    }
+
+    void removeUsedBlocks(int index, Vector3i centerPosition, World world) {
+        if (ritualDefinitions.getShouldConsumeCenterBlock(index)) {
+            world.setBlock(centerPosition.x, centerPosition.y, centerPosition.z, "Empty");
+        }
+
+        List<RitualPattern> ritualPatterns = ritualDefinitions.getPatterns(index);
+        for (RitualPattern ritualPattern : ritualPatterns) {
+            int radius = ritualPattern.radius();
+            int amountRemaining = ritualPattern.amount();
+            int side = 2 * radius + 1;
+            int total = side * side * side;
+
+            if (ritualPattern.shouldConsume()) {
+                for (int i = 0; i < total; i++) {
+                    int ix = centerPosition.x - radius + (i % side);
+                    int iy = centerPosition.y - radius + ((i / side) % side);
+                    int iz = centerPosition.z - radius + (i / (side * side));
+
+                    Vector3i samplePosition = new Vector3i(ix, iy, iz);
+                    if (getBlockId(samplePosition, world).equals(ritualPattern.blockId())) {
+                        world.setBlock(samplePosition.x, samplePosition.y, samplePosition.z, "Empty");
+                        amountRemaining--;
+                        if (amountRemaining <= 0) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    void setInteractionState() {
+        //world.setBlockInteractionState(, new BlockType("Empty"), "Empty");
+    }
+
+    int getMaxPatternRadius(List<Integer> ritualSetups) {
+        int maxRadius = 0;
+        for (Integer ritualSetup : ritualSetups) {
+            List<RitualPattern> ritualPatterns = ritualDefinitions.getPatterns(ritualSetup);
+            for (RitualPattern ritualPattern : ritualPatterns) {
+                if (maxRadius < ritualPattern.radius()) {
+                    maxRadius = ritualPattern.radius();
+                }
+            }
+        }
+        return maxRadius;
+    }
+
+    int getMaxSacrificeRadius(List<Integer> ritualSetups) {
+        int maxRadius = 0;
+        for (Integer ritualSetup : ritualSetups) {
+            List<RitualSacrifice> ritualSacrifices = ritualDefinitions.getSacrifices(ritualSetup);
+            for (RitualSacrifice ritualSacrifice : ritualSacrifices) {
+                if (maxRadius < ritualSacrifice.radius()) {
+                    maxRadius = ritualSacrifice.radius();
+                }
+            }
+        }
+        return maxRadius;
+    }
+
+    List<Integer> getFullRitualSetupRange() {
+        List<Integer> possibleSetups = new ArrayList<>();
+        for (int i = 0; i < ritualDefinitions.getRitualSetupsCount(); i++) {
+            possibleSetups.add(i);
+        }
+        return possibleSetups;
+    }
+
+    String getBlockId(Vector3i samplePosition, World world) {
+        BlockType blockType = world.getBlockType(samplePosition);
+        String blockId = "Empty";
+        if (blockType != null) {
+            blockId = blockType.getId();
+        }
+        return blockId;
     }
 
     Vector3d blockToEntityPos(Vector3i blockPosition) {
@@ -84,6 +319,6 @@ public class RitualSpawner {
     }
 
     Vector3i entityToBlockPos(Vector3d entityPosition) {
-        return new Vector3i(entityPosition, 0);
+        return new Vector3i(entityPosition.sub(0.5, 1, 0.5), 3);
     }
 }

src/main/java/dev/hytalemodding/definitions/RitualDefinitions.java

@@ -8,19 +8,17 @@ public class RitualDefinitions {
 
     public RitualDefinitions() {
         // Crude skeleton ritual
-        ritualSetups.add(new RitualSetup("Deco_Bone_Skulls", RitualTypes.SKELETON_ARMY)
+        ritualSetups.add(new RitualSetup("Deco_Bone_Skulls", true, RitualTypes.SKELETON)
-                .addPatern("Furniture_Crude_Torch", 2, 4, true)
+                .addPattern("Furniture_Crude_Torch", 2, 4, false, true)
-                .addSacrifice("Ingredient_Life_Essence"));
+                .addSacrifice("Ingredient_Life_Essence", 1, 1, true));
+        ritualSetups.add(new RitualSetup("Furniture_Temple_Light_Brazier", false, RitualTypes.YEDI)
+                .addPattern("Rock_Crystal_Cyan_Small", 3, 6, false, false)
+                .addPattern("Rubble_Ice", 3, 6, true, false)
+                .addSacrifice("Ingredient_Ice_Essence", 2, 1, true));
     }
 
-    public List<Integer> containsCenterBlock(String blockId) {
+    public int getRitualSetupsCount() {
-        List<Integer> possibleSetups = new ArrayList<>();
+        return ritualSetups.size();
-        for(int i = 0; i < ritualSetups.size(); i++) {
-            if(ritualSetups.get(i).getCenterBlockId().equals(blockId)) {
-                possibleSetups.add(i);
-            }
-        }
-        return possibleSetups;
     }
 
     public RitualTypes getRitualType(int index) {
@@ -31,11 +29,19 @@ public class RitualDefinitions {
         return ritualSetups.get(index).getCenterBlockId();
     }
 
+    public boolean getShouldConsumeCenterBlock(int index) {
+        return ritualSetups.get(index).getShouldConsumeCenterBlock();
+    }
+
     public List<RitualPattern> getPatterns(int setupIndex) {
         return ritualSetups.get(setupIndex).getPatterns();
     }
 
-    public String getSacrificeItemId(int setupIndex, int sacrificeIndex) {
+    public List<RitualSacrifice> getSacrifices(int setupIndex) {
+        return ritualSetups.get(setupIndex).getSacrifices();
+    }
+
+    public RitualSacrifice getSacrificeItemId(int setupIndex, int sacrificeIndex) {
         return ritualSetups.get(setupIndex).getSacrificeItemId(sacrificeIndex);
     }
 }

src/main/java/dev/hytalemodding/definitions/RitualPattern.java

@@ -1,3 +1,3 @@
 package dev.hytalemodding.definitions;
 
-public record RitualPattern(String blockId, int radius, int amount, boolean shouldConsume) { }
+public record RitualPattern(String blockId, int radius, int amount, boolean shouldConsume, boolean shouldInteract) { }

src/main/java/dev/hytalemodding/definitions/RitualSacrifice.java

@@ -0,0 +1,3 @@
+package dev.hytalemodding.definitions;
+
+public record RitualSacrifice(String itemId, int radius, int amount, boolean shouldConsume) { }

src/main/java/dev/hytalemodding/definitions/RitualSetup.java

@@ -6,21 +6,23 @@ import java.util.List;
 public class RitualSetup {
     RitualTypes ritualType;
     String centerBlockId;
+    boolean shouldConsumeCenterBlock;
     List<RitualPattern> patterns = new ArrayList<>();
-    List<String> sacrificeItemIds = new ArrayList<>();
+    List<RitualSacrifice> sacrifices = new ArrayList<>();
 
-    public RitualSetup(String centerBlockId, RitualTypes ritualType) {
+    public RitualSetup(String centerBlockId, boolean shouldConsumeCenterBlock, RitualTypes ritualType) {
-        this.ritualType = ritualType;
         this.centerBlockId = centerBlockId;
+        this.shouldConsumeCenterBlock = shouldConsumeCenterBlock;
+        this.ritualType = ritualType;
     }
 
-    public RitualSetup addPatern(String blockId, int radius, int amount, boolean shouldConsume) {
+    public RitualSetup addPattern(String blockId, int radius, int amount, boolean shouldConsume, boolean shouldInteract) {
-        patterns.add(new RitualPattern(blockId, radius, amount, shouldConsume));
+        patterns.add(new RitualPattern(blockId, radius, amount, shouldConsume, shouldInteract));
         return this;
     }
 
-    public RitualSetup addSacrifice(String sacrifice) {
+    public RitualSetup addSacrifice(String itemId, int radius, int amount, boolean shouldConsume) {
-        sacrificeItemIds.add(sacrifice);
+        sacrifices.add(new RitualSacrifice(itemId, radius, amount, shouldConsume));
         return this;
     }
 
@@ -32,6 +34,10 @@ public class RitualSetup {
         return centerBlockId;
     }
 
+    public boolean getShouldConsumeCenterBlock() {
+        return shouldConsumeCenterBlock;
+    }
+
     public RitualPattern getPattern(int index) {
         return patterns.get(index);
     }
@@ -40,7 +46,11 @@ public class RitualSetup {
         return patterns;
     }
 
-    public String getSacrificeItemId(int index) {
+    public List<RitualSacrifice> getSacrifices() {
-        return sacrificeItemIds.get(index);
+        return sacrifices;
+    }
+
+    public RitualSacrifice getSacrificeItemId(int index) {
+        return sacrifices.get(index);
     }
 }

src/main/java/dev/hytalemodding/definitions/RitualTypes.java

@@ -2,6 +2,6 @@ package dev.hytalemodding.definitions;
 
 public enum RitualTypes {
     NONE,
-    SKELETON_ARMY,
+    SKELETON,
     YEDI
 }

src/main/java/dev/hytalemodding/events/RitualBreakBlockEvent.java

@@ -6,8 +6,8 @@ import com.hypixel.hytale.component.CommandBuffer;
 import com.hypixel.hytale.component.Store;
 import com.hypixel.hytale.component.query.Query;
 import com.hypixel.hytale.component.system.EntityEventSystem;
+import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
 import com.hypixel.hytale.server.core.event.events.ecs.BreakBlockEvent;
-import com.hypixel.hytale.server.core.inventory.ItemStack;
 import com.hypixel.hytale.server.core.universe.world.World;
 import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 import dev.hytalemodding.RitualSpawner;
@@ -28,14 +28,14 @@ public class RitualBreakBlockEvent extends EntityEventSystem<EntityStore, BreakB
                        @NonNullDecl Store<EntityStore> store,
                        @NonNullDecl CommandBuffer<EntityStore> commandBuffer,
                        @NonNullDecl BreakBlockEvent breakBlockEvent) {
-        ItemStack itemHolding = breakBlockEvent.getItemInHand();
-        String itemId = "Empty";
-        if(itemHolding != null) {
-            itemId = itemHolding.getItemId();
-        }
-        Vector3i blockPosition = breakBlockEvent.getTargetBlock();
         World world = store.getExternalData().getWorld();
-        ritualSpawner.blockChangeEvent(itemId, blockPosition, world);
+        Vector3i blockPosition = breakBlockEvent.getTargetBlock();
+        BlockType blockType = world.getBlockType(blockPosition);
+        String blockId = "Empty";
+        if(blockType != null) {
+            blockId = blockType.getId();
+        }
+        ritualSpawner.blockChangeEvent(blockId, blockPosition, world, false);
     }
 
     @NullableDecl

src/main/java/dev/hytalemodding/events/RitualDropItemEvent.java

@@ -31,7 +31,7 @@ public class RitualDropItemEvent extends EntityEventSystem<EntityStore, DropItem
         assert transform != null;
         Vector3d targetPosition = transform.getPosition();
         World world = store.getExternalData().getWorld();
-        ritualSpawner.sacrificeDropEvent(itemId, targetPosition, world);
+        ritualSpawner.sacrificeDropEvent(itemId, targetPosition, world, store, archetypeChunk.getReferenceTo(index));
     }
 
     @NullableDecl

src/main/java/dev/hytalemodding/events/RitualPlaceBlockEvent.java

@@ -28,14 +28,14 @@ public class RitualPlaceBlockEvent extends EntityEventSystem<EntityStore, PlaceB
                        @NonNullDecl Store<EntityStore> store,
                        @NonNullDecl CommandBuffer<EntityStore> commandBuffer,
                        @NonNullDecl PlaceBlockEvent placeBlockEvent) {
-        ItemStack itemHolding = placeBlockEvent.getItemInHand();
-        String itemId = "Empty";
-        if(itemHolding != null) {
-            itemId = itemHolding.getItemId();
-        }
-        Vector3i targetPosition = placeBlockEvent.getTargetBlock();
         World world = store.getExternalData().getWorld();
-        ritualSpawner.blockChangeEvent(itemId, targetPosition, world);
+        Vector3i targetPosition = placeBlockEvent.getTargetBlock();
+        ItemStack itemHolding = placeBlockEvent.getItemInHand();
+        String blockId = "Empty";
+        if(itemHolding != null) {
+            blockId = itemHolding.getItemId();
+        }
+        ritualSpawner.blockChangeEvent(blockId, targetPosition, world, true);
     }
 
     @NullableDecl