Tradução em português europeu

O Unity é uma ótima ferramenta para criar protótipos de tudo, desde jogos até visualizações interativas. Neste artigo, analisamos tudo o que precisas saber para começar a utilizar o Unity.

Primeiro, um pouco sobre mim: sou um programador amador em Unity, modelador 3D e designer gráfico, que já trabalho com Unity e Blender há mais de 5 anos. Agora, sou aluno de Matemática Financeira na Universidade College Dublin e, ocasionalmente, faço design gráfico, protótipos para a web e protótipos de jogos como freelance.

Introdução

Este artigo é para aqueles que nunca utilizaram o Unity, mas que tenham alguma experiência em programação ou design/desenvolvimento para a web. No final deste artigo, deves ter uma boa compreensão geral do motor (em inglês, engine), assim como de todas as funções e código necessários para começar a criar um jogo básico.

Por que o Unity?

Se quiseres criar jogos

Existem apenas algumas opções quando falamos de desenvolvimento de jogos independentes. As três escolhas principais, se quiseres desenvolver jogos, são o Unreal, o Unity ou o GameMaker.

O Unity é provavelmente a opção menos restritiva entre as 3 plataformas. Este fornece-te um produto muito cru logo à partida, mas é muito flexível, bem documentado e altamente extensível para criar basicamente qualquer género de jogo que possas imaginar.

Existem bastantes jogos muito bem-sucedidos, como o Escape from Tarkov (Atirador), Monument Valley (Puzzle) e o This War of Mine (Estratégia/Sobrevivência), todos criados com o Unity.

Na realidade, o motor em que crias o teu primeiro jogo provavelmente não é muito importante. Por isso, o meu conselho é que escolhas um e sigas com esse.

Se quiseres criar protótipos de experiências de utilizador

Visto que o Unity é apenas um motor com algumas físicas, animações e renderização 3D em tempo real, também é um ótimo espaço para criar protótipos completos e interativos para estudos de Experiências de Utilizador (UX – do inglês, User Experience).

O Unity tem suporte total para Realidade Virtual e Realidade Aumentada. Ele pode, então, ser uma ótima ferramenta para explorar arquitetura, automatizações e simulações com os clientes.

Secções deste artigo

• Por que o Unity?
• Janela de edição do Unity
• Objetos de jogo do Unity
• Componentes incorporados do Unity
• Criar componentes personalizados
• Estrutura de MonoComportamento
• Manipular GameObjects
• Raycasting
• Deteção de colisão
• Características avançadas
• Conselhos para iniciantes
• Bons recursos e comunidades
• Conclusão

Janela de edição do Unity

A janela de edição é dividida em várias secções. Vamos abordar isto muito brevemente porque vamos referir esta janela constantemente ao longo deste artigo. Se já te sentires à vontade com isto, podes passar esta parte à frente!

Vista da cena: permite a colocação e o movimento de GameObjects na cena

Vista do jogo: permite visualizar como o jogador verá a cena a partir da câmara

Inspetor: fornece detalhes sobre o GameObject selecionado na cena

Recursos e projeto: todos os pré-fabricados, texturas, modelos, scripts e outros estão armazenados aqui

Hierarquia: permite colocar e estruturar GameObjects dentro da cena

Agora, estamos prontos para começar!

Objetos de jogo do Unity

O que são os GameObjects

Os GameObjects são o bloco de construção principal para tudo no motor de jogos Unity. O nome quase que revela tudo:

Tudo o que colocares dentro de uma cena no Unity deve estar envolvida por um "game object" (objeto de jogo).

Se tiveres experiência em design para a web, podes pensar em GameObjects muito como elementos <div>! Recipientes extremamente aborrecidos, mas altamente extensíveis, para criar funcionalidades ou visuais complexos.

Praticamente tudo, desde efeitos de partículas, câmaras, jogadores, elementos de Interface de Utilizador, … (a lista continua) é um GameObject.

Criar hierarquia

Tal com uma <div> em desenvolvimento para a web, um GameObject também é um recipiente. Tal como colocas <div>s umas dentro de outras para criar layouts variados e desejáveis ou abstrações, podes querer fazer o mesmo com os objetos de jogo.

A lógica por trás da colocação de game objects uns dentro de outros é muito parecida com o que é feito em desenvolvimento para a web, vou fornecer alguns exemplos…

Desorganização e eficiência

Analogia com a web: tens muitos elementos semelhantes que podem ser gerados dinamicamente em tempo real em resposta a interações de utilizadores e desejam manter as coisas organizadas.

Tradução do Unity: estás a criar uma cópia do Minecraft e tens muitos blocos na cena, então precisas de adicionar e remover 'pedaços' de blocos da cena por questões de desempenho. Então, faz sentido ter cada pedaço associado a um GameObject pai vazio, visto que remover o pedaço pai remove todos os blocos filhos.

Posicionamento

Analogia com a web: queres manter a posição do conteúdo contido 'relativo' ao recipiente e não à página da web.

Tradução do Unity: criaste um conjunto de drones ajudantes que pairam à volta do jogador. Preferias claramente não escrever código para indicar aos drones para seguir o jogador. Então, em vez disso, instancias os drones como filhos do game object do jogador.

Componentes incorporados do Unity

O Modelo de componente do ator

Os GameObjects por si só são bastante inúteis — tal como vimos, são praticamente apenas recipientes. De maneira a fornecer funcionalidade, temos de adicionar componentes, que são essencialmente scripts escritos em C# ou em Javascript.

O Unity funciona com base num modelo de componente de ator – simplificando, os GameObjects são os atores e os componentes são os teus scripts.

Se já tiveres alguma vez criado uma aplicação para a web, estarás à vontade com a ideia de criar pequenos componentes reutilizáveis, tais como botões, elementos de formulário, layouts flexíveis que têm várias diretrizes diferentes e propriedades personalizáveis. Depois, podes montar estes pequenos componentes em páginas da web maiores.

A grande vantagem dessa abordagem é o nível de reutilização e canais de comunicação claramente definidos entre elementos. Tal como em desenvolvimento de jogos, queremos minimizar o risco de efeitos secundários indesejados. Pequenos erros tendem a ficar fora do controlo se não tivermos cuidado e são extremamente difíceis de depurar. Por isso, criar componentes pequenos, robustos e reutilizáveis é crucial.

Componentes chave incorporados

Acho que está na hora de mostrar alguns exemplos dos componentes incorporados fornecidos pelo motor de jogos Unity.

• MeshFilter: permite-te atribuir materiais a uma malha (em inglês, mesh) 3D para um GameObject
• MeshRender: permite-te atribuir materiais a uma malha 3D
• [Box | Mesh]Collider: ativa a deteção do GameObject durante colisões
• Rigidbody: aciona uma simulação física realista para ser aplicada num GameObjects com malhas 3d e aciona eventos de deteção em colisões de caixas
• Light: ilumina partes da tua cena
• Camera: define a vista do jogador para ser anexada a um GameObject
• Vários componentes de tela da Interface de Utilizador para exibir Interfaces Gráficas de Utilizador

Existem muitos mais, mas estes são os principais que precisas conhecer. Uma dica é que podes aceder a todos os documentos através do manual do Unity e na referência de scripting off-line, onde quer que estejas:

Criar componentes personalizados

Os componentes incorporados controlam primeiramente a física e o visual, mas, para realmente criar um jogo, vais precisar de aceitar inputs do utilizador e manipular esses componentes padrão assim como os próprios GameObjects.

Para começar a criar componentes, vai até ao GameObject desejado > Add Component (Adicionar componente) > escreve o nome do teu novo componente na barra de pesquisa > new script (novo script) (C#).

Como recomendação geral, eu desaconselho utilizar Javascript no Unity. Não foi mantido atualizado com todas as coisas boas que vieram com o ES6 e a maioria das coisas mais avançadas depende de coisas em C# transferidas para Javascript… Por experiência própria, torna-se simplesmente numa solução alternativa gigantesca.

Estrutura de um MonoComportamento

Funções-chave

Todos os componentes herdam da classe do MonoComportamento. Ela inclui vários métodos predefinidos, principalmente:

• void Start(), que é chamado quando um objeto que contém o script é instanciado na cena. Isso é útil sempre que queremos executar algum código de inicialização (por exemplo, definir o equipamento de um jogador após este ser colocado num jogo).
• void Update(), que é chamado a cada frame. É aqui que fica a parte do código que envolve o input do utilizador, atualizando várias propriedades como o movimento de um jogador na cena.

Variáveis do inspetor

Por vezes, queremos tornar os componentes o mais flexíveis possível. Por exemplo, todas as armas podem ter um dano diferente, cadência de tiro, se tem visão etc. Embora todas as armas sejam essencialmente a mesma coisa, podemos querer ser capazes de criar rapidamente diferentes variedades no editor do Unity.

Outro exemplo onde podemos querer fazer isso é quando criamos um componente da Interface de Utilizador, que acompanha os movimentos do rato do utilizador e coloca o cursor na janela. Aqui, podemos querer controlar a sensibilidade dos movimentos do cursor (se o utilizador está a utilizar um joystick ou controlador x um rato de computador). Então, faria sentido ter essa variável fácil de alterar, tanto no modo de edição como durante o tempo de execução.

Podemos fazer isso facilmente ao declará-las como variáveis públicas no corpo do componente.

Aceitar inputs de utilizador

Como é óbvio, queremos que o nosso jogo responda a inputs de utilizador. Uma das maneiras mais comuns de se fazer isso é utilizar os seguintes métodos na função Update() de um componente (ou noutro local que queiras):

• Input.GetKey(KeyCode.W): retorna verdadeiro quando a tecla W está a ser pressionada
• Input.GetKeyDown(KeyCode.W): retorna verdadeiro quando a tecla W é pressionada pela primeira vez
• Input.GetAxis("Vertical"), Input.GetAxis("Horizontal") Retorna entre -1,1 a partir do movimento de input do rato

Manipular GameObjects

Assim que recebermos inputs do utilizador, vamos querer que os GameObjects na nossa cena respondam. Existem vários tipos de respostas que podemos considerar:

• Translação, rotação, escala
• Criar GameObjects
• Enviar mensagens a GameObjects/componentes existentes

Transformações

Todos os GameObjects têm uma propriedade transform, que permite que várias manipulações úteis sejam realizadas no game object atual.

Os métodos são bastante auto-explicativos, basta observar que utilizamos  gameObject em minúsculas para nos referirmos ao GameObject que detém essa instância em específico do componente.

Por norma, é boa prática utilizar local[Position,Rotation] em vez da posição/rotação global de um objeto. Isso, geralmente, torna mais fácil mover objetos num modo que faça sentido, pois o eixo do espaço local estará orientado e centrado no objeto pai e não na origem do mundo e direções x, y e z.

Caso precises de fazer a conversão entre espaço local ou global (que é geralmente o caso), podes utilizar o seguinte:

Como podes imaginar, existe alguma álgebra linear bastante simples atrás disso, indicada pelo 'Inverse' no nome do método.

Criar GameObjects

Visto que os GameObjects são basicamente tudo na tua cena, podes querer ser capaz de gerá-los na hora. Por exemplo, se o teu jogador tiver um género de um lançador de projéteis, podes querer ser capaz de criar projéteis na hora, que vão ter a sua própria lógica encapsulada para voar, efetuar dano etc…

Primeiro, precisamos de introduzir a noção de um Prefab. Podemos criar esses ao arrastar qualquer GameObject na hierarquia da cena para a pasta dos assets.

Isso, basicamente, armazena um template do objeto que tínhamos na cena, com todas as mesmas configurações.

Assim que tivermos estes componentes prefab, podemos atribuí-los a variáveis de inspeção (como abordamos anteriormente) em qualquer componente na cena. Então, podemos criar GameObjects como especificado pelo prefab a qualquer altura.

Podemos realizar 'Instanciação' do prefab e manipulá-lo para a localização desejada na cena e estabelecer as relações hierárquicas necessárias.

Aceder a outros GameObjects e componentes

Por vezes, precisamos de comunicar com outros GameObjects assim como os seus componentes associados. Assim que tiveres uma referência a um game object, isso fica muito simples.

ComponentName comp = some_game_object.GetComponent<ComponentName>();

Depois disso, podes aceder a quaisquer métodos/variáveis públicos do componente de maneira a manipular o GameObject. Essa é a parte mais direta, no entanto. Obter realmente a referência para o GameObject pode ser feito de várias formas diferentes…

Aceder através de variável de inspeção

Esta é a maneira mais direta. Cria simplesmente uma variável pública para o GameObject, tal como demonstramos anteriormente com os prefabs, e arrasta-a manualmente para o componente através do inspetor. De seguida, acede à variável tal como acima.

Aceder através de tags

Podemos atribuir tags a GameObjects ou prefabs através do inspetor e depois utilizar as funções find do game object para localizar as referências para eles.

Isso é simplesmente feito como abaixo.

GameObject some_game_object = GameObject.FindGameObjectWithTag(“Brick”);

Aceder através do atributo transform

Se quisermos aceder a componentes em algum objeto pai, podemos simplesmente fazer isto através do atributo transform.

ComponentName comp = gameObject.transform.parent.GetComponent<ComponentName>();

Aceder através de funções SendMessage

Como alternativa, se quisermos enviar uma mensagem a muitos outros componentes ou desejarmos enviar uma mensagem a um objeto que está bastante acima na hierarquia, podemos utilizar as funções de envio de mensagem, que aceitam o nome da função, seguido pelos argumentos.

gameObject.SendMessage("MethodName",params); // Mensagem de Broadcast

gameObject.SendMessageUpwards("MethodName", params); // Apenas recebido por componentes que estão hierarquicamente acima.

Raycasting

Podes ter ouvido falar disso antes, quando as pessoas comparam jogos de FPS que são 'baseados em físicas' ou 'baseados em raios'. Raycasting é essencialmente como ter um laser que, quando entra em contacto com um 'collider' ou 'rigidbody', retorna um 'hit' e passa de volta os detalhes do objeto.

Existem dois cenários onde isto é útil (existem provavelmente muitos mais):

1. Se estivesses a desenhar um sistema de armas para um jogo, poderias utilizar raycasting para detetar a colisão e até mesmo personalizar o comprimento do raio de modo a que as armas corpo-a-corpo 'atinjam' apenas a curtas distâncias.
2. Criar um raio desde o ponteiro do rato até um ponto num espaço 3D, ou seja, se desejares que o utilizador seja capaz de selecionar unidades com o seu rato num jogo de estratégia.

Como podes ver, o código para isso é um pouco mais complicado. A coisa principal a compreender é que, para criar um raio para onde o rato está a apontar num espaço 3D, é necessária a transformação ScreenPointToRay. A razão para isso é que a câmara está a renderizar um espaço 3D como uma janela 2D no ecrã do teu computador. Então, existe naturalmente uma projeção envolvida para transferir de volta para 3D.

Deteção de colisão

Anteriormente, mencionamos os componentes Collider e Rigidbody, que podem ser adicionados a um objeto. A regra para colisões é que um objeto na colisão deve ter um rigidbody e o outro deve ter um collider (ou ambos terem os dois componentes). Repara que, ao utilizar raycasting, os raios vão interagir apenas com objetos com componentes collider anexados.

Assim que fizermos a configuração dentro de qualquer componente personalizado anexado ao objeto, podemos utilizar os métodos OnCollisionEnter, OnCollisionStay e OnCollisionExit para responder a colisões. Assim que tivermos a informação de colisão, podemos obter o GameObject responsável e utilizar o que aprendemos anteriormente para interagir também com componentes anexados a ele.

Uma coisa a ter em conta é que os rigid-bodies fornecem físicas como gravidade aos objetos. Então, se desejares desligar isto, vais precisar de marcar o is_kinematic.

Características avançadas

Não vamos abordar nada disto para já, mas talvez num artigo futuro — isso é apenas para ficares a par da sua existência.

Criar interfaces gráficas de utilizador (GUI)

O Unity tem um motor de UI completo para definir a GUI do teu jogo. Por norma, esses componentes funcionam de maneira muito semelhante ao resto do motor.

Estender o editor do Unity

O Unity permite-te adicionar botões personalizados aos teus inspetores para que possas afetar o mundo no modo de edição. Por exemplo, para ajudar com a construção do mundo, podes desenvolver uma janela personalizada de ferramentas para criar casas modulares.

Animação

O Unity tem um sistema de animação baseado em gráficos que te permite juntar e controlar animações em vários objetos, tais como jogadores a implementar um sistema de animação com base nos ossos.

Materiais e PBR

O Unity funciona num motor de renderização com base em físicas que permite ter luzes em tempo real e materiais realistas. A realidade é que vais aprender primeiro modelação 3D ou vais utilizar modelos já feitos e otimizados por alguém, de modo a criares algo que realmente tenha bom aspeto.

Dicas para principiantes

Se estiveres a planear criar o teu primeiro jogo, não subestimes a complexidade e o tempo que leva a escrever até o mais trivial dos jogos. Lembra-te que a maior parte dos jogos lançados na Steam têm equipas a trabalhar neles durante anos a tempo inteiro!

Escolhe um conceito simples e divide-o em pequenos objetivos alcançáveis. É altamente recomendado dividir o teu jogo em tantos componentes independentes quanto possível, pois é muito menos provável encontrares erros se mantiveres os componentes simples em vez de blocos de código monolíticos.

Antes de avançares para a escrita de qualquer código para qualquer parte do teu jogo, pesquisa o que outras pessoas fizeram antes para resolver o mesmo problema — é provável que tenham uma solução bastante mais otimizada.

Bons recursos e comunidades

O desenvolvimento de jogos tem uma das melhores comunidades de todas. Existem muitos profissionais altamente habilitados na indústria, que fornecem conteúdo gratuitamente ou por quase nada. É uma área que requer modeladores 3D, artistas conceptuais, designers de jogos, programadores e assim adiante. Abaixo, coloquei os links para alguns recursos gerais ótimos (em inglês) que encontrei para cada um desses campos:

Arte Conceptual

• Feng Zhu Design School (mais de 90 horas de tutoriais de arte conceptual)
• Tyler Edlin Art (ótima comunidade de arte BST com feedback de profissionais em desafios mensais)
• Art Cafe (entrevistas e workshops com artistas conceptuais famosos)
• Trent Kaniuga (ilustrador e artista 2D que também está a criar o seu próprio jogo)

Modelação 3D

• CG Cookie (melhores princípios básicos de malhas 3D no Blender – eles têm muitos outros excelentes conteúdos para o Blender)
• Tor Frick (modeladores de Hard Surface e escultores no Blender)
• Gleb Alexandrov (pequenos tutoriais potentes sobre renderização no Blender)

Desenvolvimento de jogos

• DoubleFine Amnesia Fortnight (programadores de jogos que fazem maratonas de duas semanas a programar e gravam todo o seu processo de design)
• GameMakers Toolkit (examina princípios de design de jogos)

Programação

• Série Handmade Hero no canal Molly Rocket (como criar um jogo e motor a partir do zero em C)
• Jonathan Blow (programador independente que faz livestreams do seu desenvolvimento de jogos)
• Brackeys (bons tutoriais de Unity)

Conclusão

Espero que tenhas gostado deste tutorial! Também faço um pouco de design gráfico, assim como protótipos de jogos e Interfaces de Utilizador.

Se o tutorial foi do teu agrado, dá uma vista de olhos ao portfólio do autor! Ele também está presente no LinkedIn.

O desenvolvimento de jogos é a arte de criar jogos e descreve o planejamento, desenvolvimento e o lançamento de um jogo. Pode envolver a geração de conceitos, design, criação, teste e o lançamento em si. Ao criar jogos, é importante pensar sobre a mecânica do jogo, recompensas, engajamento dos jogadores e design de níveis.

Um desenvolvedor de jogos pode ser um programador, um designer de sons, um artista, um designer ou tantas outras funções que estão disponíveis no setor.

O desenvolvimento de jogos pode ser feito por estúdios de desenvolvimento de jogos gigantes, mas também por indivíduos. Pode ser pequeno ou grande, como você quiser. Basta que ele permita ao jogador interagir com seu conteúdo e ser capaz de manipular os elementos do jogo. É o que você precisa para chamá-lo de "game".

Para se envolver no desenvolvimento de jogos, você não precisa escrever código. Artistas podem criar e desenhar partes do jogo, enquanto um desenvolvedor se concentra, por exemplo, em programar uma barra de vida. Um testador pode estar envolvido em conferir se o jogo funciona conforme o esperado.

Para resolver problemas que os frameworks de jogos costumavam ter, foram criadas ferramentas como o libGDX e o OpenGL. Eles ajudaram o desenvolvimento de jogos a ser muito mais rápido e mais fácil, fornecendo diversas funções pré-prontas e recursos. Porém, ainda costumava ser difícil entrar no setor ou compreender um framework para alguém vindo de um histórico que não fosse da área da programação, o que é um caso comum no cenário de desenvolvimento de jogos hoje em dia.

Foi quando as engines de jogos como Construct, Game Maker, Unity e Unreal foram desenvolvidas. Em geral, uma engine tem tudo o que um framework costumava ter, mas com uma abordagem muito mais amigável, usando uma interface gráfica de usuário (ou GUI) e auxiliando com o desenvolvimento gráfico do jogo.

Em alguns casos, como no Game Maker e no Construct, a quantidade de funções pré-fabricadas é tão grande que pessoas sem nenhum conhecimento em programação poderia construir um jogo do zero, o que aumentou o número de envolvidos na área e tornou o desenvolvimento de jogos acessível a, praticamente, qualquer um.

Engines de jogos

Muitos desenvolvedores escolhem desenvolver jogos, hoje, usando uma Engine de desenvolvimento de jogos.

Engines de jogos podem tornar o processo de criação de um jogo muito mais fácil e permitir que desenvolvedores reutilizem várias funcionalidades. Elas também são responsáveis pela renderização dos gráficos 2D e 3D, pela física e pela detecção de colisões, efeitos sonoros, scripts e muito mais.

Algumas engines de jogos têm uma curva de aprendizagem bastante acentuada, como a CryEngine e a Unreal Engine. Outras ferramentas, no entanto, são bastante acessíveis para os iniciantes. Algumas delas sequer precisam que você consiga escrever código para criar seu próprio jogo, como, por exemplo, a Construct.

A engine de jogos Unity se encontra em algum lugar no meio do caminho. Embora seja fácil de utilizar para iniciantes, alguns jogos comerciais bastante conhecidos já foram criados usando a Unity (por exemplo, Overcooked e Superhot).

A engine de jogos BuildBox serve basicamente para o desenvolvimento de jogos supercasuais.

Engines de jogos conhecidas

• CryEngine
• Engine Unreal
• Engine Unity Game
• Game Maker
• Construct 3
• Twine
• Source
• Frostbite
• Buildbox

Mais informações (em inglês)

• Uma lista incrível de recursos para desenvolvimento de jogos
• Livros de programação de jogos
• Framework OpenGL
• Engine de jogos Construct
• Engine Game Maker
• Engine Unity3D
• Engine Unreal
• BuildBox

Saudações da equipe de desenvolvedores do Learn to Code RPG! Somos Lynn, KayLa e Nielda. Temos trabalhado arduamente na construção de novas aventuras para nossos personagens.

Tenho o prazer de anunciar o lançamento do Learn to Code RPG v1.5, um ano após o lançamento do Learn to Code RPG v1 (curiosidade: estamos chamando de v1.5 em vez de v2 porque temos grandes planos para a v2, que planejamos lançar em breve).

O que é o Learn to Code RPG?

O Learn to Code RPG é um jogo de romance visual (do inglês, visual novel) interativo onde você aprenderá a programar sozinho, fará amigos na indústria de tecnologia e perseguirá seu sonho de trabalhar com desenvolvimento de software. 🎯

O jogo, agora, tem:

• Mais horas de jogo 🎮
• Arte e música originais 🎨
• Mais de mil questões sobre ciência da computação 📚
• Mais de 50 conquistas que você pode desbloquear 🏆
• 6 finais diferentes 👀
• Mais de 10 personagens com os quais você pode fazer amizade, além de um gato adorável 🐱
• Minijogos 👾
• Um sistema de reputação, um sistema de dinheiro e itens divertidos que você pode comprar para seu gato e personalizar seu quarto 🏠

Trailer do jogo Learn to Code RPG v1.5

Você também pode assistir ao trailer do jogo abaixo e compartilhar o vídeo do YouTube com amigos e amigas:

Você pode baixar o jogo e jogá-lo gratuitamente. Ele está disponível para PC, Mac e Linux, na itch.io, e para Android, na Google Play Store.

Se você quiser saber mais sobre o jogo em si e sobre o processo de desenvolvimento, continue lendo.

Agora, vamos ver alguns aspectos da história, personagens, gráficos e código. Tenho certeza de que você vai gostar e pode até se inspirar a programar seu próprio videogame.

Como o LearnToCodeRPG foi da v1 para a v1.5

A equipe

Quando Lynn criou a v1, ela estava trabalhando sozinha no jogo, fazendo malabarismos com a escrita, a programação e a criação de alguns ativos.

Com este lançamento, para dar a Lynn mais tempo para se concentrar no código, KayLa cuidou da redação e Nielda ajudou a pensar nos recursos e na criação dos recursos de arte.

Quer ver uma exemplo de trabalho em equipe? Aqui está um para você, a loja de itens. Depois de comprar os móveis da loja, o jogador verá os móveis em seu quarto.

• Lynn programou a loja, os itens e a personalização do quarto
• KayLa e Nielda tiveram ideias para os itens
• KayLa escreveu textos divertidos para os itens
• Nielda criou todas as imagens – a sala e os itens – analisando ativos em 3D e aplicando texturas sobre eles

A história central do Learn to Code RPG

Na v1 (ou a versão que chamamos de Prólogo), a história começa quando nossa protagonista, Lydia, decide conseguir um emprego na indústria de tecnologia. Ela precisa aprender a codificar, fazer amigos na indústria, encontrar mentores, enfrentar entrevistas técnicas e, ao final, chegar ao seu objetivo – um novo emprego em desenvolvimento de software.

Construindo a partir da história do Prólogo, na v1.5 (ou o que chamamos de Arco I), Lydia começa a trabalhar como desenvolvedora full-stack. Ela, agora, precisa interagir com seus novos colegas no dia a dia e reagir aos eventos que surgem.

Ela enfrentará todas as coisas que um engenheiro de software do mundo real enfrenta – mudanças nos requisitos do projeto, comunicação com gerentes de projeto, aprendizado com desenvolvedores seniores e assim por diante.

Fora do trabalho, Lydia também pode ir ao Hacker Space com os amigos que ela fez quando estava aprendendo a programar.

No Hacker Space, Lydia pode encontrar velhos conhecidos, que também estão procurando emprego. Ela pode decidir se deve ou não os indicar para empregos.

Ela também pode retribuir à comunidade, orientando alunos do ensino médio em seus projetos.

Nunca faltam coisas divertidas para se fazer no Hacker Space. 😄

Os personagens

Para dar mais profundidade aos personagens, fizemos um brainstorming usando o formato de cartão de personagem mostrado abaixo. Aqui está o cartão de personagem para Lydia:

Lydia conhece muitos novos colegas neste arco e nossa lista de personagens foi bastante expandida.

Ao criar os personagens, às vezes, nosso artista, o Noa, experimenta variações de cores e estilos de cabelo até chegar a um design que nos agrade:

Aqui você também verá uma prévia de um dos muitos personagens e suas muitas expressões:

Claro, o favorito de todos, Mint, o gatinho, ainda é o suporte emocional mais importante para este arco de história. 🐱

Os gráficos

Agora, passamos para outros gráficos além da arte de sprites de personagens. Assim como na v1, novamente criamos imagens de fundo aplicando um filtro semelhante à aquarela às imagens do mundo real.

Como muitas histórias acontecem na empresa em que Lydia trabalha, também tentamos encontrar imagens nos bancos de imagens que fossem coerentes com o esquema de cores, como as abaixo:

O código

Assim como na v1, usamos o mecanismo de jogo com o qual estamos mais familiarizados, o Ren'Py Visual Novel Engine.

Durante este ano de desenvolvimento, uma notícia realmente empolgante para a comunidade do Ren'Py é que o Ren'Py 8 agora oferece suporte ao Python 3. Isso é fascinante!

Comparado ao Python 2.7 (que usamos no Ren'Py 7.4, quando desenvolvemos o Learn to Code RPG v1), o Python 3 traz muitos novos recursos que impactam positivamente nosso desenvolvimento.

Isso também significa que tivemos que gastar um pouco de tempo para migrar do Python 2.7 para o Python 3 em nosso projeto (foi um pequeno commit no Git, acredite 🤓).

Agora, algumas estatísticas interessantes: o linter integrado do Ren'Py é perfeito para coletar estatísticas para comparações entre a v1 e a v1.5:

# v1
Ren'Py 7.4.8.1895 lint report, generated at: Fri Dec 17 22:11:43 2021
Statistics:
The game contains 1,335 dialogue blocks, containing 15,390 words and 85,105 characters, for an average of 11.5 words and 64 characters per block.
The game contains 40 menus, 20 images, and 49 screens.

# v1.5
Ren'Py 8.0.3.22090809 lint report, generated at: Tue Dec 20 19:22:05 2022
Statistics:
The game contains 3,339 dialogue blocks, containing 41,214 words and 220,501
characters, for an average of 12.3 words and 66 characters per block.
The game contains 68 menus, 19 images, and 51 screens.

Pelas estatísticas, podemos ver que quase triplicamos o conteúdo da história. Uau! 🤩

As etapas para o LearnToCodeRPG: da v1.5 à v2

Viva! Após um ano inteiro de desenvolvimento, levamos a v1 a novos patamares e agora apresentamos a você o Learn to Code RPG v1.5.

O que é mais empolgante: estamos apenas começando. Assim como Quincy sempre gosta de dizer, o céu é o limite. ✈️

Aqui estão algumas coisas que você pode esperar na v2 (ou até antes, entre a v1.5 e a v2):

• 🌎 Localização: todo o texto da v1 foi totalmente traduzido para o português e temos uma comunidade ativa trabalhando na tradução do jogo para outros idiomas do mundo. Você também pode ajudar, começando por aqui.
• 🎭 Mais histórias e personagens: temos mais de 10 personagens planejados e alguns já desenhados
• 📚 Banco expandido de perguntas do questionário e repetição espaçada para ajudá-lo a aprender com mais eficiência.
• 💻 Atualização automática interna ao jogo para se manter atualizado com as últimas correções de bugs, recursos e histórias.
• ... e muito mais em nossa lista de desejos! 🎁

Por último, mas não menos importante, esperamos que você goste de jogar este jogo tanto quanto nós gostamos de desenvolvê-lo! 🥳

Links (textos em inglês)

Você pode encontrar o jogo na itch.io, aqui:

Learn to Code RPG by freeCodeCamp.org

Learn to code and get a dev job 🎯

itch.io

Este é o repositório do GitHub com todo o código:

GitHub - freeCodeCamp/LearnToCodeRPG: A visual novel video game where you learn to code and get a dev job 🎯

A visual novel video game where you learn to code and get a dev job 🎯 - GitHub - freeCodeCamp/LearnToCodeRPG: A visual novel video game where you learn to code and get a dev job 🎯

freeCodeCampGitHub

Se você ainda não leu sobre como a v1 do jogo tomou forma, aqui está um artigo para você:

Learn to Code RPG – A Visual Novel Video Game Where you Learn Computer Science Concepts

Learn to Code RPG is an interactive visual novel game where you will teach yourself to code, make friends in the tech industry, and pursue your dream of becoming a developer.

Lynn ZhengfreeCodeCamp.org

E aqui está o kit de imprensa oficial do jogo:

Learn to Code RPG – Press Kit

This is the press kit for the game, Learn to Code RPG.

Lynn ZhengfreeCodeCamp.org

Se estiver interessado em criar um Visual Novel Game, confira este meu artigo:

How to Make a Visual Novel Game in 10 Minutes – Python Ren’Py Tutorial

Do you have a story idea that you’d like to turn into a novel? How about addingvisual appeal and interactivity to that novel? A Visual Novel [https://en.wikipedia.org/wiki/Visual_novel] might be the gamegenre you are looking for. And this tutorial is here to help set you up in 10minutes, with m…

Lynn ZhengfreeCodeCamp.org

Esperamos que você goste de aprender sobre como é trabalhar com tecnologia jogando o Learn to Code RPG. 🧑‍💻