Game development / Project case study
Ultrawave.
Gameplay engineering & collaborative game design
A top-down space roguelite where you battle waves of enemies and gather resources to upgrade your ship in between rounds.

At a glance
- Engine / framework
- MonoGame
- Languages
- C#
- Technical focus
- Gameplay engineering & collaborative game design
- My role
- Gameplay Engineer & Co-Designer
- Team
- 3 developers, with game design shared across the team
- Timeline
- May 2024 - August 2026
Game overview
Ultrawave is a top-down space combat game built in C# on a custom game engine using the MonoGame framework. Players fight through escalating enemy waves, collect resources and experience, and develop their ship through combat upgrades and hub progression. A run moves from survival into a boss encounter before returning the player to the hub.
I am one of three developers. All three of us collaborated on game design, including enemies, weapons, buildings, progression, and engine architecture. My engineering work turned those designs into enemy behaviors, weapon implementations, and reusable gameplay components.
- Hub & loadout
- Survive & upgrade
- Boss encounter
- Collect & return
My contributions
- Enemy AI Enemy concepts, behavior implementations, and transition conditions.
- Weapons Designed and implemented multiple weapon types before settling on the current weapon types.
- Reusable gameplay Behaviors, conditions, drops, pickups, and components assembled through Creatable factories.
- Progression Designed and implemented weapon specific upgrades, ship upgrades, and building upgrades.
- Integration Connected art assets and gameplay features to shared spawning, collision, and lifecycle systems.
- Prototyping The original Pixi-based particle integration, wave function collapse background generation, early peer-to-peer networking systems, and other systems which were replaced or moved away from.
Team credit: Game design was collaborative between me and the other lead programmer. Art, UI, and music were outsourced to other contributors.
Enemy AI
I contributed enemy concepts and implemented enemy behaviors and transition conditions. Each enemy needs movement, attacks, animation, and warning effects to work together, so its intent is readable and the player has a chance to react.
The state-based framework composes those actions into attack sequences. A state can move, fire, stop, change animation, or begin a telegraph. Conditions determine when to transition based on time, distance, energy, health, or animation completion.
Early Grabbler behavior
This early capture shows Grabblers moving back and forth around the player in a circle. It documents an earlier behavior iteration; it is not a demonstration of the current Elephant attack sequence described below.
Coordinating an attack sequence
The Elephant, one of the early enemies, approaches, stops to telegraph a dash, charges a defined distance, and then recovers. Splitting that sequence into states lets movement, the visual warning, attack completion, and cooldown participate in the same behavior flow.
- Approach
- Telegraph
- Charge
- Recover
The same framework supports all the different enemy behaviors. Grabblers avoid player shots and try to steal drops, or the Leech latches on the the player and slow them down.
Implementation detail: behaviors and conditions
AIBehaviorStateMachine tracks the active state and an optional global override. Each BState contains behaviors and conditional transitions. Conditions are evaluated before behaviors run, and a matching condition may choose randomly among several destination states. BBehavior supplies enter, update, and exit hooks, allowing actions to be composed without putting an entire enemy’s logic into a single update method.
Global transitions can interrupt the current behavior. The override is cleared after transitioning.
Weapons
I helped design every weapon with the team and wrote the weapon code. Each weapon controls its firing pattern while sharing input, lifecycle, owner, and spawning interfaces. The objects created by an attack then combine travel, collision, damage, lifetime, and presentation components.
This supports weapons with different engineering requirements:
- Axiom: semi-automatic fire with an unlockable staged charge shot.
- Disperser: spread fire that can become a single slug, with slug damage incorporating pellet count.
- Arclance: a boomerang-like projectile that flies out and back, with unlockable orbiting secondary projectiles.
- LightBlade: a sustained beam with damage ticks and modifiers such as pulse, pull, and turret beams.
Keeping active attacks in sync
A weapon upgrade can affect an attack that already exists. LightBlade explicitly refreshes the damage of its active beam when damage upgrades apply; certain upgrades also require refreshing turret beams. Updating the weapon’s data alone would leave these active attacks using values they had already cached.
Implementation detail: the shared weapon contract
IWeapon covers press/release input, updating, service binding, owner synchronization, cleanup, and a bullet-fired event. Optional secondary behavior uses ISecondaryFireWeapon. BaseWeapon handles shared projectile quantity and scale behavior, creating spread volleys by cloning spawn descriptors and rotating their target directions. Target and muzzle-position interfaces provide aiming information from the owner.
Reusable gameplay components
I wrote many of the behaviors, conditions, drops, pickups, and other components used by Ultrawave’s gameplay. These run on a shared entity/component framework built around WeatheredObject, which combines movement, collision, behavior, and presentation in individual objects.
Assembling objects with Creatables
I worked with Creatables to assemble and spawn gameplay objects. These factory methods construct a WeatheredObject from reusable components: a projectile needs travel, collision, damage, lifetime, and graphics; an enemy adds AI, targeting, health, and drops.
- Spawn descriptor
- Entity service & factory
- Creatable + components
- Initialize & register
SpawnDescriptor carries an archetype name, transform, persistence information, and an Extra dictionary of creation parameters. The factory resolves the archetype to its construction function. The entity service then binds services, initializes the object’s family, registers colliders, and raises the spawn event.
Connecting combat to drops and pickups
My drop and pickup work connects combat outcomes to resources. DropOnDeathComponent responds to a health death event. DropComponent rolls chances and quantities, then requests drop archetypes through the entity service. AddResourceWithDelayComponent gates pickup availability with a timer.
This gives each component a distinct responsibility while letting enemy death, spawning, pickup timing, and progression cooperate through shared systems.
Upgrades & progression
I collaborated on progression and building design and contributed code to the upgrade system. The game connects two progression layers: hub upgrades and choices made during a run.
- Hub progression stores upgrade requirements, costs, claim state, and effects. Upgrade nodes can represent branches, but the current weapon tiers use linear chains.
- Run progression combines generic, dash, and equipped-weapon options. Eligibility checks filter choices against progression, weapon identity, stack limits, prerequisites, and incompatible tags before weighted selection.
Capability interfaces such as IAdjustDamage let effects work with supported weapon features. This connects upgrade selection to the weapon implementations and their changes in behavior.
Physics integration & debugging
We had to write our own physics engine. A lot of work was done my my teammate before I joined the project, but I used it in gameplay, connecting spawned objects and collision behavior, and debugging how those systems interacted.
The early capture below makes that distinction visible: the debug box represents the ship’s actual collider, and the resolver prevents it from intersecting another box. The ship artwork and collision geometry are separate parts of the interaction.
Shared framework context
The physics service gathers nearby candidates with a quadtree before detailed collision checks. It includes discrete and continuous paths, layer masks, raycasts, overlap queries, and physical response. Continuous handling is especially relevant to fast projectiles.
WeatheredObject supports parent/child hierarchies for attached hitboxes and effects. The entity service queues creation, destruction, and despawning, keeping collider registration aligned with object lifecycle.
Asset integration
I integrated art assets into the gameplay pipeline, connecting sprite sheets and animation data to runtime objects and effects. My contribution was the technical integration; asset creation and UI implementation were outside my role.
The atlas pipeline reads packed frame metadata—including rotation, trimmed offsets, original size, and pivots—to preserve sprite placement and animation alignment. Category wrappers expose named sprites and animations to gameplay code, while collision geometry is loaded separately from exported hitbox data.
Original particle integration
I implemented Ultrawave’s original particle integration using the Pixi particle system. That earlier implementation became the base for a later rewrite.
Development history: My contribution was the original integration. The current system’s pooling, configuration, and cached settings belong to the subsequent rewrite and are not presented here as features I authored.
Development history
Earlier builds show the work behind the finished presentation: testing gameplay with placeholder visuals, trying bounded background effects, and debugging generated tiles. These captures document prototypes and intermediate results rather than the current game’s final appearance.
Concept art & visual development
These concept paintings show another part of Ultrawave’s development: the visual ideas explored alongside the gameplay systems. They are included here as context for the project. The artwork was created by other contributors; my role focused on gameplay engineering, collaborative game design, and technical asset integration.


Gameplay before the art pass
This early screenshot records a stage when gameplay objects were represented largely by colored cubes and other placeholder visuals. It provides context for the implementation work that happened before the art was integrated.

A bounded field of stars
An early solution generated stars within a radius around the player and moved that region with them. This explored how to give the background a star field without generating an unbounded number of stars as the player traveled.
Background tiling experiments
I wrote a wave function collapse algorithm for background tile generation. That background system and other prototypes were subsequently reworked as the game evolved.
This capture shows tiles against a white debugging background while we were trying to make the tiling work. It documents the development process; it does not, by itself, demonstrate the original algorithm’s constraint rules or generation steps.