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

class="kw">import com.google.gson.JsonElement;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
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.Builder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderCodecObjectHelper;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderCombatConfig;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderDescriptorState;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderFactory;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderInfo;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderObjectListHelper;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderObjectReferenceHelper;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderTemplateInteractionVars;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderValidationHelper;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.FeatureEvaluatorHelper;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.FeatureOverride;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.InstructionContextHelper;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.InstructionType;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.SupportConfigBuilder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.AssetArrayHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.AssetHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.BooleanHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.DoubleHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.EnumHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.FloatHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.IntHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.NumberArrayHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.StringArrayHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.StringHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.AssetValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleRangeValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleSequenceValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleSingleValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.IntRangeValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.IntSingleValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.StringArrayNoEmptyStringsValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.StringNotEmptyValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.StringNullOrNotEmptyValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.BlockSetExistsValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.ItemDropListExistsValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.ItemExistsValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.ModelExistsValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.ParticleSystemExistsValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.RootInteractionValidator;
class="kw">import com.hypixel.hytale.server.npc.config.balancing.BalanceAsset;
class="kw">import com.hypixel.hytale.server.npc.decisionmaker.stateevaluator.StateEvaluator;
class="kw">import com.hypixel.hytale.server.npc.instructions.Instruction;
class="kw">import com.hypixel.hytale.server.npc.movement.MovementMode;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.BuilderMotionControllerMapUtil;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.MotionController;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.builders.BuilderMotionControllerBase;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.role.SpawnEffect;
class="kw">import com.hypixel.hytale.server.npc.util.expression.ExecutionContext;
class="kw">import com.hypixel.hytale.server.npc.util.expression.Scope;
class="kw">import com.hypixel.hytale.server.npc.validators.NPCLoadTimeValidationHelper;
class="kw">import com.hypixel.hytale.server.spawning.ISpawnable;
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 java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Set;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class BuilderRole class="kw">extends SupportConfigBuilder<Role> class="kw">implements ISpawnableWithModel, SpawnEffect, RoleBuilder {
   class="kw">protected class="kw">static class="kw">final double[] DEFAULT_HEAD_PITCH_RANGE = new double[]{-89.0, 89.0};
   class="kw">protected String[] displayNames;
   class="kw">protected class="kw">final AssetHolder appearance = new AssetHolder();
   class="kw">protected class="kw">final AssetHolder dropListId = new AssetHolder();
   class="kw">protected class="kw">final IntHolder maxHealth = new IntHolder();
   class="kw">protected double inertia;
   class="kw">protected class="kw">final DoubleHolder knockbackScale = new DoubleHolder();
   class="kw">protected String opaqueBlockSet;
   class="kw">protected boolean applyAvoidance;
   class="kw">protected double entityAvoidanceStrength;
   class="kw">protected double collisionDistance;
   class="kw">protected double collisionForceFalloff;
   class="kw">protected double collisionRadius;
   class="kw">protected float collisionViewAngle;
   class="kw">protected class="kw">final DoubleHolder separationDistance = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationWeight = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationDistanceTarget = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationNearRadiusTarget = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationFarRadiusTarget = new DoubleHolder();
   class="kw">protected class="kw">final BooleanHolder applySeparation = new BooleanHolder();
   class="kw">protected class="kw">final BooleanHolder avoidanceFallCheck = new BooleanHolder();
   class="kw">protected class="kw">final EnumHolder<Role.AvoidanceMode> avoidanceMode = new EnumHolder<>();
   class="kw">protected class="kw">final EnumHolder<Role.SeparationMode> separationMode = new EnumHolder<>();
   class="kw">protected class="kw">final EnumHolder<FeatureOverride> featureOverrideOrientationHint = new EnumHolder<>();
   class="kw">protected class="kw">final EnumHolder<FeatureOverride> featureOverrideAlwaysSeparate = new EnumHolder<>();
   class="kw">protected class="kw">final EnumHolder<FeatureOverride> featureOverrideNormalizeDistances = new EnumHolder<>();
   class="kw">protected class="kw">final DoubleHolder separationSafeDistanceMultiplier = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationLegacySteeringStrength = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationPushSteeringStrength = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationPushDistanceWeightDefault = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationPushDistanceWeightTarget = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationPushDistanceWeightAttacker = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder separationPushSpeedScale = new DoubleHolder();
   class="kw">protected boolean stayInEnvironment;
   class="kw">protected String allowedEnvironments;
   class="kw">protected class="kw">final StringArrayHolder flockSpawnTypes = new StringArrayHolder();
   class="kw">protected class="kw">final BooleanHolder flockSpawnTypeRandom = new BooleanHolder();
   class="kw">protected class="kw">final StringArrayHolder flockAllowedRoles = new StringArrayHolder();
   class="kw">protected class="kw">final BooleanHolder canLeadFlock = new BooleanHolder();
   class="kw">protected class="kw">final FloatHolder spawnLockTime = new FloatHolder();
   class="kw">protected double flockWeightAlignment;
   class="kw">protected double flockWeightSeparation;
   class="kw">protected double flockWeightCohesion;
   class="kw">protected double flockInfluenceRange;
   class="kw">protected boolean corpseStaysInFlock;
   class="kw">protected class="kw">final BooleanHolder invulnerable = new BooleanHolder();
   class="kw">protected class="kw">final BooleanHolder breathesInAir = new BooleanHolder();
   class="kw">protected class="kw">final BooleanHolder breathesInWater = new BooleanHolder();
   class="kw">protected class="kw">final AssetArrayHolder hotbarItems = new AssetArrayHolder();
   class="kw">protected class="kw">final AssetArrayHolder offHandItems = new AssetArrayHolder();
   class="kw">protected class="kw">final AssetHolder inventoryItemsDropList = new AssetHolder();
   class="kw">protected class="kw">final IntHolder defaultOffHandSlot = new IntHolder();
   class="kw">protected boolean pickupDropOnDeath;
   class="kw">protected String[] armor;
   class="kw">protected class="kw">final DoubleHolder deathAnimationTime = new DoubleHolder();
   class="kw">protected class="kw">final AssetHolder deathParticles = new AssetHolder();
   class="kw">protected class="kw">final BooleanHolder dropDeathItemsInstantly = new BooleanHolder();
   class="kw">protected float despawnAnimationTime;
   @Nonnull
   class="kw">protected AssetHolder deathInteraction = new AssetHolder();
   class="kw">protected class="kw">final AssetHolder spawnParticles = new AssetHolder();
   class="kw">protected class="kw">final NumberArrayHolder spawnParticleOffset = new NumberArrayHolder();
   class="kw">protected class="kw">final StringHolder spawnParticlesTargetNode = new StringHolder();
   class="kw">protected class="kw">final BooleanHolder spawnParticlesDetached = new BooleanHolder();
   class="kw">protected double spawnViewDistance;
   class="kw">protected int inventorySlots;
   class="kw">protected int hotbarSlots;
   class="kw">protected int offHandSlots;
   class="kw">protected class="kw">final BuilderObjectReferenceHelper<Map<String, MotionController>> motionControllers = new BuilderObjectReferenceHelper<>(
      BuilderMotionControllerMapUtil.CLASS_REFERENCE, this
   );
   class="kw">protected class="kw">final BuilderObjectListHelper<Instruction> instructionList = new BuilderObjectListHelper<>(Instruction.class, this);
   class="kw">protected class="kw">final BuilderObjectReferenceHelper<Instruction> interactionInstruction = new BuilderObjectReferenceHelper<>(Instruction.class, this);
   class="kw">protected class="kw">final BuilderObjectReferenceHelper<Instruction> deathInstruction = new BuilderObjectReferenceHelper<>(Instruction.class, this);
   class="kw">protected class="kw">final StringHolder initialMotionController = new StringHolder();
   class="kw">protected class="kw">final BuilderCodecObjectHelper<StateEvaluator> stateEvaluator = new BuilderCodecObjectHelper<>(StateEvaluator.class, StateEvaluator.CODEC, null);
   class="kw">protected class="kw">final BuilderCombatConfig combatConfig = new BuilderCombatConfig(BalanceAsset.CHILD_ASSET_CODEC, BalanceAsset.VALIDATOR_CACHE.getValidator());
   class="kw">protected class="kw">final BuilderTemplateInteractionVars interactionVars = new BuilderTemplateInteractionVars();
   class="kw">protected class="kw">final BooleanHolder isMemory = new BooleanHolder();
   class="kw">protected class="kw">final StringHolder memoriesCategory = new StringHolder();
   class="kw">protected class="kw">final StringHolder memoriesNameOverride = new StringHolder();
   class="kw">protected class="kw">final StringHolder nameTranslationKey = new StringHolder();
   class="kw">protected class="kw">final NumberArrayHolder headPitchAngleRange = new NumberArrayHolder();
   class="kw">protected class="kw">final BooleanHolder overrideHeadPitchAngle = new BooleanHolder();

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

   @Override
   class="kw">public boolean isSpawnable() {
      class="kw">return true;
   }

   @Nonnull
   @Override
   class="kw">public String getShortDescription() {
      class="kw">return "Generic role for NPC";
   }

   @Nonnull
   @Override
   class="kw">public String getLongDescription() {
      class="kw">return "Generic role for NPC with a core planner and list of Motion controllers.";
   }

   @Nonnull
   @Override
   class="kw">public BuilderDescriptorState getBuilderDescriptorState() {
      class="kw">return BuilderDescriptorState.Stable;
   }

   @Nonnull
   class="kw">public Role build(@Nonnull BuilderSupport var1) {
      throw new UnsupportedOperationException("Use BuilderRole.createAndAttach(holder, builderSupport) - Role requires entity context");
   }

   @Nonnull
   @Override
   class="kw">public Role createAndAttach(@Nonnull Holder<EntityStore> var1, @Nonnull BuilderSupport var2) {
      class="kw">return Role.createAndAttach(var1, this, var2);
   }

   @Override
   class="kw">public boolean validate(String var1, @Nonnull NPCLoadTimeValidationHelper var2, @Nonnull ExecutionContext var3, Scope var4, @Nonnull List<String> var5) {
      var2.setInventorySizes(this.inventorySlots, this.hotbarSlots, this.offHandSlots);

      boolean var6;
      try {
         String[] var7 = this.hotbarItems.get(var3);
         var6 = var7 == null || var7.length == 0 || var2.validateHotbarHasSlot(var7.length - 1, "HotbarItems", var5);
      } catch (IllegalStateException var14) {
         var5.add(String.format("%s: %s", var1, var14.getMessage()));
         var6 = false;
      }

      boolean var15;
      try {
         String[] var8 = this.offHandItems.get(var3);
         var15 = (var8 == null || var8.length == 0 || var2.validateOffHandHasSlot(var8.length - 1, "OffHandItems", var5))
            & var2.validateOffHandHasSlot(this.defaultOffHandSlot.get(var3), "DefaultOffHandSlot", var5);
      } catch (IllegalStateException var13) {
         var5.add(String.format("%s: %s", var1, var13.getMessage()));
         var15 = false;
      }

      boolean var16 = true;
      String var9 = this.initialMotionController.get(var3);
      if (var9 != null) {
         BuilderFactory var10 = this.builderManager.getFactory(MotionController.class);

         try {
            BuilderMotionControllerBase var11 = (BuilderMotionControllerBase)var10.createBuilder(var9);
            var2.requireMotionControllerType(var11.getClassType());
         } catch (IllegalArgumentException var12) {
            var5.add(String.format("%s: Unable to set InitialMotionController to %s as no such MotionController exists", var1, var9));
            var16 = false;
         }
      }

      var2.pushPrecedingScope();
      boolean var17 = this.instructionList.validate(var1, var2, this.builderManager, var3, var4, var5);
      var2.popPrecedingScope();
      class="kw">return super.validate(var1, var2, var3, var4, var5)
         & var6
         & var15
         & var16
         & var17
         & this.interactionInstruction.validate(var1, var2, this.builderManager, var3, var4, var5)
         & this.deathInstruction.validate(var1, var2, this.builderManager, var3, var4, var5)
         & this.stateTransitionController.validate(var1, var2, this.builderManager, var3, var4, var5)
         & this.motionControllers.validate(var1, var2, this.builderManager, var3, var4, var5)
         & this.combatConfig.validate(var1, var2, var3, var5);
   }

   @Nonnull
   class="kw">public BuilderRole readConfig(@Nonnull JsonElement var1) {
      super.readConfig(var1);
      this.setNotComponent();
      this.requireInt(var1, "MaxHealth", this.maxHealth, IntSingleValidator.greater0(), BuilderDescriptorState.Stable, "Max health", null);
      this.requireAsset(var1, "Appearance", this.appearance, ModelExistsValidator.required(), BuilderDescriptorState.Stable, "Model to use for rendering", null);
      this.getStringArray(
         var1,
         "DisplayNames",
         var1x -> this.displayNames = var1x,
         null,
         null,
         StringArrayNoEmptyStringsValidator.get(),
         BuilderDescriptorState.Stable,
         "List of possible display names to choose from",
         null
      );
      this.requireString(
         var1,
         "NameTranslationKey",
         this.nameTranslationKey,
         StringNotEmptyValidator.get(),
         BuilderDescriptorState.Stable,
         "The translation key for this NPC's name",
         null
      );
      this.getAsset(
         var1,
         "OpaqueBlockSet",
         var1x -> this.opaqueBlockSet = var1x,
         "Opaque",
         BlockSetExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Blocks blocking line of sight",
         null
      );
      this.getDouble(
         var1, "Inertia", var1x -> this.inertia = var1x, 1.0, DoubleSingleValidator.greater(0.1), BuilderDescriptorState.Experimental, "Inertia", null
      );
      this.getDouble(
         var1,
         "KnockbackScale",
         this.knockbackScale,
         1.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Stable,
         "Scale factor for knockback",
         "Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it."
      );
      this.getInt(
         var1,
         "InventorySize",
         var1x -> this.inventorySlots = var1x,
         0,
         IntRangeValidator.between(0, 36),
         BuilderDescriptorState.Stable,
         "Number of available inventory slots",
         null
      );
      this.getInt(
         var1,
         "HotbarSize",
         var1x -> this.hotbarSlots = var1x,
         3,
         IntRangeValidator.between(3, 8),
         BuilderDescriptorState.Stable,
         "Number of available hotbar slots",
         null
      );
      this.getInt(
         var1,
         "OffHandSlots",
         var1x -> this.offHandSlots = var1x,
         0,
         IntRangeValidator.between(0, 4),
         BuilderDescriptorState.Stable,
         "The number of slots for off-hand items",
         null
      );
      this.getAssetArray(
         var1,
         "HotbarItems",
         this.hotbarItems,
         null,
         0,
         8,
         ItemExistsValidator.orDroplistWithConfig(AssetValidator.ListCanBeEmpty),
         BuilderDescriptorState.Stable,
         "Hotbar items (e.g. primary weapon, secondary weapon, etc)",
         null
      );
      this.getAssetArray(
         var1,
         "OffHandItems",
         this.offHandItems,
         null,
         0,
         8,
         ItemExistsValidator.withConfig(AssetValidator.ListCanBeEmpty),
         BuilderDescriptorState.Stable,
         "Off-hand items (e.g. shields, torches, etc)",
         null
      );
      this.getAsset(
         var1,
         "PossibleInventoryItems",
         this.inventoryItemsDropList,
         null,
         ItemDropListExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "A droplist defining the possible items the NPCs inventory could contain",
         null
      );
      this.getInt(
         var1,
         "DefaultOffHandSlot",
         this.defaultOffHandSlot,
         -1,
         IntRangeValidator.between(-1, 4),
         BuilderDescriptorState.Stable,
         "The class="kw">default off-hand item slot (-1 is empty)",
         null
      );
      this.getAssetArray(
         var1,
         "Armor",
         var1x -> this.armor = var1x,
         null,
         null,
         ItemExistsValidator.withConfig(AssetValidator.ListCanBeEmpty),
         BuilderDescriptorState.WorkInProgress,
         "Armor items",
         null
      );
      this.getAsset(
         var1,
         "DropList",
         this.dropListId,
         null,
         ItemDropListExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Drop list to spawn when killed",
         null
      );
      this.getDouble(
         var1,
         "CollisionDistance",
         var1x -> this.collisionDistance = var1x,
         5.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Stable,
         "Collision lookahead",
         null
      );
      this.getDouble(
         var1,
         "CollisionForceFalloff",
         var1x -> this.collisionForceFalloff = var1x,
         2.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Falloff rate for collision force",
         null
      );
      this.getDouble(
         var1, "CollisionRadius", var1x -> this.collisionRadius = var1x, -1.0, null, BuilderDescriptorState.Experimental, "Collision radius override", null
      );
      this.getFloat(
         var1,
         "CollisionViewAngle",
         var1x -> this.collisionViewAngle = var1x,
         320.0F,
         DoubleRangeValidator.between(0.0, 360.0),
         BuilderDescriptorState.Experimental,
         "Collision detection view cone",
         null
      );
      this.getDouble(
         var1,
         "SeparationDistance",
         this.separationDistance,
         3.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Desired separation distance",
         null
      );
      this.getDouble(
         var1,
         "SeparationWeight",
         this.separationWeight,
         1.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "Blend factor separation",
         null
      );
      this.getDouble(
         var1,
         "SeparationDistanceTarget",
         this.separationDistanceTarget,
         1.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "Desired separation distance when close to target",
         null
      );
      this.getDouble(
         var1,
         "SeparationNearRadiusTarget",
         this.separationNearRadiusTarget,
         1.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Distance when using SeparationDistanceTarget",
         null
      );
      this.getDouble(
         var1,
         "SeparationFarRadiusTarget",
         this.separationFarRadiusTarget,
         5.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Use normal separation distance from further than this distance",
         null
      );
      this.getBoolean(
         var1, "ApplyAvoidance", var1x -> this.applyAvoidance = var1x, false, BuilderDescriptorState.Experimental, "Apply avoidance steering force", null
      );
      this.getBoolean(
         var1,
         "AvoidanceFallCheck",
         this.avoidanceFallCheck,
         false,
         BuilderDescriptorState.Deprecated,
         "Deprecated no-op retained for backwards compatibility",
         null
      );
      this.getBoolean(var1, "ApplySeparation", this.applySeparation, false, BuilderDescriptorState.Experimental, "Apply separation steering force", null);
      this.getEnum(
         var1,
         "AvoidanceMode",
         this.avoidanceMode,
         Role.AvoidanceMode.class,
         Role.AvoidanceMode.Any,
         BuilderDescriptorState.Experimental,
         "Abilities to use for avoidance",
         null
      );
      this.getEnum(
         var1,
         "SeparationMode",
         this.separationMode,
         Role.SeparationMode.class,
         Role.SeparationMode.Legacy,
         BuilderDescriptorState.Experimental,
         "Mode for separation calculation",
         null
      );
      this.getDouble(
         var1,
         "SeparationPushSafeDistanceMultiplier",
         this.separationSafeDistanceMultiplier,
         0.8,
         DoubleRangeValidator.between01(),
         BuilderDescriptorState.Experimental,
         "Push Mode: Multiplier to reduce target distance to avoid NPC jittering close to target",
         null
      );
      this.getDouble(
         var1,
         "SeparationLegacySteeringStrength",
         this.separationLegacySteeringStrength,
         0.5,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Legacy mode: Separation steering strength",
         null
      );
      this.getDouble(
         var1,
         "SeparationPushSteeringStrength",
         this.separationPushSteeringStrength,
         0.8,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Push mode: Separation steering strength",
         null
      );
      this.getDouble(
         var1,
         "SeparationPushDistanceWeightDefault",
         this.separationPushDistanceWeightDefault,
         1.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Push mode: falloff exponent for separation distance",
         null
      );
      this.getDouble(
         var1,
         "SeparationPushDistanceWeightTarget",
         this.separationPushDistanceWeightTarget,
         8.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Push mode: falloff exponent when NPC is close to motion target",
         null
      );
      this.getDouble(
         var1,
         "SeparationPushDistanceWeightAttacker",
         this.separationPushDistanceWeightAttacker,
         8.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Push mode: falloff exponent towards other potential attackers when close to motion target",
         null
      );
      this.getDouble(
         var1,
         "SeparationPushSpeedScale",
         this.separationPushSpeedScale,
         0.5,
         DoubleRangeValidator.fromExclToIncl(0.0, 1.0),
         BuilderDescriptorState.Experimental,
         "Push mode: scale to increase smaller speeds for separation",
         null
      );
      this.getOverride(
         var1,
         "SeparationOverrideOrientation",
         this.featureOverrideOrientationHint,
         BuilderDescriptorState.Experimental,
         "Whether to override orientation of NPC when separating",
         null
      );
      this.getOverride(
         var1,
         "SeparationOverrideAlwaysSeparate",
         this.featureOverrideAlwaysSeparate,
         BuilderDescriptorState.Experimental,
         "Whether to separate even if the NPC would rest",
         null
      );
      this.getOverride(
         var1,
         "SeparationOverrideNormalizeDistances",
         this.featureOverrideNormalizeDistances,
         BuilderDescriptorState.Experimental,
         "Whether to normalize distances when summing distances",
         null
      );
      this.getDouble(
         var1,
         "EntityAvoidanceStrength",
         var1x -> this.entityAvoidanceStrength = var1x,
         1.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "Blending factor avoidance",
         null
      );
      this.getBoolean(
         var1, "StayInEnvironment", var1x -> this.stayInEnvironment = var1x, false, BuilderDescriptorState.Experimental, "Stay in spawning environment", null
      );
      this.getString(
         var1,
         "AllowedEnvironments",
         var1x -> this.allowedEnvironments = var1x,
         null,
         StringNullOrNotEmptyValidator.get(),
         BuilderDescriptorState.Experimental,
         "Allowed environment to walk in",
         null
      );
      this.getStringArray(
         var1,
         "FlockSpawnTypes",
         this.flockSpawnTypes,
         null,
         0,
         Integer.MAX_VALUE,
         StringArrayNoEmptyStringsValidator.get(),
         BuilderDescriptorState.WorkInProgress,
         "Types of NPC this flock should consist off",
         null
      );
      this.getBoolean(
         var1,
         "FlockSpawnTypesRandom",
         this.flockSpawnTypeRandom,
         false,
         BuilderDescriptorState.WorkInProgress,
         "Create a randomized flock if true else spawn in order of FlockSpawnTypes",
         null
      );
      this.getStringArray(
         var1,
         "FlockAllowedNPC",
         this.flockAllowedRoles,
         null,
         0,
         Integer.MAX_VALUE,
         StringArrayNoEmptyStringsValidator.get(),
         BuilderDescriptorState.Experimental,
         "List of NPCs allowed in flock",
         null
      );
      this.getBoolean(var1, "FlockCanLead", this.canLeadFlock, false, BuilderDescriptorState.Experimental, "This NPC can be flock leader", null);
      this.getDouble(
         var1,
         "FlockWeightAlignment",
         var1x -> this.flockWeightAlignment = var1x,
         1.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Blending flock alignment",
         null
      );
      this.getDouble(
         var1,
         "FlockWeightSeparation",
         var1x -> this.flockWeightSeparation = var1x,
         1.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Blending flock separation",
         null
      );
      this.getDouble(
         var1,
         "FlockWeightCohesion",
         var1x -> this.flockWeightCohesion = var1x,
         1.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Blending flock cohesion",
         null
      );
      this.getDouble(
         var1,
         "FlockInfluenceRange",
         var1x -> this.flockInfluenceRange = var1x,
         10.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Influence radius flock forces",
         null
      );
      this.getCodecObject(
         var1, "CombatConfig", this.combatConfig, BuilderDescriptorState.Stable, "The combat configuration providing optional combat action evaluator", null
      );
      this.getBoolean(var1, "Invulnerable", this.invulnerable, false, BuilderDescriptorState.Stable, "Makes NPC ignore damage", null);
      this.getBoolean(var1, "BreathesInAir", this.breathesInAir, true, BuilderDescriptorState.WorkInProgress, "Can breath in air", null);
      this.getBoolean(var1, "BreathesInWater", this.breathesInWater, false, BuilderDescriptorState.WorkInProgress, "Can breath in fluid/water", null);
      this.getBoolean(
         var1, "PickupDropOnDeath", var1x -> this.pickupDropOnDeath = var1x, false, BuilderDescriptorState.Stable, "Drop last picked item on death", null
      );
      this.getDouble(
         var1,
         "DeathAnimationTime",
         this.deathAnimationTime,
         1.5,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "How long to let the death animation play before removing",
         null
      );
      this.getAsset(
         var1,
         "DeathParticles",
         this.deathParticles,
         "Effect_Death",
         ParticleSystemExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Particles to play when the NPC corpse is removed.",
         null
      );
      this.getBoolean(
         var1,
         "DropDeathItemsInstantly",
         this.dropDeathItemsInstantly,
         false,
         BuilderDescriptorState.Stable,
         "Whether or not to drop death items instantly on death, or when the body disappears.",
         null
      );
      this.getAsset(
         var1,
         "DeathInteraction",
         this.deathInteraction,
         null,
         RootInteractionValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Experimental,
         "Interaction to run on death",
         null
      );
      this.getFloat(
         var1,
         "DespawnAnimationTime",
         var1x -> this.despawnAnimationTime = var1x,
         0.8F,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "How long to let the despawn animation play before removing",
         null
      );
      this.getAsset(
         var1,
         "SpawnParticles",
         this.spawnParticles,
         null,
         ParticleSystemExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Experimental,
         "Particle system when spawning",
         null
      );
      this.getVector3d(
         var1,
         "SpawnParticlesOffset",
         this.spawnParticleOffset,
         null,
         null,
         BuilderDescriptorState.Experimental,
         "Displacement from foot point to spawn relative to NPC heading",
         null
      );
      this.getString(
         var1, "SpawnParticlesTargetNode", this.spawnParticlesTargetNode, null, null, BuilderDescriptorState.Stable, "Target node for spawn particles", null
      );
      this.getBoolean(
         var1,
         "SpawnParticlesDetached",
         this.spawnParticlesDetached,
         true,
         BuilderDescriptorState.Stable,
         "Whether spawn particles should be attached to the model or not",
         null
      );
      this.getDouble(
         var1,
         "SpawnViewDistance",
         var1x -> this.spawnViewDistance = var1x,
         75.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "View distance for spawn particle",
         null
      );
      this.getBoolean(
         var1,
         "CorpseStaysInFlock",
         var1x -> this.corpseStaysInFlock = var1x,
         false,
         BuilderDescriptorState.Stable,
         "Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death",
         null
      );
      this.getBoolean(
         var1,
         "OverrideHeadPitchAngle",
         this.overrideHeadPitchAngle,
         true,
         BuilderDescriptorState.Experimental,
         "Whether to override the head pitch angle range",
         null
      );
      this.getDoubleRange(
         var1,
         "HeadPitchAngleRange",
         this.headPitchAngleRange,
         DEFAULT_HEAD_PITCH_RANGE,
         DoubleSequenceValidator.betweenWeaklyMonotonic(-90.0, 90.0),
         BuilderDescriptorState.Experimental,
         "Head rotation pitch range to be used instead of model camera settings",
         null
      );
      this.validateAny(this.breathesInAir, this.breathesInWater);
      this.requireObject(
         var1,
         "MotionControllerList",
         this.motionControllers,
         BuilderDescriptorState.Stable,
         "Motion controllers",
         null,
         new BuilderValidationHelper(this.fileName, null, this.internalReferenceResolver, null, null, this.extraInfo, this.evaluators, this.readErrors)
      );
      this.getArray(
         var1,
         "Instructions",
         this.instructionList,
         null,
         BuilderDescriptorState.WorkInProgress,
         "List of instructions",
         null,
         new BuilderValidationHelper(
            this.fileName,
            null,
            this.internalReferenceResolver,
            this.stateHelper,
            new InstructionContextHelper(InstructionType.Default),
            this.extraInfo,
            this.evaluators,
            this.readErrors
         )
      );
      this.getObject(
         var1,
         "InteractionInstruction",
         this.interactionInstruction,
         BuilderDescriptorState.Stable,
         "Interaction instruction",
         "An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction",
         new BuilderValidationHelper(
            this.fileName,
            null,
            this.internalReferenceResolver,
            this.stateHelper,
            new InstructionContextHelper(InstructionType.Interaction),
            this.extraInfo,
            this.evaluators,
            this.readErrors
         )
      );
      this.getObject(
         var1,
         "DeathInstruction",
         this.deathInstruction,
         BuilderDescriptorState.Stable,
         "Death instruction",
         "An instruction which will run only when the NPC is dead until they are removed",
         new BuilderValidationHelper(
            this.fileName,
            null,
            this.internalReferenceResolver,
            this.stateHelper,
            new InstructionContextHelper(InstructionType.Death),
            this.extraInfo,
            this.evaluators,
            this.readErrors
         )
      );
      this.getObject(
         var1,
         "StateTransitions",
         this.stateTransitionController,
         BuilderDescriptorState.Stable,
         "State transition actions",
         "A set of state transitions and the actions that will be executed during them",
         new BuilderValidationHelper(
            this.fileName,
            new FeatureEvaluatorHelper().lock(),
            this.internalReferenceResolver,
            this.stateHelper,
            new InstructionContextHelper(InstructionType.StateTransitions),
            this.extraInfo,
            this.evaluators,
            this.readErrors
         )
      );
      this.getCodecObject(var1, "StateEvaluator", this.stateEvaluator, BuilderDescriptorState.Stable, "A state evaluator", null);
      this.getString(
         var1,
         "InitialMotionController",
         this.initialMotionController,
         null,
         StringNullOrNotEmptyValidator.get(),
         BuilderDescriptorState.Stable,
         "The initial motion controller to set",
         "The initial motion controller to set. If omitted and there are multiple, one will be chosen at random."
      );
      this.getCodecObject(var1, "InteractionVars", this.interactionVars, BuilderDescriptorState.Stable, "Interaction vars to be used in interactions.", null);
      this.getBoolean(var1, "IsMemory", this.isMemory, false, BuilderDescriptorState.Stable, "Used to define if the NPC has a Memory to record.", null);
      this.getString(
         var1,
         "MemoriesCategory",
         this.memoriesCategory,
         "Other",
         StringNullOrNotEmptyValidator.get(),
         BuilderDescriptorState.Stable,
         "Category to put the NPC in, as part of the Memories Plugin",
         null
      );
      this.getString(
         var1, "MemoriesNameOverride", this.memoriesNameOverride, "", null, BuilderDescriptorState.Stable, "Overrides the Memory name when set.", null
      );
      this.getFloat(
         var1,
         "SpawnLockTime",
         this.spawnLockTime,
         1.5,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Stable,
         "How long the NPC should be locked and unable to perform behavior when first spawned",
         null
      );
      StateEvaluator var2 = this.stateEvaluator.build();
      if (var2 != null) {
         this.evaluators.add(var2);
         var2.prepareOptions(this.stateHelper);
         this.stateHelper.setHasStateEvaluator();
      }

      class="kw">return this;
   }

   @Nonnull
   @Override
   class="kw">public String getIdentifier() {
      BuilderInfo var1 = NPCPlugin.get().getBuilderInfo(this);
      Objects.requireNonNull(var1, "Have builder but can't get builderInfo for it");
      class="kw">return var1.getKeyName();
   }

   @Nonnull
   @Override
   class="kw">public SpawnTestResult canSpawn(@Nonnull SpawningContext var1) {
      Builder var2 = this.motionControllers.getBuilder(this.builderManager, var1.getExecutionContext(), this);
      if (var2 class="kw">instanceof ISpawnable) {
         SpawnTestResult var3 = ((ISpawnable)var2).canSpawn(var1);
         if (var3 != SpawnTestResult.TEST_OK) {
            class="kw">return var3;
         }
      }

      class="kw">return SpawnTestResult.TEST_OK;
   }

   @Override
   class="kw">public boolean requiresSpawnDropHeightCheck(@Nonnull SpawningContext var1) {
      class="kw">return !(
         this.motionControllers.getBuilder(this.builderManager, var1.getExecutionContext(), this) class="kw">instanceof ISpawnable var3
            && !var3.requiresSpawnDropHeightCheck(var1)
      );
   }

   @Override
   class="kw">public void getMovementModes(
      @Nonnull SpawningContext var1, @Nonnull Set<MovementMode> var2, @Nonnull Set<MovementMode> var3, @Nonnull Set<MovementMode> var4
   ) {
      Builder var5 = this.motionControllers.getBuilder(this.builderManager, var1.getExecutionContext(), this);
      if (var5 class="kw">instanceof ISpawnable) {
         ((ISpawnable)var5).getMovementModes(var1, var2, var3, var4);
      }
   }

   @Nonnull
   @Override
   class="kw">public Class<Role> category() {
      class="kw">return Role.class;
   }

   @Override
   class="kw">public String getSpawnModelName(ExecutionContext var1, Scope var2) {
      class="kw">return this.appearance.get(var1);
   }

   @Nullable
   @Override
   class="kw">public Scope createModifierScope(ExecutionContext var1) {
      class="kw">return null;
   }

   @Nonnull
   @Override
   class="kw">public Scope createExecutionScope() {
      class="kw">return this.getBuilderParameters().createScope();
   }

   @Override
   class="kw">public void markNeedsReload() {
      NPCPlugin.get().setRoleBuilderNeedsReload(this);
   }

   @Override
   class="kw">public String getSpawnParticles(@Nonnull BuilderSupport var1) {
      class="kw">return this.spawnParticles.get(var1.getExecutionContext());
   }

   @Override
   class="kw">public Vector3d getSpawnParticleOffset(@Nonnull BuilderSupport var1) {
      class="kw">return createVector3d(this.spawnParticleOffset.get(var1.getExecutionContext()), Vector3d::new);
   }

   @Override
   class="kw">public String getSpawnParticleTargetNode(@Nonnull BuilderSupport var1) {
      class="kw">return this.spawnParticlesTargetNode.get(var1.getExecutionContext());
   }

   @Override
   class="kw">public boolean isSpawnParticleDetached(@Nonnull BuilderSupport var1) {
      class="kw">return this.spawnParticlesDetached.get(var1.getExecutionContext());
   }

   @Override
   class="kw">public double getSpawnViewDistance() {
      class="kw">return this.spawnViewDistance;
   }

   @Override
   class="kw">public class="kw">final boolean isEnabled(ExecutionContext var1) {
      class="kw">return true;
   }

   class="kw">public int getMaxHealth(@Nonnull BuilderSupport var1) {
      class="kw">return this.maxHealth.get(var1.getExecutionContext());
   }

   @Nullable
   class="kw">public String[] getDisplayNames() {
      class="kw">return this.displayNames;
   }

   class="kw">public String getNameTranslationKey(BuilderSupport var1) {
      class="kw">return this.nameTranslationKey.get(var1.getExecutionContext());
   }

   class="kw">public String getAppearance(@Nonnull BuilderSupport var1) {
      class="kw">return this.appearance.get(var1.getExecutionContext());
   }

   @Override
   class="kw">public boolean breathesInAir(@Nonnull ExecutionContext var1, @Nullable Scope var2) {
      class="kw">return this.breathesInAir.get(var1);
   }

   @Override
   class="kw">public boolean breathesInWater(@Nonnull ExecutionContext var1, @Nullable Scope var2) {
      class="kw">return this.breathesInWater.get(var1);
   }

   class="kw">public int getOpaqueBlockSet() {
      int var1 = BlockSet.getAssetMap().getIndex(this.opaqueBlockSet);
      if (var1 == Integer.MIN_VALUE) {
         throw new IllegalArgumentException("Unknown key! " + this.opaqueBlockSet);
      } else {
         class="kw">return var1;
      }
   }

   class="kw">public double getInertia() {
      class="kw">return this.inertia;
   }

   class="kw">public double getKnockbackScale(@Nonnull BuilderSupport var1) {
      class="kw">return this.knockbackScale.get(var1.getExecutionContext());
   }

   @Nullable
   class="kw">public String[] getHotbarItems(@Nonnull BuilderSupport var1) {
      class="kw">return this.hotbarItems.get(var1.getExecutionContext());
   }

   @Nullable
   class="kw">public String[] getOffHandItems(@Nonnull BuilderSupport var1) {
      class="kw">return this.offHandItems.get(var1.getExecutionContext());
   }

   class="kw">public String getInventoryItemsDropList(@Nonnull BuilderSupport var1) {
      class="kw">return this.inventoryItemsDropList.get(var1.getExecutionContext());
   }

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

   class="kw">public boolean isPickupDropOnDeath() {
      class="kw">return this.pickupDropOnDeath;
   }

   class="kw">public String getDropListId(@Nonnull BuilderSupport var1) {
      class="kw">return this.dropListId.get(var1.getExecutionContext());
   }

   class="kw">public double getCollisionDistance() {
      class="kw">return this.collisionDistance;
   }

   class="kw">public double getCollisionForceFalloff() {
      class="kw">return this.collisionForceFalloff;
   }

   class="kw">public boolean isAvoidingEntities() {
      class="kw">return this.applyAvoidance;
   }

   class="kw">public Role.AvoidanceMode getAvoidanceMode(BuilderSupport var1) {
      class="kw">return this.avoidanceMode.get(var1.getExecutionContext());
   }

   class="kw">public Role.SeparationMode getSeparationMode(BuilderSupport var1) {
      class="kw">return this.separationMode.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationSafeDistanceMultiplier(BuilderSupport var1) {
      class="kw">return this.separationSafeDistanceMultiplier.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationLegacySteeringStrength(BuilderSupport var1) {
      class="kw">return this.separationLegacySteeringStrength.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationPushSteeringStrength(BuilderSupport var1) {
      class="kw">return this.separationPushSteeringStrength.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationPushDistanceWeightDefault(BuilderSupport var1) {
      class="kw">return this.separationPushDistanceWeightDefault.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationPushDistanceWeightTarget(BuilderSupport var1) {
      class="kw">return this.separationPushDistanceWeightTarget.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationPushDistanceWeightAttacker(BuilderSupport var1) {
      class="kw">return this.separationPushDistanceWeightAttacker.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationPushSpeedScale(BuilderSupport var1) {
      class="kw">return this.separationPushSpeedScale.get(var1.getExecutionContext());
   }

   class="kw">public FeatureOverride getOverrideUseOrientationHint(BuilderSupport var1) {
      class="kw">return this.featureOverrideOrientationHint.get(var1.getExecutionContext());
   }

   class="kw">public FeatureOverride getOverrideAlwaysSeparate(BuilderSupport var1) {
      class="kw">return this.featureOverrideAlwaysSeparate.get(var1.getExecutionContext());
   }

   class="kw">public FeatureOverride getOverrideNormalizeDistances(BuilderSupport var1) {
      class="kw">return this.featureOverrideNormalizeDistances.get(var1.getExecutionContext());
   }

   class="kw">public double getCollisionRadius() {
      class="kw">return this.collisionRadius;
   }

   class="kw">public double getSeparationDistance(BuilderSupport var1) {
      class="kw">return this.separationDistance.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationWeight(BuilderSupport var1) {
      class="kw">return this.separationWeight.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationDistanceTarget(BuilderSupport var1) {
      class="kw">return this.separationDistanceTarget.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationNearRadiusTarget(BuilderSupport var1) {
      class="kw">return this.separationNearRadiusTarget.get(var1.getExecutionContext());
   }

   class="kw">public double getSeparationFarRadiusTarget(BuilderSupport var1) {
      class="kw">return this.separationFarRadiusTarget.get(var1.getExecutionContext());
   }

   class="kw">public boolean isApplySeparation(BuilderSupport var1) {
      class="kw">return this.applySeparation.get(var1.getExecutionContext());
   }

   class="kw">public boolean isAvoidanceFallCheck(BuilderSupport var1) {
      class="kw">return this.avoidanceFallCheck.get(var1.getExecutionContext());
   }

   class="kw">public boolean isStayingInEnvironment() {
      class="kw">return this.stayInEnvironment;
   }

   class="kw">public String getAllowedEnvironments() {
      class="kw">return this.allowedEnvironments;
   }

   class="kw">public double getEntityAvoidanceStrength() {
      class="kw">return this.entityAvoidanceStrength;
   }

   class="kw">public boolean isOverridingHeadPitchAngle(@Nonnull BuilderSupport var1) {
      class="kw">return this.overrideHeadPitchAngle.get(var1.getExecutionContext());
   }

   class="kw">public float[] getHeadPitchAngleRange(@Nonnull BuilderSupport var1) {
      double[] var2 = this.headPitchAngleRange.get(var1.getExecutionContext());
      class="kw">return new float[]{(float)(var2[0] * (float) (Math.PI / 180.0)), (float)(var2[1] * (float) (Math.PI / 180.0))};
   }

   @Nullable
   class="kw">public String[] getFlockSpawnTypes(@Nonnull BuilderSupport var1) {
      class="kw">return this.flockSpawnTypes.get(var1.getExecutionContext());
   }

   class="kw">public boolean isFlockSpawnTypeRandom(@Nonnull BuilderSupport var1) {
      class="kw">return this.flockSpawnTypeRandom.get(var1.getExecutionContext());
   }

   @Nonnull
   class="kw">public String[] getFlockAllowedRoles(@Nonnull BuilderSupport var1) {
      class="kw">return this.nonNull(this.flockAllowedRoles.get(var1.getExecutionContext()));
   }

   class="kw">public boolean isCanLeadFlock(@Nonnull BuilderSupport var1) {
      class="kw">return this.canLeadFlock.get(var1.getExecutionContext());
   }

   class="kw">public double getFlockWeightAlignment() {
      class="kw">return this.flockWeightAlignment;
   }

   class="kw">public double getFlockWeightSeparation() {
      class="kw">return this.flockWeightSeparation;
   }

   class="kw">public double getFlockWeightCohesion() {
      class="kw">return this.flockWeightCohesion;
   }

   class="kw">public double getFlockInfluenceRange() {
      class="kw">return this.flockInfluenceRange;
   }

   class="kw">public float getCollisionViewAngle() {
      class="kw">return (float) (Math.PI / 180.0) * this.collisionViewAngle;
   }

   @Nullable
   class="kw">public String getBalanceAsset(@Nonnull BuilderSupport var1) {
      class="kw">return this.combatConfig.build(var1.getExecutionContext());
   }

   class="kw">public double getDeathAnimationTime(@Nonnull BuilderSupport var1) {
      class="kw">return this.deathAnimationTime.get(var1.getExecutionContext());
   }

   class="kw">public String getDeathParticles(@Nonnull BuilderSupport var1) {
      class="kw">return this.deathParticles.get(var1.getExecutionContext());
   }

   class="kw">public boolean isDropDeathItemsInstantly(@Nonnull BuilderSupport var1) {
      class="kw">return this.dropDeathItemsInstantly.get(var1.getExecutionContext());
   }

   @Nullable
   class="kw">public String getDeathInteraction(@Nonnull BuilderSupport var1) {
      String var2 = this.deathInteraction.get(var1.getExecutionContext());
      class="kw">return var2 != null && !var2.isEmpty() ? var2 : null;
   }

   class="kw">public float getDespawnAnimationTime() {
      class="kw">return this.despawnAnimationTime;
   }

   class="kw">public boolean isInvulnerable(BuilderSupport var1) {
      class="kw">return this.invulnerable.get(var1.getExecutionContext());
   }

   class="kw">public int getInventorySlots() {
      class="kw">return this.inventorySlots;
   }

   class="kw">public int getHotbarSlots() {
      class="kw">return this.hotbarSlots;
   }

   class="kw">public int getOffHandSlots() {
      class="kw">return this.offHandSlots;
   }

   class="kw">public byte getDefaultOffHandSlot(@Nonnull BuilderSupport var1) {
      class="kw">return (byte)this.defaultOffHandSlot.get(var1.getExecutionContext());
   }

   class="kw">public boolean isCorpseStaysInFlock() {
      class="kw">return this.corpseStaysInFlock;
   }

   @Nullable
   class="kw">public Map<String, MotionController> getMotionControllerMap(@Nonnull BuilderSupport var1) {
      class="kw">return this.motionControllers.build(var1);
   }

   class="kw">public String getInitialMotionController(@Nonnull BuilderSupport var1) {
      class="kw">return this.initialMotionController.get(var1.getExecutionContext());
   }

   @Nullable
   class="kw">public List<Instruction> getInstructionList(@Nonnull BuilderSupport var1) {
      var1.setCurrentInstructionContext(InstructionType.Default);
      class="kw">return this.instructionList.build(var1);
   }

   @Nullable
   class="kw">public Instruction getInteractionInstruction(@Nonnull BuilderSupport var1) {
      var1.setCurrentInstructionContext(InstructionType.Interaction);
      class="kw">return this.interactionInstruction.build(var1);
   }

   @Nullable
   class="kw">public Instruction getDeathInstruction(@Nonnull BuilderSupport var1) {
      var1.setCurrentInstructionContext(InstructionType.Death);
      class="kw">return this.deathInstruction.build(var1);
   }

   class="kw">public void registerStateEvaluator(@Nonnull BuilderSupport var1) {
      var1.setStateEvaluator(this.stateEvaluator.build());
   }

   @Nullable
   class="kw">public Map<String, String> getInteractionVars(@Nonnull BuilderSupport var1) {
      class="kw">return this.interactionVars.build(var1.getExecutionContext());
   }

   class="kw">public boolean isMemory(ExecutionContext var1) {
      class="kw">return this.isMemory.get(var1);
   }

   @Override
   class="kw">public boolean isMemory(ExecutionContext var1, Scope var2) {
      class="kw">return this.isMemory.get(var1);
   }

   @Override
   class="kw">public String getMemoriesCategory(ExecutionContext var1, Scope var2) {
      class="kw">return this.memoriesCategory.get(var1);
   }

   class="kw">public String getMemoriesNameOverride(ExecutionContext var1) {
      class="kw">return this.memoriesNameOverride.get(var1);
   }

   @Override
   class="kw">public String getMemoriesNameOverride(ExecutionContext var1, @Nullable Scope var2) {
      class="kw">return this.memoriesNameOverride.get(var1);
   }

   @Nonnull
   @Override
   class="kw">public String getNameTranslationKey(ExecutionContext var1, @Nullable Scope var2) {
      class="kw">return this.nameTranslationKey.get(var1);
   }

   class="kw">public float getSpawnLockTime(BuilderSupport var1) {
      class="kw">return this.spawnLockTime.get(var1.getExecutionContext());
   }

   @Override
   class="kw">protected void runLoadTimeValidationHelper0(String var1, NPCLoadTimeValidationHelper var2, ExecutionContext var3, @Nonnull List<String> var4) {
      NPCPlugin var5 = NPCPlugin.get();
      String[] var6 = this.flockSpawnTypes.get(var3);
      boolean var7 = true;
      if (var6 != null) {
         for (String var11 : var6) {
            if (!var5.hasRoleName(var11)) {
               var7 = false;
               var4.add(String.format("%s: No such role '%s' for %s", var1, var11, this.flockSpawnTypes.getName()));
            }
         }
      }

      String[] var13 = this.flockAllowedRoles.get(var3);
      if (var13 != null) {
         for (String var12 : var13) {
            if (!var5.hasRoleName(var12)) {
               var7 = false;
               var4.add(String.format("%s: No such role '%s' for %s", var1, var12, this.flockAllowedRoles.getName()));
            }
         }
      }

      if (!var7) {
         throw new IllegalStateException(
            String.format("Invalid roles referenced for %s or %s", this.flockSpawnTypes.getName(), this.flockAllowedRoles.getName())
         );
      }
   }
}