class="kw">package com.hypixel.hytale.server.spawning.beacons;

class="kw">import com.hypixel.hytale.component.AddReason;
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.RemoveReason;
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.RootDependency;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.random.RandomExtra;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.server.core.asset.type.responsecurve.ScaledXYResponseCurve;
class="kw">import com.hypixel.hytale.server.core.entity.Frozen;
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.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Spectating;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.PlayerSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabCopyableComponent;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.flock.FlockPlugin;
class="kw">import com.hypixel.hytale.server.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.role.support.MarkedEntitySupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.StateSupport;
class="kw">import com.hypixel.hytale.server.spawning.SpawningContext;
class="kw">import com.hypixel.hytale.server.spawning.SpawningPlugin;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawns.config.BeaconNPCSpawn;
class="kw">import com.hypixel.hytale.server.spawning.controllers.BeaconSpawnController;
class="kw">import com.hypixel.hytale.server.spawning.controllers.SpawnControllerSystem;
class="kw">import com.hypixel.hytale.server.spawning.controllers.SpawnJobSystem;
class="kw">import com.hypixel.hytale.server.spawning.jobs.NPCBeaconSpawnJob;
class="kw">import com.hypixel.hytale.server.spawning.util.FloodFillEntryPoolProviderSimple;
class="kw">import com.hypixel.hytale.server.spawning.util.FloodFillPositionSelector;
class="kw">import com.hypixel.hytale.server.spawning.wrappers.BeaconSpawnWrapper;
class="kw">import it.unimi.dsi.fastutil.Pair;
class="kw">import it.unimi.dsi.fastutil.objects.Object2IntMap;
class="kw">import it.unimi.dsi.fastutil.objects.Reference2DoubleMap;
class="kw">import java.time.Instant;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
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 SpawnBeaconSystems {
   class="kw">public class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final double[] POSITION_CALCULATION_DELAY_RANGE = new double[]{0.0, 1.0};
   class="kw">private class="kw">static class="kw">final double LOAD_TIME_SPAWN_DELAY = 15.0;

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

   class="kw">public class="kw">static class CheckDespawn class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
      class="kw">private class="kw">final ComponentType<EntityStore, LegacySpawnBeaconEntity> componentType;
      @Nullable
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public CheckDespawn(ComponentType<EntityStore, LegacySpawnBeaconEntity> var1, ComponentType<EntityStore, InitialBeaconDelay> var2) {
         this.componentType = var1;
         this.npcComponentType = NPCEntity.getComponentType();
         this.query = Query.and(var1, UUIDComponent.getComponentType(), Query.not(var2));
      }

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

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         LegacySpawnBeaconEntity var6 = var3.getComponent(var2, this.componentType);
         assert var6 != null;
         UUIDComponent var7 = var3.getComponent(var2, UUIDComponent.getComponentType());
         assert var7 != null;
         BeaconSpawnController var8 = var6.getSpawnController();
         Instant var9 = var6.getDespawnSelfAfter();
         WorldTimeResource var10 = var5.getResource(WorldTimeResource.getResourceType());
         if (var9 != null && var10.getGameTime().isAfter(var9)) {
            this.despawnAllSpawns(var8.getSpawnedEntities(), var5);
            var5.removeEntity(var3.getReferenceTo(var2), RemoveReason.REMOVE);
         } else {
            World var11 = var4.getExternalData().getWorld();
            BeaconSpawnWrapper var12 = var6.getSpawnWrapper();
            if (var12.shouldDespawn(var11, var10)) {
               LOGGER.at(Level.FINE).log("Removing spawn beacon %s due to matching despawn parameters", var7.getUuid());
               this.despawnAllSpawns(var8.getSpawnedEntities(), var5);
               var5.removeEntity(var3.getReferenceTo(var2), RemoveReason.REMOVE);
            }
         }
      }

      class="kw">private void despawnAllSpawns(@Nonnull List<Ref<EntityStore>> var1, @Nonnull CommandBuffer<EntityStore> var2) {
         for (int var3 = 0; var3 < var1.size(); var3++) {
            Ref var4 = var1.get(var3);
            if (var4.isValid()) {
               NPCEntity var5 = var2.getComponent(var4, this.npcComponentType);
               if (var5 != null && !StateSupport.get(var4, var2).isInBusyState() && !var5.isDespawning()) {
                  var5.setToDespawn();
               }
            }
         }

         var1.clear();
      }
   }

   class="kw">public class="kw">static class ControllerTick class="kw">extends SpawnControllerSystem<NPCBeaconSpawnJob, BeaconSpawnController> {
      class="kw">private class="kw">static class="kw">final ThreadLocal<List<NPCEntity>> THREAD_LOCAL_VALIDATED_ENTITIES = ThreadLocal.withInitial(ArrayList::new);
      class="kw">private class="kw">final ComponentType<EntityStore, LegacySpawnBeaconEntity> componentType;
      class="kw">private class="kw">final ComponentType<EntityStore, FloodFillPositionSelector> floodFillPositionSelectorComponentType;
      class="kw">private class="kw">final ComponentType<EntityStore, PlayerRef> playerRefComponentType;
      @Nullable
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType;
      class="kw">private class="kw">final ComponentType<EntityStore, DeathComponent> deathComponentComponentType;
      class="kw">private class="kw">final ComponentType<EntityStore, UUIDComponent> uuidComponentType = UUIDComponent.getComponentType();
      class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> playerSpatialResource;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public ControllerTick(
         ComponentType<EntityStore, LegacySpawnBeaconEntity> var1,
         ComponentType<EntityStore, FloodFillPositionSelector> var2,
         ComponentType<EntityStore, InitialBeaconDelay> var3
      ) {
         this.componentType = var1;
         this.floodFillPositionSelectorComponentType = var2;
         this.playerRefComponentType = PlayerRef.getComponentType();
         this.npcComponentType = NPCEntity.getComponentType();
         this.transformComponentType = TransformComponent.getComponentType();
         this.deathComponentComponentType = DeathComponent.getComponentType();
         this.playerSpatialResource = EntityModule.get().getPlayerSpatialResourceType();
         this.query = Query.and(var1, var2, this.transformComponentType, Query.not(var3));
         this.dependencies = Set.of(
            new SystemDependency<>(Order.AFTER, PlayerSpatialSystem.class, OrderPriority.CLOSEST),
            new SystemDependency<>(Order.AFTER, SpawnBeaconSystems.PositionSelectorUpdate.class)
         );
      }

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

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

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return false;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         FloodFillPositionSelector var6 = var3.getComponent(var2, this.floodFillPositionSelectorComponentType);
         assert var6 != null;
         if (!var6.shouldRebuildCache()) {
            TransformComponent var7 = var3.getComponent(var2, this.transformComponentType);
            assert var7 != null;
            Vector3d var8 = var7.getPosition();
            LegacySpawnBeaconEntity var9 = var3.getComponent(var2, this.componentType);
            assert var9 != null;
            var9.setSpawnAttempts(0);
            List var10 = THREAD_LOCAL_VALIDATED_ENTITIES.get();
            BeaconSpawnController var11 = var9.getSpawnController();
            List var12 = var11.getSpawnedEntities();
            if (!var12.isEmpty()) {
               Reference2DoubleMap var13 = var11.getEntityTimeoutCounter();
               boolean var14 = var11.isDespawnNPCsIfIdle();
               double var15 = var11.getBeaconRadiusSquared();
               double var17 = var11.getDespawnNPCAfterTimeout();

               for (int var19 = var12.size() - 1; var19 >= 0; var19--) {
                  Ref var20 = var12.get(var19);
                  if (!var20.isValid()) {
                     var12.remove(var19);
                  } else {
                     NPCEntity var21 = var5.getComponent(var20, this.npcComponentType);
                     if (var21 != null && !var21.isDespawning()) {
                        Role var22 = var21.getRole();
                        if (var22 != null) {
                           boolean var23 = MarkedEntitySupport.get(var20, var5).hasMarkedEntityInSlot(var9.getSpawnWrapper().getSpawn().getTargetSlot());
                           TransformComponent var24 = var5.getComponent(var20, this.transformComponentType);
                           assert var24 != null;
                           Vector3d var25 = var24.getPosition();
                           double var26 = var25.distanceSquared(var8);
                           if ((var14 && !var23 || var26 > var15) && !StateSupport.get(var20, var5).isInBusyState()) {
                              double var28 = var13.mergeDouble(var20, var1, Double::sum);
                              if (var28 >= var17) {
                                 var21.setToDespawn();
                              }
                           } else {
                              var13.put(var20, 0.0);
                              var10.add(var21);
                           }
                        }
                     }
                  }
               }
            }

            WorldTimeResource var35 = var5.getResource(WorldTimeResource.getResourceType());
            if (!isReadyToRespawn(var9, var35)) {
               var10.clear();
            } else {
               int var36 = MathUtil.floor(var8.y());
               BeaconSpawnWrapper var37 = var9.getSpawnWrapper();
               int[] var16 = var37.getSpawn().getYRange();
               double var38 = var36 + var16[0];
               double var39 = var36 + var16[1];
               SpatialResource var40 = var4.getResource(this.playerSpatialResource);
               List var41 = SpatialResource.getThreadLocalReferenceList();
               var40.getSpatialStructure().collect(var8, var37.getBeaconRadius(), var41);
               List var42 = var11.getPlayersInRegion();

               for (int var43 = 0; var43 < var41.size(); var43++) {
                  Ref var45 = var41.get(var43);
                  if (var45.isValid()) {
                     PlayerRef var47 = var5.getComponent(var45, this.playerRefComponentType);
                     assert var47 != null;
                     TransformComponent var27 = var5.getComponent(var45, this.transformComponentType);
                     assert var27 != null;
                     double var52 = var27.getPosition().y();
                     if (!(var52 < var38)
                        && !(var52 > var39)
                        && !var5.getArchetype(var45).contains(this.deathComponentComponentType)
                        && !var5.getArchetype(var45).contains(Spectating.getComponentType())) {
                        var42.add(var47);
                     }
                  }
               }

               var9.setLastPlayerCount(var42.size());
               Ref var44 = var3.getReferenceTo(var2);
               if (var42.isEmpty()) {
                  LegacySpawnBeaconEntity.setToDespawnAfter(var44, var11.getDespawnBeaconAfterTimeout(), var5);
                  var10.clear();
               } else {
                  boolean var46 = false;

                  for (int var48 = 0; var48 < var42.size(); var48++) {
                     Ref var50 = var42.get(var48).getReference();
                     TransformComponent var53 = var5.getComponent(var50, this.transformComponentType);
                     assert var53 != null;
                     Vector3d var29 = var53.getPosition();
                     if (var29.distanceSquared(var8) <= var11.getSpawnRadiusSquared()) {
                        var46 = true;
                        break;
                     }
                  }

                  if (var46) {
                     LegacySpawnBeaconEntity.clearDespawnTimer(var44, var5);
                  } else {
                     LegacySpawnBeaconEntity.setToDespawnAfter(var44, var11.getDespawnBeaconAfterTimeout(), var5);
                  }

                  ScaledXYResponseCurve var49 = var37.getSpawn().getMaxSpawnsScalingCurve();
                  int var51 = var11.getBaseMaxTotalSpawns();
                  int var54 = var49 != null ? var51 + MathUtil.floor(var49.computeY(var42.size()) + 0.25) : var51;
                  var11.setCurrentScaledMaxTotalSpawns(var54);
                  if (var11.getSpawnedEntities().size() >= var54) {
                     var42.clear();
                     var10.clear();
                  } else {
                     Object2IntMap var55 = var11.getEntitiesPerPlayer();

                     for (int var30 = 0; var30 < var10.size(); var30++) {
                        NPCEntity var31 = var10.get(var30);
                        Role var32 = var31.getRole();
                        if (var32 != null) {
                           Ref var33 = MarkedEntitySupport.get(var31.getReference(), var5)
                              .getMarkedEntityRef(var9.getSpawnWrapper().getSpawn().getTargetSlot());
                           if (var33 != null) {
                              UUIDComponent var34 = var5.getComponent(var33, this.uuidComponentType);
                              if (var34 != null) {
                                 var55.mergeInt(var34.getUuid(), 1, Integer::sum);
                              }
                           }
                        }
                     }

                     var42.sort(var11.getThreatComparator());
                     var55.clear();
                     this.tickController(var11, var4);
                     var42.clear();
                     var11.setNextPlayerIndex(0);
                     var10.clear();
                  }
               }
            }
         }
      }

      class="kw">private class="kw">static boolean isReadyToRespawn(@Nonnull LegacySpawnBeaconEntity var0, @Nonnull WorldTimeResource var1) {
         Instant var2 = var0.getNextSpawnAfter();
         if (var2 == null) {
            class="kw">return true;
         }

         Instant var3 = var0.isNextSpawnAfterRealtime() ? Instant.now() : var1.getGameTime();
         class="kw">return var3.isAfter(var2);
      }

      class="kw">protected void prepareSpawnJobGeneration(@Nonnull BeaconSpawnController var1, @Nonnull ComponentAccessor<EntityStore> var2) {
         if (var1.isRoundStart()) {
            Ref var3 = var1.getOwnerRef();
            LegacySpawnBeaconEntity var4 = var2.getComponent(var3, LegacySpawnBeaconEntity.getComponentType());
            assert var4 != null;
            ScaledXYResponseCurve var5 = var4.getSpawnWrapper().getSpawn().getConcurrentSpawnsScalingCurve();
            int[] var6 = var1.getBaseMaxConcurrentSpawns();
            List var7 = var1.getPlayersInRegion();
            int var8;
            int var9;
            if (var5 != null) {
               var8 = var6[0] + MathUtil.floor(var5.computeY(var7.size()) + 0.25);
               var9 = var6[1] + MathUtil.floor(var5.computeY(var7.size()) + 0.25);
            } else {
               var8 = var6[0];
               var9 = var6[1];
            }

            var1.setCurrentScaledMaxConcurrentSpawns(RandomExtra.randomRange(var8, var9));
            var1.setRoundStart(false);
         }

         int var10 = Math.max(0, var1.getCurrentScaledMaxConcurrentSpawns()) - var1.getSpawnsThisRound();
         var1.setRemainingSpawns(var10);
         if (var10 == 0) {
            var1.onAllConcurrentSpawned(var2);
         }
      }

      class="kw">protected void createRandomSpawnJobs(@Nonnull BeaconSpawnController var1, @Nonnull ComponentAccessor<EntityStore> var2) {
         while (var1.getActiveJobCount() < var1.getMaxActiveJobs()) {
            if (var1.createRandomSpawnJob(var2) == null) {
               var1.addRoundSpawn();
            }
         }
      }
   }

   class="kw">public class="kw">static class EntityAdded class="kw">extends RefSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, SpawnBeacon> componentType;

      class="kw">public EntityAdded(ComponentType<EntityStore, SpawnBeacon> var1) {
         this.componentType = var1;
      }

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.componentType;
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         SpawnBeacon var5 = var3.getComponent(var1, this.componentType);
         assert var5 != null;
         String var6 = var5.getSpawnConfigId();
         int var7 = BeaconNPCSpawn.getAssetMap().getIndex(var6);
         if (var7 == Integer.MIN_VALUE) {
            SpawnBeaconSystems.LOGGER.at(Level.SEVERE).log("Beacon %s removed due to missing spawn beacon type: %s", var1, var6);
            var4.removeEntity(var1, RemoveReason.REMOVE);
         } else {
            BeaconSpawnWrapper var8 = SpawningPlugin.get().getBeaconSpawnWrapper(var7);
            var5.setSpawnWrapper(var8);
            FloodFillPositionSelector var9 = new FloodFillPositionSelector(var3.getExternalData().getWorld(), var8);
            var9.setCalculatePositionsAfter(
               RandomExtra.randomRange(SpawnBeaconSystems.POSITION_CALCULATION_DELAY_RANGE[0], SpawnBeaconSystems.POSITION_CALCULATION_DELAY_RANGE[1])
            );
            var4.putComponent(var1, FloodFillPositionSelector.getComponentType(), var9);
            var4.ensureComponent(var1, PrefabCopyableComponent.getComponentType());
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }
   }

   class="kw">public class="kw">static class LegacyEntityAdded class="kw">extends RefSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, LegacySpawnBeaconEntity> componentType;

      class="kw">public LegacyEntityAdded(ComponentType<EntityStore, LegacySpawnBeaconEntity> var1) {
         this.componentType = var1;
      }

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.componentType;
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         LegacySpawnBeaconEntity var5 = var3.getComponent(var1, this.componentType);
         assert var5 != null;
         String var6 = var5.getSpawnConfigId();
         int var7 = BeaconNPCSpawn.getAssetMap().getIndex(var6);
         if (var7 == Integer.MIN_VALUE) {
            SpawnBeaconSystems.LOGGER.at(Level.SEVERE).log("Beacon %s removed due to missing spawn beacon type: %s", var1, var6);
            var4.removeEntity(var1, RemoveReason.REMOVE);
         } else {
            var5.setSpawnWrapper(SpawningPlugin.get().getBeaconSpawnWrapper(var7));
            World var8 = var3.getExternalData().getWorld();
            BeaconSpawnController var9 = new BeaconSpawnController(var8, var1);
            var5.setSpawnController(var9);
            BeaconSpawnWrapper var10 = var5.getSpawnWrapper();
            if (var10 != null) {
               var9.initialise(var10);
               FloodFillPositionSelector var11 = new FloodFillPositionSelector(var8, var10);
               var11.setCalculatePositionsAfter(
                  RandomExtra.randomRange(SpawnBeaconSystems.POSITION_CALCULATION_DELAY_RANGE[0], SpawnBeaconSystems.POSITION_CALCULATION_DELAY_RANGE[1])
               );
               var4.putComponent(var1, FloodFillPositionSelector.getComponentType(), var11);
               ScaledXYResponseCurve var12 = var10.getSpawn().getMaxSpawnsScalingCurve();
               int var13 = var9.getBaseMaxTotalSpawns();
               int var14 = var12 != null ? var13 + MathUtil.floor(var12.computeY(var5.getLastPlayerCount()) + 0.25) : var13;
               var9.setCurrentScaledMaxTotalSpawns(var14);
            }

            if (var2 == AddReason.LOAD) {
               InitialBeaconDelay var15 = new InitialBeaconDelay();
               var15.setLoadTimeSpawnDelay(15.0);
               var4.putComponent(var1, InitialBeaconDelay.getComponentType(), var15);
            }

            var4.ensureComponent(var1, PrefabCopyableComponent.getComponentType());
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }
   }

   class="kw">public class="kw">static class LoadTimeDelay class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, InitialBeaconDelay> componentType;
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = RootDependency.lastSet();

      class="kw">public LoadTimeDelay(ComponentType<EntityStore, InitialBeaconDelay> var1) {
         this.componentType = var1;
      }

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

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.componentType;
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         InitialBeaconDelay var6 = var3.getComponent(var2, this.componentType);
         assert var6 != null;
         if (var6.tickLoadTimeSpawnDelay(var1)) {
            var5.removeComponent(var3.getReferenceTo(var2), this.componentType);
         }
      }
   }

   class="kw">public class="kw">static class PositionSelectorUpdate class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, FloodFillPositionSelector> componentType;
      class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType;
      class="kw">private class="kw">final ResourceType<EntityStore, FloodFillEntryPoolProviderSimple> floodFillEntryPoolProviderSimpleResourceType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, SpawnBeaconSystems.CheckDespawn.class));

      class="kw">public PositionSelectorUpdate(
         ComponentType<EntityStore, FloodFillPositionSelector> var1, ResourceType<EntityStore, FloodFillEntryPoolProviderSimple> var2
      ) {
         this.componentType = var1;
         this.transformComponentType = TransformComponent.getComponentType();
         this.floodFillEntryPoolProviderSimpleResourceType = var2;
         this.query = Query.and(var1, this.transformComponentType);
      }

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

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

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return false;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         FloodFillPositionSelector var6 = var3.getComponent(var2, this.componentType);
         assert var6 != null;
         if (var6.shouldRebuildCache() && var6.tickCalculatePositionsAfter(var1)) {
            var6.init();
            TransformComponent var7 = var3.getComponent(var2, this.transformComponentType);
            assert var7 != null;
            Vector3d var8 = var7.getPosition();
            FloodFillEntryPoolProviderSimple var9 = var4.getResource(this.floodFillEntryPoolProviderSimpleResourceType);
            var6.buildPositionCache(var8, var9.getPool());
         }
      }
   }

   class="kw">public class="kw">static class SpawnJobTick class="kw">extends SpawnJobSystem<NPCBeaconSpawnJob, BeaconSpawnController> {
      class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
      class="kw">private class="kw">final ComponentType<EntityStore, LegacySpawnBeaconEntity> componentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, Player> playerComponentType;
      class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, SpawnBeaconSystems.ControllerTick.class));

      class="kw">public SpawnJobTick(ComponentType<EntityStore, LegacySpawnBeaconEntity> var1, ComponentType<EntityStore, InitialBeaconDelay> var2) {
         this.componentType = var1;
         this.playerComponentType = Player.getComponentType();
         this.transformComponentType = TransformComponent.getComponentType();
         this.query = Query.and(var1, Query.not(var2));
      }

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

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

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return false;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         LegacySpawnBeaconEntity var6 = var3.getComponent(var2, this.componentType);
         assert var6 != null;
         this.tickSpawnJobs(var6.getSpawnController(), var4, var5);
      }

      class="kw">protected void onStartRun(NPCBeaconSpawnJob var1) {
      }

      class="kw">protected void onEndProbing(
         @Nonnull BeaconSpawnController var1, @Nonnull NPCBeaconSpawnJob var2, SpawnJobSystem.Result var3, @Nonnull ComponentAccessor<EntityStore> var4
      ) {
         Ref var5 = var1.getOwnerRef();
         if (var5.isValid()) {
            LegacySpawnBeaconEntity var6 = var4.getComponent(var5, LegacySpawnBeaconEntity.getComponentType());
            assert var6 != null;
            if (var3 == SpawnJobSystem.Result.FAILED && var6.getSpawnAttempts() > 5) {
               LegacySpawnBeaconEntity.prepareNextSpawnTimer(var5, var4);
               var2.setBudgetUsed(var2.getColumnBudget());
            } else if (var3 == SpawnJobSystem.Result.PERMANENT_FAILURE) {
               var6.remove();
            } else if (var3 != SpawnJobSystem.Result.SUCCESS) {
               var6.notifyFailedSpawn();
            }
         }
      }

      class="kw">protected boolean pickSpawnPosition(@Nonnull BeaconSpawnController var1, @Nonnull NPCBeaconSpawnJob var2, @Nonnull CommandBuffer<EntityStore> var3) {
         Ref var4 = var2.getPlayer();
         if (var4 != null && var4.isValid()) {
            TransformComponent var5 = var3.getComponent(var4, this.transformComponentType);
            assert var5 != null;
            Vector3d var6 = var5.getPosition();
            Ref var7 = var1.getOwnerRef();
            LegacySpawnBeaconEntity var8 = var3.getComponent(var7, LegacySpawnBeaconEntity.getComponentType());
            assert var8 != null;
            class="kw">return var8.prepareSpawnContext(var6, var2.getSpawnsThisRound(), var2.getRoleIndex(), var2.getSpawningContext(), var3);
         } else {
            class="kw">return false;
         }
      }

      @Nonnull
      class="kw">protected SpawnJobSystem.Result trySpawn(@Nonnull BeaconSpawnController var1, @Nonnull NPCBeaconSpawnJob var2, @Nonnull CommandBuffer<EntityStore> var3) {
         class="kw">return this.spawn(var3.getExternalData().getWorld(), var1, var2, var3);
      }

      @Nonnull
      class="kw">protected SpawnJobSystem.Result spawn(
         World var1, @Nonnull BeaconSpawnController var2, @Nonnull NPCBeaconSpawnJob var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         SpawningContext var5 = var3.getSpawningContext();
         Vector3d var6 = var5.newPosition();
         Rotation3f var7 = var5.newRotation();
         int var8 = var3.getRoleIndex();
         String var9 = var5.activeMotionControllerType;
         var4.run(
            var8x -> {
               try {
                  Pair var9 = NPCPlugin.get()
                     .spawnEntity(
                        var8x,
                        var8,
                        var6,
                        var7,
                        var5.getModel(),
                        (var3x, var4x, var5x) -> postSpawn(var3x, var4x, var8, var9, var2.isDebugSpawnFrozen(), var5x)
                     );
                  Ref var10 = (Ref<EntityStore>)var9.first();
                  FlockPlugin.trySpawnFlock(
                     var10,
                     (NPCEntity)var9.second(),
                     var8,
                     var6,
                     var7,
                     var3.getFlockSize(),
                     var3.getFlockAsset(),
                     null,
                     (var3x, var4x, var5x) -> postSpawn(var3x, var4x, var8, var9, var2.isDebugSpawnFrozen(), var5x),
                     var8x
                  );
                  this.onSpawn(var10, var2, var3, var8x);
                  this.endProbing(var2, var3, SpawnJobSystem.Result.SUCCESS, var8x);
               } catch (RuntimeException var11) {
                  LOGGER.at(Level.WARNING).log("Spawn job %s: Failed to create %s: %s", var3.getJobId(), NPCPlugin.get().getName(var8), var11.getMessage());
                  this.endProbing(var2, var3, SpawnJobSystem.Result.FAILED, var8x);
               }

               var2.addIdleJob(var3);
            }
         );
         class="kw">return SpawnJobSystem.Result.PENDING_SPAWN;
      }

      class="kw">private void onSpawn(
         @Nonnull Ref<EntityStore> var1, @Nonnull BeaconSpawnController var2, @Nonnull NPCBeaconSpawnJob var3, @Nonnull Store<EntityStore> var4
      ) {
         HytaleLogger.Api var5 = LOGGER.at(Level.FINE);
         if (var5.isEnabled()) {
            TransformComponent var6 = var4.getComponent(var1, this.transformComponentType);
            assert var6 != null;
            Vector3d var7 = var6.getPosition();
            var5.log("Spawn job %s: Created %s at position %s", var3.getJobId(), NPCPlugin.get().getName(var3.getRoleIndex()), var7);
         }

         Ref var9 = var3.getPlayer();
         assert var9 != null;
         Ref var10 = var2.getOwnerRef();
         LegacySpawnBeaconEntity var8 = var4.getComponent(var10, LegacySpawnBeaconEntity.getComponentType());
         assert var8 != null;
         var8.notifySpawn(var9, var1, var4);
      }

      class="kw">private class="kw">static void postSpawn(
         @Nonnull NPCEntity var0, @Nonnull Ref<EntityStore> var1, int var2, @Nullable String var3, boolean var4, @Nonnull Store<EntityStore> var5
      ) {
         var0.setSpawnRoleIndex(var2);
         var0.setActiveMotionControllerName(var3);
         if (var4) {
            var5.ensureComponent(var1, Frozen.getComponentType());
         }
      }
   }
}