Cenário procedural com partes pré modeladas.

Eu tava querendo ter uns lugares novos pra brincar com os personagens q eu fizer, e tbm experimentar umas questões de gameplay de jogos de plataforma (q eu gosto).. Então fiz uns models pra uns encaixarem nos outros de maneira randômica e então eu ter sempre um lugar \'novo\' pra andar, etc...

Usei o Unreal Engine 4 pra fazer o encaixe, e o método q usei foi o \"Recursive Backtracking\", só q alterado... O \"recursive backtracking\" é uma técnica de geração de labirintos.. O q eu mudei dele foi q dá pra escolher o numero minimo de \"Ts\" (\"tês\".. no caso bifurcações XD) (no caso, ele gera o \'labirinto\' varias e varias vezes (apesar de q o computador faz essa logica quase que instantaneamente então só qdo o mapa é muito grande mesmo tipo 20x20 q ele \'pensa\' um instante, embora q pequeno...).. O \"T\" (a bifurcação), segundo o q eu entendi, é o componente que, basicamente, transforma algo que é simplesmente um \'caminho\' (\"é só vc seguir q vc chega no final\", de maneira linear) em algo que se assemelha a um \'labirinto\', na medida em que vc tem o \'impasse\' e há a geração de necessidade de tomada de decisão (entre os dois caminhos..)..

O \'recursive backtracking\' (esse paragrafo é uma explicação sobre o Recursive Backtracker) é logisticamente simples e pode ser aplicado a N dimensões (daria pra fazer com gameplay e modulos 3d, apesar de q aí iria ter mais q 16 formatos básicos, como vou explicar a seguir..)... Pode ser usado tanto pra resolver \'labirintos\' quanto pra gerar eles também...
(os passos lógicos do Recursive Backtracing em 2d)

...Imagine q vc tem um grafico cartesiano X e Y (com os tracinhos, tipo aqueles papéis de desenho técnico q tinha..), e cada quadradinho é uma \'casa\'

... Primeiramente vc junta todas essas coordenadas (das \'casas\') possíveis de serem andadas, um conjunto.. Vou chamar esse \'conjunto\' de um \'array\'... aliás, daqui em diante vou chamar esse tipo de \'conjunto de coisas\' de \'arrays\' de coisas... E dá pra esse array o nome de \"casas andáveis\" ou coisa assim (um nome bacana pra ficar mais facil qq coisa e tal...)...

(no caso, evidentemente, vc tem q modelar os models dos \'modulos\' de salas de maneira a q eles se encaixem perfeitamente e tal... Isso gera uma questão a respeito do material também, mas vou falar disso mais pra frente...)

Desse array (dentre esse conjunto) vc escolhe (vc programa... ah.. vcs são espertos e vão entender =D..) qualquer uma dessas (coordenadas do array), randomicamente.... Isso seria, uma coordenada randômica dentre aquelas \'possiveis\', q tão no array das \'casas andaveis\'... Essa vai ser a coordenada inicial...

Então vc cria um array duplicata desse das \"casas andáveis\" q é pra comparar e chamar os models no final do processo...

Então vc cria um outro array, chamado de \'coordenadas já andadas\' ou coisa mais sucinta... e põe essa primeira coordenada nesse das andadas, e tira do array das andaveis XDD..

Então, tendo-se a \"casa inicial\" (a coordenada inicial), vc remove a mesma do array das \"casas andaveis\" (ja falei)... Toda vez q se \'adicionar\' uma casa nova (das andáveis iniciais), tem q se remover ela do conjunto (do array) das casas \'andaveis\' (pq ela n é andavel e sim andada heuhue XD)..;

Enfim, tendo-se obtido essa casa inicial, \'pra onde iriamos?`.. e então a gente constrói um outro array (outro conjunto) de \'possibilidades\', digamos assim, da próxima casa... Vc tem q \"perguntar\" (no caso articular um booleano \"sim-não\", \"verdadeiro-falso\") praquele primeiro array das \"casas visitaveis\" assim:
-Tem coordenada válida pra esquerda? (caso tenha, adiciona ao conjunto da possível próxima casa...)
-Tem coordenada válida pra direita? (caso tenha, adiciona ao conjunto da possível próxima casa...)
-Tem coordenada válida pra cima (ou norte a depender do caso etc..) ? (caso tenha, adiciona ao conjunto da possível próxima casa...)
-Tem coordenada válida pra baixo (ou sul a depender do caso, etc..)? (caso tenha, adiciona ao conjunto da possível próxima casa...)...

(Uma das razões pra excluir a \'proxima\' casa toda vez é q, caso ela já tenha sido percorrida, n vai ter ela (essa coordenada) pra ser escolhida aqui nesse processo...)

Então, dessas coordenadas \'elegíveis\' pra serem a próxima casa, vc escolhe uma randomicamente, e tira essa mesma coordenada do array das \'andáveis\' e põe a mesma no array das \'andadas\'...

E então se repete o processo até se chegar num lugar onde não há nenhuma casa \'andável\' pra ser elegível como próxima casa... Muito embora ainda haja casas andáveis (no array das casas andáveis xd..)... Aí é q entra o \'backtrack\', ou seja.. \'a gente\' tem q voltar... Por isso q o metodo se chama \"recursive backtracking\"... =D...

Os arrays (os \'conjuntos\'.. e se vc por pra traduzir \'array\' vai dar algo bem parecido com \'conjunto\' mesmo... o conceito de array é pra isso mesmo (agrupar elementos em conjuntos)) tem um ordenamento referente à posição em q eles foram adicionados ao array, por exemplo, a primeira casa q eu adicionei lá no conjunto das \'casa andadas\' vai ser o \'primeiro\' do array das casas andadas, e o ultimo q eu adicionei vai ser o ultimo elemento do conjunto, etc...

Aí então, se n dá pra adicionar nenhuma casa (e ainda tem casas andáveis), vc pensa (vc programa o programinha pra pensar isso =D):
-Então se n tem nenhuma saída nessa ultima... tem na penúltima (adicionada)?
-Se n tem saída na penultima, tem na antepenultima?
-Se n tem na antepenultima, tem na anterior?
-E por aí vai...

Isso é o \"backtrack\" ele vai retrocedendo as casas previamente adicionadas e testando, cada uma delas, pra ver se tem alguma saída... Quando n tem ele volta mais uma (no histórico digamos assim, das já adicionadas) qdo tem saída ocorre o fenomeno do \"T\".. =D.. E então se retorna pra logística inicial, procurando as próximas casas, etc..

Procedendo dessa maneira, até não haver mais nenhum elemento no array das \'casas andáveis\' (inicial) se constrói um cenário randômico (as peças são pré-feitas, não o caminho, q nem o esquema do Diablo 1) e, com a presença do \"T\" (bifurcação) se obtém algo que se pode chamar de labirinto...

...

Sobre o ordenamento dos models, até pq eu n queria ter \'casas inúteis\' ou vazias sem sentido, dividi os formatos possíveis em 16... (pra ter as salas maiores e grandonas abertas, teria 30 e tantas quase 40 mas isso vou pensar depois =D..).. A imagem marcada com I mostra o conceito de cada uma dessas 16...

Comparando-se a casa (coordenada) anterior, a que se está e a próxima q vai ser adicionada, vc vai determinar o formato da casa presente... Por exemplo, caso a \'altura\' (Z) da casa presente for igual à altura da casa anterior e da próxima casa, essa coordenada vai pro conjunto das casas \"do tipo 1\"... Caso o Z do do ultimo e do meio sejam iguais, E o Z do da frente maior do que o Z do do meio, E o Y do da frente maior do que o Y do ultimo, é uma casa do tipo 7, etc, etc...

O T é uma questão quase igual só q mais chata de explicar...


(segunda e terceira imagens são um teste do recursive backtrace... os models tão só com a iluminação..)

(na segunda imagem (com os traços) o branco é o caminho feito antes de a logica chegar no lugar onde n teria saída possível, o azul até o sorriso é o programa retrocedendo às casas já adicionadas até encontrar uma casa onde haja saída possível (por isso o sorriso =D).. e o verde é o mesmo processo q o branco... Isso pode acontecer N vezes e tal...)


A terceira imagem é uma de uma feita de 8 por 8 casas, pra demonstração... Daria pra deixar de qtos fossem... Mas de 5 por 5 já dá trabalho xdd.. de 10 por 10 já é meio tenso... Eu deixei pro maximo ser de 20 por 20... Q eu queria tbm por pra fazer online e cooperativo e tal...


....


Tá dando RAIOS aqui então vou postar ja... depois posto o personagem brincando lá e se pessoal curtir até um link pra escalar um labirinto infinito muhuhu XDD..

A Beleza está entre a Ética e a Razão!..

A primeira é só pra mostrar q a transição vc nem vê na textura =D... Consegui articular uma textura 4K de menos de 500k com o formato TGA e articulando preto e branco com o mapa procedural \"Cellular\" do 3ds.. :)... É quase um mapa procedural (pq o renderizado é gigantesco... eu limpei e tal e usei questões de materiais do ue4 (q nem a gente usa no 3ds mas diferente e as vezes chato, mas as vezes mais legal hehe...)..Usei uma técnica derivada da texura orientada ao World-Space...(e não ao UVW, senão eu ia ter q fazer uma textura pra cada model de \'sala\' o q ia ficar gigantesco caso eu quisesse um minimo de qualidade... etc..).

Na segunda to pulando (qdo ele tá com pouca velocidade ele cai e pula de um jeito (na animação) e qdo ele tá correndo ele dá mortalzinho qdo tá pulando xd...) e vendo a mira (fiz um sisteminha de mira usando a Trigonometria q tinha aprendido aquela vez lá q fiz o script de \'orbitas\' e tbm dos vai e vem dos outros rigs (literalmente aprendí a Trigonometria e seus usos na animação com o \"vai e vem\" das coisas heuheuhueuhue XDD)... Deixei o numpad (os q tem as setas e tal) pra controlar a camera... E subindo e descendo a camera vc sobe e desce tbm a mira... Ele atira magias, um \'pregão\' e tbm uma picareta (mas ele tem q \'adicionar num inventario\' antes de equipar... vai veno só pra andar com um personagem num lugar já brizei heuhueuhe... mas um bom estudo =D...)..

Na terceira to numa das salas do tipo \"dead-end\" (só tem saída pra um lado)... Nessas eu pus uns volumes nuns lugares onde, num lugar randômico desse volume \'nasce\' um cristal randômico (tem só uns 4 mas eu queria tipo 20 até pq é super facil de modelar cristaizinhos... xd..)...

Depois posto mais de gameplay :)..

A Beleza está entre a Ética e a Razão!..