This is my talk at iGBL2023, the International Conference on Game Based Learning. It’s a bit all over the place, so I decided to sumarise my experience into a paper that has been submitted to GALA2023, the Games and Learning Alliance Conference which will be hosted in TU Dublin in November 2023. Below is an edited version of the submission:

Game Engines 2 is a module offered to 4th year Computer Science and 3rd year Game Design students at TU Dublin, spanning one semester. The module consists of two hours of classroom teaching and two hours of lab time per week.  Around 40 students take the module each year, split roughly between Computer Science and Game Design students. The course is delivered in-person, streamed on Microsoft Teams, and recorded. The VLE used is GitHub with recordings of the classes and code examples posted to a GitHub repository each week (1).

The module focuses on game AI, approached from a computer science standpoint, and encompasses various subjects like Steering Behaviors (2), Finite State Machines (FSM) (3), and path finding (4). Studying Steering Behaviors (see section 1.4) provides computer science students with the opportunity to develop their problem-solving skills and computational thinking abilities. The design and implementation of Steering Behaviors require the application of concepts such as vector mathematics, spatial reasoning, collision detection and computational complexity. Students are tasked with devising efficient algorithms to calculate steering forces, manage interactions between agents, and optimize performance. Additionally, students get to program interesting simulations inspired by nature or movies and are encouraged to be creative in their assignments. Themes from previous assignments include sci-fi space battle recreations from classic movies and TV (5) and emergent nature simulations (6) inspired by John Conway’s Game of Life (7), cellular biology, evolution and the origins of life.

Since its introduction in 2006, I have been teaching this module every year, accumulating a total of 17 years of teaching experience. Game Engines 2 follows on from Game Engines 1, a module that covers mathematics, physics and coding for game developers and explores how a game engine works with a similar creative and hands-on approach.

The modules have gone through different iterations as technology has evolved beginning with DirectX C++ (8) following with XNA (9), BGE (10), Unity and in the last semester Godot. BGE (Bryan’s Game Engine) is of note, being a custom game engine, I developed for the course in C++. The engine is a code-only, scene-graph based 3D engine with physics, sound and support from VR headsets. The engine’s code is available on GitHub (10) and formed the foundation for many interesting student projects with 50 forks and contributions from students, meaning that that it has been compiled for Mac, Linux, Windows and has bindings for Python.

Since 2016 the course has used Unity exclusively, due to its popularity, demand from students and industry. Additionally, I worked on two side projects in Unity that developed my knowledge and capability with the engine. These being DEEP and Infinite Forms.

DEEP: A meditative virtual reality experience

DEEP is a meditative virtual reality experience, set in a fantasy underwater environment. Movement in the game is controlled by deep breathing. The players breathing is tracked either using a VR controller, or a custom breathing sensor attached to the player (11,12). I programmed emergent and reactive AI for the underwater creatures in DEEP, including a whale, schools of fish and formations of manta rays (Figure 1). DEEP is installed as a permanent exhibition in the Nemo Childrens Museum in Amsterdam and was one of twelve projects selected for exhibition at the Tribeca Film Festival in 2016.

Figure 1: Creatures from DEEP: A Medititive Virtual Reality Experience. Source: (13)

Infinite Forms: An Infinite Generative World with Psychedelic Themes

Infinite Forms is an art project inspired by nature, digital life, emergence and psychedelic themes such as the nature of reality, consciousness, language and thought (14). It consists of a procedural 3D world inhabited by procedural flora and fauna, many of which can be inhabited or interacted with by the player. The process of creating Infinite Forms was compared with a psychedelic experience where nature inspired ideas, ideas became algorithms and algorithms took form in virtual reality (15,16).

Infinite Forms references the work of Terrance McKenna, ethnobotanist, philosopher, author, and speaker, known for his writings and talks on psychedelics, shamanism, and altered states of consciousness, who wrote about his experiences with early virtual reality systems in the book the Archaic Revival (14). McKenna writes:

“In the not-too-distant future men and women may shed the monkey body to become virtual octopi swimming in a silicon sea… Like the octopus, our destiny is to become what we think, to have our thoughts become our bodies and our bodies become our thoughts. This is the essence of a more perfect Logos, a Logos not heard but beheld.” (14)

And so, in Infinite Forms, the player can embody a psychedelic octopus and have their arms become the octopus tentacles (see Figure 2). Infinite Forms pushes Unity game engine to the limit and features simulations of 23K autonomous agents implementing various Steering Behaviors, at 90 FPS using the ECS (Entity Component System), which I started working with in 2017, before it was finally made an official part of Unity in 2023 (17). Infinite Forms has been exhibited at Ozora in 2017 and 2019, the Cologne International Film Festival, Clash of Realities (Cologne) and Re:publica where I gave talks about similarities between virtual reality and psychedelic experiences (18). The project has over 72 branches and 673 commits at the time of writing (19).

Figure 2: Screenshots from Infinite Forms, demonstrating some of the creatures and environments. Source: Author

Steering Behaviors for Autonomous Agents

The creatures in both DEEP and Infinite Forms are simulated using Steering Behaviors for Autonomous Agents (20) . These are a way of controlling the locomotion of autonomous agents in games, movies and robotics and are based on the application of forces. Steering Behaviors can be used for path following, obstacle avoidance, pursuit, and evasion, wandering, and flocking among other uses. Steering Behaviors can be combined in various ways to create complex and emergent artificial life simulations. For example, Boids simulate the flocking behavior of birds using a set of simple rules: separation, alignment, and cohesion (21). Boids can be seen as a specific example of steering behaviors.

Steering Behaviors are considered an essential element of Game AI and there are talks and each year discussing steering behaviors at the Game Developers Conference.

Motivation for Switching from Unity

Despite a significant amount of time spent developing the course and my own projects using Unity, I decided this year to port all the examples to Godot and share the experience of doing so with my students. The motivations for switching from Unity are listed in Table 1.

Table 1. Unity pain points with Godot solutions. Source: Author

Unity Pain Point	Godot Solution
Poor Performance and Responsiveness	Fast and responsive IDE. Live code editing
Long Build Time for Oculus Quest	Build time reduced from 7 minutes to 20 seconds
Compatibility Problems and Errors	Projects are compatible between major releases. New releases can be installed in seconds
Unreliable Functionality of Debugger	Code editing and debugging are built in to the Godot editor
Complexity and Hassle of Licensing	MIT license. No need to register
Complexity and Verbosity of C#	Simplicity of GDScript
Constantly Changing APIs (ECS)	Multi-threading and ECS are experimental in Godot
Multi-gigabyte download and install size	100Mb download and install. Godot runs on an Android phone

The increasingly poor performance and responsiveness of Unity. Unity often takes a long time to launch or to recompile after editing code. This disrupts the flow of live coding demonstrations and wastes valuable class time. It also makes creative coding frustrating as it is difficult to enter a “flow state” with constant reloading and pauses in workflow. Figure 3 shows a small sample of Unity “busy for” messages. This made the process of grading student work on the course a particularly frustrating experience.

Figure 3: Unity “busy for” messages. These cause a break in “flow state” creative work. Source: Author

Long build times for deploying games to the Oculus Quest 2 VR headset. Builds from Unity to the Quest 2 headset, take about 7 minutes for a simple game project. This reduces the opportunities for testing and iterating of VR games in the classroom and for creative purposes. By comparison, a full build to the Oculus Quest 2 of a similar sized project from Godot takes around 20 seconds.

Compatibility problems and errors in existing projects caused by minor version updates of Unity. This added more overhead and hassle to maintaining the course materials and ensuring that they worked properly on different hardware and operating systems.

Unreliable functionality of Unity’s debugger, which often failed to work in labs. Similarly, code completion would often fail to work for entire semesters in VS Code because of issues with Unity.

Complexity and hassle of licensing Unity for educational purposes, since it is a commercial engine with different tiers of licenses (personal, student, professional). This required running batch files and having students create Unity accounts to activate Unity on each lab computer every time we used it, resulting in a delays at the start of every lab session.

Complexity and verbosity of C#, which is the main scripting language for Unity. C# requires more knowledge of object-oriented programming concepts and data structures, which can be challenging and intimidating for beginners and non-programmers. It also requires significant boiler plate code to make even simple examples work. By comparison Godot uses a more concise language called GDScript which has a syntax similar to Python.

Constantly changing API’s, particularly in relation to ECS necessitating frequent rewrites of examples.

Introduction to Godot game engine

Godot is an open-source game engine hosted on GitHub which has over 1000 contributors (22). The project was initiated by Juan Linietsky and Ariel Manzur. The project is named after the Samuel Beckett play “Waiting for Godot” (23) and the projects tagline is: “The Game Engine you have been Waiting For”. Godot can be used to create both 2D and 3D games for desktop computers, mobile devices, web browsers, game consoles and virtual reality.

It is licensed under the MIT license, which is a permissive and flexible software license that grants users the right to use, copy, modify and distribute the software and its source code. The design philosophy of the engine is based on the concept of nodes and scenes, which are reusable components that can be arranged in a hierarchical structure (24). Nodes can have various functions, such as rendering graphics, playing sounds, detecting collisions, or scripting behaviors. Scenes are collections of nodes that form a logical unit, such as a level, a character, or a menu. Scenes can also be nested and instantiated, allowing for modularity and reusability. Godot engine is written in C++, but it provides its own scripting language called GDScript, which is interpreted, like Python. The Godot editor supports scripting in GDScript or C# without leaving the IDE, with code completion and debugging built-in to the editor.

The engine is around 100Mb to download compared to several gigabytes for Unity and other commercial game engines. Godot can run on lightweight devices such as smartphones, as the engine and IDE is a Godot project made in Godot. Similarly, iteration times in Godot are extremely fast and code can be edited live as the game is running. As soon as code is saved, it is in the running game. This feature alone elevates Godot above Unity as a development tool for creators and in education where attention, flow and creativity are crucial to the creative and learning experience.

Porting the Course from Unity to Godot

To port the course to Godot, a new project and repository was created and, week by week, examples were ported from Unity C# to Godot GDScript (6). The semester lasts 13 weeks, and each week, new Steering Behaviors or concepts were explored with live coding examples. Classes were held in-person and streamed live on Teams, recorded, and made available on the course git repo (6). At the conclusion of the semester, a complete Godot project was available. The project consists of example scenes that demonstrate Godot programming idioms or Game AI concepts from the course. Some notable features of the project are:

TankGame – This scene demonstrates several Godot coding idioms such as nodes, timers, physics, lerping, materials, cameras, lighting, collisions, and input. It consists of a player-controlled tank and a procedurally generated wall that the player can shoot. This familiarizes students with Godot workflows and coding. Figure 4 shows TankGame running, with the Godot editor, node graph and code visible in the background.

Figure 4: TankGame – A demonstration of Godot idioms. Source: Author

Seek, Arrive, Wander, Harmonic, PathFollowing – These scenes demonstrate the various steering behaviors applied to a procedural creature and a spaceship in several, separate scenes. In each scene, the player can switch between FPS, Boid-following or Boid-camera mode to change the camera tracking. Steering Behaviors draw gizmos, in the form of vector lines, arrows, and cubes to illustrate how they function.  Each behavior is implemented as a separate Node that can have a weight and priority. Figure 5 depicts the Path Following steering behavior implemented on a procedural creature and on a spaceship. There is a third Boid implementing OffsetPursue on an invisible Node to which the camera can be attached to follow the creature. In this mode, the Camera’s quaternion will be smoothly interpolated to look at the creature so that a smooth tracking camera shot is achieved.

Figure 5: Path following steering behavior. Source: Author

Hybrid – This scene demonstrates a hybrid creature composed of PathFollowing, Wander, PlayerSteering and Harmonic steering behaviors with weights and priorities that can be adjusted to achieve an anthropomorphic, emergent creature. This also demonstrates the Weighted Truncated Running Sum with Prioritisation algorithm for combining steering forces with weights and priorities. The SpineAnimation system from Infinite Forms was also ported over to Godot so that spines, wings, and tails can be animated procedurally.

Figure 6: A hybrid creature implementing multiple behaviors to achieve emergence. Source: Author

StateMachines – This scene consists of one spaceship that defends a base, and another spaceship that attacks the base. The spaceships are Boid’s, that implement Seek and Arrive steering behaviors. They can also attack each other by firing missiles. Each spaceship has a Finite State Machine (FSM) that determines which steering behaviors are active. The FSM code is modelled on Matt Buckland’s examples from the book “Programming Game AI By Example” (3). These in turn, are modelled on the State Machine Design Pattern outlined in the seminal “Design patterns : elements of reusable object-oriented software”

Code is written so that a Boid script can be attached to a CharacterBody3D node (Godot’s equivalent to a Kinematic Rigidbody from Unity), and Steering Behavior nodes can be attached to the Boid node with relevant weights and priorities.

Figure 7: Predator/prey simulation using Steering Behaviors and Finite State Machines. Source: Author

Boids – There are several scenes that demonstrate schools of 200 boids interacting using Separation, Cohesion, Alignment, Wander, ObstacleAvoidance and Constrain behaviors. These scenes implement cell space partitioning in GDSCript, using appropriate algorithms and data structures. They demonstrate the performance improvement that accrues from reducing the complexity of the neighbor counting from O(n²) to O(n) using cell space partitioning (3). This algorithm can be enabled or disabled to observe how it affects the performance of the simulation. Enabling the algorithm typically results in a doubling of the FPS, or number of Boids that can be simulated. This can be further increased using multi-threading and in previous experiments using ECS in Unity I was able to achieve 23K Boids at 90 FPS (17).  It is also an example of “emergence” as the Boids spontaneously form “flocks”, that can be quite hypnotic to observe. Figure 8 shows a Boid at the center, with the adjacent cells containing neighbor Boids highlighted in blue. Counted neighbors are rendered with a yellow box around them so that users may better understand how the algorithm counts neighbors.

Figure 8: Boids implemented using cell space partitioning to improve performance. Source: Author

OffsetPursue – In this scene the leader Boid implements Wander and NoiseWander behaviors to direct the Boid to explore the scene. NoiseWander is an adaptation from Reynold’s original wandering behavior implemented using Perlin Noise (20). The followers implement OffsetPursue and will try to maintain formation with the leader, while simultaneously avoiding obstacles as indicated by the yellow lines projected from the front of the Boids.

Figure 9: Offset Pursue Steering Behavior is used to simulate a formation of spaceships. Source: Author

TakeControl – The creation of scene presented in Figure 10 was given as an exercise to students in a 3-hour, open-book, lab test. In this scene the creature has a “control orb” on its back. The player can initially move using FPS (First Person Shooter) controls. However, if they enter the orb, they take control of the creature and player input will generate forces that are applied to the creature. This interaction is implemented in Infinite Forms in VR to simulate the experience of riding on the back of a flying dragon. For the full test that was given to students see (25).

Figure 10: Take control of a creature by entering the “control orb” on its back. Gizmos from the Harmonic and ObstacleAvoidance Steering Behaviors active on the Boid are visible.

Each steering behavior is implemented as a separate GDScript node, so that nodes can be combined to create game element from a composite of nodes (Figure 11).

Figure 11: Node hierarchy of the Attacker from Figure 7 showing how nodes can be combined to create a composite element in a game. Source: Author

The repo has 14 branches and 256 commits. It has 18 forks from students who forked the repo for their assignment (6).

Outcomes

In response to feedback from the Game Design students, who had had been developing games in Unity for several years, I decided to show examples from both game engines side-by-side throughout the semester and make the previous course examples in Unity and recordings of classes available for those students who preferred to stick with Unity. Additionally, students could choose Unity or Godot for their lab test, assignment, or exam.

Deliverables are summarized below:

• The repository for the course consists of examples that demonstrate how to program many forms of emergent game AI in Godot. These can form the basis for games and simulations and are available on GitHub under MIT license. (6)
• 20+ hours of class recordings (6)
• 13 weeks of lab tasks written in markdown format on GitHub with accompanying videos on YouTube (6)
• Student assignment (5)
• Rubric and marking scheme (5)
• YouTube playlist of assignment submissions (26)
• Lab test (25)
• Unity to Godot porting, quick reference guide(27)

From the Godot cohort, some interesting assignments include a procedural city and traffic simulation and a simulation of polar bears finding fish (Figure 12).

Figure 12: Student assignments (5). Source: Author

I also introduced Godot to my second-year programming students, who used it to make games for Games Fleadh, the national games and console programming competition hosted by LIT Thurles each year (28). There were two TU Dublin games made with Godot on the theme of Endless Runner. A VR game for Oculus Quest 2 developed by a team of students entitled BitBoy (29)

And a procedural platformer called ADashAwayFromDeath developed by a lone student, Matthew Bradon.

Figure 13 shows TU Dublin students at the competition in 2023, with competition judge John Romero, the programmer behind DOOM. 

Figure 13: TU Dublin students meet legendary game designer John Romero, with games made in Godot, Unity and Unreal. Source: Author

Conclusions

The paper outlines the Game Engines 2 module offered to 4th year Computer Science and 3rd year Game Design students at TU Dublin and its transition from Unity to Godot. This was done due to various advantages offered by Godot over Unity, including its fast and responsive IDE, reduced build times, compatibility, and the simplicity and elegance of GDScript for teaching and creative coding.

To port the course to Godot, examples were systematically converted from Unity C# to Godot GDScript, with each week exploring new steering behaviours or concepts through live coding examples. Notable features of the Godot project included demonstrations of various steering behaviors, state machines, and boids simulations with improved performance through cell space partitioning.

The outcomes of the course include a repository of examples showcasing emergent game AI in Godot, along with recordings, lab tasks, assignments, and marking schemes. Notably, Godot was also introduced to second-year programming students who utilized it to create games for the national games and console programming competition.

In conclusion, the transition to Godot provided a positive experience over Unity, despite the significant work involved in learning a new game engine and language. I encourage its use for academics and students studying game development due to its fast workflow which encourages flow state creativity for lecturers, researchers and students. Further, as an open-source engine developed by the community of creators who use it, we can engage students in the sustainability of an open-source competitor to the commercial game engines.

References

1. Duggan B. Game Engines 2 2023 [Internet]. 2023 [cited 2023 Jul 23]. Available from: https://github.com/skooter500/GE2-2023

2. Steering Behaviors For Autonomous Characters [Internet]. [cited 2023 Jul 23]. Available from: http://www.red3d.com/cwr/steer/

3.        Buckland M. Programming Game AI by Example. 1st edition. Plano, Texas: Jones & Bartlett Learning; 2004. 495 p.

4.        Duggan B, Mtenzi F. An Optimised Implementation of the A Algorithm using the STL. Sch Comput Dublin Inst Technol. 2006;

5.        Duggan B. Assignment Title: ‘The Game of Life: Exploring the Emergence of Complexity’ [Internet]. [cited 2023 Jul 24]. Available from: https://github.com/skooter500/GE2-2021-2022/blob/master/ca.md

6.        Duggan B. Game Engines 2 2023 [Internet]. 2023 [cited 2023 Jul 24]. Available from: https://github.com/skooter500/GE2-2023

7.        Games M. The fantastic combinations of John Conway’s new solitaire game “life” by Martin Gardner. Sci Am. 1970;223:120–3.

8.        Luna FD. Introduction to 3D Game Programming with DirectX 9.0. Plano, Tex: Wordware Publishing Inc.; 2003. 388 p.

9.        Lobao AS, Evangelista B, DEFARIAS JAL. Beginning XNA 2.0 Game Programming: From Novice to Professional. 1st ed. edition. Berkeley, CA: Apress; 2008. 456 p.

10.      Duggan B. skooter500/BGE [Internet]. 2021 [cited 2023 Jul 24]. Available from: https://github.com/skooter500/BGE

11.      Weerdmeester J. Take a DEEP breath: Exploring the potential of game-based biofeedback interventions for anxiety regulation. 2021;

12.      Weerdmeester J, Rooij MMJW van, Maciejewski DF, Engels RCME, Granic I. A Randomized Controlled Trial Assessing the Efficacy of a Virtual Reality Biofeedback Video Game: Anxiety Outcomes and Appraisal Processes. Technol Mind Behav. 2021 Aug 5;2(2).

13.      deep vr [Internet]. [cited 2023 Jul 24]. deep vr. Available from: https://www.exploredeep.com

14.      McKenna TK. The Archaic Revival: Speculations on Psychedelic Mushrooms, the Amazon, Virtual Reality, Ufos, Evolution, Shamanism, the Rebirth of the Goddess. Illustrated edition. San Francisco, Calif.: Bravo Ltd; 1998. 288 p.

15.      EXPLORING PARALLELS BETWEEN PSYCHEDELIC EXPERIENCES AND VIRTUAL REALITY [Internet]. 2017 [cited 2023 Jul 24]. Available from: https://www.youtube.com/watch?v=h0cs-4g4qWw

16.      Forms – a journey into the deep heart of code [Internet]. 2017 [cited 2023 Jul 24]. Available from: https://www.youtube.com/watch?v=ZLmbl5NSCew

17.      Duggan B. skooter500/ECS2020 [Internet]. 2023 [cited 2023 Jul 24]. Available from: https://github.com/skooter500/ECS2020

18.      Duggan B. Infinite Forms [Internet]. Dr Bryan Duggan’s Blog. 2017 [cited 2023 Jul 24]. Available from: https://bryanduggan.org/projects/forms/

19.      Duggan B. Infinite Forms [Internet]. 2023 [cited 2023 Jul 24]. Available from: https://github.com/skooter500/Forms

20.      Reynolds CW. Steering behaviors for autonomous characters. In Citeseer; 1999. p. 763–82.

21.      Reynolds CW. Flocks, herds and schools: A distributed behavioral model. In 1987. p. 25–34.

22.      Duggan B. Godot Engine [Internet]. Godot Engine; 2023 [cited 2023 Jul 24]. Available from: https://github.com/godotengine/godot

23.      Beckett S. Waiting for Godot: A Tragicomedy in Two Acts. Main edition. London: Faber & Faber; 2006. 96 p.

24.      Godot Engine documentation [Internet]. [cited 2023 Jul 24]. Nodes and scene instances. Available from: https://docs.godotengine.org/en/stable/tutorials/scripting/tutorials/scripting/nodes_and_scene_instances.html

25.      Duggan B. Game Engines Lab Test 2023 [Internet]. 2023 [cited 2023 Jul 24]. Available from: https://github.com/skooter500/GE2-Test-2023-Starter

26.      Monkey Ecosystem Programming assignment [Internet]. 2023 [cited 2023 Jul 24]. Available from: https://www.youtube.com/watch?v=zlIDZ-ISafg

27.      Duggan B. GitHub. [cited 2023 Jul 24]. Unity to Godot Porting Guide. Available from: https://github.com/skooter500/GE2-2023/blob/master/godot_ref.md

28.      Gamesfleadh [Internet]. [cited 2023 Jul 24]. Available from: https://gamesfleadh.ie/

29.      Capacite AT. BitBoy – endless-runner-2023 [Internet]. 2023 [cited 2023 Jul 24]. Available from: https://github.com/AdrianCapacite/endless-runner-2023