Boundary Breaker

Position

Programmer, Game Designer, Project Manager

Description

Boundary Breaker is a hybrid 2D plane fighting game using 3D models, engineered as a technical crossover blending traditional anime fighter mechanics with percentage-based platformer knockback scaling.

Our core design goal was to deliver a high-stakes, fast-paced combat demo focused on launching opponents through destructible holographic barrier walls.

Serving as the lead gameplay programmer, project manager, and co-designer, I focused on building the project's core framework. My contributions centered on designing and coding a custom Hierarchical Finite State Machine, calculating frame-perfect physics and vector-based knockback scaling, and resolving character bone-structure configurations to align custom 3D animations with Unity's Humanoid avatar skeleton.

Project period

5 month

Project type

2D Fighting Game

Used Software

Unity, Rider, Sourcetree

Team Size

Programming

Github Project

Itch.io

Moves Field

Designer Friendly Attack Data Architecture

Inspector-Driven Move Database: Engineered a highly customizable attack configuration architecture within the Unity Inspector, exposing critical fighting game variables (Damage, Stun, Hit-Stop and Knockback Vectors) as modular array entries.
Advanced Physics & Combo Logic: Integrated structural gameplay flags directly into the data fields, giving designers control over Fixed Knockback scaling (for combo retention), Combo Prevention rules (combo enders), Knockdown triggers and Inverted Pull-In vectors.
Context-Menu Automation Tooling: Built a custom Unity editor extension featuring a script context-menu command that automatically parses animation files to extract total frame counts, streamlining the design workflow.

Visual Frame Data Analysis & Color Coding

Diegetic Fighting Game Timings: Programmed a visual frame checker that breaks down indiviudal attack animations into the three core phases of fighting game design: Startup, Active, Recovery.
Intuitive Frame Windows: Implemented slider-based editor tools to accurately define frame-perfect hit windows, allowing rapid iteration and immediate visual confirmation of move metrics inside the engine.

Modular Hitbox & Hurtbox Generation

Color-Coded Collision States: Scripted a dynamic, real-time debugging layer for custom-generated phsysics volumes, utilizing distinct colors to instantly identify Inactive states, Open Collision phases and Active Colliding frames.
Modular Character Anchors: Designed decoupled input fields for assigning character specific Hitboxes and Hurtboxes per move, ensuring accurate frame-by-frame spacing, hurtbox exposure during attack and clean phsycial interactions.

Character Pool

Seamless Match Transition via Character Pooling

Single Scene Architecture: Integrated a character pooling system that allows the character selection screen and the actual combat match to exist within the exact same Unity scene, eliminating loading screens.
Pre-Cached Fighter Loading: Pre-spawned the underlying character prefabs during the selection phase, enabling an instant transition into the match by simply switching the UI layer and activating the selected fighter models.
Scalable Architecture: Designed the pool around decoupled prefabs, ensuring that new characters can be injected into the selection-to-combat data pipeline with zero code modifications.

Player State Machine

Hierarchical Finite State Machine Architecture

Hierarchical State Execution: Engineered a custom Hierarchical Finite State Machine from scratch utilizing a decoupled architecture with explicit "EnterState", "UpdateState" and "ExitState" lifecycles.
Root & Sub-State Layering: Implemented a multi-layered state structure separating global Root States (e.g. Grounded, Airborne) from localized Sub-States (e.g. Attacking, Dashing) to allow seamless sub-state switching without disrupting core root logic and phsysics calculations.
Factory Pattern Integration: Utilized a Player State Factory to centralize state initialization, memory allocations and instance management, ensuring predictable state transitions and preventing loose reference dependencies.
Deterministic Gameplay & Debugging: Established a strict, modular rule set dictating valid action windows per state, drastically isolating edge-case bugs and streamlining the technical debugging pipeline during development.

Holo Wall Shader Graph

Scanlines and Intersection

Reactive Holographic Shader Architecture

Layered Scanline & Intersection Effects: Engineered a cyberpunk inspired hologram material featuring high-frequency scanlines and dynamic depth-based intersection highlights to emphasize spatial contact where the barrier meets other world geometry.
Edge Glow & Projection Animation: Developed an emissive fresnel edge glow paired with a slow-moving, large-scale scanline loop to simulate an active, generator-projected forcefield aesthetic.
Texture Depth & Height Mapping: Utilized the core barrier texture as a displacement heightmap directly within the graph to introduce tactile micro-depth, breaking up the flat look of the 2D plane.

Dynamic Collision & Dissolve Mechanics

Procedural Collision Ripples: Integraded a localized wave-distortion algorithm that dynamically spawns expandable impact ripples extending outward from the exact vector position where a player hits the wall.
State-Driven Dissolve Effect: Programmed a dynamic destruction sequence triggered by high-knockback gameplay events, blending a structural dissolve mask with a radiant red color shift that disintegrates the barrier starting from the initial point of impact.