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

class="kw">import com.hypixel.hytale.builtin.tagset.TagSetPlugin;
class="kw">import com.hypixel.hytale.builtin.tagset.config.NPCGroup;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.common.map.IWeightedMap;
class="kw">import com.hypixel.hytale.component.Component;
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.Store;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.function.consumer.TriConsumer;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.Model;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.group.EntityGroup;
class="kw">import com.hypixel.hytale.server.core.entity.reference.InvalidatablePersistentRef;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.WorldGenId;
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.flock.StoredFlock;
class="kw">import com.hypixel.hytale.server.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.Builder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderInfo;
class="kw">import com.hypixel.hytale.server.npc.components.SpawnMarkerReference;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.npc.movement.MovementMode;
class="kw">import com.hypixel.hytale.server.spawning.ISpawnableWithModel;
class="kw">import com.hypixel.hytale.server.spawning.SpawnTestResult;
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.spawnmarker.config.SpawnMarker;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawnsuppression.SpawnSuppression;
class="kw">import it.unimi.dsi.fastutil.Pair;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.time.Duration;
class="kw">import java.time.Instant;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.ThreadLocalRandom;
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 SpawnMarkerEntity class="kw">implements Component<EntityStore> {
   class="kw">private class="kw">static class="kw">final double SPAWN_LOST_TIMEOUT = 35.0;
   @Nonnull
   class="kw">private class="kw">static class="kw">final InvalidatablePersistentRef[] EMPTY_REFERENCES = new InvalidatablePersistentRef[0];
   class="kw">public class="kw">static class="kw">final ArrayCodec<InvalidatablePersistentRef> NPC_REFERENCES_CODEC = new ArrayCodec<>(
      InvalidatablePersistentRef.CODEC, InvalidatablePersistentRef[]::new
   );
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<SpawnMarkerEntity> CODEC = BuilderCodec.<SpawnMarkerEntity>builder(SpawnMarkerEntity.class, SpawnMarkerEntity::new)
      .addField(new KeyedCodec<>("SpawnMarker", Codec.STRING), (var0, var1) -> var0.spawnMarkerId = var1, var0 -> var0.spawnMarkerId)
      .addField(new KeyedCodec<>("RespawnTime", Codec.DOUBLE), (var0, var1) -> var0.respawnCounter = var1, var0 -> var0.respawnCounter)
      .addField(new KeyedCodec<>("SpawnCount", Codec.INTEGER), (var0, var1) -> var0.spawnCount = var1, var0 -> var0.spawnCount)
      .addField(new KeyedCodec<>("GameTimeRespawn", Codec.DURATION), (var0, var1) -> var0.gameTimeRespawn = var1, var0 -> var0.gameTimeRespawn)
      .addField(new KeyedCodec<>("SpawnAfter", Codec.INSTANT), (var0, var1) -> var0.spawnAfter = var1, var0 -> var0.spawnAfter)
      .addField(new KeyedCodec<>("NPCReferences", NPC_REFERENCES_CODEC), (var0, var1) -> var0.npcReferences = var1, var0 -> var0.npcReferences)
      .addField(new KeyedCodec<>("PersistedFlock", StoredFlock.CODEC), (var0, var1) -> var0.storedFlock = var1, var0 -> var0.storedFlock)
      .addField(
         new KeyedCodec<>("SpawnPosition", Vector3dUtil.CODEC),
         (var0, var1) -> var0.spawnPosition.set(var1),
         var0 -> var0.storedFlock == null ? null : var0.spawnPosition
      )
      .build();
   class="kw">private class="kw">static class="kw">final int MAX_FAILED_SPAWNS = 5;
   class="kw">private String spawnMarkerId;
   class="kw">private SpawnMarker cachedMarker;
   class="kw">private double respawnCounter;
   @Nullable
   class="kw">private Duration gameTimeRespawn;
   @Nullable
   class="kw">private Instant spawnAfter;
   class="kw">private int spawnCount;
   @Nullable
   class="kw">private Set<UUID> suppressedBy;
   class="kw">private int failedSpawns;
   class="kw">private boolean loggedNoConfiguration;
   @Nullable
   class="kw">private class="kw">final SpawningContext context;
   class="kw">private class="kw">final Vector3d spawnPosition = new Vector3d();
   class="kw">private InvalidatablePersistentRef[] npcReferences;
   @Nullable
   class="kw">private StoredFlock storedFlock;
   @Nullable
   class="kw">private List<Pair<Ref<EntityStore>, NPCEntity>> tempStorageList;
   class="kw">private double timeToDeactivation;
   class="kw">private boolean despawnStarted;
   class="kw">private double spawnLostTimeoutCounter;

   class="kw">public class="kw">static ComponentType<EntityStore, SpawnMarkerEntity> getComponentType() {
      class="kw">return SpawningPlugin.get().getSpawnMarkerComponentType();
   }

   class="kw">public SpawnMarkerEntity() {
      this(new SpawningContext());
   }

   class="kw">private SpawnMarkerEntity(@Nullable SpawningContext var1) {
      this.context = var1;
      this.npcReferences = EMPTY_REFERENCES;
   }

   class="kw">public SpawnMarker getCachedMarker() {
      class="kw">return this.cachedMarker;
   }

   class="kw">public void setCachedMarker(@Nonnull SpawnMarker var1) {
      this.cachedMarker = var1;
      this.loggedNoConfiguration = false;
   }

   class="kw">public int getSpawnCount() {
      class="kw">return this.spawnCount;
   }

   class="kw">public void setSpawnCount(int var1) {
      this.spawnCount = var1;
   }

   class="kw">public void setRespawnCounter(double var1) {
      this.respawnCounter = var1;
   }

   class="kw">public void setSpawnAfter(@Nullable Instant var1) {
      this.spawnAfter = var1;
   }

   @Nullable
   class="kw">public Instant getSpawnAfter() {
      class="kw">return this.spawnAfter;
   }

   class="kw">public void setGameTimeRespawn(@Nullable Duration var1) {
      this.gameTimeRespawn = var1;
   }

   @Nullable
   class="kw">public Duration pollGameTimeRespawn() {
      Duration var1 = this.gameTimeRespawn;
      this.gameTimeRespawn = null;
      class="kw">return var1;
   }

   class="kw">public boolean tickRespawnTimer(float var1) {
      class="kw">return (this.respawnCounter -= var1) <= 0.0;
   }

   @Nullable
   class="kw">public Set<UUID> getSuppressedBy() {
      class="kw">return this.suppressedBy;
   }

   class="kw">public void setStoredFlock(@Nonnull StoredFlock var1) {
      this.storedFlock = var1;
   }

   @Nullable
   class="kw">public StoredFlock getStoredFlock() {
      class="kw">return this.storedFlock;
   }

   class="kw">public double getTimeToDeactivation() {
      class="kw">return this.timeToDeactivation;
   }

   class="kw">public void setTimeToDeactivation(double var1) {
      this.timeToDeactivation = var1;
   }

   class="kw">public boolean tickTimeToDeactivation(float var1) {
      class="kw">return (this.timeToDeactivation -= var1) <= 0.0;
   }

   class="kw">public boolean tickSpawnLostTimeout(float var1) {
      class="kw">return (this.spawnLostTimeoutCounter -= var1) <= 0.0;
   }

   @Nonnull
   class="kw">public Vector3d getSpawnPosition() {
      class="kw">return this.spawnPosition;
   }

   class="kw">public InvalidatablePersistentRef[] getNpcReferences() {
      class="kw">return this.npcReferences;
   }

   class="kw">public void setNpcReferences(@Nullable InvalidatablePersistentRef[] var1) {
      this.npcReferences = var1 != null ? var1 : EMPTY_REFERENCES;
   }

   @Nullable
   class="kw">public List<Pair<Ref<EntityStore>, NPCEntity>> getTempStorageList() {
      class="kw">return this.tempStorageList;
   }

   class="kw">public void setTempStorageList(@Nonnull List<Pair<Ref<EntityStore>, NPCEntity>> var1) {
      this.tempStorageList = var1;
   }

   class="kw">public boolean isDespawnStarted() {
      class="kw">return this.despawnStarted;
   }

   class="kw">public void setDespawnStarted(boolean var1) {
      this.despawnStarted = var1;
   }

   class="kw">public void refreshTimeout() {
      this.spawnLostTimeoutCounter = 35.0;
   }

   class="kw">public boolean spawnNPC(@Nonnull Ref<EntityStore> var1, @Nonnull SpawnMarker var2, @Nullable List<Ref<EntityStore>> var3, @Nonnull Store<EntityStore> var4) {
      assert this.context != null;
      if (this.context == null) {
         class="kw">return false;
      }

      IWeightedMap var5 = var2.getWeightedConfigurations();
      if (var5 == null) {
         if (!this.loggedNoConfiguration) {
            this.loggedNoConfiguration = true;
            SpawningPlugin.get().getLogger().at(Level.WARNING).log("Marker %s (%s) has no spawn configurations and cannot spawn", var1, this.spawnMarkerId);
         }

         this.refreshTimeout();
         class="kw">return false;
      } else {
         SpawnMarker.SpawnConfiguration var6 = var5.get(ThreadLocalRandom.current());
         if (var6 == null) {
            if (!this.loggedNoConfiguration) {
               this.loggedNoConfiguration = true;
               SpawningPlugin.get()
                  .getLogger()
                  .at(Level.WARNING)
                  .log("Marker %s (%s) has no spawn configuration to choose from and cannot spawn", var1, this.spawnMarkerId);
            }

            this.refreshTimeout();
            class="kw">return false;
         } else {
            boolean var7 = var2.isRealtimeRespawn();
            if (var7) {
               this.respawnCounter = var6.getRealtimeRespawnTime();
            } else {
               this.spawnAfter = null;
               this.gameTimeRespawn = var6.getSpawnAfterGameTime();
            }

            UUIDComponent var8 = var4.getComponent(var1, UUIDComponent.getComponentType());
            assert var8 != null;
            UUID var9 = var8.getUuid();
            String var10 = var6.getNpc();
            if (var10 != null && !var10.isEmpty()) {
               NPCPlugin var11 = NPCPlugin.get();
               int var12 = var11.getIndex(var10);
               TransformComponent var13 = var4.getComponent(var1, TransformComponent.getComponentType());
               assert var13 != null;
               Vector3d var14 = var13.getPosition();
               BuilderInfo var15 = var11.getRoleBuilderInfo(var12);
               if (var15 == null) {
                  SpawningPlugin.get().getLogger().at(Level.WARNING).log("Marker %s attempted to spawn non-existent NPC role '%s'", var9, var10);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.NONEXISTENT_ROLE);
                  class="kw">return false;
               }

               Builder var16 = var15.isValid() ? var15.getBuilder() : null;
               if (var16 == null) {
                  SpawningPlugin.get().getLogger().at(Level.WARNING).log("Marker %s attempted to spawn invalid NPC role '%s'", var9, var10);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.INVALID_ROLE);
                  class="kw">return false;
               }

               if (!var16.isSpawnable()) {
                  SpawningPlugin.get().getLogger().at(Level.WARNING).log("Marker %s attempted to spawn a non-spawnable (class="kw">abstract) role '%s'", var9, var10);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.INVALID_ROLE);
                  class="kw">return false;
               }

               ISpawnableWithModel var17 = (ISpawnableWithModel)var16;
               if (!this.context.setSpawnable(var17)) {
                  SpawningPlugin.get().getLogger().at(Level.WARNING).log("Marker %s failed to spawn NPC role '%s' due to failed role validation", var9, var10);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.FAILED_ROLE_VALIDATION);
                  class="kw">return false;
               }

               List var18 = SpatialResource.getThreadLocalReferenceList();
               SpatialResource var19 = var4.getResource(EntityModule.get().getPlayerSpatialResourceType());
               var19.getSpatialStructure().collect(var14, var2.getExclusionRadius(), var18);
               boolean var20 = !var18.isEmpty();
               if (var20) {
                  this.refreshTimeout();
                  class="kw">return false;
               }

               World var21 = var4.getExternalData().getWorld();
               if (!this.context.set(var21, var14.x, var14.y, var14.z)) {
                  SpawningPlugin.get()
                     .getLogger()
                     .at(this.failDetailLevel())
                     .log("Marker %s attempted to spawn NPC '%s' at %s but the chunk is unloaded or no spawn span exists", var9, var10, var14);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.NO_VALID_SPAWN_POSITION);
                  class="kw">return false;
               }

               Set var22 = this.context.getSpawnMovementModes();
               if (var22.isEmpty()) {
                  SpawningPlugin.get()
                     .getLogger()
                     .at(this.failDetailLevel())
                     .log(
                        "Marker %s attempted to spawn NPC '%s' but there are either no valid motion controllers or breathing config is incompatible",
                        var9,
                        var10
                     );
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.NO_MOVEMENT_MODES);
                  class="kw">return false;
               }

               MovementMode var23 = var22.iterator().next();
               if (!this.context.setMovementMode(var23, true)) {
                  SpawningPlugin.get()
                     .getLogger()
                     .at(this.failDetailLevel())
                     .log("Marker %s attempted to spawn NPC '%s' but movement mode %s is invalid for spawning", var9, var10, var23);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.MOVEMENT_MODE_REJECTED);
                  class="kw">return false;
               }

               SpawnTestResult var24 = this.context.canSpawn(true, false);
               if (var24 != SpawnTestResult.TEST_OK) {
                  SpawningPlugin.get()
                     .getLogger()
                     .at(this.failDetailLevel())
                     .log("Marker %s attempted to spawn NPC '%s' at %s but could not fit: %s", var9, var10, var14, var24);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.NO_ROOM);
                  class="kw">return false;
               }

               this.spawnPosition.set(this.context.xSpawn, this.context.ySpawn, this.context.zSpawn);
               double var25 = var2.getMaxDropHeightSquared();
               double var27 = this.spawnPosition.distanceSquared(var14);
               if (var17.requiresSpawnDropHeightCheck(this.context) && var27 > var25) {
                  SpawningPlugin.get()
                     .getLogger()
                     .at(this.failDetailLevel())
                     .log("Marker %s attempted to spawn NPC '%s' but was offset too far from the ground at %s", var9, var10, var14);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.TOO_HIGH);
                  class="kw">return false;
               }

               TriConsumer var29 = (var1x, var2x, var3x) -> {
                  SpawnMarkerReference var4 = var3x.ensureAndGetComponent(var2x, SpawnMarkerReference.getComponentType());
                  var4.getReference().setEntity(var1, var3x);
                  var4.refreshTimeoutCounter();
                  WorldGenId var5 = var3x.getComponent(var1, WorldGenId.getComponentType());
                  int var6 = var5 != null ? var5.getWorldGenId() : 0;
                  var3x.putComponent(var2x, WorldGenId.getComponentType(), new WorldGenId(var6));
               };
               Rotation3f var30 = var13.getRotation();
               Pair var31 = var11.spawnEntity(var4, var12, this.spawnPosition, var30, null, var29);
               if (var31 == null) {
                  SpawningPlugin.get()
                     .getLogger()
                     .at(Level.WARNING)
                     .log("Marker %s could not spawn NPC role '%s' because the entity was rejected while being added", var9, var10);
                  this.fail(var1, var9, var10, var14, var4, SpawnMarkerEntity.FailReason.INVALID_ROLE);
                  class="kw">return false;
               }

               Ref var32 = (Ref<EntityStore>)var31.first();
               NPCEntity var33 = (NPCEntity)var31.second();
               if (var3 != null) {
                  var3.add(var32);
               }

               Ref var34 = FlockPlugin.trySpawnFlock(var32, var33, var4, var12, this.spawnPosition, var30, var6.getFlockDefinition(), var29);
               EntityGroup var35 = var34 == null ? null : var4.getComponent(var34, EntityGroup.getComponentType());
               this.spawnCount = var35 != null ? var35.size() : 1;
               if (this.storedFlock != null) {
                  this.despawnStarted = false;
                  this.npcReferences = new InvalidatablePersistentRef[this.spawnCount];
                  if (var35 != null) {
                     var35.forEachMember((var3x, var4x, var5x) -> {
                        InvalidatablePersistentRef var6 = new InvalidatablePersistentRef();
                        var6.setEntity(var4x, var4);
                        var5x[var3x] = var6;
                        if (var3 != null) {
                           if (var4x.equals(var32)) {
                              class="kw">return;
                           }

                           var3.add(var4x);
                        }
                     }, this.npcReferences);
                  } else {
                     InvalidatablePersistentRef var36 = new InvalidatablePersistentRef();
                     var36.setEntity(var32, var4);
                     this.npcReferences[0] = var36;
                  }

                  this.storedFlock.clear();
               }

               SpawningPlugin.get()
                  .getLogger()
                  .at(Level.FINE)
                  .log("Marker %s spawned %s and set respawn to %s", var9, var33.getRoleName(), var7 ? this.respawnCounter : this.gameTimeRespawn);
               this.refreshTimeout();
               class="kw">return true;
            } else {
               SpawningPlugin.get()
                  .getLogger()
                  .at(Level.FINE)
                  .log("Marker %s performed noop spawn and set repawn to %s", var9, var7 ? this.respawnCounter : this.gameTimeRespawn);
               this.refreshTimeout();
               class="kw">return true;
            }
         }
      }
   }

   class="kw">private void fail(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull UUID var2,
      @Nonnull String var3,
      @Nonnull Vector3d var4,
      @Nonnull Store<EntityStore> var5,
      @Nonnull SpawnMarkerEntity.FailReason var6
   ) {
      boolean var7 = this.nextFailRemovesMarker();
      this.failedSpawns++;
      if (var7) {
         SpawningPlugin.get()
            .getLogger()
            .at(Level.WARNING)
            .log("Marker %s (%s) at %s removed due to repeated spawning fails of NPC %s with reason: %s", this.spawnMarkerId, var2, var4, var3, var6);
         var5.removeEntity(var1, RemoveReason.REMOVE);
      } else {
         this.refreshTimeout();
      }
   }

   class="kw">private boolean nextFailRemovesMarker() {
      class="kw">return this.failedSpawns + 1 >= 5;
   }

   @Nonnull
   class="kw">private Level failDetailLevel() {
      class="kw">return this.nextFailRemovesMarker() ? Level.WARNING : Level.FINE;
   }

   class="kw">public void setSpawnMarker(@Nonnull SpawnMarker var1) {
      this.spawnMarkerId = var1.getId();
      this.setCachedMarker(var1);
      if (this.cachedMarker.getDeactivationDistance() > 0.0) {
         this.storedFlock = new StoredFlock();
         this.tempStorageList = new ObjectArrayList();
      } else {
         this.storedFlock = null;
         this.tempStorageList = null;
      }
   }

   class="kw">public int decrementAndGetSpawnCount() {
      class="kw">return --this.spawnCount;
   }

   class="kw">public String getSpawnMarkerId() {
      class="kw">return this.spawnMarkerId;
   }

   class="kw">public boolean isManualTrigger() {
      class="kw">return this.cachedMarker.isManualTrigger();
   }

   class="kw">public boolean trigger(@Nonnull Ref<EntityStore> var1, @Nullable List<Ref<EntityStore>> var2, @Nonnull Store<EntityStore> var3) {
      class="kw">return this.cachedMarker.isManualTrigger() && this.spawnCount <= 0 ? this.spawnNPC(var1, this.cachedMarker, var2, var3) : false;
   }

   class="kw">public boolean isSuppressedBy(@Nonnull SpawnSuppression var1) {
      int[] var2 = var1.getSuppressedGroupIds();
      if (var2 != null && var2.length != 0) {
         SpawnMarker var3 = this.cachedMarker != null ? this.cachedMarker : SpawnMarker.getAssetMap().getAsset(this.spawnMarkerId);
         if (var3 == null) {
            class="kw">return true;
         }

         IWeightedMap var4 = var3.getWeightedConfigurations();
         if (var4 == null) {
            class="kw">return false;
         }

         NPCPlugin var5 = NPCPlugin.get();
         TagSetPlugin.TagSetLookup var6 = TagSetPlugin.get(NPCGroup.class);
         boolean[] var7 = new boolean[]{false};
         var4.forEach(var4x -> {
            if (!var7[0]) {
               String var5 = var4x.getNpc();
               if (var5 != null && !var5.isEmpty()) {
                  int var6 = var5.getIndex(var5);

                  for (int var10 : var2) {
                     IntSet var11 = var6.getSet(var10);
                     if (var11 != null && var11.contains(var6)) {
                        var7[0] = true;
                        class="kw">return;
                     }
                  }
               }
            }
         });
         class="kw">return var7[0];
      } else {
         class="kw">return true;
      }
   }

   class="kw">public void suppress(@Nonnull UUID var1) {
      if (this.suppressedBy == null) {
         this.suppressedBy = new HashSet<>();
      }

      this.suppressedBy.add(var1);
   }

   class="kw">public void releaseSuppression(@Nonnull UUID var1) {
      if (this.suppressedBy != null) {
         this.suppressedBy.remove(var1);
      }
   }

   class="kw">public void clearAllSuppressions() {
      if (this.suppressedBy != null) {
         this.suppressedBy.clear();
      }
   }

   @Nonnull
   @Override
   class="kw">public Component<EntityStore> clone() {
      SpawnMarkerEntity var1 = new SpawnMarkerEntity();
      var1.spawnMarkerId = this.spawnMarkerId;
      var1.cachedMarker = this.cachedMarker;
      var1.respawnCounter = this.respawnCounter;
      var1.gameTimeRespawn = this.gameTimeRespawn;
      var1.spawnAfter = this.spawnAfter;
      var1.spawnCount = this.spawnCount;
      var1.suppressedBy = this.suppressedBy != null ? new HashSet<>(this.suppressedBy) : null;
      var1.failedSpawns = this.failedSpawns;
      var1.loggedNoConfiguration = this.loggedNoConfiguration;
      var1.spawnPosition.set(this.spawnPosition);
      var1.npcReferences = this.npcReferences;
      var1.storedFlock = this.storedFlock != null ? this.storedFlock.clone() : null;
      var1.timeToDeactivation = this.timeToDeactivation;
      var1.despawnStarted = this.despawnStarted;
      var1.spawnLostTimeoutCounter = this.spawnLostTimeoutCounter;
      class="kw">return var1;
   }

   @Nullable
   @Override
   class="kw">public Component<EntityStore> cloneSerializable() {
      SpawnMarkerEntity var1 = new SpawnMarkerEntity(null);
      var1.spawnMarkerId = this.spawnMarkerId;
      var1.respawnCounter = this.respawnCounter;
      var1.spawnCount = this.spawnCount;
      var1.gameTimeRespawn = this.gameTimeRespawn;
      var1.spawnAfter = this.spawnAfter;
      var1.npcReferences = this.npcReferences;
      var1.storedFlock = this.storedFlock != null ? this.storedFlock.cloneSerializable() : null;
      var1.spawnPosition.set(this.spawnPosition);
      class="kw">return var1;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "SpawnMarkerEntity{spawnMarkerId='"
         + this.spawnMarkerId
         + "', cachedMarker="
         + this.cachedMarker
         + ", respawnCounter="
         + this.respawnCounter
         + ", gameTimeRespawn="
         + this.gameTimeRespawn
         + ", spawnAfter="
         + this.spawnAfter
         + ", spawnCount="
         + this.spawnCount
         + ", spawnLostTimeoutCounter="
         + this.spawnLostTimeoutCounter
         + ", failedSpawns="
         + this.failedSpawns
         + ", context="
         + this.context
         + ", spawnPosition="
         + this.spawnPosition
         + ", storedFlock="
         + this.storedFlock
         + "} "
         + super.toString();
   }

   class="kw">public class="kw">static Model getModel(@Nonnull SpawnMarker var0) {
      String var1 = var0.getModel();
      ModelAsset var2 = null;
      if (var1 != null && !var1.isEmpty()) {
         var2 = ModelAsset.getAssetMap().getAsset(var1);
      }

      Model var3;
      if (var2 == null) {
         var3 = SpawningPlugin.get().getSpawnMarkerModel();
      } else {
         var3 = Model.createUnitScaleModel(var2);
      }

      class="kw">return var3;
   }

   class="kw">private enum FailReason {
      INVALID_ROLE,
      NONEXISTENT_ROLE,
      FAILED_ROLE_VALIDATION,
      NO_ROOM,
      NO_VALID_SPAWN_POSITION,
      NO_MOVEMENT_MODES,
      MOVEMENT_MODE_REJECTED,
      TOO_HIGH;

      FailReason() {
      }
   }
}