Andrii Miroshnyk

Gameplay & Systems Programmer

I build gameplay systems with a focus on clean architecture, fast iteration, and strong game feel.

Location: Copenhagen, Denmark | Email: mirikandrew@gmail.com | LinkedIn: andrii-mirik | itch.io: enryu-mirik | CV: View PDF

UNITY C# GAMEPLAY SYSTEMS CLEAN ARCHITECTURE GAME FEEL RAPID DELIVERY

Game Jam Projects

Rogue Scribe (Ludum Dare 58)

Type: Game Jam
Role: Gameplay & Systems Programmer
Timeline: 2 days initial build + 2 months further development
Team Size: Solo

Overview: Dynamic action-parkour game made in Unity, focused on modular movement and spell systems.

What I Built

  • Architected systems with Zenject DI and ECS-like design approach.
  • Built modular ability/inventory/AI structures.
  • Created highly composable state and spell systems, enabling rapid creation of movement states (wall run, gravity shift, dash) and spells (geyser, fireball, laser).

Project highlight

  • Implemented a Zenject-backed infrastructure state machine for the whole game: typed lifecycle states, payload-driven transitions, and routing Update / FixedUpdate / LateUpdate into whichever state is active.
  • Built a graph-based gameplay state machine with conditional and catch-all (“any”) edges, state history, and multi-instance support (same state type, different index). A factory assembles machines from a flat list of StateConfiguration entries.
  • Composed the player controller from the same core using ScriptableObject movement configs (BaseMoveStateConfig): each asset adds its own states plus a transition table, so a new mechanic set is mostly new configs, not a rewrite of the engine.

Challenges

  • Created a state-machine builder system for the main character where gameplay changes significantly depending on which state configurations are passed as input.
  • Built many mechanics in a short jam timeframe by using composable logic blocks for reusable movement and spell behavior.
  • Kept architecture clean under rapid iteration pressure by applying modular boundaries and dependency injection.

Results & Impact

  • Jam-ready gameplay with multiple movement and spell combinations.
  • System design supports fast feature extension.

Tech Stack

Unity, C#, Git, Zenject, Performance Profiling, Memory Management, ProBuilder, FMOD

Links

Media

Rogue Scribe screenshot 1 Rogue Scribe screenshot 2 Rogue Scribe screenshot 3 Rogue Scribe screenshot 4 Rogue Scribe screenshot 5 Rogue Scribe screenshot 6

Against the Fog (Nordic Game Jam 2026)

Type: Game Jam
Role: Lead Game Developer
Timeline: 2 days
Team Size: 5 people

Overview: Atmospheric survival city builder where players push back fog, manage resources, and build a lighthouse.

What I Built

  • Drove the project to completion as the lead gameplay programmer in a team of five people I had just met.
  • Created all core gameplay systems and implemented most of the art assets.

Project highlight

My first in-person jam (not online-only): led a team of five people I met for the first time and we still shipped a cohesive build—no integration blockers—within about a day and a half of focused production time.

Challenges

  • Delivered a polished strategic experience in a 48-hour jam scope with lead-level technical ownership.

Results & Impact

  • Playable jam build delivered for Nordic Game Jam 2026.

Tech Stack

Unity, C#, Git

Links

Media

Against the Fog screenshot 1 Against the Fog gameplay gif

Beacon Bound (Ludum Dare 59)

Type: Game Jam
Role: Gameplay & Systems Programmer
Timeline: 2 days
Team Size: Solo

Overview: First-person adventure on a mist-shrouded island where relighting the beacon and guiding ships out of the fog drives progression.

What I Built

  • Built a playable level where lighting leads the player between objectives, clarifies the core loop, and reinforces what to do next without heavy UI reliance.
  • Implemented level generation and ship routing so arrivals and paths stay coherent with the island layout.
  • Owned a large share of environment work plus post-processing and lighting to sell atmosphere and readability.

Project highlight

  • Heavy focus on lighting and mood: authored a custom beacon shader that reads like a volumetric spotlight driving the focal beam.
  • Added a depth-based fog shader that fades scene detail using the depth buffer for a soft, readable horizon.
  • Tuned post-processing—contrast and color grading—to lock the cold coastal palette and sell the “lost in the mist” atmosphere.

Challenges

  • As a solo 48-hour scope, balancing readable beacon-driven direction, generation and route logic, and polished environmental presentation required tight prioritization and fast iteration.

Results & Impact

  • Delivered a complete Ludum Dare 59 entry with a playable build published on itch.io.

Tech Stack

Unity, C#, Git, Procedural Generation, Custom Shaders, Post-Processing, Lighting & Atmosphere

Links

Media

Beacon Bound screenshot 1 Beacon Bound screenshot 2 Beacon Bound gameplay gif 1 Beacon Bound gameplay gif 2

AbyssLonging (Ludum Dare 57)

Type: Game Jam
Role: Gameplay & Systems Programmer
Timeline: 2 days
Team Size: Solo

Overview: Procedurally generated dungeon game where players descend to lower floors using diverse abilities.

What I Built

  • Created the dungeon generation logic and progression flow for descending through procedurally structured floors.
  • Built a character controller with parkour elements tailored to vertical traversal and this level design style.
  • Designed and assembled ProBuilder levels to create a strong sense of massive megastructure spaces.

Project highlight

  • Used ProBuilder to rapidly prototype 10 playable levels shaped around the player’s movement abilities and traversal constraints.
  • Split content into simple and hard tiers; as difficulty ramps, the generator randomly selects the next authored stage from the pool that matches the current difficulty band.

Challenges

  • This was my first game jam, so the key challenge was delivering the full game in two days from initial concept to final itch.io upload.

Results & Impact

  • Completed playable jam entry with generated dungeon gameplay.
  • Reached the top 10% of games in that jam on my first attempt.

Tech Stack

Unity, C#, Git, ProBuilder

Links

Media

AbyssLonging screenshot 1 AbyssLonging screenshot 2

Commercial Projects

Love Blast: Block Puzzle

Type: Commercial
Role: Gameplay & Systems Programmer
Timeline: 1 year
Developers: 3
Total Team Size: 11 (dev + art + design + QA)

Overview: Implemented and expanded puzzle gameplay features for a released mobile title.

What I Built

  • Implemented core Block Blast-style gameplay with figure spawn logic, VFX, combo systems, and polished game feel.
  • Built a player retention system with continuous difficulty balancing and controlled figure drop behavior.
  • Built chat UI with Telegram-like animations and notifications, and added an Instagram-like gallery with custom animations.
  • Built REST API analytics integration and automated data pipeline streaming to BigQuery, generating retention/engagement reports and telemetry hooks that track player actions.
  • Built a 400-level progression system and created a Google Sheets pipeline where designers fill level data that is automatically imported into the game, including CSV import tools for rapid balance iteration.
  • Implemented a full tutorial system.
  • Created custom Unity Editor tools for technical artists and level designers: level editor with visual validation, automated asset validators, and content pipeline automation.

Project highlight

  • Built and maintained clean code with a full MVC-style separation, a clear entry point, and a structured initialization flow so gameplay, UI, and data stayed decoupled as scope grew.
  • Separated responsibilities into dedicated services and systems (purchases, ads, timers, progression, resources, and related live-ops areas) and composed them through Zenject (DI) for predictable lifetimes and easier testing.
  • Ran weekly code reviews and infrastructure planning sessions to evolve patterns, reduce coupling, and scale the project without turning the codebase into a bottleneck.

Challenges

  • The game went through several major redesign phases, and due to flexible architecture these changes were implemented quickly with minimal bugs.

Results & Impact

  • Delivered a large content pipeline with 400 levels, 20 characters, and 7 hotels.
  • Optimized resource management to reduce build size by 30% and improve startup speed by 20%.
  • Improved UI responsiveness and overall game feel, resulting in a 23% increase in user engagement and session duration.

Tech Stack

Unity, C#, Git, Zenject, UniTask, DoTween, Firebase, BigQuery, Custom Editor, Xcode, Android Studio, Memory Management, REST API Integration, Addressables, AppLovin

Links

Media

Love Blast screenshot 1 Love Blast screenshot 2 Love Blast screenshot 3 Love Blast screenshot 4 Love Blast screenshot 5 Love Blast screenshot 6

Slime Time

Type: Commercial
Role: Gameplay Programmer
Timeline: 1 month
Team Size: 4 people

Overview: Contributed gameplay features and monetization content for a mobile title.

What I Built

  • Created several new playable characters.
  • Implemented two paid bundles.
  • Built procedurally generated endless mode.

Project highlight

  • Joined a mostly complete production codebase and delivered new features while matching the team’s existing engineering style and conventions.
  • Refactored level creation around an abstract factory and object pooling, improving average frame rate by ~10% and making the pipeline cleaner for procedural endless mode work.

Challenges

  • Worked within an existing codebase and maintained quality through regular code review practices.

Results & Impact

  • Expanded character roster and purchasable content.
  • Added replayability with procedural endless mode.

Tech Stack

Unity, C#, Git, Procedural Generation, IAP Catalog

Links

Media

Slime Time screenshot 1 Slime Time screenshot 2 Slime Time screenshot 3

Pet Projects

Endless Zip

Type: Pet Project / Test Project
Role: Gameplay & Systems Programmer
Timeline: 4 days
Team Size: Solo

Overview: Fast-paced Unity test project delivered in 4 days with clean architecture and polished game feel.

What I Built

  • Core gameplay loop and control flow.
  • Modular systems with maintainable architecture boundaries.
  • Gameplay feedback tuning for responsive feel.

Project highlight

  • Built an animation choreography layer on UniTask that composes reusable tweens—bounce, appear/disappear, fade, move—as awaitable building blocks instead of one-off coroutine spaghetti.
  • Used it heavily on the win screen to script parallel and sequential beats (panel reveal, every button, particles) with a full intro cycle while staying data-driven and avoiding brittle hard-coded timelines.

Challenges

  • Delivered complete assignment quality in 4 days through strict feature prioritization and modular implementation sequence.
  • Kept clean architecture under time pressure by using consistent system boundaries and reusable components.

Results & Impact

  • All test task conditions completed in 4 days.
  • Project structure is ready for scaling and extension.

Tech Stack

Unity, C#, Git, UniTask, Clean Architecture, Modular Systems

Links

Media

Endless Zip screenshot

Skyroads

Type: Test Project
Role: Gameplay & Systems Programmer
Timeline: 3 days
Team Size: Solo

Overview: Test project delivered in 3 days with clean architecture and complete task requirements.

What I Built

  • Implemented required gameplay functionality for test scope.
  • Maintained clean and readable project architecture.
  • Provided project summary via README.

Project highlight

  • Drove the entire loop through a single global state machine with one tick path, so every frame is fully ordered and easy to reason about when debugging gameplay flow.
  • Wired the machine through a custom service locator instead of a heavy DI framework—deliberately lightweight, but still demonstrating I can stand up a small composition root quickly when the brief calls for it.

Challenges

  • To improve visual quality, I added a road-bending effect. This introduced rendering artifacts, which I fixed by manually increasing the object rendering bounds size.

Results & Impact

  • Delivered complete test project in 3 days.

Tech Stack

Unity, C#, Git, State Machine, Service Locator

Links

Media

Skyroads screenshot Skyroads gameplay screenshot 2

Commercial Projects (No Longer Available)

These projects were developed commercially but are currently unavailable in stores.

Samurai Warlords

Type: Commercial (Unreleased)
Role: Unity Developer
Company: Lumighost
Timeline: 1.5 years | Team Size: 5 people

Overview: Chess game with samurai warriors, 3D character customization, and multiplayer-ready gameplay systems.

What I Built

  • Replaced classic chess pieces with 3D samurai characters.
  • Implemented modular character customization (skins, weapons, armor) with preview system.
  • Created cutscene and capture effects systems, including synchronized transitions.
  • Built multiplayer client/server features with Photon.

Project highlight

  • Built a cutscene stack that combined Timelines, Cinemachine, and splines to choreograph camera moves and hit dramatic angles during captures and story beats.
  • For combat presentation, layered a third-party mesh-cutting solution with blood particle effects and decals so heavy hits read visceral without ballooning animation cost.

Reason It Is Not Available

The project did not reach release because it was an NFT project, and the clients decided to stop development.

Tech Stack

Unity, C#, Git, Photon, Timeline, Cinemachine, Splines

Media

Samurai Warlords screenshot 1 Samurai Warlords screenshot 2 Samurai Warlords screenshot 3 Samurai Warlords screenshot 4

Brain Bricks

Type: Commercial (Hidden from Stores)
Role: UI Developer
Company: BG Games
Period: April 2021 - September 2021

Overview: 2D casual puzzle game with new mechanics and improved level/content workflows.

What I Built

  • Implemented new gameplay mechanics and UI systems.
  • Refactored level data from hardcoded structures to ScriptableObjects.
  • Built progression and unlock flow with object pooling for smooth lists.

Project highlight

Migrated the entire playfield from Canvas space into world coordinates with SpriteRenderer-driven pieces so VFX, animation, and batching stayed cheaper to author—lifting average frame rate by ~15% while simplifying future content work.

Reason It Is Not Available

The project became unavailable because it was not updated for a long time, so it was hidden from stores.

Tech Stack

Unity, C#, Git, ScriptableObjects, SpriteRenderer, World-Space Gameplay

Media

Brain Bricks screenshot 1 Brain Bricks screenshot 2

Crokobit

Type: Commercial (Hidden from Stores)
Role: Core Systems Developer
Company: BG Games
Timeline: 5 months | Team Size: 8 people

Overview: Commercial mobile game listed in CV as released project; core systems were part of my contribution area.

What I Built

  • Built core progression systems: building/location upgrades with offline progress and parameterized level formulas.
  • Implemented boss AI with a custom multi-phase state machine and a flexible projectile combat system.
  • Developed balance/content tooling with ScriptableObject configs and CSV import for fast iteration.

Project highlight

  • Treated each city as its own scene, loaded asynchronously through Addressables when the player travels the world map; location upgrades swapped scenes by unloading the old instance and streaming in the upgraded layout.
  • Kept enemies and buildings simulating across those transitions because their business rules stayed decoupled from the view layer, so gameplay state did not reset when visuals rehydrated.

Results & Impact

  • Improved mass-combat performance by 40% using object pooling with warm-up.
  • Reduced memory usage by 60% with Addressables + additive loading while maintaining 60 FPS on low-end Android devices.
  • Increased player retention by 25% through accurate offline progress and idle mechanics.

Reason It Is Not Available

The project became unavailable because it was not updated for a long time, so it was hidden from stores.

Tech Stack

Unity, C#, Git, ScriptableObjects, Factory Pattern, State Machine, Object Pooling, Addressables, CSV Pipeline

Media

Crokobit screenshot 1 Crokobit screenshot 2 Crokobit screenshot 3