Java 如何进行碰撞

我在做吃豆人。我现在有一个玩家控制吃豆人，一个玩家控制幽灵。它们都扩展了相同的抽象类。我很难找到一种方法来检查它们是否相撞。这是抽象类 `

package org.entity.mobs；
导入java.awt.Point；
导入组织常数；
导入org.entity.entity；
公共抽象类Mob扩展实体{
专用点目的地；
受保护的int nextDirection=4；
保护int方向；
受保护的int-tempX；
公众暴民（整数x，整数y）{
super（x，y）；
目的地=新点（）；
}
公共无效更新（）{
if（常数.walls[destination.y][destination.x]！=1）{
开关（方向）{
案例1：
y-=2；
打破
案例2：
y+=2；
打破
案例3：
x-=2；
打破
案例4：
x+=2；
打破
违约：
打破
}
}
if（onGrid（））{
方向=下一个方向；
}
}
public void setNextDirection（int键）{
开关（钥匙）{
case Constants.PACMAN_UP：
this.nextDirection=1；
打破
case Constants.PACMAN_DOWN：
此.nextDirection=2；
打破
case Constants.PACMAN_左：
此.nextDirection=3；
打破
case Constants.PACMAN_右：
此.nextDirection=4；
打破
}
}
公共点getDestination（）{
返回目的地；
}
public void setDestination（）{
点=新点（）；
开关（方向）{
案例1://向上
设定点位置（x/20，（（y-1）/20））；
如果（x%20=16）{
tempX=（x+5）/20；
}否则{
tempX=x；
}
打破
案例2://关闭
设定位置（x/20，（y/20）+1）；
如果（x%20=16）{
tempX=（x+5）/20；
}否则{
tempX=x；
}
打破
案例3://左
设定位置（（（x-1）/20），y/20）；
如果（x%20=16）{
tempX=（x+5）/20；
}否则{
tempX=x；
}
打破
案例4://对
设定点位置（（x/20）+1，y/20）；
如果（x%20=16）{
tempX=（x+5）/20；
}否则{
tempX=x；
}
打破
违约：
打破
}
目的地。设置位置（点）；
}
公共布尔onGrid（）{
收益率（x%20==0）和&（y%20==0）；
}
}

` 这就是我要用碰撞法的地方

    package org;

import org.entity.tiles.Wall;
import org.entity.tiles.Pellet;
import java.awt.Graphics;
import java.util.ArrayList;
import org.entity.Entity;
import org.entity.mobs.Mob;

public class Grid {

    private Entity[][] grid = new Entity[31][28];
    private ArrayList<Mob> entities = new ArrayList<>();

    public Grid() {
        // Fills grid
        for (int row = 0; row < grid.length; row++) {
            for (int col = 0; col < grid[0].length; col++) {
                switch (Constants.walls[row][col]) {
                    case 0:
                        grid[row][col] = new Pellet(col, row);
                        break;
                    case 1:
                        grid[row][col] = new Wall(col, row);
                        break;
                    case 2:
                        // TODO middle
                        break;
                    case 3:
                        grid[row][col] = new Pellet(col, row, true);
                        break;
                    default:
                        break;
                }
            }
        }
        // TODO: possibly add more
    }

    public void update() {
        // move entities in units that can evenly go into 20 (1,2,4,5,10,20)
        for (Mob mob : entities) {
            mob.setDestination();
            mob.update();
        }
    }

    public void draw(Graphics g) {
        // Draw Maze
        g.drawImage(ImageLibrary.MAZE.getImage(), 0, 0, null);

        // draws Tiles
        for (Entity[] row : grid) {
            for (Entity tile : row) {
                if (tile != null) {
                    tile.draw(g);
                }
            }
        }

        // draws mobs
        for (Entity mob : entities) {
            mob.draw(g);
        }
    }

    public void add(Mob entity) {
        entities.add(entity);
    }
}

package组织；
导入org.entity.tiles.Wall；
导入org.entity.tiles.Pellet；
导入java.awt.Graphics；
导入java.util.ArrayList；
导入org.entity.entity；
导入org.entity.mobs.Mob；
公共类网格{
私有实体[]网格=新实体[31][28]；
私有ArrayList实体=新ArrayList（）；
公共电网（）{
//填充网格
对于（int row=0；row

在实体类中创建java.awt.Rectangle。矩形的坐标表示发生碰撞检测的边界框。在实体更新中，更新矩形的位置

在网格类中，创建一个方法chrckCollisions并遍历实体数组，检查每个实体是否与另一个实体冲突。（搜索“握手问题”，这是一种简单的方法，但您始终可以对其进行优化。）矩形中有一种相交（矩形）方法，您应该使用

在实体类中有一个“公共抽象void onCollision（实体其他）”的方法。在这里，您为每个子类指定在与另一个实体发生冲突时要执行的操作。例如，如果我们在ghost子类中，检查我们是否与pacman发生碰撞，然后执行某些操作

当发现两个实体发生碰撞时，将调用此方法。希望这有帮助

检查

    package org;

import org.entity.tiles.Wall;
import org.entity.tiles.Pellet;
import java.awt.Graphics;
import java.util.ArrayList;
import org.entity.Entity;
import org.entity.mobs.Mob;

public class Grid {

    private Entity[][] grid = new Entity[31][28];
    private ArrayList<Mob> entities = new ArrayList<>();

    public Grid() {
        // Fills grid
        for (int row = 0; row < grid.length; row++) {
            for (int col = 0; col < grid[0].length; col++) {
                switch (Constants.walls[row][col]) {
                    case 0:
                        grid[row][col] = new Pellet(col, row);
                        break;
                    case 1:
                        grid[row][col] = new Wall(col, row);
                        break;
                    case 2:
                        // TODO middle
                        break;
                    case 3:
                        grid[row][col] = new Pellet(col, row, true);
                        break;
                    default:
                        break;
                }
            }
        }
        // TODO: possibly add more
    }

    public void update() {
        // move entities in units that can evenly go into 20 (1,2,4,5,10,20)
        for (Mob mob : entities) {
            mob.setDestination();
            mob.update();
        }
    }

    public void draw(Graphics g) {
        // Draw Maze
        g.drawImage(ImageLibrary.MAZE.getImage(), 0, 0, null);

        // draws Tiles
        for (Entity[] row : grid) {
            for (Entity tile : row) {
                if (tile != null) {
                    tile.draw(g);
                }
            }
        }

        // draws mobs
        for (Entity mob : entities) {
            mob.draw(g);
        }
    }

    public void add(Mob entity) {
        entities.add(entity);
    }
}