Question

所以我在java中制作2D游戏，但是我对游戏的运行速度有一些问题（这很慢），这是由我的碰撞检测方法造成的，而我和＃39;我不太清楚如何纠正它。因此，基本上对于我的敌人运动的碰撞检测，我使用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乘300，您可以制作网格：

byte[][] grid = new byte[100][100]

更改此尺寸以获得更好/更差的分辨率，测试性能等。

现在，在运行游戏之前，您可以通过设置grid墙和其他所有内容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
}

希望这会有所帮助，但可能有点像重构

使用列表进行碰撞检测的最快方法是什么？

1 个答案: