A Bug in the System

Grads in Games SFAS 2021 Games Programming Winner

Grads in Games: Search For a Star 2021

Every year, an organization known as Grads in Games, organizes a competition to promote the placement of junior game developers in the industry. In 2021, I submitted this project as my entry for the Games Programming category and was incredibly honoured to take the first place!

We were given the project brief along with an existing Unity3D code base (a bare bones dialogue system), and our goal was to expand this code base and turn it into a small game over the span of two months.

A Bug in the System, is a story-driven physics platformer where you play a small beetle that finds himself crawling along the guts of a crash-landed spaceship. I pulled a lot of inspiration from Limbo, Inside and Little Nightmares, which all have this sombre atmosphere that somehow manages to be peaceful and captivating despite the clearly bleak world it inhabits.

Play it here: https://chronicbite.itch.io/abuginthesystem

Development Plan

In early December, amid heavy university work, I focused on planning, concept development, and experimenting with styles for my project.

As I progressed past the initial production stages, I prioritized building the game's core systems, starting with player animation and environment pipelines. Implementing a scene loading system and expanding the dialogue system were crucial for maintaining performance, and supporting the gameplay loop.

In the final days of the jam, I wrapped up documentation, set up the game page on itch.io, and submitted it.

Production Schedule

Art Direction

The art direction for this game had a strong presence in my mind from the start. I knew I wanted to make a game with a distinct art style so I could showcase some shader work and create impressive visual effects. After some color studies, I decided to go with black and white for a few reasons.

For one, It simplifies asset creation tremendously, but most importantly it makes it extremely easier to join assets from different sources and have a strong and homogenous looking visual style in the end. Especially on a tight schedule.

Progress from sketch to fully textured 3D Model (Modelled and Rigged in Blender)

In-Engine Art Tests

After the sketches and texturing tests above, I started experimenting with shaders for post-processing. This quickly led me to the decision of migrating the project to URP so I could have more control and, also, take advantage of the scriptable render pipeline to write my own render features. Seen below in the form of a custom outline shader. Some of the built-in post-processing is also used including vignette, contrast, and bloom.

Character Controller

The character is made up of three main systems. The Animation Rig, the Physics Rig, and the Camera Rig. Each system is specialized and is solely responsible for its own function.

Animation Rig

The animation is fully procedural. The legs are driven by Inverse Kinematics and some secondary motion is created via dynamic bones (for the antlers, head and abdomen).

I achieved this using Unity's Animation Rigging Package, which allowed me to bring the beetle to life, while only needing to manage the body and feet positions programatically.

Pose System

Associated with the animation Rig is a Pose system. The beetle can hold several different poses, (eg: standing still, walking, flying, grasping an object, etc). This meant the character could for instance tuck its legs when in the air, spread them further when walking and then bring them closer together when standing still.

I ended up writing a custom inspector for it, which allowed me to edit each pose and create new ones easily.

Physics Rig

The Physics Rig is quite simplistic, it’s made up of a single sphere collider which, driven by the player input, rolls towards the desired direction. This made it so the character keeps momentum and climbs by rolling up steep hills quite easily.

The animation rig is kept at the centre of this sphere and we keep track of the points of contact so we can properly orientate the beetle according to the ground normal.

Putting it all together

With the physics rig driving the character movement and orientation, and the pose system selecting points on the ground for the beettle to place its feet, we then procedurally animate the legs to move from one point to the next when the distance surpasses a certain threshold.

Character Abilities: Flying

By holding space bar the player can control the beetle to unfurl its wings and fly. The flight is limited to a small amount of time which serves as a way to lift off the ground for a small jump, or help in climbing a particularly steep surface.

When flapping the wings, we swap the material and mesh to create a motion blur effect

The extend/retract and flapping animations are done through skeletal animation

Character Abilities: Grasping

The beetle is also able to use its hind legs to grab onto to small physics objects, which it can then carry around for short distances or flip levers for puzzle solving.

The beetle is able grasp and fly simultaneously

Slots snap an object into place when its close by

Camera Rig

For this game, I knew I wanted to have a single shot camera that was mostly fixed and constricted, allowing me to carefully pick all the shots. This was done to both evoke the same cinematic feeling as the sources I was drawing from but also to save me some time in setting up all the environment. Scenes only needed to look right from one particular angle.

To achieve this I extended Unity’s Cinemachine Package and created a camera manager which managed the camera transition based on the player position and specific trigger volumes.

In this example the camera starts out with a tight zoomed-in shot that moves along a track as the character makes its way through a narrow tunnel.

Next, it pulls back to a much wider almost top-down shot that also applies a different post processing profile (done here for testing purposes but used in the game to adjust luminosity and for dramatic effect).

Finally as the beetle makes it over the wall, the camera transition to a tracking shot that swivels to show you where they landed.

As mentioned before, we control each of these shots based on volumes that, when detecting the presence of the character change from one specific shot to the next.

In this example we see the camera move to track the beetle in the same area as before, from the tight tunnel to the open area.

We can see as the camera moves to to find the best possible shot of the action, while preserving the cinematic intent and constraints laid out.

Environment: Vegetation and Wind System

I created a Vegetation and Wind System to make the scenes more alive and dynamic. The blades of grass and leaves all use a single low-poly instanced mesh that is controlled via a vertex shader, making it extremely performant.

The player deforms the vegetation on contact

Wind direction and power affects all vegetation

Environment: Terrain Pipeline

I created a custom material that combines different textures into a single shader and then used Unity's Polybrush Package to deform and paint the vertices of the terrain planes, and also to easily place vegetation instances aligned with the terrain.

Vertex painting to mix different terrain materials in a single shader

Polybrush is used to paint the vegetation objects at the correct angle in the terrain

Environment: Physics Props

Lots of elements in the game are fully physics driven and respond to the player's presence.

The main way to interact with the dialogue system is through a broken keyboard that click-clacks under the bug's feet and two buttons that let the player make 'yes' or 'no' choices.

Extra bits and bobs

There are many more things that went into this project that I cannot fully outline here.

Amongst these, I implemented a sub-scene streaming system that allowed me to control precisely when objects would get streamed/de-streamed and do this efficiently and async.

I also made many extensions to the provided base dialogue system to support arbitrary speed changes, dramatic pauses and choices.

Grid placement and collision visualization

Thanks for reading!

Overall, this project went quite well, closely aligning with my initial plans!

While I typically struggle with over-scoping, effective planning helped me manage scope efficiently. By the end of the project there were still some bugs to address for a better user experience, ranging from minor issues like storyline inconsistencies to major ones like physics collider entanglement. However I think this is to be expected when developing an ambitious game within tight time constraints, especially when play testing isn't really viable.

Despite its imperfections, I'm proud of the project and happy for the skills it taught me :)

Next project: C++ Path Tracer

Grads in Games, Search for a Star 2021 Games Programming Winner

Page updated

Google Sites

Report abuse