A 2.5D turn-based RPG built in C++ with a custom engine, featuring Octopath Traveler-inspired isometric visuals and deep gameplay systems. This project showcases expertise in game systems architecture, turn-based combat design, attribute-based mechanics, and data-driven content pipelines.
Gameplay Trailer
Core Systems
Turn-Based Combat Architecture — Designed and implemented a complete turn-based combat system using state machine patterns. The TurnBaseSubsystem orchestrates combat flow through distinct states (Round, SkillSelection, SkillExecution, BattleSettlement), enabling complex turn sequences and AI decision-making.
Attribute-Driven Mechanics — Built a comprehensive RPG attribute system where character stats (Health, Mana, Attack, Defense, Speed) drive all gameplay calculations. Attributes influence initiative ordering, damage calculations, and skill effectiveness, creating emergent gameplay depth.
Character Skill System — Implemented a flexible skill framework supporting character-specific abilities with distinct animations, mana costs, and effects. Skills integrate seamlessly with the combat state machine and trigger synchronized animation sequences.
Data-Driven Content Pipeline — Architected an XML-based configuration system enabling designers to create characters, skills, dungeons, and maps without C++ compilation. Implemented robust parsing and validation systems for rapid content iteration.
2.5D Lighting & Rendering — Engineered a dynamic lighting system with real-time sun direction, intensity, and ambient light adjustments. Implemented proper depth sorting and sprite rendering for authentic 2.5D visuals.
Physical Simulation & Collision — Built an actor-based physics system with collision detection and response. Implemented proper 2.5D space navigation with depth-aware collision handling.
Sprite Animation Framework — Designed a state-driven animation system supporting hierarchical animation playback. Implemented frame-perfect synchronization between animations and combat state transitions.
Comprehensive UI System — Built a complete HUD system including battle UI, skill selection, target selection, turn sequence visualization, and progression indicators.
System Architecture
graph TD
Game["Game - State Machine"]
Clock["Clock - Time Management"]
PlayerCtrl["PlayerController - Input Handling"]
TurnBase["TurnBaseSubsystem - Turn Management"]
BattleState["Battle States - State Stack"]
Initiative["Initiative Queue - Action Ordering"]
Character["Character - Battle Entity"]
Skills["Skill System - Ability Execution"]
Buffs["Buff System - Status Effects"]
PakData["PakData - XML Parsing"]
Definitions["Definitions - Character/Skill/Dungeon"]
Map["Map System - Scene Generation"]
Scene["Scene - 2.5D Rendering"]
Animation["Animation System - State-Driven Playback"]
Lighting["Lighting System - Dynamic Illumination"]
WidgetSubsystem["WidgetSubsystem - Widget Management"]
BattleUI["Battle UI - HUD Widgets"]
SkillUI["Skill UI - Selection & Targeting"]
Game --> TurnBase
Game --> PlayerCtrl
Game --> Clock
Game --> Scene
TurnBase --> BattleState
BattleState --> Initiative
Initiative --> Character
Character --> Skills
Character --> Buffs
Character --> Animation
Skills --> Definitions
Character --> Definitions
PakData --> Definitions
Map --> PakData
Scene --> Map
Scene --> Lighting
Scene --> Animation
WidgetSubsystem --> BattleUI
WidgetSubsystem --> SkillUI
BattleUI --> Character
SkillUI --> SkillsTurn-Based Combat System
The TurnBaseSubsystem orchestrates turn-based combat through a hierarchical state machine. Combat flows through distinct phases: Round initialization calculates initiative, SkillSelection allows player input, SkillExecution resolves actions, and BattleSettlement handles victory/defeat conditions.
Initiative & Action Ordering
Characters roll initiative at battle start based on Speed attributes. The system maintains an ordered queue determining action sequence. This creates dynamic turn ordering where player decisions influence future turns.
Skill Execution Pipeline
Skills trigger character-specific animations synchronized with combat state. The system validates skill prerequisites (mana cost, cooldown), applies effects, and broadcasts results to UI systems.
2.5D Scene & Lighting System
Implemented a dynamic lighting system enabling real-time adjustments to sun direction, intensity, and ambient light. The system creates atmospheric transitions and enhances visual storytelling through lighting design.
Scene Transitions & Level Progression
Implemented seamless transitions between exploration and battle scenes. The system manages camera positioning, lighting adjustments, and UI state changes during scene transitions.
User Interface System
Built a comprehensive UI system managing all player interactions. The system includes main menu, skill selection, target selection, turn sequence visualization, and level progression indicators.
Level Progression & Unlocking
Implemented a level progression system with unlock mechanics. Players progress through dungeons, unlocking new levels as they complete objectives. The system provides clear UI feedback for locked/unlocked states.
Data-Driven Architecture
The entire game content pipeline is driven by XML configuration files. Character definitions specify stats, skills, and animations. Skill definitions include mana costs, cooldowns, and effects. Dungeon definitions configure encounters and progression. This architecture enables rapid content iteration without recompilation.
XML Configuration System
<!-- Character Definition Example -->
<Character name="Warrior" health="100" mana="30" attack="15" defense="10" speed="8">
<Skill name="BasicAttack" manaCost="0" cooldown="0" />
<Skill name="PowerStrike" manaCost="20" cooldown="2" />
</Character>
<!-- Dungeon Definition Example -->
<Dungeon name="Forest Ruins" scene="ForestScene" preRequest="None">
<Enemy name="Goblin" healthMultiplier="1.0" damageMultiplier="1.0" />
<Enemy name="Orc" healthMultiplier="1.5" damageMultiplier="1.2" />
</Dungeon>Map Generation from Image Data
Maps are generated from image files where each pixel represents a tile. This enables rapid level design and visual consistency between design and implementation.
Design Philosophy
Modular State Architecture — The turn-based system uses a state stack pattern enabling complex turn sequences while maintaining clean separation of concerns. Each state handles specific combat phases independently, making the system extensible for new combat mechanics.
Attribute-Centric Design — All gameplay mechanics derive from character attributes. This creates emergent gameplay where attribute relationships drive combat depth without hard-coded special cases.
Data-Driven Extensibility — XML configuration enables designers to create content without C++ knowledge. The parsing system validates all data, preventing runtime errors from malformed configurations.
Event-Driven Communication — Systems communicate through events rather than direct references. This decouples combat logic from UI, animation, and audio systems, enabling independent iteration and testing.
Performance-Conscious Architecture — The system uses efficient data structures and algorithms. Initiative calculations use simple comparisons; state transitions are O(1); animation lookups use hash maps for constant-time access.
Debuggable Systems — All major systems include debug visualization and console commands. Turn sequences can be inspected; attribute modifiers can be traced; skill effects can be validated without gameplay.