class="kw">package com.hypixel.hytale.builtin.triggervolumes.system;

class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.SignalTag;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerEventType;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.TaggedVolumeEffectUtil;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.AbstractDenyRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.CreativePlacementRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.DamageMultiplierRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoBuildRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoDamageRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoDestroyRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoDoorOpenRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoHarvestRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoUseRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.TriggerVolumeManager;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.VolumeEntry;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
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.Ref;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.SystemGroup;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.EntityEventSystem;
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.farming.FarmingData;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
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.PlaceBlockEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.UseBlockEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.UseEntityEvent;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageEventSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemComponent;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.BlockHarvestUtils;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.TimeUnit;
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="kw">final class TriggerVolumeRuleSystems {
   class="kw">private TriggerVolumeRuleSystems() {
   }

   @Nullable
   class="kw">private class="kw">static TriggerVolumeManager manager(@Nonnull Store<EntityStore> var0, @Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
      class="kw">return var0.getResource(var1);
   }

   @Nonnull
   class="kw">private class="kw">static Vector3d blockCenter(@Nonnull Vector3i var0) {
      class="kw">return new Vector3d(var0.x() + 0.5, var0.y() + 0.5, var0.z() + 0.5);
   }

   @Nullable
   class="kw">private class="kw">static String blockKeyFromItem(@Nullable ItemStack var0) {
      class="kw">return var0 != null && var0.getItem() != null && var0.getItem().hasBlockType() ? var0.getItem().getBlockId() : null;
   }

   @Nullable
   class="kw">private class="kw">static String itemIdFrom(@Nullable ItemStack var0) {
      class="kw">return var0 != null ? var0.getItemId() : null;
   }

   @Nullable
   class="kw">private class="kw">static String resolveEntityName(@Nonnull ComponentAccessor<EntityStore> var0, @Nonnull Ref<EntityStore> var1) {
      if (var0.getComponent(var1, Player.getComponentType()) != null) {
         class="kw">return "Player";
      }

      ComponentType var2 = NPCEntity.getComponentType();
      if (var2 == null) {
         class="kw">return null;
      }

      NPCEntity var3 = var0.getComponent(var1, var2);
      class="kw">return var3 != null ? var3.getRoleName() : null;
   }

   class="kw">static boolean isDestroyExcepted(@Nonnull NoDestroyRule var0, @Nullable String var1, @Nullable String var2) {
      boolean var3 = false;
      if (var0.hasBlockException()) {
         if (!var0.isBlockExcepted(var1)) {
            class="kw">return false;
         }

         var3 = true;
      }

      if (var0.hasToolException()) {
         if (!var0.isToolExcepted(var2)) {
            class="kw">return false;
         }

         var3 = true;
      }

      class="kw">return var3;
   }

   class="kw">private class="kw">static void sendDenySignals(
      @Nonnull TriggerVolumeManager var0,
      @Nonnull AbstractDenyRule var1,
      @Nonnull VolumeEntry var2,
      @Nonnull Store<EntityStore> var3,
      @Nullable Ref<EntityStore> var4,
      @Nonnull Vector3d var5,
      @Nullable String var6
   ) {
      List var7 = var1.getSignalTags();
      UUID var8 = resolveActorUuid(var3, var4);
      AbstractDenyRule.DenySignalTarget var9 = var1.getTarget();
      if (var9 != AbstractDenyRule.DenySignalTarget.OTHER) {
         var0.enqueueVolumeEvent(TriggerEventType.SIGNAL_RECEIVED, var4, var8, var2.getId(), var7, var5, var6);
      }

      if (var9 != AbstractDenyRule.DenySignalTarget.SELF) {
         String var10 = TaggedVolumeEffectUtil.composeTagFilter(var1.getMatchKey(), var1.getMatchValue());

         for (VolumeEntry var12 : TaggedVolumeEffectUtil.collectTargets(var0, var10, var1.getRadius(), var5)) {
            var0.enqueueVolumeEvent(TriggerEventType.SIGNAL_RECEIVED, var4, var8, var12.getId(), var7, var5, var6);
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static UUID resolveActorUuid(@Nonnull Store<EntityStore> var0, @Nullable Ref<EntityStore> var1) {
      if (var1 != null && var1.isValid()) {
         UUIDComponent var2 = var0.getComponent(var1, UUIDComponent.getComponentType());
         if (var2 != null) {
            class="kw">return var2.getUuid();
         }
      }

      class="kw">return TriggerVolumeManager.ENVIRONMENT_ACTOR_UUID;
   }

   class="kw">public class="kw">static class="kw">final class CreativePlacement class="kw">extends EntityEventSystem<EntityStore, PlaceBlockEvent> {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public CreativePlacement(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(PlaceBlockEvent.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull PlaceBlockEvent var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            if (var6.hasActiveRule(TriggerVolumeRuleSystems.blockCenter(var5.getTargetBlock()), CreativePlacementRule.class)) {
               var5.setConsumeItem(false);
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }

   class="kw">public class="kw">static class="kw">final class DamageMultiplier class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public DamageMultiplier(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         this.managerResourceType = var1;
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return DamageModule.get().getFilterDamageGroup();
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return TransformComponent.getComponentType();
      }

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            TransformComponent var7 = var2.getComponent(var1, TransformComponent.getComponentType());
            if (var7 != null) {
               List var8 = var6.getActiveRules(var7.getPosition(), DamageMultiplierRule.class);
               List var9 = collectAttackerRules(var6, var4, var5);
               if (!var8.isEmpty() || !var9.isEmpty()) {
                  String var10 = TriggerVolumeRuleSystems.resolveEntityName(var4, var2.getReferenceTo(var1));
                  String var11 = resolveAttackerName(var4, var5);
                  float var12 = 1.0F;
                  ArrayList var13 = new ArrayList<>();

                  for (DamageMultiplierRule var15 : var8) {
                     if (var15.getDirection() != DamageMultiplierRule.Direction.DEALT && var15.affects(var10)) {
                        var12 *= var15.getMultiplier();
                        var13.add(var15);
                     }
                  }

                  for (DamageMultiplierRule var17 : var9) {
                     if (var17.getDirection() != DamageMultiplierRule.Direction.RECEIVED && !containsIdentity(var13, var17) && var17.affects(var11)) {
                        var12 *= var17.getMultiplier();
                     }
                  }

                  if (var12 != 1.0F) {
                     var5.setAmount(var5.getAmount() * var12);
                  }
               }
            }
         }
      }

      @Nullable
      class="kw">private class="kw">static String resolveAttackerName(@Nonnull CommandBuffer<EntityStore> var0, @Nonnull Damage var1) {
         if (var1.getSource() class="kw">instanceof Damage.EntitySource var2) {
            Ref var4 = var2.getRef();
            class="kw">return !var4.isValid() ? null : TriggerVolumeRuleSystems.resolveEntityName(var0, var4);
         } else {
            class="kw">return null;
         }
      }

      @Nonnull
      class="kw">private class="kw">static List<DamageMultiplierRule> collectAttackerRules(
         @Nonnull TriggerVolumeManager var0, @Nonnull CommandBuffer<EntityStore> var1, @Nonnull Damage var2
      ) {
         if (var2.getSource() class="kw">instanceof Damage.EntitySource var3) {
            Ref var6 = var3.getRef();
            if (!var6.isValid()) {
               class="kw">return List.of();
            }

            TransformComponent var5 = var1.getComponent(var6, TransformComponent.getComponentType());
            class="kw">return var5 == null ? List.of() : var0.getActiveRules(var5.getPosition(), DamageMultiplierRule.class);
         } else {
            class="kw">return List.of();
         }
      }

      class="kw">private class="kw">static boolean containsIdentity(@Nonnull List<DamageMultiplierRule> var0, @Nonnull DamageMultiplierRule var1) {
         for (DamageMultiplierRule var3 : var0) {
            if (var3 == var1) {
               class="kw">return true;
            }
         }

         class="kw">return false;
      }
   }

   class="kw">public class="kw">static class="kw">final class DamageRuleFilter class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public DamageRuleFilter(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         this.managerResourceType = var1;
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return DamageModule.get().getFilterDamageGroup();
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return TransformComponent.getComponentType();
      }

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            TransformComponent var7 = var2.getComponent(var1, TransformComponent.getComponentType());
            if (var7 != null) {
               Vector3d var8 = var7.getPosition();
               List var9 = var6.getActiveRules(var8, NoDamageRule.class);
               if (!var9.isEmpty()) {
                  String var10 = TriggerVolumeRuleSystems.resolveEntityName(var4, var2.getReferenceTo(var1));
                  boolean var11 = isPlayerVsPlayer(var2, var1, var4, var5);

                  for (NoDamageRule var13 : var9) {
                     if (var13.protects(var10) && (!var13.isPvpOnly() || var11)) {
                        var5.setCancelled(true);
                        class="kw">return;
                     }
                  }
               }
            }
         }
      }

      class="kw">private class="kw">static boolean isPlayerVsPlayer(
         @Nonnull ArchetypeChunk<EntityStore> var0, int var1, @Nonnull CommandBuffer<EntityStore> var2, @Nonnull Damage var3
      ) {
         if (var0.getComponent(var1, Player.getComponentType()) == null) {
            class="kw">return false;
         } else if (var3.getSource() class="kw">instanceof Damage.EntitySource var4) {
            Ref var6 = var4.getRef();
            class="kw">return !var6.isValid() ? false : var2.getComponent(var6, Player.getComponentType()) != null;
         } else {
            class="kw">return false;
         }
      }
   }

   class="kw">public class="kw">static class="kw">final class NoBuild class="kw">extends EntityEventSystem<EntityStore, PlaceBlockEvent> {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public NoBuild(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(PlaceBlockEvent.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull PlaceBlockEvent var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            Vector3d var7 = TriggerVolumeRuleSystems.blockCenter(var5.getTargetBlock());
            List var8 = var6.getActiveRulesWithVolume(var7, NoBuildRule.class);
            if (!var8.isEmpty()) {
               String var9 = TriggerVolumeRuleSystems.blockKeyFromItem(var5.getItemInHand());

               for (TriggerVolumeManager.ActiveRule var11 : var8) {
                  if (!var11.rule().isBlockExcepted(var9)) {
                     var5.setCancelled(true);
                     TriggerVolumeRuleSystems.sendDenySignals(var6, var11.rule(), var11.volume(), var3, var2.getReferenceTo(var1), var7, var9);
                     class="kw">return;
                  }
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }

   class="kw">public class="kw">static class="kw">final class NoDestroyBlockBreak class="kw">extends EntityEventSystem<EntityStore, BreakBlockEvent> {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public NoDestroyBlockBreak(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(BreakBlockEvent.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull BreakBlockEvent var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            Vector3d var7 = TriggerVolumeRuleSystems.blockCenter(var5.getTargetBlock());
            String var8 = var5.getBlockType().getId();
            String var9 = TriggerVolumeRuleSystems.itemIdFrom(var5.getItemInHand());
            Ref var10 = var2.getReferenceTo(var1);

            for (TriggerVolumeManager.ActiveRule var12 : var6.getActiveRulesWithVolume(var7, NoDestroyRule.class)) {
               if (!TriggerVolumeRuleSystems.isDestroyExcepted(var12.rule(), var8, var9)) {
                  var5.setCancelled(true);
                  TriggerVolumeRuleSystems.sendDenySignals(var6, var12.rule(), var12.volume(), var3, var10, var7, var8);
                  class="kw">return;
               }
            }

            if (BlockHarvestUtils.shouldPickupByInteraction(var5.getBlockType())) {
               for (TriggerVolumeManager.ActiveRule var14 : var6.getActiveRulesWithVolume(var7, NoHarvestRule.class)) {
                  if (!var14.rule().isBlockExcepted(var8)) {
                     var5.setCancelled(true);
                     TriggerVolumeRuleSystems.sendDenySignals(var6, var14.rule(), var14.volume(), var3, var10, var7, var8);
                     class="kw">return;
                  }
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }

   class="kw">public class="kw">static class="kw">final class NoDestroyBlockDamage class="kw">extends EntityEventSystem<EntityStore, DamageBlockEvent> {
      class="kw">private class="kw">static class="kw">final long DENY_SIGNAL_COOLDOWN_NANOS = TimeUnit.MILLISECONDS.toNanos(300L);
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;
      @Nonnull
      class="kw">private class="kw">final Map<UUID, Long> lastDenySignalNanos = new ConcurrentHashMap<>();

      class="kw">public NoDestroyBlockDamage(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(DamageBlockEvent.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull DamageBlockEvent var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            Vector3d var7 = TriggerVolumeRuleSystems.blockCenter(var5.getTargetBlock());
            List var8 = var6.getActiveRulesWithVolume(var7, NoDestroyRule.class);
            if (!var8.isEmpty()) {
               String var9 = var5.getBlockType().getId();
               String var10 = TriggerVolumeRuleSystems.itemIdFrom(var5.getItemInHand());

               for (TriggerVolumeManager.ActiveRule var12 : var8) {
                  if (!TriggerVolumeRuleSystems.isDestroyExcepted(var12.rule(), var9, var10)) {
                     var5.setCancelled(true);
                     this.sendDenySignalsDebounced(var6, var12.rule(), var12.volume(), var3, var2.getReferenceTo(var1), var7, var9);
                     class="kw">return;
                  }
               }
            }
         }
      }

      class="kw">private void sendDenySignalsDebounced(
         @Nonnull TriggerVolumeManager var1,
         @Nonnull NoDestroyRule var2,
         @Nonnull VolumeEntry var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull Ref<EntityStore> var5,
         @Nonnull Vector3d var6,
         @Nullable String var7
      ) {
         UUIDComponent var8 = var4.getComponent(var5, UUIDComponent.getComponentType());
         if (var8 != null) {
            long var9 = System.nanoTime();
            this.lastDenySignalNanos.entrySet().removeIf(var2x -> var9 - var2x.getValue() >= DENY_SIGNAL_COOLDOWN_NANOS);
            Long var11 = this.lastDenySignalNanos.get(var8.getUuid());
            if (var11 != null && var9 - var11 < DENY_SIGNAL_COOLDOWN_NANOS) {
               class="kw">return;
            }

            this.lastDenySignalNanos.put(var8.getUuid(), var9);
         }

         TriggerVolumeRuleSystems.sendDenySignals(var1, var2, var3, var4, var5, var6, var7);
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }

   class="kw">public class="kw">static class="kw">final class NoDoorOpen class="kw">extends EntityEventSystem<EntityStore, UseBlockEvent.Pre> {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public NoDoorOpen(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(UseBlockEvent.Pre.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull UseBlockEvent.Pre var5
      ) {
         if (var5.getBlockType().isDoor()) {
            TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
            if (var6 != null) {
               Vector3d var7 = TriggerVolumeRuleSystems.blockCenter(var5.getTargetBlock());
               List var8 = var6.getActiveRulesWithVolume(var7, NoDoorOpenRule.class);
               if (!var8.isEmpty()) {
                  var5.setCancelled(true);
                  TriggerVolumeManager.ActiveRule var9 = var8.get(0);
                  TriggerVolumeRuleSystems.sendDenySignals(var6, var9.rule(), var9.volume(), var3, var2.getReferenceTo(var1), var7, var5.getBlockType().getId());
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }

   class="kw">public class="kw">static class="kw">final class NoHarvestUse class="kw">extends EntityEventSystem<EntityStore, UseBlockEvent.Pre> {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public NoHarvestUse(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(UseBlockEvent.Pre.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull UseBlockEvent.Pre var5
      ) {
         BlockType var6 = var5.getBlockType();
         FarmingData var7 = var6.getFarming();
         if (var7 != null && var7.getStages() != null) {
            TriggerVolumeManager var8 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
            if (var8 != null) {
               Vector3d var9 = TriggerVolumeRuleSystems.blockCenter(var5.getTargetBlock());
               List var10 = var8.getActiveRulesWithVolume(var9, NoHarvestRule.class);
               if (!var10.isEmpty()) {
                  String var11 = var6.getId();

                  for (TriggerVolumeManager.ActiveRule var13 : var10) {
                     if (!var13.rule().isBlockExcepted(var11)) {
                        var5.setCancelled(true);
                        TriggerVolumeRuleSystems.sendDenySignals(var8, var13.rule(), var13.volume(), var3, var2.getReferenceTo(var1), var9, var11);
                        class="kw">return;
                     }
                  }
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }

   class="kw">public class="kw">static class="kw">final class NoUseBlock class="kw">extends EntityEventSystem<EntityStore, UseBlockEvent.Pre> {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public NoUseBlock(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(UseBlockEvent.Pre.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull UseBlockEvent.Pre var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            Vector3d var7 = TriggerVolumeRuleSystems.blockCenter(var5.getTargetBlock());
            List var8 = var6.getActiveRulesWithVolume(var7, NoUseRule.class);
            if (!var8.isEmpty()) {
               String var9 = var5.getBlockType().getId();

               for (TriggerVolumeManager.ActiveRule var11 : var8) {
                  if (!var11.rule().isBlockExcepted(var9)) {
                     var5.setCancelled(true);
                     TriggerVolumeRuleSystems.sendDenySignals(var6, var11.rule(), var11.volume(), var3, var2.getReferenceTo(var1), var7, var9);
                     class="kw">return;
                  }
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }

   class="kw">public class="kw">static class="kw">final class NoUseEntity class="kw">extends EntityEventSystem<EntityStore, UseEntityEvent.Pre> {
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;

      class="kw">public NoUseEntity(@Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1) {
         super(UseEntityEvent.Pre.class);
         this.managerResourceType = var1;
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull UseEntityEvent.Pre var5
      ) {
         TriggerVolumeManager var6 = TriggerVolumeRuleSystems.manager(var3, this.managerResourceType);
         if (var6 != null) {
            Ref var7 = var5.getTargetEntity();
            if (var7.isValid()) {
               TransformComponent var8 = var3.getComponent(var7, TransformComponent.getComponentType());
               if (var8 != null && var8.getPosition() != null) {
                  Vector3d var9 = new Vector3d(var8.getPosition());
                  List var10 = var6.getActiveRulesWithVolume(var9, NoUseRule.class);
                  if (!var10.isEmpty()) {
                     ItemComponent var11 = var3.getComponent(var7, ItemComponent.getComponentType());
                     ItemStack var12 = var11 != null ? var11.getItemStack() : null;
                     String var13 = var12 != null ? var12.getItemId() : null;

                     for (TriggerVolumeManager.ActiveRule var15 : var10) {
                        if (!var15.rule().isBlockExcepted(var13)) {
                           var5.setCancelled(true);
                           TriggerVolumeRuleSystems.sendDenySignals(var6, var15.rule(), var15.volume(), var3, var2.getReferenceTo(var1), var9, var13);
                           class="kw">return;
                        }
                     }
                  }
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }
   }
}