BodyMotionMoveAway.java

package com.hypixel.hytale.server.npc.corecomponents.movement;

import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.math.random.RandomExtra;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.math.vector.Vector3f;
import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
import com.hypixel.hytale.server.core.modules.physics.util.PhysicsMath;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
import com.hypixel.hytale.server.npc.corecomponents.movement.builders.BuilderBodyMotionMoveAway;
import com.hypixel.hytale.server.npc.entities.NPCEntity;
import com.hypixel.hytale.server.npc.movement.Steering;
import com.hypixel.hytale.server.npc.movement.controllers.MotionController;
import com.hypixel.hytale.server.npc.movement.steeringforces.SteeringForceEvade;
import com.hypixel.hytale.server.npc.navigation.AStarBase;
import com.hypixel.hytale.server.npc.navigation.AStarNode;
import com.hypixel.hytale.server.npc.navigation.AStarWithTarget;
import com.hypixel.hytale.server.npc.role.Role;
import com.hypixel.hytale.server.npc.sensorinfo.InfoProvider;
import com.hypixel.hytale.server.npc.util.NPCPhysicsMath;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public     {
      stopDistance;
      stopDistanceSquared;
     [] holdDirectionDurationRange;
      changeDirectionViewSector;
      jitterAngle;
      erraticDistanceSquared;
      erraticJitter;
      erraticChangeDurationMultiplier;
         ();
     fleeDirection;
     holdDirectionTimeRemaining;

     {
      (builderMotionFind, support);
      .stopDistance = builderMotionFind.getStopDistance(support);
      .stopDistanceSquared = .stopDistance * .stopDistance;
      .holdDirectionDurationRange = builderMotionFind.getHoldDirectionDurationRange(support);
      .changeDirectionViewSector = builderMotionFind.getChangeDirectionViewSectorRadians(support);
      .jitterAngle = builderMotionFind.getDirectionJitterRadians(support);
         builderMotionFind.getErraticDistance(support);
      .erraticDistanceSquared = erraticDistance * erraticDistance;
         builderMotionFind.getErraticExtraJitterRadians(support);
      .erraticJitter = MathUtil.clamp(.jitterAngle + erraticExtraJitter, , );
      .erraticChangeDurationMultiplier = builderMotionFind.getErraticChangeDurationMultiplier(support);
      .evade.setDistances(builderMotionFind.getSlowdownDistance(support), .stopDistance);
      .evade.setFalloff(builderMotionFind.getFalloff(support));
      .evade.setAdhereToDirectionHint();
   }

      {
      .activate(ref, role, componentAccessor);
      .holdDirectionTimeRemaining = ;
   }

      {
         (NPCEntity)componentAccessor.getComponent(ref, NPCEntity.getComponentType());

       npcComponent != ;

         npcComponent.getCurrentHorizontalSpeedMultiplier(ref, componentAccessor);
       (speedMultiplier == ) {
         desiredSteering.clear();
          ;
      }  {
         .holdDirectionTimeRemaining -= dt * ()speedMultiplier;
          .computeSteering(ref, role, infoProvider, dt, desiredSteering, componentAccessor);
      }
   }

      {
         (TransformComponent)componentAccessor.getComponent(ref, TransformComponent.getComponentType());

       transformComponent != ;

         transformComponent.getPosition();
         transformComponent.getRotation();
         .getLastTargetPosition();
       (NPCPhysicsMath.inViewSector(selfPosition.x, selfPosition.z, bodyRotation.getYaw(), .changeDirectionViewSector, lastTargetPosition.x, lastTargetPosition.z)) {
         .holdDirectionTimeRemaining = ;
      }

       (.holdDirectionTimeRemaining <= ) {
            selfPosition.distanceSquaredTo(lastTargetPosition) < .erraticDistanceSquared;
            inErraticRange ? .erraticJitter : .jitterAngle;
         .fleeDirection = PhysicsMath.headingFromDirection(selfPosition.x - lastTargetPosition.x, selfPosition.z - lastTargetPosition.z) + RandomExtra.randomRange(-jitter, jitter);
         .holdDirectionTimeRemaining = RandomExtra.randomRange(.holdDirectionDurationRange);
          (inErraticRange) {
            .holdDirectionTimeRemaining *= .erraticChangeDurationMultiplier;
         }
      }

      .evade.setPositions(selfPosition, lastTargetPosition);
      .evade.setDirectionHint(.fleeDirection);
         role.getActiveMotionController();
         .desiredAltitudeWeight >=  ? .desiredAltitudeWeight : motionController.getDesiredAltitudeWeight();
       .scaleSteering(ref, role, .evade, desiredSteering, desiredAltitudeWeight, componentAccessor);
   }

      {
       aStarNode.getEstimateToGoal() <= ;
   }

      {
       motionController.waypointDistanceSquared(position, lastTestedPosition) >= .stopDistanceSquared;
   }

      {
       Math.max(, ()(.stopDistance - motionController.waypointDistance(fromPosition, ((AStarWithTarget)aStarBase).getTargetPosition())));
   }

      {
      aStarBase.buildBestPath(AStarNode::getEstimateToGoal, (oldV, v) -> v < oldV, );
   }
}