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

class="kw">import com.hypixel.hytale.builtin.weather.components.WeatherTracker;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.tick.TickingSystem;
class="kw">import com.hypixel.hytale.function.function.TriIntObjectDoubleToByteFunction;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.protocol.BlockMaterial;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
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.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.spawning.SpawningPlugin;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawns.LightType;
class="kw">import com.hypixel.hytale.server.spawning.beacons.LegacySpawnBeaconEntity;
class="kw">import com.hypixel.hytale.server.spawning.util.LightRangePredicate;
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.Object2ByteMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ByteOpenHashMap;
class="kw">import java.util.List;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;

class="kw">public class LocalSpawnControllerSystem class="kw">extends TickingSystem<EntityStore> {
   class="kw">public class="kw">static class="kw">final double RUN_FREQUENCY_SECONDS = 5.0;
   class="kw">private class="kw">static class="kw">final int LIGHT_LEVEL_EVALUATION_RADIUS = 4;
   class="kw">private class="kw">final Archetype<EntityStore> controllerArchetype;
   class="kw">private class="kw">final ComponentType<EntityStore, LocalSpawnController> spawnControllerComponentType;
   class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentype;
   class="kw">private class="kw">final ComponentType<EntityStore, WeatherTracker> weatherTrackerComponentType;
   class="kw">private class="kw">final ComponentType<EntityStore, LocalSpawnBeacon> localSpawnBeaconComponentType;
   class="kw">private class="kw">final ComponentType<EntityStore, LegacySpawnBeaconEntity> spawnBeaconComponentType;
   class="kw">private class="kw">final ResourceType<EntityStore, LocalSpawnState> localSpawnStateResourceType;
   class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> beaconSpatialComponent;

   class="kw">public LocalSpawnControllerSystem(
      ComponentType<EntityStore, LocalSpawnController> var1,
      ComponentType<EntityStore, TransformComponent> var2,
      ComponentType<EntityStore, WeatherTracker> var3,
      ComponentType<EntityStore, LocalSpawnBeacon> var4,
      ComponentType<EntityStore, LegacySpawnBeaconEntity> var5,
      ResourceType<EntityStore, LocalSpawnState> var6,
      ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> var7
   ) {
      this.spawnControllerComponentType = var1;
      this.transformComponentype = var2;
      this.weatherTrackerComponentType = var3;
      this.localSpawnBeaconComponentType = var4;
      this.spawnBeaconComponentType = var5;
      this.localSpawnStateResourceType = var6;
      this.beaconSpatialComponent = var7;
      this.controllerArchetype = Archetype.of(var1, PlayerRef.getComponentType(), var2, var3);
   }

   @Override
   class="kw">public void tick(float var1, int var2, @Nonnull Store<EntityStore> var3) {
      LocalSpawnState var4 = var3.getResource(this.localSpawnStateResourceType);
      List var5 = var4.getLocalControllerList();
      var3.forEachChunk(this.controllerArchetype, (var3x, var4x) -> {
         for (int var5 = 0; var5 < var3x.size(); var5++) {
            LocalSpawnController var6 = var3x.getComponent(var5, this.spawnControllerComponentType);
            assert var6 != null;
            if (var6.tickTimeToNextRunSeconds(var1)) {
               var5.add(var3x.getReferenceTo(var5));
            }
         }
      });
      if (!var5.isEmpty()) {
         World var6 = var3.getExternalData().getWorld();
         List var7 = var4.getLocalPendingSpawns();
         List var8 = SpatialResource.getThreadLocalReferenceList();

         for (int var9 = 0; var9 < var5.size(); var9++) {
            Ref var10 = var5.get(var9);
            LocalSpawnController var11 = var3.getComponent(var10, this.spawnControllerComponentType);
            assert var11 != null;
            PlayerRef var12 = var3.getComponent(var10, PlayerRef.getComponentType());
            assert var12 != null;
            SpawningPlugin.get().getLogger().at(Level.FINE).log("Running local spawn controller for player %s", var12.getUsername());
            TransformComponent var13 = var3.getComponent(var10, this.transformComponentype);
            assert var13 != null;
            WeatherTracker var14 = var3.getComponent(var10, this.weatherTrackerComponentType);
            assert var14 != null;
            var14.updateEnvironment(var13, var3);
            int var15 = var14.getEnvironmentId();
            List var16 = SpawningPlugin.get().getBeaconSpawnsForEnvironment(var15);
            if (var16 != null && !var16.isEmpty()) {
               BeaconSpawnWrapper var17 = var16.getFirst();
               double var18 = var17.getBeaconRadius();
               int[] var20 = var17.getSpawn().getYRange();
               int var21 = var20[0];
               int var22 = var20[1];

               for (int var23 = 1; var23 < var16.size(); var23++) {
                  BeaconSpawnWrapper var24 = var16.get(var23);
                  double var25 = var24.getBeaconRadius();
                  if (var25 > var18) {
                     var18 = var25;
                  }

                  int[] var27 = var24.getSpawn().getYRange();
                  if (var27[0] < var21) {
                     var21 = var27[0];
                  }

                  if (var27[1] > var22) {
                     var22 = var27[1];
                  }
               }

               var18 *= 2.0;
               Vector3d var55 = var13.getPosition();
               double var56 = var18 * var18;
               int var26 = Math.abs(var21) + Math.abs(var22);
               int var57 = MathUtil.floor(var55.y());
               int var28 = Math.max(0, var57 - var26);
               int var29 = Math.min(319, var57 + var26);
               SpatialResource var30 = var3.getResource(this.beaconSpatialComponent);
               var30.getSpatialStructure().ordered(var55, var18, var8);
               WorldTimeResource var31 = var3.getResource(WorldTimeResource.getResourceType());
               double var32 = var31.getSunlightFactor();
               int var34 = MathUtil.floor(var55.x());
               int var35 = MathUtil.floor(var55.y());
               int var36 = MathUtil.floor(var55.z());
               Object2ByteOpenHashMap var37 = new Object2ByteOpenHashMap();
               var37.defaultReturnValue((byte)-1);

               label134:
               for (int var38 = 0; var38 < var16.size(); var38++) {
                  BeaconSpawnWrapper var39 = var16.get(var38);
                  if (var39.spawnParametersMatch(var3)) {
                     for (int var40 = 0; var40 < var8.size(); var40++) {
                        Ref var41 = var8.get(var40);
                        LegacySpawnBeaconEntity var42 = var3.getComponent(var41, this.spawnBeaconComponentType);
                        assert var42 != null;
                        TransformComponent var43 = var3.getComponent(var41, this.transformComponentype);
                        assert var43 != null;
                        double var44 = var43.getPosition().y();
                        if (!(var44 > var29) && !(var44 < var28)) {
                           int var46 = var42.getSpawnWrapper().getSpawnIndex();
                           if (var46 == var39.getSpawnIndex()) {
                              class="kw">continue label134;
                           }
                        }
                     }

                     for (int var58 = 0; var58 < var7.size(); var58++) {
                        LegacySpawnBeaconEntity var60 = var7.get(var58);
                        Ref var62 = var60.getReference();
                        TransformComponent var63 = var3.getComponent(var62, TransformComponent.getComponentType());
                        assert var63 != null;
                        Vector3d var64 = var63.getPosition();
                        double var45 = var64.y();
                        if (!(var45 > var29) && !(var45 < var28)) {
                           double var47 = var55.x - var64.x;
                           double var49 = var55.z - var64.z;
                           double var51 = var47 * var47 + var49 * var49;
                           if (!(var51 > var56)) {
                              int var53 = var60.getSpawnWrapper().getSpawnIndex();
                              if (var53 == var39.getSpawnIndex()) {
                                 class="kw">continue label134;
                              }
                           }
                        }
                     }

                     if (spawnLightLevelMatches(var6, var34, var35, var36, var32, var39, var37)) {
                        Pair var59 = LegacySpawnBeaconEntity.create(var39, var13.getPosition(), var13.getRotation(), var3);
                        Ref var61 = (Ref<EntityStore>)var59.first();
                        if (var61 != null && var61.isValid()) {
                           var3.ensureComponent(var61, this.localSpawnBeaconComponentType);
                           SpawningPlugin.get()
                              .getLogger()
                              .at(Level.FINE)
                              .log("Placed spawn beacon of type %s at position %s for player %s", var39.getSpawn().getId(), var55, var12.getUsername());
                           var7.add((LegacySpawnBeaconEntity)var59.second());
                        }
                     }
                  }
               }

               var8.clear();
               var37.clear();
               var11.setTimeToNextRunSeconds(5.0);
            } else {
               var11.setTimeToNextRunSeconds(5.0);
            }
         }

         var5.clear();
         var7.clear();
      }
   }

   class="kw">private class="kw">static boolean spawnLightLevelMatches(
      @Nonnull World var0, int var1, int var2, int var3, double var4, @Nonnull BeaconSpawnWrapper var6, @Nonnull Object2ByteMap<LightType> var7
   ) {
      LightRangePredicate var8 = var6.getLightRangePredicate();
      if (var8.isTestLightValue()) {
         byte var9 = getCachedAverageLightValue(
            LightType.Light,
            var0,
            var1,
            var2,
            var3,
            var4,
            (var0x, var1x, var2x, var3x, var4x) -> LightRangePredicate.calculateLightValue(var3x, var0x, var1x, var2x, var4x),
            var7
         );
         if (!var8.testLight(var9)) {
            class="kw">return false;
         }
      }

      if (var8.isTestSkyLightValue()) {
         byte var10 = getCachedAverageLightValue(
            LightType.SkyLight,
            var0,
            var1,
            var2,
            var3,
            var4,
            (var0x, var1x, var2x, var3x, var4x) -> var3x.getGlobalLight().getSkyLight(var0x, var1x, var2x),
            var7
         );
         if (!var8.testSkyLight(var10)) {
            class="kw">return false;
         }
      }

      if (var8.isTestSunlightValue()) {
         byte var11 = getCachedAverageLightValue(
            LightType.Sunlight,
            var0,
            var1,
            var2,
            var3,
            var4,
            (var0x, var1x, var2x, var3x, var4x) -> (byte)(var3x.getGlobalLight().getSkyLight(var0x, var1x, var2x) * var4x),
            var7
         );
         if (!var8.testSunlight(var11)) {
            class="kw">return false;
         }
      }

      if (var8.isTestRedLightValue()) {
         byte var12 = getCachedAverageLightValue(
            LightType.RedLight,
            var0,
            var1,
            var2,
            var3,
            var4,
            (var0x, var1x, var2x, var3x, var4x) -> var3x.getGlobalLight().getRedBlockLight(var0x, var1x, var2x),
            var7
         );
         if (!var8.testRedLight(var12)) {
            class="kw">return false;
         }
      }

      if (var8.isTestGreenLightValue()) {
         byte var13 = getCachedAverageLightValue(
            LightType.GreenLight,
            var0,
            var1,
            var2,
            var3,
            var4,
            (var0x, var1x, var2x, var3x, var4x) -> var3x.getGlobalLight().getGreenBlockLight(var0x, var1x, var2x),
            var7
         );
         if (!var8.testGreenLight(var13)) {
            class="kw">return false;
         }
      }

      if (var8.isTestBlueLightValue()) {
         byte var14 = getCachedAverageLightValue(
            LightType.BlueLight,
            var0,
            var1,
            var2,
            var3,
            var4,
            (var0x, var1x, var2x, var3x, var4x) -> var3x.getGlobalLight().getBlueBlockLight(var0x, var1x, var2x),
            var7
         );
         class="kw">return var8.testBlueLight(var14);
      } else {
         class="kw">return true;
      }
   }

   class="kw">private class="kw">static byte getCachedAverageLightValue(
      LightType var0,
      @Nonnull World var1,
      int var2,
      int var3,
      int var4,
      double var5,
      @Nonnull TriIntObjectDoubleToByteFunction<BlockSection> var7,
      @Nonnull Object2ByteMap<LightType> var8
   ) {
      byte var9 = var8.getByte(var0);
      if (var9 < 0) {
         int var10 = 0;
         int var11 = 0;
         ChunkStore var12 = var1.getChunkStore();
         Store var13 = var12.getStore();
         int var14 = var2 - 4;
         int var15 = var2 + 4 - 1;
         int var16 = var3;
         int var17 = var3 + 4 - 1;
         int var18 = var4 - 4;
         int var19 = var4 + 4 - 1;

         for (int var20 = ChunkUtil.chunkCoordinate(var14); var20 <= ChunkUtil.chunkCoordinate(var15); var20++) {
            int var21 = Math.max(var14, ChunkUtil.minBlock(var20));
            int var22 = Math.min(var15, ChunkUtil.maxBlock(var20));

            for (int var23 = ChunkUtil.chunkCoordinate(var18); var23 <= ChunkUtil.chunkCoordinate(var19); var23++) {
               int var24 = Math.max(var18, ChunkUtil.minBlock(var23));
               int var25 = Math.min(var19, ChunkUtil.maxBlock(var23));

               for (int var26 = ChunkUtil.chunkCoordinate(var16); var26 <= ChunkUtil.chunkCoordinate(var17); var26++) {
                  Ref var27 = var12.getChunkSectionReference(var20, var26, var23);
                  if (var27 != null && var27.isValid()) {
                     BlockSection var28 = var13.getComponent(var27, BlockSection.getComponentType());
                     if (var28 != null) {
                        int var29 = Math.max(var16, ChunkUtil.minBlock(var26));
                        int var30 = Math.min(var17, ChunkUtil.maxBlock(var26));

                        for (int var31 = var21; var31 <= var22; var31++) {
                           for (int var32 = var24; var32 <= var25; var32++) {
                              for (int var33 = var29; var33 <= var30; var33++) {
                                 int var34 = var28.get(var31, var33, var32);
                                 if (var34 != 0) {
                                    BlockType var35 = BlockType.getAssetMap().getAsset(var34);
                                    if (var35 == null || var35.getMaterial() == BlockMaterial.Solid) {
                                       class="kw">continue;
                                    }
                                 }

                                 var10++;
                                 var11 += var7.apply(var31, var33, var32, var28, var5);
                              }
                           }
                        }
                     }
                  }
               }
            }
         }

         var9 = var10 > 0 ? (byte)((float)var11 / var10) : 0;
         var8.put(var0, var9);
      }

      class="kw">return var9;
   }
}