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

class="kw">import com.hypixel.hytale.builtin.triggervolumes.EntityTargetType;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.component.IgnoreTriggerVolumes;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerContext;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerEventType;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.event.TriggerVolumeEvent;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.ConditionTiming;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.GroupEntry;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.RejectionDelayMode;
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.builtin.triggervolumes.shape.TriggerVolumeShape;
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.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
class="kw">import com.hypixel.hytale.component.dependency.OrderPriority;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.spatial.SpatialData;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.tick.TickingSystem;
class="kw">import com.hypixel.hytale.event.IEventDispatcher;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.PlayerSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.projectile.component.Projectile;
class="kw">import com.hypixel.hytale.server.core.modules.time.TimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.TickSuppressionRegistry;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkFlag;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
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 it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import java.time.Instant;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.HashMap;
class="kw">import java.util.HashSet;
class="kw">import java.util.IdentityHashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.Map.Entry;
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">public class TriggerVolumeTickingSystem class="kw">extends TickingSystem<EntityStore> {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final double DEFAULT_ENTITY_HEIGHT = 1.8;
   class="kw">private class="kw">static class="kw">final int MAX_PENDING_EVENTS_PER_TICK = 64;
   class="kw">private class="kw">static class="kw">final int[] SINGLE_DEFAULT_ENTRY = new int[]{0};
   @Nonnull
   class="kw">private class="kw">static class="kw">final ThreadLocal<Set<UUID>> THREAD_LOCAL_PREVIOUS = ThreadLocal.withInitial(HashSet::new);
   @Nonnull
   class="kw">private class="kw">static class="kw">final ThreadLocal<Map<UUID, Ref<EntityStore>>> THREAD_LOCAL_PREVIOUS_REFS = ThreadLocal.withInitial(HashMap::new);
   @Nonnull
   class="kw">private class="kw">static class="kw">final ThreadLocal<Vector3d> THREAD_LOCAL_TEST_POINT = ThreadLocal.withInitial(Vector3d::new);
   @Nonnull
   class="kw">private class="kw">static class="kw">final ThreadLocal<List<VolumeEntry>> THREAD_LOCAL_CANDIDATES = ThreadLocal.withInitial(ArrayList::new);
   @Nonnull
   class="kw">private class="kw">static class="kw">final ThreadLocal<List<Ref<EntityStore>>> THREAD_LOCAL_ENTITY_REFS = ThreadLocal.withInitial(ArrayList::new);
   @Nonnull
   class="kw">private class="kw">static class="kw">final ThreadLocal<List<VolumeEntry>> THREAD_LOCAL_ACTIVE_SNAPSHOT = ThreadLocal.withInitial(ArrayList::new);
   @Nonnull
   class="kw">private class="kw">final ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;
   @Nonnull
   class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> playerSpatialResourceType;
   @Nonnull
   class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> entitySpatialResourceType;
   @Nonnull
   class="kw">private class="kw">final ResourceType<EntityStore, TimeResource> timeResourceType;
   @Nonnull
   class="kw">private class="kw">final ResourceType<EntityStore, TickSuppressionRegistry> tickSuppressionResourceType;
   @Nonnull
   class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;
   @Nonnull
   class="kw">private class="kw">final TriggerVolumeTickingSystem.EventDispatcher eventDispatcher;

   class="kw">public TriggerVolumeTickingSystem(
      @Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1,
      @Nonnull ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> var2,
      @Nonnull ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> var3,
      @Nonnull ResourceType<EntityStore, TimeResource> var4,
      @Nonnull ResourceType<EntityStore, TickSuppressionRegistry> var5
   ) {
      this(var1, var2, var3, var4, var5, TriggerVolumeTickingSystem::dispatchToServerEventBus);
   }

   TriggerVolumeTickingSystem(
      @Nonnull ResourceType<EntityStore, TriggerVolumeManager> var1,
      @Nonnull ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> var2,
      @Nonnull ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> var3,
      @Nonnull ResourceType<EntityStore, TimeResource> var4,
      @Nonnull ResourceType<EntityStore, TickSuppressionRegistry> var5,
      @Nonnull TriggerVolumeTickingSystem.EventDispatcher var6
   ) {
      this.managerResourceType = var1;
      this.playerSpatialResourceType = var2;
      this.entitySpatialResourceType = var3;
      this.timeResourceType = var4;
      this.tickSuppressionResourceType = var5;
      this.eventDispatcher = var6;
      this.dependencies = Set.of(new SystemDependency<>(Order.AFTER, PlayerSpatialSystem.class, OrderPriority.CLOSEST));
   }

   @Nonnull
   @Override
   class="kw">public Set<Dependency<EntityStore>> getDependencies() {
      class="kw">return this.dependencies;
   }

   @Override
   class="kw">public void tick(float var1, int var2, @Nonnull Store<EntityStore> var3) {
      TriggerVolumeManager var4 = var3.getResource(this.managerResourceType);
      if (var4 != null) {
         VolumeSpatialIndex var5 = var4.getSpatialIndex();
         var5.applyPendingChanges();
         Set var6 = var4.getActiveVolumes();
         if (!var5.isEmpty() || !var6.isEmpty()) {
            this.runVolumeLifecycle(var1, var3, var4, var5, var6);
         }

         DelayedEffectScheduler var7 = var4.getDelayedEffectScheduler();
         if (!var7.isEmpty()) {
            var7.tick(System.nanoTime(), var3);
         }

         this.processPendingEvents(var4, var3);
         var4.flushClientRuleVolumesIfDirty();
         TickSuppressionRegistry var8 = var3.getResource(this.tickSuppressionResourceType);
         if (var8 != null) {
            var4.flushTickSuppressionIfDirty(var8);
         }

         TimeResource var9 = var3.getResource(this.timeResourceType);
         processVolumesToRemove(var4, var9);
      }
   }

   class="kw">private void runVolumeLifecycle(
      float var1, @Nonnull Store<EntityStore> var2, @Nonnull TriggerVolumeManager var3, @Nonnull VolumeSpatialIndex var4, @Nonnull Set<VolumeEntry> var5
   ) {
      Set var6 = Collections.newSetFromMap(new IdentityHashMap<>());
      List var7 = THREAD_LOCAL_CANDIDATES.get();
      World var8 = var3.getWorld();
      this.collectCandidatesFromEntityPositions(var2, var4, var6, var7, var3.hasEntityTargetVolumes());
      var6.removeIf(var1x -> !isVolumeChunkLoaded(var1x, var8));
      List var9 = THREAD_LOCAL_ACTIVE_SNAPSHOT.get();
      var9.clear();
      var9.addAll(var5);

      for (VolumeEntry var11 : var9) {
         boolean var12 = !var11.isEnabled() || !isVolumeChunkLoaded(var11, var8);
         if (var12) {
            var6.remove(var11);
            if (!var11.getTrackedEntities().isEmpty()) {
               this.processTrackedEntityExits(var11, var2, var3);
            }

            var3.updateTrackingState(var11);
         } else if (!var11.getTrackedEntities().isEmpty()) {
            var6.add(var11);
         }
      }

      for (VolumeEntry var15 : var6) {
         try {
            this.tickVolume(var15, var1, var2, var3);
         } catch (Exception var13) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var13)).log("Error ticking trigger volume '%s'", var15.getId());
         }

         var3.updateTrackingState(var15);
      }
   }

   class="kw">private class="kw">static boolean isVolumeChunkLoaded(@Nonnull VolumeEntry var0, @Nullable World var1) {
      class="kw">return var0.isKeepLoaded() || var1 == null || isChunkLoaded(var1, var0.getPosition());
   }

   class="kw">private void processPendingEvents(@Nonnull TriggerVolumeManager var1, @Nonnull Store<EntityStore> var2) {
      for (int var3 = 0; var3 < 64; var3++) {
         TriggerVolumeManager.PendingTriggerEvent var4 = var1.pollPendingEvent();
         if (var4 == null) {
            class="kw">return;
         }

         this.processPendingEvent(var4, var1, var2, System.nanoTime());
      }

      if (var1.hasPendingEvents()) {
         LOGGER.at(Level.WARNING).log("Deferred trigger volume events to a later tick after %d events", 64);
      }
   }

   class="kw">private void processPendingEvent(
      @Nonnull TriggerVolumeManager.PendingTriggerEvent var1, @Nonnull TriggerVolumeManager var2, @Nonnull Store<EntityStore> var3, long var4
   ) {
      if (var1.actorRef() == null || var1.actorRef().isValid()) {
         if (var1.actorRef() == null || !isTriggerExempt(var1.actorRef(), var3)) {
            if (var1.volumeId() != null) {
               VolumeEntry var10 = var2.getVolume(var1.volumeId());
               if (var10 != null && var10.isEnabled()) {
                  this.firePendingEvent(var10, var1, var2, var3, var4);
               }
            } else if (var1.blockPosition() != null) {
               VolumeSpatialIndex var6 = var2.getSpatialIndex();
               var6.applyPendingChanges();
               List var7 = THREAD_LOCAL_CANDIDATES.get();
               var7.clear();
               var6.collectCandidates(var1.blockPosition(), var7);

               for (VolumeEntry var9 : var7) {
                  if (var9.isEnabled() && var9.getShape().contains(var9.getPosition(), var1.blockPosition())) {
                     this.firePendingEvent(var9, var1, var2, var3, var4);
                  }
               }
            }
         }
      }
   }

   class="kw">private class="kw">static boolean isTriggerExempt(@Nonnull Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1) {
      class="kw">return var1.getComponent(var0, IgnoreTriggerVolumes.getComponentType()) != null;
   }

   class="kw">private void firePendingEvent(
      @Nonnull VolumeEntry var1,
      @Nonnull TriggerVolumeManager.PendingTriggerEvent var2,
      @Nonnull TriggerVolumeManager var3,
      @Nonnull Store<EntityStore> var4,
      long var5
   ) {
      this.firePendingVolumeEvent(var1, var2, var4, var5);
      this.firePendingGroupEvent(var1, var2, var3, var4, var5);
   }

   class="kw">private void firePendingVolumeEvent(
      @Nonnull VolumeEntry var1, @Nonnull TriggerVolumeManager.PendingTriggerEvent var2, @Nonnull Store<EntityStore> var3, long var4
   ) {
      if (!var1.isOnCooldown(var2.actorUuid(), var4)) {
         for (int var9 : collectEntries(var1.getConditions(), var1.getEffects(), var1.getRejectionEffects())) {
            if (hasMatchingEventEffect(var2.eventType(), var1.getEffects(), var9)
               || hasMatchingEventEffect(var2.eventType(), var1.getRejectionEffects(), var9)
               || hasMatchingEventCondition(var2.eventType(), var1.getConditions(), var9)) {
               this.fireGatedEffects(
                  var2.eventType(),
                  var2.actorRef(),
                  var1,
                  var3,
                  var4,
                  var2.actorUuid(),
                  var9,
                  null,
                  var1.getConditions(),
                  var1.getEffects(),
                  var1.getRejectionEffects(),
                  var1.getConditionTiming() == ConditionTiming.BEFORE_VOLUME_DELAY ? var1.getActivationDelay() : 0.0F,
                  rejectionDelay(var1.getRejectionDelayMode(), var1.getActivationDelay()),
                  VolumeEntry.EffectBucket.VOLUME,
                  VolumeEntry.EffectBucket.VOLUME_REJECTION,
                  "volume '" + var1.getId() + "'",
                  var2
               );
            }
         }
      }
   }

   class="kw">private void firePendingGroupEvent(
      @Nonnull VolumeEntry var1,
      @Nonnull TriggerVolumeManager.PendingTriggerEvent var2,
      @Nonnull TriggerVolumeManager var3,
      @Nonnull Store<EntityStore> var4,
      long var5
   ) {
      if (var1.getGroupId() != null) {
         GroupEntry var7 = var3.getGroup(var1.getGroupId());
         if (var7 != null && var7.isEnabled()) {
            if (!var1.isOnCooldown(var2.actorUuid(), var5)) {
               List var8 = getGroupSpatialVolumes(var1, var3, var7);

               for (int var12 : collectEntries(var7.getConditions(), var7.getEffects(), var7.getRejectionEffects())) {
                  if (hasMatchingEventEffect(var2.eventType(), var7.getEffects(), var12)
                     || hasMatchingEventEffect(var2.eventType(), var7.getRejectionEffects(), var12)
                     || hasMatchingEventCondition(var2.eventType(), var7.getConditions(), var12)) {
                     this.fireGatedEffects(
                        var2.eventType(),
                        var2.actorRef(),
                        var1,
                        var4,
                        var5,
                        var2.actorUuid(),
                        var12,
                        var8,
                        var7.getConditions(),
                        var7.getEffects(),
                        var7.getRejectionEffects(),
                        var7.getConditionTiming() == ConditionTiming.BEFORE_VOLUME_DELAY ? var1.getActivationDelay() : 0.0F,
                        rejectionDelay(var7.getRejectionDelayMode(), var1.getActivationDelay()),
                        VolumeEntry.EffectBucket.GROUP,
                        VolumeEntry.EffectBucket.GROUP_REJECTION,
                        "group '" + var7.getId() + "' via volume '" + var1.getId() + "'",
                        var2
                     );
                  }
               }
            }
         }
      }
   }

   class="kw">private class="kw">static void processVolumesToRemove(@Nonnull TriggerVolumeManager var0, @Nonnull TimeResource var1) {
      Instant var2 = var1.getNow();

      for (VolumeEntry var4 : var0.getVolumes()) {
         if (var4.isPendingDestroy() || var4.isExpired(var2)) {
            String var5 = var4.getId();
            var0.getDelayedEffectScheduler().cancelForVolume(var4);
            var0.unregister(var5);
            var0.notifyViewersRemove(var5);
         }
      }
   }

   class="kw">private void collectCandidatesFromEntityPositions(
      @Nonnull Store<EntityStore> var1, @Nonnull VolumeSpatialIndex var2, @Nonnull Set<VolumeEntry> var3, @Nonnull List<VolumeEntry> var4, boolean var5
   ) {
      SpatialResource var6 = var1.getResource(this.playerSpatialResourceType);
      if (var6 != null) {
         SpatialData var7 = var6.getSpatialData();

         for (int var8 = 0; var8 < var7.size(); var8++) {
            var4.clear();
            var2.collectCandidates(var7.getVector(var8), var4);
            var3.addAll(var4);
         }
      }

      if (var5) {
         SpatialResource var10 = var1.getResource(this.entitySpatialResourceType);
         if (var10 != null) {
            SpatialData var11 = var10.getSpatialData();

            for (int var9 = 0; var9 < var11.size(); var9++) {
               var4.clear();
               var2.collectCandidates(var11.getVector(var9), var4);
               var3.addAll(var4);
            }
         }
      }
   }

   class="kw">private void tickVolume(@Nonnull VolumeEntry var1, float var2, @Nonnull Store<EntityStore> var3, @Nonnull TriggerVolumeManager var4) {
      TriggerVolumeShape var5 = var1.getShape();
      Vector3d var6 = var1.getPosition();
      Set var7 = THREAD_LOCAL_PREVIOUS.get();
      Map var8 = THREAD_LOCAL_PREVIOUS_REFS.get();
      var7.clear();
      var8.clear();
      var7.addAll(var1.getTrackedEntities().keySet());
      var8.putAll(var1.getTrackedEntities());
      var1.getTrackedEntities().clear();
      List var9 = SpatialResource.getThreadLocalReferenceList();
      if (var1.getTargetTypes().contains(EntityTargetType.PLAYER)) {
         SpatialResource var10 = var3.getResource(this.playerSpatialResourceType);
         if (var10 != null) {
            var10.getSpatialStructure().collect(var6, var5.getMaxDistanceFromOrigin(), var9);
         }
      }

      if (usesEntitySpatial(var1.getTargetTypes())) {
         SpatialResource var25 = var3.getResource(this.entitySpatialResourceType);
         if (var25 != null) {
            var25.getSpatialStructure().collect(var6, var5.getMaxDistanceFromOrigin(), var9);
         }
      }

      List var26 = THREAD_LOCAL_ENTITY_REFS.get();
      var26.clear();
      var26.addAll(var9);
      long var11 = System.nanoTime();
      int[] var13 = collectEntries(var1.getConditions(), var1.getEffects(), var1.getRejectionEffects());
      int[] var14 = SINGLE_DEFAULT_ENTRY;
      if (var1.getGroupId() != null) {
         GroupEntry var15 = var4.getGroup(var1.getGroupId());
         if (var15 != null) {
            var14 = collectEntries(var15.getConditions(), var15.getEffects(), var15.getRejectionEffects());
         }
      }

      for (int var27 = 0; var27 < var26.size(); var27++) {
         Ref var16 = var26.get(var27);
         if (var16.isValid() && matchesTargetTypes(var1.getTargetTypes(), var16, var3) && !isTriggerExempt(var16, var3)) {
            TransformComponent var17 = var3.getComponent(var16, TransformComponent.getComponentType());
            if (var17 != null && containsEntity(var5, var6, var17, var3.getComponent(var16, BoundingBox.getComponentType()))) {
               UUIDComponent var18 = var3.getComponent(var16, UUIDComponent.getComponentType());
               if (var18 != null) {
                  UUID var19 = var18.getUuid();
                  var1.getTrackedEntities().put(var19, var16);
                  boolean var20 = var7.remove(var19);
                  if (!var20) {
                     if (var1.isOnCooldown(var19, var11)) {
                        class="kw">continue;
                     }

                     this.clearIntervalTimers(var1, var19);

                     for (int var24 : var13) {
                        if (!isTickActivationGate(var1.getConditions(), var1.getEffects(), var1.getRejectionEffects(), var24)) {
                           this.activateVolumeEntry(var16, var1, var3, var11, var19, var24);
                        }
                     }

                     for (int var39 : var14) {
                        if (!hasGroupTickActivationGate(var1, var4, var39)) {
                           this.activateGroupEntry(var16, var1, var4, var3, var11, var19, var39);
                        }
                     }
                  }

                  for (int var40 : var13) {
                     if (var1.isVolumeActivated(var40, var19)) {
                        this.fireEffects(TriggerEventType.TICK, var16, var1, var3, var11, var19, var40);
                     } else if (isTickActivationGate(var1.getConditions(), var1.getEffects(), var1.getRejectionEffects(), var40)) {
                        this.processVolumeTickActivationGate(var16, var1, var3, var11, var19, var40);
                     }
                  }

                  if (var1.getGroupId() != null) {
                     for (int var41 : var14) {
                        if (var1.isGroupActivated(var1.getGroupId(), var41, var19)) {
                           this.fireGroupEffects(TriggerEventType.TICK, var16, var1, var4, var3, var11, var19, var41);
                        } else {
                           this.processGroupTickActivationGate(var16, var1, var4, var3, var11, var19, var41);
                        }
                     }
                  }
               }
            }
         }
      }

      for (UUID var29 : var7) {
         this.fireVolumeExit(var1, var8.get(var29), var29, var4, var3, var11, false);
      }
   }

   void fireVolumeExit(
      @Nonnull VolumeEntry var1,
      @Nullable Ref<EntityStore> var2,
      @Nonnull UUID var3,
      @Nonnull TriggerVolumeManager var4,
      @Nonnull Store<EntityStore> var5,
      long var6,
      boolean var8
   ) {
      if (var2 != null && var2.isValid() && !isTriggerExempt(var2, var5)) {
         this.dispatchEvent(TriggerEventType.EXIT, var1, var2, var3);

         for (int var12 : collectEntries(var1.getConditions(), var1.getEffects(), var1.getRejectionEffects())) {
            this.fireEffects(TriggerEventType.EXIT, var2, var1, var5, var6, var3, var12);
         }

         if (var1.getGroupId() != null) {
            GroupEntry var14 = var4.getGroup(var1.getGroupId());
            if (var14 != null) {
               for (int var13 : collectEntries(var14.getConditions(), var14.getEffects(), var14.getRejectionEffects())) {
                  this.fireGroupEffects(TriggerEventType.EXIT, var2, var1, var4, var5, var6, var3, var13);
               }
            }
         }
      }

      notifyVolumeEntityExit(var1, var3);
      this.fireGroupOnEntityExit(var1, var4, var3);
      if (!var8 && var1.isCancelDelayedEffectsOnExit()) {
         var4.getDelayedEffectScheduler().cancelNonExitForEntityInVolume(var3, var1);
      }

      var1.clearEntityRuntimeState(var3);
   }

   class="kw">private boolean activateVolumeEntry(
      @Nonnull Ref<EntityStore> var1, @Nonnull VolumeEntry var2, @Nonnull Store<EntityStore> var3, long var4, @Nonnull UUID var6, int var7
   ) {
      TriggerVolumeTickingSystem.ActivationResult var8 = this.fireEffects(TriggerEventType.ENTER, var1, var2, var3, var4, var6, var7);
      if (var8 != TriggerVolumeTickingSystem.ActivationResult.ACCEPTED) {
         class="kw">return false;
      }

      this.completeVolumeActivation(var1, var2, var4, var6, var7);
      class="kw">return true;
   }

   class="kw">private void completeVolumeActivation(@Nonnull Ref<EntityStore> var1, @Nonnull VolumeEntry var2, long var3, @Nonnull UUID var5, int var6) {
      if (var2.getTrackedEntities().containsKey(var5)) {
         var2.markVolumeActivated(var6, var5);
         var2.recordActivation(var5, var3);
         this.dispatchEvent(TriggerEventType.ENTER, var2, var1, var5);
      }
   }

   class="kw">private void processVolumeTickActivationGate(
      @Nonnull Ref<EntityStore> var1, @Nonnull VolumeEntry var2, @Nonnull Store<EntityStore> var3, long var4, @Nonnull UUID var6, int var7
   ) {
      if (var2.isOnCooldown(var6, var4)) {
         var2.markVolumeActivated(var7, var6);
      } else {
         TriggerContext var8 = new TriggerContext(var1, var3, TriggerEventType.TICK, var2);
         if (this.conditionsPass(var2.getConditions(), TriggerEventType.TICK, var7, var8, "volume '" + var2.getId() + "'")) {
            this.activateVolumeEntry(var1, var2, var3, var4, var6, var7);
         } else if (var2.markVolumeTickRejectionFired(var7, var6)) {
            this.fireEffectList(
               TriggerEventType.TICK,
               var1,
               var2,
               var3,
               var4,
               var6,
               null,
               var2.getRejectionEffects(),
               var7,
               0.0F,
               VolumeEntry.EffectBucket.VOLUME_REJECTION,
               "volume '" + var2.getId() + "'",
               null
            );
         }
      }
   }

   class="kw">private boolean activateGroupEntry(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull VolumeEntry var2,
      @Nonnull TriggerVolumeManager var3,
      @Nonnull Store<EntityStore> var4,
      long var5,
      @Nonnull UUID var7,
      int var8
   ) {
      String var9 = var2.getGroupId();
      if (var9 == null) {
         class="kw">return false;
      }

      TriggerVolumeTickingSystem.ActivationResult var10 = this.fireGroupEffects(TriggerEventType.ENTER, var1, var2, var3, var4, var5, var7, var8);
      if (var10 != TriggerVolumeTickingSystem.ActivationResult.ACCEPTED) {
         class="kw">return false;
      }

      this.completeGroupActivation(var2, var9, var7, var8);
      class="kw">return true;
   }

   class="kw">private void completeGroupActivation(@Nonnull VolumeEntry var1, @Nonnull String var2, @Nonnull UUID var3, int var4) {
      if (var1.getTrackedEntities().containsKey(var3)) {
         var1.markGroupActivated(var2, var4, var3);
      }
   }

   class="kw">private void processGroupTickActivationGate(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull VolumeEntry var2,
      @Nonnull TriggerVolumeManager var3,
      @Nonnull Store<EntityStore> var4,
      long var5,
      @Nonnull UUID var7,
      int var8
   ) {
      String var9 = var2.getGroupId();
      if (var9 != null) {
         GroupEntry var10 = var3.getGroup(var9);
         if (var10 != null && var10.isEnabled() && isTickActivationGate(var10.getConditions(), var10.getEffects(), var10.getRejectionEffects(), var8)) {
            if (var2.isOnCooldown(var7, var5)) {
               var2.markGroupActivated(var9, var8, var7);
            } else {
               List var11 = getGroupSpatialVolumes(var2, var3, var10);
               if (!var11.isEmpty()) {
                  TriggerContext var12 = new TriggerContext(var1, var4, TriggerEventType.TICK, var2, var11);
                  String var13 = "group '" + var10.getId() + "' via volume '" + var2.getId() + "'";
                  if (this.conditionsPass(var10.getConditions(), TriggerEventType.TICK, var8, var12, var13)) {
                     this.activateGroupEntry(var1, var2, var3, var4, var5, var7, var8);
                  } else if (var2.markGroupTickRejectionFired(var9, var8, var7)) {
                     this.fireEffectList(
                        TriggerEventType.TICK,
                        var1,
                        var2,
                        var4,
                        var5,
                        var7,
                        var11,
                        var10.getRejectionEffects(),
                        var8,
                        0.0F,
                        VolumeEntry.EffectBucket.GROUP_REJECTION,
                        var13,
                        null
                     );
                  }
               }
            }
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static List<VolumeEntry> getGroupSpatialVolumes(@Nonnull VolumeEntry var0, @Nonnull TriggerVolumeManager var1, @Nonnull GroupEntry var2) {
      ArrayList var3 = new ArrayList<>();

      for (String var5 : var2.getMemberVolumeIds()) {
         VolumeEntry var6 = var1.getVolume(var5);
         if (var6 != null) {
            var3.add(var6);
         }
      }

      if (var3.isEmpty()) {
         var3.add(var0);
      }

      class="kw">return var3;
   }

   class="kw">private TriggerVolumeTickingSystem.ActivationResult fireEffects(
      @Nonnull TriggerEventType var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull Store<EntityStore> var4,
      long var5,
      @Nonnull UUID var7,
      int var8
   ) {
      if (!hasMatchingEventEffect(var1, var3.getEffects(), var8) && !hasMatchingEventEffect(var1, var3.getRejectionEffects(), var8)) {
         if (!hasMatchingEventCondition(var1, var3.getConditions(), var8)) {
            class="kw">return TriggerVolumeTickingSystem.ActivationResult.ACCEPTED;
         }

         if (var3.getConditionTiming() == ConditionTiming.AFTER_VOLUME_DELAY && var3.getActivationDelay() > 0.0F) {
            class="kw">return this.scheduleDelayedVolumeGate(var1, var2, var3, var4, var5, var7, var8);
         }

         TriggerContext var9 = new TriggerContext(var2, var4, var1, var3);
         class="kw">return this.conditionsPass(var3.getConditions(), var1, var8, var9, "volume '" + var3.getId() + "'")
            ? TriggerVolumeTickingSystem.ActivationResult.ACCEPTED
            : TriggerVolumeTickingSystem.ActivationResult.REJECTED;
      } else {
         class="kw">return var3.getConditionTiming() == ConditionTiming.AFTER_VOLUME_DELAY && var3.getActivationDelay() > 0.0F
            ? this.scheduleDelayedVolumeGate(var1, var2, var3, var4, var5, var7, var8)
            : this.fireGatedEffects(
               var1,
               var2,
               var3,
               var4,
               var5,
               var7,
               var8,
               null,
               var3.getConditions(),
               var3.getEffects(),
               var3.getRejectionEffects(),
               var3.getConditionTiming() == ConditionTiming.BEFORE_VOLUME_DELAY ? var3.getActivationDelay() : 0.0F,
               rejectionDelay(var3.getRejectionDelayMode(), var3.getActivationDelay()),
               VolumeEntry.EffectBucket.VOLUME,
               VolumeEntry.EffectBucket.VOLUME_REJECTION,
               "volume '" + var3.getId() + "'"
            );
      }
   }

   @Nonnull
   class="kw">private TriggerVolumeTickingSystem.ActivationResult scheduleDelayedVolumeGate(
      @Nonnull TriggerEventType var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull Store<EntityStore> var4,
      long var5,
      @Nonnull UUID var7,
      int var8
   ) {
      if (var1 == TriggerEventType.ENTER && !var3.markVolumeActivationPending(var8, var7)) {
         class="kw">return TriggerVolumeTickingSystem.ActivationResult.PENDING;
      }

      this.getScheduler(var4)
         .scheduleGate(
            (var2x, var3x, var4x, var5x, var6, var7x, var8x) -> this.fireDelayedVolumeEffects(var2x, var3x, var4x, var5x, var6, var7x, var8x, var8),
            var2,
            var7,
            var1,
            var3,
            var5,
            var3.getActivationDelay(),
            null
         );
      class="kw">return TriggerVolumeTickingSystem.ActivationResult.PENDING;
   }

   class="kw">private void fireDelayedVolumeEffects(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull UUID var2,
      @Nonnull TriggerEventType var3,
      @Nonnull VolumeEntry var4,
      @Nullable List<VolumeEntry> var5,
      @Nonnull Store<EntityStore> var6,
      long var7,
      int var9
   ) {
      try {
         TriggerVolumeTickingSystem.ActivationResult var10 = this.fireGatedEffects(
            var3,
            var1,
            var4,
            var6,
            var7,
            var2,
            var9,
            null,
            var4.getConditions(),
            var4.getEffects(),
            var4.getRejectionEffects(),
            0.0F,
            rejectionDelay(var4.getRejectionDelayMode(), var4.getActivationDelay()),
            VolumeEntry.EffectBucket.VOLUME,
            VolumeEntry.EffectBucket.VOLUME_REJECTION,
            "volume '" + var4.getId() + "'"
         );
         if (var3 == TriggerEventType.ENTER && var10 == TriggerVolumeTickingSystem.ActivationResult.ACCEPTED) {
            this.completeVolumeActivation(var1, var4, var7, var2, var9);
         }
      } class="kw">finally {
         if (var3 == TriggerEventType.ENTER) {
            var4.clearVolumeActivationPending(var9, var2);
         }
      }
   }

   class="kw">private TriggerVolumeTickingSystem.ActivationResult fireGatedEffects(
      @Nonnull TriggerEventType var1,
      @Nullable Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull Store<EntityStore> var4,
      long var5,
      @Nonnull UUID var7,
      int var8,
      @Nullable List<VolumeEntry> var9,
      @Nonnull List<TriggerCondition> var10,
      @Nonnull List<TriggerEffect> var11,
      @Nonnull List<TriggerEffect> var12,
      float var13,
      float var14,
      @Nonnull VolumeEntry.EffectBucket var15,
      @Nonnull VolumeEntry.EffectBucket var16,
      @Nonnull String var17
   ) {
      class="kw">return this.fireGatedEffects(var1, var2, var3, var4, var5, var7, var8, var9, var10, var11, var12, var13, var14, var15, var16, var17, null);
   }

   class="kw">private TriggerVolumeTickingSystem.ActivationResult fireGatedEffects(
      @Nonnull TriggerEventType var1,
      @Nullable Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull Store<EntityStore> var4,
      long var5,
      @Nonnull UUID var7,
      int var8,
      @Nullable List<VolumeEntry> var9,
      @Nonnull List<TriggerCondition> var10,
      @Nonnull List<TriggerEffect> var11,
      @Nonnull List<TriggerEffect> var12,
      float var13,
      float var14,
      @Nonnull VolumeEntry.EffectBucket var15,
      @Nonnull VolumeEntry.EffectBucket var16,
      @Nonnull String var17,
      @Nullable TriggerVolumeManager.PendingTriggerEvent var18
   ) {
      TriggerContext var19 = var9 != null ? createContext(var2, var4, var1, var3, var9, var18) : createContext(var2, var4, var1, var3, List.of(var3), var18);
      boolean var20 = this.conditionsPass(var10, var1, var8, var19, var17);
      List var21 = var20 ? var11 : var12;
      VolumeEntry.EffectBucket var22 = var20 ? var15 : var16;
      float var23 = var20 ? var13 : var14;
      this.fireEffectList(var1, var2, var3, var4, var5, var7, var9, var21, var8, var23, var22, var17, var18);
      class="kw">return var20 ? TriggerVolumeTickingSystem.ActivationResult.ACCEPTED : TriggerVolumeTickingSystem.ActivationResult.REJECTED;
   }

   @Nonnull
   class="kw">private class="kw">static TriggerContext createContext(
      @Nullable Ref<EntityStore> var0,
      @Nonnull Store<EntityStore> var1,
      @Nonnull TriggerEventType var2,
      @Nonnull VolumeEntry var3,
      @Nonnull List<VolumeEntry> var4,
      @Nullable TriggerVolumeManager.PendingTriggerEvent var5
   ) {
      class="kw">return var5 == null
         ? new TriggerContext(var0, var1, var2, var3, var4)
         : new TriggerContext(var0, var1, var2, var3, var4, null, var5.signalTags(), var5.blockPosition(), var5.blockId(), var5.interactionType());
   }

   class="kw">private boolean conditionsPass(
      @Nonnull List<TriggerCondition> var1, @Nonnull TriggerEventType var2, int var3, @Nonnull TriggerContext var4, @Nonnull String var5
   ) {
      ArrayList var6 = new ArrayList<>();

      for (TriggerCondition var8 : var1) {
         if (var8.getEntry() == var3 && var8.getEventType() == var2) {
            try {
               if (!var8.test(var4)) {
                  class="kw">return false;
               }

               var6.add(var8);
            } catch (Throwable var11) {
               ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var11)).log("Error evaluating condition %s on %s", var8.getClass().getSimpleName(), var5);
               class="kw">return false;
            }
         }
      }

      for (TriggerCondition var13 : var6) {
         try {
            var13.applyOnAccept(var4);
         } catch (Throwable var10) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var10))
               .log("Error applying accepted condition %s on %s", var13.getClass().getSimpleName(), var5);
            class="kw">return false;
         }
      }

      class="kw">return true;
   }

   class="kw">static boolean hasTickActivationGate(@Nonnull List<TriggerCondition> var0, int var1) {
      for (TriggerCondition var3 : var0) {
         if (var3.getEntry() == var1 && var3.getEventType() == TriggerEventType.TICK) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">static boolean isTickActivationGate(@Nonnull List<TriggerCondition> var0, @Nonnull List<TriggerEffect> var1, @Nonnull List<TriggerEffect> var2, int var3) {
      class="kw">return hasTickActivationGate(var0, var3)
         && !hasMatchingEventEffect(TriggerEventType.ENTER, var1, var3)
         && !hasMatchingEventEffect(TriggerEventType.ENTER, var2, var3)
         && !hasMatchingEventCondition(TriggerEventType.ENTER, var0, var3);
   }

   class="kw">static boolean hasMatchingEventEffect(@Nonnull TriggerEventType var0, @Nonnull List<TriggerEffect> var1, int var2) {
      for (TriggerEffect var4 : var1) {
         if (var4.getEntry() == var2 && var4.getEventType() == var0) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">static boolean hasMatchingEventCondition(@Nonnull TriggerEventType var0, @Nonnull List<TriggerCondition> var1, int var2) {
      for (TriggerCondition var4 : var1) {
         if (var4.getEntry() == var2 && var4.getEventType() == var0) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">private class="kw">static boolean hasGroupTickActivationGate(@Nonnull VolumeEntry var0, @Nonnull TriggerVolumeManager var1, int var2) {
      String var3 = var0.getGroupId();
      if (var3 == null) {
         class="kw">return false;
      }

      GroupEntry var4 = var1.getGroup(var3);
      class="kw">return var4 != null && var4.isEnabled() && isTickActivationGate(var4.getConditions(), var4.getEffects(), var4.getRejectionEffects(), var2);
   }

   @Nonnull
   class="kw">private class="kw">static int[] collectEntries(@Nonnull List<TriggerCondition> var0, @Nonnull List<TriggerEffect> var1, @Nonnull List<TriggerEffect> var2) {
      IntOpenHashSet var3 = new IntOpenHashSet();

      for (TriggerCondition var5 : var0) {
         var3.add(var5.getEntry());
      }

      for (TriggerEffect var9 : var1) {
         var3.add(var9.getEntry());
      }

      for (TriggerEffect var10 : var2) {
         var3.add(var10.getEntry());
      }

      if (var3.isEmpty()) {
         class="kw">return SINGLE_DEFAULT_ENTRY;
      }

      int[] var8 = var3.toIntArray();
      Arrays.sort(var8);
      class="kw">return var8;
   }

   class="kw">private void fireEffectList(
      @Nonnull TriggerEventType var1,
      @Nullable Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull Store<EntityStore> var4,
      long var5,
      @Nonnull UUID var7,
      @Nullable List<VolumeEntry> var8,
      @Nonnull List<TriggerEffect> var9,
      int var10,
      float var11,
      @Nonnull VolumeEntry.EffectBucket var12,
      @Nonnull String var13,
      @Nullable TriggerVolumeManager.PendingTriggerEvent var14
   ) {
      for (int var15 = 0; var15 < var9.size(); var15++) {
         TriggerEffect var16 = var9.get(var15);
         if (var16.getEntry() == var10 && var16.getEventType() == var1) {
            VolumeEntry.EffectEntityKey var17 = null;
            boolean var18 = false;
            if (var1 == TriggerEventType.TICK && var16.getInterval() > 0.0F) {
               var17 = new VolumeEntry.EffectEntityKey(var12, var15, var7);
               long var19 = var3.getLastFireTimes().getOrDefault(var17, Long.MIN_VALUE);
               var18 = var19 != Long.MIN_VALUE;
               if (var18) {
                  double var21 = (var5 - var19) / 1.0E9;
                  if (var21 < var16.getInterval()) {
                     class="kw">continue;
                  }
               }
            }

            float var24 = var11 + effectDelay(var1, var16, var18);
            if (var24 > 0.0F) {
               DelayedEffectScheduler var20 = this.getScheduler(var4);
               if (var17 != null) {
                  VolumeEntry.EffectEntityKey var26 = var17;
                  if (var3.markDelayedEffectPending(var26)) {
                     var20.schedule(var16, var2, var7, var1, var3, var5, var24, var8, (var2x, var3x) -> {
                        var3.clearDelayedEffectPending(var26);
                        if (var2x) {
                           var3.getLastFireTimes().put(var26, var3x);
                        }
                     }, var4, var14);
                  }
               } else {
                  var20.schedule(var16, var2, var7, var1, var3, var5, var24, var8, null, var4, var14);
               }
            } else {
               try {
                  Ref var25 = var3.getProjectileSource().resolveActorRef(var2, var4);
                  TriggerContext var27 = createContext(var25, var4, var1, var3, var8 != null ? var8 : List.of(var3), var14);
                  var16.execute(var27);
                  if (var17 != null) {
                     var3.getLastFireTimes().put(var17, var5);
                  }
               } catch (Throwable var23) {
                  ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var23)).log("Error executing effect %s on %s", var16.getClass().getSimpleName(), var13);
               }
            }
         }
      }
   }

   class="kw">static float effectDelay(@Nonnull TriggerEventType var0, @Nonnull TriggerEffect var1, boolean var2) {
      class="kw">return var0 == TriggerEventType.TICK && var2 ? 0.0F : var1.getDelay();
   }

   class="kw">private TriggerVolumeTickingSystem.ActivationResult fireGroupEffects(
      @Nonnull TriggerEventType var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull TriggerVolumeManager var4,
      @Nonnull Store<EntityStore> var5,
      long var6,
      @Nonnull UUID var8,
      int var9
   ) {
      if (var3.getGroupId() == null) {
         class="kw">return TriggerVolumeTickingSystem.ActivationResult.REJECTED;
      }

      GroupEntry var10 = var4.getGroup(var3.getGroupId());
      if (var10 == null || !var10.isEnabled()) {
         class="kw">return TriggerVolumeTickingSystem.ActivationResult.REJECTED;
      }

      if (var10.getConditions().isEmpty() && var10.getEffects().isEmpty() && var10.getRejectionEffects().isEmpty()) {
         class="kw">return TriggerVolumeTickingSystem.ActivationResult.ACCEPTED;
      }

      if (hasMatchingEventEffect(var1, var10.getEffects(), var9) || hasMatchingEventEffect(var1, var10.getRejectionEffects(), var9)) {
         List var13 = getGroupSpatialVolumes(var3, var4, var10);
         if (var13.isEmpty()) {
            class="kw">return TriggerVolumeTickingSystem.ActivationResult.REJECTED;
         }

         if (!var10.getTargetTypes().isEmpty()) {
            EntityTargetType var12 = resolveTargetType(var2, var5);
            if (var12 == null) {
               class="kw">return TriggerVolumeTickingSystem.ActivationResult.REJECTED;
            }

            if (!var10.getTargetTypes().contains(var12)) {
               class="kw">return TriggerVolumeTickingSystem.ActivationResult.REJECTED;
            }
         }

         class="kw">return var10.getConditionTiming() == ConditionTiming.AFTER_VOLUME_DELAY && var3.getActivationDelay() > 0.0F
            ? this.scheduleDelayedGroupGate(var1, var2, var3, var10, var5, var6, var8, var9, var13)
            : this.fireGroupEffectLists(
               var1,
               var2,
               var3,
               var10,
               var5,
               var6,
               var8,
               var9,
               var13,
               var10.getConditionTiming() == ConditionTiming.BEFORE_VOLUME_DELAY ? var3.getActivationDelay() : 0.0F,
               rejectionDelay(var10.getRejectionDelayMode(), var3.getActivationDelay())
            );
      } else {
         if (!hasMatchingEventCondition(var1, var10.getConditions(), var9)) {
            class="kw">return TriggerVolumeTickingSystem.ActivationResult.ACCEPTED;
         }

         if (var10.getConditionTiming() == ConditionTiming.AFTER_VOLUME_DELAY && var3.getActivationDelay() > 0.0F) {
            class="kw">return this.scheduleDelayedGroupGate(var1, var2, var3, var10, var5, var6, var8, var9, getGroupSpatialVolumes(var3, var4, var10));
         }

         TriggerContext var11 = new TriggerContext(var2, var5, var1, var3, getGroupSpatialVolumes(var3, var4, var10));
         class="kw">return this.conditionsPass(var10.getConditions(), var1, var9, var11, "group '" + var10.getId() + "' via volume '" + var3.getId() + "'")
            ? TriggerVolumeTickingSystem.ActivationResult.ACCEPTED
            : TriggerVolumeTickingSystem.ActivationResult.REJECTED;
      }
   }

   @Nonnull
   class="kw">private TriggerVolumeTickingSystem.ActivationResult scheduleDelayedGroupGate(
      @Nonnull TriggerEventType var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull GroupEntry var4,
      @Nonnull Store<EntityStore> var5,
      long var6,
      @Nonnull UUID var8,
      int var9,
      @Nonnull List<VolumeEntry> var10
   ) {
      if (var1 == TriggerEventType.ENTER && !var3.markGroupActivationPending(var4.getId(), var9, var8)) {
         class="kw">return TriggerVolumeTickingSystem.ActivationResult.PENDING;
      }

      this.getScheduler(var5)
         .scheduleGate(
            (var3x, var4x, var5x, var6x, var7, var8x, var9x) -> this.fireDelayedGroupEffects(var5x, var3x, var6x, var4, var8x, var9x, var4x, var9, var7),
            var2,
            var8,
            var1,
            var3,
            var6,
            var3.getActivationDelay(),
            var10
         );
      class="kw">return TriggerVolumeTickingSystem.ActivationResult.PENDING;
   }

   class="kw">private void fireDelayedGroupEffects(
      @Nonnull TriggerEventType var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull GroupEntry var4,
      @Nonnull Store<EntityStore> var5,
      long var6,
      @Nonnull UUID var8,
      int var9,
      @Nullable List<VolumeEntry> var10
   ) {
      try {
         if (!var4.isEnabled()) {
            class="kw">return;
         }

         TriggerVolumeTickingSystem.ActivationResult var11 = this.fireGroupEffectLists(
            var1, var2, var3, var4, var5, var6, var8, var9, var10, 0.0F, rejectionDelay(var4.getRejectionDelayMode(), var3.getActivationDelay())
         );
         if (var1 == TriggerEventType.ENTER && var11 == TriggerVolumeTickingSystem.ActivationResult.ACCEPTED) {
            this.completeGroupActivation(var3, var4.getId(), var8, var9);
         }
      } class="kw">finally {
         if (var1 == TriggerEventType.ENTER) {
            var3.clearGroupActivationPending(var4.getId(), var9, var8);
         }
      }
   }

   class="kw">private TriggerVolumeTickingSystem.ActivationResult fireGroupEffectLists(
      @Nonnull TriggerEventType var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull VolumeEntry var3,
      @Nonnull GroupEntry var4,
      @Nonnull Store<EntityStore> var5,
      long var6,
      @Nonnull UUID var8,
      int var9,
      @Nullable List<VolumeEntry> var10,
      float var11,
      float var12
   ) {
      List var13 = var10 != null ? var10 : List.of(var3);
      class="kw">return this.fireGatedEffects(
         var1,
         var2,
         var3,
         var5,
         var6,
         var8,
         var9,
         var13,
         var4.getConditions(),
         var4.getEffects(),
         var4.getRejectionEffects(),
         var11,
         var12,
         VolumeEntry.EffectBucket.GROUP,
         VolumeEntry.EffectBucket.GROUP_REJECTION,
         "group '" + var4.getId() + "' via volume '" + var3.getId() + "'"
      );
   }

   class="kw">private class="kw">static float rejectionDelay(@Nonnull RejectionDelayMode var0, float var1) {
      class="kw">return var0 == RejectionDelayMode.USE_VOLUME_DELAY ? var1 : 0.0F;
   }

   @Nonnull
   class="kw">private DelayedEffectScheduler getScheduler(@Nonnull Store<EntityStore> var1) {
      TriggerVolumeManager var2 = var1.getResource(this.managerResourceType);
      if (var2 == null) {
         throw new IllegalStateException("TriggerVolumeManager missing on store");
      } else {
         class="kw">return var2.getDelayedEffectScheduler();
      }
   }

   class="kw">private class="kw">static boolean usesEntitySpatial(@Nonnull Set<EntityTargetType> var0) {
      class="kw">return var0.contains(EntityTargetType.NPC) || var0.contains(EntityTargetType.ITEM_DROP) || var0.contains(EntityTargetType.PROJECTILE);
   }

   class="kw">private class="kw">static boolean matchesTargetTypes(@Nonnull Set<EntityTargetType> var0, @Nonnull Ref<EntityStore> var1, @Nonnull Store<EntityStore> var2) {
      EntityTargetType var3 = resolveTargetType(var1, var2);
      class="kw">return var3 != null && var0.contains(var3);
   }

   @Nullable
   class="kw">private class="kw">static EntityTargetType resolveTargetType(@Nonnull Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1) {
      if (var1.getComponent(var0, PlayerRef.getComponentType()) != null) {
         class="kw">return EntityTargetType.PLAYER;
      } else if (var1.getComponent(var0, ItemComponent.getComponentType()) != null) {
         class="kw">return EntityTargetType.ITEM_DROP;
      } else {
         class="kw">return var1.getComponent(var0, Projectile.getComponentType()) == null && var1.getComponent(var0, ProjectileComponent.getComponentType()) == null
            ? EntityTargetType.NPC
            : EntityTargetType.PROJECTILE;
      }
   }

   class="kw">private void fireGroupOnEntityExit(@Nonnull VolumeEntry var1, @Nonnull TriggerVolumeManager var2, @Nonnull UUID var3) {
      if (var1.getGroupId() != null) {
         GroupEntry var4 = var2.getGroup(var1.getGroupId());
         if (var4 != null) {
            for (TriggerCondition var6 : var4.getConditions()) {
               var6.onEntityExit(var3);
            }

            for (TriggerEffect var9 : var4.getEffects()) {
               var9.onEntityExit(var3);
            }

            for (TriggerEffect var10 : var4.getRejectionEffects()) {
               var10.onEntityExit(var3);
            }
         }
      }
   }

   class="kw">private class="kw">static void notifyVolumeEntityExit(@Nonnull VolumeEntry var0, @Nonnull UUID var1) {
      for (TriggerCondition var3 : var0.getConditions()) {
         var3.onEntityExit(var1);
      }

      for (TriggerEffect var6 : var0.getEffects()) {
         var6.onEntityExit(var1);
      }

      for (TriggerEffect var7 : var0.getRejectionEffects()) {
         var7.onEntityExit(var1);
      }
   }

   class="kw">private void dispatchEvent(@Nonnull TriggerEventType var1, @Nonnull VolumeEntry var2, @Nonnull Ref<EntityStore> var3, @Nonnull UUID var4) {
      this.eventDispatcher.dispatch(var1, var2, var3, var4);
   }

   class="kw">private class="kw">static void dispatchToServerEventBus(@Nonnull TriggerEventType var0, @Nonnull VolumeEntry var1, @Nonnull Ref<EntityStore> var2, @Nonnull UUID var3) {
      HytaleServer var4 = HytaleServer.get();
      if (var4 != null) {
         IEventDispatcher var5 = var4.getEventBus().dispatchFor(TriggerVolumeEvent.class, var1.getWorldName());
         if (var5.hasListener()) {
            var5.dispatch(new TriggerVolumeEvent(var1.getWorldName(), var0, var1, var2, var3));
         }
      }
   }

   class="kw">private void clearIntervalTimers(@Nonnull VolumeEntry var1, @Nonnull UUID var2) {
      var1.getLastFireTimes().object2LongEntrySet().removeIf(var1x -> ((VolumeEntry.EffectEntityKey)var1x.getKey()).entityId().equals(var2));
   }

   class="kw">private void processTrackedEntityExits(@Nonnull VolumeEntry var1, @Nonnull Store<EntityStore> var2, @Nonnull TriggerVolumeManager var3) {
      long var4 = System.nanoTime();

      for (Entry var7 : var1.getTrackedEntities().entrySet()) {
         UUID var8 = var7.getKey();
         Ref var9 = var7.getValue();
         if (var9 != null && var9.isValid()) {
            this.dispatchEvent(TriggerEventType.EXIT, var1, var9, var8);

            for (int var13 : collectEntries(var1.getConditions(), var1.getEffects(), var1.getRejectionEffects())) {
               this.fireEffects(TriggerEventType.EXIT, var9, var1, var2, var4, var8, var13);
            }

            if (var1.getGroupId() != null) {
               GroupEntry var15 = var3.getGroup(var1.getGroupId());
               if (var15 != null) {
                  for (int var14 : collectEntries(var15.getConditions(), var15.getEffects(), var15.getRejectionEffects())) {
                     this.fireGroupEffects(TriggerEventType.EXIT, var9, var1, var3, var2, var4, var8, var14);
                  }
               }
            }
         }

         notifyVolumeEntityExit(var1, var8);
         this.fireGroupOnEntityExit(var1, var3, var8);
         var1.clearEntityRuntimeState(var8);
      }

      var1.getTrackedEntities().clear();
   }

   class="kw">private class="kw">static boolean isChunkLoaded(@Nonnull World var0, @Nonnull Vector3d var1) {
      long var2 = ChunkUtil.indexChunkFromBlock(var1.x(), var1.z());
      ChunkStore var4 = var0.getChunkStore();
      Ref var5 = var4.getChunkReference(var2);
      if (var5 != null && var5.isValid()) {
         WorldChunk var6 = var4.getStore().getComponent(var5, WorldChunk.getComponentType());
         class="kw">return var6 != null && var6.is(ChunkFlag.TICKING);
      } else {
         class="kw">return false;
      }
   }

   class="kw">private class="kw">static boolean containsEntity(@Nonnull TriggerVolumeShape var0, @Nonnull Vector3d var1, @Nonnull TransformComponent var2, @Nullable BoundingBox var3) {
      Vector3d var4 = var2.getPosition();
      if (var0.contains(var1, var4)) {
         class="kw">return true;
      }

      double var5 = var3 != null ? var3.getBoundingBox().height() : 1.8;
      if (var5 <= 0.0) {
         class="kw">return false;
      }

      Vector3d var7 = THREAD_LOCAL_TEST_POINT.get();
      var7.set(var4.x(), var4.y() + var5 * 0.5, var4.z());
      if (var0.contains(var1, var7)) {
         class="kw">return true;
      }

      var7.set(var4.x(), var4.y() + var5, var4.z());
      class="kw">return var0.contains(var1, var7);
   }

   class="kw">private enum ActivationResult {
      ACCEPTED,
      REJECTED,
      PENDING;

      ActivationResult() {
      }
   }

   @FunctionalInterface
   class="kw">interface EventDispatcher {
      void dispatch(@Nonnull TriggerEventType var1, @Nonnull VolumeEntry var2, @Nonnull Ref<EntityStore> var3, @Nonnull UUID var4);
   }
}