Unannounced Title

Overview

An unannounced commercial title in development at Tech Tree Games. The product is under NDA, so this page describes the engineering and withholds the names.

Game Programmer, core architecture and technical leadership

This is the deepest engineering work I have done. I designed the combat architecture in the project's first weeks, and twenty-six months later every major system still runs on those foundations. I also lead the technical side of the team in practice: onboarding, code review, standards, and day-to-day direction for up to four developers working with artists and designers. Across those months I have built more than forty systems end to end, each carried from its data model through logic to interface and animation, in collaboration with the artists and designers who shaped it.

The core is three decisions made early and defended since. Every combatant derives from one damage abstraction, so weapons, status effects and targeting resolve against the base type and never ask what they hit. Weapon execution runs on a scheduling primitive I wrote, the action cycle, and the weapon's own volley is just the default cycle, which is why a collectible ability layer added two years in attached its abilities as further cycles instead of as a parallel system. And systems communicate through ScriptableObject events with serialized, inspector-readable listeners, so features ship without reopening combat.

Content is data. Twelve weapon archetypes and fifteen abilities are authored as assets against shared contracts, every stat resolves through a single source-of-truth database, and I built the balance tooling myself, including a combat simulator a designer can assemble any matchup in without playing to it.

Combat architecture unrewritten in 26 months
12 weapon archetypes and 15 abilities on one contract
Technical lead in practice for up to four developers
Steady 60+ FPS without lowering the art bar

My contributions

Combat foundation

Designed the combat core in the project's first two weeks: an abstract damage base under every combatant, weapons as abstract types resolving through one firing pipeline, and pooling and singleton utilities beneath them. Twenty-six months of features have shipped on it without a rewrite.
Three weeks in, introduced a second abstraction level between the damage base and the concrete combatant, on the explicit bet that other combatant categories would come. A year later one did, and it was implemented by extension while the damage resolver, targeting and effects code went untouched. That is the open/closed principle applied a year ahead of its payoff.
Wrote the projectile system to guarantee a hit at any distance, with per-unit accuracy, friendly-fire prevention, and a custom pool built for many combatants firing at once.
Separated persistent state from scene actors: each combatant's health and stats live in an instance object the scene component reads through, so save data, the simulator and a live fight all share one source of truth.

Action cycles

Reworked weapon execution onto a single scheduling primitive, the action cycle: cooldown as a live-evaluated function, the action as a coroutine, pause and loop semantics, and events the interface binds to. The weapon's own volley is just the default cycle.
That one change carried the collectible ability layer. Fifteen abilities attach as additional cycles on the same primitive, cooldown modifiers apply mid-cycle because cooldown is a function and not a cached number, and the reload interface needed no second code path.
Extended the shared damage model with damage reduction, armour piercing and mitigation-ignoring damage, resolved in one place for every source.

Weapons and status effects

Built twelve weapon archetypes end to end, each with its own structure, status effects, upgrade containers and interface actions, all against the shared weapon contract.
Composed status effects as components behind one cleansable-effect interface, so any combatant can carry any effect and a new effect works everywhere the day it is written.
Split the weapon upgrade containers apart when they began growing into one class, keeping a single responsibility per type while the roster tripled.
Made target availability composable: anything can veto a combatant as a target by registering a blocker, and the combatant is targetable exactly when no blockers remain. Smoke, stealth-like effects and scripted moments all use the same mechanism.

A second combatant category

Delivered the second combatant category as the extension the architecture had been holding a place for: persistence, a rebuild timer, escalating challenge tiers and multi-stage encounters, resolved through the abstraction throughout.
Built encounters against a single opponent made of several destructible parts. The player can focus any part individually, the encounter ends the moment the last part falls, and player units defeated mid-fight are replaced automatically from reserve.
Built a generic streak system and extended it for these encounters, with ScriptableObject events whose listeners are serialized and readable in the inspector.

Meta-game and economy

Built the withheld under NDA layer: its behaviour and popups, unit travel carrying attributes and progress that survives scene changes, exchanges gated on resources, and auto-repeat.
Built the repair economy end to end: dynamic instant-fix pricing, idle recovery for units returning damaged, upgrades, and the panel behaviour around them.
Built the player inventories and the save system, then hardened them for live operation: every content entry carries a persistent ID, so renaming or reordering content in a later version cannot corrupt an installed player's data.
Refactored the stats and inventory paths onto the Strategy pattern where variant behaviour had been accumulating as conditionals.

Tooling for the team

Built the balance tooling: a combat simulator where a designer assembles any matchup, repeats any unit, and upgrades freely inside the tool.
Moved every stat's name, description, icon and display format into one source-of-truth database asset, ending the drift between what a stat does and what its tooltip says, and giving external tools a single place to read from.
Rebuilt the task system so designers compose tasks freely without risking players' saved data in live ops.
Instrumented the ScriptableObject event layer so subscriptions are serialized and traceable in the editor, and the event graph can be read instead of debugged.

Onboarding

Built an event-driven tutorial handler with per-step game states and a guided pointer, across five parts plus a fully guided one.
Wrote helper classes whose only job is to keep every button in the correct interactable state mid-tutorial.
Built its highlight system, then generalised it into the one used for every feature-unlock moment in the game.
Guarded it across unrelated systems: gestures stay available throughout, difficulty holds until tasks complete, and recovery and exchanges run faster during onboarding.

Interface replacement

Carried a full art and interface replacement through a live codebase: built the sprite atlas, applied sprite settings, cleared the old assets out and repaired every reference the removal broke.
Consolidated a family of near-duplicate end-of-combat popups into one modular popup, and centralised the game's resources from many types down to two, so later features price against a small, stable set.
Built a view handler with canvas-over-3D support, fitting views between the top and bottom bars so they adapt across device shapes instead of being positioned per screen.

Performance

Ran the optimisation pass as an experiment per change: profile on device, alter one variable, keep it only if the frame time improves. The discipline cut both ways, and features that are reflexively enabled elsewhere were removed here because measurement showed each cost more than it returned on the target hardware: static batching, the GPU Resident Drawer, and GPU occlusion culling.
Built LOD for world objects driven by camera distance, tied shadow distance to camera zoom, applied GPU instancing, and optimised the heaviest environment shader in the combat scene.
Trimmed the render pipeline per build: a no-shadow URP variant, render scale on device, post-processing off, VSync removed, and target framerate set per device class.
Installed Project Auditor, wired FPS displays into SRDebugger on both scenes, and built the tooling to measure performance on device instead of in the editor.

Live support

The largest single category of my work here: sustained correction and refinement across every system above.
Interface polish, notification behaviour, sorting and scroll persistence, unlock conditions, spawn-rate tuning for the early game, tooltip behaviour, null guards on popups, reward display, and several hundred small usability fixes.