围棋规则引擎：代码级逻辑描述

class GoBoard {
public:
    static constexpr int SIZE = 19;                  // 19×19
    static constexpr int TOTAL = SIZE * SIZE;        // 361

    enum Stone { EMPTY = 0, BLACK = 1, WHITE = 2 };

    Stone at(int row, int col) const;
    void  place(int row, int col, Stone color);
    void  remove(int row, int col);

    static bool onBoard(int row, int col);           // 边界检查
    static int  toIndex(int row, int col);           // (row,col) → 361索引
    static void toCoord(int index, int &row, int &col);

private:
    Stone m_grid[TOTAL] = { EMPTY };
};

// 4 邻接方向（上下左右）
constexpr int DIRS[4][2] = {
    {-1, 0}, {1, 0}, {0, -1}, {0, 1}
};

// 计算棋盘上某个位置所在连通组的"气集合"
struct Group {
    std::vector<int> stones;     // 组内棋子索引
    std::vector<int> liberties;  // 气点索引（去重）
};

Group GoBoard::computeGroup(int row, int col) const
{
    Group g;
    Stone color = at(row, col);
    if (color == EMPTY) return g;

    bool visited[TOTAL] = { false };
    bool libAdded[TOTAL] = { false };  // 气点去重

    std::vector<int> stack;
    stack.push_back(toIndex(row, col));
    visited[toIndex(row, col)] = true;

    while (!stack.empty()) {
        int idx = stack.back(); stack.pop_back();
        int r, c; toCoord(idx, r, c);
        g.stones.push_back(idx);

        for (auto &d : DIRS) {
            int nr = r + d[0], nc = c + d[1];
            if (!onBoard(nr, nc)) continue;

            int ni = toIndex(nr, nc);
            Stone s = at(nr, nc);

            if (s == EMPTY) {
                if (!libAdded[ni]) {
                    g.liberties.push_back(ni);
                    libAdded[ni] = true;
                }
            } else if (s == color && !visited[ni]) {
                visited[ni] = true;
                stack.push_back(ni);
            }
        }
    }
    return g;
}

// 便捷方法
int GoBoard::countLiberties(int row, int col) const {
    return (int)computeGroup(row, col).liberties.size();
}

// 落子后执行: 移除所有气数为 0 的对方组
// 返回: 被提掉的棋子数量

int GoBoard::captureOpponent(int row, int col, Stone myColor)
{
    Stone oppColor = (myColor == BLACK) ? WHITE : BLACK;
    std::vector<int> deadStones;

    for (auto &d : DIRS) {
        int nr = row + d[0], nc = col + d[1];
        if (!onBoard(nr, nc)) continue;
        if (at(nr, nc) != oppColor) continue;

        // 检查是否已被记录（避免同一个组被重复处理）
        int ni = toIndex(nr, nc);
        bool alreadyDead = false;
        for (int ds : deadStones) {
            if (ds == ni) { alreadyDead = true; break; }
        }
        if (alreadyDead) continue;

        Group g = computeGroup(nr, nc);
        if (g.liberties.empty()) {
            // 气为 0 → 提掉整个组
            for (int si : g.stones) {
                deadStones.push_back(si);
            }
        }
    }

    // 执行提子
    for (int si : deadStones) {
        int r, c; toCoord(si, r, c);
        m_grid[si] = EMPTY;
    }

    return (int)deadStones.size();
}

enum class MoveResult { LEGAL, OCCUPIED, SUICIDE, KO };

struct MoveInfo {
    MoveResult result;
    int captured;           // 被提棋子数
    uint64_t nextHash;      // 用于劫争检测的局面对比哈希
};

MoveInfo GoBoard::tryMove(int row, int col, Stone color)
{
    MoveInfo info{};
    info.result = MoveResult::LEGAL;

    // 1. 交叉点为空？
    if (at(row, col) != EMPTY) {
        info.result = MoveResult::OCCUPIED;
        return info;
    }

    // 2. 备份局面（用于回退）
    Stone backup[TOTAL];
    std::copy(m_grid, m_grid + TOTAL, backup);

    // 3. 临时落子
    place(row, col, color);

    // 4. 先捕获对方（规则：先杀对方，再判自杀）
    info.captured = captureOpponent(row, col, color);

    // 5. 检查自己
    Group myGroup = computeGroup(row, col);
    if (myGroup.liberties.empty()) {
        // 自杀：回退
        std::copy(backup, backup + TOTAL, m_grid);
        info.result = MoveResult::SUICIDE;
        info.captured = 0;
        return info;
    }

    // 6. 检查劫争
    uint64_t newHash = computeHash();
    if (newHash == m_prevHash) {
        std::copy(backup, backup + TOTAL, m_grid);
        info.result = MoveResult::KO;
        info.captured = 0;
        return info;
    }

    m_prevHash = newHash;
    info.nextHash = newHash;
    return info;
}

// 预计算随机表
uint64_t ZOBRIST[361][3];  // [position][EMPTY/BLACK/WHITE]

void initZobrist() {
    std::mt19937_64 rng(42);
    for (int i = 0; i < TOTAL; i++)
        for (int c = 0; c < 3; c++)
            ZOBRIST[i][c] = rng();
}

// 增量更新哈希（O(1)，不需要遍历全盘）
void GoBoard::updateHash(uint64_t &hash, int idx, Stone oldColor, Stone newColor) {
    hash ^= ZOBRIST[idx][(int)oldColor];  // 移除旧
    hash ^= ZOBRIST[idx][(int)newColor];  // 加入新
}

class GoBoard {
    std::unordered_set<uint64_t> m_history;  // 历史局面哈希集合
    uint64_t m_prevHash = 0;

    bool isKo(uint64_t newHash) const {
        if (newHash == m_prevHash) return true;         // 简单劫
        if (m_history.count(newHash)) return true;      // 超级劫
        return false;
    }
};

class GoEngine {
    int m_consecutivePasses = 0;

    void pass() {
        m_consecutivePasses++;
        if (m_consecutivePasses >= 2) endGame();
        switchTurn();
    }

    void placeStone(int row, int col) {
        m_consecutivePasses = 0;  // 落子 → 重置
    }
};

Territory GoBoard::scoreTerritory() const
{
    Territory t;
    bool visited[TOTAL] = { false };

    for (int i = 0; i < TOTAL; i++) {
        if (m_grid[i] != EMPTY || visited[i]) continue;

        std::vector<int> region;
        bool touchesBlack = false;
        bool touchesWhite = false;

        std::vector<int> stack = { i };
        visited[i] = true;

        while (!stack.empty()) {
            int idx = stack.back(); stack.pop_back();
            region.push_back(idx);
            int r, c; toCoord(idx, r, c);

            for (auto &d : DIRS) {
                int nr = r + d[0], nc = c + d[1];
                if (!onBoard(nr, nc)) continue;
                int ni = toIndex(nr, nc);
                Stone s = at(nr, nc);

                if (s == EMPTY && !visited[ni]) {
                    visited[ni] = true;
                    stack.push_back(ni);
                } else if (s == BLACK) touchesBlack = true;
                else if (s == WHITE) touchesWhite = true;
            }
        }

        if (touchesBlack && !touchesWhite)
            t.blackTerritory += (int)region.size();
        else if (touchesWhite && !touchesBlack)
            t.whiteTerritory += (int)region.size();
    }
    return t;
}

struct Score {
    double black, white, margin;
    std::string winner;
};

Score GoBoard::computeFinalScore(const Territory &t, double komi = 6.5) const
{
    Score s;
    int blackStones = 0, whiteStones = 0;
    for (int i = 0; i < TOTAL; i++) {
        if (m_grid[i] == BLACK) blackStones++;
        else if (m_grid[i] == WHITE) whiteStones++;
    }

    // 数子法（中国规则）
    s.black = blackStones + t.blackTerritory;
    s.white = whiteStones + t.whiteTerritory + komi;
    s.margin = s.black - s.white;
    s.winner = (s.margin > 0) ? "Black" : "White";
    return s;
}

enum class RuleSet { CHINESE, JAPANESE };

Score GoBoard::scoreGame(RuleSet rule, double komi) const
{
    Territory t = scoreTerritory();

    if (rule == RuleSet::CHINESE) {
        // 数子法: 子 + 空
        int black = 0, white = 0;
        for (int i = 0; i < TOTAL; i++) {
            if (m_grid[i] == BLACK) black++;
            else if (m_grid[i] == WHITE) white++;
        }
        return {
            (double)(black + t.blackTerritory),
            (double)(white + t.whiteTerritory + komi)
        };
    } else {
        // 数目法: 空 - 死子
        return {
            (double)(t.blackTerritory - m_capturedBlack),
            (double)(t.whiteTerritory - m_capturedWhite + komi)
        };
    }
}

class GoEngine {
public:
    void reset();
    void pass();
    MoveInfo play(int row, int col);    // 落子 → 返回合法性+提子信息

    const GoBoard& board() const;
    Stone currentPlayer() const;
    int  moveNumber() const;
    uint64_t boardHash() const;

    bool isGameOver() const;
    Score finalScore(RuleSet rule = RuleSet::CHINESE, double komi = 7.5) const;

    std::string toSGF() const;          // 导出 SGF 格式
    std::string toGTP(const std::string &cmd) const; // GTP 协议格式化
};

// GoBoard.h
#pragma once
#include <vector>
#include <unordered_set>
#include <random>
#include <cstring>

class GoBoard {
public:
    static constexpr int SIZE = 19;
    static constexpr int TOTAL = SIZE * SIZE;
    static constexpr int DIRS[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};

    enum Stone { EMPTY = 0, BLACK = 1, WHITE = 2 };

    GoBoard();

    Stone at(int row, int col) const { return m_grid[toIndex(row,col)]; }
    void  place(int r, int c, Stone s) { m_grid[toIndex(r,c)] = s; }
    void  remove(int r, int c) { m_grid[toIndex(r,c)] = EMPTY; }

    static bool onBoard(int r, int c) {
        return r >= 0 && r < SIZE && c >= 0 && c < SIZE;
    }
    static int  toIndex(int r, int c) { return r * SIZE + c; }
    static void toCoord(int i, int &r, int &c) { r = i / SIZE; c = i % SIZE; }

    struct Group { std::vector<int> stones, liberties; };
    Group computeGroup(int row, int col) const;
    int   countLiberties(int row, int col) const;
    int   captureOpponent(int row, int col, Stone myColor);

    uint64_t computeHash() const;

    struct Territory {
        int blackTerritory = 0, whiteTerritory = 0;
        std::vector<int> deadBlack, deadWhite;
    };
    Territory scoreTerritory() const;

private:
    Stone m_grid[TOTAL] = { EMPTY };
};