java - 列表碰撞检测的最快方法？

Question

所以我正在用java制作一个2D游戏，但是我在游戏的运行速度方面遇到了一些问题(它非常慢)，这是由我的碰撞检测方法引起的，我不太明白确定如何纠正它。因此，基本上，为了对敌人运动进行碰撞检测，我使用 2 个列表(ArrayLists)，一个用于我的墙壁，一个用于我的敌人(因为我不让敌人发生碰撞)。所以我的问题是，如果我使用 Maps 而不是 ArrayLists 会更合适/更快，还是只是我的实现导致游戏运行缓慢？这是我目前的敌人移动和 ImageTile 界面的代码(如果需要任何补充代码，请随时说)，谢谢大家:

public interface ImageTile {

    String getName();
    Position getPosition();

}


public abstract class Enemy implements ImageTile {

    protected Position position;
    protected String name;
    protected int Damage;
    protected int Health;
    protected int Vision;

    public Enemy(Position position){
        this.position=position;
    }


    public abstract void move(Hero hero, List<Wall> walls, List<Enemy> enemies);

    public void loseHealth(int Damage){
        this.Health-=Damage;
    }

    public int getDamage() {
        return Damage;
    }

    public int getVision() {
        return Vision;
    }

    public int getHealth() {
        return Health;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Position getPosition() {
        return position;
    }
}


public class Bat extends Enemy {    

    public Bat(Position position) {
        super(position);
        this.Damage=100;
        this.Health=150;
        this.Vision=5;
    }

    @Override
    public String getName() {
        return "Bat";
    }

    @Override
    public void move(Hero hero, List<Wall> walls, List<Enemy> enemies){
        int x = hero.getPosition().getX();
        int y = hero.getPosition().getY();
        int x0 = position.getX();
        int y0 = position.getY();
        if((int) Math.sqrt((x0-x) * (x0-x) + (y0-y) * (y0-y))<Vision){
            if(x>x0 && y>y0){
                if(x0<9 && y0<9){
                    if(!walls.contains(new Wall(new Position(x0+1,y0+1))) && !hero.getPosition().equals(new Position(x0+1,y0+1)))
                          x0++; y0++;
                    if(hero.getPosition().equals(new Position(x0+1,y0+1)))
                          hero.loseHealth(getDamage());
                }
            }
            if(x>x0 && y<y0){
                if(x0<9 && y0>1){
                    if(!walls.contains(new Wall(new Position(x0+1,y0-1))) && !hero.getPosition().equals(new Position(x0+1,y0-1)))
                         x0++; y0--;
                    if(hero.getPosition().equals(new Position(x0+1,y0-1)))
                       hero.loseHealth(getDamage());
                }
            }
            if(x<x0 && y>y0){
                if(x0>1 && y0<9){
                    if(!walls.contains(new Wall(new Position(x0-1,y0+1))) && !hero.getPosition().equals(new Position(x0-1,y0+1)))
                         x0--; y0++;
                    if(hero.getPosition().equals(new Position(x0-1,y0+1)))
                       hero.loseHealth(getDamage());
                }
            }

            if(x<x0 && y<y0){
                if(x0>1 && y0>1){
                    if(!walls.contains(new Wall(new Position(x0-1,y0-1))) && !hero.getPosition().equals(new Position(x0-1,y0-1)))
                         x0--; y0--;
                    if(hero.getPosition().equals(new Position(x0-1,y0-1)))
                       hero.loseHealth(getDamage());
                }
            }
            this.position=new Position(x0,y0);
        }else{
            Random random = new Random();
            int i=random.nextInt(4);
            if(i==0){
                if(x0>1){
                    if(!walls.contains(new Wall(new Position(x0-1,y0))))
                        this.position=position.plus(Direction.LEFT.asVector());
                }
            }
            if(i==1){
                if(x0<9){
                   if(!walls.contains(new Wall(new Position(x0+1,y0))))
                        this.position=position.plus(Direction.RIGHT.asVector());
                }
            }
            if(i==2){
                if(y0>1){
                    if(!walls.contains(new Wall(new Position(x0,y0-1))))
                        this.position=position.plus(Direction.UP.asVector());
                }
            }
            if(i==3){
                if(y0<9){
                    if(!walls.contains(new Wall(new Position(x0,y0+1))))
                        this.position=position.plus(Direction.DOWN.asVector());
                }
            }
        }
    }
}

Answer 1

一种方法是预先启动网格。这意味着您需要进行一些预加载，但在运行时处理速度非常快。

假设您的“世界”大小为 300 x 300，您可以制作一个网格:

字节[][]网格=新字节[100][100]

更改此大小以获得更好/更差的分辨率、测试性能等。

现在，在运行游戏之前，您可以通过将墙壁的 1 设置为 1 并将其他所有内容设置为 0 来填充网格。

您的可移动对象在网格中拥有自己的坐标，例如:

Public class Enemy{
    private int x;
    private int y;
    //Or use Coordinate, whichever you prefer
} 

现在，当可移动物体(敌人/玩家)想要移动时，您可以简单地检查是否会发生碰撞，例如:

//Move right
if (grid[enemy.getX()+1][enemy.getY()] == 1){
    //Cannot move
}
else {
    //Move right
    enemy.setX(enemy.getX()+1);
    //And whatever else you want to do
}

希望这有帮助，不过可能需要一些重构