Portfolio

About

I recently completed a Level 7 Diploma (equivalent to a masters) in Game Development for Computer Gaming (awarded by City & Guilds) through a home learning provider, where I achieved a Distinction overall. I’ve developed skills within the C++ programming language from memory management, event systems (utilising callbacks to objects), processing systems to inheritance, including polymorphism through virtual methods. I’ve also integrated third party solutions such as Bullet Physics and SFML. Other more general fields covered include file serialisation (e.g. Text, CSV and XML file parsing), path finding, collision and tree structure optimisations (binary/quad/oc trees).

I’ve learned core shader programming through HLSL and the Direct3D 9 API, producing shaders capable of ambient, diffuse and specular (phong) highlighting, normal mapping, directional and point light generation, post processing, particle effects and shadow volume generation. I’ve gained an understanding of the Unity3D engine and its C# based scripting language, which includes the use of templating and inheritance to generate unified singleton objects, along with a consistent state manager to transition scenes through a single function call.

Before I started my course with Train2Game, I studied at The Mirfield Free Grammar & Sixth Form (GCSE and A-Level). During my time there I would say my overall favourite subject was Design Technology – 3D Design. Something I will always take from this subject is the importance of research, and its ability to expand into great concepts/designs which surpass the original concepts/design. The course also showed me how to take a criteria (for a product/idea) and develop it. These are both things I believe transfer greatly into my current course.

I was fortunate enough to gain some work experience in QA/Gameplay testing at Sumo Digital on their title 'Sonic & All-Star Racing: Transformed' for a total of five weeks, which resulted in my name appearing in the games credits!

3D Design

Haste Blackjack

Haste Blackjack’s AI uses a pseudo random number generator to decide what the cards should total before the AI 'sticks'. This simple logic gives a realistic choice that the user may have picked themselves. The AI doesn't utilise the players cards to make a decision (i.e. Cards are invisible to the computer).

The game should run on Windows XP and above. Visual Studio 2008 Redistributable will be required to run it.

The Adventures Of Pedro

The Adventures Of Pedro is a re-make of my original Section 2 portfolio projects. The project allowed me to establish dramatic improvements in my programming abilities when compared to the original project. I regard the Adventures Of Pedro as my first feature rich game, containing nine levels, various enemy types and multiple interactive props, all providing unique challenges throughout the levels. I wrote the game using C++ and DirectDraw.

The game should run on Windows XP and above. Visual Studio 2008 Redistributable will be required to run it.

Vorb Breaker - Highscore Server

I originally produced a networked (HTTP / TCP / Sockets) C++ program that allowed me to host an online highscore with my own machine; however, I soon found that leaving my own machine constantly switched on would be costly overtime and also wasteful given the low traffic expected from the system.

I transitioned into using a PHP script that could run on any basic web hosting service that supports PHP (i.e. server side computation). The script works by accepting score information through the URL; however, URL’s only support a limited character set, so the system on the clients side converts the score information into numeric characters (0 to 9), ready for the server side script to convert back into readable text.

A simple ‘XOR’ encryption/decryption system is also used. The script returns information to the client through basic ‘echo’ calls.

The Adventures Of Pedro: Robots Vs. Slime

I produced this game as part of my Section 3A portfolio project, which required me to produce my first 3D game within C++ and Direct3D 9 (fixed function pipeline). The game itself requires the player to control the robot character from one end of the room to the next, avoiding collision with the slime characters. Additional slime characters are added on each new level, providing a simple but consistent difficulty curve.

The game should run on Windows XP and above. Visual Studio 2008 Redistributable will be required to run it.

Vorb Breaker

Vorb Breaker is a commercial project based on the classic 2D brick breaking game. Created with C++ code using Marmalade SDK, Vorb Breaker encompasses a unique power up/weapons system (including an upgrade ability), touch screen/accelerometer controls, 170 levels (extendible by users) and an online highscore table (created through socket programming and PHP).

The programming, artwork and majority of levels were created by me. Paint.net was used for the 2D artwork. The game requires an Android phone (Version 2.3 and above), and comes packaged as a ‘Lite’ or ‘Full’ version.

Mosync

I decided to trial a new C++ cross-platform compiler for mobile devices called MoSync SDK. The result was a simple application that involves clicking a randomly positioned node within a grid of multiple nodes. I subsequently compiled the application to Android.

Sonic & All Stars Racing: Transformed

Between the 2nd July 2012 and the 20th July 2012, I volunteered to work at Sumo Digital as part of a new temporary team with the primary goal of helping to balance the game. My role comprised of giving opinions on my initial impressions of the game, such as what I liked, what I didn't like and any issues, complications or confusions I had etc.

My core time spent at Sumo Digital involved playing levels multiple times using Excel to record my lap times, allowing the mass data of the team to be collected and reviewed. These play tests had to be done to schedule and also required a questionnaire to be filled in after playing through each level five times.

Naturally any bugs, crashes, errors found during play testing were reported directly to the QA team. I also got an opportunity to participate within a design aspect of the game (though I don't believe our combined ideas made it into the game). I also got the opportunity to talk to one of the Sumo Digital programmers, who gave me general advise as well as talking me through one of his assigned tasks, which I'm pleased to say I could follow along with.

Between the 17th September and 30th September, I was asked to return to Sumo Digital to help out on a new balancing team; however, this time the role involved a much more QA based role, as the tasks presented often involved testing specific levels for bugs, again to a strict schedule.

Client:
Dale Haste

Date:
September 2012

Service:
Q/A, Play Testing

Valentines Day App

I decided to create my better half an Android app for Valentine’s Day (2014). It took three weeks to make (would have been two without the server synchronisation!) and was fortunately well received. The app gave me a great opportunity to trial the cross platform 'compiler' called Cocos2d-X, which allowed me to compile to Android using C++.

The app allows one 'heart' per day to be opened (a heart can range from a picture to a 'spendable' token to even a personal message). The hearts are selected at random and will stack if several days are missed.

The server side code is written within PHP, allowing me to use a standard website hosting service, and making the HTTP system provided within Cocos2d-X a viable option. The server provides a back up of all opened hearts as well as allowing simple synchronisation between different devices (knowing a phone upgrade was highly likely in this same year).

Client:
Dale Haste

Date:
February 2014

Service:
C++, Cocos2d-x

Dirt Maze

I developed Dirt Maze in preparation for my final City & Guilds projects. The project focuses mostly on graphics programming (HLSL), but also incorporates many gameplay related concepts (i.e. path finding, collision etc.).

The initial code consisted of code from my course; however, I soon extensively modified and extended the code, providing large optimisations, bug fixes and improved design in many places. I also replaced all existing HLSL shaders with my own. This includes shaders for ambient, diffuse and specular lighting, as well as normal mapping and skinned meshes. The UI bars are controlled via a shader.

Particle Effects

Fire

Smoke

Sparks

Dirt Trails

Leaf Emitter

Mud Emitter

Cloud Burst

Bullet Cloud Stream

Post-Processing

Blur

Greyscale / Black & White

Fade In/Out

All post-processing effects are capable of running alongside each other. The game utilises my own level loading system, which in short procedurally generates entire levels based on level designs produced within MS Excel (converted to the .CSV format). Most of the models were created by me using Blender3D and its DirectX (.x) exporter. I downloaded the 'Pig' model (with permission, special thanks to Colin Lover!), where I UV mapped, rigged and animated it to produce a walking animation.

The game should run on Windows 7 and above. The Visual Studio 2012 Redistributable will be required to run it.

Dirt Maze - 3D Environment

The original Dirt Maze game produces its levels using a 2D spreadsheet; however, this update utilises the same 'engine' in order to produce levels from a modelled 3D environment (though it's missing enemies and other gameplay elements in this version). To do this I created code that provided polygon collision against sphere and line objects, making it simple to keep my sphere player object inside the 3D scene.

Polygon collision detection is highly expensive, so I optimised the system using an octree that basically places polygons into a positional hierarchy, so that only collision testing takes place against objects within the close vicinity.

I also implemented code that forced the viewing camera to remain inside the playing environment (utilises the new collision system). I created the 3D environment within Blender3D using its DirectX (.x) exporter. The 3D environment allows for much more diverse levels.

The game should run on Windows 7 and above. Visual Studio 2012 Redistributable will be required to run it.

Exo

EXO was a team project consisting of:

Myself - Lead Developer

Sean Kelly - Team Captain & Developer

Abdul Yasir – Designer

David Gunner Jnr – Developer

Justin Mills - Artist & Animator

EXO was created as preparation for the T2G Game Jam 2014, allowing the team to become familiar with each other and the software required. Unity has been chosen as the game engine due to its rapid development capabilities and short learning curve. Prior to this I had next to no experience with Unity, but the transition to UnityScript (i.e. 'C#') from C++ was very smooth!

Trapped

The team created Trapped within 48 hours at the T2G Game Jam 2014 using Unity3D as the engine of choice.

Myself - Lead Developer

Sean Kelly - Team Captain & Developer

Abdul Yasir – Designer

David Gunner Jnr – Developer

Justin Mills - Artist & Animator

All scripts were written using UnityScript (i.e. 'C#') during the 48 hour jam (except for the state manager). Unfortunately the game is still fairly incomplete. Due to time restraints across the team, the project is unlikely to become fully complete.

Tileshifter & Perforce (Deprecated)

Tileshifter is an open source mobile game project created using Cocos2d-x. It was created within a small team. The project originally utilised Perforce as its source control (hosted by Assembla); however, it was moved onto Git (hosted by BitBucket). The visuals shown display the game during its ‘early alpha’ stage and are very much out of date.

SVN & Batch Script

I decided to trial SVN (using a local Tortoise SVN repository) for the first of my final City & Guilds projects. I found SVN to be similar to Perforce and generally simple to use.

I found that performing backups for the repository should be done using a specific utility for SVN, preventing its corruption during a backup. The backup utility is activated through the command prompt, so I opted for a one click solution using my own batch script.

The script appends a counter on every run (prevents overwriting old backups) and stores the new backup within a numbered folder.

Client:
City & Guilds

Date:
May 2014

Service:
SVN, Batch Script

Asset Builder - Python

As part of my final projects, I needed a way to manage my assets (images, data files, sounds etc.) between development, debug and release directories. To handle this I produced a python script that reads a text file denoting which files need copying from development folders to the debug and release folders.

With this in place I now only had to update the text file when an asset was added/removed and activate the python script.

Git - SourceTree

For my final three City & Guilds projects, I opted to utilise Git for source control using the GUI client known as SourceTree. The repository is hosted through BitBucket. I found it incredibly easy to use, as it mostly ties in with many concepts from SVN and Perforce.

Client:
City & Guilds

Date:
April 2015

Service:
Git, SourceTree

Asset Builder - Batch Script

I found that my original python based asset builder gave the potential for compatibility issues when built on other machines (i.e. python has to be installed for it to work). My solution involved converting the existing python script into a batch script. This batch script is guaranteed to execute on all Windows based machines running Windows 7 and above.

The new asset builder was utilised within the remaining three City & Guilds projects. The script provides a core file that allows unique variations to reuse the same code (i.e. reducing code duplication).

Spherez

Created for my first of four City & Guilds assignments, the game utilises my own C++ and HLSL code. The code is designed to revolve around the idea of game objects, allowing different components to attach to any game object (e.g. rendering, collision etc.) dependent on the individual game objects needs.

An event system provides generic communication between all systems by allowing them to send their specific event messages as well as listen for event messages they're interested in, allowing systems to exist free from the other systems.

I introduced a processing system that allows objects to request execution time, which allows the execution flow to be fully managed and potentially optimised (e.g. many processes may fire once per second, opposed to every frame). The processing system didn't introduce multitasking/threading due to time constraints, though its design should make its introduction simpler.

I wrote a new memory manager that provides memory leak, dangling pointer and buffer overrun detection that often traced back to the source through additional debug information collection. The memory manager assigns a larger block of memory (i.e. a memory pool) that it splits and assigns out as memory requests come through. Returning memory is reassigned to the available block and often expands itself if its neighbouring allocations also return (i.e. they expand into each other).

The project utilises Bullet Physics for its collision detection and Direct3D 9 (with HLSL) for rendering. The HLSL shaders includes ambient, diffuse and specular (phong) highlighting, normal mapping, directional and point lighting, post-processing, particle effects and shadow volumes. I produced a custom text file parser that allowed deriving objects to introduce both CSV and XML parsing through the control of a resource system.

Most models were created by me using Blender3D (exported into the '.x' format).

Deep Sea Diver

Created for my second of four City & Guilds assignments, the assignment utilises an existing game and C++ code base that utilises Direct3D 9 (with HLSL). The objective of the assignment is to make specific improvements to the existing game, including difficulty settings, weapon upgrades, shield capabilities, collision detection improvements (per-bone collision), AI/enemy improvements along with a demo mode and mission briefing.

Client:
City & Guilds

Date:
June 2015

Service:
C++, Direct3D 9, HLSL, Git

Jungle Warrior

Created for my third of four City & Guilds assignments, my objective involved creating a game within Unity3D (with free assets from the asset store as required) based on a supplied technical design document. The game is a first person shooter that utilises the guns laser sight for aiming.

The game utilises Unity's C# based script for all core logic, including a templated base class that unifies all singleton type objects and a state machine system that controls scene transition elegantly.

The Adventures Of Pedro: Robot Asylum

Created for my last of four City & Guilds assignments, my objective was to produce a first person 3D maze game. I decided to utilise my first City & Guilds assignment (Spherez) as the starting point for this one, it uses C++ and Direct3D (HLSL) at its core. The assignment revolves around level design, so I produced my designed levels within an MS Excel spreadsheet, which I could convert into a CSV format.

The CSV formatted level designs meant I could procedurally generate unique 3D levels through the same codebase. I did this by parsing the basic CSV file information into the declared game objects and simply transformed them as depicted by the spreadsheet node requesting them.

The original game (Spherez) allowed the player object to move freely within the 3D world, but the new game needed to lock the player onto invisible ‘rails’ that already existed within the AI systems path finding abilities. I introduced a new path finding type within the AI system that acknowledged the original user input event messages, while enforcing the new ‘railed’ requirement. This solution greatly reduced code duplication that a less flexible codebase may have encountered.

Client:
City & Guilds

Date:
October 2015

Service:
C++, Direct3D 9, HLSL, Git

Tileshifter

Tileshifter is an open source project created within a very small team. The project originally utilised Perforce for source control; however, the project now utilises Git (hosted by BitBucket).

The project is developed between a Windows PC and a Apple Mac, which causes inconsistencies within the Android build process. An ideal solution would be to host a server that builds an Android APK file using the latest codebase; however, this would be expensive.

The alternative solution involved deploying separate virtual machines on both development machines, which although built separately, does unify the builds. Vagrant (which internally utilises VirtualBox) automates the majority of the Android build process.

Happy...?

Warning: Mild jump scares may occur! Created as part of a newly formed team consisting of Myself (Developer), Andrew Wilson (Developer), Chris Taylor (Artist) and Richard Evans (Composer).

Given roughly 40 hours to create (plus a few hours after for further improvements), we managed to produce a short horror game that portrays a story through imagery and music.

The project still requires plenty of polish, but given the time frame, I feel the team achieved a respectable outcome. Please note the 'Space Bar' key is used as the 'action' key, which can be used when the screen displays text.