MỞ ĐẦU1.Giới thiệu đề tài: Đề tài Game Mê Cung Maze Game là một trò chơi trí tuệ, trong đó người chơi điều khiển nhân vật di chuyển trong một mê cung phức tạp để tìm đường ra trong thời
GIỚI THIỆU
1.Giới thiệu về ngôn ngữ lập trình Python
Python là một ngôn ngữ lập trình bậc cao cho các mục đích lập trình đa năng, do Guido van Rossum tạo ra và lần đầu ra mắt vào năm 1991 Python được thiết kế với ưu điểm mạnh là dễ đọc, dễ học và dễ nhớ Python là ngôn ngữ có hình thức rất sáng sủa, cấu trúc rõ ràng, thuận tiện cho người mới học lập trình và là ngôn ngữ lập trình dễ học; được dùng rộng rãi trong phát triển trí tuệ nhân tạo Cấu trúc của Python còn cho phép người sử dụng viết mã lệnh với số lần gõ phím tối thiểu Vào tháng 7 năm 2018, van Rossum đã từ chức lãnh đạo trong cộng đồng ngôn ngữ Python sau 30 năm làm việc.
Python hoàn toàn tạo kiểu động và dùng cơ chế cấp phát bộ nhớ tự động; do vậy nó tương tự như Perl, Ruby, Scheme, Smalltalk, và Tcl Python được phát triển trong một dự án mã mở, do tổ chức phi lợi nhuận Python Software Foundation quản lý.
Ban đầu, Python được phát triển để chạy trên nền Unix Nhưng rồi theo thời gian, Python dần mở rộng sang mọi hệ điều hành từ MS-DOS đến Mac
OS, OS/2, Windows, Linux và các hệ điều hành khác thuộc họ Unix Mặc dù sự phát triển của Python có sự đóng góp của rất nhiều cá nhân, nhưng Guido van Rossum hiện nay vẫn là tác giả chủ yếu của Python Ông giữ vai trò chủ chốt trong việc quyết định hướng phát triển của Python.
Python luôn được xếp hạng vào những ngôn ngữ lập trình phổ biến nhất.
2.Giới Thiệu về thư viện Pygame
Pygame là một tập hợp các module Python được thiết kế để viết trò chơi điện tử Pygame bổ sung chức năng lên trên thư viện SDL Điều này cho phép ta tạo các trò chơi và chương trình đa phương tiện đầy đủ tính năng bằng ngôn ngữ Python.
Pygame có tính di động cao và chạy trên hầu hết mọi nền tảng và hệ điều hành.
Pygame miễn phí Được phát hành theo giấy phép LGPL, ta có thể tạo mã nguồn mở, phần mềm miễn phí, phần mềm chia sẻ và trò chơi thương mại với nó.
3.Một số module thuộc thư viện Pygame
- Một số lớp cơ bản:
• pygame.Color : Đại diện cho một màu sắc, gồm 4 thuộc tính thể hiện cho 4 yếu tố màu là đỏ (r), lục (g), lam (b) và độ trong suốt
(a) Các đối tượng của lớp này được dùng để truyền và các hàm có hỗ trợ trong các module của thư viện Pygame đề xác định màu cần vẽ.
• pygame.Surface : Đại diện cho một bề mặt hay khung vẽ cho phép ta vẽ hình lên nó Đối tượng của lớp này có thể là khung màn hình (là giá trị trả về của hàm pygame.display.set_mode()), hay khung được người lập trình định nghĩa để chứa một nhóm hình được vẽ trước mà về sau có thể vẽ lên khung màn hình Lớp cung cấp hàm blit() cho phép vẽ khung này lên khung khác hay lên màn hình
• pygame.Rect : Là lớp cho phép tạo các đối tượng lưu trữ tọa độ của các vật thể trên màn hình Gồm một số thuộc tính có thể sử dụng như: x, y, w, h, top, left, bottom, right, size, width, height.
• pygame.event.Event : Là lớp đại diện cho các sự kiện xảy ra trong chương trình, chẳng hạn như thoát chương trình, người dùng nhập bàn phím, chuột di chuyển hay cả việc kích thước màn hình thay đổi.
• pygame.font.Font : Là lớp hỗ trợ việc tải phông chữ và có hàm cho phép tạo ra pygame.Surface mới và vẽ chữ trên nó cho phông chữ hiện tại.
- Một số hàm cơ bản:
• pygame.init() : là hàm giúp khởi tạo, tải các thành phần của thư viện Pygame vào ứng dụng trò chơi của ta.
• pygame.quit() : là hàm giúp ta hủy khởi tạo các thành phần của thư viện của Pygame, giúp ta thoát ứng dụng một cách an toàn.
• pygame.display.set_mode() : là hàm giúp khởi tạo cửa sổ hoặc màn hình để hiển thị.
• pygame.display.flip() : là hàm giúp cập nhật lại toàn bộ màn hình.
• pygame.display.update() : là hàm giúp cập nhật một phần màn hình nếu ta cung cấp các đối tượng thuộc lớp pygame.Rect cần cập nhật, ngược lại nó sẽ cập nhật toàn bộ màn hình.
• pygame.display.Info() : là hàm giúp thu thập các thông số của màn hình hiển thị cũng như cửa sổ ứng dụng hiện tại.
• pygame.display.set_caption() : Là hàm giúp thay đổi tiêu đề của cửa sổ ứng dụng.
• pygame.draw.rect() : Là hàm dùng để vẽ một hình chữ nhật lên các đối tượng thuộc lớp pygame.Surface.
• pygame.draw.circle() : Là hàm dùng để vẽ một hình chữ nhật lên các đối tượng thuộc lớp pygame.Surface.
• pygame.event.get() : Là hàm giúp lấy ra toàn bộ các sự kiện trong hàng đợi sự kiện của ứng dụng.
• pygame.font.SysFont() : là hàm giúp tải phông chữ hệ thống từ tên phông chữ hệ thống.
• pygame.font.Font.render() : là hàm giúp tạo ra pygame.Surface và vẽ chữ trên nó cho phông chữ hiện tại.
• pygame.image.load() : là hàm giúp tạo ra pygame.Surface và vẽ ảnh đó lên.
4.Giới thiệu về Maze Game
Maze Game (Trò chơi Mê Cung) là một thể loại trò chơi giải đố cổ điển, được xây dựng trên một khung giới hạn (thường là một khu vực hình chữ nhật) chứa các đường đi và các bức tường.
Mục tiêu của trò chơi là người chơi phải tìm ra đường đi hợp lệ, điều khiển nhân vật từ điểm Xuất phát (Start) đến điểm Kết thúc (End) Người chơi sử dụng các phím điều khiển (thường là các phím mũi tên) để di chuyển nhân vật lên, xuống, trái, phải Quy tắc cơ bản là nhân vật không được phép di chuyển vào các ô tường, buộc người chơi phải quan sát và lập kế hoạch di chuyển qua các đường đi (Paths) chằng chịt Trò chơi kết thúc khi nhân vật chạm đến vị trí đích, thường có thể bổ sung thêm các yếu tố như tính thời gian, vật phẩm hoặc bẫy để tăng thêm thử thách cho người chơi.
Hình 2.1: Hình minh họa cho một màn chơi.
PHÁT TRIỂN ỨNG DỤNG MAZE GAME
Mục tiêu chung
● Xây dựng một game mê cung 2D (top-down) cho người chơi: di chuyển qua mê cung, né kẻ địch, tới ô exit để hoàn thành level.
● Hỗ trợ đăng ký / đăng nhập, lưu tiến trình, lưu điểm, leaderboard.
● Cho phép tùy chỉnh skin nhân vật (preset, màu, ảnh) và sửa/tạo mê cung tùy ý (Maze Editor).
● Hỗ trợ âm thanh, UI đơn giản, nhiều level, tăng độ khó theo level.
Thành phần chính (modules) và trách nhiệm
○ Điểm vào chương trình; khởi tạo pygame, màn hình, Game và vòng lặp chính.
○ Điều phối toàn bộ trạng thái game (menu, login, playing, editor, leaderboard, ).
○ Sinh mê cung, tạo player/enemy, xử lý sự kiện cấp cao, cập nhật và render.
○ Quản lý vị trí, di chuyển, va chạm, skin, HP và render nhân vật.
○ Hành vi kẻ địch (patrol, chase), va chạm, tấn công người chơi và render kẻ địch.
● maze_generator.py (class MazeGenerator)
○ Sinh mê cung bằng DFS và Prim.
○ Đánh dấu ô start/exit, phân bố enemy (cell type CELL_ENEMY).
○ Quản lý SQLite: bảng users, scores, mazes, multiplayer_sessions.
○ Hash mật khẩu, đăng ký/đăng nhập, lưu điểm/maze, load mazes, update skin/progress.
○ Giao diện chỉnh sửa mê cung: vẽ tường/start/exit/enemy, lưu/ tải từ DB.
● UI (thư mục src/UI)
○ UIManager.py — helper để vẽ text.
○ Button.py — button cơ bản.
○ InputBox.py — textbox cho username/password.
○ SkinSelector.py — màn hình chọn skin (kết hợp pygame + tkinter để chọn màu/ảnh).
○ constants.py — hằng số dùng chung (màu, kích thước, trạng thái, cell types, skin list, v.v.).
○ font_manager.py — hàm get_font để tải font hỗ trợ tiếng Việt.
○ sound_manager.py — class SoundManager quản lý hiệu ứng âm thanh.
Data flow
2 Người dùng tương tác menu / login (qua InputBox, UIManager).
3 Khi bắt đầu level: Game._generate_level() gọi MazeGenerator
4 Game tìm ô CELL_START/CELL_ENEMY để tạo Player và Enemy.
○ Check: kiểm tra win/lose, save điểm.
6 Khi kết thúc level / game, DatabaseManager lưu điểm/tiến trình/maze.
Trạng thái hệ thống (state machine)
Các trạng thái chính của game được định nghĩa trong constants.py
(STATE_MENU, STATE_LOGIN, STATE_PLAYING, ) Dưới đây là bảng tóm tắt trạng thái và sự kiện chuyển đổi:
Trạng thái hiện tại Sự kiện Trạng thái kế tiếp khi chy to tr v ma trn mê cung.
Input: s kin pygame Game.handle_event() chuyn xung Player.handle_input().
Game.update() cp nht player.update(), v mê cung, nhân vt, enemy, UI.
Menu Nhấn 1 (Start/Continue) playing / login nếu chưa login
Menu Nhấn 2 (New Game) playing / login
Menu Nhấn 6 login (nếu chưa) hoặc đăng xuất login ENTER (thành công) menu login Nhấn R register register ENTER (thành công) chuyển về login tự động playing ESC/P paused paused ESC/P playing playing đạt exit level_complete playing HP = 0 game_over editor ESC menu
2.Sơ đồ chức năng (Use case)
Hình 2 Use case tổng quát
Use Case 1: Đăng ký / Đăng nhập
● Tiền điều kiện: Ứng dụng đã được mở
○ Người chơi chọn Login/Register từ menu.
○ Nhập username/password qua InputBox.
○ gọi DatabaseManager.register_user hoặc login_user.
○ Nếu thành công, lưu thông tin user vào Game.current_user.
○ Username đã tồn tại → thông báo lỗi.
Sai mt khu thông báo.
Use Case 2: Chơi game (Start/Continue)
● Tiền điều kiện: Trên menu, chọn Start (hoặc Continue nếu có tiến trình).
1 Game gọi sinh mê cung.
4 Người chơi điều khiển nhân vật, né kẻ địch.
5 Nếu chạm ô EXIT → level complete, update DB nếu đăng nhập. 6.
Vòng lp chính chy (Input Update Render Check).
Nu HP str:
"""Hash password using SHA-256.""" return hashlib.sha256(password.encode()).hexdigest() Đăng ký def register_user(self, username: str, password: str):
"""Đăng ký người dùng mới.""" try: hashed_pw = self.hash_password(password) self.cursor.execute(
"INSERT INTO users (username, password, skin_type, skin_value, last_level) VALUES (?, ?, ?, ?, ?)",
) self.conn.commit() return True except Exception as e: print(f"Lỗi khi đăng ký: {e}") return False Đăng nhập def login_user(self, username: str, password: str):
"""Đăng nhập tài khoản.""" try: hashed_pw = self.hash_password(password) self.cursor.execute(
"SELECT id, username, skin_type, skin_value, last_level FROM users WHERE username = ? AND password = ?",
) result = self.cursor.fetchone() if result: return {
} return None except Exception as e: print(f"Lỗi khi đăng nhập: {e}") return None
3.3.2 Các chức năng DB (API của DatabaseManager)
● register_user(username, password) — hash password bằng SHA-256, insert user.
● login_user(username, password) — so sánh hash.
● update_user_progress(user_id, last_level) — cập nhật last_level.
● update_user_skin(user_id, skin_type, skin_value) — lưu skin.
● save_score(user_id, score, level) — insert vào bảng scores.
● get_leaderboard(limit) — lấy top scores kèm username.
● save_custom_maze(name, maze_data, user_id) — lưu maze dưới dạng
● get_custom_mazes(user_id) / load_custom_maze(maze_id) — quản lý mazes.
Cấu trúc vòng lặp game
Vòng lặp chính tuân thủ mô hình:
Game nhận sự kiện bàn phím từ pygame.event.get() Người chơi có thể:
● Di chuyển bằng phím W, A, S, D hoặc phím mũi tên.
● Dừng/tạm dừng bằng ESC.
● Chọn tùy chọn trong menu bằng chuột hoặc phím Enter.
3.4.2 Update (Cập nhật trạng thái)
● Cập nhật vị trí nhân vật dựa trên hướng di chuyển và tốc độ
● Di chuyển kẻ địch (Enemy) tự động trong mê cung.
● Tính toán điểm, máu, và thời gian chơi.
● Kiểm tra va chạm giữa người chơi và kẻ địch.
● Cập nhật hiệu ứng âm thanh qua SoundManager.
● Vẽ mê cung, nhân vật, kẻ địch, và các UI lên màn hình.
● Cập nhật thanh máu, điểm, và thời gian.
● Hiển thị thông báo khi thắng hoặc thua.
● Dùng pygame.display.flip() để cập nhật khung hình.
3.4.4 Check (Kiểm tra điều kiện)
● Nếu người chơi chạm CELL_EXIT → chuyển sang màn tiếp theo, lưu điểm.
Input Update Render Check Loop.
● Kiểm tra thời gian giới hạn của level (LEVEL_TIME_LIMIT).
Sau mỗi chu kỳ, game tiếp tục lặp lại từ bước Input cho đến khi người chơi thoát Bộ đếm FPS đảm bảo tốc độ khung hình ổn định (60 FPS).
# Main game loop running = True while running:
# Handle events (Input) for event in pygame.event.get(): if event.type == pygame.QUIT: running = False game.handle_event(event) # Update game state (Update) dt = clock.tick(FPS) / 1000.0 # Delta time in seconds game.update(dt)
# Render to screen (Render) game.render()
# Update display pygame.display.flip() # Check game conditions (Check) if game.should_quit: running = False Đây là vòng lặp chính của trò chơi, đảm nhận việc xử lý sự kiện, cập nhật trạng thái và vẽ khung hình mới liên tục để tạo chuyển động.
Thuật toán sinh mê cung
Để tạo ra các bản đồ mê cung ngẫu nhiên trong trò chơi, hệ thống sử dụng hai thuật toán phổ biến:
● DFS (Depth-First Search) – tạo mê cung dạng “ngõ cụt” phức tạp.
● Prim’s Algorithm – tạo mê cung có độ phân bố đường đi đều hơn.
Cả hai thuật toán đều hoạt động trên lưới ô vuông (grid), trong đó mỗi ô có thể là tường (CELL_WALL) hoặc đường đi (CELL_PATH).
3.5.1 Thuật toán DFS (Depth-First Search) a) Ý tưởng thuật toán
Thuật toán DFS sinh mê cung bằng cách xuất phát từ một ô ban đầu, mở đường ngẫu nhiên qua các ô chưa được thăm, và quay lui (backtrack) khi không còn hướng đi hợp lệ.
Kết quả là một mê cung có nhiều ngõ cụt và một đường duy nhất từ Start →
Exit. b) Các bước thực hiện
1 Khởi tạo toàn bộ lưới là tường (CELL_WALL).
2 Chọn ô bắt đầu (1, 1) → đánh dấu là đường đi (CELL_PATH).
3 Duyệt theo chiều sâu: o Lấy ô hiện tại từ ngăn xếp (stack). o Tìm ô láng giềng chưa thăm (cách 2 ô theo 4 hướng). o Nếu có:
▪ Chọn ngẫu nhiên 1 ô láng giềng,
▪ Đánh dấu ô đó là đường,
▪ Đưa vào stack. o Nếu không còn hướng đi, quay lui (pop).
4 Sau khi duyệt hết, gọi _set_start_and_exit() để đặt vị trí Start và Exit. c) Đoạn code def generate_dfs(self) -> List[List[int]]:
# Start from position (1, 1) start_x, start_y = 1, 1 self.maze[start_y][start_x] = CELL_PATH
# DFS stack stack = [(start_x, start_y)] while stack: x, y = stack[-1]
# Get unvisited neighbors (2 cells away) neighbors = self._get_unvisited_neighbors(x, y) if neighbors:
# Choose random neighbor nx, ny = random.choice(neighbors)
# Remove wall between current and neighbor wall_x = x + (nx - x) // 2 wall_y = y + (ny - y) // 2 self.maze[wall_y][wall_x] = CELL_PATH self.maze[ny][nx] = CELL_PATH stack.append((nx, ny)) else: stack.pop()
# Set start and exit self._set_start_and_exit() return self.maze d) Đặc điểm và ưu điểm
● Dễ cài đặt, tốc độ nhanh.
● Mỗi lần chạy tạo ra kết quả khác nhau nhờ ngẫu nhiên hóa. e) Hạn chế
● Cấu trúc mê cung không đồng đều, có vùng rỗng, vùng dày đặc.
● Độ “cân bằng” thấp hơn thuật toán Prim.
3.5.2 Thuật toán Prim (Prim’s Algorithm) a) Ý tưởng thuật toán
Thuật toán Prim bắt đầu từ một ô đường đi duy nhất, sau đó mở rộng dần bằng cách chọn ngẫu nhiên một bức tường nằm giữa vùng đã đi qua và vùng chưa đi qua, rồi phá tường để kết nối hai vùng.
Kết quả là một mê cung có độ phân bố đều hơn và ít ngõ cụt hơn DFS. b) Các bước thực hiện
1 Khởi tạo toàn bộ lưới là tường (CELL_WALL).
Cho ra mê cung có nhiu ngõ ct
2 Chọn ngẫu nhiên một ô bắt đầu → đánh dấu là đường (CELL_PATH).
3 Đưa các bức tường xung quanh ô đó vào danh sách walls.
4 Trong khi danh sách walls chưa rỗng: o Chọn ngẫu nhiên một bức tường (wall_x, wall_y). o Xác định hai ô nằm hai bên tường đó:
▪ Nếu một ô là đường, một ô chưa thăm, thì phá tường → biến ô chưa thăm thành đường.
▪ Thêm các tường mới xung quanh ô vừa mở vào danh sách.
5 Gọi _set_start_and_exit() để đặt điểm bắt đầu và kết thúc. c) Đoạn code def generate_prim(self) -> List[List[int]]:
# Start from random position start_x = random.randrange(1, self.width, 2) start_y = random.randrange(1, self.height, 2) self.maze[start_y][start_x] = CELL_PATH
# List of walls to consider walls = self._get_surrounding_walls(start_x, start_y) while walls:
# Pick random wall wall_x, wall_y = random.choice(walls) walls.remove((wall_x, wall_y))
# Check if wall separates visited and unvisited cells neighbors = self._get_wall_neighbors(wall_x, wall_y) visited = [n for n in neighbors if self.maze[n[1]][n[0]] == CELL_PATH] unvisited = [n for n in neighbors if self.maze[n[1]][n[0]] == CELL_WALL] if len(visited) == 1 and len(unvisited) == 1:
# Remove wall self.maze[wall_y][wall_x] = CELL_PATH
# Mark unvisited cell as path ux, uy = unvisited[0] self.maze[uy][ux] = CELL_PATH
# Add new walls new_walls = self._get_surrounding_walls(ux, uy) for w in new_walls: if w not in walls and self.maze[w[1]][w[0]] == CELL_WALL: walls.append(w)
# Set start and exit self._set_start_and_exit() return self.maze d) Đặc điểm và ưu điểm
● Tạo mê cung có cấu trúc cân bằng, đường đi phân bố đều.
● level dễ hoặc bản đồ rộng.
● Tốc độ sinh tương đối nhanh, ổn định. e) Hạn chế
● Kết quả có thể ít tính “ngẫu nhiên” hơn DFS.
Cấu trúc mê cung đôi khi hơi đều, giảm độ khó. Ít ngõ ct phù hp cho các
Thuật toán điều khiển kẻ địch (Enemy AI)
Kẻ địch trong Maze Game hoạt động dựa trên AI hai trạng thái: tuần tra (Patrol) và truy đuổi (Chase).
Hệ thống này giúp enemy di chuyển tự nhiên và phản ứng theo khoảng cách đến người chơi. a) Cấu trúc tổng quát
● Khi người chơi ở xa hơn một ngưỡng nhất định (8 × TILE_SIZE), enemy di chuyển ngẫu nhiên (patrol).
● Khi người chơi tiến vào vùng phát hiện, enemy chuyển sang trạng thái chase và đuổi theo. b) Thuật toán truy đuổi (Chase)
1 Lấy tọa độ (x, y) của enemy và (x_p, y_p) của người chơi.
2 Tính vector hướng: dx = x p − x , dy = y p − y
4 Nếu distance > 0, cập nhật vận tốc theo hướng người chơi: v x = dx distance , v y = dy distance
5 Trong bước update, vị trí enemy được cập nhật: x= x +v x × speed × dty= y+ v y × speed× dt
6 Nếu phát hiện tường (CELL_WALL), vận tốc đảo ngược để phản hồi va chạm. Đoạn code mô tả def _chase_player(self, player_pos):
"""Enemy hướng về phía người chơi.""" dx = player_pos[0] - self.x dy = player_pos[1] - self.y distance = math.hypot(dx, dy) if distance > 0: self.velocity_x = dx / distance self.velocity_y = dy / distance c) Thuật toán tuần tra (Patrol)
Khi không phát hiện người chơi, enemy tự thay đổi hướng ngẫu nhiên sau mỗi khoảng thời gian 1–3 giây: v x = cos ( θ ) , v y = sin ( θ ) ,θ ∈ ¿
Code: def _patrol(self, dt):
"""Di chuyển ngẫu nhiên khi người chơi ở xa.""" if self.direction_timer >= self.direction_change_time: angle = random.uniform(0, 2 * math.pi) self.velocity_x, self.velocity_y = math.cos(angle), math.sin(angle) d) Xử lý va chạm và tấn công
● Hàm _check_collision() đảm bảo enemy không di chuyển xuyên tường.
● Khi va chạm với player, enemy gây sát thương và kích hoạt thời gian hồi chiêu (cooldown) trước khi có thể tấn công lại.
KẾT QUẢ VÀ ĐÁNH GIÁ
Sau quá trình thiết kế và lập trình, trò chơi Mê Cung (Maze Game) đã được hoàn thiện với các chức năng chính sau:
● Giao diện trực quan: Hiển thị mê cung bằng dạng ô vuông, dễ nhìn và dễ thao tác.
● Điều khiển linh hoạt: Người chơi có thể di chuyển nhân vật bằng các phím mũi tên (↑ ↓ ← →).
● Kiểm tra va chạm chính xác giữa nhân vật và tường.
● Phát hiện điểm đích, hiển thị thông báo chiến thắng.
● Sinh mê cung ngẫu nhiên (tùy chọn): Mỗi lần chơi có thể tạo mê cung mới, tăng độ thử thách.
● Tốc độ xử lý ổn định: Game chạy mượt, không bị giật lag, phù hợp với máy cấu hình thấp.
Bảng kiểm thử test-case:
STT Mô tả chức năng kiểm thử
Bước thực hiện Kết quả mong đợi Kết quả thực tế Đánh giá
1 Khởi động game Chạy chương trình Cửa sổ game hiển thị mê cung
2 Di chuyển nhân vật sang phải
Nhân vật di chuyển một ô sang phải
Nhân vật không thể đi xuyên qua tường
4 Đến được vị trí đích Di chuyển nhân vật đến ô đích
Hiển thị thông báo hoàn thành cấp độ Đúng theo yêu cầu ✅ Đạt
5 Thời gian phản hồi Liên tục di chuyển nhân vật trong 10 giây
Không bị trễ, game mượt
Nhn phím “” ti v trí sát tng
6 Tạo mê cung mới Chọn nút “New
Mê cung mới xuất hiện, khác trước
Chọn nút “Logout” Tài khoản được đăng xuất Đúng theo yêu cầu ✅ Đạt
8 Thoát game Chọn nút “esc” Cửa sổ game đóng lại
Chính xác ✅ Đạt Đánh giá:
○ Giao diện đơn giản, âm thanh sinh động, dễ sử dụng, thân thiện với người chơi.
○ Cấu trúc mã nguồn rõ ràng, dễ mở rộng hoặc chỉnh sửa.
○ Game hoạt động ổn định, không xuất hiện lỗi treo hoặc crash.
○ Logic xử lý đường đi và kiểm tra va chạm hoạt động chính xác.
○ Mê cung sinh ngẫu nhiên nên không nhàm chán.
○ Chưa hỗ trợ chơi hai người hoặc chơi trực tuyến.
