After the sudden closure of Intrepid Studios, I rallied a small cross-disciplinary team around a collaborative portfolio piece to continue honing our skills in Unreal 5 as we search for our next opportunities. Based on a mythical science-fiction IP I've been nurturing over several years, I set the
creative direction: filtering and shaping artist, animator, and designer
contributions, and incorporating the team's ideas into
the core vision. Additionally I took hands-on ownership of the design and implementation of
gameplay and content, as well as creating tooling to
support all pipelines.
The demo takes the shape of a combat-oriented mission, offering a brief glimpse into the conflict at the heart of the IP: players arrive in the depths of an ancient alien city, tasked with retrieving a source of power for their faction. Fighting their way
through its ancient defenders, their prize is stolen from under them by
the arrival of an unknown sentient technology.
Our goal for the project has been to pursue the combat
feel of action RPGs in the style of NieR and Phantasy Star Online,
married to MMO-inspired character-building and ability loadouts. We have been using the project to explore visual identity for the world and its factions, as well as the language for FX
and the IP's magic system.
Development Info
Responsibilities
The Seat of Creation: Exploring Primogenitor Architecture
Project Telos takes place in an ancient city at the origin of the known universe. The question for us from a visual development perspective was how we should depict the home of a species that predates
creation itself.
My initial brief to the art team asked for an exploration of monolithic structures and alien materials. I wanted to represent the Primogenitors with circular geometries and shapes that defied conventional physics, but still evoke a sense of sentient utilitarianism and ancient purpose.
After exploring brutalist styles alongside options that conveyed ancient sculpture and metallurgy, we ultimately landed on an aesthetic centered around malleable celestial metal: structures and devices created to harness the raw power of the cosmos, seemingly shaped into being rather than assembled.
Not only did that aesthetic become the heart of our environment, it also informed the shape language for the sentinel units left behind by the
Primogenitors as enemies in the level.
Earlier exterior concepts exploring the use of ancient stone. Art by Ryan Richmond.
Early explorations of shape language and architecture. Art by Lawrence van der Merwe.
Initial explorations of a space shaped from living, ancient metal. Art by Ryan Richmond.
Applying the "living metal" aesthetic to a playable space. Art by Ryan Richmond.
Concept that informed environment art direction. Art by Ryan Richmond.
Environment WIP by Charlie Pennington and Zach Turner.
The Invading Intelligence: Quantum Computing Manifested
Although the base population of the level is made up of the sentinels and servants left behind by the Primogenitors, I wanted to use the demo to convey the faction at odds with the player: a race of sentient, extra-dimensional technology that seeks to acquire the Primogenitor's secrets for its own ends.
The artistic angle for these invaders came from the team. Working against an early brief for an antagonist that had to feel categorically other, one of our environment artists suggested quantum computing as a direction. The suggestion immediately resonated, and we pulled on that thread to shape the visual design of our enemy faction.
The problem it solved was distinctness. The player faction's technology is a hybrid of human engineering and salvaged ancient alien technology, grounded in this universe. The invaders needed to diverge from that completely: advanced along a path with no shared basis and able to break the laws of reality as the player understands them. Quantum logic gave that a concrete visual vocabulary in a thing that exists in multiple states at once and rewrites its surroundings like editing code.
That language drives the boss encounter directly. The arrival is a hacking-like corruption that overwrites the space, with the boss's abilities built from quantum concepts.
A WIP glimpse of the Event and Dialogue systems at work.
As a hands-on designer, I wanted to prioritize building a strong foundation of tools for Project Telos to
support the team's workflow and velocity. My previous career leading teams working in high-volume databases shaped how I think about organized data, scalability, and the importance of single sources of
truth so that the people doing the work can move fast without needing to maintain fragile webs
of references or re-build existing solutions.
Every tool built for Project Telos leverages
native Unreal features for maximum extensibility, and every system has
been built to support Blueprint Scripting on top of core data, allowing for customization where needed for maximum flexibility while
standardizing commonly used functions into controlled, reusable parameters.
I created a priority-queued dialogue system so content authors control
bark and scripted-exchange behavior entirely through data.
A
single asset pairs a speaker profile with an
ordered line sequence, and exposes priority, cooldown, timing rules, and
prerequisite conditions.
A dialogue manager handles all runtime dispatch:
it queues competing triggers by priority, interrupts lower-priority
lines when something more important fires, and drives a fade-in/out
portrait overlay.
Trigger volumes and events fire dialogue with
every asset rule respected automatically. Adding an ambient bark to a mission is as simple as defining the dialogue data and assigning it to a trigger.
An event director placed into each level replaces the need for hand-wired Blueprint logic with a reusable, readable data asset that listens for triggers and updates the level during play.
Underlying phase data defines what happens when an event is triggered: arm spawners, fire dialogue, start a sequence, modify the environment, and more. The data also controls how a phase exits, through conditional branches evaluated in priority order, allowing for events that can diverge based on player choices and world state for increased variety and replayability.
The director is server-authoritative and replicates phase state for all players in co-op sessions. Level-specific references like spawner volumes and the boss actor live on the director instance rather than the underlying data assets, allowing for reusable event structures that can be dropped into multiple levels with different encounters.
Combat in Project Telos feeds through Unreal's Gameplay Ability System. To keep iteration fast and data clean, I built a layer of designer-facing data assets on top of GAS so that common parameters and functions (e.g. damage, effect application, cost, targeting) are parameterized into shareable data, while custom mechanics can still drop into Blueprint when they need to.
With games like NieR as my reference, I knew that I needed to support branching combos based on a variety of contextual inputs and states. While I created the data asset wrappers to manage individual abilities, it would have been cumbersome trying to maintain the pathways between each ability in a combo, especially as new branches were brought online.
To solve this, I built a graph-based combo editor. Each node carries an associated ability, with edges assigned to input gates (e.g. single press for a light attack, held press for a heavy attack). Edges also support optional state requirements checked against live gameplay tags, allowing combos to detect states like whether a player is airborne for aerial attacks.
The executing ability is universal, so adding a new weapon with an entirely different combo structure is as simple as building the desired graph and assigning it to that weapon's item data. Input is classified at a buffer layer: when an individual step's animation opens its buffer window, the next input is captured and classified before the current step resolves, then fired or reset when the window closes to promote deliberate combo timing over button mashing.
With the responsive, weighty melee of NieR in mind, I needed weapon impacts and launches to feel immediate while staying server-authoritative. The two most common ways to handle this both break down under those demands in a networked game.
The standard approach to melee detection attaches collision primitives to the weapon and polls for overlaps every frame during a swing. In multiplayer this scales poorly: every attacking actor runs continuous collision queries, and fast swings tunnel through thin targets between frames. To solve this, I replaced persistent weapon colliders with discrete arc sweeps fired on the server. Animation notifies open the active window of a swing, and the server sweeps along the weapon's arc from the previous frame to the current one, preventing fast strikes from skipping through targets. Each sweep maintains a record of targets it has already hit, so overlapping frames register a single clean hit.
When it comes to animation-driven movement, replicating the standard root motion approach is fragile and any latency
between the client and server risks surfacing as rubber-banding or
disagreement over where a character actually ended up. My solution drives all ability-based movement including dashes, dodges, and launches through animation notifies that apply velocity curves directly to the controller (visualized in the below image as a yellow line extended from the skeleton's root). Instead of moving the character through animation data, the server applies velocity through the character movement component, mapped to Unreal's native replication and client correction systems. Movement stays authoritative and reads consistently regardless of latency.
