Schnellster Weg zur Kollisionserkennung mit Listen?

Question

also mache ich ein 2D-Spiel in Java, aber ich habe einige Probleme mit der Laufgeschwindigkeit des Spiels (es ist ziemlich langsam) und dies wird durch meine Kollisionserkennung Methoden verursacht, und ich bin mir nicht ganz sicher wie man es korrigiert. Also zur Kollisionserkennung für meine Gegnerbewegung verwende ich 2 Listen (ArrayLists), eine für meine Wände und eine für meine Feinde (weil ich keine Gegner kollidiere). Also meine Frage ist, wäre es passender/schneller, wenn ich Maps anstelle von ArrayLists verwende, oder ist es nur meine Implementierung, die das Spiel langsam laufen lässt? Hier ist der Code, den ich für den Moment habe für meinen Feind Bewegung und die ImageTile Schnittstelle (falls vorhanden komplementärer Code notwendig ist, fühlen Sie sich frei zu sagen), Danke Jungs:

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

Eine Möglichkeit wäre, ein Gitter vorge initiieren . Dies würde bedeuten, dass Sie etwas vorladen müssen, aber während der Laufzeit ist die Verarbeitung sehr schnell.

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

Ändern Sie diese Größe für besser/schlechter Auflösung, Testleistung usw.

:

Ihres „Welt“ Lassen Sie sagen, mit einer Größe von 300 bis 300 hat, könnten Sie ein Gitter machen Jetzt, bevor Sie das Spiel ausführen, füllen Sie die grid durch Setzen eines 1 für Wände und alles andere auf 0.

Ihr bewegliches Objekt (e) hält ihre eigenen im Netz zu koordinieren, zum Beispiel:

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

Wenn nun ein bewegliches Objekt (Feinde/Spieler) bewegen will, können Sie einfach überprüfen, ob eine Kollision auftreten würde, zum Beispiel:

//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 
} 

hoffe, das hilft, könnte bei [Quadtrees] (https://en.wikipedia.org/wiki/Quadtree)