Como construir um mapa telhado em Java para um jogo 2D?

Question

Não tenho certeza como abordar este problema.

Basicamente, eu quero um Pixel -> representação telha de uma janela de 400x400. Cada coordenada na tela, por exemplo 120x300 deve ser parte de uma telha. Meu menor Sprite é de 4 pixels, por isso, podemos dizer que uma telha = 4 pixels. O jogador eo inimigo sprites são 20 x 20, de modo que cada jogador / bandido vai ocupar 5 telhas.

Então eu quero usar essa classe Map para:

• Recuperar x / y coordenadas de um sprite jogador / monstro por suppling o índice / id da telha.

• Saber onde estão os limites, por isso não se move o sprite além 400x400, escondendo-a.

• A detecção de colisão, saber se uma telha é vago ou não.

Como isso pode ser feito? Falando especificamente sobre o x, y> telha ou telha index-> ??x, y conversão (para desenhar os sprites apropriadamente) aqui.

Answer 1

Em primeiro lugar, dividir o conceito de um pixel, que está apenas preocupado com a representação, com uma telha, que é um objeto real do jogo com restrições colocar no jogo.

I encontrar uma boa maneira de coisas desembaraçar como esta é começar esboçar a API aproximada do que você quer. 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 )

onde todas as unidades internas do conselho estão em telhas, e não pixels. Em seguida, informações de pixel pode ser derivada a partir da placa de forma independente a partir da representação da telha com um pouco de multiplicação interna -

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

As telhas podem ser representados internamente como uma matriz 2D ou uma única matriz, caso em que você pode usar algum tipo de esquema de representação interna para mapear a sua matriz para as casas do tabuleiro, assim, a aritmética mod.

Answer 2

Resposta curta:. Operações de multiplicação e Modulo

Mas se esta é stumping você, eu sugiro que você faça um sério reciclagem de matemática antes de tentar escrever um jogo.

Também a sua declaração

Meu menor Sprite é de 4 pixels, então nós podemos dizer que um azulejo = 4 pixels. o jogador e inimigos sprites são todos os 20 x 20, de modo que cada jogador / bandido ocupará 5 telhas.

não funciona para qualquer geometria razoável. Se por "1 azulejo = 4 pixels" Você quer dizer que as telhas são 2x2, em seguida, um jogador tem 100, e não cinco. Se você quer dizer que eles são 4x4, em seguida, os jogadores assumem 25, que ainda não é 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;
}

Você provavelmente vai querer métodos operando em dois argumentos (xey a) também.

Para o ID-> conversão peça e vice-versa você tem várias abordagens disponíveis. Qual escolher depende das necessidades exatas (velocidade, tamanho do jogo ...). Então certifique-se de que você está escondendo os detalhes de implementação, para que possa alterá-los mais tarde.

Eu começaria com uma solução fácil real:

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

A esperança que se você começou. Todo o código é escrito sem um compilador nas proximidades para que ele irá incluir erros de digitação e de erros do curso, que podem ser distribuídos sob a licença Creative Commons.

A abordagem de manter as peças em um conjunto deve funcionar bem se não há a muitas peças. Ele deve funcionar melhor do que uma matriz 2D, enquanto a maioria de área bordo não contém um pedaço. A coisa toda assume atualmente não há peças sobrepostas. Se você precisar os getPieceOnTile deve retornar uma coleção de peças. Um conjunto se a ordem não importa, uma lista se ele faz.