The stage is yours, make it a killer performance...
But don't do anything too flashy!
This project was a submission for the Global Game Jam 2023 Theme "Roots". Developed in the Unity Engine using C#, I served as the programmer for this project.
Mechanics
Impress the band, but don't bore the audience!
As the bassist for the band you have been given one job - play the Root Notes!
But the audience will get bored quickly, try to add more flair without angering the band!
Source Code
Below is some excerpts of the project's source code, highlighting the main mechanic, as well as how songs were properly implemented, and the demonstration of the Observer Pattern. The system for receiving and reading note data was implemented using the "drywetmidi" plugin for Unity from Melanchall, which reads notes from Midi files and creates timestamps based on their placement.
When implementing the Rhythm mechanics, communication between myself and the sound designer was important to understanding what was required on both fronts. This could then be tied to the overall gameplay loop and how data is transferred via the Observer Pattern. Overall this project was beneficial as it helped to explore the potential of design patterns and how they may be used within projects to make code clear, concise and more efficient. The rest of the source code can be found via the Github link below.
Fight your way through treacherous depths, in an ever-shifting labyrinth..
This project was developed as part of the Mastered Bootcamp using the Unity Engine and C#. Gameplay Programming, UI Programming, 3D Modelling of dungeon room pieces were handled by me.
Mechanics
Overcome the odds, explore the changing halls!
You suddenly find yourself trapped in an unknown labyrinth, with an enchantment placed that shifts the halls!
Choose your class, determine your strengths yourself or by chance, and fight fierce monsters as you fight to escape!
Source Code
Below are some of the excerpts of the game's source code, focusing primarily on the foundation of the player stats, how they were determined (Along with associated ability modifiers) in addition to how the player's abilities function. The prime focus of this project was a stat-driven game drawing inspiration from Dungeons & Dragons (D&D), and other Tabletop games. As well as this, the project implements concepts such as Procedural Generation, State Machines and Design Patterns.
Working on this project allowed me to apply some of what I already knew regarding RPG-style systems within a 3D space once again, while simultaneously improving on aspects that I felt were lacking or inefficient in previous projects, such as progression systems, abilities and so on. Exploring stat-driven experiences gave an insight into how the player's experience can be affected at the smallest level, still influencing the overall impact on their enjoyment of the game. Systems and mechanics were implemented in a way that was cleaner compared to previously, making them easier to adjust and refactor where necessary. However some features were cut and scaled down as a result of time constraints, and some aspects of the player's stats were not explored to the fullest degree. If you wish to see the rest of the source code, it is available via Github.
Looks like the night is not so silent after all...
This project was a submission for the Game Dev Network's Big Festive Jam 2022 theme "Exponential Possibilities". Developed in the Unity Engine using C#, I served as the Programmer and Level Designer for this project.
Mechanics
The more you carry, the more you worry!
Stealing presents is the name of the game, and they can be found all over the rooftops, but be careful!
​
Too many presents will begin to slow you down, giving the elves less work to do taking them back!
.png)
.png)
Source Code
Below is the source code for the main mechanic, movement mechanics, and the underlying structure for the AI. This project allowed for a somewhat thorough exploration of how scriptable objects may be used for AI behaviours, which may also be used as a source of inspiration for handling player actions.
My mindset behind taking part in this project was wanting to explore alternative implementations for AI enemies which were flexible and could allow for complex behaviours. Learning and applying this particular use case for scriptable objects helped to deepen my understanding of how they can be used in different ways, and made it possible for behaviours to be tweaked and adjusted in a way where it was decoupled from much of the logic. It also provided the opportunity to explore new movement mechanics and how they can be impacted by other systems, primarily the main mechanic. The rest of the source code can be found via the Github link below.
Fend off a threat from beyond.
This project was developed using Unity and C# as part of my dissertation for University, drawing inspiration from Destiny 2, Lost Ark, Star Wars: Galaxies and other FPS and MMO titles. Programming, UI Design, and Level Design were all handled by me.
Mechanics
Two Class Systems
Overcome challenges with the help of two class systems - Simple and Dynamic. Master the agile and nimble movement of the Simple Class for platforming ease and evasion, and master the power of the Dynamic Class to easily overpower your enemies. Change between these at will for flexibility in combat!
Upgrades
Not all tools will be fit for every job. Earn upgrade points from enemies to unlock different options across both classes. From more movement options for platforming challenges, to different additions to your combat arsenal. Mix and match to get the best use of these and bring down your enemies with ease!
Source Code
Below is the source code for the Class Systems, which are the main focus of this project. This provides a breakdown of how these would function in gameplay, from detecting inputs to triggering specific actions or abilities. This served to expand my understanding of such systems further from what I already knew at this stage, exploring different gameplay abilities and how the player may use them. I was able to sufficiently implement these features within the time given for this project, with them functioning and responding as intended; such as spawning projectiles, displaying important information to the player, and activating other abilities that are important to gameplay. However, the overall structure and length of the implementation could be improved, such as designating timer checks to methods that return boolean values, dividing information into sections rather than have a singular text value/string, and so on. The rest of the source code is available via the Github link below.
The Sirius Faction is leading a machine uprising, and only you can stop them! Fight, and grow strong and mighty enough to overcome them and save everyone!
This was a personal project I developed in my spare time during the Summer of 2021, using the Unity Engine and C#. Programming, Level Design, 2D Art and Sound Design were handled by me.
Mechanics
A little robot with a BIG punch
Although a defective Sirius prototype, the modifications made make you a force not to be underestimated. Use a variety of different moves in a branching combat system to take down enemies, remove obstacles, and more as you explore levels and fight against the Sirius Faction!
Upgrades
Although mighty, even some upgrades are necessary. Power-up moves, buy new ones, or increase survivability with upgrade points dropped from enemies!
Source Code
Below is the source code for the player upgrade system, in addition to elements of the player input, such as locomotion, as well as inputs for attacks and interactions with the upgrade system. Development of this project was spurred by the desire to explore Action Game style upgrade systems within a 2D platformer, as well as action game mechanics. This also served as an initial exploration of Scriptable Objects. They served well as a basis for the upgrade system; providing the structure for how such data is stored and accessed, however my understanding of them at this stage meant that they were not used to their fullest potential. My progression since this project has allowed for better practices with overall code structure and organisation, in addition to getting a better grasp on how scriptable objects may be used. If you wish to see the rest of the source code, it is available via the Github link below.
Explore the impact that your words have on the world around you, and change the story!
Developed in Unity and C# as part of a Second Year University Group Project according to a brief. Serving as the lead programmer, I was responsible for programming the main "Words" mechanic, as well as basic movement, UI, and working with designers to implement level designs.
Mechanics
Words... but with impact
All words can impact things, people and so on, but what if that was literal?
Use different words to solve puzzles, navigate the level environment and explore the pages of a storybook
Source Code
Below is an excerpt of the source code showcasing elements of the Word object, general object scripts, and examples of object effects after having words thrown. The purpose behind the project was to develop a game where words were or part of the main mechanic, which is evident in the code presented here. However, while the code functioned well and served it's purpose at the time - providing interactions between the player and elements of the environment in order to progress - the approach for the implementation could be improved via the use of interfaces, as well as eliminating the need for inheriting all boolean flags in each object and making them specific to their respective object types. The rest of the source code can be found via the Github link below.
Uncover the secrets of the past..
This project was developed using Unity and C# as part of a Final Year University group project according to a brief. Serving as the programmer, I was responsible for UI programming, programming puzzle mechanics and a branching dialogue system.
Mechanics
Solve the puzzling mystery of your past
You awake with no memory of who you are. Solve physics-based puzzles and explore a branching narrative as you work to rediscover your identity!
Source Code
Below are excerpts of the source code, demonstrating the player's grab mechanics, interactions with a pressure plate object, in addition to insight into the structure of the dialogue system. When developing this project, we had discussed blending puzzle-based gameplay with a comedic narrative that offered different dialogue pathways and endings. This project allowed me to explore one way such a system could be implemented from scratch, however due to the time taken to develop the system as well as constraints, the physics puzzles weren't explored in their entirety. The rest of the source code can be found via the Github link below.
About Thomas Shadforth
Hello! I'm a Gameplay Programmer with a degree in Computer Games Development working primarily in Unity and C#, and I'm passionate about games! I like to explore different gameplay styles and mechanics, how they operate in isolation, and understanding how they work together to affect a player's gameplay experience.
My aim is to produce engaging experiences through exploration of mechanics, and I am always exploring new techniques in order to apply them.
Demo Reel
Here is a snippet of some of my projects! You can find them and more in the projects tab!
My skills and tools include...
Below is my CV, or you can click the button to download a copy of it!