Depois de passar um tempo hoje para anotar algumas notas sobre a implementação de paredes no meu jogo baseado em blocos, de repente percebi que não seria tão simples como eu imaginava antes. Embora o estágio atual do meu trabalho não esteja nem perto de realmente criar o código relacionado à parede, criei três maneiras diferentes de fazê-lo. No momento, não tenho certeza de qual das minhas idéias funcionará melhor e se perdi alguma coisa ou não.
Importante: um personagem PODE ficar em um ladrilho que tenha paredes, independentemente de sua forma.
O comum para todas as três variantes: o mapa de mosaico será "mantido" em um contêiner std :: vector (ou similar) de dimensão única. As razões para isso são (espantosamente) explicadas nas respostas a uma pergunta diferente.
Classes de contêineres em jogos baseados em blocos.
De volta às paredes.
A) A abordagem simples.
Nada extravagante aqui. Cada contêiner de bloco pode conter não apenas caracteres, mas um ou vários objetos de parede, que são anexados à borda dentro do bloco.
Prós: fácil de implementar, nada para mudar no mecanismo. Contras: Duas coisas. Um - pode estar na minha cabeça, mas algumas combinações parecem feias. Segundo - essa abordagem permite fazer uma parede dupla a partir de dois ladrilhos adjacentes. A construção será uma parte importante do jogo, e as paredes duplas permitem que os construtores renunciem a atualizar o material das paredes por meios de jogo e apenas aumentem a durabilidade ao dobrar a parede existente. Isso não é desejável. Claro, eu poderia incluir um procedimento que proíbe a parede dupla, mas terá uma sensação ruim.
B) A abordagem inteligente (?).
Em vez de deixar os jogadores dobrarem o mapa inteiro, vou vencê-los. Cada parede tem duas metades que estão presas à borda do ladrilho por dentro. Então, para criar uma única "unidade de parede", terei que criar dois objetos de meia parede em dois blocos adjacentes.
Prós: É simétrico !!! Além disso, nenhuma alteração significativa nas especificações atuais do mecanismo é necessária. Contras: Mais problemas, mais objetos e, é claro, os "limites". Como você pode ver na figura, um canto basicamente chora por um objeto "cap". Eu sou legal com isso, não é tão difícil de adicionar. Ei, eu já tenho um plano para colunas finas feitas de quatro tampas conectadas. Doce. Ainda assim, tenho algumas preocupações em relação a possíveis problemas no campo de visão e na linha de visão.
C) A variante de revisão total.
Ou eu poderia criar bordas e cantos como contêineres separados para objetos do jogo. Bem desse jeito.
Prós: nem tenho certeza. Bem, é simples. Definitivamente. Contras: Isso exigirá uma revisão geral. Felizmente, não do código, mas da mentalidade atual da mecânica do jogo - isso é certo. Os benefícios não são tão óbvios. Além disso, essa abordagem requer muito mais contêineres do que os dois anteriores. A matemática da indexação também será um pouco trabalhosa.
Então, aqui temos - três maneiras distintas de fazer paredes entre azulejos. Se houver alguma alternativa por aí - ficarei feliz em vê-la. Se houver algum benefício / queda em alguma das abordagens que eu não vi - indique-as.
fonte
Respostas:
Eu usaria o seu método 'B'.
Para evitar a necessidade de 'tampas', estenda cada parede com "1/2 espessura de parede" nas duas direções. Isso criará muros sobrepostos onde eles se encontrarão, mas seus diagramas já sugerem que isso não é um problema.
Portanto, no método 'B', figura 3, a parede horizontal se estenderia um pouco para a esquerda e a parede vertical se estenderia um pouco.
[Sou novo por aqui, acabei de me registrar. Estou faltando alguma coisa, pois não consigo ver o botão "Adicionar comentário" em sua postagem original. Isso é um privilégio de pessoas com maior reputação? Ou estou ignorando o óbvio? Desculpe por adicionar isso como uma 'resposta'.]
fonte
Você notou que um personagem pode ficar em um ladrilho contendo uma parede, mas você já pensou em tratar cada ladrilho como uma parede? Mesmo metade de um ladrilho como parede de maneira horizontal ou vertical?
Prós: os cálculos e as colocações são triviais, a colisão é trivial, onde todos os cálculos e colisões são baseados apenas nas coordenadas da colocação das paredes.
Contras: pode afetar toda a sua implementação, código e gráficos. Você também não quer abandonar totalmente o seu método, mas também deseja casos especiais em que apenas parte de um ladrilho é uma parede (link para o passado com falésias).
É assim que eu basearia minha implementação, daqui para frente, sabendo que sempre posso fazer referência a um bloco e executar um cálculo, dependendo da localização dos meus personagens e que tipo de bloco ele é.
Na parede de um castelo, eu podia fazer um cálculo do centro desenhando uma caixa pela qual não podia passar ou, se é uma rocha redonda, eu poderia fazer o mesmo cálculo do centro, mas como um círculo, para que meu personagem pudesse se mover como se fosse arredondado.
fonte
Desculpe dizer, mas a terceira maneira é realmente a maneira de pensar, bem, você já tem a capacidade de fazer isso, então vamos seguir em frente e pensar nas outras duas!
O problema é que uma parede tem uma largura zero, dois quadrados dimensionais (altura * comprimento, em um mundo 3D) dividindo duas caixas. Você deve considerá-los como tal, mas pode usar uma solução mais simples como quando construir sua masmorra (especialmente se outras pessoas puderem construir partes).
Parece que é um jogo 2D de cima para baixo, onde as paredes têm "uma largura", então elas precisam desse canto (seu objeto 'cap'). Isso é exclusivamente 'gráficos', então eu usaria algum tipo de:
Um mapa 2D com os blocos (ou seja, tipo de bloco e outros).
Um mapa 2D com 2 paredes, ex. inferior e direita (a parede esquerda será a 'parede direita' no bloco à esquerda desta).
+ uma lógica que desenha todas as paredes e 'caps' etc.
Assim, separando lógica e gráficos. Você pode fazer uma "interface" cuidando de coisas como SetWall (ThisTile, LEFT, NOWALL) -> definindo a parede direita do bloco à esquerda do ThisTile como "NOWALL" ...
Talvez isso pareça embaçado, mas o importante é que você sempre deve tentar ter de um lado a lógica (os dados reais, sem redundância) e, do outro lado, o 'desenho dos dados' que calcula se há necessidade de um 'limite' 'etc.
++
fonte