top of page
Anchor 1

Magical Block Adventure

Overview

Magical Block Adventure is an original character-driven falling-block battle RPG built in Unity. It combines modern block-drop mechanics with fighting-game-style abilities, CPU opponents, local competitive play, and story chapters that transition directly into magical puzzle battles.


I created the game’s design and technical architecture, including the board simulation, match flow, magic system, opponent AI, story integration, save data, input handling, UI, telemetry, automated tests, and balance tooling.


Role

Creator · Game Designer · Gameplay Systems Engineer


Team

Solo development

AI-assisted production using Claude and OpenAI Codex


Timeline

2026 · Ongoing independent development


Tech Stack

Unity 6 · C# · Universal Render Pipeline · Unity Input System · ScriptableObjects · Yarn-Authored Narrative Content · Sentry Telemetry · Unity Test Framework · Headless .NET Simulation Tools · Git


Gameplay Goal

The central design challenge was turning a familiar falling-block game into a character-driven competitive battle system.

Each player’s stack functions as their health bar: a low board is healthy, while reaching the ceiling causes a knockout. Clearing lines generates attacks and charges mana, allowing players to cast offensive or defensive spells. Pending garbage can be cancelled through skilled play, making every exchange a combination of execution, resource management, and tactical decision-making.

The vertical slice supports story battles, Sprint, Marathon, three CPU difficulty levels, and local two-player matches.


Core Board & Match Systems

I implemented the complete falling-block ruleset, including:

  • Seven-bag piece randomization

  • SRS rotation states and wall kicks

  • Hold and next-piece queues

  • Ghost pieces

  • Soft and hard drops

  • Gravity, lock delay, scoring, and level progression

  • Combo-based attacks

  • Garbage delivery and cancellation

  • Shared piece sequencing for competitive matches

  • Top-out and winner resolution

  • Sprint, Marathon, CPU-versus, and local-versus rules

The board logic is separated from presentation so it can be cloned, tested, evaluated by the CPU, and reused by the external balance simulator.


Magic & Ability Architecture

Clearing lines charges mana, while special gold blocks provide additional rewards when their rows are cleared. Each character equips offensive and defensive abilities that can alter either board, cancel incoming pressure, or create temporary effects.


The current data-driven ability library contains 14 spells implemented through ScriptableObjects. Effects include garbage attacks, board displacement, repair, protective wards, counterattacks, persistent damage, and temporary constraints.


A major design problem was that stack height represents health. An attack that simply removes an opponent’s blocks can accidentally heal them. I addressed this by developing a formal offensive and defensive design framework, adding gameplay invariants, measuring before-and-after board damage, and redesigning abilities around reliable verbs such as adding, displacing, constraining, repairing, and protecting.


CPU & Balance Tooling

I built a deterministic heuristic CPU that evaluates possible placements using board height, holes, bumpiness, line clears, and next-piece information.

Difficulty is expressed through behavior rather than arbitrary stat bonuses:

  • Thinking and movement delays

  • Placement-quality ranges

  • Intentional mistakes

  • Look-ahead strength

  • Pressure-based decision degradation

  • Tactical offensive and defensive spell usage

I also created a headless CPU-versus-CPU simulator that compiles the real gameplay sources outside Unity. It supports reproducible, mirrored-seed experiments across the complete 49-loadout ability matrix and exports trial data, matchup results, rankings, and slot-level aggregates for analysis.


Story, Progression & Save Systems

I developed a narrative pipeline that connects Yarn-authored dialogue with gameplay without coupling the story layer to board internals.

The current story framework includes:

  • A four-chapter Lyra campaign route

  • Dialogue choices

  • Named story encounters

  • Branching win and loss scenes

  • Five data-driven battle stages

  • Story-to-battle transitions

  • Chapter progression and unlock handling

  • Ten save slots

  • Per-chapter and total playtime tracking

  • Match and character statistics

Save data is written through an abstract JSON storage layer using recoverable temporary-file replacement. Invalid, damaged, incompatible, or out-of-date saves are detected and rejected safely instead of breaking the game.


Player Experience Systems

I implemented the supporting systems required to turn the battle prototype into a complete vertical slice:

  • Screen routing and menu-state architecture

  • Character, ability, and stage selection

  • Pixel-aligned 640×480 presentation

  • Character portraits and battle reactions

  • Spell travel, impact, line-clear, and board-shake effects

  • Keyboard and gamepad support

  • Per-player control rebinding

  • Dynamic keyboard and controller prompts

  • Audio, display, fullscreen, VSync, and quality settings

  • Pause, rematch, confirmation, and return-to-title flows


Systems I Personally Implemented

Deterministic board model and complete falling-block rules

  • Match orchestration and game-mode handling

  • Garbage, combo, mana, and ability systems

  • Data-driven characters, abilities, pieces, and stages

  • CPU placement and spell-decision logic

  • Headless balance simulation and CSV reporting

  • Story campaign and battle integration

  • Save slots, statistics, and progression data

  • Input routing and complete control rebinding

  • Menu, HUD, portrait, and feedback systems

  • Sentry-backed battle telemetry and invariant reporting

  • Unity editor tools for authoring and validating content

  • Automated EditMode test coverage


AI-Assisted Development Workflow

I used Claude and OpenAI Codex as pair-programming and production tools throughout development. They helped accelerate implementation, refactoring, test scaffolding, editor tooling, documentation, content workflows, and technical investigation.


I remained responsible for the product vision, gameplay design, architecture, task specifications, code review, integration, debugging, playtesting, balance decisions, and final implementation. AI-assisted work was validated through Unity testing, a 90-test EditMode suite, deterministic simulation, runtime telemetry, and hands-on gameplay evaluation.


Technical Ownership

As the project’s solo creator, I defined the product direction, system boundaries, development milestones, and validation strategy.

I replaced the original monolithic prototype architecture with modular screen, match, model, input, data, and presentation layers. This made it possible to expand the game with new abilities, characters, stages, story chapters, and custom piece definitions without rewriting the core match loop.


Impact

Built a playable vertical slice spanning story, solo, CPU-versus, and local-versus play

  • Implemented a modern falling-block ruleset with deterministic, testable board logic

  • Created a 14-ability battle system with data-driven characters and loadouts

  • Developed a four-chapter story pipeline with five reusable battle stages

  • Built a behavior-driven CPU with three difficulty profiles

  • Created a reproducible headless balance simulator covering the full 49-loadout matrix

  • Established a 90-test EditMode suite across gameplay, saves, menus, input, story, and UI behavior

  • Added production-oriented telemetry, invariant monitoring, and resilient save handling

  • Demonstrated disciplined AI-assisted development through specification, review, testing, measurement, and iteration


Media & Links

Playable Build: https://davon92.itch.io/magical-block-adventure

GitHub: https://github.com/davon92/Tetris

Code Samples: Available on request

bottom of page