This was my first third year project were I was tasked to take a simulation, where lots of objects are colliding in a small place, and optimise it so it runs consistently at an acceptable FPS.  It required me to implement thread pools and region based broad face collision. I also implemented some memory optimisation and debugging tools with a memory tracker that looked at headers and footers in the objects. I made stack canaries and a memory pool for the objects to be assigned into with a class specific operator new (or malloc). 

I learnt a lot on how  optimise a program and that it boils down to transfer and access of memory at run time.  Furthermore, it is how quickly you can use that data so learning about multi-threading  a program was really beneficial. And then learning that it has an overhead to spool them a run time, so improving it my implementing a thread pool. 

This module was quite heavy in self research compared to previous years as we were given very little support and no code in the seminars. This led to it being fully researched and implemented by myself, and this felt very rewarding as I could see my skills I had learnt and developed throughout my degree coming in life. 

The simulation ended up being able to withstand10,000 objects across 8 regions while maintaining 60 FPS. I also know it could handle it at 128 regions and threads (while not as efficient to run, did show the strength of the memory optimisations).

This project also required us to port the simulation and optimise it on a PlayStation5. This meant implementing platform specific threads and vectors to optimise the code for multiple devices. A there is very little documentation for ps5 development, I learnt a lot on how to use platform specific implementation for that platform allowing for other platforms to also be incorporated by encapsulating the code specific to that platform.  I can not show any of this as it is under Sony's NDA. I achieved a first in this module.

GitHub link:

LowLevelOptimisation  

This was my second semester in third year along side completing my dissertation. The project involved creating three different scenes which each implemented a different algorithm. 

The first was a minimax algorithm for a chess AI. This meant valuing each piece and potential moves which could then score potential boards and applying an algorithm that plays the best potential move looking a certain amount of moves ahead. I also implemented a playbook for generic opening in chess like scholar's mate and how to avoid it.

The next scene involved implementing MARPO and GOAP to units to make a house. This meant having a queue so tasks and using dependency tasks to get to an overall goal and make a human like unit that thinks for itself. it also required a reactive queue so if the unit drops below a certain amount of health then it will heal itself before continuing. I also implemented a small pathfinding implementation to avoid moving through water as it requires more health to do so. I also used a similar algorithm where if the user wants to build a house on water then it will find the closest land tile and build it there.

The last scene was creating a genetic algorithm to evolve a space ship over time with different crossover types and selection types to converge on ana ideal flight path. The goal was to create a swarm algorithm where the units try to find an optimal way of landing on a platform. Then, at the end of a simulation, score them and use a selection algorithm to pick the better ones and cross over their flight paths and make a more optimal child one. 

Overall this project was very fun and one of my favourites I did throughout my university journey. I learnt a lot about standards of AI in industry and what is currently good decision making algorithms. I also learnt to plan for games where you are coding someone who is not the player. In chess it was a very different skill set to understand how the turn I was programming was performed by someone who wasn't the player and how to predict what the player will do and I achieved a first in this module.

GitHub link:

AdvancedAI  

This project was developed in my third semester of my second year at university. It required me to make a VR project, taking into consideration a lot of different user interactions and UI types. I made a carnival that requires you to shoot balloons, throw balls at coconuts and hook ducks. There were prizes given out based on how well you did. Prizes included models, AI moving cars, animated dragons and many others. There was also UI that displayed how many of the prizes the player currently has and a question marked out image for the ones not got. 

I learnt a lot on how to think in terms of the player and how to tailor an experience to the device the player is using. VR is a very different experience to regular PC and the interactions you want should be tailored to them, and this module taught me how to plan for these and later develop them. I also learnt how collision differs in hand held items for VR and how to track rotations and collisions of a held object. It also was a full experience project that I was very proud of that achieved me a first.

GitHub link:

VR Carnival 

This project was part of my third semester in my first year. I was tasked with creating a game for an evacade machine. This meant creating a game in SDL 1 that then got ported using ubuntu to the hand held device. This meant making an update loop that worked in 16 frames per second and creating a game which responds to different controls. The game consists of the player going through three "beat-em-up" levels which when reaching the far right end of the level, it takes you to the next floor. There is a boss at the end that requires pick ups found throughout the level to get stronger to beat. The boxes are also destroyable and drop a random item, either health, ammo or nothing.

I learnt an incredible amount in this module. It was my first back end module rather than using an engine, and I learnt a lot about how to debug and how to program. I developed my skills in debugging by understanding how to methodically go through problems with break points. I also learnt how to do animations with key frames to show movement and direction and attacks. I also had to use Linux to port the game so I learnt how to do basics within Linux. The project was very difficult but very fun and overall I got a first in the module.

GitHub link:

Trouble at Tyrant Technology 

This project was in my second semester of second year. It entailed me learning different steering behaviors, different pathing systems and different ways to do decision making. The video explains what each scene within Unity does and what it is showcasing.

Throughout this module I consistently learnt new techniques and new pathing algorithms. There was a lot of mathematics involved in pushing the unit to the desired facing direction with rotational forces. However, the main focus was in the decision making, where enemy pirate ships spawn in over-time and the 2 player ships will need to decide whether to attack, run away or seek for a health pick up or ammo pick up. 

This was originally done in a finite state machine where if an enemy was in range of the ship, they will attack and if they had less than 3 health they would seek for a health pack. However, as it advanced, I turned it into a fuzzy state machine which allowed for a constant wonder movement behavior to be active so all the movement felt random. If the health dropped low it would evade the enemies as well as seek the health pick up. I also made a sonar that if the other player's ship was being attacked within the range of the sonar, then the ship would go and help out so they win the fight easier. 

Overall, my different AI systems achieved a first and the audio explained video helps showcase all the different scenes and I learnt a lot about how AI works within games.

GitHub link:

AI showcase 

This project was in my first semester of second year. It required me to use hlsl to code shaders to create an application that displayed a window with lighting and objects. 

The objects displayed are all then moved and made to rotate in different ways. The plane is alpha blended to make it look translucent and you can see through it. The camera is able to move by changing the eye location and then changing all the objects locations around it. There is a sunlight that lights everything from behind the camera and when swapping between the four different cameras, it displays the shadows on the back of the objects. There is also a point light that has a lerp to change the light intensity to fall off around a point. The camera and light variables are all written in JSON and then read at run time to be created. The car and plane are OBJs and are drawn through an OBJ loader. 

I then made a skybox by creating a really large cube with a texture showing inwards. It has its own shader so it isn't cleared when everything is set to a Z depth of 1. The ground is also procedurally generated by reading an image and translating it into a height for each point on a grid, and then blending a texture across levels between certain Y levels with a lerp. 

I learnt how to program shaders and as it was my first time using DirectX, I learnt how graphics are calculated within games. Overall for this I achieved a first.

GitHub link:

DirectX 11 Showcase 

This project was in my first semester of second year. It required me to make a game that was multiplayer across a network. This meant sending packets that were translated into JSON and encrypted before being received by a server. The server would then update the other players game by sending another packet out to them with the required information.

I made a basic 2D tank game that when one player moves, it would send a packet to the server and update the location to all other players. There would also be an animation of it's facing direction that would use dead reconning to only send a packet when the direction changed, so it could be sent to all players to update on their screen. This would synchronise the games. 

I also made a lobby system which functions by sending query packets to the server asking for lobby size and current player amount in each lobby. If a player joins a lobby, they are assigned their player number. If a person moves or shoots a bullet within that lobby then it would synchronise in only that lobby.  If any player was hit with the ball then they would die.

I learnt how to use Monogame and use an extensive code base with components and how to apply them to certain objects, as well as how to make physics materials to use on different objects. I also learnt different ways to avoid deadlock and shared materials struggling to be used or being used at the same time with semaphores and locks. Overall I achieved a first in this module.

GitHub link:

Multiplayer Tank Showcase