class="kw">package com.hypixel.hytale.server.npc.systems;

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.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.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
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.system.RefSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.component.system.tick.TickingSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.server.core.entity.Frozen;
class="kw">import com.hypixel.hytale.server.core.modules.debug.DebugUtils;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.NewSpawnComponent;
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.ModelSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.TransformSystems;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
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.core.util.TargetUtil;
class="kw">import com.hypixel.hytale.server.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.components.StepComponent;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.MotionController;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.role.RoleDebugDisplay;
class="kw">import com.hypixel.hytale.server.npc.role.RoleDebugFlags;
class="kw">import com.hypixel.hytale.server.npc.role.support.CombatSupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.DebugSupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.DisplayNameSupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.EntitySupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.MarkedEntitySupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.PositionCache;
class="kw">import com.hypixel.hytale.server.npc.role.support.StateSupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.WorldSupport;
class="kw">import com.hypixel.hytale.server.npc.util.EntityDetectionUtil;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
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.Matrix4d;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3f;

class="kw">public class RoleSystems {
   class="kw">private class="kw">static class="kw">final ThreadLocal<List<Ref<EntityStore>>> ENTITY_LIST = ThreadLocal.withInitial(ReferenceArrayList::new);

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

   class="kw">public class="kw">static class BehaviourTickSystem class="kw">extends TickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, StepComponent> stepComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, Frozen> frozenComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NewSpawnComponent> newSpawnComponentType;

      class="kw">public BehaviourTickSystem(@Nonnull ComponentType<EntityStore, NPCEntity> var1, @Nonnull ComponentType<EntityStore, StepComponent> var2) {
         this.npcComponentType = var1;
         this.stepComponentType = var2;
         this.frozenComponentType = Frozen.getComponentType();
         this.newSpawnComponentType = NewSpawnComponent.getComponentType();
      }

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull Store<EntityStore> var3) {
         List var4 = RoleSystems.ENTITY_LIST.get();
         var3.forEachChunk(this.npcComponentType, (var1x, var2x) -> {
            for (int var3 = 0; var3 < var1x.size(); var3++) {
               var4.add(var1x.getReferenceTo(var3));
            }
         });
         World var5 = var3.getExternalData().getWorld();
         boolean var6 = var5.getWorldConfig().isAllNPCFrozen();

         for (Ref var8 : var4) {
            if (var8.isValid() && var3.getComponent(var8, this.newSpawnComponentType) == null) {
               float var9;
               if (var3.getComponent(var8, this.frozenComponentType) == null && !var6) {
                  var9 = var1;
               } else {
                  StepComponent var10 = var3.getComponent(var8, this.stepComponentType);
                  if (var10 == null) {
                     class="kw">continue;
                  }

                  var9 = var10.getTickLength();
               }

               NPCEntity var16 = var3.getComponent(var8, this.npcComponentType);
               assert var16 != null;

               try {
                  Role var11 = var16.getRole();
                  boolean var12 = NPCPlugin.get().isBenchmarkingRole();
                  if (var12) {
                     long var13 = System.nanoTime();
                     var11.tick(var8, var9, var3);
                     NPCPlugin.get().collectRoleTick(var11.getRoleIndex(), System.nanoTime() - var13);
                  } else {
                     var11.tick(var8, var9, var3);
                  }
               } catch (NullPointerException | IllegalArgumentException | IllegalStateException var15) {
                  ((HytaleLogger.Api)NPCPlugin.get().getLogger().at(Level.SEVERE).withCause(var15)).log("Failed to tick NPC: %s", var16.getRoleName());
                  var3.removeEntity(var8, RemoveReason.REMOVE);
               }
            }
         }

         var4.clear();
      }
   }

   class="kw">public class="kw">static class EntitySupportTickSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntitySupport> entitySupportComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, RoleSystems.BehaviourTickSystem.class));

      class="kw">public EntitySupportTickSystem(@Nonnull ComponentType<EntityStore, EntitySupport> var1) {
         this.entitySupportComponentType = var1;
      }

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

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

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

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

   class="kw">public class="kw">static class MarkedEntitySupportPostSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, MarkedEntitySupport> markedEntitySupportComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, SteeringSystem.class));

      class="kw">public MarkedEntitySupportPostSystem(@Nonnull ComponentType<EntityStore, MarkedEntitySupport> var1) {
         this.markedEntitySupportComponentType = var1;
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         MarkedEntitySupport var6 = var3.getComponent(var2, this.markedEntitySupportComponentType);
         assert var6 != null;
         var6.setTargetSlotToIgnoreForAvoidance(Integer.MIN_VALUE);
      }
   }

   class="kw">public class="kw">static class MarkedTargetRebindSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, MarkedEntitySupport> markedEntitySupportComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(
         new SystemDependency<>(Order.BEFORE, RoleSystems.PreBehaviourSupportTickSystem.class),
         new SystemDependency<>(Order.BEFORE, RoleSystems.BehaviourTickSystem.class)
      );

      class="kw">public MarkedTargetRebindSystem(@Nonnull ComponentType<EntityStore, MarkedEntitySupport> var1) {
         this.markedEntitySupportComponentType = var1;
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         MarkedEntitySupport var6 = var3.getComponent(var2, this.markedEntitySupportComponentType);
         assert var6 != null;
         var6.resolveRebinds(var4);
      }
   }

   class="kw">public class="kw">static class PositionCacheClearSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, PositionCache> positionCacheComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, SteeringSystem.class));

      class="kw">public PositionCacheClearSystem(@Nonnull ComponentType<EntityStore, PositionCache> var1) {
         this.positionCacheComponentType = var1;
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         PositionCache var6 = var3.getComponent(var2, this.positionCacheComponentType);
         assert var6 != null;
         var6.clear(var1);
      }
   }

   class="kw">public class="kw">static class PostBehaviourSupportTickSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(
         new SystemDependency<>(Order.AFTER, SteeringSystem.class), new SystemDependency<>(Order.BEFORE, TransformSystems.EntityTrackerUpdate.class)
      );

      class="kw">public PostBehaviourSupportTickSystem(@Nonnull ComponentType<EntityStore, NPCEntity> var1) {
         this.npcComponentType = var1;
         this.transformComponentType = TransformComponent.getComponentType();
         this.query = Query.and(var1, this.transformComponentType);
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         NPCEntity var6 = var3.getComponent(var2, this.npcComponentType);
         assert var6 != null;
         Ref var7 = var3.getReferenceTo(var2);
         Role var8 = var6.getRole();
         MotionController var9 = var8.getActiveMotionController();
         var9.clearOverrides();
         var9.constrainRotations(var8, var3.getComponent(var2, this.transformComponentType));
         CombatSupport var10 = var3.getComponent(var2, CombatSupport.getComponentType());
         assert var10 != null;
         var10.tick(var1);
         DisplayNameSupport var11 = var3.getComponent(var2, DisplayNameSupport.getComponentType());
         assert var11 != null;
         var11.handleNominatedDisplayName(var7, var5);
         var6.clearDamageData();
         var8.setReachedTerminalAction(false);
      }
   }

   class="kw">public class="kw">static class PreBehaviourSupportTickSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, DeathComponent> deathComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public PreBehaviourSupportTickSystem(@Nonnull ComponentType<EntityStore, NPCEntity> var1) {
         this.npcComponentType = var1;
         this.deathComponentType = DeathComponent.getComponentType();
         this.dependencies = Set.of(new SystemDependency<>(Order.BEFORE, RoleSystems.BehaviourTickSystem.class));
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         NPCEntity var6 = var3.getComponent(var2, this.npcComponentType);
         assert var6 != null;
         MarkedEntitySupport var7 = var3.getComponent(var2, MarkedEntitySupport.getComponentType());
         assert var7 != null;
         Ref[] var8 = var7.getEntityTargets();

         for (int var9 = 0; var9 < var8.length; var9++) {
            Ref var10 = var8[var9];
            if (var10 != null && !var7.isRebindSlot(var9)) {
               if (!var10.isValid()) {
                  var8[var9] = null;
               } else if (!EntityDetectionUtil.isDetectableByNPCs(var10, var5)) {
                  var8[var9] = null;
               } else {
                  DeathComponent var11 = var5.getComponent(var10, this.deathComponentType);
                  if (var11 != null) {
                     var8[var9] = null;
                  }
               }
            }
         }

         Role var12 = var6.getRole();
         Ref var13 = var3.getReferenceTo(var2);
         var12.clearOnceIfNeeded(var13, var5);
         var12.getBodySteering().clear();
         var12.getHeadSteering().clear();
         var12.getIgnoredEntitiesForAvoidance().clear();
         var6.invalidateCachedHorizontalSpeedMultiplier();
      }
   }

   class="kw">public class="kw">static class RoleActivateSystem class="kw">extends RefSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, ModelComponent> modelComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, BoundingBox> boundingBoxComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public RoleActivateSystem(@Nonnull ComponentType<EntityStore, NPCEntity> var1) {
         this.npcComponentType = var1;
         this.modelComponentType = ModelComponent.getComponentType();
         this.boundingBoxComponentType = BoundingBox.getComponentType();
         this.query = Query.and(var1, this.modelComponentType, this.boundingBoxComponentType);
         this.dependencies = Set.of(
            new SystemDependency<>(Order.AFTER, BalancingInitialisationSystem.class), new SystemDependency<>(Order.AFTER, ModelSystems.ModelSpawned.class)
         );
      }

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

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

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         NPCEntity var5 = var3.getComponent(var1, this.npcComponentType);
         assert var5 != null;
         Role var6 = var5.getRole();
         StateSupport.get(var1, var4).activate();
         DebugSupport var7 = DebugSupport.get(var1, var4);
         var7.notifyDebugFlagsListeners(var7.getDebugFlags());
         var7.setDebugFlags(var7.getDebugFlags());
         ModelComponent var8 = var3.getComponent(var1, this.modelComponentType);
         assert var8 != null;
         BoundingBox var9 = var3.getComponent(var1, this.boundingBoxComponentType);
         assert var9 != null;
         var6.updateMotionControllers(var1, var8.getModel(), var9.getBoundingBox(), var4);
         var6.clearOnce(var1, var4);
         String var10 = var5.getActiveMotionControllerName();
         if (var10 != null && var6.hasMotionController(var10)) {
            var6.setActiveMotionController(var1, var5, var10, var4);
         } else {
            var6.activateInitialMotionController(var1, var4, var5);
         }

         var6.getActiveMotionController().activate();
         var4.ensureComponent(var1, InteractionModule.get().getChainingDataComponent());
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         NPCEntity var5 = var3.getComponent(var1, this.npcComponentType);
         if (var5 != null) {
            Role var6 = var5.getRole();
            if (var6 != null) {
               MotionController var7 = var6.getActiveMotionController();
               if (var7 != null) {
                  var7.deactivate();
               }

               WorldSupport.get(var1, var4).resetAllBlockSensors(var1);
            }
         }
      }
   }

   class="kw">public class="kw">static class RoleDebugSystem class="kw">extends SteppableTickingSystem {
      class="kw">private class="kw">static class="kw">final float DEBUG_SHAPE_TIME = 0.1F;
      class="kw">private class="kw">static class="kw">final float SENSOR_VIS_OPACITY = 0.4F;
      class="kw">private class="kw">static class="kw">final double FULL_CIRCLE_EPSILON = 0.01;
      class="kw">private class="kw">static class="kw">final double DEFAULT_DEBUG_MID_HEIGHT = 1.0;
      class="kw">private class="kw">static class="kw">final float LEASH_SPHERE_RADIUS = 0.3F;
      class="kw">private class="kw">static class="kw">final float LEASH_RING_OUTER_RADIUS = 0.5F;
      class="kw">private class="kw">static class="kw">final float LEASH_RING_INNER_RADIUS = 0.4F;
      class="kw">private class="kw">static class="kw">final float NPC_RING_THICKNESS = 0.1F;
      class="kw">private class="kw">static class="kw">final float NPC_RING_OFFSET = 0.1F;
      class="kw">private class="kw">static class="kw">final float LEASH_LINE_THICKNESS = 0.05F;
      class="kw">private class="kw">static class="kw">final double PATH_WAYPOINT_SPHERE_SIZE = 0.25;
      class="kw">private class="kw">static class="kw">final double PATH_CURRENT_TARGET_SPHERE_SIZE = 0.35;
      class="kw">private class="kw">static class="kw">final double PATH_END_NODE_SPHERE_SIZE = 0.4;
      class="kw">private class="kw">static class="kw">final double PATH_SPHERE_Y_OFFSET = 0.5;
      class="kw">private class="kw">static class="kw">final double PATH_LINE_THICKNESS = 0.05;
      class="kw">private class="kw">static class="kw">final double PATH_NPC_LINE_THICKNESS = 0.08;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public RoleDebugSystem(@Nonnull ComponentType<EntityStore, NPCEntity> var1, @Nonnull Set<Dependency<EntityStore>> var2) {
         this.npcComponentType = var1;
         this.dependencies = var2;
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         DebugSupport var6 = var3.getComponent(var2, DebugSupport.getComponentType());
         assert var6 != null;
         NPCEntity var7 = var3.getComponent(var2, this.npcComponentType);
         Role var8 = var7 != null ? var7.getRole() : null;
         if (var7 == null || var8 != null) {
            RoleDebugDisplay var9 = var6.getDebugDisplay();
            if (var9 != null) {
               var9.display(var8, var2, var3, var5);
            }

            if (var6.isDebugFlagSet(RoleDebugFlags.VisMarkedTargets)) {
               renderMarkedTargetArrows(var2, var3, var5);
            }

            boolean var10 = var6.hasSensorVisData();
            boolean var11 = var6.isDebugFlagSet(RoleDebugFlags.VisLeashPosition);
            boolean var12 = var6.isVisPath() && var6.hasPathVisData();
            if (var10 || var11 || var12) {
               Ref var13 = var3.getReferenceTo(var2);
               TransformComponent var14 = var3.getComponent(var2, TransformComponent.getComponentType());
               assert var14 != null;
               BoundingBox var15 = var3.getComponent(var2, BoundingBox.getComponentType());
               World var16 = var5.getExternalData().getWorld();
               if (var10) {
                  renderSensorVisualization(var6, var13, var14, var15, var16, var5);
               }

               if (var11 && var7 != null && var15 != null) {
                  renderLeashPositionVisualization(var7, var13, var14, var15, var16);
               }

               if (var12) {
                  renderPathVisualization(var6, var14, var15, var16);
               }
            }
         }
      }

      class="kw">private class="kw">static void renderMarkedTargetArrows(int var0, @Nonnull ArchetypeChunk<EntityStore> var1, @Nonnull CommandBuffer<EntityStore> var2) {
         Ref var3 = var1.getReferenceTo(var0);
         Transform var4 = TargetUtil.getLook(var3, var2);
         Vector3d var5 = var4.getPosition();
         World var6 = var2.getExternalData().getWorld();
         MarkedEntitySupport var7 = MarkedEntitySupport.get(var3, var2);
         Ref[] var8 = var7.getEntityTargets();

         for (int var9 = 0; var9 < var8.length; var9++) {
            Ref var10 = var8[var9];
            if (var10 != null && var10.isValid()) {
               Transform var11 = TargetUtil.getLook(var10, var2);
               Vector3d var12 = var11.getPosition();
               Vector3d var13 = new Vector3d(var12.x - var5.x, var12.y - var5.y, var12.z - var5.z);
               Vector3f var14 = DebugUtils.INDEXED_COLORS[var9 % DebugUtils.INDEXED_COLORS.length];
               DebugUtils.addArrow(var6, var5, var13, var14, 0.1F, 0);
            }
         }
      }

      class="kw">private class="kw">static void renderSensorVisualization(
         @Nonnull DebugSupport var0,
         @Nonnull Ref<EntityStore> var1,
         @Nonnull TransformComponent var2,
         @Nullable BoundingBox var3,
         @Nonnull World var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
         List var6 = var0.getSensorVisData();
         if (var6 != null) {
            Vector3d var7 = var2.getPosition();
            double var8 = var3 != null ? var3.getBoundingBox().max.y / 2.0 : 1.0;
            HeadRotation var10 = var5.getComponent(var1, HeadRotation.getComponentType());
            double var11 = var10 != null ? var10.getRotation().yaw() : var2.getRotation().yaw();
            var6.sort((var0x, var1x) -> Double.compare(var1x.range(), var0x.range()));
            double var13 = 0.1;

            for (int var15 = 0; var15 < var6.size(); var15++) {
               DebugSupport.SensorVisData var16 = var6.get(var15);
               Vector3f var17 = DebugUtils.INDEXED_COLORS[var16.colorIndex() % DebugUtils.INDEXED_COLORS.length];
               double var18 = var7.y + var8 + var15 * 0.1;
               if (var16.viewAngle() > 0.0 && var16.viewAngle() < 6.273185482025147) {
                  double var20 = -var11 + Math.PI;
                  DebugUtils.addSector(var4, var7.x, var18, var7.z, var20, var16.range(), var16.viewAngle(), var16.minRange(), var17, 0.4F, 0.1F, 0);
               } else {
                  DebugUtils.addDisc(var4, var7.x, var18, var7.z, var16.range(), var16.minRange(), var17, 0.4F, 0.1F, 0);
               }
            }

            Map var40 = var0.getEntityVisData();
            if (var40 != null) {
               double var41 = 0.3;
               double var42 = 0.3;
               double var43 = 2.0;

               for (Entry var23 : var40.entrySet()) {
                  Ref var24 = var23.getKey();
                  List var25 = var23.getValue();
                  if (!var25.isEmpty() && var24.isValid()) {
                     TransformComponent var26 = var5.getComponent(var24, TransformComponent.getComponentType());
                     if (var26 != null) {
                        Vector3d var27 = var26.getPosition();
                        BoundingBox var28 = var5.getComponent(var24, BoundingBox.getComponentType());
                        double var29 = var28 != null ? var28.getBoundingBox().max.y : 2.0;
                        double var31 = var29 + 0.3;
                        boolean var33 = false;

                        for (DebugSupport.EntityVisData var35 : var25) {
                           if (var35.matched()) {
                              var33 = true;
                              break;
                           }
                        }

                        int var44 = 0;

                        for (DebugSupport.EntityVisData var36 : var25) {
                           if (var36.matched()) {
                              Vector3f var37 = DebugUtils.INDEXED_COLORS[var36.sensorColorIndex() % DebugUtils.INDEXED_COLORS.length];
                              double var38 = var31 + var44 * 0.3;
                              DebugUtils.addSphere(var4, var27.x, var27.y + var38, var27.z, var37, 0.2, 0.1F);
                              var44++;
                           }
                        }

                        if (!var33) {
                           DebugUtils.addCube(var4, var27.x, var27.y + var31, var27.z, DebugUtils.COLOR_GRAY, 0.2, 0.1F);
                        }

                        DebugUtils.addLine(var4, var7.x, var7.y + var8, var7.z, var27.x, var27.y + var31, var27.z, DebugUtils.COLOR_GRAY, 0.03, 0.1F, 0);
                     }
                  }
               }
            }

            var0.clearSensorVisData();
         }
      }

      class="kw">private class="kw">static void renderLeashPositionVisualization(
         @Nonnull NPCEntity var0, @Nonnull Ref<EntityStore> var1, @Nonnull TransformComponent var2, @Nonnull BoundingBox var3, @Nonnull World var4
      ) {
         if (var0.requiresLeashPosition()) {
            Box var5 = var3.getBoundingBox();
            double var6 = var5.max.x - var5.min.x;
            double var8 = var5.max.z - var5.min.z;
            double var10 = Math.max(var6, var8) / 2.0 + 0.1F;
            double var12 = var10 - 0.1F;
            int var14 = Math.abs(var1.getIndex()) % DebugUtils.INDEXED_COLORS.length;
            Vector3f var15 = DebugUtils.INDEXED_COLORS[var14];
            Vector3d var16 = var0.getLeashPoint();
            DebugUtils.addSphere(var4, var16, var15, 0.3F, 0.1F);
            Vector3d var17 = var2.getPosition();
            double var18 = var5.max.y / 2.0;
            double var20 = var17.y + var18;
            double var22 = var17.x - var16.x;
            double var24 = var17.z - var16.z;
            double var26 = Math.sqrt(var22 * var22 + var24 * var24);
            if (var26 > 0.001) {
               double var28 = var20 - var16.y;
               double var30 = Math.atan2(var28, var26);
               double var32 = Math.atan2(var24, var22);
               addChainRing(var4, var16.x, var16.y, var16.z, 0.5, 0.4F, var32, -var30, var15);
               addChainRing(var4, var17.x, var20, var17.z, var10, var12, var32 + Math.PI, var30, var15);
               double var34 = var22 / var26;
               double var36 = var24 / var26;
               double var38 = Math.cos(var30);
               double var40 = Math.sin(var30);
               double var42 = var16.x + var34 * 0.5 * var38;
               double var44 = var16.y + var40 * 0.5;
               double var46 = var16.z + var36 * 0.5 * var38;
               double var48 = var17.x - var34 * var10 * var38;
               double var50 = var20 - var40 * var10;
               double var52 = var17.z - var36 * var10 * var38;
               DebugUtils.addLine(var4, var42, var44, var46, var48, var50, var52, var15, 0.05F, 0.1F, 0);
            } else {
               DebugUtils.addDisc(var4, var16.x, var16.y, var16.z, 0.5, 0.4F, var15, 0.8F, 0.1F, 0);
               DebugUtils.addDisc(var4, var17.x, var20, var17.z, var10, var12, var15, 0.8F, 0.1F, 0);
               DebugUtils.addLine(var4, var16.x, var16.y, var16.z, var17.x, var20, var17.z, var15, 0.05F, 0.1F, 0);
            }
         }
      }

      class="kw">private class="kw">static void addChainRing(
         @Nonnull World var0, double var1, double var3, double var5, double var7, double var9, double var11, double var13, @Nonnull Vector3f var15
      ) {
         Matrix4d var16 = new Matrix4d();
         var16.identity();
         var16.translate(var1, var3, var5);
         var16.rotate(-var11, 0.0, 1.0, 0.0);
         var16.rotate(-var13, 0.0, 0.0, 1.0);
         DebugUtils.addDisc(var0, var16, var7, var9, var15, 0.8F, 0.1F, 0);
      }

      class="kw">private class="kw">static void renderPathVisualization(@Nonnull DebugSupport var0, @Nonnull TransformComponent var1, @Nullable BoundingBox var2, @Nonnull World var3) {
         List var4 = var0.getPathVisData();
         if (var4 != null && !var4.isEmpty()) {
            Vector3d var5 = var1.getPosition();
            double var6 = var2 != null ? var2.getBoundingBox().middleY() : 1.0;
            double var8 = 0.0;
            double var10 = 0.0;
            double var12 = 0.0;
            boolean var14 = false;
            double var15 = 0.0;
            double var17 = 0.0;
            double var19 = 0.0;
            boolean var21 = false;
            boolean var22 = false;

            for (DebugSupport.PathWaypointVisData var24 : var4) {
               Vector3d var25 = var24.position();
               double var26 = var25.y + 0.5;
               Vector3f var28;
               double var29;
               if (var24.isEndNode()) {
                  var28 = DebugUtils.COLOR_MAGENTA;
                  var29 = 0.4;
                  if (var24.isCurrentTarget()) {
                     var15 = var25.x;
                     var17 = var26;
                     var19 = var25.z;
                     var21 = true;
                     var22 = var24.isSeekTarget();
                  }
               } else if (var24.isCurrentTarget()) {
                  var28 = DebugUtils.COLOR_CYAN;
                  var29 = 0.35;
                  var15 = var25.x;
                  var17 = var26;
                  var19 = var25.z;
                  var21 = true;
                  var22 = var24.isSeekTarget();
               } else {
                  var28 = DebugUtils.COLOR_LIME;
                  var29 = 0.25;
               }

               DebugUtils.addSphere(var3, var25.x, var26, var25.z, var28, var29, 0.1F);
               if (var14) {
                  DebugUtils.addLine(var3, var8, var10, var12, var25.x, var26, var25.z, DebugUtils.COLOR_GRAY, 0.05, 0.1F, 0);
               }

               var8 = var25.x;
               var10 = var26;
               var12 = var25.z;
               var14 = true;
            }

            if (var21) {
               double var31 = var5.y + var6;
               Vector3f var32 = var22 ? DebugUtils.COLOR_RED : DebugUtils.COLOR_YELLOW;
               DebugUtils.addLine(var3, var5.x, var31, var5.z, var15, var17, var19, var32, 0.08, 0.1F, 0);
            }
         }
      }
   }

   class="kw">public class="kw">static class StateSupportUpdateSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, StateSupport> stateSupportComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, RoleSystems.BehaviourTickSystem.class));

      class="kw">public StateSupportUpdateSystem(@Nonnull ComponentType<EntityStore, StateSupport> var1) {
         this.stateSupportComponentType = var1;
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         StateSupport var6 = var3.getComponent(var2, this.stateSupportComponentType);
         assert var6 != null;
         var6.update(var5);
      }
   }

   class="kw">public class="kw">static class WorldSupportTickSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, WorldSupport> worldSupportComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, RoleSystems.BehaviourTickSystem.class));

      class="kw">public WorldSupportTickSystem(@Nonnull ComponentType<EntityStore, WorldSupport> var1) {
         this.worldSupportComponentType = var1;
      }

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

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

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

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