Game Jam Games

General information

Date completed January 2021
Role in team Developer
Environment Unity 2019.3.0f2
Language C#


For about half a year, my team (Fair Fire) and I worked on various small games from concept to publishing on to improve our work flow and make sure we can publish a concept in a quick manner so we can test whether it is viable on the market.


The first game we created was called Lanterns. It was based off of an idea of mine to give the player the power of fire and was further inspired by the god of fire in Hinduism: Agni.

In the game, the player is tasked with escorting a butterfly (human soul) to heaven. The butterfly will follow lights, and so the player can guide it forward by putting their light into a lantern in the desired direction. Certain lanterns have different effects. One such effect is the creation of a light beam between the two lanterns, striking shadows lurking between them. Another effect is that the lanterns slowly light each succeeding lantern.

public abstract class FireSource : MonoBehaviour
    public bool Lit = false;
    [HideInInspector] public Flame MyFlame;
    [HideInInspector] public Vector3 Core;

    private void Awake() {
        Core = transform.position;

    public abstract bool Light(Flame flame);

    public abstract bool Delight(FireSource target);

    public abstract bool CanReceiveLight();

    public abstract bool CanSendLight();

Because of the many different types of fire sources that can be lit or unlit by the player, it was the perfect opportunity to make use of an abstract class.

Threads of the Past

The second game, Threads of the Past, is a calming comfortable flying game, in which you play as a dreamcatcher-like entity, connecting towers with threads of light to banish the nightmares in between.

Initial movement system

The mechanics

One of the more interesting parts of the system was the flying system. We wanted it to feel comfortable and responsive, but also as uninterrupted as possible. At first, we started with a system that allowed the player to have full control and strong responsivity, but we quickly noticed it didn’t feel as dreamy as we had intended and players bumped into the pillars and walls, making it much less comfortable.

Appended movement system

To fix this issue, I wrote a new system that turned players around when they got too close to walls and automatically continued to fly in the rotated angle if the player moved left or right, making the movement flow more naturally. However, we noticed it was more difficult to control the entity, because to fly straight ahead, the player needed to perfectly center the rotation, which often resulted in over-compensating one way or the other.

Final movement system

So finally, I added the final element: returning to neutral. If the player didn’t press any buttons, the flying would slowly return to neutral. This way, there was no need to keep correcting to go back to flying straight ahead.

Searching for best collision avoidance direction

for (float i = 0.1f; i <= 1f; i += 0.1f) {
    if (Physics.SphereCast(transform.position, SphereSize, transform.forward * (1f - i) - transform.right * i, out hit, CheckDistance, CollisionLayer, QueryTriggerInteraction.Ignore)) {
        avgStrengthLeft += hit.distance;
    else {
        aversionDirectionRight = -1f;
        Debug.DrawRay(transform.position, (transform.forward * (1f - i) - transform.right * i) * CheckDistance, Color.yellow);

    if (Physics.SphereCast(transform.position, SphereSize, transform.forward * (1f - i) + transform.right * i, out hit, CheckDistance, CollisionLayer, QueryTriggerInteraction.Ignore)) {
        avgStrengthRight += hit.distance;
    else {
        aversionDirectionRight = 1f;
        Debug.DrawRay(transform.position, (transform.forward * (1f - i) + transform.right * i) * CheckDistance, Color.yellow);


Balloonomania was the third game we created together. The concept for this was thought of by Ilja, our artist. He figured since the time in which the old balloon posters were copyrighted had passed, we could re-use a ton of them to create a fun silly game experience.

The coding for Balloonomania was rather straightforward. The only hurdle I walked into was the 2D nature of the game. After not having worked on 2D games for a long time, it took some time to get back into the flow of working with 2D assets and raycasts, but once I got it back under control, the rest was a piece of cake.

player balloon scripts

Component separation

During these game jam games, I also ran into a frustration with my own code; having too many elements in a single script. I decided to try and separate each behavior into its own class. An example of this can be found in the picture above. A player balloon has balloon info, a flying, stabbing, getting stabbed and ability pickup script. Any of these can be turned off or entirely removed without breaking the rest of the functionality. It’s also useful because the AI balloons can also make use of balloon info and ability pickup.

Winter Wishes

The final game we made in this period of time was called Winter Wishes. Right before we made this one, we tried to create a really complicated game with way too many features. We had to cancel working on it, because there was simply not enough time to get it right. To prevent this from happening again, I asked the team whether we could try making a game around 1 simple mechanic, which ended up being pushing a bottle with water ripples.

After the first day I had a working prototype we could use to start testing the feel of the mechanic with friends and family members. After the first week, we already had a finished game loop and immediately started testing that one as well.

Because of the simplicity of the game and the repeated testing, I think this game turned out as the most polished game we made during our project.

%d bloggers like this: