Báo cáo bài tiểu luận số 03 môn Lập trình game (cơ bản) đề tài "Tìm hiểu về game Engine Unity"

BỘ THÔNG TIN VÀ TRUYỀN THÔNG
HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG
BÁO CÁO TIỂU LUẬN 3
Môn học: Lập trình game cơ bản
Đề tài: Tìm hiểu về G ame Engine Unity MỤC LỤC
DANH MỤC HÌNH ẢNH .............................................................................................................. 1
MỞ ĐẦU ......................................................................................................................................... 3
1. Tổng quan về Unity ...................................................................................................................... 3
2. Lịch sử về Unity ........................................................................................................................... 4
3. Kiến thức cơ bản về Unity: .......................................................................................................... 4
4. Lập trình trong Unity: ................................................................................................................ 14
5. Thiết kế game trong Unity: ........................................................................................................ 24
6. UI và UX trong Unity: ............................................................................................................... 31
7. Trò chơi a nền tảng và tích hợp mạng: ....................................................................................... 38
8. Hiệu suất và tối ưu hóa: .............................................................................................................. 49
9. Hỗ trợ và cộng ồng: .................................................................................................................... 50
10. Thử nghiệm và debugging:....................................................................................................... 52
11. Đóng gói và phát hành game: ................................................................................................... 55
KẾT LUẬN ................................................................................................................................... 56
TÀI LIỆU THAM KHẢO ........................................................................................................... 58 DANH MỤC HÌNH ẢNH
Hình ảnh 1: Download unity từ trang chủ ....................................................................................... 6
Hình ảnh 2: Cài ặt unity ................................................................................................................. 7
Hình ảnh 3: Cài ặt unity ................................................................................................................. 7
Hình ảnh 4: Cài ặt unity ................................................................................................................. 8
Hình ảnh 5: Cách cài unity .............................................................................................................. 8
Hình ảnh 6: Cách cài unity .............................................................................................................. 9
Hình ảnh 7: Cách cài unity .............................................................................................................. 9
Hình ảnh 8: Cách cài unity ............................................................................................................ 10
Hình ảnh 9: Cách cài unity ............................................................................................................ 10
Hình ảnh 10: Tạo dự án Unity ....................................................................................................... 11
Hình ảnh 11: Tạo dự án Unity ....................................................................................................... 11
Hình ảnh 12: Tạo dự án Unity ....................................................................................................... 12
Hình ảnh 13: Scene trong unity ..................................................................................................... 12
Hình ảnh 14: GameObject trong unity .......................................................................................... 13
Hình ảnh 15: Inspector trong Unity ............................................................................................... 14
Hình ảnh 16: Hierarchy trong unity ............................................................................................... 15
Hình ảnh 17: Project trong Unity .................................................................................................. 15
Hình ảnh 18: Console trong Unity ................................................................................................. 16
Hình ảnh 19: C# Script ể quản lý nhân vật .................................................................................. 16
Hình ảnh 20: Nơi chứa C# Scripts ................................................................................................. 17
Hình ảnh 21: Tạo 1 C# script mới ................................................................................................. 17
Hình ảnh 22: Cách chọn IDE ể làm việc trong Unity .................................................................. 18
Hình ảnh 23: Ví dụ về cây phân cấp Game Objects ...................................................................... 19
Hình ảnh 24: Thuộc tính của 1 Game Object ................................................................................ 20
Hình ảnh 25: Component ược gắn vào Game Object .................................................................. 21
Hình ảnh 26: Xử lý logic và sự kiện cho 1 nút bấm ...................................................................... 22
Hình ảnh 27: Quản lý tài nguyên trong Unity ............................................................................... 22
Hình ảnh 28: Giao diện của Rigidbody ......................................................................................... 30
Hình ảnh 29: Giao diện của Box Collider ..................................................................................... 31
Hình ảnh 30: Giao diện Hinge Joint .............................................................................................. 32
Hình ảnh 31: Giao diện Layer Collision Matrix ............................................................................ 32
Hình ảnh 32: Hỉnh ảnh: Minh họa về Raycast............................................................................... 33
Hình ảnh 33: Canvas trong Unity .................................................................................................. 35
Hình ảnh 34: Chế ộ render ........................................................................................................... 36
Hình ảnh 35: Inspector ối tượng Text .......................................................................................... 37
Hình ảnh 36: Inspector ối tượng Image ....................................................................................... 38
Hình ảnh 37: Inspector ối tượng Button ...................................................................................... 39
Hình ảnh 38: Transiton ối tượng Button ...................................................................................... 40
Hình ảnh 39: Event OnClick ......................................................................................................... 40
Hình ảnh 40: Script ơn giản ể tương tác với ối tượng ............................................................. 41
Hình ảnh 41: Phần File trong Unity .............................................................................................. 43
Hình ảnh 42: Giao diện phần Build Settings ................................................................................. 43
Hình ảnh 43: Giao diện phần Build Settings, phần các Scene ể xây dựng .................................. 44
Hình ảnh 44: Giao diện phần Build Settings, nút Player Settings ................................................. 45
Hình ảnh 45: Giao diện phần Audio trong Project Settings .......................................................... 45
Hình ảnh 46: Giao diện phần Player trong Project Settings .......................................................... 46
Hình ảnh 47: Giao diện phần Player (Icon) trong Project Settings ............................................... 46
Hình ảnh 48: Giao diện phần Player (Resolution and Presentation) trong Project Settings ......... 47
Hình ảnh 49: Giao diện phần Player (Splash Image) trong Project Settings ................................. 47
Hình ảnh 50: Giao diện của phần Build Settings, nút Build and Run ........................................... 48
Hình ảnh 51: Màn hình mở ầu ..................................................................................................... 48
Hình ảnh 52: Cấu trúc thư mục cơ bản của một trò chơi............................................................... 49
Hình ảnh 53: Profiler trong unity .................................................................................................. 52
Hình ảnh 54: Frame Debug trong unity ......................................................................................... 53
Hình ảnh 55: Cửa sổ console trong Unity ..................................................................................... 55 MỞ ĐẦU
Tiểu luận này tập trung vào việc tìm hiểu về game engine Unity - một công cụ phát triển trò
chơi mạnh mẽ và phổ biến trong ngành công nghiệp game hiện nay. Unity ã trở thành một
trong những game engine hàng ầu trên thị trường, ược sử dụng rộng rãi ể phát triển trò chơi a
nền tảng từ di ộng cho ến máy tính và kể cả thực tế ảo.
Trong phần này, nhóm sẽ khám phá các khía cạnh quan trọng của Unity và những khả năng
mà nó mang lại cho nhà phát triển trò chơi. Nhóm sẽ xem xét các tính năng và công nghệ
mạnh mẽ của Unity, cách nó hỗ trợ việc phát triển trò chơi a nền tảng và cung cấp một môi
trường sáng tạo cho các nhà phát triển.
Đồng thời, nhóm sẽ xem xét các công cụ và tài nguyên hỗ trợ của Unity, bao gồm việc làm
việc với ồ họa, âm thanh, vật lý và nhiều khía cạnh khác ể tạo ra trò chơi chất lượng cao.
Nhóm cũng sẽ nghiên cứu về cách Unity hỗ trợ phát triển trò chơi trong môi trường a ngôn ngữ và a nền tảng.
Cuối cùng, Nhóm sẽ ánh giá các lợi ích và hạn chế của việc sử dụng Unity trong phát triển trò
chơi, cũng như những xu hướng và triển vọng trong tương lai của nền tảng này. Mục tiêu của
tiểu luận này là cung cấp một cái nhìn tổng quan về Unity và hiểu rõ hơn về sức mạnh và tiềm
năng của game engine này trong việc phát triển trò chơi a nền tảng. Nhóm hy vọng rằng thông
qua nghiên cứu này, người ọc sẽ có cái nhìn sâu sắc và chi tiết hơn về Unity và có thể áp dụng
kiến thức này vào công việc thực tế trong lĩnh vực phát triển trò chơi.
1. Tổng quan về Unity
• Unity là một game engine a nền tảng ược phát triển bởi Unity Technologies, mà chủ yếu ể
phát triển video game cho máy tính, consoles và iện thoại. Lần ầu tiên nó ược công bố
chạy trên hệ iều hành OS X, tại Apple's Worldwide
• Developers Conference vào năm 2005, ến nay ã mở rộng 27 nền tảng.
• Unity hỗ trợ ồ họa 2D và 3D, các chức năng ược viết chủ yếu qua ngôn ngữ C#. Trong 2D
games, Unity cho phép nhập sprites và một renderer thế giới 2D tiên tiến. Đối với 3D
games, Unity cho phép thiết lập các ập iểm kỹ thuật của các kết cấu và ộ phân giải mà
công cụ trò chơi hỗ trợ, cung cấp các hỗ trợ cho bump mapping, reflection mapping,
parallax mapping, cảnh không gian ambient occlusion (SSAO), hiệu ứng bóng ổ bằng cách
sử dụng shadow maps, render thiết lập toàn cảnh ến hiệu ứng.
• Unity nổi bật với khả năng xây dựng trò chơi chạy trên nhiều nền tảng. Các nền tảng ược
hỗ trợ hiện nay là Android, Android TV, Facebook Gameroom, Fire OS, Gear VR, Google
Cardboard, Google Daydream, HTC Vive, iOS, Linux, macOS, Microsoft HoloLens,
Nintendo 3DS family, Nintendo Switch, Oculus Rift, PlayStation 4, PlayStation Vita,
PlayStation VR, Samsung Smart TV, Tizen, tvOS, WebGL, Wii U, Windows, Windows
Phone, Windows Store, và Xbox One.
2. Lịch sử về Unity
• Unity game engine khởi ộng năm 2005, nhằm "dân chủ hóa" phát triển game bằng cách
cung cấp cho nhiều nhà phát triển hơn.
• Unity 2.0 ra mắt năm 2007 với khoảng 50 tính năng mới. Bản phát hành bao gồm một
công cụ ịa hình ược tối ưu hóa cho môi trường 3D, real-time dynamic shadows, directional
lights và spotlights, phát lại video và các tính năng khác. Bản phát hành cũng bổ sung các
tính năng nhờ ó các nhà phát triển có thể cộng tác dễ dàng hơn. Nó bao gồm một
Networking Layer ể các nhà phát triển tạo game nhiều người chơi dựa trên User Datagram
Protocol, cung cấp Network Address Translation, State Synchronization, và Remote Procedure Calls.
• Unity 3.0 ra mắt tháng 9 năm 2010 với tính năng mở rộng các tính năng ồ họa của engine
cho máy tính ể bàn và video game consoles
• Tháng 11 năm 2012, Unity Technologies phát hành Unity 4.0. Phiên bản này bổ sung các
hỗ trợ cho DirectX 11 và Adobe Flash, các công cụ hoạt ảnh mới có tên Mecanim, và
quyền truy cập vào bản xem trước Linux.
• Unity Technologies ra mắt Unity 5 năm 2014, với nhiều cải tiến áng kể trong ồ họa, ặc biệt
là hỗ trợ vật lý toàn cầu.
• Năm 2016 Unity Technologies công bố Unity 5.6 và giới thiệu mô hình kinh doanh mới
bằng việc cung cấp phiên bản Personal (miễn phí) và phiên bản Professional (trả phí) của Unity.
• Năm 2018 Unity mở cửa hàng tài nguyên Asset Store, nơi các nhà phát triển có thể mua và
bán tài sản dự án và công cụ phát triển.
3. Kiến thức cơ bản về Unity:
3.1 Cách tải và cài ặt Unity
• Bước 1: Truy cập vào website chính thức của Unity https://unity.com/ và nhấp vào “Download for Windows”.
Hình ảnh 1: Download unity từ trang chủ
• Bước 2: Khởi chạy tệp .exe nhận ược > nhấp vào “I agree.
Hình ảnh 2: Cài ặt unity
• Bước 3: Chọn thư mục ể cài Unity và nhấp vào “Install”.
Hình ảnh 3: Cài ặt unity
• Bước 4: Chờ quá trình cài ặt hoàn tất và chọn vào “Finish” ể hoàn tất”.
Hình ảnh 4: Cài ặt unity
• Bước 5: Nhấp vào nút “Sign in”.
Hình ảnh 5: Cách cài unity
• Bước 6: Đăng nhập bằng tài khoản Google > xác thực Email > ồng ý các iều khoản và chọn “Continue”.
Hình ảnh 6: Cách cài unity
• Bước 7: Sau khi ăng nhập thành công, hãy chọn mở Unity app và chọn vào “Install” ở góc
phải màn hình > chọn phiên bản muốn cài ặt (tốt nhất là chọn bản mới nhất).
Hình ảnh 7: Cách cài unity
• Bước 8: Chọn một module muốn cài ặt (như trên hình) và nhấp vào “Continue”.
Hình ảnh 8: Cách cài unity
• Bước 9: Lúc này, bạn chỉ cần ồng ý với các iều khoản và bản quyền, sau ó nhấp vào “Install”
ể hoàn tất cài ặt Unity.
Hình ảnh 9: Cách cài unity
3.2 Cách tạo một dự án Unity
• Bước 1: Vào Unity Hub nhấn New Project
Hình ảnh 10: Tạo dự án Unity
• Bước 2: Đặt tên cho dự án của bạn, chọn nơi lưu trữ và chọn phiên bản Unity mà bạn muốn
sử dụng cho dự án này.
Hình ảnh 11: Tạo dự án Unity
• Bước 3 Nhấn nút "Create" ể tạo dự án.
Hình ảnh 12: Tạo dự án Unity
3.3 Các thành phần cơ bản của unity
• Scene: Cửa sổ Scene là nơi bạn tạo và chỉnh sửa các cảnh trong dự án của mình. Cảnh là nơi
bạn sắp xếp và quản lý các Game Object và tài nguyên của dự án.
Hình ảnh 13: Scene trong unity
• Game Object: Game Object là các thành phần cơ bản của môi trường 3D trong Unity.
Chúng có thể là các ối tượng như nhân vật, ối tượng tĩnh, ánh sáng, vật phẩm, vv. Bạn có
thể tạo, di chuyển, xoay, và thay ổi các thuộc tính của Game Object trong cửa sổ Inspector.
Hình ảnh 14: GameObject trong unity
• Inspector : Cửa sổ Inspector hiển thị thông tin chi tiết về Game Object ược chọn. Bạn có thể
thay ổi các thuộc tính của Game Object và gán các thành phần và kịch bản vào ó. Nó cũng
hiển thị thông tin về tài nguyên, vật liệu, và các thành phần khác liên quan ến ối tượng ang ược chọn.
Hình ảnh 15: Inspector trong Unity
• Hierarchy (Danh sách ối tượng): Cửa sổ Hierarchy hiển thị danh sách tất cả các Game
Object trong cảnh hiện tại. Nó thể hiện cấu trúc cây của các ối tượng, cho phép bạn dễ
dàng tìm và chọn chúng. Bạn cũng có thể sắp xếp và nhóm các ối tượng trong cửa sổ này.
Hình ảnh 16: Hierarchy trong unity
• Project : Cửa sổ Project là nơi bạn quản lý tất cả các tài nguyên của dự án, bao gồm tệp hình
ảnh, âm thanh, mô hình 3D, tệp văn bản và nhiều tài nguyên khác. Bạn có thể tạo, kéo và
thả, và sắp xếp các tài nguyên trong cửa sổ này.
Hình ảnh 17: Project trong Unity
• Console: Cửa sổ Console hiển thị thông báo và lỗi từ mã nguồn và chạy của ứng dụng. Điều
này rất hữu ích ể theo dõi lỗi và thông tin gỡ lỗi trong quá trình phát triển.
Hình ảnh 18: Console trong Unity
4. Lập trình trong Unity:
4.1 Ngôn ngữ lập trình C#
• C# (C Sharp) là ngôn ngữ lập trình phổ biến ược sử dụng trong Unity ể viết các scripts ể iều
khiển hành vi và tương tác của các ối tượng trong game.
Hình ảnh 19: C# Script ể quản lý nhân vật
• Tích hợp Unity và C#: Unity hỗ trợ C# như một trong những ngôn ngữ lập trình chính ể phát triển ứng dụng.
Hình ảnh 20: Nơi chứa C# Scripts
Hình ảnh 21: Tạo 1 C# script mới
• Phát triển ứng dụng a nền tảng: Một ưu iểm lớn của việc sử dụng C# trong Unity là khả
năng phát triển ứng dụng a nền tảng. C# hỗ trợ cho việc viết một lần và triển khai trên
nhiều nền tảng khác nhau như iOS, Android, PC, Mac, các thiết bị game console, VR, và AR.
• Khả năng kết hợp với Unity API: C# có thể tương tác chặt chẽ với các API và tính năng
của Unity. Có thể sử dụng C# ể thao tác với các ối tượng Unity, quản lý tài nguyên, xử lý
sự kiện và tạo logic cho game.
• Dễ thao tác: C# ược thiết kế ể có cú pháp dễ ọc và dễ hiểu, iều này giúp cho việc dễ quản
lý và bảo trì. C# cũng cung cấp nhiều tính năng như quản lý bộ nhớ tự ộng (garbage
collection) và nhiều thư viện hỗ trợ mạnh mẽ khác.
• Debugging: Unity cung cấp môi trường phát triển tích hợp cho việc debug C#. Người lập
trình có thể theo dõi biến, xem xét lỗi, và kiểm tra hành vi của ứng dụng trong thời gian thực.
• Cộng ồng lớn: Cộng ồng Unity rộng lớn và nhiều nguồn tài liệu học tập trực tuyến dành
riêng cho lập trình C#. Điều này rất hữu ích cho việc sửa lỗi hoặc nhu cầu nâng cao kiến thức. 4.2 External IDE
• Unity cho phép linh hoạt sử dụng nhiều External IDE cho việc lập trình C#. Chúng ta có thể
chọn IDE muốn dùng bằng cách chọn Edit -> Preferences -> External Tools -> External Script Editor
Hình ảnh 22: Cách chọn IDE ể làm việc trong Unity
• Một số IDE phổ biến ược sử dụng là Visual Studio (recommended). VS Code, Jetbrains Rider,... 4.3 Game objects • Game Object là gì?
○ Game Object trong Unity là một ối tượng cơ bản trong thế giới 3D hoặc 2D của trò chơi
hoặc ứng dụng. Chúng có thể biểu diễn bất kỳ thứ gì, từ nhân vật và vật phẩm ến ánh
sáng, camera, và môi trường. • Tạo Game Objects:
○ Chúng ta có thể tạo Game Objects bằng cách nhấp chuột phải trong cửa sổ Scene hoặc
Hierarchy trong Unity và chọn "Create Empty" hoặc "Create 3D Object" (hoặc "Create
2D Object" nếu Chúng ta làm việc trong không gian 2D).
○ Có thể tạo Game Objects tùy chỉnh bằng cách sử dụng Prefabs hoặc tải các mô hình 3D hoặc hình ảnh 2D. • Sắp xếp Game Objects:
○ Game Objects trong Unity ược sắp xếp theo cấu trúc cây phân cấp, ược hiển thị trong
cửa sổ Hierarchy. Điều này cho phép Chúng ta quản lý và nhóm chúng lại với nhau.
○ Ví dụ, PlayerUI có chứa HUD và UIWindow, trong chúng lại có những object con khác:
Hình ảnh 23: Ví dụ về cây phân cấp Game Objects
• Thiết lập thuộc tính Game Object:
○ Mỗi Game Object có các thuộc tính riêng, bao gồm vị trí, quay, tỷ lệ, hình dạng, vật lý
và nhiều thuộc tính khác. Chúng ta có thể chỉnh sửa các thuộc tính này trong cửa sổ Inspector.
Hình ảnh 24: Thuộc tính của 1 Game Object
• Gắn các Component (bộ phận):
○ Game Objects có thể có các Component gắn vào chúng ể cung cấp chức năng và logic.
Ví dụ, Chúng ta có thể gắn Component như Collider ( ể xác ịnh va chạm), Rigidbody ( ể
xử lý vật lý), hoặc các Component tự tạo bằng cách viết code bằng C#.
Hình ảnh 25: Component ược gắn vào Game Object
• Xử lý Logic và Sự kiện:
○ Chúng ta có thể viết Code bằng C# ể xử lý logic và sự kiện của Game Objects. Ví dụ,
Chúng ta có thể lập trình cho Game Object di chuyển, tương tác với người chơi, hoặc
thực hiện hành ộng cụ thể.
Hình ảnh 26: Xử lý logic và sự kiện cho 1 nút bấm • Tạo Prefabs:
○ Prefabs là mẫu Game Objects có thể ược tái sử dụng trong toàn bộ dự án. Chúng ta có
thể tạo Prefabs bằng cách kéo và thả Game Objects từ cửa sổ Hierarchy vào thư mục Prefabs trong Project. • Quản lý tài nguyên:
○ Unity cho phép Chúng ta quản lý tài nguyên như hình ảnh, âm thanh và mô hình 3D, và
sau ó gắn chúng vào Game Objects.
Hình ảnh 27: Quản lý tài nguyên trong Unity
• Kịch bản hóa và Animation:
○ Chúng ta có thể kịch bản hóa Game Objects bằng cách tạo các trạng thái và hành vi sử
dụng các Animation Clips và Animator Controllers. Điều này cho phép Chúng ta tạo
hoạt hình và tương tác phức tạp cho Game Objects. 4.4 Event Handling • Sự Kiện (Event):
○ Sự kiện là một hành ộng xảy ra trong trò chơi hoặc ứng dụng, ví dụ như người chơi
nhấn một phím, va chạm xảy ra, hoặc thời gian ã trôi qua. Unity cung cấp nhiều loại sự
kiện có sẵn như sự kiện chuột, sự kiện bàn phím, sự kiện va chạm, và nhiều sự kiện khác. • Scripting:
○ Để xử lý logic và sự kiện, Chúng ta sẽ code bằng C#. Code này ược gắn vào các Game
Objects dưới dạng các Component gọi là "scripts." Chúng ta có thể sử dụng các IDE
như Visual Studio hoặc Visual Studio Code ể viết Code C#.
• Xử lý Logic và Sự kiện Bằng C#:
○ Chúng ta có thể xử lý logic và sự kiện bằng cách viết Code trong các scripts gắn vào
Game Objects. Ví dụ, Chúng ta có thể lập trình Game Object ể di chuyển khi người chơi
nhấn phím, thay ổi màu sắc khi có va chạm, hoặc thực hiện hành ộng cụ thể khi một
trạng thái ược kích hoạt.
• Phát tín hiệu (Emit Events):
○ Trong C#, Chúng ta có thể sử dụng delegate và event ể phát tín hiệu và lắng nghe sự
kiện. Chúng ta có thể tạo các sự kiện tùy chỉnh trong script và sau ó gán các phương
thức xử lý sự kiện cho chúng. • Unity Event System:
○ Unity cung cấp một hệ thống sự kiện tích hợp (Unity Event System) cho việc xử lý sự
kiện trong giao diện người dùng. Chúng ta có thể sử dụng nó ể xử lý sự kiện như nhấn
nút, kéo và thả, và tương tác người dùng khác. • Coroutine:
○ Unity cung cấp khái niệm Coroutine ể xử lý các tác vụ gần như ồng thời mà không cản
trở luồng chính của ứng dụng. Coroutine thường ược sử dụng ể tạo các hiệu ứng, ộ trễ,
và tác vụ không ồng bộ.
• Truyền tin giữa Game Objects:
○ Unity cho phép Game Objects gửi và lắng nghe thông iệp bằng cách sử dụng các hàm
như SendMessage, BroadcastMessage, và SendMessageUpwards. Điều này cho phép
Game Objects tương tác với nhau và truyền thông dữ liệu hoặc thực hiện hành ộng.
• Điều khiển Animator (Animator Controller):
○ Trong trường hợp Chúng ta làm việc với hoạt hình, Chúng ta có thể tạo trình iều khiển
Animator ể xử lý các trạng thái và chuyển ổi hoạt hình dựa trên sự kiện và logic cụ thể.
4.5 AI (Artificial Intelligence)
• NavMesh và Điều khiển Di chuyển:
Unity cung cấp hệ thống iều khiển di chuyển dựa trên NavMesh ể xác ịnh vùng mà các
ối tượng có thể di chuyển. Chúng ta có thể tạo NavMeshes trên cảnh và sử dụng các
hàm như NavMeshAgent ể kiểm soát việc di chuyển của các ối tượng AI.
• Điều khiển AI bằng C#:
○ Chúng ta sẽ viết Code bằng C# ể iều khiển hành vi của các ối tượng AI. Chúng ta có thể
lập trình AI ể di chuyển, tìm ường, tránh va chạm, tấn công, và thực hiện các hành ộng
khác dựa trên logic và sự kiện trong trò chơi.
• Lập trình Trạng thái và Hành vi:
○ Một phương pháp phổ biến ể lập trình AI là sử dụng trạng thái và hành vi. Chúng ta có
thể xác ịnh các trạng thái như "tấn công," " uổi theo," "bình thường," và chuyển ổi giữa
chúng dựa trên tình huống trong trò chơi. Điều này cho phép AI phản ứng linh hoạt và tự ộng.
• Lập trình bằng Cơ sở Luật (Rule-Based Programming):
○ Chúng ta có thể sử dụng lập trình cơ sở luật ể xác ịnh quy tắc cho AI. Ví dụ, nếu thấy
người chơi ở gần, AI sẽ tấn công. Nếu có nguy cơ va chạm với ối tượng khác, AI sẽ tránh.
• Học máy (Machine Learning):
○ Unity cũng hỗ trợ tích hợp các mô hình học máy và dự án như Unity ML-Agents. Điều
này cho phép Chúng ta lập trình AI ể học từ dữ liệu và cải thiện theo thời gian.
• Sử dụng Sensor và Perception:
○ AI có thể sử dụng các cảm biến như cảm biến gần, cảm biến thị giác, hoặc cảm biến
nhiệt ể cảm nhận môi trường xung quanh và ra quyết ịnh dựa trên thông tin này.
• Thư viện AI bên ngoài:
○ Chúng ta có thể sử dụng các thư viện AI bên ngoài và tích hợp chúng vào Unity ể tạo AI
phức tạp hơn. Ví dụ, Chúng ta có thể sử dụng thư viện TensorFlow ể tạo mô hình học máy.
• Kiểm thử và Tối ưu hóa AI:
○ Sau khi lập trình AI, Chúng ta cần kiểm tra và tối ưu hóa ể ảm bảo rằng AI hoạt ộng hiệu
quả và áp ứng úng các yêu cầu của trò chơi hoặc ứng dụng.
4.6 Kết nối cơ sở dữ liệu và mạng
• Kết nối Cơ sở dữ liệu:
○ Trong Unity, Code có thể sử dụng các thư viện và API ể kết nối với cơ sở dữ liệu. Phổ
biến nhất là kết nối với cơ sở dữ liệu SQL hoặc NoSQL bằng cách sử dụng C# và các thư viện tương thích.
○ Cơ sở dữ liệu thường ược sử dụng ể lưu trữ thông tin như thông tin người dùng, iểm số,
trạng thái trò chơi, và dữ liệu liên quan. Unity hỗ trợ việc tạo kết nối với các cơ sở dữ
liệu phổ biến như MySQL, SQLite, MongoDB, và nhiều hệ thống cơ sở dữ liệu khác.
Để kết nối cơ sở dữ liệu, Code cần sử dụng các lớp và thư viện phù hợp, thiết lập kết
nối, và sau ó thực hiện các thao tác như truy vấn, cập nhật và xóa dữ liệu. • Mạng và Multiplayer:
○ Unity cho phép Code tạo trò chơi a người chơi (multiplayer game) bằng cách sử dụng
các thư viện và công nghệ mạng. Điều này cho phép người chơi kết nối và tương tác
với nhau qua Internet hoặc mạng LAN.
○ Để phát triển trò chơi a người chơi, Code cần hiểu về các giao thức mạng như TCP và
UDP, và sử dụng các thư viện như Mirror, Photon, UNET (cũ) hoặc các giải pháp mạng tùy chỉnh.
○ Code phải quản lý kết nối, ồng bộ hóa dữ liệu giữa các máy chơi và xử lý sự kiện trong
trò chơi. Điều này bao gồm việc quản lý ộ trễ mạng và xử lý hành vi của các người chơi khác.
4.7 Kiểm thử và tối ưu hóa (Testing and Optimizing) 4.7.1 Kiểm thử:
• Kiểm thử Đơn vị (Unit Testing):
○ Sử dụng các framework kiểm thử ơn vị như NUnit hoặc Unity Test Runner ể kiểm tra các
phần cơ bản của code của Chúng ta ể ảm bảo rằng chúng hoạt ộng úng cách.
• Kiểm thử Tự ộng (Automated Testing):
○ Tự ộng hóa các cuộc kiểm tra ể ảm bảo rằng các tính năng và hành vi của trò chơi hoạt
ộng as expected sau mỗi thay ổi trong code.
• Kiểm thử Tương tác (Integration Testing):
○ Kiểm tra các phần của trò chơi hoạt ộng cùng nhau một cách hợp lý, bao gồm kiểm tra
tích hợp giữa các ối tượng và hệ thống.
• Kiểm thử Beta (Beta Testing):
○ Phát hành phiên bản beta cho một nhóm người dùng thử nghiệm ể thu thập phản hồi và
dữ liệu hiệu suất từ họ.
• Kiểm thử Hiệu năng (Performance Testing):
○ Kiểm tra hiệu năng của trò chơi ể ảm bảo rằng nó chạy mượt mà và không gây tắc nghẽn
trên các nền tảng và thiết bị khác nhau.
• Kiểm thử Tương tác Mạng (Network Testing):
○ Đối với trò chơi a người chơi, thực hiện kiểm tra mạng ể ảm bảo rằng kết nối và ồng bộ
hóa hoạt ộng chính xác. 4.7.2 Tối ưu hóa:
• Tối ưu hóa Hiệu năng (Performance Optimization):
○ Tối ưu hóa code và tài nguyên ể ảm bảo trò chơi chạy mượt mà trên nhiều thiết bị. Sử
dụng công cụ như Profiler ể phát hiện và giải quyết vấn ề hiệu suất.
• Tối ưu hóa Thời gian Khởi ộng (Startup Time Optimization):
Giảm thời gian khởi ộng của trò chơi hoặc ứng dụng ể cải thiện trải nghiệm người dùng.
• Tối ưu hóa Bộ nhớ (Memory Optimization):
○ Quản lý tài nguyên và bộ nhớ cẩn thận ể tránh rò rỉ bộ nhớ và giảm thiểu việc cấp phát và giải phóng bộ nhớ.
• Tối ưu hóa Kích thước Tệp (File Size Optimization):
○ Nén tài nguyên và kích thước tệp ể giảm dung lượng của ứng dụng, ặc biệt ối với trò chơi di ộng.
• Tối ưu hóa Đồ họa (Graphics Optimization):
○ Cài ặt chất lượng ồ họa dựa trên nền tảng và cấu hình của thiết bị ể ảm bảo hiệu suất tốt nhất.
• Tối ưu hóa Mạng (Network Optimization):
○ Tối ưu hóa kết nối mạng và ồng bộ hóa dữ liệu ể giảm ộ trễ và tải trạng thái của mạng.
• Tối ưu hóa Năng lượng (Battery Optimization):
○ Giảm tiêu thụ năng lượng của thiết bị di ộng ể kéo dài thời gian sử dụng pin. 4.8 Source control
• Kiểm soát Phiên bản: Source control giúp theo dõi tất cả các phiên bản của mã nguồn và
tài liệu liên quan. Chúng ta có thể xem lịch sử thay ổi, so sánh phiên bản cũ và phiên bản
mới, và lấy lại các phiên bản trước ó nếu cần.
• Làm việc Nhóm: Trong các dự án phức tạp, nhiều người tham gia phát triển. Source
control cho phép nhiều nhà phát triển làm việc trên cùng một dự án mà không gây xung ột.
Họ có thể làm việc ộc lập trên các nhánh (branches) riêng biệt và sau ó hợp nhất (merge)
các thay ổi lại với nhau.
• Bảo mật và Quyền Truy cập: Chúng ta có thể xác ịnh quyền truy cập cho từng thành
viên trong nhóm. Một số thành viên có quyền ọc và ghi vào mã nguồn, trong khi các thành
viên khác chỉ có quyền ọc. Điều này ảm bảo bảo mật mã nguồn và tránh sự can thiệp không cần thiết.
• Sao lưu và Khôi phục: Source control làm cho việc sao lưu và khôi phục mã nguồn dễ
dàng. Nếu có sự cố hoặc lỗi, chúng ta có thể quay trở lại phiên bản trước ó một cách nhanh chóng.
• Phát triển Đa nền tảng: Nếu chúng ta phát triển trò chơi hoặc ứng dụng cho nhiều nền
tảng như iOS, Android, và máy tính, source control giúp quản lý mã nguồn và tài nguyên
cho mỗi nền tảng một cách hiệu quả.
• Hỗ trợ hợp nhất (Merge Support): Source control cung cấp các công cụ hỗ trợ hợp nhất
(merge) ể giải quyết xung ột khi nhiều người làm việc trên cùng một tệp.
• Kiểm soát Phiên bản Xác thực (Version Tagging): Chúng ta có thể ánh dấu các phiên
bản quan trọng ể dễ dàng theo dõi các phiên bản ã ược phát hành và quản lý phiên bản phát triển và thử nghiệm.
• Công cụ Source Control: Có nhiều hệ thống source control khác nhau, bao gồm Git,
Subversion (SVN), Mercurial, và Perforce, mà chúng ta có thể sử dụng trong phát triển với Unity.
5. Thiết kế game trong Unity:
5.1. Tạo và quản lý assets
• Tổng quan về Asset trong unity
○ Trong Unity, asset là thuật ngữ ược sử dụng ể chỉ các tài nguyên (resources) trong game
như hình ảnh, âm thanh, video, văn bản, 3D models, animations, v.v. Một asset có thể là
bất cứ tệp tin nào trong dự án Unity của Chúng ta, ược sử dụng ể xây dựng, thiết kế và
tạo ra trải nghiệm của game.
○ Các asset trong Unity có thể ược tạo bằng cách tạo mới từ các công cụ trong Unity,
nhưng thường thì chúng ược tạo bên ngoài Unity bằng các phần mềm ồ họa, âm thanh
hoặc video chuyên dụng và sau ó nhập khẩu vào dự án.
○ Quá trình tạo và quản lý các asset trong Unity rất quan trọng ể xây dựng các thành phần
và trải nghiệm trong game của Chúng ta. Các asset ược sử dụng trong các ối tượng, kịch
bản (script), vật liệu (material) và các thành phần khác của game, giúp tạo ra hình ảnh,
âm thanh và tương tác trong game.
○ Unity cung cấp công cụ như Project window ể hiển thị và quản lý các asset trong dự án,
cho phép Chúng ta sắp xếp vào các thư mục, tùy chỉnh các thiết lập và tối ưu hóa kích
thước và hiệu suất của chúng.
• Tạo và quản lý assets trong unity ○ Tạo assets: -
Tạo thủ công: Chúng ta có thể tạo assets bằng cách sử dụng các công cụ trong Unity,
chẳng hạn như tạo GameObject, tạo Sprite, tạo Material, v.v. -
Nhập khẩu từ nguồn bên ngoài: Unity hỗ trợ nhập khẩu nhiều ịnh dạng file như hình
ảnh (PNG, JPEG), âm thanh (WAV, MP3), video (MP4, AVI), 3D models (FBX,
OBJ), v.v. Chúng ta có thể kéo và thả các file này vào dự án Unity ể tạo assets. ○ Quản lý assets: -
Project window: Project window trong Unity hiển thị tất cả các assets có trong dự
án. Chúng ta có thể tạo thư mục và tổ chức các assets vào các thư mục khác nhau ể quản lý tốt hơn. -
Import settings: Unity cho phép Chúng ta tùy chỉnh các thiết lập khi nhập khẩu
assets. Bằng cách chọn một asset trong Project window, Chúng ta có thể iều chỉnh
các thiết lập như kích thước, ịnh dạng, nén, màu sắc, v.v. -
Prefabs: Prefab là một cách ể tạo ra các asset có thể tái sử dụng. Chúng ta có thể tạo
Prefab từ một GameObject hoặc một nhóm các GameObject. Prefab cho phép Chúng
ta duy trì cấu trúc và thuộc tính của asset trong nhiều scene khác nhau. ○ Sử dụng assets: -
Trong Scene: Chúng ta có thể kéo và thả assets từ Project window vào Scene ể sử
dụng chúng. Ví dụ, kéo một Sprite vào một GameObject ể hiển thị hình ảnh trên màn hình. -
Trong Script: Chúng ta có thể sử dụng assets trong Code Script của mình bằng cách
truy cập và tham chiếu ến chúng. Ví dụ, Chúng ta có thể sử dụng một Texture ể ặt
làm hình nền cho một ối tượng hoặc sử dụng một AudioClip ể phát âm thanh trong game. ○ Tối ưu hóa assets: -
Compression: Unity cho phép Chúng ta nén và tối ưu hóa kích thước của các assets,
ặc biệt là hình ảnh và âm thanh, ể giảm dung lượng của dự án và tăng hiệu suất chạy game. -
LOD (Level of Detail): Với các assets 3D, Chúng ta có thể tạo các mức ộ chi tiết
khác nhau (LOD) ể tăng hiệu suất. LOD cho phép Chúng ta thay thế các phiên bản
ơn giản hơn của một mesh khi xa khỏi người chơi. -
Asset Bundles: Unity cho phép Chúng ta tạo Asset Bundles, là các gói assets riêng lẻ,
ể tải xuống và quản lý assets theo yêu cầu, giúp giảm thời gian tải và tiết kiệm tài nguyên. ○ Các nguồn assets -
Unity Asset Store: Unity Asset Store là một nền tảng trực tuyến cung cấp hàng ngàn
asset sẵn có ể mua hoặc tải về miễn phí. Chúng ta có thể tìm kiếm các asset như 3D
models, textures, animations, audio, plugins và nhiều hơn nữa từ các nhà phát triển
và nghệ sĩ ộc lập trên toàn thế giới. -
Unity Community: Cộng ồng Unity rất phong phú và sáng tạo. Chúng ta có thể tìm
kiếm các trang web, diễn àn, nhóm Facebook hoặc subreddit liên quan ến Unity ể tìm
kiếm và chia sẻ các asset miễn phí hoặc ược chia sẻ bởi cộng ồng. Có nhiều nghệ sĩ
và nhà phát triển sẵn lòng chia sẻ các asset mà họ ã tạo ra. -
Tự thiết kế: Chúng ta có thể tạo các asset của riêng mình bằng cách sử dụng các
công cụ và phần mềm ồ họa như Blender, Maya, Photoshop, Audacity, v.v. Bằng
cách tạo và chỉnh sửa các asset từ ầu, Chúng ta có thể tạo ra nội dung ộc áo và phù
hợp với yêu cầu của dự án của mình. -
Open source: Có nhiều nguồn mở (open source) mà Chúng ta có thể tìm thấy các
asset miễn phí, chẳng hạn như các thư viện Code nguồn mở, các trang web chia sẻ
miễn phí, hoặc dự án Code nguồn mở trên GitHub. Chúng ta có thể tìm thấy các asset
như scripts, shaders, models, textures và nhiều hơn nữa. -
Khi sử dụng các asset từ các nguồn khác nhau, hãy ảm bảo kiểm tra và tuân thủ các
iều khoản sử dụng và giấy phép của từng asset.
○ Cách import assets từ các nguồn bên ngoài -
Tìm hiểu về ịnh dạng tệp tin ược hỗ trợ: Unity hỗ trợ nhiều ịnh dạng tệp tin, bao
gồm FBX, OBJ, PNG, JPG, và nhiều hơn nữa. Đảm bảo assets muốn import có ịnh dạng tệp tin phù hợp. -
Chuẩn bị tài liệu và assets: Đảm bảo Chúng ta có tài liệu và assets cần thiết ể
import. Điều này có thể bao gồm các tệp tin 3D, textures, hình ảnh, âm thanh, v.v. -
Mở Unity và tạo dự án mới hoặc mở dự án hiện tại. -
Tìm hiểu về cấu trúc thư mục của dự án Unity: Hiểu cách các tệp tin và thư mục
ược tổ chức trong dự án Unity ể biết chính xác nơi muốn import assets. -
Chọn "Assets" trong trình ơn Unity và chọn "Import New Asset" hoặc kéo và thả tệp
tin vào cửa sổ dự án Unity. Đảm bảo chọn vị trí úng trong dự án ể import tệp tin. -
Chờ Unity xử lý tệp tin: Unity sẽ xử lý và import tệp tin vào dự án. Thời gian xử lý
tùy thuộc vào kích thước và loại tệp tin. -
Kiểm tra: Kiểm tra trong cửa sổ Dự án Unity ể xem assets ã ược import thành công.
Chúng ta có thể kéo và thả tài sản vào cảnh (scene) hoặc sử dụng chúng trong các
thành phần khác như vật thể 3D, vật thể 2D, v.v.
5.2. Sử dụng Unity's Physics ể xử lý vật lý trong game.
• Tổng quan về Unity’s Physics
○ Unity Physics là một hệ thống vật lý tích hợp sẵn trong Unity, giúp Chúng ta mô phỏng
và xử lý các hiệu ứng vật lý trong game của mình. Nó cung cấp các công cụ và tính
năng ể mô phỏng va chạm, vật lý vật thể, và tương tác giữa các ối tượng trong môi trường 3D hoặc 2D.
• Một số khái niệm và tính năng chính của Unity Physics:
○ Rigidbodies: Rigidbody là một thành phần của GameObject trong Unity Physics, cho
phép vật thể di chuyển và tương tác với lực và va chạm trong môi trường vật lý. Bằng
cách gắn Rigidbody vào một GameObject, Chúng ta có thể áp dụng các lực như trọng
lực, lực ẩy và lực kéo, và vật thể sẽ tự ộng thích ứng và di chuyển theo các nguyên tắc vật lý.
Hình ảnh 28: Giao diện của Rigidbody
○ Colliders: Collider là một thành phần ược sử dụng ể xác ịnh vùng không gian và hình
dạng của một ối tượng trong Unity Physics. Chúng ta có thể gắn Collider vào một
GameObject ể xác ịnh khu vực va chạm và tương tác vật lý với các ối tượng khác.
Unity cung cấp nhiều loại Collider như Box Collider, Sphere Collider, Capsule Collider
và Mesh Collider ể phù hợp với hình dạng và kích thước của ối tượng.
Hình ảnh 29: Giao diện của Box Collider
○ Joint và Constraints: Unity Physics cung cấp các loại Joint và Constraints ể giới hạn và
iều khiển các mối liên kết giữa các vật thể. Ví dụ, Chúng ta có thể sử dụng Hinge Joint
ể tạo các khớp xoay giữa các vật thể, hoặc sử dụng Fixed Joint ể khóa các vật thể lại với nhau.
Hình ảnh 30: Giao diện Hinge Joint
○ Layers và Collision Matrix: Unity cho phép Chúng ta xác ịnh các Layers và Collision
Matrix ể kiểm soát việc va chạm giữa các ối tượng. Chúng ta có thể xác ịnh quy tắc va
chạm giữa các Layers khác nhau và quyết ịnh xem chúng có tương tác vật lý hay không.
Hình ảnh 31: Giao diện Layer Collision Matrix
○ Raycasting: Raycasting là một phương pháp sử dụng tia (ray) ảo ể kiểm tra va chạm và
tương tác với các ối tượng trong môi trường. Unity Physics cung cấp hỗ trợ cho Raycast
và Spherecast, cho phép Chúng ta kiểm tra va chạm và lấy thông tin từ các ối tượng xung quanh.
Hình ảnh 32: Minh họa về Raycast
• Unity Physics cung cấp một cách tiếp cận linh hoạt và mạnh mẽ ể xử lý vật lý trong game
của Chúng ta. Với các thành phần và tính năng này, Chúng ta có thể tạo ra các hiệu ứng
vật lý chân thực như va chạm, rơi tự do, nảy, kéo và kéo, và nhiều hơn nữa.
5.3. Sử dụng các phần mềm hỗ trợ như Blender hoặc Photoshop ể tạo nội dung.
• Có rất nhiều phần mềm khác mà Chúng ta có thể sử dụng ể tạo asset cho Unity. Dưới ây là
một số phần mềm phổ biến khác:
○ Autodesk Maya: Maya là một phần mềm 3D chuyên nghiệp ược sử dụng rộng rãi trong
ngành công nghiệp phim, trò chơi và thiết kế 3D. Nó cung cấp các công cụ mạnh mẽ ể
tạo và chỉnh sửa các mô hình 3D, animations, và các hiệu ứng ặc biệt.
○ 3ds Max: 3ds Max là một phần mềm 3D của Autodesk, chủ yếu ược sử dụng trong ngành
công nghiệp trò chơi và phim ảnh. Nó cung cấp các công cụ ể tạo và chỉnh sửa mô hình
3D, animations, và các hiệu ứng ặc biệt.
○ Substance Painter: Substance Painter là một công cụ tạo và chỉnh sửa textures 3D. Nó
cung cấp các tính năng tạo textures chất lượng cao, bao gồm vẽ trực tiếp trên bề mặt
3D, tạo hiệu ứng vật liệu phức tạp và xuất khẩu textures a kênh cho Unity.
○ ZBrush: ZBrush là một phần mềm chuyên dụng cho việc sculpting và tạo hình 3D. Nó
cho phép Chúng ta tạo ra các chi tiết cao cấp trên mô hình 3D và tạo ra các bản ghi
chính xác cho việc tạo textures và normal maps.
○ Adobe Illustrator: Illustrator là một phần mềm ồ họa vector chuyên nghiệp. Chúng ta có
thể sử dụng nó ể tạo các hình ảnh vector, biểu ồ và các thành phần UI cho game Unity.
○ Aseprite: Aseprite là một phần mềm chỉnh sửa sprite và pixel art. Nó cung cấp các công
cụ ặc biệt ể tạo và chỉnh sửa sprite, animation sprite và ồ họa pixel.
• Đây chỉ là một số phần mềm hỗ trợ phổ biến, và còn nhiều phần mềm khác có thể ược sử
dụng tùy thuộc vào nhu cầu và sở thích cá nhân như Blender, Photoshop, ….
6. UI và UX trong Unity: 6.1. Tổng quan
• Thiết kế giao diện người dùng ơn giản là sử dụng các assets có sẵn (hình ảnh, font chữ, các
hiệu ứng, ...), sắp xếp chúng theo 1 bố cục ược Designer thiết kế, các assets này có thể tìm
thấy trên các website, Assets Store của Unity, hoặc do chính các Designer, Artist trong dự án thiết kế.
• Các thành phần cơ bản trong thiết kế UI bao gồm Canvas, Text, Image, Button, … 6.2. Canvas
• Canvas là thành phần chính không thể thiếu trong thiết kế UI, các thành phần UI khác khi
ược khởi tạo bắt buộc phải nằm trong 1 Canvas. Khi khởi tạo 1 thành phần UI (Text,
Image, ...), Unity sẽ tự ộng tạo ra 1 Canvas nếu chưa tồn tại trong Scene.
• Để khởi tạo 1 Canvas, trong cửa sổ Hierarchy, chọn Create → UI → Canvas. Các ối tượng
UI khác cũng ược khởi tạo tương tự.
Hình ảnh 33: Canvas trong Unity
• Các ối tượng con của 1 Canvas sẽ ược render theo thứ tự từ trên xuống trong cửa sổ
Hierarchy, ối tượng nào ở trên sẽ ược render trước và có thể bị che khuất bởi ối tượng phía dưới. • Render mode
○ Có 3 tuỳ chọn hiển thị Canvas: -
Screen Space – Overlay: Canvas sẽ ược vẽ lên layer cao nhất của màn hình và nằm
trên mọi GameObject khác. Canvas với render mode này hoàn toàn không phụ thuộc vào camera. -
Screen Space – Camera: ối với mode này, cần chỉ ịnh 1 camera cho Canvas, nó sẽ
ược render theo camera, nếu như không có camera ược chỉ ịnh thì Canvas và các
thành phần bên trong sẽ không ược render. -
World Space: với tuỳ chọn này, ối tượng Canvas sẽ ược xem như 1 GameObject
thông thường, tuỳ chọn này sử dụng event camera thay vì render camera. Ngoài các
chức năng như render camera, event camera còn có thêm chức năng bắt sự kiện, dựa
trên thứ tự render, toạ ộ z, ... của các ối tượng UI. ○ Ss_2
Hình ảnh 34: Chế ộ render
○ Đối với các tùy chọn render theo Screen Space, Unity cung cấp tính năng Pixel Perfect,
tăng khả năng hiển thị sắc nét và khử vết mờ. • Rect Transform
○ Tương tự như thành phần Transform trong các GameObject khác, Rect Transform ược
sử dụng ể xác ịnh kích thước, vị trí của giao diện.
○ Đối với các tuỳ chọn render mode Screen Space - Overlay và Screen Space - Camera,
thành phần Rect Transform sẽ ược khoá lại và không thể tuỳ chỉnh. Canvas sẽ iều chỉnh
các thông số 1 cách tự ộng ể phù hợp với ộ phân giải màn hình game. • Graphic Raycast
○ Hỗ trợ bắt sự kiện, khi nhận ược tín hiệu (mouse click, touch, ...), 1 tia nhìn tại vị trí
tương tác sẽ ược tạo ra, bằng cách này dễ dàng xác ịnh ược ối tượng người chơi muốn
tương tác, thông qua tọa ộ z của ối tượng. 6.3. Text
• UI Text ược sử dụng ể hiển thị các thông tin trên màn hình như Score, Lives, Times, ... 1
số game sử dụng các texture riêng ể hiển thị thông tin thay cho text, tuy nhiên text vẫn là
lựa chọn phổ biến hơn vì tính ơn giản và dễ thao tác.
• Sau khi khởi tạo 1 ối tượng Text, cửa sổ Inspector có dạng như sau:
Hình ảnh 35: Inspector ối tượng Text
○ Rect Transform: quản lý vị trí, kích thước, góc quay, ... của Text.
○ Text: lưu trữ chuỗi ký tự cần hiển thị ra màn hình. Unity hỗ trợ 1 số chức năng ể tuỳ biến
chuỗi như font, kiểu chữ (thường, in ậm, in nghiêng, ...), cỡ chữ, màu chữ, ... Tuỳ chọn
Best Fit sẽ tự ộng iều chỉnh kích thước font chữ phù hợp với kích thước ược quy ịnh trong Rect Transform. 6.4. Image
• UI Image ược sử dụng rất phổ biến, như thiết kế background, các button, title, ...
• Chọn hình ảnh và kéo thả vào khung Source Image, ngoài ra còn có 1 số tuỳ chọn thay ổi
màu sắc, chất liệu, …
Hình ảnh 36: Inspector ối tượng Image 6.5 Button
• UI Button là 1 thành phần quan trọng, giúp người chơi tương tác với game. 1 số button quen
thuộc có thể thấy trong nhiều game là Play, Pause, Resume, Replay, …
Hình ảnh 37: Inspector ối tượng Button
• Unity cung cấp khá nhiều tính năng giúp hiển thị và thao tác với button ược dễ dàng và ẹp hơn.
• Về hiển thị, có 4 tùy chọn hiển thị trong phần Transition:
Hình ảnh 38: Transiton ối tượng Button
○ None: sử dụng hình ảnh button ược truyền vào thành phần Image. Với tùy chọn này, hình
hiển thị button sẽ không thay ổi mỗi khi người chơi thao tác.
○ Color Tint, Sprite Swap và Animation có các tùy chọn hiển thị riêng cho từng trạng thái
của button. Với Color Tint, button sẽ thay ổi màu sắc theo từng trạng thái, Sprite Swap
có hỗ trợ thay ổi sprite theo trạng thái, Animation hỗ trợ thêm các ặc tính như scale,
transform, … Tùy vào yêu cầu của game mà lựa chọn tùy chọn phù hợp.
• Về phần tương tác, Unity cung cấp sẵn event On Click. Khi click vào button, tất cả các
hành ộng ược thiết lập sẵn trong event On Click sẽ ược thực hiện, do ó có thể thực hiện
ồng thời nhiều hành ộng tùy theo nhu cầu.
○ Các ối tượng ược thêm vào có thể là 1 GameObject trong cửa sổ Hierarchy hoặc chính
button ó. Khi ó event sẽ tự ộng nhận ược các thành phần của GameObject và hiển thị
trong menu như trong hình dưới.
Hình ảnh 39: Event OnClick
○ * Nếu cần gọi 1 hàm trong script, script ó phải ược gắn vào 1 GameObject trong cửa sổ
Hierarchy và hàm này cần có phạm vi truy cập là public.
• Ngoài ra, còn hàng loạt event khác cho button ược cung cấp trong thành phần Event
Trigger (Add Component -> Event -> Event Trigger). Cách sử dụng tương tự như với event On Click.
6.6 Thao tác với các ối tượng UI trong Script
• Hầu hết thao tác với các ối tượng UI trên cửa sổ Inspector ều có thể ược thực hiện trong Script.
• Các ối tượng UI ã ược trừu tượng hóa thành các class và ược ặt trong 1 namespace có tên là UnityEngine.UI.
• Ví dụ sau minh họa 1 vài thao tác với các ối tượng UI cơ bản:
Hình ảnh 40: Script ơn giản ể tương tác với ối tượng
• Ngoài ra, khi xử lý các ối tượng UI ối với game hỗ trợ a màn hình, cần gắn anchor point cho
tất cả các ối tượng.
7. Trò chơi a nền tảng và tích hợp mạng:
7.1. Nghiên cứu về cách phát triển trò chơi a nền tảng (multiplatform).
• Unity là một công cụ phát triển trò chơi mạnh mẽ và a nền tảng, cho phép bạn xây dựng trò
chơi trên nhiều nền tảng khác nhau. Dưới ây là danh sách các nền tảng mà Unity có thể phát triển: • Desktop: ○ Windows ○ macOS ○ Linux • Mobile: ○ iOS ○ Android ○ Windows Phone • Console: ○ PlayStation 4 ○ PlayStation 5 ○ Xbox One ○ Xbox Series X/S ○ Nintendo Switch • Web:
○ WebGL (có thể chạy trên trình duyệt web)
• Augmented Reality (AR): ○ ARKit (iOS) ○ ARCore (Android) ○ Magic Leap
• Virtual Reality (VR): ○ Oculus Rift ○ Oculus Quest ○ HTC Vive ○ Windows Mixed Reality ○ PlayStation VR • Smart TV: ○ Samsung Smart TV ○ LG Smart TV ○ Android TV • Embedded Systems: ○ Google Cardboard (VR) ○ Google Daydream (VR)
• Đây chỉ là một số nền tảng phổ biến mà Unity hỗ trợ. Unity cung cấp nền tảng a dạng và
linh hoạt, cho phép nhà phát triển tạo ra trò chơi trên nhiều thiết bị và hệ iều hành khác
nhau một cách thuận tiện và hiệu quả.
• Cách xây dựng và chạy ứng dụng game với unity
○ Xác ịnh nền tảng mong muốn ở trong tab Build setting (Cài ặt bản dựng)
- Mở dự án Unity, nháy chuột vào trang file ở góc trái bên trên của cửa sổ Unity. Chọn Build Settings
Hình ảnh 41: Phần File trong Unity -
Một cửa sổ mới hiện ra, chọn nền tảng cho game ang xây dựng
Hình ảnh 42: Giao diện phần Build Settings
- Chọn chính xác scenes muốn xuất ra
 Trong phần Scenes In Build, chọn scenes mà bạn muốn có trong game của bạn khi xuất ra
Hình ảnh 43: Giao diện phần Build Settings, phần các Scene ể xây dựng
 Nếu không thấy scenes, chọn Add Open Scenes và ảm bảo scene ó ang mở trong unity
○ Chỉnh sửa một số cài ặt khác của dự án như icon, màn hình hiển thị, ộ phân giải. -
Ở góc dưới bên trái của cửa sổ Build Settings, chọn Player Settings
Hình ảnh 44: Giao diện phần Build Settings, nút Player Settings -
Một cửa sổ khác sẽ hiện ra cho phép chỉnh sửa một số cài ặt khác như âm thanh, ộ
phân giải, icon, hoặc ồ họa. Ví dụ, trong tab Audio, có thể chỉnh sửa Default Speaker
Mode (Chế ộ loa cơ bản). Một số lựa chọn như Stereo (âm thanh nổi),
Mono (âm thanh duy nhất) hoặc Surround (âm thanh xung quanh)
Hình ảnh 45: Giao diện phần Audio trong Project Settings -
Mở tab Player. Chọn tên công ty (tác giả), tên sản phẩm, phiên bản game
Hình ảnh 46: Giao diện phần Player trong Project Settings -
Chọn icon mặc ịnh của game. Có thể mở rộng phần Icon ể chỉnh sửa, chọn các icon
cho các màn hình khác nhau
Hình ảnh 47: Giao diện phần Player (Icon) trong Project Settings -
Mở phần Resolution and Presentation, và chọn ộ phân giải cho game
Hình ảnh 48: Giao diện phần Player (Resolution and Presentation) trong Project Settings -
Mở phần Splash Image. Đây là nơi bạn chỉnh sửa màn hình mở ầu, là màn hình xuất
hiện ầu tiên khi người chơi mở game.
Hình ảnh 49: Giao diện phần Player (Splash Image) trong Project Settings
○ Có thể tìm thấy một số cài ặt khác như Compression settings (Cài ặt nén) hoặc stack trace
logging (nhật ký theo dõi) nếu mở phần Other
○ Xây dựng và chạy dự án trong phần Build Settings -
Nháy chuột vào phần Build and Run, chọn thư mục ể lưu trữ các tệp của game
Hình ảnh 50: Giao diện của phần Build Settings, nút Build and Run -
Khi quá trình xây dựng ược hoàn thành, trò chơi sẽ tự ộng chạy. Unity sẽ hiển thị
màn hình mở ầu trước khi bắt ầu trò chơi
Hình ảnh 51: Màn hình mở ầu -
Di chuyển tới thư mục nơi lưu trữ các tệp game ể xem cấu trục thư mục của dự án.
Việc này sẽ phụ thuộc vào nền tảng phát triển game. Ví dụ, ối với trò chơi chỉ chạy
trên máy tính, trò chơi sẽ bao gồm tệp .exe (tệp thực thi)
Hình ảnh 52: Cấu trúc thư mục cơ bản của một trò chơi
• Một số lưu ý khi phát triển trò chơi a nền tảng:
○ Thiết kế giao diện người dùng linh hoạt: Tạo giao diện người dùng mạnh mẽ và linh
hoạt ể áp ứng các kích thước màn hình và tỷ lệ khung hình khác nhau trên các nền tảng
khác nhau. Sử dụng các thành phần UI linh hoạt như anchoring, layout groups và
responsive design ể ảm bảo giao diện người dùng hoạt ộng tốt trên mọi nền tảng.
○ Tách riêng logic game và giao diện người dùng: Đảm bảo rằng logic game và giao diện
người dùng ược tách riêng nhau. Điều này giúp tái sử dụng mã nguồn và quản lý dễ
dàng các iều chỉnh giao diện cho từng nền tảng cụ thể.
○ Quản lý tài nguyên: Đối với trò chơi a nền tảng, quản lý tài nguyên là rất quan trọng.
Đảm bảo rằng tất cả hình ảnh, âm thanh và tài nguyên khác ược tối ưu hóa kích thước
và ịnh dạng ể giảm bớt dung lượng và tối ưu hóa hiệu suất trò chơi trên mọi nền tảng.
○ Kiểm tra chéo nền tảng: Thực hiện kiểm tra và thử nghiệm trò chơi trên mọi nền tảng
mục tiêu. Điều này giúp phát hiện và sửa lỗi cụ thể của từng phiên bản, ảm bảo trò chơi
hoạt ộng chính xác và không gặp vấn ề trên mỗi nền tảng.
○ Xử lý khác biệt phần cứng và hệ iều hành: Mỗi nền tảng có các ặc iểm phần cứng và
hệ iều hành khác nhau. Hãy xem xét các yêu cầu phần cứng, hiệu năng và hạn chế của
từng nền tảng và ảm bảo rằng trò chơi của bạn tương thích và hoạt ộng tốt trên mọi phiên bản.
○ Tối ưu hóa hiệu suất: Tối ưu hóa hiệu suất trò chơi ể ảm bảo nó chạy mượt mà và tối ưu
trên mọi nền tảng. Sử dụng kỹ thuật cắt tỉa (culling), tối ưu hóa ồ họa, quản lý bộ nhớ
và sử dụng các công cụ tối ưu hóa của Unity ể cải thiện hiệu suất trò chơi.
○ Hỗ trợ nền tảng ặc biệt: Nếu bạn muốn phát triển trò chơi cho các nền tảng ặc biệt như
VR (Virtual Reality) hoặc AR (Augmented Reality), hãy tìm hiểu về các công nghệ và
yêu cầu riêng của từng nền tảng. Unity cung cấp các công cụ và tích hợp sẵn ể hỗ trợ
phát triển trò chơi trên các nền tảng này.
○ Quản lý phiên bản và cập nhật: Sử dụng hệ thống quản lý phiên bản ể theo dõi và quản
lý mã nguồn trò chơi trên các nền tảng khác nhau. Điều này giúp bạn theo dõi các phiên
bản, áp dụng các cập nhật và sửa lỗi dễ dàng trên mỗi nền tảng cụ thể.
○ Hỗ trợ ngôn ngữ a quốc gia: Nếu bạn muốn phát hành trò chơi a ngôn ngữ, hãy xem xét
việc sử dụng các công cụ hỗ trợ a ngôn ngữ của Unity. Đảm bảo rằng trò chơi của bạn
có thể dễ dàng dịch và iều chỉnh ể phù hợp với các ngôn ngữ và văn hóa khác nhau trên mỗi nền tảng.
○ Theo dõi và tương tác với cộng ồng: Unity có một cộng ồng rất lớn và sôi ộng. Hãy
tham gia các diễn àn, nhóm thảo luận và các sự kiện ể học hỏi từ những người khác và
chia sẻ kiến thức của bạn. Điều này giúp bạn nắm bắt ược các xu hướng mới, tìm hiểu
các phương pháp tốt nhất và nhận ược sự hỗ trợ từ cộng ồng Unity.
○ Tóm lại, phát triển trò chơi a nền tảng với Unity òi hỏi sự linh hoạt, quản lý tài nguyên tốt
và kiến thức về các yêu cầu và ặc iểm của từng nền tảng cụ thể. Bằng cách tuân thủ các
lưu ý trên, bạn sẽ có iểm khởi ầu tốt ể xây dựng trò chơi thành công trên nhiều nền tảng khác nhau.
7.2. Tích hợp mạng và xây dựng trò chơi a người chơi (multiplayer).
• Tổng quan về trò chơi a người chơi (multiplayer)
○ Multiplayer ( a người chơi) là thuật ngữ ược sử dụng ể chỉ trò chơi mà nhiều người có thể
tham gia cùng một lúc, tương tác và chơi với nhau thông qua mạng. Trong trò chơi a
người chơi, người chơi có thể kết nối và tương tác với nhau trong một môi trường ảo chung.
○ Có hai loại chính của trò chơi a người chơi. -
Local Multiplayer (Đa người chơi cùng một máy): Trong local multiplayer, các
người chơi cùng ngồi chơi trên cùng một máy tính hoặc thiết bị di ộng. Thông
thường, mỗi người chơi sẽ có một bộ iều khiển riêng ể tham gia vào trò chơi. Ví dụ
iển hình của local multiplayer là các trò chơi ối kháng trên console hoặc các trò chơi
như Mario Kart trên máy chơi game di ộng. -
Online Multiplayer (Đa người chơi trực tuyến): Trong online multiplayer, người
chơi kết nối và chơi với nhau thông qua mạng internet. Mỗi người chơi sẽ có một
thiết bị riêng (máy tính, console, hoặc thiết bị di ộng) và kết nối với một máy chủ
hoặc thông qua hệ thống peer-to-peer ể tương tác với các người chơi khác từ xa. Ví
dụ của online multiplayer bao gồm các trò chơi như World of Warcraft, Fortnite, hay Call of Duty: Warzone.
○ Trò chơi a người chơi mang lại trải nghiệm tương tác xã hội, cạnh tranh hoặc hợp tác
giữa người chơi. Nó cũng mở ra nhiều cơ hội cho việc kết nối và giao lưu giữa cộng ồng
game thủ trên khắp thế giới.
• Các bước cơ bản ể tích hợp mạng và xây dựng trò chơi a người chơi
○ Để tích hợp mạng và xây dựng trò chơi a người chơi trong Unity, Chúng ta có thể sử
dụng các công nghệ và công cụ như Unity Multiplayer Services, Unity Networking,
hoặc các plugin mạng bên thứ ba. Dưới ây là một tổng quan về quá trình tích hợp mạng
và xây dựng trò chơi a người chơi trong Unity:
○ Xác ịnh kiểu trò chơi a người chơi: Đầu tiên, xác ịnh loại trò chơi a người chơi Chúng
ta muốn xây dựng. Trò chơi có thể là peer-to-peer (ngang hàng) hoặc dựa trên máy chủ
(client-server). Điều này sẽ quyết ịnh phương pháp mạng và công nghệ Chúng ta sẽ sử dụng.
○ Tìm hiểu về các công nghệ mạng trong Unity: Unity cung cấp các công nghệ mạng như
Unity Multiplayer Services và Unity Networking. Unity Multiplayer Services cung cấp
các dịch vụ mạng trực tuyến như matchmaking, lưu trữ dữ liệu và kết nối mạng. Unity
Networking (UNET) cung cấp các công cụ ể xây dựng trò chơi a người chơi sử dụng
kiến trúc client-server hoặc peer-to-peer. Ngoài ra, có nhiều plugin mạng bên thứ ba
như Photon, Mirror, và uNetRPG có sẵn ể tích hợp vào Unity.
○ Xây dựng kiến trúc mạng: Dựa trên loại trò chơi a người chơi và công nghệ mạng
Chúng ta chọn, xây dựng kiến trúc mạng phù hợp. Điều này bao gồm việc xác ịnh vai
trò của máy chủ và các khách hàng, quyết ịnh cách thông báo, ồng bộ hóa dữ liệu và xử lý các sự kiện mạng.
○ Xử lý ồng bộ hóa dữ liệu: Trong trò chơi a người chơi, việc ồng bộ hóa dữ liệu giữa các
máy khách là rất quan trọng. Chúng ta cần xác ịnh cách ồng bộ hóa vị trí, hành ộng,
trạng thái và các yếu tố khác giữa các người chơi. Sử dụng các phương thức như
interpolation, extrapolation và prediction ể ảm bảo sự mượt mà và chính xác trong trò chơi a người chơi.
○ Xử lý các sự kiện mạng: Trong trò chơi a người chơi, các sự kiện mạng như kết nối, mất
kết nối, di chuyển, tương tác giữa người chơi, vv. Cần ược xử lý một cách úng ắn. Đảm
bảo rằng Chúng ta có các hàm callback và xử lý sự kiện phù hợp ể nhận dạng và xử lý các sự kiện mạng.
○ Kiểm tra và gỡ lỗi: Sau khi xây dựng chức năng a người chơi, kiểm tra và gỡ lỗi trò chơi
trong môi trường a người chơi thực tế. Đảm bảo rằng tất cả các chức năng mạng hoạt
ộng chính xác và mượt mà, và xử lý các vấn ề như ộ trễ, ồng bộ hóa và hiệu suất.
Triển khai trò chơi: Khi trò chơi ã hoàn thành và ược thử nghiệm, Chúng ta có thể triển
khai và triển khai trò chơi ể người chơi có thể kết nối và tham gia. Điều này bao gồm việc
triển khai máy chủ trò chơi (nếu áp dụng), cấu hình mạng, xử lý bảo mật và quản lý phiên kết nối người chơi.
○ Lưu ý rằng việc tích hợp mạng và xây dựng trò chơi a người chơi trong Unity có thể phức
tạp và òi hỏi hiểu biết về lập trình mạng và kiến thức chung về trò chơi a người chơi.
Nếu Chúng ta mới bắt ầu, có thể cần tìm hiểu thêm về các nguyên tắc và kỹ thuật liên
quan ến mạng và trò chơi a người chơi trước khi bắt ầu.
8. Hiệu suất và tối ưu hóa:
• Tối ưu hóa hiệu suất trong Unity là một phần quan trọng của quá trình phát triển trò chơi,
ặc biệt khi bạn muốn ảm bảo rằng trò chơi của bạn hoạt ộng mượt mà trên các thiết bị khác nhau.
• Công cụ tối ưu hóa:
○ Profiler: Profiler là một công cụ quan trọng trong Unity ể theo dõi và phân tích hiệu suất
trò chơi của bạn. Nó cung cấp thông tin về thời gian xử lý, vẽ, bộ nhớ và nhiều khía
cạnh khác của ứng dụng của bạn. Profiler giúp bạn xác ịnh các phần của trò chơi gây ra
sự chậm trễ và tìm cách tối ưu hóa chúng.
Hình ảnh 53: Profiler trong unity
○ Frame Debugger: Frame Debugger cho phép bạn xem cách Unity vẽ mỗi khung hình
của trò chơi, giúp bạn xác ịnh vấn ề trong quá trình vẽ.
Hình ảnh 54: Frame Debug trong unity
9. Hỗ trợ và cộng ồng: • Cộng ồng Unity:
○ Unity có một cộng ồng rất mạnh mẽ và ông ảo trên toàn thế giới. Chúng ta có thể tham
gia vào các diễn àn, nhóm Facebook, Reddit, và các nền tảng khác liên quan ến Unity ể
ặt câu hỏi, chia sẻ thông tin, và học hỏi từ người khác.
○ Unity Answers: Unity Answers là một diễn àn nơi chúng ta có thể ặt câu hỏi và tìm kiếm
câu trả lời từ cộng ồng. Nó rất hữu ích ể giải quyết vấn ề kỹ thuật.
○ Unity Forum: Unity có một diễn àn chính thức với nhiều chuyên mục khác nhau, từ lập
trình, ồ họa, âm thanh ến tối ưu hóa hiệu suất.
• Tài liệu và Tài liệu Học liệu:
○ Unity cung cấp tài liệu học liệu chính thức trên trang web của họ, bao gồm hướng dẫn,
ví dụ code nguồn, video học, và tài liệu hướng dẫn.
○ Unity Learn: Unity Learn là một nền tảng trực tuyến cung cấp nhiều khóa học miễn phí
về Unity, từ lập trình cơ bản ến phát triển trò chơi nâng cao.
○ Tài liệu Unity: Unity cũng có một phần tài liệu phong phú về tất cả các khía cạnh của trò
chơi và phát triển ứng dụng.
• Thư viện và Công cụ Bên Ngoài:
○ Unity cũng hỗ trợ sử dụng các thư viện và công cụ bên ngoài ược tạo bởi cộng ồng và
các công ty khác ể giúp Chúng ta phát triển trò chơi và ứng dụng nhanh hơn. Ví dụ: thư
viện như TextMesh Pro, DoozyUI, Playmaker, và các công cụ như ProBuilder giúp
Chúng ta tạo các tính năng phức tạp một cách dễ dàng.
10. Thử nghiệm và debugging:
• Unity cung cấp nhiều công cụ debugging và thử nghiệm game hữu
ích ể giúp Chúng ta phát hiện và sửa lỗi trong quá trình phát triển
game. Dưới ây là một số công cụ phổ biến có sẵn trong Unity:
○ Unity Debugger: Unity Debugger cho phép Chúng ta theo dõi và kiểm tra các biến,
các giá trị trong quá trình chạy game. Chúng ta có thể dừng game ở các iểm dừng
(breakpoints), theo dõi biến, thay ổi giá trị và xem stack trace ể tìm hiểu về lỗi và vấn ề trong Code của Chúng ta.
○ Console Window: Cửa sổ Console hiển thị các thông báo, cảnh báo và lỗi trong quá
trình chạy game. Chúng ta có thể sử dụng nó ể ghi lại thông tin debug, in ra giá trị của
các biến hoặc ghi lại thông tin quan trọng trong quá trình phát triển.
○ Profiler: Profiler là một công cụ mạnh mẽ giúp Chúng ta phân tích hiệu suất của game.
Nó cung cấp thông tin về sử dụng CPU, GPU, bộ nhớ và các tài nguyên khác trong quá
trình chạy game. Bằng cách sử dụng Profiler, Chúng ta có thể xác ịnh các vấn ề hiệu
suất và tối ưu hóa game của mình.
○ Play Mode: Trong Unity, Play Mode cho phép Chúng ta chạy game trong môi trường
phát triển ể kiểm tra và thử nghiệm các tính năng. Chúng ta có thể thay ổi và thử
nghiệm các giá trị, tương tác với game và kiểm tra hành vi trong thời gian thực.
○ Unity Test Runner: Unity Test Runner là một công cụ tích hợp ể viết và chạy các bài
kiểm tra tự ộng (automated tests) trong Unity. Chúng ta có thể viết các bài kiểm tra ể
kiểm tra các chức năng, hành vi và logic của game.
○ Remote Debugging: Unity hỗ trợ remote debugging, cho phép Chúng ta kết nối vào game
ang chạy trên các thiết bị di ộng hoặc các nền tảng khác ể theo dõi và gỡ lỗi từ xa.
○ Đây chỉ là một số công cụ phổ biến trong Unity. Unity còn rất nhiều công cụ khác ể hỗ
trợ quá trình debugging và thử nghiệm game. Hãy tìm hiểu và tận dụng những công cụ
này ể cải thiện quá trình phát triển và chất lượng của game của Chúng ta.
• Thử nghiệm và Debug với Unity Debugger ○ Mở Unity và mở dự án.
○ Chọn mục "Window" trên thanh menu, sau ó chọn "Analysis" và "Debugger" ể mở cửa sổ Unity Debugger.
○ Trong cửa sổ Unity Debugger, Chúng ta sẽ thấy các nút iều khiển như "Play", "Pause",
"Step Over", "Step Into", "Step Out", và "Stop". Sử dụng các nút này ể kiểm soát quá trình gỡ lỗi.
○ Để ặt một iểm dừng (breakpoint) trong Code của Chúng ta, hãy di chuột ến dòng Code
mà muốn dừng lại, sau ó nhấp chuột vào số dòng bên cạnh ể kích hoạt iểm dừng. Khi
game chạy và ạt ến iểm dừng, nó sẽ dừng lại và hiển thị thông tin debug. Có thể sử
dụng các nút Play và Pause ể bắt ầu và tạm dừng game trong quá trình gỡ lỗi. Khi game
dừng lại tại một iểm dừng, có thể kiểm tra và thay ổi các giá trị của các biến, xem stack
trace, và thực hiện các thao tác khác liên quan ến gỡ lỗi.
○ Sử dụng các nút Step Over, Step Into và Step Out ể iều hướng qua lại giữa các dòng
Code. Step Over cho phép tiếp tục chạy Code cho ến khi nó ạt ến dòng tiếp theo trong
cùng một phạm vi. Step Into cho phép iều hướng vào các hàm và phương thức ược gọi
từ dòng Code hiện tại. Step Out cho phép thoát khỏi hàm hiện tại và quay lại dòng gọi hàm.
○ Khi ã gỡ lỗi xong, Chúng ta có thể sử dụng nút Stop ể dừng quá trình gỡ lỗi và tiếp tục
chạy game một cách bình thường.
○ Lưu ý rằng Unity Debugger chỉ hoạt ộng trong quá trình phát triển và không nên ược sử
dụng trong phiên bản cuối cùng của game. Đảm bảo loại bỏ các iểm dừng và thông tin
debug không cần thiết trước khi xuất bản game.
• Một số kỹ thuật debug trong unity
○ Kiểm tra tính thực thi -
Trước khi sửa lỗi chương trình phải khoanh vùng oạn code bị lỗi, phạm vi càng thu
hẹp càng tốt. Việc khoanh vùng và xác ịnh oạn code lỗi thuộc về kinh nghiệm lập trình. -
Sau khi ã khoanh vùng phần code lỗi, cần xem xét tính thực thi của oạn code bằng
cách phát ra 1 thông iệp nào ó, ở ây sử dụng hàm Log thuộc lớp Debug trong Unity.
Hình ảnh 55: Cửa sổ console trong Unity -
Nếu thông iệp không ược hiển thị, 1 trong những trường hợp sau ã xảy ra: -
Script chưa ược gắn vào 1 GameObject nào trong chương trình. -
Hàm chứa oạn code thông iệp không ược gọi. -
Thông iệp nằm trong nhánh code không ược thực thi (thường gặp với các cấu trúc rẽ
nhánh if... else, switch... case, ...). -
Để xử lý, cần xem xét cẩn thận và dựa vào logic của game ể chỉnh sửa lại cho phù hợp. Kiểm tra tính logic -
Khi chắc chắn oạn code ược thực thi nhưng chương trình vẫn chạy không như mong
muốn, tiến hành quan sát sự thay ổi của các ối tượng liên quan theo thời gian. Vẫn
dùng hàm Log thuộc lớp Debug, có thể theo dõi 1 hoặc nhiều ối tượng cụ thể ể tìm
ra nguyên nhân gây ra lỗi. -
Việc khắc phục lỗi về logic game thuộc về khả năng ọc code và phân tích bài toán,
các công cụ Debug chỉ giúp sửa lỗi ược dễ dàng hơn, việc sửa lỗi sẽ phụ thuộc nhiều
vào bản thân lập trình viên.
○ Các hàm quan trọng và chức năng - Log
 Debug.Log là hàm ược sử dụng nhiều nhất trong kiểm tra và sửa lỗi chương trình,
hàm Log có chức năng hiển thị ra màn hình Console (Windows → Console) các
thông tin về 1 ối tượng trong game.
 Kiểu dữ liệu mà hàm nhận vào là Object, do ó với mọi loại dữ liệu thì hàm ều có
thể in ra cửa sổ Console của Unity Editor, tuỳ theo cách hiển thị của kiểu dữ liệu.
 Các kiểu dữ liệu thường ược lập trình viên sử dụng với hàm Log bao gồm int,
float, string, dữ liệu kiểu mảng, ...
 Các kiểu dữ liệu do Unity ịnh nghĩa như Vector2, Vector3, Quaternion, ... cũng
ược hiển thị chi tiết.
 Ngoài hàm Log nói trên, Unity còn cung cấp 1 số hàm Log nâng cao nhưng ít phổ
biến ối với lập trình viên chưa có nhiều kinh nghiệm. - Draw
 Ngoài việc hiển thị ra màn hình Console giá trị của 1 ối tượng, Unity hỗ trợ vẽ 1
ường thẳng lên màn hình. Khi cần xem xét cụ thể, sử dụng hàm DrawLine ể vẽ,
hàm có nguyên mẫu như sau:
 public static void DrawLine(Vector3 start, Vector3 end, Color color =
Color.white, float duration = 0.0f, bool depthTest = true);
 Trong ó các giá trị color, duration và depth Test ều mang sẵn giá trị mặc ịnh. 1
ường thẳng sẽ ược vẽ trong cửa sổ Scene, với 2 ầu mút ược quy ịnh rõ ràng.
 Trong trường hợp cần quan sát hướng của ối tượng, sử dụng hàm DrawRay , cách
sử dụng hàm tương tự như với hàm DrawLine:
 public static void DrawRay(Vector3 start, Vector3 dir, Color color = Color.white,
float duration = 0.0f, bool depthTest = true);
 1 ường thẳng sẽ ược vẽ từ iểm bắt ầu cho ến start + dir. Ray (tia) là 1 ường thẳng
vô hạn không có iểm kết thúc nhưng Unity Editor sẽ chỉ minh hoạ 1 phần của tia.
 * 2 hàm Draw thuộc lớp Debug sẽ vẽ lên cửa sổ Scene, nếu muốn hiển thị trực
tiếp lên màn hình Game, mở tuỳ chọn hiển thị Gizmo ở cửa sổ Game. - Break
 Trong 1 số trường hợp cần chương trình tạm dừng lại ể xem xét sự thay ổi của
các ối tượng trong game, hàm Break trong lớp Debug giúp thực hiện công việc này.
 Hàm Break thực sự trở nên hữu ích khi cần dừng chương trình tại 1 thời iểm cụ
thể, cũng có thể sử dụng công cụ Debugger có sẵn trong Visual Studio hay Mono
Develop, nhưng sẽ không xem xét ược các ối tượng 1 cách trực quan. - isDebugBuild
 Khi ưa sản phẩm hoàn thiện ra thị trường, hiển nhiên không cần ến các oạn code
Debug nữa vì ã khắc phục triệt ể các vấn ề liên quan, do ó nên loại bỏ các oạn
Debug này ra khỏi sản phẩm.
 Với hàng chục, thậm chí hàng trăm file script với nhiều dòng code, việc xoá từng
dòng Debug thủ công là iều gây lãng phí thời gian và công sức, ồng thời thể hiện
sự thiếu chuyên nghiệp trong công việc. Vậy tại sao không sử dụng 1 iều kiện
trước khi gõ dòng code Debug thông thường ể kiểm soát việc này?
 Trong lớp Debug, Unity cung cấp cho 1 thuộc tính ể kiểm tra trạng thái của sản
phẩm - thuộc tính isDebugBuild. Thuộc tính này sẽ trả về true nếu như sản phẩm
vẫn ang trong quá trình hoàn thiện (thường gọi là Beta Release). Trạng thái của
sản phẩm có thể ược tìm thấy tại cửa sổ Build Setting (Ctrl + Shift + B),
checkbox "Development Build". Ngoài ra tại cửa sổ Unity Editor, thuộc tính này
luôn mang giá trị là true.
11. Đóng gói và phát hành game: 11.1. Đóng gói
• Cấu hình Nền tảng Mục tiêu (Platform Configuration):
○ Thiết lập cấu hình trò chơi cho nền tảng mục tiêu. Điều này bao gồm thiết lập ộ phân
giải, tỷ lệ khung hình, và các thiết lập ặc biệt khác cho từng nền tảng.
• Xử lý Dữ liệu và Tài nguyên (Data and Asset Handling):
○ Đảm bảo rằng tất cả tài nguyên, âm thanh, hình ảnh và tệp cần thiết ược óng gói vào
ứng dụng hoặc tệp cài ặt một cách úng cách.
• Xác thực và Chữ ký Số (Authentication and Digital Signing):
○ Nếu cần, xác thực và chữ ký số ứng dụng của chúng ta ể ảm bảo tính toàn vẹn và áng tin cậy của nó.
• Xây dựng Tệp cài ặt (Build Installation Files):
○ Xây dựng tệp cài ặt hoặc gói cho từng nền tảng mục tiêu. Điều này bao gồm việc tạo
tệp cài ặt .exe, .apk, .ipa, hoặc các ịnh dạng khác tương ứng.
• Kiểm tra cuối cùng (Final Testing):
○ Chạy kiểm tra cuối cùng trên các tệp cài ặt ể ảm bảo rằng chúng hoạt ộng một cách
chính xác trên nền tảng mục tiêu. 11.2. Phát hành game
• Chọn Nền tảng Phân phối:
○ Đầu tiên, chúng ta cần xác ịnh nền tảng mà chúng ta muốn phát hành trò chơi trên,
chẳng hạn như PC, iện thoại di ộng, máy tính bảng, console, hoặc nền tảng VR. Mỗi
nền tảng có quy tắc và yêu cầu riêng, vì vậy hãy tìm hiểu kỹ về nền tảng mà chúng ta muốn phát triển.
• Đáp ứng các Yêu cầu của Nền tảng:
○ Mỗi nền tảng có các quy ịnh và yêu cầu riêng về ộ phân giải, kích thước tệp, chứng
thực ứng dụng, và các yêu cầu khác. Đảm bảo rằng trò chơi của chúng ta tuân thủ các quy tắc này.
• Chuẩn bị Tài liệu và Thông tin:
○ Đối với nền tảng di ộng, chúng ta cần chuẩn bị tài liệu và thông tin liên quan ến ứng
dụng, bao gồm hình ảnh biểu trưng ứng dụng, mô tả, tên ứng dụng, từ khoá, tác giả, và thông tin liên hệ.
• Nộp Ứng dụng cho Cửa hàng Ứng dụng:
○ Đối với các cửa hàng ứng dụng như Google Play (cho Android) hoặc App Store (cho
iOS), chúng ta cần tạo tài khoản cho nhà phát triển, ưa lên ứng dụng của chúng ta và
cung cấp thông tin và tài liệu cần thiết. Sau ó, chúng ta sẽ nộp ứng dụng của mình ể ược xem xét và phê duyệt.
• Phát hành và Quảng bá:
○ Sau khi ứng dụng của chúng ta ã ược phê duyệt, chúng ta có thể phát hành nó trên cửa
hàng ứng dụng. Sau ó, chúng ta có thể bắt ầu chiến dịch quảng bá ể thông báo với
người dùng về ứng dụng.
• Cập nhật và Duy trì:
○ Sau khi phát hành, chúng ta có thể phải quản lý các bản cập nhật cho trò chơi, bao gồm
việc phát hành các bản vá lỗi, cải thiện hiệu năng và thêm tính năng mới. Đảm bảo rằng
chúng ta tiếp tục theo dõi và phản hồi với người dùng. KẾT LUẬN
Tiểu luận này ã trình bày chi tiết về các khía cạnh quan trọng trong việc phát triển trò chơi trong môi trường Unity.
Trong phần tổng quan, chúng ta ã có cái nhìn tổng quan về Unity và nhận thấy rằng ây là một
game engine mạnh mẽ và phổ biến trong ngành công nghiệp game. Unity cung cấp một loạt các
tính năng và công cụ cho phép nhà phát triển tạo ra trò chơi a nền tảng với hiệu suất cao và trải nghiệm tuyệt vời.
Trong phần lịch sử về Unity, chúng ta ã i sâu vào quá trình phát triển và lịch sử của Unity.
Chúng ta ã nhận thấy rằng Unity ã trải qua sự phát triển áng kể từ khi ra mắt và ã trở thành một
trong những công cụ phát triển trò chơi hàng ầu trên thị trường.
Phần kiến thức cơ bản về Unity ã giúp chúng ta hiểu về cấu trúc và thành phần chính của Unity.
Chúng ta ã tìm hiểu về Scene, GameObject, Component và Script trong Unity, cùng với các khái
niệm cơ bản khác như transform, input và physics. Điều này cung cấp cho chúng ta một nền tảng
vững chắc ể bắt ầu phát triển trò chơi trong Unity.
Phần lập trình trong Unity ã giúp chúng ta khám phá ngôn ngữ lập trình C# và cách sử dụng nó
trong việc phát triển trò chơi trong Unity. Chúng ta ã tìm hiểu về các cú pháp cơ bản, quản lý
script và cách tương tác giữa các thành phần trong trò chơi. Điều này giúp chúng ta viết mã linh
hoạt và mạnh mẽ ể iều khiển trò chơi trong Unity.
Phần thiết kế game trong Unity ã giúp chúng ta hiểu về quá trình thiết kế trò chơi, từ khái niệm
và ý tưởng ban ầu cho ến việc xây dựng mô hình, môi trường và gameplay. Chúng ta ã tìm hiểu
về sử dụng các công cụ và tài nguyên có sẵn trong Unity ể tạo ra trò chơi hấp dẫn và ồ họa.
Phần UI và UX trong Unity ã giúp chúng ta hiểu về thiết kế giao diện người dùng và trải nghiệm
người dùng trong trò chơi. Chúng ta ã tìm hiểu về các thành phần UI trong Unity, cách tạo và tùy
chỉnh giao diện người dùng, cũng như các nguyên tắc thiết kế UX ể tạo ra trải nghiệm trò chơi
tốt nhất cho người chơi.
Phần trò chơi a nền tảng và tích hợp mạng ã giúp chúng ta hiểu về cách phát triển trò chơi a nền
tảng trong Unity và cách tích hợp mạng ể chơi trò chơi a người chơi. Chúng ta ã tìm hiểu về các
công nghệ và công cụ có sẵn trong Unity ể xây dựng trò chơi a nền tảng và tạo kết nối mạng cho trò chơi.
Phần hiệu suất và tối ưu hóa ã giúp chúng ta hiểu về quy trình tối ưu hóa và cải thiện hiệu suất
của trò chơi trong Unity. Chúng ta ã tìm hiểu về các kỹ thuật tối ưu hóa, quản lý tài nguyên, cải
thiện hiệu suất ồ họa và quản lý bộ nhớ ể ảm bảo trò chơi chạy mượt và có hiệu suất tốt trên nhiều nền tảng.
Phần hỗ trợ và cộng ồng ã giúp chúng ta hiểu về các nguồn tài liệu, tài liệu học trực tuyến và
cộng ồng hỗ trợ của Unity. Chúng ta ã tìm hiểu cách tìm kiếm thông tin hữu ích, ặt câu hỏi và
tương tác với cộng ồng Unity ể giải quyết các vấn ề và học hỏi từ những người khác.
Phần thử nghiệm và debugging ã giúp chúng ta hiểu về quy trình thử nghiệm và sửa lỗi trong quá
trình phát triển trò chơi trong Unity. Chúng ta ã tìm hiểu về các kỹ thuật thử nghiệm, sửa lỗi và
gỡ lỗi trong Unity ể ảm bảo rằng trò chơi hoạt ộng úng và không có lỗi trong quá trình chơi.
Phần óng gói và phát hành game ã giúp chúng ta hiểu về quy trình óng gói và phát hành trò chơi
trong Unity. Chúng ta ã tìm hiểu về các công cụ và quy trình ể óng gói trò chơi thành các phiên
bản phù hợp cho các nền tảng khác nhau và cách phát hành trò chơi trên các cửa hàng ứng dụng và nền tảng game.
Tổng cộng, trong tiểu luận này chúng ta ã khám phá và hiểu rõ các khía cạnh quan trọng trong
việc phát triển trò chơi trong môi trường Unity. Từ kiến thức cơ bản về Unity ến lập trình, thiết
kế game, UI/UX, tích hợp mạng, hiệu suất, hỗ trợ và cộng ồng, thử nghiệm và debugging, óng
gói và phát hành game, chúng ta ã có cái nhìn tổng quan và nền tảng vững chắc ể bắt ầu hành
trình phát triển trò chơi trong Unity.
TÀI LIỆU THAM KHẢO
Unity (phần mềm làm game) – Wikipedia
(https://vi.wikipedia.org/wiki/Unity_(ph%E1%BA%A7n_m%E1%BB%81m_l%C3%A0m_game
)?fbclid=IwAR2JcC4tZfCTNWyekuJO2x75ewUpnpFHirfAB-QwRnTLGr_0BxhkqSbGeg8)