Đề tài: Xây dựng game nhập vai chiến thuật thu thập, huấn luyện và tiến hóa quái thú bằng Java và lập trình hướng đối tượng.
Trong quá trình học lập trình hướng đối tượng, sinh viên thường được tiếp cận với các khái niệm như lớp, đối tượng, đóng gói, kế thừa, đa hình, trừu tượng hóa, interface, generic, exception và các nguyên lý thiết kế phần mềm. Tuy nhiên, nếu chỉ thực hành thông qua những bài toán đơn giản như quản lý sinh viên, quản lý thư viện hoặc quản lý nhân viên, việc hình dung mối quan hệ giữa nhiều đối tượng trong một hệ thống lớn có thể gặp nhiều hạn chế.
Game nhập vai chiến thuật là một bài toán phù hợp để áp dụng lập trình hướng đối tượng vì một game có rất nhiều thực thể và hành vi tương tác với nhau. Ví dụ, người chơi có Trainer, Trainer sở hữu nhiều Monster, Monster có Type, Skill, Stats, Item và Evolution. Các Monster có thể kế thừa từ một lớp cơ sở, đồng thời triển khai các interface khác nhau. Battle Engine có thể tương tác với các đối tượng Monster thông qua abstraction và polymorphism.
Từ đó, đề tài MONSTERRA — OOP Monster Battle RPG được xây dựng với mục tiêu tạo ra một game RPG trong đó người chơi khám phá thế giới, thu thập quái thú, huấn luyện, tiến hóa và tham gia các trận chiến chiến thuật.
Hệ thống được thiết kế xoay quanh các cơ chế:
Đề tài đồng thời được sử dụng như một môi trường thực tế để vận dụng các kiến thức của môn Lập trình hướng đối tượng từ Chương 1 đến Chương 13.
Đề tài hướng tới các mục tiêu chính:
Phiên bản prototype tập trung vào:
Các chức năng như multiplayer, PvP trực tuyến, marketplace, cloud save và hệ thống mạng xã hội không nằm trong phạm vi phiên bản đầu tiên.
Hệ thống được định hướng theo kiến trúc hướng đối tượng, trong đó các thành phần của game được mô hình hóa thành các lớp độc lập.
Một số đối tượng chính:
Player
└── Trainer
├── Monster
├── Inventory
├── Progress
└── Achievement
Monster
├── Stats
├── Type
├── Skill
├── Evolution
└── StatusEffect
Battle
├── BattleEngine
├── BattleAction
├── DamageCalculator
└── BattleAI
World
├── Map
├── Area
├── NPC
├── WildMonster
└── Gym
Hệ thống Battle sử dụng một Battle Engine độc lập với giao diện. Điều này cho phép thay đổi giao diện mà không cần viết lại toàn bộ logic chiến đấu.
AI được tích hợp vào đối thủ trong Battle.
AI sẽ:
Ví dụ:
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
Đây là game AI/decision-making, không phải Generative AI.
Đồ án gồm 6 chương chính:
Ngoài ra đồ án gồm tài liệu tham khảo và phụ lục đặc tả Use Case.
Các game RPG thu thập quái thú thường có một số cơ chế đặc trưng:
Những cơ chế này có tính tương tác cao và tạo ra nhiều quan hệ giữa các đối tượng.
Đối với mục tiêu học tập của môn Lập trình hướng đối tượng, đây là một bài toán có ưu điểm:
Hệ thống gồm các nhóm chức năng:
Actor chính:
┌────────────────────┐
│ 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
Actor phụ:
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
Luồng chính của ứng dụng:
┌──────────────┐
│ 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
| Thành phần | Nội dung |
|---|---|
| Use Case | New Game |
| Actor | Player |
| Mục tiêu | Tạo một game mới |
| Tiền điều kiện | Không có profile đang chơi |
| Hậu điều kiện | Profile mới được tạo |
| Trigger | Player chọn New Game |
Nếu tên Trainer không hợp lệ:
InvalidTrainerNameException
Hệ thống yêu cầu nhập lại.
| Thành phần | Nội dung |
|---|---|
| Use Case | Continue Game |
| Actor | Player |
| Mục tiêu | Tiếp tục game đã lưu |
| Tiền điều kiện | Có save data |
| Hậu điều kiện | Game State được khôi phục |
| Trigger | Player chọn Continue |
Nếu save data bị lỗi:
SaveDataCorruptedException
Hệ thống thông báo lỗi và cho phép người chơi quay lại Main Menu.
Hệ thống phải cho phép dễ dàng:
mà không phải sửa toàn bộ hệ thống.
Các phép tính Damage, EXP, Level và Evolution phải cho kết quả nhất quán.
Hệ thống áp dụng bốn nguyên lý chính:
Dữ liệu Monster được che giấu bên trong class.
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;
}
}
Các hành vi chung được định nghĩa trong abstract class.
public abstract class Monster {
public abstract void attack();
}
Các Monster cụ thể kế thừa class cơ sở.
Monster
├── FlameMonster
├── AquaMonster
├── LeafMonster
└── StormMonster
Battle Engine làm việc với Monster thay vì phụ thuộc vào từng Monster cụ thể.
Monster monster = new FlameMonster();
monster.attack();
Một số hành vi có thể được biểu diễn bằng interface.
public interface Evolvable {
Monster evolve();
}
public interface BattleCapable {
void attack();
}
Collection được sử dụng xuyên suốt hệ thống.
List<Monster> team;
Map<String, Item> inventory;
Set<String> achievements;
Có thể xây dựng Generic Repository:
public interface Repository<T> {
T findById(int id);
void save(T entity);
void delete(T entity);
}
Các exception riêng:
GameException
├── SaveDataException
├── InvalidMonsterException
├── InvalidTrainerException
├── InvalidBattleActionException
└── EvolutionException
Các biểu đồ được sử dụng:
JavaFX được sử dụng để xây dựng GUI.
Các thành phần:
Database được sử dụng để lưu:
Có thể sử dụng SQLite cho prototype vì dễ triển khai và không yêu cầu server.
AI được thiết kế dưới dạng Adaptive Battle AI.
Không sử dụng LLM để sinh hội thoại.
AI nhận input:
Player Monster
Player Type
Player HP
Previous Actions
Used Skills
Battle Turn
Opponent Monster
Type Effectiveness
Sau đó tính điểm cho các hành động:
Action Score =
Type Advantage
+ Damage Potential
+ Survival Probability
+ Player Pattern Prediction
Ví dụ:
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
AI vẫn nằm trong hệ thống OOP:
BattleAI
├── PatternAnalyzer
├── ActionEvaluator
├── TypeAnalyzer
└── StrategySelector
Đề tài sử dụng kiến trúc phân lớp kết hợp tư tưởng MVC.
┌───────────────────────────────┐
│ JavaFX UI │
│ View │
└───────────────┬───────────────┘
│
┌───────────────▼───────────────┐
│ Controller │
│ Input / Event │
└───────────────┬───────────────┘
│
┌───────────────▼───────────────┐
│ Game / Service │
│ Business Logic │
└───────────────┬───────────────┘
│
┌────────┴────────┐
▼ ▼
┌──────────────┐ ┌──────────────┐
│ AI Engine │ │ Battle Engine│
└──────────────┘ └──────────────┘
│
┌───────────────▼───────────────┐
│ Repository / DAO │
└───────────────┬───────────────┘
│
┌───────────────▼───────────────┐
│ Database │
└───────────────────────────────┘
Hệ thống được chia thành các module:
MONSTERRA
│
├── UI
├── Game
├── Player
├── Monster
├── Battle
├── AI
├── World
├── Item
├── Evolution
├── Save
├── Database
└── Utility
Đề xuất package:
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
}
Type Chart:
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
Có thể mở rộng bảng khắc chế thành một TypeEffectivenessMatrix.
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) {
// ...
}
}
Các bảng chính:
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
| Công nghệ | Mục đích |
|---|---|
| Java | Ngôn ngữ lập trình |
| JavaFX | GUI |
| SQLite | Database |
| JDBC | Kết nối Database |
| Maven | Quản lý dependency/build |
| Git | Version Control |
| JUnit | Unit Test |
| UML Tool | Phân tích thiết kế |
| IntelliJ IDEA / VS Code | IDE |
Phiên bản prototype hướng tới hoàn thành:
Player điều khiển Trainer trên bản đồ.
Khi đi vào vùng cỏ:
Random Encounter
↓
Generate Wild Monster
↓
Start Battle
Battle được xử lý theo lượt:
Player chooses action
↓
Validate action
↓
AI chooses action
↓
Determine priority
↓
Execute faster action
↓
Calculate damage
↓
Apply status
↓
Update HP
↓
Check winner
↓
Reward EXP
Ví dụ:
Fire → Grass
Damage × 2.0
Grass → Fire
Damage × 0.5
Khi người chơi sử dụng Skill:
🔥 Fire Skill
↓
Target = 🌿 Grass Monster
↓
Type Advantage = 2.0x
↓
Critical/Normal calculation
↓
Final Damage
Monster đạt đủ điều kiện:
Level >= Required Level
+
Evolution Condition
↓
Evolution Available
↓
Player Confirmation
↓
Transform Monster
↓
Update Stats / Skills
Gym đóng vai trò như các cột mốc của game.
Ví dụ:
GYM 1 — Forest Gym
Specialty: GRASS
GYM 2 — Storm Gym
Specialty: ELECTRIC
GYM 3 — Tide Gym
Specialty: WATER
GYM 4 — Inferno Gym
Specialty: FIRE
Mỗi Gym có:
Kiểm thử:
Ví dụ:
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
Kiểm thử:
Map
↓
Encounter
↓
Battle
↓
Victory
↓
EXP
↓
Level Up
↓
Evolution
↓
Save
Kiểm tra:
Game có thể được đóng gói thành Java application.
Cấu trúc:
MONSTERRA/
│
├── app/
├── resources/
│ ├── images/
│ ├── sounds/
│ ├── maps/
│ └── data/
│
├── database/
│
├── src/
│
├── pom.xml
└── README.md
Có thể đóng gói thành:
MONSTERRA.jar
hoặc sử dụng jpackage để tạo ứng dụng native cho Windows.
Thay vì hard-code nhiều câu lệnh if/else, hệ thống sử dụng bảng quan hệ Type.
Type × Type → Multiplier
Điều này cho phép dễ dàng thêm Type mới.
Evolution không đơn giản là tăng Level.
Một Monster có thể có nhiều điều kiện:
Level
+
Item
+
Time
+
Location
+
Battle Condition
Ví dụ:
Monster A
Level >= 20
+
Fire Stone
↓
Evolution B
Đây là một trong những điểm nổi bật nhất của đề tài.
AI không chỉ chọn hành động random.
Nó xây dựng một hồ sơ chiến đấu tạm thời của người chơi:
Player Battle Profile
Preferred Type:
FIRE
Preferred Skill:
Flame Burst
Switch Frequency:
LOW
Aggression:
HIGH
Healing Frequency:
MEDIUM
Sau đó AI điều chỉnh chiến thuật.
Có thể chia:
EASY
↓
Random + Basic Type Advantage
NORMAL
↓
Type Advantage + HP Awareness
HARD
↓
Pattern Analysis + Prediction
BOSS
↓
Pattern Analysis
+
Prediction
+
Counter Strategy
+
Team Switching
Điều này tạo cảm giác:
Boss thực sự “học” cách người chơi đánh.
Game tự động lưu theo chu kỳ.
Ví dụ:
Every 60 seconds
↓
Check Game State
↓
Serialize
↓
Database
Ngoài ra người chơi có thể:
Menu → Save Game
để lưu thủ công.
Một điểm đóng góp quan trọng của đề tài là OOP không chỉ nằm trong code mà trực tiếp tạo ra gameplay.
| Kiến thức OOP | Ứng dụng |
|---|---|
| Class | Monster, Player, Skill |
| Object | Monster cụ thể |
| Encapsulation | Stats |
| Abstraction | Monster/Battle |
| Inheritance | Monster species |
| Overriding | Monster behavior |
| Interface | Evolvable, BattleCapable |
| Polymorphism | Battle Engine |
| Generic | Repository/Collection |
| Exception | Game Exception |
| Composition | Monster → Stats/Skills |
| Aggregation | Player → Team |
| UML | Thiết kế hệ thống |
| SOLID | Architecture |
| Design Pattern | Strategy/Factory/State |
Có thể áp dụng một số Design Pattern phù hợp.
Tạo Monster:
Monster monster =
MonsterFactory.create("FLAMETAIL");
AI strategy:
AggressiveStrategy
DefensiveStrategy
BalancedStrategy
CounterStrategy
Battle State:
PlayerTurn
EnemyTurn
Victory
Defeat
Theo dõi Game State:
GameState
│
├── UI
├── AutoSave
└── Achievement
Đề tài MONSTERRA — OOP Monster Battle RPG xây dựng một game nhập vai chiến thuật dựa trên mô hình thu thập, huấn luyện và chiến đấu với Monster.
Hệ thống cung cấp các chức năng:
Về mặt học thuật, đề tài tạo điều kiện áp dụng hầu hết kiến thức của môn Lập trình hướng đối tượng, bao gồm:
Đặc biệt, việc xây dựng Battle Engine và Adaptive Battle AI giúp hệ thống có mức độ tương tác cao hơn so với các ứng dụng quản lý thông thường.
Hoàn thiện core gameplay:
Mở rộng thế giới:
Nâng cấp AI:
Mở rộng multiplayer:
Player A
↕
Battle Server
↕
Player B
Cho phép PvP.
Phát triển hệ thống Competitive:
Phát triển AI nâng cao
Có thể sử dụng Machine Learning để học từ dữ liệu trận đấu:
Battle History
↓
Feature Extraction
↓
Player Behavior Model
↓
Prediction
↓
AI Strategy
Phiên bản nâng cao có thể sử dụng Reinforcement Learning để tìm chiến thuật tối ưu.
| Thuộc tính | Nội dung |
|---|---|
| ID | UC-01 |
| Tên | New Game |
| Actor | Player |
| Priority | High |
| Trigger | Chọn New Game |
| Preconditions | Không yêu cầu |
| Postconditions | Profile mới được tạo |
| Thuộc tính | Nội dung |
|---|---|
| ID | UC-02 |
| Tên | Continue |
| Actor | Player |
| Priority | High |
| Preconditions | Có save data |
| Postconditions | Game State được khôi phục |
| Thuộc tính | Nội dung |
|---|---|
| ID | UC-03 |
| Tên | Explore Map |
| Actor | Player |
| Priority | High |
Explore
↓
Random Encounter
↓
Generate Wild Monster
↓
Battle Start
↓
Player Action
↓
AI Action
↓
Resolve Turn
↓
Check HP
↓
Victory / Defeat
Monster phải đáp ứng điều kiện Evolution.
Gain EXP
↓
Level Up
↓
Check Evolution Rule
↓
Evolution Available?
│
├── No → Continue
│
└── Yes
↓
Show Animation
↓
Player Confirm
↓
Transform
↓
Update Stats
↓
Save
Player đến Gym.
Hệ thống kiểm tra điều kiện mở Gym.
Player chọn Challenge.
Gym Leader xuất hiện.
Hệ thống khởi tạo Boss Team.
Battle bắt đầu.
AI điều khiển Gym Leader.
Nếu Player thắng:
Nếu Player thua:
Boss là phiên bản nâng cao của Gym Battle.
Boss có:
Ví dụ:
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
Player có thể thay đổi:
| Thuộc tính | Nội dung |
|---|---|
| ID | UC-12 |
| Actor | Battle AI |
| Input | Battle State |
| Output | Action |
| Priority | High |
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
MONSTERRA không chỉ là một game Pokémon-like.
Ba yếu tố chính tạo nên sản phẩm:
RPG Exploration + OOP Architecture + Adaptive Battle AI
Trong đó:
Đặc biệt, AI không được đưa vào chỉ để “có AI”, mà giải quyết một vấn đề thực tế của game:
Làm thế nào để Boss không đánh theo một kịch bản cố định mà có thể phản ứng với cách chơi của từng người?
Đây là điểm có thể sử dụng làm USP chính khi thuyết trình trước ban giám khảo và 10 team đánh giá chéo.
comments (0)