Xây dựng ứng dụng game với python game 2D Flappy Bird | Tiểu luận Cơ sở lập trình

BỘ GIÁO DỤC VÀ ĐÀO TẠO
TRƯỜNG ĐẠI HỌC VĂN LANG -----F&E-----
KHOA KỸ THUẬT CƠ ĐIỆN VÀ MÁY TÍNH
TIỂU LUẬN THI KẾT THÚC HỌC PHẦN: CƠ SỞ LẬP TRÌNH BÁO CÁO CUỐI KỲ
ĐỀ TÀI XÂY DỰNG ỨNG DỤNG GAME VỚI PYTHON GAME 2D FLAPPY BIRD STTH: ĐINH LÊ ĐOAN NGỌC MSSV: 2374601080016 STTH: TRẦN DUY LINH MSSV: 2374601080014
STTH: NGUYỄN NGỌC LAN PHƯƠNG MSSV: 2374601080019
GIẢNG VIÊN HỖ TRỢ: NGUYỄN QUỐC DŨNG
TP HỒ CHÍ MINH, Ngày 14, tháng 05, năm 2024 MỤC LỤC
LỜI MỞ ĐẦU ....................................................................................................................3
I. MỔ TẢ VỀ GAME 2D “FLAPPY BIRD” ...................................................................4
1. Mục tiêu ......................................................................................................................4
2. Yêu cầu kỹ thuật ........................................................................................................4
a. Giao diện trò chơi: ..................................................................................................4
b. Nguyên lý hoạt động game ....................................................................................5
c. Cách điều khiển ......................................................................................................6
d. Thử thách của trò chơi ..........................................................................................6
e. Cách ghi điểm ..........................................................................................................6
f. Kết thúc trò chơi .....................................................................................................7
3. Thuật toán và Cấu trúc Dữ liệu ................................................................................7
4. Thách thức ..................................................................................................................7
II. PHÂN TÍCH THUẬT TOÁN ......................................................................................8
1. Cấu trúc chương trình. ..............................................................................................8
a. Ngôn ngữ lập trình Python ....................................................................................8
b. Thư viện Pygame: ..................................................................................................8
c. Các biến và hàm chính được sử dụng trong chương trình. ................................9
3. Thuật toán chính ......................................................................................................10
a. Vòng lặp trò chơi ..................................................................................................10
b. Xử lý việc va chạm của chim với ống thông qua hàm check_collision ..12
c. Các cột ống hình thành ........................................................................................13
d. Điều khiển chim ....................................................................................................14
e. Quản lý điểm số .....................................................................................................15
f. Hiệu ứng và âm thanh ..........................................................................................16
III. TỔNG KẾT ...............................................................................................................17 LỜI MỞ ĐẦU Kính chào mọi người,
Trong bản báo cáo này, chúng tôi sẽ khám phá sâu hơn về môn Cơ sở Lập Trình, một môn
học không thể thiếu trong chương trình đào tạo của Khoa Kỹ thuật, Cơ điện và Máy tính.
Môn học này không chỉ là nền tảng cho sự phát triển kỹ năng lập trình mà còn là bước đệm
vững chắc cho sinh viên hướng tới hiểu biết sâu sắc về thuật toán - nghệ thuật giải quyết
vấn đề một cách logic và có hệ thống.
Chúng ta sẽ cùng nhau tìm hiểu về Python, ngôn ngữ lập trình được sử dụng trong cộng
đồng khoa học dữ liệu đông đảo và năng động. Python không chỉ nổi bật với cú pháp thân
thiện, dễ đọc mà còn được biết đến với khả năng tích hợp mạnh mẽ, cho phép kết nối và
xử lý dữ liệu từ đa dạng nguồn khác nhau. Thông qua việc sử dụng các thư viện phong phú
như NumPy, Pandas, Matplotlib, Seaborn và Scikit-learn, Python đã trở thành công cụ
không thể thiếu trong việc phân tích và trực quan hóa dữ liệu.
Đặc biệt, trong phần thực hành của báo cáo, chúng tôi sẽ trình bày một bài tập lập trình
thực tế sử dụng Python, nơi chúng tôi được thử thách với việc phát triển một tựa game 2D
đơn giản nhưng hấp dẫn: Flappy Bird. Mục tiêu của chúng tôi không chỉ là hoàn thành
nhiệm vụ được giao mà còn là chia sẻ quá trình học hỏi và phát triển kỹ năng lập trình của
mình thông qua việc tạo ra một trò chơi điện tử.
Hãy cùng chúng tôi khám phá hành trình này qua từng trang của báo cáo.
I. MỔ TẢ VỀ GAME 2D “FLAPPY BIRD” 1. Mục tiêu
Phát triển một phiên bản đơn giản của game “Flappy Bird” sử dụng Python, nơi người chơi
điều khiển một chú chim bay qua các cột mà không được chạm vào chúng. 2. Yêu cầu kỹ thuật a. Giao diện trò chơi:
Sử dụng thư viện như Pygame để tạo giao diện đồ họa, hiển thị chú chim, các cột, và điểm số.
Hình ảnh hiển thị chú chim:
Khi chi ở dưới map
Khi chim ở giữa map Khi chim ở trên map Hình ảnh nền game: Cột xanh Mặt đường Phong nền màn đêm Hình ảnh thông báo:
Thông báo bắt đầu
Thông báo khi game thua
b. Nguyên lý hoạt động game
Trong trò chơi "Flappy Bird", nguyên lý của trò chơi tạo ra một môi trường tương tác giữa
người chơi và trò chơi, nơi mỗi hành động của người chơi có một phản ứng tương ứng trong trò chơi. Trọng Lực:
- Trọng lực là lực kéo chim xuống dưới, tạo ra một chuyển động liên tục và tăng dần về phía mặt đất. Lực Nâng:
- Khi người chơi nhấn phím cách, một lực nâng được tạo ra để đẩy chim lên trên, chống lại trọng lực.
- Lực nâng này có thể được mô phỏng bằng một giá trị cố định hoặc một công thức
phụ thuộc vào tốc độ của chim. Va Chạm:
- Va chạm xảy ra khi chim chạm vào cột hoặc mặt đất, dẫn đến kết thúc trò chơi.
- Hệ thống phát hiện va chạm kiểm tra vị trí của chim so với cột và mặt đất để xác
định xem có va chạm không.
Chuyển Động của Cột:
- Các cột di chuyển từ phải sang trái với tốc độ đều, tạo ra thách thức cho người chơi
khi điều khiển chim bay qua chúng.
- Tốc độ của cột có thể được điều chỉnh để tăng độ khó của trò chơi. Điểm Số:
- Điểm số được tính dựa trên số lượng cột mà chim đã vượt qua.
- Mỗi khi chim vượt qua một cột mà không va chạm, người chơi nhận được một điểm.
Tốc Độ và Gia Tốc:
- Tốc độ của chim thay đổi khi lực nâng được áp dụng, và chim sẽ chậm lại khi lực nâng không còn.
- Gia tốc có thể được tính toán dựa trên sự thay đổi về tốc độ theo thời gian.
Mô hình vật lý trong "Flappy Bird" tạo ra một trải nghiệm chơi game đơn giản nhưng đầy
thách thức, yêu cầu người chơi phải có sự tập trung và phản xạ nhanh nhẹn để đạt được điểm số cao.
c. Cách điều khiển
Đối với việc điều khiển nhân vật chính trong trò chơi ‘Flappy Bird’, người chơi sẽ sử dụng
phím cách (spacebar) trên bàn phím máy tính để thực hiện hành động nhảy lên. Mỗi lần
nhấn phím cách, chú chim sẽ thực hiện một cú nhảy nhẹ, giúp nó vượt qua các chướng ngại
vật là những cột ống đặt liên tiếp trên đường bay. Sự đơn giản trong cách điều khiển này
đòi hỏi người chơi phải có sự tập trung cao độ và phán đoán chính xác thời điểm nhấn phím
để chú chim có thể bay xa hơn mà không va chạm vào cột ống, qua đó tăng cơ hội đạt được
điểm số cao hơn trong trò chơi.
d. Thử thách của trò chơi
Trong trò chơi “Flappy Bird”, thử thách chính đến từ những cột cây mà người chơi phải
điều khiển chú chim bay qua. Các cột này được tạo ra một cách tự động với khoảng cách
ngẫu nhiên giữa chúng, tạo nên một môi trường không lường trước được, đòi hỏi sự phản
ứng nhanh nhẹn và tính toán chính xác từ phía người chơi. Điều này làm tăng độ khó của
trò chơi và khiến cho mỗi lần chơi đều mang lại trải nghiệm mới mẻ và thú vị. e. Cách ghi điểm
Trong trò chơi “Flappy Bird”, điểm số được tính là một phần quan trọng để đánh giá khả
năng điều khiển của người chơi. Mỗi lần con chim bay qua một cột mà không va chạm,
người chơi sẽ được cộng một điểm. Điểm số không chỉ phản ánh số lượng cột mà con chim
đã vượt qua mà còn thể hiện sự kiên nhẫn và độ chính xác trong từng động tác của người
chơi. Điểm số càng cao, cho thấy người chơi đã dành nhiều thời gian để luyện tập và đã
đạt được sự tự tin để vượt qua những thách thức ngày càng khó khăn trong trò chơi. f. Kết thúc trò chơi
Khi chơi game trong “Flappy Bird”, mỗi va chạm với chướng ngại vật đều đánh dấu là trò
chơi đã kết thúc một đoạn hành trình. Dù là va chạm với cột hay rơi xuống đất, màn hình
sẽ hiển thị điểm số cuối cùng mà người chơi đã đạt được. Điểm số này không chỉ là kết
quả của những nỗ lực trong lần chơi đó, mà còn là thước đo cho sự kiên trì và khéo léo. Và
dù kết quả có thế nào, trò chơi luôn cho bạn cơ hội để bắt đầu lại từ đầu, để cải thiện kỹ
năng và phá vỡ kỷ lục của chính mình. Mỗi lần “va chạm” và kết thúc trò chơi sẽ luôn bắt
đầu lại từ đầu, việc này tạo nên một thách thức mới, và một niềm vui mới trong việc chinh
phục những điểm số cao hơn.
3. Thuật toán và Cấu trúc Dữ liệu
Thuật toán: Thuật toán của “Flappy Bird” tương đối đơn giản nhưng hiệu quả. Trò chơi
sử dụng một vòng lặp game cơ bản để xử lý đầu vào từ người chơi, cập nhật trạng thái của
game, và render hình ảnh trên màn hình. Khi người chơi chạm vào màn hình, một lực đẩy
lên được áp dụng cho chim, tạo ra chuyển động nhảy. Nếu không có đầu vào, chim sẽ rơi
xuống do trọng lực. Thuật toán cũng phải xử lý va chạm giữa chim và các ống, cũng như
điểm số dựa trên số ống mà chim đã bay qua.
Cấu trúc Dữ liệu: Cấu trúc dữ liệu trong “Flappy Bird” bao gồm các biến để lưu trữ điểm
số, trạng thái của chim, và vị trí của các ống. Mảng hoặc danh sách liên kết có thể được sử
dụng để quản lý các ống di chuyển trên màn hình. Cấu trúc dữ liệu này cho phép trò chơi
nhanh chóng và dễ dàng cập nhật và render các ống mới khi chim tiếp tục di chuyển qua màn hình.
Mỗi ống là một đối tượng với các thuộc tính như vị trí trên màn hình và trạng thái (đã vượt
qua hay chưa). Khi một ống di chuyển ra khỏi màn hình, nó có thể được tái sử dụng và đặt
lại vị trí để tạo ra một thách thức mới cho người chơi, giúp tối ưu hóa hiệu suất và giảm
bớt việc cấp phát bộ nhớ mới.
Trò chơi “Flappy Bird” là một ví dụ điển hình về cách một thuật toán đơn giản và cấu trúc
dữ liệu hiệu quả có thể tạo ra một trải nghiệm chơi game gây nghiện và thú vị. Sự kết hợp
giữa lập trình game thông minh và thiết kế cấu trúc dữ liệu tối ưu đã giúp “Flappy Bird”
trở thành một hiện tượng toàn cầu. 4. Thách thức
§ Đảm bảo trò chơi chạy mượt mà và phản hồi nhanh với hành động của người chơi
§ Tạo ra một thuật toán để sinh ra các cột một cách ngẫu nhiên nhưng vẫn đảm bảo tính khả thi cho người chơi.
II. PHÂN TÍCH THUẬT TOÁN
1. Cấu trúc chương trình.
a. Ngôn ngữ lập trình Python
Python là một ngôn ngữ lập trình đa năng, mạnh mẽ và dễ học, được sử
dụng rộng rãi trong nhiều lĩnh vực khác nhau, từ phân tích dữ liệu đến
phát triển trò chơi. Trong khoa học dữ liệu, Python được ưa chuộng nhờ
vào thư viện phong phú như NumPy, pandas, và scikit-learn, giúp xử lý
và phân tích dữ liệu một cách hiệu quả. Python cũng hỗ trợ mạnh mẽ
cho việc học máy và trí tuệ nhân tạo, làm cho nó trở thành công cụ
không thể thiếu cho các nhà khoa học dữ liệu.
Bên cạnh đó, Python còn là lựa chọn phổ biến để phát triển trò chơi nhờ vào sự đơn giản
và linh hoạt của nó. Ví dụ, để tạo một tựa game 2D như “Flappy Bird”, người lập trình có
thể sử dụng thư viện Pygame, một thư viện chuyên biệt cho việc phát triển trò chơi, cung
cấp các công cụ để xử lý đồ họa, âm thanh và nhập liệu. b. Thư viện Pygame:
Pygame là một thư viện đa năng cho
ngôn ngữ lập trình Python, được thiết
kế để phát triển trò chơi và các ứng
dụng đồ họa. Với Pygame, lập trình
viên có thể tạo ra các trò chơi với đồ
họa 2D một cách dễ dàng và hiệu quả.
Thư viện này cung cấp các công cụ để xử lý hình ảnh, âm thanh, sự kiện, và nhiều tính
năng khác cần thiết cho việc phát triển game.
Khi áp dụng Pygame vào việc làm game "Flappy Bird", có thể tận dụng các chức năng của thư viện để:
§ Tạo Giao Diện Đồ Họa: Sử dụng các hàm vẽ để tạo ra hình ảnh của chim và các cột trong game.
§ Xử Lý Sự Kiện: Lắng nghe và phản hồi lại các sự kiện từ bàn phím, như việc người
chơi nhấn phím cách để chim bay lên.
§ Âm Thanh: Thêm âm thanh cho các hành động như tiếng chim bay và âm thanh khi va chạm.
§ Vật Lý Trò Chơi: Điều chỉnh tốc độ di chuyển của chim và cột, cũng như áp dụng
trọng lực để tạo cảm giác thực tế.
§ Điểm Số và Hiển Thị: Tính toán điểm số dựa trên số cột mà chim đã vượt qua và
hiển thị nó trên màn hình.
Sử dụng Pygame, việc tạo ra một phiên bản "Flappy Bird" không chỉ là một bài tập lập
trình mà còn là một cơ hội thể hiện khả năng sáng tạo và hiểu biết về lập trình hướng đối
tượng và xử lý sự kiện trong Python. Đây là một trải nghiệm học tập giá trị, giúp củng cố
kiến thức và kỹ năng lập trình thông qua việc tạo ra một sản phẩm trò chơi hoàn chỉnh và thú vị.
c. Các biến và hàm chính được sử dụng trong chương trình.
Dưới đây là các biến và hàm chính được sử dụng trong đoạn code trò chơi “Flappy Bird”: Biến:
¥ gravity: Đại diện cho lực hấp dẫn ảnh hưởng đến chim.
¥ bird_movement: Đại diện cho chuyển động của chim.
¥ game_active: Biến boolean xác định trạng thái của trò chơi (đang chơi hoặc đã kết thúc).
¥ score và high_score: Điểm số hiện tại và điểm số cao nhất.
¥ floor_x_pos: Vị trí của sàn trên màn hình.
¥ bird_list và bird_index: Danh sách các hình ảnh của chim và chỉ số hiện tại trong danh sách.
¥ bird_rect: Hình chữ nhật bao quanh chim, dùng để xác định vị trí và va chạm.
¥ pipe_list: Danh sách chứa các ống.
¥ pipe_height: Các giá trị chiều cao khác nhau cho ống.
¥ score_sound_countdown: Đếm ngược để phát âm thanh điểm số. Hàm:
¥ draw_floor(): Hiển thị sàn di chuyển.
¥ create_pipe(): Tạo ra một cặp ống mới với vị trí ngẫu nhiên.
¥ move_pipe(pipes): Di chuyển các ống sang trái trên màn hình.
¥ draw_pipes(pipes): Hiển thị các ống trên màn hình.
¥ check_collision(pipes): Kiểm tra va chạm giữa chim và các ống hoặc ranh giới trên và dưới.
¥ rotate_bird(bird1): Xoay chim dựa trên chuyển động của nó.
¥ bird_animation(): Thay đổi hình ảnh của chim để tạo hiệu ứng đập cánh.
¥ score_display(game_state): Hiển thị điểm số trên màn hình.
¥ update_score(score, high_score): Cập nhật điểm số cao nhất.
Các biến và hàm này làm nền tảng cho cơ chế hoạt động của trò chơi, từ việc điều khiển
chim, quản lý điểm số, đến việc tạo và hiển thị các đối tượng trong trò chơi.
3. Thuật toán chính
a. Vòng lặp trò chơi
Vòng lặp “While True” là một cấu trúc lặp vô hạn, thường được sử dụng trong các trò chơi
để giữ cho trò chơi chạy liên tục cho đến khi một sự kiện cụ thể xảy ra, như người chơi
thua cuộc hoặc chọn thoát trò chơi. Trong trường hợp của đoạn code này, vòng lặp “While
True” được sử dụng để:
Xử lý việc thoát game:
Nếu người chơi chọn thoát trò chơi (pygame.QUIT), hàm pygame.quit() sẽ được
gọi để thoát khỏi pygame, và sys.exit() sẽ được gọi để thoát khỏi chương trình.
Xử lý việc nhấn phím:
Khi trò chơi đang hoạt động và người chơi nhấn phím (pygame.K_SPACE),
bird_movement sẽ được đặt lại về 0 và sau đó được gán giá trị -8 để tạo hiệu ứng chim
bay lên. Âm thanh đập cánh được gáng vào(flap_sound.play()) cũng sẽ được phát.
Nếu trò chơi không hoạt động và người chơi nhấn phím, trò chơi sẽ được khởi động lại.
Danh sách cột ống (pipe_list) sẽ được xóa sạch, vị trí của chim (bird_rect) sẽ
được đặt lại, bird_movement và score cũng sẽ được đặt lại về 0.
Tạo ra các cột ống (chướng ngại vật) mới:
Khi sự kiện spawnpipe xảy ra, một cặp cột ống mới sẽ được tạo ra bằng hàm
create_pipe() và được thêm vào danh sách ống (pipe_list).
Thể hiện việc đập cánh của chim:
Sự kiện birdflap được sử dụng để thay
đổi hình ảnh của chim, tạo hiệu ứng đập
cánh. Nếu chỉ số của chim (bird_index)
nhỏ hơn 2, nó sẽ được tăng lên 1. Nếu chỉ số
đã là 2, nó sẽ được đặt lại về 0. Sau đó, hàm
bird_animation() sẽ được gọi để cập
nhật hình ảnh và vị trí của chim.
Khi game ở trạng thái hoạt động (game_active) và khi trò chơi kết thúc. Khi game_active là True:
Chú chim: bird_movement tăng lên theo giá trị của gravity, làm cho chim rơi
xuống. Sau đó, chim được xoay theo hàm rotate_bird() và vị trí trung tâm theo chiều
dọc của chim (bird_rect.centery) cũng được cập nhật. Chim sau đó được vẽ lên
màn hình tại vị trí mới.
Kiểm tra va chạm: Hàm check_collision() được gọi để kiểm tra xem chim có va
chạm với ống không. Nếu có va chạm, game_active sẽ trở thành False và trò chơi sẽ kết thúc.
Cột ống: Danh sách ống (pipe_list) được di chuyển qua hàm move_pipe() và sau
đó được vẽ lên màn hình qua hàm draw_pipes().
Điểm số: Điểm số (score) tăng lên một chút (0.01) sau mỗi khung hình và được hiển thị trên màn hình.
Âm thanh điểm số: Một bộ đếm ngược cho âm thanh điểm số
(score_sound_countdown) được giảm xuống sau mỗi khung hình. Khi bộ đếm này
đạt đến 0, âm thanh điểm số sẽ được phát và bộ đếm được đặt lại về 100. Khi game_active là False:
Màn hình game over được vẽ lên màn hình và điểm số cuối cùng được hiển thị.
Cuối cùng, hàm draw_floor() được gọi để vẽ sàn và nếu vị trí của sàn
(floor_x_pos) nhỏ hơn hoặc bằng -400, nó sẽ được đặt lại về 0 để tạo hiệu ứng sàn di
chuyển liên tục. pygame.display.update() được gọi để cập nhật toàn bộ màn hình
với những thay đổi mới, và clock.tick(100) đặt tốc độ khung hình là 100 khung hình
mỗi giây, giúp trò chơi chạy mượt mà và ổn định.
b. Xử lý việc va chạm của chim với ống thông qua hàm check_collision
§ Duyệt qua từng ống (pipe) trong danh sách ống (pipes): Hàm bắt đầu bằng việc lặp
qua từng ống trong danh sách ống đã được tạo.
§ Kiểm tra va chạm giữa chim và ống: Sử dụng phương thức colliderect() để
kiểm tra xem hình chữ nhật của chim (bird_rect) có giao nhau (va chạm) với
hình chữ nhật của ống (pipe) hay không. Nếu có va chạm, hàm sẽ phát âm thanh
va chạm (hit_sound.play()) và trả về False, biểu thị rằng đã xảy ra va chạm
và trò chơi sẽ kết thúc.
§ Kiểm tra va chạm giữa chim và ranh giới trên cùng hoặc dưới cùng của màn hình:
Nếu chim bay quá cao (bird_rect.top <= -75) hoặc quá thấp
(bird_rect.bottom >= 600), hàm cũng sẽ trả về False, biểu thị rằng chim
đã va chạm với ranh giới của màn hình và trò chơi sẽ kết thúc.
§ Trả về True nếu không có va chạm: Nếu không có va chạm nào được phát hiện,
hàm sẽ trả về True, cho phép trò chơi tiếp tục.
Cách xác định va chạm trong Pygame dựa trên việc kiểm tra giao nhau giữa các hình chữ
nhật (rectangles) đại diện cho các đối tượng trong trò chơi. Mỗi đối tượng như chim và ống
đều có một hình chữ nhật liên kết với nó, và Pygame cung cấp các phương thức để kiểm
tra sự giao nhau giữa các hình chữ nhật này, từ đó xác định xem có va chạm hay không.
c. Các cột ống hình thành Hàm move_pipe
Hàm move_pipe: Hàm này được sử dụng để di chuyển các ống trên màn hình.
§ Vòng lặp for: Duyệt qua từng ống trong danh sách các ống (pipes).
§ Di chuyển ống: Giảm giá trị centerx (vị trí trung tâm theo trục x) của mỗi ống đi
5 đơn vị. Điều này làm cho các ống di chuyển sang trái trên màn hình.
§ Trả về danh sách ống: Sau khi di chuyển, hàm trả về danh sách các ống đã được cập nhật vị trí. Hàm draw_pipes
Hàm draw_pipes: Hàm này được sử dụng để vẽ (hiển thị) các ống lên màn hình.
§ Vòng lặp for: Tương tự như hàm move_pipe, hàm này cũng duyệt qua từng ống trong danh sách.
§ Kiểm tra vị trí của ống: Nếu ống nằm dưới một vị trí nhất định (trong trường hợp
này là pipe.bottom >= 600), ống sẽ được vẽ như bình thường.
§ Lật ống: Nếu ống không nằm dưới vị trí đó, nó sẽ được lật ngược (để tạo ống trên)
sử dụng phương thức pygame.transform.flip(). Tham số False biểu thị
không lật theo trục x, và True biểu thị lật theo trục y.
§ Vẽ ống lên màn hình: Sử dụng phương thức blit của đối tượng screen để vẽ
ống lên màn hình tại vị trí được chỉ định bởi pipe.
Như vậy, các ống trong trò chơi được di chuyển liên tục sang trái để tạo ra thách thức cho
người chơi, và được hiển thị trên màn hình theo cách phản ánh vị trí hiện tại của chúng,
với việc lật ống để tạo ra ống trên và ống dưới. d. Điều khiển chim
Chú chim được điều khiển thông qua sự kiện pygame.KEYDOWN và hàm bird_animation.
Khi trò chơi đang hoạt động (game_active == True) và người chơi nhấn phím không
gian, biến bird_movement được đặt lại về 0 và sau đó được gán giá trị -8. Điều này tạo
ra một lực nhảy lên cho chim, cho phép nó bay lên trên màn hình.
Âm thanh cánh đập (flap_sound) được phát để cung cấp phản hồi âm thanh cho hành động.
Nếu trò chơi không hoạt động (game_active == False) và người chơi nhấn phím
không gian, trò chơi sẽ được khởi động lại. Danh sách ống (pipe_list) được xóa sạch,
vị trí của chim được đặt lại, biến bird_movement và score được đặt lại về 0.
Hàm bird_animation: Hàm này tạo ra hoạt ảnh cho chim bằng cách thay đổi giữa các
hình ảnh khác nhau của chim để tạo ra hiệu ứng cánh đập.
§ Hàm chọn một hình ảnh chim mới từ danh sách các hình ảnh (bird_list) dựa
trên chỉ số hiện tại (bird_index).
§ Một hình chữ nhật mới (new_bird_rect) được tạo ra với tâm ở cùng vị trí trung
tâm y như hình chữ nhật chim hiện tại (bird_rect.centery), nhưng với vị trí
trung tâm x cố định là 100.
§ Hàm trả về hình ảnh chim mới và hình chữ nhật mới, cho phép chim được hiển thị
với hoạt ảnh cánh đập trên màn hình.
Như vậy, người chơi điều khiển chim bằng cách nhấn phím không gian để chim bay lên và
tránh va chạm với các ống, trong khi hàm bird_animation tạo ra hiệu ứng đập cánh cho chim. e. Quản lý điểm số
Hàm score_display: Hàm này hiển thị điểm số trên màn hình dựa trên trạng thái của trò chơi.
§ Trạng thái ‘main game’: Khi trò chơi đang diễn ra, điểm số hiện tại được chuyển
đổi thành chuỗi và hiển thị trên màn hình.
§ Trạng thái ‘game_over’: Khi trò chơi kết thúc, điểm số hiện tại và điểm cao nhất
được hiển thị. Điểm số hiện tại được hiển thị ở trên cùng và điểm cao nhất được
hiển thị ở dưới cùng của màn hình.
§ Hiển thị điểm số: Sử dụng phương thức render của đối tượng game_font để
tạo ra một bề mặt (surface) chứa điểm số, sau đó sử dụng phương thức blit để
vẽ bề mặt này lên màn hình tại vị trí được xác định bởi score_rect.
Hàm update_score: Hàm này cập nhật và lưu trữ điểm cao nhất.
§ So sánh điểm số: Nếu điểm số hiện tại (score) cao hơn điểm cao nhất
(high_score), điểm cao nhất sẽ được cập nhật.
§ Trả về điểm cao nhất: Hàm trả về giá trị mới của high_score, cho phép nó
được lưu trữ và sử dụng trong các lần chơi sau.
Như vậy, hàm score_display quản lý việc hiển thị điểm số trên màn hình trong các
trạng thái khác nhau của trò chơi, trong khi hàm update_score đảm bảo rằng điểm cao
nhất luôn được cập nhật và lưu trữ
f. Hiệu ứng và âm thanh Âm Thanh:
§ flap_sound: Âm thanh này được phát khi người chơi nhấn phím cách để chim
bay lên. Được kích hoạt trong sự kiện pygame.KEYDOWN khi game_active là True.
§ hit_sound: Âm thanh này được phát khi chim va chạm với ống. Điều này xảy ra
trong hàm check_collision, nếu bird_rect va chạm với bất kỳ pipe nào trong pipe_list.
§ score_sound: Âm thanh này được phát khi người chơi đạt được một điểm số
nhất định. Trong vòng lặp game, nếu score_sound_countdown giảm xuống
0, âm thanh này sẽ được phát.
Hiệu Ứng Hình Ảnh:
§ rotate_bird: Hàm này tạo ra hiệu ứng xoay cho chim dựa trên giá trị của
bird_movement. Chim được xoay theo một góc tỷ lệ với tốc độ di chuyển của nó.
§ bird_animation: Hàm này chuyển đổi giữa các hình ảnh khác nhau của chim
để tạo ra hiệu ứng cánh đập. Điều này được kích hoạt bởi sự kiện birdflap được đặt timer.
§ draw_pipes: Hàm này vẽ các ống trên màn hình. Nếu ống nằm dưới một độ cao
nhất định (pipe.bottom >= 600), nó sẽ được vẽ như bình thường. Nếu không,
ống sẽ được lật ngược và vẽ lên màn hình.
Hiệu Ứng Điểm Số:
§ score_display: Hàm này hiển thị điểm số hiện tại và điểm số cao nhất khi trò
chơi kết thúc. Điểm số được cập nhật liên tục trong vòng lặp game và được hiển thị
dưới dạng văn bản trên màn hình. III. TỔNG KẾT
Trong quá trình thực hiện đồ án, chúng tôi đã áp dụng kiến thức về lập trình Python và thư
viện Pygame để xây dựng một trò chơi 2D đơn giản nhưng thú vị. Qua đó, chúng tôi đã
hiểu sâu hơn về cách thức hoạt động của các hàm, việc quản lý sự kiện, và cách tạo đồ họa
trong trò chơi. Đồ án đã giúp củng cố và nâng cao kỹ năng lập trình của nhóm, đồng thời
mở rộng hiểu biết về khoa học dữ liệu qua việc xử lý và tối ưu hóa dữ liệu trong game.
Đồ án đã đạt được mục tiêu đề ra là tạo ra một trò chơi Flappy Bird 2D hoạt động mượt
mà và ổn định. Mặc dù còn một số hạn chế như đồ họa còn đơn giản và chưa có nhiều tính
năng, nhưng đồ án đã thể hiện được tiềm năng của Python trong việc phát triển game.
Trong tương lai, nhóm có thể tiếp tục phát triển thêm nhiều tính năng mới, cải thiện đồ họa
và tối ưu hóa hiệu suất để nâng cao trải nghiệm người dùng.