I o snandroidc++

ĐẠI HỌC ĐÀ NẴNG
TRƯỜNG ĐẠI HỌC BÁCH KHOA
KHOA CÔNG NGHỆ THÔNG TIN
Tel. (84-511) 736 949, Fax. (84-511) 842 771
Website: itf.ud.edu.vn, E-mail: cntt@edu.ud.vn
ĐỒ ÁN TỐT NGHIỆP KỸ SƯ
NGÀNH CÔNG NGHỆ THÔNG TIN
MÃ NGÀNH: 05115
ĐỀ TÀI:
XÂY DỰNG GAME 3D SWORD MAN TRÊN ANDROID
IOS VÀ WINDOWS
SINH VIÊN: HỒ THỊ TRANG
LỚP : 06T4
CBHD : THS. TRỊNH CÔNG DUY
ĐÀ NẴNG, 06/2011

Xây dựng game 3D Sword Man trên Android, IOS và Windows
SVTH: Hồ Thị Trang – Lớp 06T4 Page 2
NHẬN XÉT CỦA CÁN BỘ HƯỚNG DẪN
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
Đà Nẵng, ngày …, tháng …, năm 2011
Cán bộ hướng dẫn
THS. Trịnh Công Duy

NHẬN XÉT CỦA CÁN BỘ PHẢN BIỆN
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
…………………………………………………………………………………
Đà Nẵng, ngày …, tháng …, năm 2011
Cán bộ phản biện

LỜI CẢM ƠN
Tôi xin chân thành cảm ơn các thầy cô giáo trong khoa Công Nghệ Thông Tin cùng
toàn thể thầy cô của trường Đại Học Bách Khoa Đà Nẵng đã truyền đạt cho tôi những kiến
thức quý giá trong suốt những năm học vừa qua.
Xin chân thành cảm ơn thầy: Trịnh Công Duy đã tận tình chỉ bảo và giúp đỡ cho tôi
hoàn thành đồ án này.
Cuối cùng tôi xin cảm ơn các bạn trong khoa công nghệ thông tin, những người đã giúp
đỡ, chia sẽ những kiến thức, kinh nghiệm, tài liệu…trong suốt quá trình nghiên cứu thực hiện
đề tài.

LỜI CAM ĐOAN
Tôi xin cam đoan:
1 Những nội dung trong báo cáo này là do tôi thực hiện.
2 Mọi tham khảo dùng trong báo cáo này đều được trích dẫn rõ ràng tên
tác giả, tên công trình, thời gian, địa điểm công bố.
3 Mọi sao chép không hợp lệ, vi phạm quy chế đào tạo, hay gian trá, tôi xin
chịu hoàn toàn trách nhiệm.
Sinh viên thực hiện
Hồ Thị Trang

MỤC LỤC
CHƯƠNG 1. TỔNG QUAN VỀ ĐỀ TÀI .................................................................................. 15
1.1. Giới thiệu đề tài................................................................................................................ 15
1.2. Mục đích, ý nghĩa của đề tài ............................................................................................ 15
1.3. Phương án triển khai đề tài .............................................................................................. 15
CHƯƠNG 2. CƠ SỞ LÝ THUYẾT ........................................................................................... 17
2.1. Giới thiệu các công cụ để làm game 3D .......................................................................... 17
2.1.1. Visual C++ .................................................................................................................17
2.1.2. Giới thiệu về OpenGL................................................................................................17
2.1.2.1. Giới thiệu .............................................................................................................17
2.1.2.2. Cấu trúc lệnh trong OpenGL................................................................................18
2.1.2.3. Thư viện OpenGL ................................................................................................20
2.1.2.4. Đường ống dẫn trong OpenGL (OpenGL Rendering pipeline)...........................21
2.1.3. Giới thiệu về OpenGL ES 2.0 ....................................................................................22
2.1.4. Giới thiệu về hệ điều hành ANDROID và IOS..........................................................23
2.1.4.1. ANDROID ...........................................................................................................23
2.1.4.2. IOS .......................................................................................................................25
2.2. Giới thiệu về 3D cơ bản................................................................................................... 27
2.2.1. Hệ tọa độ 3D...............................................................................................................27
2.2.2. Quy tắc bàn tay trái- bàn tay phải ..............................................................................28

2.2.3. Xác định vị trí của một điểm trong tọa độ 3D............................................................28
2.2.4. Các phép dịch chuyển cơ bản ở trong 3D ..................................................................29
2.2.4.1. Phép Tịnh tiến (Translate)....................................................................................29
2.2.4.2. Phép biến dạng theo một tỷ lệ..............................................................................30
2.2.4.3. Phép quay quanh một trục tọa độ theo một góc a................................................31
2.2.5. Phép chiếu trong 3D...................................................................................................32
2.2.5.1. Chiếu phối cảnh ...................................................................................................33
2.2.5.2. Chiếu trực giao (phép chiếu vuông góc)..............................................................33
2.2.6. Tọa độ thực đến thiết bị..............................................................................................34
2.3. Cấu trúc của một game..................................................................................................... 36
2.3.1. Game Loop (vòng lặp của game) ...............................................................................36
2.3.2. Framerate (FPS) .........................................................................................................37
2.3.3. Bộ nhớ (memory) .......................................................................................................38
2.3.4. State............................................................................................................................38
2.4. Giới thiệu về NDK........................................................................................................... 39
CHƯƠNG 3. PHÂN TÍCH TRÒ CHƠI ..................................................................................... 43
3.1. Hệ thống và tính khả chuyển (portability):...................................................................... 43
3.1.1. C/C++ và thư viện......................................................................................................43
3.1.2. Phân tích tính khả chuyển (portability) của các thành phần trong trò chơi ...............44
3.2. Xây dựng hệ thống khả chuyển........................................................................................ 47

3.2.1. Sử dụng các tiền xử lý................................................................................................48
3.2.2. Sử dụng nguyên mẫu hàm, lớp trừu tượng.................................................................48
3.3. Cấu trúc của một Trò chơi ............................................................................................... 49
3.3.1. Vòng lặp trò chơi........................................................................................................49
3.3.2. Cấu trúc trò chơi.........................................................................................................51
3.3.3. Nội dung trò chơi........................................................................................................53
3.3.4. Đồ họa ........................................................................................................................56
3.3.5. Âm Thanh...................................................................................................................58
CHƯƠNG 4. QUÁ TRÌNH LẬP TRÌNH................................................................................... 60
4.1. Thiết kế chương trình....................................................................................................... 60
4.2. Vòng lặp trò chơi ............................................................................................................. 61
4.3. Nội dung trò chơi ............................................................................................................. 62
4.3.1. Khởi tạo vị trí hiện tại của trái cây.............................................................................63
4.3.2. Cập nhật trạng thái của trái cây..................................................................................63
4.3.3. Kiểm tra va chạm .......................................................................................................64
4.3.4. Tính toán lại các trạng thái sau khi va chạm..............................................................64
4.4. Đồ Họa ............................................................................................................................. 64
4.4.1.Tải shader và biên dịch................................................................................................65
4.4.2. Vẽ một đối tượng 3D..................................................................................................65
4.4.3. Vẽ một đối tượng 2D..................................................................................................66

4.5. Nhập................................................................................................................................. 66
4.6. Âm thanh.......................................................................................................................... 67
4.7. Giao diện ứng dụng.......................................................................................................... 67
4.8. Giao diện xuất nhập tập tin .............................................................................................. 68
CHƯƠNG 5. QUY TRÌNH CHUYỂN TRÒ CHƠI................................................................... 69
5.1. Chuyển sang IOS ............................................................................................................. 69
5.1.1. Cài đặt môi trường phát triển .....................................................................................69
5.1.2. Tạo dự án, biên dịch...................................................................................................70
5.1.3. Âm thanh ....................................................................................................................70
5.1.4. Nhập ...........................................................................................................................71
5.1.5. Giao diện ứng dụng ....................................................................................................72
5.1.6. Xuất nhập tập tin ........................................................................................................73
5.2. Chuyển sang Android....................................................................................................... 73
5.2.1 Cài đặt phần mềm........................................................................................................73
5.2.2. Hoạt động của JNI và quy trình biên dịch..................................................................74
5.2.3. Đồ họa ........................................................................................................................75
5.2.4. Âm thanh ....................................................................................................................75
5.2.5. Cảm ứng chạm............................................................................................................76
5.2.6. Giao diện ứng dụng ....................................................................................................77
5.2.7. Xử lí file .....................................................................................................................78

CHƯƠNG 6. QUÁ TRÌNH KIỂM THỬ SẢN PHẨM GAME LÀM RA................................ 80
6.1. Cài đặt hệ thống ............................................................................................................... 80
6.1.1. Cài đặt trên Android...................................................................................................80
6.1.2. Cài đặt trên IOS..........................................................................................................80
6.2. Kiểm thử........................................................................................................................... 81
CHƯƠNG 7.MỘT SỐ KẾT QUẢ VÀ DEMO CỦA GAME .................................................... 84
7.1. Kết quả demo trên Windows............................................................................................ 84
7.2. Kết quả demo trên IOS..................................................................................................... 88
7.3. Kết quả demo trên Android (điện thoại Galaxy s)........................................................... 92
CHƯƠNG 8. KẾT LUẬN........................................................................................................... 97
8.1. Kết quả đạt được .............................................................................................................. 97
8.2. Những vấn đề còn tồn đọng ............................................................................................. 97
8.3. Hướng phát triển của đề tài.............................................................................................. 97

MỤC LỤC CÁC HÌNH
Hình 1. Biễu diễn OpenGl và mối quan hệ với các API .............................................................21
Hình 2. Biễu diễn đường ống dẫn trong OpenGL.......................................................................22
Hình 3. Biễu diễn đường ống dẫn trong OpenGL 2.0.................................................................23
Hình 4. Biễu tượng của hệ điều hành Android ...........................................................................24
Hình 5. Hình ảnh của hệ điều hành IOS trên Ipad .....................................................................27
Hình 6. Biễu diễn hệ tọa độ 3D...................................................................................................28
Hình 7. Biễu diễn quy tắc bàn tay trái- bàn tay phải..................................................................28
Hình 8. Biễu diễn một điểm trong hệ tọa độ 3D .........................................................................29
Hình 9. Biễu diễn phép tịnh tiến một đối tượng theo một vector................................................30
Hình 10. Biễu diễn phép biến dạng một vật theo một tỷ lệ .........................................................31
Hình 11. Biễu diễn phép quay quanh một trục tọa độ theo một góc a........................................31
Hình 12. biễu diễn phép chiếu phối cảnh....................................................................................33
Hình 13. Biễu diễn phép chiếu vuông góc...................................................................................34
Hình 14. Biễu diễn tọa độ thực đến thiết bị thông qua NDC......................................................34
Hình 15. Biễu diễn về NDC.........................................................................................................35
Hình 16. Biễu diễn sự biến đổi 3 chiều thành 2 chiều ................................................................35
Hình 17. Biễu diễn quá trình xây dựng và chuyển trò chơi. .......................................................47
Hình 18. Biễu diễn vòng lặp của trò chơi ...................................................................................50
Hình 19. Cấu trúc của một trò chơi ............................................................................................51

Hình 20. Giao diện của trò chơi .................................................................................................52
Hình 21. Trạng thái của trò chơi ................................................................................................53
Hình 22. Biễu diễn chuyển động của trái cây.............................................................................54
Hình 23. Biễu diễn thanh kiếm của người chơi...........................................................................55
Hình 24. Biễu diễn va chạm giữa thanh kiếm và trái cây...........................................................55
Hình 25. Biễu diễn tính toán tọa độ sau va chạm.......................................................................56
Hình 26. Biễu diễn đối tượng 3D trong trò chơi.........................................................................57
Hình 27. Biễu diễn giao diện 2D.................................................................................................57
Hình 28. Biễu diễn cách bố trí để vẽ giao diện 2D trong trò chơi..............................................58
Hình 29. Biễu diễn khung thiết kế của chương trình ..................................................................60
Hình 30. Cách kế thừa các lớp trừ tượng trên các nền tảng khác nhau.....................................61
Hình 31. Biễu diễn vòng lặp của trò chơi ...................................................................................62
Hình 32. Vòng đời của một trái cây............................................................................................63
Hình 33. Sơ đồ hoạt động của OpenGl ES 2.0 trong chương trình............................................64
Hình 34. Kết quả demo về main menu ở trên Windows..............................................................84
Hình 35. Kết quả demo giao diện lúc đang chơi game trên windows ........................................85
Hình 36. Kết quả demo lúc người chơi chạm vào trái cây trên windows...................................86
Hình 37. Kết quả demo lúc Game over trên windows ................................................................87
Hình 38. Demo giao diện màn hình highscore trên windows.....................................................88
Hình 39. Kết quả demo biểu tượng icon của game trên ios........................................................89

Hình 40. Kết quả demo màn hình mainmeu trên ios...................................................................90
Hình 41. Kết quả demo màn hình lúc đang chơi game trên ios.................................................90
Hình 42. Kết quả demo màn hình highscore trên ios..................................................................91
Hình 43. Kết quả demo màn hình gameOver trên ios.................................................................91
Hình 44. Kết quả demo màn hình About trên ios........................................................................92
Hình 45. Kết quả demo biểu tượng icon của game trên Android ...............................................93
Hình 46. Kết quả demo màn hình mainmenu trên Android ........................................................94
Hình 47. Kết quả demo màn hình game play trên Android ........................................................94
Hình 48. Kết quả demo màn hình highScore trên Android.........................................................95
Hình 49. Kết quả demo màn hình GameOver trên Android .......................................................96
Hình 50. Kết quả demo màn hình About trên Android ...............................................................96

MỤC LỤC CÁC BẢNG
Bảng1. Biễu diễn các kiểu dữ liệu trong OpenGL ......................................................................19
Bảng 2. Các phiên bản OpenGL ES có thể sử dụng ND để tạo ra thư viện native ....................42
Bảng 3. Thực tế của các thành phần trong trò chơi trên 3 hệ thống..........................................45
Bảng 4. Bảng nhận xét các thành phần trò chơi trên cả 3 hệ thống...........................................46
Bảng 5. Bản thiết kế âm thanh ....................................................................................................59
Bảng 6. Biễu diễn các ca kiểm thử về gamePlay ........................................................................82
Bảng 7. Hình biễu diễn các ca kiểm thử về âm thanh.................................................................83
Bảng 8. Hình biễu diễn các ca kiểm thử về Interrupt .................................................................83

CHƯƠNG 1. TỔNG QUAN VỀ ĐỀ TÀI
1.1. Giới thiệu đề tài
Với đà phát triển của thông tin di dộng như hiện nay, thiết bị di động trở thành một trợ thủ
không thể thiếu của đa số mọi người. Các trò chơi giải trí trên di động ngày càng đa dạng. Đặc
biệt sự ra đời của hệ điều hành android và IOS càng tạo ra bước phát triển mới cho các ứng
dụng trên di động.
Công nghệ game ngày càng phát triển. Tuy nhiên đa số các game đều làm ở dạng 2D.
Thời gian gần đây một xu hướng game mới là game ở dạng 3D đang được ưa chuộng. Vì vậy,
bản thân em chọn đề tài này nhằm muốn nghiên cứu về kỹ thuật làm game 3D trên hệ điều
hành ANDROID và IOS. Bước đầu xây dựng demo một chương trình game đơn giản phục vụ
cho quá trình nghiên cứu và công việc tương lai sau này.
1.2. Mục đích, ý nghĩa của đề tài
Củng cố những kiến thức đã học và nghiên cứu: tìm hiểu hệ điều hành android và IOS,
nghiên cứu công ghệ làm game 3D.
Nghiên cứu cách xây dựng một game đa nền tảng, và quá trình chuyển từ windows sang
Android và IOS.
Xây dựng trò chơi Sword Man trên hệ điều hành android, IOS, Windows.
1.3. Phương án triển khai đề tài
Để hoàn thành đề tài này, trong quá trình triển khai thực hiện cần tuân thủ các bước sau:
Lập kế hoạch thực hiện đề tài.
Thiết kế hệ thống và dữ liệu.
Xây dựng chương trình (chia nhỏ các chức năng thành các module và component để giải
quyết từng phần).

Củng cố kết quả đã đạt được (bao gồm kiểm thử các module và chức năng của hệ thống,
chỉnh sửa lỗi nếu có và tiến tới hoàn thiện chương trình ở mức có thể).
Song song với các giai đoạn trên là quá trình học hỏi, tích góp tài liệu và các kiến thức về
các công cụ liên quan nhằm phục vụ cho việc xây dựng và hoàn thiện đề tài.

CHƯƠNG 1. CƠ SỞ LÝ THUYẾT
2.1. Giới thiệu các công cụ để làm game 3D
2.1.1. Visual C++
Visual C++ là bộ công cụ lập trình nằm trong bộ Microsoft Visual Studio. Đây là một
môi trường lập trình đa năng dành cho ngôn ngữ C/C++ và vì là một môi trường lập trình trên
hệ điều hành Windows nên Visual C++ cho phép lập trình viên thực hiện rất nhiều công việc,
hỗ trợ lập trình viên việc coding, thiết kế giao diện.. Trong VC++ chúng ta có thể tạo được :
các ứng dụng trên Windows, ActiveX, hay thư viện liên kết động DLL…VC++ có nhiều công
cụ giúp việc thiết kế giao diện cho chương trình, kiểm lỗi và sửa lỗi.
2.1.2. Giới thiệu về OpenGL
2.1.2.1. Giới thiệu
Là một bộ thư viện đồ họa mở. Có khoảng 150 hàm giúp xây dựng các đối tượng và
thao tác cần thiết trong các ứng dụng tương tác 3D.
OpenGL hỗ trợ các hàm đồ họa:
• Xây dựng các đối tượng phức tạp từ các thành phần hình học cơ bản (điểm, đoạn, đa
giác, ảnh bitmap).
• Sắp xếp đối tượng trong 3D và chọn điểm thuận lợi để quan sát.
• Tính toán màu sắc của các đối tượng (màu sắc của đối tượng được quy định bởi điều
kiện chiếu sáng, texture của đối tượng, mô hình được xây dựng hoặc là kết hợp của cả 2 hoặc 3
yếu tố đó).
• Biến đổi những mô tả toán học của đối tượng và thông tin màu sắc thành phần các
pixel trên màn hình (quá trình này được gọi là rasterization).
Có API đa nền tảng: Windows, Mac, Linux, Unix.

Các hệ thống dùng để nhúng:
- Iphone, Windows mobile…
Dùng cho đa ngôn ngữ:
- C, C++, Python, Ruby, PHP…
Dùng cho cả cách vẽ trong 2D và 3D.
Những thứ OpenGL không hỗ trợ:
• Bản thân OpenGL không có sẵn các hàm nhập xuất hay thao tác trên window.
• OpenGL không có sẵn các hàm cấp cao để xây dựng các mô hình đối tượng, thay
vào đó, người dùng phải tự xây dựng từ các thành phần hình học cơ bản (điểm, đoạn thẳng, đa
giác).
2.1.2.2. Cấu trúc lệnh trong OpenGL
OpenGL sử dụng tiền tố gl và tiếp theo đó là những từ những từ được viết hoa ở chữ cái
đầu để tạo nên tên của một lệnh, ví dụ glClearColor(). Tương tự, OpenGL đặt tên các hằng số
bắt đầu bằng GL_ và các từ tiếp sau đều được viết hoa và cách nhau bởi dấu ’_’, ví dụ:
GL_COLOR_BUFFER_BIT.
Bên cạnh đó, với một số lệnh, để ám chỉ số lượng cũng như kiểu tham số được truyền,
một số hậu tố được sử dụng như trong bảng sau:
Hậu tố Kiểu dữ liệu Tương ứng với
kiểu trong C
Tương ứng với
kiểu trong
OpenGL
B 8-bit integer Signed char Glbyte
S 16-bit integer Short Glshort
I 32-bit integer Int or long Glint, Glsizei

F 32-bit floating-
point
Float GLfloat,
Glclampf
D 64-bit floating-
point
Double Glbouble,
GLclampd
Ub 8-bit unsigned
integer
Unsigned char GLubyte,
GLboolean
Us 16-bit unsigned
integer
Unsigned short GLushort
Ui 32-bit unsigned
integer
Unsigned int or
unsigned long
GLuint,
GLenum,
GLbitfield
Bảng1. Biễu diễn các kiểu dữ liệu trong OpenGL
Ví dụ: glVertex2i(1, 3) tương ứng với xác định một điểm(x, y) với x, y nguyên.
Lưu ý:
OpenGL có định nghĩa một số kiểu biến, việc sử dụng các định nghĩa này thay vì định
nghĩa có sẵn của C sẽ tránh gây lỗi khi biên dịch code trên một hệ thống khác.
Một vài lệnh của OpenGL kết thúc bởi v ám chỉ rằng tham số truyền vào là một vector.
Ví dụ: glColor3fv(color_array) là mảng 1 chiều có 3 phần tử là float.

2.1.2.3. Thư viện OpenGL
Core library
OpenGL utility library(GLU)
Links với hệ thống window
OpenGL Utility Toolkit(Glut)
Để khắc phục một số nhược điểm của OpenGL, GLUT được tạo ra với nhiều hàm hỗ
trợ:
• Quản lý window
• Display callback
• Nhập xuất (bàn phím, chuột…)
• Vẽ một số đối tượng 3D phức tạp (mặt cầu, khối hộp…)
OpenGL cho hệ thống nhúng
• Mobile phone
• PDAS
• Video game consoles
Hệ tọa độ của OpenGL
OpenGL dùng hệ tọa độ theo quy tắc bàn tay phải.
Mối quan hệ giữa OpenGL với các API

Hình 1. Biễu diễn OpenGl và mối quan hệ với các API
2.1.2.4. Đường ống dẫn trong OpenGL (OpenGL Rendering pipeline)
Đường ống dẫn của OpenGL gồm một chuỗi các quá trình xử lý theo trình tự. Hai đồ
họa thông tin, dữ liệu vertex-based và pixel-based, được xử lý thông qua các đường ống, Kết
hợp với nhau sau đó được viết vào frame buffer.Chú ý rằng OpenGL có thể gửi các dữ liệu đã
được xử lý lại cho ứng dụng của chúng ta.

Hình 2. Biễu diễn đường ống dẫn trong OpenGL
2.1.3. Giới thiệu về OpenGL ES 2.0
Là một phần mềm giao diện để vẽ đồ họa 3D phức tạp trên các thiết bị cầm tay và
nhúng. Nó chính là thư viện đồ họa cho các thiết bị cầm tay và nhúng với lập trình 3D phần
cứng bao gồm điện thoại di động, PDA, thiết bị, xe cộ, và hệ thống điện tử. Với OpenGL ES
2.0 thì chúng ta có thể lập trình shader trên các thiết bị nhỏ và di động.
Đường ống dẫn(pipeline) trong OpenGL ES 2.0

Hình 3. Biễu diễn đường ống dẫn trong OpenGL 2.0
2.1.4. Giới thiệu về hệ điều hành ANDROID và IOS
2.1.4.1. ANDROID
Android cung cấp một bộ đầy đủ các phần mềm cho các thiết bị di động: Nó là một hệ
thống điều hành, middleware và các ứng dụng di động chủ chốt. Các Android Software
Development Kit (SDK) bây giờ đã có.

Hình 4. Biễu tượng của hệ điều hành Android
Android được xây dựng để cho phép các nhà phát triển tạo ra các ứng dụng di động hấp
dẫn tận dụng tất cả một chiếc điện thoại đã cung cấp. Nó được xây dựng để được thực sự mở.
Ví dụ, một ứng dụng có thể kêu gọi bất kỳ chức năng lõi của điện thoại như thực hiện cuộc gọi,
gửi tin nhắn văn bản, hoặc bằng cách sử dụng máy ảnh, cho phép các nhà phát triển để tạo ra
phong phú hơn và nhiều hơn nữa những kinh nghiệm cố kết cho người dùng.
Hơn nữa, nó sử dụng một máy ảo tuỳ chỉnh được thiết kế để tối ưu hóa bộ nhớ và tài
nguyên phần cứng trong một môi trường di động. Android là mã nguồn mở, nó có thể được
liberally mở rộng.
Android không phân biệt giữa các ứng dụng lõi của điện thoại và các ứng dụng của bên
thứ ba. Với các thiết bị xây dựng trên Hệ điều hành Android, người dùng có thể hoàn toàn thích
ứng với điện thoại đến lợi ích của họ. Họ có thể trao đổi trên màn hình của điện thoại, những
phong cách của dialer, hoặc bất kỳ ứng dụng.
Android phá bỏ rào cản để xây dựng các ứng dụng mới và sáng tạo. Ví dụ, một nhà phát
triển có thể kết hợp thông tin từ các trang web với dữ liệu trên điện thoại di động của một cá

nhân – ví dụ như địa chỉ liên hệ của người dùng, lịch, hoặc vị trí địa lý – để cung cấp một trải
nghiệm người dùng có liên quan hơn. Với Android, một nhà phát triển có thể xây dựng một
ứng dụng cho phép người dùng xem vị trí của bạn bè của họ và được cảnh báo khi họ đang có
trong vùng phụ cận cho họ một cơ hội để kết nối.
Với Android tốc độ nhanh và phát triển ứng dụng dễ dàng.
Android cung cấp truy cập đến một loạt các thư viện công cụ hữu ích và có thể được sử
dụng để xây dựng các ứng dụng phong phú. Ví dụ, Android cho phép các nhà phát triển để có
được vị trí của điện thoại, và cho phép các thiết bị giao tiếp với nhau tạo điều kiện cho đồng
đẳng rich-to-peer ứng dụng xã hội.
Rất nhiều nhà phát triển hệ điều hành Android đã vào cuộc và các ROM cho Android
độc đáo được ra đời với nhiều tích năng nổi trội được tích hợp và đầy sáng tạo.
2.1.4.2. IOS
IOS được biết đến từ tháng 6 năm 2010. Là một hệ điều hành trên thiết bị di động của
Apple. Đầu tiên nó được phát triển cho iPhone. Sau đó được mở rộng cho các thiết bị khác của
Apple như: Ipod touch, iPad và Apple TV.
IOS là hệ điều hành nổi tiếng nhanh gọn và an toàn của Apple. IOS trên Iphone là một
hệ điều hành đa nhiệm (chúng ta vừa có thể duyệt web và vừa tải một cái gì đó từ trên mạng
về), được cài đặt trình duyệt web Safari an toàn và tốc độ nhanh.
Hệ điều hành IOS hỗ trợ Unicode, đây là điều rất được quan tâm tại thị trường việt Nam.
Ngoài ra các phần mềm như từ điển mở, phần mềm văn phòng mở…
Hệ điều hành Iphone được nhúng vào dưới dạng 1 firmware, dùng để restore, update
trực tiếp từ iTunes (thư viện âm nhạc, ứng dụng … khổng lồ của Apple) khi cài OS Iphone vì
nó là 1 dạng firmware nên chúng được nhớ trên chip, Rom phần cứng của Iphone, nhằm ngăn
chặn hacker, những người bẻ khóa. Chính vì điều này mà mỗi khi chúng ta update hay restore
lên phiên bản mới thì chúng ta sẽ không thể restore về phiên bản cũ trước đó.
Phiên bản IOS đầu tiên là firmware 1.0.

Hiện tại OS mới nhất của Iphone là 4.3.3.
Một số hình ảnh về hệ điều hành IOS trên ipad, iphone

Hình 5. Hình ảnh của hệ điều hành IOS trên Ipad
2.2. Giới thiệu về 3D cơ bản
2.2.1. Hệ tọa độ 3D
Được định nghĩa bởi 3 trục tọa độ: ox, oy, oz.

Hình 6. Biễu diễn hệ tọa độ 3D
2.2.2. Quy tắc bàn tay trái- bàn tay phải
Hình 7. Biễu diễn quy tắc bàn tay trái- bàn tay phải
2.2.3. Xác định vị trí của một điểm trong tọa độ 3D
Cho điểm P (Px, Py, Pz) trong tọa độ 3D. Ta biểu diễn như sau:

Hình 8. Biễu diễn một điểm trong hệ tọa độ 3D
2.2.4. Các phép dịch chuyển cơ bản ở trong 3D
Translate
Scale
Rotate
2.2.4.1. Phép Tịnh tiến (Translate)
Tịnh tiến một đối tượng P theo một vector V

Hình 9. Biễu diễn phép tịnh tiến một đối tượng theo một vector
Cho vector V:
V = Vx * i + Vy *j + Vz *k
Phép tịnh tiến P thành P’ theo vector V được xác định như sau:
Tv: P -> P’
Tv = { Px’ = Px + Vx, Py’ = Py + Vy, Pz’ = Pz + Vz}
2.2.4.2. Phép biến dạng theo một tỷ lệ
S: P -> P’
S = { Px’ = Px *Sx, Py’ = Py *Sy, Pz’ = Pz * Sz}

Hình 10. Biễu diễn phép biến dạng một vật theo một tỷ lệ
2.2.4.3. Phép quay quanh một trục tọa độ theo một góc a
Hình 11. Biễu diễn phép quay quanh một trục tọa độ theo một góc a
Quay quanh trục Ox, Oy, Oz
Cách xác định tọa độ theo phép quanh quay một trục

• Quay quanh trục Ox:
R (a, x): P -> P’
R (a, x) = {
Px’ = Px
Py’ = Py * Cos (a) – Pz * Sin (a)
Pz’ = Py * Sin (a) + Pz * Cos (a)
}
• Quay quanh trục Oy:
R (a, y): P -> P’
R (a, y) = {
Py’ = Py
Px’ = Py * Cos (a) + Pz * Sin (a)
Pz’ = -Px * Sin (a) + Pz * Cos (a)
}
• Quay quanh trục Oz:
R (a, z): P -> P’
R (a, z) = {
Pz’ = Pz
Px’ = Px * Cos (a) - Py * Sin (a)
Py’ = Px * Sin (a) + Py * Cos (a)
}
2.2.5. Phép chiếu trong 3D
Giới hạn vùng để vẽ ảnh trên thiết bị 3D:
Trái, phải, trên, dưới, gần, xa.

2.2.5.1. Chiếu phối cảnh
Là hình chiếu được xây dựng bằng phép chiếu xuyên tâm.
Đặc điểm của phép chiếu này là tạo cho người xem có cảm giác xa gần giống như nhìn
trong thực tế.
Là một cách vẽ trong hội họa, hay tạo hình, dùng để thể hiện các hình ảnh 3 chiều một
cách gần đúng trên một bề mặt 2 chiều nhờ vào các quy luật phối cảnh. Các quy luật phối cảnh
được xây dựng trên các quy tắc hình học chặt chẽ. Các quy tắc phối cảnh giúp hình ảnh 2 chiều
trở thành 3 chiều, khiến chúng được quan sát được trực quan hơn trên tranh vẽ.
Ứng dụng của hình chiều phối cảnh là đi kèm theo các hình chiếu vuông góc trong bản
vẽ thiết kế kiến trúc và xây dựng để biễu diễn các công trình có kích thước lớn.
Hình 12. biễu diễn phép chiếu phối cảnh
2.2.5.2. Chiếu trực giao (phép chiếu vuông góc)
Trong phép chiếu này, khoảng cách của vật tới camera không ảnh hưởng tới độ lớn của
vật đó khi hiển thị.
Phép chiếu trực giao hay còn được gọi là phép chiếu nhìn từ trên xuống hoặc từ dưới
lên. Có 2 phép chiếu khác cũng khá thông dụng là:

Phép nhìn từ trước: Tia chiếu song song với trục x và mặt phẳng quan sát là yz. Phép chiếu
này loại bỏ thành phần x của P.
Phép chiếu nhìn từ phía bên cạnh: Tia chiếu song song với trục y và mặt phẳng chiếu này
loại bỏ thành phần y của P.
Hình 13. Biễu diễn phép chiếu vuông góc
2.2.6. Tọa độ thực đến thiết bị
Tọa độ thực -> tọa độ mắt -> NDC -> Thiết bị
Hình 14. Biễu diễn tọa độ thực đến thiết bị thông qua NDC
NDC
Là thiết bị chuẩn hóa tọa độ. Có hình dạng là một lập phương có tọa độ các điểm cố
định. Chỉ có những điểm nằm trong NDC mới được vẽ.
Xác định tọa độ theo quy tắc bàn tay trái.

Hình 15. Biễu diễn về NDC
Biểu đồ thể hiện sự biến đổi 3 chiều thành thành điểm có tọa độ 2 chiều
Hình 16. Biễu diễn sự biến đổi 3 chiều thành 2 chiều

2.3. Cấu trúc của một game
Các khái niệm trong game
2.3.1. Game Loop (vòng lặp của game)
Là thành phần quan trọng của bất kỳ game nào. Game loop giúp game chạy ổn định hơn
không bị ảnh hưởng bởi tác động của người dùng.
Hầu hết các chương trình truyền thống đều đáp ứng thông điệp đưa vào của người dùng .
Ví dụ như: word thì định dạng và text theo nhưng gì người dùng nhập vào, nếu người dùng
không nhập vào thì nó không làm gì cả. Nhưng đối với một chương trình game thì dù người
dùng có nhập vào thông điệp hay không thi nó vẫn thực hiện theo một cấu trúc chương trình có
sẵn đây chính là vòng lặp của game.
Một vòng lặp game rất đơn giản nó có thể trông như thế này:
While ( user doesn't exit )
check for user input
run AI
move enemies
resolve collisions
draw graphics
play sounds
end while
Các vòng lặp game có thể thay đổi như sự phát triển của game nhưng hầu hết chúng đều
dựa trên ý tưởng cơ bản này.
Vòng lặp game khác nhau tùy thuộc vào nền tảng mà nó phát triển.Vòng lặp game được
thực hiên thông qua 2 hàm chính là Update và Paint.

2.3.2. Framerate (FPS)
Số lần vẽ khung hình trên một giây. Framerate chậm sẽ làm cho người dùng không có
cảm giác thật, ảnh hưởng đến sự tương tác của người dùng với trò chơi.
Các yếu tố làm cho framerate chậm
• Hình vẽ có kích thước lớn.
• Tính toán trong game nhiều.
• Lỗi của thiết bị.
Cách cải thiện framerate
• Tối ưu hóa tính toán và các điều kiện thực hiện trong game:
+ Sử dụng ít vòng lặp.
+ Dùng phép toán dịch chuyển bit thay cho phép nhân và phép chia.
+ Khai báo các biến và phương thức ở dạng static.
• Caching module của các file ảnh, tối ưu hóa các module dùng để vẽ sao cho số lượng
module vẽ ra là ít.
• Dùng Bacbuffer: Không vẽ từng sprite ra màn hình mà ta vẽ các sprite lên một ảnh
sau đó vẽ ảnh đó ra màn hình.
• Bỏ các hiệu ứng không cần thiết.
Limit Frame rate
Là sự giới hạn lại số lần vẽ trên một giây của trò chơi. Nhằm mục đích dùng trong
những trường hợp ứng dụng có frame rate quá nhanh, sẽ làm cho ứng dụng không ổn định.
Ảnh hưởng đến quá trình xử lý, người chơi không chơi kịp và một điều nữa là nó dẫn đến
việc nhanh hết pin của thiết bị.

2.3.3. Bộ nhớ (memory)
Là kích thước bộ nhớ có thể dùng để chạy chương trình game của thiết bị.
Các yếu Tố ảnh hưởng đến bộ nhớ trong game
• File ảnh dùng trong game.
• Âm thanh dùng trong game.
• Các file text, mảng chứa text trong game.
Tối ưu hóa bộ nhớ
• Đơn giản hóa các frame và hình ảnh động.
• Chia ảnh ra thành các module nhỏ.
• Xóa các module của dữ liệu sau khi caching.
• Dùng gói sound có dung lượng nhỏ, Load sound khi chạy sound và giải phóng (free)
khi dừng sound.
• Dùng mảng một chiều thay vì dùng mảng 2 chiều.
• Chỉ giữ những đối tượng cần thiết trong bộ nhớ. Để tránh vấn đề phân mảnh bộ nhớ (là
các đối tượng thường dùng (fonts, main characters, common interface sprites, … ) ).
• Load khi muốn vẽ và giải phóng khi đi ra khỏi màn hình.
• Tránh phân mảnh bộ nhớ: load đối tượng có kích thước lớn trước. Giữ cho bộ nhớ ổn
định. Không load và giải phóng quá nhiều lần.
2.3.4. State
Là các trạng thái của một game. Chúng có liên quan chặt chẽ với nhau.Thông thường
một game thường có các trạng thái sau: mainmenu, gamestart, gamewin, gameover, about,
highscore, Exit…

2.4. Giới thiệu về NDK
Là bộ công cho phép nhúng các mã code lên các ứng dụng android. ứng dụng Android
chạy trong máy ảo Dalvik. NDK cho phép chúng ta dùng các ứng dụng viết bằng ngôn ngữ C
và C++ lên thiết bị android.
NDK cung cấp một số hỗ trợ sau:
• Một tập hợp các Toos và files build dùng để tạo ra các thư viện mã từ sources C và
C++.
• Cách để nhúng các thư viện mã vào một file (.apk) gói ứng dụng mà chúng ta có thể
chạy được trên các thiết bị android.
• Tài liệu, ví dụ và một số hướng dẫn.
• Một bộ các thư viện C/C++ được hỗ trợ trong tất cả các phiên bản sau này của hệ điều
hành Android, bắt đầu từ Android 1.5. Từ phiên bản 2.3 trở đi, hệ điều hành android còn hỗ trợ
them cách viết Activity bằng C/C++.
NDK cung cấp bộ header cho libc ( bột thư viện C ), libm (bột thư viện toán học),
openGL ES(thư viện đồ họa 3D), giao diện JNI(là giao diện để liên lạc giữa java và native
code), một số thư viện khác, được chứa trong Development Tools.
Khi nào thì Native code
Không phải khi nào NDK cũng đều có lợi với tất cả các ứng dụng. Vì vậy chúng ta cần
cân bằng lợi ích với nhược điểm của nó. Đặc biệt trong trường hợp sử dụng native code không
làm tăng hiệu suất thực thi mà làm tăng sự phức tạp của ứng dụng. Nói chung chỉ nên sử dụng
native code nếu nó là cần thiết đối với ứng dụng của mình. Chứ không phải vì chúng ta thích
chương trình trong C/C++.
Frame android cung cấp 2 cách để dùng native code :
• Dùng Android framework để viết ứng dụng của mình và dùng JNI để truy cập API
được cung cấp bởi Android NDK. Kỹ thuật này cho phép chúng ta tận dụng các tiện ích của

Android framework, nhưng vẫn cho phép chúng ta viết native code khi cần thiết. Chúng ta có
thể cài ứng dụng sử dụng Native code thông qua JNI trên thiết bị chạy android 1.5 hoặc mới
hơn.
• Viết một native activity, cho phép chúng ta thực hiện cài đặt vòng đời của ứng
dụng android trên native code. Android SDK cung cấp lớp NativeActivity cho phép chúng ta
cài đặt vòng đời thông qua các hàm sau (onCreate(), onResume(), ..).
Development tool
NDK gồm một bộ công cụ (compilers, linkers, …) dùng để tạo ra mã nhị phân cho bộ vi
xử lý ARM trên hệ điều hành Linux, OS X, và Windows(với Cygwin).
Cung cấp một bộ headers của hệ thống cho các API native chuẩn mà được đảm bảo
được hỗ trợ trong tất cả các phiên bản sau này của nền tảng:
• Libc (thư viện C) headers.
• Libm (thư viện toán học) headers.
• Giao diện JNI headers.
• Liblog (Android logging) header.
• OpenGL ES 1.1 và OpenGL ES 2.0(thư viện graphics library) headers.
• Libjnigraphics (Pixel buffer access) header(for Android 2.2. trở lên).
• Thư viện OpenSL ES native audio.
• API cho ứng dụng android.
NDK cũng cung cấp một hệ thống biên dịch giúp chúng ta làm việc hiệu quả với mã
nguồn của mình mà không cần điều khiển chi tiết các công cụ/ nền tảng/ CPU/ ABI. Người
dùng chỉ cần tạo các file biên dịch đơn giản để mô tả mã nguồn của mình mà trong ứng dụng
Android sử dụng. Và hệ thống biên dịch sẽ sử dụng các file này để biên dịch, và tạo ra một thư
viện động bỏ trực tiếp vào trong dự án của mình.

Hệ thống và phần mềm yêu cầu
• The Android SDK
- Hoàn tất cài đặt một Android SDK (bao gồm tất cả các phụ thuộc).
- Phiên bản SDK Android 1.5 trở đi.
• Hệ điều hành hỗ trợ
- Window XP (32-bit) hoặc vista (32- hoặc 64 -bit).
- Mac Os x10.4.8 hoặc hơn (đối với X86).
- Linux (32 hoặc 64 bit, thử nghiệm trên Linux Ubuntu Dapper Drake).
• Các công cụ Cần Thiết
- Đối với tất cả các nền tảng, bắt buộc GNU Make 3.81 trở lên.
- Đối với Window, bắt buộc Cygwin 1.7 trở lên. NDK không làm việc với Cygwin 1.5.
• Nền tảng Android tương thích
Các thư viện native được tạo ra bởi Android NDK chỉ có thể sử dụng trên các thiết bị
Android phiên bản 1.5 trở đi. Điều này là do Bộ công cụ và ABI liên quan đến những thay đổi
làm cho các thư viện native không tương thích với hình ảnh hệ thống 1.0 và 1.1.
Vì lí do này nên chúng ta nên sử dụng thư viện native được tạo ra với NDK trong ứng
dụng mà được triển khai trên các thiết bị chạy trên nền tảng android 1.5 trở đi.
Để đảm bảo tính tương thích, một ứng dụng dùng thư viện native tạo ra với NDK phải
khai báo <uses- sdk> phần tử trong file mainfese của nó, với một giá trị thuộc tính của
android:minSdkVersion 3 hoặc lớn hơn.
Ví dụ:
<manifest>

<uses-sdk android:minSdkVersion="3" />
...
</manifest>
Nếu sử dụng NDK để tạo ra thư viện native có sử dụng OpenGL ES API, thì ứng dụng
chứa các thư viện chỉ có thể được triển khai trên các thiết bị chạy tối tiểu là các phiên bản được
nêu dưới đây:
OpenGL ES Version
Used
Compatible Android
Platform(s)
Required uses-sdk Attribute
OpenGL ES 1.1 Android 1.6 and
higher
android:minSdkVersion="4"
OpenGL ES 2.0 Android 2.0 and
higher
android:minSdkVersion="5"
Bảng 2. Các phiên bản OpenGL ES có thể sử dụng ND để tạo ra thư viện native

CHƯƠNG 3. PHÂN TÍCH TRÒ CHƠI
3.1. Hệ thống và tính khả chuyển (portability):
3.1.1. C/C++ và thư viện
Để đạt được yêu cầu đặt ra của bài toán, là hệ thống có thể chạy được trên cả ba Hệ điều
hành: Windows, Android và IOS. Và trong quá trình làm không cần mất nhiều thời gian, chúng
ta cần phải phân tích kỹ lưỡng và đề xuất phương án phù hợp để tiến hành đề ra giải pháp và
xây dựng bài toán.
Nhận xét:
Cả ba hệ điều hành đều cung cấp môi trường lập trình trên ngôn ngữ ANSI C/C++.
• Windows: Hổ trợ sẵn.
• IOS: GCC, kết hợp với Objective C.
• Android: JNI từ Android 1.5, Native Activity từ Android 2.3.
Cả ba hệ điều hành đều cung cấp thư viện OpenGL ES 2.0.
• Android: Từ phiên bản 2.1.
• IOS: Hầu hết các thiết bị chạy IOS đều hổ trợ OpenGL ES 2.0.
• Windows: Thông qua bộ giả lập OpenGL ES 2.0 của PowerVR.
Môi trường C/C++ trên cả ba hệ điều hành tương đối giống nhau. Tuy nhiên số lượng
các thư viện hổ trợ khác nhau, do đó chúng ta chỉ sử dụng các thư viện chuẩn mà cả 3 đều
hỗ trợ.
Có thể dễ dàng chuyển một thư viện C chuẩn lên cả 3 hệ điều hành (trong trường hợp
ứng dụng này, tôi đã chuyển thành công thư viện LIB PNG – hổ trợ đọc và xử lí tập tin
hình ảnh PNG trong C/C++).

Tất cả đều hổ trợ các công cụ phát triển mạnh mẽ, Android và IOS đều chạy trên nền
tảng GCC.
Do đó, trong quá trình lập trò chơi, chúng ta nên sử dụng hợp lí các công cụ, thư viện, mã
nguồn và lập trình một cách tối ưu để có thể sử dụng lại trên cả ba nền tảng khác nhau này
3.1.2. Phân tích tính khả chuyển (portability) của các thành phần trong trò chơi
Thông thường, trong một trò chơi (tức là một ứng dụng) sẽ có các thành phần như sau:
- Vòng lặp trò chơi: là trung tâm của trò chơi, quản lí vòng đời, trạng thái của trò chơi.
- Logic: là phần xử lí của trò chơi, xử lí thuật toán, trí thông minh nhân tạo, tương tác
với người chơi.
- Đồ Họa: là phần thể hiện của trò chơi.
- Âm thanh: là phần không thể thiếu của trò chơi, giúp trò chơi trở nên sinh động hơn.
- Nhập: đối với các thiết bị IOS, Android thì tương tác chủ yếu thông qua cảm ứng
chạm (touch screen), giúp người dùng tương tác với trò chơi.
- Giao diện ứng dụng: là bộ khung tương tác với nền tảng của ứng dụng: cho phép ứng
dụng khởi chạy, tạm ngưng, ngưng, và xử lí các sự kiện liên quan.
Đối với các thành phần trên, ta có bảng thực tế như sau:
Nền tảng /
Yếu tố
Windows Android IOS
Vònglặp trò
chơi
Có thể cài đặt giống nhau trên cả ba hệ thống do đều viết bằng C/C++.
Logic Tương tự, ta có thể cài đặt giống nhau trên cả ba hệ thống.
Đồ Họa - Direct X.
- OpenGL.
- OpenGLES (thông
qua bộ giả lập).
- OpenGL ES 1.1.
- OpenGL ES 2.0.
(C/C++: từ Android
2.1; Java: từ Android
2.2).
- OpenGL ES 1.1.
- OpenGL ES 2.0.
Âm thanh - Có thể sử dụng các - MediaPlayer. - Open AL.

bộ thư viện âm
thanh.
- SoundPool.
- Open SL ES (Từ
Android 2.2).
- Hổ trợ các định
dạng: midi, wav,
m4a, mp3 …
- AVAAudioPlayer.
- Hổ trợ các định
dạng: mp3, m4a.
Nhập - Nhận thông điệp từ
windows.
- Từ View – phương
thức
OnTouchEvent().
Không hổ trợ nhận sự
kiện cảm ứng trực
tiếp từ JNI.
- TouchBegan(),
TouchEnded() và
TouchMoved() trong
view controller của
Objective C.
Giao diện
ứng dụng:
- main() tạo cửa
sổ và tương tác.
- Activity viết bằng
Java.
- Native activity viết
bằng C/C++. (từ
Android 2.3).
- AppDelegate viết
bằng Objective C.
Xuất nhập
tập tin
- Dùng thư viên
<stdio.h>.
- Đọc tập tin từ
res/raw qua JNI.
- Đọc tập tin từ tài
nguyên ứng dụng.
Ghi tập tin vào thư
mục tài liệu của
người dùng.
Bảng 3. Thực tế của các thành phần trong trò chơi trên 3 hệ thống
Từ bảng thực tế trên, ta có bảng nhận xét sau:
Yếu tố Tính Khả Chuyển Giải Pháp
Vòng lặp trò chơi Cài đặt bằng C/C++.
Logic Trò Chơi Cài đặt bằng C/C++.
Đồ Họa Dùng OpenGL ES 2.0. API 2.0
mạnh mẽ hơn nhiều so với 1.1 và
hầu hết các thiết bị hiện tại đều hổ
trợ.
Âm thanh Không có một chuẩn chung về âm
thanh. Tuy nhiên ở mức độ đơn

giản, chúng ta không xử lí nhiều tới
âm thanh (âm thanh nổi, v.v…).
- Trên windows: không cài đặt âm
thanh.
- IOS: Sử dung AVAAudioPlayer.
- Android OS: Sử dụng
MediaPlayer.
Nhập Tương tự, ta không có một API
chung để nhận cảm ứng, do đó
phần này ta phải viết riêng trên
từng hệ thống.
Giao diện ứng dụng Phần này ta phải viết riêng trên
Xuất nhập tập tin Phần này ta phải viết riêng trên
Bảng 4. Bảng nhận xét các thành phần trò chơi trên cả 3 hệ thống.
Với lựa chọn trên, trò chơi của chúng ta sẽ chạy được trên các nền tảng với cấu hình
như sau:
Windows: 32 bit, card đồ họa hỗ trợ OpenGL ES 2.0.
Android: phiên bản 2.1 trở về sau.
IOS: phiên bản 3.0 trở về sau.
Dựa vào bảng phân tích trên, ta tiến hành chia phần cài đặt ra các phần sau.
Phần có thể sử dụng chung:
• Chung cho tất cả các trò chơi: các thành phần chung cho toàn bộ các trò chơi.
• Riêng biệt của trò chơi hiện tại: ví dụ thuật toán, logic, ý tưởng trò chơi.
• Phần phải cài đặt riêng: đây là phần mình phải cài đặt riêng cho từng hệ
thống, tuy nhiên, các phần này đơn giản hơn nhiều so với các phần còn lại,
chúng ta sẽ thiết kế để cài đặt phần này có thể sử dụng chung cho toàn bộ các
trò chơi.
Từ đó, ta suy ra quy trình thực hiện như sau:

Hình 17. Biễu diễn quá trình xây dựng và chuyển trò chơi.
Ta sẽ ưu tiên xây dựng các thành phần chung nhất, sau đó hoàn thành trò chơi trên
windows. Nơi chúng ta được sự trợ giúp của các công cụ và môi trường quen thuộc giúp chúng
ta cài đặt và gỡ rối một cách dễ dàng. Sau đó chúng ta sẽ thực hiện đưa lên các nền tảng khác
một cách dễ dàng.
3.2. Xây dựng hệ thống khả chuyển
Để dễ dàng hơn trong việc lập trình cũng như việc chuyển trò chơi từ hệ thống này sang
các nền tảng khác, ta cần phải xây dựng hệ thống theo các phương pháp sau.
Windows 32
Quá trình chuyển
Trò chơi
Cài đặt phần chung.
Cài đặt cho windows,
Cài đặt trò chơi
Cài đặt cho từng nền tảng

3.2.1. Sử dụng các tiền xử lý
Các thông số kỹ thuật của các thiết bị tương đối khác nhau, đôi khi cũng có sự khác
nhau giữa các thư viện trên các thiết bị. Do đó ta cần phải sử dụng các định nghĩa tiền xử lí để
có thể viết mã nguồn chạy tốt trên mọi hệ thống.
Các định nghĩa tiền xử lí có sẵn trên hệ thống:
- WIN32: có giá trị đúng khi nền tảng biên dịch hiện tại là windows.
- ANDROID: có giá trị đúng khi nền tảng biên dịch hiện tại là Android.
- __IPHONE_4_0: có giá trị đúng khi nền tảng biên dịch hiện tại là IOS 4.0 trở về sau.
Các cách sử dụng tiền xử lí để tăng tính khả chuyển trong chương trình:
Định nghĩa các thông số: các thiết bị có thể có màn hình khác nhau, do đó ta đưa các
thông số đó vào các định nghĩa lúc biên dịch.
#define SCREEN_W 960
#define SCREEN_H 640
Viết riêng cho từng cấu hình: sử dụng tiền xử lí #if, #else, #endif để viết một đoạn mã
mà chỉ chạy trên một nền tảng mong muốn.
#if __IPHONE_4_0
#import <OpenGLES/ES2/gl.h>
#import <OpenGLES/ES2/glext.h>
#else
#include <GLES2/gl2.h>
#endif
3.2.2. Sử dụng nguyên mẫu hàm, lớp trừu tượng
Khai báo một nguyên mẫu hàm, lớp trừu tượng chung cho tất cả các hệ thống sau đó ta
cài đặt khác nhau trên mỗi nền tảng khác nhau.
Ví dụ, do xử lí âm thanh trong trò chơi này tương đối đơn giản, do đó, ta cần hai hàm để
thực hiện chơi một âm thanh bất kỳ và dừng tất cả các âm thanh đang chơi. Ta khai báo nguyên
mẫu hàm như sau:
// Play Sound
void PlaySound(int id, int loop = 1);

// Stop all sound
void StopSound();
Và sau đó ta sẽ viết hàm này trên các hệ thống khác nhau sử dụng tiền xử lý như phương
pháp trên.
3.3. Cấu trúc của một Trò chơi
3.3.1. Vòng lặp trò chơi
Vòng lặp trò chơi chính là trung tâm của trò chơi. Trò chơi khác hẳn với các ứng dụng
hướng sự kiện khác, ngay cả khi không có sự kiện xuất nhập, trò chơi vẫn phải hoạt động và
đáp ứng liên tục để tạo ra hiệu ứng hoạt động của các nhân vật, đối tượng trong trò chơi.
Có thể ví dụ trò chơi như một cuốn phim hoạt hình mà người chơi có thể tương tác với
các nhân vật trong trò chơi. Để tạo được hiệu ứng hoạt hình, trò chơi phải vẽ hơn 12 hình trên
một giây để đảm bảo hiệu ứng hoạt hình. Ngoài ra trò chơi cần phải tính toán, xử lí các sự kiện
phát sinh, tính toán các vật thể, các nhân vật và hoạt động trong trò chơi.
Đó là hai công việc chính của vòng lặp trò chơi
- Cập nhật, tính toán trạng thái hiện tại.
- Vẽ các nhân vật, đối tượng, giao diện màn hình.

Hình 18. Biễu diễn vòng lặp của trò chơi
Hai hành động này được lặp đi lặp lại liên tiếp nhau trong suốt trò chơi hình thành nên
vòng lặp chính của trò chơi. Để mọi việc rõ ràng và dễ dàng hơn, chúng ta nên tách riêng biệt
hai hành động này và sử dụng các biến trạng thái để lập trình.
Ví dụ:
Trong game cần vẽ một quả bóng di động. Ta nhận thấy:
- Để xử lí cập nhật, tính toán trạng thái của quả bóng ta cần các thông tin bao gồm:
bán kính bóng, vị trí trái bóng, và vận tốc của trái bóng.
- Để vẽ trái bóng lên màn hình: ta cần biết các thông tin: bán kính, vị trí.
Bán kính, vị trí, vận tốc: chính là các biến trạng thái chung cho chương trình. Sử dụng
các biến trạng thái này, ở hành động cập nhật, ta không cần quan tâm trái bóng được vẽ
như thế nào vẫn có thể thực hiện được và ngược lại. Việc nhìn một góc nhìn riêng biệt
sẽ khiến chúng ta làm mọi việc dễ dàng và đơn giản hơn nhiều.
Kết thúc
Xử lí sự kiện
Vẽ
Sai
Đúng

Số lần vẽ/cập nhật trên một giây gọi là FPS (Frame per second). Thông thường, một
trò chơi 3D có số FPS chuẩn là 60 FPS. Số FPS càng lớn thì trò chơi chạy càng mượt mà, tuy
nhiên nếu số FPS quá lớn thì sẽ gây hiện tượng trò chơi quá nhanh, người dùng không thể chơi
tốt được, khi đó, chúng ta cần phải giới hạn số FPS lại một giá trị mong muốn.
FPS là giá trị phụ thuộc nhiều vào cấu hình của thiết bị, do đó: việc chuyển đổi trò chơi
trên nhiều hệ thống khác nhau sẽ dẫn đến số FPS khác nhau. Trên một thiết bị mạnh hơn, số
FPS sẽ tăng lên, do đó chúng ta sẽ phải giới hạn lại. Ngược lại, chúng ta cần tối ưu hóa thuật
toán, cách vẽ hoặc chỉnh sửa nội dung của trò chơi đó để đạt được số FPS mong muốn tạo ra
kết quả tối ưu cho người chơi.
3.3.2. Cấu trúc trò chơi
Hình 19. Cấu trúc của một trò chơi
Một trò chơi bao gồm nhiều giao diện khác nhau. Ví dụ: bảng chọn chính, mục giới
thiệu trò chơi, mục điểm cao nhất và trò chơi. Để tích hợp điều này vào vòng lặp chính, chúng
ta sẽ có một biến trạng thái lưu lại giao diện hiện tại của trò chơi, rồi theo đó xử lí tương ứng.
Dựa vào biến trạng thái chúng ta sẽ lưu lại giao diện hiện tại và xử lí trạng thái tương
ứng. Tương tự như trong hàm cập nhật hoặc hàm vẽ.
Trong thiết kế trò chơi của mình, tôi đưa ra các giao diện sau
- Bảng chọn chính: Hiển thị các mục để người chơi có thể truy xuất được các mục
khác trong trò chơi.
- Điểm cao: Ghi lại các kỷ lục được lập trong trò chơi.
- Giới thiệu: Giới thiệu sơ lược về trò chơi.

- Trò chơi: nơi người chơi chơi và ghi điểm.
- Kết thúc trò chơi: Khi người chơi bị mất hết mạng.
Hình 20. Giao diện của trò chơi
Các trạng thái của trò chơi
Vẽ
Xử lí sự kiện
Trạng thái hiện tại
Xử lí trò chơiXử lí bảng chọn Xử lí giới thiệu

-
Hình 21. Trạng thái của trò chơi
3.3.3. Nội dung trò chơi
Trò chơi mô phỏng hành động cắt trái cây của một kiếm sĩ. Trò chơi chỉ có một chế độ
chơi duy nhất tính điểm. Người chơi được bắt đầu với năm mạng và một thanh kiếm. Trái cây
lần lượt được tung lên từ bên dưới, người chơi có nhiệm vụ sử dụng kiếm để cắt trái cây ra làm
đôi trước khi trái cây đó rơi ra khỏi tầm nhìn. Cứ mỗi trái cây cắt thành công, người chơi sẽ
dành được một điểm.
Độ khó của trò chơi: tăng dần, cứ 50 điểm đạt được, trò chơi sẽ xuất hiện thêm một trái
cây khiến mức độ khó của trò chơi tăng lên. Ngược lại người chơi sẽ được tặng một mạng.
Trò chơi kết thúc: khi người chơi mất tất cả các số mạng của mình. Cứ mỗi khi người
chơi làm rơi một trái cây, người chơi sẽ bị trừ một mạng.
Các thiết kế thuật toán:
Chuyển động của trái cây:
Bảng chọn chính
Vào chơi
Xem Điểm Giới Thiệu
Hết
Chọn Xem Điểm Chọn Giới thiệu
Chọn Vào chơi
Mất hết mạng
Chọn nút quay lại

Ban đầu vị trí P trái cây được đặt bên dưới màn hình. Trái cây được cung cấp một vận
tốc ban đầu và . Trong môi trường tồn tại gia tốc trọng trường . Theo đó, sau
mỗi khung hình, ta có cập nhật trạng thái của trái cây đã cho như sau:
•
•
•
Hình 22. Biễu diễn chuyển động của trái cây
Thanh kiếm của người chơi:
Thanh kiếm, vết chém của người chơi được nhập từ màn hình thông qua cảm ứng
chạm. Dữ liệu vào tương đối rời rạc do hạn chế của hệ điều hành. Ví dụ khi người dùng lượt
tay trên màn hình thì sẽ có khoảng n điểm được ghi lại (không phải tất cả các điểm). Từ
những dữ liệu này, chúng ta xây dựng thành thanh kiếm có hình dạng tương đối như hình.
P

Hình 23. Biễu diễn thanh kiếm của người chơi
Kiểm tra va chạm:
Ta kiểm tra va chạm giữa thanh kiếm và trái cây bằng cách kiểm tra va chạm giữa thanh
kiếm và hình chữ nhật viền xung quanh trái cây.
Hình 24. Biễu diễn va chạm giữa thanh kiếm và trái cây
Tính toán tọa độ sau va chạm:
Thanh kiếm sau khi được render
Quy tắc:
DB = BC = w/2.Trong đó, w là độ rộng của
thanh kiếm tại B.
Chạm và các điểm được ghi nhận
A
B
D
C

Trước khi va chạm: Gia tốc của vật là . Sau khi va chạm: Trái cây được cắt làm 2, và
được truyền thêm một gia tốc tương ứng do lực chém truyền vào là . Gia tốc sau:
.
Hình 25. Biễu diễn tính toán tọa độ sau va chạm
3.3.4. Đồ họa
Chúng ta sử dụng bộ thư viện OPENGL ES 2.0. Ta cài đặt một số phương thức để vẽ
một đối tượng 3D và vẽ giao diện 2D.
Vẽ đối tượng 3D:
- Một đối tượng 3D bao gồm định nghĩa về tọa độ và một đối tượng texture được lưu
riêng rẻ.
- Dữ liệu về tọa độ trong trò chơi được tạo ra bằng phần mềm 3DS Max Studio, và sau
đó được xuất ra tập tin văn bản kiểu obj (wave front object), đây là dữ liệu bao gồm
các thông tin để vẽ một đối tượng:
• Tọa độ. (vertex position).
• UV. (textcoord).
• Vector Normal. (để tính toán ánh sáng).
- Đối tượng 3D trong trò chơi chủ yếu là trái cây và đã được cắt sẵn ra làm 2 phần
bằng nhau đễ dễ dàng xử lí trong trò chơi.

Hình 26. Biễu diễn đối tượng 3D trong trò chơi
Các đối tượng này được tự vẽ để đảm bảo tính đơn giản và tăng tốc độ thực thi trong
chương trình.
Vẽ giao diện 2D:
Giao diện 2D là một phần không thể thiếu trong trò chơi, vì nó là phần quan trọng để thể
hiện thông tin tới người dùng.
Để vẽ 2D trong OpenGL ES 2.0 chúng ta tạo một texture rồi tiến hành vẽ từng bộ đôi
tam giác 1 ra màn hình. Ví dụ, để vẽ hình bên dưới thì chúng ta vẽ hai tam giác như sau:
Hình 27. Biễu diễn giao diện 2D
Để tạo ra toàn bộ giao diện 2D trong chương trình, ta nén tất cả vào một texture có kích
thước lớn, sau đó tải vào bộ nhớ và vẽ từng bộ đôi tam giác như mô hình trên.

Hình 28. Biễu diễn cách bố trí để vẽ giao diện 2D trong trò chơi
3.3.5. Âm Thanh
Trò chơi tương đối đơn giản, do đó trong chương trình ta có hai loại âm thanh sau:
Âm thanh nền.
Âm thanh hiệu ứng.
Ta có bản thiết kế âm thanh như sau:
Tên âm thanh Mô tả Kích hoạt
MUSIC_TITLE Nhạc nền. Kích hoạt tại bảng chọn chính.
CUT Âm hiệu ứng Người dùng chọn một menu.
Người dùng cắt thành công một trái cây.

GAME_OVER Nhạc nền. Khi trò chơi kết thúc.
Bảng 5. Bản thiết kế âm thanh

CHƯƠNG 4. QUÁ TRÌNH LẬP TRÌNH
4.1. Thiết kế chương trình
Dựa vào các phân tích, ta có thiết kế khung của một chương trình.
Hình 29. Biễu diễn khung thiết kế của chương trình
- Lớp Application là bộ giao tiếp giữa ứng dụng và các nền tảng.
- Lớp FileSystem là lớp trừu tượng được dùng để thực hiện các hành động đọc/ghi tập
tin.
-Lớp VideoDriver: là lớp cài đặt các phương thức vẽ hình liên quan đến OpenGLES
2.0.

- Lớp Sprite2DManager, Sprite3DManager là lớp chịu trách nhiệm tải các đối tượng
3D cũng như giao diện 2D và vẽ lên trong chương trình.
Ở mỗi nền tảng các đối tượng này sẽ được kế thừa và cài đặt khác nhau nếu cần thiết.
Hình 30. Cách kế thừa các lớp trừ tượng trên các nền tảng khác nhau
Đây là bộ khung cần thiết để chúng ta tiến hành xây dựng các thành phần trong
chương trình.
4.2. Vòng lặp trò chơi
Chúng ta thực hiện vòng lặp trò chơi qua hai phương thức của lớp Application, đó là
phương thức Update() và Render().
- Phương thức Update: cập nhật trạng thái của trò chơi.
- Phương thức Render: Render nội dung của trò chơi ra màn hình thiết bị.
Do trò chơi bao gồm nhiều giao diện (bảng chọn chính, xem kỷ lục, xem giới thiệu, chơi
game…). Chúng ta sẽ khai báo một biến trạng thái để lưu trữ trạng thái hiện tại. Sau đó ở hàm
Update và Render, chúng ta sẽ dựa vào biến trạng thái này để cập nhật trò chơi.
void UpdateGame(int type)
{
switch (s_iCurrentState)
{

case GAME_START:
UpdateGameStart(type);
break;
case MAIN_MENU:
UpdateMainMenu(type);
…
Ứng với mỗi trạng thái ta sử dụng một chỉ thị để xác định hành động hiện tại là Paint
hay Render. Ngoài ra mỗi trạng thái cần có các hành động để tải và hủy bỏ các đối tượng trên.
- UPDATE: Cập nhật trạng thái hiện tại.
- PAINT: Render trạng thái hiện tại.
- CTOR: Tải các đối tượng cần thiết để vẽ và tính toán trạng thái hiện tại.
- DTOR: Hủy bỏ các biến đã sử dụng trong trạng thái hiện tại.
Hình 31. Biễu diễn vòng lặp của trò chơi
4.3. Nội dung trò chơi
Chúng ta định nghĩa các biến trạng thái rồi lần lượt cài đặt các nội dung như sau:
Các biến dùng để vẽ và cập nhật trái cây:
enum {ST_NORMAL, ST_CUT, ST_HIDDEN};
struct Fruit
{
int status;
float x;
float y;
float ax;
float ay;
int model;
};

Fruit fruits[MAX];
Các biến dùng để lưu trữ và xử lí nhập từ người chơi:
int blades[MAX_BLADE][2];
int bladesLength = 0;
Ta có vòng đời của một trái cây như sau:
Hình 32. Vòng đời của một trái cây
Các chức năng cài đặt:
4.3.1. Khởi tạo vị trí hiện tại của trái cây
// gán gia t c
fruits[i].ay = 0.28f;
fruits[i].ax = (rand() % 10 - 5) * 0.01f;
// gán v trí
fruits[i].y = -2.8f;
fruits[i].x = (rand() % 90) / 10.0f - 4.0f;
// gán tr ng thái
fruits[i].status = ST_NORMAL;
// gán lo i trái cây
fruits[i].model = (rand() % 3) * 3;
4.3.2. Cập nhật trạng thái của trái cây
// Tính toán l i gia t c
fruits[i].ay -= 0.007f;
fruits[i].y += fruits[i].ay;
fruits[i].x += fruits[i].ax;
// Xác ñ nh l i tr ng thái
if (fruits[i].y < -3.0f)
{
fruits[i].status = ST_HIDDEN;
}

4.3.3. Kiểm tra va chạm
Chúng ta kiểm tra cắt nhau giữa các điểm thuộc thanh kiếm và đường biên va chạm của
trái cây như sau:
// ax, ay là t a ñ c a trái cây.
float cx = blades[bladesLength - 2][0] + vx * j * stepLength;
float cy = blades[bladesLength - 2][1] + vy * j * stepLength;
if(fruits[i].status == ST_NORMAL
&&
PointerInRect(cx, cy, ax - 56, ay - 58, 112, 116))
{
// Đã c t nhau…
4.3.4. Tính toán lại các trạng thái sau khi va chạm
fruits[i].ax += 0.02f * vx;
fruits[i].ay += 0.02f * vy;
fruits[i].model = fruits[i].model + 1;
fruits[i].status = ST_CUT;
Tuy nhiên bây giờ, trái cây của chúng ta đã được cắt làm 2: do đó, chúng ta sẽ có:
fruits[i + 1].ax = -fruits[i].ax;
fruits[i + 1].x = fruits[i].x;
fruits[i + 1].y = fruits[i].y;
fruits[i + 1].ay = -fruits[i].ay;
fruits[i + 1].model = fruits[i].model + 1;
fruits[i + 1].status = ST_CUT;
4.4. Đồ Họa
Sơ đồ hoạt động của OpenGLES 2.0 trong chương trình như sau:
Hình 33. Sơ đồ hoạt động của OpenGl ES 2.0 trong chương trình
Để cài đặt đồ họa với OpenGLES 2.0 chúng ta cần phải cài đặt các tính năng sau.

4.4.1.Tải shader và biên dịch
OpenGLES 2.0 cung cấp một đường ống để chúng ta có thể lập trình cách thức hoạt
động của bộ xử lí đồ họa.
Shader là bộ điều khiển hoạt động của OpenGLES 2.0 và được chạy ngay trên bộ xử lí
đồ họa. Shader được viết bằng ngôn ngữ shader (glsl) và bao gồm hai phần: shader đỉnh (vertex
shader) và shader điểm ảnh (fragment shader). Ứng dụng OpenGLES 2.0 chỉ có thể hoạt động
khi đã được xác định một cặp shader trong hệ thống. Do đó chúng ta phải cài đặt shader cho
lớp xử lí đồ họa của mình.
- Tải shader từ tập tin.
- Biên dịch shader.
- Liên kết shader thành chương trình.
- Sử dụng chương trình đó để vẽ.
4.4.2. Vẽ một đối tượng 3D
Để vẽ một đối tượng 3D, chúng ta sử dụng phép chiếu phối cảnh. Một đối tượng 3D
được xác định bởi các thuộc tính:
- Vị trí, dữ liệu, màu sắc, UV của từng đỉnh thuộc đối tượng.
- Quan hệ giữa các đỉnh thuộc đối tượng.
- Texture: hình ảnh được áp lên đối tượng đó.
Trong chương trình, vị trí, dữ liệu, màu sắc, uv của đối tượng được lưu dưới dạng file
.OBJ có định dạng như sau:
v $x $y $z ; đỉnh có tọa độ x y z
vt $u $v ; tọa độ uv của đối tượng.
vn $x $y $z ; vec-tơ chính phương.
f $i/$j/$k $i’/$j’/$k’ $i’’/$j’’/$k’’; Xác định một mặt tam giác của đối tượng, trong đó:
$i: vị trí của tọa độ, $j: vị trí của uv, $k: vị trí của vector chính phương tại đỉnh đó,
Các thông tin này được nén lại vào một file nhị phân chứa nhiều đối tượng cùng lúc
mục đích: dễ dàng tải và thực hiện trong chương trình.

Lúc vẽ, chúng ta truyền các tham số này vào một shader trong OPENGL ES và bộ xử lí
đồ họa sẽ vẽ đối tượng này lên màn hình.
driver->SetArray(ATTRIB_VERTEX, 3, meshes[i].vertices);
driver->SetArray(ATTRIB_TEX_COORD, 2, meshes[i].texCoords);
//driver->SetArray(ATTRIB_NORMAL, 3, meshes[i].normals);
driver->SetTexture2D(0, manager-
>GetTexture(meshes[i].textureId));
driver->DrawArray(TRIANGLES, meshes[i].nVertices);
4.4.3. Vẽ một đối tượng 2D
Để vẽ một đối tượng 2D, chúng ta sử dụng phép chiếu vuông góc. Tương tự như đối
tượng 3D, chúng ta sẽ lưu thông tin của các đối tượng 2D vào một file nhị phân, sau đó tải vào
bộ nhớ và vẽ ra.
4.5. Nhập
Ta sử dụng hàm PointerEvent trong đối tượng Application để nhận và xử lí các sự kiện
nhập từ cảm ứng / chuột. Ở trên windows, ta xử lí như sau:
case WM_LBUTTONDOWN:
mouseDown = true;
bt::core::Application::GetApplication()
->PointerEvent(bt::core::POINTER_START, x, y);
break;
case WM_MOUSEMOVE:
if (mouseDown)
{
->PointerEvent(bt::core::POINTER_MOVED, x, y);
};
break;
case WM_LBUTTONUP:
mouseDown = false;
->PointerEvent(bt::core::POINTER_ENDED, x, y);
break;
Ở trong trò chơi của mình, chúng ta chỉ cần cài đặt và xử lí hàm PointerEvent mà không
cần phải biết thật sự cảm ứng/chuột được nhận như thế nào.
Ví dụ:

if (pointerState == POINTER_START &&
PointerInRect(m_iLastPointerX, m_iLastPointerY,
SCREEN_W - 100, SCREEN_H - 100, 100, 100))
{
SwitchState(MAIN_MENU);
}
4.6. Âm thanh
Ta đưa ra hai phương thức để chơi âm thanh:
// Play Sound
void PlaySound(int id, int loop = 1);
// Stop all sound
void StopSound();
Tuy nhiên, trong windows, chúng ta không xử lí âm thanh – do không cần thiết và
không có đủ thời gian để thực hiện.
4.7. Giao diện ứng dụng
Ứng dụng của chúng ta xây dựng là ứng dụng console: để có giao diện giúp chúng ta
debug dễ dàng. Đầu vào của ứng dụng là hàm main() -> chúng ta thực hiện các việc sau:
- Khởi tạo ứng dụng.
- Tạo cửa sổ và khởi tạo đối tượng OpenGL ES 2.0.
- Bắt đầu trò chơi.
- Gọi vòng lặp trò chơi.
app->StartApp();
while (!exit)
{
// Update and Paint
app->Update();
app->Render();
eglSwapBuffers(context->display, context->surface);
};
app->Destroyed();

4.8. Giao diện xuất nhập tập tin
Việc xuất nhập tập tin trong windows tương đối đơn giản. Chúng ta chỉ cần sử dụng các
phương thức cơ bản của thư viện <stdio.h> để thực hiện.
// Open a file in Windows 32bits so easily
FILE* Win32FileSystem::OpenFile(const char *filename, const
char *mode)
{
FILE *file;
fopen_s(&file, filename, mode);
return file;
};

CHƯƠNG 5. QUY TRÌNH CHUYỂN TRÒ CHƠI
Sau khi thực hiện cài đặt các bước trên, ta có được ứng dụng trò chơi hoàn chỉnh trên
windows. Tuy nhiên, mục tiêu của chúng ta là khiến chương trình đó chạy được trên các thiết
bị Android và IOS. Để làm được điều đó, chúng ta cần phải tiến hành chuyển sang IPhone và
Android OS. Để làm được điều đó ta cần phải cài đặt các thành phần khác nhau trên các hệ
thống này.
5.1. Chuyển sang IOS
5.1.1. Cài đặt môi trường phát triển
Cho tới thời điểm này, ứng dụng IOS chỉ có thể phát triển, biên dịch và gỡ rối trên
XCODE. XCODE chỉ có thể chạy được trên hệ điều hành MAC OS. Và ứng dụng IOS chỉ có
thể được tự do phân phối hợp pháp trên AppleStore. Do đó chúng ta phải tiến hành cài đặt môi
trường phát triển cho IOS.
- Cài đặt MAC OS, có 2 cách:
• Phải mua thiết bị Apple, Mac OS được cài sẵn trên đó.
• Cài đặt bất hợp pháp sử dụng HackIntosh.
- Cài đặt Xcode 4, IOS Dev SDK 4.3
• Xcode 4 được cung cấp miễn phí cho nhà phát triển IPHONE, MAC.
• IOS Dev SDK 4.3 và Xcode 4 yêu cầu phiên bản Mac 10.6.3 trở về sau.
Để phát triển ứng dụng và kiểm thử trên thiết bị IOS thật sự, ta phải có các yêu cầu
sau:
- Thiết bị IOS: iPhone, iPod Touch hoặc iPad. iPod Touch là lựa chọn hợp lí do cấu
hình cao tương đương iPhone nhưng giá thành lại rẻ hơn nhiều (1/3).
- Tài khoản IPhone Developer của Apple, đi kèm xác nhận và bộ phát triển: có thời
hạn một năm với giá là 99$. Tài khoản này cho phép nhà phát triển ứng dụng phân
phối ứng dụng của mình trên Apple Store dưới hình thức miễn phí hoặc thu phí.

5.1.2. Tạo dự án, biên dịch
Xcode cung cấp cho chúng ta công cụ rất tốt để tạo dự án và biên dịch. Trong chương
trình của mình, em sử dụng ví dụ có sẵn của iPhone SDK là Hello OpenGL ES 2.0 để tiến hành
cài đặt tiếp các thành phần khác của ứng dụng.
Sau đó chúng ta tiến hành chuyển các thành phần khác vào iPhone.
5.1.3. Âm thanh
Ta sử dụng đối tượng âm thanh AVAAudioPlayer của AVFoundation để tiến hành cài
đặt âm thanh trên IOS.
- Khởi tạo âm thanh:
- Bắt đầu một âm thanh:

- Tắt tất cả âm thanh:
5.1.4. Nhập
Sự kiện touch được nhận từ lớp ViewController của ứng dụng, thông qua 3 hàm:
- touchesBegan.
- touchesEnded.
- touchesMoved.
Ta chỉ cần lấy tọa độ Touch tương ứng và tiến hành chuyển qua.

Đối với phiên bản iPhone 4, chúng ta phải nhân đôi tọa độ (do iPhone 4 sử dụng màn
hình võng mạc có độ phân giải gấp 4 lần độ phân giải iphone thường).
Trong iPhone không hổ trợ tọa độ Touch ở chế độ màn hình ngang. Do đó ta phải tự tính
toán theo công thức: x = y, y = SCREEN_H – x.
5.1.5. Giao diện ứng dụng
Trong ví dụ cho sẵn của ứng dụng iPhone OpenGL ES 2.0, chúng ta đã có được bộ
khung để tiến hành xây dựng ứng dụng. Do tất cả mã nguồn đã được viết trên C++ nên ta
không cần chú ý tới nhiều về cấu trúc chương trình iPhone, chúng ta chỉ cần gọi các hàm để
load ứng dụng C++ của chúng ta lên là được. Các phương thức để thêm đối tượng của chúng ta
vào.
- awakFromNib: là phương thức được gọi sau khi View đã được load từ file nib. Ở
đây chúng ta sẽ gọi hàm khởi động ứng dụng của mình.
- renderFrame: là phương thức để vẽ ứng dụng IOS sử dụng OpenGL ES 2.0, ở đây
chúng ta sẽ gọi hàm xử lí vòng lặp của mình.
ApplicationDelegate là lớp xử lí các sự kiện liên quan tới ứng dụng:
- applicationDidEnterBackground: Được gọi khi ứng dụng bị ẩn đi, ở đây ta sẽ gọi
app->Paused.

- applicationWillEnterForeground: Được gọi khi ứng dụng hiện trở lại, ở đây ta sẽ gọi
hàm app->Resumed.
5.1.6. Xuất nhập tập tin
Các tập tin tài nguyên được đưa vào resource của ứng dụng, khi biên dịch các tập tin
này sẽ được chép sang tập tin đóng gói của ứng dụng. Sau khi cài đặt, các tập tin này sẽ được
chép vào thư mục cài đặt của ứng dụng. Để đọc được các tập tin này, chúng ta cần phải lấy
đường dẫn chính xác để sử dụng. Ở ứng dụng IOS, ta chỉ cần thêm hàm để lấy đường dẫn
chính xác.
5.2. Chuyển sang Android
5.2.1 Cài đặt phần mềm
Để tạo môi trường phát triển trên Android ta cần cài đặt các công cụ sau:
- Java SDK: yêu cầu để chạy ứng dụng Java.
- Cygwin 1.7 trở về sau: dùng để giả lập môi trường phát triển linux, gcc và chạy
NDK.
- Android SDK: cần thiết để biên dịch, đóng gói ứng dụng Android. Ngoài ra Android
SDK còn cung cấp cho chúng ta các công cụ để tương tác với thiết bị di động, và bộ
giả lập.
- Android NDK: Dùng để biên dịch mã nguồn C ra thư viện từ đó gọi từ java.

5.2.2. Hoạt động của JNI và quy trình biên dịch
Như chúng ta đều biết, ứng dụng android chạy trên nền chính là Java. Muốn chạy
C/C++ ta có hai giải pháp:
- Sử dụng JNI: từ android 1.5 trở về sau.
- Sử dụng Native Activity: từ android 2.3 trở về sau.
Native Activity là phương án lựa chọn tốt hơn, bởi vì chương trình sẽ không tốn chi phí
giao dịch giữa máy ảo Java và C/C++. Tuy nhiên, tới thời điểm hiện tại, số lượng các thiết bị
hổ trợ Android 2.3 tương đối hiếm nên chúng ta sẽ sử dụng giải pháp JNI.
Hoạt động của JNI được mô tả như sau:
- Các phương thức JNI được đánh dấu bằng từ khóa native.
- Các phương thức này được viết bằng C++ và biên dịch ra thư viện liên kết động .so.
- Thư viện liên kết động được Load lên trong chương trình Java bằng lời gọi
System.loadLibrary(…);
- Khi trong chương trình Java có lời gọi tới hàm native, máy ảo Java sẽ tìm kiếm trong
thư viện động xem hàm này đã được cài đặt chưa, sau đó các đối tượng Java sẽ được
chuyển thành C++ để thực hiện lời gọi tới C++.
- Trong C++ cũng cung cấp các thư viện cho phép giao tiếp tới máy ảo và chương
trình Java.
Quy trình xây dựng một chương trình có sử dụng JNI như sau:
- Khai báo phương thức native ở trong lớp Java.
- Khai báo và cài đặt phương thức này trong C. (Nếu C++ thì phải sử dụng extern
“C” để tránh sửa tên trong C++). Quy tắc đặt tên hàm đó như sau:

tengoi_tenlop_tenphuongthuc
- Sau đó dùng NDK để biên dịch mã nguồn C thành thư viện liên kết động và thư viện
này được tự động bỏ vào thư mục lib của dự án android.
- Viết chương trình java gọi các hàm native này.
- Dùng bộ SDK để biên dịch thành ứng dụng apk.
Do các bước sử dụng NDK để biên dịch được thực hiện trên dấu nhắc lệnh, do đó chúng
ta sẽ tạo tập tin lệnh để thực hiện điều này.
5.2.3. Đồ họa
Android hổ trợ OpenGLES 2.0 trong NDK từ phiên bản 2.1 trở về sau. Và trong ví dụ
NDK có sẵn ví dụ thực thi với OpenGL ES 2.0 nên ta có thể sử dụng ví dụ này, sau đó thay đổi
các thành phần trong đó để tải ứng dụng C++ và chạy lên.
Ngoài ra để biên dịch với OpenGL ES 2.0 thì trong make file của dự án NDK ta phải
thêm dòng LOCAL_LDLIBS := -llog -lz -lGLESv2.
5.2.4. Âm thanh
NDK không hổ trợ chơi âm thanh cho đến Android phiên bản 2.2 trở về sau. Do đó
chúng ta sẽ sử dụng Java để chạy các tập tin âm thanh.
Phần tải các tập tin âm thanh, Play Sound và StopSound được cài đặt trong Java:

Trong C++, ta cài đặt các hàm PlaySound và Stop Sound bằng cách gọi tới hàm
PlaySound trong đối tượng Java.
5.2.5. Cảm ứng chạm
Trong ứng dụng Android, ta nhận sự kiện cảm ứng chạm thông qua hàm
OnTouchEvent.

Từ đó ta gọi đến các hàm native trong C++ và xử lí nó.
5.2.6. Giao diện ứng dụng
Ứng dụng Java được viết theo Activity. Trong ứng dụng Java, chúng ta tải một
GLSurfaceView để thể hiện giao diện OpenGL ES 2.0. Trong các hàm này, chúng ta thêm các
phương thức để gọi chương trình C/C++ của chúng ta từ thư viện native lên và thực hiện.
Các phương thức:

- onSurfaceCreate: được gọi khi đối tượng GLSurfaceView được tạo ra, tại đây ta cần
gọi hàm app->Init(), và app->StartGame().
- onDrawFrame: hàm được gọi khi đối tượng được vẽ ra. Tại đây ta cần gọi các hàm
app->Update(), và app->Render.
5.2.7. Xử lí file
Các tập tin trong res/raw sẽ truy cập được từ Android bằng lệnh fdopen(). Tuy nhiên, ta
cần phải biết các thông số ID để thực hiện truy xuất này.
Từ Java ta có thể lấy các thông số này và truyền vào C/C++:
Trong C++ ta lưu lại các tham số này.
Sau đó sử dụng lúc cần thiết.

Vậy là ta có thể đọc các tập tin tài nguyên và hiển thị lên trong trò chơi.

I o snandroidc++

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Viewers also liked

Viewers also liked (8)

Similar to I o snandroidc++

Similar to I o snandroidc++ (20)

I o snandroidc++