- 1. Khajak (game jam, 2016)
- 2. Instanced Rendering Example for Kha (tech demo, 2015)
- 3. Personal Growth (game jam, 2015)
- 4. 10up: Blupp the Gruesome (game jam, 2015)
- 5. Trope Raider (game jam, 2015)
- 6. Typefighters (full game, 2014 - 2015)
- 7. ConnGame (game jam, 2014)
- 8. Clash of Duty: Medieval Warfare (game jam, 2014)
- 9. A-Maze-Thing (game jam, 2013)
- 10. TypeCraft (prototype, 2011 - 2012)
- 11. CoopTris (full game, 2010 - 2011)
- 12. VSTris (prototype, 2009)
- 13. SweeperVS (full game, 2008)
Khajak (game jam, 2016)
Getting more and more into kha I was really looking forward to using it at the Global Game Jam. Since it is more of an SDK then a full-fledged game engine Robert Konrad and I prepared some basic functionality
like .obj-file loading and rendering as well as a particle system in advance.
During the idea phase we quickly became interested in doing a boat racing game for two players, which allowed Robert to implement a water simulation he read about some time ago and me to experiment with boat physics. Fortunately it was easy to integrate the actual topic "Ritual" as a narrative justification for the race.
Development went very smooth, even the creation of the most complex 3D objects I have made so far. Our game was fully playable after one day, giving us plenty of time to work on the details. Working on the tutorial with one day left felt pretty surreal, since that was something we normally did in the last minute or even had to skip. I also think that the unusual movement (physics based rowing with bumper and trigger) was the first time we had a simple, but also engaging core mechanic. Tying the strenght of each stroke to the delay between hitting bumper and trigger added depth, and mastering this timing was a deciding factor in our test matches.
Developed together with Robert Konrad using kha
Instanced Rendering Example for Kha (tech demo, 2015)
Having contributed instanced rendering functionality to the WebGL backend of the Kha
SDK I was asked to provide some example code, too. The first version of this demo explained the concept, but was not very interesting to look at and did not show the strenghts of instancing. So I decided to extend the example a little - this is the result.
Personal Growth (game jam, 2015)
At work one of my tasks is to further develop the authoring tool StoryTec
, with which you can build Adventure Games including some pre-defined minigames. Having worked on it for quite some time I wanted to put it to the test by checking out what can be done with it in just three days. And since it is aimed squarely at non-programmers, it also forced me out of my comfort zone, concentrating on drawing and story for this game.
In the end it became a tale about learning live lessons, which I felt was a great fit for the topic "Growing". Drawing so much and working alone during a game jam where interesting new challenges, while working with and sometimes around the limitations posed by the basic scripting and limited number of objects provided by the tool was a very interesting task tingling my programmer senses. Nevertheless, I'm looking forward to programming again for the next game jam. ;-)
10up: Blupp the Gruesome (game jam, 2015)
After two weeks of me playing around with the kha SDK it was a no-brainer to use the same technology for Ludum Dare 33.
Our idea was to create a multiplayer game for a single PC where players take turns of one minute while the other player is supposed to look away. At night one of the workers transforms into a monster, trying to find the items that allow him or her to escape. During daytime, the other player is able to check log files for traces of nightly activity. However all of their timestamps are missing and there are AI-controlled workers roaming the building as well...
Another game jam entry I am very proud of, as the basic idea is quite interesting and we managed to iron out most bugs. However, with complex systems like a flexible AI, multi-agent elevator controls and a dialogue module in which a programmer could sink his teeth in there wasn't enough time for balancing in the end, making the game one-sided in favor of the monster. We also had many ideas for additional objects the players could interact with.
Created togehter with Augusto Garcia, Ingo Jakobs, Martin Konrad and Robert Konrad using the kha2D engine.
Agent player (daytime)
Monster player (nighttime)
Trope Raider (game jam, 2015)
We decided to use the "Global Game Jam 2015" theme (What do we do now?) as an excuse to think about some of our favorite gaming tropes. Green water is bad, semi-broken walls can be destroyed, changing to a more energetic music announces a boss fight and so on - but what would happen if we had to unlearn those?
With three out of four people creating assets during most of the jam, this game is certainly the most impressive looking and sounding one I worked on during a game jam so far. However it is very short and I think that getting our point (and the jokes) across could have benefited from a bit more fine tuning. Nevertheless I am quite pleased with the result, especially since we just worked for approx. 36 hours on it.
Made with Johannes Alef, Michael Rau and Rebecca Schieren using the Unity engine.
Column hall with enemy
Typefighters (full game, 2014 - 2015)
As predicted in 2012, I could not resist revisiting the idea of a competitive typing game for two players. I chose a completely different approach however, developing a relatively simple framework in Unity first. As the framework contained everything in terms of mechanics and representation I could then focus on iterating on the games rules in order to solve the problems I noticed during the development of TypeCraft.
The results of lots of player feedback have been 8 distinct modes that not only emphasize typing speed and correctness, but also other skills like reaction time, sustained attention, or tactics. Combined with lots of room for "smaller victories" and user defined goals these keep weaker players from being demoralized completely when playing against a faster player.
Other features include custom word lists, singleplayer AIs for every mode and a menu that can be completely navigated by typing its entries. As it is the second fully completed game I also focused a lot more on PR, posting more news, spend more time creating screenshots and trailers
as well as maintained an IndieDB-page
and a Twitter account
. The press coverage I could achieve included being a Freeware Pick on IndieGames.com
and being mentioned on the Indie Game Magazine
the game's campaign on Steam Greenlight.
All in all I am quite pleased with the result, as I was able to create a quite polished game with a novel premise that is really fun to play (if one is interested in the niche that is typing games). I was also able to tie up the loose ends I left dangling on TypeCraft and gathered a lot more experience on marketing and contacting press.
ConnGame (game jam, 2014)
A (hopefully humorous) text adventure game developed for the "Ludum Dare 30" game jam which is written as a dialog between the player and the player character. The topic of the jam was "connected worlds", so we build a game that connectes all other game(world)s created at our location. Every game has it's own location with puzzles based on objects taken from their world. At a certain point in each world the player character encourages the player to play the referenced game in order to give him some time - which must be proven by a keyword.
The idea to build a technically simple game for this game jam worked out great and allowed us to spend most of the time on dialog writing and puzzle design with some spare time for testing. Therefore we could add all the features we wanted and even finished a refinded version based on the testers feedback during the jam.
Made together with Max Maag and Bernd Bohmeier in a beta version of the Unity engine (we wanted to test some of the new gui features). This is my first game which is designed in such a way that it works on mobile devices (Android).
Clash of Duty: Medieval Warfare (game jam, 2014)
My second game jam entry, this time for the "Global Game Jam 2014". The topic "We don't see things as they are, we see them as we are." was a tough one and in the end my team decided to go for a multiplayer strategy game where you initially project your units state onto the enemy ones. After each fight one property of the unit is revealed, giving you the opportunity to counter it properly next time.
Sadly organisational difficulties (private responsibilites in my team meant too few working hours together) resulted in a development process which was not properly organized. Therefore we did not completely achieve what we in mind, with rudimentary balancing and a barely working singleplayer mode. However we had lots of fun as well as the opportunity to get some design and development practice, which has been our main goal for the event.
The game was created with Frank Englert, Stefan Huebecker, Johannes Konert, Florian Mehm, Philipp Schillinger and Viktor Wendel using the Unity engine.
Upgraded squire meeting his oponent on a bridge
A-Maze-Thing (game jam, 2013)
This game was developed for the "Ludum Dare 27" game jam, which had the theme "10 Seconds". It is set in a (randomly generated) maze-like space ship filled with aliens, from which the player must rescue his fellow crew members. The theme is incorporated by the fact that the ship's scanners (i.e. the minimap) are malfunctioning and therefore only update every ten seconds. This way the player has to anticipate enemy movement as well as memorize his own position to prevent running into an enemy behind the next corner. The resulting time frame of uncertainty is meant to create tension, which increases with the time elapsed since the last update.
I am very proud of the result, especially because it was the first game jam entry for everyone on my team. However, we learned quite a few lessons along the way, including that one should never forget to plan appropriately - especially under tight time constraints.
"A-Maze-Thing" is based on the Unity engine and was created together with Florian Mehm, Moritz Neeb, Stefan Huebecker and Viktor Wendel.
Enemy in a hallway
Crew member following the player
Enemy collector as shown in the tutorial
TypeCraft (prototype, 2011 - 2012)
I always admired the clever concept behind "Typing of the Dead", which allowed players to improve their typing skills while playing. Regretfully there are far to few games which followed up on that idea, and there are even less which allow players to compete against others using only your typing skills.
Since I heard lots of good things about the "StarCraft II" editor, which supports not only maps but completely new games (as long as the players own the original game), I also wanted to give the editor a try. This lead to the idea of bulding a simple typing-based strategy game which can be played competitively by two players. It is based on the principle that each player builds units by typing a randomly choosen word. The opponent is then able to kill this unit by typing the exact same word. If he is not fast enough and the unit reaches his home base, he loses some health.
Stronger units have longer words attached to them, mirroring longer construction times (on the attacker's side) and more health (on the defender's side). However, these advanced units can only be build if the player upgrades his base by typing a longer sentence, which also increases the health of the base but requires him to pause his attacking / defending efforts momentarily.
After playing some rounds with the initial prototype, it became clear that it was extremely dependent on the player's typing skills and that it only lasted more than a minute when played by very similarily skilled players. This lead to the decision to not elaborate it further. However, I might follow up on this idea in the future with a cooperative concept involving balancing mechanisms for differently skilled players, maybe also using a technology which is more accessible for players.
Basic map design and GUI
End game statistics
Early version without build menu
CoopTris (full game, 2010 - 2011)
Since I wanted to gather some experience on implementing a game engine from scratch (with basic versions of the most common features), I decided to write my next game using C++ and the Qt framework for basic convinience features. This time it would be a cooperative game based on the lessons I learned while working on "VSTris".
The most important decision was to wrap the playing field around a cylinder, making it "infinite" and preventing players from pushing others into a corner. The game can be played by two local players on splitscreen and up to four players online. It is even possible to mix these modes, i.e. join an online server with a local two player team. After a game, the score is submitted to an online highscore if desired - which resulted in an intense competition between some teams. At the end, their ambitions required them to use voice chat in order to keep up with the fast-paced games. They also had some interesting discussions regarding their strategies, for example on whether to have the players move all around the cylinder or dividing it into sections for which a single player is responsible.
On the technical side the game uses a simple 3D graphics engine using OpenGL (supporting "Vertex Buffer Objects" and "Display Lists"), fast and robust network code enabling games over the internet and a dedicated server infrastructure including a masterserver. Besides from that I added home-made sound effects, text chat, a short intro animation and an options menu which controlles things like display resolution, three graphics quality presets and VSync. After gathering player feedback I included a function to invert controls horizontally as well, which made them more intuitive for a notable number of players. This fact can be attributed to the players having different points of references for their movement (turning the cylinder right means rotationg the camera left).
Three players, online
Two players, splitscreen
Four players, lobby
VSTris (prototype, 2009)
Because I had so much fun designing "SweeperVS", I decided to turn my attention to another classic – "Tetris". Although there are many multiplayer versions of this game available, most of them separate the players between different playing fields. In contrast, I wanted to have more direct competition by having them share a single one. But this resulted in an interesting challenge regarding the game ending condition: It was either too easy to play destructively and force the other player to loose by blocking his active block, or a player could end the game at will when having the lead.
Besides a two player competitive mode for local play, I also added a singleplayer mode. Field size, block colors and the optional preview can be configured via the options menu. This game was never finished however, since I decided to work on a cooperative take on the original formula instead (using a different programming language this time).
A Java runtime environment is required to play the game.
Two players, big field size
One player, small field size
SweeperVS (full game, 2008)
Having played many rounds of "Minesweeper" during my late school years, I had the idea to transfer it's basic principle into a multiplayer setting. In doing so I hoped to create a multiplayer game which could be understood almost immediately by most people, since the original game has been installed on almost every pc for quite some time.
Adapting the ruleset for competitive gameplay was an interesting task and required adequately rewarding the players for taking the risk of an uncertain move. Although I think that the end result is quite decent, playing the game as a cooperative puzzle by ignoring the individual scores turned out to be more fun in the end.
"SweeperVS" can be played by up to four players on a LAN. It offers three difficulty levels: "normal" (256 squares, 40 mines), "hard" (512 squares, 99 mines) and "insane" (1440 squares, 333 mines).
Since the game is written in Java, it requires the corresponding runtime environment in order to run.
Four players, hard difficulty
Four players, insane difficulty
Four players, normal difficulty (with player list)