Dưới đây là mô-đun **C99**, dùng để **chấm điểm và chọn nước trong danh sách nước hợp lệ** do engine cung cấp. **Thiết kế 256 policy:** - **32 mô-típ**: hai xe siết vua, chiếu hàng cuối, tốt nhốt vua, ghim, xiên, đòn đôi, phong cấp, tốt thông, phong tỏa… - Mỗi mô-típ có **8 biến thể nước đi**: thường, ăn quân, chiếu, ăn + chiếu; và 4 biến thể tương ứng khi đang bị chiếu. - Mỗi policy có ID, trọng số, tên và thông tin đã khớp. **Lưu ý:** Đây là bộ pattern heuristic, không phải 256 bài toán chiếu hết được giải cứng. **Chiếu hết/hòa phải được bộ luật và bộ sinh nước hợp lệ xác nhận**. Phần phát hiện hai xe/tốt nhốt vua chỉ nhận diện thế siết vua, không tự kết luận chiếu hết. ## 1. `chess_policy.h` ```c #ifndef CHESS_POLICY_H #define CHESS_POLICY_H #include #include #ifdef __cplusplus extern "C" { #endif enum { PM_WHITE = 0, PM_BLACK = 1 }; enum { PM_EMPTY = 0, PM_PAWN = 1, PM_KNIGHT = 2, PM_BISHOP = 3, PM_ROOK = 4, PM_QUEEN = 5, PM_KING = 6 }; /* * Board convention: * a1 = 0, b1 = 1, ..., h8 = 63. * White pieces: positive. * Black pieces: negative. * * This is a board snapshot, NOT the engine's complete game state. * Castling rights, en-passant rights and repetition history remain * the responsibility of the host engine. */ typedef struct { int8_t square[64]; uint8_t side_to_move; } PMBoard; enum { PM_MF_CAPTURE = 1u << 0, PM_MF_EP = 1u << 1, PM_MF_CASTLE = 1u << 2 }; typedef struct { uint8_t from; uint8_t to; /* 0, PM_KNIGHT, PM_BISHOP, PM_ROOK or PM_QUEEN. */ uint8_t promotion; uint8_t flags; } PMMove; /* * Terminal status of candidate.after. * * The host engine MUST determine this using legal move generation * and its draw rules. King mobility alone cannot determine mate * or stalemate. * * PM_DRAW means a draw already recognized/adjudicated by the engine, * not merely that a draw might be claimable. */ typedef enum { PM_LIVE = 0, PM_CHECKMATE, PM_STALEMATE, PM_DRAW } PMTerminal; /* * Optional verified tactical information: * can the opponent mate immediately after this candidate? * * UNKNOWN is the safe default. * Set YES/NO only after checking all relevant legal replies. */ typedef enum { PM_M1_UNKNOWN = 0, PM_M1_NO, PM_M1_YES } PMMateOne; typedef struct { PMMove move; PMBoard after; PMTerminal terminal; PMMateOne opponent_mate_in_one; } PMCandidate; typedef enum { PM_F_TWO_ROOK_NET = 0, PM_F_BACK_RANK, PM_F_PAWN_CAGE, PM_F_KING_FLIGHTS, PM_F_KING_PRESSURE, PM_F_KING_SHIELD, PM_F_FORK, PM_F_ABSOLUTE_PIN, PM_F_RELATIVE_PIN, PM_F_SKEWER, PM_F_DISCOVERED_ATTACK, PM_F_EN_PRISE, PM_F_CHEAP_ATTACK, PM_F_OVERLOADED_DEFENDER, PM_F_PROMOTION, PM_F_PASSED_PAWN, PM_F_CONNECTED_PASSERS, PM_F_ISOLATED_PAWN, PM_F_DOUBLED_PAWN, PM_F_PAWN_CHAIN, PM_F_PAWN_BREAK, PM_F_BLOCKADE, PM_F_ROOK_FILE, PM_F_ROOK_SEVENTH, PM_F_CONNECTED_ROOKS, PM_F_BISHOP_PAIR, PM_F_BAD_BISHOP, PM_F_KNIGHT_OUTPOST, PM_F_DEVELOPMENT, PM_F_CENTER, PM_F_KING_ENDGAME, PM_F_MOBILITY, PM_FAMILY_COUNT } PMFamily; /* * mode = CAPTURE | CHECK | EVASION * * 0: quiet * 1: capture * 2: check * 3: capture + check * 4: quiet evasion * 5: capture evasion * 6: countercheck without capture * 7: countercheck with capture */ enum { PM_MODE_CAPTURE = 1u, PM_MODE_CHECK = 2u, PM_MODE_EVASION = 4u }; enum { PM_VARIANT_COUNT = 8, PM_POLICY_COUNT = 256, PM_MATE_SCORE = 1000000, PM_EVAL_LIMIT = 100000 }; #define PM_NO_MOVE ((size_t)-1) /* Policy ID = family * 8 + mode. */ typedef struct { uint16_t id; uint8_t family; uint8_t mode; int16_t weight; const char *pattern; const char *variant; } PMPolicy; typedef enum { PM_REASON_HEURISTIC = 0, PM_REASON_MATE, PM_REASON_STALEMATE, PM_REASON_DRAW, PM_REASON_ALLOWS_MATE_ONE } PMReason; typedef struct { /* * Higher is better for before.side_to_move. * Not a White-centric evaluation. */ int32_t score; /* * Before final clamping/terminal override: * score = base_score + sum(contribution[]). * * base_score contains material AFTER the move plus * the quiet-weight positional baseline BEFORE the move. */ int32_t base_score; int32_t contribution[PM_FAMILY_COUNT]; /* 256-bit set: policies that produced a nonzero change. */ uint64_t matched[4]; uint8_t mode; PMReason reason; } PMResult; /* Returns NULL for an invalid ID. */ const PMPolicy *pm_policy(unsigned id); /* Returns 1 if policy ID contributed, otherwise 0. */ int pm_has_match(const PMResult *result, unsigned id); /* * Score one LEGAL candidate. * * Returns: * 0 success * -1 malformed/inconsistent input * * Basic sanity checks are performed, but this function is NOT * a legal move validator. */ int pm_score_move( const PMBoard *before, const PMCandidate *candidate, PMResult *result ); /* * Choose the highest-scoring candidate. * Equal scores retain input order. * * Returns PM_NO_MOVE if the list is empty, input is malformed, * or every candidate fails sanity checks. * * result may be NULL. */ size_t pm_choose_move( const PMBoard *before, const PMCandidate *candidates, size_t count, PMResult *result ); #ifdef __cplusplus } #endif #endif ``` ## 2. `chess_policy.c` ```c #include "chess_policy.h" #include /* ---------- Exactly 256 policies: 32 families x 8 modes ---------- */ #define POLICY(F, N, M, W, V) \ { \ (uint16_t)((F) * PM_VARIANT_COUNT + (M)), \ (uint8_t)(F), (uint8_t)(M), (int16_t)(W), (N), (V) \ } #define POLICY8(F, N, A, B, C, D, E, G, H, I) \ POLICY(F, N, 0, A, "quiet"), \ POLICY(F, N, 1, B, "capture"), \ POLICY(F, N, 2, C, "check"), \ POLICY(F, N, 3, D, "capture_check"), \ POLICY(F, N, 4, E, "evasion"), \ POLICY(F, N, 5, G, "evasion_capture"), \ POLICY(F, N, 6, H, "countercheck"), \ POLICY(F, N, 7, I, "countercheck_capture") static const PMPolicy policies[] = { POLICY8(PM_F_TWO_ROOK_NET, "two_rook_net", 10, 9, 16, 14, 8, 8, 14, 12), POLICY8(PM_F_BACK_RANK, "back_rank", 16, 12, 24, 20, 28, 24, 24, 22), POLICY8(PM_F_PAWN_CAGE, "pawn_cage", 10, 8, 16, 14, 20, 18, 20, 18), POLICY8(PM_F_KING_FLIGHTS, "king_flights", 5, 4, 6, 5, 14, 12, 12, 10), POLICY8(PM_F_KING_PRESSURE, "king_pressure", 4, 3, 7, 6, 3, 3, 6, 5), POLICY8(PM_F_KING_SHIELD, "king_shield", 8, 6, 6, 5, 12, 10, 10, 8), POLICY8(PM_F_FORK, "fork", 28, 24, 44, 38, 22, 20, 36, 32), POLICY8(PM_F_ABSOLUTE_PIN, "absolute_pin", 22, 18, 30, 26, 24, 22, 28, 24), POLICY8(PM_F_RELATIVE_PIN, "relative_pin", 14, 12, 20, 18, 12, 10, 18, 16), POLICY8(PM_F_SKEWER, "skewer", 24, 20, 36, 32, 18, 16, 30, 26), POLICY8(PM_F_DISCOVERED_ATTACK, "discovered_attack", 16, 14, 28, 24, 14, 12, 24, 20), POLICY8(PM_F_EN_PRISE, "en_prise", 26, 28, 26, 28, 30, 32, 28, 30), POLICY8(PM_F_CHEAP_ATTACK, "cheap_attack", 8, 6, 12, 10, 8, 6, 10, 8), POLICY8(PM_F_OVERLOADED_DEFENDER, "overloaded_defender", 18, 16, 26, 22, 20, 18, 24, 20), POLICY8(PM_F_PROMOTION, "promotion", 24, 22, 32, 30, 26, 24, 32, 30), POLICY8(PM_F_PASSED_PAWN, "passed_pawn", 12, 10, 10, 9, 8, 8, 9, 8), POLICY8(PM_F_CONNECTED_PASSERS, "connected_passers", 8, 7, 8, 7, 6, 6, 7, 6), POLICY8(PM_F_ISOLATED_PAWN, "isolated_pawn", 10, 8, 8, 7, 7, 6, 7, 6), POLICY8(PM_F_DOUBLED_PAWN, "doubled_pawn", 9, 8, 7, 6, 6, 5, 6, 5), POLICY8(PM_F_PAWN_CHAIN, "pawn_chain", 7, 6, 7, 6, 8, 7, 8, 7), POLICY8(PM_F_PAWN_BREAK, "pawn_break", 6, 5, 8, 7, 5, 4, 7, 6), POLICY8(PM_F_BLOCKADE, "blockade", 12, 10, 12, 10, 14, 12, 14, 12), POLICY8(PM_F_ROOK_FILE, "rook_file", 14, 12, 18, 16, 10, 9, 16, 14), POLICY8(PM_F_ROOK_SEVENTH, "rook_seventh", 14, 12, 20, 18, 10, 9, 18, 16), POLICY8(PM_F_CONNECTED_ROOKS, "connected_rooks", 12, 10, 16, 14, 10, 9, 14, 12), POLICY8(PM_F_BISHOP_PAIR, "bishop_pair", 28, 26, 28, 26, 22, 20, 24, 22), POLICY8(PM_F_BAD_BISHOP, "bad_bishop", 5, 4, 5, 4, 4, 3, 4, 3), POLICY8(PM_F_KNIGHT_OUTPOST, "knight_outpost", 22, 20, 26, 24, 16, 14, 22, 20), POLICY8(PM_F_DEVELOPMENT, "development", 12, 10, 10, 9, 8, 7, 9, 8), POLICY8(PM_F_CENTER, "center", 6, 5, 7, 6, 5, 4, 6, 5), POLICY8(PM_F_KING_ENDGAME, "king_endgame_opposition", 8, 7, 8, 7, 10, 9, 10, 9), POLICY8(PM_F_MOBILITY, "mobility", 2, 1, 2, 1, 2, 1, 2, 1) }; #undef POLICY8 #undef POLICY typedef char pm_assert_family_count[ PM_FAMILY_COUNT == 32 ? 1 : -1 ]; typedef char pm_assert_policy_count[ sizeof(policies) / sizeof(policies[0]) == PM_POLICY_COUNT ? 1 : -1 ]; /* ---------- Geometry ---------- */ static const int value[7] = { 0, 100, 320, 330, 500, 900, 20000 }; /* First four directions are orthogonal. */ static const int dx[8] = { 1, -1, 0, 0, 1, 1, -1, -1 }; static const int dy[8] = { 0, 0, 1, -1, 1, -1, 1, -1 }; static const int knight_dx[8] = { 1, 2, 2, 1, -1, -2, -2, -1 }; static const int knight_dy[8] = { 2, 1, -1, -2, -2, -1, 1, 2 }; static int iabs(int x) { return x < 0 ? -x : x; } static int imin(int a, int b) { return a < b ? a : b; } static int imax(int a, int b) { return a > b ? a : b; } static int file_of(int s) { return s & 7; } static int rank_of(int s) { return s >> 3; } static int inside(int f, int r) { return f >= 0 && f < 8 && r >= 0 && r < 8; } static int owner(int p) { return p > 0 ? PM_WHITE : p < 0 ? PM_BLACK : -1; } static int piece_type(int p) { return p < 0 ? -p : p; } static int color_sign(int c) { return c == PM_WHITE ? 1 : -1; } static int forward(int c) { return c == PM_WHITE ? 1 : -1; } static int relative_rank(int c, int s) { return c == PM_WHITE ? rank_of(s) : 7 - rank_of(s); } static int square_color(int s) { return (file_of(s) + rank_of(s)) & 1; } static int edge_square(int s) { int f = file_of(s); int r = rank_of(s); return f == 0 || f == 7 || r == 0 || r == 7; } static int piece_units(int type) { return (value[type] + 50) / 100; } static uint64_t bit(int s) { return UINT64_C(1) << s; } static int popcount64(uint64_t x) { int n = 0; while (x) { x &= x - 1; ++n; } return n; } static uint64_t king_ring(int s) { uint64_t result = 0; int f = file_of(s); int r = rank_of(s); int d; for (d = 0; d < 8; ++d) { int x = f + dx[d]; int y = r + dy[d]; if (inside(x, y)) result |= bit(y * 8 + x); } return result; } /* * Geometric attack map: * - includes the first occupied square on slider rays; * - includes defended friendly pieces; * - does not filter absolute pins. * * Suitable for pattern heuristics, not full move generation. */ static uint64_t attacks_from(const PMBoard *b, int s) { uint64_t result = 0; int p = b->square[s]; int type = piece_type(p); int c = owner(p); int f = file_of(s); int r = rank_of(s); int d; if (!p) return 0; if (type == PM_PAWN) { int y = r + forward(c); for (d = -1; d <= 1; d += 2) { int x = f + d; if (inside(x, y)) result |= bit(y * 8 + x); } return result; } if (type == PM_KNIGHT) { for (d = 0; d < 8; ++d) { int x = f + knight_dx[d]; int y = r + knight_dy[d]; if (inside(x, y)) result |= bit(y * 8 + x); } return result; } if (type == PM_KING) return king_ring(s); if (type == PM_BISHOP || type == PM_ROOK || type == PM_QUEEN) { int begin = type == PM_BISHOP ? 4 : 0; int end = type == PM_ROOK ? 4 : 8; for (d = begin; d < end; ++d) { int x = f + dx[d]; int y = r + dy[d]; while (inside(x, y)) { int t = y * 8 + x; result |= bit(t); if (b->square[t]) break; x += dx[d]; y += dy[d]; } } } return result; } /* Attack test with the actual occupancy of the supplied board. */ static int attacked_at(const PMBoard *b, int s, int by) { int f = file_of(s); int r = rank_of(s); int sign = color_sign(by); int pawn_rank = r - forward(by); int d; for (d = -1; d <= 1; d += 2) { int x = f + d; if (inside(x, pawn_rank) && b->square[pawn_rank * 8 + x] == sign * PM_PAWN) return 1; } for (d = 0; d < 8; ++d) { int x = f + knight_dx[d]; int y = r + knight_dy[d]; if (inside(x, y) && b->square[y * 8 + x] == sign * PM_KNIGHT) return 1; } for (d = 0; d < 8; ++d) { int x = f + dx[d]; int y = r + dy[d]; if (inside(x, y) && b->square[y * 8 + x] == sign * PM_KING) return 1; } for (d = 0; d < 8; ++d) { int x = f + dx[d]; int y = r + dy[d]; while (inside(x, y)) { int p = b->square[y * 8 + x]; if (p) { if (owner(p) == by) { int type = piece_type(p); if (type == PM_QUEEN || (d < 4 && type == PM_ROOK) || (d >= 4 && type == PM_BISHOP)) return 1; } break; } x += dx[d]; y += dy[d]; } } return 0; } /* * Safe adjacent king moves, including captures, excluding castling. * Occupancy is updated for every test, avoiding stale slider rays. * * This is NOT the number of legal moves of the whole side. */ static int king_flights(const PMBoard *b, int c, int king) { int count = 0; int f = file_of(king); int r = rank_of(king); int d; for (d = 0; d < 8; ++d) { int x = f + dx[d]; int y = r + dy[d]; int t; PMBoard next; if (!inside(x, y)) continue; t = y * 8 + x; if (owner(b->square[t]) == c) continue; /* A chess move never captures the opposing king. */ if (piece_type(b->square[t]) == PM_KING) continue; next = *b; next.square[king] = PM_EMPTY; next.square[t] = (int8_t)(color_sign(c) * PM_KING); if (!attacked_at(&next, t, 1 - c)) ++count; } return count; } /* ---------- Position analysis ---------- */ typedef struct { const PMBoard *board; uint64_t attacks[64]; uint64_t occupied[2]; uint64_t pawns[2]; uint64_t pawn_attacks[2]; uint64_t passed[2]; uint8_t defenders[2][64]; int least_attacker[2][64]; int count[2][7]; int pawn_file[2][8]; int king[2]; int material[2]; /* Total non-pawn, non-king material of both sides. */ int nonpawn; int flights[2]; int checkers[2]; int pressure[2]; /* * Positive values are beneficial to the corresponding side. * Weakness families store negative values. */ int feature[2][PM_FAMILY_COUNT]; } View; static int is_passed_pawn(const View *a, int c, int s) { int t; int f = file_of(s); int r = rank_of(s); for (t = 0; t < 64; ++t) { if (!(a->pawns[1 - c] & bit(t))) continue; if (iabs(file_of(t) - f) <= 1 && forward(c) * (rank_of(t) - r) > 0) return 0; } return 1; } static void pawn_features(View *a, int c) { const PMBoard *b = a->board; int *v = a->feature[c]; int other = 1 - c; int f; int s; for (f = 0; f < 8; ++f) { if (a->pawn_file[c][f] > 1) v[PM_F_DOUBLED_PAWN] -= a->pawn_file[c][f] - 1; } for (s = 0; s < 64; ++s) { int rr; int left; int right; if (!(a->pawns[c] & bit(s))) continue; f = file_of(s); rr = relative_rank(c, s); left = f > 0 ? a->pawn_file[c][f - 1] : 0; right = f < 7 ? a->pawn_file[c][f + 1] : 0; if (!left && !right) --v[PM_F_ISOLATED_PAWN]; if (a->pawn_attacks[c] & bit(s)) ++v[PM_F_PAWN_CHAIN]; v[PM_F_PAWN_BREAK] += popcount64(a->attacks[s] & a->pawns[other]) * (rr >= 3 ? 2 : 1); if (a->passed[c] & bit(s)) { int t; v[PM_F_PASSED_PAWN] += rr >= 3 ? (rr - 2) * (rr - 2) : 1; for (t = s + 1; t < 64; ++t) { if (!(a->passed[c] & bit(t))) continue; if (iabs(file_of(t) - f) == 1 && iabs(rank_of(t) - rank_of(s)) <= 1) { v[PM_F_CONNECTED_PASSERS] += imin(rr, relative_rank(c, t)); } } } } /* Blockade an opposing passed pawn from directly in front. */ for (s = 0; s < 64; ++s) { int front; int bonus; int type; if (!(a->passed[other] & bit(s))) continue; front = s + forward(other) * 8; if (front < 0 || front >= 64 || owner(b->square[front]) != c) continue; bonus = relative_rank(other, s); type = piece_type(b->square[front]); if (type == PM_KNIGHT) bonus += 2; else if (type == PM_KING) ++bonus; v[PM_F_BLOCKADE] += bonus; } } static void tactical_features(View *a, int c) { const PMBoard *b = a->board; int *v = a->feature[c]; int other = 1 - c; int needed[64] = {0}; int s; for (s = 0; s < 64; ++s) { int p = b->square[s]; int type; int targets = 0; int t; if (owner(p) != c) continue; type = piece_type(p); if (type != PM_KING) { int enemy_attacks = a->defenders[other][s]; int own_defenders = a->defenders[c][s]; /* * Approximate material at risk. * Not SEE: pinned attackers and exchange sequences * require search in the host engine. */ if (enemy_attacks) { if (!own_defenders) { v[PM_F_EN_PRISE] -= piece_units(type); } else if (a->least_attacker[other][s] < value[type]) { int loss = value[type] - a->least_attacker[other][s]; v[PM_F_EN_PRISE] -= (loss + 99) / 100; } } /* * A single defender responsible for multiple attacked * valuable pieces is a possible overload. */ if (enemy_attacks && own_defenders == 1 && value[type] >= 300) { for (t = 0; t < 64; ++t) { if (owner(b->square[t]) == c && (a->attacks[t] & bit(s))) { ++needed[t]; break; } } } /* Geometric profitable-target fork approximation. */ for (t = 0; t < 64; ++t) { int target_type; if (!(a->attacks[s] & bit(t)) || owner(b->square[t]) != other) continue; target_type = piece_type(b->square[t]); if (target_type == PM_PAWN) continue; if (target_type == PM_KING || !a->defenders[other][t] || value[target_type] > value[type]) ++targets; } if (targets >= 2) v[PM_F_FORK] += targets - 1; } /* Slider x-rays: absolute pins, relative pins and skewers. */ if (type == PM_BISHOP || type == PM_ROOK || type == PM_QUEEN) { int begin = type == PM_BISHOP ? 4 : 0; int end = type == PM_ROOK ? 4 : 8; int d; for (d = begin; d < end; ++d) { int x = file_of(s) + dx[d]; int y = rank_of(s) + dy[d]; int front = -1; while (inside(x, y)) { int q = y * 8 + x; int target = b->square[q]; if (target) { if (owner(target) != other) break; if (front < 0) { front = q; } else { int first = piece_type(b->square[front]); int second = piece_type(target); if (second == PM_KING && first != PM_KING) { v[PM_F_ABSOLUTE_PIN] += 1 + piece_units(first) / 3; } else if (first != PM_KING && second != PM_KING && value[second] > value[first]) { ++v[PM_F_RELATIVE_PIN]; } else if (second != PM_KING && (first == PM_KING || value[first] > value[second])) { ++v[PM_F_SKEWER]; } break; } } x += dx[d]; y += dy[d]; } } } } for (s = 0; s < 64; ++s) { int type; if (needed[s] >= 2) v[PM_F_OVERLOADED_DEFENDER] -= needed[s] - 1; if (owner(b->square[s]) != other) continue; type = piece_type(b->square[s]); if (type == PM_KING) continue; if (a->least_attacker[c][s] < value[type]) { int difference = value[type] - a->least_attacker[c][s]; v[PM_F_CHEAP_ATTACK] += imax(1, difference / 100); } } } static void piece_features(View *a, int c) { static const int center[4] = {27, 28, 35, 36}; const PMBoard *b = a->board; int *v = a->feature[c]; int other = 1 - c; int bishop_colors = 0; int s; for (s = 0; s < 64; ++s) { int type; int rr; int f; if (owner(b->square[s]) != c) continue; type = piece_type(b->square[s]); rr = relative_rank(c, s); f = file_of(s); if (type != PM_PAWN && type != PM_KING) { uint64_t moves = a->attacks[s] & ~a->occupied[c] & ~bit(a->king[other]); v[PM_F_MOBILITY] += popcount64(moves); } if ((type == PM_KNIGHT || type == PM_BISHOP) && rr > 0) ++v[PM_F_DEVELOPMENT]; if (type == PM_BISHOP) { int t; bishop_colors |= 1 << square_color(s); /* Same-color blocked friendly pawns hinder the bishop. */ for (t = 0; t < 64; ++t) { int front; if (!(a->pawns[c] & bit(t)) || square_color(t) != square_color(s)) continue; front = t + forward(c) * 8; if (front >= 0 && front < 64 && b->square[front]) --v[PM_F_BAD_BISHOP]; } } if (type == PM_KNIGHT && rr >= 3 && rr <= 5 && (a->pawn_attacks[c] & bit(s))) { int challenged = 0; int t; /* * Outpost approximation: supported by a pawn and no * opposing adjacent-file pawn ahead can chase it. */ for (t = 0; t < 64; ++t) { if (!(a->pawns[other] & bit(t))) continue; if (iabs(file_of(t) - f) == 1 && forward(c) * (rank_of(t) - rank_of(s)) > 0) { challenged = 1; break; } } if (!challenged) v[PM_F_KNIGHT_OUTPOST] += 1 + (f == 3 || f == 4); } if (type == PM_ROOK) { int t; if (!a->pawn_file[c][f]) { v[PM_F_ROOK_FILE] += a->pawn_file[other][f] ? 1 : 2; } if (rr == 6) { v[PM_F_ROOK_SEVENTH] += 2; if (relative_rank(c, a->king[other]) == 7) ++v[PM_F_ROOK_SEVENTH]; } else if (rr == 7 && relative_rank(c, a->king[other]) == 7) { ++v[PM_F_ROOK_SEVENTH]; } for (t = s + 1; t < 64; ++t) { if (b->square[t] == color_sign(c) * PM_ROOK && (a->attacks[s] & bit(t))) ++v[PM_F_CONNECTED_ROOKS]; } } } /* Two promoted bishops on the same color are not a bishop pair. */ if (bishop_colors == 3) v[PM_F_BISHOP_PAIR] = 1; for (s = 0; s < 4; ++s) { int q = center[s]; int p = b->square[q]; v[PM_F_CENTER] += imin(3, a->defenders[c][q]); if (p == color_sign(c) * PM_PAWN) v[PM_F_CENTER] += 2; else if (owner(p) == c && piece_type(p) != PM_KING) ++v[PM_F_CENTER]; } } static void king_features(View *a, int c) { const PMBoard *b = a->board; int *v = a->feature[c]; int other = 1 - c; int k = a->king[c]; int enemy_king = a->king[other]; int f = file_of(k); int r = rank_of(k); uint64_t ring = king_ring(k); uint64_t enemy_ring = king_ring(enemy_king); int cage = popcount64( ring & (a->pawns[c] | a->pawn_attacks[other]) ); /* * A pawn cage matters most when the king is already pressured. * Friendly pawn shelter alone is not automatically a weakness. */ if (a->flights[c] <= 1 && a->pressure[c] > 0) v[PM_F_PAWN_CAGE] = -cage * (2 - a->flights[c]); if (relative_rank(c, k) == 0 && a->flights[c] <= 1 && (a->count[other][PM_ROOK] || a->count[other][PM_QUEEN]) && (a->pressure[c] > 0 || cage >= 2)) { v[PM_F_BACK_RANK] = -(2 - a->flights[c]) * (2 + imin(3, a->pressure[c])); } if (a->nonpawn <= 2600 || a->pressure[c] > 0) v[PM_F_KING_FLIGHTS] = a->flights[c]; v[PM_F_KING_PRESSURE] = a->pressure[other]; if (a->count[other][PM_QUEEN] || (a->count[other][PM_ROOK] && a->nonpawn > 1800)) { int df; int step; for (df = -1; df <= 1; ++df) { for (step = 1; step <= 2; ++step) { int x = f + df; int y = r + forward(c) * step; if (inside(x, y) && b->square[y * 8 + x] == color_sign(c) * PM_PAWN) { v[PM_F_KING_SHIELD] += step == 1 ? 2 : 1; } } } } /* * Two-rook mating-net heuristic: * rook control around the enemy king, reduced flights, * edge confinement, checks and connected rooks. * * This does NOT assert forced mate. */ if (a->count[c][PM_ROOK] >= 2) { int rook_pressure = 0; int rook_checks = 0; int s; for (s = 0; s < 64; ++s) { if (b->square[s] != color_sign(c) * PM_ROOK) continue; rook_pressure += popcount64(a->attacks[s] & enemy_ring); if (a->attacks[s] & bit(enemy_king)) ++rook_checks; } if (rook_pressure || rook_checks) { v[PM_F_TWO_ROOK_NET] = 2 * rook_pressure + (8 - a->flights[other]) + 2 * edge_square(enemy_king) + 2 * rook_checks + v[PM_F_CONNECTED_ROOKS]; } } /* Activate the king in sufficiently simplified queenless endings. */ if (!a->count[PM_WHITE][PM_QUEEN] && !a->count[PM_BLACK][PM_QUEEN] && a->nonpawn <= 1600) { int center_distance = imin(iabs(f - 3), iabs(f - 4)) + imin(iabs(r - 3), iabs(r - 4)); int nearest_pawn = 8; int s; v[PM_F_KING_ENDGAME] = 6 - center_distance; for (s = 0; s < 64; ++s) { if (piece_type(b->square[s]) == PM_PAWN) { int distance = imax( iabs(file_of(s) - f), iabs(rank_of(s) - r) ); nearest_pawn = imin(nearest_pawn, distance); } } if (nearest_pawn < 8) v[PM_F_KING_ENDGAME] += 7 - nearest_pawn; } } static void analyze(const PMBoard *b, View *a) { int c; int s; memset(a, 0, sizeof(*a)); a->board = b; for (c = 0; c < 2; ++c) { a->king[c] = -1; for (s = 0; s < 64; ++s) a->least_attacker[c][s] = 30000; } for (s = 0; s < 64; ++s) { int p = b->square[s]; int type; int t; if (!p) continue; c = owner(p); type = piece_type(p); a->occupied[c] |= bit(s); ++a->count[c][type]; if (type == PM_KING) { a->king[c] = s; } else { a->material[c] += value[type]; if (type != PM_PAWN) a->nonpawn += value[type]; } a->attacks[s] = attacks_from(b, s); if (type == PM_PAWN) { a->pawns[c] |= bit(s); a->pawn_attacks[c] |= a->attacks[s]; ++a->pawn_file[c][file_of(s)]; } for (t = 0; t < 64; ++t) { if (!(a->attacks[s] & bit(t))) continue; ++a->defenders[c][t]; if (value[type] < a->least_attacker[c][t]) a->least_attacker[c][t] = value[type]; } } for (c = 0; c < 2; ++c) { uint64_t ring = king_ring(a->king[c]); a->checkers[c] = a->defenders[1 - c][a->king[c]]; a->flights[c] = king_flights(b, c, a->king[c]); a->pressure[c] = 3 * a->checkers[c]; for (s = 0; s < 64; ++s) { if (ring & bit(s)) a->pressure[c] += a->defenders[1 - c][s]; if ((a->pawns[c] & bit(s)) && is_passed_pawn(a, c, s)) a->passed[c] |= bit(s); } } for (c = 0; c < 2; ++c) { pawn_features(a, c); tactical_features(a, c); piece_features(a, c); king_features(a, c); } /* * Direct/distant opposition in king-and-pawn endings. * The side not to move holds geometric opposition. * Pawn tempi and zugzwang still require search. */ if (a->nonpawn == 0) { int df = iabs(file_of(a->king[0]) - file_of(a->king[1])); int dr = iabs(rank_of(a->king[0]) - rank_of(a->king[1])); int opposition = 0; if ((df == 0 && dr >= 2 && dr % 2 == 0) || (dr == 0 && df >= 2 && df % 2 == 0)) { opposition = df + dr == 2 ? 3 : 1; } else if (df == 2 && dr == 2) { opposition = 1; } a->feature[1 - b->side_to_move][PM_F_KING_ENDGAME] += opposition; } } /* ---------- Move-dependent patterns ---------- */ /* * New attacks by pieces that did not move. * Targets must also have remained on the same squares. * * Detects opening a rook/bishop/queen line, including discovered * checks, and also penalizes opening an opposing line accidentally. */ static int discovered_attacks(const View *before, const View *after, int c) { int count = 0; int s; for (s = 0; s < 64; ++s) { uint64_t newly_attacked; int t; int p = after->board->square[s]; if (owner(p) != c || before->board->square[s] != p) continue; newly_attacked = after->attacks[s] & ~before->attacks[s] & after->occupied[1 - c]; for (t = 0; t < 64; ++t) { int target; if (!(newly_attacked & bit(t))) continue; target = after->board->square[t]; if (target == before->board->square[t] && piece_type(target) != PM_PAWN) ++count; } } return count; } static int feature_for(const View *a, int c, int family) { /* * After our move the opponent moves next: * our exposed material is more urgent than attacking an enemy * piece that the opponent may simply rescue. */ if (family == PM_F_EN_PRISE) { return 4 * a->feature[c][family] - a->feature[1 - c][family]; } return a->feature[c][family] - a->feature[1 - c][family]; } /* ---------- Input sanity checks ---------- */ static int valid_board(const PMBoard *b) { int kings[2] = {0, 0}; int s; if (!b || b->side_to_move > PM_BLACK) return 0; for (s = 0; s < 64; ++s) { int p = b->square[s]; int type; if (p < -PM_KING || p > PM_KING) return 0; type = piece_type(p); if (type == PM_KING) ++kings[owner(p)]; if (type == PM_PAWN && (rank_of(s) == 0 || rank_of(s) == 7)) return 0; } return kings[PM_WHITE] == 1 && kings[PM_BLACK] == 1; } static int valid_candidate(const PMBoard *before, const PMCandidate *c) { const PMMove *m; int us; int source; int type; int expected; unsigned allowed_flags = PM_MF_CAPTURE | PM_MF_EP | PM_MF_CASTLE; if (!c || !valid_board(&c->after)) return 0; if ((unsigned)c->terminal > PM_DRAW || (unsigned)c->opponent_mate_in_one > PM_M1_YES) return 0; us = before->side_to_move; if (c->after.side_to_move != 1 - us) return 0; m = &c->move; if (m->from >= 64 || m->to >= 64 || m->from == m->to) return 0; if ((unsigned)m->flags & ~allowed_flags) return 0; source = before->square[m->from]; type = piece_type(source); if (owner(source) != us || owner(before->square[m->to]) == us || piece_type(before->square[m->to]) == PM_KING) return 0; if (m->promotion && m->promotion != PM_KNIGHT && m->promotion != PM_BISHOP && m->promotion != PM_ROOK && m->promotion != PM_QUEEN) return 0; if (m->promotion) { if (type != PM_PAWN || relative_rank(us, m->to) != 7) return 0; } else if (type == PM_PAWN && relative_rank(us, m->to) == 7) { return 0; } if ((m->flags & PM_MF_EP) && (type != PM_PAWN || before->square[m->to] != PM_EMPTY)) return 0; if ((m->flags & PM_MF_CASTLE) && type != PM_KING) return 0; if ((m->flags & PM_MF_CAPTURE) && !before->square[m->to] && !(m->flags & PM_MF_EP)) return 0; expected = color_sign(us) * (m->promotion ? m->promotion : type); if (c->after.square[m->from] != PM_EMPTY || c->after.square[m->to] != expected) return 0; /* * Deliberately not checking the complete move transition: * castling transit squares, EP rights, slider paths, etc. * Candidates must already be legal in the host engine. */ return 1; } /* ---------- Scoring ---------- */ static int32_t bounded_score(int64_t score) { if (score > PM_EVAL_LIMIT) return PM_EVAL_LIMIT; if (score < -PM_EVAL_LIMIT) return -PM_EVAL_LIMIT; return (int32_t)score; } static int score_with_before( const View *before, const PMCandidate *candidate, PMResult *result ) { View after; const PMBoard *b = before->board; int us = b->side_to_move; int other = 1 - us; unsigned mode = 0; int64_t base; int64_t change = 0; int family; memset(result, 0, sizeof(*result)); if (!valid_candidate(b, candidate)) return -1; analyze(&candidate->after, &after); /* A legal move must leave our own king out of check. */ if (after.checkers[us]) return -1; /* Catch contradictory terminal metadata where possible. */ if (candidate->terminal == PM_CHECKMATE && !after.checkers[other]) return -1; if (candidate->terminal == PM_STALEMATE && after.checkers[other]) return -1; if (b->square[candidate->move.to] || (candidate->move.flags & PM_MF_EP)) mode |= PM_MODE_CAPTURE; if (after.checkers[other]) mode |= PM_MODE_CHECK; if (before->checkers[us]) mode |= PM_MODE_EVASION; result->mode = (uint8_t)mode; /* * Absolute material permits sensible comparison with draws, * which have score 0 rather than a material-relative delta. */ base = after.material[us] - after.material[other]; for (family = 0; family < PM_FAMILY_COUNT; ++family) { unsigned id = (unsigned)family * PM_VARIANT_COUNT + mode; const PMPolicy *policy = &policies[id]; const PMPolicy *quiet = &policies[family * PM_VARIANT_COUNT]; int old_feature = feature_for(before, us, family); int new_feature = feature_for(&after, us, family); int gain; int32_t contribution; /* * Event patterns have no persistent positional baseline. * Their feature values in analyze() remain zero. */ if (family == PM_F_DISCOVERED_ATTACK) { new_feature = discovered_attacks(before, &after, us) - discovered_attacks(before, &after, other); } else if (family == PM_F_PROMOTION) { new_feature = candidate->move.promotion ? 1 : 0; } else if (family == PM_F_DEVELOPMENT && (candidate->move.flags & PM_MF_CASTLE)) { new_feature += 2; } base += (int64_t)quiet->weight * old_feature; gain = new_feature - old_feature; contribution = (int32_t)((int64_t)policy->weight * gain); result->contribution[family] = contribution; change += contribution; if (gain) { result->matched[id >> 6] |= UINT64_C(1) << (id & 63); } } result->base_score = (int32_t)base; result->score = bounded_score(base + change); result->reason = PM_REASON_HEURISTIC; /* * Verified game outcomes override every geometric heuristic. * A pawn cage or zero king flights alone never reaches here * as "mate" without terminal metadata from the host engine. */ if (candidate->terminal == PM_CHECKMATE) { result->score = PM_MATE_SCORE - 1; result->reason = PM_REASON_MATE; } else if (candidate->terminal == PM_STALEMATE) { result->score = 0; result->reason = PM_REASON_STALEMATE; } else if (candidate->terminal == PM_DRAW) { result->score = 0; result->reason = PM_REASON_DRAW; } else if (candidate->opponent_mate_in_one == PM_M1_YES) { result->score = -PM_MATE_SCORE + 2; result->reason = PM_REASON_ALLOWS_MATE_ONE; } return 0; } /* ---------- Public API ---------- */ const PMPolicy *pm_policy(unsigned id) { return id < PM_POLICY_COUNT ? &policies[id] : NULL; } int pm_has_match(const PMResult *result, unsigned id) { if (!result || id >= PM_POLICY_COUNT) return 0; return (int)( (result->matched[id >> 6] >> (id & 63)) & UINT64_C(1) ); } int pm_score_move( const PMBoard *before, const PMCandidate *candidate, PMResult *result ) { View analyzed_before; if (!result) return -1; memset(result, 0, sizeof(*result)); if (!valid_board(before)) return -1; analyze(before, &analyzed_before); return score_with_before(&analyzed_before, candidate, result); } size_t pm_choose_move( const PMBoard *before, const PMCandidate *candidates, size_t count, PMResult *result ) { View analyzed_before; PMResult best_result; PMResult current; size_t best = PM_NO_MOVE; size_t i; if (result) memset(result, 0, sizeof(*result)); if (!valid_board(before) || !candidates || !count) return PM_NO_MOVE; analyze(before, &analyzed_before); memset(&best_result, 0, sizeof(best_result)); for (i = 0; i < count; ++i) { if (score_with_before( &analyzed_before, &candidates[i], ¤t) != 0) continue; if (best == PM_NO_MOVE || current.score > best_result.score) { best = i; best_result = current; } } if (best != PM_NO_MOVE && result) *result = best_result; return best; } ``` ## Cách tích hợp Biên dịch: ```bash cc -std=c99 -O2 -Wall -Wextra -pedantic -c chess_policy.c ``` Với mỗi nước hợp lệ, engine cần: 1. Điền `move`. 2. Thực hiện nước đó và lấy snapshot `after`, với lượt đi đã đổi. 3. Xác định `terminal` bằng bộ sinh nước hợp lệ và luật hòa. 4. Để `opponent_mate_in_one = PM_M1_UNKNOWN` nếu chưa kiểm tra chiến thuật này. Chọn nước: ```c PMResult result; size_t best = pm_choose_move( &before, candidates, candidate_count, &result ); if (best != PM_NO_MOVE) { /* Engine thực hiện candidates[best].move. */ } ``` Xem policy nào đã tác động: ```c for (unsigned id = 0; id < PM_POLICY_COUNT; ++id) { if (pm_has_match(&result, id)) { const PMPolicy *p = pm_policy(id); /* * p->pattern * p->variant * result.contribution[p->family] * * Contribution > 0: khuyến khích nước đi. * Contribution < 0: cảnh báo/giảm điểm. */ } } ``` ### Hai vị trí kiểm thử phù hợp với ví dụ của bạn | Mô-típ | FEN | Nước chiếu hết | |---|---|---| | Hai xe phối hợp | `k7/5R2/8/8/8/8/8/6RK w - - 0 1` | `Rg8#` | | Tốt nhốt vua, chiếu hàng cuối | `6k1/5ppp/8/8/8/8/8/4R1K1 w - - 0 1` | `Re8#` | Khi engine xác nhận `PM_CHECKMATE`, cả hai nước phải nhận **`PM_MATE_SCORE - 1`**, bất kể điểm heuristic. **Khuyến nghị:** dùng bộ này để chọn nước cho engine đơn giản hoặc làm **move ordering** cho alpha-beta. Để chống đòn phối hợp, thí quân và chiếu hết nhiều nước đáng tin cậy, vẫn cần search/quiescence; các trọng số trên là mặc định thủ công, chưa phải trọng số đã tune theo Elo.

Viết 1 file .c và .h: -Dùng cho 1 chess engine pattern-match...