Selected case study
Alyve
A Unity 6 ARPG built as a laboratory for modular gameplay, custom navigation and living-world systems.
End-to-end Unity systems engineering across combat, navigation, crowds, population, characters, animation and evaluation.

At a glance
- Product
- Independent action RPG
- Ownership
- Game and systems development
- Engine
- Unity 6 and C#
- Focus
- Gameplay, simulation and tooling
- State
- Active development
A systems laboratory
Alyve is an independent action RPG I am building in Unity 6. It is also a long-term systems laboratory: a place to explore how combat, movement, characters, simulation and tooling can share a coherent architecture without turning the game into one monolithic controller.
Architectural foundation
The Entity/Body/Brain model separates three concerns that games often bind together. The entity owns identity and domain state. The body represents the character in the world. The brain provides control, whether that control comes from a player, AI or another source.
This separation makes changing representation or control a deliberate composition decision rather than a rewrite of the underlying character.
Combat as a reusable system
Combat is data-driven across reusable skills, weapons, targeting and combos, with a central damage pipeline defining how effects are applied. The goal is not a catalogue of mechanics; it is a small set of boundaries that lets mechanics interact without each one knowing every character implementation.
That approach supports iteration because content and behaviour can change independently while still passing through shared rules.
Navigation and a living world
Alyve uses custom multilevel navigation that combines per-agent paths with shared flow fields. Tiered crowd behaviour scales how much simulation detail is applied, while the living population connects agents to routines, activities and reactive states.
These systems are designed together: navigation is infrastructure for behaviour, and behaviour gives movement a purpose beyond reaching a destination.
Characters, animation and tooling
Runtime character composition and a PlayableGraph animation stack keep visual representation modular. Editor tooling, PlayMode tests and visual evaluation workflows make system behaviour repeatable and easier to inspect.
Automated checks provide regression evidence; they do not decide whether an animation feels right or whether a scene has reached its visual target. Those remain explicit human review steps.
Current state
Alyve remains in active development. The project demonstrates deep Unity architecture, implementation and evaluation discipline, while technical validation is kept distinct from the final feel and finish of the game.
01 — Key contributions
Key contributions
- 01
Entity, Body and Brain architecture
Identity, physical representation and control are separated so the same gameplay entity can change bodies or decision sources without duplicating its domain state.
- 02
Combat as a reusable system
Skills, weapons, targeting and combos share a data-driven foundation and central damage path, keeping individual mechanics composable instead of embedding rules in character scripts.
- 03
Navigation, crowds and population
Custom multilevel navigation combines individual paths with shared flow fields, while tiered crowds and daily population behaviours connect movement to a living world.
- 04
Characters, animation and evaluation
Runtime character composition, PlayableGraph animation, editor tooling, PlayMode tests and visual review workflows make complex behaviour easier to build and inspect.
Stack and tools
Stack and tools
Unity 6
URP, Burst and Collections, Playables and editor tooling
C#
Gameplay systems, tools, tests and runtime architecture