Wie man ein Fliesen-Karte in Java für ein 2D-Spiel?

Question

Nicht sicher, wie Sie zur Lösung dieses Problems.

Im Grunde, will ich einen Pixel -> Kachel-Darstellung einer 400x400 Fenster.Jede Koordinate auf dem Bildschirm, in e.g 120x300 sollte ein Teil der Fliese.Meine kleinste sprite 4 Pixel, so können wir sagen, dass 1 tile = 4 Pixel.Der Spieler und feindlichen sprites sind alle 20 x 20, so dass jeder Spieler/böser Kerl wird besetzen 5 Fliesen.

Dann möchte ich diese Karte benutzen-Klasse:

• Abrufen der x/y-Koordinaten von einem Spieler/monster-sprite durch ver index/id der Fliese.

• Zu wissen, wo die Grenzen sind, so dass es nicht bewegen das sprite über 400x400, damit es zu verbergen.

• Kollisionserkennung, zu wissen, ob die Fliese frei ist oder nicht.

Wie kann das getan werden?Reden, speziell über die x -, y->Fliese oder Kachel index->x,y-Konvertierung (für das zeichnen des sprites entsprechend) hier.

Answer 1

Erstens, split-out-Konzept von ein pixel, nur um Repräsentation, mit einer Kachel, die eine tatsächliche Spiel-Objekt mit Einschränkungen Plätze auf dem Spiel.

Ich finden ein guter Weg, um zu entwirren, Dinge wie dieses zu beginnen, skizzieren die grobe API, 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 des Vorstands sind in den Fliesen, nicht auf Pixel.Dann pixel-Informationen abgeleitet werden kann aus dem Vorstand unabhängig von der Kachel-Darstellung mit ein bisschen interne Multiplikation-

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

Die Fliesen können werden intern dargestellt als 2d-array oder eine Matrix, in dem Fall würden Sie eine Art der internen Darstellung Schema zum map array in den Vorstand Quadrate, also die mod-Arithmetik.

Answer 2

Kurze Antwort:Multiplikation und Modulo-Operationen.

Aber wenn dies ist guckten Sie, würde ich vorschlagen, Sie tun eine ernste Mathematik Auffrischungskurs, bevor Sie versuchen zu schreiben, ein Spiel.

Auch Ihre Aussage

Meine kleinste sprite 4 Pixel, so dass wir können Sie sagen, 1 tile = 4 Pixel.Die - player und Feind sprites sind alle 20 x 20, so dass jeder Spieler/Bösewicht besetzen 5 Fliesen.

nicht jeder angemessenen geometrie.Wenn Sie von "1 tile = 4 Pixel" du meinst, dass die Fliesen werden 2x2, dann ein Spieler nimmt 100, nicht fünf.Wenn Sie meinen, 4x4, dann die Spieler übernehmen die 25, die immer noch nicht 5.

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, die auf zwei Argumente (x und y) als auch.

Für die ID->Stück Umwandlung und Umgekehrt, haben Sie verschiedene Ansätze zur Verfügung.Welche zu wählen, hängt von der genauen Anforderungen (Geschwindigkeit, Größe des Spiels ...).So stellen Sie sicher, dass Sie versteckt sind, die die details der Implementierung, so können Sie Sie später auf.

Ich würde anfangen mit einer ganz einfache Lösung:

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 Sie sofort loslegen.Alle code ist geschrieben, ohne einen compiler in der Nähe, so wird es auch Tippfehler und natürlich Fehler, die möglicherweise verbreitet werden unter der creative-commons-Lizenz.

Der Ansatz, halten Sie die Stücke in ein Satz sollte gut funktionieren, wenn es sind nicht zu viele Stücke.Es sollte besser funktionieren als ein 2D-array so lange wie die meisten Brett-Bereich, die nicht enthalten ist ein Stück.Die ganze Sache aktuell davon ausgeht, dass es keine überlappenden Teile.Wenn Sie benötigen diese getPieceOnTile muss zurück, eine Sammlung von Stücken.Ein gesetzt, wenn die Reihenfolge keine Rolle, eine Liste, wenn es funktioniert.