← Back to portfolio
Unity / C# Gameplay Case Study

Caliber of Chaos

A 2D / 2.5D action-puzzle shooter where colored shots do more than deal damage: they change the state of the battlefield.

Enemies and objects are protected by elemental seals. The player must choose the right element, break the seal, cleanse corruption, transform the environment, and only then finish the target. This is more than a shooter: every bullet is a tool for mutation, purification, and tactical problem-solving.

Play the Prototype Explore the Architecture
Unity 6 C# Top-down Shooter Action-Puzzle Roguelite Prototype ScriptableObject Architecture Object Pooling
Project Overview

The core hook: shooting changes the rules of combat

What makes the game unique

In a typical twin-stick shooter, a bullet simply deals damage. In Caliber of Chaos, every bullet carries an element, mutation context, faction, modifiers, and impact rules. It can break seals, cleanse corruption, charge nodes, recolor the ground, turn objects into allies, or trigger an explosive reaction.

Combat revolves around choosing the right color, not just aiming accurately.
The environment becomes part of the combat system: trees, nodes, shields, nests, terrain, and enemies all react to elements.
The player is not only a shooter, but also a purifier of the world: combat is part destruction and part rescue.

My role

I built the project as a solo prototype: I designed the core loop, programmed the gameplay systems, structured the architecture, configured Unity prefabs, tested interactions, and developed the system into a playable demo.

GD
Game DesignerDesigned the purification fantasy, elemental combat, seals, nests, risk/reward systems, and level structure.
C#
Gameplay ProgrammerImplemented weapons, bullets, enemies, mutations, damage, UI feedback, inventory, and level flow.
SA
Systems ArchitectDecomposed complex combat into small components, pipeline handlers, ScriptableObject configurations, and reusable modules.
Core Gameplay Loop

From entering a corrupted zone to cleansing the floor

Enter the zoneThe player enters a corrupted room containing enemies, nodes, a nest, or a blocked passage.
Read the seal colorAn enemy or object has an active seal: Bio Red, Crystal Blue, Purge Green, or Gold Yellow.
Choose a weaponThe player switches weapon cores or weapon slots and fires the matching element.
Break the defenseThe correct color removes the seal or charges the node; the wrong one may reset progress.
Deal HP damageOnce the defense is down, the standard damage pipeline begins reducing the target's health.
Cleanse or mutatePurge cleanses, while other elements alter the properties of objects, terrain, and enemies.
Claim the rewardThe player earns essence or gains access to a chest, passage, portal, or new weapon build.
Climb higherThe loop scales into towers, floors, boss fights, and a meta system for crafting amulets from monster parts.
Technical Architecture

Complex mechanics built from small, clear systems

Weapon → Bullet → Impact Pipeline → World Reaction

WeaponFrame
shot pattern
WeaponCore
element
WeaponMod
behavior
BulletContext
shot data
BulletMover
movement
Impact Pipeline
rule chain
Damage / Seal / Mutation
result

WeaponFrame

Defines the weapon's firing pattern: pistol, automatic, shotgun, or mortar, as well as fire rate, spread, bullet speed, gravity mode, and projectile count.

WeaponCore

Defines the shot's element and purpose: Bio, Crystal, Purge, or Gold. The core affects damage, emission color, and how the world reacts.

WeaponMod

Adds bullet behavior such as Simple, Homing, Explosive, or Fragmenting. A mod extends the frame/core combination without changing it.

Implemented Gameplay Systems

Gameplay systems that demonstrate my Unity/C# expertise

Bullet Impact Pipeline

A bullet is not implemented as one enormous monolithic class. Instead, it passes through a chain of impact handlers. Each handler owns one focused responsibility: ignored layers, faction rules, shields, ground mutation, mutable objects, spell nodes, damage, explosions, or despawning.

BulletImpactPipeline.cs
BulletImpactContext context = new(...);

foreach (BulletImpactHandler handler in handlers)
{
    handler.Handle(context);

    if (context.IsResolved)
        break;
}

if (!context.StopProcessing)
    context.StopAndDespawn();

Why this architecture works

Once a project introduces seals, shields, mutations, explosive bullets, faction rules, and multiple object types, simple OnCollision logic quickly becomes unwieldy. The pipeline makes it possible to add new world reactions without rewriting the entire bullet implementation.

Open/Closed principle: a new effect means adding a new handler.
The bullet carries context without knowing the implementation details of every target.
The processing order is visible in the Inspector and easy to debug.
The system is ready for ricochets, poison pools, armor, boss phases, destructible props, and more.

Enemy AI

Enemies are composed from behavior, movement, attack, health, target-detection, and mutation-controller components. The system supports melee, ranged, patrol, friendly-attacker, and spawner-driven behaviors.

Mutation System

ElementType affects terrain, enemies, and objects. Crystal can slow, Bio can corrupt, Purge can cleanse, and Gold can empower through separate presets.

Seal System

Spell nodes and elemental seals add a puzzle layer to the shooter: HP damage is enabled only after using the correct element.

Spawner System

Spawners use MaintainAlive, FiniteWave, Burst, and Single modes, along with budget and maximum-alive limits, to create varied encounter patterns.

System Breakdown

Project architecture as a component map

Gameplay Composition
Player
 ├─ PlayerMovement
 ├─ PlayerWeapon
 ├─ GroundDetector
 ├─ Inventory
 └─ GameFlow interaction

Weapon
 ├─ WeaponFrame  // rate, spread, gravity, projectiles
 ├─ WeaponCore   // element, damage, emission
 ├─ WeaponMod    // simple, homing, explosive
 └─ BulletSpawner + Pool

Bullet
 ├─ BulletContext
 ├─ BulletMover
 ├─ Rigidbody + Collider
 └─ BulletImpactPipeline
Enemy / World Composition
Enemy
 ├─ Health
 ├─ EnemyMovement // NavMeshAgent
 ├─ EnemyBehaviour
 ├─ TargetDetector
 ├─ AttackDetector / Hitbox
 ├─ SpellNodesCounter
 └─ MutationControllerEnemy

World Objects
 ├─ MutationObject
 ├─ TransformationObject
 ├─ ElementChargeCounter
 ├─ SpecialForce
 └─ Visual via MaterialPropertyBlock
Design Value

Why this system is engaging for the player

Combat as situational analysis

The player considers more than enemy HP: seal color, mutation type, enemy positioning, terrain state, and nearby objects all matter.

Weapons as a construction kit

Frame/Core/Mod provides a scalable foundation: new weapon types can be assembled through combinations instead of programming every weapon from scratch.

The world as a gameplay system

The environment is not decorative: it mutates, becomes cleansed, blocks paths, helps the player, or amplifies threats.

Current Status

The prototype already demonstrates a playable core and systemic depth

Implemented

Core shootingDone
Weapon switchingDone
Bullet Impact PipelineDone
Enemy behaviour prototypesDone
Seal / Spell Node logicDone
Mutation object interactionsDone
Playable WebGL prototypeDone

In development

More enemy variationsIn progress
Better UI feedbackIn progress
Floor goals and tower structureIn progress
Meta crafting: monster parts + essenceDesign
Boss and biome progressionDesign
Polish, VFX, balanceIn progress
What This Project Demonstrates

This case study shows that I can do more than write code: I can turn game mechanics into a coherent system

Gameplay Programming.
Weapons, bullets, collisions, damage, enemy AI, spawners, interactive objects, inventory, and game flow.

Game Systems Design.
Colored seals, purification, mutation, risk/reward, towers, floor objectives, crafting, and the progression loop.

Scalable Architecture.
Component composition, ScriptableObject configurations, pipeline handlers, pooling, faction rules, and extensible modules.

Open the Playable Prototype Back to Portfolio