Wie erstellt man eine Kachel-Map in Java für ein 2D-Spiel?

Question

Nicht sicher, wie Sie dieses Problem angehen.

Grundsätzlich möchte ich eine Pixel -> Tile-Darstellung eines 400x400-Fensters. Jede Koordinate auf dem Bildschirm, z. B. 120x300, sollte Teil einer Kachel sein. Mein kleinstes Sprite ist 4 Pixel, also können wir 1 Kachel = 4 Pixel sagen. Der Spieler und die gegnerischen Sprites sind alle 20 x 20, also belegt jeder Spieler/Bösewicht 5 Kacheln.

Dann möchte ich diese Map-Klasse verwenden:

• Rufen Sie die x/y-Koordinaten eines Spielers/Monster-Sprite von den Index/id der Fliese suppling.

• Wissen, wo die Grenzen sind, so bewegt es das Sprite nicht über 400x400 hinaus und versteckt es so.

• Kollisionserkennung, ob eine Kachel frei ist oder nicht.

Wie kann das gemacht werden? Sprechen wir hier speziell über die x, y-> Kachel- oder Kachelindex-> ​​x, y-Konvertierung (um die Sprites angemessen zu zeichnen).

Answer 1

Erstens, teilen Sie das Konzept eines Pixels, das nur mit Darstellung betroffen ist, mit einer Kachel, die ein tatsächliches Spielobjekt ist Einschränkungen, die es auf das Spiel setzt.

Ich finde eine gute Möglichkeit, Dinge wie diese zu entwirren, ist es, die grobe API zu skizzieren, was Sie wollen. Etwas wie:

public class Board { 
    public Board (int width, int height){.. } 
    public boolean isOccupied(int x, int y){.. } 
    public void moveTo(Point from, Point to) { .. 
    (maybe throws an exception for outofbounds) 

wo alle internen Einheiten der Platine in Kacheln sind, nicht Pixel. Dann Pixelinformation kann von der Platine unabhängig voneinander aus den Fliesen Darstellung mit einem wenig internen Multiplikations-

public Point getPixelPosition(int xTilePos, int yTilePos, int pixelsPerTile).. 

Die Fliesen können als 2D-Array oder einen einzelnen Array dargestellt werden intern abgeleitet wird, in welchem ​​Fall würden Sie Verwenden Sie eine Art von internem Repräsentationsschema, um Ihr Array den Platinenquadraten zuzuordnen, also der Mod-Arithmetik.

Answer 2

Kurze Antwort: Multiplikation und Modulo-Operationen.

Aber wenn das Sie stampft, würde ich vorschlagen, dass Sie eine ernsthafte Mathe Auffrischung tun, bevor Sie versuchen, ein Spiel zu schreiben.

Auch Ihre Aussage

Mein kleinster Sprit 4 Pixel, so dass wir können sagen, dass 1 Kachel = 4 Pixel. Die Spieler und Feind Sprites sind alle 20 x 20, so dass jeder Spieler/Gauner wird 5 Fliesen besetzen.

funktioniert nicht für irgendeine sinnvolle Geometrie. Wenn mit "1 Kachel = 4 Pixel" gemeint ist, dass die Kacheln 2x2 sind, dann nimmt ein Spieler 100, nicht fünf. Wenn Sie meinen, sie sind 4x4, dann nehmen die Spieler 25, was immer noch nicht 5 ist.

Answer 3

/** size of a tile in pixel (for one dimension)*/ 
int TILE_SIZE_IN_PIXEL = 4; 
/** size of a piece in tiles (for one dimension)*/ 
int PIECE_SIZE_IN_TILE = 5; 


public int tileToPixel(int positionInTiles){ 
    return TILE_SIZE_IN_PIXEL * positionInTiles; 
} 

/** returns the tile coordinate to which the given tile coordinate belongs 

Note: tileToPixel(pixelToTile(x)) only returns x if x is the upper or left edge of a tile 
*/ 
public int pixelToTile(int positionInPixel){ 
    return positionInPixel/TILE_SIZE_IN_PIXEL; 
} 

Sie werden wahrscheinlich wollen, dass Methoden auch mit zwei Argumenten arbeiten (x und y at).

Für die ID-> Stückumwandlung und umgekehrt stehen Ihnen verschiedene Ansätze zur Verfügung. Welche zu wählen ist, hängt von den genauen Anforderungen ab (Geschwindigkeit, Größe des Spiels ...). Stellen Sie daher sicher, dass Sie die Implementierungsdetails ausblenden, damit Sie sie später ändern können.

würde ich mit einer echten einfachen Lösung starten:

public class Piece{ 
    /** x position measured in tiles */ 
    private int x; 
    /** y position measured in tiles */ 
    private int y; 

    /** I don't think you need this, but you asked for it. I'd pass around Piece instances instead */ 
    private final Long id; 

    public void getX(){ 
     return x; 
    } 
    public void getY(){ 
     return y; 
    } 

    public void getID(){ 
     return id; 
    } 

} 

public class Board(){ 
    private Set<Long,Piece> pieces = new HashMap<Piece>(pieces); 

    public Piece getPieceOnTile(int tileX, int tileY){ 
     for(Piece piece:pieces){ 
      if (isPieceOnTile(piece, tileX, tileY)) return piece; 
     } 
    } 

    private boolean isPieceOnTile(piece, tileX, tileY){ 
     if (piece.getX() < tileX) return false; 
     if (piece.getX() > tileX + PIECE_SIZE_IN_TILE) return false; 

     if (piece.getY() < tileY) return false; 
     if (piece.getY() > tileY + PIECE_SIZE_IN_TILE) return false; 

     return true; 
    } 
} 

Hoffnung, die Du gestartet wird. Der gesamte Code wird ohne einen Compiler in der Nähe geschrieben, so dass Tippfehler und natürlich Bugs enthalten sind, die unter der Creative-Commons-Lizenz vertrieben werden.

Der Ansatz, die Teile in einem Satz zu behalten, sollte gut funktionieren, wenn es nicht zu viele Teile gibt. Es sollte besser funktionieren als ein 2D-Array, solange die meisten Board-Bereiche kein Stück enthalten. Das Ganze geht derzeit davon aus, dass es keine überlappenden Teile gibt. Wenn Sie diese benötigen, muss getPieceOnTile eine Sammlung von Stücken zurückgeben. Ein Set, wenn die Reihenfolge keine Rolle spielt, eine Liste, wenn es so ist.