Hugo Scott-Slade Full Stack & Game Developer

• 
• 
• 
• 

I personally developed the AI in it's entirety.

• Personality based, such as objective-focused or combat-oriented.
• Used an action & priority system which was affected differently for each game mode.
• They can chat and react to other players and other bots using quick chat or the emote system.
• Their 'inputs' were the same as human players, using line-of-sight and the minimap.
• Controlled their characters through a virtual gamepad so they couldn't do any impossible or special behaviours.
• Attract mode for in-person events.
  • The AI could take over an idle machine and show message enticing players to play.
  • A player could take over the controls and being playing an in-progress game immediately.
• Games could run and test themselves using multiple clients indefinitely. Combining this with our bugtracker made it easier to find and fix obscure issues.

The game supports cross-play and cross-progression using shared player accounts. There is also an event system which controls shop content, double xp weekends, etc.

The backend system was built using Gamesparks. Here are some of the features I created:

• Feature planning for UI/UX as well as data structure.
• Account creation forms with client-side verification for gamepad, touch screen and keyboard/mouse.
• Scoped out and briefed an event system which allowed iterative development and future extensibility.
• Built tools to manage backend and game data allowing non-technical team members to operate autonomously.
• Integrated all these features into the game.

Since I was responsible for nearly every single build of the game and the numerous different versions of the game for different scenarios (dev, publisher builds, in-person events, store builds, etc) I had to build a system to help me manage everything.

The base building blocks of my solution were Scripting Define Symbols as they let me discretely manage features as needed. I also used different settings for libraries and assets but that was on a platform-by-platform level was only useful for more general issues (e.g. no Discord integration on Nintendo Switch).

• Created 'Build Definition' objects which contained a list of Scripting Define Symbols with a toggle and a description.
• Setup Build Definitions for each version, e.g: Steam Development, Steam Demo, Steam Beta, Steam Release, Non-Steam PC In-Person Event, etc, etc.
• In-person event builds allowed bypassing external auth and a custom LAN mode since the internet at events is often terrible.
• Integration with Itch.IO's Butler to upload new builds remotely for other team members/my other machines to use.
• Manage publisher/region specific builds.
• PC builds in about 40 seconds since majority of content in Addressables. This allowed rapid iteration and testing of builds.

All these features were made to be simple to use with everything visual in Editor windows.

I was the sole gameplay developer for the project and worked from prototype to release. I was also involved in game design from both a design and technical angle.

Here are some highlights of my work on the project:

• I developed the vehicle physics with a focus on maneuverability and responsiveness.
• 6 playable characters with their own vehicles which handled differently but consistently.
• 3 permanent game modes & some event based ones.
• Many iterations on game modes during prototype stage with a focus on testing quickly with realtime multiplayer.
• Multiple powerups with emergent interactions.
• Behind the scene changes, such as powerup weighting for players to keep games engaging and competitive.

I created a suite of tools extending Unity for creation of the levels. The key features are:

• Modular building creator with different sections & styles.
• Automatically attach windows, doors and other facades based on style (e.g. residential, derelict, etc)
• Place props individually or group with different sets and adjustable randomness.
• Create different surfaces and materials for both visual and gameplay differences.
• Pavement placement by dragging over area.
• Using user defined areas to control lighting and mesh fidelity allowing quick and effective performance optimization.

Meshes generated through this system were cached and re-used across the scene(s) reducing file size. They also supported lightmapping.

Localisation was considered from the very start of the project so I developed a framework alongside the project.

Usage

• Localized strings could be setup directly in Editor and exported out when ready to localise.
• Localized label component using either Unity's Text or TextMeshPro which handled updating text automatically.
• Automatic string creation - either through component or tools to easily convert existing text/prefabs to localisation system.
• Text setup allowed additional format settings allowing simple text substition for dynamic elements such as player name, level, etc
• Font family & style setup allowed automatic font swapping for any language, maintaining custom styles.
• All Left-to-right languages supported. RTL support was not required but could be added.

Import / Export

• Export all existing text as CSV with suitable key/group for organization.
• Import tool using Google Sheets with configurable import map allowing various data setups.
• Generate JSON files if needed for either each language or all combined.
• Additionally it creates files for each language with every unique character to use with TextMeshPro to setup Font assets ahead of time for best performance.
• New localisations added directly into spreadsheet created as reference inside Unity.

Remote Update

Remote update is not a requirement for the framework and can be enabled/disabled at anytime with a new build.

Update with Addressables

If your project uses Unity's Addressables package and is setup for remote updates then you can setup an addressable group and the localization framework will handle downloading the new data and updating your game's text.

Update with URL

A URL can be setup to fetch a JSON file from on every launch. This setup is very simple and supports all platforms.

Tools

I developed many tools for use with this framework for different stages of development.

• Import - update all text using Google Sheet
• Export - take all text in game and export to CSV
• Duplicates - find duplicate text entries and allow removal & replace old instances with new across project.
• Quick setup - convert any prefab/scene to use the localisation framework & create any new/missing strings ready for export.
• Localizer Helper - build of game with option to highlight every visible text field and detail where in localization sheet it is, with copy + paste shortcode for convenience.
• Gibberish mode - Replace your text in editor/build with gibberish to easily find unlocalised strings and test content/font sizing.

I have shipped multiple products using this framework across multiple platforms including desktop, mobile and console.

I built the networking on top of Photon. Here are a few of the key features I added:

• Room codes for easy cross platform play.
• Bot takeover any player which disconnects during a game.
• Minimal data transfer using bitpacking.
• Smooth player rigidbody movement using interpolation and parameters adjusted per player's latency.
• Collision rewind using latency and tracked position for more consistent projectiles + impacts across different connections.
• Quick play - automatically find and join any active game in your region.
• A blend of authoritative host and client-side triggers with host verification.

I was solely responsible for getting the game running in a perfomative way across multiple platforms.

PC

• Game shipped on PC with uncapped framerate option.
• PC game runs on lower-end machines.

Nintendo Switch

• Runs smoothly at 30 FPS in both handheld and docked.
• I ensured minimal patch sizes for updates.
• This version was also released in Japan through a publisher which required a separate build so I created a tool to automate moving between versions.

Other Platforms

Despite not releasing on the these platforms due to other constraints, I have done the necessary work for the following platforms:

MacOS

The game is completely playable on MacOS with 30FPS+ performance with no shader/input/etc issues.

Mobile

I developed full touch screen control support for mobile (bluetooth/mfi controllers also supported) and went through a heavy optimization process.

• The game runs at 30FPS on an iPhone 6S (2015) with a peak runtime memory consumption of 85% of limit.
• Newer iOS and Android models run at 60FPS.

I created the vast majority of in-game and UI effects, including meshes, textures, shaders and platform optimization. I created & shipped many animations and effects either with no design or just description/static images.

• Vehicle shader using color masks, decals and 5 different materials & clearcoat allowing rapid content creation.
• Custom vehicle shader using traditional PBR textures alongside built-in clearcoat of the base shader.
• Boost trails with support for upto 8 attachment points per trail.
• Powerup effects such as electricity arcs and frozen objects.
• Stylized in game messaging with localisation support.
• Custom post-processing including deterministic glitch effect which affected authored area only.
• UI effects and animations such as level up & item unlock.

All of the above were also included in the Addressables system for minimal runtime memory usage and improved loading times.

I built a framework for many projects alongside Drive Buy to handle the UI. The key features are:

• Simple to use API for moving between screens with multiple layers.
• Transitions could be created through a visual editor and reused throughout project.
• Leveraged Unity's Addressables package for improved loading times, reduced memory usage and smaller disk size.
• Input managed for keyboard/mouse, touch and gamepad with automatic visual updates for glyphs.
• Selected object managed between screens with history.
• Endless scrolling dynamic content with smooth performance with simple script data-source interface.
• Simple memory management and editor-friendly preload groups.

I have shipped multiple products using this framework across multiple platforms including desktop, mobile and console.