None of us on our team made a game before, let alone participated in a game jam, so we were quite nervous participating in Ludum Dare 51. Godot, an open source and free game engine, was the tool that we decided on using and we wouldn't have completed Clique Hell High if we a different engine.

The final gauntlet of our game built in Godot 3.5.1 with custom tooling created during the weekend jam

We were able to animate cut scenes for Clique Hell High right in Godot

Animations were composited right in Godot for the opening and cut scenes, speeding up our workflow

As the jam progressed we started to get the hang of the essential functions of Godot's animation system. Godot lets you animate "everything," meaning any property of any node could be animated such as:

• Visibility of a node
• Position
• Opacity

Keyframes could be dropped in, animation frames of an animated sprint chosen, then the resulting animated scene dropped in the game. It was quick enough to work with to rule out using secondary software for compositing our animations.

It's free (but not that kind of free)

Let's be honest, free is good, and by free, I don't mean monetary free. I mean zero control over how we use the software. With 6 of us sharing the wifi, our internet was a little spotty at times, and if we had to deal with license/registration servers glitching out right in the middle of our jam, we'd have failed entirely. Godot has no licensing servers so you don't have to worry about a poor internet connection preventing your use of the tool. Oh and it doesn't cost money.

Killer App: Scenes Inside Scenes

The final room as a scene, which ended up being instanced in the main level as a node itself

Git version control let multiple team members work on the project at the same time and Godot takes advantage of this with scenes being useable as regular nodes. One team member could be declared as the current owner of a scene (such as the ending area of our game) and hands off for other team members. Then another team member could drop an instance of said scene in the master level scene, and both team members could thus contribute to the level without merge conflicts. Game engines which don't let the designers instance scenes inside scenes reduce the ability to team up and work simultaneously on problems, because merge conflicts can arise when working on the same scene. This let us work faster, as a result.

GDScript is easy to learn

GDScript has been easy to pick up and sophisticated enough to solve problems

It's python-like meaning that the syntax is quick to pick up on if one's used python, and quick to pick up on if one hasn't. No curly braces to miss which means newer devs on the team don't have to troubleshoot syntax errors due to missing closing braces. The textual not and keywords are easy to read. Not only is it syntactic sugar, but the editor itself is quite powerful, adequate for small projects without having to reach for other tools. No need to install 3gb of dot.net SDKs, no worry about C++ linkers misbehaving on different systems. Download it and program right away.

It has an HTML5 export

There are just too many games to go through during the jam to download and install games and being able to export to HTML5 was key to letting people play our game with ease. We didn't run into any major problems that wouldn't have happened in Unity any ways. Loading of content was done in loading scenes before playing said content, to ensure that stuttering didn't occur during gameplay or cut scenes. We used the GDNative mode for the HTML5 exporter and the game played well enough in browsers to not hear any complaints from players so far.

We built tools for our designers with tool

In a gdscript file, if the keyword tool is placed at the top, then it exposes whether the node is rendered in the editor or in the game with a simple if Engine.editor_hint: conditional. This was used for a few key game components which allowed our level designers to tweak the level components and see the results right in the enditor.

The most useful one was the editor hint to determine if a cat or dog should be rendered right in the game engine editor, letting our designers see visually which enemies were toggled as dogs and which as cats.

``` func process(delta): if not Engine.editorhint: _handlefacing()

if Engine.editor_hint:
    _set_visual()
    var should_show_aim_line:bool = not aim_at_player
    if not show_aim_line and should_show_aim_line:
        show_aim_line = true
        $LineFireDirection.show()
    if not should_show_aim_line and show_aim_line:
        show_aim_line = false
        $LineFireDirection.hide()
    if show_aim_line:
        calc_line_dir()

``` Checking whether it's the editor that's rendering and if so, rendering visual aids for the level designers

The custom script variables accessible for the enemies were picked up on by the editor, and visuals were rendered accordingly.

Some of the enemies aim directly at the player, while others fire in a fixed direction. This was done with an aim_at_player variable, which was then picked up on in the editor to render a visual guide.

Then with a simple function, if aim_at_player is false, it determines the direction based off the angle configured.

func _get_line_fire_dir()->Vector2: var r := deg2rad(aim_direction) var p := (Vector2(cos(r), sin(r)).normalized() * aim_guide_length) as Vector2 return p

The command line interface is build pipeline friendly

We set up an automated build pipeline using github actions (which you can read about in my previous article, We released Clique Hell High 112 times and this is how we did it.... Godot has a sophisticated command line interface that lets you do most everything related to exporting directly from the command line without special tooling. The selection of ready-to-use github actions was large enough for us to find one that worked well within an hour.

Summary

Overall, Godot exceeded our expectations. Most folks on the team who used godot over the jam had never used it before, but were able to contribute to the game effectively. It's easy enough to learn "on the job" and Godot never really got in our way as we worked on the game. For anybody who hasn't tried it out, give it a whirl, because it was more than adequate for us and key to being able to deliver Clique Hell High and all of the content in it within the 72 hour time constraint.