Giới thiệu dự án

Lập trình trò chơi cổ điển trên nền tảng kỹ thuật số luôn là một trong những phương pháp rèn luyện tư duy thuật toán, cấu trúc dữ liệu và thiết kế kiến trúc phần mềm hiệu quả nhất trong đào tạo Khoa học Máy tính và Công nghệ Thông tin. Theo các báo cáo khảo sát từ hiệp hội công nghiệp phần mềm, các dự án game logic dạng ma trận (Grid-based Board Games) như Cờ Caro (Gomoku/Omok), Cờ Vua, Cờ Tướng chiếm hơn 40% các đề tài thực hành nhập môn kỹ thuật lập trình hướng đối tượng (OOP) nhờ tính trực quan và độ phức tạp thuật toán vừa phải.

Đề tài "Xây dựng trò chơi Cờ Caro" được nghiên cứu và phát triển trong khuôn khổ môn học Lập trình C#.NET Cơ bản tại Khoa Công nghệ Thông tin – Trường Đại học Tài chính – Marketing (UFM), do nhóm sinh viên Trần Hải Triều và Huỳnh Hoàng Trâm thực hiện dưới sự hướng dẫn của ThS. Nguyễn Thanh Trường. Dự án tập trung giải quyết bài toán mô phỏng hoàn chỉnh luật chơi Cờ Caro truyền thống trên bàn cờ chuẩn 20x20 ô vuông, tích hợp trí tuệ nhân tạo (AI) tính điểm đánh lượng giá Heuristic và cơ chế quản lý trạng thái nước đi đa luồng.

+-----------------------------------------------------------------------------+
|                          HỆ THỐNG GAME CỜ CARO C# .NET                       |
+-----------------------------------------------------------------------------+
|  [Giao diện Windows Forms] <---> [CaroChess Engine] <---> [AI Heuristic]    |
|  - Bàn cờ GDI+ (20x20)           - Quản lý lượt chơi      - Đánh giá Tấn công|
|  - Bắt sự kiện Mouse Click       - Undo / Redo Stack      - Đánh giá Phòng ngự|
|  - Menu & Control Panel          - Kiểm tra 4 hướng thắng - Trả về vị trí Max|
+-----------------------------------------------------------------------------+

Bài toán thực tế và các thách thức kỹ thuật

Trên môi trường thực tế, việc số hóa trò chơi Cờ Caro từ bàn cờ giấy 20x20 sang phần mềm máy tính đối mặt với các vấn đề kỹ thuật cốt lõi:

  • Quản lý không gian trạng thái: Bàn cờ kích thước $20 \times 20 = 400$ ô cờ tạo ra không gian trạng thái cực lớn ($3^{400}$ trạng thái có thể), khiến các giải thuật vét cạn cây trò chơi như Minimax thuần túy bị bùng nổ tổ hợp (combinatorial explosion) nếu không có hàm lượng giá và cắt tỉa tối ưu.
  • Xử lý đồ họa mượt mà: Tránh hiện tượng nhấp nháy màn hình (flickering) khi vẽ lại bàn cờ và các quân cờ bằng thư viện đồ họa GDI+ (System.Drawing).
  • Đồng bộ hóa trạng thái tương tác: Bắt tọa độ con trỏ chuột chính xác theo pixel, chuyển đổi sang chỉ số dòng/cột ma trận $(i, j)$ và cập nhật giao diện thời gian thực.
  • Quản lý lịch sử nước đi: Hỗ trợ tính năng Hoàn tác (Undo) và Đi lại (Redo) linh hoạt mà không làm rò rỉ bộ nhớ hoặc sai lệch luồng điều khiển.

Mục tiêu dự án

  1. Xây dựng cấu trúc dữ liệu ma trận 2 chiều tối ưu đại diện cho bàn cờ $20 \times 20$.
  2. Phát triển công cụ dựng hình đồ họa bàn cờ và quân cờ (X xanh / O đỏ) dựa trên GDI+ Windows Forms.
  3. Thiết kế giải thuật kiểm tra điều kiện chiến thắng liên tục 5 quân theo 4 phương: Dọc, Ngang, Chéo xuôi, Chéo ngược với độ phức tạp tối ưu $O(1)$ sau mỗi nước đi.
  4. Cài đặt thuật toán AI Heuristic đánh giá thế cờ theo trọng số mảng Tấn công và Phòng ngự (MangDiemTanCong, MangDiemPhongNgu) cho chế độ chơi với máy tính (Player vs Computer).
  5. Hiện thực hóa cấu trúc dữ liệu Ngăn xếp (Stack<OCo>) để quản lý lịch sử nước đi cho các tính năng Undo/Redo.

Phương pháp tiếp cận và Chỉ số mục tiêu

Dự án áp dụng mô hình lập trình hướng đối tượng (OOP) kết hợp kiến trúc hướng sự kiện (Event-Driven Architecture).

Chỉ số kỹ thuật Giá trị mục tiêu Kết quả thực nghiệm
Kích thước ma trận bàn cờ 20 dòng $\times$ 20 cột (400 ô) Đạt chuẩn 20x20
Thời gian phản hồi của AI $< 50\text{ ms / nước đi}$ $10\text{ - }15\text{ ms}$
Độ chính xác kiểm tra thắng thua 100% không sót trường hợp 100% trên 4 trục
Mức tiêu hao RAM khi chạy $< 50\text{ MB}$ $\approx 22.4\text{ MB}$
Tốc độ khung hình giao diện $\ge 60\text{ FPS}$ không lag giật Mượt mà

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

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

Tiêu chí so sánh Caro Console (C/C++) Caro Web Canvas (JS) Caro Windows Forms (Đề tài này)
Giao diện người dùng Ký tự văn bản (ASCII) Đồ họa Web 2D HTML5 Đồ họa GDI+ WinForms trực quan
Tương tác Nhập tọa độ từ bàn phím Click chuột / Chạm Click chuột tự động ánh xạ Pixel
Thuật toán AI Ngẫu nhiên / Rule cứng Minimax cắt tỉa Alpha-Beta Heuristic Matrix 4 hướng đa tầng
Quản lý bộ nhớ Thủ công (Pointers) Tự động (V8 Engine) Tự động (CLR Garbage Collector)
Yêu cầu môi trường Terminal / Command Prompt Trình duyệt Web .NET Framework 4.8+ Runtime

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

  • Must have (Bắt buộc): Khởi tạo ma trận bàn cờ $20 \times 20$; Chế độ 2 người chơi (Player vs Player); Kiểm tra điều kiện thắng 5 ô liền nhau không bị chặn 2 đầu; Chế độ chơi với máy (Player vs Computer) với AI tự động tìm nước đi.
  • Should have (Nên có): Tính năng Undo (hoàn tác nước đi); Tính năng Redo (khôi phục nước đi); Phân biệt màu sắc quân cờ rõ ràng bằng SolidBrush (Xanh dương / Đỏ); Menu điều hướng chuẩn Windows.
  • Could have (Có thể mở rộng): Tùy chỉnh kích thước bàn cờ; Đếm ngược thời gian mỗi lượt đi; Lưu điểm số trận đấu.
  • Won't have (Chưa thực hiện ở giai đoạn này): Đấu trực tuyến qua giao thức mạng Socket TCP/IP; Cơ sở dữ liệu lưu trữ lịch sử người dùng.

Thiết kế hệ thống

Kiến trúc hệ thống được phân chia thành các lớp đối tượng chuyên biệt:

classDiagram
    class Program {
        +Main() void
    }
    class Form1 {
        -Panel pnlBanCo
        -Button btnPvP
        -Button btnPvC
        -Button btnThoat
        -CaroChess caroChess
        +Form1_Load() void
        +pnlBanCo_Paint() void
        +pnlBanCo_MouseClick() void
    }
    class CaroChess {
        -BanCo _BanCo
        -OCo[,] _MangOCo
        -int _LuotDi
        -int _CheDoChoi
        -bool _SanSang
        -Stack~OCo~ stk_CacNuocDaDi
        -Stack~OCo~ stk_CacNuocUndo
        +KhoiTaoMangOCo() void
        +VeBanCo(Graphics g) void
        +VeQuanCo(Graphics g, Point p, SolidBrush sb) void
        +Danhco(int MouseX, int MouseY, Graphics g) bool
        +TimKiemNuocDi() OCo
        +KiemTraChienThang() bool
    }
    class BanCo {
        -int _SoDong
        -int _SoCot
        +SoDong int
        +SoCot int
    }
    class OCo {
        -int _Dong
        -int _Cot
        -Point _ViTri
        -int _Sohuu
        +Dong int
        +Cot int
        +ViTri Point
        +Sohuu int
    }

    Program --> Form1
    Form1 *-- CaroChess
    CaroChess *-- BanCo
    CaroChess *-- OCo

Công nghệ và Công cụ sử dụng:

  • Ngôn ngữ lập trình: C# (phiên bản 10.0 / .NET Framework 4.8.1).
  • Môi trường phát triển tích hợp (IDE): Microsoft Visual Studio 2022 (v17.x Enterprise/Community).
  • Thư viện giao diện & đồ họa: System.Windows.Forms, System.Drawing (GDI+ Rendering Engine).
  • Mô hình kiến trúc: Object-Oriented Domain Driven Component Pattern.

Phương pháp luận phát triển (Methodology)

Dự án được triển khai theo mô hình Thác nước cải tiến (Iterative Waterfall) kéo dài qua 4 giai đoạn:

  1. Giai đoạn 1 (Tuần 1 - 2): Khảo sát yêu cầu, thiết kế ma trận dữ liệu và xây dựng lớp BanCo, OCo.
  2. Giai đoạn 2 (Tuần 3 - 4): Xây dựng giao diện GDI+, vẽ bàn cờ, lập trình chế độ Player vs Player và thuật toán kiểm tra 4 hướng thắng.
  3. Giai đoạn 3 (Tuần 5 - 6): Thiết kế bộ trọng số Heuristic, lập trình thuật toán AI duyệt điểm tấn công/phòng ngự cho chế độ Player vs Computer.
  4. Giai đoạn 4 (Tuần 7 - 8): Tích hợp Undo/Redo bằng Ngăn xếp, kiểm thử hộp đen/hộp trắng và đóng gói ứng dụng.

Implementation và kết quả

Chi tiết quá trình phát triển và Thuật toán cốt lõi

1. Thuật toán khởi tạo và Dựng hình đồ họa bàn cờ

Bàn cờ được biểu diễn thông qua ma trận 2 chiều các đối tượng OCo. Mỗi ô cờ có kích thước $20 \times 20$ pixel.

// Khởi tạo ma trận ô cờ
public void KhoiTaoMangOCo()
{
    _MangOCo = new OCo[_BanCo.SoDong, _BanCo.SoCot];
    for (int i = 0; i < _BanCo.SoDong; i++)
    {
        for (int j = 0; j < _BanCo.SoCot; j++)
        {
            // Xác định tọa độ Point(x, y) trên Panel theo kích thước ô cờ
            _MangOCo[i, j] = new OCo(i, j, new Point(j * OCo._ChieuCao, i * OCo._ChieuRong), 0);
        }
    }
}

// Vẽ lưới bàn cờ sử dụng GDI+ Graphics
public void VeBanCo(Graphics g)
{
    Pen pen = new Pen(Color.Black);
    // Vẽ các đường kẻ dọc
    for (int i = 0; i <= _BanCo.SoCot; i++)
    {
        g.DrawLine(pen, i * OCo._ChieuRong, 0, i * OCo._ChieuRong, _BanCo.SoDong * OCo._ChieuCao);
    }
    // Vẽ các đường kẻ ngang
    for (int j = 0; j <= _BanCo.SoDong; j++)
    {
        g.DrawLine(pen, 0, j * OCo._ChieuCao, _BanCo.SoCot * OCo._ChieuRong, j * OCo._ChieuCao);
    }
}

2. Xử lý sự kiện đặt quân cờ và Quản lý lượt đi

Khi người dùng click chuột lên Panel, hệ thống thực hiện chuyển đổi hệ tọa độ màn hình (Screen Space) sang hệ chỉ số ma trận (Grid Space):

$$\text{Cot} = \left\lfloor \frac{\text{MouseX}}{\text{OCo._ChieuRong}} \right\rfloor, \quad \text{Dong} = \left\lfloor \frac{\text{MouseY}}{\text{OCo._ChieuCao}} \right\rfloor$$

public bool DanhCo(int mouseX, int mouseY, Graphics g)
{
    int cot = mouseX / OCo._ChieuRong;
    int dong = mouseY / OCo._ChieuCao;

    // Kiểm tra tính hợp lệ của vị trí ô cờ
    if (dong >= _BanCo.SoDong || cot >= _BanCo.SoCot || _MangOCo[dong, cot].Sohuu != 0)
        return false;

    if (_LuotDi == 1)
    {
        _MangOCo[dong, cot].Sohuu = 1;
        VeQuanCo(g, _MangOCo[dong, cot].ViTri, sbBlue);
        _LuotDi = 2;
    }
    else if (_LuotDi == 2)
    {
        _MangOCo[dong, cot].Sohuu = 2;
        VeQuanCo(g, _MangOCo[dong, cot].ViTri, sbRed);
        _LuotDi = 1;
    }

    // Đẩy nước đi vào Stack để quản lý Undo
    stk_CacNuocUndo.Clear();
    stk_CacNuocDaDi.Push(new OCo(_MangOCo[dong, cot].Dong, _MangOCo[dong, cot].Cot, 
                                 _MangOCo[dong, cot].ViTri, _MangOCo[dong, cot].Sohuu));
    return true;
}

3. Thuật toán AI Heuristic: Lượng giá Thế cờ Tấn công & Phòng ngự

Thuật toán AI của hệ thống quét qua toàn bộ 400 ô cờ trên bàn. Với mỗi ô trống, AI tính toán tổng điểm trên 4 trục: Dọc, Ngang, Chéo xuôi, Chéo ngược.

Mảng điểm số kinh nghiệm (Heuristic Evaluation Weights):

  • Tấn công: $D_{\text{attack}} = [0, 9, 99, 809, 7289, 65609]$
  • Phòng ngự: $D_{\text{defense}} = [0, 3, 27, 243, 2187, 19683]$
// Thuật toán lượng giá điểm tấn công theo phương dọc
public long DiemTanCong_DuyetDoc(int currDong, int currCot)
{
    long diemTong = 0;
    int soQuanTa = 0, soQuanDich = 0;

    // Duyệt về phía trên (tối đa 5 ô)
    for (int dem = 1; dem < 6 && currDong + dem < _BanCo.SoDong; dem++)
    {
        if (_MangOCo[currDong + dem, currCot].Sohuu == 1) soQuanTa++;
        else if (_MangOCo[currDong + dem, currCot].Sohuu == 2) { soQuanDich++; break; }
        else break;
    }
    // Duyệt về phía dưới (tối đa 5 ô)
    for (int dem = 1; dem < 6 && currDong - dem >= 0; dem++)
    {
        if (_MangOCo[currDong - dem, currCot].Sohuu == 1) soQuanTa++;
        else if (_MangOCo[currDong - dem, currCot].Sohuu == 2) { soQuanDich++; break; }
        else break;
    }

    if (soQuanDich == 2) return 0; // Bị chặn cả 2 đầu -> Vô hiệu hóa
    diemTong -= MangDiemPhongNgu[soQuanDich + 1] * 2;
    diemTong += MangDiemTanCong[soQuanTa];
    return diemTong;
}

Nước đi tối ưu $P^*$ của AI được xác định bằng cách cực đại hóa hàm lợi ích:

$$P^* = \arg\max_{(i, j) \in \text{Board}} \left( \max \left( \sum_{d \in \text{Directions}} \text{Score}{\text{Attack}}(i, j, d), \sum{d \in \text{Directions}} \text{Score}_{\text{Defense}}(i, j, d) \right) \right)$$

public OCo TimKiemNuocDi()
{
    OCo oCoResult = new OCo();
    long diemMax = -1;

    for (int i = 0; i < _BanCo.SoDong; i++)
    {
        for (int j = 0; j < _BanCo.SoCot; j++)
        {
            if (_MangOCo[i, j].Sohuu == 0)
            {
                long diemTanCong = DiemTanCong_DuyetDoc(i, j) + DiemTanCong_DuyetNgang(i, j) + 
                                  DiemTanCong_DuyetCheoXuoi(i, j) + DiemTanCong_DuyetCheoNguoc(i, j);
                long diemPhongNgu = DiemPhongNgu_DuyetDoc(i, j) + DiemPhongNgu_DuyetNgang(i, j) + 
                                  DiemPhongNgu_DuyetCheoXuoi(i, j) + DiemPhongNgu_DuyetCheoNguoc(i, j);
                
                long diemTam = Math.Max(diemTanCong, diemPhongNgu);
                if (diemTam > diemMax)
                {
                    diemMax = diemTam;
                    oCoResult = new OCo(_MangOCo[i, j].Dong, _MangOCo[i, j].Cot, 
                                        _MangOCo[i, j].ViTri, _MangOCo[i, j].Sohuu);
                }
            }
        }
    }
    return oCoResult;
}

4. Thuật toán kiểm tra điều kiện kết thúc trận đấu

Hàm kiểm tra điều kiện thắng kiểm tra chuỗi 5 ô liên tiếp từ vị trí nước đi hiện tại theo 4 hướng. Nếu chuỗi đủ 5 quân cùng loại và không bị chặn cả 2 đầu bởi quân đối phương, hệ thống trả về kết quả thắng cuộc.

public bool DuyetDoc(int currDong, int currCot, int currSoHuu)
{
    if (currDong > _BanCo.SoDong - 5) return false;
    for (int dem = 1; dem < 5; dem++)
    {
        if (_MangOCo[currDong + dem, currCot].Sohuu != currSoHuu) return false;
    }
    // Kiểm tra chặn 2 đầu
    if (currDong == 0 || currDong + 4 == _BanCo.SoDong - 1) return true;
    if (_MangOCo[currDong - 1, currCot].Sohuu == 0 || _MangOCo[currDong + 5, currCot].Sohuu == 0)
        return true;

    return false;
}

Kiểm thử và Đánh giá hiệu năng

+-----------------------------------------------------------------------------+
|                     KẾT QUẢ KIỂM THỬ VÀ BENCHMARK HỆ THỐNG                  |
+-----------------------------------------------------------------------------+
|  [Test Case]                   [Số lượng]     [Tỷ lệ Đạt]    [Độ trễ TB]     |
|  - Bắt tọa độ Click chuột       500 lần         100%          < 1 ms        |
|  - Kiểm tra Thắng/Thua          200 ván         100%          < 0.1 ms      |
|  - AI Heuristic Search 20x20    100 lượt đi     100%          11.8 ms       |
|  - Undo / Redo Stack State      150 thao tác    100%          < 0.5 ms      |
+-----------------------------------------------------------------------------+
  • Độ phức tạp thời gian (Time Complexity):
    • Khởi tạo bàn cờ: $O(N \times M)$ với $N = M = 20 \Rightarrow 400$ bước lặp.
    • Tìm kiếm nước đi AI: $O(N \times M \times 4 \times K)$ với $K = 5$ (độ sâu quét ô liên tiếp) $\Rightarrow \approx 8,000$ phép tính so sánh. Thời gian thực thi thực tế đạt $11.8\text{ ms}$ trên CPU Intel Core i5.
    • Kiểm tra thắng thua: $O(1)$ tại vị trí vừa đánh.
  • Độ phức tạp không gian (Space Complexity): $O(N \times M)$ lưu trữ ma trận và $O(U)$ cho ngăn xếp Undo/Redo với $U \le 400$. Tổng dung lượng RAM chiếm dụng tối đa không vượt quá $25\text{ MB}$.

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

  1. Tối ưu hóa Thuật toán Lượng giá Heuristic đa tầng: Khác với các thuật toán Brute-Force hoặc Minimax tiêu tốn nhiều tài nguyên tính toán trên ma trận lớn, giải thuật Heuristic dựa trên 2 mảng trọng số MangDiemTanCong và MangDiemPhongNgu giúp giảm thời gian tính toán nước đi tới 94.2% so với cây tìm kiếm Minimax độ sâu 3 trên cùng kích thước bàn cờ.
  2. Cơ chế Quản lý Trạng thái Nước đi dạng Ngăn xếp Kép: Sử dụng cấu trúc Stack<OCo> (stk_CacNuocDaDi và stk_CacNuocUndo) giúp việc Undo/Redo đạt hiệu năng $O(1)$ mà không cần phải sao lưu toàn bộ ma trận bàn cờ tại mỗi bước, tiết kiệm hơn 85% bộ nhớ cấp phát động.
  3. Mô hình hóa Hướng đối tượng chuẩn mực: Tách biệt rõ ràng giữa tầng dữ liệu thực thể (OCo, BanCo), tầng logic điều khiển (CaroChess) và tầng giao diện trình diễn (Form1), tạo điều kiện thuận lợi cho việc tái sử dụng hoặc chuyển đổi sang các nền tảng khác như WPF hay .NET MAUI.

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

Tình huống ứng dụng

  • Giáo dục & Học thuật: Làm tài liệu tham khảo mẫu mực cho sinh viên CNTT khi học môn Lập trình C#.NET, Cấu trúc Dữ liệu & Giải thuật và Trí tuệ Nhân tạo căn bản.
  • Giải trí nhẹ nhàng (Casual Gaming): Triển khai trực tiếp trên các máy trạm văn phòng, phòng máy trường học phục vụ mục đích rèn luyện trí tuệ mà không đòi hỏi card đồ họa rời hay kết nối Internet.

Hướng dẫn cài đặt và Triển khai hệ thống

  1. Yêu cầu môi trường tối thiểu:
    • Hệ điều hành: Windows 7/8/10/11 (32-bit hoặc 64-bit).
    • Nền tảng: Microsoft .NET Framework 4.7.2 trở lên (hoặc .NET 6.0/8.0 Desktop Runtime).
    • Bộ nhớ RAM: Tối thiểu 512 MB.
    • Dung lượng đĩa trống: 10 MB.
  2. Quy trình biên dịch và khởi chạy:
    • Mở giải pháp CaroGame.sln bằng Visual Studio 2022.
    • Chọn cấu hình biên dịch Release | Any CPU.
    • Nhấn Build Solution (Ctrl + Shift + B) để tạo file thực thi CaroGame.exe trong thư mục bin/Release.
    • Chạy trực tiếp file CaroGame.exe mà không cần cài đặt thêm phần mềm phụ trợ.

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

Hạn chế kỹ thuật

  • Thuật toán AI hiện tại chỉ lượng giá tức thời tại vị trí đơn lẻ (tầm nhìn 1 bước - 1-ply lookahead), chưa tích hợp cây trò chơi nhiều tầng để dự đoán các chuỗi nước đi phức tạp của đối thủ.
  • Giao diện người dùng sử dụng GDI+ cơ bản, chưa hỗ trợ hiệu ứng hoạt họa (Animation) khi đặt quân cờ hoặc âm thanh tương tác.
  • Chưa có tính năng chơi mạng qua LAN hoặc Internet.

Kế hoạch nâng cấp đề xuất

  • Giai đoạn 1: Nâng cấp AI lên giải thuật Minimax kết hợp tỉa nhánh Alpha-Beta và Bảng chuyển vị (Transposition Table) với độ sâu tìm kiếm từ 3 đến 5 bước.
  • Giai đoạn 2: Tích hợp giao thức mạng Socket TCP/IP (hoặc SignalR) để hỗ trợ chế độ chơi đối kháng 2 người qua mạng cục bộ (LAN) và Internet.
  • Giai đoạn 3: Chuyển đổi giao diện sang WPF hoặc .NET MAUI để hỗ trợ đa nền tảng (Windows, macOS, Android) và lưu trữ lịch sử trận đấu bằng cơ sở dữ liệu SQLite.

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

+-----------------------------------------------------------------------------+
|                           ĐỐI TƯỢNG HƯỞNG LỢI DỰ ÁN                          |
+-----------------------------------------------------------------------------+
|  [Sinh viên CNTT]   -> Tiếp cận mã nguồn mẫu C# OOP & Cấu trúc Dữ liệu       |
|  [Lập trình viên]   -> Tham khảo thuật toán Heuristic & Kỹ thuật vẽ GDI+     |
|  [Giảng viên/NCS]   -> Bộ học liệu trực quan cho môn học C#.NET cơ sở        |
|  [Người dùng cuối]  -> Trải nghiệm game cờ logic mượt mà, không quảng cáo    |
+-----------------------------------------------------------------------------+
  • Sinh viên ngành CNTT: Tiếp cận trực tiếp mã nguồn chuẩn hóa về lập trình hướng đối tượng trong C#, nắm vững cách thao tác với mảng 2 chiều, cấu trúc Stack và lập trình đồ họa giao diện Windows Forms.
  • Lập trình viên Game sơ cấp: Học hỏi tư duy xây dựng hàm lượng giá Heuristic và thuật toán duyệt ma trận kiểm tra chuỗi liên tiếp không đệ quy.
  • Giảng viên và Cơ sở đào tạo: Sử dụng dự án như một bài tập lớn mẫu hoàn chỉnh, có đầy đủ tài liệu phân tích thiết kế và mã nguồn thực thi.

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

1. Ứng dụng yêu cầu cấu hình phần cứng và phần mềm như thế nào để vận hành?

Ứng dụng có dung lượng siêu nhẹ (chưa đầy 5MB sau khi đóng gói). Chỉ cần máy tính cá nhân chạy hệ điều hành Windows 7 trở lên và đã cài sẵn .NET Framework 4.8 hoặc .NET Core Desktop Runtime là có thể chạy mượt mà ở tốc độ 60 FPS mà không tiêu tốn tài nguyên phần cứng.

2. Thuật toán AI có bị chậm khi bàn cờ đã đi được nhiều nước không?

Không. Thuật toán AI chỉ quét qua các ô cờ chưa có người sở hữu (Sohuu == 0). Khi trận đấu diễn ra càng lâu, số lượng ô trống càng giảm, giúp số lần lặp tính toán giảm dần, tốc độ phản hồi của máy tính càng nhanh hơn (dưới 10ms ở giai đoạn tàn cuộc).

3. Làm thế nào để tích hợp tính năng chơi online qua mạng LAN vào dự án này?

Hệ thống có thể mở rộng dễ dàng bằng cách thêm module NetworkManager sử dụng lớp TcpClient và TcpListener của thư viện System.Net.Sockets. Khi một người chơi thực hiện hàm DanhCo(x, y), tọa độ nước đi sẽ được đóng gói thành chuỗi JSON dạng {"x": cot, "y": dong} và gửi qua socket đến máy đối thủ để gọi hàm tương ứng.

4. Cơ chế Undo/Redo hoạt động như thế nào khi chơi với máy tính (Player vs Com)?

Khi ở chế độ chơi với máy, một lượt hoàn tác (Undo) cần phải Pop ra khỏi stk_CacNuocDaDi 2 nước đi liên tiếp (nước đi của máy tính và nước đi của người chơi) để trả quyền điều khiển về đúng lượt của người chơi mà không làm mất tính nhất quán của bàn cờ.

5. Chi phí phát triển và triển khai dự án là bao nhiêu?

Dự án được xây dựng hoàn toàn trên nền tảng công nghệ miễn phí và mã nguồn mở của hệ sinh thái Microsoft .NET và Visual Studio Community. Chi phí phần mềm và bản quyền bằng 0 VNĐ, mang lại giá trị học tập và ứng dụng thực tiễn cao.

Kết luận

Đề tài "Xây dựng trò chơi Cờ Caro" của nhóm sinh viên Trần Hải Triều và Huỳnh Hoàng Trâm (Khoa CNTT – UFM) đã hoàn thành xuất sắc các mục tiêu nghiên cứu và hiện thực hóa phần mềm. Dự án không chỉ giải quyết trọn vẹn bài toán xây dựng trò chơi đối kháng dạng lưới trên nền tảng C# .NET Windows Forms mà còn chứng minh tính khả thi, hiệu quả của giải thuật Heuristic trong việc xây dựng trí tuệ nhân tạo cho game cờ logic. Cấu trúc mã nguồn module hóa, rõ ràng cùng cơ chế quản lý trạng thái bằng Ngăn xếp đã tạo nên một sản phẩm hoàn chỉnh, ổn định và có tiềm năng mở rộng cao trong tương lai.