BỘ GIÁO DỤC VÀ ĐÀO TẠO

TRƯỜNG ĐẠI HỌC KIẾN TRÚC

BÀI TẬP LỚN MÔN TRÍ TUỆ NHÂN TẠO

NGHIÊN CỨU VÀ XÂY DỰNG GHOST-PACMAN TRÊN THUẬT TOÁN DFS

Giảng viên hướng dẫn: ThS. Nguyễn Thị Huệ

Nhóm: 7
Sinh viên thực hiện: Lưu Việt Dương (Nhóm trưởng)
Nguyễn Quốc Việt Hùng
Phạm Đức Trịnh
Đỗ Vĩnh Đại
Đỗ Anh Tuấn

Hà Nội, 10/2023
 MỤC LỤC

MỤC LỤC..........................................................................................................2
DANH MỤC VIẾT TẮT...................................................................................4
DANH MỤC HÌNH ẢNH.................................................................................5
LỜI NÓI ĐẦU...................................................................................................7
CHƯƠNG 1. TỔNG QUAN VỀ ĐỀ TÀI.........................................................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. Lịch sử phát triển...............................................................................8
1.1.3. Các lĩnh vực nghiên cứu và ứng dụng cơ bản...................................9
1.1.4. Những vấn đề chưa được giải quyết................................................10
1.1.5. Các hướng phát triển.......................................................................10
1.2. Tổng quan về đề tài...........................................................................10
1.2.1 Ý tưởng.............................................................................................10
1.2.2. Cách chơi.........................................................................................11
1.2.3. Phương hướng.................................................................................11
1.3. Các công nghệ sử dụng trong đề tài..................................................11
1.3.1. Ngôn ngữ Python.............................................................................11
1.3.2. Thư viện Time.................................................................................12
1.3.3. Thư viện Imple Object Oriented Graphics......................................12
CHƯƠNG 2. ỨNG DỤNG THUẬT TOÁN DFS VÀO PACMAN...............13
2.1. Thuật toán DFS tổng quát.................................................................13
2.1.1. Khái niệm........................................................................................13
2.1.2. Mô tả thuật toán DFS qua đồ thị.....................................................14
2.1.3. Ưu nhược điểm................................................................................15
2.2. Áp dụng thuật toán vào dự án...........................................................15

2
 2.2.1. Trạng thái xuất phát.........................................................................15
2.2.2. Thiết lập DFS..................................................................................15
CHƯƠNG 3: TRIỂN KHAI HỆ THỐNG.......................................................16
3.1. Khởi tạo giá trị cơ bản.......................................................................16
3.2. Thiết lập môi trường cần thiết cho DFS............................................18
3.3. Thiết lập thuật toán DFS...................................................................22
3.4. Thiết lập di chuyển đối tượng theo DFS...........................................23
3.5. Thiết lập vòng lặp thực hiện chính....................................................24
KẾT LUẬN......................................................................................................25
TÀI LIỆU THAM KHẢO................................................................................26

3
 DANH MỤC VIẾT TẮT

STT Ký hiệu viết tắt Ý nghĩa

1 ĐHĐTCB Đồ họa đối tượng cơ bản
2 DFS Tìm kiếm theo chiều sâu (Depth-first search)
3 node Khối có trên đồ thị xét duyệt

4
 DANH MỤC HÌNH ẢNH

ST
Ký hiệu hình ảnh Ý nghĩa
T

1 Hình 2.1 Đồ thị mô tả thuật toán DFS

2 Hình 3.1.1 Thiết lập thư viện để thiết kế

3 Hình 3.1.2 Tạo cửa sổ ứng dụng và thiết lập màu nền

Tạo danh sách vị trí tường chặn và danh sách node kề

4 Hình 3.1.3
nhau

5 Hình 3.1.4 Vẽ tường chặn trên cửa sổ

6 Hình 3.1.5 Thiết lập biến toàn cục bắt đầu và vị trí cơ bản

7 Hình 3.1.6 Vẽ đối tượng Ghost

8 Hình 3.1.7 Thiết lập biến toàn cục kết thúc và thiết lập vị trí cơ bản

9 Hình 3.1.8 Vẽ đối tượng Pacman

10 Hình 3.1.9 Tạo danh sách đường đi rỗng theo DFS

Hình
11 Mô tả cửa sổ ứng dụng
3.1.10

12 Hình 3.2.1 Tạo cửa sổhàm thiết lập node kề

13 Hình 3.2.2 Kiểm tra node có trùng tường hay không

14 Hình 3.2.3 Thiết lập danh sách giá trị danh sách node kề

15 Hình 3.2.4 Kiểm tra và chèn node vào danh sách kề

16 Hình3.2.5 Khởi tạo hàm di chuyển đối tượng Pacman

17 Hình 3.2.6 Thiết lập di chuyển lên trên

18 Hình 3.2.7 Thiết lập di chuyển xuống dưới

5
19 Hình 3.2.8 Thiết lập di chuyển sang trái

20 Hình 3.2.9 Thiết lập di chuyển sang phải

Hình
21 Thay đổi vị trí kết thúc
3.2.10

Hình
22 Làm mới danh sách path và gọi hàm tìm đường đi DFS
3.2.11

23 Hình 3.3.1 Khởi tạo hàm DFS

24 Hình 3.3.2 Kiểm tra node và mục tiêu

25 Hình 3.3.3 Ngắn vòng lặp nếu thấy mục tiêu

26 Hình 3.3.4 Kiểm tra và chèn đường đi

27 Hình 3.4.1 Khởi tạo hàm di chuyển Ghost

28 Hình 3.4.2 Khởi tạo vòng lặp và tạo hoạt ảnh

29 Hình 3.4.3 Tạo biến chứa 2 giá trị node trong path liền nhau

30 Hình 3.4.4 Tính khoảng cách thay đổi vị trí Ghost

31 Hình 3.4.5 Di chuyển Ghost và gán giá trị bắt đầu mới

32 Hình 3.5.1 Khởi tạo vòng lặp trò chơi

33 Hình 3.5.2 Gọi hàm vòng lặp chính

6
 LỜI NÓI ĐẦU
Trí tuệ nhân tạo hiện đang đóng vai trò rất quan trọng trong cuộc sống hoạt
động muôn màu muôn vẻ của thế giới.
Vậy “Trí tuệ nhân tạo - AI” là gì? AI – Aritifical Intelligence hay còn được gọi
là trí tuệ nhân tạo là một ngành khoa học kỹ thuật liên quan đến máy móc thông minh.
Trí tuệ nhân tạo được thực hiện bằng cách nghiên cứu suy nghĩ của con người , các
con người học hỏi, sự quyết định, cách làm việc khi gặp một vấn đề nào đó.
Thông qua quá trình nghiên cứu trên tạo thành một nền tảng quan trọng trong
việc phát triển và tạo nên hệ thống máy móc thông minh rồi áp dụng nó vào mục địch
khác nhau trong cuộc sống của nhân loại.
Với trí tuệ nhân tạo, nhân loại đã có thể giải quyết nhiều vấn đề một cách tốt
hơn. Để tìm hiểu sâu hơn về AI nói chúng cũng như các thuật toán tìm kiếm nói riêng,
nhóm xin triển khai việc nghiên cứu và xây dựng Ghost-Pacman dựa trên thuật toán
DFS.
Do thời gian hạn chế cũng như việc kỹ năng có thể thiếu sót trong hiểu biết về
xây dựng phần mềm và trí tuệ nhân tạo, nghiên cứu và xây dựng của nhóm vẫn sẽ còn
nhiều hạn chế. Rất mong nhận được sự đóng góp ý kiến từ thầy cô.

7
 CHƯƠNG 1. TỔNG QUAN VỀ ĐỀ TÀI
1.1. Tổng quan về trí tuệ nhân tạo
1.1.1. Khái niệm

Có nhiều quan điểm khác nhau về trí tuệ nhân tạo nhưng chưa có thống nhất
chung.
Trí tuệ nhân tạo là một nhánh của khoa học máy tính, có mục đích tạo ra các
thực thể (phần mềm máy tính hoặc máy tính) có trí tuệ hoặc có trí thông minh.
1.1.2. Lịch sử phát triển

Vào năm 1943, Warren McCulioch và Walter Pitts bắt đầu thực hiện nghiên
cứu ba cơ sở lý thuyết cơ bản: triết học cơ bản và chức năng của các noron thần kinh;
phân tích các mệnh đề logic; và lý thuyết dự đoán của Turing. Các tác giả đã nghiên
cứu đề xuât mô hình noron nhân tạo, mỗi noron đặc trưng bởi hai trạng thái “bật”,
“tắt” và phát hiện mạng noron có khả năng học.
Thuật ngữ “Trí tuệ nhân tạo” (Artificial Intelligence - AI) được thiết lập bởi
John McCarthy tại Hội thảo đầu tiên về chủ đề này vào mùa hè năm 1956. Đồng thời,
ông cũng đề xuất ngôn ngữ lập trình Lisp – một trong những ngôn ngữ lập trình hàm
tiêu biểu, được sử dụng trong lĩnh vực AI. Sau đó, Alan Turing đưa ra "Turing test"
như là một phương pháp kiểm chứng hành vi thông minh.
Thập kỷ 60, 70 Joel Moses viết chương trình Macsyma - chương trình toán
học sử dụng cơ sở tri thức đầu tiên thành công. Marvin Minsky và Seymour Papert đưa
ra các chứng minh đầu tiên về giới hạn của các mạng nơ-ron đơn giản. Ngôn ngữ lập
trình logic Prolog ra đời và được phát triển bởi Alain Colmerauer. Ted Shortliffe xây
dựng thành công một số hệ chuyên gia đầu tiên trợ giúp chẩn đoán trong y học, các hệ
thống này sử dụng ngôn ngữ luật để biểu diễn tri thức và suy diễn.
Vào đầu những năm 1980, những nghiên cứu thành công liên quan đến AI
như các hệ chuyên gia (expert systems) – một dạng của chương trình AI mô phỏng tri
thức và các kỹ năng phân tích của một hoặc nhiều chuyên gia con người
Vào những năm 1990 và đầu thế kỷ 21, AI đã đạt được những thành tựu to lớn
nhất, AI được áp dụng trong logic, khai phá dữ liệu, chẩn đoán y học và nhiều lĩnh vực
ứng dụng khác trong công nghiệp. Sự thành công dựa vào nhiều yếu tố: tăng khả năng
tính toán của máy tính, tập trung giải quyết các bài toán con cụ thể, xây dựng các mối
quan hệ giữa AI và các lĩnh vực khác giải quyết các bài toán tương tự, và một sự

8
chuyển giao mới của các nhà nghiên cứu cho các phương pháp toán học vững chắc và
chuẩn khoa học chính xác.
1.1.3. Các lĩnh vực nghiên cứu và ứng dụng cơ bản

Lập luận, suy diễn tự động: Khái niệm lập luận (reasoning), và suy diễn
(reference) được sử dụng rất phổ biến trong lĩnh vực AI. Lập luận là suy diễn logic,
dùng để chỉ một tiến trình rút ra kết luận (tri thức mới) từ những giả thiết đã cho (được
biểu diễn dưới dạng cơ sở tri thức). Như vậy, để thực hiện lập luận người ta cần có các
phương pháp lưu trữ cơ sở tri thức và các thủ tục lập luận trên cơ sở tri thức đó.
Biểu diễn tri thức: Muốn máy tính có thể lưu trữ và xử lý tri thức thì cần có
các phương pháp biểu diễn tri thức. Các phương pháp biểu diễn tri thức ở đây bao gồm
các ngôn ngữ biểu diễn và các kỹ thuật xử lý tri thức. Một ngôn ngữ biểu diễn tri thức
được đánh giá là “tốt” nếu nó có tính biểu đạt cao và các tính hiệu quả của thuật toán
lập luận trên ngôn ngữ đó. Tính biểu đạt của ngôn ngữ thể hiện khả năng biểu diễn một
phạm vi rộng lớn các thông tin trong một miền ứng dụng. Tính hiệu quả của các thuật
toán lập luận thể hiện chi phí về thời gian và không gian dành cho việc lập luận. Tuy
nhiên, hai yếu tố này dường như đối nghịch nhau, tức là nếu ngôn ngữ có tính biểu đạt
cao thì thuật toán lập luận trên đó sẽ có độ phức tạp lớn (tính hiệu quả thấp) và ngược
lại (ngôn ngữ đơn giản, có tính biểu đạt thấp thì thuật toán lập luận trên đó sẽ có hiệu
quả cao). Do đó, một thách thức lớn trong lĩnh vực AI là xây dựng các ngôn ngữ biểu
diễn tri thức mà có thể cân bằng hai yếu tố này, tức là ngôn ngữ có tính biểu đạt đủ tốt
(tùy theo từng ứng dụng) và có thể lập luận hiệu quả.
Lập kế hoạch: khả năng suy ra các mục đích cần đạt được đối với các nhiệm
vụ đưa ra, và xác định dãy các hành động cần thực hiện để đạt được mục đích đó.
Học máy: là một lĩnh vực nghiên cứu của AI đang được phát triển mạnh mẽ và
có nhiều ứng dụng trong các lĩnh vực khác nhau như khai phá dữ liệu, khám phá tri
thức, …
Xử lý ngôn ngữ tự nhiên: là một nhánh của AI, tập trung vào các ứng dụng
trên ngôn ngữ của con người. Các ứng dụng trong nhận dạng tiếng nói, nhận dạng chữ
viết, dịch tự động, tìm kiếm thông tin, …
Hệ chuyên gia: cung cấp các hệ thống có khả năng suy luận để đưa ra những
kết luận. Các hệ chuyên gia có khả năng xử lý lượng thông tin lớn và cung cấp các kết
luận dựa trên những thông tin đó. Có rất nhiều hệ chuyên gia nổi tiếng như các hệ
chuyên gia y học MYCIN, đoán nhận cấu trúc phân tử từ công thức hóa học
DENDRAL…

9
 1.1.4. Những vấn đề chưa được giải quyết

Mặc dù đạt được nhiều thành tựu và có nhiều ứng dụng đáng kể, các hệ thống
trí tuệ nhân tạo hiện nay chưa đạt được mức độ trí tuệ nhân tạo mạnh (strong AI) hay
trí tuệ nhân tạo tổng quát (Artificial General Intelligence). Đây cũng được coi là vấn
đề khó nhất và chưa được giải quyết. Trí tuệ nhân tạo mạnh là khái niệm để chỉ khả
năng của máy tính thực hiện bất cứ công việc trí tuệ nào mà con người có thể thực
hiện. Khái niệm trí tuệ mạnh được sử dụng để phân biệt với trí tuệ nhân tạo yếu (weak
AI) hay trí tuệ nhân tạo ứng dụng (applied AI), tức là dùng máy tính để giải quyết từng
bài toán ra quyết định hay lập luận đơn lẻ. Như vậy, trí tuệ nhân tạo mạnh đòi hỏi giải
quyết đầy đủ các công việc trí tuệ như người trong khi trí tuệ nhân tạo yếu giải quyết
bài toán cụ thể.
Các khó khăn để đạt được trí tuệ nhân tạo tổng quát bao gồm khả năng thị
giác máy, xử lý ngôn ngữ tự nhiên, khả năng xử lý các tình hướng mới, tình huống
không ngờ tới khi giải quyết các bài toán thực tế. Đây là những lĩnh vực mà máy tính
còn thua kém con người. Các hệ thống trí tuệ nhân tạo hiện nay có thể giải quyết tốt
bài toán đặt ra trong một phạm vi hẹp. Tuy nhiên, khi gặp vấn đề thực tế ở phạm vi
rộng hơn, hệ thống trí tuệ nhân tạo thường không thể xử lý được các tình huống mới,
vượt ra ngoài ngữ cảnh ban đầu của bài toán. Ngược lại, con người có khả năng xử lý
tốt hơn nhiều những trường hợp như vậy do có hiểu biết rộng về thế giới xung quanh.
Việc trang bị cho máy tính lượng tri thức như con người hiện vẫn là vấn đề chưa được
giải quyết
1.1.5. Các hướng phát triển

Hiện nay trí tuệ nhân tạo có thể mang lại nhiều cơ hội phát triển theo nhiều
khuynh hướng khác nhau chẳng hạn như Tìm kiếm trong không gian, học máy, hệ
chuyên gia, nhân dạng và xử lý tiếng nói… Không chỉ dừng lại ở đó trí tuệ nhân tạo
ngày càng phát triển mang lại nhiều khuynh hướng phát triển hơn nữa bên cạnh đó các
ngành phát triển từ trí tuệ nhân tạo cũng ngày càng khó khăn hơn khi tìm kiếm tuyển
chọn người nội dung khắt khe hơn…
1.2. Tổng quan về đề tài
1.2.1 Ý tưởng

Pacman là một trò chơi nổi tiếng khắp thế giới vào những năm đầu thập niên
1980, ngày nay dù đã không còn nổi tiếng như ngày đó nhưng vẫn không thể không
công nhận sự thú vị trong trò chơi này.

10
 Nhằm lưu giữ lấy một trò chơi thế kỷ dựa vào thuật toán hiện đại DFS hy
vọng có thể mang lại sự sống mới cho trò chơi tuyệt vời này.
1.2.2. Cách chơi

Với mục đích thiết kế thuật toán tìm kiếm đường đi cho nhân vật Ghost, thiết
kế trò chơi sẽ cho thấy rõ ràng phương pháp tìm kiếm đường đi của nhân vật Ghost khi
định vị vị trí của Pacman trên bản đồ.
1.2.3. Phương hướng

Phát triển xây dựng trò chơi dựa trên thuật toán DFS và một số công nghệ phổ
biến khác hiện nay.
1.3. Các công nghệ sử dụng trong đề tài
1.3.1. Ngôn ngữ 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.
Ngôn ngữ lập trình Python được tạo bởi Guido van Rossum 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. 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.
Lý do lựa chọn ngôn ngữ do các ưu điểm tối ưu của ngôn ngữ như sau:
Đơn giản, dễ học: Python có cú pháp rất đơn giản, rõ ràng. Nó dễ đọc và viết
hơn rất nhiều khi so sánh với những ngôn ngữ lập trình khác như C++, Java, C#.
Python làm cho việc lập trình trở nên thú vị, cho phép bạn tập trung vào những giải
pháp chứ không phải cú pháp.
Miễn phí, mã nguồn mở: Bạn có thể tự do sử dụng và phân phối Python, thậm
chí là dùng cho mục đích thương mại. Vì là mã nguồn mở, bạn không những có thể sử
dụng các phần mềm, chương trình được viết trong Python mà còn có thể thay đổi mã
nguồn của nó. Python có một cộng đồng rộng lớn, không ngừng cải thiện nó mỗi lần
cập nhật.
Khả năng di chuyển: Các chương trình Python có thể di chuyển từ nền tảng
này sang nền tảng khác và chạy nó mà không có bất kỳ thay đổi nào. Nó chạy liền
mạch trên hầu hết tất cả các nền tảng như Windows, macOS, Linux.
Khả năng mở rộng và có thể nhúng: Giả sử một ứng dụng đòi hỏi sự phức tạp
rất lớn, bạn có thể dễ dàng kết hợp các phần code bằng C, C++ và những ngôn ngữ

11
khác (có thể gọi được từ C) vào code Python. Điều này sẽ cung cấp cho ứng dụng của
bạn những tính năng tốt hơn cũng như khả năng scripting mà những ngôn ngữ lập trình
khác khó có thể làm được.
Ngôn ngữ thông dịch cấp cao: Không giống như C/C++, với Python, bạn
không phải lo lắng những nhiệm vụ khó khăn như quản lý bộ nhớ, dọn dẹp những dữ
liệu vô nghĩa,... Khi chạy code Python, nó sẽ tự động chuyển đổi code sang ngôn ngữ
máy tính có thể hiểu. Bạn không cần lo lắng về bất kỳ hoạt động ở cấp thấp nào.
Thư viện tiêu chuẩn lớn để giải quyết những tác vụ phổ biến: Python có một
số lượng lớn thư viện tiêu chuẩn giúp cho công việc lập trình của bạn trở nên dễ thở
hơn rất nhiều, đơn giản vì không phải tự viết tất cả code. Ví dụ: Bạn cần kết nối cơ sở
dữ liệu MySQL trên Web server? Bạn có thể nhập thư viện MySQLdb và sử dụng nó.
Những thư viện này được kiểm tra kỹ lưỡng và được sử dụng bởi hàng trăm người. Vì
vậy, bạn có thể chắc chắn rằng nó sẽ không làm hỏng code hay ứng dụng của mình.
Hướng đối tượng: Mọi thứ trong Python đều là hướng đối tượng. Lập trình
hướng đối tượng (OOP) giúp giải quyết những vấn đề phức tạp một cách trực quan.
Với OOP, bạn có thể phân chia những vấn đề phức tạp thành những tập nhỏ hơn bằng
cách tạo ra các đối tượng.
1.3.2. Thư viện Time

Thư viện Time trong Python cung cấp nhiều cách biểu diễn thời gian trong
code, chằng hạn như đối tượng, số, chuỗi… Thư viện này cũng cung cấp chức năng
khác ngoài việc đại diện cho thời gian như chờ đợi trong quá trình thực thi đoạn mã,
đo lường độ hiệu quả của mã.
Mặc dù thư viện này luôn có sẵn nhưng không phải tất cả các chức năng đều
có sẵn trên tất cả các nền tảng khác nhau. Hầu hết các hàm được định nghĩa trong thư
viện Time đều gọi các hàm thư viện nền tảng C có cùng tên. Đôi khi có thể hữu ích khi
tham khảo tài liệu nền tảng vì ngữ nghĩa của các chức năng này khác nhau giữa các
nền tảng.
Ngoài ra thư viện này còn cho phép tạm dừng việc thực thi mã của mình trong
một số giây nhất định. Điều này có thể hữu ích để tạo độ trễ hoặc tạm dừng trong
chương trình.
1.3.3. Thư viện Imple Object Oriented Graphics

Thư viện đồ họa hướng đối tượng đơn giản được thiết kế để giúp những người
mới lập trình có thể dễ dàng thử nghiệm đồ họa máy tính phương thức hướng đối

12
tượng. Thư viện này được viết bởi John Zelle để sử dụng cùng với cuốn sách " Python
Programming: An Introduction to Computer Science – Tạm dịch: Lập trình Python:
Giới thiệu về Khoa học máy tính" (Franklin, Beedle & Associates).
Thư viên này là phần mềm mã nguồn mở được phát hành theo các điều khoản
của GPL. Thư viện này là một trình bao bọc xung quanh Tkinter và sẽ chạy trên bất kỳ
nền tảng nào có Tkinter. Nguyên tắc sử dụng đặt tệp “graphics.py” nơi Python có thể
thấy.
Thư viện này chứa hai loại đối tượng trong thư viện. Lớp GraphWin triển khai
một cửa sổ nơi có thể thực hiện việc vẽ và cung cấp nhiều GraphicsObject khác nhau
để có thể vẽ vào GraphWin.
Các đối tượng được triển khai trong từ lớp GraphWin hỗ trợ chuyển đổi tọa độ
thông qua phương thức setCoords và các phương thức tương tác chuột và bàn phím.
Thư viện cung cấp các đối tượng đồ họa sau: Point (Điểm), Line (Đường),
Circle (Hình tròn), Oval (Hình bầu dục), Rectangle (Hình chữ nhật), Polygon (Đa
giác), Text (Văn bản), Entry (Nhập văn bản), Image (Hình ảnh).
Các thuộc tính khác nhau của các đối tượng đồ họa có thể được đặt như màu
đường viền, màu tô và độ rộng. Các đối tượng đồ họa cũng hỗ trợ di chuyển và ẩn nấp
để tạo hiệu ứng hoạt ảnh.

CHƯƠNG 2. ỨNG DỤNG THUẬT TOÁN DFS VÀO PACMAN

2.1. Thuật toán DFS tổng quát
2.1.1. Khái niệm.

Thuật toán DFS là một dạng thuật toán tìm kiếm trên đồ thị nút điểm hay cây.
Trong lý thuyết khoa học máy tính, thuật toán DFS nằm trong chiến lượng tìm kiếm
mù (tìm kiếm không có định hướng, không chú ý đến giá trị thông tin, giá trị được
duyệt).
Ý tưởng thuật toán triển khai thuật toán DFS cơ bản:
Duyệt xa nhất theo từng nhánh, khi nhánh đã duyệt hết, lùi về tìm và duyệt
những nhánh tiếp theo. Quá trình duyệt đỉnh chỉ dừng lại khi đã tìm thấy mục tiêu
hoặc khi đã duyệt qua hết tất cả các đỉnh

13
 2.1.2. Mô tả thuật toán DFS qua đồ thị.

Hình 2.1. Đồ thị mô tả thuật toán DFS

Đỉnh bắt đầu A.
Đỉnh kết thúc H.

Lần lặp Đỉnh Open Close

0 [A] []

1 A [B E F] [A]

2 B [C E F] [A B]

3 C [E F] [A B C]

4 E [D F] [A B C E]

5 D [G H F] [A B C E D]

6 G [H F] [A B C E D G]

7 H [F] [A B C E D G H]

14
 2.1.3. Ưu nhược điểm

Thuật toán DFS cho phép xét duyệt tất cacr các đỉnh rồi trả về kết quả. Nếu số
đỉnh là hữ hạn, thuật toán chắc chắn tìm ra kết quả. Tuy nhiên, DFS lại mang chính
chất vét cạn, nếu số đỉnh quá lớn có thể dẫn đến nhiều vấn đề. Ngoài ra, DFS không
chú ý đến thông tin các đỉnh để duyệt mà mù quáng duyệt tất cả nên có thể dẫn đến
việc duyệt các đỉnh không cần thiết
2.2. Áp dụng thuật toán vào dự án
2.2.1. Trạng thái xuất phát

Khởi tạo vị trí những nơi không thể va chạm và những nơi có thể di chuyển là
các node đồng thời kiểm tra các node kề với nhau để có thể tạo ra cây đồ thị cho Ghost
di chuyển trên khắp bản đồ để tìm kiếm và truy đuổi mục tiêu.
Đồng thời thiết lập vị trí xuất phát và kết thúc ban đều để có thể thiết lập giá
trị cơ bản cho trò chơi
2.2.2. Thiết lập DFS

Ý tưởng áp dụng giải thuật để sử dụng trong trò chơi được triển khai như sau.
Sau khi đã thiết lập các giá trị và node cơ bản, tiến hành sử dụng vòng lặp các giá trị từ
vị trí xuất phát ban đầu kiểm tra các node kề nhau có thể di chuyển.
Nếu node đó có thể di chuyển thì xác nhận node đó đã được kiểm tra và gán
vào tập giá trị Close. Sau khi gán xong giá trị kiếm tra xem node đó có phải là giá trị
kết thúc không, nếu phải thì kết thúc chương trình và trả lại giá trị đường đi cho đối
tượng Ghost để di chuyển.
Nếu như node đang xét không phải là giá trị kết thúc, tiền hành gán và gọi lại
giá trị node hiện tại làm node xét tiếp tục vòng lặp như vậy cho đến khi tìm ra được vị
trí kết thúc thì dừng.
Vì trò chơi Pacman có đối tượng Pacman tức vị trí kết thúc có thể di chuyển,
nên việc tìm kiếm dựa trên thuật toán DFS sẽ được khởi chạy liên tục để chạy tìm
kiếm khi đối tượng Pacman thay đổi vị trí.

15
 CHƯƠNG 3: TRIỂN KHAI HỆ THỐNG
3.1. Khởi tạo giá trị cơ bản
Khởi tạo tập tin và nhập các thư viện cần thiết cho việc lập trình và thiết kế trò
chơi bằng Python và thư viện ĐHHĐTCG.

Hình 3.1.1
Sau khi đã nhập các thư viện và tài nguyên cần thiết tiền hành tạo cửa sổ ứng
dụng được đặt tên là win có tên là ProjectPacman với kích thước là 500x500. Sau đó
đổ màu nền cho thông qua hàm setBackground bằng mã rgb có tham số là ba giá trị
255.

Hình 3.1.2
Tiếp theo đó tạo bản đồ bằng cách xây dựng các node tường giá trị dựa trên
các tập giá trị tọa độ (x, y) được xác định sẵn trong danh sách wallList sau đó tạo thêm
một danh sách rỗng để chứa các node trống có thể di chuyển và chứa các giá trị kề của
node trống đó.

Hình 3.1.3
Sau khi đã xây dựng các điểm cơ bản trên ma trận đồ thị vị trí (x, y) tiến hành
sử dụng vòng lặp để vẽ các hình vuông nối với nhau theo vị trí đã được đặt để hiển thị
tường cản lên trên cửa sổ màn hình hiển thị.

16
 Hình 3.1.4
Tạo biến startPoint toàn cục làm biến chứa dữ liệu tọa độ của điểm khởi đầu
cơ bản của của thuật toán DFS. Sử dụng biến toàn cục để có thể truy xuất dữ liệu sau
này giúp cho việc gán giá trị và thay đổi vị trí bắt đầu thuận tiện hơn.

Hình 3.1.5
Sau khi đã đặt biến toàn cục hoàn tất tiến hành thiết lập hình ảnh của đối
tượng Ghost trên cửa sổ hiển thị thông qua sử dụng hàm Circle sau đó truyền vào hai
tham số được tính toán theo công thức dựa trên giá trị tọa độ đã được xác định sau đó
đổ màu đỏ và vẽ lên cửa sổ hiển thị.

Hình 3.1.6
Tiếp tục tạo biến endPoint toàn cục làm biến chứa dữ liệu tọa độ của điểm kết
thúc cơ bản của của thuật toán DFS. Sử dụng biến toàn cục để có thể truy xuất dữ liệu
sau này giúp cho việc gán giá trị và thay đổi vị trí bắt đầu thuận tiện hơn.

Hình 3.1.7
Sau khi đã đặt biến toàn cục hoàn tất tiến hành thiết lập hình ảnh của đối
tượng Pacman trên cửa sổ hiển thị thông qua sử dụng hàm Circle sau đó truyền vào hai
tham số được tính toán theo công thức dựa trên giá trị tọa độ đã được xác định sau đó
đổ màu vàng và vẽ lên cửa sổ hiển thị.

17
Hình 3.1.8

18
 Tạo hàm đường dẫn sau khi tìm đường trong hệ thống DFS để gán các node
đường đi sau đó đưa cho đối tượng Ghost rồi di chuyển trong lưới đồ thị cửa sổ

Hình 3.1.9
Sau khi thiết kế khối môi trường cơ bản hoàn tất khi chạy chương trình ta sẽ
nhận được một chửa sổ chứa các vật thể và tường cản như sau.

Hình 3.1.10
3.2. Thiết lập môi trường cần thiết cho DFS
Khởi tạo hàm createAdjencyDict để kiểm tra tất cả các node trên bản đồ và để
phân loại chúng theo phân mục khác nhau bắt đầu với việc fởi tạo hai vòng lặp lồng
nhau chạy từ giá từ một tới mười một để chạy quay hết tất cả các node trong hệ thống
mạng lưới đồ thị trong cửa sổ hiển thị.

19
 Với mỗi lần kiểm tra một cặp giá trị vị trí trong hệ thống mạng lưới đồ thị
điểm này sẽ được gắn vào một biến point sau đó được mang đi để kiểm tra

Hình 3.2.1
Nếu node point này nằm trong danh sách tường chặn thì điểm node này sẽ
ngay lập tức được bỏ qua và kiểm tra điểm tiếp theo.

Hình 3.2.2
Nếu node point này không nằm trong danh sách tường chặn thì khởi tạo danh
sách giá trị node kề với bản thân node đó.

Hình 3.2.3
Sau khi khởi tạo danh sách giá trị node kề với node kiểm tra vị trí của node đó
nằm ở phía nào của node hiện tại đang kiểm tra. Sau khi đã kiểm tra được vị trí phía
của node đó thêm node đó vào danh sách giá trị node kề đã được khởi tạo ở phía trên
bằng cách tạo một biến tạm thời sau đó chèn giá trị vào danh sách với cú pháp insert().

20
 Hình 3.2.4
Khởi tạo hàm di chuyển cho đối tượng Pacman thông qua hàm moving() sau
đó gọi tới biến toàn cục endPoint đã được tạo trước ở trên cùng với biến key là giá trị
phím đươc nhận từ bàn phím khi nhấn phím.

Hình 3.2.5
Các phím di chuyển được xác định trước là phím mũi tên Right, Left, Up,
Down. Với mỗi phím khác nhau chúng sẽ được xây dựng thuật toán di chuyển khác
nhau. Bắt đầu với phím Up.
Khi nhấn phím Up đối tượng Pacman sẽ di chuyển lên trên bằng cách trừ đi
tọa độ y ban đầu đi 50 đơn vị, đồng thời cũng kiểm tra với các node trong khối tường
cản. Nếu giá trị sau khi di chuyển bị trùng với tường cản thì hủy bỏ giá trị di chuyển
bằng cách đẩy lùi lại giá trị di chuyển ban đầu. Ta có thể kiểm tra bằng cách xét vị trí
trung tâm của các đối tượng lập thể.

Hình 3.2.6
Khi nhấn phím Down đối tượng Pacman sẽ di chuyển xuống dưới bằng cách
tăng thêm tọa độ y ban đầu 50 đơn vị, đồng thời cũng kiểm tra với các node trong khối
tường cản. Nếu giá trị sau khi di chuyển bị trùng với tường cản thì hủy bỏ giá trị di
chuyển bằng cách đẩy lùi lại giá trị di chuyển ban đầu. Ta có thể kiểm tra bằng cách
xét vị trí trung tâm của các đối tượng lập thể.

Hình 3.2.7

21
 Khi nhấn phím Left đối tượng Pacman sẽ di chuyển sang trái bằng cách trừ đi
tọa độ x ban đầu đi 50 đơn vị, đồng thời cũng kiểm tra với các node trong khối tường
cản. Nếu giá trị sau khi di chuyển bị trùng với tường cản thì hủy bỏ giá trị di chuyển
bằng cách đẩy lùi lại giá trị di chuyển ban đầu. Ta có thể kiểm tra bằng cách xét vị trí
trung tâm của các đối tượng lập thể.

Hình 3.2.8
Khi nhấn phím Right đối tượng Pacman sẽ di chuyển sang phải bằng cách tăng
thêm tọa độ x ban đầu 50 đơn vị, đồng thời cũng kiểm tra với các node trong khối
tường cản. Nếu giá trị sau khi di chuyển bị trùng với tường cản thì hủy bỏ giá trị di
chuyển bằng cách đẩy lùi lại giá trị di chuyển ban đầu. Ta có thể kiểm tra bằng cách
xét vị trí trung tâm của các đối tượng lập thể.

Hình 3.2.9
Sau khi di chuyển tọa độ điểm kết thúc đã bị thay đổi ta đổi tọa độ của biến
toàn cục endPoint. Việc sử dụng biến toàn cục giúp việc thay đổi vị trí tọa độ dễ dàng
hơn mà không bị ảnh hưởng đến tọa độ vị trí khác.

Hình 3.2.10
Vì tọa độ vị trí kết thúc đã bị thay đổi nên khối đường đi cũng sẽ bị thay đổi
theo, nên toàn bộ đường đi ban đầu sẽ bị loại bỏ để hàm ìm đường đi DFS làm mới.

Hình 3.2.11

22
 3.3. Thiết lập thuật toán DFS
Thiết lập hàm dfs nhận vào hai tham số là node và target trong đó node là giá
trị node xét duyệt để tìm đường đi, target là giá trị đích tới. Bắt đầu khởi tại một biến
endReached có giá trị False để xác định có thể kết thúc vòng lặp tìm kiếm đường đi
hay chưa. Nếu có thể kết thúc tìm kiếm thì endReached sẽ có giá trị True.
Đầu tiên nó xác nhận node được truyền vào là node đã được ghé thăm trong hệ
thống danh sách nodeVisit rồi truyền tọa độ vị trí của node này vào cuối danh sách
path để lưu lại làm đường di chuyển.

Hình 3.3.1
Nếu giá trị tham số node truyền vào cùng vị trí với giá trị tham số target truyền
vào thì trả lại giá trị True để kết thúc việc tìm kiếm.

Hình 3.3.2
Sau khi đã kiểm tra tiến hành thực hiện một vòng lặp qua các điểm node kề
với node giá trị được tuyền vào. Node kề này được kiểm tra và thêm vào thông qua
hàm createAdjencyDict đã được gọi đến ở trên. Nếu lúc này giá trị endReached bằng
True thì ngắt vòng lặp.

Hình 3.3.3

23
 Nếu giá trị nodeVisit xét duyệt hiện đang là False gọi lại hàm đệ quy truyền
vào hai tham số là point tức điểm đang xét và giá trị target cũ để tái kiểm tra và thực
hiện lại các bước phía trên. Sau đó kiểm tra nếu như giá trị của endReached không
phải là True thì tiếp tục gán giá trị node này vào cuối danh sách path.

Hình 3.3.4
3.4. Thiết lập di chuyển đối tượng theo DFS
Gọi và tạo hàm moveGhost không nhận vào bất kỳ tham số nào. Hàm này sẽ
bắt đầu bằng việc truy cập gọi đến biến toàn cục startPoint để di chuyển và liên tục
làm mới vị trí bắt đầu.

Hình 3.4.1
Sau đó tạo vòng lặp số lượng các giá trị có trong danh sách path. Với mỗi lần
lặp lại dãn cách chúng đi 0.1s bằng cú pháp sleep của thư viện time đã nhập từ trước
để tạo ra hoạt ảnh di chuyển.

Hình 3.4.2
Với mỗi lần lặp tạo ra hai giá trị lưu trữ biến cell và cellBefore để trữ node xét
duyệt và node trước node đó phục vụ cho việc tính toán khoảng cách di chuyển.

Hình 3.4.3

24
 Tiếp tục tạo thêm hai biến changex và changey để tính toán khoảng cách di
chuyển mỗi lần lặp trong vòng lặp để sử dụng cho di chuyển đối tượng Ghost di
chuyển theo DFS đã được tạo trong danh sách path đã được tạo.

Hình 3.4.4
Thay đổi vị trí của đối tượng Ghost di chuyển theo danh sách path thông qua
mức di chuyển đã được tính toán và gắn vào giá trị của hai biến changex và changey
phía trên thông qua hàm move. Sau khi di chuyển thì gán giá trị biến startPoint bằng
với giá trị của ô node đã di chuyển tới đó.

Hình 3.4.5
3.5. Thiết lập vòng lặp thực hiện chính
Vòng lặp chính của game sẽ thực hiện theo cách gọi lại liên tục khi mà cửa sổ
game vẫn còn đang chạy với cú pháp while True. Đồng thời mỗi lần phải chạy sẽ làm
mới lại vị trí các node đã được kiểm tra cho mỗi lần tìm kiếm di chuyển DFS.

Hình 3.5.1
Thiết lập giá trị biến key lưu giữ lại giá trị phím được nhấn trên bàn phím sau
đó truyền vào cho hàm moving để di chuyển đối tượn Pacman. Sau đó di chuyển theo
hàm moveGhost để di chuyển theo dfs đã được thực hiện trong lệnh gọi hàm moving.

Hình 3.5.2

25
 KẾT LUẬN
Có thể thấy rằng thuật toán tìm đường có thể áp dụng vô cùng nhiều trong thời
đại hiện nay. Thuật toán DFS này chỉ là một phần cơ bản trong hệ thống thuật toán của
trí tuệ nhân tạo nhưng cũng đã cho thấy được sự ảnh hưởng quan trọng trong việc thiết
kế và sáng tạo của nhân loại.
Tuy nhiên chương trình hệ thống trên vẫn còn chưa được tối ưu và chưa được
tối ưu hóa hết hệ thống cơ bản của đề tài chẳng hạn như chưa thể thiết lập di chuyển
hai đối tượng Ghost và Pacman cùng một lúc vì thiếu hụt kỹ năng và độ hiểu biết cơ
bản.

26
 TÀI LIỆU THAM KHẢO
[1] GS. TS Từ Minh Phương, Giáo trình Nhập môn trí tuệ nhân tạo, Học viện
Công nghệ Bưu chính Viễn thông, 2014
[2] PGS. TS Đinh Mạnh Tường, Giáo trình Trí tuệ Nhân tạo. Khoa CNTT -
Đại học Quốc gia Hà Nội, 2006
[3] Python Software Foundation, time — Time access and conversions -
Python 3.12.0 documentation, 2023 Available at:
https://docs.python.org/3/library/time.html
[4] LeMaster Tech, plemaster01 - PythonPacman, 2022, Available at:
https://github.com/plemaster01/PythonPacman/tree/main

27