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

Question

Vous ne savez pas comment aborder ce problème.

Fondamentalement, je veux une représentation Pixel -> Tile d'une fenêtre 400x400. Chaque coordonnée sur l'écran, par exemple 120x300 doit faire partie d'une tuile. Mon plus petit sprite est de 4 pixels, donc on peut dire que 1 carreau = 4 pixels. Le joueur et les sprites ennemis sont tous 20 x 20, donc chaque joueur/méchant occupera 5 tuiles.

Je veux utiliser cette classe de la carte à:

• Récupérer les coordonnées x/y d'un sprite joueur/monstre par suppling l'index/id de la tuile. Sachant où sont les limites, il ne déplace pas l'image-objet au-delà de 400x400, le cachant ainsi.

• Détection de collision, sachant si une dalle est vide ou non.

Comment cela peut-il être fait? Parler spécifiquement de la conversion x, y-> tile ou tile index-> ​​x, y (pour dessiner les sprites de façon appropriée) ici.

Answer 1

Premièrement, diviser le concept d'un pixel, qui est juste concerné par la représentation, avec une tuile, qui est un objet de jeu réel avec contraintes qu'il place sur le jeu.

Je trouve un bon moyen de démêler les choses comme ceci est de commencer à esquisser l'API rugueuse de ce que vous voulez. 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 de la carte sont en mosaïque, pas en pixels. informations Ensuite pixel peut être dérivé du conseil d'administration de la représentation indépendamment des carreaux avec un peu de multiplication- interne

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

Les tuiles peuvent être représentés en interne comme un tableau 2D ou un seul tableau, auquel cas vous auriez utiliser une sorte de schéma de représentation interne pour mapper votre tableau aux cases du tableau, donc l'arithmétique du mod.

Answer 2

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

Mais si cela vous bouscule, je vous suggère de faire un sérieux rappel de maths avant d'essayer d'écrire un jeu.

également votre déclaration

Mon petit lutin est de 4 pixels, donc nous peut dire que 1 tile = 4 pixels. Le joueur et les sprites 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 tuile = 4 pixels" vous voulez dire que les tuiles sont 2x2, alors un joueur prend 100, pas cinq. Si vous voulez dire qu'ils sont en 4x4 alors les joueurs en prennent 25, ce qui n'est toujours pas 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 aurez probablement besoin de méthodes opérant sur deux arguments (x et y at).

Pour la conversion ID-> pièce et vice versa vous avez différentes approches disponibles. Lequel choisir dépend des exigences exactes (vitesse, taille du jeu ...). Assurez-vous donc de masquer les détails d'implémentation, afin de pouvoir les modifier ultérieurement.

Je commencerais avec une vraie solution facile:

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

espoir que vous permet de démarrer. Tout le code est écrit sans compilateur à proximité, donc il inclura des fautes de frappe et bien sûr des bogues, qui peuvent être distribués sous licence creative commons.

L'approche de garder les pièces dans un ensemble devrait bien fonctionner s'il n'y a pas beaucoup de pièces. Cela devrait fonctionner mieux qu'un tableau 2D tant que la plupart des cartes ne contiennent pas de pièces. Le tout suppose actuellement qu'il n'y a pas de chevauchement des pièces. Si vous avez besoin de ces getPieceOnTile, vous devez retourner une collection de pièces. Un ensemble si l'ordre n'a pas d'importance, une liste si c'est le cas.