Steve Wheeler

Developer for the MMORPG Brighter Shores at Fen Research, working alongside the original creators of RuneScape.

Shipped Work and Key Contributions

• Easter 2026 Event: Lead Developer. A seasonal scavenger hunt quest about tracking down runaway rabbits.
  • Designed the quest's story, theme and objectives.
  • Mapped the Rabbit Cafe and wrote dialogue for its patrons.
  • Design and implementation of the core gameplay mechanic: the rabbit herding and capture system.
• 'The Maintenance Crew': Lead Developer. A large-scale quest featuring multiple puzzles, bosses and cutscenes.
  • Narrative/character design, all quest dialogue and cutscene composition.
  • Puzzle design and implementation, including real-time navigation challenges, and environmental hazards.
  • Boss design and implementation, including a multi-phase boss with multiple novel mechanics.
• Filtration Station: Lead Developer. Brighter Shores' first repeatable minigame with varying rules and difficulty.
  • Owned the design and implementation of the minigame from concept to release.
  • Created the game's core mechanics and systems and iterated upon them, resulting in eight unique game modes across four different difficulties.
  • Created and implemented a 'puzzle solver' using a BFS pathfinding implementation to procedurally generate random puzzles.
• Project Milestone: Helped with implementation and balance work for the wider Milestones update.
• Co-designed and implemented various 'bounties' (time-gated activities) for several of the game’s professions, contributing activity design, gameplay implementation, reward/balance iteration, and live-content polish.

Video & Screenshots

As part of my PhD at the Human Interface Technology Lab (HIT Lab NZ), I designed and built a custom VR learning environment for training firefighters, over the course of a year and a half and working throughout with industry experts and stakeholders. The design was driven by a framework I developed to align a learner's preferences and VR's strengths with the training tasks and the environment itself.

I then evaluated it across two user studies with 55 participants, 15 of them professional firefighters, including one I organised and ran at a fire station in Canterbury, New Zealand.

Features

• Fire propagation based on wind speed, wind direction, moisture level of fuel, and slope inclination.
• Scripted live demonstrations of fire behaviour.
• Interactive lessons that allow the user to experiment with different simulations.
• Randomised quizzes to encourage reflection and reinforcement.
• In-depth tutorial that covers the environment's controls and tasks.

Video & Screenshots

Professional work, delivered with the University of Kent for a security company based in London. The brief was to train new security guards in the basics of a patrol, so I designed the scenarios around testing a trainee's situational awareness and their grasp of correct procedure.

As the sole developer, working alongside a 3D artist, I designed and built the full application, and met regularly with the client and project supervisors to gather and refine requirements and shape features. Built in Unity with the SteamVR SDK.

Due to the nature of the research project, the source code is not available.

Features

• Individual persistent user profiles and statistics.
• Multiple individual randomised hazards.
• Task management system in which users must complete multiple tasks to complete an object.
• In-game voice recording and playback.
• Instructors can record trainee interaction with simulation as a video file and later review.
• Statistics saved as CSV file for instructors to review later.
• Tutorial system with Text-to-Speech voice.
• Inventory system in which users can add and remove virtual objects from the world around them.

Video & Screenshots

Prop-oriented World Rotation (POWR) is a VR interaction technique I conceived and designed for my Master's dissertation. It maps objects from the user's physical environment onto objects in the virtual world, so, for example, the bed in their room stands in for a crate in the game. That gives the player real haptic feedback from the virtual world without needing any bespoke prop or device.

A game was developed to demonstrate this technique. The game is a shooter (similar to Time Crisis) where you shoot all the robots to advance to the next checkpoint. Each checkpoint has a virtual object the player uses for cover, scaled and mapped to a physical object in the user's room. The crate object is mapped to the bed, and any door object in the game is mapped to the room door.

The work won best poster/demo at the VRST 2021 conference, voted for by conference participants, and was later published as a peer-reviewed academic paper in 2024.

Features

• Implementation of "POWR" in a demonstration game.
• A variety of enemies and obstacles with their own logic.
• Wave-based shooting mechanics.

Video & Screenshots

SAGE (Steve's Awesome Game Engine) is an engine and editor I built for the genres I most want to design for: top-down RTS games, management sims and RPGs. The point of the editor is design speed. I can lay out maps, place and wire up entities, script behaviour and test changes in play mode without leaving the tool. Underneath it's a reusable C++20 framework, but it exists to let me prototype and iterate on systemic gameplay quickly.

It started out as the engine behind my previous RPG engine example, but has since been expanded significantly into a broader game framework with reusable runtime systems, editor tooling, scripting, serialization, and an asset pipeline.

Standout Systems

• Integrated editor for building maps, placing entities, editing components, and testing changes in play mode.
• Navigation and movement systems designed for point-and-click controls, including multi-tile footprints, obstacle avoidance, and smooth actor turning.
• Lua scripting for entity behaviours, gameplay events, and project-specific game APIs.
• Custom UI framework for in-game windows, tables, tooltips, drag-and-drop, and themed HUD overlays.
• Terrain tools for sculpting heightfields, authoring navigation surfaces, and aligning gameplay objects to the world.
• Editor undo/redo history, including hierarchy edits, component changes, transforms, terrain sculpting, and multi-selection edits.
• Collision and trigger system with raycasts, box/mesh queries, collision layers, and an editable collision matrix.
• Rendering stack for dynamic models, skinned animation, emissive materials, skyboxes, custom shaders, and particles.
• Packed asset and serialization pipeline for loading game resources, saving editor maps, and reusing groups of entities as flatpacks.

Video

A vertical slice of a systemic CRPG inspired by Baldur's Gate 3 and Divinity: Original Sin 2, with its own gameplay framework (AI, UI, rendering and tooling) built from scratch without Unity or Unreal.

The objective of this project was to create a vertical slice of a Baldur's Gate 3/Divinity: Original Sin 2-inspired CRPG without using a game engine, such as Unity or Unreal. Instead, I built the engine on top of the low-level 'raylib' library in C++, primarily using raylib for window management and rendering. The goal was to learn how to build systems and tools from scratch, which I take for granted when using large-scale game engines, such as pathfinding, particle systems, visual effects, or serialisation.

In this demo, the player awakens in a cave and must navigate through a goblin cult that has occupied an underground dungeon. The player must repair a lever that opens their escape route through a series of quest chains to leave the dungeon area. Due to this, the demo was dubbed 'LeverQuest.'

Standout Systems

• Dialogue and quest system built around a custom markup language, so branching dialogue, quest logic and conditionals can be authored as content without touching engine code.
• Custom UI Library imitating HTML table layout logic, including the ability to drag and drop icons contextually.
• Multi-unit A*/BFS Pathfinding system with navigation resolution.

Additional systems include billboarded particles, JSON/Binary serialisation, lighting, equippable inventory items, and a Blender-to-engine asset pipeline.

Video & Screenshots

Implemented a full fixed-function rendering pipeline from scratch, including rasterization, Z-buffering, shading, model loading, and texture filtering.

A software renderer written from scratch in C++ and SDL. This was a challenge I'd wanted to tackle since I first started making games, and a chance to dig into the fundamentals of 3D rendering while sharpening my 3D maths and C++. It implements a complete "fixed-function" pipeline, backed by a custom maths library and an OBJ/MTL parser, with three scenes and a GUI for switching between shading method and texture filtering.

Low-level Graphics & Maths

• Custom vector/matrix maths libraries: slib and smath.
• Model/material loading via ObjParser for obj and mtl files.
• Full rendering pipeline through Renderer and triangle rasterization through Rasterizer.

Additional support includes flat/Gouraud shading, nearest-neighbour and bilinear texture filtering, directional lighting, texture atlases, scene controls, and multithreaded processing.

Video & Screenshots