java复杂形状碰撞检测

Java中可以通过使用Shape类来表示复杂形状，包括矩形、圆形、多边形等。Shape类提供了intersects()、contains()等方法，可以用于检测两个形状是否相交、一个形状是否包含另一个形状等。

对于复杂形状的碰撞检测，可以采用分割轴定理（SAT）算法。该算法的基本思想是将形状投影到一条直线上，然后检测它们在该直线上的投影是否重叠。如果所有的投影都重叠，则说明形状相交。

具体实现时，可以先将两个形状的所有边转换成向量，然后计算每个向量的垂直向量（法向量）。接着，对于每个法向量，分别将两个形状投影到该向量上，并检测它们在该向量上的投影是否重叠。如果所有的投影都重叠，则说明形状相交。

参考代码如下：

public boolean checkCollision(Shape shape1, Shape shape2) {
    for (Line2D edge : getEdges(shape1)) {
        if (!isSeparatingAxis(edge, shape1, shape2)) {
            return false;
        }
    }
    for (Line2D edge : getEdges(shape2)) {
        if (!isSeparatingAxis(edge, shape1, shape2)) {
            return false;
        }
    }
    return true;
}

private List<Line2D> getEdges(Shape shape) {
    List<Line2D> edges = new ArrayList<>();
    PathIterator pathIterator = shape.getPathIterator(null);
    double[] coords = new double[6];
    double[] lastCoords = new double[2];
    while (!pathIterator.isDone()) {
        int type = pathIterator.currentSegment(coords);
        switch (type) {
            case PathIterator.SEG_MOVETO:
                lastCoords[0] = coords[0];
                lastCoords[1] = coords[1];
                break;
            case PathIterator.SEG_LINETO:
                Line2D edge = new Line2D.Double(lastCoords[0], lastCoords[1], coords[0], coords[1]);
                edges.add(edge);
                lastCoords[0] = coords[0];
                lastCoords[1] = coords[1];
                break;
            default:
                break;
        }
        pathIterator.next();
    }
    return edges;
}

private boolean isSeparatingAxis(Line2D edge, Shape shape1, Shape shape2) {
    Vector2D normal = new Vector2D(edge.getY2() - edge.getY1(), edge.getX1() - edge.getX2());
    normal.normalize();
    Projection proj1 = project(normal, shape1);
    Projection proj2 = project(normal, shape2);
    return !proj1.overlaps(proj2);
}

private Projection project(Vector2D axis, Shape shape) {
    PathIterator pathIterator = shape.getPathIterator(null);
    double[] coords = new double[6];
    double min = Double.POSITIVE_INFINITY;
    double max = Double.NEGATIVE_INFINITY;
    while (!pathIterator.isDone()) {
        int type = pathIterator.currentSegment(coords);
        switch (type) {
            case PathIterator.SEG_MOVETO:
            case PathIterator.SEG_LINETO:
                double dot = axis.dotProduct(new Vector2D(coords[0], coords[1]));
                if (dot < min) {
                    min = dot;
                }
                if (dot > max) {
                    max = dot;
                }
                break;
            default:
                break;
        }
        pathIterator.next();
    }
    return new Projection(min, max);
}

private static class Projection {
    private double min;
    private double max;

    public Projection(double min, double max) {
        this.min = min;
        this.max = max;
    }

    public boolean overlaps(Projection other) {
        return !(this.max < other.min || other.max < this.min);
    }
}

其中，getEdges()方法用于获取形状的边，isSeparatingAxis()方法用于检测一个法向量是否为分离轴，project()方法用于将形状投影到一个向量上，Projection类用于表示投影的区间。