Una mirada más cercana al motor de juego Godot

Juego desde cero tiene una larga serie echando un vistazo en profundidad a varios motores de juegos disponibles. Hoy vamos a ver el Motor de juego Godot, un motor de juego basado en C++ de código abierto con un editor mundial completo al estilo de Unity. Godot se ejecuta en plataformas Windows, Linux y Mac y puede apuntar a todas ellas, además de iOS, Android, PS3 y PS Vita, NaCL con HTML5 y Windows Phone, ambos en desarrollo.

En las propias palabras de Godot:

Godot es un motor de juego 2D y 3D avanzado, repleto de funciones y multiplataforma. Proporciona un gran conjunto de herramientas comunes, por lo que puede concentrarse en crear su juego sin reinventar la rueda.

Esa descripción también es increíblemente acertada, seguramente te sorprenderá la cantidad de herramientas que se incluyen. ¡Ahora entremos de inmediato!

Hay un video en esta publicación disponible aquí (e incrustado en la parte inferior de la página) que entra en un poco más de detalle.

El editor

Comienzas con Godot descargando el ejecutable desde la página de descargas. Probablemente espera que esto sea un instalador, pero estaría equivocado. En cambio, cuando lo ejecuta, obtiene el Administrador de proyectos:

Aquí puede crear un nuevo proyecto o cargar uno existente. Finalmente, una vez que haya seleccionado o creado, accederá al editor:

Aquí es donde ocurre la magia. La captura de pantalla anterior es de la demostración de Platformer que se está editando. La ventana de la izquierda es donde se compone su escena. Como puede ver en las cuatro pestañas anteriores, puede trabajar en 2D, 3D, edición de secuencias de comandos o navegar por la ayuda integrada en esta ventana. Los íconos de arriba a la izquierda son en realidad menús y muchas de las funciones y herramientas están escondidas detrás de Escena e Importación.

El cuadro de diálogo superior derecho es su gráfico de escena:

Aquí puede ver (y crear/ejecutar) los elementos que componen su mundo. Simplemente haga clic en el ícono Nuevo para agregar nuevos elementos al mundo, o en el ícono + para agregar una nueva instancia en su lugar. Los otros íconos son para conectar guiones y señales (eventos) a los objetos en su mundo.

Debajo del gráfico de escena, tienes la ventana Inspector, que te permite establecer las propiedades de los objetos en tu escena. Como puede ver en la captura de pantalla, Godot adopta un enfoque muy modular/componente que es bastante popular en estos días:

Esto le permite inspeccionar visualmente y editar las propiedades de los objetos de su juego. También representa uno de los primeros defectos de Godot… algunos de los controles son difíciles de usar. Por ejemplo, si no presiona Intro después de editar una propiedad de texto, los valores se pierden. Además, la modificación de campos numéricos puede ser un fastidio a veces. Son todas las cosas que se pueden arreglar con el tiempo (después de todo, Godot solo fue de código abierto hace aproximadamente un año), pero por ahora es torpe y algo molesto.

Codificación

Así que ese es el editor visual… ¿qué pasa con el código?

Bueno, la mayor parte de su programación se realizará en GDScript, utilizando el editor incluido. GDScript es un lenguaje de secuencias de comandos propietario de Python-esque. En general, no me gusta este enfoque, ya que hace que todas las herramientas y editores existentes sean inútiles, pierde los años de corrección de errores, mejoras de rendimiento, etc. mientras fuerza una curva de aprendizaje para todos los que quieren usar el motor. Dicho esto, la idea detrás de un lenguaje de secuencias de comandos es que deben ser fáciles de usar y aprender.

Los autores explicaron su decisión en las preguntas frecuentes:

La respuesta corta es que preferimos que un programador haga el pequeño esfuerzo de aprender GDScript para que luego tenga una experiencia fluida, que atraerlo con un lenguaje de programación familiar que resulte en una peor experiencia. Estamos de acuerdo si prefieres no darle una oportunidad a Godot debido a esto, pero te recomendamos encarecidamente que lo pruebes y veas los beneficios por ti mismo.

Los idiomas oficiales de Godot son GDScript y C++.

GDScript está diseñado para integrarse desde cero a la forma en que funciona Godot, más que cualquier otro lenguaje, y es muy simple y fácil de aprender. Se tarda uno o dos días en sentirse cómodo y es muy fácil ver los beneficios una vez que lo hace. Por favor, haga el esfuerzo de aprender GDScript, no se arrepentirá.

La API de Godot C++ también es eficiente y fácil de usar (todo el editor de Godot está hecho con esta API), y una excelente herramienta para optimizar partes de un proyecto, pero tratar de usarla en lugar de GDScript para un juego completo es, en la mayoría de los casos. , una pérdida de tiempo.

Sí, durante más de una década intentamos en el pasado integrar varias máquinas virtuales (e incluso enviamos juegos usándolas), como Python, Squirrel y Lua (de hecho, creamos tolua++ en el pasado, uno de los enlazadores de C++ más populares). Ninguno de ellos funcionó tan bien como lo hace GDScript ahora.

Se puede encontrar más información sobre cómo familiarizarse con GDScript o lenguajes escritos dinámicamente aquí.

Eso cubre el por qué de todos modos, ahora veamos el lenguaje en sí. Como dije antes, es un lenguaje de secuencias de comandos similar a Python (basado en espacios en blanco). Veamos un ejemplo de las demostraciones incluidas:

extends RigidBody2D


const STATE_WALKING = 0
const STATE_DYING = 1

var state = STATE_WALKING
var direction = -1
var anim=""
var rc_left=null
var rc_right=null
var WALK_SPEED = 50

var bullet_class = preload("res://bullet.gd")

func _die():
   queue_free()

func _pre_explode():
   #stay there
   clear_shapes()
   set_mode(MODE_STATIC)
   get_node("sound").play("explode")
   

func _integrate_forces(s):

   var lv = s.get_linear_velocity()
   var new_anim=anim

   if (state==STATE_DYING):
      new_anim="explode"
   elif (state==STATE_WALKING):
      
      new_anim="walk"
      
      var wall_side=0.0
      
      for i in range(s.get_contact_count()):
         var cc = s.get_contact_collider_object(i)
         var dp = s.get_contact_local_normal(i)
         
         if (cc):
         
            
            if (cc extends bullet_class and not cc.disabled):
               set_mode(MODE_RIGID)
               state=STATE_DYING
               s.set_angular_velocity(sign(dp.x)*33.0)
               set_friction(true)
               cc.disable()
               get_node("sound").play("hit")
               
               break
            

         if (dp.x>0.9):
            wall_side=1.0
         elif (dp.x<-0.9):
            wall_side=-1.0
            
      if (wall_side!=0 and wall_side!=direction):
      
         direction=-direction
         get_node("sprite").set_scale( Vector2(-direction,1) )       
      if (direction<0 and not rc_left.is_colliding() and rc_right.is_colliding()):
         direction=-direction
         get_node("sprite").set_scale( Vector2(-direction,1) )
      elif (direction>0 and not rc_right.is_colliding() and rc_left.is_colliding()):
         direction=-direction
         get_node("sprite").set_scale( Vector2(-direction,1) )
         
         
      lv.x = direction * WALK_SPEED
         
   if( anim!=new_anim ):
      anim=new_anim
      get_node("anim").play(anim)
            
   s.set_linear_velocity(lv)


func _ready():
   rc_left=get_node("raycast_left")
   rc_right=get_node("raycast_right")

Como alguien criado con llaves y punto y coma, puede tomar un poco de tiempo romper la memoria muscular, pero en su mayor parte el lenguaje es bastante intuitivo y fácil de usar. Puedes ver una cartilla de lenguaje rápido aquí.

Recuerde que antes dije que el editor de código estaba integrado en el motor, echemos un vistazo ahora:

Como puede ver, el editor proporciona la mayoría de las características comunes que esperaría de un IDE, siendo una de sus favoritas la finalización automática. Las características como la intención del código, buscar y reemplazar y la sangría automática están disponibles, cosas que a menudo faltan en los editores integrados. Como lidiar con la ventana del Inspector, aunque puede haber algunas molestias, como la ventana de autocompletar que aparece cuando intenta pasar el cursor por su código, lo que requiere que presione Escape para descartarlo. En su mayor parte, aunque la experiencia de edición es sólida y, con suerte, algunas de las verrugas desaparecerán con el tiempo.

Ahora quizás el mayor negocio de todos:

¡Depuración! Aquí es donde tantos lenguajes de secuencias de comandos caseros realmente apestan, la falta de depuración. No Godot:

Puede establecer puntos de interrupción, entrar o pasar por encima de su código en ejecución y, lo que es más importante, inspeccionar valores de variables y marcos de pila. Una vez más, es la experiencia de depuración lo que a menudo hace que trabajar en lenguajes de secuencias de comandos sea una molestia, ¡así que es bueno ver esto!

Oye, ¿qué hay de C++?

Por supuesto, uno de los grandes atractivos de Godot será el soporte de C++, entonces, ¿dónde entra eso exactamente? Bueno, primero y lo más obvio, Godot está escrito en C++ y es totalmente de código abierto bajo la licencia MIT (una licencia muy, muy liberal), por lo que, por supuesto, puedes hacer lo que quieras. halé la fuente de Github y compilado sin problemas en Visual Studio 2013 en solo unos minutos. Sin embargo, el proceso de compilación se basa en Scons, lo que significa que debe tener Python 2.7x y Scons instalados y configurados, pero ninguno de los dos es gran cosa.

¿Qué pasa con la extensión de Godot? Eso es lo que la mayoría de la gente querrá hacer. Bueno, afortunadamente, es bastante fácil crear extensiones de C ++, aunque nuevamente necesita Scons y tiene que hacer un poco de configuración, pero una vez que lo haya hecho una vez, suponiendo que tiene un entorno de desarrollo configurado correctamente, el proceso debería ser rápido y en su mayoría indoloro. . De la página wiki Aquí hay un módulo C++ de muestra:

sumador.h

/* sumator.h */
#ifndef SUMATOR_H
#define SUMATOR_H

#include "reference.h"

class Sumator : public Reference {
    OBJ_TYPE(Sumator,Reference);

    int count;

protected:
    static void _bind_methods();
public:

    void add(int value);
    void reset();
    int get_total() const;

    Sumator();
};

#endif

sumador.cpp

/* sumator.cpp */
#include "sumator.h"
void Sumator::add(int value) {
    count+=value;
}

void Sumator::reset() {
    count=0;
}
int Sumator::get_total() const {
    return count;
}
void Sumator::_bind_methods() const {
    ObjectTypeDB::bind_method("add",&Sumator::add);
    ObjectTypeDB::bind_method("reset",&Sumator::reset);
    ObjectTypeDB::bind_method("get_total",&Sumator::get_total);
}
Sumator::Sumator() {
    count=0;
}

Luego, en tu script puedes usarlo como:

var s = Sumator.new()
s.add(10)
s.add(20)
s.add(30)
print( s.get_total() )
s.reset()

Si hereda de Node2D o una clase derivada, estará disponible en el editor. Puede exponer las propiedades al inspector y tratar su módulo como cualquier otro nodo disponible. Sin embargo, recuerde que, en aras de la productividad, solo debería pasar a C++ como último recurso. Sin embargo, es bastante simple de hacer.

Nodos, Nodos y más Nodos

En el corazón de Godot, el mundo es esencialmente un árbol de Nodos, así que supongo que vale la pena ver algunos de los nodos disponibles y cómo funcionan. Desde la ventana del gráfico de escena, agrega un nuevo nodo al mundo usando este icono:

A continuación, es cuestión de elegir qué tipo, que por supuesto podría incluir módulos que usted mismo creó en C++.

Como puede ver en la pequeña porción que he mostrado arriba, ya hay MUCHOS nodos integrados disponibles. Desde controles de interfaz de usuario hasta controladores de física, búsqueda de rutas y herramientas de inteligencia artificial, contenedores delimitadores, reproductores de video y más. Esencialmente, creas tu juego componiendo escenas, que luego se componen de nodos. Una vez que haya creado un nodo, puede escribirlo. Simplemente seleccione su nodo en el gráfico de escena y luego haga clic en el ícono de secuencia de comandos:

Luego se mostrará un diálogo de Nuevo Script:

Y se creará su script:

Como puede ver, el script en sí se hereda del tipo de nodo que seleccionó. Ahora puede crear secuencias de comandos para cualquier y toda la lógica adjunta a este nodo en particular. Esencialmente, su lógica de juego se implementa aquí.

Además de conectar secuencias de comandos a los nodos del juego, también puede conectar Signals.

Las señales se pueden considerar como eventos entrantes:

¡AYUDA!

Entonces, ¿qué pasa con la Ayuda entonces? Bueno, esto es tanto una fortaleza como una debilidad de Godot. Como vio anteriormente, en realidad hay una pestaña de ayuda integrada. Puede buscarlo en cualquier momento, o presione SHIFT + F1 mientras codifica para obtener ayuda sensible al contexto:

Es invaluable, pero desafortunadamente el archivo de ayuda resultante a menudo es solo una lista de métodos/parámetros y nada más. A menudo, en cambio, solo mantengo el referencia de clase de la Wiki abrir en una ventana del navegador. Para un proyecto de código abierto, la referencia es bastante buena, pero aún podría necesitar mucho más amor.

A continuación están los tutoriales, hay una selección bastante buena. disponible en Wiki pero creo que realmente se necesita una buena serie para principiantes en profundidad. Para alguien que acaba de descargar Godot y está pensando «ahora qué»… eso presenta un desafío. Dicho esto, probablemente crearé uno, ¡así que esto no debería ser un problema a tiempo!

Finalmente, y quizás lo más valioso, se incluyen varias demostraciones:

Publicación

Entonces, una vez que hayas terminado tu juego, ¿cómo lo publicas en las distintas plataformas disponibles? Bueno, para empezar, haga clic en el botón Exportar:

También necesita una plantilla de exportación, que está disponible en el sitio de descargas de Godot. Además, debe configurar la cadena de herramientas para cada plataforma, como el SDK de Android para Android, XCode para iOS (¡y una Mac! Desafortunadamente, no puede evitar la necesidad de una Mac para el requisito de desarrollo de iOS), etc. Pero el El proceso se detalla para usted y lo hacen bastante fácil.

Resumen

Ni siquiera he mencionado la plétora de herramientas escondidas en el editor… necesito importar una fuente, hay una herramienta para eso. Hay un complemento mejorado de Blender COLLADA que funcionó cuando lo probé. Hay una herramienta para asignar controles a comandos, hay herramientas para comprimir y modificar texturas al importar, para modificar animaciones 3D entrantes, etc. Básicamente, si necesita hacerlo, probablemente haya una herramienta en alguna parte.

Por otro lado, el proceso en sí puede ser bastante desalentador. Averiguar cómo obtener información, el ciclo de vida de un script, etc., no es inmediatamente obvio. Realmente es un motor con el que tienes que sentarte y simplemente jugar. A veces chocará contra una pared y puede ser bastante frustrante. Sin embargo, también es muy divertido y una vez que comienza a hacer clic, es un gran motor para trabajar.

Definitivamente te recomiendo que consultes a Godot, especialmente si estás buscando una experiencia similar a Unity de código abierto. Dicho esto, llamar a esto un clon de Unity sin duda no le haría ningún favor, Godot es un pequeño gran motor de juego por sí solo que merece mucha más exposición.