Battle of Mustafar

VR, Agile Group Project, Spatial Audio, HLSL shaders, Fmod, C#, Eye Tracking  Made with Unity
Group Role: Game play Programmer & 3D Artist 
Showcased at develop Brighton 2019

Battle of Mustafar is a wave survival game where the player must survive waves of drones by deflecting blaster bolts back at the attacking drones.

The drones in this game were trained with a genetic algorithm used to avoid objects 
A genetic Algorithm was used for the drones AI for movement and and avoidance of objects.

Spatial Skydiving

Networked With Spatial OS , Ray marching shaders, HLSL, Fmod, C#, Made with Unity

Spatial skydiving is a game where players compete to get the highest score by flying by skydiving in a procedurally generated environment.

The motives for this project was to learn a new and upcoming networking architecture, further develop my shader programming skills, 3D modelling skills and to combine these learnings into a functioning multiplayer game.

 Totally Realistic Racing

VR, Splines, Run time Mesh Generation & Deformation, Spatial audio, Fmod, C#, Made with Unity 
Awarded with Best undergraduate Games Project 

Totally Realistic Racing is based on creating a slot car racing track in VR .
The track pieces can be manipulated by grabbing each end and moving them around this then uses cubic bézier curves to define the path of the track piece as well as defining a path for the race cars to follow.
this then allows for a mesh to be created along the path bases upon a predefined shape to extrude along the path.

The player can also decorate the track with re-sizeable objects such as buildings, trees and coloured blocks  to make the track look more interesting.

Once the player is happy with their track they can then start a race where the player controls the blue car's throttle with the controller trigger. all the steering is done by AI. car is going too fast round a corner it will spin out and will be over taken if going too slow. 

Shinobi Swipe

Android, Agile Group Project, Inverse kinematics, C#, Made with Unity
Group Role:  Lead Programmer

Shinobi Swipe is a one on one fighter game where the player needs to defeat the opponent before being defeated themselves. As based on the name, rather than pressing buttons to perform different moves the player swipes.

To reduce the complexity of the game and having lots of swipes, the screen is divided across the body of the shinobi. This allows for the top half to register swipes that control the hands, and the bottom half to control the feet. 

Each section has three different swipes. A swipe up and right, a swipe down and right and a swipe right. 
These performs moves relevant to the swipe.
For example, a swipe right on the top half of the screen performs a high punch aimed at the enemy’s head.   


Spire

VR, Dungeon Crawler, Agile Group Project, Spatial Audio, Fmod, C#, Made with Unity
Group Role: Team Leader, Lead Programmer & Designer
Showcased at Develop Brighton 2018

Spire is a VR game where the player has to clear each room to progress to the next room, this can be done solving a puzzle or defeating all the skeletons on the current floor.
The end goal of the game is at the top of the tower where the skeleton king resides, once the skeleton king is defeated the player unlocks an endless mode with the skeleton kings crown. 


Aquatic Rush

Android, Endless Swimmer, Agile Group Project, Google Play Networked High Scores, C#, Made with Unity
Group Role: Team Leader & Lead Programmer

Aquatic Rush is an endless swimmer where the player controls a fish to eat as many other fish while avoiding hazards and swimming away from the chasing net.

The Speed of the player fish is determined by how the player is shaking their phone, this is done by detecting spikes of acceleration from the accelerometer. This emulates the waggling motion of a fish.
The player then can steer the fish by tilting the device from side to side.

Once the player dies or is caught, their score can be uploaded to a networked high score list to see how they compare to other players.     


 Cat Attack

Networked Asymmetric FPS, Photon networking, Agile Group Project, C#, Made with Unity
Group Role: Team Leader , game play Programmer &  3D Animator 

Cat Attack Is an Asymmetric Multiplayer FPS where the mice have to bring all the cheese back to their nest while the cat has to kill the mice or defend the cheese from the mice before the timer runs out.
The cat and mice each have their own characteristics and abilities.
The mice move around slower than the cat but can hide in small nooks, have a small jump and climb on the walls and ceiling.
Whereas the cat can move around fast sprint for extra speed and jump very high.  
There are as many rounds as there are players so that each player can play as the cat.
To allow the can and mice to find / avoid each other periodically the mice will squeak and cat will meow and through the spatial audio will be able to locate or avoid each other .  
For game balance each playing mouse increases the amount of cheese required to collect. 
  

AGS RACER

Network Multiplayer, UNet, Web-sockets, Split Screen, procedurally Generated, Racing, C#, python, Keras, Convolutional neural networks, Playstation 4, PC, Made with Unity 

Showcased at develop Brighton 2017


My idea behind creating AGS Racer was t o make a racing game where no player knows what track layout will be, as usually in a racing game you need to learn a track to know what to expect.


The race track consists of a starting line , a finish line and an assortment of track pieces. 

Each piece of the track I modelled in 3DS MAX to create prefabs with a defined curvature going left, right, up, down and straight.These  track pieces are then automatically aligned based on alignment nodes defining the start and end of each part.   


The following code shows the process of choosing creating the parts of the race track so that the direction is biased to avoid the track intersecting with itself excluding the starting and finishing line.  



 void CreateParts ()

 {

  Transform endPoint;

  Transform startPoint;


  trackDirection = Vector3.zero;

  int randomTrackNum;


 if (Currentpart < trackLength - 1) {


   endPoint = Track [Currentpart - 1].transform.Find ( "End" ).transform;


   do { // when creating new part check trackpartprefabs direction if direction is to larger try new track part

    randomTrackNum = Random .Range (0, TrackPartPrefab.Length); //creates a random number

   } while  

    (trackDirection.x + TrackPartPrefab [randomTrackNum].angle.x > maxangle ||
trackDirection.x + TrackPartPrefab [randomTrackNum].angle.x < -maxangle ||

     trackDirection.y + TrackPartPrefab [randomTrackNum].angle.y > maxangle ||
 trackDirection.y + TrackPartPrefab [randomTrackNum].angle.y < -maxangle ||

     trackDirection.z + TrackPartPrefab [randomTrackNum].angle.z > maxangle ||
 trackDirection.z + TrackPartPrefab [randomTrackNum].angle.z < -maxangle);

   //end of do while loop conditions


   trackDirection += TrackPartPrefab [randomTrackNum].angle; // sets new track direction  

   startPoint = TrackPartPrefab [randomTrackNum].part.transform.Find ( "Start" ).transform; // sets the start point of the current track piece

 

    //Instantiates track part in the end point position of the previous track object

   Track [Currentpart] = Instantiate (TrackPartPrefab [randomTrackNum].part,
 endPoint.position, endPoint.rotation, StartingPoint.transform)
as GameObject ;


   Track [Currentpart].transform.Translate (-startPoint.position);

   Currentpart++;


  } else if (Currentpart == trackLength - 1) 

  {

   built = true ;

   buildingtrack = false ;

   BuildTrack ();

  }   

 }



During the time I took this game to display at the Kingston University booth during 2017 Brighton develop Conference, I learnt about PID controllers and realised that it would improve how the racers hovered above the track by reducing hover oscillation, so by the next day I had researched and implemented the following code.     


[SerializeField] private float PIDproportion = 1;     //initial force

[SerializeField] private float PIDintegral = 0;       //time taken

[SerializeField] private float PIDderivative = 0.1f; //damper


private float previousError;

private float P, I, D;


float PIDoutput( float currentError, float DeltaTime)

{

        P = currentError;

        I += P * DeltaTime;

        D = (P - previousError) / DeltaTime;

        previousError = currentError;

        return (P * PIDproportion + I * PIDintegral + D * PIDderivative);

}




Neural Network AI addition


A 2D convolutional network was trained using 38,000 images with controller inputs and time stamps. 


the ai works by having unity send a picture of what the car sees to a python server via web-sockets, this then uses a 2D convolutional neural network to evaluate the picture and send inputs back to unity. The neural network used in this video was created from 30 minutes of gameplay


PeaceMan Pat

FPS,Group Project, Game Jam Winner, C#, Made with Unity

The concept of this game was designed to fit around the theme of armistice.
In this game the player goes around 'informing' the uninformed armies of red and blue to stop fighting as otherwise the armies will eventually kill each other.   

My role in Peaceman Pat was to implement the movement of the player , the 'distribution' (shooting) mechanics of the notice and how the notice would interact with the world and the AI.



Ravenous Cities

RTS, Group Project, Blueprints, Made with Unreal Engine 4

In Ravenous Cities, the player has to be the last surviving city from a group of 100 other cities.
this is done by choosing modules to expand the city e.g. engines, turrets, housing, scavenging and shields, as well as navigating the landscape to avoid slowing down in lakes or sand pits , or choosing to scavenge these areas for more resources.   

My role in Ravenous Cities was to procedurally generate the terrain via instances and simplex noise, implement the movement system of all the cities, including how the cities  interact with the terrain. I also created all the 3D models and textures in this game.


Gold Runner

3D Platformer, Made entirely from C++

Gold Runner is a 3D platformer where the player has to collect all the gold on the level to progress to the next level. To successfully  collect all the gold in each level the player has to avoid spiky projectiles shot from a pursuing death sphere, while jumping off platforms and walls. 



Glider Flight

2D Arcade,Custom Physics, NACA air-foil, Made entirely from C++ 

The objective of glider flight is to launch, fly and redesign the gliders wing to get high scores in  Maximum altitude and maximum distance.




After the player has launched the glider they can then guide the glider to collect power-ups that increase lift and speed while also avoiding the hazards which slow the glider down or decrease the lift 

 

After the player lands they then have the chance to either retry with the same air-foil design or create a new air-foil using NACA  standards.
 
The following code shows the process of calculating the x and y coordinates required to draw a 4 Digit series NACA  air-foil 
 // calculates the X coordinates of the air-foils points
for (int i = 1; i < loops; i++)
 {
  X[i] = (1 - cos(((i - 1) * 90 / loops - 1)* 3.14 / 180));
 }

 for (int i = 1; i < loops - 1; i++)
 {
 // calculates the thickness of the air-foil based upon the thickness variable and x position
  Y_T[i] = (thickness / 0.2)*((0.2969*pow(X[i], 0.5)) - (0.16*X[i]) - (0.3516*(pow(X[i], 2))+ (0.2843*(pow(X[i], 3))) - (0.1015*(pow(X[i], 4))));

  // calculates the camber location and camber intensity of the air-foil 
   Y_C[i] = (camber / (pow(camberlocation / 10, 2)))*((2 * (camberlocation/10 )*X[i]) -pow(X[i], 2));

// stores the Y coordinates for the upper and lower lines of the air-foil
  upper[i] = (Y_C[i] + Y_T[i]);
  lower[i] = (Y_C[i] - Y_T[i]);


 }

Light Rider 2D

Endless runner, single and multiplayer, AI, Made entirely from C++

Light Rider 2D is a top down  tron like game where the player has to survive to progress to the next round , and trap other ships to gain points.


 


Share by: