Animal animal = new Dog();
animal.makeSound();

                 OOP KNOWLEDGE
                       │
                       ↓
              ┌─────────────────┐
              │   OOP CHARACTERS│
              └────────┬────────┘
                       │
                       ↓
              ┌─────────────────┐
              │  BATTLE ENGINE  │
              └────────┬────────┘
                       │
             ┌─────────┴─────────┐
             ↓                   ↓
       PLAYER ACTION          BUG AI
             │                   │
             └─────────┬─────────┘
                       ↓
               ADAPTIVE AI
                       │
                       ↓
               BATTLE RESULT
                       │
                       ↓
                  DATABASE

Player Actions
      ↓
Behavior Tracking
      ↓
Pattern Analysis
      ↓
Prediction
      ↓
AI Decision
      ↓
Enemy Action

Attack → Attack → Defense → Attack → Attack

Counter / Defense / Punish

Defense → Skill → Defense → Skill

Easy
Normal
Hard

Easy ────────→ Adaptive ────────→ Hard
                  ↑
                  │
          Player behavior

Class
Object
Abstraction
Inheritance
Polymorphism
Interface

class Animal {}
class Dog extends Animal {}

Đề bài
↓
Code
↓
Compile
↓
Output

Action
↓
Consequence
↓
Feedback
↓
Strategy
↓
Reward

                 ┌──────────────────────┐
                 │      OOP ARENA       │
                 │                      │
Player ──────────┤ Manage Profile       │
                 │                      │
Player ──────────┤ Learn OOP            │
                 │                      │
Player ──────────┤ Select Character     │
                 │                      │
Player ──────────┤ Start Battle         │
                 │        │             │
                 │        ↓             │
                 │   Adaptive AI        │
                 │                      │
Player ──────────┤ Use Skill            │
                 │                      │
Player ──────────┤ Answer Quiz          │
                 │                      │
Player ──────────┤ View Statistics      │
                 └──────────────────────┘

Start Battle
     │
     ├── Select Character
     │
     ├── Initialize Battle
     │
     ├── Player Turn
     │      ├── Normal Attack
     │      ├── Use Skill
     │      ├── Defense
     │      └── Special Action
     │
     ├── AI Turn
     │      ├── Analyze Behavior
     │      ├── Predict Action
     │      └── Select Counter
     │
     ├── Calculate Damage
     │
     ├── Check Status
     │
     └── End Battle

Mở ứng dụng
      ↓
Main Menu
      ↓
Chọn Battle
      ↓
Chọn Character
      ↓
Chọn Enemy
      ↓
Khởi tạo Battle
      ↓
Player Turn
      ↓
Player Action
      ↓
Record Behavior
      ↓
AI Analysis
      ↓
AI Action
      ↓
Calculate Result
      ↓
Check HP
   ↙       ↘
HP > 0    HP = 0
  ↓          ↓
Next Turn   End Battle
             ↓
        Save Statistics

Character Locked
      ↓
Display Requirement
      ↓
Return Character Selection

Player Action
Current HP
Enemy HP
Available Skills
Previous Actions
Turn Number
Battle State

Collect Data
      ↓
Build Behavior Profile
      ↓
Calculate Action Probability
      ↓
Predict Next Action
      ↓
Evaluate Counter Actions
      ↓
Select Best Action
      ↓
Execute

ATTACK
DEFEND
SPECIAL
COUNTER
HEAL

New Character
New Skill
New Boss
New Game Mode
New AI Strategy

public class Character {
    private int hp;

    public int getHp() {
        return hp;
    }

    public void takeDamage(int damage) {
        if (damage < 0) {
            throw new IllegalArgumentException();
        }

        hp = Math.max(0, hp - damage);
    }
}

public abstract class Character {
    public abstract void performAction();
}

Character
   │
   ├── EncapsulationHero
   ├── InheritanceHero
   ├── PolymorphismHero
   └── InterfaceHero

Character character;

character = new EncapsulationHero();
character.attack();

character = new PolymorphismHero();
character.attack();

public enum ActionType {
    ATTACK,
    DEFEND,
    SKILL,
    HEAL
}

Turn 1 → ATTACK
Turn 2 → ATTACK
Turn 3 → SKILL
Turn 4 → ATTACK
Turn 5 → DEFEND

Attack: 60%
Skill: 20%
Defense: 15%
Heal: 5%

             Next Action

          A       D       S       H

A       0.60    0.10    0.20    0.10
D       0.20    0.50    0.20    0.10
S       0.40    0.10    0.40    0.10
H       0.30    0.20    0.10    0.40

ATTACK = 60%
SKILL  = 20%
DEFEND = 10%
HEAL   = 10%

Player Win Rate
Damage Dealt
Damage Received
Average Turn
Skill Usage
Defense Rate

Difficulty ↑

Difficulty ↓

┌─────────────────────────────┐
│        Presentation         │
│          JavaFX             │
├─────────────────────────────┤
│        Application          │
│      Controllers            │
├─────────────────────────────┤
│          Domain             │
│ Characters / Battle / AI    │
├─────────────────────────────┤
│       Infrastructure        │
│ SQLite / Repository         │
└─────────────────────────────┘

UI ≠ Game Logic ≠ AI ≠ Database

                    JavaFX UI
                        │
                        ↓
                  Controllers
                        │
            ┌───────────┼───────────┐
            ↓           ↓           ↓
       BattleService  QuizService  PlayerService
            │
            ↓
        BattleEngine
            │
      ┌─────┴─────┐
      ↓           ↓
 Player         Enemy
      │           │
      │        AdaptiveAI
      │           │
      └─────┬─────┘
            ↓
       ResultService
            ↓
       Repository
            ↓
         SQLite

src/main/java/com/ooparena/
│
├── app/
│   └── OOPArenaApplication.java
│
├── controller/
│   ├── MainController.java
│   ├── BattleController.java
│   ├── CharacterController.java
│   ├── QuizController.java
│   └── StatisticsController.java
│
├── model/
│   ├── character/
│   ├── enemy/
│   ├── battle/
│   ├── skill/
│   ├── quiz/
│   └── player/
│
├── ai/
│   ├── AdaptiveAI.java
│   ├── BehaviorTracker.java
│   ├── PatternAnalyzer.java
│   ├── ActionPredictor.java
│   └── DifficultyManager.java
│
├── service/
│   ├── BattleService.java
│   ├── PlayerService.java
│   ├── QuizService.java
│   └── StatisticsService.java
│
├── repository/
│   ├── PlayerRepository.java
│   ├── BattleRepository.java
│   └── StatisticsRepository.java
│
├── database/
│   ├── DatabaseManager.java
│   └── SchemaInitializer.java
│
├── exception/
│   ├── InvalidActionException.java
│   ├── CharacterLockedException.java
│   └── BattleStateException.java
│
├── util/
│   ├── RandomUtils.java
│   └── ValidationUtils.java
│
└── view/
    └── ...

╔════════════════════════════════════╗
║          OOP ĐẠI CHIẾN             ║
║                                    ║
║          ⚔ PLAY BATTLE             ║
║                                    ║
║          📚 OOP ACADEMY            ║
║                                    ║
║          🧬 CLASS LAB              ║
║                                    ║
║          📊 STATISTICS             ║
║                                    ║
║          ⚙ SETTINGS                ║
╚════════════════════════════════════╝

┌─────────────────────────────────────────┐
│ SELECT YOUR OOP HERO                    │
├────────────┬────────────┬───────────────┤
│ 🛡️         │ 🧬         │ 🎭             │
│ Encapsulate │ Inheritance│ Polymorphism  │
│             │            │               │
│ DEFENSE 95  │ ATK 90     │ SPEED 95      │
│             │            │               │
│ [SELECT]    │ [SELECT]   │ [SELECT]      │
└────────────┴────────────┴───────────────┘

┌───────────────────────────────────────────┐
│               BOSS BATTLE                 │
│                                           │
│     PLAYER                  BOSS           │
│                                           │
│   🛡️ HERO               💀 NULL BEAST     │
│   ██████████             ████████         │
│   HP 100/100              HP 150/150      │
│                                           │
│              TURN 05                      │
│                                           │
│ ┌────────┐ ┌────────┐ ┌────────┐          │
│ │ ATTACK │ │ SKILL  │ │ DEFEND │          │
│ └────────┘ └────────┘ └────────┘          │
│                                           │
│ AI ANALYSIS: ████████                     │
└───────────────────────────────────────────┘

┌───────────────────────────┐
│ AI BEHAVIOR ANALYSIS      │
├───────────────────────────┤
│ Attack       ███████ 65%  │
│ Skill        ███      20% │
│ Defense      ██       10% │
│ Heal         █         5% │
│                           │
│ Predicted: ATTACK         │
│ Confidence: 65%           │
└───────────────────────────┘

oop_arena.db

Player
------------------
id
username
level
experience
created_at

Character
------------------
id
name
type
hp
attack
defense
unlocked

Battle
------------------
id
player_id
character_id
enemy_id
result
turn_count
damage_dealt
damage_taken
started_at
ended_at

ActionHistory
------------------
id
battle_id
turn_number
actor
action_type
timestamp

Skill
------------------
id
name
type
damage
cooldown
description

Player
  │
  └────< Battle
             │
             ├──── Character
             │
             ├──── Enemy
             │
             └────< ActionHistory

BehaviorTracker
+
PatternAnalyzer
+
ActionPredictor
+
DifficultyManager

Character
     ↓
Choose Skill
     ↓
Battle Engine
     ↓
Damage Calculation
     ↓
Enemy Reaction

╔══════════════════════════════════╗
║          QUIZ ATTACK             ║
╠══════════════════════════════════╣
║ Which concept hides internal     ║
║ implementation details?          ║
║                                  ║
║ A. Inheritance                   ║
║ B. Encapsulation                 ║
║ C. Polymorphism                  ║
║ D. Generic                       ║
╚══════════════════════════════════╝

+30 DAMAGE

-10 HP

Polymorphism

        Character
            ▲
     ┌──────┼──────┐
     │      │      │
    Dog    Cat    Bird
     │      │      │
   bark() meow() sing()

Attributes
Methods
Inheritance
Override
Interface

Turn 1 ATTACK
Turn 2 ATTACK
Turn 3 ATTACK
Turn 4 ATTACK

Attack probability = 82%

→ Boss switches to Counter Mode

@Test
void characterCannotHaveNegativeHp() {
    Character hero = new EncapsulationHero();

    hero.takeDamage(9999);

    assertEquals(0, hero.getHp());
}

ATTACK
ATTACK
ATTACK
ATTACK
ATTACK

Predicted action = ATTACK

DEFEND
DEFEND
DEFEND
DEFEND

Predicted action = DEFEND

UI
 ↓
Controller
 ↓
BattleService
 ↓
BattleEngine
 ↓
AI
 ↓
Repository
 ↓
Database

OOP-Arena/
├── oop-arena.jar
├── config/
├── database/
│   └── oop_arena.db
└── README.md

java -jar oop-arena.jar

OOP → textbook → code

OOP
 ↓
Character
 ↓
Skill
 ↓
Battle
 ↓
Consequence

Player behavior

Adaptive enemy behavior

Aggressive
Attack-heavy

Defensive
Skill-heavy

+50 XP
Unlocked: POLYMORPHISM

Game Character
      ↓
Abstract Class
      ↓
Inheritance
      ↓
Override
      ↓
Polymorphism

Abstract Class
Inheritance
Encapsulation
Polymorphism
Interface
Generic
Exception
Collection

BattleEngine

public interface EnemyStrategy {
    Action chooseAction(BattleState state);
}

RandomStrategy
AggressiveStrategy
DefensiveStrategy
AdaptiveStrategy

EnemyStrategy strategy;

EnemyStrategy
├── RandomStrategy
├── AggressiveStrategy
├── DefensiveStrategy
└── AdaptiveStrategy

CharacterFactory.create("POLYMORPHISM");

HP changed
Battle state changed
Turn changed

Class
Object
Inheritance
Abstraction
Encapsulation
Polymorphism
Interface
Exception
Generic

Player vs Player

Global OOP Ranking

Random abilities
Random weaknesses
Random patterns

Chapter 1
   ↓
Chapter 2
   ↓
...
Chapter 13

Create Profile
     ↓
Enter Username
     ↓
Validate
     ↓
Save

Open Character Menu
        ↓
View Characters
        ↓
View Stats
        ↓
Select Character
        ↓
Confirm

Select Concept
      ↓
View Character
      ↓
View OOP Principle
      ↓
View Example

Select Character
      ↓
Select Enemy
      ↓
Initialize Battle
      ↓
Start Turn

Player
  ↓
Attack
  ↓
BattleEngine
  ↓
Calculate Damage
  ↓
Enemy.takeDamage()
  ↓
Update UI

Player
  ↓
Select Skill
  ↓
Validate Cooldown
  ↓
Execute Skill
  ↓
Apply Effect
  ↓
Update Battle State

Show Question
      ↓
Player Answer
      ↓
Validate Answer
      ↓
Correct?
 ↙          ↘
Yes          No
 ↓            ↓
Damage       Penalty

Enemy Turn
    ↓
Read Battle State
    ↓
Read Action History
    ↓
Analyze Pattern
    ↓
Predict Player Action
    ↓
Evaluate Available Actions
    ↓
Select Strategy
    ↓
Execute Action

Battle End
    ↓
Calculate Result
    ↓
Calculate XP
    ↓
Update Player
    ↓
Save Battle
    ↓
Save Action History
    ↓
Update Statistics