╔════════════════════════════════════════════════════════════════════════════╗
║ TURN-BASED BATTLE SYSTEM ARCHITECTURE ║
╚════════════════════════════════════════════════════════════════════════════╝
┌─────────────────────────────────────────────────────────────────────────┐
│ GAME APPLICATION LAYER │
├─────────────────────────────────────────────────────────────────────────┤
│ BattleSimulator (Interactive) BattleDemo (Automated) │
│ - Player input handling - AI decision making │
│ - Character selection - Automated demo │
│ - Turn prompt - Statistics display │
└─────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ BATTLE ENGINE CORE │
├─────────────────────────────────────────────────────────────────────────┤
│ Battle.java │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ Key Methods: │ │
│ │ • start() → determineTurnOrder() → initialize battle │ │
│ │ • executePlayerAction() → skill validation → execution │ │
│ │ • processStatusEffects() → update all active effects │ │
│ │ • endTurn() → shift turn, regenerate FP │ │
│ │ • isBattleFinished() → check victory conditions │ │
│ │ • displayStatus() → visual battle state │ │
│ └──────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────┘
│ │
│ │
▼ ▼
┌──────────────────────────────────────┐ ┌──────────────────────────────┐
│ State Management Layer │ │ Logging & Event Layer │
├──────────────────────────────────────┤ ├──────────────────────────────┤
│ BattleState (Enum) │ │ BattleLog.java │
│ - WAITING │ │ - Stores all actions │
│ - PLAYER1_TURN │ │ - Manages log records │
│ - PLAYER2_TURN │ │ - Display capabilities │
│ - FINISHED │ │ │
│ │ │ BattleAction.java │
│ Manages flow control & validation │ │ - Action metadata │
│ │ │ - Damage/Healing tracking │
│ │ │ - Timestamp recording │
└──────────────────────────────────────┘ └──────────────────────────────┘
│ │
└────────────────────┬─────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ CHARACTER & ENTITY LAYER │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ BaseCharacter (Abstract) │
│ ├─ name, HP, FP, ATK, DEF, SPD │
│ ├─ skills: List<Skill> │
│ ├─ activeEffects: List<StatusEffect> │
│ ├─ Methods: │
│ │ • takeDamage() / takeDamageWithMechanics() │
│ │ • heal() │
│ │ • useFocusPoints() / regenFocusPoints() │
│ │ • addEffect() / processEffects() / updateStatusEffects() │
│ │ • canMove() │
│ └─ getActiveEffectNames() │
│ │
│ Concrete Character Implementations: │
│ ├─ FireCharacter (HP:100, ATK:35, DEF:15, SPD:30) 🔥 │
│ ├─ WaterCharacter (HP:120, ATK:25, DEF:25, SPD:10) 💧 │
│ ├─ EarthCharacter (HP:140, ATK:25, DEF:30, SPD:5) 🌍 │
│ └─ WindCharacter (HP:90, ATK:30, DEF:10, SPD:50) 💨 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
│
└─────────────────────────────────┬──────────────────────────────┐
│ │
▼ ▼
┌───────────────────────────────────────────────────┐ ┌──────────────────┐
│ SKILL EXECUTION LAYER │ │ EFFECT SYSTEM │
├───────────────────────────────────────────────────┤ ├──────────────────┤
│ │ │ │
│ Skill (Interface) │ │ StatusEffect │
│ ├─ getName() │ │ ├─ apply() │
│ ├─ getFpCost() │ │ ├─ tick() │
│ └─ use(user, target) │ │ ├─ remove() │
│ │ │ └─ decreaseDur() │
│ Common Skills: │ │ │
│ ├─ AttackSkill (0 FP) │ │ Concrete Effects:│
│ ├─ GuardSkill (0 FP) │ │ ├─ BurnEffect │
│ └─ HealSkill (10 FP) │ │ │ (5 dmg/turn) │
│ │ │ ├─ FreezeEffect │
│ Elemental Skills (Special): │ │ │ (skip turn) │
│ ├─ FireballSkill (25 FP) → Burn Effect │ │ └─ AttackBuffEff│
│ ├─ IceBlastSkill (30 FP) → Freeze Effect │ │ │
│ ├─ RockThrowSkill (20 FP) │ │ EffectType Enum:│
│ └─ AirSlashSkill (25 FP) │ │ ├─ DAMAGE │
│ │ │ ├─ CROWD_CONTROL│
│ │ │ ├─ BUFF │
│ │ │ └─ DEBUFF │
│ │ │ │
└───────────────────────────────────────────────────┘ └──────────────────┘
│ │
└──────────────────────────────┬─────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────────┐
│ UTILITY LAYER │
├──────────────────────────────────────────────────────────────────────────┤
│ │
│ ElementalAdvantage (Utility) │
│ ├─ getMultiplier(attacker, defender) → 0.75, 1.0, or 1.5 │
│ └─ getEffectivenessMessage() │
│ │
│ ElementType (Enum) │
│ ├─ FIRE ──┐ │
│ ├─ WATER ──┼─ Rock-Paper-Scissors cycle │
│ ├─ EARTH ──┤ │
│ ├─ WIND ──┘ │
│ └─ NEUTRAL │
│ │
│ Constants.java (Configuration) │
│ │
└──────────────────────────────────────────────────────────────────────────┘
┌─────────────┐
│ START │
└──────┬──────┘
│
▼
┌──────────────────────────────┐
│ Create Battle(p1, p2) │
│ BattleState = WAITING │
└──────────┬───────────────────┘
│
▼
┌──────────────────────────────┐
│ battle.start() │
│ - determine Turn Order │
│ - check speed diff │
│ - if equal: coin flip │
└──────────┬───────────────────┘
│
▼
┌──────────────────────────────┐
│ Set CurrentState: │
│ PLAYER1_TURN or PLAYER2_TURN │
└──────────┬───────────────────┘
│
▼
┌──────────────┐
│ MAIN LOOP │
└──────────────┘
┌─────────────────────────────────────┐
│ displayStatus() │
│ - Show HP bars, FP bars │
│ - Show active effects │
│ - Show available skills │
└──────────────┬──────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ Check canMove() │
│ - Frozen? → Skip turn │
│ - Continue: get skill input │
└──────────────┬──────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ executePlayerAction(skillIndex) │
│ - Validate skill index │
│ - Check FP >= FpCost │
│ - Execute: skill.use(user, target) │
└──────────────┬──────────────────────┘
│
▼
┌────────────────┐
│ Skill Executes │
├────────────────┤
│ • Calculate damage
│ • Check dodge
│ • Check crit
│ • Apply elem bonus
│ • Apply defense
│ • Add effect
└────────┬───────┘
│
▼
┌─────────────────────────────────────┐
│ processStatusEffects() │
│ - Tick all active effects │
│ - Apply damage/effects │
│ - Remove expired effects │
└──────────────┬──────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ isBattleFinished()? │
│ - HP <= 0? → END BATTLE │
│ - Surrender? → END BATTLE │
│ - Continue: next turn │
└──────────────┬──────────────────────┘
│
▼
┌─────────────────────────────────────┐
│ endTurn() │
│ - Switch player (P1↔P2) │
│ - Increment turn counter │
│ - Regenerate FP (+10) │
└──────────────┬──────────────────────┘
│
Loop back to displayStatus()
┌──────────────────────┐
│ Raw Damage = ATK │
└──────────┬───────────┘
│
▼
┌──────────────────────────────────────┐
│ Check Critical Hit? │
│ Chance = Speed / 4.0 (max 25%) │
│ If crit: damage *= 1.5 │
└──────────┬─────────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ Apply Elemental Multiplier │
│ 0.75x (disadvantage) │
│ 1.0x (neutral) │
│ 1.5x (advantage) │
└──────────┬─────────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ Apply Defense │
│ finalDamage = damage - defense │
│ min(0) │
└──────────┬─────────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ Apply to Target HP │
│ target.HP -= finalDamage │
└──────────────────────────────────────┘
┌────────────────────────────────┐
│ dodgeChance = (defender.speed │
│ - attacker.speed) / 100 * 100│
│ max = 30% │
└──────────────┬─────────────────┘
│
▼
┌────────────────────────────────┐
│ random() * 100 < dodgeChance? │
│ YES → "Dodge! Attack missed" │
│ NO → Damage applied │
└────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ Battle │◄────────│ BattleState │ │
│ ├──────────────┤ └──────────────┘ │
│ │ - state │ │
│ │ - turnCount │ ┌──────────────┐ │
│ │ - player1 │◄────────│ BaseCharacter│ │
│ │ - player2 │ └──────────────┘ │
│ │ - battleLog │◄────────┐ │
│ └──────────────┘ │ │
│ │ │ │
│ ▼ │ │
│ ┌──────────────┐ │ │
│ │ BattleLog │ │ │
│ ├──────────────┤ │ │
│ │ - actions[] │ │ │
│ └──────────────┘ │ │
│ │ │ │
│ ▼ │ │
│ ┌──────────────┐ │ │
│ │BattleAction │ │ │
│ ├──────────────┤ │ │
│ │ - actor │ │ │
│ │ - skill │ │ │
│ │ - damage │ │ │
│ └──────────────┘ │ │
│ │ │
│ BaseCharacter◄────┘ │
│ ├─ FireCharacter │
│ ├─ WaterCharacter │
│ ├─ EarthCharacter │
│ ├─ WindCharacter │
│ │ │
│ ├─ skills: List◄────┐ │
│ │ │ │
│ │ ┌─────────────┴──────────────┐ │
│ │ │ │ │
│ │ ▼ ▼ │
│ │ Skill (Interface) │ │
│ │ ├─ AttackSkill │ │
│ │ ├─ GuardSkill │ │
│ │ ├─ HealSkill │ │
│ │ └─ *Elemental Skills │ │
│ │ ├─ FireballSkill │ │
│ │ ├─ IceBlastSkill │ │
│ │ ├─ RockThrowSkill │ │
│ │ └─ AirSlashSkill │ │
│ │ │ │
│ └─ activeEffects: List◄───────────┤ │
│ │ │
│ StatusEffect (Abstract)◄─────┘ │
│ ├─ BurnEffect │
│ └─ FreezeEffect │
│ │
└─────────────────────────────────────────────────────────────┘
Purpose: Track battle state transitions
Implementation: Enum BattleState {WAITING, PLAYER1_TURN, ...}
Benefit: Clear state management, prevents invalid transitions
Purpose: Different skill implementations
Implementation: Skill interface with multiple implementations
Benefit: Easy to add new skills, polymorphic execution
Purpose: Record and replay events
Implementation: BattleLog observes all actions
Benefit: Decoupled logging, can extend with reports
Purpose: Define battle character structure
Implementation: Abstract class with abstract methods
Benefit: Consistent character interface, customizable skills
Purpose: Add effects to characters
Implementation: StatusEffect wrapper pattern
Benefit: Can stack effects, easy to add new effects
Purpose: Create character instances
Implementation: Switch statement creating characters
Benefit: Centralized character creation
| Operation | Complexity | Notes |
|---|---|---|
| Turn execution | O(n) | n = number of active effects |
| Skill selection | O(1) | Direct array access |
| Damage calculation | O(1) | Fixed set of operations |
| Battle log | O(1) | Capped at 100 entries |
| Status effect update | O(n) | n = active effects (usually 1-3) |
| Victory check | O(1) | Simple HP comparison |
Memory: ~5-10 KB per battle (excluding display)
Current implementation: Single-threaded
- All operations happen sequentially
- No concurrent modifications
If future multiplayer online:
- Use synchronized collections
- Add thread-safe queue for battle commands
- Implement message passing for turn validation
Level 1: Current (Single Player, 1v1)
├─ Interactive mode: ✅
└─ Demo mode: ✅
Level 2: Local Multiplayer
├─ Split screen display
├─ Controller input support
└─ Tournament mode
Level 3: Online Multiplayer
├─ Network serialization
├─ Latency compensation
└─ Server-side battle validation
Level 4: Advanced Features
├─ Item system
├─ Leveling/Experience
├─ Skill trees
└─ Campaign mode
Level 5: Meta Game
├─ Rank/Rating system
├─ Cosmetics/Skins
├─ Seasonal updates
└─ Esports integration
Development:
├─ mvn clean compile
├─ mvn test
└─ java -cp target/classes com.game.battle.BattleSimulator
Distribution:
├─ mvn package
├─ java -jar target/TurnBaseGameJava-1.0-SNAPSHOT.jar
└─ OR create standalone executable with Maven Assembly Plugin
Architecture Version: 1.0 Last Updated: 2025 Status: Production Ready ✅