# OOP ĐẠI CHIẾN — AI OOP ARENA > **Tên đề tài:** OOP Đại Chiến – Ai Là Người Giỏi Nhất? > **Tên tiếng Anh:** OOP Arena – The Battle of Object-Oriented Programming > **Nền tảng:** Desktop Application > **Ngôn ngữ:** Java > **GUI:** JavaFX > **CSDL:** SQLite > **Mô hình:** Object-Oriented Design + MVC/MVVM-inspired architecture > **AI:** Adaptive Gameplay AI dựa trên phân tích hành vi và dự đoán pattern > **Đối tượng:** Sinh viên học Lập trình hướng đối tượng --- # CHƯƠNG 1. GIỚI THIỆU ĐỀ TÀI ## 1.1 Đặt vấn đề Lập trình hướng đối tượng (Object-Oriented Programming – OOP) là một trong những nền tảng quan trọng trong quá trình đào tạo sinh viên ngành Công nghệ thông tin và Khoa học máy tính. Các khái niệm như: - Class - Object - Encapsulation - Abstraction - Inheritance - Polymorphism - Interface - Generic - Exception có tính trừu tượng tương đối cao đối với sinh viên mới bắt đầu học. Phương pháp học truyền thống chủ yếu dựa trên: - đọc lý thuyết; - xem ví dụ code; - vẽ UML; - làm bài tập; - sửa lỗi chương trình. Cách tiếp cận này giúp sinh viên hiểu cú pháp và nguyên lý, nhưng chưa thực sự tạo ra môi trường để sinh viên **trực tiếp trải nghiệm mối quan hệ giữa các khái niệm OOP**. Ví dụ, khi học về polymorphism, sinh viên có thể hiểu: ```java Animal animal = new Dog(); animal.makeSound(); ``` nhưng việc hiểu tại sao polymorphism hữu ích và nó tạo ra lợi ích gì trong một hệ thống thực tế thường khó hơn. Từ vấn đề đó, đề tài **OOP Đại Chiến – OOP Arena** được xây dựng với ý tưởng biến các khái niệm OOP thành những nhân vật có khả năng chiến đấu. Ví dụ: | Khái niệm OOP | Nhân vật | | ------------- | --------------- | | Encapsulation | Shield Knight | | Inheritance | Mutant Warrior | | Polymorphism | Shapeshifter | | Abstraction | Abstract Mage | | Interface | Connector | | Generic | Template Wizard | | Exception | Error Handler | Ngược lại, các lỗi lập trình trở thành kẻ địch: | Bug | Boss | | -------------------- | ------------ | | NullPointerException | Null Beast | | StackOverflowError | Stack Demon | | Infinite Loop | Loop Hydra | | ClassCastException | Cast Monster | | RuntimeException | Runtime Boss | Qua đó, kiến thức OOP được chuyển từ dạng **khái niệm trừu tượng** thành một hệ thống tương tác trực quan. --- ## 1.2 Mục tiêu và phạm vi đề tài ### 1.2.1 Mục tiêu tổng quát Xây dựng một ứng dụng game giáo dục bằng Java giúp sinh viên: - làm quen với tư duy hướng đối tượng; - nhận biết vai trò của các nguyên lý OOP; - thực hành inheritance, abstraction, encapsulation và polymorphism; - hiểu exception và generic; - quan sát trực quan quan hệ giữa các class; - học thông qua gameplay thay vì chỉ đọc lý thuyết. Đồng thời, hệ thống áp dụng **AI thích nghi** để tạo ra trải nghiệm chơi khác nhau dựa trên hành vi của người chơi. --- ### 1.2.2 Mục tiêu cụ thể Hệ thống hướng tới các mục tiêu: 1. Xây dựng game chiến đấu theo lượt. 2. Mỗi nhân vật đại diện cho một khái niệm OOP. 3. Xây dựng hệ thống kỹ năng dựa trên nguyên lý OOP. 4. Xây dựng hệ thống Bug/Boss. 5. Xây dựng AI điều khiển Boss. 6. AI phân tích hành vi người chơi. 7. AI thay đổi chiến thuật dựa trên dữ liệu thu thập. 8. Xây dựng giao diện JavaFX. 9. Lưu trữ người chơi, trận đấu và thống kê. 10. Thể hiện rõ các nguyên lý OOP trong chính kiến trúc phần mềm. --- ## 1.2.3 Phạm vi ### Trong phạm vi - Game desktop. - Single player. - Battle theo lượt. - Nhiều loại nhân vật. - Nhiều loại Bug. - Boss AI. - Hệ thống skill. - Level/progression. - Statistics. - Tutorial. - Class relationship visualization. - Database local. - UML/Class Diagram. - AI thích nghi. ### Ngoài phạm vi MVP - Multiplayer online. - Payment. - Cloud account. - PvP realtime. - Open-world. - Generative AI. - Voice assistant. - LLM chatbot. --- # 1.3 Định hướng giải pháp Hệ thống được xây dựng theo hướng: ```text OOP KNOWLEDGE │ ↓ ┌─────────────────┐ │ OOP CHARACTERS│ └────────┬────────┘ │ ↓ ┌─────────────────┐ │ BATTLE ENGINE │ └────────┬────────┘ │ ┌─────────┴─────────┐ ↓ ↓ PLAYER ACTION BUG AI │ │ └─────────┬─────────┘ ↓ ADAPTIVE AI │ ↓ BATTLE RESULT │ ↓ DATABASE ``` AI không sinh câu trả lời bằng ngôn ngữ tự nhiên. Thay vào đó: ```text Player Actions ↓ Behavior Tracking ↓ Pattern Analysis ↓ Prediction ↓ AI Decision ↓ Enemy Action ``` Ví dụ người chơi liên tục sử dụng: ```text Attack → Attack → Defense → Attack → Attack ``` AI phát hiện người chơi có xu hướng ưu tiên Attack. Ở lượt tiếp theo, Boss có thể chuyển sang chiến thuật: ```text Counter / Defense / Punish ``` Nếu người chơi thay đổi: ```text Defense → Skill → Defense → Skill ``` AI tiếp tục cập nhật mô hình. ### AI không phải "độ khó cố định" Đây là điểm quan trọng. Thay vì: ```text Easy Normal Hard ``` hệ thống hướng tới: ```text Easy ────────→ Adaptive ────────→ Hard ↑ │ Player behavior ``` Boss tự điều chỉnh. --- # 1.4 Bố cục đồ án Đồ án gồm 6 chương chính: - **Chương 1:** Giới thiệu đề tài. - **Chương 2:** Khảo sát và phân tích yêu cầu. - **Chương 3:** Nền tảng lý thuyết và công nghệ. - **Chương 4:** Phân tích thiết kế, triển khai và đánh giá hệ thống. - **Chương 5:** Các giải pháp và đóng góp nổi bật. - **Chương 6:** Kết luận và hướng phát triển. Ngoài ra gồm: - Tài liệu tham khảo. - Phụ lục. - Đặc tả Use Case. --- # CHƯƠNG 2. KHẢO SÁT VÀ PHÂN TÍCH YÊU CẦU # 2.1 Khảo sát hiện trạng Sinh viên học OOP thường gặp ba vấn đề chính. ### Vấn đề 1 — Kiến thức trừu tượng Các khái niệm: ```text Class Object Abstraction Inheritance Polymorphism Interface ``` khó hình dung khi chỉ học qua slide/code. ### Vấn đề 2 — Học lý thuyết thiếu phản hồi trực tiếp Sinh viên có thể viết: ```java class Animal {} class Dog extends Animal {} ``` nhưng chưa chắc hiểu rõ **tại sao** inheritance và polymorphism được sử dụng. ### Vấn đề 3 — Thiếu động lực Các bài tập OOP thường có cấu trúc: ```text Đề bài ↓ Code ↓ Compile ↓ Output ``` Trong khi game có: ```text Action ↓ Consequence ↓ Feedback ↓ Strategy ↓ Reward ``` OOP Arena tận dụng cơ chế thứ hai để biến kiến thức thành trải nghiệm. --- # 2.2 Tổng quan chức năng Các chức năng chính: 1. Quản lý người chơi. 2. Tutorial OOP. 3. Chọn nhân vật. 4. Xem thông tin nhân vật. 5. Xem kỹ năng. 6. Battle. 7. AI Enemy. 8. Boss Battle. 9. OOP Quiz Battle. 10. Xem class relationship. 11. Xem lịch sử trận đấu. 12. Xem thống kê. 13. Lưu tiến trình. 14. Settings. --- # 2.2.1 Biểu đồ Use Case tổng quát ```mermaid flowchart LR Player((Player)) System((OOP Arena)) Player --> UC1[Quản lý hồ sơ] Player --> UC2[Học OOP] Player --> UC3[Chọn nhân vật] Player --> UC4[Bắt đầu trận đấu] Player --> UC5[Sử dụng kỹ năng] Player --> UC6[Trả lời Quiz] Player --> UC7[Xem Class Diagram] Player --> UC8[Xem thống kê] UC4 --> AI[Adaptive AI] AI --> UC5 ``` Có thể biểu diễn đầy đủ hơn bằng Use Case UML: ```text ┌──────────────────────┐ │ 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 │ └──────────────────────┘ ``` --- # 2.2.2 Biểu đồ Use Case phân rã — Battle Use Case lớn: > **UC-B01: Battle** được phân rã thành: ```text 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 ``` --- # 2.2.3 Quy trình nghiệp vụ ## Quy trình chơi cơ bản ```text 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 ``` --- # 2.3 Đặc tả chức năng ## 2.3.1 Đặc tả Use Case A — Bắt đầu trận đấu ### Tên **UC-B01 – Start Battle** ### Actor Player. ### Mục tiêu Cho phép người chơi bắt đầu một trận đấu với Bug/Boss. ### Preconditions - Ứng dụng đang hoạt động. - Người chơi đã chọn nhân vật. - Có enemy hợp lệ. ### Main Flow 1. Người chơi chọn `Battle`. 2. Hệ thống hiển thị danh sách character. 3. Người chơi chọn character. 4. Hệ thống hiển thị enemy. 5. Người chơi chọn enemy. 6. Hệ thống khởi tạo Battle. 7. Hệ thống tạo các object tương ứng. 8. Battle Engine bắt đầu. 9. Người chơi thực hiện action. 10. AI xử lý lượt của enemy. 11. Hệ thống tính toán kết quả. 12. Trận đấu tiếp tục cho đến khi một bên bị đánh bại. ### Alternative Flow Nếu người chơi không đủ điều kiện mở khóa character: ```text Character Locked ↓ Display Requirement ↓ Return Character Selection ``` ### Postconditions - Battle kết thúc. - Kết quả được lưu. - Statistics được cập nhật. --- # 2.3.2 Đặc tả Use Case B — AI thích nghi ### Tên **UC-AI01 – Adaptive Enemy Behavior** ### Actor Adaptive AI. ### Mục tiêu Phân tích hành vi người chơi và lựa chọn chiến thuật phù hợp. ### Input ```text Player Action Current HP Enemy HP Available Skills Previous Actions Turn Number Battle State ``` ### Process ```text Collect Data ↓ Build Behavior Profile ↓ Calculate Action Probability ↓ Predict Next Action ↓ Evaluate Counter Actions ↓ Select Best Action ↓ Execute ``` ### Output Một action: ```text ATTACK DEFEND SPECIAL COUNTER HEAL ``` --- # 2.4 Yêu cầu phi chức năng ## Performance - Thời gian phản hồi UI < 200 ms đối với các thao tác thông thường. - AI decision không gây treo giao diện. - Battle engine xử lý realtime theo lượt. ## Usability - Giao diện trực quan. - Các skill có icon và mô tả. - Người chơi có thể hiểu chức năng mà không cần đọc tài liệu kỹ thuật. ## Reliability - Không crash khi nhập dữ liệu không hợp lệ. - Exception phải được xử lý. - Battle state phải nhất quán. ## Maintainability Code phải: - chia package; - tuân thủ OOP; - hạn chế coupling; - sử dụng interface/abstraction; - có unit test. ## Portability Ứng dụng chạy được trên các hệ điều hành hỗ trợ Java. ## Extensibility Có thể thêm: ```text New Character New Skill New Boss New Game Mode New AI Strategy ``` mà không cần sửa toàn bộ hệ thống. --- # CHƯƠNG 3. NỀN TẢNG LÝ THUYẾT VÀ CÔNG NGHỆ SỬ DỤNG # 3.1 Lập trình hướng đối tượng Hệ thống áp dụng bốn nguyên lý chính: ### Encapsulation Thông tin HP không được thay đổi trực tiếp: ```java 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); } } ``` --- ### Abstraction ```java public abstract class Character { public abstract void performAction(); } ``` --- ### Inheritance ```text Character │ ├── EncapsulationHero ├── InheritanceHero ├── PolymorphismHero └── InterfaceHero ``` --- ### Polymorphism ```java Character character; character = new EncapsulationHero(); character.attack(); character = new PolymorphismHero(); character.attack(); ``` Cùng một interface nhưng hành vi khác nhau. --- # 3.2 UML Sử dụng: - Use Case Diagram - Class Diagram - Sequence Diagram - Activity Diagram - Package Diagram Đặc biệt Class Diagram là thành phần quan trọng để chứng minh hệ thống được thiết kế theo OOP. --- # 3.3 Java Java được lựa chọn vì: - hỗ trợ OOP mạnh; - static typing; - inheritance; - interface; - abstract class; - generic; - exception; - collection framework; - ecosystem lớn; - phù hợp trực tiếp với nội dung môn học. --- # 3.4 JavaFX JavaFX được sử dụng để xây dựng: - Main Menu; - Character Selection; - Battle Arena; - Health Bar; - Skill Panel; - Quiz; - Statistics; - Class Diagram Viewer. --- # 3.5 SQLite SQLite được sử dụng vì: - miễn phí; - mã nguồn mở; - không cần database server; - phù hợp ứng dụng desktop; - dễ triển khai. --- # 3.6 AI thích nghi ## 3.6.1 Không sử dụng Generative AI Hệ thống **không sử dụng ChatGPT/LLM để sinh text**. AI nằm trực tiếp trong gameplay. --- ## 3.6.2 Behavior Tracking Mỗi action của người chơi được ghi nhận: ```java public enum ActionType { ATTACK, DEFEND, SKILL, HEAL } ``` Ví dụ: ```text Turn 1 → ATTACK Turn 2 → ATTACK Turn 3 → SKILL Turn 4 → ATTACK Turn 5 → DEFEND ``` --- ## 3.6.3 Pattern Analysis Hệ thống thống kê: ```text Attack: 60% Skill: 20% Defense: 15% Heal: 5% ``` AI có thể phát hiện: > Player có xu hướng tấn công trực tiếp. Sau đó ưu tiên counter. --- ## 3.6.4 Markov-style Prediction Có thể sử dụng transition matrix: ```text 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 ``` Nếu hành động hiện tại là `ATTACK`, AI dự đoán: ```text ATTACK = 60% SKILL = 20% DEFEND = 10% HEAL = 10% ``` AI sẽ lựa chọn counter tương ứng. --- ## 3.6.5 Adaptive Difficulty AI cũng theo dõi: ```text Player Win Rate Damage Dealt Damage Received Average Turn Skill Usage Defense Rate ``` Nếu người chơi thắng quá dễ: ```text Difficulty ↑ ``` Nếu người chơi thua liên tục: ```text Difficulty ↓ ``` Điều này tạo ra trải nghiệm: > **AI không chỉ đánh người chơi — AI học cách người chơi đánh.** --- # CHƯƠNG 4. PHÂN TÍCH THIẾT KẾ, TRIỂN KHAI VÀ ĐÁNH GIÁ HỆ THỐNG # 4.1 Thiết kế kiến trúc # 4.1.1 Lựa chọn kiến trúc phần mềm Đề xuất sử dụng kiến trúc **Layered + MVC/MVVM-inspired**. ```text ┌─────────────────────────────┐ │ Presentation │ │ JavaFX │ ├─────────────────────────────┤ │ Application │ │ Controllers │ ├─────────────────────────────┤ │ Domain │ │ Characters / Battle / AI │ ├─────────────────────────────┤ │ Infrastructure │ │ SQLite / Repository │ └─────────────────────────────┘ ``` Mục tiêu là tách: ```text UI ≠ Game Logic ≠ AI ≠ Database ``` --- # 4.1.2 Thiết kế tổng quan ```text JavaFX UI │ ↓ Controllers │ ┌───────────┼───────────┐ ↓ ↓ ↓ BattleService QuizService PlayerService │ ↓ BattleEngine │ ┌─────┴─────┐ ↓ ↓ Player Enemy │ │ │ AdaptiveAI │ │ └─────┬─────┘ ↓ ResultService ↓ Repository ↓ SQLite ``` --- # 4.1.3 Thiết kế chi tiết gói Đề xuất cấu trúc: ```text 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/ └── ... ``` --- # 4.2 Thiết kế chi tiết # 4.2.1 Thiết kế giao diện ## Màn hình 1 — Main Menu ```text ╔════════════════════════════════════╗ ║ OOP ĐẠI CHIẾN ║ ║ ║ ║ ⚔ PLAY BATTLE ║ ║ ║ ║ 📚 OOP ACADEMY ║ ║ ║ ║ 🧬 CLASS LAB ║ ║ ║ ║ 📊 STATISTICS ║ ║ ║ ║ ⚙ SETTINGS ║ ╚════════════════════════════════════╝ ``` --- ## Màn hình 2 — Character Selection ```text ┌─────────────────────────────────────────┐ │ SELECT YOUR OOP HERO │ ├────────────┬────────────┬───────────────┤ │ 🛡️ │ 🧬 │ 🎭 │ │ Encapsulate │ Inheritance│ Polymorphism │ │ │ │ │ │ DEFENSE 95 │ ATK 90 │ SPEED 95 │ │ │ │ │ │ [SELECT] │ [SELECT] │ [SELECT] │ └────────────┴────────────┴───────────────┘ ``` --- # Màn hình 3 — Battle Arena ```text ┌───────────────────────────────────────────┐ │ BOSS BATTLE │ │ │ │ PLAYER BOSS │ │ │ │ 🛡️ HERO 💀 NULL BEAST │ │ ██████████ ████████ │ │ HP 100/100 HP 150/150 │ │ │ │ TURN 05 │ │ │ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │ │ ATTACK │ │ SKILL │ │ DEFEND │ │ │ └────────┘ └────────┘ └────────┘ │ │ │ │ AI ANALYSIS: ████████ │ └───────────────────────────────────────────┘ ``` --- # Màn hình 4 — AI Analysis Có thể có một panel phụ: ```text ┌───────────────────────────┐ │ AI BEHAVIOR ANALYSIS │ ├───────────────────────────┤ │ Attack ███████ 65% │ │ Skill ███ 20% │ │ Defense ██ 10% │ │ Heal █ 5% │ │ │ │ Predicted: ATTACK │ │ Confidence: 65% │ └───────────────────────────┘ ``` **Lưu ý:** Khi thi thật, panel này có thể được ẩn hoặc chỉ xuất hiện sau trận để tránh làm lộ chiến thuật AI. --- # 4.2.2 Thiết kế lớp Class diagram lõi: ```mermaid classDiagram class Character { <> -String name -int hp -int maxHp -int attackPower +attack(Character target) +defend() +takeDamage(int damage) +isAlive() } class EncapsulationHero class InheritanceHero class PolymorphismHero class InterfaceHero Character <|-- EncapsulationHero Character <|-- InheritanceHero Character <|-- PolymorphismHero Character <|-- InterfaceHero class Skill { <> +execute(Character user, Character target) } class AttackSkill class DefenseSkill class PolymorphismSkill class ExceptionSkill Skill <|.. AttackSkill Skill <|.. DefenseSkill Skill <|.. PolymorphismSkill Skill <|.. ExceptionSkill class Enemy { <> } class BugEnemy class BossEnemy Enemy <|-- BugEnemy Enemy <|-- BossEnemy class AdaptiveAI { +analyze() +predict() +selectAction() } class BattleEngine { +start() +playerTurn() +enemyTurn() +endBattle() } BattleEngine --> Character BattleEngine --> Enemy BattleEngine --> AdaptiveAI Character --> Skill ``` --- # 4.2.3 Thiết kế cơ sở dữ liệu SQLite database: ```text oop_arena.db ``` ## Bảng Player ```text Player ------------------ id username level experience created_at ``` ## Bảng Character ```text Character ------------------ id name type hp attack defense unlocked ``` ## Bảng Battle ```text Battle ------------------ id player_id character_id enemy_id result turn_count damage_dealt damage_taken started_at ended_at ``` ## Bảng Action History ```text ActionHistory ------------------ id battle_id turn_number actor action_type timestamp ``` ## Bảng Skill ```text Skill ------------------ id name type damage cooldown description ``` Quan hệ: ```text Player │ └────< Battle │ ├──── Character │ ├──── Enemy │ └────< ActionHistory ``` --- # 4.3 Xây dựng ứng dụng # 4.3.1 Thư viện và công cụ sử dụng ### Ngôn ngữ **Java** ### GUI **JavaFX** ### Build **Maven** ### Database **SQLite** ### Version Control **Git + GitHub** ### IDE **IntelliJ IDEA / VS Code / Eclipse** ### Testing **JUnit** ### UML Có thể sử dụng: - PlantUML - draw.io - StarUML ### AI Không yêu cầu API trả phí. AI có thể được xây dựng hoàn toàn bằng Java: ```text BehaviorTracker + PatternAnalyzer + ActionPredictor + DifficultyManager ``` Điều này rất phù hợp với tiêu chí: > Không sử dụng công nghệ mất phí. --- # 4.3.2 Kết quả đạt được MVP dự kiến có: ### Character - Encapsulation - Inheritance - Polymorphism - Abstraction - Interface ### Enemy - NullPointerException Boss - InfiniteLoop Boss - ClassCastException Boss - StackOverflow Boss ### Game modes **Training Mode** Học từng concept. **Battle Mode** Đánh Bug. **Boss Mode** Đánh Boss có AI. **Quiz Battle** Trả lời câu hỏi OOP để gây damage. **Class Lab** Xem class/object/UML trực quan. --- # 4.3.3 Minh họa các chức năng chính ## Feature 1 — OOP Battle ```text Character ↓ Choose Skill ↓ Battle Engine ↓ Damage Calculation ↓ Enemy Reaction ``` --- ## Feature 2 — Quiz Attack Ví dụ: ```text ╔══════════════════════════════════╗ ║ QUIZ ATTACK ║ ╠══════════════════════════════════╣ ║ Which concept hides internal ║ ║ implementation details? ║ ║ ║ ║ A. Inheritance ║ ║ B. Encapsulation ║ ║ C. Polymorphism ║ ║ D. Generic ║ ╚══════════════════════════════════╝ ``` Đúng: ```text +30 DAMAGE ``` Sai: ```text -10 HP ``` Như vậy kiến thức trực tiếp ảnh hưởng tới gameplay. --- # Feature 3 — Class Lab Người chơi chọn: ```text Polymorphism ``` Hệ thống hiển thị: ```text Character ▲ ┌──────┼──────┐ │ │ │ Dog Cat Bird │ │ │ bark() meow() sing() ``` Có thể click từng class để xem: ```text Attributes Methods Inheritance Override Interface ``` --- # Feature 4 — Adaptive Boss Ví dụ người chơi: ```text Turn 1 ATTACK Turn 2 ATTACK Turn 3 ATTACK Turn 4 ATTACK ``` AI: ```text Attack probability = 82% → Boss switches to Counter Mode ``` Người chơi nhận ra: > "Boss đang bắt bài mình." Đây chính là **hook để tạo wow moment trong demo**. --- # 4.4 Kiểm thử ## Unit Test Test: - Character damage. - Skill. - HP. - Cooldown. - AI prediction. - Difficulty. - Quiz validation. Ví dụ: ```java @Test void characterCannotHaveNegativeHp() { Character hero = new EncapsulationHero(); hero.takeDamage(9999); assertEquals(0, hero.getHp()); } ``` --- ## AI Test Input: ```text ATTACK ATTACK ATTACK ATTACK ATTACK ``` Expected: ```text Predicted action = ATTACK ``` Input: ```text DEFEND DEFEND DEFEND DEFEND ``` Expected: ```text Predicted action = DEFEND ``` --- ## Integration Test Kiểm tra: ```text UI ↓ Controller ↓ BattleService ↓ BattleEngine ↓ AI ↓ Repository ↓ Database ``` --- # 4.5 Triển khai MVP có thể đóng gói thành: ```text OOP-Arena/ ├── oop-arena.jar ├── config/ ├── database/ │ └── oop_arena.db └── README.md ``` Người dùng cài Java Runtime phù hợp và chạy: ```bash java -jar oop-arena.jar ``` Trong phiên bản hoàn thiện có thể đóng gói native application cho Windows. --- # CHƯƠNG 5. CÁC GIẢI PHÁP VÀ ĐÓNG GÓP NỔI BẬT Đây là chương **rất quan trọng đối với hackathon**. Không nên chỉ nói: > "Ứng dụng có CRUD và JavaFX." Phải nhấn mạnh các điểm khác biệt. --- # 5.1 Biến OOP thành gameplay Thay vì: ```text OOP → textbook → code ``` hệ thống sử dụng: ```text OOP ↓ Character ↓ Skill ↓ Battle ↓ Consequence ``` Ví dụ: > Polymorphism không còn là một đoạn code trong slide mà trở thành một nhân vật có khả năng thay đổi hành vi trong trận đấu. --- # 5.2 AI không phải chatbot Một điểm nổi bật: > **AI được dùng để điều khiển gameplay thay vì sinh nội dung văn bản.** AI quan sát: ```text Player behavior ``` và tạo: ```text Adaptive enemy behavior ``` Điều này khiến AI trở thành **một phần thực sự của sản phẩm**, thay vì một chatbot được gắn thêm để "có AI". --- # 5.3 AI tạo trải nghiệm cá nhân hóa Hai người chơi khác nhau sẽ có thể gặp Boss khác nhau. ### Player A ```text Aggressive Attack-heavy ``` → Boss thiên về Counter. ### Player B ```text Defensive Skill-heavy ``` → Boss thay đổi chiến thuật. Do đó: > **Cùng một Boss nhưng gameplay không hoàn toàn giống nhau.** --- # 5.4 Gamification Kiến thức OOP được đưa vào: - HP - Damage - Skill - Level - XP - Boss - Achievement - Combo - Quiz Ví dụ: ```text +50 XP Unlocked: POLYMORPHISM ``` --- # 5.5 "OOP trong OOP" Đây là điểm mình đặc biệt khuyến nghị nhấn mạnh khi thuyết trình. Ứng dụng **dạy OOP bằng một hệ thống được xây dựng bằng OOP**. Ví dụ: ```text Game Character ↓ Abstract Class ↓ Inheritance ↓ Override ↓ Polymorphism ``` Trong khi chính source code của game cũng sử dụng: ```text Abstract Class Inheritance Encapsulation Polymorphism Interface Generic Exception Collection ``` Nói cách khác: > **Sản phẩm vừa là công cụ học OOP, vừa là một case study về cách xây dựng phần mềm hướng đối tượng.** --- # 5.6 Mapping toàn bộ kiến thức môn học Đây là bảng rất đáng đưa vào slide/demo: | Chương | Trong OOP Arena | | --------- | ------------------------------- | | Chương 1 | Tổng quan hệ thống | | Chương 2 | Java + UML | | Chương 3 | Encapsulation | | Chương 4 | Constructor + Object | | Chương 5 | Overloading + static | | Chương 6 | Aggregation + Inheritance | | Chương 7 | Abstract + Interface + Override | | Chương 8 | Polymorphism | | Chương 9 | Generic + Collection | | Chương 10 | Exception | | Chương 11 | JavaFX | | Chương 12 | Class Diagram + OO Design | | Chương 13 | SOLID + Design Pattern | Như vậy sản phẩm **không phải game Java đơn thuần**. Nó là một **hệ thống tích hợp gần như toàn bộ nội dung môn học**. --- # 5.7 Áp dụng SOLID Ví dụ: ```text BattleEngine ``` không nên trực tiếp biết cách AI dự đoán. Thay vào đó: ```java public interface EnemyStrategy { Action chooseAction(BattleState state); } ``` Có: ```java RandomStrategy AggressiveStrategy DefensiveStrategy AdaptiveStrategy ``` Battle Engine chỉ biết: ```java EnemyStrategy strategy; ``` → dễ mở rộng. Đây là cách đưa **Design Pattern + SOLID** vào chương nâng cao. --- # 5.8 Design Pattern Có thể áp dụng: ### Strategy Pattern Cho AI: ```text EnemyStrategy ├── RandomStrategy ├── AggressiveStrategy ├── DefensiveStrategy └── AdaptiveStrategy ``` ### Factory Pattern Tạo character: ```java CharacterFactory.create("POLYMORPHISM"); ``` ### Observer Pattern Theo dõi: ```text HP changed Battle state changed Turn changed ``` ### Repository Pattern Tách database khỏi business logic. Đây sẽ là điểm cộng kỹ thuật lớn. --- # CHƯƠNG 6. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN # 6.1 Kết luận Đề tài **OOP Đại Chiến – OOP Arena** hướng tới giải quyết vấn đề học các khái niệm lập trình hướng đối tượng theo phương pháp trực quan và tương tác. Hệ thống chuyển đổi các khái niệm: ```text Class Object Inheritance Abstraction Encapsulation Polymorphism Interface Exception Generic ``` thành các thành phần gameplay. Bên cạnh đó, hệ thống sử dụng Adaptive AI để phân tích hành vi của người chơi và điều chỉnh chiến thuật của đối thủ. Điểm khác biệt của đề tài nằm ở việc AI không được sử dụng như một chatbot thông thường mà được tích hợp trực tiếp vào **cơ chế ra quyết định của game**. Đồng thời, chính phần mềm cũng được thiết kế theo các nguyên lý OOP mà nó giảng dạy. --- # 6.2 Hướng phát triển ## 1. Multiplayer ```text Player vs Player ``` ## 2. Online leaderboard ```text Global OOP Ranking ``` ## 3. AI nâng cao Có thể thay Markov-based prediction bằng: - Decision Tree; - Reinforcement Learning; - Q-Learning; - contextual bandit; - machine learning model. ## 4. Procedural Boss Tạo Boss với: ```text Random abilities Random weaknesses Random patterns ``` ## 5. OOP Campaign ```text Chapter 1 ↓ Chapter 2 ↓ ... Chapter 13 ``` Mỗi chapter mở khóa một cơ chế. ## 6. Teacher Mode Giáo viên có thể: - tạo quiz; - xem kết quả; - xem concept nào sinh viên yếu; - tạo custom Boss. --- # TÀI LIỆU THAM KHẢO Có thể xây dựng danh mục tham khảo theo các nhóm: 1. Tài liệu Java chính thức. 2. Tài liệu JavaFX. 3. Tài liệu SQLite. 4. Tài liệu UML. 5. Tài liệu về Object-Oriented Design. 6. Tài liệu về Design Patterns. 7. Tài liệu về Adaptive AI / game AI. 8. Giáo trình Lập trình hướng đối tượng của môn học. Khi hoàn thiện báo cáo, các tài liệu cụ thể cần được ghi theo một chuẩn thống nhất như IEEE hoặc APA. --- # PHỤ LỤC ## Phụ lục A — Danh sách Character | Character | Concept | Vai trò | | ----------------- | ------------- | -------- | | Shield Knight | Encapsulation | Tank | | Mutant Warrior | Inheritance | Damage | | Shapeshifter | Polymorphism | Adaptive | | Abstract Mage | Abstraction | Special | | Connector | Interface | Support | | Template Wizard | Generic | Utility | | Exception Handler | Exception | Counter | --- ## Phụ lục B — Danh sách Boss | Boss | Concept | | ------------ | -------------------- | | Null Beast | NullPointerException | | Loop Hydra | Infinite Loop | | Stack Demon | StackOverflow | | Cast Monster | ClassCastException | | Runtime Lord | RuntimeException | --- # ĐẶC TẢ USE CASE ## UC-01 — Quản lý người chơi **Actor:** Player ```text Create Profile ↓ Enter Username ↓ Validate ↓ Save ``` --- ## UC-02 — Chọn Character ```text Open Character Menu ↓ View Characters ↓ View Stats ↓ Select Character ↓ Confirm ``` --- ## UC-03 — Xem thông tin OOP ```text Select Concept ↓ View Character ↓ View OOP Principle ↓ View Example ``` --- ## UC-04 — Start Battle ```text Select Character ↓ Select Enemy ↓ Initialize Battle ↓ Start Turn ``` --- ## UC-05 — Attack ```text Player ↓ Attack ↓ BattleEngine ↓ Calculate Damage ↓ Enemy.takeDamage() ↓ Update UI ``` --- ## UC-06 — Use Skill ```text Player ↓ Select Skill ↓ Validate Cooldown ↓ Execute Skill ↓ Apply Effect ↓ Update Battle State ``` --- ## UC-07 — Answer Quiz ```text Show Question ↓ Player Answer ↓ Validate Answer ↓ Correct? ↙ ↘ Yes No ↓ ↓ Damage Penalty ``` --- ## UC-08 — Adaptive AI ```text Enemy Turn ↓ Read Battle State ↓ Read Action History ↓ Analyze Pattern ↓ Predict Player Action ↓ Evaluate Available Actions ↓ Select Strategy ↓ Execute Action ``` --- ## UC-09 — Save Battle Result ```text Battle End ↓ Calculate Result ↓ Calculate XP ↓ Update Player ↓ Save Battle ↓ Save Action History ↓ Update Statistics ```