Geração Processual em Games


18 quintilhões de planetas
, cada um com a extensão de um planeta real. Áreas praticamente infinitas pra você, seus filhos, seus netos, bisnetos e os bisnetos dos seus bisnetos explorarem ininterruptamente, do momento em que aprendem a segurar num controle de videogame até o momento em que morrem de velhice. De fato, seriam necessários 584.942.417.355 anos para visitar – por apenas um segundo – todos os planetas de No Man’s Sky.

O jogo, que está sendo desenvolvido pela Hello Games, tem chamado a atenção do público nos últimos anos pelo seu potencial de gerar horas gigantescas de exploração, levando o conceito de mundo aberto, eu diria, a um novo nível: universo aberto.

No Man's SkyNo Man’s Sky, 2015

Duas palavras: geração processual (ou, como também dizem por aí, “procedural”).

Quem é, afinal, essa tal de geração processual?

A ideia da geração processual é, basicamente, quando o computador cria, de maneira quase aleatória, o conteúdo do jogo. Em vez de termos uma equipe de level designers, por exemplo, projetando cada nível individualmente – o que leva tempo e dinheiro – temos uma máquina capaz de criar cenários infinitamente maiores em muito menos tempo.

O conceito é muito complexo e explicar aqui todo seu fundamento matemático não acrescentaria muita coisa (até porque eu também não saberia explicar como funciona). Além disso, é um método que abrange muitas aplicações diferentes, portanto vou focar aqui na geração processual de uma maneira geral. Mas, de maneira resumida, a ideia pode até soar simples. É assim: primeiro é gerado um número, que posteriormente é usado pra gerar vários outros números através de um algoritmo específico. Esses números iniciais são chamados de seeds (se você joga/jogou Minecraft: sim, são aqueles números que você tem a opção de escolher na hora de gerar o mundo). Esse recurso é bem usado na computação em geral, mas nesse artigo aqui só nos convém seu uso no desenvolvimento de videogames, obviamente.

MinecraftMinecraft, 2009

De fato, uma máquina fundamentalmente lógica é incapaz de trabalhar com valores aleatórios. O segredo das seeds é que elas atuam como uma espécie de fórmula que sempre resulta numa mesma sequência de números que parecem aleatórios. Na realidade, o uso de seeds é um processo pseudorrandômico. Afinal, é assim que sempre que duas pessoas inserem a mesma seed, o mundo criado pra elas no Minecraft também é o mesmo.

Não apenas a questão matemática da coisa é pseudorrandômica, mas o seu game design também. Pode não parecer óbvio, mas um jogo criado de maneira realmente randômica teria o risco de ser um jogo impossível de ser concluído, ou pior: poderia criar um jogo excessivamente chato. Portanto, antes de tudo, regras devem ser traçadas para pautar essas “aleatoriedades” que serão construídas com a geração processual: quantidade máxima de inimigos, tamanho padrão do cenário, como os itens se posicionam na tela e por aí vai. O processo é mais ou menos o de criar um cenário caótico onde tudo pode acontecer e “lapidar” as possibilidades até que elas fiquem dentro do que é aceitável.

Resumindo tudo isso numa única frase: geração processual é um método usado para criar conteúdos algoritmicamente em vez de criá-los manualmente.

O conceito pode parecer original, mas não é. Na realidade, vários jogos, numa época em que todo espaço num disquete valia ouro para os programadores, se aproveitaram dessa ideia pra economizar memória.

Rogue (1980), provavelmente, foi um dos primeiros jogos a fazer uso da técnica ou, pelo menos, ajudou bastante a popularizá-la. Desenvolvido por Michael Toy, Glenn Wichman e Ken Arnold, era uma aventura em calabouços com possibilidades infinitas de exploração, inúmeras armadilhas e inimigos, que só foi possível graças ao seu game design que se baseava em geração processual. Isso na época em que os gráficos de muitos jogos (no caso de Rogue, renderizados em ASCII) ainda abusavam da imaginação das crianças. O gênero que conhecemos hoje como “roguelike” (literalmente “tipo Rogue”) teve sua origem nesse cara.

Rogue, 1980

Elite, de 1984, foi desenvolvido por Ian Bell e David Braben. O jogo é uma aventura galáctica com um complexo sistema econômico e social, com um esquema de comércio muito bem elaborado. Além disso, oito galáxias gigantes estão à disposição do jogador, todas geradas através de um algoritmo que usa a sequência de Fibonacci para criar seus mundos. Se isso já não fosse espantoso demais para um jogo de 1984, fique sabendo que a ideia original era criar 282 trilhões de galáxias através de geração processual, cada uma com 256 sistemas solares (e provavelmente cada sistema solar com seu grupo de planetas). Infelizmente, a ideia não foi pra frente porque a publicadora ficou com medo de assustar os jogadores com a quantidade exorbitante de planetas. No Man’s Sky não parece tão surpreendente agora, não é mesmo?

Elite, 1984

Uma herdeira mais famosa dessa ideia talvez seja a série Diablo, da Blizzard Entertainment. Um jogo de ação/RPG que ajudou a definir o gênero de exploração e pilhagem em masmorras, Diablo I trouxe um nível de exploração poucas vezes visto antes ao implementar a geração processual na criação do conteúdo de suas dungeons. Nunca uma masmorra será igual à outra, e as experiências sempre oferecem algo novo.

Diablo 1, 1996

“Nossa, mas essa tal de geração processual é porreta mesmo, hein! Por que eu não vejo todos os jogos usando ela por aí?”

Primeiro porque não é tão simples assim, e cada jogo é um caso. Um jogo construído detalhe por detalhe por um profissional específico é, naturalmente, muito mais bem feito que um jogo construído quase aleatoriamente por um algoritmo; é uma troca: a qualidade pela quantidade. Além do fato de que a chance de qualquer ambiente criado com geração processual ser memorável é quase nula (provavelmente só pra quem jogou, mesmo). Ninguém precisaria visitar todos os 18 quintilhões de planetas de No Man’s Sky pra saber que depois das primeiras centenas a experiência já não é tão surpreendente. Minecraft, idem: cenários não muito diferentes entre si que se repetem, repetem e repetem… Infinitamente.

E segundo, porque é difícil: construir um jogo com geração processual de qualidade, coerente e envolvente requer um trabalho intenso de programação. Por isso que poucos jogos com um tempo de experiência definida – como Zelda, que tem aquele tempo estimado de jogo e depois disso acabou – usam geração processual, e mais jogos como Minecraft, Terraria e Dwarf Fortress, com suas experiências de tempo indefinidas, usam desse método. Afinal, gastar recursos para criar apenas um pequeno aspecto da produção usando a geração processual acaba sendo menos prático – e provavelmente de qualidade inferior – do que trabalhar manualmente esses detalhes do jogo.

Na prática, a geração processual permite que os desenvolvedores economizem uma quantidade absurda de arquivos no produto final, que só é inserida através de sequências lógicas de etapas na hora em que o jogo é iniciado. Em outras palavras, temos um artista (por exemplo) que só precisa criar uma quantidade limitada de assets (imagens, texturas etc) que é usada pelo algoritmo na hora de gerar o conteúdo do jogo.

A questão não é discutir se esses jogos são bons ou ruins; isso fica a critério do gosto de cada jogador. A ideia aqui foi tentar esclarecer o conceito de geração de conteúdo através do método processual e como isso está mudando – ou, pra ser mais preciso, já mudou – a maneira como os jogos estão sendo feitos. Espero que o artigo tenha sido bem explicativo; se não, que, no mínimo, tenha te incitado a imaginação para tentar pensar nas possibilidades que o futuro da geração processual pode trazer pros videogames.

Artigo desenvolvido por PATRICK DIEGO, divulgado no blog Gabinales.

Resumido/adaptado por Leonardo Ortiz – Célula de Jogos.

Comments Are Closed