Đề tài Project 1 game rpg

TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI

VIỆN CÔNG NGHỆ THÔNG TIN VÀ TRUYỀN THÔNG

~~~~~~*~~~~~~

BÁO CÁO
BÀI TẬP LỚN MÔN HỌC
PROJECT I
Giảng viên hướng dẫn
Sinh viên thực hiện

: ThS.

Trịnh Thành Trung

: Đỗ Khắc Linh -20132259
Nguyễn Đức Long-20132374
Trần Văn Lộc-20132437
Ngô Đức Nhật-20132860
Phạm Thu Nga-20132739

Hà Nội – Tháng 12/2015
1


2


Mục lục
Danh sách hình vẽ .................................................................. Error! Bookmark not defined.

LỜI CÁM ƠN .......................................................................................................................... 3
GIỚI THIỆU CHUNG................................................................................................................ 4
I.

Tổng quan về các kiến thức liên quan .............................................................................. 6
1.

Mô hình lập trình hướng đối tượng ............................................................................ 6

2.

Giới thiệu về chủ đề bài tập lớn – Trò chơi game nhập vai ..................................... 11

II. Phân tích thiết kế mức kiến trúc ..................................................................................... 13
1.

Biểu đồ USE – CASE .............................................................................................. 13

2.

Biểu đồ lớp ............................................................................................................... 15

III. Thiết kế chi tiết và giải pháp kỹ thuật ............................................................................. 18
1.

Thiết kế chi tiết các lớp ............................................................................................ 18

IV. Kết luận và đánh giá ....................................................................................................... 28
V. Tài liệu tham khảo .......................................................................................................... 28

LỜI CÁM ƠN
Chúng em là những sinh viên Công nghệ thông tin, nhưng hai năm học qua,
chúng em chưa thực sự hiểu sâu về ngành, chưa có những nhận thức đúng đắn về
ngành mà mình học, chỉ nghĩ học công nghệ thông tin chỉ cần lập trình giỏi. Khi
3


tham gia môn học Hướng đối tượng, được sự hướng dẫn của thầy Trịnh Thành
Trung và tham gia làm đồ án môn học, chúng em đã học tập được rất nhiều kĩ
năng: kĩ năng làm việc nhóm, kĩ năng báo cáo, kĩ năng lập trình…và quan trọng
hơn hết là hiểu rõ hơn về một quy trình làm phần mềm. Trong quá trình làm đồ án,
còn có nhiều sai sót và chúng em xin hứa sẽ cố gắng để hoàn thiện chương trình
hơn. Chúng em xin gửi lời cám ơn đến thầy Trịnh Thành Trung đã dạy và giúp đỡ
chúng em hoàn thiện đồ án này.

GIỚI THIỆU CHUNG
Mục đích khi thực hiện bài tập lớn
Công nghệ thông tin, từ khi xuất hiện tới hiện tại đã phát triển qua nhiều
giai đoạn, với những sự đột phá về cả phần cứng lẫn phần mềm. Đặc biệt là sự
4


phát triển của phần mềm gắn với những bước phát triển của các mô hình lập trình
(Programming paradigm), đó là các mô hình: lập trình thủ tục (Procedural
progaramming), lập trình hướng đối tượng (object – oriented programming, lập
trình logic ( logic programming), lập trình hàm (functional programming)… Trong
đó, mô hình lập trình hướng đối tượng đang là mô hình lập trình được sử dụng
rộng rãi nhất. Chính từ thực tiễn đó, đòi hỏi mỗi người sinh viên ngành công nghệ
thông tin phải nắm chắc tất cả kiến thức, nội dung và các kỹ thuật của mô hình lập
trình này, đổng thời áp dụng mô hình lập trình này để tạo ra các ứng dụng mạnh

mẽ, mang tính thực tiễn cao, nâng cao phong cách và kỹ thuật lập trình để đủ khả
năng tiếp tục tiến lên trong hành trình khám phá thế giới công nghệ thông tin của
chính bản thân sinh viên.
Mục đích khi thực hiện bài tập lớn này của chúng em là để tìm hiểu các
kiến thức về lập trình hướng đối tượng, đồng thời sử dụng những kiến thức đã học
được để xây dựng một chương trình theo mô hình lập trình hướng đối tượng.
Chương trình chúng em chọn để thực hiện là trò chơi xây tháp canh( Tower
Defense).
Phạm vi kiến thức tìm hiểu:
- Các nội dung, kỹ thuật của lập trình hướng đối tượng.
- Cách xây dựng một chương trình bằng mô hình lập trình hướng đối
tượng.
- Cách để thiết kế và xây dựng nên một trò chơi với kiến trúc tốt, có khả
năng sửa lỗi, thay đổi và mở rộng.
Phương pháp thực hiện bài tập lớn:
- Nắm chắc các kiến thức và các kỹ thuật mà giảng viên đã truyền đạt trên
lớp, đồng thời thực hành các nội dung đó nhiều lần qua các bài tập và trong
chính quá trình thực hiện bài tập lớn để thực sự hiểu và sử dụng hiệu quả.
- Tham khảo thêm các kiến thức trên Mạng, các cuốn sách về lập trình, học
hỏi kinh nghiệm từ các anh chị khóa trên để mở rộng hiểu biết về lập trình
hướng đối tượng.
- Tham khảo các bài tập lớn, các chương trình mã nguồn mở từ trên mạng
để hiểu được cách thiết kết và lập trình một ứng dụng trong thực tế, từ đó
học hỏi và áp dụng những gì đã học vào thực hiện bài tập lớn.
- Học tập cách làm việc nhóm, cách phân chia công việc cho các thành viên
trong nhóm sao cho mỗi thành viên độc lập trong nhiệm vụ, nhưng thống
5


nhất trong hành động và phát huy được các thế mạnh và khả năng của mỗi

thành viên trong quá trình thực hiện bài tập lớn.
-Thực hiện bài tập lớn theo quy trình, các bước các giai đoạn chung trong
phát triển một phần mềm, tuân thủ đúng các quy tắc, không chạy theo tiến
độ mà đốt cháy giai đoạn.

I.

Tổng quan về các kiến thức liên quan

1.
1.1.

Mô hình lập trình hướng đối tượng
Lập trình hướng đối tượng là gì?

Lập trình hướng đối tượng là một trong những mô hình lập trình được sử
dụng phổ biến nhất hiện nay. Nó là một mô hình lập trình có sự kế thừa và phát
triển từ các mô hình lập trình trước đó, sự phát triển của nó gắn liền với quá trình
6


trừu tượng hóa trong lập trình. Nếu như lập trình assembly là sự trừu tượng hóa
mã máy(mã nhị phân) thành các chỉ thị điều khiển và các kiểu dữ liệu cơ bản, thì
lập trình thủ tục là sự trừu tượng hóa các chỉ thị và kiểu dữ liệu trên thành các
trạng thái và các câu lệnh điều khiển thay đổi trạng thái, rồi trừu tượng hóa lập
trình lên một mức cao hơn nữa, đó là chia chương trình thành các chức năng nhỏ,
rồi các chức năng đó lại được chia thành các chức năng nhỏ hơn. Khi đó mỗi công
việc sẽ được thực hiện bởi một đơn vị, được gọi là hàm(hay thủ tục). Chương trình
thực hiện là sự thực hiện tuần tự của các hàm để xử lý và biến đổi dữ liệu theo các
luồng điều khiển, chính vì vậy tư tưởng của lập trình hàm là ”chương trình = cấu

trúc dữ liệu + giải thuật”. Chúng ta có thể thấy, ở lập trình hàm có sự trừu tượng
hóa lên tới một mức rất cao, phù hợp với nhiều bài toán thực tiễn, do đó mô hình
lập trình này đã từng là mô hình lập trình chủ yếu trong một thời gian dài. Tuy
nhiên với sự mở rộng ngày càng lớn về quy mô và độ phức tạp của chương trình
ngày càng lớn, thì lập trình hướng đối tượng bộc lộ nhược điểm của mình khi tách
rời giữa dữ liệu và xử lý. Khi đó, lâp trình hướng đối tượng ra, tiếp tục nâng cao
mức độ trừu tượng hóa, sử dụng khái niệm mới – đối tượng, để chỉ sự trừu tượng
hóa dữ liệu, tức là với mỗi dữ liệu nhất định sẽ đi liền với các cách thức để xử lý
với dữ liệu đó, và khi đó dữ liệu cùng với các phương thức xử lý dữ liệu đó được
đóng gói lại thành một thực thể, được gọi là đối tượng. Tư tưởng của lập trình
hướng đối tượng được Alan Kay trình bày như sau:
-

Tất cả đều là đối tượng
Chương trình phần mềm có thể coi là một tập hợp các đối tượng tương tác
với nhau
Mỗi đối tượng trong phần mềm đều có dữ liệu độc lập của mình và chiếm
bộ nhớ riêng cho mình.
Mỗi đối tượng đều có dạng đặc trưng của lớp các đối tượng đó
Tất cả các đối tượng thuộc cùng một lớp đều có hành vi giống nhau

Mô hình lập trình hướng đối tượng có thể hiểu là sự trừu tượng hóa bài toán
thành các đối tượng và tương tác giữa các đối tượng đó, trong đó các đối tượng là
một sự đóng gói của các thuộc tính và các phương thức xử lý trên các thuộc tính
đó.
Các nguyên lý cơ bản của lập trình hướng đối tượng

1.2.

Lập trình hướng đối tượng gồm 4 nguyên lý cơ bản như sau:

-

Nguyên lý trừu tượng hóa:

7


-

-

-

+ Trừu tượng hóa là quá trình loại bỏ đi thông tin cụ thể và giữ lại những
thông tin chung, trong đó tập trung vào các đặc điểm cơ bản của một loại
thực thể, giúp phân biệt giữa thực thể đó với các loại thực thể khác
+ Trừu tượng hóa là quá trình thực hiện khi mô tả các thực thể ngoài thực
tiễn vào trong bài toán, khi đó người lập trình sẽ quyết định những gì là
quan trọng và những gì là không quan trọng trong bài toán. Do đó trừu
tượng hóa phụ thuộc vào yêu cầu của bài toán đối với đối tượng , tức là
quá trình trừ tượng hóa phụ thuộc vào góc nhìn.
Nguyên lý đóng gói:
+ Đóng gói là quá trình che giấu, ẩn đi các chi tiết thực hiện bên trong (dữ
liệu và các phương thức private). Khi thực hiện đóng gói, người sử dụng
đối tượng sẽ không thể thấy tất cả các thuộc tính và phương thức bên trong
đối tượng, mà sẽ sử dụng đối tượng thông qua một giao diện do người viết
lớp thiết lập.
+ Đóng gói cho phép người thiết kế lớp có thể bảo vệ dữ liệu của mình
thông qua việc kiểm soát những gì mà người dùng ở bên ngoài có thể truy
cập vào đối tượng. Đồng thời nguyên tắc đóng gói cho phép thay đổi thiết

kế bên trong của lớp nhưng không làm ảnh hưởng tới những người sử
dụng các đối tượng của lớp đó, trong trường hợp giao diện của lớp không
bị thay đổi.
Nguyên lý Module hóa:
+ Module hóa là quá trình người sử dụng chia hệ thống thành các đơn vị
chức năng, các đơn vị này có tính độc lập với nhau, được kết nối với nhau
để tạo thành hệ thống hoàn chỉnh.
+ Nguyên lý module được sử dụng giúp chia nhỏ hệ thống phức tạp thành
các thành phần nhỏ hơn, đơn giản hơn. Đồng thời trong quá trình thiết kế
và triển khai hệ thống, nguyên lý mô đun giúp phân chia công việc một
cách hiệu quả, đồng thời cho phép người sử dụng dễ dàng nâng cấp, bảo
trì, sửa lỗi hệ thống, và kiểm soát được tiến độ và chất lượng của các thành
phần trong hệ thống.
Nguyên lý phân cấp
+ Nguyên lý phân cấp là quá trình người lập trình sắp xếp mức độ trừu
tượng hóa của các đối tượng vào một cấu trúc cây. Hệ thống có thể được
phân cấp bằng nhiều cách khác nhau, tùy yêu cầu của người thiết kế, như
phân cấp kết tập, phân cấp lớp, phân cấp phạm vi, phân cấp kế thừa, phân
cấp thành phần…
+ Quá trình phân cấp giúp cho người lập trình thiết kế hệ thống một cách
khoa học, tránh được sự dư thừa không cần thiết, và cả các lỗi có thể phát
sinh từ sự dư thừa đó, đồng thời cho phép người lập trình tái sử dụng các
8


thành phần chung. Quá trình phân cấp còn giúp cho hệ thống trở nên gọn
nhẹ, chặt chẽ, hiệu quả và dễ dàng quản lý, nâng cấp và sửu chữa..
Phân tích thiết kế hướng đối tượng

1.3.

Phương pháp luận (methodology) trong PT&TK phần mềm thông thường
được định nghĩa như là một tập các quá trình và thao tác để tìm và khám phá cách
có thể giải quyết được bài toán phần mềm. Phân tích thiết kế hướng đối tượng là
một trong những phương pháp luận hiệu quả nhất để phá triển phần mềm.
Phương pháp phân tích thiết kế hướng đối tượng gồm có sáu giai đoạn:
-

Giai đoạn 0: Lập kế hoạch (make a plan)
Giai đoạn 1: Xác định mục tiêu - làm gì (what are we making)
Giai đoạn 2: Xác định cách làm thế nào (how to build it)
Giai đoạn 3: Xây dựng phần lõi - Building the core
Giai đoạn 4: Lặp lại (hiệu chỉnh) các trường hợp sử dụng
Giai đoạn 5: Phát triển (evolution)

1.3.1 Lập kế hoạch
Ở giai đoạn lập kế hoạch, chúng ta cần xác định những gì cần thiết để bắt
đầu dự án, các yếu tố đầu vào, đầu ra cơ bản của dự án như:
-

-

Các mốc thời gian quan trọng trong dự án: Ngày bắt đầu, lịch làm việc, các
mốc thời gian nhận, và trả nhiệm vụ, các thời hạn chót cho mỗi phần công
việc, thời điểm bắt đầu dự án.
Các nguồn lực về vốn đầu tư cho dự án
Các nguồn lực về con người cho dự án: Số lượng thành viên, trình độ của
các thành viên trong dự án.
Mục tiêu đề ra khi thực hiện dự án, các yêu cầu đặt ra khi dự án được hoàn
thành

Các đầu vào khác trong dự án: Công nghệ sẽ áp dụng trong dự án, phạm vi
triển khai của dự án, các đối tác tham gia phát triển với dự án, các phương
án dự trù trong tương lai cho dự án ...

1.3.2 Xác định mục tiêu
Trong giai đoạn này, chúng ta có nhiệm vụ xác định cụ thể các mục tiêu,
chức năng và nhiệm vụ mà phần mềm chúng ta xây dụng phải đáp ứng.
Để xác định mục tiên, chúng ta cần tiến hành phân tính yêu cầu và mô tả
của hệ thống bằng việc sử dụng các ký pháp và kỹ thuật Use case để mô tả các yêu
cầu trên
9


1.3.3 Xác định cách làm như thế nào
Sau khi xác định được mục tiêu, ta cần xác định những phương pháp và
những phương tiện để thực hiện các mục tiêu đó, rồi tìm cách giải quyết bài toán
đặt ra bằng mô hình lập trình hướng đối tượng.
Trong giai đoạn này, nhiệm vụ của người lập trình là tìm kiếm trình tự các
công việc phải làm để thực hiện các yêu cầu đã được mô tả ở phần Biểu đồ use
case, từ đó xây dựng lên biểu đồ trình tự cho bài toán, từ đó xây dựng kiến trúc cơ
bản cho toàn bộ bài toán đặt ra. Sau khi đã xây dựng được phần kiến trúc, chúng ta
tiến hành tìm kiếm và xây dựng các đối tượng có mặt trong thiết kế đó, với các
thuộc tính và phương thức mà kiến trúc yêu cầu. Bước xây dựng các đối tượng này
đi liền với việc phát hiện các đối tượng có chung một nguyên mẫu( tức là có
chung các kiểu thuộc tính và chung hành động) từ đó tiến hành phát triển và xây
dựng các lớp của các đối tượng có trong hệ thống.
Việc phát hiện, mô tả và xây dựng đối tượng tuân thủ theo 5 bước sau đây:
-

-

-

-

Phát hiện đối tượng (Object discovery). Bước này được thực hiện ở giai
đoạn phân tích chương trình. Chúng ta phát hiện các đối tượng nhờ các
yếu tố bên ngoài và các đặc điểm bên ngoài
Lắp ráp đối tượng (Object assembly). Bước tìm kiếm các đặc điểm của đối
tượng để thêm vào các thuộc tính, các hàm thành phần cho đối tượng.
Xây dựng hệ thống (System construction). Trong giai đoạn này chúng ta
phát triển các đối tượng, xem xét các tương tác giữa các đối tượng để hình
thành hệ thống hoạt động.
Mở rộng hệ thống (System extension). Khi chúng ta thêm vào các tính
năng của hệ thống, chúng ta cần thêm các lớp mới, các đối tượng mới và
các tương tác giữa các đối tượng này với các đối tượng đã có trong hệ
thống.
Tái sử dụng đối tượng (Object reuse). Đây là một trong những thử nghiệm
quan trọng của các đối tượng và lớp trong thiết kế phần mềm. Chúng ta
cần phải sử dụng lại các lớp và các đối tượng trong phần mềm (thông qua
tính kế thừa và tương tác giữa các đối tượng)
Trong khi phát hiện và triển khai các lớp, cần lưu ý các đặc điểm sau đây:

-

Chúng ta cần phân biệt rõ việc tạo ra lớp, sau đó mới nghĩa tới việc phát
triển và hoàn thiện lớp trong quá trình giải quyết bài toán
Việc phát hiện ra các lớp cần thiết cho chương trình là một trong những
nhiệm vụ chính của thiết kế hệ thống, nếu chúng ta đã có những lớp này
(trong một thư viện lớp nào đó chẳng hạn) thì công việc sẽ dễ dàng hơn

10


-

-

-

Khi phân tích hay phát triển các lớp không nên tập trung vào để biết tất cả
về một lớp, chúng ta sẽ biết tất cả các thuộc tính này khi phát triển hệ
thống (learns as you go)
Khi tiến hành lập trình cần tuân thủ theo các thiết kế đã làm. Không nên
băn khoăn rằng chúng ta sẽ không sử dụng phương pháp lập trình truyền
thống và cảm thấy choáng ngợp trước số lượng lớn các đối tượng.
Luôn luôn giữ nguyên tắc: mọi vấn đề cần giải quyết theo phương án đơn
giản nhất, không nên phức tạp hóa. Sử dụng nguyên lý của Occam Razor:
Lớp đơn giản nhất bao giờ cũng là lớp tốt nhất, hãy bắt đầu bằng những
cái đơn giản và chúng ta sẽ kết thúc bằng những hệ thống phức tạp

Trong quá trình xác định cách làm, thì việc tìm kiếm, phát hiện và xây
dựng các lớp và các đối tượng là đi liền và có mối quan hệ chặt chẽ với nhau. Việc
phát hiện các đối tượng trong hệ thống giúp ta xác định được các thực thể, từ các
thực thể đó chúng ta tìm kiếm và xây dựng các lớp chứa thực thể đó, đồng thời
trừu tượng và phân cấp các lớp dựa trên sơ đồ đối tượng. Việc phát hiện đối tượng
còn giúp cho việc tìm kiếm các thuộc tính và các phương thức của các lớp, còn
việc phát triển các lớp giúp cho việc phân nhóm, phân cấp các đối tượng, Một
cách tổng quát, khi xác định cách làm cho hệ thống, chúng ta cần tìm được các đối
tượng có trong hệ thống để giải quyết các yêu cầu của bài toán, sau đó chúng ta
thiết kế và xây dựng các lớp cho các đối tượng đã nói ở trên, đồng thời tạo ra các

đối tượng mới thông qua các lớp đã phát triển.
Trong quá trình xây dựng và phát triển các lớp, ta sử dung thẻ tương tác
CRC để thể hiện thông tin của các lớp

1.3.4 Xây dựng phần lõi
Ở giai đoạn này, từ kiến trúc ta đã xây dựng được ở phần 2, ta tiến hành
hiện thực hóa kiến trúc ấy trên môi trường lập trình thực tế.
Việc xây dựng phần lõi yêu cầu thực hiện đúng các thiết kế, đồng thời đảm
bảo phần lõi hệ thống có khả năng kết nối tốt, trở thành trung tâm gắn kết các mô
đun còn lại trong hệ thống, đảm bảo cho hệ thống vận hành ổn định, và cung cấp
khả năng thay đổi, mở rộng và phát triển cho hệ thống.
Việc xây dựng phần lõi hệ thống cần phải thực hiện một cách cẩn thận, ít
sai sót, do ảnh hưởng từ phần lõi của hệ thống tới các phần còn lại trong hệ thống
là rất lớn. Bên cạnh đó, việc xây dựng phần lõi của hệ thống còn đòi hỏi người lập

11


trình phải thiết lập được các chuẩn kết nối giữa các mô đun của hệ thống với nhau,
thống qua việc kết nối các mô đun với phần lõi của hệ thống.
1.3.5 Lặp lại, hiệu chỉnh các trường hợp sử dụng
Ở giai đoạn này ta triển khai chi tiết hệ thống trên cơ sở phần lõi đã được
thiết kế, sao cho hệ thống của chung ta giải quyết được các vấn đề đặt ra khi
chúng ta xây dựng biểu đồ use case. Các ca sử dụng trong biểu đồ use case được
triển khai trong hệ thống thành các đối tượng và các tương tác giữa chúng, sao cho
sau tập hợp các tương tác đó, thì yêu cầu được đáp ứng.
Đồng thời trong quá trình triển khai các ca sử dụng trên hệ thống, nếu môi
trường thực hiện các trường hợp sử dụng có thay đổi(yêu cầu thay đổi, hoặc khả
năng đáp ứng của hệ thống khác với yêu cầu đặt ra ban đầu khi thiêt kế) thì chúng
ta sẽ phải hiện chỉnh lại các trường hợp sử dụng sao cho phù hợp với các đặc điểm

và khả năng mà hệ thông của chúng ta đáp ứng được.
1.3.6 Phát triển
Ở giai đoạn này, khi mà chúng ta đã triên khai xong thiết kế chi tiết của hệ
thống để giải quyết các yêu cầu đặt ra, chúng ta đi vào hoàn thiện chi tiết hệ thống.
Đây là giai đoạn mà người lập trình triển khai trên một môi trường thực tế các
thiết kế của những phần trước, kế hợp các bước lập trình, kiểm thử, sửa lỗi để
hoàn thiện hệ thống. Đồng thời trong quá trình phát triển, có thể mở rộng thêm hệ
thống để đáp ứng các nhu cầu mới.

Giới thiệu về chủ đề bài tập lớn – Trò chơi game nhập vai
Với những nền tảng kiến thức đã tiếp thu được như trên, nhóm chúng em đã
đề xuất chủ đề cho bài tập lớn là trò chơi game nhập vai.

2.

2.1.

Nội dung trò chơi

Trên màn hình trò chơi, sẽ có map có nhân vật do người chơi điều khiển và
những quái vật di chuyển trên đó. Người chơi sẽ sử dụng có phím để di chuyển và
các nút để tấn công quái. Mỗi lần người chơi tiêu diệt được một con quái vật sẽ
được cộng một lượng kinh nghiệm tương ứng, Trong lúc tấn công quái vật thì quái
vật cũng tấn công nhân vật làm cho nhân vật bị trừ một lượng máu nhất định. Khi
người chơi tiêu diệt một lượng quái nhất định trên bản đồ thì sẽ xuất hiện 1 điểm
dịch chuyển để người chơi có thể di chuyển sang 1 map mới. Khi người chơi đi
hết 3 map sẽ chiến thắng. Nếu người chơi hết máu thì người chơi sẽ thua. Trò chơi
kết thúc khi cả người chơi thắng hoặc thua.
12

Những điểm quan trọng trong trò chơi
Yêu cầu cơ bản đối với trò chơi

2.2.
2.3.

Xây dựng được một trò chơi đáp ứng được nội dung của trò chơi, đảm bảo
trò chơi cho phép người chơi thực hiện các thao tác sau:
-

-

-

-

Chức năng chơi game: Cho phép người chơi lựa chọn chức năng chơi
game thông qua việc chọn vào nút “ Start” trong menu mở đầu hoặc có thể
là xem chi tiết về trò chơi thông qua việc chọn nút “About”, xem thông tin
về điểm cao thông qua nút “High score”. Người chơi có thể chọn “Quit” để
thoát khỏi trò chơi.
Sau khi người chơi chọn “Start” để vào game thì sẽ tiến hành nạp map và
quái vật, cho phép người chơi chơi trò chơi ở trạng thái chơi game của trò
chơi. Ở trạng thái chơi game, người chơi có thể nhìn toàn bộ map, toàn bộ
quái vật di chuyển trên map và các vật cản không cho người chơi đi qua.
Người chơi cũng nhìn thấy các chỉ số của nhân vật và quái ở bên tay phải
màn hình. Trong phần tương tác với trò chơi, cho phép người chơi di
chuyển trên bản đồ ở những đường đi không có vật cản. Người chơi sẽ di
chuyển trên bản đồ, người chơi sẽ bị tấn công khi gặp chạm mặt quái(đối

với quái đánh gần) hoặc nằm trong tầm đánh của quái đánh xa, khi bị tấn
công người chơi sẽ mất máu.
Chức năng chuyển map: Khi người chơi đánh chết 1 số lượng quái nhất
định thì cửa dịch chuyển sẽ hiện ra, cho phép người chơi có thể di chuyển
sang map mới. Khi người chơi di chuyển hết các map sẽ thắng
Chức năng xem thông tin về trò chơi: Cho phép người chơi xem thông tin
về trò chơi, nhóm phát triển…
Chức năng kết thúc trò chơi: Kết thúc chương trình.

13


II.

Phân tích thiết kế mức kiến trúc

1.

Biểu đồ USE – CASE

1.1.

Xây dựng biểu đồ use-case từ các yêu cầu đặt ra

Hình 1: biểu đồ usecase cho trò chơi game nhập vai

1.2.

Phân tích biểu đồ use-case và xây dựng kiến trúc hệ thống
Từ biểu đồ đã được thiết kế ở phần trên, ta tiến hành phân tích hệ thống.

Biểu đồ usecase ở trên cho thấy, mỗi yêu cầu của người dùng được cụ thể
hóa thành một chức năng của hệ thống. Ở trong hệ thống thì các chức năng này
được thực hiện trong các trạng thái(màn hình) của hệ thống, với các màn hình sau
:
14


-

Màn hình Menu: Xuất hiện khi khởi động trò chơi, cho phép người chơi
chuyển tới các chức năng chính của hệ thống:
+ Màn hình chơi của trò chơi.(Start)
+ Màn hình xem High score.(High score)
+ Màn hình xem thông tin về trò chơi.(About)

-

Màn hình xem thông tin về trò chơi cho phép người chơi xem thông tin về
trò chơi.
Màn hình xem High score cho phép người chơi xem thông tin điểm cao
của những người chơi trước.
Màn hình chơi game: Xuất hiện sau khi người chơi ấn nút Start, màn hình
sẽ xuất hiện 1 map. Trên đó, sẽ xuất hiện 1 nhân vật do người chơi điều
khiển(di chuyển và tấn công), và quái vật(di chuyển và tấn công người
chơi khi nằm trong tầm đánh). Khi đánh hết 1 lượng quái nhất định sẽ di
chuyển sang map khác.

Từ các phân tích trên, chúng ta có thể thấy rằng, trong trò chơi tồn
tại nhiều trạng thái( màn hình) khác nhau, tương ứng với các chức năng khác

nhau. Các trạng thái này tuy thực hiện các chức năng khác nhau, có nội dung
khác nhau, bao gồm các đối tượng khác nhau, nhưng có những điểm chung
sau:
-

-

Các màn hình này cần phải thực hiện được các yêu cầu cơ bản như: hiển
thị nội dung lên màn hình máy tính, cho phép người chơi tương tác thông
qua chuột và máy tính và xử lý các tương tác đó.
Các màn hình này phải có khả năng chuyển đổi qua lại giữa các màn hình
với nhau.
Các màn hình này phải có khả năng tạo ra chuyển động của các đối tượng
theo thời gian.

Từ những điều ở trên, nhóm đã quyết định sử dụng xây dựng kiến trúc
module cho hệ thống này. Kiến trúc này được thiết kế như sau:
-

Module lõi của hệ thống là module quản lý game (GameStateManager).
Module này có các nhiệm vụ sau:
+ Thiết lập môi trường chạy hệ thống (đồ họa, âm thanh, bộ nghe sự
kiện).

15


+ Thiết lập phương thức hoạt động cho hệ thống (vòng lặp game, các
biến kiểm tra trạng thái game, biến kiểm soát tốc độ các đối tượng trong
game...)

-

+ Cung cấp cho các trạng thái game các phương tiện để triển khai nội
dung của trạng thái game: Cung cấp đối tượng đồ họa, inputListener,
biến kiểm soát tốc độ theo thời gian delta, các phương thức kiểm soát
trạng thái game ...
+ Quản lý danh sách trạng thái game có trong hệ thống, thiết lập trạng
thái game được lựa chọn để thể hiện ra màn hình người chơi ở thời
điểm hiện tại, chuyển đổi trạng thái hiện tại sang các trạng thái game
khác.
Các màn hình game trong trò chơi được thiết kế thành các module chính,
các module này sẽ ghép nối vào module lõi( module lõi sẽ quản lý danh
sách các module này). Các module này có các nhiệm vụ sau:
+ Xây dựng nội dung của module đó theo chức năng của module
+ Sử dụng các thành phần mà module lõi cung cấp cho các trạng thái
game để thực hiện các công việc: vẽ hình ảnh lên màn hình bằng đối tượng
đồ họa được cung cấp, cập nhật các đối tượng theo thời gian delta mà
module lõi cung cấp cho nó.
+ Sử dụng các phương thức của module lõi để chuyển sang màn hình
game khác hoặc thay đổi trạng thái hiện tại của trò chơi ( tạm dừng, tiếp tục
hay kết thúc trò chơi….).

Sau khi đã thiết kế được kiến trúc cho trò chơi, chúng ta sẽ triển khai biểu đồ use
case thành biểu đồ trình tự dựa trên kiến trúc được thiết kế
2.

Biểu đồ lớp
Biểu đồ lớp cho toàn bộ hệ thống.

16


Hình 7: Biểu đồ lớp cho GameState

17


Hình 2: Biểu đồ lớp cho 1 giao diện trò chơi

18


Hình 3: Biểu đồ lớp cho Enemy

III.
1.

Thiết kế chi tiết và giải pháp kỹ thuật
Thiết kế chi tiết các lớp

19


-

Lớp GameState

Là lớp trừu tượng cho các cho các lớp sau kế thừa
 Lớp MenuState

Các thuộc tính:
private imge menustate : là icon ảnh của button.
private image diamond: là icon chỉ lúc chọn.
private int curentOption : là chỉ đánh dấu nhận dạng đang ở vị trí
của menu state.
Các phương thức:
public void init():dùng để load ảnh.
public void update() :update trạng thái của đối tương.
public void draw(Graphics2D): dùng để vẽ hình ảnh đã load.
private void selectOption(): dùng chọn chuyển sang mà hình tiếp
theo sau khi chọn.

20


private void selectOption() {
if (currentOption == 0) {
gsm.setState(GameStateManager.PLAY);
}
if (currentOption == 1) {
gsm.setState(GameStateManager.ABOUTSTATE);
}
if (currentOption == 2) {
gsm.setState(GameStateManager.HIGHSCORE);
}
if (currentOption == 3) {
System.exit(0);
}
}

 Lớp Highscore và lớp About đều kế thừa từ lớp GameState. Và có
các phương thức tương tự như lớp MenuState.

-

Class: InterfaceGame

Các thuộc tính:
private Image background: chứa hình ảnh nền cho giao diện.
private Image port0: chưa hình ảnh của điểm dịch chuyển.
Các phương thức:
 Int(): load ảnh cho toàn bộ map.
 Update(): Cập nhập trạng thái cho toàn bộ map.

21


 Checkscore(): Kiểm tra điểm nếu đủ 1 số lượng điểm nhất định
sẽ qua map.
public void checksocre() {
if (robot.getScore() == 5 && robot.getcenterX() < 100 &&
robot.getcenterY() > 400) {
gsm.setState(2);
}
}
 Draw(Graphics): vẽ các hình ảnh lên map.
public void draw(Graphics2D g2) {
g2.drawImage(background, 0, 0, null);
g2.drawImage(huyhieu, 1150, 0, null);
for (int i = 0; i < arraytile.size(); i++) {

Tile t = arraytile.get(i);
g2.drawImage(t.getImage(), t.getTlx(), t.getTly(), null);
g2.drawRect((int)t.getRectangle().getX(),(int)t.getRectangle().getY(),
(int)t.getRectangle().getWidth(), (int)t.getRectangle().getHeight());
}
if (robot.getScore() == 5) {
g2.drawImage(port0, 100, 500, null);
}
robot.paint(g2);
enemygirl.paint(g2);
enemybone1.paint(g2);
enemybone2.paint(g2);
enemyspider1.paint(g2);
enemyspider2.paint(g2);
enemyeagle.paint(g2);
enemyeagle2.paint(g2);
}
 keyType(), keyPressed(), keyArratile(), keyType(): dùng để lắng
nghe các sự kiện nhập từ bàn phím.
public void keyPressed(KeyEvent e) {
switch (e.getKeyCode()) {
case KeyEvent.VK_RIGHT:
22


robot.moveRight();
break;
case KeyEvent.VK_LEFT:
robot.moveLeft();
break;

case KeyEvent.VK_UP:
robot.movetop();
break;
case KeyEvent.VK_DOWN:
robot.movebottom();
break;
case KeyEvent.VK_SPACE:
robot.shoot();
break;
}
robot.setmove(true);
}

-

Class: Robot

23


-

Các thuộc tính:
speedX,speedY: tốc dộ di chuyển trên map của nhân vật
centerX,centerY: tọa độ chảu nhân vật trên bản đồ.
Health: máu của nhân vật.
Rect,rect2: vẽ hình chữ nhật xét va chạm
Score : điểm của người chơi.
Các phương thức:
ImageHealth(): load ảnh thanh máu của nhân vật khi bị tấn công.

moveLeft(), moveRight(),movebottom(),moveRight(): phương thức di
chuyển của nhân vật
stop(): trạng thái dừng của nhân vật.
shoot(): phương thức tấn công của nhân vật.
Class Tile

Các thuộc tính:
Tly, tlx là tỉ lệ theo 2 chiều x và y của bản đồ.
Type: loại map
R: là thuộc tính dùng để vẽ hình chữ nhật, xét va chạm .
Các phương thức:
getTlx,getTLy dùng để lấy tỉ lệ theo chiều x,y;
setTlx,setTly dùng để gán các giá trị cho tỉ lệ theo x và y.
getType: lấy giá trị của loại map tương ứng
 Phương thức khởi tạo cho tile:
public Tile(int tlx, int tly, int type,Robot robot) throws IOException {
this.robot = robot;
init();
r = new Rectangle();
this.tlx = tlx * 70;
this.tly = tly * 70;
this.type = type;
if (type == 3) {
image = tree;
24


} else if (type == 4) {
image = f21;
} else if (type == 5) {

image = f22;
} else if (type == 2) {
image = f23;
} else if (type == 1) {
image = null;
}
}
 Class MapData

Class chưa phương thức load map cho toàn bộ trò chơi:
public void loadmap(String map, int c, Robot robot) throws
IOException {
ArrayList<String> lines = new ArrayList<String>();
int width = 0;
int height = 0;
String path = "/Maps/" + map;
InputStream in = getClass().getResourceAsStream(path);
BufferedReader reader = new BufferedReader(
new InputStreamReader(in)
);
while (true) {
String line = reader.readLine();
if (line == null) {
reader.close();
break;
}
if (!line.startsWith("!")) {
lines.add(line);
width = Math.max(width, line.length());
}

}
height = lines.size();
for (int i = 0; i < height; i++) {
25