HashMap vs if - else

[Lexi]

Ich bin gerade dabei ein Bomberman Spiel zu schreiben. Dort habe ich jetzt eine move Methode implementiert, die die Spielfigur bewegen soll. Das man bei Bomberman nicht auf jedes Feld sondern, logischerweise, nur auf Hindernisfreie Felder treten kann, muss ich vorher abfragen ob das zu betretende Feld hindernisfrei ist. Zunächst hatte ich die 4 Richtungen in 4 Methoden aufgeteilt "moveUp(), moveRight() ...", doch das gefiel mir nicht so gut.

public boolean moveUp(Player player){
		int xPos = player.getXPos();
		int yPos = player.getYPos();
		
		if(fields[xPos][yPos-1].isBetretbar()){
			player.setYPos(yPos+1);
			return true;
		}
		return false;
	}

// usw ...

Dann habe ich versucht das ganze mit einer HashMap zu lösen:

Map<Integer,Point> moveOrders = new HashMap<Integer,Point>();
	
	
	public PlayGround() {
		moveOrders.put(PlayGround.MOVE_UP,new Point(0,-1));
		moveOrders.put(PlayGround.MOVE_RIGHT,new Point(1,0));
		moveOrders.put(PlayGround.MOVE_DOWN,new Point(0,1));
		moveOrders.put(PlayGround.MOVE_LEFT,new Point(-1,0));
            }

public boolean move(Player player, int moveOrderKey){
		int xPos = player.getXPos();
		int yPos = player.getYPos();
		
		Point moveOrder = moveOrders.get(moveOrderKey);
		if(fields[xPos+moveOrder.x][yPos+moveOrder.y]!=null){
			if(fields[xPos+moveOrder.x][yPos+moveOrder.y].isWalkable()){
				player.setPosition(xPos+moveOrder.x, yPos+moveOrder.y);
				return true;
			}
		}
		return false;
	}

So habe ich nur noch eine einzige Methode.

Was sagt ihr dazu ? Ist sowas ein günstiger Einsatz für eine HashMap oder hätte ich lieber bei meinen 4 Methoden bleiben sollen ?

 

[Ebenius]

Ich würde ein enum verwenden und dort alles reintun:

public enum WalkDirection {

  UP(0, -1),
  DOWN(0, 1),
  LEFT(-1, 0),
  RIGHT(1, 0);

  public final int deltaX;
  public final int deltaY;

  /** Creates a new {@code WalkDirection}. */
  private WalkDirection(int dx, int dy) {
    this.deltaX = dx;
    this.deltaY = dy;
  }
}

Dann eine move-Methode:

public boolean move(Player player, WalkDirection dir) {
  int xPos = player.getXPos();
  int yPos = player.getYPos();

  if (fields[xPos + dir.deltaX][yPos + dir.deltaY] != null) {
    if (fields[xPos + dir.deltaX][yPos + dir.deltaY].isWalkable()) {
      player.setPosition(xPos + dir.deltaX, yPos + dir.deltaY);
      return true;
    }
  }
  return false;
}

... so in etwa ...

Ebenius

 

[SlaterB]

die eine Methode statt 4 ist sehr gut, die Map ist etwas diskussionswürdig,
durchaus schon eine gelungen kurze Umsetzung, aber vielleicht doch zu verwirrend in diesem Zusammenhang,

alternativ könntest du in der einen statt 4 Methoden auch folgendes vergleichsweise einfaches schreiben:

public boolean move(Player player, int moveOrderKey){
        int xPos = player.getXPos();
        int yPos = player.getYPos();
        
        if (moveOrderKey == PlayGround.MOVE_UP ||   moveOrderKey == PlayGround.MOVE_DOWN) {
           xPos += (moveOrderKey == PlayGround.MOVE_UP ? 1 : -1);
        } else {
           yPos += (moveOrderKey == PlayGround.MOVE_RIGHT ? 1 : -1);
        }    
        
        // oder noch besser
        switch (moveOrderKey) {
           case PlayGround.MOVE_UP:
               xPos++;
               break;
           case PlayGround.MOVE_DOWN:
               xPos--;
               break;
           ....
       }

        // prüfen ob Position außer Grenzen?
        Field f = fields[xPos][yPos];
        if(f !=null && f.isWalkable()){
            player.setPosition(xPos, yPos);
            return true;
        }
        return false;
    }

je mehr Möglichkeiten es gibt, desto schwieriger wird es, mit if/ else zu arbeiten,
switch sollte immer eine Alternative sein, benötigt aber mindestens 2 Zeilen (in einer extra-Methode mit return, drei mit break; )
während das Einfügen in eine Map wie bei dir vielleicht nur eine Zeile braucht
(edit: zum Vergleich zu Ebenius Postings braucht die Enum auch eine Zeile)

bei 100 Elementen kann das schon was ausmachen

 

[Lexi]

Also funktionieren tut das Enum genausogut wie die HashMap.
Nur leider komme ich da noch nciht so ganz hinter wie das ganze genau funktioniert.

  UP(0, -1),

Ist das ein Konstruktoraufruf ? Wenn ja wann wird der aufgerufen ?
Wenn ich

WalkDirektion dir = WalkDirektion.UP;

aufrufe ?

 

[Marco13]

Die Dinger wie das "UP" sind Instanzen der Klasse WalkDirection, und das
UP(0,1)
ist tatsächlich fast das gleiche wie ein Konstruktoraufruf. Aufgerufen wird das ganze quasi (!) "beim Programmstart" (wenn der Classloader mal drüberrutscht oder so).

Hier gibt's noch mehr Info dazu: Enums

Die Intention, diese 4 Methoden in einer abzuhandeln, ist schon richtig. Eine Map verwendet man aber (grob gesagt) dann, wenn man "eine unbekannte Anzahl unbekannter Objekte auf andere Objekte abbilden will". In diesem Fall hast du aber eine bekannte Anzahl (nämlich 4) und auch bekannte Objekte (nämlich die "moveOrderKeys"). In so einem Fall würde man statt der Map einfach einen Array verwenden (davon ausgehend, dass die moveOrderKeys von 0 bis 4 durchnummeriert sind). Aber die enums sind in diesem Fall noch besser - eleganter und "sicherer" - wenn der moveOrderKey nur ein int ist, kann da jemand böses ja einfach mal -666 übergeben -> *knirsch* - bei enums geht nur das, was auch gehen soll.

 

[Ebenius]

Du hast noch nicht so viel mit enums gearbeitet?

  UP(0, -1),

Ist das ein Konstruktoraufruf ?

Ja. Die vier Instanzen des WalkDirection-enum werden bei Initialisierung (das heißt spätestens direkt vor dem ersten Zugriff auf einen der Member) der Klasse WalkDirection aufgebaut. Es gibt nur genau diese vier Instanzen.

Mehr Infos findest Du im Sun Java™ Tutorial: Enum Types.

Ebenius

 

[Lexi]

Du hast noch nicht so viel mit enums gearbeitet?
Ebenius

Gearbeitet noch nie, aber schonmal drüber gelesen.

Könnte man nciht im Prinzip sagen, dass UP, RIGHT, LEFT, DOWN jeweils eine Art Objekt sind die jeweils die Instantzvariablen deltaX und deltaY haben ?

 

[Ebenius]

Kann man sagen. UP, RIGHT, LEFT, DOWN sind jeweils ein Objekt mit genau jenen Instanzvariablen. Zusätzlich ist garantiert, dass es nur genau diese vier Instanzen gibt. Außerdem kann man sie super im switch-Statement nutzen.

Ebenius

 

[Lexi]

Ich denke jetzt habe ich das mit den enums verstanden.
Besten Dank an alle