在Android Studio中实现线段交点计算与碰撞检测：以Pong游戏为例

// Bounce right side
if ((ballX > screenWidth) && (ballSpeedX > 0.0f)) { /* ... */ }
// Bounce left side
if ((80 * ballX < screenHeight) && (ballSpeedX < 0.0f)) { /* ... */ }
// ...

// 辅助类，表示一个二维点
class Vector2D {
    float x, y;

    public Vector2D(float x, float y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

// 辅助类，表示一条线段
class LineSegment {
    Vector2D p1, p2;

    public LineSegment(Vector2D p1, Vector2D p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
}

import android.graphics.PointF; // Android SDK 提供的 PointF 类

public class LineSegmentIntersection {

    private static final float EPSILON = 1e-6f; // 用于浮点数比较的误差容忍度

    /**
     * 计算线段所在直线的 A, B, C 参数
     * @param p1 线段的第一个点
     * @param p2 线段的第二个点
     * @return 包含 A, B, C 的 float 数组 {A, B, C}
     */
    private static float[] getLineEquationParams(Vector2D p1, Vector2D p2) {
        float A = p1.y - p2.y;
        float B = p2.x - p1.x;
        float C = p1.x * p2.y - p2.x * p1.y;
        return new float[]{A, B, C};
    }

    /**
     * 检查一个点是否在线段上（包括端点）
     * @param point 要检查的点
     * @param segment 线段
     * @return 如果点在线段上则返回 true，否则返回 false
     */
    private static boolean isPointOnSegment(Vector2D point, LineSegment segment) {
        float minX = Math.min(segment.p1.x, segment.p2.x);
        float maxX = Math.max(segment.p1.x, segment.p2.x);
        float minY = Math.min(segment.p1.y, segment.p2.y);
        float maxY = Math.max(segment.p1.y, segment.p2.y);

        // 检查点是否在矩形边界框内
        if (point.x < minX - EPSILON || point.x > maxX + EPSILON ||
            point.y < minY - EPSILON || point.y > maxY + EPSILON) {
            return false;
        }

        // 进一步检查点是否共线（对于水平或垂直线段，只需边界框检查即可，
        // 但对于倾斜线段，需要确保点确实在线段上而不是边界框内但在外围）
        // 这里简化为边界框检查，因为在找到直线交点后，共线性已经满足
        // 实际应用中，如果点是直线交点，且满足边界框，则它必然在线段上
        return true;
    }


    /**
     * 计算两条线段的交点
     * @param seg1 第一条线段
     * @param seg2 第二条线段
     * @return 如果两条线段相交，返回交点的 Vector2D 对象；否则返回 null
     */
    public static Vector2D getIntersectionPoint(LineSegment seg1, LineSegment seg2) {
        float[] params1 = getLineEquationParams(seg1.p1, seg1.p2);
        float A1 = params1[0], B1 = params1[1], C1 = params1[2];

        float[] params2 = getLineEquationParams(seg2.p1, seg2.p2);
        float A2 = params2[0], B2 = params2[1], C2 = params2[2];

        float denominator = A1 * B2 - A2 * B1;

        // 如果分母接近0，说明直线平行或重合
        if (Math.abs(denominator) < EPSILON) {
            // 如果C1*A2 - C2*A1 或 C2*B1 - C1*B2 也接近0，说明线段共线，可能有无限交点或部分重叠
            // 对于游戏碰撞，通常视为不相交或特殊处理
            return null;
        }

        float intersectX = (C2 * B1 - C1 * B2) / denominator;
        float intersectY = (C1 * A2 - C2 * A1) / denominator;

        Vector2D intersectionPoint = new Vector2D(intersectX, intersectY);

        // 检查计算出的交点是否在线段1和线段2的范围内
        if (isPointOnSegment(intersectionPoint, seg1) && isPointOnSegment(intersectionPoint, seg2)) {
            return intersectionPoint;
        } else {
            return null;
        }
    }
}

// 在 PongView 类中添加或修改
// ... (其他成员变量) ...
private LineSegmentIntersection intersectionHelper = new LineSegmentIntersection(); // 实例化辅助类

protected void collisionCheck() {
    // 获取球的运动轨迹线段
    Vector2D ballStart = new Vector2D(oldBallX, oldBallY);
    Vector2D ballEnd = new Vector2D(ballX, ballY);
    LineSegment ballPath = new LineSegment(ballStart, ballEnd);

    // 获取右球拍线段
    float rPaddleX = 7 * screenWidth / 8f; // 使用f确保浮点运算
    Vector2D rPaddleP1 = new Vector2D(rPaddleX, rPaddle * screenHeight - halfPaddle);
    Vector2D rPaddleP2 = new Vector2D(rPaddleX, rPaddle * screenHeight + halfPaddle);
    LineSegment rightPaddleSegment = new LineSegment(rPaddleP1, rPaddleP2);

    // 获取左球拍线段
    float lPaddleX = screenWidth / 8f; // 使用f确保浮点运算
    Vector2D lPaddleP1 = new Vector2D(lPaddleX, lPaddle * screenHeight - halfPaddle);
    Vector2D lPaddleP2 = new Vector2D(lPaddleX, lPaddle * screenHeight + halfPaddle);
    LineSegment leftPaddleSegment = new LineSegment(lPaddleP1, lPaddleP2);

    Vector2D intersectionPoint = null;

    // 检查与右球拍的碰撞
    intersectionPoint = intersectionHelper.getIntersectionPoint(ballPath, rightPaddleSegment);
    if (intersectionPoint != null) {
        // 发生碰撞，处理反弹
        handleCollision(intersectionPoint, true); // true表示右球拍
        return; // 一帧内只处理一次碰撞，避免重复或错误反弹
    }

    // 检查与左球拍的碰撞
    intersectionPoint = intersectionHelper.getIntersectionPoint(ballPath, leftPaddleSegment);
    if (intersectionPoint != null) {
        // 发生碰撞，处理反弹
        handleCollision(intersectionPoint, false); // false表示左球拍
        return;
    }

    // 原有的屏幕边界碰撞检测
    // Bounce right side
    if ((ballX + 10 > screenWidth) && (ballSpeedX > 0.0f)) { // 考虑球的宽度10
        ballSpeedX *= -1.0f;
        // pip.start(); // 播放音效
    }
    // Bounce left side
    if ((ballX < 0) && (ballSpeedX < 0.0f)) { // 考虑球的宽度10
        ballSpeedX *= -1.0f;
        // pip.start(); // 播放音效
    }
    // Bounce bottom side
    if ((ballY + 10 > screenHeight) && (ballSpeedY > 0.0f)) { // 考虑球的高度10
        ballSpeedY *= -1.0f;
        // pip.start(); // 播放音效
    }
    // Bounce top side
    if ((ballY < 0) && (ballSpeedY < 0.0f)) { // 考虑球的高度10
        ballSpeedY *= -1.0f;
        // pip.start(); // 播放音效
    }

    // Log.d("TAG", "Ball is moving"); // 移除或调整此Log，避免频繁输出
}

/**
 * 处理球与球拍碰撞后的逻辑
 * @param intersectPoint 碰撞点
 * @param isRightPaddle 是否是右球拍
 */
private void handleCollision(Vector2D intersectPoint, boolean isRightPaddle) {
    // 1. 将球的位置精确设置到碰撞点
    // 由于球有宽度和高度（10x10），我们需要根据碰撞方向调整其左上角坐标
    if (is