Do Unity ao Godot Engine

Este guia fornece uma visão geral do Godot Engine do ponto de vista de um usuário Unity, e procura lhe ajudar a migrar sua experiência existente em Unity para o mundo do Godot.

Nota

This article talks about older versions of Unity. Nestable prefabs (‘Nested prefabs’) were added to Unity 2018.3. Nestable prefabs are analogous to Godot’s scenes, and allow a more Godot-like approach to scene organization.

Diferenças

  Unity Godot
Licença Proprietário, código fechado, licença grátis com teto de rendimento e restrições de uso Licença MIT, grátis e código totalmente aberto sem nenhuma restrição
OS (editor) Windows, macOS, Linux Windows, macOS, X11 (Linux, *BSD)
OS (exportar)
  • Desktop: Windows, mac OS, Linux
  • Dispositivos móveis: Android, iOS, Windows Phone, Tizen
  • Web: WebAssembly ou asm.js
  • Consoles: PS4, PS Vita, Xbox One, Xbox 360, Wii U, Nintendo 3DS
  • VR: Oculus Rift, SteamVR, Google Cardboard, PlayStation VR, Gear VR, HoloLens
  • TV: Android TV, Samsung Smart TV, tvOS
  • Desktop: Windows, mac OS, X11
  • Dispositivos móveis: Android, iOS
  • Web: WebAssembly
  • Console: Ver Suporte para Consoles em Godot
  • Realidade virtual: Oculus Rift, SteamVR
Sistema de cenas
  • Componente/Cena (GameObject > Component)
  • Prefabs
Árvore de cenas e nós, permitindo que cenas sejam aninhadas e/ou herdem outras cenas
Ferramentas de terceiros Visual Studio ou VS Code
Vantagens notáveis
  • Comunidade enorme
  • Grande armazém de recursos

O editor

A Godot Engine fornece um editor rico em recursos que lhe permite construir seus jogos. As imagens abaixo exibem os dois editores com blocos coloridos para indicar funcionalidades em comum.

../../_images/unity-gui-overlay.png ../../_images/godot-gui-overlay.png

Embora ambos os editores possam parecer semelhantes, há muitas diferenças por trás. Ambos permitem organizar o projeto usando o sistema de arquivos, mas a abordagem da Godot é mais simples com um único arquivo de configuração, formato de texto minimalista e nenhum metadado. Tudo isso contribui para a Godot ser muito mais amigável para sistemas VCS, como Git, Subversion ou Mercurial.

O painel Cena da Godot é semelhante ao painel Hierarquia da Unity, mas, como cada nó tem uma função específica, a abordagem usada pela Godot é mais visualmente descritiva. É mais fácil entender o que uma cena específica faz de relance.

O inspetor na Godot é mais minimalista, mostrando apenas propriedades. Graças a isso, os objetos podem expor uma quantidade muito maior de parâmetros úteis para o usuário sem precisar ocultar a funcionalidade nas APIs da linguagem. Como um acréscimo, Godot permite a animação visual de qualquer uma dessas propriedades, portanto é possível alterar cores, texturas, enumerações ou mesmo links para recursos em tempo real sem envolver código.

A barra de ferramentas na parte superior da tela é semelhante no sentido de permitir o controle da reprodução do projeto, mas os projetos na Godot são executados em uma janela separada ao invés de serem executados no editor (mas a árvore e os objetos ainda podem ser explorados na janela do depurador).

Esta abordagem possui várias vantagens:

  • Executar o projeto e fechá-lo é rápido (A Unity precisa salvar, executar o projeto, fechar o projeto e, em seguida, recarregar o estado anterior).
  • A edição ao vivo é muito mais útil porque as alterações feitas ao editor entram em vigor imediatamente no jogo e não são perdidas (nem precisam ser sincronizadas) quando o jogo é fechado. Isso permite fluxos de trabalho fantásticos, como criar níveis enquanto você os reproduz.
  • O editor é mais estável porque o jogo é executado em um processo separado.
  • O jogo em execução pode ser explorado de diferentes ângulos ao alternar o botão “Sobrepor Câmera” na viewport do editor, o que vai alternar entre usar a visão do editor e a visão da câmera do jogo.

Finalmente, a barra de ferramentas superior inclui um menu para depuração remota. Essas opções simplificam a implantação em um dispositivo (telefone conectado, tablet ou navegador via HTML5), e a edição de depuração/edição ao vivo após a exportação do jogo.

O sistema de cena

This is the most important difference between Unity and Godot and the favorite feature of most Godot users.

O sistema de cena da Unity consiste em incorporar todos os recursos necessários em uma cena e vinculá-los, definindo componentes e scripts para eles.

O sistema de cena da Godot é parecido superficialmente com a da Unity. Um ‘nível’ consiste de uma coleção de nós, cada um com um propósito: Sprite, Malha, Luz, etc. No entanto, os nós da Godot são organizados em forma de árvore. Cada nó pode ter vários filhos, o que torna cada um sub-cena da cena principal. Isso significa que você pode compor uma cena inteira com cenas diferentes armazenadas em arquivos diferentes.

Por exemplo, pense em um nível de plataforma. Você poderia compor com vários elementos:

  • Tijolos
  • Moedas
  • O jogador
  • Os inimigos

Na Unity, você colocaria todos os GameObjects na cena: o jogador, várias instâncias de inimigos, tijolos em todos os lugares para formar o chão do nível e, em seguida, várias instâncias de moedas em todo o nível. Você adicionaria vários componentes a cada elemento para vinculá-los e adicionar lógica ao nível: por exemplo, você adicionaria um BoxCollider2D a todos os elementos da cena para que eles pudessem colidir. Este princípio é diferente na Godot.

Na Godot, você dividiria toda a sua cena em três cenas separadas e menores, que você instanciaria na cena principal.

  1. Uma cena para o Jogador sozinho.

Considere o jogador como um elemento reutilizável em outros níveis. Em nosso caso, o elemento de jogador precisa pelo menos de um nó AnimatedSprite. Este nó contém as texturas do sprite necessárias para formar várias animações (por exemplo, animação de andar).

  1. Uma cena para o Inimigo.

An enemy is also an element we’d like to use in several scenes. It’s almost the same as the Player node. The only differences are the script (it needs ‘AI’ routines to generate the enemy’s behavior) and the sprite textures used by the AnimatedSprite node.

  1. Uma cena de nível.

A Level scene is composed of Bricks (for platforms), Coins (for the player to collect) and a number of instances of the Enemy scene. Each instance is a node in the Level scene tree. These instances are separate enemies, which initially have shared behavior and appearance as defined in the Enemy scene. You can set different properties for each Enemy node (to change its color, for example).

4. A Main scene. The Main scene would be composed of one root node with 2 children: a Player instance node, and a Level instance node. The root node can be anything, generally a “root” type such as “Node” which is the most global type, or “Node2D” (root type of all 2D-related nodes), “Spatial” (root type of all 3D-related nodes) or “Control” (root type of all GUI-related nodes).

Como você pode ver, toda cena é organizada como uma árvore. O mesmo vale para as propriedades dos nós: você não adiciona um componente de colisão a um nó para torná-lo colidível, como acontece no Unity. Em vez disso, você torna este nó um filho de um novo nó específico que possui propriedades de colisão. Godot possui vários tipos de colisão, dependendo do uso (veja Introdução à física).

  • Quais são as vantagens deste sistema? Esse sistema não aumentaria potencialmente a profundidade da árvore de cena? Além disso, a Unity não te permite organizar GameObjects colocando-os em GameObjects vazios?

    • Em primeiro lugar, este sistema está mais próximo do paradigma bem conhecido da orientação a objetos: Godot fornece um número de nós que não são claramente “Objetos de Jogo”, mas eles fornecem seus filhos com suas próprias capacidades: isto é herança.
    • Godot permite a extração de uma sub-árvore de cena para torná-la uma cena própria. Então mesmo que uma árvore de cena fique muito profunda, ela pode ser dividida em sub-árvores menores. Isso é melhor para a capacidade de reutilização, já que você pode incluir qualquer sub-árvore como filho de qualquer nó. Colocar vários GameObjects em um GameObject vazio na Unity não oferece a mesma possibilidade.

Organização do projeto

../../_images/unity-project-organization-example.png

Não existe arquitetura de projeto perfeita. Qualquer arquitetura pode funcionar para ambas Unity e Godot.

No entanto, frequentemente observamos uma arquitetura comum para projetos Unity, que consiste em ter uma pasta Assets no diretório raiz que contém várias pastas, uma por tipo de recurso: Áudio, Gráficos, Modelos, Materiais, Scripts, Cenas, etc.

Como o sistema de cenas da Godot permite dividir as cenas em cenas menores, cada cena e sub-cena existindo como um arquivo de cena no projeto, recomendamos que você organize seu projeto de maneira um pouco diferente. Esta wiki fornece uma página para isto: Organização do projeto.

Onde estão meus prefabs?

O conceito de prefabs fornecido pela Unity é um elemento “modelo” da cena. É reutilizável, e cada instância do prefab que existe na cena tem uma existência própria, mas todas elas têm as mesmas propriedades definidas pelo prefab.

Godot não fornece prefabs como tal, mas esta funcionalidade está aqui, graças ao seu sistema de cena: O sistema de cena é organizado como uma árvore. Godot permite que você salve uma sub-árvore de uma cena como seu próprio arquivo de cena. Essa nova cena pode ser instanciada quantas vezes você quiser. Qualquer alteração que você fizer nessa cena nova e separada será aplicada a suas instâncias. No entanto, qualquer alteração feita na instância não terá impacto na cena “modelo”.

../../_images/save-branch-as-scene.png

Para ser preciso, você pode modificar os parâmetros da instância no painel Inspetor. Os nós que compõem essa instância são bloqueados inicialmente. Você pode desbloqueá-los, se precisar, clicando com o botão direito do mouse na instância e selecionando “Filhos Editáveis” no menu. Você não precisa fazer isso para adicionar novos nós filhos a esse nó, mas lembre-se de que esses novos filhos pertencerão à instância, não à cena “modelo” salva no disco. Se você quiser adicionar novos filhos a todas as instâncias da sua cena de ‘modelo’, você precisa adicioná-los na cena ‘modelo’.

../../_images/editable-children.png

Correspondência do glossário

  • GameObject -> Nó
  • Adicionar um componente -> Herdar
  • Prefab -> Arquivo de cena reutilizável

Scripting: GDScript, C # e Visual Script

Design

A Unity suporta o C#. O C# se beneficia da integração com o Visual Studio e de outros recursos, como os tipos estáticos.

Godot fornece sua própria linguagem de script, GDScript bem como suporte para Visual Script e C#. O GDScript empresta sua sintaxe do Python, mas não está relacionado a ele. Se você quer saber sobre por que é usada uma linguagem de script customizada, por favor leia Básicos do GDScript e Perguntas Frequentes. GDScript é fortemente ligado à API de Godot e não demora para aprender: Entre uma noite para um programador experiente e uma semana para um iniciante completo.

Unity allows you to attach as many scripts as you want to a GameObject. Each script adds a behavior to the GameObject: For example, you can attach a script so that it reacts to the player’s controls, and another that controls its specific game logic.

Em Godot, você só pode anexar um script por nó. Você pode usar um arquivo GDScript externo ou incluir o script diretamente no nó. Se você precisar anexar mais scripts a um nó, considere duas soluções, dependendo da cena e do que deseja alcançar:

  • adicione um novo nó entre o nó de destino e seu pai atual e adicione um script a esse novo nó.
  • ou, você pode dividir o nó de destino em vários filhos e anexar um script a cada um deles.

Como você pode ver, pode ser fácil transformar uma cena em uma bagunça. Considere dividir uma cena complicada em vários ramos menores.

Conexões: grupos e sinais

Você pode controlar nós acessando-os usando um script e chamando funções embutidas ou definidas pelo usuário neles. Você também pode colocar nós em um grupo e chamar uma função em todos os nós contidos neste grupo. Isto é explicado na documentação sobre scripting.

Nós podem emitir sinais quando certas ações ocorrem. Você pode conectar esses sinais para chamar uma função específica quando eles acontecem. Veja mais na documentação sobre sinais.

Serialização de scripts

O Unity pode manipular a serialização de scripts de duas maneiras:

  • Implícito: Todos os campos públicos em uma classe são automaticamente serializados se o tipo for serializável (Dicionário não é serializável).
  • Explicito: Campos não públicos podem ser serializados usando o atributo ``[SerializeField] ``.

Godot também possui um sistema de serialização de scripts embutido, mas funciona apenas explicitamente. Você pode serializar qualquer tipo serializável (:ref: embutidos e vários tipos da engine <doc_binary_serialization_api>, incluindo :ref: class_Array e Dictionary) usando a palavra-chave export. Veja a :ref: documentação sobre exportações <doc_gdscript_exports> para detalhes.

Unity também tem um tipo de dados chamado `` ScriptableObject`` usado para serializar objetos de recursos personalizados. Seu equivalente em Godot é a classe base para todos os recursos: Resource. Criar um script que herda Resource permitirá que você crie objetos serializáveis personalizados. Mais informações sobre recursos podem ser encontradas aqui.

Usando Godot em C++

Godot permite que você desenvolva seu projeto diretamente em C++ usando sua API, o que não é possível com a Unity no momento. Como exemplo, você pode considerar o editor da Godot Engine como um “jogo” escrito em C ++ usando a API da Godot.

Se você estiver interessado em usar Godot com C++, você pode querer começar a ler a página Desenvolvendo em C++.