Java Vector2.dot方法代碼示例

import com.badlogic.gdx.math.Vector2; //導入方法依賴的package包/類
public Range projectSegment(Vector2 onto) {
    // create new range or use an recycled range
    Range range = RangePool.create();

    // normailize vector
    onto.nor();

    // calculate min and max value with dot product
    float min = onto.dot(point1);
    float max = onto.dot(point2);
    range.set(min, max);

    return range;
}
 

import com.badlogic.gdx.math.Vector2; //導入方法依賴的package包/類
public static boolean onOneSide(Line axis, Segment s) {
    Vector2 d1 = Vector2Pool.create(s.getPoint1()).sub(axis.getBase());
    Vector2 d2 = Vector2Pool.create(s.getPoint2()).sub(axis.getBase());
    Vector2 n = FastMath.rotateVector90(axis.getDirection(), Vector2Pool.create());

    float dotProduct = n.dot(d1) * n.dot(d2);

    // recycle vectors
    Vector2Pool.free(d1, d2, n);

    return dotProduct > 0;
}
 

import com.badlogic.gdx.math.Vector2; //導入方法依賴的package包/類
public static boolean checkVectorsParallel(Vector2 v1, Vector2 v2) {
    // rotate vector 90 degrees
    Vector2 rotatedVector1 = rotateVector90(v1, Vector2Pool.create());

    // 2 vectors are parallel, if dot product = 0
    float dotProduct = rotatedVector1.dot(v2);

    Vector2Pool.free(rotatedVector1);

    return dotProduct == 0;
}
 

import com.badlogic.gdx.math.Vector2; //導入方法依賴的package包/類
@Override
protected void process(int entityId) {
    PositionComponent pos = mapperPosition.get(entityId);
    CharacterComponent character = mapperCharacterComponent.get(entityId);
    StatComponent stats = mapperStatComponent.get(entityId);
    PhysicComponent physicComponent = mapperPhysicComponent.get(entityId);
    RenderComponent renderComponent = mapperRenderComponent.get(entityId);


    /**
     * Movement code. Does not (as of yet) contain proper pathfinder logic.
     */
    if (character.move.dst(pos.position) != 0 && physicComponent.body.getLinearVelocity().equals(Vector2.Zero) && !stats.getFlag(StatComponent.FlagStat.dead)) {
        if (stats.getRuntimeStat(StatComponent.RuntimeStat.actionPoints) >= 1 && (renderComponent == null || renderComponent.isInState(IDLE)
                || renderComponent.isInState(ATTACK))) {
            Vector2 dir = vectorPool.obtain();
            Vector2 speed = vectorPool.obtain();
            if (Math.abs(character.move.x - pos.position.x) > Math.abs(character.move.y - pos.position.y))
                dir.set(Math.signum(character.move.x - pos.position.x), 0);
            else
                dir.set(0, Math.signum(character.move.y - pos.position.y));

            if (renderComponent != null) {
                renderComponent.setRenderState(dir.y == 0 ? MOVE_SIDE :
                        dir.y < 0 ? MOVE_DOWN : MOVE_UP);
                if (dir.x != 0)
                    renderComponent.flipX = dir.x < 0;
            }
            physicComponent.body.setLinearVelocity(speed.set(dir).scl(stats.getCurrentStat(StatComponent.BaseStat.moveSpeed)));
            character.stepMove.set(dir.add(pos.position));
            character.startToEnd.set(dir.set(pos.position).sub(character.stepMove));
            vectorPool.free(dir);
            vectorPool.free(speed);
            stats.addRuntimeStat(StatComponent.RuntimeStat.actionPoints, -1);
            character.targetId = -1;
        }
    } else if (!physicComponent.body.getLinearVelocity().equals(Vector2.Zero)) {
        Vector2 curr = vectorPool.obtain();

        curr.set(physicComponent.body.getPosition()).sub(character.stepMove);

        if (curr.dot(character.startToEnd) < 0) {
            physicComponent.body.setLinearVelocity(Vector2.Zero);
            physicComponent.body.setTransform(pos.position, physicComponent.body.getAngle());
            renderComponent.setRenderState(IDLE);
        }
        vectorPool.free(curr);
    }

    /**
     * Auto-attack logic.
     */
    if (!character.character.isCasting())
        if (character.targetId == entityId)
            character.targetId = -1;
        else if (character.targetId != -1) {
            Vector2 vector = vectorPool.obtain();
            PositionComponent target = mapperPosition.get(character.targetId);
            if (target == null)
                character.targetId = -1;
            else {
                if (Math.abs(vector.set(pos.position).dst(target.position)) <= stats.getCurrentStat(StatComponent.BaseStat.attackRange)) {
                    if (pos.position.x < target.position.x)
                        renderComponent.faceRight();
                    else if (pos.position.x > target.position.x)
                        renderComponent.faceLeft();
                    character.character.startAttack();
                    renderComponent.setRenderState(ATTACK);
                } else
                    character.targetId = -1;
            }
            vectorPool.free(vector);
        } else if (character.targetId == -1 && renderComponent.isInState(ATTACK))
            renderComponent.setRenderState(IDLE);


    character.character.tick(getWorld().getDelta());
}