By the time I finished my bachelor's degree at Darmstadt University of Applied Sciences, I had already worked as a Junior Gameplay Programmer for Crytek for one year. To stay in contact with both students and the university itself, I approached the professors and offered to give lectures about game development and programming in general (at hda these are called electives).

So far I have offered one such an elective every year, starting in 2019. All of them took place over multiple months and were attended by ~20 students each.

In addition, from time to time I am approached either internally at Crytek or externally by various universities whether I would like to hold a guest lecture about a game-related topic.

Elective WS19/20 - Core Engine & ECS

The first elective I gave was called 'Playtime is over: Game Engine Development using C++'. The title is a bit cheesy, I'll admit.

The goal of the elective was to write a data-oriented ECS based on SFML. While the library is a bit outdated it is easy to set up for multiple platforms and it makes writing a game engine on top of it very comfortable.

Ultimately, the engine supported an entity system, data pools and systems that acted upon these pools.

You can find the final version of the engine here. Please note that this engine was written in collaboration with students to teach both C++ and the inner logic of a game engine. It is neither optimized nor adherent to all professional coding standards (which is totally fine of course since it was written in collaboration with beginners).

Elective WS20/21 - Serialization & Multithreading

The second elective I gave was called 'Game Development and Beyond' and was less about game engine programming in particular and more about topics that from my experience were not talked about often during the Animation & Game programme. We built the features we talked about on top of the engine that was built in my first elective.

This elective was held entirely remotely due to the Covid-19 pandemic and was thus not as interactive as I would have hoped. Still, we made the best of the situation and managed to talk about all topics that we planned to talk about:

The first topic was serialization of data into files and/or memory. We made use of the JSON library by Niels Lohmann for JSON serialization and tinyxml2 by Lee Thomason for human readable file serialization and wrote our own archiving system that hid the serialization implementation behind an interface but still was able to serialize STL containers and even other serializable objects without the use of an interface class. We talked about the memory layout of objects, how bytes do not have an inherent meaning and how it is up to the programmer how to interpret these bytes.

For the second topic I gave an introduction into multithreading. Since we were still working within the context of a game engine, the first real application of this concept was in the form of a render thread. We created a triple-buffered render data queue and discussed different ways of synchronzing the main and render thread as fast and as sporadically as possible. After this demonstration of a dedicated thread, I introduced the students to std::async as a mean to explain worker threads that handle all kinds of tasks. In the example, we took a flood-fill algorithm used e.g. in tile-based strategy games like Fire Emblem and moved it to a worker thread. Once the task had been completed, we retrieved the calculation result and applied it to the game.

During the last session of the elective we had taken what we learned about serialization and multithreading and applied that knowledge in the field of networking. By understanding the properties of bytes as raw data and then grasping the concept of two flows of execution computing data independent from another, the students were in a good position to also understand how data is transmitted over a network and ultimately acted upon on the receiving end. Due to time constraints I was only able to give a short glimpse at networking and merely demonstrated how to use it within the context of a simple game but the feedback I got from the students gave me the impression that it was an easy to understand explanation of networking, which was my goal after all.

There are recordings of all online sessions but due to privacy concerns I will not post them publicly here. If you are interested in these videos, please reach out to me. The template on which the students could (not should) build their assignment for the elective can be found here.

Elective WS21/22 - Networking & Multiplayer

After the successful introduction to networking during my previous elective, I offered a course that would take a deeper look at how games communicate across a network and how to utilize this to write robust multiplayer gameplay logic.

Again, this elective was held entirely remotely due to the Covid-19 pandemic but this time around, interaction between the students and me was more lively than the last time. We managed to go through all important topics that I had planned at a pace that felt appropriate.

After a brief recap of the previous elective's topics (data serialization) we started out by talking about network protocols, UDP and TCP in particular. We reused the code template used during the previous elective and wrote an engine system that was able to create and handle a simple listening server with multiple clients. Over the course of the elective we added logic on top of this system that allowed the programmer to declare RMIs (or RPCs, if you prefer that), spawn entities over the network, serialize types and entity IDs over network in a safe manner and how to interpolate and predict basic velocity-based movement. We also took server authority into account and had all gameplay-relevant logic be evaluated on the server only.

For the last topic I wanted to give a glimpse into implementing a simple NAT punchthrough but due to time constraints we were not able to fit it into the allocated schedule.

During the last session of the elective we had taken what we learned about serialization and multithreading and applied that knowledge in the field of networking. By understanding the properties of bytes as raw data and then grasping the concept of two flows of execution computing data independent from another, the students were in a good position to also understand how data is transmitted over a network and ultimately acted upon on the receiving end. Due to time constraints I was only able to give a short glimpse at networking and merely demonstrated how to use it within the context of a simple game but the feedback I got from the students gave me the impression that it was an easy to understand explanation of networking, which was my goal after all.

Again, there are recordings of all online sessions but due to privacy concerns I will not post them publicly here. If you are interested in these videos, please reach out to me.

In December of 2021 I was approached by the Technische Hochschule Mittelhessen about whether I would be interested in giving a talk about a topic of my choosing. I got my presentation checked to avoid leaking any sensitive information and held a talk about reconnecting in online multiplayer games with a post mortem of Hunt's then-new reconnect feature. Due to the still ongoing pandemic the talk was held remotely and was streamed via twitch.tv. You can find a recording of the presentation here.