/* chess3d.c —— 3D 国际象棋（棋盘与棋子都是真 3D 立方体，不是贴图）
 * chess3d.c -- 3D chess (the board and pieces are real 3D cubes, not a picture)
 *
 * 走的是 **第 5 层**（`ui_3d_*`，号段 600–634）：一个俯视相机 + 一个单位立方体网格，
 * It uses **layer 5** (`ui_3d_*`, opcodes 600-634): one top-down camera and one unit-cube mesh,
 * 64 块棋盘格与 32 个棋子都是**同一个网格**的实例（改位置/缩放/颜色），
 * and the 64 tiles plus 32 pieces are instances of **that same mesh** (position/scale/color).
 * 所以只有一份顶点数据 —— 这也正是 3D 该有的写法（别为每种棋子各建一个网格）。
 * so there is a single vertex buffer -- which is how 3D is meant to be done (do not build a mesh per piece).
 *
 * 玩法：点自己的棋子（选中格变亮），再点目标格；走法按国际象棋的走子规则判定（兵/马/象/车/后/王），
 * Rules: tap one of your pieces (its tile lights up), then tap the target; moves follow the chess rules
 * for pawn/knight/bishop/rook/queen/king,
 * 吃子直接吃掉，**吃掉对方的王**即获胜（本样例不判将军/将死 —— 那是完整对局引擎的事）。
 * captures are direct, and **capturing the enemy king** wins (this sample does not model check/mate --
 * that belongs to a full game engine).
 *
 * ⚠ 2D 层要清成**透明**（`ui_2d_clear(0)`）：3D 视口是透过 2D 层看的，不清就是一片黑。
 * ⚠ The 2D layer must be cleared **transparent** (`ui_2d_clear(0)`): the 3D viewport shows through
 *   the 2D layer, and an opaque layer is a black screen.
 *
 * ⚠ 索引要在**所有顶点写完之后**再写（`cube_min.c` 里踩过：边写顶点边写索引 ⇒ 索引被顶点覆盖，
 * ⚠ Write indices **after every vertex is in place** (learned in `cube_min.c`: interleaving them
 *    makes the vertices overwrite the indices,
 *   网格照常返回句柄、画出来却是一堆垃圾三角形）。
 *    the mesh still returns a handle and draws garbage triangles).
 */

#include <vml_ui.h>
#include <vml_3d.h>
#include <stdlib.h>
#include <stdio.h>

#define MAX_FRAMES 40000
#define MB_CAP 512

/* 棋子：0 = 空；1..6 白兵马车象后王；11..16 黑 */
#define PT_PAWN 1
#define PT_ROOK 2
#define PT_KNIGHT 3
#define PT_BISHOP 4
#define PT_QUEEN 5
#define PT_KING 6

static float MB[MB_CAP];
static int g_vn;

static int SW, SH, g_lang;
static int vp, mesh;
static int obj_tile[8][8];      /* 棋盘格对象 */
static int obj_piece[8][8];     /* 棋子对象（0 = 没有） */
static int board[8][8];         /* 复用 piece 类型值 */
static float g_dist = 14.0f;      /* 相机距离：按画布宽高比现算，见 main */
static int sel_f = -1, sel_r = -1;
static int white_turn = 1, over;

static unsigned int seed = 20261125;
static int rnd(int n)
{
    seed = seed * 1103515245u + 12345u;
    return (int)((seed >> 16) % (unsigned int)n);
}

/* ── 网格：一个棱长 2 的立方体（±1，中心原点）────────────────────────── */

static void mbv(int i, float px, float py, float pz, float nx, float ny, float nz, float u, float v)
{
    int b = i * 8;
    MB[b + 0] = px; MB[b + 1] = py; MB[b + 2] = pz;
    MB[b + 3] = nx; MB[b + 4] = ny; MB[b + 5] = nz;
    MB[b + 6] = u;  MB[b + 7] = v;
}

static void mb_index(int k, int v)
{
    int *ip;
    ip = (int *)&MB[0];
    ip[g_vn * 8 + k] = v;
}

static void add_face(float ax, float ay, float az, float bx, float by, float bz,
                     float cx, float cy, float cz, float dx, float dy, float dz,
                     float nx, float ny, float nz)
{
    int b = g_vn;
    mbv(b + 0, ax, ay, az, nx, ny, nz, 0.0f, 1.0f);
    mbv(b + 1, bx, by, bz, nx, ny, nz, 1.0f, 1.0f);
    mbv(b + 2, cx, cy, cz, nx, ny, nz, 1.0f, 0.0f);
    mbv(b + 3, dx, dy, dz, nx, ny, nz, 0.0f, 0.0f);
    g_vn = g_vn + 4;
}

static void gen_cube(void)
{
    int f, k;
    g_vn = 0;
    add_face(-1, -1, 1,  1, -1, 1,  1, 1, 1,  -1, 1, 1,  0, 0, 1);
    add_face(1, -1, -1,  -1, -1, -1,  -1, 1, -1,  1, 1, -1,  0, 0, -1);
    add_face(-1, 1, 1,  1, 1, 1,  1, 1, -1,  -1, 1, -1,  0, 1, 0);
    add_face(-1, -1, -1,  1, -1, -1,  1, -1, 1,  -1, -1, 1,  0, -1, 0);
    add_face(1, -1, 1,  1, -1, -1,  1, 1, -1,  1, 1, 1,  1, 0, 0);
    add_face(-1, -1, -1,  -1, -1, 1,  -1, 1, 1,  -1, 1, -1,  -1, 0, 0);
    for (f = 0; f < 6; f++) {
        k = f * 6;
        mb_index(k + 0, f * 4 + 0); mb_index(k + 1, f * 4 + 1); mb_index(k + 2, f * 4 + 2);
        mb_index(k + 3, f * 4 + 0); mb_index(k + 4, f * 4 + 2); mb_index(k + 5, f * 4 + 3);
    }
}

/* ── 棋盘 ─────────────────────────────────────────────────────────── */

static float wx(int f) { return (float)f - 3.5f; }      /* 文件 → 世界 x */
static float wz(int r) { return (float)r - 3.5f; }      /* 行   → 世界 z */

static int tile_color(int f, int r)
{
    return ((f + r) & 1) ? 0xFF8A5A3A : 0xFFE8D8B0;
}

static float piece_height(int p)
{
    int t = p % 10;
    if (t == PT_PAWN) return 0.55f;
    if (t == PT_ROOK) return 0.80f;
    if (t == PT_KNIGHT) return 0.80f;
    if (t == PT_BISHOP) return 0.95f;
    if (t == PT_QUEEN) return 1.10f;
    return 1.25f;                                          /* 王最高 */
}

static void place_piece(int f, int r, int p)
{
    float h, base = 0.02f;
    board[f][r] = p;
    if (obj_piece[f][r] > 0) { ui_3d_obj_free(obj_piece[f][r]); obj_piece[f][r] = 0; }
    if (p == 0) return;
    h = piece_height(p) / 2.0f;
    obj_piece[f][r] = ui_3d_obj_create(vp, mesh);
    ui_3d_obj_set_scale(obj_piece[f][r], 0.30f, h, 0.30f);
    ui_3d_obj_set_pos(obj_piece[f][r], wx(f), base + h, wz(r));
    ui_3d_obj_set_color(obj_piece[f][r], p < 10 ? 0xFFF2F0E8 : 0xFF2A2A32);
}

static void setup_board(void)
{
    int f, r, p;
    for (f = 0; f < 8; f++)
        for (r = 0; r < 8; r++) {
            if (obj_piece[f][r] > 0) { ui_3d_obj_free(obj_piece[f][r]); obj_piece[f][r] = 0; }
            board[f][r] = 0;
        }

    /* 兵 */
    for (f = 0; f < 8; f++) {
        place_piece(f, 1, PT_PAWN);
        place_piece(f, 6, PT_PAWN + 10);
    }
    /* 底线：车 马 象 后 王 象 马 车 */
    {
        int back[8];
        back[0] = PT_ROOK;   back[1] = PT_KNIGHT; back[2] = PT_BISHOP; back[3] = PT_QUEEN;
        back[4] = PT_KING;   back[5] = PT_BISHOP; back[6] = PT_KNIGHT; back[7] = PT_ROOK;
        for (f = 0; f < 8; f++) {
            place_piece(f, 0, back[f]);
            place_piece(f, 7, back[f] + 10);
        }
    }
    sel_f = -1;
    sel_r = -1;
    white_turn = 1;
    over = 0;
}

/* 选中格描边：把该格的立方体调亮（3D 里没有"描边"，换颜色最直接） */
static void refresh_tiles(void)
{
    int f, r;
    for (f = 0; f < 8; f++)
        for (r = 0; r < 8; r++) {
            int c = tile_color(f, r);
            if (f == sel_f && r == sel_r) c = 0xFF51E86E;
            ui_3d_obj_set_color(obj_tile[f][r], c);
        }
}

/* ── 走子规则（伪合法：含吃子；不判将军）────────────────────────────── */

static int in_board(int f, int r) { return f >= 0 && r >= 0 && f < 8 && r < 8; }

static int path_clear(int f0, int r0, int f1, int r1)
{
    int df = f1 - f0, dr = r1 - r0;
    int sf = df > 0 ? 1 : (df < 0 ? -1 : 0);
    int sr = dr > 0 ? 1 : (dr < 0 ? -1 : 0);
    int f = f0 + sf, r = r0 + sr;
    while (f != f1 || r != r1) {
        if (board[f][r] != 0) return 0;
        f = f + sf;
        r = r + sr;
    }
    return 1;
}

static int can_move(int f0, int r0, int f1, int r1)
{
    int p = board[f0][r0], t = p % 10;
    int df = f1 - f0, dr = r1 - r0;
    int adf = df < 0 ? -df : df, adr = dr < 0 ? -dr : dr;
    int target = board[f1][r1];
    int white = p < 10;

    if (p == 0) return 0;
    if (f0 == f1 && r0 == r1) return 0;
    if (target != 0 && (target < 10) == white) return 0;     /* 不能吃自己的 */

    if (t == PT_PAWN) {
        int dir = white ? 1 : -1;                            /* 白往上（行号增大） */
        if (df == 0 && dr == dir && target == 0) return 1;
        if (df == 0 && dr == 2 * dir && target == 0 && ((white && r0 == 1) || (!white && r0 == 6)))
            return 1;
        if (adf == 1 && dr == dir && target != 0) return 1;  /* 斜吃 */
        return 0;
    }
    if (t == PT_KNIGHT)
        return (adf == 1 && adr == 2) || (adf == 2 && adr == 1);
    if (t == PT_BISHOP)
        return adf == adr && path_clear(f0, r0, f1, r1);
    if (t == PT_ROOK)
        return (df == 0 || dr == 0) && path_clear(f0, r0, f1, r1);
    if (t == PT_QUEEN)
        return ((adf == adr) || df == 0 || dr == 0) && path_clear(f0, r0, f1, r1);
    /* 王：一步 */
    return adf <= 1 && adr <= 1;
}

/* ── 画面 ─────────────────────────────────────────────────────────── */

static char *numstr(int v)
{
    static char buf[24];
    itoa(v, buf);
    return buf;
}

static void hud(void)
{
    ui_2d_text(10, 24, over ? (g_lang == 0 ? "结束" : "Game over")
                            : (white_turn ? (g_lang == 0 ? "白方走" : "White to move")
                                          : (g_lang == 0 ? "黑方走" : "Black to move")),
               0xFFFFFFFF, 16, VML_ANCHOR_LEFT);
    ui_2d_text(10, 48, g_lang == 0 ? "点自己的棋子，再点目标格" : "Tap your piece, then the target",
               0xFFC0C8D0, 11, VML_ANCHOR_LEFT);
    ui_2d_present();
}

/* 屏幕坐标 → 棋盘格：相机是**俯视 + 正中**，所以映射就是线性的（见文件头） */
static void tap(int px, int py)
{
    float span_v, span_h, wxv, wzv;
    int f, r, p;

    span_v = 2.0f * g_dist * 0.41421356f;       /* 2*d*tan(22.5°)；d 见 main（按宽高比算的） */
    span_h = span_v * (float)SW / (float)SH;     /* 横向按宽高比展开 */
    wxv = ((float)px / (float)SW - 0.5f) * span_h;
    wzv = ((float)py / (float)SH - 0.5f) * span_v;
    f = (int)(wxv + 4.0f);
    r = (int)(wzv + 4.0f);
    if (!in_board(f, r)) return;

    p = board[f][r];
    if (sel_f < 0) {
        if (p == 0) return;
        if ((p < 10) != (white_turn == 1)) return;      /* 不是自己的棋子 */
        sel_f = f; sel_r = r;
        refresh_tiles();
        return;
    }

    if (f == sel_f && r == sel_r) { sel_f = -1; sel_r = -1; refresh_tiles(); return; }

    if (can_move(sel_f, sel_r, f, r)) {
        int moving = board[sel_f][sel_r];
        if (p % 10 == PT_KING) over = 1;                /* 吃王 = 结束 */
        place_piece(f, r, moving);                      /* 目标格放上，源格清空 */
        place_piece(sel_f, sel_r, 0);
        white_turn = white_turn ? 0 : 1;
        sel_f = -1;
        sel_r = -1;
        refresh_tiles();
    } else {
        sel_f = f; sel_r = r;                           /* 点别的自己的棋子 = 改选 */
        refresh_tiles();
    }
}

int main(void)
{
    int msg[4];
    int tid;
    int done = 0;
    int f, r;
    float span;

    g_lang = ui_scr_get_language();
    ui_win_open_ex("chess3d.c", 0, 0, VML_WIN_ROTATABLE, VML_WIN_NO_GAMEPAD);
    SW = ui_scr_get_w_ex(ui_scr_get_orientation(), VML_CHROME_NONE);
    SH = ui_scr_get_h_ex(ui_scr_get_orientation(), VML_CHROME_NONE);
    if (SW <= 0) SW = 360;
    if (SH <= 0) SH = 620;

    vp = ui_3d_viewport_create(0, 0, SW, SH, 0);
    /* 俯视相机：正上方往下看（偏 0.01 避免 up 与视线共线）。d=12 ⇒ 可视高 ≈9.94 > 棋盘 8，四周留得出边 */
    /* 相机距离按**宽高比**现算：竖屏时横向可视宽度 = 可视高 × 宽高比，
     * 要让 8 格（+边距）在宽度方向也装得下 ⇒ d 取两者需要的较大值。
     * ⚠ 写死一个 d 在 480×640 上刚好、到 1080×1900 就会被切掉两边（实测过）。 */
    {
        float aspect = (float)SW / (float)SH;
        float need_h = 9.0f / 0.82842712f;            /* 竖着要装 9 个单位（棋盘 8 + 边） */
        float need_w = 9.0f / (0.82842712f * aspect); /* 横着装同样宽度 */
        g_dist = need_h > need_w ? need_h : need_w;
    }
    ui_3d_viewport_set_camera(vp, 0.0f, g_dist, 0.01f, 0.0f, 0.0f, 0.0f);
    ui_3d_viewport_set_fov(vp, 45.0f, 0.1f, 100.0f);
    ui_3d_viewport_set_bg(vp, 0xFF101018);
    ui_3d_viewport_set_light(vp, 0.3f, 1.0f, 0.4f, -1, 0.55f);

    gen_cube();
    mesh = ui_3d_mesh_create((int)&MB[0], g_vn, 36);

    /* 64 块棋盘格（薄立方体） */
    for (f = 0; f < 8; f++)
        for (r = 0; r < 8; r++) {
            obj_tile[f][r] = ui_3d_obj_create(vp, mesh);
            ui_3d_obj_set_scale(obj_tile[f][r], 0.48f, 0.02f, 0.48f);
            ui_3d_obj_set_pos(obj_tile[f][r], wx(f), 0.0f, wz(r));
            ui_3d_obj_set_color(obj_tile[f][r], tile_color(f, r));
        }

    setup_board();
    ui_2d_clear(0);                 /* 透明：让 3D 透上来 */
    hud();

    tid = ui_timer_set(200, 1);
    while (!done && ui_win_is_closed() == 0) {
        int t = ui_msg_wait(msg, 0);
        if (t == VML_MSG_NONE) continue;

        if (t == VML_MSG_TOUCHDOWN || t == VML_MSG_MOUSEDOWN) {
            if (!over) tap(msg[1], msg[2]);
            ui_2d_clear(0);
            hud();
            continue;
        }
        if (t == VML_MSG_KEYDOWN) {
            if (msg[1] == VML_KEY_ESCAPE) { setup_board(); refresh_tiles(); ui_2d_clear(0); hud(); }
            continue;
        }
        if (t == VML_MSG_TIMER) { hud(); continue; }
        if (t == VML_MSG_WINDOWCLOSE) break;
    }

    ui_timer_kill(tid);
    ui_win_close();
    printf("chess3d: turn=%s over=%d\n", white_turn ? "white" : "black", over);
    return 0;
}
