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

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.codec.validation.Validators;
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.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.StateMappingHelper;
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 it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.Arrays;
class="kw">import javax.annotation.Nonnull;

class="kw">public class StateEvaluator class="kw">extends Evaluator<StateOption> class="kw">implements Component<EntityStore> {
   class="kw">public class="kw">static class="kw">final BuilderCodec<StateEvaluator> CODEC = BuilderCodec.builder(StateEvaluator.class, StateEvaluator::new)
      .append(
         new KeyedCodec<>("Options", new ArrayCodec<>(StateOption.CODEC, StateOption[]::new)), (var0, var1) -> var0.rawOptions = var1, var0 -> var0.rawOptions
      )
      .documentation("The list of state options to evaluate.")
      .addValidator(Validators.nonNull())
      .addValidator(Validators.nonEmptyArray())
      .add()
      .<Double>append(new KeyedCodec<>("ExecutionFrequency", Codec.DOUBLE), (var0, var1) -> var0.executeFrequency = var1, var0 -> var0.executeFrequency)
      .documentation("The frequency with which the state evaluator should be run.")
      .addValidator(Validators.greaterThan(0.0))
      .add()
      .<Double>append(new KeyedCodec<>("StateChangeCooldown", Codec.DOUBLE), (var0, var1) -> var0.stateChangeCooldown = var1, var0 -> var0.stateChangeCooldown)
      .documentation("The delay before performing the next state evaluation after a successful class="kw">switch to another state.")
      .addValidator(Validators.greaterThan(0.0))
      .add()
      .<Double>append(new KeyedCodec<>("MinimumConsideredUtility", Codec.DOUBLE), (var0, var1) -> var0.minimumUtility = var1, var0 -> var0.minimumUtility)
      .documentation("The minimum utility value to consider when selecting from evaluated options.")
      .addValidator(Validators.greaterThanOrEqual(0.0))
      .add()
      .build();
   class="kw">protected StateOption[] rawOptions;
   class="kw">protected double executeFrequency = 0.1;
   class="kw">protected double stateChangeCooldown = 2.0;
   class="kw">protected double minimumUtility = 0.1;
   class="kw">private double timeUntilNextExecute;
   class="kw">private boolean active = true;
   class="kw">private class="kw">final EvaluationContext evaluationContext = new EvaluationContext();

   class="kw">public class="kw">static ComponentType<EntityStore, StateEvaluator> getComponentType() {
      class="kw">return NPCPlugin.get().getStateEvaluatorComponentType();
   }

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

   class="kw">public boolean isActive() {
      class="kw">return this.active;
   }

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

   @Nonnull
   class="kw">public EvaluationContext getEvaluationContext() {
      class="kw">return this.evaluationContext;
   }

   class="kw">public void prepareOptions(@Nonnull StateMappingHelper var1) {
      if (this.options == null) {
         this.options = new ObjectArrayList(this.rawOptions.length);

         for (StateOption var5 : this.rawOptions) {
            var1.getAndPutSetterIndex(var5.getState(), var5.getSubState(), var5::setStateIndex);
            this.options.add(new StateEvaluator.SelfOptionHolder(var5));
         }
      }
   }

   class="kw">public boolean shouldExecute(double var1) {
      if ((this.timeUntilNextExecute -= var1) > 0.0) {
         class="kw">return false;
      }

      this.timeUntilNextExecute = this.executeFrequency;
      class="kw">return true;
   }

   class="kw">public void prepareEvaluationContext(@Nonnull EvaluationContext var1) {
      var1.setMinimumUtility(this.minimumUtility);
      var1.setMinimumWeightCoefficient(0.0);
      var1.setPredictability(1.0F);
   }

   class="kw">public void onStateSwitched() {
      this.timeUntilNextExecute = this.stateChangeCooldown;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "StateEvaluator{executeFrequency="
         + this.executeFrequency
         + ", stateChangeCooldown="
         + this.stateChangeCooldown
         + ", minimumUtility="
         + this.minimumUtility
         + ", rawOptions="
         + Arrays.toString(this.rawOptions)
         + "}";
   }

   @Nonnull
   @Override
   class="kw">public Component<EntityStore> clone() {
      StateEvaluator var1 = new StateEvaluator();
      var1.options = this.options;
      var1.rawOptions = this.rawOptions;
      var1.executeFrequency = this.executeFrequency;
      var1.stateChangeCooldown = this.stateChangeCooldown;
      var1.minimumUtility = this.minimumUtility;
      var1.timeUntilNextExecute = this.timeUntilNextExecute;
      var1.active = this.active;
      class="kw">return var1;
   }

   class="kw">public class SelfOptionHolder class="kw">extends Evaluator<StateOption>.OptionHolder {
      class="kw">public SelfOptionHolder(StateOption nullx) {
         super(nullx);
      }

      @Override
      class="kw">public double calculateUtility(int var1, @Nonnull ArchetypeChunk<EntityStore> var2, CommandBuffer<EntityStore> var3, @Nonnull EvaluationContext var4) {
         var4.setLastUsedNanos(this.lastUsedNanos);
         class="kw">return this.utility = ((StateOption)this.option).calculateUtility(var1, var2, var2.getReferenceTo(var1), var3, var4);
      }
   }
}