Fly to the Moon is a vertically endless 2D platformer that I created using C++ and OpenGL.

The player must hold space to use their jet pack to ascend through the sky, whilst trying to hit certain interactables whilst avoiding others. These affect the player in various ways, such as: increasing the player's score, reducing their speed, causing fuel leaks and fuel regeneration.

The higher the player ascends, the greater their score. As the player ascends, the background colour and ambient lighting darken significantly.

This game utilises a large portion of OpenGL's functionality, including unique vertex and fragment shaders, a projection matrix with a view (operated using a Camera class), texture loader, optimised vertex data, and shader programs. These have been used to create specific effects, such as the darkening game world whilst the UI, and the moon, remains at a constant light intensity. Fragment shaders have also been used to create effects such as changing colour of the background, and the fuel gauge using uniformed variables.

Additionally, there is a simple, but complete character controller with two textures depending on the direction they are facing, score and high-score tracking, scrolling clouds as well as a comprehensive collision and physics system. The physics system has two fundamental functions: adding force, and adding impulse. These are used as basic functions for player movement and responses to collisions. The collision system primarily works by checking the bounding boxes of the player compared to each platform within their range, and generating collision data for successful collision, such as the direction of collision (normal), and the magnitude of the collision (penetration). This is used to create a vector, which can be used to resolve the collision.

C++, OpenGL, PC Game

This is a clone of the original 'Jelly Up!' game, which involves a square moving horizontally on a platform, attempting to avoid the edges of platforms which do not have walls through jumping to the next platform, in order to avoid falling off the edge. Each time the player reaches the next platform, the score is incremented. As the player's score increases, platforms gradually get thinner, demanding faster reaction times.

This clone includes a title screen, shop (where different player colours are unlocked using the in-game currency) and two levels, where the second level includes an additional level of functionality. Both levels contain coins for the player to collect, challenging the player to choose between safety and collecting coins. In the second level, there are green and red diamonds. The green diamonds make every platform in sight have solid walls, and the red diamonds temporarily speed up the player, forcing the user to react faster to upcoming platforms.

I created this game in its entirety, developing systems such as an in-game shop, player movement and physics updates, infinite platform generation (with optimised memory usage and garbage collection), coin and diamond spawning. I also developed a 'Jelly Up Engine' class which handled all the base functionality, using scripts for each level to add individual functionality.

The game also includes a basic sound engine for sounds such as jumping, coin collection and shop purchases. There is also the feature of parallax scrolling, where the background moved downwards at a lower rate than the platforms in order to perpetuate the illusion of the player gaining altitude.

Since platforms generate infinitely to provide an infinite game loop, efficient memory management was non-negotiable. In order to free the application of statistical dependencies (based on the number of platforms generated), old platforms would be removed from the platform array as they go out of view of the player. This would constitute a major optimisation past a score of 14, since this is the number of platforms the player can see within a single frame, accounting for a buffer platform on either end of the platform stack.

C++ / SFML, PC Game

In recent weeks, I have been working on two separate aspects of game development: multiplayer programming, and destruction physics.

Player #2 is connected to a LAN server which is hosted by Player #1. Each player can see eachother's movements as well as changes within the environment. Upon shooting a ball at a cube, the cube spontaneously fragments and explodes.

Cube fragmentation is a relatively simple process. Fragments are spawned based on the desired number of chunks, using this value as a divisor to calculate the size of each cube fragment. Each cube is given a random material and controlled force depending on the point of impact on the cube.

Combining multiplayer functionality and physics reactions with a high number of gameobjects is computationally challenging, due to the requirement to produce so many fragments within a single frame. Through a combination of chunk queueing and object pooling, the client remains well above 800 FPS even at the frame where collison takes place, and the cube separates into 216 individual objects. Having tested on multiple devices connected to the same network, reliably low latency serves as the foundations for an upcoming local co-op multiplayer game filled with destruction and high explositivity!

The depiction is in a GIF format for size reduction, reducing perceived framerate. The demonstration project runs smoothly on both the host and client instance.

Whilst the original 'Panzault' was 2D, this is a 3D recreation of the game, created in Unity and C#.

For this project, I developed a basic environment, tank controller, enemy AI, powerups, explosion system, score system and complete game loop.

The player is a tank, which can navigate through the environment. There is an infinite wave of overhead enemy planes of two different types. Some fly directly overhead, whilst other specifically fly towards the game world, and can drop bombs on the player tank. The player must shoot planes to knock them off course, and prevent them from dropping bombs. The closer bombs get to the player, the more damage the tank takes. The tank also takes damage if hit by enemy aircraft.

The game also has two power-ups. The coins add to the player's score in the same way that hitting aircraft does. There are also red health powerups, which restore some of the player's health. However, collecting powerups inevitably distract the player from shooting enemy aircraft, resulting in an increased exposure to danger.

Creating this game demanded effective CPU and memory management due to the abundance of spawnable in-world objects such as aircraft, coins, health powerups, bombs and explosion visuals. As such, object pooling has been implemented in appropriate cases. I also developed an interactive tank controller, level system, multiple user interfaces and their functionality, and infinite levels with a fair difficulty curve.

Unity, C#, PC Game

Outside the Box, is a puzzle based game which is fully playable on Xbox and PC. The game was originally developed for console, but controls have been ported to support keyboard and mouse inputs too.

Within outside the box, the player must complete a series of five puzzles, increasing in difficulty, in order to escape the box. Initially, the player spawns within a 'waiting room', where there are elevator-style doors to allow the player into the puzzle room. The player must complete the puzzle, before the doors will open to allow them back into the waiting room.

Puzzles include: matching coloured boxes to their corresponding tiles, shooting a certain number of targets in the allotted time, assembling platforms to collect a gun in order to eliminate cylindrical enemies, a boss fight where you must defeat a cylindrical enemy spawning spacecraft, and finally a combination lock. The first four puzzles each give the player a number. In the final puzzle, the four numbers must be scrambled to determine the correct code, which finally allows the player to exit the puzzle room to an outdoor space, where the game ends.

Within this game, I created systems such as: the player controller including an item interact and basic weapon system, automatic doors which cannot be breached by the player, game logic for 5 puzzles, a comprehensive sound system, enemy AI, and complex player state logic. There is also a settings menu for controls such as volume and haptic feedback intensity.

Unity, C#, Xbox / PC Game

Created in 2019, this was one of my first complete programming projects. It was created using Python and Tkinter. 

The user can generate a random scramble pattern of length between 20 and 50. Additionally, if they are unfamiliar with the notation of the scramble pattern, a separate screen provides clarity. The timer can also be used without a scramble pattern, if the cube has been pre-scrambled or randomly scrambled. Upon starting the timer, the scramble (if present) is hidden from sight to prevent reverse engineering the scramble back to a solved cube. Once the timer has been stopped (upon solving the cube) the time is recorded in a time-sheet, along with the date and time of when this was achieved. This also reveals the scramble pattern, which can be useful if they wanted to replicate or improve upon a particularly good solve. 

The scramble generator also carefully provides a variety of moves, void of inverse movements (which counter-act one another) to ensure that a valid scramble is produced. The minimum bound for the scramble length is 20, since this is the smallest number of unique Rubik's Cube turns required to ensure a complete scramble has been achieved (sometimes referred to as God's number)

The timesheet data is saved upon exiting the program, meaning the user can return to find their timesheet and averages intact. The statistics calculator conveys to the player their best solve time, average of 3, average of 5 and overall average solve time. The timesheet can also be erased in-application if the user desires a fresh start.

I created this at the age of 17 as an offline solution to online Rubik's Cube solve timers which I had used previously. It includes all of the regular functionality which is expected of a Rubik's Cube solve timer, with the addition of providing the notation for beginners or those unaccustomed to speed-solving. 

Python / Tinkter, Windows Executable Application