Java Vector2.len方法代碼示例

import com.badlogic.gdx.math.Vector2; //導入方法依賴的package包/類
/** Normalize this vector and return the length before normalization.  Alters this vector. */
public static final float normalize(Vector2 self) {
	
	final float length = self.len();
	if (length < Settings.EPSILON) {
		return 0f;
	}
	
	self.x /= length;
	self.y /= length;
	return length;
}
 

import com.badlogic.gdx.math.Vector2; //導入方法依賴的package包/類
/**
 * Checks whether the ball's model reached the level's end position.
 *
 * @return True if ball reached end position, false otherwise.
 */
private boolean ballReachedEnd() {
    Vector2 diff = new Vector2(endPos);
    diff.sub(ballModel.getX(), ballModel.getY());

    return diff.len() < BallModel.RADIUS;
}
 

import com.badlogic.gdx.math.Vector2; //導入方法依賴的package包/類
@Override
public void processEntity(Entity entity, float deltaTime) {
    TransformComponent transform = pm.get(entity);
    VelocityComponent velocity = vm.get(entity);
    PathComponent path = pathM.get(entity);
    MinionComponent minionComponent = minionM.get(entity);

    if (path.nextPoint == null) {
        velocity.linear.setZero();
        velocity.angular = 0;
        return;
    }

    // calc dir and len
    Vector2 toTarget = temp.set(path.nextPoint).sub(transform.position);
    float distance = toTarget.len();
    // don't go too far!
    if (distance <= 0.05) {
        velocity.linear.setZero();
        velocity.angular = 0;
        path.nextPoint = null;
        return;
    }

    float maxSpeed = minionComponent.speed;
    System.out.println("speed " + maxSpeed);
    // Target velocity combines speed and direction
    Vector2 targetVelocity = toTarget.scl(maxSpeed / distance); // Optimized code for:
    // toTarget.nor().scl(maxSpeed)

    // Acceleration tries to get to the nextPoint velocity without exceeding max acceleration
    targetVelocity.sub(velocity.linear).scl(1f / linearAccelerationTime).limit(maxLinearAcceleration);

    // set it
    velocity.linear.set(toTarget);

    // angular

    // Check for a zero direction, and set to 0 is so
    if (velocity.linear.isZero(zeroThreshold)) {
        velocity.angular = 0;
        return;
    }

    // Calculate the orientation based on the velocity of the owner
    float targetOrientation = VectorUtil.vectorToAngle(velocity.linear);

    // Get the rotation direction to the nextPoint wrapped to the range [-PI, PI]
    float rotation = ArithmeticUtils.wrapAngleAroundZero(targetOrientation - (transform.rotation - 90) * MathUtils.degreesToRadians);

    // Absolute rotation
    float rotationSize = rotation < 0f ? -rotation : rotation;

    // Check if we are there, set velocity to 0 and return if so
    if (rotationSize <= 0.1) {
        velocity.angular = 0;
        return;
    }

    // Use maximum rotation
    float targetRotation = maxAngularSpeed;

    // The final nextPoint rotation combines
    // speed (already in the variable) and direction
    targetRotation *= rotation / rotationSize;

    // Acceleration tries to get to the nextPoint rotation
    velocity.angular = (targetRotation - velocity.angular) / angularAccelerationTime;

    // Check if the absolute acceleration is too great
    float angularAcceleration = velocity.angular < 0f ? -velocity.angular : velocity.angular;
    if (angularAcceleration > maxAngularAcceleration) {
        velocity.angular *= maxAngularAcceleration / angularAcceleration;
    }
}