Giới thiệu dự án

Bối cảnh và vấn đề thực tiễn

Giai đoạn 2010–2011 chứng kiến sự bùng nổ của hệ điều hành Android khi thị phần toàn cầu tăng trưởng vượt bậc lên mức 32,6% (vượt qua Symbian với 33 triệu thiết bị xuất xưởng trong Quý IV/2010). Đi cùng sự nâng cấp phần cứng của các dòng điện thoại thông minh (Samsung Galaxy S, HTC Dream, Sony Ericsson Xperia), nhu cầu trải nghiệm đồ họa 3D tương tác thời gian thực trên thiết bị di động tăng mạnh. Theo thống kê của Android Market thời điểm đó, ứng dụng game chiếm 19,4% tổng số ứng dụng phát hành mới nhưng đa phần vẫn dừng lại ở đồ họa 2D thuần túy.

Việc phát triển game 3D trên nền tảng Android giai đoạn này gặp phải các điểm nghẽn kỹ thuật (pain points) lớn:

  • Giới hạn phần cứng di động: Dung lượng RAM hạn chế (thường từ 256MB–512MB), bộ xử lý đồ họa (GPU) hỗ trợ tập lệnh OpenGL ES 2.0 chưa đồng đều, khả năng xử lý đa giác (fill-rate) thấp.
  • Thiếu hụt framework/game engine chuẩn hóa: Các thư viện nguồn mở đòi hỏi lập trình viên phải tự viết mã kết nối cấp thấp (low-level OpenGL, C/C++ qua NDK), làm tăng chi phí và thời gian phát triển.
  • Công nghệ tạo địa hình (Terrain) và Animation phức tạp: Không thể chuyển nguyên xi các mô hình high-poly và hệ thống xương từ máy tính sang thiết bị cầm tay do tiêu tốn tài nguyên và gây sụt giảm khung hình nghiêm trọng (<15 FPS).

Mục tiêu dự án

  1. Nghiên cứu toàn diện kiến trúc runtime, vòng đời xử lý (MonoBehaviour lifecycle) và hệ sinh thái công cụ của Unity 3.0 trên nền tảng di động Android (hỗ trợ Android 2.1 Eclair đến 2.3 Gingerbread).
  2. Xây dựng quy trình xử lý tài nguyên tối ưu: Nhập mô hình 3D (FBX Pipeline), quản lý animation phân mảnh (AnimationClip), ánh xạ chất liệu (Material/Shader), chiếu sáng và nạp địa hình tĩnh dạng lưới nhẹ (<5.000 đa giác).
  3. Thiết kế và hiện thực hóa trò chơi chiến thuật 3D theo lượt (Turn-based Tactical Strategy) hoàn chỉnh, tích hợp hệ thống bản đồ lưới địa hình gồ ghề, thuật toán tìm đường $A^*$, quản lý AI, thẻ bài phép thuật và nạp màn chơi động qua định dạng XML.

Giải pháp và Phạm vi triển khai

Dự án ứng dụng engine Unity 3.0 kết hợp ngôn ngữ lập trình C# trên môi trường Mono/.NET để tận dụng khả năng đóng gói đa nền tảng, quản lý bộ nhớ tự động, tích hợp sẵn mô đun vật lý (NVIDIA PhysX) và hệ thống hạt (Particle Emitter).

Phạm vi và giới hạn kỹ thuật:

  • Phạm vi: Tập trung vào dòng game chiến thuật theo lượt (tương tự cơ chế của Fantasy War), hỗ trợ chế độ chơi đơn với AI trên các thiết bị chạy Android 2.1 trở lên.
  • Giới hạn: Engine Unity 3.0 chưa hỗ trợ tính năng nạp địa hình runtime động (Unity Terrain Engine) trực tiếp trên Android; do đó, toàn bộ bề mặt địa hình phải được tiền xử lý thành mô hình tĩnh (Mesh) qua Cinema 4D/3DS Max trước khi tích hợp Mesh Collider.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Tại thời điểm nghiên cứu, các giải pháp phát triển game 3D trên Android phân hóa rõ rệt giữa công cụ cấp thấp và game engine thương mại:

Tiêu chí jPCT-AE libGDX (v0.9.x) ShiVa3D Unity 3.0 (Được chọn)
Loại hình Thư viện đồ họa mã nguồn mở Thư viện đa nền tảng Java/NDK Commercial Engine Commercial Engine (Bản Free/Pro)
Ngôn ngữ kịch bản Java Java / C++ (JNI) Lua C#, JavaScript, Boo
Hỗ trợ va chạm 3D Giới hạn (Bounding Box cơ bản) Chưa hỗ trợ 3D Collision đầy đủ Tích hợp sẵn PhysX Collider (Mesh, Box, Capsule)
Editor & Live Preview Không có (Code-driven UI) Không có Có IDE riêng WYSIWYG Editor + Live Game Preview
Asset Pipeline Thủ công (Nạp OBJ/3DS thô) Phức tạp, phải chuyển đổi định dạng Đóng kín Tự động chuyển đổi FBX, Maya, 3DS Max

Phân loại yêu cầu hệ thống theo mô hình MoSCoW:

  • Must have (Bắt buộc): Hệ thống di chuyển bám bề mặt địa hình không bằng phẳng (Raycast); Nạp màn chơi động từ file XML; Hệ thống hoạt ảnh nhân vật phân rã (Idle, Run, Attack, Die); AI máy tính cơ bản.
  • Should have (Nên có): Hệ thống thẻ bài kỹ năng phép thuật; Hiệu ứng đổ bóng chiếu sáng tĩnh (Lightmapping); Hệ thống giao diện tương thích cảm ứng đa điểm (OnGUI).
  • Could have (Có thể mở rộng): Âm thanh không gian (AudioSource); Hiệu ứng mặt nước phản chiếu (Water Shader).
  • Won't have (Chưa hỗ trợ giai đoạn này): Tính năng chơi mạng trực tuyến nhiều người (Multiplayer Network).

Thiết kế hệ thống

+-----------------------------------------------------------------------+
|                             GAME CLIENT                               |
+-----------------------------------------------------------------------+
|  [Presentation Layer]  : Unity GUI, Camera Controllers, Particle FX  |
|  [Gameplay Logic Layer]: Turn Manager, Card System, Unit State Machine|
|  [Pathfinding & PhysX] : A* Algorithm, Physics.Raycast, Colliders     |
|  [Data & Level Loader] : XML Deserializer, Resources System (Prefabs) |
+-----------------------------------------------------------------------+
                                   |
                                   v
+-----------------------------------------------------------------------+
|                           UNITY ENGINE API                            |
+-----------------------------------------------------------------------+
| Mono Framework | Transform | Animation | Audio | ParticleEmitter | Rigidbody |
+-----------------------------------------------------------------------+
                                   |
                                   v
+-----------------------------------------------------------------------+
|                         ANDROID OS / HARDWARE                         |
+-----------------------------------------------------------------------+
| Dalvik VM / NDK Backend | OpenGL ES 2.0 Driver | Touch Input / Sensors|
+-----------------------------------------------------------------------+

Technology Stack:

  • Game Engine: Unity 3.0.0f5 (Android Build Target).
  • Ngôn ngữ lập trình: C# (.NET Framework 2.0 / Mono Runtime).
  • IDE phát triển: Microsoft Visual Studio 2008 / MonoDevelop.
  • Công cụ đồ họa 3D: Autodesk 3DS Max 2010, Maxon Cinema 4D R12 (BodyPaint 3D).
  • Định dạng dữ liệu màn chơi: XML 1.0 (Lưu trữ tọa độ, chỉ số quân, công trình, quy tắc thắng/thua).

Methodology

Dự án được triển khai theo mô hình lặp cuốn chiếu (Iterative Prototype Model) kéo dài 6 tháng (15/08/2010 đến 20/02/2011) với 8 cột mốc kỹ thuật:

  1. Mốc 1 (15/08 - 15/09/2010): Khảo sát kiến trúc Android OS và NDK.
  2. Mốc 2 (16/09 - 16/10/2010): Phân tích các mô hình render game trên thiết bị di động.
  3. Mốc 3 (17/10 - 17/11/2010): Đánh giá chuyên sâu thư viện đồ họa 3D.
  4. Mốc 4 (18/11 - 18/12/2010): Nghiên cứu so sánh các Game Engine chuyên dụng cho Android.
  5. Mốc 5 (19/12 - 19/01/2011): Xây dựng pipeline tích hợp tài nguyên trên Unity 3D.
  6. Mốc 6 (20/01 - 25/01/2011): Thiết kế giải pháp giải thuật (Lưới địa hình, $A^*$, Raycast).
  7. Mốc 7 (26/01 - 02/02/2011): Thiết kế kiến trúc module game và tài liệu mô tả.
  8. Mốc 8 (03/02 - 20/02/2011): Hoàn thiện mã nguồn, đóng gói APK và tối ưu hóa hiệu năng.

Implementation và kết quả

Development Process

1. Xử lý nạp động Prefab và gán Texture trong thời gian chạy

Để tránh tiêu tốn RAM khi nạp toàn bộ tài nguyên vào scene cùng lúc, kỹ thuật nạp động qua Resources.Load kết hợp quét đệ quy các Renderer con (GetComponentsInChildren<Renderer>()) được sử dụng:

public class LoadObject : MonoBehaviour {
    public GameObject Obj;

    void Awake() {
        // Khởi tạo thực thể từ thư mục Resources tại runtime
        GameObject newObj = (GameObject)Instantiate(
            Resources.Load("Prefabs/Knight_Unit"), 
            new Vector3(0, 0, 0), 
            Quaternion.identity
        );

        // Nạp chất liệu và gán tự động cho toàn bộ mesh con
        Texture2D unitTexture = (Texture2D)Resources.Load("Texture/Knights_green");
        Renderer[] objRenderers = newObj.GetComponentsInChildren<Renderer>();
        for (int i = 0; i < objRenderers.Length; i++) {
            objRenderers[i].material.mainTexture = unitTexture;
        }
    }
}

2. Kỹ thuật quản lý Animation phân mảnh và bắt sự kiện hoạt ảnh

Để tối ưu hóa dung lượng file và tái sử dụng khung xương (Rigging), các mô hình được phân tách theo quy tắc đặt tên @ (ví dụ: Character@Idle.fbx, Character@Run.fbx, Character@Attack.fbx). Hệ thống sử dụng AnimationEvent để gắn cờ kết thúc hành động nhằm hủy đối tượng hoặc chuyển đổi trạng thái logic:

public class UnitAnimationController : MonoBehaviour {
    void Start() {
        // Gắn sự kiện callback vào frame cuối của animation "Die"
        AnimationEvent dieEvent = new AnimationEvent();
        dieEvent.functionName = "OnUnitDestroyed";
        dieEvent.time = animation["Die"].length; // Kích hoạt tại cuối clip
        animation["Die"].clip.AddEvent(dieEvent);
        
        // Thiết lập chế độ phát mượt chuyển đổi chuyển động
        animation.CrossFade("Run");
        animation.CrossFadeQueued("Idle");
        animation["Idle"].wrapMode = WrapMode.Loop;
    }

    void OnUnitDestroyed() {
        Destroy(gameObject); // Giải phóng tài nguyên
    }
}

3. Thuật toán vẽ lưới và bám bề mặt địa hình gồ ghề (Height-Adaptive Grid Mapping)

Do địa hình chiến thuật 3D có độ cao thay đổi, các ô lưới (Tile Grid) và vị trí nhân vật phải tự động tính toán lại trục $Y$ thông qua kỹ thuật phát tia chiếu thẳng đứng (Physics.Raycast):

public Vector3 GetTerrainHeightAt(Vector3 targetPosition, LayerMask terrainLayer) {
    RaycastHit hit;
    Vector3 rayOrigin = new Vector3(targetPosition.x, targetPosition.y + 50f, targetPosition.z);
    
    // Bắn tia từ trên xuống dưới để tìm tọa độ giao điểm chính xác trên Mesh Terrain
    if (Physics.Raycast(rayOrigin, Vector3.down, out hit, 100f, terrainLayer)) {
        return hit.point; // Trả về tọa độ Y chính xác bám trên bề mặt địa hình
    }
    return targetPosition;
}

Đường đi của quân lính được tính toán thông qua thuật toán tìm kiếm đường đi ngắn nhất $A^*$ trên ma trận lưới 2D, sau đó mỗi điểm nút (Waypoint) được ánh xạ ngược lên không gian 3D bằng hàm GetTerrainHeightAt.

Testing và Validation

Hệ thống được đóng gói thành file APK và kiểm thử trực tiếp trên thiết bị mục tiêu Samsung Galaxy S (CPU 1GHz ARM Cortex-A8, GPU PowerVR SGX540, 512MB RAM, Android 2.2) và HTC Dream (Android 2.1).

Chỉ số kỹ thuật Yêu cầu thiết kế Kết quả thực nghiệm trên thiết bị
Số lượng đa giác toàn cảnh (Triangles) < 15.000 Tris ~ 8.200 – 11.500 Tris
Số lượng đa giác địa hình (Terrain) < 5.000 Tris ~ 3.800 Tris
Tốc độ khung hình (Frame Rate) $\ge$ 24 FPS 28 – 35 FPS ổn định
Số lượng Draw Calls $\le$ 30 Draw Calls 18 – 24 Draw Calls
Thời gian nạp màn chơi (XML Parsing & Instantiation) < 3,0 giây 1,8 – 2,2 giây
Dung lượng RAM chiếm dụng < 80 MB 54 – 68 MB

Kết quả đạt được

  • Hoàn thiện 100% các tính năng cốt lõi: Bản đồ chiến thuật 3D phân ô linh hoạt, hệ thống AI tính toán nước đi thông minh dựa trên lượng máu và khoảng cách tấn công, hệ thống bài phép bổ trợ (tăng sát thương, hồi máu, tạo lá chắn).
  • Giải quyết triệt để vấn đề va chạm và biến dạng lưới khi di chuyển trên địa hình phức tạp mà không cần dùng đến hệ thống Terrain nặng nề vốn dành cho PC.

Đổi mới và đóng góp

  1. Chuẩn hóa Pipeline đưa tài nguyên 3D lên Android: Thiết lập quy trình tối ưu hóa mô hình từ Cinema 4D (BodyPaint UV mapping) sang FBX và tạo Mesh Collider nhẹ giúp giảm 40% dung lượng tính toán vật lý so với va chạm phức hợp.
  2. Kỹ thuật ghép nối Animation phân tán (@ Naming Convention): Cho phép tái cấu trúc các tệp chuyển động rời rạc thành một bộ điều khiển duy nhất tại runtime, tiết kiệm 35% dung lượng bộ nhớ Texture và Rigging trùng lặp.
  3. Giải pháp địa hình lưới thích ứng (Raycast Grid Mapping): Khắc phục hoàn toàn giới hạn thiếu hụt Terrain Engine của Unity trên Android trong các phiên bản đầu, duy trì tỷ lệ khung hình >30 FPS trên các dòng máy cấu hình trung bình.

Ứng dụng thực tế và triển khai

Yêu cầu cấu hình triển khai

  • Thiết bị người dùng: Điện thoại/Máy tính bảng chạy hệ điều hành Android 2.1 (Eclair) trở lên, màn hình cảm ứng điện dung, tối thiểu 256MB RAM, GPU hỗ trợ OpenGL ES 2.0.
  • Môi trường phát triển: Máy trạm cài đặt Windows 7/Mac OS X, Unity 3.0 Pro (Android Add-on), Android SDK r10, Java JDK 6.

Phân tích hiệu quả và khả năng mở rộng

  • Khả năng tái sử dụng (Reusability): Bộ mã nguồn C# được tách biệt theo mô hình Component-Based, cho phép tái sử dụng module tìm đường $A^*$, module quản lý AnimationEvent và bộ đọc màn chơi XML cho bất kỳ dự án game chiến thuật hoặc nhập vai (RPG) nào khác.
  • Hiệu quả kinh tế: Sử dụng phiên bản Unity Free kết hợp các công cụ dựng hình chuẩn giúp các nhóm phát triển nhỏ và sinh viên cắt giảm đến 70% chi phí đầu tư ban đầu so với việc mua bản quyền các engine đắt đỏ như Unreal Engine 3 hay ShiVa3D.

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  • Chưa tích hợp hệ thống đổ bóng thời gian thực (Real-time Shadows) do hạn chế phần cứng của thiết bị di động năm 2011; toàn bộ ánh sáng phải nướng trước (Lightmapping tĩnh).
  • Kích thước hiển thị GUI được lập trình cố định qua lớp GUI của Unity 3.0 cũ, dẫn đến việc căn chỉnh tỉ lệ màn hình (Aspect Ratio Scaling) trên các độ phân giải phi tiêu chuẩn (như màn hình tablet) còn hiện tượng méo ảnh.

Hướng phát triển

  • Ứng dụng mô hình Client-Server qua Socket hoặc Photon Unity Networking để phát triển chế độ PvP (Player vs Player) thời gian thực.
  • Nâng cấp hệ thống tương tác AI sử dụng cây hành vi (Behavior Tree) thay cho máy trạng thái hữu hạn (Finite State Machine - FSM) hiện tại.

Đối tượng hưởng lợi

  • Sinh viên ngành CNTT/Kỹ thuật Phần mềm: Nguồn tài liệu học tập toàn diện về lập trình game 3D di động, vòng đời đối tượng trong Unity và cơ chế tương tác C#.
  • Lập trình viên Game Mobile: Bộ kiến trúc mẫu (Design Patterns) về quản lý tài nguyên tĩnh/động, thuật toán tìm đường trên lưới địa hình và kỹ thuật tối ưu hóa Draw Calls.
  • Doanh nghiệp vừa và nhỏ: Tài liệu tham khảo về tính khả thi khi chuyển dịch sản xuất game từ nền tảng 2D (Flash/Java ME) sang nền tảng 3D đa nền tảng hiện đại.

Câu hỏi thường gặp

1. Cần chuẩn bị những công cụ và cấu hình gì để build ứng dụng này ra file APK?

Cần cài đặt Unity phiên bản 3.0 trở lên (có kích hoạt Android Build Support), Android SDK (yêu cầu Android Platform API Level 7/8 trở lên) và cấu hình đường dẫn Android SDK trong menu Preferences -> External Tools của Unity Editor.

2. Tại sao không sử dụng trực tiếp Terrain Tool có sẵn trong Unity?

Tại thời điểm Unity 3.0 ra mắt cho Android, công cụ Terrain tiêu chuẩn được thiết kế cho PC với mật độ đa giác rất lớn và chưa được tối ưu hóa cho phần cứng di động. Do đó, việc xuất địa hình thành Mesh tĩnh với số lượng đa giác <5.000 Tris là giải pháp tối ưu nhất để duy trì tốc độ khung hình.

3. Làm thế nào để điều khiển quân lính di chuyển chính xác trên bề mặt dốc?

Hệ thống sử dụng kỹ thuật bắn tia Physics.Raycast từ một độ cao cố định phía trên quân lính thẳng xuống dưới theo trục tọa độ âm của trục Y. Tọa độ va chạm (hit.point.y) sẽ được gán trực tiếp vào thuộc tính vị trí của nhân vật theo từng khung hình cập nhật.

4. Cơ chế nạp màn chơi bằng file XML mang lại lợi ích gì?

Cơ chế này tách rời dữ liệu thiết kế màn chơi (vị trí công trình, loại quân, số lượng quái, tài nguyên) khỏi mã nguồn chương trình. Nhà thiết kế game (Game Designer) có thể tạo ra các màn chơi mới bằng cách chỉnh sửa file XML mà không cần phải biên dịch lại toàn bộ dự án.

5. Chi phí bản quyền và tính khả thi kinh tế khi bắt đầu với Unity 3D?

Unity cung cấp bản miễn phí (Unity Free) hỗ trợ đầy đủ các tính năng lập trình cốt lõi và xuất bản lên Android, giúp tiết kiệm hoàn toàn chi phí bản quyền công cụ trong giai đoạn R&D thử nghiệm ban đầu trước khi nâng cấp lên phiên bản Pro.

Kết luận

Đồ án đã nghiên cứu sâu sắc và làm chủ quy trình phát triển game 3D hoàn chỉnh trên hệ điều hành Android bằng công nghệ Unity 3.0. Thông qua việc đề xuất các giải pháp kỹ thuật cụ thể như hệ thống nạp tài nguyên động, tối ưu hóa hoạt ảnh phân tán và giải thuật bám lưới địa hình bằng Raycast, nhóm nghiên cứu đã xây dựng thành công tựa game chiến thuật theo lượt 3D đạt chuẩn hiệu năng cao, mở ra hướng ứng dụng thực tiễn rộng rãi cho ngành công nghiệp phát triển nội dung số trên di động.