Como gerar um mapa em Java?
https://stackoverflow.com/questions/1026975
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
I tentar completar um jogo de RPG para um projeto, mas não tenho idéia de como fazer o mapa do jogo. Ele não precisa ser gráfica, mas o código para todo o mapa e cada telha deve estar correto.
Até agora, eu pensei em fazer um mapa não matricial (como pedido pelo professor) usando um ArrayList que contêm todas as peças ligadas.
public abstract class Casella {
/**
* @uml.property name="tabellone"
* @uml.associationEnd multiplicity="(1 1)" inverse="casella:Tabellone"
* @uml.association name="contains"
*/
private int id;
private boolean free = true;
private List adjacent;
private List items;
private Tabellone tabellone = null;
public void in(){
free = false;
}
public void out(){
free = true;
}
}
Este era o código para um único azulejo (que tem 3 classes que estende-lo). Eu ainda não tenho idéia de como montar e gerar um mapa.
Obrigado pelo seu tempo.
Solução 6
Eu consegui isso usando listas de adjacência. Cada célula terá um ArrayList contendo os índices das células adjacentes. Esses índices são os que a referida célula tem no mapa ArrayList de células.
Outras dicas
Não comece com a implementação, começar com a forma como você gostaria de usar o mapa. Isso vai dar-lhe algumas restrições como implementá-lo. Por exemplo:
Ao desenhar o mapa, como você acessá-lo? Ao coordenar? Ou "ir para o oeste da telha X"?
[EDIT] Eu sugiro começar com o loop principal do jogo RPG. Você precisa colocar o caractere / em algum lugar simbólico (ou seja, ele precisa de algum tipo de relação com uma telha).
Então você precisa para mover o personagem. Um personagem deve ser capaz de examinar o ladrilho atual (adversários, itens, tipo). Ele precisa de uma maneira de saber como ele pode mover (ou seja, há uma parede à direita?)
Isto dá-lhe uma interface para seu mapa: serviços que presta para outros objetos no jogo. Quando você tem uma idéia do que as necessidades de interface para fornecer, que deve lhe dar uma idéia de como implementar o mapa (a estrutura de dados).
Como para gerar um mapa, use um gerador de números aleatórios mais alguns "senso comum". Ter um olhar para os azulejos adjacentes: Quando eles são todos da cidade, esta telha é provavelmente cidade, também. Mesmo para planícies. Hills são itens singulares, e eles são menos frequentes.
Executar este código, imprimir o mapa como ASCII ( "C" dade, "P" Lain, "H" doente) para ver se funciona.
Para gerar um mapa como este sem o uso de uma matriz, eu recomendo começar com uma telha centro e, em seguida, preencher o mapa para fora usando um algoritmo de busca primeira amplitude modificada. Primeiro de tudo, vamos precisar de algo um pouco melhor do que uma lista de telhas adjacentes. Você poderia simplesmente ter quatro variáveis, uma para cada direção que armazena a próxima azulejo, como tal:
private Tabellone up = null;
private Tabellone down = null;
private Tabellone left = null;
private Tabellone right = null;
Say começamos com o centro-mais telha. Tudo que você tem a fazer agora é descobrir quantas das direções são nulos, e criar um novo objeto Tablellone para cada sentido, certificando-se de definir cada uma das variáveis ??neste objeto atual e definir a variável oposta apropriado no objeto criado .
Tabellone adj = new Tabellone();
up = adj;
adj.setDown(this);
Uma vez que você preencheu todos os sentidos neste azulejo, você, em seguida, escolha uma das outras peças que você criou e realizar a mesma operação. Este é o lugar onde o algoritmo de busca em largura entra. Você pode usar uma fila para passar por cada telha que você criou e preencher as direções. Para fazer parar o algoritmo, basta definir um limite para o número de peças que você deseja criar e usar um contador para manter o controle de quantas foram criadas.
int count = 0;
ArrayList<Tabellone> queue = new ArrayList<Tabellone>()
queue.add(/*center tile*/);
while (count < 100) { //if we want 100 tiles
//take out the center tile from the beginning of the array list, create a tile for each direction and add those tiles to the array list, then increment count by 1.
}
Nota:. Este algoritmo, tal como está irá criar um mapa em forma de diamante, se você quiser um quadrado, você precisa ter uma variável para cada sentido diagonal bem
Claro que, se isso parece um pouco mais complicado do que você gostaria, eu recomendo um sistema de coordenadas.
As paredes, baggs e áreas são recipientes especiais, que irá realizar todas as paredes, baggs e áreas do jogo.
private String level =
" ######\n"
+ " ## #\n"
+ " ##$ #\n"
+ " #### $##\n"
+ " ## $ $ #\n"
+ "#### # ## # ######\n"
+ "## # ## ##### ..#\n"
+ "## $ $ ..#\n"
+ "###### ### #@## ..#\n"
+ " ## #########\n"
+ " ########\n";
Este é o nível do jogo. Exceto para o espaço, há cinco caracteres. O hash (#) representa uma parede. O dólar ($) representa a caixa para mover. O caractere de ponto (.) Representa o lugar onde devemos mover a caixa. A pelo carácter (@) é o sokoban. E, finalmente, o caractere de nova linha (\ n) inicia uma nova linha do mundo.
é a velocidade ou memória uma enorme preocupação para este projeto? Se não, por que não usar uma matriz 2d?
Algo como
Casella map [][] = new Casella[xSize][ySize];
A partir daqui é fácil de conceber, apenas imaginá-lo como uma planilha do Excel, onde cada célula é uma telha no mapa.
A forma como você está indo é bom, porém, apenas um pouco difícil de conceituar às vezes. Você tem uma lista de telhas adjacentes. Assim, ao criar seu mapa que começar por algum lado, possivelmente superior esquerdo, e de lá ir.
Você pode usar laços for aninhados, a fim de criar o mapa, e para ajudar a determinar os itens de ponta.
for(int i = 0; i < XSIZE ; ++i)
for(int j = 0; j < YSIZE ; ++j)
if(j==0) //found left edge (i.e. no adjacent ones to the left)
if(j==(YSIZE)) //found right edge (you get the picture)
O ponto de usar os loops, e verificar as bordas, é que você está indo para necessidade de trás da ligação e para a frente, para cima e para baixo por cada telha, exceto nas bordas, onde você terá 2 ou 3 ligações em vez de 4.
As necessidades de código para ser correto realmente não é um requisito funcional, por isso é difícil dizer exatamente o que está correto sem saber mais sobre o seu jogo / mapa.
Supondo que você tenha um mapa que tem azulejos X e adjacência não ordenou uma solução não matricial é melhor, uma solução comum é apenas para modelá-lo como um gráfico usando lista de adjacência para adjacência ou incidência lista não simétrica para adjacência simétrica . Se você estiver usando uma lista de incidência que você precisa de um objeto de ponta que contêm os vértices da borda está se conectando, se você está usando a lista de adjacência a multimap pode ser legal para uso.
Se você quer uma solução não-matricial com adjacência ordenou AlbertoPL tem a solução para isso.
Assumindo que tem um mapa eis X telhas de largura e Y azulejos de altura e as peças que estão ao lado uns dos outros são adjacentes, de modo que cada painel tem no máximo 4 e min 2 telhas adjacentes pode utilizar uma matriz para acesso as telhas e também representam adjacência por adjacência matricial. A ideia é que o mapa [Y] [X] é adjacente para mapear [Y + 1] [X] e mapear [Y] [x + 1] e inversamente. Esta solução pode também encaixar max adjacência 6 e 3 min a telha se telha [Y + 1] [x + 1] é adjacente à telha [Y] [X]. Vantagem disso é que você pode facilmente analisar o mapa, e uma vez que tem 2 dimensões a sua natural para modelá-lo como este. Desvantagem é que uma vez que uma telha é definido, você não pode mudar a sua adjacência sem alterar a matriz. Como isso não é o que você o professor sugeriu que você pode não querer fazê-lo, mas se você tiver (estático) adjacência ordenou isso pode ser maneira mais fácil de fazê-lo.
Se é um mapa baseado em azulejo, em seguida, cada quarto tem uma relação fixa com os seus quartos adjacentes. Você pode não precisar se preocupar com coordenadas (embora possa ser mais simples se as telhas são quadrados), mas você vai precisar se preocupar com as direções.
Se as telhas são quadrados, pontos cardeais (N, S, E, W) pode ser tudo o que você precisa se preocupar. Se eles estão azulejos hexagonais, você pode numerar as saídas 1-6 (talvez com constantes finais estáticos). Em seguida, cada peça adjacente pode estar ligada a esta, juntamente com a sua saída.
Como foi dito por Aaron , você precisa primeiro decidir como as coordenadas Maping será.
Mas você não está limitado por um X-Y-Z sistema de coordenadas. Por exemplo, cada telha poderia estar ligado a qualquer outra peça em seu mapa. Tudo depende de como você quer construí-lo.
Você diz que você está construindo um jogo de RPG, então você precisa ter uma boa visão do terreno envolvente seu personagem. É multi-nível? Como é que o personagem se mover de um lado a lado para outro? É a forma como o movimento de um?
Existem, literalmente, dezenas de pergunta a ser feita ao projetar um mapa para um jogo.
Você precisa planejar muito bem em primeiro lugar, antes de iniciar a codificação.
