¿Cómo construir un mapa en mosaico en Java para un juego en 2D?

Question

No estoy seguro de cómo abordar este problema.

Básicamente, quiero un píxel - > Representación en mosaico de una ventana de 400x400. Cada coordenada en la pantalla, por ejemplo, 120x300 debe ser parte de un mosaico. Mi sprite más pequeño es de 4 píxeles, por lo que podemos decir que 1 azulejo = 4 píxeles. El jugador y los sprites enemigos son todos de 20 x 20, por lo que cada jugador / hombre malo ocupará 5 casillas.

Luego quiero usar esta clase de Mapa para:

• Recupera las coordenadas x / y de un jugador / sprite monstruo al proporcionar el índice / id de la ficha.

• Saber dónde están los límites, por lo que no mueve el sprite más allá de 400x400 , por lo que lo oculta.

• Detección de colisiones, sabiendo si una pieza está vacía o no.

¿Cómo se puede hacer esto? Hablando específicamente sobre el índice x, y- > azulejo o azulejo- > x, y (para dibujar los sprites apropiadamente) aquí.

Answer 1

En primer lugar, divida el concepto de píxel, que solo tiene que ver con la representación, con un mosaico, que es un objeto de juego real con restricciones que impone al juego.

Encuentro que una buena manera de desenredar cosas como esta es comenzar a esbozar la API aproximada de lo que quieres. Algo como:

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 )

donde todas las unidades internas de la placa están en mosaicos, no en píxeles. Luego, la información de píxeles se puede derivar de la placa de forma independiente de la representación de mosaico con un poco de multiplicación interna-

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

Los mosaicos pueden representarse internamente como una matriz 2d o una matriz única, en cuyo caso usarías algún tipo de esquema de representación interna para asignar tu matriz a los cuadrados de la pizarra, por lo tanto, la aritmética mod.

Answer 2

Respuesta corta: operaciones de multiplicación y módulo.

Pero si esto te está molestando, te sugiero que hagas un repaso de matemáticas antes de intentar escribir un juego.

También tu declaración

  

Mi sprite más pequeño es de 4 píxeles, por lo que   Se puede decir que 1 pieza = 4 píxeles. los   jugador y enemigos sprites son todos 20 x   20, por lo que cada jugador / malo ocupará   5 fichas.

no funciona para cualquier geometría razonable. Si por " 1 mosaico = 4 píxeles " quieres decir que las fichas son 2x2, entonces un jugador toma 100, no cinco. Si quieres decir que son 4x4, los jugadores toman 25, que aún no es 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;
}

Probablemente también querrá métodos que operen en dos argumentos (x e y en).

Para la conversión de piezas ID y & y viceversa, tiene varios enfoques disponibles. Cuál elegir depende de los requisitos exactos (velocidad, tamaño del juego ...). Así que asegúrese de que está ocultando los detalles de la implementación, para poder cambiarlos más adelante.

Empezaría con una solución realmente fácil:

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

Espero que te ayude a empezar. Todo el código se escribe sin un compilador cercano, por lo que incluirá errores tipográficos y, por supuesto, errores, que pueden distribuirse bajo la licencia de Creative Commons.

El enfoque de mantener las piezas en un conjunto debería funcionar bien si no hay muchas piezas. Debería funcionar mejor que una matriz 2D siempre que la mayoría del área del tablero no contenga una pieza. Todo el asunto actualmente asume que no hay piezas superpuestas. Si los necesita, getPieceOnTile debe devolver una colección de piezas. Un conjunto si el orden no importa, una lista si lo hace.