Comment construire une carte en mosaïque en Java pour un jeu en 2D?

Question

Vous ne savez pas comment aborder ce problème.

En gros, je veux un pixel - > Représentation en mosaïque d'une fenêtre 400x400. Chaque coordonnée à l'écran, par exemple 120x300 doit faire partie d'une mosaïque. Mon plus petit sprite est de 4 pixels, on peut donc dire que 1 mosaïque = 4 pixels. Les sprites des joueurs et des ennemis sont tous de 20 x 20, donc chaque joueur / méchant occupera 5 tuiles.

Ensuite, je souhaite utiliser cette classe Map pour:

• Récupérez les coordonnées x / y d'un sprite de joueur / monstre en fournissant l'index / id de la tuile.

• Savoir où se trouvent les limites pour ne pas déplacer le sprite au-delà de 400x400 , donc le masquer.

• Détection des collisions, savoir si une tuile est vacante ou non.

Comment cela peut-il être fait? Parlez spécifiquement de la conversion x, y - ou gabarit ou index de gabarit> x, y (pour dessiner correctement les sprites) ici.

Answer 1

Tout d’abord, divisez le concept de pixel, qui ne concerne que la représentation, avec une tuile, qui est un objet de jeu réel avec des contraintes qu’il impose au jeu.

Je trouve un bon moyen de démêler des choses comme celle-ci, c'est de commencer à dessiner l'API de base que vous souhaitez. Quelque chose comme:

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 )

où toutes les unités internes du tableau sont en carreaux et non en pixels. Ensuite, les informations sur les pixels peuvent être dérivées du tableau indépendamment de la représentation en mosaïque avec un peu de multiplication interne -

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

Les tuiles peuvent être représentées en interne sous la forme d'un tableau 2D ou d'un tableau unique. Dans ce cas, vous utiliseriez une sorte de schéma de représentation interne pour mapper votre tableau sur les carrés du tableau, d'où l'arithmétique mod.

Answer 2

Réponse courte: Opérations de multiplication et Modulo.

Mais si cela vous gêne, je vous conseillerais de faire un sérieux rappel de maths avant d'essayer d'écrire un jeu.

Votre déclaration également

  

Mon plus petit sprite mesure 4 pixels, donc nous   peut dire que 1 tuile = 4 pixels. le   les sprites de joueurs et ennemis sont tous 20 x   20, donc chaque joueur / méchant occupera   5 tuiles.

ne fonctionne pas pour une géométrie raisonnable. Si par "1 mosaïque = 4 pixels" vous voulez dire que les tuiles sont 2x2, puis un joueur en prend 100, pas cinq. Si vous voulez dire qu’ils sont 4x4, les joueurs en prennent 25, ce qui n’est pas encore 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;
}

Vous voudrez probablement aussi des méthodes opérant sur deux arguments (x et y at).

Pour la conversion de pièces ID - > et inversement, différentes approches sont disponibles. Lequel choisir dépend des exigences exactes (vitesse, taille du jeu ...). Assurez-vous donc de masquer les détails de la mise en œuvre afin de pouvoir les modifier ultérieurement.

Je commencerais par une vraie solution simple:

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

J'espère que cela vous aide à démarrer. Tout le code est écrit sans compilateur à proximité. Il comprendra donc des fautes de frappe et bien sûr des bogues, qui peuvent être distribués sous la licence creative commons.

L’approche consistant à conserver les pièces dans un ensemble devrait bien fonctionner s’il n’y en a pas beaucoup. Cela devrait fonctionner mieux qu'un tableau 2D tant que la plupart des zones de carte ne contiennent pas de pièce. Actuellement, tout suppose que les pièces ne se chevauchent pas. Si vous en avez besoin, getPieceOnTile doit renvoyer une collection de pièces. Un ensemble si l'ordre n'a pas d'importance, une liste si c'est le cas.