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

class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.config.CombatBalanceAsset;
class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.evaluator.CombatActionEvaluator;
class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.evaluator.CombatActionEvaluatorConfig;
class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.evaluator.combatactions.CombatActionOption;
class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.memory.DamageMemory;
class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.memory.TargetMemory;
class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.memory.TargetMemorySystems;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.Component;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
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.HolderSystem;
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.protocol.GameMode;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
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.interaction.InteractionModule;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.config.balancing.BalanceAsset;
class="kw">import com.hypixel.hytale.server.npc.decisionmaker.core.EvaluationContext;
class="kw">import com.hypixel.hytale.server.npc.decisionmaker.core.Evaluator;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.npc.instructions.ExecutionSupport;
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.support.CombatSupport;
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.systems.BalancingInitialisationSystem;
class="kw">import com.hypixel.hytale.server.npc.systems.RoleSystems;
class="kw">import com.hypixel.hytale.server.npc.valuestore.ValueStore;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import java.util.List;
class="kw">import java.util.Set;
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 CombatActionEvaluatorSystems {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();

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

   class="kw">public class="kw">static class CombatConstructionData class="kw">implements Component<EntityStore> {
      class="kw">protected String combatState;
      class="kw">protected int markedTargetSlot;
      class="kw">protected int minRangeSlot;
      class="kw">protected int maxRangeSlot;
      class="kw">protected int positioningAngleSlot;

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

      class="kw">public class="kw">static ComponentType<EntityStore, CombatActionEvaluatorSystems.CombatConstructionData> getComponentType() {
         class="kw">return NPCCombatActionEvaluatorPlugin.get().getCombatConstructionDataComponentType();
      }

      class="kw">public String getCombatState() {
         class="kw">return this.combatState;
      }

      class="kw">public void setCombatState(String var1) {
         if (this.combatState != null && !this.combatState.equals(var1)) {
            throw new IllegalStateException("Cannot have more than one combat state in an NPC!");
         }

         this.combatState = var1;
      }

      class="kw">public int getMarkedTargetSlot() {
         class="kw">return this.markedTargetSlot;
      }

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

      class="kw">public int getMinRangeSlot() {
         class="kw">return this.minRangeSlot;
      }

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

      class="kw">public int getMaxRangeSlot() {
         class="kw">return this.maxRangeSlot;
      }

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

      class="kw">public int getPositioningAngleSlot() {
         class="kw">return this.positioningAngleSlot;
      }

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

      @Nonnull
      @Override
      class="kw">public Component<EntityStore> clone() {
         CombatActionEvaluatorSystems.CombatConstructionData var1 = new CombatActionEvaluatorSystems.CombatConstructionData();
         var1.combatState = this.combatState;
         var1.markedTargetSlot = this.markedTargetSlot;
         var1.minRangeSlot = this.minRangeSlot;
         var1.maxRangeSlot = this.maxRangeSlot;
         var1.positioningAngleSlot = this.positioningAngleSlot;
         class="kw">return var1;
      }
   }

   class="kw">public class="kw">static class EvaluatorTick class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, CombatActionEvaluator> componentType;
      class="kw">private class="kw">final ComponentType<EntityStore, TargetMemory> targetMemoryComponentType;
      class="kw">private class="kw">final ComponentType<EntityStore, DamageMemory> damageMemoryComponentType;
      @Nullable
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, Player> playerComponentType;
      class="kw">private class="kw">final ComponentType<EntityStore, ValueStore> valueStoreComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType;
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public EvaluatorTick(
         ComponentType<EntityStore, CombatActionEvaluator> var1, ComponentType<EntityStore, TargetMemory> var2, ComponentType<EntityStore, DamageMemory> var3
      ) {
         this.componentType = var1;
         this.targetMemoryComponentType = var2;
         this.damageMemoryComponentType = var3;
         this.npcComponentType = NPCEntity.getComponentType();
         this.playerComponentType = Player.getComponentType();
         this.valueStoreComponentType = ValueStore.getComponentType();
         this.transformComponentType = TransformComponent.getComponentType();
         this.query = Archetype.of(var1, var2, this.npcComponentType, this.valueStoreComponentType, this.transformComponentType);
         this.dependencies = Set.of(
            new SystemDependency<>(Order.BEFORE, RoleSystems.PreBehaviourSupportTickSystem.class),
            new SystemDependency<>(Order.AFTER, TargetMemorySystems.Ticking.class)
         );
      }

      @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.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
      ) {
         NPCEntity var6 = var3.getComponent(var2, this.npcComponentType);
         assert var6 != null;
         Role var7 = var6.getRole();
         if (!var3.getArchetype().contains(DeathComponent.getComponentType())) {
            CombatActionEvaluator var8 = var3.getComponent(var2, this.componentType);
            assert var8 != null;
            var8.tickBasicAttackCoolDown(var1);
            StateSupport var9 = var3.getComponent(var2, StateSupport.getComponentType());
            assert var9 != null;
            MarkedEntitySupport var10 = var3.getComponent(var2, MarkedEntitySupport.getComponentType());
            assert var10 != null;
            int var11 = var9.getStateIndex();
            if (var11 != var8.getRunInState()) {
               if (var8.getCurrentAction() != null) {
                  var8.completeCurrentAction(true, true);
                  var8.clearPrimaryTarget();
                  var10.clearMarkedEntity(var8.getMarkedTargetSlot());
                  HytaleLogger.Api var31 = CombatActionEvaluatorSystems.LOGGER.at(Level.FINEST);
                  if (var31.isEnabled()) {
                     var31.log("%s: Leaving combat", var3.getReferenceTo(var2));
                  }
               }

               DamageMemory var32 = var3.getComponent(var2, this.damageMemoryComponentType);
               if (var32 != null) {
                  var32.clearTotalDamage();
               }
            } else {
               CombatSupport var12 = var3.getComponent(var2, CombatSupport.getComponentType());
               assert var12 != null;
               if (!var12.isExecutingAttack()) {
                  ValueStore var13 = var3.getComponent(var2, this.valueStoreComponentType);
                  assert var13 != null;
                  double[] var14 = var8.consumePostExecutionDistanceRange();
                  if (var14 != null) {
                     var13.storeDouble(var8.getMinRangeSlot(), var14[0]);
                     var13.storeDouble(var8.getMaxRangeSlot(), var14[1]);
                  }

                  int var15 = var9.getSubStateIndex();
                  CombatActionEvaluatorConfig.BasicAttacks var16 = var8.getBasicAttacks(var15);
                  if (var16 != null) {
                     var8.setCurrentBasicAttackSet(var15, var16);
                     String var17 = var8.getCurrentBasicAttack();
                     if (var17 != null) {
                        if (!var8.tickBasicAttackTimeout(var1)) {
                           var10.setMarkedEntity(var8.getMarkedTargetSlot(), var8.getBasicAttackTarget());
                           class="kw">return;
                        }

                        var8.clearCurrentBasicAttack();
                        HytaleLogger.Api var18 = CombatActionEvaluatorSystems.LOGGER.at(Level.FINEST);
                        if (var18.isEnabled()) {
                           var18.log("%s: Basic attack timed out", var3.getReferenceTo(var2));
                        }
                     }

                     if (var8.canUseBasicAttack(var2, var3, var5)) {
                        MotionController var34 = var7.getActiveMotionController();
                        TransformComponent var19 = var3.getComponent(var2, this.transformComponentType);
                        assert var19 != null;
                        Vector3d var20 = var19.getPosition();
                        Ref var21 = null;
                        CombatActionEvaluator.CombatOptionHolder var22 = var8.getCurrentAction();
                        if (var22 == null || ((CombatActionOption)var22.getOption()).getActionTarget() != CombatActionOption.Target.Friendly) {
                           Ref var23 = var8.getPrimaryTarget();
                           if (var23 != null && var23.isValid()) {
                              TransformComponent var24 = var5.getComponent(var23, this.transformComponentType);
                              assert var24 != null;
                              Vector3d var25 = var24.getPosition();
                              if (var34.getSquaredDistance(var20, var25, var16.shouldUseProjectedDistance()) < var16.getMaxRangeSquared()) {
                                 var21 = var23;
                              }
                           }
                        }

                        if (var21 == null) {
                           TargetMemory var42 = var3.getComponent(var2, this.targetMemoryComponentType);
                           assert var42 != null;
                           var21 = var42.getClosestHostile();
                        }

                        if (var21 != null) {
                           TransformComponent var43 = var5.getComponent(var21, this.transformComponentType);
                           assert var43 != null;
                           Vector3d var44 = var43.getPosition();
                           if (var34.getSquaredDistance(var20, var44, var16.shouldUseProjectedDistance()) < var16.getMaxRangeSquared()) {
                              var8.setBasicAttackTarget(var21);
                              var10.setMarkedEntity(var8.getMarkedTargetSlot(), var21);
                              String[] var46 = var16.getAttacks();
                              String var26;
                              if (var16.isRandom()) {
                                 var26 = var46[RandomExtra.randomRange(var46.length)];
                              } else {
                                 int var27 = var8.getNextBasicAttackIndex();
                                 var26 = var46[var27];
                                 if (++var27 >= var46.length) {
                                    var27 = 0;
                                 }

                                 var8.setNextBasicAttackIndex(var27);
                              }

                              var8.setCurrentBasicAttack(var26, var16.isDamageFriendlies(), var16::getInteractionVars);
                              var8.setBasicAttackTimeout(var16.getTimeout());
                              HytaleLogger.Api var50 = CombatActionEvaluatorSystems.LOGGER.at(Level.FINEST);
                              if (var50.isEnabled()) {
                                 var50.log("%s: Started basic attack %s", var3.getReferenceTo(var2), var26);
                              }
                           }
                        }
                     }
                  } else {
                     var8.setCurrentBasicAttackSet(var15, null);
                  }

                  CombatActionEvaluator.CombatOptionHolder var33 = var8.getCurrentAction();
                  if (var33 != null) {
                     if (((CombatActionOption)var33.getOption()).getActionTarget() == CombatActionOption.Target.Self) {
                        class="kw">return;
                     }

                     if (!var8.hasTimedOut(var1)) {
                        Ref var35 = var8.getPrimaryTarget();
                        if (var35 != null && var35.isValid() && !var5.getArchetype(var35).contains(DeathComponent.getComponentType())) {
                           Player var38 = var5.getComponent(var35, this.playerComponentType);
                           if (var38 == null || var38.getGameMode() == GameMode.Adventure) {
                              var10.setMarkedEntity(var8.getMarkedTargetSlot(), var35);
                              class="kw">return;
                           }
                        }
                     }

                     var8.terminateCurrentAction();
                     var8.clearPrimaryTarget();
                     var10.clearMarkedEntity(var8.getMarkedTargetSlot());
                     HytaleLogger.Api var36 = CombatActionEvaluatorSystems.LOGGER.at(Level.FINEST);
                     if (var36.isEnabled()) {
                        var36.log("%s: Lost current action target or timed out", var3.getReferenceTo(var2));
                     }
                  }

                  if (var8.getOptionsBySubState().containsKey(var15)) {
                     EvaluationContext var37 = var8.getEvaluationContext();
                     double var39 = var8.getMinRunUtility();
                     var37.setMinimumUtility(var39);
                     var37.setMinimumWeightCoefficient(0.0);
                     var37.setLastUsedNanos(var8.getLastRunNanos());
                     CombatActionEvaluator.RunOption var40 = var8.getRunOption();
                     double var41 = var40.calculateUtility(var2, var3, var8.getPrimaryTarget(), var5, var37);
                     var37.reset();
                     if (!(var41 < var39)) {
                        Int2ObjectMap var45 = var8.getOptionsBySubState();
                        List var47 = (List<Evaluator<CombatActionOption>.OptionHolder>)var45.get(var15);
                        var8.setActiveOptions(var47);
                        ExecutionSupport var48 = var7.acquireExecutionSupport(var3.getReferenceTo(var2), var5);

                        try {
                           var8.selectNextCombatAction(var2, var3, var5, var48, var13);
                        } class="kw">finally {
                           var48.clearForReuse();
                        }

                        var8.setLastRunNanos(System.nanoTime());
                        DamageMemory var51 = var3.getComponent(var2, this.damageMemoryComponentType);
                        if (var51 != null) {
                           var51.clearRecentDamage();
                        }

                        HytaleLogger.Api var28 = CombatActionEvaluatorSystems.LOGGER.at(Level.FINEST);
                        if (var28.isEnabled()) {
                           var28.log("%s: Has run the combat action evaluator", var3.getReferenceTo(var2));
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class OnAdded class="kw">extends HolderSystem<EntityStore> {
      @Nullable
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType = NPCEntity.getComponentType();
      class="kw">private class="kw">final ComponentType<EntityStore, CombatActionEvaluatorSystems.CombatConstructionData> combatConstructionDataComponentType;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public OnAdded(ComponentType<EntityStore, CombatActionEvaluatorSystems.CombatConstructionData> var1) {
         this.combatConstructionDataComponentType = var1;
         this.dependencies = Set.of(new SystemDependency<>(Order.AFTER, BalancingInitialisationSystem.class));
         this.query = Query.and(var1, this.npcComponentType);
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
         NPCEntity var4 = var1.getComponent(this.npcComponentType);
         assert var4 != null;
         Role var5 = var4.getRole();
         if (var5 != null && var5.getBalanceAsset() != null) {
            BalanceAsset var6 = BalanceAsset.getAssetMap().getAsset(var5.getBalanceAsset());
            if (var6 class="kw">instanceof CombatBalanceAsset var7) {
               CombatActionEvaluatorSystems.CombatConstructionData var8 = var1.getComponent(this.combatConstructionDataComponentType);
               assert var8 != null;
               PositionCache var9 = var1.getComponent(PositionCache.getComponentType());
               assert var9 != null;
               StateSupport var10 = var1.getComponent(StateSupport.getComponentType());
               assert var10 != null;
               CombatActionEvaluator var11 = new CombatActionEvaluator(var10, var7.getEvaluatorConfig(), var8);
               var11.setupNPC(var1);
               var9.addExternalPositionCacheRegistration(var11::setupNPC);
               var1.putComponent(TargetMemory.getComponentType(), new TargetMemory(var7.getTargetMemoryDuration()));
               var1.putComponent(CombatActionEvaluator.getComponentType(), var11);
               var1.ensureComponent(InteractionModule.get().getChainingDataComponent());
               var1.removeComponent(this.combatConstructionDataComponentType);
            }
         }
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3) {
      }

      @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;
      }
   }
}