Backyard Snowdown

Backyard Snowdown was produced by "Frankenfruit Studio". Our game was the product of my 2017 end of year team game assignment. Frankenfruit Studio consisted of 2 designers, 2 programmers, and 3 artists. We created a kid's imagination of a backyard winter snow fight! A fast-paced local multiplayer party game!
The last kid standing wins.

The Development Process

Backyard Snowdown's development spanned over 2 months. Early on, both our designers were absent for around 4 weeks, due to this our other programmer and I took it upon ourselves to design the game. We ended up having a really great response from the teachers and other students. This taught us to be flexible and innovative when it came to thinking on our feet. As a part of the assessment, our teachers organized an industry panel, whose job was to come in and provide feedback on the various games. What surpised us, when it came to our turn to present, was that the panel, during the question period, had no advice for us. (Every other group had advice given). This gave our team a huge boost in morale because it showed us that we had been developing the game to a high standard.

What I contributed

Jumping Snowman
I created the jumping snowman that appears and starts jumping around dealing a knock-back effect to players. I learned a lot about Unity's math functions such as Vector3.Lerp and Physics.CheckSphere.

I programmed the dash feature. Dash allows the players to dive towards players or snowballs, which allows players to pickup snowballs or steal them from other players and to also catch them mid-flight. This really adds an interesting and fun element of gameplay to the game as it allows players to have more of a chance aginst other players.

Object Pool
I learned how to create an object pool during the development of the game. Object pools allow for more efficient management of game assets/resources. It also eliminates the possibility of an object existing more times than is allowed by the object pool.

Player Logic
The player script went through many stages of development; was very complex and taught us a lot about specific Unity features, such as layers, collision detection, Fixed Update, code neatness, code commenting standards and complex systems such as the snowball charging and firing systems.

The snowball is the element of the game that players use to damage other players and ultimately is the way the winner is decided. This script is also quite complex, it tracks a number of variables such as velocity and collision targets to provide a balanced way for it to function.

View on Github

Real World Racer

Real World Racer (RWR) is a game that was created for my end-of-year team game project for my second year of my AIE games programming course.
In RWR you can explore the globe and create race tracks anywhere. Beat your best track times and challange your friends!

The Development Process

Development spanned over 6 months, June to November (in 2018). In this time our team developed the game, maintained documentation, performed testing, implemented changes and produced marketing material.
Initially we wanted to utilise Mapbox (3rd party addon for getting map data), and Photon (3rd party addon for multiplayer game capability) to create an experience for players to play together anywhere in the world. Our teachers advised us at our first review that the scope may be too large. We discussed this as a team and decided to make drastic changes. Instead of live multiplayer action, we would focus on getting Mapbox working well to allow players to create their own maps, set their best track times, and challenge their friends instead. This ended up being a better scope as coordinating Mapbox and Photon was proving too tough for 3 programmers.

What I contributed

Track Creator
I was the main programmer for the track creator aspect of the game. This is a major part of the game as it allows anyone to create race tracks, placing waypoints and other assets anywhere in the world.

Save Load Maps
As I was the main developer of the track creator system, I knew how it was specifically programmed, thus allowing me to implement and subsequently learn a lot about Unity when it came to saving and loading map files. It was a lot of fun. I love building systems like this!

The ghost was your best time on the map you are playing represented as a ghost, like in Mario Kart! This was a ton of fun to program, it taught me about saving large amounts of data, optimizing it and loading the data again, all while preserving performance.

Race Logic
I was the sole programmer for the race logic and how players were tracked against the ghost to see who finished the track first. This was a super fun aspect of the programming because I had to use a ton of math to track the player and ghost progression on the track.

Other aspects
Since the team was only 6 people, we were all in the same room and we would constantly help each other with code. This led me to having my code appear in almost every aspect of the game such as the: menu systems, Mapbox loading code, and car controller amongst other various areas. I learned alot from working on this project.

Git Bash
Another huge thing for me during the project was I only used git from the command line. This ended up being essential version-control issues came up. The rest of my team was using various git GUI interfaces, and occasionally issues would arise where the command line was required. Eventually I converted the other 2 programmers to the command line and they loved it. I even had other students on the floor asking for my help.

Langton's Ant

In mid 2019 I got the sudden urge to make something cool in Unity. I had recently watched this video and decided to create it in Unity. I had a lot of fun creating it and thought "this would be cool to release on Steam", so I checked and no one had done it yet (please don't beat me to it)!

Here's the description Wikipedia provides: "Langton's ant is a two-dimensional universal Turing machine with a very simple set of rules but complex emergent behaviour. It was invented by Chris Langton in 1986 and runs on a square lattice of black and white cells. The universality of Langton's ant was proven in 2000."

The Development Process

Initially I just wanted to get the maths of Langton's Ant working in Unity, so I started with initialising cubes and using raycasts from a player gameobject to get it working. After a little while, I got it working, but the number of cubes being created was silly and Unity wasn't handling it well. Next, I set out to optimize my code. I learned a ton of cool Unity optimisations such as disabling physics engine and learning more about raycasts amongst other things. In the end the biggest optimization by far was changing from creating cubes to simply having a texture whose pixels I was changing based on some complexish maths.

Features I added to the base program

This allows the ant to seamlessly loop offscreen and appear on the other side. This allows causes the ant to loop back and interact again with the path and create some more awesome patterns! This is the best when a highway is created.
You can see this in the video below.

Instead of stepping 1 unit at a time, the ant steps farther each time, this also results in some amazing patterns!

Steam Page

Six Million Dollar Vigilante Reloaded

Six Million Dollar Vigilante Reloaded was created during a game jam at AIE. This was a three day game jam.

The game is about a robot in the "old west" shooting bad guys and reaching the boss and to defeat him.

What I contributed

Object Pool
This is used to pool the bullet prefab so we could instantiate 6 bullets at the start of the game and then just reuse them during the game. Setting the bullets to false when they are reloaded and activating them when the player shoots.

Round Manager
I spent alot of time on this part of the project, making it really easy for the designers to set up. It functions if all the enemies in the current room are all dead or not; when it detects this it moves to the next room. The system is modular; you just have to use the folder structure provided. When the game starts, my code runs and automatically detects how many enemies are in each room and also how many rooms there are. This information is stored in a list of lists. The main benefit in using this is that the traditional way, requires designers to drag and drop the enemies onto a publicly exposed list variable. This method is more efficient because it detects the enemies and adds them via code.

Fly Camera
This works in unison with the round manager; when the fly camera script gets the information from the round manager, that all the enemies in the room have died, it triggers to fly to the next room. It does this by lerping between empty game objects in the scene and by Transform.LookAt lerping. There is a list of "Camera Location Points" and a list of "Camera Look at Points." These lists are self-explanatory and tells the camera where to go and to where to look. Its location is in correlation with the current round.

View on Github

Barefoot Engine

Back in May-June 2018 we studied the OpenGL Shading Language (GLSL) using AIE's bootstrap as the base of the engine. We are programming the rendering capabilities of the engine. In my engine I have included 5 multi-textured models (4 of which are loaded from an obj and an accompanying mtl file), a custom phong lighting shader which lights each model, a particle system shader and a shader that handles the blended floor texture.

View on Bitbucket


One of the many subjects we covered in 2017, during my course, was "steering behaviours", we learned about various behaviours such as: seek, flee, wander, flocking.

View on Github

Blocky Swing

A little while ago, a friend and I wanted to create a game together in Unity. We brainstormed and settled on a rage inducing game format as it is quite engaging.

We learned lots about aspects of design and also that it is important to not get too attached to features if they are not working.

We plan to release it for free on the Play store and on Steam.



Your Gallery

In the game "Your Gallary" you select photos that represent "What home means to you" to decorate a modern art gallery. Click the photos to find one you like.

The game was developed over a three day span for the theme "What home means to you". It was developed alongside Nathan Nette using Unity 3D and Blender 3D. It was good to learn how to do different things in Unity, particularly how to have it so players can import their own photos into the game, atleast on the desktop version which is avaliable for download here.

Play! View on Github