Java Point2D.getY方法代码示例

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
private boolean intersect(double agentX, double agentY, double pointX, double pointY, Blockade blockade)
{
    List<Line2D> lines = GeometryTools2D.pointsToLines(GeometryTools2D.vertexArrayToPoints(blockade.getApexes()), true);
    for (Line2D line : lines)
    {
        Point2D start = line.getOrigin();
        Point2D end = line.getEndPoint();
        double startX = start.getX();
        double startY = start.getY();
        double endX = end.getX();
        double endY = end.getY();
        if (java.awt.geom.Line2D.linesIntersect(
                agentX, agentY, pointX, pointY,
                startX, startY, endX, endY
        ))
        {
            return true;
        }
    }
    return false;
}
 

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
public boolean linesIntersect(Point2D point, Point2D targetPoint, Edge edge) {
    Point2D start = edge.getStart();
    double startX = start.getX();
    double startY = start.getY();
    Point2D end = edge.getEnd();
    double endX = end.getX();
    double endY = end.getY();
    return Line2D.linesIntersect(point.getX(), point.getY(), targetPoint.getX(), targetPoint.getY(), startX, startY, endX, endY) && !PositionUtil.equalsPoint(targetPoint, ((startX + endX) / 2.0D), (startY + endX) / 2.0D, 10.0D);
}
 

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
public boolean linesIntersect(Point2D point, Point2D targetPoint, Edge edge) {
    Point2D start = edge.getStart();
    double startX = start.getX();
    double startY = start.getY();
    Point2D end = edge.getEnd();
    double endX = end.getX();
    double endY = end.getY();
    return Line2D.linesIntersect(point.getX(), point.getY(), targetPoint.getX(), targetPoint.getY(), startX, startY, endX, endY) &&
            !PositionUtil.equalsPoint(targetPoint, ((startX + endX) / 2.0D), (startY + endY) / 2.0D, 1000.0D);
}
 

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
private Point2D getEdgePoint(Edge edge) {
    Point2D start = edge.getStart();
    Point2D end = edge.getEnd();
    return new Point2D(((start.getX() + end.getX()) / 2.0D), ((start.getY() + end.getY()) / 2.0D));
}
 

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
private Action getIntersectEdgeAction(double agentX, double agentY, double pointX, double pointY, Road road)
{
    Set<Point2D> movePoints = this.getMovePoints(road);
    Point2D bestPoint = null;
    double bastDistance = Double.MAX_VALUE;
    for (Point2D p : movePoints)
    {
        if (!this.intersect(agentX, agentY, p.getX(), p.getY(), road))
        {
            if (!this.intersect(pointX, pointY, p.getX(), p.getY(), road))
            {
                double distance = this.getDistance(pointX, pointY, p.getX(), p.getY());
                if (distance < bastDistance)
                {
                    bestPoint = p;
                    bastDistance = distance;
                }
            }
        }
    }
    if (bestPoint != null)
    {
        double pX = bestPoint.getX();
        double pY = bestPoint.getY();
        if (!road.isBlockadesDefined())
        {
            return new ActionMove(Lists.newArrayList(road.getID()), (int) pX, (int) pY);
        }
        ActionClear actionClear = null;
        ActionMove actionMove = null;
        Vector2D vector = this.scaleClear(this.getVector(agentX, agentY, pX, pY));
        int clearX = (int) (agentX + vector.getX());
        int clearY = (int) (agentY + vector.getY());
        vector = this.scaleBackClear(vector);
        int startX = (int) (agentX + vector.getX());
        int startY = (int) (agentY + vector.getY());
        for (Blockade blockade : this.worldInfo.getBlockades(road))
        {
            if (this.intersect(startX, startY, pX, pY, blockade))
            {
                if (this.intersect(startX, startY, clearX, clearY, blockade))
                {
                    if (actionClear == null)
                    {
                        actionClear = new ActionClear(clearX, clearY, blockade);
                    }
                    else
                    {
                        if (actionClear.getTarget() != null)
                        {
                            Blockade another = (Blockade) this.worldInfo.getEntity(actionClear.getTarget());
                            if (another != null && this.intersect(blockade, another))
                            {
                                return new ActionClear(another);
                            }
                        }
                        return actionClear;
                    }
                }
                else if (actionMove == null)
                {
                    actionMove = new ActionMove(Lists.newArrayList(road.getID()), (int) pX, (int) pY);
                }
            }
        }
        if (actionClear != null)
        {
            return actionClear;
        }
        else if (actionMove != null)
        {
            return actionMove;
        }
    }
    Action action = this.getAreaClearAction((PoliceForce) this.agentInfo.me(), road);
    if (action == null)
    {
        action = new ActionMove(Lists.newArrayList(road.getID()), (int) pointX, (int) pointY);
    }
    return action;
}
 

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
public static Point2D getEdgePoint(Edge edge) {
    Point2D start = edge.getStart();
    Point2D end = edge.getEnd();
    return new Point2D(((start.getX() + end.getX()) / 2.0D), ((start.getY() + end.getY()) / 2.0D));
}
 

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
public static double valueOfCompare(Point2D position, Point2D another) {
    double dx = position.getX() - another.getX();
    double dy = position.getY() - another.getY();
    return dx*dx + dy*dy;
}
 

import rescuecore2.misc.geometry.Point2D; //导入方法依赖的package包/类
@Override
public Action think(int currentTime, ChangeSet updateWorldData, MessageManager manager) {
    this.organizeUpdateInfo(currentTime, updateWorldData, manager);
    if (this.me.getBuriedness() > 0) {
        return this.buriednessAction(manager);
    }
    if(posInit) {
        this.posInit = false;
        this.agentPoint[0] = new Point2D(this.me.getX(), this.me.getY());
        this.agentPoint[1] = new Point2D(this.me.getX(), this.me.getY());
    }
    else {
        this.agentPoint[1] = this.agentPoint[0];
        this.agentPoint[0] = new Point2D(this.me.getX(), this.me.getY());
    }

    this.checkClearPath(currentTime);

    if(this.target == null || this.clearPath == null || this.clearPath.isEmpty()) {
        this.target = this.impassableSelector.getNewTarget(currentTime);
        if(this.target != null && this.target.getValue() == this.me.getPosition().getValue()) {
            this.impassableSelector.remove(this.target);
            this.target = this.impassableSelector.getNewTarget(currentTime);
        }
        if(this.target == null) {
            this.beforeMove = true;
            return new ActionMove(this, this.routeSearcher.noTargetMove(currentTime, this.me));
        }
        this.clearPath = this.routeSearcher.getPath(currentTime, this.me(), this.target);
        if(this.clearPath == null || this.clearPath.isEmpty()) {
            this.beforeMove = true;
            return new ActionMove(this, this.routeSearcher.noTargetMove(currentTime, this.me));
        }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //before agent position == this agent position && this.beforeMove
    if(this.target.getValue() != this.me().getPosition().getValue() && this.clearPoints == null) {
        if (this.beforeMove) {
            //clear
            if (PositionUtil.equalsPoint(this.agentPoint[1], this.agentPoint[0], 1000.0D)) {
                this.beforeMove = false;
                EntityID id = this.clearPath.get(this.clearPath.indexOf(this.me.getPosition()) + 1);
                return this.clear.getAction(this, id);
            }
        }
        this.beforeMove = true;
        return new ActionMove(this, this.clearPath);
    }
    else {
        Point2D targetPoint = this.clearPoints.get(this.count);
        if (this.beforeMove) {
            //clear
            if (PositionUtil.equalsPoint(this.agentPoint[1], this.agentPoint[0], 1000.0D)) {
                this.beforeMove = false;
                return this.clear.getAction(this, targetPoint);
            }
        }
        List<EntityID> path = new ArrayList<>();
        if(this.target.getValue() != this.me().getPosition().getValue()) {
            path.add(this.me().getPosition());
        }
        path.add(this.target);
        return new ActionMove(this, path, (int)targetPoint.getX(), (int)targetPoint.getY());
    }
}