class="kw">package com.hypixel.hytale.server.core.modules.interaction;

class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
class="kw">import com.hypixel.hytale.protocol.BlockPosition;
class="kw">import com.hypixel.hytale.protocol.BlockSoundEvent;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.protocol.SoundCategory;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocksound.config.BlockSoundSet;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockBreakingDropType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockGathering;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.HarvestingDropType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.PhysicsDropType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.SoftBlockDropType;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.BrokenPenalties;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.GatheringEffectsConfig;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.ItemTool;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.ItemToolSpec;
class="kw">import com.hypixel.hytale.server.core.blocktype.component.BlockPhysics;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionChain;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionManager;
class="kw">import com.hypixel.hytale.server.core.entity.ItemUtils;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.BreakBlockEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.DamageBlockEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.EnvironmentBreakBlockEvent;
class="kw">import com.hypixel.hytale.server.core.inventory.InventoryComponent;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.modules.blockhealth.BlockHealth;
class="kw">import com.hypixel.hytale.server.core.modules.blockhealth.BlockHealthChunk;
class="kw">import com.hypixel.hytale.server.core.modules.blockhealth.BlockHealthModule;
class="kw">import com.hypixel.hytale.server.core.modules.blockset.BlockSetModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemComponent;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.host.InteractionHost;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.item.ItemModule;
class="kw">import com.hypixel.hytale.server.core.modules.projectile.config.StandardPhysicsProvider;
class="kw">import com.hypixel.hytale.server.core.modules.time.TimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.ParticleUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.SoundUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockOperations;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.connectedblocks.ConnectedBlocksUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.FillerBlockUtil;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectLists;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class BlockHarvestUtils {
   class="kw">private class="kw">static class="kw">final float INTERACTION_HOST_TTL_SECONDS = 30.0F;
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();

   class="kw">public BlockHarvestUtils() {
   }

   class="kw">public class="kw">static boolean performBlockDamage(
      @Nonnull Vector3i var0,
      @Nullable ItemStack var1,
      @Nullable ItemTool var2,
      float var3,
      int var4,
      boolean var5,
      @Nonnull Ref<ChunkStore> var6,
      @Nonnull ComponentAccessor<EntityStore> var7,
      @Nonnull ComponentAccessor<ChunkStore> var8
   ) {
      class="kw">return performBlockDamage(null, null, var0, var1, var2, null, false, var3, var4, var5, var6, var7, var8);
   }

   class="kw">public class="kw">static boolean performBlockDamage(
      @Nullable Ref<EntityStore> var0,
      @Nullable Ref<EntityStore> var1,
      @Nonnull Vector3i var2,
      @Nullable ItemStack var3,
      @Nullable ItemTool var4,
      @Nullable String var5,
      boolean var6,
      float var7,
      int var8,
      boolean var9,
      @Nonnull Ref<ChunkStore> var10,
      @Nonnull ComponentAccessor<EntityStore> var11,
      @Nonnull ComponentAccessor<ChunkStore> var12
   ) {
      BlockHarvestUtils.ItemDamageContext var13 = createItemDamageContext(var0, var11);
      class="kw">return damageSingleBlock(var0, var1, var2, var3, var4, var5, var6, var7, var8, var9, true, var13, var10, var11, var12);
   }

   class="kw">public class="kw">static int performBlockDamage(
      @Nullable Ref<EntityStore> var0,
      @Nullable Ref<EntityStore> var1,
      @Nonnull List<Vector3i> var2,
      @Nonnull Vector3i var3,
      @Nullable ItemStack var4,
      @Nullable ItemTool var5,
      @Nullable String var6,
      boolean var7,
      float var8,
      int var9,
      boolean var10,
      boolean var11,
      @Nonnull ComponentAccessor<EntityStore> var12,
      @Nonnull ComponentAccessor<ChunkStore> var13
   ) {
      if (var2.isEmpty()) {
         class="kw">return 0;
      }

      BlockHarvestUtils.ItemDamageContext var14 = createItemDamageContext(var0, var12);
      ChunkStore var15 = var14.world().getChunkStore();
      boolean var16 = !var11 && var0 != null && var4 != null;
      BlockType var17 = var16 ? var14.world().getBlockType(var3.x(), var3.y(), var3.z()) : null;
      int var18 = 0;

      for (int var19 = 0; var19 < var2.size(); var19++) {
         Vector3i var20 = var2.get(var19);
         if (var20.y() >= 0 && var20.y() < 320) {
            Ref var21 = var15.getChunkSectionReferenceAtBlock(var20.x, var20.y, var20.z);
            if (var21 != null && var21.isValid()) {
               try {
                  if (damageSingleBlock(var0, var1, new Vector3i(var20), var4, var5, var6, var7, var8, var9, var10, var11, var14, var21, var12, var13)) {
                     var18++;
                  }
               } catch (Exception var23) {
                  ((HytaleLogger.Api)((HytaleLogger.Api)LOGGER.at(Level.WARNING).atMostEvery(5, TimeUnit.MINUTES)).withCause(var23))
                     .log("Failed to damage block at [%d, %d, %d]", var20.x(), var20.y(), var20.z());
               }
            }
         }
      }

      if (var16) {
         applyItemDurabilityLoss(var0, var4, var4.getItem(), var17, var12);
      }

      class="kw">return var18;
   }

   class="kw">public class="kw">static void performBlockBreak(
      @Nullable Ref<EntityStore> var0,
      @Nullable ItemStack var1,
      @Nonnull Vector3i var2,
      @Nonnull Ref<ChunkStore> var3,
      @Nonnull ComponentAccessor<EntityStore> var4,
      @Nonnull ComponentAccessor<ChunkStore> var5
   ) {
      performBlockBreak(var0, var1, var2, 0, var3, var4, var5);
   }

   class="kw">public class="kw">static int performBlockBreak(
      @Nullable Ref<EntityStore> var0,
      @Nullable ItemStack var1,
      @Nonnull List<Vector3i> var2,
      int var3,
      @Nonnull ComponentAccessor<EntityStore> var4,
      @Nonnull ComponentAccessor<ChunkStore> var5
   ) {
      if (var2.isEmpty()) {
         class="kw">return 0;
      }

      World var6 = var4.getExternalData().getWorld();
      ChunkStore var7 = var6.getChunkStore();
      int var8 = 0;

      for (Vector3i var10 : var2) {
         if (var10.y() >= 0 && var10.y() < 320) {
            Ref var11 = var7.getChunkSectionReferenceAtBlock(var10.x, var10.y, var10.z);
            if (var11 != null && var11.isValid()) {
               try {
                  performBlockBreak(var0, var1, new Vector3i(var10), var3, var11, var4, var5);
                  var8++;
               } catch (Exception var13) {
                  ((HytaleLogger.Api)((HytaleLogger.Api)LOGGER.at(Level.WARNING).atMostEvery(5, TimeUnit.MINUTES)).withCause(var13))
                     .log("Failed to break block at [%d, %d, %d]", var10.x(), var10.y(), var10.z());
               }
            }
         }
      }

      class="kw">return var8;
   }

   class="kw">public class="kw">static void performBlockBreak(
      @Nullable Ref<EntityStore> var0,
      @Nullable ItemStack var1,
      @Nonnull Vector3i var2,
      int var3,
      @Nonnull Ref<ChunkStore> var4,
      @Nonnull ComponentAccessor<EntityStore> var5,
      @Nonnull ComponentAccessor<ChunkStore> var6
   ) {
      performBlockBreak(var0, var0, var1, var2, var3, var4, var5, var6);
   }

   class="kw">public class="kw">static void performBlockBreak(
      @Nullable Ref<EntityStore> var0,
      @Nullable Ref<EntityStore> var1,
      @Nullable ItemStack var2,
      @Nonnull Vector3i var3,
      int var4,
      @Nonnull Ref<ChunkStore> var5,
      @Nonnull ComponentAccessor<EntityStore> var6,
      @Nonnull ComponentAccessor<ChunkStore> var7
   ) {
      int var8 = var3.x();
      int var9 = var3.y();
      int var10 = var3.z();
      BlockSection var11 = var7.getComponent(var5, BlockSection.getComponentType());
      assert var11 != null;
      int var12 = var11.get(var8, var9, var10);
      if (var12 != 0) {
         BlockType var13 = BlockType.getAssetMap().getAsset(var12);
         if (var13 != null) {
            World var14 = var7.getExternalData().getWorld();
            Vector3i var15 = var3;
            if (!var13.isUnknown()) {
               int var16 = var11.getFiller(var8, var9, var10);
               int var17 = FillerBlockUtil.unpackX(var16);
               int var18 = FillerBlockUtil.unpackY(var16);
               int var19 = FillerBlockUtil.unpackZ(var16);
               if (var17 != 0 || var18 != 0 || var19 != 0) {
                  var15 = new Vector3i(var15).sub(var17, var18, var19);
                  BlockType var20 = var14.getBlockType(var15);
                  if (var20 != null && !var13.getId().equals(var20.getId())) {
                     var14.breakBlock(var8, var9, var10, var4);
                     class="kw">return;
                  }
               }
            }

            performBlockBreak(var15, var13, var2, 0, null, null, var4, var0, var1, var5, var6, var7);
         }
      }
   }

   class="kw">public class="kw">static void performBlockBreak(
      @Nonnull Vector3i var0,
      @Nonnull BlockType var1,
      @Nullable ItemStack var2,
      int var3,
      @Nullable String var4,
      @Nullable String var5,
      int var6,
      @Nullable Ref<EntityStore> var7,
      @Nonnull Ref<ChunkStore> var8,
      @Nonnull ComponentAccessor<EntityStore> var9,
      @Nonnull ComponentAccessor<ChunkStore> var10
   ) {
      performBlockBreak(var0, var1, var2, var3, var4, var5, var6, var7, var7, var8, var9, var10);
   }

   class="kw">public class="kw">static void performBlockBreak(
      @Nonnull Vector3i var0,
      @Nonnull BlockType var1,
      @Nullable ItemStack var2,
      int var3,
      @Nullable String var4,
      @Nullable String var5,
      int var6,
      @Nullable Ref<EntityStore> var7,
      @Nullable Ref<EntityStore> var8,
      @Nonnull Ref<ChunkStore> var9,
      @Nonnull ComponentAccessor<EntityStore> var10,
      @Nonnull ComponentAccessor<ChunkStore> var11
   ) {
      if (var1 != BlockType.EMPTY) {
         int var12 = var0.x();
         int var13 = var0.y();
         int var14 = var0.z();
         Ref var15 = var9;
         if (var7 != null) {
            BreakBlockEvent var16 = new BreakBlockEvent(var2, var0, var1);
            var10.invoke(var7, var16);
            if (var16.isCancelled()) {
               BlockSection var17 = var11.getComponent(var9, BlockSection.getComponentType());
               if (var17 != null) {
                  var17.invalidateBlock(var12, var13, var14);
               }

               class="kw">return;
            }

            var0 = var16.getTargetBlock();
         } else {
            var10.invoke(new EnvironmentBreakBlockEvent(var0, var1));
         }

         if (var0.x != var12 || var0.y != var13 || var0.z != var14) {
            BlockSection var25 = var11.getComponent(var9, BlockSection.getComponentType());
            if (var25 != null) {
               var25.invalidateBlock(var12, var13, var14);
            }
         }

         if (!ChunkUtil.isSameChunkSection(var12, var13, var14, var0.x, var0.y, var0.z)) {
            var15 = var11.getExternalData().getChunkSectionReferenceAtBlock(var0.x, var0.y, var0.z);
            if (var15 == null || !var15.isValid()) {
               class="kw">return;
            }
         }

         int var26 = var0.x();
         int var27 = var0.y();
         int var18 = var0.z();
         BlockSection var19 = var11.getComponent(var15, BlockSection.getComponentType());
         if (var19 != null) {
            int var20 = var19.getFiller(var26, var27, var18);
            int var21 = var19.get(var26, var27, var18);
            BlockType var22 = BlockType.getAssetMap().getAsset(var21);
            boolean var23 = BlockInteractionUtils.isNaturalAction(var7, var10);
            if (!var23) {
               var6 |= 2048;
            }

            if (!BlockInteractionUtils.isNoPhysics(var7, var10)) {
               var6 |= 256;
            }

            int var24 = var19.getRotationIndex(var26, var27, var18);
            naturallyRemoveBlock(var0, var22, var20, var3, var4, var5, var6, var15, var10, var11);
            fireOnBreakInteraction(var7, var8, var22, var0, var24, var6, var10);
         }
      }
   }

   @Deprecated
   class="kw">public class="kw">static void naturallyRemoveBlockByPhysics(
      @Nonnull Vector3i var0,
      @Nonnull BlockType var1,
      int var2,
      int var3,
      @Nonnull Ref<ChunkStore> var4,
      @Nonnull ComponentAccessor<EntityStore> var5,
      @Nonnull ComponentAccessor<ChunkStore> var6
   ) {
      int var7 = 1;
      String var8 = null;
      String var9 = null;
      BlockGathering var10 = var1.getGathering();
      if (var10 != null) {
         PhysicsDropType var11 = var10.getPhysics();
         BlockBreakingDropType var12 = var10.getBreaking();
         SoftBlockDropType var13 = var10.getSoft();
         HarvestingDropType var14 = var10.getHarvest();
         if (var11 != null) {
            var8 = var11.getItemId();
            var9 = var11.getDropListId();
         } else if (var12 != null) {
            var7 = var12.getQuantity();
            var8 = var12.getItemId();
            var9 = var12.getDropListId();
         } else if (var13 != null) {
            var8 = var13.getItemId();
            var9 = var13.getDropListId();
         } else if (var14 != null) {
            var8 = var14.getItemId();
            var9 = var14.getDropListId();
         }
      }

      var3 |= 32;
      naturallyRemoveBlock(var0, var1, var2, var7, var8, var9, var3, var4, var5, var6);
   }

   class="kw">public class="kw">static void naturallyRemoveBlock(
      @Nonnull Vector3i var0,
      @Nullable BlockType var1,
      int var2,
      int var3,
      String var4,
      String var5,
      int var6,
      @Nonnull Ref<ChunkStore> var7,
      @Nonnull ComponentAccessor<EntityStore> var8,
      @Nonnull ComponentAccessor<ChunkStore> var9
   ) {
      if (var1 != null) {
         BlockSection var10 = var9.getComponent(var7, BlockSection.getComponentType());
         assert var10 != null;
         Vector3i var11 = var0;
         if (!var1.isUnknown()) {
            int var12 = FillerBlockUtil.unpackX(var2);
            int var13 = FillerBlockUtil.unpackY(var2);
            int var14 = FillerBlockUtil.unpackZ(var2);
            if (var12 != 0 || var13 != 0 || var14 != 0) {
               var11 = new Vector3i(var11).sub(var12, var13, var14);
               String var15 = var1.getId();
               Ref var16 = var7;
               if (!ChunkUtil.isSameChunkSection(var11.x, var11.y, var11.z, var0.x, var0.y, var0.z)) {
                  var7 = var9.getExternalData().getChunkSectionReferenceAtBlock(var11.x, var11.y, var11.z);
                  if (var7 == null || !var7.isValid()) {
                     class="kw">return;
                  }

                  var10 = var9.getComponent(var7, BlockSection.getComponentType());
                  assert var10 != null;
               }

               var1 = BlockType.getAssetMap().getAsset(var10.get(var11.x(), var11.y(), var11.z()));
               if (var1 == null) {
                  throw new IllegalStateException("Null block type fetched for " + var11 + " during block break");
               }

               if (!var15.equals(var1.getId())) {
                  BlockOperations.setBlock(var9.getExternalData(), var16, var0.x(), var0.y(), var0.z(), 0, BlockType.EMPTY, 0, 0, var6);
                  class="kw">return;
               }
            }
         }

         if ((var6 & 1024) == 0) {
            BlockSoundSet var17 = BlockSoundSet.getAssetMap().getAsset(var1.getBlockSoundSetIndex());
            if (var17 != null) {
               int var19 = var17.getSoundEventIndices().getOrDefault(BlockSoundEvent.Break, 0);
               if (var19 != 0) {
                  int var21 = var10.getRotationIndex(var11.x(), var11.y(), var11.z());
                  Vector3d var22 = new Vector3d();
                  var1.getBlockCenter(var21, var22);
                  var22.add(var11.x(), var11.y(), var11.z());
                  SoundUtil.playSoundEvent3d(var19, SoundCategory.SFX, var22, var8);
               }
            }
         }

         removeBlock(var11, var1, var6, var7, var10, var9);
         if ((var6 & 2048) == 0 && var3 > 0) {
            Vector3d var18 = Vector3iUtil.toVector3d(var0).add(0.5, 0.0, 0.5);
            List var20 = getDrops(var1, var3, var4, var5);
            spawnDrops(var8, var20, var18);
         }
      }
   }

   class="kw">public class="kw">static boolean shouldPickupByInteraction(@Nullable BlockType var0) {
      class="kw">return var0 != null && var0.getGathering() != null && var0.getGathering().isHarvestable();
   }

   class="kw">public class="kw">static void performPickupByInteraction(
      @Nonnull Ref<EntityStore> var0,
      @Nonnull Vector3i var1,
      @Nonnull BlockType var2,
      int var3,
      @Nonnull Ref<ChunkStore> var4,
      @Nonnull BlockSection var5,
      @Nonnull ComponentAccessor<EntityStore> var6,
      @Nonnull ComponentAccessor<ChunkStore> var7
   ) {
      Vector3i var8 = var1;
      Ref var9 = var4;
      BlockSection var10 = var5;
      if (!var2.isUnknown()) {
         int var11 = FillerBlockUtil.unpackX(var3);
         int var12 = FillerBlockUtil.unpackY(var3);
         int var13 = FillerBlockUtil.unpackZ(var3);
         if (var11 != 0 || var12 != 0 || var13 != 0) {
            var8 = new Vector3i(var8).sub(var11, var12, var13);
            if (!ChunkUtil.isSameChunkSection(var8.x, var8.y, var8.z, var1.x, var1.y, var1.z)) {
               var9 = var7.getExternalData().getChunkSectionReferenceAtBlock(var8.x, var8.y, var8.z);
               if (var9 == null || !var9.isValid()) {
                  class="kw">return;
               }

               var10 = var7.getComponent(var9, BlockSection.getComponentType());
               assert var10 != null;
            }

            String var14 = var2.getId();
            var2 = BlockType.getAssetMap().getAsset(var10.get(var8.x(), var8.y(), var8.z()));
            if (var2 == null) {
               class="kw">return;
            }

            if (!var14.equals(var2.getId())) {
               BlockOperations.setBlock(var7.getExternalData(), var4, var1.x(), var1.y(), var1.z(), 0, BlockType.EMPTY, 0, 0, 0);
               class="kw">return;
            }
         }
      }

      Vector3d var22 = new Vector3d();
      int var23 = var5.getRotationIndex(var1.x(), var1.y(), var1.z());
      var2.getBlockCenter(var23, var22);
      var22.add(var1.x(), var1.y(), var1.z());
      int var24 = 0;
      var24 |= 256;
      BreakBlockEvent var26 = new BreakBlockEvent(null, var8, var2);
      var6.invoke(var0, var26);
      if (var26.isCancelled()) {
         var5.invalidateBlock(var1.x(), var1.y(), var1.z());
      } else {
         Vector3i var15 = var26.getTargetBlock();
         if (!ChunkUtil.isSameChunkSection(var15.x, var15.y, var15.z, var8.x, var8.y, var8.z)) {
            var9 = var7.getExternalData().getChunkSectionReferenceAtBlock(var15.x, var15.y, var15.z);
            if (var9 == null || !var9.isValid()) {
               class="kw">return;
            }

            var10 = var7.getComponent(var9, BlockSection.getComponentType());
            assert var10 != null;
         }

         var8 = var15;
         if (!BlockInteractionUtils.isNaturalAction(var0, var6)) {
            var24 |= 2048;
         }

         removeBlock(var8, var2, var24, var9, var10, var7);
         fireOnBreakInteraction(var0, var0, var2, var8, var23, var24, var6);
         HarvestingDropType var16 = var2.getGathering().getHarvest();
         String var17 = var16.getItemId();
         String var18 = var16.getDropListId();

         for (ItemStack var20 : getDrops(var2, 1, var17, var18)) {
            ItemUtils.interactivelyPickupItem(var0, var20, var22, var6);
         }

         if ((var24 & 1024) == 0) {
            playBlockSound(var2, BlockSoundEvent.Harvest, var22, var6);
         }
      }
   }

   @Nonnull
   class="kw">public class="kw">static List<ItemStack> getDrops(@Nonnull BlockType var0, int var1, @Nullable String var2, @Nullable String var3) {
      if (var3 == null && var2 == null) {
         Item var8 = var0.getItem();
         class="kw">return var8 == null ? ObjectLists.emptyList() : ObjectLists.singleton(new ItemStack(var8.getId(), var1));
      }

      List var4 = new ObjectArrayList();
      if (var3 != null) {
         ItemModule var5 = ItemModule.get();
         if (var5.isEnabled()) {
            for (int var6 = 0; var6 < var1; var6++) {
               List var7 = var5.getRandomItemDrops(var3);
               var4.addAll(var7);
            }
         }
      }

      if (var2 != null) {
         var4.add(new ItemStack(var2, var1));
      }

      class="kw">return var4;
   }

   @Nullable
   class="kw">private class="kw">static ItemToolSpec getSpecPowerDamageBlock(@Nullable Item var0, @Nullable BlockType var1, @Nullable ItemTool var2) {
      if (var1 == null) {
         class="kw">return null;
      }

      BlockGathering var3 = var1.getGathering();
      if (var3 == null) {
         class="kw">return null;
      }

      BlockBreakingDropType var4 = var3.getBreaking();
      if (var4 == null) {
         class="kw">return null;
      }

      String var5 = var4.getGatherType();
      if (var5 == null) {
         class="kw">return null;
      }

      if (var0 == null || var0.getWeapon() == null && var0.getBuilderTool() == null) {
         int var6 = var4.getQuality();
         if (var2 == null) {
            ItemToolSpec var12 = ItemToolSpec.getAssetMap().getAsset(var5);
            class="kw">return var12 != null && var12.getQuality() < var6 ? null : var12;
         }

         ItemToolSpec[] var7 = var2.getSpecs();
         if (var7 != null) {
            for (ItemToolSpec var11 : var7) {
               if (Objects.equals(var11.getGatherType(), var5)) {
                  if (var11.getQuality() < var6) {
                     class="kw">return null;
                  }

                  class="kw">return var11;
               }
            }
         }

         class="kw">return null;
      } else {
         class="kw">return null;
      }
   }

   class="kw">private class="kw">static double calculateDurabilityUse(@Nonnull Item var0, @Nullable BlockType var1) {
      if (var1 == null) {
         class="kw">return 0.0;
      }

      BlockGathering var2 = var1.getGathering();
      if (var2 != null && !var2.isSoft()) {
         if (var0.getTool() == null) {
            class="kw">return 0.0;
         }

         ItemTool var3 = var0.getTool();
         ItemTool.DurabilityLossBlockTypes[] var4 = var3.getDurabilityLossBlockTypes();
         if (var4 == null) {
            class="kw">return var0.getDurabilityLossOnHit();
         }

         String var5 = var1.getId();
         int var6 = BlockType.getAssetMap().getIndex(var5);
         if (var6 == Integer.MIN_VALUE) {
            throw new IllegalArgumentException("Unknown key! " + var5);
         }

         BlockSetModule var7 = BlockSetModule.getInstance();

         for (ItemTool.DurabilityLossBlockTypes var11 : var4) {
            int[] var12 = var11.getBlockTypeIndexes();
            if (var12 != null) {
               for (int var16 : var12) {
                  if (var16 == var6) {
                     class="kw">return var11.getDurabilityLossOnHit();
                  }
               }
            }

            int[] var18 = var11.getBlockSetIndexes();
            if (var18 != null) {
               for (int var17 : var18) {
                  if (var7.blockInSet(var17, var5)) {
                     class="kw">return var11.getDurabilityLossOnHit();
                  }
               }
            }
         }

         class="kw">return var0.getDurabilityLossOnHit();
      } else {
         class="kw">return 0.0;
      }
   }

   @Nonnull
   class="kw">private class="kw">static BlockHarvestUtils.ItemDamageContext createItemDamageContext(@Nullable Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1) {
      World var2 = var1.getExternalData().getWorld();
      SpatialResource var3 = var1.getResource(EntityModule.get().getPlayerSpatialResourceType());
      TimeResource var4 = var1.getResource(TimeResource.getResourceType());
      boolean var5 = var0 != null && ItemUtils.canApplyItemStackPenalties(var0, var1);
      class="kw">return new BlockHarvestUtils.ItemDamageContext(var2, var3, var4, var5);
   }

   class="kw">private class="kw">static boolean damageSingleBlock(
      @Nullable Ref<EntityStore> var0,
      @Nullable Ref<EntityStore> var1,
      @Nonnull Vector3i var2,
      @Nullable ItemStack var3,
      @Nullable ItemTool var4,
      @Nullable String var5,
      boolean var6,
      float var7,
      int var8,
      boolean var9,
      boolean var10,
      @Nonnull BlockHarvestUtils.ItemDamageContext var11,
      @Nonnull Ref<ChunkStore> var12,
      @Nonnull ComponentAccessor<EntityStore> var13,
      @Nonnull ComponentAccessor<ChunkStore> var14
   ) {
      World var15 = var11.world();
      GameplayConfig var16 = var15.getGameplayConfig();
      ChunkSection var17 = var14.getComponent(var12, ChunkSection.getComponentType());
      if (var17 == null) {
         class="kw">return false;
      }

      Ref var18 = var17.getChunkColumnReference();
      BlockChunk var19 = var14.getComponent(var18, BlockChunk.getComponentType());
      if (var19 == null) {
         class="kw">return false;
      }

      BlockSection var20 = var14.getComponent(var12, BlockSection.getComponentType());
      if (var20 == null) {
         class="kw">return false;
      }

      int var21 = var20.getRotationIndex(var2.x, var2.y, var2.z);
      boolean var22 = false;
      int var23 = var19.getEnvironment(var2.x, var2.y, var2.z);
      Environment var24 = Environment.getAssetMap().getAsset(var23);
      SpatialResource var25 = var11.playerSpatialResource();
      if (var24 != null && !var24.isBlockModificationAllowed()) {
         var20.invalidateBlock(var2.x, var2.y, var2.z);
         class="kw">return false;
      }

      BlockType var26 = BlockType.getAssetMap().getAsset(var20.get(var2.x, var2.y, var2.z));
      if (var26 == null) {
         class="kw">return false;
      }

      BlockGathering var27 = var26.getGathering();
      if (var27 == null) {
         class="kw">return false;
      }

      if (var6 && !var27.getToolData().containsKey(var5)) {
         class="kw">return false;
      }

      Vector3d var28 = new Vector3d();
      var26.getBlockCenter(var21, var28);
      var28.add(var2.x, var2.y, var2.z);
      Vector3i var29 = new Vector3i(var2.x, var2.y, var2.z);
      Ref var30 = var12;
      BlockSection var31 = var20;
      Ref var32 = var18;
      if (!var26.isUnknown()) {
         int var33 = var20.getFiller(var2.x, var2.y, var2.z);
         int var34 = FillerBlockUtil.unpackX(var33);
         int var35 = FillerBlockUtil.unpackY(var33);
         int var36 = FillerBlockUtil.unpackZ(var33);
         if (var34 != 0 || var35 != 0 || var36 != 0) {
            var29 = new Vector3i(var29).sub(var34, var35, var36);
            if (!ChunkUtil.isSameChunkSection(var29.x, var29.y, var29.z, var2.x, var2.y, var2.z)) {
               var30 = var14.getExternalData().getChunkSectionReferenceAtBlock(var29.x, var29.y, var29.z);
               if (var30 == null || !var30.isValid()) {
                  class="kw">return false;
               }

               var31 = var14.getComponent(var30, BlockSection.getComponentType());
               assert var31 != null;
               ChunkSection var37 = var14.getComponent(var30, ChunkSection.getComponentType());
               assert var37 != null;
               var32 = var37.getChunkColumnReference();
            }

            String var61 = var26.getId();
            var26 = var15.getBlockType(var29.x(), var29.y(), var29.z());
            if (var26 == null) {
               class="kw">return false;
            }

            if (!var61.equals(var26.getId())) {
               BlockOperations.setBlock(var14.getExternalData(), var12, var2.x, var2.y, var2.z, 0, BlockType.EMPTY, 0, 0, 0);
               class="kw">return true;
            }

            var27 = var26.getGathering();
            if (var27 == null) {
               class="kw">return false;
            }
         }
      }

      if (var9 && handleExplosionReactionState(var15, var26, var2)) {
         class="kw">return true;
      }

      Item var57 = var3 != null ? var3.getItem() : null;
      if (var4 == null && var57 != null) {
         var4 = var57.getTool();
      }

      ItemToolSpec var58 = getSpecPowerDamageBlock(var57, var26, var4);
      float var59 = var58 != null ? var58.getPower() : 0.0F;
      boolean var60 = var11.canApplyItemStackPenalties();
      if (var59 != 0.0F && var57 != null && var57.getTool() != null && var3.isBroken() && var60) {
         BrokenPenalties var62 = var16.getItemDurabilityConfig().getBrokenPenalties();
         var59 *= 1.0F - (float)var62.getTool(0.0);
      }

      int var38 = 1;
      String var39;
      String var40;
      float var63;
      if (var59 != 0.0F) {
         BlockBreakingDropType var41 = var27.getBreaking();
         var63 = var59;
         var38 = var41.getQuantity();
         var39 = var41.getItemId();
         var40 = var41.getDropListId();
      } else {
         if (!var27.isSoft()) {
            if (var57 != null && var57.getWeapon() == null) {
               if (var0 != null) {
                  GatheringEffectsConfig var69 = var16.getGatheringConfig().getUnbreakableBlockConfig();
                  if ((var8 & 4) == 0) {
                     String var71 = var69.getParticleSystemId();
                     if (var71 != null) {
                        List var73 = SpatialResource.getThreadLocalReferenceList();
                        var25.getSpatialStructure().collect(var28, 75.0, var73);
                        ParticleUtil.spawnParticleEffect(var71, var28, var73, var13);
                     }
                  }

                  if ((var8 & 1024) == 0) {
                     int var72 = var69.getSoundEventIndex();
                     if (var72 != 0) {
                        SoundUtil.playSoundEvent3d(var0, var72, var28, var13);
                     }

                     if (var57.getTool() != null) {
                        int var74 = var57.getTool().getIncorrectMaterialSoundLayerIndex();
                        if (var74 != 0) {
                           SoundUtil.playSoundEvent3d(var0, var74, var28, var13);
                        }
                     }
                  }
               }

               class="kw">return false;
            }

            class="kw">return false;
         }

         SoftBlockDropType var66 = var27.getSoft();
         if (!var66.isWeaponBreakable() && var57 != null && var57.getWeapon() != null) {
            class="kw">return false;
         }

         var63 = 1.0F;
         var39 = var66.getItemId();
         var40 = var66.getDropListId();
         var7 = 1.0F;
      }

      var63 *= var7;
      if (var26.getGathering().shouldUseDefaultDropWhenPlaced()) {
         BlockPhysics var67 = var14.getComponent(var12, BlockPhysics.getComponentType());
         boolean var42 = var67 != null && var67.isDeco(var2.x, var2.y, var2.z);
         if (var42) {
            var39 = null;
            var40 = null;
         }
      }

      TimeResource var68 = var11.timeResource();
      BlockHealthChunk var70 = var14.getComponent(var32, BlockHealthModule.get().getBlockHealthChunkComponentType());
      assert var70 != null;
      float var43 = var70.getBlockHealth(var29);
      DamageBlockEvent var44 = new DamageBlockEvent(var3, var29, var26, var43, var63);
      if (var0 != null) {
         var13.invoke(var0, var44);
      } else {
         var13.invoke(var44);
      }

      if (var44.isCancelled()) {
         var20.invalidateBlock(var2.x, var2.y, var2.z);
         class="kw">return false;
      }

      var63 = var44.getDamage();
      var26 = var44.getBlockType();
      var2 = var44.getTargetBlock();
      if (!ChunkUtil.isSameChunkSection(var2.x, var2.y, var2.z, var29.x, var29.y, var29.z)) {
         var30 = var14.getExternalData().getChunkSectionReferenceAtBlock(var2.x, var2.y, var2.z);
         if (var30 == null || !var30.isValid()) {
            class="kw">return false;
         }

         var31 = var14.getComponent(var30, BlockSection.getComponentType());
         assert var31 != null;
         ChunkSection var45 = var14.getComponent(var30, ChunkSection.getComponentType());
         assert var45 != null;
         var32 = var45.getChunkColumnReference();
         var70 = var14.getComponent(var32, BlockHealthModule.get().getBlockHealthChunkComponentType());
         assert var70 != null;
      }

      var21 = var31.getRotationIndex(var2.x, var2.y, var2.z);
      var26.getBlockCenter(var21, var28);
      var28.add(var2.x, var2.y, var2.z);
      BlockHealth var75 = var70.damageBlock(var68.getNow(), var15, var2, var63);
      if (var70.isBlockFragile(var2) || var75.isDestroyed()) {
         BlockGathering.BlockToolData var46 = var27.getToolData().get(var5);
         boolean var47 = var46 != null;
         if (!var47) {
            performBlockBreak(var2, var26, var3, var38, var39, var40, var8, var0, var1, var30, var13, var14);
            var22 = true;
         } else {
            String var48 = var46.getStateId();
            BlockType var49 = var48 != null ? var26.getBlockForState(var48) : null;
            boolean var50 = var49 != null && !var26.getId().equals(var49.getId());
            if (var50) {
               var75.setHealth(1.0F);
               BlockOperations.setBlock(var14.getExternalData(), var30, var2.x, var2.y, var2.z, BlockType.getAssetMap().getIndex(var49.getId()), var49, 0, 0, 0);
               if ((var8 & 1024) == 0) {
                  playBlockSound(var26, BlockSoundEvent.Break, var28, var13);
               }

               if ((var8 & 2048) == 0) {
                  List var51 = getDrops(var26, 1, var46.getItemId(), var46.getDropListId());
                  Vector3d var52 = new Vector3d(var2.x + 0.5, var2.y, var2.z + 0.5);
                  spawnDrops(var13, var51, var52);
               }
            } else {
               performBlockBreak(var2, var26, var3, var38, var39, var40, var8 | 2048, var0, var1, var30, var13, var14);
               var22 = true;
               if ((var8 & 2048) == 0) {
                  List var81 = getDrops(var26, 1, var46.getItemId(), var46.getDropListId());
                  if (!var81.isEmpty()) {
                     Vector3d var82 = new Vector3d(var2.x + 0.5, var2.y, var2.z + 0.5);
                     spawnDrops(var13, var81, var82);
                  }
               }
            }
         }
      } else if ((var8 & 1024) == 0) {
         playBlockSound(var26, BlockSoundEvent.Hit, var28, var13);
      }

      if (var0 != null) {
         if ((var8 & 1024) == 0 && !var28.equals(Vector3dUtil.MAX)) {
            int var76 = 0;
            if (var58 != null) {
               var76 = var58.getHitSoundLayerIndex();
            }

            if (var76 == 0 && var57 != null && var57.getTool() != null) {
               var76 = var57.getTool().getHitSoundLayerIndex();
            }

            if (var76 != 0) {
               SoundUtil.playSoundEvent3d(var0, var76, var28.x(), var28.y(), var28.z(), var13);
            }
         }

         if (var58 != null && var58.isIncorrect()) {
            GatheringEffectsConfig var77 = var16.getGatheringConfig().getIncorrectToolConfig();
            if (var77 != null) {
               if ((var8 & 4) == 0) {
                  String var78 = var77.getParticleSystemId();
                  if (var78 != null) {
                     List var80 = SpatialResource.getThreadLocalReferenceList();
                     var25.getSpatialStructure().collect(var28, 75.0, var80);
                     ParticleUtil.spawnParticleEffect(var78, var28, var80, var13);
                  }
               }

               if ((var8 & 1024) == 0) {
                  int var79 = var77.getSoundEventIndex();
                  if (var79 != 0) {
                     SoundUtil.playSoundEvent3d(var0, var79, var28, var13);
                  }
               }
            }
         }
      }

      if (var10 && var0 != null) {
         applyItemDurabilityLoss(var0, var3, var57, var26, var13);
      }

      class="kw">return var22;
   }

   class="kw">private class="kw">static void applyItemDurabilityLoss(
      @Nonnull Ref<EntityStore> var0, @Nullable ItemStack var1, @Nullable Item var2, @Nullable BlockType var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      if (var1 != null && var2 != null && !var1.isUnbreakable()) {
         if (ItemUtils.canDecreaseItemStackDurability(var0, var4)) {
            InventoryComponent.Hotbar var5 = var4.getComponent(var0, InventoryComponent.Hotbar.getComponentType());
            if (var5 != null && var5.getActiveSlot() != -1) {
               double var6 = calculateDurabilityUse(var2, var3);
               ItemUtils.updateItemStackDurability(var0, var1, var5.getInventory(), var5.getActiveSlot(), -var6, var4);
            }
         }
      }
   }

   class="kw">private class="kw">static void removeBlock(
      @Nonnull Vector3i var0,
      @Nonnull BlockType var1,
      int var2,
      @Nonnull Ref<ChunkStore> var3,
      @Nonnull BlockSection var4,
      @Nonnull ComponentAccessor<ChunkStore> var5
   ) {
      World var6 = var5.getExternalData().getWorld();
      ChunkSection var7 = var5.getComponent(var3, ChunkSection.getComponentType());
      assert var7 != null;
      ComponentType var8 = BlockHealthModule.get().getBlockHealthChunkComponentType();
      BlockHealthChunk var9 = var5.getComponent(var7.getChunkColumnReference(), var8);
      assert var9 != null;
      var9.removeBlock(var6, var0);
      BlockOperations.setBlock(var5.getExternalData(), var3, var0.x(), var0.y(), var0.z(), 0, BlockType.EMPTY, 0, 0, var2);
      if ((var2 & 256) != 0) {
         int var10 = var4.getRotationIndex(var0.x, var0.y, var0.z);
         BlockBoundingBoxes var11 = BlockBoundingBoxes.getAssetMap().getAsset(var1.getHitboxTypeIndex());
         if (var11 != null) {
            FillerBlockUtil.forEachFillerBlock(
               var11.get(var10), (var2x, var3x, var4x) -> var6.performBlockUpdate(var0.x() + var2x, var0.y() + var3x, var0.z() + var4x, false)
            );
         }
      }

      ConnectedBlocksUtil.setConnectedBlockAndNotifyNeighbors(
         var5.getExternalData(), BlockType.getAssetMap().getIndex("Empty"), RotationTuple.NONE, Vector3iUtil.ZERO, var0, var3, var4
      );
   }

   class="kw">private class="kw">static void playBlockSound(
      @Nonnull BlockType var0, @Nonnull BlockSoundEvent var1, @Nonnull Vector3d var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      BlockSoundSet var4 = BlockSoundSet.getAssetMap().getAsset(var0.getBlockSoundSetIndex());
      if (var4 != null) {
         int var5 = var4.getSoundEventIndices().getOrDefault(var1, 0);
         if (var5 != 0) {
            SoundUtil.playSoundEvent3d(var5, SoundCategory.SFX, var2, var3);
         }
      }
   }

   class="kw">private class="kw">static void spawnDrops(@Nonnull ComponentAccessor<EntityStore> var0, @Nonnull List<ItemStack> var1, @Nonnull Vector3d var2) {
      Holder[] var3 = ItemComponent.generateItemDrops(var0, var1, var2, Rotation3f.IDENTITY);
      var0.addEntities(var3, AddReason.SPAWN);
   }

   class="kw">private class="kw">static boolean handleExplosionReactionState(@Nonnull World var0, @Nonnull BlockType var1, @Nonnull Vector3i var2) {
      String var3 = var1.getExplosionReactionState();
      if (var3 == null) {
         class="kw">return false;
      }

      BlockType var4 = var1.getBlockForState(var3);
      if (var4 == null) {
         class="kw">return false;
      }

      int var5 = BlockType.getAssetMap().getIndex(var4.getId());
      if (var5 == Integer.MIN_VALUE) {
         class="kw">return false;
      }

      long var6 = ChunkUtil.indexChunkFromBlock(var2.x, var2.z);
      WorldChunk var8 = var0.getChunkIfInMemory(var6);
      int var9 = 260;
      int var10 = var8.getRotationIndex(var2.x, var2.y, var2.z);
      var8.setBlock(var2.x(), var2.y(), var2.z(), var5, var4, var10, 0, 260);
      class="kw">return true;
   }

   class="kw">public class="kw">static void fireOnBreakInteraction(
      @Nullable Ref<EntityStore> var0,
      @Nullable Ref<EntityStore> var1,
      @Nonnull BlockType var2,
      @Nonnull Vector3i var3,
      int var4,
      int var5,
      @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      if (var0 != null && (var5 & 4096) == 0) {
         if (var6 class="kw">instanceof CommandBuffer var7) {
            queueBlockInteraction(var0, var1 != null ? var1 : var0, InteractionType.OnBreak, var2, var3, var4, var7);
         }
      }
   }

   class="kw">public class="kw">static void queueOnBreakImpactInteraction(
      @Nonnull Ref<EntityStore> var0, @Nonnull BlockType var1, @Nonnull Vector3i var2, int var3, @Nonnull CommandBuffer<EntityStore> var4
   ) {
      queueBlockInteraction(var0, var0, InteractionType.OnBreakImpact, var1, var2, var3, var4);
   }

   class="kw">private class="kw">static void queueBlockInteraction(
      @Nonnull Ref<EntityStore> var0,
      @Nonnull Ref<EntityStore> var1,
      @Nonnull InteractionType var2,
      @Nonnull BlockType var3,
      @Nonnull Vector3i var4,
      int var5,
      @Nonnull CommandBuffer<EntityStore> var6
   ) {
      String var7 = var3.getInteractions().get(var2);
      if (var7 != null) {
         try {
            InteractionManager var8 = var0.isValid() ? var6.getComponent(var0, InteractionModule.get().getInteractionManagerComponent()) : null;
            if (var8 == null) {
               queueBlockInteractionOnHost(var0, var2, var7, var3, var4, var5, var6);
               class="kw">return;
            }

            Ref var9 = var1.isValid() ? var1 : var0;
            queueBlockInteractionChain(var8, var0, var9, var2, var7, var3, var4, var5, var6);
         } catch (Throwable var10) {
            logBlockInteractionFailure(var10, var2, var7, var3, var4);
         }
      }
   }

   class="kw">private class="kw">static void queueBlockInteractionOnHost(
      @Nonnull Ref<EntityStore> var0,
      @Nonnull InteractionType var1,
      @Nonnull String var2,
      @Nonnull BlockType var3,
      @Nonnull Vector3i var4,
      int var5,
      @Nonnull CommandBuffer<EntityStore> var6
   ) {
      World var7 = var6.getExternalData().getWorld();
      Vector3d var8 = new Vector3d(var4.x + 0.5, var4.y + 0.5, var4.z + 0.5);
      Vector3i var9 = new Vector3i(var4);
      var7.execute(() -> {
         Store var8 = var7.getEntityStore().getStore();
         if (var8 != null) {
            try {
               Ref var9 = InteractionHost.spawnHost(var8, var8, new Rotation3f(), 30.0F, new InteractionSimulationHandler());
               if (var9 == null) {
                  class="kw">return;
               }

               InteractionManager var10 = var8.getComponent(var9, InteractionModule.get().getInteractionManagerComponent());
               InteractionHost var11 = var8.getComponent(var9, InteractionHost.getComponentType());
               if (var10 == null || var11 == null) {
                  class="kw">return;
               }

               Ref var12 = var0.isValid() ? var0 : var9;
               var11.setChain(queueBlockInteractionChain(var10, var12, var9, var1, var2, var3, var9, var5, var8));
            } catch (Throwable var13) {
               logBlockInteractionFailure(var13, var1, var2, var3, var9);
            }
         }
      });
   }

   class="kw">private class="kw">static void logBlockInteractionFailure(
      @Nonnull Throwable var0, @Nonnull InteractionType var1, @Nonnull String var2, @Nonnull BlockType var3, @Nonnull Vector3i var4
   ) {
      ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var0))
         .log("Failed to run %s interaction '%s' for block '%s' at %s", var1, var2, var3.getId(), var4);
   }

   @Nonnull
   class="kw">private class="kw">static InteractionChain queueBlockInteractionChain(
      @Nonnull InteractionManager var0,
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull InteractionType var3,
      @Nonnull String var4,
      @Nonnull BlockType var5,
      @Nonnull Vector3i var6,
      int var7,
      @Nonnull ComponentAccessor<EntityStore> var8
   ) {
      RootInteraction var9 = RootInteraction.getRootInteractionOrUnknown(var4);
      InteractionContext var10 = var1.equals(var2)
         ? InteractionContext.forInteraction(var0, var1, var3, var8)
         : InteractionContext.forProxyEntity(var0, var1, var2, var8);
      BlockPosition var11 = new BlockPosition(var6.x, var6.y, var6.z);
      StandardPhysicsProvider var12 = var8.getComponent(var2, StandardPhysicsProvider.getComponentType());
      BlockPosition var13 = var12 != null ? var12.getContactBlock() : null;
      var10.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK_RAW, var13 != null ? var13 : var11);
      var10.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK, var11);
      var10.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK_TYPE, var5);
      var10.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK_ROTATION_INDEX, var7);
      InteractionChain var14 = var0.initChain(var3, var10, var9, -1, var11, false);
      var0.queueExecuteChain(var14);
      class="kw">return var14;
   }

   class="kw">private record ItemDamageContext(
      @Nonnull World world,
      @Nonnull SpatialResource<Ref<EntityStore>, EntityStore> playerSpatialResource,
      @Nonnull TimeResource timeResource,
      boolean canApplyItemStackPenalties
   ) {
      class="kw">private ItemDamageContext {
      }
   }
}