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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.function.consumer.QuadConsumer;
class="kw">import com.hypixel.hytale.function.predicate.QuadPredicate;
class="kw">import com.hypixel.hytale.function.predicate.TriIntObjPredicate;
class="kw">import com.hypixel.hytale.math.random.RandomExtra;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.util.TrigMathUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.protocol.BlockPosition;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionChain;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionManager;
class="kw">import com.hypixel.hytale.server.core.modules.blockset.BlockSetModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.debug.DebugUtils;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsMath;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
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.BuilderSupport;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.BodyMotionBase;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.combat.builders.BuilderBodyMotionCharge;
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.instructions.Instruction;
class="kw">import com.hypixel.hytale.server.npc.movement.Steering;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.BlockHit;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.EntityHit;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.MotionController;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.ProbeMoveData;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.RailPath;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.RailPathRefreshResolver;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.RailPathSmoother;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.RailStepConfig;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.RailStepResult;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.TargetContactSamplePlanner;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.role.RoleDebugFlags;
class="kw">import com.hypixel.hytale.server.npc.role.support.DebugSupport;
class="kw">import com.hypixel.hytale.server.npc.role.support.PositionCache;
class="kw">import com.hypixel.hytale.server.npc.sensorinfo.InfoProvider;
class="kw">import com.hypixel.hytale.server.npc.util.AimingData;
class="kw">import com.hypixel.hytale.server.npc.util.NPCPhysicsMath;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.Reference2DoubleMap;
class="kw">import it.unimi.dsi.fastutil.objects.Reference2DoubleOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.Reference2DoubleMap.Entry;
class="kw">import java.util.BitSet;
class="kw">import java.util.EnumSet;
class="kw">import java.util.List;
class="kw">import java.util.function.IntPredicate;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.function.Supplier;
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">import org.joml.Vector3dc;
class="kw">import org.joml.Vector3f;

class="kw">public class BodyMotionCharge class="kw">extends BodyMotionBase class="kw">implements DebugSupport.DebugFlagsChangeListener {
   class="kw">private class="kw">static class="kw">final InteractionType INTERACTION_TYPE = InteractionType.Collision;
   class="kw">private class="kw">static class="kw">final float CHARGE_DEBUG_SHAPE_DURATION_SECONDS = 5.0F;
   class="kw">private class="kw">static class="kw">final double CHARGE_STATE_DEBUG_MARKER_RADIUS = 1.0;
   class="kw">private class="kw">static class="kw">final float CHARGE_PROBE_DEBUG_SHAPE_DURATION_SECONDS = 0.05F;
   class="kw">private class="kw">static class="kw">final double CHARGE_PROBE_END_MARKER_RADIUS = 1.0;
   class="kw">private class="kw">static class="kw">final float CHARGE_PROBE_FRESH_OPACITY = 1.0F;
   class="kw">private class="kw">static class="kw">final float CHARGE_PROBE_STALE_OPACITY = 0.45F;
   class="kw">private class="kw">static class="kw">final double CHARGE_DEBUG_SPHERE_RADIUS = 0.2;
   class="kw">private class="kw">static class="kw">final double CHARGE_DEBUG_CUBE_SIZE = 0.2;
   class="kw">private class="kw">static class="kw">final int DEFAULT_COLLISION_BUFFER_CAPACITY = 8;
   class="kw">private class="kw">static class="kw">final double MIN_CHARGE_DISTANCE = 1.0;
   class="kw">private class="kw">static class="kw">final double TARGET_CONTACT_WINDOW_MIN = 1.0E-6;
   class="kw">private class="kw">static class="kw">final double TARGET_CONTACT_WINDOW_MAX = 1.5;
   class="kw">private class="kw">static class="kw">final double RAIL_REFRESH_PATH_TOLERANCE = 0.05;
   class="kw">private class="kw">static class="kw">final double CHARGE_END_PLANE_EPSILON = 1.0E-6;
   class="kw">private class="kw">static class="kw">final double CONTACT_CONTEXT_HYSTERESIS_TARGET_DISTANCE = 1.5;
   class="kw">private class="kw">static class="kw">final double CONTACT_CONTEXT_HYSTERESIS_TARGET_DISTANCE_DELTA = 1.0;
   class="kw">private class="kw">static class="kw">final double CONTACT_CONTEXT_HYSTERESIS_PROBE_START_DELTA = 0.5;
   class="kw">private class="kw">static class="kw">final double CONTACT_SAMPLE_DISTANCE_EPSILON = 0.001;
   class="kw">private class="kw">static class="kw">final double MAX_RELATIVE_SPEED_CHARGE_SEARCH_RADIUS = 64.0;
   class="kw">private class="kw">static class="kw">final double CHARGE_CANDIDATE_APPROACH_PADDING = 2.0;
   class="kw">private class="kw">static class="kw">final double CHARGE_SEARCH_RADIUS = 14.8F;
   class="kw">private class="kw">static class="kw">final QuadPredicate<Ref<EntityStore>, Ref<EntityStore>, Object, ComponentAccessor<EntityStore>> NOT_SELF_PREDICATE = (var0, var1, var2, var3) -> !var0.equals(
      var1
   );
   class="kw">private class="kw">static class="kw">final QuadConsumer<Ref<EntityStore>, Ref<EntityStore>, List<Ref<EntityStore>>, ComponentAccessor<EntityStore>> COLLECT_ENTITY_CONSUMER = (var0, var1, var2, var3) -> {
      if (var0 != null && var0.isValid() && var0 != var1) {
         var2.add(var0);
      }
   };
   class="kw">private class="kw">static class="kw">final TriIntObjPredicate<BodyMotionCharge> COLLECT_OVERLAPPING_PASS_THROUGH_BLOCK_CONSUMER = BodyMotionCharge::collectOverlappingPassThroughBlock;
   class="kw">protected class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
   class="kw">protected class="kw">final double relativeTurnSpeed;
   class="kw">protected class="kw">final double lockedOnHalfAngleRad;
   class="kw">protected class="kw">final double[] lockedOnDurationRange;
   class="kw">protected class="kw">final double[] windingUpDurationRange;
   class="kw">protected class="kw">final double[] postChargeDurationRange;
   class="kw">protected class="kw">final boolean skipLockedOnState;
   class="kw">protected class="kw">final boolean skipWindingUpState;
   class="kw">protected class="kw">final double[] chargeDistanceRange;
   class="kw">protected class="kw">final boolean windingUpUninterruptable;
   class="kw">protected class="kw">final double windingUpRelativeTurnSpeed;
   class="kw">protected class="kw">final double chargeRelativeSpeed;
   class="kw">protected class="kw">final int ignoredBlockSet;
   class="kw">protected class="kw">final int removedBlockSet;
   @Nullable
   class="kw">private class="kw">final Predicate<CollisionConfig> ignoredBlockFilter;
   class="kw">protected class="kw">final boolean clearOnceOnStateChange;
   class="kw">protected class="kw">final double chargeAbsoluteSpeed;
   class="kw">protected class="kw">final double chargeAcceleration;
   class="kw">protected class="kw">final boolean ignoredBlockSetTriggers;
   class="kw">protected class="kw">final boolean entityStopsCharge;
   class="kw">protected class="kw">final double climbSlope;
   class="kw">protected class="kw">final double dropSlope;
   class="kw">protected class="kw">final double horizontalSkipGapWidth;
   @Nullable
   class="kw">private class="kw">final String blockCollisionInteractionId;
   @Nullable
   class="kw">private class="kw">final String npcCollisionInteractionId;
   @Nullable
   class="kw">private class="kw">final String playerCollisionInteractionId;
   class="kw">protected class="kw">final double repeatCollisionIgnoreDuration;
   class="kw">protected class="kw">final double probeMinInterval;
   class="kw">protected class="kw">final double probeMaxInterval;
   class="kw">protected class="kw">final double probeMinDirectionChange;
   class="kw">protected class="kw">final double probeChargeRecomputeDistance;
   class="kw">protected class="kw">final double knockbackThreshold;
   @Nullable
   class="kw">private Instruction parentInstruction;
   class="kw">protected class="kw">final AimingData aimingData = new AimingData();
   class="kw">protected class="kw">final Vector3d targetPosition = new Vector3d();
   class="kw">protected class="kw">final Rotation3f rotation = new Rotation3f();
   class="kw">protected class="kw">final ProbeMoveData probeMoveData = new ProbeMoveData();
   class="kw">protected class="kw">final Vector3d chargeStartPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d chargeEndPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d chargeDirection = new Vector3d();
   class="kw">protected class="kw">final Vector3d chargeProbeEndPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d chargeProbeTargetDirection = new Vector3d();
   class="kw">protected class="kw">final Vector3d chargeProbeEndDirection = new Vector3d();
   class="kw">protected class="kw">final Vector3d chargeProbeArrowOrigin = new Vector3d();
   class="kw">private class="kw">final Vector3d launchChargeStartReference = new Vector3d();
   class="kw">private class="kw">final Vector3d launchChargeEndReference = new Vector3d();
   class="kw">private class="kw">final Vector3d launchChargePlaneNormal = new Vector3d();
   class="kw">private class="kw">final RailPath railPath = new RailPath();
   class="kw">private class="kw">final RailPath candidateRailPath = new RailPath();
   class="kw">private class="kw">final RailPathSmoother railPathSmoother = new RailPathSmoother();
   class="kw">private class="kw">final RailPathSmoother.Config smootherConfig = new RailPathSmoother.Config();
   class="kw">private class="kw">final RailStepConfig railConfig = new RailStepConfig();
   class="kw">private class="kw">final RailStepResult railResult = new RailStepResult();
   class="kw">private double chargeSpeed;
   class="kw">private class="kw">final Vector3d railDelta = new Vector3d();
   class="kw">private class="kw">final Vector3d railStepTargetPosition = new Vector3d();
   class="kw">private class="kw">final Vector3d railReplanAnchorPosition = new Vector3d();
   class="kw">private class="kw">final Vector3d railRefreshProbeStartPosition = new Vector3d();
   class="kw">private class="kw">final Vector3d computedPassThroughCollisionPoint = new Vector3d();
   class="kw">private class="kw">final Vector3d computedPassThroughNormal = new Vector3d();
   @Nullable
   class="kw">private World tempWorld;
   class="kw">private class="kw">final List<Ref<EntityStore>> candidateEntitiesBuffer = new ObjectArrayList(8);
   class="kw">private class="kw">final List<EntityHit> filteredEntityHits = new ObjectArrayList(8);
   class="kw">private class="kw">final BitSet acceptedEntityHitIndexes = new BitSet(8);
   class="kw">private class="kw">final Reference2DoubleMap<Ref<EntityStore>> lastEntityCollisionHitTimes = new Reference2DoubleOpenHashMap(8);
   class="kw">private BodyMotionCharge.ChargeState state = BodyMotionCharge.ChargeState.LostTarget;
   class="kw">private BodyMotionCharge.ChargeState sensorVisibleState = BodyMotionCharge.ChargeState.LostTarget;
   class="kw">private boolean debugChargeState;
   class="kw">private boolean debugChargePath;
   class="kw">private boolean visChargePath;
   class="kw">private boolean visChargeCollisions;
   class="kw">private boolean visChargeEntityHits;
   class="kw">private boolean visChargeProbe;
   class="kw">private double timeSinceHaveTarget;
   class="kw">private double phaseEndTime;
   class="kw">private double lastProbeTime;
   class="kw">private class="kw">final Vector3d lastProbeDirection = new Vector3d();
   class="kw">private class="kw">final float cosProbeMinDirectionChange;
   class="kw">private double lastProbeDistanceSquared;
   class="kw">private boolean lastProbeBoundingBoxesOverlapped;
   class="kw">private double chargeDistanceSinceLastRailRefresh;
   class="kw">private double probeSizeCompensation;
   class="kw">private class="kw">final Box targetWorldBoundingBox = new Box();
   class="kw">private class="kw">final Box npcWorldBoundingBox = new Box();
   class="kw">private class="kw">final Vector3d expectedHitPosition = new Vector3d();
   class="kw">private class="kw">final ProbeMoveData.SegmentLocation hitSegmentLocation = new ProbeMoveData.SegmentLocation();
   class="kw">private class="kw">final TargetContactSamplePlanner.Scratch targetContactSampleScratch = new TargetContactSamplePlanner.Scratch();
   class="kw">private class="kw">final double[] targetContactSampleDistances = new double[6];
   class="kw">private class="kw">final RailPathSmoother.HitSide[] targetContactSampleSides = new RailPathSmoother.HitSide[6];
   class="kw">private class="kw">final RailPathSmoother.ContactContext railContactContext = new RailPathSmoother.ContactContext();
   class="kw">private double lastRefreshTargetDistance = Double.NaN;
   class="kw">private boolean lastRefreshContactDroppedNearTarget;
   class="kw">private class="kw">final RailPathSmoother.ContactContext retainedContactContext = new RailPathSmoother.ContactContext();
   class="kw">private class="kw">final Vector3d retainedContactProbeStartPosition = new Vector3d();
   class="kw">private boolean hasRetainedContactContext;
   class="kw">private double retainedContactTargetDistance = Double.NaN;
   class="kw">private double activeChargeDistance;
   class="kw">private boolean hasProbeEndPosition;
   class="kw">private boolean hasLaunchChargeReference;

   class="kw">public BodyMotionCharge(@Nonnull BuilderBodyMotionCharge var1, @Nonnull BuilderSupport var2) {
      super(var1);
      this.relativeTurnSpeed = var1.getRelativeTurnSpeed(var2);
      this.lockedOnHalfAngleRad = var1.getLockedOnHalfAngleRadians(var2);
      this.lockedOnDurationRange = var1.getLockedOnDurationRange(var2);
      this.windingUpDurationRange = var1.getWindingUpDurationRange(var2);
      this.postChargeDurationRange = var1.getPostChargeDurationRange(var2);
      this.skipLockedOnState = isZeroDurationRange(this.lockedOnDurationRange);
      this.skipWindingUpState = isZeroDurationRange(this.windingUpDurationRange);
      this.chargeDistanceRange = var1.getChargeDistanceRange(var2);
      this.windingUpUninterruptable = var1.isWindingUpUninterruptable(var2);
      this.windingUpRelativeTurnSpeed = var1.getWindingUpRelativeTurnSpeed(var2);
      this.chargeRelativeSpeed = var1.getChargeRelativeSpeed(var2);
      this.activeChargeDistance = Math.max(1.0, RandomExtra.randomRange(this.chargeDistanceRange));
      this.clearOnceOnStateChange = var1.isClearOnceOnStateChange(var2);
      this.chargeAbsoluteSpeed = var1.getChargeAbsoluteSpeed(var2);
      this.chargeAcceleration = var1.getChargeAcceleration(var2);
      this.ignoredBlockSetTriggers = var1.isIgnoredBlockSetTriggers(var2);
      this.entityStopsCharge = var1.isEntityStopsCharge(var2);
      this.climbSlope = var1.getClimbSlope(var2);
      this.dropSlope = var1.getDropSlope(var2);
      this.horizontalSkipGapWidth = var1.getHorizontalSkipGapWidth(var2);
      this.blockCollisionInteractionId = var1.getBlockCollisionInteraction(var2);
      this.npcCollisionInteractionId = var1.getNPCCollisionInteraction(var2);
      this.playerCollisionInteractionId = var1.getPlayerCollisionInteraction(var2);
      this.repeatCollisionIgnoreDuration = var1.getRepeatCollisionIgnoreDuration(var2);
      this.knockbackThreshold = var1.getKnockbackThreshold(var2);
      this.probeMinInterval = var1.getProbeMinInterval(var2);
      this.probeMaxInterval = var1.getProbeMaxInterval(var2);
      this.probeMinDirectionChange = var1.getProbeMinDirectionChangeRadians(var2);
      double var3 = var1.getProbeChargeRecomputeDistance(var2);
      if (!(var3 <= 0.0) && Double.isFinite(var3)) {
         this.probeChargeRecomputeDistance = var3;
      } else {
         this.probeChargeRecomputeDistance = Double.POSITIVE_INFINITY;
      }

      this.cosProbeMinDirectionChange = TrigMathUtil.cos(this.probeMinDirectionChange);
      this.ignoredBlockSet = var1.getIgnoredBlockSet(var2);
      this.removedBlockSet = var1.getRemovedBlockSet(var2);
      if (this.ignoredBlockSet == Integer.MIN_VALUE) {
         this.ignoredBlockFilter = null;
      } else {
         int var5 = this.ignoredBlockSet;
         this.ignoredBlockFilter = var1x -> var1x.blockType == null || !BlockSetModule.getInstance().blockInSet(var5, var1x.blockType);
         this.probeMoveData.setBlockCollisionFilter(this.ignoredBlockFilter);
      }

      if (this.removedBlockSet != Integer.MIN_VALUE) {
         int var7 = this.removedBlockSet;
         IntPredicate var6 = var1x -> BlockSetModule.getInstance().blockInSet(var7, var1x);
         this.probeMoveData.setBreathableBlockOverride(var6);
      }

      this.aimingData.requireCloseCombat();
   }

   @Override
   class="kw">public void activate(@Nonnull Ref<EntityStore> var1, @Nonnull ExecutionSupport var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      if (this.debugChargeState) {
         int var4 = -1;
         NetworkId var5 = var3.getComponent(var1, NetworkId.getComponentType());
         if (var5 != null) {
            var4 = var5.getId();
         }

         Role var6 = var2.getRole();
         String var7 = var6 != null ? var6.getRoleName() : null;
         var7 = var7 == null ? "???" : var7;
         NPCPlugin.get().getLogger().at(Level.INFO).log("BodyMotionCharge activating role=%s entityId=%s", var7, var4);
      }

      super.activate(var1, var2, var3);
      this.state = BodyMotionCharge.ChargeState.LostTarget;
      this.sensorVisibleState = BodyMotionCharge.ChargeState.LostTarget;
      MotionController var8 = var2.getMotionContextSupport().getActiveMotionController();
      if (var8 != null) {
         this.updateSizeCompensation(var8);
      }

      this.resetRailState();
   }

   @Override
   class="kw">public void deactivate(@Nonnull Ref<EntityStore> var1, @Nonnull ExecutionSupport var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      super.deactivate(var1, var2, var3);
      this.resetRailState();
      this.sensorVisibleState = BodyMotionCharge.ChargeState.LostTarget;
      if (this.debugChargeState) {
         int var4 = -1;
         NetworkId var5 = var3.getComponent(var1, NetworkId.getComponentType());
         if (var5 != null) {
            var4 = var5.getId();
         }

         Role var6 = var2.getRole();
         String var7 = var6 != null ? var6.getRoleName() : null;
         var7 = var7 == null ? "???" : var7;
         NPCPlugin.get().getLogger().at(Level.INFO).log("BodyMotionCharge deactivating role=%s entityId=%s", var7, var4);
      }
   }

   @Override
   class="kw">public void motionControllerChanged(
      @Nullable Ref<EntityStore> var1, @Nonnull NPCEntity var2, MotionController var3, @Nullable ComponentAccessor<EntityStore> var4
   ) {
      super.motionControllerChanged(var1, var2, var3, var4);
      this.updateSizeCompensation(var3);
   }

   class="kw">private void updateSizeCompensation(@Nonnull MotionController var1) {
      double var2 = NPCPhysicsMath.getMaxBoundingBoxExtent(var1.getCollisionBoundingBox(), var1.getComponentSelector());
      this.probeSizeCompensation = var2 / 2.0;
   }

   class="kw">private void resetRailState() {
      this.chargeSpeed = 0.0;
      this.railPath.reset();
      this.candidateRailPath.reset();
      this.railPathSmoother.reset();
      this.smootherConfig.reset();
      this.railResult.reset();
      this.railConfig.candidateEntities = null;
      this.candidateEntitiesBuffer.clear();
      this.filteredEntityHits.clear();
      this.acceptedEntityHitIndexes.clear();
      this.lastEntityCollisionHitTimes.clear();
      this.hasProbeEndPosition = false;
      this.chargeDistanceSinceLastRailRefresh = 0.0;
      this.hasLaunchChargeReference = false;
      this.railContactContext.reset();
      this.lastRefreshTargetDistance = Double.NaN;
      this.lastRefreshContactDroppedNearTarget = false;
      this.retainedContactContext.reset();
      this.retainedContactProbeStartPosition.zero();
      this.hasRetainedContactContext = false;
      this.retainedContactTargetDistance = Double.NaN;
   }

   @Override
   class="kw">public void loaded(ExecutionSupport var1) {
      super.loaded(var1);
      if (this.clearOnceOnStateChange && this.parent class="kw">instanceof Instruction var2 && var2.getParent() class="kw">instanceof Instruction var5) {
         this.parentInstruction = var5;
      }
   }

   @Override
   class="kw">public void registerWithSupport(ExecutionSupport var1) {
      super.registerWithSupport(var1);
      DebugSupport var2 = var1.getDebugSupport();
      var2.registerDebugFlagsListener(this);
      this.onDebugFlagsChanged(var2.getDebugFlags());
      var1.getPositionCache().requirePlayerDistanceUnsorted(14.8F);
      var1.getPositionCache().requireEntityDistanceUnsorted(14.8F);
   }

   @Override
   class="kw">public void preComputeSteering(@Nonnull Ref<EntityStore> var1, @Nonnull ExecutionSupport var2, @Nullable InfoProvider var3, @Nonnull Store<EntityStore> var4) {
      if (var3 != null) {
         var3.passExtraInfo(this.aimingData);
      }
   }

   @Override
   class="kw">public boolean computeSteering(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull ExecutionSupport var2,
      @Nullable InfoProvider var3,
      double var4,
      @Nonnull Steering var6,
      @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      if (var3 != null && var3.getPositionProvider() != null) {
         this.timeSinceHaveTarget += var4;
         Ref var8 = var3.getPositionProvider().getTarget();
         boolean var9 = var8 != null && var3.getPositionProvider().providePosition(this.targetPosition);
         if (this.state == BodyMotionCharge.ChargeState.LostTarget) {
            this.sensorVisibleState = BodyMotionCharge.ChargeState.LostTarget;
            var6.clear();
            this.clearEntityCollisionHits();
            if (!var9) {
               class="kw">return true;
            }

            this.activeChargeDistance = Math.max(1.0, RandomExtra.randomRange(this.chargeDistanceRange));
            this.aimingData.setChargeDistance(this.activeChargeDistance);
            this.transitionChargeState(BodyMotionCharge.ChargeState.Aiming, var1, var2, var7, "have target");
            this.lastProbeTime = -Double.MAX_VALUE;
            this.timeSinceHaveTarget = 0.0;
         }

         TransformComponent var10 = var7.getComponent(var1, TRANSFORM_COMPONENT_TYPE);
         assert var10 != null;
         Vector3d var11 = var10.getPosition();
         Rotation3f var12 = var10.getRotation();
         MotionController var13 = var2.getMotionContextSupport().getActiveMotionController();
         if (var13 == null) {
            class="kw">return false;
         }

         double var14 = var9 ? var13.waypointDistanceSquared(var11, this.targetPosition) : Double.MAX_VALUE;
         boolean var16;
         if (var14 <= this.activeChargeDistance * this.activeChargeDistance) {
            var16 = this.aimingData.computeSolution(var11, this.targetPosition, null);
         } else {
            var16 = false;
         }

         if (this.state == BodyMotionCharge.ChargeState.Aiming) {
            this.sensorVisibleState = BodyMotionCharge.ChargeState.Aiming;
            if (!var9) {
               this.transitionChargeState(BodyMotionCharge.ChargeState.LostTarget, var1, var2, var7, "no target");
               class="kw">return true;
            }

            if (var16) {
               turnTo(var6, this.aimingData, this.relativeTurnSpeed);
               if (this.aimingData.isOnTarget(var12.yaw(), var12.pitch(), this.lockedOnHalfAngleRad)
                  && this.isReachable(var1, var7, var11, var12, var13, var8, this.targetPosition, var14)) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.LockedOn, var1, var2, var7, "on target");
               }

               class="kw">return true;
            } else {
               NPCPhysicsMath.rotationFromDirection(var11, this.targetPosition, var12, this.rotation);
               turnTo(var6, this.rotation, this.relativeTurnSpeed);
               class="kw">return true;
            }
         } else if (this.state == BodyMotionCharge.ChargeState.LockedOn) {
            this.sensorVisibleState = BodyMotionCharge.ChargeState.LockedOn;
            if (var9 && var16) {
               turnTo(var6, this.aimingData, this.relativeTurnSpeed);
               if (this.aimingData.isOnTarget(var12.yaw(), var12.pitch(), this.lockedOnHalfAngleRad)
                  && this.isReachable(var1, var7, var11, var12, var13, var8, this.targetPosition, var14)) {
                  if (this.isPhaseOver()) {
                     this.transitionChargeState(BodyMotionCharge.ChargeState.WindingUp, var1, var2, var7, null);
                  }

                  class="kw">return true;
               } else {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.Aiming, var1, var2, var7, "not reachable/not on target");
                  class="kw">return true;
               }
            } else {
               this.transitionChargeState(BodyMotionCharge.ChargeState.LostTarget, var1, var2, var7, "no solution");
               class="kw">return true;
            }
         } else if (this.state == BodyMotionCharge.ChargeState.WindingUp) {
            this.sensorVisibleState = BodyMotionCharge.ChargeState.WindingUp;
            if (this.windingUpUninterruptable) {
               if (var9) {
                  NPCPhysicsMath.rotationFromDirection(var11, this.targetPosition, var12, this.rotation);
                  turnTo(var6, this.rotation, this.windingUpRelativeTurnSpeed);
               } else {
                  turnTo(var6, var12, this.windingUpRelativeTurnSpeed);
               }

               if (this.isPhaseOver()) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.Launch, var1, var2, var7, null);
               }

               class="kw">return true;
            } else if (!var16) {
               this.transitionChargeState(BodyMotionCharge.ChargeState.LostTarget, var1, var2, var7, "lost target/no solution (interruptable)");
               class="kw">return true;
            } else {
               turnTo(var6, this.aimingData, this.windingUpRelativeTurnSpeed);
               if (!this.isPhaseOver()) {
                  class="kw">return true;
               } else if (this.aimingData.isOnTarget(var12.yaw(), var12.pitch(), this.lockedOnHalfAngleRad)
                  && this.isReachable(var1, var7, var11, var12, var13, var8, this.targetPosition, var14)) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.Launch, var1, var2, var7, null);
                  class="kw">return true;
               } else {
                  this.transitionChargeState(
                     this.skipLockedOnState ? BodyMotionCharge.ChargeState.Aiming : BodyMotionCharge.ChargeState.LockedOn,
                     var1,
                     var2,
                     var7,
                     "off target/unreachable"
                  );
                  class="kw">return true;
               }
            }
         } else {
            if (this.state == BodyMotionCharge.ChargeState.Launch) {
               this.sensorVisibleState = BodyMotionCharge.ChargeState.Launch;
               clearAccumulatedFallDistance(var1, var7);
               this.computeSmoothedChargeRail(var1, var7, var12, var11, var13, this.activeChargeDistance, var8, var9, this.railPath, this.visChargeProbe);
               this.updateLaunchChargeReference(var11);
               this.chargeSpeed = 0.0;
               this.chargeDistanceSinceLastRailRefresh = 0.0;
               this.transitionChargeState(BodyMotionCharge.ChargeState.Charging, var1, var2, var7, null);
               class="kw">return true;
            }

            if (this.state == BodyMotionCharge.ChargeState.Charging) {
               this.sensorVisibleState = BodyMotionCharge.ChargeState.Charging;
               var6.clear();
               clearAccumulatedFallDistance(var1, var7);
               if (var13.isForcePushed()) {
                  double var17 = var13.getCombinedExternalVelocityLength();
                  boolean var19 = var17 < this.knockbackThreshold;
                  if (this.debugChargeState) {
                     int var20 = -1;
                     NetworkId var21 = var7.getComponent(var1, NetworkId.getComponentType());
                     if (var21 != null) {
                        var20 = var21.getId();
                     }

                     NPCPlugin.get()
                        .getLogger()
                        .at(Level.INFO)
                        .log(
                           "BodyMotionCharge knockback check entityId=%s role=%s knockbackAmount=%.5f threshold=%.5f ignored=%s",
                           var20,
                           var2.getName(),
                           var17,
                           this.knockbackThreshold,
                           var19
                        );
                  }

                  if (!var19) {
                     this.transitionChargeState(BodyMotionCharge.ChargeState.Knockback, var1, var2, var7, "force pushed");
                     class="kw">return true;
                  }

                  var13.clearExternalForces();
               }

               if (this.railPath.isFinished()) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.Finished, var1, var2, var7, null);
                  class="kw">return true;
               }

               double var31 = this.getEffectiveMaximumChargeSpeed(var13);
               this.chargeSpeed = Math.min(this.chargeSpeed + this.chargeAcceleration * var4, var31);
               double var32 = this.chargeSpeed * var4;
               this.railPath.snapY(var11);
               int var33 = this.railPath.getCursor();
               double var22 = this.railPath.getSegmentProgress();
               this.railPath.advance(var11, var32, this.railDelta);
               boolean var24 = this.railPath.getCursor() != var33 || var22 <= 1.0E-6 && this.railPath.getSegmentProgress() > 1.0E-6;
               this.renderChargePathDebug(var7, var11, var24);
               this.populateCandidateEntities(var1, var2, var7);
               this.railConfig.ignoredBlockFilter = this.ignoredBlockFilter;
               this.railConfig.ignoredBlocksFireTriggers = this.ignoredBlockSetTriggers;
               this.railConfig.stopOnEntityHit = this.entityStopsCharge;
               this.railConfig.candidateEntities = this.candidateEntitiesBuffer.isEmpty() ? null : this.candidateEntitiesBuffer;

               try {
                  Role var25 = var2.getRole();
                  assert var25 != null;
                  var13.applyRailStep(var1, var25, this.railDelta, this.railConfig, this.railResult, var7);
                  this.computePassThroughHitsFromOverlappingIgnoredBlocks(var11, var13, var7);
                  if (this.visChargeEntityHits) {
                     int var26 = -1;
                     NetworkId var27 = var7.getComponent(var1, NetworkId.getComponentType());
                     if (var27 != null) {
                        var26 = var27.getId();
                     }

                     if (this.railResult.getPassThroughCount() > 0) {
                        NPCPlugin.get()
                           .getLogger()
                           .at(Level.INFO)
                           .log(
                              "BodyMotionCharge block collisions role=%s entityId=%s count=%d appliedFraction=%.5f obstructed=%s",
                              var25.getRoleName(),
                              var26,
                              this.railResult.getPassThroughCount(),
                              this.railResult.appliedFraction,
                              this.railResult.obstructed
                           );
                     }
                  }

                  clearAccumulatedFallDistance(var1, var7);
                  this.refreshEntityCollisionHits();
                  this.chargeDistanceSinceLastRailRefresh = this.chargeDistanceSinceLastRailRefresh + this.railDelta.length() * this.railResult.appliedFraction;
               } class="kw">finally {
                  this.railConfig.candidateEntities = null;
                  this.candidateEntitiesBuffer.clear();
               }

               this.renderChargeCollisionDebug(var7);
               this.executeBlockCollisionInteraction(var1, var7);
               this.executeEntityCollisionInteraction(var1, var7);
               if (this.railResult.obstructed) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.Obstructed, var1, var2, var7, null);
                  class="kw">return true;
               } else if (this.railResult.hitEntity) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.EntityHit, var1, var2, var7, null);
                  class="kw">return true;
               } else if (this.railPath.isFinished()) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.Finished, var1, var2, var7, null);
                  class="kw">return true;
               } else if (this.hasPassedLaunchChargeEndPlane(var11)) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.Finished, var1, var2, var7, null);
                  class="kw">return true;
               } else {
                  this.refreshChargeRailIfNeeded(var1, var7, var11, var12, var13, var8, var9, this.getRemainingDistanceToLaunchReference(var11));
                  class="kw">return true;
               }
            } else {
               if (this.state != BodyMotionCharge.ChargeState.Knockback
                  && this.state != BodyMotionCharge.ChargeState.EntityHit
                  && this.state != BodyMotionCharge.ChargeState.Obstructed
                  && this.state != BodyMotionCharge.ChargeState.Finished) {
                  this.sensorVisibleState = this.state;
                  class="kw">return true;
               }

               this.sensorVisibleState = this.state;
               var6.clear();
               this.clearEntityCollisionHits();
               if (this.isPhaseOver()) {
                  this.transitionChargeState(BodyMotionCharge.ChargeState.LostTarget, var1, var2, var7, null);
               }

               class="kw">return true;
            }
         }
      } else {
         class="kw">return false;
      }
   }

   class="kw">private class="kw">static void clearAccumulatedFallDistance(@Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1) {
      ComponentType var2 = NPCEntity.getComponentType();
      assert var2 != null;
      NPCEntity var3 = var1.getComponent(var0, var2);
      if (var3 != null && var3.getCurrentFallDistance() > 0.0) {
         var3.setCurrentFallDistance(0.0);
      }
   }

   class="kw">private boolean shouldProbe(Vector3d var1, MotionController var2) {
      if (this.timeSinceHaveTarget >= this.lastProbeTime + this.probeMaxInterval) {
         class="kw">return true;
      } else {
         class="kw">return this.timeSinceHaveTarget < this.lastProbeTime + this.probeMinInterval
            ? false
            : !NPCPhysicsMath.isInViewCone(var1, this.lastProbeDirection, this.cosProbeMinDirectionChange, this.targetPosition, var2.getComponentSelector());
      }
   }

   class="kw">private boolean isReachable(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull ComponentAccessor<EntityStore> var2,
      @Nonnull Vector3d var3,
      @Nonnull Rotation3f var4,
      @Nonnull MotionController var5,
      @Nullable Ref<EntityStore> var6,
      @Nonnull Vector3d var7,
      double var8
   ) {
      boolean var10 = false;
      boolean var11 = this.lastProbeBoundingBoxesOverlapped && this.lastProbeDistanceSquared >= var8;
      if (this.shouldProbe(var3, var5)) {
         var10 = true;
         this.lastProbeTime = this.timeSinceHaveTarget;
         double var12 = this.probeCharge(var1, var2, var4, var3, var5) + this.probeSizeCompensation;
         this.lastProbeDistanceSquared = var12 * var12;
         this.lastProbeBoundingBoxesOverlapped = false;
         this.railContactContext.reset();
         var11 = this.lastProbeDistanceSquared >= var8;
         if (var11 && var6 != null) {
            this.lastProbeBoundingBoxesOverlapped = this.updateTargetContactContext(var2, var5, var6, var7, var8, var3);
            var11 = this.lastProbeBoundingBoxesOverlapped;
            if (!var11) {
               this.lastProbeDistanceSquared = Double.MAX_VALUE;
            }
         }
      }

      if (this.visChargeProbe) {
         boolean var14 = this.isTargetOutsideProbeViewCone(var3, var5);
         this.renderChargeProbeDebug(var2, var3, this.targetPosition, var11, var14, var10);
      }

      class="kw">return var11;
   }

   class="kw">private void refreshChargeRailIfNeeded(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull ComponentAccessor<EntityStore> var2,
      @Nonnull Vector3d var3,
      @Nonnull Rotation3f var4,
      @Nonnull MotionController var5,
      @Nullable Ref<EntityStore> var6,
      boolean var7,
      double var8
   ) {
      if (var5.is2D()) {
         if (!(this.chargeDistanceSinceLastRailRefresh < this.probeChargeRecomputeDistance)) {
            if (!(var8 <= 1.0E-6)) {
               this.chargeDistanceSinceLastRailRefresh = this.chargeDistanceSinceLastRailRefresh - this.probeChargeRecomputeDistance;
               RailPathRefreshResolver.RefreshDecision var10 = RailPathRefreshResolver.resolve(
                  this.railPath,
                  this.candidateRailPath,
                  var3,
                  var8,
                  0.05,
                  this.railReplanAnchorPosition,
                  var1x -> this.hasLaunchChargeReference
                     ? computeRemainingDistanceToLaunchEndPlane(var1x, this.launchChargeEndReference, this.launchChargePlaneNormal)
                     : this.railPath.getRemainingDistance(),
                  (var7x, var8x) -> this.computeSmoothedChargeRailForRefresh(
                     var1, var2, var4, var7x, var5, var8x, var6, var7, this.candidateRailPath, this.visChargeProbe
                  ),
                  this::isLastProbeBlocked,
                  this::isRailReplacementAllowed
               );
               if (this.debugChargePath) {
                  NPCPlugin.get()
                     .getLogger()
                     .at(Level.INFO)
                     .log(
                        "[NPC] BodyMotionCharge rail refresh entityId=%s replaced=%s committedTraversal=%s commitType=%s blocked=%s unreachable=%s",
                        getNetworkId(var1, var2),
                        var10.replaced(),
                        var10.committedAnchor(),
                        var10.commitType(),
                        var10.blocked(),
                        var10.unreachable()
                     );
               }
            }
         }
      }
   }

   class="kw">private void updateLaunchChargeReference(@Nonnull Vector3dc var1) {
      this.hasLaunchChargeReference = false;
      int var2 = this.railPath.getWaypointCount();
      if (var2 > 0) {
         this.launchChargeStartReference.set(var1);
         this.launchChargeEndReference.set(this.railPath.getWaypoint(var2 - 1));
         this.launchChargePlaneNormal.set(this.launchChargeEndReference).sub(this.launchChargeStartReference);
         if (!(this.launchChargePlaneNormal.lengthSquared() <= 1.0E-12)) {
            this.launchChargePlaneNormal.normalize();
            this.hasLaunchChargeReference = true;
         }
      }
   }

   class="kw">private double getRemainingDistanceToLaunchReference(@Nonnull Vector3dc var1) {
      class="kw">return !this.hasLaunchChargeReference
         ? this.railPath.getRemainingDistance()
         : computeRemainingDistanceToLaunchEndPlane(var1, this.launchChargeEndReference, this.launchChargePlaneNormal);
   }

   class="kw">private boolean hasPassedLaunchChargeEndPlane(@Nonnull Vector3dc var1) {
      if (!this.hasLaunchChargeReference) {
         class="kw">return false;
      }

      this.chargeProbeEndDirection.set(var1).sub(this.launchChargeEndReference);
      class="kw">return this.chargeProbeEndDirection.dot(this.launchChargePlaneNormal) >= -1.0E-6;
   }

   class="kw">static double computeRemainingDistanceToLaunchEndPlane(@Nonnull Vector3dc var0, @Nonnull Vector3dc var1, @Nonnull Vector3dc var2) {
      double var3 = var0.x() - var1.x();
      double var5 = var0.y() - var1.y();
      double var7 = var0.z() - var1.z();
      double var9 = var3 * var2.x() + var5 * var2.y() + var7 * var2.z();
      class="kw">return var9 >= 0.0 ? 0.0 : -var9;
   }

   class="kw">private double computeSmoothedChargeRailForRefresh(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull ComponentAccessor<EntityStore> var2,
      @Nonnull Rotation3f var3,
      @Nonnull Vector3dc var4,
      @Nonnull MotionController var5,
      double var6,
      @Nullable Ref<EntityStore> var8,
      boolean var9,
      @Nonnull RailPath var10,
      boolean var11
   ) {
      this.railRefreshProbeStartPosition.set(var4);
      class="kw">return this.computeSmoothedChargeRail(var1, var2, var3, this.railRefreshProbeStartPosition, var5, var6, var8, var9, var10, var11);
   }

   class="kw">private double computeSmoothedChargeRail(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull ComponentAccessor<EntityStore> var2,
      @Nonnull Rotation3f var3,
      @Nonnull Vector3d var4,
      @Nonnull MotionController var5,
      double var6,
      @Nullable Ref<EntityStore> var8,
      boolean var9,
      @Nonnull RailPath var10,
      boolean var11
   ) {
      double var12 = this.probeCharge(var1, var2, var3, var4, var5, var6);
      double var14 = var9 ? var5.waypointDistanceSquared(var4, this.targetPosition) : Double.POSITIVE_INFINITY;
      double var16 = var12 + this.probeSizeCompensation;
      this.lastRefreshTargetDistance = var9 ? Math.sqrt(var14) : Double.NaN;
      boolean var18 = this.hasRetainedContactContext;
      this.lastRefreshContactDroppedNearTarget = false;
      if (var9 && var16 * var16 >= var14) {
         this.updateTargetContactContext(var2, var5, var8, this.targetPosition, var14, var4);
      } else {
         this.railContactContext.reset();
      }

      if (this.railContactContext.valid) {
         this.retainedContactContext.setFrom(this.railContactContext);
         this.retainedContactProbeStartPosition.set(var4);
         this.hasRetainedContactContext = true;
         this.retainedContactTargetDistance = this.lastRefreshTargetDistance;
      } else if (this.canReuseRetainedContactContext(var4)) {
         this.railContactContext.setFrom(this.retainedContactContext);
      } else {
         this.retainedContactContext.reset();
         this.hasRetainedContactContext = false;
         this.retainedContactTargetDistance = Double.NaN;
      }

      if (!this.railContactContext.valid && var18 && Double.isFinite(this.lastRefreshTargetDistance) && this.lastRefreshTargetDistance <= 1.5) {
         this.lastRefreshContactDroppedNearTarget = true;
      }

      if (var11) {
         this.renderChargeProbeDebug(var2, var4, this.targetPosition, var12 * var12 >= var14, this.isTargetOutsideProbeViewCone(var4, var5), true);
      }

      this.smootherConfig.climbSlope = this.climbSlope;
      this.smootherConfig.dropSlope = this.dropSlope;
      this.smootherConfig.horizontalSkipGapWidth = this.horizontalSkipGapWidth;
      this.smootherConfig.blockedWallEndOffset = this.computeBlockedWallEndOffset(var6, var12);
      this.railPathSmoother.smooth(this.probeMoveData, var5, this.smootherConfig, this.railContactContext);
      var10.capture(this.railPathSmoother.getWaypoints(), this.railPathSmoother.getWaypointSegmentCommitTypes(), this.railPathSmoother.getWaypointCount());
      class="kw">return var12;
   }

   class="kw">private boolean isLastProbeBlocked() {
      if (this.probeMoveData.segmentCount > 0 && this.probeMoveData.segments != null) {
         ProbeMoveData.Segment var1 = this.probeMoveData.segments[this.probeMoveData.segmentCount - 1];
         class="kw">return var1 == null || var1.type == null || !var1.type.isBlocked()
            ? false
            : !this.railContactContext.valid
               || !Double.isFinite(this.railContactContext.hitDistanceS)
               || !(var1.distance > this.railContactContext.hitDistanceS + 1.0E-6);
      } else {
         class="kw">return false;
      }
   }

   class="kw">private boolean isRailReplacementAllowed() {
      class="kw">return !this.lastRefreshContactDroppedNearTarget;
   }

   class="kw">private boolean canReuseRetainedContactContext(@Nonnull Vector3dc var1) {
      if (!this.hasRetainedContactContext || !this.retainedContactContext.valid) {
         class="kw">return false;
      } else if (!Double.isFinite(this.lastRefreshTargetDistance) || !Double.isFinite(this.retainedContactTargetDistance)) {
         class="kw">return false;
      } else if (this.lastRefreshTargetDistance > 1.5) {
         class="kw">return false;
      } else {
         class="kw">return Math.abs(this.lastRefreshTargetDistance - this.retainedContactTargetDistance) > 1.0
            ? false
            : this.retainedContactProbeStartPosition.distance(var1) <= 0.5;
      }
   }

   class="kw">private double computeBlockedWallEndOffset(double var1, double var3) {
      if (this.probeSizeCompensation <= 0.0) {
         class="kw">return 0.0;
      }

      double var5 = var1 - var3;
      class="kw">return var5 <= 0.0 ? 0.0 : Math.min(this.probeSizeCompensation, var5);
   }

   @Nullable
   class="kw">private class="kw">static Integer getNetworkId(@Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1) {
      NetworkId var2 = var1.getComponent(var0, NetworkId.getComponentType());
      class="kw">return var2 != null ? var2.getId() : null;
   }

   class="kw">private double probeCharge(
      @Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2, Rotation3f var3, Vector3d var4, MotionController var5
   ) {
      class="kw">return this.probeCharge(var1, var2, var3, var4, var5, this.activeChargeDistance);
   }

   class="kw">private double probeCharge(
      @Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2, Rotation3f var3, Vector3d var4, MotionController var5, double var6
   ) {
      PhysicsMath.vectorFromAngles(var3.yaw(), var3.pitch(), this.chargeDirection);
      this.chargeDirection.normalize(var6);
      this.chargeStartPosition.set(var4);
      this.chargeEndPosition.set(this.chargeStartPosition).add(this.chargeDirection);
      this.lastProbeDirection.set(this.chargeDirection).mul(var5.getComponentSelector()).normalize();
      this.probeMoveData.setSaveSegments(true);
      double var8 = var5.probeMove(var1, this.chargeStartPosition, this.chargeDirection, this.probeMoveData, var2);
      this.chargeProbeEndPosition.set(this.probeMoveData.probePosition);
      this.hasProbeEndPosition = true;
      this.probeMoveData.setSaveSegments(false);
      class="kw">return var8;
   }

   class="kw">private void renderChargeProbeDebug(
      @Nonnull ComponentAccessor<EntityStore> var1, @Nonnull Vector3dc var2, @Nonnull Vector3dc var3, boolean var4, boolean var5, boolean var6
   ) {
      World var7 = var1.getExternalData().getWorld();
      Vector3f var8 = var4 && !var5 ? DebugUtils.COLOR_LIME : DebugUtils.COLOR_RED;
      float var9 = var6 ? 1.0F : 0.45F;
      this.chargeProbeArrowOrigin.set(var2);
      this.chargeProbeTargetDirection.set(var3).sub(var2);
      if (this.chargeProbeTargetDirection.lengthSquared() > 1.0E-12) {
         DebugUtils.addArrow(var7, this.chargeProbeArrowOrigin, this.chargeProbeTargetDirection, var8, var9, 0.05F, 0);
      }

      if (this.hasProbeEndPosition) {
         this.chargeProbeEndDirection.set(this.chargeProbeEndPosition).sub(var2);
         if (this.chargeProbeEndDirection.lengthSquared() > 1.0E-12) {
            DebugUtils.addArrow(var7, this.chargeProbeArrowOrigin, this.chargeProbeEndDirection, var8, var9, 0.05F, 0);
         }

         DebugUtils.addSphere(var7, this.chargeProbeEndPosition.x, this.chargeProbeEndPosition.y, this.chargeProbeEndPosition.z, var8, var9, 1.0, 0.05F);
      }
   }

   class="kw">private boolean isTargetOutsideProbeViewCone(@Nonnull Vector3d var1, @Nonnull MotionController var2) {
      class="kw">return !NPCPhysicsMath.isInViewCone(var1, this.lastProbeDirection, this.cosProbeMinDirectionChange, this.targetPosition, var2.getComponentSelector());
   }

   class="kw">private boolean updateTargetContactContext(
      @Nonnull ComponentAccessor<EntityStore> var1,
      @Nonnull MotionController var2,
      @Nullable Ref<EntityStore> var3,
      @Nonnull Vector3d var4,
      double var5,
      @Nonnull Vector3dc var7
   ) {
      this.railContactContext.reset();
      if (var3 == null) {
         class="kw">return false;
      }

      BoundingBox var8 = var1.getComponent(var3, BoundingBox.getComponentType());
      if (var8 == null) {
         class="kw">return false;
      }

      this.npcWorldBoundingBox.assign(var2.getCollisionBoundingBox());
      this.targetWorldBoundingBox.assign(var8.getBoundingBox()).offset(var4);
      double var9 = NPCPhysicsMath.getMinBoundingBoxDistance(this.npcWorldBoundingBox, this.targetWorldBoundingBox, var2.getComponentSelector());
      if (var9 <= 0.0) {
         class="kw">return false;
      }

      this.railContactContext.contactWindowHalfWidth = MathUtil.clamp(var9, 1.0E-6, 1.5);
      double var11 = Math.sqrt(var5);
      assert this.probeMoveData.segments != null;
      double var13 = this.probeMoveData.segments[this.probeMoveData.segmentCount - 1].distance;
      int var15 = TargetContactSamplePlanner.planSamples(
         this.probeMoveData, var11, var9, var13, 0.001, this.targetContactSampleScratch, this.targetContactSampleDistances, this.targetContactSampleSides
      );

      for (int var16 = 0; var16 < var15; var16++) {
         if (this.tryContactSample(this.targetContactSampleDistances[var16], this.targetContactSampleSides[var16], var2, var7, var13)) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">private boolean tryContactSample(double var1, @Nonnull RailPathSmoother.HitSide var3, @Nonnull MotionController var4, @Nonnull Vector3dc var5, double var6) {
      double var8 = MathUtil.clamp(var1, 0.0, var6);
      if (!this.probeMoveData.computePosition(var8, this.expectedHitPosition)) {
         class="kw">return false;
      }

      this.npcWorldBoundingBox.assign(var4.getCollisionBoundingBox()).offset(this.expectedHitPosition);
      boolean var10 = this.npcWorldBoundingBox.isIntersecting(this.targetWorldBoundingBox);
      if (!var10) {
         class="kw">return false;
      }

      this.updateContactContext(var8, this.expectedHitPosition.y, var3, var5);
      class="kw">return true;
   }

   class="kw">private void updateContactContext(double var1, double var3, @Nonnull RailPathSmoother.HitSide var5, @Nonnull Vector3dc var6) {
      assert this.probeMoveData.initialPosition.distanceSquared(var6) <= 1.0E-12;
      this.railContactContext.valid = true;
      this.railContactContext.hitDistanceS = var1;
      this.railContactContext.hitY = var3;
      this.railContactContext.hitSide = var5;
      this.railContactContext.hitSegmentIndex = -1;
      if (this.probeMoveData.locateSegmentAtDistance(var1, this.hitSegmentLocation)) {
         this.railContactContext.hitSegmentIndex = this.hitSegmentLocation.segmentIndex;
      }
   }

   class="kw">private void transitionChargeState(
      @Nonnull BodyMotionCharge.ChargeState var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull ExecutionSupport var3,
      @Nonnull ComponentAccessor<EntityStore> var4,
      @Nullable String var5
   ) {
      if (var1 != this.state) {
         BodyMotionCharge.ChargeState var6 = this.state;
         if (var1 == BodyMotionCharge.ChargeState.LockedOn && this.skipLockedOnState) {
            var1 = BodyMotionCharge.ChargeState.WindingUp;
         }

         if (var1 == BodyMotionCharge.ChargeState.WindingUp && this.skipWindingUpState) {
            var1 = BodyMotionCharge.ChargeState.Launch;
         }

         class="kw">switch (var1) {
            case LockedOn:
               this.initPhaseDuration(this.lockedOnDurationRange);
            case LostTarget:
            case Launch:
            case Charging:
            class="kw">default:
               break;
            case WindingUp:
               this.initPhaseDuration(this.windingUpDurationRange);
               break;
            case Obstructed:
            case EntityHit:
            case Knockback:
            case Finished:
               this.initPhaseDuration(this.postChargeDurationRange);
         }

         if (this.parentInstruction != null) {
            this.parentInstruction.clearOnce();
         }

         if (this.debugChargeState) {
            renderChargeOutcomeDebugMarkerIfNeeded(var6, var1, var2, var4);
         }

         if (this.debugChargeState) {
            int var7 = -1;
            NetworkId var8 = var4.getComponent(var2, NetworkId.getComponentType());
            if (var8 != null) {
               var7 = var8.getId();
            }

            Role var9 = var3.getRole();
            String var10 = var9 != null ? var9.getRoleName() : null;
            var10 = var10 == null ? "???" : var10;
            NPCPlugin.get()
               .getLogger()
               .at(Level.INFO)
               .log("BodyMotionCharge state %s -> %s role=%s entityId=%s reason=%s", this.state, var1, var10, var7, var5 != null ? var5 : "<no reason>");
         }

         this.state = var1;
      }
   }

   class="kw">private class="kw">static void renderChargeOutcomeDebugMarkerIfNeeded(
      @Nonnull BodyMotionCharge.ChargeState var0,
      @Nonnull BodyMotionCharge.ChargeState var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      if (var0 == BodyMotionCharge.ChargeState.Charging) {
         Vector3f var4 = class="kw">switch (var1) {
            case Obstructed -> DebugUtils.COLOR_RED;
            case EntityHit -> DebugUtils.COLOR_GREEN;
            case Knockback -> DebugUtils.COLOR_CYAN;
            case Finished -> DebugUtils.COLOR_WHITE;
            class="kw">default -> null;
         };
         if (var4 != null) {
            TransformComponent var5 = var3.getComponent(var2, TRANSFORM_COMPONENT_TYPE);
            if (var5 != null) {
               Vector3d var6 = var5.getPosition();
               World var7 = var3.getExternalData().getWorld();
               DebugUtils.addSphere(var7, var6.x, var6.y, var6.z, var4, 1.0, 5.0F);
            }
         }
      }
   }

   class="kw">private void computePassThroughHitsFromOverlappingIgnoredBlocks(
      @Nonnull Vector3d var1, @Nonnull MotionController var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      if (this.ignoredBlockSet != Integer.MIN_VALUE && this.railResult.getPassThroughCount() != 0) {
         World var4 = var3.getExternalData().getWorld();
         this.npcWorldBoundingBox.assign(var2.getCollisionBoundingBox());
         if (this.railDelta.lengthSquared() > 1.0E-12) {
            this.computedPassThroughNormal.set(this.railDelta).normalize().negate();
         } else {
            this.computedPassThroughNormal.zero();
         }

         this.tempWorld = var4;

         try {
            this.npcWorldBoundingBox.forEachBlock(var1.x, var1.y, var1.z, 0.0, this, COLLECT_OVERLAPPING_PASS_THROUGH_BLOCK_CONSUMER);
         } class="kw">finally {
            this.tempWorld = null;
         }
      }
   }

   class="kw">private class="kw">static boolean collectOverlappingPassThroughBlock(int var0, int var1, int var2, @Nonnull BodyMotionCharge var3) {
      if (var3.hasPassThroughBlock(var0, var1, var2)) {
         class="kw">return true;
      }

      assert var3.tempWorld != null;
      WorldChunk var4 = var3.tempWorld.getChunkIfInMemory(ChunkUtil.indexChunkFromBlock(var0, var2));
      if (var4 == null) {
         class="kw">return true;
      }

      int var5 = var4.getBlock(var0, var1, var2);
      if (!BlockSetModule.getInstance().blockInSet(var3.ignoredBlockSet, var5)) {
         class="kw">return true;
      }

      var3.computedPassThroughCollisionPoint.set(var0 + 0.5, var1 + 0.5, var2 + 0.5);
      var3.railResult
         .nextPassThrough()
         .assign(var0, var1, var2, var5, var3.computedPassThroughCollisionPoint, var3.computedPassThroughNormal, var3.railResult.appliedFraction);
      class="kw">return true;
   }

   class="kw">private boolean hasPassThroughBlock(int var1, int var2, int var3) {
      int var4 = this.railResult.getPassThroughCount();

      for (int var5 = 0; var5 < var4; var5++) {
         BlockHit var6 = this.railResult.getPassThrough(var5);
         if (var6.blockX == var1 && var6.blockY == var2 && var6.blockZ == var3) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">private void renderChargePathDebug(@Nonnull ComponentAccessor<EntityStore> var1, @Nonnull Vector3dc var2, boolean var3) {
      if (this.visChargePath) {
         if (!(this.railDelta.lengthSquared() <= 1.0E-12)) {
            this.railStepTargetPosition.set(var2).add(this.railDelta);
            Vector3f var4 = var3 ? DebugUtils.COLOR_BLUE : DebugUtils.COLOR_WHITE;
            World var5 = var1.getExternalData().getWorld();
            DebugUtils.addSphere(var5, this.railStepTargetPosition.x, this.railStepTargetPosition.y, this.railStepTargetPosition.z, var4, 0.2, 5.0F);
         }
      }
   }

   class="kw">private void renderChargeCollisionDebug(@Nonnull ComponentAccessor<EntityStore> var1) {
      if (this.visChargeCollisions || this.visChargeEntityHits) {
         World var2 = var1.getExternalData().getWorld();
         if (this.visChargeCollisions) {
            int var3 = this.railResult.getPassThroughCount();

            for (int var4 = 0; var4 < var3; var4++) {
               BlockHit var5 = this.railResult.getPassThrough(var4);
               DebugUtils.addCube(var2, var5.blockX + 0.5, var5.blockY + 0.5, var5.blockZ + 0.5, DebugUtils.COLOR_RED, 0.2, 5.0F);
            }
         }

         int var7 = this.railResult.getEntityHitCount();
         Vector3f var8 = this.visChargeEntityHits ? DebugUtils.COLOR_YELLOW : DebugUtils.COLOR_GREEN;

         for (int var9 = 0; var9 < var7; var9++) {
            EntityHit var6 = this.railResult.getEntityHit(var9);
            if (!this.visChargeEntityHits || this.acceptedEntityHitIndexes.get(var9)) {
               DebugUtils.addCube(var2, var6.targetPosition.x, var6.targetPosition.y, var6.targetPosition.z, var8, 0.2, 5.0F);
            }
         }
      }
   }

   class="kw">private void populateCandidateEntities(@Nonnull Ref<EntityStore> var1, @Nonnull ExecutionSupport var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      this.candidateEntitiesBuffer.clear();
      PositionCache var4 = var2.getPositionCache();
      var4.getPlayers().forEachEntityUnordered(14.8F, NOT_SELF_PREDICATE, COLLECT_ENTITY_CONSUMER, var1, null, this.candidateEntitiesBuffer, var3, var3);
      var4.getNpcs().forEachEntityUnordered(14.8F, NOT_SELF_PREDICATE, COLLECT_ENTITY_CONSUMER, var1, null, this.candidateEntitiesBuffer, var3, var3);
   }

   class="kw">private boolean isPhaseOver() {
      class="kw">return this.timeSinceHaveTarget >= this.phaseEndTime;
   }

   class="kw">private void initPhaseDuration(@Nonnull double[] var1) {
      double var2 = RandomExtra.randomRange(var1);
      this.phaseEndTime = this.timeSinceHaveTarget + var2;
   }

   class="kw">private class="kw">static boolean isZeroDurationRange(@Nonnull double[] var0) {
      class="kw">return var0[0] == 0.0 && var0[1] == 0.0;
   }

   @Nonnull
   class="kw">public BodyMotionCharge.ChargeState getState() {
      class="kw">return this.sensorVisibleState;
   }

   class="kw">public int getBlockHitCount() {
      class="kw">return this.railResult.getPassThroughCount();
   }

   @Nonnull
   class="kw">public BlockHit getBlockHit(int var1) {
      class="kw">return this.railResult.getPassThrough(var1);
   }

   class="kw">public int getEntityHitCount() {
      class="kw">return this.filteredEntityHits.size();
   }

   @Nonnull
   class="kw">public EntityHit getEntityHit(int var1) {
      class="kw">return this.filteredEntityHits.get(var1);
   }

   class="kw">private void executeBlockCollisionInteraction(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      if (this.blockCollisionInteractionId != null) {
         InteractionManager var3 = var2.getComponent(var1, InteractionModule.get().getInteractionManagerComponent());
         if (var3 != null) {
            RootInteraction var4 = RootInteraction.getRootInteractionOrUnknown(this.blockCollisionInteractionId);
            World var5 = var2.getExternalData().getWorld();
            int var6 = this.railResult.getPassThroughCount();

            for (int var7 = 0; var7 < var6; var7++) {
               BlockHit var8 = this.railResult.getPassThrough(var7);
               BlockPosition var9 = new BlockPosition(var8.blockX, var8.blockY, var8.blockZ);
               InteractionContext var10 = InteractionContext.forInteraction(var3, var1, INTERACTION_TYPE, var2);
               var10.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK_RAW, var9);
               var10.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK, var5.getBaseBlock(var9));
               InteractionChain var11 = var3.initChain(INTERACTION_TYPE, var10, var4, -1, var9, false);
               var3.queueExecuteChain(var11);
            }
         }
      }
   }

   class="kw">private void executeEntityCollisionInteraction(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      if (this.npcCollisionInteractionId != null || this.playerCollisionInteractionId != null) {
         InteractionManager var3 = var2.getComponent(var1, InteractionModule.get().getInteractionManagerComponent());
         if (var3 != null) {
            RootInteraction var4 = this.npcCollisionInteractionId != null ? RootInteraction.getRootInteractionOrUnknown(this.npcCollisionInteractionId) : null;
            RootInteraction var5 = this.playerCollisionInteractionId != null
               ? RootInteraction.getRootInteractionOrUnknown(this.playerCollisionInteractionId)
               : null;
            if (var4 != null || var5 != null) {
               int var6 = this.filteredEntityHits.size();

               for (int var7 = 0; var7 < var6; var7++) {
                  EntityHit var8 = this.filteredEntityHits.get(var7);
                  RootInteraction var9 = var8.isPlayer ? var5 : var4;
                  if (var9 != null) {
                     Ref var10 = var8.entity;
                     if (var10 != null && var10.isValid()) {
                        NetworkId var11 = var2.getComponent(var10, NetworkId.getComponentType());
                        int var12 = var11 != null ? var11.getId() : -1;
                        InteractionContext var13 = InteractionContext.forInteraction(var3, var1, INTERACTION_TYPE, var2);
                        var13.getMetaStore().putMetaObject(Interaction.TARGET_ENTITY, var10);
                        InteractionChain var14 = var3.initChain(INTERACTION_TYPE, var13, var9, var12, null, false);
                        var3.queueExecuteChain(var14);
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">private void refreshEntityCollisionHits() {
      this.filteredEntityHits.clear();
      this.acceptedEntityHitIndexes.clear();
      int var1 = this.railResult.getEntityHitCount();
      if (var1 != 0) {
         if (this.repeatCollisionIgnoreDuration <= 0.0) {
            this.lastEntityCollisionHitTimes.clear();

            for (int var10 = 0; var10 < var1; var10++) {
               this.filteredEntityHits.add(this.railResult.getEntityHit(var10));
               this.acceptedEntityHitIndexes.set(var10);
            }
         } else {
            double var2 = this.timeSinceHaveTarget - this.repeatCollisionIgnoreDuration;
            ObjectIterator var4 = this.lastEntityCollisionHitTimes.reference2DoubleEntrySet().iterator();

            while (var4.hasNext()) {
               Entry var5 = (Entry<Ref<EntityStore>>)var4.next();
               Ref var6 = (Ref<EntityStore>)var5.getKey();
               if (var5.getDoubleValue() <= var2 || var6 == null || !var6.isValid()) {
                  var4.remove();
               }
            }

            for (int var11 = 0; var11 < var1; var11++) {
               EntityHit var12 = this.railResult.getEntityHit(var11);
               Ref var7 = var12.entity;
               if (var7 != null && var7.isValid()) {
                  double var8 = this.lastEntityCollisionHitTimes.getOrDefault(var7, Double.NEGATIVE_INFINITY);
                  if (!(this.timeSinceHaveTarget - var8 < this.repeatCollisionIgnoreDuration)) {
                     this.filteredEntityHits.add(var12);
                     this.acceptedEntityHitIndexes.set(var11);
                     this.lastEntityCollisionHitTimes.put(var7, this.timeSinceHaveTarget);
                  }
               }
            }
         }
      }
   }

   class="kw">private void clearEntityCollisionHits() {
      this.filteredEntityHits.clear();
      this.acceptedEntityHitIndexes.clear();
      this.lastEntityCollisionHitTimes.clear();
   }

   class="kw">private double getEffectiveMaximumChargeSpeed(@Nullable MotionController var1) {
      if (this.chargeAbsoluteSpeed > 0.0) {
         class="kw">return this.chargeAbsoluteSpeed;
      }

      double var2 = var1 != null ? var1.getMaximumSpeed() : 0.0;
      class="kw">return this.chargeRelativeSpeed * var2;
   }

   @Override
   class="kw">public void onDebugFlagsChanged(EnumSet<RoleDebugFlags> var1) {
      this.debugChargeState = var1.contains(RoleDebugFlags.ChargeState);
      this.debugChargePath = var1.contains(RoleDebugFlags.ChargePath);
      this.railPathSmoother.setDebug(this.debugChargePath);
      this.visChargePath = var1.contains(RoleDebugFlags.VisChargePath);
      this.visChargeCollisions = var1.contains(RoleDebugFlags.VisChargeCollisions);
      this.visChargeEntityHits = var1.contains(RoleDebugFlags.VisChargeEntityHits);
      this.visChargeProbe = var1.contains(RoleDebugFlags.VisChargeProbe);
   }

   class="kw">private class="kw">static void turnTo(@Nonnull Steering var0, @Nonnull Rotation3f var1, double var2) {
      var0.setYaw(var1.yaw());
      var0.setPitch(var1.pitch());
      var0.setRelativeTurnSpeed(var2);
   }

   class="kw">private class="kw">static void turnTo(@Nonnull Steering var0, @Nonnull AimingData var1, double var2) {
      var0.setYaw(var1.getYaw());
      var0.setPitch(var1.getPitch());
      var0.setRelativeTurnSpeed(var2);
   }

   class="kw">public enum ChargeState class="kw">implements Supplier<String> {
      Aiming("Have a target"),
      LockedOn("Target in range and within view cone"),
      LostTarget("Target lost or out of range"),
      WindingUp("Preparing to charge"),
      Launch("Starting the charge"),
      Charging("Charging"),
      Obstructed("Charge obstructed by something"),
      EntityHit("Charge stopped at an entity"),
      Knockback("Charge obstructed by knockback or other ext force"),
      Finished("Finished charge");

      class="kw">private class="kw">final String description;

      ChargeState(String nullxx) {
         this.description = nullxx;
      }

      class="kw">public String get() {
         class="kw">return this.description;
      }
   }
}