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

class="kw">import com.hypixel.hytale.builtin.npccombatactionevaluator.evaluator.combatactions.CombatActionOption;
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.map.MapCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.common.util.MapUtil;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.npc.decisionmaker.core.conditions.base.Condition;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.Map;
class="kw">import javax.annotation.Nonnull;

class="kw">public class CombatActionEvaluatorConfig {
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<CombatActionEvaluatorConfig> CODEC = BuilderCodec.builder(
         CombatActionEvaluatorConfig.class, CombatActionEvaluatorConfig::new
      )
      .appendInherited(
         new KeyedCodec<>("AvailableActions", new MapCodec<>(CombatActionOption.CHILD_ASSET_CODEC, Object2ObjectOpenHashMap::new)),
         (var0, var1) -> var0.availableActions = MapUtil.combineUnmodifiable(var0.availableActions, var1),
         var0 -> var0.availableActions,
         (var0, var1) -> var0.availableActions = var1.availableActions
      )
      .addValidator(Validators.nonNull())
      .addValidator(CombatActionOption.VALIDATOR_CACHE.getMapValueValidator())
      .documentation("A map of all available combat actions this NPC can take.")
      .add()
      .<Map>append(
         new KeyedCodec<>("ActionSets", new MapCodec<>(CombatActionEvaluatorConfig.ActionSet.CODEC, Object2ObjectOpenHashMap::new)),
         (var0, var1) -> var0.actionSets = var1,
         var0 -> var0.actionSets
      )
      .addValidator(Validators.nonNull())
      .addValidator(Validators.nonEmptyMap())
      .documentation("A mapping of all combat substate names to the basic attacks and abilities that should be used in them.")
      .add()
      .<String[]>appendInherited(
         new KeyedCodec<>("RunConditions", Condition.CHILD_ASSET_CODEC_ARRAY),
         (var0, var1) -> var0.runConditions = var1,
         var0 -> var0.runConditions,
         (var0, var1) -> var0.runConditions = var1.runConditions
      )
      .addValidator(Validators.nonNull())
      .addValidator(Validators.nonEmptyArray())
      .addValidator(Condition.VALIDATOR_CACHE.getArrayValidator())
      .documentation("The list of conditions that determine whether or not the combat action evaluator should run.")
      .add()
      .<Double>appendInherited(
         new KeyedCodec<>("MinRunUtility", Codec.DOUBLE),
         (var0, var1) -> var0.minRunUtility = var1,
         var0 -> var0.minRunUtility,
         (var0, var1) -> var0.minRunUtility = var1.minRunUtility
      )
      .addValidator(Validators.range(0.5, 1.0))
      .documentation("The minimum utility score required to be returned from the RunConditions to trigger a new run of the combat action evaluator.")
      .add()
      .<Double>appendInherited(
         new KeyedCodec<>("MinActionUtility", Codec.DOUBLE),
         (var0, var1) -> var0.minActionUtility = var1,
         var0 -> var0.minActionUtility,
         (var0, var1) -> var0.minActionUtility = var1.minActionUtility
      )
      .addValidator(Validators.range(0.0, 1.0))
      .documentation("The minimum utility score required for any individual combat action to be run.")
      .add()
      .<double[]>appendInherited(
         new KeyedCodec<>("PredictabilityRange", Codec.DOUBLE_ARRAY),
         (var0, var1) -> var0.predictabilityRange = var1,
         var0 -> var0.predictabilityRange,
         (var0, var1) -> var0.predictabilityRange = var1.predictabilityRange
      )
      .addValidator(Validators.doubleArraySize(2))
      .addValidator(Validators.weaklyMonotonicSequentialDoubleArrayValidator())
      .documentation("A random range from which to pick the NPC's predictability factor.")
      .add()
      .build();
   @Nonnull
   class="kw">private class="kw">static class="kw">final double[] DEFAULT_PREDICTABILITY_RANGE = new double[]{1.0, 1.0};
   class="kw">protected Map<String, String> availableActions = Collections.emptyMap();
   class="kw">protected Map<String, CombatActionEvaluatorConfig.ActionSet> actionSets;
   class="kw">protected String[] runConditions;
   class="kw">protected double minRunUtility = 0.8;
   class="kw">protected double minActionUtility = 0.1;
   class="kw">protected double[] predictabilityRange = DEFAULT_PREDICTABILITY_RANGE;

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

   class="kw">public Map<String, String> getAvailableActions() {
      class="kw">return this.availableActions;
   }

   class="kw">public Map<String, CombatActionEvaluatorConfig.ActionSet> getActionSets() {
      class="kw">return this.actionSets;
   }

   class="kw">public String[] getRunConditions() {
      class="kw">return this.runConditions;
   }

   class="kw">public double getMinRunUtility() {
      class="kw">return this.minRunUtility;
   }

   class="kw">public double getMinActionUtility() {
      class="kw">return this.minActionUtility;
   }

   class="kw">public double[] getPredictabilityRange() {
      class="kw">return this.predictabilityRange;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "CombatActionEvaluatorConfig{availableActions="
         + this.availableActions
         + ", actionSets="
         + this.actionSets
         + ", runConditions="
         + Arrays.toString(this.runConditions)
         + ", minRunUtility="
         + this.minRunUtility
         + ", minActionUtility="
         + this.minActionUtility
         + ", predictabilityRange="
         + Arrays.toString(this.predictabilityRange)
         + "}";
   }

   class="kw">public class="kw">static class ActionSet {
      @Nonnull
      class="kw">public class="kw">static class="kw">final BuilderCodec<CombatActionEvaluatorConfig.ActionSet> CODEC = BuilderCodec.builder(
            CombatActionEvaluatorConfig.ActionSet.class, CombatActionEvaluatorConfig.ActionSet::new
         )
         .append(
            new KeyedCodec<>("BasicAttacks", CombatActionEvaluatorConfig.BasicAttacks.CODEC),
            (var0, var1) -> var0.basicAttacks = var1,
            var0 -> var0.basicAttacks
         )
         .documentation("The basic attacks to be used in this combat substate.")
         .add()
         .<String[]>append(new KeyedCodec<>("Actions", Codec.STRING_ARRAY), (var0, var1) -> var0.combatActions = var1, var0 -> var0.combatActions)
         .addValidator(Validators.nonNull())
         .addValidator(Validators.nonEmptyArray())
         .documentation("A list of available actions that should be used in this combat substate, mapped from AvailableActions.")
         .add()
         .build();
      class="kw">protected CombatActionEvaluatorConfig.BasicAttacks basicAttacks;
      class="kw">protected String[] combatActions;

      class="kw">protected ActionSet() {
      }

      class="kw">public CombatActionEvaluatorConfig.BasicAttacks getBasicAttacks() {
         class="kw">return this.basicAttacks;
      }

      class="kw">public String[] getCombatActions() {
         class="kw">return this.combatActions;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "ActionSet{basicAttacks=" + this.basicAttacks + ", combatActions=" + Arrays.toString(this.combatActions) + "}";
      }
   }

   class="kw">public class="kw">static class BasicAttacks {
      @Nonnull
      class="kw">public class="kw">static class="kw">final BuilderCodec<CombatActionEvaluatorConfig.BasicAttacks> CODEC = BuilderCodec.builder(
            CombatActionEvaluatorConfig.BasicAttacks.class, CombatActionEvaluatorConfig.BasicAttacks::new
         )
         .append(new KeyedCodec<>("Attacks", RootInteraction.CHILD_ASSET_CODEC_ARRAY), (var0, var1) -> var0.attacks = var1, var0 -> var0.attacks)
         .addValidator(Validators.nonNull())
         .addValidator(Validators.nonEmptyArray())
         .addValidator(RootInteraction.VALIDATOR_CACHE.getArrayValidator())
         .documentation("The sequence of basic attacks to be used.")
         .add()
         .<Boolean>append(new KeyedCodec<>("Randomise", Codec.BOOLEAN), (var0, var1) -> var0.randomise = var1, var0 -> var0.randomise)
         .documentation("Whether or not the basic attacks should be executed randomly, or run in the order they were defined in.")
         .add()
         .<Double>append(new KeyedCodec<>("MaxRange", Codec.DOUBLE), (var0, var1) -> {
            var0.maxRange = var1;
            var0.maxRangeSquared = var1 * var1;
         }, var0 -> var0.maxRange)
         .addValidator(Validators.nonNull())
         .addValidator(Validators.greaterThan(0.0))
         .documentation("How close a target needs to be to use a basic attack against them.")
         .add()
         .<Float>append(new KeyedCodec<>("Timeout", Codec.FLOAT), (var0, var1) -> var0.timeout = var1, var0 -> var0.timeout)
         .addValidator(Validators.greaterThan(0.0F))
         .documentation("How long before giving up if a target moves out of range while preparing to execute a basic attack.")
         .add()
         .<double[]>append(new KeyedCodec<>("CooldownRange", Codec.DOUBLE_ARRAY), (var0, var1) -> var0.cooldownRange = var1, var0 -> var0.cooldownRange)
         .addValidator(Validators.nonNull())
         .addValidator(Validators.doubleArraySize(2))
         .addValidator(Validators.weaklyMonotonicSequentialDoubleArrayValidator())
         .documentation("A random range to pick a cooldown between basic attacks from.")
         .add()
         .<Map>appendInherited(
            new KeyedCodec<>("InteractionVars", new MapCodec<>(RootInteraction.CHILD_ASSET_CODEC, Object2ObjectOpenHashMap::new)),
            (var0, var1) -> var0.interactionVars = var1,
            var0 -> var0.interactionVars,
            (var0, var1) -> var0.interactionVars = var1.interactionVars
         )
         .addValidator(RootInteraction.VALIDATOR_CACHE.getMapValueValidator())
         .documentation("Interaction vars to modify the values in the interaction itself.")
         .add()
         .<Boolean>appendInherited(
            new KeyedCodec<>("DamageFriendlies", Codec.BOOLEAN),
            (var0, var1) -> var0.damageFriendlies = var1,
            var0 -> var0.damageFriendlies,
            (var0, var1) -> var0.damageFriendlies = var1.damageFriendlies
         )
         .documentation("Whether or not basic attacks should be able to damage friendly targets.")
         .add()
         .<Boolean>appendInherited(
            new KeyedCodec<>("UseProjectedDistance", Codec.BOOLEAN),
            (var0, var1) -> var0.useProjectedDistance = var1,
            var0 -> var0.useProjectedDistance,
            (var0, var1) -> var0.useProjectedDistance = var1.useProjectedDistance
         )
         .documentation("Whether to use projected distance instead of 3D distance for checking if in range of basic attacks.")
         .add()
         .build();
      class="kw">protected String[] attacks;
      class="kw">protected boolean randomise;
      class="kw">protected double maxRange;
      class="kw">protected double maxRangeSquared;
      class="kw">protected float timeout = 2.0F;
      class="kw">protected double[] cooldownRange;
      class="kw">protected Map<String, String> interactionVars = Collections.emptyMap();
      class="kw">protected boolean damageFriendlies;
      class="kw">protected boolean useProjectedDistance;

      class="kw">protected BasicAttacks() {
      }

      class="kw">public String[] getAttacks() {
         class="kw">return this.attacks;
      }

      class="kw">public boolean isRandom() {
         class="kw">return this.randomise;
      }

      class="kw">public double getMaxRange() {
         class="kw">return this.maxRange;
      }

      class="kw">public double getMaxRangeSquared() {
         class="kw">return this.maxRangeSquared;
      }

      class="kw">public float getTimeout() {
         class="kw">return this.timeout;
      }

      class="kw">public double[] getCooldownRange() {
         class="kw">return this.cooldownRange;
      }

      class="kw">public Map<String, String> getInteractionVars(InteractionContext var1) {
         class="kw">return this.interactionVars;
      }

      class="kw">public boolean isDamageFriendlies() {
         class="kw">return this.damageFriendlies;
      }

      class="kw">public boolean shouldUseProjectedDistance() {
         class="kw">return this.useProjectedDistance;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "BasicAttacks{attacks="
            + Arrays.toString(this.attacks)
            + ", randomise="
            + this.randomise
            + ", maxRange="
            + this.maxRange
            + ", maxRangeSquared="
            + this.maxRangeSquared
            + ", timeout="
            + this.timeout
            + ", cooldownRange="
            + Arrays.toString(this.cooldownRange)
            + ", interactionVars="
            + this.interactionVars
            + ", damageFriendlies="
            + this.damageFriendlies
            + ", useProjectedDistance="
            + this.useProjectedDistance
            + "}";
      }
   }
}