bao-cao-mon-hoc-ai-de-tai-bao-cao.docx

lOMoAR cPSD|15600744
TRƯỜNGĐẠIHỌCKIẾNTRÚCHÀNỘI
KHOACÔNGNGHỆTHÔNGTIN
ĐỒ ÁN MÔN HỌC TRÍ TUỆ NHÂN TẠO
NGHIÊNCỨUVÀ XÂYDỰNGTRÒCHƠIRẮNSĂNMỒI
SỬ DỤNG THUẬT TOÁN TÌM KIẾM THEO CHIỀU
RỘNG(BFS)
Ngành: CÔNG NGHỆ THÔNG TIN
Giảngviênhướngdẫn:Ths.NguyễnThịHuệ
Lớp:21CN2
Nhóm: 3
Nhóm sinh viên thực hiện:
Họ và tên: Mai Xuân Điệp Msv: 2155010072
Họ và tên: Nguyễn Đỗ Công Msv: 2155010037
Họ và tên: Vũ Tuấn Dương Msv: 2155010062
Họ và tên: Nguyễn Vũ Việt Anh Msv: 2155010017
Hà Nội, 10/2023

MỤC LỤC
LỜI MỞ ĐẦU........................................................................................................................................ 5
DANH MỤC BẢNG BIỂU ................................................................................................................... 6
DANH MỤC CÁC TỪ VIẾT TẮT ...................................................................................................... 7
CHƯƠNG 1: CƠ SỞ LÝ THUYẾT..................................................................................................... 8
1.1. Tổng quan về trí tuệ nhân tạo........................................................................................................ 8
1.1.1. Khái niệm.......................................................................................................................................8
1.1.2. Phân loại ........................................................................................................................................9
1.1.3. Ứng dụng của trí tuệ nhân tạo......................................................................................................10
1.1.4. Mặt tích cực và khó khăn của trí tuệ nhân tạo..............................................................................12
1.2. Tổng quan về đề tài..................................................................................................................... 13
1.2.1. Mô tả trò chơi...............................................................................................................................13
1.2.2. Lịch sử hình thành và phát triển của trò chơi...............................................................................13
1.2.3. Ứng dụng và đề xuất cải tiến trò chơi ..........................................................................................14
1.3. Các công nghệ áp dụng trong đề tài............................................................................................ 14
1.3.1. Tổng quan về ngôn ngữ lập trình Python.....................................................................................15
1.3.2. Thư viện Pygame .........................................................................................................................16
CHƯƠNG 2: ỨNG DỤNG THUẬT TOÁN BREADTH FIRST SEARCH XÂY DỰNG SNAKE
GAME .................................................................................................................................................. 18
2.1. Thuật toán Breadth First Search.................................................................................................. 18
2.1.1. Mô tả thuật toán ...........................................................................................................................18
2.1.2. Thuật toán ....................................................................................................................................18
2.1.3. Ưu, nhược điểm ...........................................................................................................................20
2.2. Ứng dụng thuật toán Breadth First Search xây dựng Snake Game............................................. 21
2.2.1. Thuật toán BFS trong trò chơi rắn săn mồi..................................................................................21
2.2.2. Áp dụng thuật toán BFS...............................................................................................................21
CHƯƠNG 3: XÂY DỰNG VÀ TRIỂN KHAIỨNG DỤNG ........................................................... 23
3.1. Xây dựng trò chơi ....................................................................................................................... 23
3.1.1. Xây dựng khung nhìn...................................................................................................................23
3.1.2. Xây dựng con rắn và thức ăn .......................................................................................................24
3.1.3. Hiển thị điểm số và thông điệp ....................................................................................................25
3.2. Hoạt động của trò chơi................................................................................................................ 25
3.2.1. Di chuyển.....................................................................................................................................25
3.2.2. Tìm đường đi ...............................................................................................................................27
3.3. Áp dụng thuật toán BFS.............................................................................................................. 28
3.4. Hoàn thiện trò chơi...................................................................................................................... 29
KẾT LUẬN.......................................................................................................................................... 34
Tài liệu tham khảo .............................................................................................................................. 35

LỜI MỞ ĐẦU
Công nghệ thông tin đang phát triển với tốc độ chóng mặt, trong đó lập trình là
một trong những lĩnh vực quan trọng nhất. Lập trình là quá trình viết các chương
trình máy tính để thực hiện các nhiệm vụ cụ thể. Để trở thành một lập trình viên
giỏi, cần phải có kiến thức vững chắc về nguyên lý và kỹ thuật lập trình.
Môn học "Nguyên lý và kỹ thuật lập trình" là môn học cơ sở của ngành công
nghệ thông tin, có vai trò quan trọng trong việc đào tạo các kỹ sư công nghệ thông
tin. Kiến thức và kỹ năng được học trong môn học này sẽ giúp sinh viên có nền
tảng vững chắc để học các môn học chuyên ngành khác và phát triển sự nghiệp
trong lĩnh vực công nghệ thông tin. Trong đây nhóm em sẽ nghiên cứu và xây
dựng trò chơi rắn săn mồi sử dụng thuật toán tìm kiếm theo chiều rộng (BFS).
Trò chơi rắn săn mồi là một trò chơi cổ điển, phổ biến và dễ cài đặt. Trong trò
chơi này đòi hỏi con rắn phải có khả năng ra quyết định thông minh để tìm kiếm
mồi, trong khi đó tránh va chạm với thân mình và biên của bản đồ, kèm theo đó
là sống sót lâu nhất có thể. Đây là một bài toán thú vị, có thể áp dụng nhiều kỹ
thuật và thuật toán khác nhau để giải quyết. Và BFS là thuật toán tìm kiếm theo
chiều rộng nổi tiếng trong lý thuyết đồ thị. Thuật toán này sẽ duyệt từ gốc và
loang dần đến các nút có độ sâu tăng dần. Nó là một thuật toán đơn giản giúp
chúng ta tìm được đường đi ngắn nhất giữa 2 ô trong ma trận. Dựa trên thuật
toán này chúng ta sẽ xây dựng được một AI đơn giản cho Snake game. Từ đó
mô tả một phần ứng dụng của AI trong thực tế.
Do kiến thức và vốn hiểu biết vẫn còn nhiều hạn chế nên trong đề tài nghiên
cứu vẫn còn nhiều thiếu sót, nhóm em kính mong quý thầy (cô) sẽ thông cảm và
đưa ra nhận xét về đề tài để nhóm có thể hoàn thiện hơn. Nhóm em xin chân
thành cảm ơn!

PHẦN I: MỞ ĐẦU
1. Lý do chọn đề tài
Trò chơi Snake (Rắn săn mồi) là một đề tài phù hợp để áp dụng các kiến thức và kỹ năng
về lập trình, đồng thời phát triển các kỹ năng mềm. Trò chơi này cũng là một cơ hội tốt
để giải trí và thư giãn. Trò chơi Snake nó có lối chơi đơn giản nhưng hấp dẫn, phù hợp
với mọi lứa tuổi. Sử dụng các khái niệm cơ bản về lập trình, các ngôn ngữ lập trình phổ
biến, các cấu trúc dữ liệu và thuật toán cơ bản, các kỹ thuật lập trình. Giúp phát triển các
kỹ năng mềm, chẳng hạn như kỹ năng giải quyết vấn đề, kỹ năng tư duy logic, kỹ năng
làm việc nhóm.
2. Mục tiêu của đề tài
Mục tiêu của đề tài là nghiên cứu và phát triển một trò chơi Snake mới với các tính năng
cải tiến so với các trò chơi Snake truyền thống. Các tính năng cải tiến này có thể bao
gồm:
 Tăng độ khó của trò chơi
 Thêm các yếu tố mới vào trò chơi, chẳng hạn như kẻ thù hoặc môi trường
 Tối ưu hóa hiệu suất của trò chơi
3. Đối tượng và phạm vi nghiên cứu
Đối tượng nghiên cứu của đề tài là trò chơi Snake. Phạm vi nghiên cứu bao gồm các
khía cạnh sau:
 Cơ chế trò chơi
 Đồ họa trò chơi
 Âm thanh trò chơi
 AI của trò chơi
4. Phương pháp nghiên cứu
Các phương pháp nghiên cứu được sử dụng trong đề tài bao gồm:
 Nghiên cứu lý thuyết

 Nghiên cứu thực nghiệm
 Phân tích và đánh giá
Nghiên cứu lý thuyết sẽ được sử dụng để nghiên cứu các cơ chế trò chơi, đồ họa trò
chơi, âm thanh trò chơi và AI của trò chơi Snake.
Nghiên cứu thực nghiệm sẽ được sử dụng để thử nghiệm các tính năng cải tiến của trò
chơi Snake.
Phân tích và đánh giá sẽ được sử dụng để đánh giá hiệu quả của các tính năng cải tiến.
Dưới đây là một số ví dụ cụ thể về các tính năng cải tiến có thể được nghiên cứu trong
đề tài này:
 Tăng độ khó của trò chơi: Điều này có thể được thực hiện bằng cách tăng tốc độ di
chuyển của rắn, giảm số lượng ô trống trong bàn chơi hoặc thêm các kẻ thù vào trò
chơi.
 Thêm các yếu tố mới vào trò chơi: Điều này có thể bao gồm việc thêm các vật
phẩm đặc biệt vào bàn chơi, cho phép rắn thay đổi hình dạng hoặc thêm các môi
trường mới.
 Tối ưu hóa hiệu suất của trò chơi: Điều này có thể được thực hiện bằng cách cải
thiện hiệu quả của mã nguồn hoặc sử dụng các kỹ thuật tối ưu hóa.
Việc nghiên cứu và phát triển một trò chơi Snake mới với các tính năng cải tiến có thể
mang lại những lợi ích sau:
 Tạo ra một trò chơi Snake mới lạ và hấp dẫn hơn cho người chơi.
 Thúc đẩy sự phát triển của trò chơi Snake.
 Tăng cường khả năng sáng tạo và kỹ năng lập trình của người nghiên cứu.

PHẦN II: NỘI DUNG ĐỀ TÀI
CHƯƠNG 1: CƠ SỞ LÝ THUYẾT
1. Tổng quan về trí tuệ nhân tạo
1.1. Khái niệm về chương trình và lập trình
Chương trình là một tập hợp các hướng dẫn được viết theo một ngôn ngữ lập trình cụ
thể, được máy tính thực thi để thực hiện một nhiệm vụ nào đó.
Chương trình máy tính có thể được chia thành hai loại chính:
 Chương trình hệ thống: Là các chương trình được sử dụng để quản lý và vận hành
hệ thống máy tính, chẳng hạn như hệ điều hành, trình dịch, và trình biên dịch.
 Chương trình ứng dụng: Là các chương trình được sử dụng để thực hiện các nhiệm
vụ cụ thể của người dùng, chẳng hạn như phần mềm văn phòng, phần mềm đồ họa,
và phần mềm trò chơi.
Lập trình là quá trình tạo ra một chương trình máy tính. Lập trình viên sử dụng các
ngôn ngữ lập trình để viết chương trình.
Lập trình là một kỹ năng quan trọng trong nhiều lĩnh vực, chẳng hạn như:
 Công nghệ thông tin: Lập trình là nền tảng của ngành công nghệ thông tin.
 Khoa học dữ liệu: Lập trình được sử dụng để thu thập, xử lý, và phân tích dữ liệu.
 Kỹ thuật: Lập trình được sử dụng để điều khiển các thiết bị và hệ thống.
1.2 Mã lệnh và dữ liệu
Mã lệnh là một tập hợp các hướng dẫn được viết theo một ngôn ngữ lập trình cụ thể,
được máy tính thực thi để thực hiện một nhiệm vụ nào đó. Mã lệnh có thể được chia
thành hai loại chính:
 Mã lệnh cấp thấp: Mã lệnh cấp thấp là các mã lệnh được viết trực tiếp cho phần
cứng máy tính. Mã lệnh cấp thấp thường được viết bằng ngôn ngữ máy hoặc ngôn
ngữ lắp ráp.

 Mã lệnh cấp cao: Mã lệnh cấp cao là các mã lệnh được viết cho con người dễ hiểu.
Mã lệnh cấp cao thường được viết bằng các ngôn ngữ lập trình bậc cao, chẳng hạn
như Python, Java, và C++.
Dữ liệu là thông tin được lưu trữ trong máy tính. Dữ liệu có thể là số, chữ, biểu thức,
hoặc cấu trúc dữ liệu phức tạp hơn. Dữ liệu được lưu trữ trong máy tính dưới dạng các
bit, là các đơn vị nhỏ nhất của thông tin.
Mối quan hệ giữa mã lệnh và dữ liệu
Mã lệnh và dữ liệu là hai thành phần quan trọng của một chương trình máy tính. Mã
lệnh là các hướng dẫn để máy tính thực hiện, còn dữ liệu là thông tin mà máy tính cần
để thực hiện các hướng dẫn đó.
Mã lệnh và dữ liệu có mối quan hệ chặt chẽ với nhau. Mã lệnh cần dữ liệu để thực
hiện các hướng dẫn của mình. Ví dụ, nếu mã lệnh cần tính tổng của hai số, thì mã lệnh
cần dữ liệu là hai số cần tính tổng.
Ngược lại, dữ liệu cũng cần mã lệnh để được sử dụng. Ví dụ, nếu dữ liệu là một danh
sách các số, thì cần có mã lệnh để truy cập và xử lý các số trong danh sách đó.
Các loại dữ liệu
Dữ liệu có thể được phân loại theo nhiều cách khác nhau, chẳng hạn như theo kiểu dữ
liệu, theo cách lưu trữ, hoặc theo mức độ phức tạp.
 Theo kiểu dữ liệu, dữ liệu có thể được chia thành các loại sau:
Kiểu dữ liệu nguyên thủy: Kiểu dữ liệu nguyên thủy là các kiểu dữ liệu đơn giản,
chẳng hạn như số nguyên, số thực, và ký tự.
Kiểu dữ liệu phức tạp: Kiểu dữ liệu phức tạp là các kiểu dữ liệu chứa nhiều dữ liệu
đơn giản, chẳng hạn như mảng, danh sách, và cấu trúc.
 Theo cách lưu trữ, dữ liệu có thể được chia thành các loại sau:
Dữ liệu tĩnh: Dữ liệu tĩnh là dữ liệu được lưu trữ trong bộ nhớ cố định của máy
tính.

Dữ liệu động: Dữ liệu động là dữ liệu được lưu trữ trong bộ nhớ động của máy
tính.
 Theo mức độ phức tạp, dữ liệu có thể được chia thành các loại sau:
Dữ liệu đơn giản: Dữ liệu đơn giản là dữ liệu không có cấu trúc.
Dữ liệu cấu trúc: Dữ liệu cấu trúc là dữ liệu có cấu trúc, chẳng hạn như mảng,
danh sách, và cấu trúc.
Các cấu trúc dữ liệu
Cấu trúc dữ liệu là một tập hợp các dữ liệu có liên quan với nhau. Cấu trúc dữ liệu
được sử dụng để lưu trữ và quản lý dữ liệu một cách hiệu quả hơn.
Có nhiều loại cấu trúc dữ liệu khác nhau, chẳng hạn như:
 Mảng: Mảng là một cấu trúc dữ liệu có thứ tự, trong đó các phần tử được lưu trữ
theo một thứ tự nhất định.
 Danh sách: Danh sách là một cấu trúc dữ liệu có thứ tự, trong đó các phần tử có
thể được thêm, xóa, hoặc thay đổi một cách dễ dàng.
 Cấu trúc: Cấu trúc là một cấu trúc dữ liệu có thứ tự, trong đó các phần tử có thể có
các kiểu dữ liệu khác nhau.
 Đồ thị: Đồ thị là một cấu trúc dữ liệu không có thứ tự, trong đó các phần tử được
kết nối với nhau bằng các đường.
 Các kỹ thuật xử lý dữ liệu
 Có nhiều kỹ thuật khác nhau để xử lý dữ liệu, chẳng hạn như:
 So sánh: So sánh là kỹ thuật để so sánh hai giá trị dữ liệu và xác định xem chúng
bằng nhau hay không.
 Toán học: Toán học là kỹ thuật để thực hiện các phép toán số học trên dữ liệu.
 Lọc: Lọc là kỹ thuật để loại bỏ các giá trị dữ liệu không mong muốn.
 Phân loại: Phân loại là kỹ thuật để phân loại dữ liệu theo các thuộc tính nhất định
1.3 Ngôn ngữ lập trình

1.3.1. Khái niệm về ngôn ngữ lập trình
Ngôn ngữ lập trình là một hệ thống các ký hiệu và quy tắc được sử dụng để viết
chương trình máy tính. Ngôn ngữ lập trình cho phép lập trình viên giao tiếp với
máy tính và chỉ định cho máy tính thực hiện các nhiệm vụ.
1.3.2. Các loại ngôn ngữ lập trình
Có nhiều loại ngôn ngữ lập trình khác nhau, được phân loại theo nhiều cách khác
nhau, chẳng hạn như:
 Theo chức năng: Ngôn ngữ lập trình có thể được phân loại thành ngôn ngữ lập
trình mệnh lệnh, ngôn ngữ lập trình hướng đối tượng, ngôn ngữ lập trình chức
năng, và ngôn ngữ lập trình quy tắc.
 Theo mức độ trừu tượng: Ngôn ngữ lập trình có thể được phân loại thành ngôn
ngữ lập trình bậc thấp, ngôn ngữ lập trình bậc trung, và ngôn ngữ lập trình bậc
cao.
 Theo mục đích sử dụng: Ngôn ngữ lập trình có thể được phân loại thành ngôn
ngữ lập trình hệ thống, ngôn ngữ lập trình ứng dụng, và ngôn ngữ lập trình
chuyên dụng.
1.3.3. Thành phần của ngôn ngữ lập trình
Ngôn ngữ lập trình có các thành phần chính sau:
 Từ khóa: Từ khóa là các từ được định nghĩa trong ngôn ngữ lập trình và có ý
nghĩa đặc biệt. Ví dụ, từ khóa print trong ngôn ngữ Python được sử dụng để in
ra màn hình.
 Tên: Tên là các ký tự được sử dụng để xác định các biến, hàm, và các đối
tượng khác trong chương trình.
 Câu lệnh: Câu lệnh là các đơn vị cơ bản của chương trình. Câu lệnh chỉ định
cho máy tính thực hiện một nhiệm vụ cụ thể.
 Cấu trúc dữ liệu: Cấu trúc dữ liệu là cách thức tổ chức dữ liệu trong máy tính.
Cấu trúc dữ liệu giúp lưu trữ và truy cập dữ liệu một cách hiệu quả.

 Hàm: Hàm là một khối mã có thể được sử dụng lại trong chương trình. Hàm
giúp tổ chức chương trình một cách hợp lý và hiệu quả.
1.3.4. Cú pháp của ngôn ngữ lập trình
Cú pháp của ngôn ngữ lập trình là quy tắc xác định cách thức sắp xếp các từ, ký
tự, và câu lệnh trong chương trình. Cú pháp của ngôn ngữ lập trình phải được
tuân theo để chương trình có thể được biên dịch và thực thi chính xác.
1.3.5. Semantik của ngôn ngữ lập trình
Semantik của ngôn ngữ lập trình là ý nghĩa của các từ, ký tự, và câu lệnh trong
chương trình. Semantik của ngôn ngữ lập trình giúp xác định cách thức máy tính
hiểu và thực thi chương trình.
1.3.6. Các bước học ngôn ngữ lập trình
Để học ngôn ngữ lập trình, cần thực hiện các bước sau:
Học lý thuyết: Học các kiến thức cơ bản về ngôn ngữ lập trình, chẳng hạn như
các thành phần của ngôn ngữ lập trình, cú pháp và semantik của ngôn ngữ lập
trình.
Luyện tập: Luyện tập viết mã để thực hành các kiến thức đã học.
Làm dự án: Làm dự án là cách tốt nhất để áp dụng các kiến thức đã học vào thực
tế.
1.3.7. Một số ngôn ngữ lập trình phổ biến
Một số ngôn ngữ lập trình phổ biến hiện nay bao gồm:
Python: Python là một ngôn ngữ lập trình bậc cao, dễ học và dễ sử dụng. Python
được sử dụng trong nhiều lĩnh vực, chẳng hạn như học máy, trí tuệ nhân tạo, khoa
học dữ liệu, và phát triển web.
Java: Java là một ngôn ngữ lập trình hướng đối tượng, mạnh mẽ và linh hoạt.
Java được sử dụng trong nhiều lĩnh vực, chẳng hạn như phát triển ứng dụng di
động, phát triển ứng dụng web, và phát triển phần mềm hệ thống.
C++: C++ là một ngôn ngữ lập trình hướng đối tượng, mạnh mẽ và hiệu quả. C++

được sử dụng trong nhiều lĩnh vực, chẳng hạn như phát triển phần mềm hệ thống,
phát triển trò chơi, và phát triển ứng dụng di động.
1.4 Quá trình phát triển phần mềm
Quá trình phát triển phần mềm (Software Development Process - SDLC) là một tập
hợp các bước được thực hiện để phát triển phần mềm. SDLC giúp đảm bảo rằng phần
mềm được phát triển một cách hiệu quả và đáp ứng các yêu cầu của người dùng.
Có nhiều mô hình SDLC khác nhau, mỗi mô hình có những ưu điểm và nhược điểm
riêng. Một số mô hình SDLC phổ biến bao gồm:
 Mô hình thác nước: Mô hình thác nước là mô hình SDLC truyền thống. Mô hình
này được thực hiện theo một trình tự tuần tự, từ phân tích đến thiết kế, lập trình,
kiểm thử, và triển khai.
 Mô hình vòng lặp: Mô hình vòng lặp là mô hình SDLC linh hoạt hơn mô hình thác
nước. Mô hình này cho phép các giai đoạn của SDLC được lặp lại nhiều lần để
đảm bảo rằng phần mềm đáp ứng các yêu cầu của người dùng.
 Mô hình tăng trưởng theo từng bước: Mô hình tăng trưởng theo từng bước là mô
hình SDLC cho phép phần mềm được phát triển theo từng bước nhỏ. Mô hình này
giúp giảm thiểu rủi ro và đảm bảo rằng phần mềm đáp ứng các yêu cầu của người
dùng.
Các bước của SDLC
Các bước của SDLC thường bao gồm:
 Phân tích: Bước phân tích là bước xác định các yêu cầu của người dùng và các
chức năng của phần mềm.
 Thiết kế: Bước thiết kế là bước xác định cấu trúc và chức năng của phần mềm.
 Lập trình: Bước lập trình là bước viết mã nguồn của phần mềm.
 Kiểm thử: Bước kiểm thử là bước kiểm tra phần mềm để đảm bảo phần mềm hoạt
động chính xác.
 Triển khai: Bước triển khai là bước đưa phần mềm vào sử dụng.

 Bảo trì: Bước bảo trì là bước sửa lỗi và nâng cao hiệu suất của phần mềm.
Các kỹ thuật phát triển phần mềm
Ngoài các bước của SDLC, có một số kỹ thuật phát triển phần mềm khác có thể được
sử dụng để nâng cao hiệu quả của quá trình phát triển phần mềm. Một số kỹ thuật phát
triển phần mềm phổ biến bao gồm:
 Kiểm soát phiên bản: Kiểm soát phiên bản là kỹ thuật giúp quản lý các phiên bản
khác nhau của mã nguồn.
 Thống nhất phát triển: Thống nhất phát triển là kỹ thuật giúp các lập trình viên làm
việc cùng nhau trên cùng một dự án.
 Mô hình hóa dữ liệu: Mô hình hóa dữ liệu là kỹ thuật giúp tổ chức dữ liệu trong
phần mềm một cách hiệu quả.
 Thiết kế hướng đối tượng: Thiết kế hướng đối tượng là kỹ thuật giúp tổ chức phần
mềm theo các đối tượng.
 Phát triển dựa trên thử nghiệm: Phát triển dựa trên thử nghiệm là kỹ thuật giúp
đảm bảo rằng phần mềm được kiểm thử kỹ lưỡng trước khi triển khai.
1.5 Lỗi chương trình
Lỗi chương trình là những lỗi xảy ra trong chương trình máy tính. Lỗi chương trình có
thể gây ra các vấn đề như chương trình không hoạt động, chương trình hoạt động
không chính xác, hoặc chương trình hoạt động chậm.
Lỗi chương trình có thể được phân loại theo nhiều cách khác nhau, chẳng hạn như:
 Theo nguyên nhân: Lỗi chương trình có thể được phân loại thành lỗi logic, lỗi cú
pháp, và lỗi do phần cứng.
 Theo mức độ nghiêm trọng: Lỗi chương trình có thể được phân loại thành lỗi
nghiêm trọng, lỗi không nghiêm trọng, và lỗi thông báo.
Lỗi logic là lỗi xảy ra do logic của chương trình không chính xác. Lỗi logic có thể gây
ra các vấn đề như chương trình hoạt động không chính xác, hoặc chương trình không
hoạt động.

Lỗi cú pháp là lỗi xảy ra do chương trình không tuân theo quy tắc cú pháp của ngôn
ngữ lập trình. Lỗi cú pháp có thể khiến chương trình không thể biên dịch hoặc thực
thi.
Lỗi do phần cứng là lỗi xảy ra do phần cứng của máy tính gặp sự cố. Lỗi do phần
cứng có thể khiến chương trình hoạt động không ổn định hoặc không hoạt động.
Cách tìm lỗi chương trình
Có nhiều cách khác nhau để tìm lỗi chương trình. Một số cách phổ biến bao gồm:
 Kiểm tra cú pháp: Kiểm tra cú pháp là bước đầu tiên trong quá trình tìm lỗi
chương trình. Kiểm tra cú pháp giúp xác định xem chương trình có tuân theo quy
tắc cú pháp của ngôn ngữ lập trình hay không.
 Kiểm tra logic: Kiểm tra logic là bước tiếp theo trong quá trình tìm lỗi chương
trình. Kiểm tra logic giúp xác định xem logic của chương trình có chính xác hay
không.
 Kiểm thử: Kiểm thử là bước cuối cùng trong quá trình tìm lỗi chương trình. Kiểm
thử giúp xác định xem chương trình hoạt động chính xác hay không.
Cách sửa lỗi chương trình
Khi tìm thấy lỗi chương trình, cần sửa lỗi để chương trình hoạt động chính xác. Cách
sửa lỗi chương trình phụ thuộc vào loại lỗi.
Đối với lỗi cú pháp, cần sửa lại mã nguồn để tuân theo quy tắc cú pháp của ngôn ngữ
lập trình.
Đối với lỗi logic, cần sửa lại logic của chương trình để chương trình hoạt động chính
xác.
Đối với lỗi do phần cứng, cần thay thế hoặc sửa chữa phần cứng của máy tính.
2. Tổng quan về đề tài
2.1. Mô tả trò chơi
Snake game, một tựa game kinh điển đã quá phổ biến với nhiều thế hệ. Snake
game hay còn được gọi là trò chơi rắn săn mồi là một trò chơi mà chúng ta cần

khiến con rắn di chuyển đến chỗ thức ăn. Trong bài bài chúng ta sẽ áp dụng thuật
toán BFS để tạo ra một AI cho trò chơi. Con rắn có thể di chuyển qua trái, phải,
lên, xuống. Trong quá trình di chuyển Thuật toán có thể giúp con rắn tự tìm ra
đường đi tốt nhất đến mồi. Tránh cắn trúng thân mình và đâm vào tường biên rồi
đạt số điểm lớn nhất cóthể.
Con rắn sẽ ngày một dài ra đòi hỏi nó phải có khả năng điều khiển để có thể né
tránh các chướng ngại vật kể cả cơ thể của nó. Với thuật toán BFS, ta có thể dễ
dàng tìm đường đi ngắn nhất giữa đầu rắn và thức ăn. Ta có thể trang bị cho con
rắn năng lực điểu khiển cơ thể để tránh vật cản thông qua một nhận xét quan
trọng: “ Miễn là tồn tại đường đi từ đầu rắn đến đuôi rắn, về cơ bản con rắn có thể
đi tiếp”.
2.2 Lịch sử hình thành và phát triển của trò chơi
Trò chơi Snake (hay còn gọi là rắn săn mồi) là một trong những trò chơi điện
tử đầu tiên và đã trở thành một biểu tượng của ngành công nghiệp game
Trò chơi Snake xuất hiện đầu tiên vào những năm 1970 trên các máy tính đơn
giản như DEC PDP-1. Trò chơi này không được phát triển để công bố mà chỉ là
một ví dụ minh họa cho các hệ thống máy tính thời kỳ đó. Đến thập kỷ 1980 game
Snake trở nên phổ biến khi xuất hiện trên các máy chơi game điện tử như Nokia
6110 vào những năm 1997. Điều này làm cho trò chơi trở nên nổi tiếng trên toàn
cầu và trở thành một trong những trò chơi đầu tiên trên điện thoại di động. Trong
thập kỷ 1990, Snake đã xuất hiện trên nhiều hệ thống máy tính và thiết bị di động
khác nhau, và phiên bản của trò chơi này đã được phát triển và cải thiện liên tục.
Nokia Snake (1997): Snake trở nên phổ biến trên điện thoại di động khi Nokia
giới thiệu trò chơi này trên điện thoại di động Nokia 6110. Snake II (2000): Phiên
bản Snake II có thêm tính năng gấp đôi, khiến con rắn tăng gấp đôi mỗi khi ăn
mồi. Nhiều phiên bản và biến thể: Kể từ đó, có hàng loạt phiên bản và biến thể của
trò chơi Snake đã được phát triển trên nhiều nền tảng và thiết bị khác nhau, từ điện
thoại di động đến máy tính cá nhân và các trang web chơi game trực tuyến. Ngày
nay, Snake vẫn còn tồn tại dưới nhiều hình thức khác nhau. Ngoài các phiên bản
trên điện thoại di động, có các phiên bản trò chơi trực tuyến miễn phí hoặc được

tích hợp vào các trình duyệt web.
Snake đã trở thành một phần của ký ức game của nhiều người chơi và vẫn
được kính trọng như một biểu tượng của lịch sử game điện tử.
2.3 Ứng dụng và đề xuất cải tiến trò chơi
Trò chơi rắn săn mồi (Snake) không chỉ là một trò giải trí đơn thuần, mà còn có
nhiều ứng dụng và lợi ích khác ngoài việc giúp người chơi giải trí. Trò chơi Snake
là một cách tuyệt vời để giải trí và giảm căng thẳng. Người chơi có thể chơi trong
thời gian ngắn để giải toả căng thẳng hoặc giải trí trong những khoảnh khắc trống
rảnh. Chơi Snake yêu cầu sự tập trung và kỹ năng phản xạ, giúp cải thiện khả năng
tập trung và nhanh nhẹn của người chơi. Trong một số trường hợp, các phiên bản
của trò chơi Snake đã được sử dụng để giảng dạy lập trình hoặc làm ví dụ minh
họa cho các khái niệm trong khoa học máy tính. Việc phát triển phiên bản riêng
của trò chơi Snake có thể giúp người học lập trình phát triển kỹ năng lập trình và
hiểu rõ về các nguyên tắc của trò chơi điện tử. Người thiết kế giao diện có thể sử
dụng các yếu tố của trò chơi Snake để thiết kế các yếu tố tương tác trong ứng dụng
hoặc trang web, đặc biệt là với việc sử dụng hình ảnh của con rắn và các mô hình
chuyển động. Trò chơi Snake cũng đã được sử dụng trong lĩnh vực trí tuệ nhân tạo
để phát triển các thuật toán về máy học và học sâu, đặc biệt trong ngữ cảnh của
việc học máy tự học (reinforcement learning).
Cải tiến trò chơi rắn săn mồi có thể tạo ra trải nghiệm mới và thú vị cho người
chơi. Chúng ta cải thiện đồ họa và hiệu ứng để tạo ra trải nghiệm hấp dẫn hơn. Sử
dụng đồ họa 3D hoặc các hiệu ứng đặc biệt để làm cho trò chơi trở nên sống động
hơn. Thêm chế độ chơi đa người để người chơi có thể thi đấu với bạn bè hoặc
người chơi trực tuyến khác. Phát triển chế độ chơi đối kháng trực tuyến, trong đó
người chơi có thể thi đấu trực tuyến với người chơi khác từ khắp nơi trên thế giới.
Tạo ra nhiều cấp độ khó khăn và thách thức khác nhau để người chơi không bao
giờ cảm thấy chán chường. Cho phép người chơi chọn các kỹ năng hoặc đặc điểm
đặc biệt cho con rắn của họ, giúp họ tạo ra chiến lược chơi riêng và trải nghiệm cá
nhân hóa. Thêm chế độ chơi theo cấp độ, trong đó người chơi phải hoàn thành các
màn chơi với các điều kiện và thách thức đặc biệt để tiến xa hơn trong trò chơi. Sử

dụng trí tuệ nhân tạo để tạo ra một hệ thống điều khiển cho con rắn không người
chơi, giúp tạo ra một trải nghiệm chơi đầy thách thức. Xây dựng hệ thống điểm số
và xếp hạng trực tuyến để khuyến khích cạnh tranh và sự tham gia của người chơi.
Cho phép con rắn tương tác với môi trường xung quanh, như tránh các chướng
ngại vật hoặc tận dụng chúng để đạt được mục tiêu. Tạo ra nhiều màn chơi và bản
đồ đa dạng, mỗi bản đồ có các tính chất và điểm đặc biệt, giúp người chơi không
bao giờ cảm thấy nhàm chán. Tích hợp tính năng tương tác với cộng đồng, cho
phép người chơi chia sẻ thành tích, gợi ý và thậm chí thiết kế các màn chơi và bản
đồ mới.
2.4 Các công nghệ áp dụng trong đề tài
2.4.1. Tổng quan về ngôn ngữ lập trình Python
Python là ngôn ngữ lập trình hướng đối tượng bậc cao. Điều đặc biệt ở ngôn
ngữ này là sự đa năng, đa công dụng. Mang các tính năng ưu việt như tạo kiểu
dữ liệu tự động và cơ chế cung cấp bộ nhớ tự động. Python là ngôn ngữ có
mục đích chung, nghĩa là nó có thể được sử dụng để tạo nhiều chương trình
khác nhau và không chuyên biệt cho bất kỳ vấn đề cụ thể nào. Tính linh hoạt
này, cùng với sự thân thiện thì Python cực kỳ phù hợp cho người mới bắt đầu.
Hình 1.1.1: Tổng quan về ngôn ngữ lập trình Python
Những tính năng chính của Python
Cực kỳ đơn giản và dễ tiếp thu cũng như thực hành: sự đơn giản của ngôn
ngữ này thể hiện ở các câu lệnh dễ học, dễ hiểu. Python biến những “cú pháp
code khó nhằn” trở nên dễ dàng hơn bằng những giải pháp.

Hoàn toàn miễn phí và là mã nguồn mở: nhà lập trình có thể thoải mái di
chuyển Python thậm chí sử dụng nó với mục đích thương mại hóa. Với đặc
trưng là một ngôn ngữ lập trình mã nguồn mở. Bạn hoàn toàn có thể thay đổi
các mã nguồn mở của Python ở bất cứ các ứng dụng phần mềm nào.
Là một ngôn ngữ di động: di động có nghĩa là nó rất dễ di chuyển từ nền
tảng này sang các nền tảng khác. Đồng thời, bạn có thể chạy chương trình của
Python ở mọi nền tảng mà không sợ có bất kỳ những thay đổi nào ảnh hưởng.
Python là ngôn ngữ phiên dịch cao cấp: khi chạy chương trình Python trên
bất cứ hệ điều hành hay mạng Internet nào. Python có thể hoàn toàn tự động
dịch và chạy theo đúng chương trình dữ liệu của máy tính đó.
Ưu điểm của Python
Python có cấu trúc đơn giản, rõ ràng và rất dễ học. Đây được coi là một trong
những ngôn ngữ nên học cho những người mới bắt đầu tiếp cận đến lập trình.
Python có mặt trên tất cả các hệ điều hành phổ biến như: Windows, MacOS,
MS- DOS, Unix,… đây cũng thể hiện được sự đa năng của ngôn ngữ này.
Tương thích với thư viện lớn nhất hiện nay với 400 triệu người sử dụng như
data mining Scikit-learn, Pandas…
Tốc độ xử lý cũng là một trong những lí do tạo nên ưu điểm của Python.
Ngôn ngữ này có thể tạo ra những script siêu nhỏ tới những phần mềm cực lớn
như Blender 3D. Nhược điểm của Python
Các cấu trúc của Python đòi hỏi nhiều không gian bộ nhớ hơn, ngôn ngữ
này không thể phát huy hết tác dụng trong điều kiện bộ nhớ hạn chế.
Python không phải là ngôn ngữ được ưu tiên để phát triển ứng dụng di động
hay trò chơi do tiêu tốn nhiều bộ nhớ hơn và tốc độ xử lý chậm so với ngôn
ngữ khác.
Rất khó để chạy các bài kiểm tra trên mã được viết bằng Python, các lỗi trên
này thường xuất hiện trong thời gian chạy, điều này khiến việc kiểm tra trở
nên khó khăn hơn.

Ứng dụng của Python
Phân tích dữ liệu và học máy: Trong khoa học dữ liệu, cho phép các nhà
phân tích dữ liệu và các chuyên gia khác sử dụng ngôn ngữ này để thực hiện
các phép tính thống kê phức tạp, tạo trực quan hóa dữ liệu, xây dựng thuật
toán học máy, thao tác và phân tích dữ liệu cũng như hoàn thành các nhiệm vụ
khác liên quan đến dữ liệu.
Python có thể xây dựng nhiều dạng trực quan hóa dữ liệu khác nhau, chẳng
hạn như biểu đồ đường và thanh, biểu đồ hình tròn, biểu đồ 3D.
Python cũng có một số thư viện cho phép các lập trình viên viết chương
trình để phân tích dữ liệu và học máy nhanh hơn và hiệu quả hơn, như
TensorFlow và Keras.
Phát triển web: Python thường được sử dụng để phát triển back-end của
trang web hoặc ứng dụng những phần mà người dùng không nhìn thấy. Vai trò
của Python trong phát triển web có thể bao gồm gửi dữ liệu đến và đi từ máy
chủ, xử lý dữ liệu và giao tiếp với cơ sở dữ liệu, định tuyến URL và đảm bảo
tính bảo mật. Python cung cấp một số khuôn khổ để phát triển web. Những cái
thường được sử dụng bao gồm Django và Flask.
Tự động hoá và phát triển phần mềm: Python có thể tư động hóa một nhiệm
vụ lặp đi lặp lại. Quá trình viết code được sử dụng để xây dựng các quy trình
tự động này được gọi là viết script. Trong thế giới mã hóa, tự động hóa có thể
được sử dụng để kiểm tra lỗi trên nhiều tệp, chuyển đổi tệp, thực hiện phép
toán đơn giản và loại bỏ các bản sao trong dữ liệu.
Python thậm chí có thể được sử dụng bởi những người mới bắt đầu để tự
động hóa các tác vụ đơn giản trên máy tính—chẳng hạn như đổi tên tệp, tìm và
tải xuống nội dung trực tuyến hoặc gửi email hoặc văn bản theo khoảng thời
gian mong muốn.
Trong phát triển phần mềm, Python có thể hỗ trợ các tác vụ như kiểm soát
bản dựng, theo dõi lỗi và thử nghiệm. Với Python, các nhà phát triển phần
mềm có thể tự động kiểm tra các sản phẩm hoặc tính năng mới. Một số công

cụ Python được sử dụng để kiểm thử phần mềm bao gồm Green và
Requestium.
2.4.2. Thư viện Pygame
Pygame là một mô-đun Python đa nền tảng được thiết kế để viết trò chơi
điện tử. Nó bao gồm đồ hoạ máy tính và thư viện âm thanh được thiết kế để sử
dụng với ngôn ngữ lập trình Python.
Hình 1.1.2: Thư viện Pygame
Pygame ban đầu được viết bởi Pete Shinners để thay thế PySDL sau khi quá
trình phát triển của nó bị đình trệ. Đây là một dự án cộng đồng từ năm 2000 và
được phát hành theo phần mềm miễn phí mã nguồn mở GNU Lesser General
Public License.
Pygame sử dụng thư viện Simple DirectMedia Layer (SDL), với mục đích
cho phép phát triển trò chơi máy tính trong thời gian thực mà không cần cơ
chế bậc thấp của ngôn ngữ lập trình C và các dẫn xuất của nó. Điều này dựa
trên giả định rằng các chức năng đắt tiền nhất bên trong trò chơi có thể được
trừu tượng hóa khỏi logic trò chơi, do đó có thể sử dụng ngôn ngữ lập trình bậc
cao, chẳng hạn như Python, để cấu trúc trò chơi.
Các tính năng khác mà SDL không có bao gồm toán học vectơ, phát hiện va
chạm, quản lý độ họa 2d, hỗ trợ MIDI, camera, thao tác mảng pixel, chuyển
đổi, lọc, hỗ trợ phông chữ freetype nâng cao và vẽ.
Các ứng dụng sử dụng pygame có thể chạy trên điện thoại và máy
tính bảng Android với việc sử dụng Bộ phụ pygame cho Android (pgs4a). Âm
thanh, rung, bàn phím và gia tốc kế được hỗ trợ trên Android.

CHƯƠNG 2: XÂY DỰNG VÀ TRIỂN KHAI ỨNG DỤNG
1. Xây dựng trò chơi
1.1. Xây dựng khung nhìn
Đầu tiên để sử dụng trò chơi ta cần khai báo ba thư viện: pygame, random, os.
1. import pygame
2. import random
3. import os
Hình 2.1: Khai báo thư viện
 pygame: Thư viện đồ họa và âm thanh cho Python
 random: Thư viện để tạo số ngẫu nhiên
 os: Thư viện để truy cập các tập tin và thư mục trên hệ thống
1. WIDTH = 512
2. HEIGHT = 256
3. FPS = 15
4. CELL_WIDTH = 16
5. ROWS = HEIGHT//CELL_WIDTH
6. COLS = WIDTH//CELL_WIDTH
7. LEVELS = 4
8. MAX_SCORE_PER_LVL = [90, 150, 210, 1000000]
9. DOUBLE_SPEED_TIME = 80
Hình 2.2: Xây dựng khung nhìn
 WIDTH và HEIGHT là các thông số xác định kích thước của cửa sổ trò chơi.
Trong ví dụ này, chiều rộng của cửa sổ là 512 pixel và chiều cao là 256 pixel.
 FPS là thông số xác định tốc độ trò chơi. Trong ví dụ này, trò chơi sẽ được vẽ lại
15 lần mỗi giây.
 CELL_WIDTH là thông số xác định kích thước của mỗi ô trong lưới trò chơi.
Trong ví dụ này, mỗi ô có kích thước 16 pixel.
 ROWS và COLS là các thông số tính toán số hàng và cột trong lưới trò chơi.
Trong ví dụ này, lưới trò chơi có 16 hàng và 32 cột.
 LEVELS là thông số xác định số lượng cấp độ khác nhau trong trò chơi. Trong
ví dụ này, trò chơi có 4 cấp độ.
 MAX_SCORE_PER_LVL là một mảng chứa số điểm tối đa cần đạt được để

vượt qua mỗi cấp độ. Trong ví dụ này, số điểm tối đa cần đạt được để vượt qua
cấp độ 1 là 90, cấp độ 2 là 150, cấp độ 3 là 210 và cấp độ 4 là 1000000.
 DOUBLE_SPEED_TIME là thông số xác định thời gian hiệu lực của item tăng
tốc. Trong ví dụ này, item tăng tốc sẽ có hiệu lực trong 80 khung hình.
1.2. Thiết lập môi trường:
1. pygame.init()
2. pygame.mixer.quit()
3. pygame.mixer.init()
4. screen = pygame.display.set_mode((WIDTH, HEIGHT))
5. pygame.display.set_caption("Snake")
Hình 2.3: Thiết lập môi trường cho trò chơi
Đoạn code này thực hiện các bước khởi tạo ban đầu cho trò chơi Snake:
1. Khởi tạo Pygame:
pygame.init() khởi động thư viện Pygame, cần thiết để sử dụng các chức năng của
Pygame trong trò chơi.
2. Tắt và khởi tạo lại bộ trộn âm thanh:
pygame.mixer.quit() tắt bộ trộn âm thanh cũ, nếu có.
pygame.mixer.init() khởi tạo lại bộ trộn âm thanh, cho phép trò chơi phát âm thanh và
nhạc nền.
3. Tạo cửa sổ trò chơi:
pygame.display.set_mode((WIDTH, HEIGHT)) tạo một cửa sổ trò chơi với kích
thước được xác định bởi WIDTH và HEIGHT (512 pixel x 256 pixel).
4. Đặt tiêu đề cho cửa sổ:
pygame.display.set_caption("Snake") đặt tiêu đề cho cửa sổ trò chơi là "Snake".
1.3. Thiết lập font chữ cho trò chơi:
1. FONT_LARGE = pygame.font.SysFont('comic-sans', 50)
2. FONT_MEDIUM = pygame.font.SysFont('comic-sans', 30)
3. FONT_SMALL = pygame.font.SysFont('comic-sans', 25)
Hình 2.4: Thiết lập font chữ
Đoạn code này thiết lập các font chữ khác nhau sẽ được sử dụng trong trò chơi Snake:
 FONT_LARGE: Font chữ lớn với kích thước 50, dùng để hiển thị các thông tin
quan trọng như điểm số, thời gian và cấp độ.
 FONT_MEDIUM: Font chữ trung bình với kích thước 30, dùng để hiển thị các

thông tin bổ sung như hướng dẫn, menu và thông báo.
 FONT_SMALL: Font chữ nhỏ với kích thước 25, dùng để hiển thị các thông tin
chi tiết như số mạng còn lại và thời gian hiệu lực của bonus item.
Việc sử dụng các font chữ khác nhau giúp hiển thị thông tin trong game một cách rõ
ràng và dễ đọc, đồng thời tạo ra sự phân cấp giữa các thông tin quan trọng và thông
tin phụ.
1.4. Định nghĩa các giá trị và màu sắc sử dụng trong lưới trò chơi:
1. EMPTY = 0
2. SNAKE = 1
3. WALL = 2
4. RABBIT = 3
5. BONUS_INFINITE_RABBITS = 4
6. BONUS_DOUBLE_SPEED = 5
Hình 2.5: Các giá trị trong lưới
 EMPTY: Biểu thị các ô trống trên màn hình.
 SNAKE: Biểu thị các ô có rắn đang chiếm vị trí.
 WALL: Biểu thị các ô tường mà rắn không thể đi qua.
 RABBIT: Biểu thị các ô có thỏ mà rắn có thể ăn để tăng điểm.
 BONUS_INFINITE_RABBITS: Biểu thị các ô có thưởng "thỏ vô hạn", cho phép
rắn ăn thỏ liên tục trong một khoảng thời gian.
 BONUS_DOUBLE_SPEED: Biểu thị các ô có thưởng "tốc độ gấp đôi", cho
phép rắn di chuyển nhanh hơn trong một khoảng thời gian.
1. WHITE = (255, 255, 255)
2. BLACK = (0, 0, 0)
3. RED = (255, 0, 0)
4. GREEN = (0, 255, 0)
5. BLUE = (0, 0, 255)
6. YELLOW = (255, 255, 0)
Hình 2.6: Màu sắc hiển thị trong lưới
 WHITE: Màu trắng thường được sử dụng làm nền màn hình.
 BLACK: Màu đen thường được sử dụng cho các yếu tố như văn bản, tường, v.v.
 RED: Màu đỏ thường được sử dụng cho các yếu tố liên quan đến game over,
chẳng hạn như hiển thị khi rắn chết.
 GREEN: Màu xanh lá cây thường được sử dụng cho các yếu tố liên quan đến

điểm số và thỏ.
 BLUE: Màu xanh dương thường được sử dụng cho các yếu tố liên quan đến
thưởng tốc độ gấp đôi.
 YELLOW: Màu vàng thường được sử dụng cho các yếu tố liên quan đến thưởng
thỏ vô hạn.
1.5. Tải ảnh và các âm thanh cần thiết cho trò chơi:
1. snake_body_horiz = pygame.image.load(os.path.join('images', 'HORIZ.png'))
2. snake_body_vert = pygame.image.load(os.path.join('images', 'VERT.png'))
3. rabbit = pygame.image.load(os.path.join('images', 'rabbit.png'))
4. grass = pygame.image.load(os.path.join('images', 'grass.png'))
5. border = pygame.image.load(os.path.join('images', 'border-grey.png'))
6. star = pygame.image.load(os.path.join('images', 'star.png'))
7. snake_head = []
8. snake_tail = []
9. snake_corners = []
10.for i in range(1, 5):
11. snake_head.append(pygame.image.load(os.path.join('images', f'H{i}.png')))
12. snake_tail.append(pygame.image.load(os.path.join('images', f'T{i}.png')))
13. snake_corners.append(pygame.image.load(os.path.join('images', f'C{i}.png')))
Hình 2.7: Tải ảnh lên trò chơi
 snake_body_horiz: Ảnh phần thân rắn theo chiều ngang.
 snake_body_vert: Ảnh phần thân rắn theo chiều dọc.
 rabbit: Ảnh thỏ.
 grass: Ảnh nền cỏ.
 border: Ảnh viền màn hình.
 star: Ảnh biểu tượng thưởng.
 snake_head: List ảnh đầu rắn với các góc nhìn khác nhau.
 snake_tail: List ảnh đuôi rắn với các góc nhìn khác nhau.
 snake_corners: List ảnh khúc cua rắn với các góc nhìn khác nhau.
Vòng lặp for tải các ảnh đầu, đuôi và khúc cua rắn với các góc nhìn khác nhau (từ 1
đến 4).
1. eat_sound = pygame.mixer.Sound(os.path.join('sound', 'eat_sound.ogg'))
2. die_sound = pygame.mixer.Sound(os.path.join('sound', 'die_sound.ogg'))
Hình 2.8: Tải âm thanh lên trò chơi

 eat_sound: Âm thanh phát ra khi rắn ăn thỏ.
 die_sound: Âm thanh phát ra khi rắn chết.
1.6. Xây dựng con rắn
1.6.1. Khởi tạo con rắn:
1. class Snake:
2. def __init__(self):
3. self.head = [ROWS//2, COLS//2]
4. self.body = []
5. self.body.append([self.head[0], self.head[1] - 1])
6. self.dir = 1
7. self.body_dir = [1]
8.
9. def dir_up(self):
10. if self.dir != 2:
11. self.dir = 0
12.
13. def dir_down(self):
15. self.dir = 2
16.
17. def dir_left(self):
19. self.dir = 3
20.
21. def dir_right(self):
23. self.dir = 1
Hình 2.9: Khởi tạo các thuộc tính con rắn
Phần code này khởi tạo các thuộc tính của con rắn như sau:
 head: Vị trí đầu rắn được đặt ở giữa màn hình.
 body: List body ban đầu chỉ có một phần tử, là vị trí đầu rắn.
 dir: Hướng di chuyển của rắn được đặt là 1, tức là hướng phải.
 body_dir: List body_dir ban đầu cũng chỉ có một phần tử, là hướng 1.
1.6.2. Di chuyển và cập nhật vị trí của rắn:
1. def update(self):
2. # update head position
3. self.body.append(self.head)
4. self.body_dir.append(self.dir)
5. self.head = self.head.copy()
6.
7. # move head accorning to direction
8. if self.dir == 0:
9. self.head[0] -= 1
10. elif self.dir == 1:

11. self.head[1] += 1
12. elif self.dir == 2:
13. self.head[0] += 1
14. else:
15. self.head[1] -= 1
16.
17. # handle head position out of bounds
18. if self.head[0] < 0:
19. self.head[0] = ROWS - 1
20. if self.head[0] >= ROWS:
21. self.head[0] = 0
22. if self.head[1] < 0:
23. self.head[1] = COLS - 1
24. if self.head[1] >= COLS:
25. self.head[1] =0
26.
27.def reset(self):
28. self.head = [ROWS//2, COLS//2]
29. self.body = []
30. self.body.append([self.head[0], self.head[1] - 1])
31. self.body_dir = [1]
32. self.dir = 1
33. self.speed_col = 1
34. self.speed_row = 0
Hình 2.10: Cập nhật vị trí của con rắn
Phần code này cập nhật vị trí của con rắn như sau:
 Cách di chuyển của rắn trong game Snake được thực hiện thông qua hàm
update() của class Snake. Hàm này sẽ cập nhật vị trí của con rắn dựa trên
hướng di chuyển hiện tại.
Để xác định hướng di chuyển, hàm update() sẽ kiểm tra biến direction của
con rắn. Biến này sẽ lưu trữ hướng di chuyển hiện tại của con rắn, có thể là
UP, DOWN, LEFT, hoặc RIGHT.
Sau khi xác định được hướng di chuyển, hàm update() sẽ cập nhật vị trí của
phần đầu con rắn. Vị trí mới của phần đầu sẽ được tính bằng cách cộng thêm
vector hướng di chuyển vào vị trí hiện tại của phần đầu.
Để cập nhật vị trí của các phần còn lại của con rắn, hàm update() sẽ sử dụng
vòng lặp. Trong vòng lặp, hàm sẽ cập nhật vị trí của mỗi phần bằng cách lấy
vị trí của phần liền trước nó.
Ví dụ, nếu con rắn có 5 phần, thì vòng lặp sẽ cập nhật vị trí của phần 2 bằng
cách lấy vị trí của phần 1, vị trí của phần 3 bằng cách lấy vị trí của phần 2,
và cứ tiếp tục như vậy.
 Hàm reset(self) có nhiệm vụ reset lại vị trí và hướng di chuyển của con rắn

trong game Snake. Hàm được sử dụng khi:
1. Game over: Khi con rắn va chạm với chính nó, tường hoặc đạt đến
điểm giới hạn, game sẽ kết thúc và hàm reset được gọi để đưa con rắn
về vị trí ban đầu.
2. Nâng cấp cấp độ: Khi con rắn đạt đủ điểm để nâng cấp lên cấp độ
mới, hàm reset được gọi để đặt con rắn về vị trí ban đầu với hướng di
chuyển mới.
1.6.3. Vẽ rắn lên màn hình:
1. def draw(self, win):
2. # draw head and tail
3. head_x = self.head[1] * CELL_WIDTH
4. head_y = self.head[0] * CELL_WIDTH
5.
6. tail_x = snake.body[0][1] * CELL_WIDTH
7. tail_y = snake.body[0][0] * CELL_WIDTH
8. tail_dir = snake.body_dir[0]
9.
10. win.blit(snake_head[self.dir], (head_x, head_y))
11. win.blit(snake_tail[tail_dir], (tail_x, tail_y))
12.
13. # draw body
14. for i, (row, col) in enumerate(self.body[1:]):
15. x = col * CELL_WIDTH
16. y = row * CELL_WIDTH
17.
18. dir = self.body_dir[i]
19. next_dir = self.dir if (i + 1 >= len(self.body)) else self.body_d
ir[i+1]
20.
21. # select appropriate sprite for current body part
22. if dir == next_dir:
23. if dir == 0 or dir == 2:
24. sprite = snake_body_vert
25. else:
26. sprite = snake_body_horiz
27. elif dir == 0 and next_dir == 1 or dir == 3 and next_dir == 2:
28. sprite = snake_corners[3]
33. else:
35.
36. # draw body part
37. win.blit(sprite, (x, y))
Hình 2.11: Vẽ rắn lên màn hình
Phần code này vẽ con rắn lên màn hình như sau:
 Vẽ đầu và đuôi rắn bằng các ảnh sprite tương ứng.

 Vẽ các đoạn thân rắn bằng cách lặp qua list body.
 Chọn ảnh sprite phù hợp cho từng đoạn thân rắn dựa vào hướng di chuyển
của đoạn thân đó và hướng di chuyển của đoạn kế tiếp.
1.6.4. Xây dựng ma trận:
1. Khởi tạo:
1. def __init__(self, lvl=0):
2. self.grid = [[EMPTY for j in range(COLS)] for i in range(ROWS)]
3. self.lvl = lvl
4. self.set_random_rabbit()
Hình 2.12: Khởi tạo ma trận
Phần code này khởi tạo các thuộc tính của Grid như sau:
 grid: Ma trận chứa các giá trị EMPTY (ô trống), RABBIT (ô thỏ), WALL (ô
tường), BONUS_DOUBLE_SPEED (ô thưởng tăng tốc),
BONUS_INFINITE_RABBITS (ô thưởng thỏ vô hạn).
 lvl: Cấp độ của game.
Phần code cũng gọi phương thức set_random_rabbit để đặt một con thỏ ngẫu
nhiên tại ô trống.
2. Phương thức:
1. def set_rabbit(self, pos):
2. self.grid[pos[0]][pos[1]] = RABBIT
3.
4. def set_random_rabbit(self):
5. pos = self.random_empty_pos()
6. self.set_rabbit(pos)
7.
8. def cell(self, pos):
9. return self.grid[pos[0]][pos[1]]
10.
11.def set_cell(self, pos, content):
12. self.grid[pos[0]][pos[1]] = content
13.
14.def advance_level(self):
15. self.lvl += 1
16. self.clear_rabbits()
17.
18. # for each level draw add additional wall cells
19. if self.lvl == 1:
20. for row in range(ROWS):
21. if row != ROWS//2:
22. self.grid[row][0] = self.grid[row][COLS - 1] = WALL
23.

24. for col in range(COLS):
25. self.grid[0][col] = self.grid[ROWS - 1][col] = WALL
26. elif self.lvl == 2:
27. row1, col1 = ROWS//4, COLS//4
28. row2 = ROWS - row1
29. col2 = COLS - col1
30.
31. for col in range(col1, col2):
32. self.grid[row1][col] = WALL
33. self.grid[row2][col] = WALL
34. elif self.lvl == 3:
35. row1, col1 = ROWS//4, COLS//4
36. row2 = ROWS - row1
37. row3 = (row1 + row2)//2
38. col2 = COLS - col1
39.
40. print(col1, col2)
41. for row in range(row1, row2 + 1):
42. if row != row3:
43. self.grid[row][col1] = WALL
44. self.grid[row][col2] = WALL
45. print(row)
46.
47.
48. self.set_random_rabbit()
49.
50. def clear_rabbits(self):
53. if self.grid[row][col] == RABBIT:
54. self.grid[row][col] = EMPTY
55.
56.
57. def random_empty_pos(self):
58. positions = []
59.
62. if self.grid[row][col] == EMPTY:
63. positions.append([row, col])
64.
65. return random.choice(positions)
66.
67.
68. def next_empty_pos(self, pos):
69. row, col = pos
70. for i in range(row, ROWS):
71. if row != i:
72. col = 0
73.
74. for j in range(col, COLS):
75. if self.grid[i][j] == EMPTY:
76. return (i, j)
77.
78. return False
Hình 2.13: Các phương thức của ma trận
 Phương thức set_rabbit(self, pos):
Phương thức này đặt ô tại vị trí pos thành RABBIT (ô thỏ).
 Phương thức set_random_rabbit(self):
Phương thức này đặt một con thỏ ngẫu nhiên tại ô trống. Phương thức này

làm như vậy bằng cách gọi phương thức random_empty_pos() để lấy một vị
trí ô trống, sau đó gọi phương thức set_rabbit() để đặt ô đó thành RABBIT.
 Phương thức cell(self, pos):
Phương thức này lấy giá trị của ô tại vị trí pos.
 Phương thức set_cell(self, pos, content):
Phương thức này gán giá trị content cho ô tại vị trí pos.
 Phương thức advance_level(self):
Phương thức này tăng cấp độ của game, xóa các con thỏ và tạo các bức
tường theo cấp độ. Phương thức này làm như vậy bằng cách: Tăng giá trị của
thuộc tính lvl; Gọi phương thức clear_rabbits() để xóa tất cả các con thỏ;
Thêm các bức tường mới theo cấp độ.
 Phương thức clear_rabbits(self):
Phương thức này xóa tất cả các con thỏ trên màn hình. Phương thức này làm
như vậy bằng cách lặp qua ma trận grid và đặt tất cả các ô có giá trị RABBIT
thành EMPTY.
 Phương thức random_empty_pos(self):
Phương thức này chọn ngẫu nhiên một ô trống. Phương thức này làm như
vậy bằng cách lặp qua ma trận grid và trả về vị trí của ô đầu tiên có giá trị
EMPTY.
 Phương thức next_empty_pos(self, pos):
Phương thức này tìm ô trống tiếp theo từ vị trí pos. Phương thức này làm như
vậy bằng cách lặp qua ma trận grid bắt đầu từ vị trí pos và trả về vị trí của ô
đầu tiên có giá trị EMPTY.
3. Vẽ ma trận:
1. def draw(self, screen):
2. # draw grass on all cells
7. screen.blit(grass, (x, y))
8.

9.
10. # draw walls
13. if self.grid[row][col] == WALL:
16. screen.blit(border, (x, y))
17.
18.
19. # draw rabbits
22. if self.grid[row][col] == RABBIT:
25. screen.blit(rabbit, (x, y))
26.
27.
28. # draw bonuses
31. if self.grid[row][col] == BONUS_DOUBLE_SPEED or self.grid
[row][col] == BONUS_INFINITE_RABBITS:
32. x = col * CELL_WIDTH - 8
33. y = row * CELL_WIDTH - 8
34. screen.blit(star, (x, y))
Hình 2.14: Vẽ ma trận
Phương thức draw(self, screen): Phương thức này vẽ các ô trên màn hình.
Phương thức này làm như vậy bằng cách lặp qua ma trận grid và vẽ ảnh tương
ứng với giá trị của ô đó. Cụ thể:
• Vẽ cỏ trên tất cả các ô bằng ảnh grass.
• Vẽ các bức tường bằng ảnh border.
• Vẽ các con thỏ bằng ảnh rabbit.
• Vẽ các ô thưởng bằng ảnh star.
1.6.5. Hiển thị màn hình kết thúc
1. def end_game(win, score):
2. pygame.time.wait(700)
3. run = True
4.
5. while run:
6. # draw grass
11. screen.blit(grass, (x, y))
12.
13. # display score

14. best = best_score(score)
15. text_message = FONT_LARGE.render(f'Score: {score} Best: {best}', 1,
WHITE)
16. text_play_again = FONT_SMALL.render('Press any key to continue...', 1,
WHITE)
17. win.blit(text_message, ((WIDTH -
text_message.get_width())//2, (HEIGHT - 3*text_message.get_height())//2))
18. win.blit(text_play_again, ((WIDTH -
text_play_again.get_width())//2, HEIGHT//2))
19. pygame.display.update()
20.
21. for event in pygame.event.get():
22. if event.type == pygame.QUIT:
23. run = False
24.
25. if event.type == pygame.KEYDOWN:
26. return False
27.
28. return True
Hình 2.15: Hiển thị màn hình kết thúc
Đoạn code này là hàm end_game(win, score) trong game Snake, có nhiệm vụ:
 Hiển thị màn hình kết thúc:
Chờ 700ms để đảm bảo người chơi thấy được màn hình kết thúc.
Vẽ nền cỏ lên màn hình.
Hiển thị số điểm hiện tại và điểm cao nhất.
Hiển thị thông báo "Nhấn bất kỳ phím nào để tiếp tục...".
Cập nhật màn hình.
 Chờ người chơi nhấn phím:
Bắt đầu một vòng lặp while để chờ người chơi nhấn phím.
Kiểm tra các sự kiện:
1. Nếu người chơi nhấn QUIT, thoát khỏi game.
2. Nếu người chơi nhấn bất kỳ phím nào, thoát khỏi vòng lặp và trả về False
để bắt đầu game mới.
 Trả về True:
Sau khi người chơi nhấn phím, hàm trả về True để báo hiệu game đã kết thúc.
1.6.6. Kiểm tra và cập nhật điểm cao nhất
1. def best_score(score):
2. file = open('scores.txt', 'r+')
3.

4. file_content = file.readlines()
5. best = 0
6.
7. if file_content:
8. best = int(file_content[0])
9.
10. # sees if the current score is greater than the previous best
11. if best < score:
12. file.truncate(0)
13. file.seek(0)
14. file.write(str(score))
15. best = score
16.
17. file.close()
18. return best
Hình 2.16: Kiểm tra và cập nhật điểm cao nhất
Hàm best_score(score) được thiết lập như sau:
 Mở file scores.txt để đọc/ghi điểm cao nhất.
 Đọc nội dung file vào list file_content.
 Nếu file có nội dung, lấy điểm cao nhất từ file và gán cho biến best.
 Kiểm tra nếu score hiện tại cao hơn điểm cao nhất:
 Xóa nội dung file.
 Viết score hiện tại vào file.
 Cập nhật biến best với score mới.
 Đóng file và trả về điểm cao nhất.
1.6.7. Vẽ các thành phần của game lên màn hình
1. def draw(screen, snake, grid, score):
2. screen.fill(WHITE)
3. grid.draw(screen)
4. snake.draw(screen)
5.
6. # show score
7. text = FONT_MEDIUM.render(f'Score: {score}', False, WHITE)
8. screen.blit(text, (WIDTH - text.get_width() - 25, 20))
9. pygame.display.flip()
Hình 2.17: Vẽ các thành phần của game lên màn hình
Hàm draw(screen, snake, grid, score) được thiết lập như sau:
 Tô màn hình màu trắng.

 Vẽ grid lên màn hình.
 Vẽ con rắn lên màn hình.
 Tạo text hiển thị score.
 Vẽ text lên màn hình.
 Cập nhật màn hình.
1.6.8. Tạo các đối tượng và biến cần thiết
1. clock = pygame.time.Clock()
2. snake = Snake()
3. grid = Grid()
4. score = 0
5. infinite_rabbits = False
6. double_speed_timer = 0
7. score_lvl = [0] * LEVELS
Hình 2.18: Khởi tạo các đối tượng và biến cần thiết
 Tạo đối tượng clock để kiểm soát tốc độ game.
 Tạo con rắn.
 Tạo grid.
 Khởi tạo biến score lưu trữ số điểm.
 Khởi tạo biến infinite_rabbits kiểm tra trạng thái thưởng thỏ vô hạn.
 Khởi tạo biến double_speed_timer đếm thời gian thưởng tăng tốc.
 Khởi tạo list score_lvl lưu trữ điểm cho mỗi cấp độ.
1.6.9. Vòng lặp chính của trò chơi
1. running = True
2. while running:
3. # keep loop running at the right speed
4. if double_speed_timer > 0:
5. double_speed_timer -= 1
6. clock.tick(int(2 * FPS))
7. else:
8. clock.tick(FPS)
9.
10. # Process input (events)
11. for event in pygame.event.get():
12. if event.type == pygame.QUIT:
13. running = False
14. elif event.type == pygame.KEYDOWN:

15. if event.key == pygame.K_DOWN:
16. snake.dir_down()
17. elif event.key == pygame.K_UP:
18. snake.dir_up()
19. elif event.key == pygame.K_RIGHT:
20. snake.dir_right()
21. elif event.key == pygame.K_LEFT:
22. snake.dir_left()
23.
24. # Snake head on RABBIT
25. if grid.cell(snake.head) == RABBIT:
26. eat_sound.play()
27. score += 10 if not infinite_rabbits else 1
28. grid.set_cell(snake.head, EMPTY)
29.
30. if not infinite_rabbits:
31. grid.set_random_rabbit()
32. else:
33. snake.body.pop(0)
34. snake.body_dir.pop(0)
35.
36. # Snake head on Bonus element
37. if grid.cell(snake.head) == BONUS_DOUBLE_SPEED:
38. double_speed_timer = DOUBLE_SPEED_TIME
40. elif grid.cell(snake.head) == BONUS_INFINITE_RABBITS:
41. infinite_rabbits = True
43.
44. # Make move according to snake's direction
45. snake.update()
46.
47. # Game Over
48. if snake.head in snake.body or grid.cell(snake.head) == WALL:
49. die_sound.play()
50.
51. if end_game(screen, score):
52. running = False
53. break
54. else:
55. grid = Grid()
56. snake = Snake()
58. double_speed_timer = 0
59. score_lvl = [0] * LEVELS
60. score = 0
61.
62. if infinite_rabbits:
63. rabbit_pos = grid.next_empty_pos(rabbit_pos)
64.
65. if rabbit_pos:
66. grid.set_rabbit(rabbit_pos)
67. else:
69. grid.clear_rabbits()
70. grid.set_random_rabbit()
71. elif False:
72. pass
73. else:
74. # advance to next level if accumulated score per level > MAX_SCORE_PER
_LVL
75. if score - score_lvl[grid.lvl - 1] > MAX_SCORE_PER_LVL[grid.lvl]:
76. score_lvl[grid.lvl] = score

77. snake.reset()
78. grid.advance_level()
79.
80. # instantiate bonus drop item with given probability
81. if not infinite_rabbits and not double_speed_timer:
82. r = random.uniform(0, 1)
83.
84. if r < 0.0025:
85. row, col = grid.random_empty_pos()
86.
87. if r < 0.0015:
88. grid.grid[row][col] = BONUS_DOUBLE_SPEED
89. else:
90. grid.grid[row][col] = BONUS_INFINITE_RABBITS
91. rabbit_pos = (0, 0)
92.
93. # Draw / render
94. draw(screen, snake, grid, score)
Hình 2.19: Vòng lặp chính của trò chơi
Vòng lặp này thực hiện các công việc sau:
1. Kiểm soát tốc độ game:
Kiểm tra nếu đang có thưởng tăng tốc, game sẽ chạy với tốc độ gấp đôi FPS.
Nếu không có thưởng tăng tốc, game sẽ chạy với tốc độ FPS bình thường.
2. Xử lý sự kiện:
Lấy các sự kiện từ người chơi.
Kiểm tra sự kiện QUIT để thoát game.
Kiểm tra sự kiện KEYDOWN để thay đổi hướng di chuyển của con rắn.
3. Xử lý va chạm với thỏ:
Kiểm tra nếu đầu con rắn va chạm với thỏ.
Nếu va chạm:
1. Phát âm thanh ăn thỏ.
2. Tăng score.
3. Xóa thỏ khỏi grid.
Nếu không có thưởng thỏ vô hạn: Tạo một thỏ mới ở vị trí ngẫu nhiên.
Nếu có thưởng thỏ vô hạn: Mở rộng con rắn.
4. Xử lý va chạm với bonus:
Kiểm tra nếu đầu con rắn va chạm với bonus tăng tốc hoặc bonus thỏ vô hạn.

Nếu va chạm:
1. Thực hiện hành động tương ứng với bonus.
2. Xóa bonus khỏi grid.
5. Cập nhật vị trí con rắn:
Di chuyển con rắn theo hướng đã chọn.
6. Kiểm tra game over:
Kiểm tra nếu đầu con rắn va chạm với chính nó hoặc tường.
Nếu va chạm:
1. Phát âm thanh game over.
2. Bắt đầu game mới nếu người chơi chọn "Play again".
3. Nếu không, thoát game.
7. Xử lý thưởng thỏ vô hạn:
Nếu có thưởng thỏ vô hạn: Tìm vị trí trống tiếp theo cho thỏ.
Nếu tìm thấy, đặt thỏ ở vị trí đó.
Nếu không tìm thấy, tắt thưởng thỏ vô hạn và xóa tất cả thỏ trên grid.
8. Kiểm tra nâng cấp cấp độ:
Kiểm tra nếu điểm tích lũy của cấp độ hiện tại đã vượt quá điểm tối đa.
Nếu vượt quá:
1. Lưu điểm tích lũy hiện tại.
2. Reset con rắn.
3. Nâng cấp độ.
9. Tạo bonus:
Nếu không có thưởng thỏ vô hạn và không có thưởng tăng tốc, có một xác suất
nhỏ để tạo một bonus mới ở vị trí ngẫu nhiên.
10. Vẽ màn hình:
Vẽ con rắn, grid, score và các thành phần khác lên màn hình.
Tóm lại, đoạn code này điều khiển tất cả các hoạt động của game Snake, từ xử lý

sự kiện đến cập nhật vị trí, va chạm và nâng cấp cấp độ.
1.6.10. Kết thúc chương trình
1. pygame.quit()
Hình 2.20: Kết thúc chương trình pygame
Dòng code pygame.quit() trong Python là một hàm được sử dụng để kết thúc
chương trình Pygame. Hàm này sẽ giải phóng tất cả các tài nguyên được sử dụng
bởi Pygame, chẳng hạn như font, bề mặt và bộ đệm âm thanh.
Khi được gọi, hàm pygame.quit() sẽ thực hiện các bước sau:
1. Giải phóng tất cả các tài nguyên được sử dụng bởi Pygame.
2. Dừng vòng lặp sự kiện. Điều này có nghĩa là Pygame sẽ không còn xử lý
bất kỳ sự kiện nào, chẳng hạn như nhấn phím hoặc nhấp chuột.
3. Thoát khỏi chương trình.
Cần lưu ý rằng pygame.quit() không giống như đóng cửa sổ. Mặc dù nó sẽ giải
phóng tất cả các tài nguyên Pygame và dừng vòng lặp sự kiện, nhưng nó sẽ
không đóng cửa sổ chính.
1.6.11. Chạy chương trình
Kết quả đạt được sau khi chạy chương trình:
Hình 2.21: Cửa sổ chơi trò chơi Snake

Hình 2.22: Sau khi ăn bonus thưởng thỏ vô hạn
Hình 2.23: Sau khi đủ điểu kiện lên level 2 trong trò chơi

Hình 2.24: Game over xuất hiện khi rắn va chạm

PHẦN III: KẾT LUẬN
Sau quá trình nghiên cứu và xây dựng trò chơi rắn săn mồi, nhóm chúng em
xin được tổng kết một số điều như sau:
Kết quả đạt được
Thiết kế được một AI đơn giản cho trò chơi rắn săn mồi. Con rắn tuân theo
quy tắc “Miễn là còn đường đi từ đầu rắn tới đuôi rắn, thì con rắn vẫn có thể tiếp
tục đi”. Thoả mãn một số ràng buộc như là đâm vào tường hoặc chính nó thì
thua, ăn đồ ăn chiều dài tăng lên một đơn vị.
Sử dụng thuật toán đơn giản mà hiệu quả giúp con rắn gần như luôn tìm được
đường đi tới thức ăn hoặc đuôi của mình.
Chương trình thực thi thành công và xuất ra được cửa sổ.
Hạn chế
Thuật toán chỉ thực sự hữu dụng khi cửa sổ khung hình là
nhỏ.
Do kiến thức lập trình còn hạn chế hầu hết chương trình đều tham khảo dựa
trên chương trình có sẵn.
Chưa đưa ra được hướng phát triển mở rộng cho trò chơi.
Kết luận
Chúng em còn nhiều thiếu sót trong đề tài cũng như trong quá trình thực hiện
đề tài. Từ đó chúng em cũng mong nhân được nhiều ý kiến cũng như đóng góp
từ quý thầy (cô) để có thể hoàn thiện đề tài và bổ sung thêm kiến thức.
Chúng em xin chân thành cảm ơn!

Tài liệu tham khảo
[1] PGS.TS Từ Minh Phương, Giáo trình Nhập môn trí tuệ nhân tạo, Nhà xuất
bản Thông tin và truyền thông, xuất bản năm 2014.
[2] Python ( ngôn ngữ lập trình) - Wikipedia
https://vi.wikipedia.org/wiki/Python_(ng%C3%B4n_ng%E1%BB%AF_l%E1%BA
%ADp_tr%C3%ACnh)
[3] Tạo AI đơn giản cho game rắn với BFS
https://github.com/trituenhantaoio/snake_bfs/blob/master/snake_bfs.py
[4] BFS (Breadth first search) https://vnoi.info/wiki/algo/graph-theory/breadth-
first-search.md
[5] Pygame – Wikipedia Tiếng Việt https://vi.wikipedia.org/wiki/Pygame

bao-cao-mon-hoc-ai-de-tai-bao-cao.docx

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to bao-cao-mon-hoc-ai-de-tai-bao-cao.docx

Similar to bao-cao-mon-hoc-ai-de-tai-bao-cao.docx (20)

bao-cao-mon-hoc-ai-de-tai-bao-cao.docx