MONSTERRA — OOP Monster Battle RPG

Player
 └── Trainer
      ├── Monster
      ├── Inventory
      ├── Progress
      └── Achievement

Monster
 ├── Stats
 ├── Type
 ├── Skill
 ├── Evolution
 └── StatusEffect

Battle
 ├── BattleEngine
 ├── BattleAction
 ├── DamageCalculator
 └── BattleAI

World
 ├── Map
 ├── Area
 ├── NPC
 ├── WildMonster
 └── Gym

Player frequently uses:
Fire Skill     65%
Normal Skill   20%
Water Skill    15%

AI prediction:
Next action = Fire Skill

AI response:
Switch to Water-resistant Monster

                    ┌────────────────────┐
                    │       PLAYER       │
                    └─────────┬──────────┘
                              │
       ┌──────────────────────┼───────────────────────┐
       │                      │                       │
       ▼                      ▼                       ▼
  Manage Game            Explore World           Manage Monster
       │                      │                       │
       ├── New Game           ├── Move               ├── View
       ├── Continue           ├── Explore            ├── Train
       ├── Save               ├── NPC                ├── Skill
       └── Settings           └── Wild Monster       └── Evolution
                              │
                              ▼
                           Battle
                              │
                  ┌───────────┼───────────┐
                  ▼           ▼           ▼
                Wild       Gym Leader    Boss

SYSTEM
 ├── Auto Save
 ├── Load Data
 └── Game State Management

BATTLE AI
 ├── Observe Player
 ├── Analyze Pattern
 ├── Predict Action
 └── Select Counter Strategy

                    Battle
                      │
       ┌──────────────┼───────────────┐
       │              │               │
       ▼              ▼               ▼
 Select Monster   Select Action   Check Battle State
                       │
             ┌─────────┼─────────┐
             ▼         ▼         ▼
           Skill      Item      Switch
             │
             ▼
       Calculate Damage
             │
             ▼
       Apply Type Effectiveness
             │
             ▼
       Apply Status Effect
             │
             ▼
        Update HP/EXP
             │
             ▼
        Check Winner

Evolution
    │
    ├── Check Level
    ├── Check Item
    ├── Check Condition
    ├── Show Evolution Preview
    ├── Confirm Evolution
    └── Update Monster Form

Save Game
   │
   ├── Collect Player State
   ├── Collect Monster State
   ├── Collect Inventory
   ├── Collect World Progress
   ├── Serialize Data
   └── Store Database

                  ┌──────────────┐
                  │ Main Screen  │
                  └──────┬───────┘
                         │
              ┌──────────┼──────────┐
              │                     │
              ▼                     ▼
        New Game / Continue      Settings
              │                     │
              ▼                     ▼
        Open RPG Map            Game Options
              │
       ┌──────┴──────┐
       │             │
       ▼             ▼
    New Game      Continue
       │             │
       ▼             │
   Tutorial          │
       │             │
       └──────┬──────┘
              ▼
       Free Exploration
              │
       ┌──────┼──────┐
       ▼      ▼      ▼
      NPC    Wild   Items
             Monster
               │
               ▼
             Battle
               │
       ┌───────┴────────┐
       ▼                ▼
     Victory           Defeat
       │                │
       ▼                ▼
      EXP             Retry
       │
       ▼
   Level / Evolution
       │
       ▼
    Continue

InvalidTrainerNameException

SaveDataCorruptedException

public class Monster {
    private String name;
    private int hp;
    private int level;

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp;
    }
}

public abstract class Monster {
    public abstract void attack();
}

Monster
 ├── FlameMonster
 ├── AquaMonster
 ├── LeafMonster
 └── StormMonster

Monster monster = new FlameMonster();
monster.attack();

public interface Evolvable {
    Monster evolve();
}

public interface BattleCapable {
    void attack();
}

List<Monster> team;
Map<String, Item> inventory;
Set<String> achievements;

public interface Repository<T> {
    T findById(int id);
    void save(T entity);
    void delete(T entity);
}

GameException
 ├── SaveDataException
 ├── InvalidMonsterException
 ├── InvalidTrainerException
 ├── InvalidBattleActionException
 └── EvolutionException

Player Monster
Player Type
Player HP
Previous Actions
Used Skills
Battle Turn
Opponent Monster
Type Effectiveness

Action Score =
    Type Advantage
  + Damage Potential
  + Survival Probability
  + Player Pattern Prediction

Player Pattern:

Turn 1 → Fire Skill
Turn 2 → Fire Skill
Turn 3 → Switch
Turn 4 → Fire Skill

AI:
Fire usage = 75%

Prediction:
Player likely uses Fire

Decision:
Switch to Water-resistant Monster

BattleAI
 ├── PatternAnalyzer
 ├── ActionEvaluator
 ├── TypeAnalyzer
 └── StrategySelector

┌───────────────────────────────┐
│          JavaFX UI            │
│           View                │
└───────────────┬───────────────┘
                │
┌───────────────▼───────────────┐
│         Controller            │
│      Input / Event            │
└───────────────┬───────────────┘
                │
┌───────────────▼───────────────┐
│       Game / Service          │
│      Business Logic           │
└───────────────┬───────────────┘
                │
       ┌────────┴────────┐
       ▼                 ▼
┌──────────────┐  ┌──────────────┐
│   AI Engine  │  │ Battle Engine│
└──────────────┘  └──────────────┘
                │
┌───────────────▼───────────────┐
│       Repository / DAO        │
└───────────────┬───────────────┘
                │
┌───────────────▼───────────────┐
│          Database             │
└───────────────────────────────┘

MONSTERRA
│
├── UI
├── Game
├── Player
├── Monster
├── Battle
├── AI
├── World
├── Item
├── Evolution
├── Save
├── Database
└── Utility

com.monsterra
│
├── app
│   └── Main.java
│
├── controller
│   ├── MainController.java
│   ├── MapController.java
│   ├── BattleController.java
│   └── SettingsController.java
│
├── model
│   ├── player
│   ├── monster
│   ├── battle
│   ├── item
│   ├── world
│   └── gym
│
├── service
│   ├── GameService.java
│   ├── BattleService.java
│   ├── EvolutionService.java
│   └── SaveService.java
│
├── ai
│   ├── BattleAI.java
│   ├── PatternAnalyzer.java
│   └── StrategySelector.java
│
├── repository
│   ├── PlayerRepository.java
│   ├── MonsterRepository.java
│   └── SaveRepository.java
│
├── exception
│
├── util
│
└── database

╔══════════════════════════════════╗
║            MONSTERRA             ║
║                                  ║
║         [ NEW GAME ]             ║
║                                  ║
║         [ CONTINUE ]             ║
║                                  ║
║         [ SETTINGS ]             ║
║                                  ║
║           [ EXIT ]               ║
╚══════════════════════════════════╝

╔══════════════════════════════════╗
║         CREATE TRAINER           ║
║                                  ║
║ Name: [________________]         ║
║                                  ║
║ Choose Starter:                  ║
║                                  ║
║  🔥 Emberling   💧 Aquaffin      ║
║  🌿 Leafling    ⚡ Voltkit       ║
║                                  ║
║            [ START ]              ║
╚══════════════════════════════════╝

┌───────────────────────────────────────────┐
│ HP ████████      TEAM 3/6       Lv. 12    │
├───────────────────────────────────────────┤
│                                           │
│        🌲 Forest                          │
│             ↓                             │
│     🏠──────🌳──────🌳                    │
│      │                                  │ │
│      │             🏔️                   │ │
│      └───────────────🏟️ GYM              │
│                                           │
│                 Player                    │
│                   🧍                     │
│                                           │
├───────────────────────────────────────────┤
│ [TEAM] [BAG] [MAP] [SAVE] [MENU]         │
└───────────────────────────────────────────┘

╔══════════════════════════════════════════╗
║              GYM BATTLE                  ║
║                                          ║
║ Enemy: Stormfang Lv. 24                  ║
║ HP ███████████░░                         ║
║                                          ║
║              🐺                          ║
║                                          ║
║                          🦎              ║
║ Player: Flametail Lv. 22                 ║
║ HP ████████░░                            ║
║                                          ║
║ [ATTACK] [SKILL] [SWITCH] [ITEM]         ║
╚══════════════════════════════════════════╝

        BEFORE                 AFTER

      🔥 Flametail   ─────→   🔥🔥 Infernoon

           [ Evolution! ]

      [ CANCEL ]       [ EVOLVE ]

public abstract class Monster {

    private int id;
    private String name;
    private int level;
    private int experience;

    private Stats stats;
    private List<Type> types;
    private List<Skill> skills;

    public abstract void performPassiveEffect();

    public void gainExperience(int exp) {
        experience += exp;
    }
}

public enum Type {
    FIRE,
    WATER,
    GRASS,
    ELECTRIC,
    EARTH,
    AIR,
    LIGHT,
    DARK
}

             FIRE WATER GRASS ELECTRIC
FIRE           1    0.5   2      1
WATER          2     1   0.5     1
GRASS         0.5    2    1      1
ELECTRIC       1     2    0.5    1

public class Skill {

    private String name;
    private Type type;
    private int power;
    private int accuracy;
    private int manaCost;

    public void execute(Monster attacker,
                        Monster defender) {
        // ...
    }
}

public class Battle {

    private Monster playerMonster;
    private Monster enemyMonster;

    private BattleState state;

    public void executeTurn(BattleAction action) {
        // ...
    }
}

public class EvolutionRule {

    private int requiredLevel;
    private Item requiredItem;
    private Monster evolutionTarget;

    public boolean canEvolve(Monster monster) {
        return monster.getLevel() >= requiredLevel;
    }
}

public class Gym {

    private String name;
    private GymLeader leader;
    private List<Monster> team;
    private Badge reward;

    public Battle startBattle(Player player) {
        // ...
    }
}

PLAYER
-------------------------
id
name
money
current_area
pos_x
pos_y
created_at
updated_at

MONSTER
-------------------------
id
player_id
species_id
nickname
level
experience
hp

SPECIES
-------------------------
id
name
base_hp
base_attack
base_defense
base_speed

SKILL
-------------------------
id
name
type
power
accuracy
mana_cost

MONSTER_SKILL
-------------------------
monster_id
skill_id
slot

INVENTORY
-------------------------
player_id
item_id
quantity

GYM_PROGRESS
-------------------------
player_id
gym_id
completed
completed_at

SAVE_GAME
-------------------------
id
player_id
save_slot
save_time
game_state

Random Encounter
       ↓
Generate Wild Monster
       ↓
Start Battle

Player chooses action
        ↓
Validate action
        ↓
AI chooses action
        ↓
Determine priority
        ↓
Execute faster action
        ↓
Calculate damage
        ↓
Apply status
        ↓
Update HP
        ↓
Check winner
        ↓
Reward EXP

Fire → Grass
Damage × 2.0

Grass → Fire
Damage × 0.5

🔥 Fire Skill
       ↓
Target = 🌿 Grass Monster
       ↓
Type Advantage = 2.0x
       ↓
Critical/Normal calculation
       ↓
Final Damage

Level >= Required Level
        +
Evolution Condition
        ↓
Evolution Available
        ↓
Player Confirmation
        ↓
Transform Monster
        ↓
Update Stats / Skills

GYM 1 — Forest Gym
Specialty: GRASS

GYM 2 — Storm Gym
Specialty: ELECTRIC

GYM 3 — Tide Gym
Specialty: WATER

GYM 4 — Inferno Gym
Specialty: FIRE

Test Fire vs Grass
Expected: 2x damage

Test Fire vs Water
Expected: 0.5x damage

Test Evolution Level < requirement
Expected: false

Test Evolution Level >= requirement
Expected: true

Map
 ↓
Encounter
 ↓
Battle
 ↓
Victory
 ↓
EXP
 ↓
Level Up
 ↓
Evolution
 ↓
Save

MONSTERRA/
│
├── app/
├── resources/
│   ├── images/
│   ├── sounds/
│   ├── maps/
│   └── data/
│
├── database/
│
├── src/
│
├── pom.xml
└── README.md

MONSTERRA.jar

Type × Type → Multiplier

Level
+
Item
+
Time
+
Location
+
Battle Condition

Monster A
Level >= 20
+
Fire Stone
        ↓
Evolution B

Player Battle Profile

Preferred Type:
FIRE

Preferred Skill:
Flame Burst

Switch Frequency:
LOW

Aggression:
HIGH

Healing Frequency:
MEDIUM

EASY
 ↓
Random + Basic Type Advantage

NORMAL
 ↓
Type Advantage + HP Awareness

HARD
 ↓
Pattern Analysis + Prediction

BOSS
 ↓
Pattern Analysis
+
Prediction
+
Counter Strategy
+
Team Switching

Every 60 seconds
        ↓
Check Game State
        ↓
Serialize
        ↓
Database

Menu → Save Game

Monster monster =
    MonsterFactory.create("FLAMETAIL");

AggressiveStrategy
DefensiveStrategy
BalancedStrategy
CounterStrategy

PlayerTurn
EnemyTurn
Victory
Defeat

GameState
   │
   ├── UI
   ├── AutoSave
   └── Achievement

Player A
    ↕
Battle Server
    ↕
Player B

Battle History
      ↓
Feature Extraction
      ↓
Player Behavior Model
      ↓
Prediction
      ↓
AI Strategy

Explore
   ↓
Random Encounter
   ↓
Generate Wild Monster
   ↓
Battle Start
   ↓
Player Action
   ↓
AI Action
   ↓
Resolve Turn
   ↓
Check HP
   ↓
Victory / Defeat

Gain EXP
   ↓
Level Up
   ↓
Check Evolution Rule
   ↓
Evolution Available?
   │
   ├── No → Continue
   │
   └── Yes
          ↓
     Show Animation
          ↓
     Player Confirm
          ↓
     Transform
          ↓
     Update Stats
          ↓
     Save

Phase 1
Normal Strategy

HP < 50%
     ↓
Phase 2
Aggressive Strategy

HP < 20%
     ↓
Final Phase
Counter Strategy

Game State
    ↓
Collect Player
    ↓
Collect Monster
    ↓
Collect Inventory
    ↓
Collect World Progress
    ↓
Serialize
    ↓
Database
    ↓
Save Complete

                         MONSTERRA
                             │
             ┌───────────────┼────────────────┐
             │               │                │
             ▼               ▼                ▼
          PLAYER            WORLD           BATTLE
             │               │                │
       ┌─────┼─────┐      Map/Area      ┌─────┼─────┐
       │     │     │         │          │     │     │
     Team  Item  Profile    NPC       Skill  Type   AI
       │                     │          │     │     │
       ▼                     ▼          ▼     ▼     ▼
    Monster              Encounter   Damage Effect Strategy
       │
   ┌───┼────┐
   ▼   ▼    ▼
 Stats Skill Evolution
             │
             ▼
          EVOLUTION
             │
             ▼
          STRONGER
          MONSTER
             │
             ▼
           GYM
             │
             ▼
           BOSS
             │
             ▼
        NEW REGION

Explore
   ↓
Encounter
   ↓
Battle
   ↓
Win
   ↓
EXP / Item
   ↓
Level Up
   ↓
Evolution
   ↓
Build Stronger Team
   ↓
Challenge Gym
   ↓
Get Badge
   ↓
Unlock New Region
   ↓
Explore Again

             INPUT
               │
               ▼
       ┌────────────────┐
       │ Player Profile │
       └───────┬────────┘
               │
       ┌───────▼────────┐
       │   Game State    │
       │                 │
       │ • Player        │
       │ • Monster Team  │
       │ • Inventory     │
       │ • Map Position  │
       │ • Gym Progress  │
       │ • Settings      │
       └───────┬────────┘
               │
        ┌──────┴───────┐
        │              │
        ▼              ▼
   Manual Save     Auto Save
        │              │
        └──────┬───────┘
               ▼
          DATABASE
               │
               ▼
          LOAD / READ
               │
               ▼
              OUT
               │
               ▼
       Restored Game State