Animated Hit Flash
Enemy materials oscillate between their original color and a brighter variation during hit reactions, creating a brief flashing effect using DOTween.
UNITY · C# · ANDROID
A mobile runner and boss rush game combining procedural stages, character-specific combat, and roguelite progression.
Official gameplay trailer. GildHunt was previously published on Google Play.
GildHunt is a completed Android game that combines procedurally generated runner challenges with side-scrolling boss encounters.
Players complete ten runner stages, collecting temporary upgrades from shops encountered every three stages. Their accumulated build is then tested against a zone-specific boss.
Defeating bosses unlocks new zones and rewards currency used to purchase characters and permanent equipment.
Game Designer & Lead Developer. I designed the gameplay mechanics, characters, bosses, progression systems, and levels, and implemented the game in Unity using C#. Pixel art production involved commissioned freelance artists and a family collaborator.
I built a shared combat abstraction using an abstract CharacterAbility class, defining common methods for executing attacks, switching abilities, and updating ability information.
PlayerAttack and PlayerSkill inherit from this base class, implementing separate behaviors for basic attacks and special abilities. Character-specific subclasses extend these systems with unique combat mechanics.
Combat calculations combine character attributes, equipment modifiers, and player progression data. Both attack systems also implement a short input buffer to improve responsiveness.
ChangeAbility() · UseAbility() · UpdateAbility()
Melee collisions, attack animations, damage and critical hits.
Projectiles, skill modifiers, and character-specific behaviors.
Unique attacks, special abilities, animations and resource management.
I designed and implemented a layered combat feedback system to make attacks feel impactful while keeping damage information readable during fast-paced mobile gameplay.
Enemy materials oscillate between their original color and a brighter variation during hit reactions, creating a brief flashing effect using DOTween.
Star-shaped particles appear when enemies take damage. Critical hits change the particles to red, making powerful attacks immediately recognizable.
Damage indicators rise and fade while following the affected enemy. Critical hits display larger, red-colored numbers.
Directional knockback varies between melee and ranged attacks, while randomized sound pitch adds variation to repeated impacts.
I implemented input buffering to preserve attack inputs briefly when the character cannot immediately execute an action. A slow-motion ability selector allows players to switch between three character-specific abilities using touchscreen controls.
I designed a touchscreen ability selector inspired by weapon-wheel interfaces, allowing players to switch between three character-specific abilities without completely interrupting combat.

Tapping the active ability button expands three selectable icons around it. A semi-transparent purple overlay indicates that selection mode is active.
Gameplay slows to 20% speed while the player selects an ability. The physics timestep is adjusted accordingly to maintain consistent physics updates.
UI animations use DOTween with independent time updates, allowing the icons to expand and collapse at normal speed even while gameplay is slowed down.
I combined continuous environment generation with handcrafted enemy encounter patterns to create varied runner stages without sacrificing intentional gameplay pacing.
Background layers and floor segments are spawned independently as their active pieces reach predefined position thresholds. Each segment moves through the scene, allowing the runner environment to extend continuously during gameplay.
Instead of spawning enemies at arbitrary intervals, I authored sequences defining enemy types, spawn timing, and lane positions. The cemetery zone features nine patterns distributed across three difficulty groups.
A torch-lined path appears near the end of each runner stage, visually communicating the approaching finish without relying on a prominent countdown timer. Its trigger also initiates the level completion sequence.
Each level selects from a curated pool of encounter patterns. Random selection introduces variety while preventing consecutive repetition.
Two patterns per stage, with no immediate repetition. Each spawn specifies its enemy type, lane, and timing.
I designed a progression system combining permanent equipment, temporary roguelite upgrades, and character-specific abilities. Player data stores equipped item IDs, while gameplay systems retrieve their relevant attributes from ScriptableObject databases.
Combat, health, and shield systems independently resolve equipped items and combine their modifiers with character attributes and player statistics.
Gameplay systems resolve the data they need from character definitions, equipped item IDs, and persistent player statistics.
Combat, health, and shield systems retrieve the relevant data and calculate their effective values.
Damage · Attack Speed · Critical Hits · Health · Shields
I separated temporary upgrades into two categories based on how they affect gameplay.
Numerical bonuses such as increased damage, health, and shields are applied directly to the current run's statistics when acquired, avoiding repeated application during subsequent level loads.
Upgrades that introduce special gameplay behaviors are tracked by their IDs and resolved when needed. This keeps the number of effects processed during level initialization smaller.
Character-specific ScriptableObjects define ability charge limits, while the current run tracks remaining charges independently. This supports different resource limits and combat styles across playable characters.
Boss encounters use state-driven behavior and coroutine-based action sequences to coordinate attack selection, execution, and recovery. Attack probabilities and combat pacing evolve according to remaining health.
Bosses also feature dedicated entrance and defeat animations, including a transformation sequence for the Alchemist.
Boss behavior is organized into states, with attack selection influenced by the boss's remaining health.

Extends its root-like arm to strike from a distance and summons underground spikes at the player's position, forcing constant movement.

Summons skeletons, teleports, launches spiral and vertical projectile patterns, and attacks using a high-speed raven.

Uses potions, clones, and slimes before transforming into an ice beast with charges, jumps, and environmental ice attacks.
I built Velrath around two distinct combat phases, combining weighted attack selection, scripted transformation, and arena-wide visual changes.
Potion attacks, slime summons, fog, and clones that reposition across the arena.
A new moveset featuring charges, targeted jumps, and falling ice hazards.
When the first health bar reaches zero, a scripted sequence transforms the boss and arena. Animations, lighting, environmental effects, collision shapes, and UI are updated before combat resumes with a new health pool.
Three attack-weight tables change the likelihood of each move according to remaining HP.
A queue tracks the two most recent attacks. Selection retries reduce repetitive sequences without completely preventing them.
Recovery intervals decrease as the boss loses health, increasing pressure on the player.
DOTween trajectories, randomized icicle falls, and separated clone positions create movement and positioning challenges.
Beyond core gameplay, I implemented systems to support multilingual content and preserve player progression between sessions.
GildHunt supports English, Spanish, German, and French using Unity Localization String Tables and LocalizedString references.
The LanguageManager automatically selects a supported language based on the device settings, with English as the fallback. I validated the behavior on an Android device by switching its system language.
Player progression is serialized using Unity's JsonUtility and stored locally through Application.persistentDataPath.
The save system preserves progression data such as unlocked equipment, equipped item IDs, and game progress across sessions.
I led GildHunt from its initial concept through game design, programming, content integration, and its Android release. The project was completed and published on Google Play.
I designed the core gameplay loop, character abilities, progression systems, levels, and boss encounters, shaping the overall player experience.
I implemented the gameplay systems in Unity and C#, including combat, procedural encounters, boss behavior, progression, localization, and persistence.
I collaborated with freelance pixel artists and a family contributor, coordinating visual asset production and integrating their work into the game.
GildHunt reached a completed Android release. It is no longer listed following a period without maintenance updates.