共享会话
此前的分析是
分享于 2026年9月22日 13:21
提问者此前的分析是：
根節點並不是一次完整比較全部走法，而是每次抽取少量候選：
const sampleSize = Math.min( pool.remaining, mode === 'tree' ? 6 : 5 );
rollout 還有 17% 隨機選擇：
const epsilon = mode === 'tree' ? 0.02 : 0.17;
在七乘七棋盤的大分支數下，3～12 秒的 MCTS 結果可能有相當大的抽樣噪音。
最終分數經 tanh 壓縮
return Math.tanh(score / 12);
當 rollout 結果的絕對分數較大時，tanh 接近 -1 或 1，相差 2～3 分的影響會被壓得很小。這使確定的孤獨數扣分容易被隨機 rollout 的差異掩蓋。
分析完畢。
現在要修改為： 移除 tanh，改用原始分差。（不要一會兒使用目前行動方視角、一會兒使用根節點玩家視角。回傳視角必須與 backpropagation 的正負號邏輯一致。移除 tanh 後，要重新調整 UCT exploration constant，因為 exploitation 從 [-1, 1] 變成了實際分數單位） 根節點候選提高至約 12～32 個，依時間調整。 強制納入所有會改變孤獨數狀態的候選。 rollout 隨機率從 17% 降低
回答要求：給出修改代碼的python腳本。
QuanAI以下 Python 腳本會讀取 battlenumber244.html，完成指定修改後輸出為 battlenumber245.html：
- 移除所有
tanh評估壓縮，搜尋值改為根節點玩家視角的原始分差。 - Backpropagation 全程保存根節點玩家視角，不交替翻轉正負號。
- 無合法行動使用高權重的直接判負分數。
- 按原本
/ 12的尺度重新調整 UCT exploration constant 與 prior bias。 - 根節點候選抽樣數按思考時間動態設為 12～32。
- 根節點優先且強制納入所有會改變孤獨數狀態的合法落子。
- 不再於根節點預先排除會形成己方孤獨數的走法，改由原始分差評估。
- rollout 的 epsilon 隨機率由 17% 降至 6%。
expected顯示原始分差；介面中的勝率只作顯示換算，不參與搜尋。
python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修改 Battle Number HTML 內的 MCTS／alpha-beta 搜尋。
預設：
輸入：battlenumber244.html
輸出：battlenumber245.html
用法：
python patch_battlenumber_mcts.py
或：
python patch_battlenumber_mcts.py input.html output.html
若輸入與輸出為同一路徑，腳本會先建立 .bak 備份。
"""
from __future__ import annotations
import argparse
import re
import shutil
from pathlib import Path
def replace_literal(
text: str,
old: str,
new: str,
*,
label: str,
expected: int = 1,
) -> str:
count = text.count(old)
if count != expected:
raise RuntimeError(
f"{label}: 預期找到 {expected} 處，實際找到 {count} 處。"
"來源檔案可能不是指定版本，或已經套用過此修改。"
)
return text.replace(old, new)
def replace_regex(
text: str,
pattern: str,
replacement,
*,
label: str,
expected: int = 1,
flags: int = 0,
) -> str:
result, count = re.subn(
pattern,
replacement,
text,
flags=flags,
)
if count != expected:
raise RuntimeError(
f"{label}: 預期替換 {expected} 處，實際替換 {count} 處。"
"來源檔案可能不是指定版本，或已經套用過此修改。"
)
return result
def patch_html(text: str) -> str:
# ------------------------------------------------------------------
# 1. 更新 Worker 說明。
# ------------------------------------------------------------------
text = replace_literal(
text,
" 所有回傳的評估值以 tanh 歸一化到 [-1, 1]。",
(
" 所有搜尋評估值均使用根節點玩家視角的原始分差；\n"
" backpropagation 不交替翻轉正負號。"
),
label="更新 Worker 評估說明",
)
# ------------------------------------------------------------------
# 2. 加入原始分數尺度下的 UCT 參數。
#
# 舊評估是 tanh(score / 12)，因此在接近零分時，
# 一個正規化單位約對應 12 個實際分數單位。
# exploration constant 與 prior bias 同步乘以 12。
# ------------------------------------------------------------------
text = replace_literal(
text,
""" const ROOT_EXTRACTION_CAP = 2600;
const NODE_EXTRACTION_CAP = 220;
const ROLLOUT_EXTRACTION_CAP = 72;
""",
""" const ROOT_EXTRACTION_CAP = 2600;
const NODE_EXTRACTION_CAP = 220;
const ROLLOUT_EXTRACTION_CAP = 72;
// RAW_SCORE_MCTS_PATCH_V1
//
// 搜尋值改為實際分差後，UCT 參數也必須使用相同分數尺度。
// 舊版 tanh(score / 12) 在零附近約等於 score / 12，
// 因此以 12 倍作為第一版重新校準。
const UCT_RAW_SCORE_SCALE = 12;
const UCT_EXPLORATION_PLACE =
1.08 * UCT_RAW_SCORE_SCALE;
const UCT_EXPLORATION_EXTRACT =
1.14 * UCT_RAW_SCORE_SCALE;
const UCT_PRIOR_BIAS =
0.18 * UCT_RAW_SCORE_SCALE;
// 無合法行動是直接判負，必須壓過任何一般數字分差。
const RAW_FORFEIT_SCORE = 1000;
// 只用於介面顯示，不會回饋到 MCTS 或 alpha-beta。
const DISPLAY_SCORE_SPAN = 24;
""",
label="加入原始分差搜尋常數",
)
# ------------------------------------------------------------------
# 3. Placement pool 保存根節點的孤獨數狀態變化候選。
# ------------------------------------------------------------------
text = replace_literal(
text,
""" return {
lo: new Uint32Array(ORIENT_COUNT),
hi: new Uint32Array(ORIENT_COUNT),
remaining: 0,
tactical: null
};
""",
""" return {
lo: new Uint32Array(ORIENT_COUNT),
hi: new Uint32Array(ORIENT_COUNT),
remaining: 0,
tactical: null,
// 只有根節點會填入此陣列。
// 其中包含所有會改變任一非零棋子孤獨數狀態的走法。
lonelyChanges: null,
lonelyChangeTotal: 0
};
""",
label="擴充 placement pool",
)
# ------------------------------------------------------------------
# 4. 根節點不再過濾己方孤獨數走法。
#
# 改為使用完整合法池，並把所有孤獨數狀態變化走法列入
# lonelyChanges，之後在普通抽樣候選之前強制展開。
# ------------------------------------------------------------------
new_root_pool = """ // ROOT_LONELY_STATE_CANDIDATES_V1
//
// 根節點保留完整合法行動，不再預先刪除立即形成己方
// 孤獨數的走法。這些走法應由原始分差自行反映扣分。
//
// 所有會令任何非零棋子的孤獨數狀態發生變化的走法，
// 都會加入 lonelyChanges，並在普通隨機候選之前展開。
function makeRootPlacementPool(state) {
const pool = makePlacementPool(state);
if (pool.remaining <= 0) {
return pool;
}
pool.lonelyChanges =
buildLonelyStateChangingActions(
state,
pool
);
pool.lonelyChangeTotal =
pool.lonelyChanges.length;
return pool;
}
"""
text = replace_regex(
text,
r" // MCTS 根節點防呆：.*?"
r"(?= // 若 target 只剩一個可由落子封閉的開口)",
new_root_pool,
label="改寫根節點 placement pool",
flags=re.DOTALL,
)
# ------------------------------------------------------------------
# 5. 加入「是否改變孤獨數狀態」的精確局部判定。
#
# 一枚新棋只可能改變：
# - 新棋本身；
# - 上下左右相鄰棋子的孤獨狀態。
# ------------------------------------------------------------------
lonely_state_helpers = r"""
// 判斷一手落子是否會改變任一非零棋子的孤獨數狀態。
//
// 落子只會影響新棋本身及四個鄰格，所以不需要重算整盤。
function placementChangesLonelyState(
state,
action
) {
if (
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
state.board[action.i]
) {
return false;
}
const orient =
action._o !== undefined
? action._o
: orientationId(action.t, action.r);
const type = ORIENT_TYPE[orient];
const row = Math.floor(action.i / N);
const col = action.i % N;
const affected = [];
const before = [];
for (let direction = 0; direction < 4; direction++) {
const nextRow = row + D4[direction][0];
const nextCol = col + D4[direction][1];
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
const next = nextRow * N + nextCol;
const code = state.board[next];
// 叉零的數值為零，不列入孤獨數狀態候選。
if (
!code ||
TRI[tileType(code)] <= 0
) {
continue;
}
affected.push(next);
before.push(
isLonelyAt(state.board, next)
);
}
const previous = state.board[action.i];
state.board[action.i] =
1 +
(state.turn << 4) +
orient;
try {
// 新落下的非零棋子若成為孤獨數，也屬於狀態變化。
if (
TRI[type] > 0 &&
isLonelyAt(
state.board,
action.i
)
) {
return true;
}
for (
let index = 0;
index < affected.length;
index++
) {
const after = isLonelyAt(
state.board,
affected[index]
);
if (after !== before[index]) {
return true;
}
}
return false;
} finally {
state.board[action.i] = previous;
}
}
// 掃描完整根節點合法池，找出所有會改變孤獨數狀態的走法。
//
// 結果由低到高排序，之後使用 pop() 先展開啟發值較高者。
// 即使啟發值較低，所有此類走法仍會保留在陣列中。
function buildLonelyStateChangingActions(
state,
pool
) {
const result = [];
for (
let orient = 0;
orient < ORIENT_COUNT;
orient++
) {
forEachPairBit(
pool.lo[orient],
pool.hi[orient],
index => {
const action = {
kind: 'place',
i: index,
t: ORIENT_TYPE[orient],
r: ORIENT_ROT[orient],
_o: orient
};
if (
!placementChangesLonelyState(
state,
action
)
) {
return;
}
action._rootLonelyHeuristic =
localPlacementHeuristic(
state,
action
);
action._rootLonelyOrder =
action._rootLonelyHeuristic +
Math.random() * 0.001;
result.push(action);
}
);
}
result.sort(
(first, second) =>
first._rootLonelyOrder -
second._rootLonelyOrder
);
return result;
}
"""
text = replace_literal(
text,
" function priorFromPlacementHeuristic(heuristic, tacticalBonus) {",
lonely_state_helpers
+ " function priorFromPlacementHeuristic(heuristic, tacticalBonus) {",
label="加入孤獨數狀態變化判定",
)
# ------------------------------------------------------------------
# 6. takePlacementAction 支援根節點動態抽樣數。
# ------------------------------------------------------------------
text = replace_literal(
text,
" function takePlacementAction(pool, state, mode) {",
""" function takePlacementAction(
pool,
state,
mode,
requestedSampleSize = null
) {""",
label="擴充 takePlacementAction 參數",
)
# 所有孤獨數狀態變化候選，必須在普通候選抽樣前取出。
text = replace_literal(
text,
""" if (pool.remaining <= 0) {
return null;
}
if (pool.tactical === null) {
""",
""" if (pool.remaining <= 0) {
return null;
}
// 根節點首先展開所有會改變孤獨數狀態的合法走法。
// poolRemoveAction 令它們不會在後面的普通抽樣中重複出現。
if (Array.isArray(pool.lonelyChanges)) {
while (pool.lonelyChanges.length) {
const action =
pool.lonelyChanges.pop();
if (!poolHasAction(pool, action)) {
continue;
}
const heuristic =
Number.isFinite(
action._rootLonelyHeuristic
)
? action._rootLonelyHeuristic
: localPlacementHeuristic(
state,
action
);
poolRemoveAction(pool, action);
return {
action,
prior: priorFromPlacementHeuristic(
heuristic,
0
)
};
}
}
if (pool.tactical === null) {
""",
label="強制展開孤獨數狀態變化候選",
)
# 根節點使用外部傳入的 12～32；內部樹節點維持 6，
# rollout 維持 5。
text = replace_literal(
text,
""" const sampleSize = Math.min(
pool.remaining,
mode === 'tree' ? 6 : 5
);
""",
""" const defaultSampleSize =
mode === 'tree'
? 6
: 5;
const effectiveSampleSize =
Number.isFinite(requestedSampleSize)
? Math.max(
1,
Math.floor(requestedSampleSize)
)
: defaultSampleSize;
const sampleSize = Math.min(
pool.remaining,
effectiveSampleSize
);
""",
label="加入動態候選抽樣數",
)
# rollout epsilon 由 17% 降為 6%。
text = replace_literal(
text,
""" const epsilon =
mode === 'tree'
? 0.02
: 0.17;
""",
""" const epsilon =
mode === 'tree'
? 0.01
: 0.06;
""",
label="降低 rollout 隨機率",
)
# ------------------------------------------------------------------
# 7. 原始分差評估：所有結果統一為根節點玩家視角。
#
# Backpropagation 不翻號，因此每一層保存的 value 都必須是
# rootPlayer 視角。
# ------------------------------------------------------------------
raw_evaluation_block = """ // 將玩家一視角的零和分差轉成根節點玩家視角。
//
// MCTS backpropagation 不會逐層翻轉符號，因此所有 rollout、
// terminal evaluation 與 no-action result 都必須使用此視角。
function rootPerspectiveScore(
playerZeroScore,
rootPlayer
) {
return rootPlayer === 0
? playerZeroScore
: -playerZeroScore;
}
function placementEvaluation(
state,
rootPlayer
) {
return rootPerspectiveScore(
state.ps,
rootPlayer
);
}
function fullEvaluation(
state,
rootPlayer
) {
const playerZeroScore =
state.ps +
state.raw0 -
state.raw1;
return rootPerspectiveScore(
playerZeroScore,
rootPlayer
);
}
function noActionResult(state, rootPlayer) {
return state.turn === rootPlayer
? -RAW_FORFEIT_SCORE
: RAW_FORFEIT_SCORE;
}
// 只把原始分差換算成介面顯示用的 0..1 數值。
// 此值不參與 selection、backpropagation 或 alpha-beta。
function scoreToDisplayWinRate(score) {
const value = Number(score);
if (!Number.isFinite(value)) {
return 0.5;
}
if (value >= RAW_FORFEIT_SCORE) {
return 1;
}
if (value <= -RAW_FORFEIT_SCORE) {
return 0;
}
return clamp(
0.5 +
value /
(DISPLAY_SCORE_SPAN * 2),
0,
1
);
}
"""
text = replace_regex(
text,
r" function normalizedPlacementEvaluation\(.*?"
r"(?= // 落子 rollout 的硬性邊界：)",
raw_evaluation_block,
label="改寫搜尋評估函式",
flags=re.DOTALL,
)
# 更新函式名稱引用。
placement_eval_count = text.count(
"normalizedPlacementEvaluation"
)
if placement_eval_count < 1:
raise RuntimeError(
"找不到 normalizedPlacementEvaluation 的呼叫位置。"
)
text = text.replace(
"normalizedPlacementEvaluation",
"placementEvaluation",
)
full_eval_count = text.count(
"normalizedFullEvaluation"
)
if full_eval_count < 1:
raise RuntimeError(
"找不到 normalizedFullEvaluation 的呼叫位置。"
)
text = text.replace(
"normalizedFullEvaluation",
"fullEvaluation",
)
# ------------------------------------------------------------------
# 8. takeUntried：根節點使用依時間計算的候選數。
# ------------------------------------------------------------------
take_untried_and_target = """ function takeUntried(
node,
root,
context
) {
if (node.kind === 'place') {
return takePlacementAction(
node.pool,
node.state,
'tree',
node === root
? context.rootPlacementSampleSize
: null
);
}
if (
node.kind === 'extract' &&
node.untried &&
node.untried.length
) {
const selected = node.untried.pop();
return {
action: selected.action,
prior: selected.prior
};
}
return null;
}
// 按思考時間把根節點 placement 候選提高到 12～32。
//
// 約略對應：
// < 2 秒：12
// 2～4 秒：16
// 4～8 秒：20
// 8～16 秒：24
// 16～32 秒：28
// >= 32 秒：32
function rootPlacementCandidateTarget(timeMs) {
const seconds = Math.max(
0.1,
(Number(timeMs) || 1000) / 1000
);
const tier =
seconds < 2
? 0
: Math.floor(
Math.log2(seconds)
);
return clamp(
12 + tier * 4,
12,
32
);
}
"""
text = replace_regex(
text,
r" function takeUntried\(node\) \{.*?"
r"(?= function progressiveWideningLimit\()",
take_untried_and_target,
label="改寫 takeUntried 並加入根候選數函式",
flags=re.DOTALL,
)
# ------------------------------------------------------------------
# 9. Progressive widening 的根節點基數使用 12～32，
# 並保證不小於孤獨數狀態變化候選總數。
# ------------------------------------------------------------------
progressive_widening = """ function progressiveWideningLimit(
node,
root,
context
) {
const visits = Math.max(1, node.visits);
const rootNode = node === root;
if (node.state.phase === 'place') {
if (rootNode) {
const forcedLonelyCount =
node.pool &&
Number.isFinite(
node.pool.lonelyChangeTotal
)
? node.pool.lonelyChangeTotal
: 0;
const rootBase = Math.max(
context.rootPlacementSampleSize,
forcedLonelyCount
);
return (
rootBase +
Math.floor(
2.75 *
Math.sqrt(
Math.max(0, visits - 1)
)
)
);
}
return (
5 +
Math.floor(
2.25 * Math.sqrt(visits)
)
);
}
return (
(rootNode ? 8 : 4) +
Math.floor(
(rootNode ? 3.4 : 1.9) *
Math.sqrt(visits)
)
);
}
function nodeCanExpand(
node,
root,
context
) {
return (
nodeHasUntried(node) &&
node.children.length <
progressiveWideningLimit(
node,
root,
context
)
);
}
"""
text = replace_regex(
text,
r" function progressiveWideningLimit\(.*?"
r"(?= // UCT 加入小幅先驗偏置。)",
progressive_widening,
label="改寫 progressive widening",
flags=re.DOTALL,
)
# 更新 nodeCanExpand 呼叫。
text = replace_literal(
text,
"nodeCanExpand(node, root)",
"nodeCanExpand(node, root, context)",
label="更新 nodeCanExpand 呼叫",
expected=2,
)
# 更新 takeUntried 呼叫。
text = replace_literal(
text,
"const selected = takeUntried(node);",
"""const selected = takeUntried(
node,
root,
context
);""",
label="更新 expansion takeUntried 呼叫",
)
text = replace_literal(
text,
"const selected = takeUntried(root);",
"""const selected = takeUntried(
root,
root,
context
);""",
label="更新 emergency takeUntried 呼叫",
)
# ------------------------------------------------------------------
# 10. UCT exploration 與 prior bias 改為原始分數尺度。
# ------------------------------------------------------------------
text = replace_literal(
text,
""" const explorationConstant =
node.state.phase === 'place'
? 1.08
: 1.14;
""",
""" const explorationConstant =
node.state.phase === 'place'
? UCT_EXPLORATION_PLACE
: UCT_EXPLORATION_EXTRACT;
""",
label="調整 UCT exploration constant",
)
text = replace_literal(
text,
""" const priorBias =
0.18 *
priorRatio *
sqrtParent /
(1 + visits);
""",
""" const priorBias =
UCT_PRIOR_BIAS *
priorRatio *
sqrtParent /
(1 + visits);
""",
label="調整 UCT prior bias",
)
# 更新 UCT 視角說明。
text = replace_literal(
text,
""" // UCT 加入小幅先驗偏置。
// 孤獨數戰術仍須經 rollout 驗證，不會僅因規則 bonus 而強制選中。
""",
""" // UCT 加入小幅先驗偏置。
//
// child.value 永遠是根節點玩家視角：
// - 根節點玩家行動時最大化 mean。
// - 對手行動時最大化 -mean，即最小化根玩家分數。
//
// exploitation、exploration 與 prior bias 現在都使用實際分數單位。
""",
label="更新 UCT 視角註解",
)
# ------------------------------------------------------------------
# 11. alpha-beta 靜態評估移除 tanh，統一根玩家視角。
# ------------------------------------------------------------------
exact_alpha_beta = """ function exactAlphaBetaEvaluation(
state,
rootPlayer
) {
if (state.phase === 'place') {
// applyPlacementInPlace 只會在第 49 枚棋子落下時更新 ps。
// 深度限制內的中間局面必須從目前棋盤重新計分。
const playerZeroScore =
regionScore(state.board);
return rootPerspectiveScore(
playerZeroScore,
rootPlayer
);
}
return fullEvaluation(
state,
rootPlayer
);
}
"""
text = replace_regex(
text,
r" function exactAlphaBetaEvaluation\(.*?"
r"(?= function alphaBetaRecursive\()",
exact_alpha_beta,
label="改寫 alpha-beta 原始分差評估",
flags=re.DOTALL,
)
# alpha-beta 已完整列出所有合法行動，不應再排除己方孤獨數走法。
text = replace_regex(
text,
r"\n // 與 MCTS 根節點使用相同防呆。.*?"
r"(?=\n if \(!actions.length\))",
"",
label="移除 alpha-beta 根節點孤獨數過濾",
flags=re.DOTALL,
)
# alpha-beta 無合法行動值改為直接判負值。
text = replace_literal(
text,
""" value: -1,
noLegal: true
""",
""" value: -RAW_FORFEIT_SCORE,
noLegal: true
""",
label="調整 alpha-beta 無合法行動分數",
)
# ------------------------------------------------------------------
# 12. 搜尋 context 保存根節點候選目標。
# ------------------------------------------------------------------
text = replace_literal(
text,
""" const context = {
rootPlayer,
rootPhase: rootState.phase,
maxTreePlies: safeDepthRounds * 2,
currentNode: null
};
""",
""" const context = {
rootPlayer,
rootPhase: rootState.phase,
maxTreePlies: safeDepthRounds * 2,
rootPlacementSampleSize:
rootPlacementCandidateTarget(timeMs),
currentNode: null
};
""",
label="加入根節點動態候選 context",
)
# 極短時間的 emergency candidate 也使用同一目標。
text = replace_literal(
text,
" const emergencySampleSize = 5;",
""" const emergencySampleSize =
context.rootPlacementSampleSize;""",
label="調整 emergency 根候選數",
)
# MCTS 根節點無合法行動的 expected 也改為原始分差尺度。
text = replace_literal(
text,
" expected: -1,",
" expected: -RAW_FORFEIT_SCORE,",
label="調整 MCTS 無合法行動 expected",
)
# ------------------------------------------------------------------
# 13. 介面 winRate 不再假定 expected 位於 [-1, 1]。
# ------------------------------------------------------------------
win_rate_pattern = (
r"winRate:\s*clamp\(\s*"
r"\(\s*(result\.value|expected)\s*\+\s*1\s*\)"
r"\s*/\s*2\s*,\s*0\s*,\s*1\s*\)"
)
def replace_win_rate(match: re.Match[str]) -> str:
value = match.group(1)
return f"winRate: scoreToDisplayWinRate({value})"
text = replace_regex(
text,
win_rate_pattern,
replace_win_rate,
label="更新原始分差的 winRate 顯示換算",
expected=4,
flags=re.DOTALL,
)
# ------------------------------------------------------------------
# 14. prepareNode 註解不再宣稱根節點排除己方孤獨數。
# ------------------------------------------------------------------
text = replace_literal(
text,
""" // 根節點只在存在安全落子時排除立即自成孤獨數的棋。
// 內部節點仍保留完整規則，用來正確模擬後續局面。
""",
""" // 根節點使用完整合法池，並另外強制排入所有
// 會改變孤獨數狀態的候選；內部節點維持一般抽樣。
""",
label="更新 prepareNode 根節點註解",
)
# ------------------------------------------------------------------
# 15. Backpropagation 明確保持根玩家視角，不逐層翻號。
# ------------------------------------------------------------------
text = replace_literal(
text,
""" // Backpropagation
while (node) {
node.visits++;
node.value += result;
node = node.parent;
}
""",
""" // Backpropagation
//
// result 已經是 rootPlayer 視角，因此每一層都累加
// 同一個值，不在奇偶層交替翻轉正負號。
while (node) {
node.visits++;
node.value += result;
node = node.parent;
}
""",
label="更新 backpropagation 視角註解",
)
# ------------------------------------------------------------------
# 16. fallback 同樣不預先排除形成己方孤獨數的合法走法。
# fallback 只在 Worker 失敗時使用，但行為應與完整根池一致。
# ------------------------------------------------------------------
fallback_replacement = """ // fallback 保留完整合法行動。
// 孤獨數造成的得失由下面的實際分數比較決定。
const actions = allActions;
"""
text = replace_regex(
text,
r" // Worker 建立失敗或回傳無效行動時，fallback 也不能.*?"
r"(?= // 主執行緒使用獨立的 Fisher-Yates shuffle。)",
fallback_replacement,
label="移除 fallback 己方孤獨數過濾",
flags=re.DOTALL,
)
# ------------------------------------------------------------------
# 17. 最終驗證。
# ------------------------------------------------------------------
forbidden_fragments = {
"Math.tanh(": "仍殘留 tanh 評估",
"mode === 'tree' ? 6 : 5": "仍殘留舊的固定候選抽樣",
": 0.17;": "仍殘留 17% rollout epsilon",
"(expected + 1) / 2": "仍使用 [-1, 1] 的勝率換算",
"(result.value + 1) / 2": "alpha-beta 仍使用舊勝率換算",
}
for fragment, message in forbidden_fragments.items():
if fragment in text:
raise RuntimeError(message)
required_fragments = [
"function rootPerspectiveScore(",
"const UCT_EXPLORATION_PLACE =",
"function rootPlacementCandidateTarget(",
"function buildLonelyStateChangingActions(",
"context.rootPlacementSampleSize",
"RAW_FORFEIT_SCORE",
"mode === 'tree'\n ? 0.01\n : 0.06",
]
for fragment in required_fragments:
if fragment not in text:
raise RuntimeError(
f"修改後缺少必要代碼：{fragment}"
)
return text
def main() -> None:
parser = argparse.ArgumentParser(
description=(
"修改 Battle Number 的 MCTS：使用原始分差、"
"動態根候選、強制孤獨數候選及較低 rollout 隨機率。"
)
)
parser.add_argument(
"input",
nargs="?",
default="battlenumber244.html",
help="輸入 HTML，預設為 battlenumber244.html",
)
parser.add_argument(
"output",
nargs="?",
default="battlenumber245.html",
help="輸出 HTML，預設為 battlenumber245.html",
)
args = parser.parse_args()
input_path = Path(args.input)
output_path = Path(args.output)
if not input_path.is_file():
raise SystemExit(
f"找不到輸入檔案：{input_path}"
)
source = input_path.read_text(
encoding="utf-8"
)
try:
patched = patch_html(source)
except RuntimeError as error:
raise SystemExit(
f"修改失敗：{error}"
) from error
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
# 若直接覆寫原檔，先備份。
if input_path.resolve() == output_path.resolve():
backup_path = input_path.with_suffix(
input_path.suffix + ".bak"
)
shutil.copy2(
input_path,
backup_path,
)
print(f"已建立備份：{backup_path}")
output_path.write_text(
patched,
encoding="utf-8",
newline="\n",
)
print(f"修改完成：{output_path}")
print("已套用：")
print(" 1. 移除 tanh，改用根節點玩家視角的原始分差")
print(" 2. UCT exploration/prior bias 改用實際分數尺度")
print(" 3. 根節點候選按時間調整為 12～32")
print(" 4. 強制優先展開所有孤獨數狀態變化候選")
print(" 5. rollout epsilon 由 17% 降至 6%")
print(" 6. backpropagation 全程不翻轉根玩家視角分數")
if __name__ == "__main__":
main()將腳本儲存為 patch_battlenumber_mcts.py，與 HTML 放在同一目錄後執行：
bash
python patch_battlenumber_mcts.py或指定檔名：
bash
python patch_battlenumber_mcts.py battlenumber244.html battlenumber245.html為什麼修改之後，AI還是會走出直接送分的棋？為什麼還是落下一個棋子直接是「孤獨數」？AI不知道孤獨數會扣分嗎？
QuanAI因為目前這個修改版其實只是讓 AI 「偵測到孤獨數狀態發生變化」，並沒有讓它在根節點把「製造己方孤獨數」視為必須避免的扣分行為。更嚴重的是，程式還會優先展開這些走法。
最主要的問題：評估函式沒有看到當前孤獨數扣分
上一版把落子階段評估改成：
js
function placementEvaluation(
state,
rootPlayer
) {
return rootPerspectiveScore(
state.ps,
rootPlayer
);
}但同一份程式裡已經註明：
js
// applyPlacementInPlace 只會在第 49 枚棋子落下時更新 ps。也就是說：
- AI 落下一枚立即成為孤獨數的棋；
- 棋盤畫面已經能看出它是孤獨數；
- 但
state.ps很可能尚未更新這項扣分； - MCTS 在中途停止 rollout 時，得到的仍是舊分數。
因此，對 AI 的搜尋評估而言，這個孤獨數可能暫時「沒有扣分」。
只有 rollout 剛好模擬到完整計分點，AI 才可能間接看到後果。思考時間短、分支多或 rollout 提前截斷時，這項訊息很容易消失。
第二個問題：程式刻意移除了孤獨數安全過濾
上一版明確做了這件事：
js
// 根節點保留完整合法行動，不再預先刪除立即形成己方
// 孤獨數的走法。也就是原本可能存在的：
如果有不會形成己方孤獨數的走法，就不要考慮直接形成孤獨數的走法。
這層保護已經被移除了。
原本的修改假設「原始分差評估自然會懲罰這些走法」，但由於 placementEvaluation() 只讀取尚未即時更新的 state.ps，這個假設並不成立。
第三個問題：孤獨數候選被「優先展開」，不是被懲罰
這段邏輯：
js
pool.lonelyChanges =
buildLonelyStateChangingActions(
state,
pool
);收集的是：
所有會改變孤獨數狀態的走法。
它沒有區分以下幾種完全不同的情況：
- 製造己方孤獨數——通常不好；
- 消除己方孤獨數——通常很好；
- 製造對方孤獨數——通常很好；
- 消除對方孤獨數——通常不好；
- 新落下的棋本身立即成為孤獨數——通常不好。
接著 takePlacementAction() 又會優先取出它們：
js
if (Array.isArray(pool.lonelyChanges)) {
while (pool.lonelyChanges.length) {
const action =
pool.lonelyChanges.pop();
// ...
return {
action,
prior: priorFromPlacementHeuristic(
heuristic,
0
)
};
}
}所以實際效果是：
只要某一步會改變孤獨數狀態，不管是好是壞，都優先讓 MCTS 展開。
而且這裡傳入的 tactical bonus 是 0：
js
priorFromPlacementHeuristic(heuristic, 0)沒有針對「製造己方孤獨數」增加負分。
因此，AI 確實偵測到了那步會造成孤獨數，但程式沒有告訴它這是壞事。
第四個問題：UCT 探索強度可能過高
上一版將探索常數直接乘以 12：
js
const UCT_EXPLORATION_PLACE =
1.08 * 12; // 12.96這個換算只在 tanh(score / 12) 接近零分時近似成立，並不代表整個分數範圍都適合直接乘以 12。
如果一般落子間的實際差距只有 1～3 分，而 exploration bonus 可以達到十幾分，就可能出現：
- 明明某步評估比較差；
- 但因為訪問次數較少；
- UCT 仍然大量探索它；
- 思考時間不足時，最終訪問數與平均值受到噪音影響；
- 最後選到直接送分的棋。
這不是孤獨數問題的根本原因，但會放大問題。
所以 AI 到底知不知道孤獨數會扣分？
精確地說：
- 規則函式知道什麼叫孤獨數，因為有
isLonelyAt()； - 候選產生器知道某一步會改變孤獨狀態；
- 但 MCTS 的中途評估並沒有立即把這個扣分算進去；
- 而且候選分類沒有區分這次變化對自己是好還是壞。
所以目前的 AI 是：
看得出「這裡發生了孤獨數變化」，但不知道這次變化究竟值多少分，甚至還會優先探索它。
這不算真正理解孤獨數扣分。
正確修改方向
1. 落子階段必須按當前棋盤重新計分
最直接的修正是把：
js
function placementEvaluation(
state,
rootPlayer
) {
return rootPerspectiveScore(
state.ps,
rootPlayer
);
}改成：
js
function placementEvaluation(
state,
rootPlayer
) {
const currentScore =
regionScore(state.board);
return rootPerspectiveScore(
currentScore,
rootPlayer
);
}這樣每次 rollout 提前結束時，都會根據目前棋盤重新計算包括孤獨數在內的分差，而不是讀取尚未更新的 state.ps。
如果 regionScore() 確實包含孤獨數扣分，這是最重要的修正。
2. 必須區分「有利」和「有害」的孤獨數變化
不應只回傳 Boolean：
js
placementChangesLonelyState(...)應該計算落子前後的孤獨數分差，例如：
js
function placementScoreDelta(
state,
action,
rootPlayer
) {
const before =
regionScore(state.board);
const previous =
state.board[action.i];
const orient =
action._o !== undefined
? action._o
: orientationId(
action.t,
action.r
);
state.board[action.i] =
1 +
(state.turn << 4) +
orient;
try {
const after =
regionScore(state.board);
return rootPerspectiveScore(
after - before,
rootPlayer
);
} finally {
state.board[action.i] =
previous;
}
}然後候選應按 delta 分類：
delta > 0：對根玩家有利；delta === 0：沒有立即分數變化；delta < 0：直接送分。
不能再把所有孤獨數變化放在同一個 lonelyChanges 裡。
3. 如果要求 AI 絕不無故送分，就要恢復安全過濾
如果你的要求是：
只要存在不會立即送分的合法棋，AI 就不能走立即送分的棋。
那就不能只依賴 MCTS 的軟評估，而應採用硬性安全規則：
js
const safeActions = actions.filter(
action =>
placementScoreDelta(
state,
action,
rootPlayer
) >= 0
);
const allowedActions =
safeActions.length
? safeActions
: actions;這代表：
- 如果有不扣分的合法走法，只搜尋不扣分的走法；
- 只有所有合法走法都會扣分時，才允許選擇扣分最少的走法。
這樣才能真正保證 AI 不會在存在安全選項時直接送分。
4. 根節點最後選棋時再做一次安全檢查
即使搜尋內部已修正，最終輸出行動前仍可增加保險：
js
const safeChildren =
root.children.filter(
child =>
placementScoreDelta(
rootState,
child.action,
rootPlayer
) >= 0
);
const selectableChildren =
safeChildren.length
? safeChildren
: root.children;然後只從 selectableChildren 中選最終走法。
這可以防止：
- rollout 噪音；
- 思考時間太短；
- UCT 探索過強；
- 某個評估路徑漏算；
導致 AI 最終輸出立即送分棋。
5. 不要強制納入所有孤獨數變化，只強制納入有利變化
原本：
js
if (
placementChangesLonelyState(
state,
action
)
) {
result.push(action);
}應改成類似：
js
const delta =
placementScoreDelta(
state,
action,
rootPlayer
);
if (delta > 0) {
action._immediateScoreDelta =
delta;
result.push(action);
}有害的孤獨數走法可以保留在普通合法候選池中，或者在有安全走法時直接排除，但不應該被「強制優先展開」。
結論
AI 還會直接落出孤獨數，並不是因為 isLonelyAt() 壞掉，而是上一版修改有三個核心設計錯誤：
placementEvaluation()使用沒有即時更新的state.ps，所以看不到當前孤獨數扣分；- 程式移除了根節點避免己方孤獨數的安全過濾；
- 程式把所有孤獨數狀態變化都當成重要候選，卻沒有區分對自己有利還是有害。
最重要的修正是：
js
function placementEvaluation(
state,
rootPlayer
) {
return rootPerspectiveScore(
regionScore(state.board),
rootPlayer
);
}再加上根節點安全規則：
有不立即扣分的合法走法時，禁止選擇立即扣分的走法。
否則，即使增加思考時間、降低 epsilon 或增加 rollout 數量，也只能降低直接送分的機率，不能真正避免它。
提问者把所有的修改都寫到一個python腳本中
QuanAI下面是一個完整的修正腳本，預設讀取上一版產生的 battlenumber245.html，輸出為 battlenumber246.html。
這個版本會同時修正：
- 落子階段以
regionScore(state.board)即時計算真實分差。 - 精確判斷落子前後的孤獨數變化。
- 區分：
- 製造己方孤獨數；
- 消除己方孤獨數；
- 製造對方孤獨數；
- 消除對方孤獨數。
- 根節點存在安全走法時，硬性排除：
- 立即製造己方孤獨數的走法；
- 立即造成負分差的走法。
- 如果所有走法都不好，只保留製造己方孤獨數最少且立即損失最小的走法。
- 只強制優先搜尋有利的孤獨數戰術。
- alpha-beta 根節點套用相同安全規則。
- 降低先前過高的 UCT exploration constant。
- 保留原先的 6% rollout epsilon、根玩家視角原始分差與不翻號 backpropagation。
python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修正 battlenumber245.html 中的孤獨數評估及根節點安全選棋。
預設：
輸入：battlenumber245.html
輸出：battlenumber246.html
用法：
python patch_battlenumber_lonely_safety.py
或：
python patch_battlenumber_lonely_safety.py input.html output.html
若輸入與輸出為相同路徑，會先建立 .bak 備份。
此腳本針對已經套用 RAW_SCORE_MCTS_PATCH_V1 的版本。
"""
from __future__ import annotations
import argparse
import re
import shutil
from pathlib import Path
def replace_once(
text: str,
old: str,
new: str,
*,
label: str,
) -> str:
count = text.count(old)
if count != 1:
raise RuntimeError(
f"{label}: 預期找到 1 處，實際找到 {count} 處。"
"請確認輸入檔案是上一版產生的 battlenumber245.html，"
"且尚未套用這個修正。"
)
return text.replace(old, new, 1)
def replace_regex_once(
text: str,
pattern: str,
replacement,
*,
label: str,
flags: int = 0,
) -> str:
result, count = re.subn(
pattern,
replacement,
text,
count=1,
flags=flags,
)
if count != 1:
raise RuntimeError(
f"{label}: 預期替換 1 處，實際替換 {count} 處。"
)
return result
def replace_between(
text: str,
start_marker: str,
end_marker: str,
replacement: str,
*,
label: str,
) -> str:
start = text.find(start_marker)
if start < 0:
raise RuntimeError(
f"{label}: 找不到起始標記。"
)
second_start = text.find(
start_marker,
start + len(start_marker),
)
if second_start >= 0:
raise RuntimeError(
f"{label}: 起始標記出現不只一次。"
)
end = text.find(
end_marker,
start + len(start_marker),
)
if end < 0:
raise RuntimeError(
f"{label}: 找不到結束標記。"
)
return (
text[:start]
+ replacement
+ text[end:]
)
def find_matching_brace(
text: str,
opening_brace: int,
) -> int:
"""
找出 JavaScript 函式本體的結束大括號。
會略過一般字串、template string 及註解中的大括號。
"""
if (
opening_brace < 0
or opening_brace >= len(text)
or text[opening_brace] != "{"
):
raise ValueError(
"opening_brace 不是有效的大括號位置"
)
depth = 0
index = opening_brace
state = "normal"
escaped = False
while index < len(text):
char = text[index]
next_char = (
text[index + 1]
if index + 1 < len(text)
else ""
)
if state == "line_comment":
if char in "\r\n":
state = "normal"
index += 1
continue
if state == "block_comment":
if char == "*" and next_char == "/":
state = "normal"
index += 2
else:
index += 1
continue
if state in {
"single_quote",
"double_quote",
"template",
}:
if escaped:
escaped = False
index += 1
continue
if char == "\\":
escaped = True
index += 1
continue
if (
state == "single_quote"
and char == "'"
):
state = "normal"
elif (
state == "double_quote"
and char == '"'
):
state = "normal"
elif (
state == "template"
and char == "`"
):
state = "normal"
index += 1
continue
if char == "/" and next_char == "/":
state = "line_comment"
index += 2
continue
if char == "/" and next_char == "*":
state = "block_comment"
index += 2
continue
if char == "'":
state = "single_quote"
index += 1
continue
if char == '"':
state = "double_quote"
index += 1
continue
if char == "`":
state = "template"
index += 1
continue
if char == "{":
depth += 1
elif char == "}":
depth -= 1
if depth == 0:
return index
index += 1
raise RuntimeError(
"找不到 JavaScript 函式的結束大括號。"
)
def find_javascript_functions(
text: str,
) -> list[dict[str, object]]:
pattern = re.compile(
r"\bfunction\s+"
r"([A-Za-z_$][A-Za-z0-9_$]*)"
r"\s*\([^)]*\)\s*\{"
)
functions: list[dict[str, object]] = []
for match in pattern.finditer(text):
opening_brace = text.find(
"{",
match.start(),
match.end(),
)
if opening_brace < 0:
continue
try:
closing_brace = find_matching_brace(
text,
opening_brace,
)
except RuntimeError:
continue
functions.append(
{
"name": match.group(1),
"start": match.start(),
"opening": opening_brace,
"closing": closing_brace,
"body": text[
opening_brace + 1:
closing_brace
],
}
)
return functions
def patch_alpha_beta_root_safety(
text: str,
) -> str:
"""
在 alpha-beta 的根搜尋函式中，在 !actions.length 判斷前
插入相同的根節點安全過濾。
這裡使用原地修改 actions 陣列，所以 actions 即使以 const
宣告也不會有問題。
"""
marker = "ALPHA_BETA_ROOT_SAFETY_V2"
if marker in text:
raise RuntimeError(
"alpha-beta 根節點安全修正似乎已經套用。"
)
candidates = []
for function in find_javascript_functions(text):
name = str(function["name"])
lower_name = name.lower()
body = str(function["body"])
if "alphabeta" not in lower_name:
continue
if "recursive" in lower_name:
continue
if "evaluation" in lower_name:
continue
if not re.search(
r"if\s*\(\s*!actions\.length\s*\)",
body,
):
continue
if "rootPlayer" not in body:
continue
candidates.append(function)
if len(candidates) != 1:
names = [
str(function["name"])
for function in candidates
]
raise RuntimeError(
"無法唯一識別 alpha-beta 根搜尋函式。"
f"候選函式：{names}"
)
function = candidates[0]
body = str(function["body"])
empty_test = re.search(
r"(?m)^([ \t]*)"
r"if\s*\(\s*!actions\.length\s*\)\s*\{",
body,
)
if empty_test is None:
raise RuntimeError(
"alpha-beta 根搜尋函式內找不到 "
"if (!actions.length)。"
)
if re.search(r"\brootState\.phase\b", body):
state_name = "rootState"
elif re.search(r"\bstate\.phase\b", body):
state_name = "state"
elif re.search(r"\brootState\b", body):
state_name = "rootState"
elif re.search(r"\bstate\b", body):
state_name = "state"
else:
raise RuntimeError(
"無法識別 alpha-beta 根狀態變數。"
)
indentation = empty_test.group(1)
insertion = (
f"{indentation}"
"// ALPHA_BETA_ROOT_SAFETY_V2\n"
f"{indentation}"
f"if ({state_name}.phase === 'place') {{\n"
f"{indentation}"
" const rootSafetyActions =\n"
f"{indentation}"
" filterRootPlacementActions(\n"
f"{indentation}"
f" {state_name},\n"
f"{indentation}"
" actions,\n"
f"{indentation}"
" rootPlayer\n"
f"{indentation}"
" );\n"
"\n"
f"{indentation}"
" actions.length = 0;\n"
f"{indentation}"
" actions.push(...rootSafetyActions);\n"
f"{indentation}"
"}\n"
"\n"
)
insertion_position = (
int(function["opening"])
+ 1
+ empty_test.start()
)
return (
text[:insertion_position]
+ insertion
+ text[insertion_position:]
)
def patch_html(text: str) -> str:
if "RAW_SCORE_MCTS_PATCH_V1" not in text:
raise RuntimeError(
"找不到 RAW_SCORE_MCTS_PATCH_V1。"
"這個腳本應套用到上一版產生的 "
"battlenumber245.html。"
)
if "LONELY_SAFETY_PATCH_V2" in text:
raise RuntimeError(
"LONELY_SAFETY_PATCH_V2 已存在，"
"不可重複套用。"
)
# --------------------------------------------------------------
# 1. 加入版本標記。
# --------------------------------------------------------------
text = replace_once(
text,
"// RAW_SCORE_MCTS_PATCH_V1",
(
"// RAW_SCORE_MCTS_PATCH_V1\n"
" // LONELY_SAFETY_PATCH_V2"
),
label="加入 V2 版本標記",
)
# --------------------------------------------------------------
# 2. 降低先前過高的 UCT 常數。
#
# 原本直接乘以 12 會令 exploration bonus 經常高達十幾分，
# 足以蓋過一般孤獨數扣分。
#
# 以下是較保守的原始分差尺度初始值。
# --------------------------------------------------------------
uct_pattern = re.compile(
r""" const UCT_RAW_SCORE_SCALE = 12;
const UCT_EXPLORATION_PLACE =
1\.08 \* UCT_RAW_SCORE_SCALE;
const UCT_EXPLORATION_EXTRACT =
1\.14 \* UCT_RAW_SCORE_SCALE;
const UCT_PRIOR_BIAS =
0\.18 \* UCT_RAW_SCORE_SCALE;
"""
)
uct_replacement = """ // LONELY_SAFETY_PATCH_V2
//
// 原始分差模式下不再直接把舊常數乘以 12。
// 過高的 exploration bonus 會蓋過 1～數分的直接損失。
const UCT_EXPLORATION_PLACE = 3.20;
const UCT_EXPLORATION_EXTRACT = 3.40;
const UCT_PRIOR_BIAS = 0.60;
"""
text, uct_count = uct_pattern.subn(
uct_replacement,
text,
count=1,
)
if uct_count != 1:
raise RuntimeError(
"找不到上一版的 UCT 常數區塊。"
)
# --------------------------------------------------------------
# 3. 根節點完整套用安全過濾。
#
# makeRootPlacementPool 不再把所有孤獨數變化都優先加入，
# 而是：
#
# - 有安全棋時刪掉直接送分棋；
# - 所有棋都不好時保留傷害最小者；
# - 只優先有利的孤獨數戰術。
# --------------------------------------------------------------
old_root_pool = """ // ROOT_LONELY_STATE_CANDIDATES_V1
//
// 根節點保留完整合法行動，不再預先刪除立即形成己方
// 孤獨數的走法。這些走法應由原始分差自行反映扣分。
//
// 所有會令任何非零棋子的孤獨數狀態發生變化的走法，
// 都會加入 lonelyChanges，並在普通隨機候選之前展開。
function makeRootPlacementPool(state) {
const pool = makePlacementPool(state);
if (pool.remaining <= 0) {
return pool;
}
pool.lonelyChanges =
buildLonelyStateChangingActions(
state,
pool
);
pool.lonelyChangeTotal =
pool.lonelyChanges.length;
return pool;
}
"""
new_root_pool = """ // ROOT_LONELY_SAFETY_POLICY_V2
//
// 根節點先分析每一手合法落子的即時分數及孤獨數變化。
//
// 只要存在安全走法，就硬性排除：
// 1. 立即製造根玩家孤獨數的走法；
// 2. 目前棋盤分差立即下降的走法。
//
// 如果所有合法走法都不好，則只保留製造己方孤獨數
// 最少、並且立即損失最小的走法。
function makeRootPlacementPool(state) {
const pool = makePlacementPool(state);
if (pool.remaining <= 0) {
return pool;
}
applyRootPlacementSafetyPolicy(
state,
pool,
state.turn
);
return pool;
}
"""
text = replace_once(
text,
old_root_pool,
new_root_pool,
label="改寫根節點 placement pool",
)
# --------------------------------------------------------------
# 4. 以精確的落子效果分析取代單純 Boolean 判斷。
# --------------------------------------------------------------
helper_start = (
" // 判斷一手落子是否會改變任一非零棋子的孤獨數狀態。"
)
helper_end = (
" function priorFromPlacementHeuristic(heuristic, tacticalBonus) {"
)
new_helpers = r""" // 取得棋盤上一枚非零數字棋的孤獨數狀態。
//
// 叉零不屬於孤獨數，因此回傳 null。
function numberedLonelyStatus(
board,
index
) {
if (
index < 0 ||
index >= SIZE
) {
return null;
}
const code = board[index];
if (!code) {
return null;
}
const type = tileType(code);
if (TRI[type] <= 0) {
return null;
}
return {
owner: ((code - 1) >> 4) & 1,
lonely: isLonelyAt(
board,
index
)
};
}
// 分析一手落子造成的立即分數及孤獨數變化。
//
// immediateDelta 永遠使用 rootPlayer 視角：
// 正數：對根玩家立即有利
// 負數：對根玩家立即不利
//
// 只需要檢查落子格及上下左右鄰格，因為其他棋子的
// 孤獨狀態不可能被這一步直接改變。
function placementImmediateEffect(
state,
action,
rootPlayer,
knownBeforeScore = null
) {
if (
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
state.board[action.i]
) {
return null;
}
const orient =
action._o !== undefined
? action._o
: orientationId(
action.t,
action.r
);
const row = Math.floor(
action.i / N
);
const col = action.i % N;
const affected = [action.i];
for (
let direction = 0;
direction < 4;
direction++
) {
const nextRow =
row + D4[direction][0];
const nextCol =
col + D4[direction][1];
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
affected.push(
nextRow * N + nextCol
);
}
const beforeStatuses =
affected.map(
index =>
numberedLonelyStatus(
state.board,
index
)
);
const beforeScore =
Number.isFinite(
knownBeforeScore
)
? knownBeforeScore
: regionScore(
state.board
);
const previous =
state.board[action.i];
state.board[action.i] =
1 +
(state.turn << 4) +
orient;
try {
const afterScore =
regionScore(state.board);
let rootLonelyCreated = 0;
let rootLonelyResolved = 0;
let opponentLonelyCreated = 0;
let opponentLonelyResolved = 0;
let changesLonelyState = false;
for (
let index = 0;
index < affected.length;
index++
) {
const before =
beforeStatuses[index];
const after =
numberedLonelyStatus(
state.board,
affected[index]
);
const beforeOwner =
before
? before.owner
: -1;
const afterOwner =
after
? after.owner
: -1;
const beforeLonely =
Boolean(
before &&
before.lonely
);
const afterLonely =
Boolean(
after &&
after.lonely
);
if (
beforeOwner !== afterOwner ||
beforeLonely !== afterLonely
) {
if (
beforeLonely ||
afterLonely
) {
changesLonelyState = true;
}
}
// 新產生的根玩家孤獨數。
if (
afterOwner === rootPlayer &&
afterLonely &&
!(
beforeOwner === rootPlayer &&
beforeLonely
)
) {
rootLonelyCreated++;
}
// 被消除的根玩家孤獨數。
if (
beforeOwner === rootPlayer &&
beforeLonely &&
!(
afterOwner === rootPlayer &&
afterLonely
)
) {
rootLonelyResolved++;
}
// 新產生的對手孤獨數。
if (
afterOwner >= 0 &&
afterOwner !== rootPlayer &&
afterLonely &&
!(
beforeOwner === afterOwner &&
beforeLonely
)
) {
opponentLonelyCreated++;
}
// 被消除的對手孤獨數。
if (
beforeOwner >= 0 &&
beforeOwner !== rootPlayer &&
beforeLonely &&
!(
afterOwner === beforeOwner &&
afterLonely
)
) {
opponentLonelyResolved++;
}
}
return {
immediateDelta:
rootPerspectiveScore(
afterScore - beforeScore,
rootPlayer
),
beforeScore,
afterScore,
rootLonelyCreated,
rootLonelyResolved,
opponentLonelyCreated,
opponentLonelyResolved,
changesLonelyState
};
} finally {
state.board[action.i] =
previous;
}
}
// 安全走法必須同時符合：
//
// 1. 不直接製造根玩家的孤獨數；
// 2. 不令根玩家的即時分差下降。
function isSafeRootPlacementEffect(
effect
) {
return Boolean(
effect &&
effect.rootLonelyCreated === 0 &&
effect.immediateDelta >= 0
);
}
// 當沒有完全安全的走法時，選出傷害最小的一組。
//
// 第一優先：製造己方孤獨數最少。
// 第二優先：即時分差最高，也就是損失最小。
function leastHarmfulPlacementEntries(
entries
) {
if (!entries.length) {
return [];
}
let minimumCreated =
Infinity;
for (const entry of entries) {
minimumCreated = Math.min(
minimumCreated,
entry.effect.rootLonelyCreated
);
}
const leastLonelyEntries =
entries.filter(
entry =>
entry.effect.rootLonelyCreated ===
minimumCreated
);
let bestDelta = -Infinity;
for (
const entry of leastLonelyEntries
) {
bestDelta = Math.max(
bestDelta,
entry.effect.immediateDelta
);
}
return leastLonelyEntries.filter(
entry =>
entry.effect.immediateDelta >=
bestDelta - 1e-9
);
}
// 從分析結果中選出根節點允許搜尋的走法。
function allowedRootPlacementEntries(
entries
) {
const safeEntries =
entries.filter(
entry =>
isSafeRootPlacementEffect(
entry.effect
)
);
if (safeEntries.length) {
return safeEntries;
}
return leastHarmfulPlacementEntries(
entries
);
}
// 判斷這一步是否屬於值得優先搜尋的有利孤獨數戰術。
//
// 必須：
// - 即時分差為正；
// - 沒有製造己方孤獨數；
// - 消除己方孤獨數，或製造對方孤獨數；
// - 沒有幫對方消除孤獨數。
function isBeneficialLonelyTactic(
effect
) {
return Boolean(
effect &&
effect.immediateDelta > 0 &&
effect.rootLonelyCreated === 0 &&
effect.opponentLonelyResolved === 0 &&
(
effect.rootLonelyResolved > 0 ||
effect.opponentLonelyCreated > 0
)
);
}
// 對一般 action 陣列套用根節點安全規則。
//
// alpha-beta 根搜尋也使用此函式。
function filterRootPlacementActions(
state,
actions,
rootPlayer
) {
if (
!Array.isArray(actions) ||
!actions.length
) {
return [];
}
const beforeScore =
regionScore(state.board);
const entries = [];
for (const action of actions) {
if (
!action ||
action.kind !== 'place'
) {
entries.push({
action,
effect: {
immediateDelta: 0,
rootLonelyCreated: 0,
rootLonelyResolved: 0,
opponentLonelyCreated: 0,
opponentLonelyResolved: 0,
changesLonelyState: false
}
});
continue;
}
const effect =
placementImmediateEffect(
state,
action,
rootPlayer,
beforeScore
);
if (!effect) {
continue;
}
action._rootImmediateDelta =
effect.immediateDelta;
action._rootLonelyCreated =
effect.rootLonelyCreated;
entries.push({
action,
effect
});
}
return allowedRootPlacementEntries(
entries
).map(
entry => entry.action
);
}
// 對 MCTS 根節點的 bit-pool 套用相同安全規則。
//
// 被判定為不允許的走法會直接由根節點 pool 移除，
// 所以它們不可能成為最後輸出的根節點行動。
function applyRootPlacementSafetyPolicy(
state,
pool,
rootPlayer
) {
const beforeScore =
regionScore(state.board);
const entries = [];
for (
let orient = 0;
orient < ORIENT_COUNT;
orient++
) {
forEachPairBit(
pool.lo[orient],
pool.hi[orient],
index => {
const action = {
kind: 'place',
i: index,
t: ORIENT_TYPE[orient],
r: ORIENT_ROT[orient],
_o: orient
};
const effect =
placementImmediateEffect(
state,
action,
rootPlayer,
beforeScore
);
if (!effect) {
return;
}
action._rootImmediateDelta =
effect.immediateDelta;
action._rootLonelyCreated =
effect.rootLonelyCreated;
entries.push({
action,
effect
});
}
);
}
const allowedEntries =
allowedRootPlacementEntries(
entries
);
const allowedKeys =
new Set(
allowedEntries.map(
entry =>
entry.action._o *
SIZE +
entry.action.i
)
);
// 將不安全根走法直接從 bit-pool 刪除。
for (const entry of entries) {
const key =
entry.action._o *
SIZE +
entry.action.i;
if (!allowedKeys.has(key)) {
poolRemoveAction(
pool,
entry.action
);
}
}
// 只優先有利的孤獨數戰術。
const beneficial = [];
for (
const entry of allowedEntries
) {
if (
!isBeneficialLonelyTactic(
entry.effect
)
) {
continue;
}
if (
!poolHasAction(
pool,
entry.action
)
) {
continue;
}
const heuristic =
localPlacementHeuristic(
state,
entry.action
);
entry.action._rootLonelyHeuristic =
heuristic;
// 陣列稍後以 pop() 取出，因此由低到高排序。
entry.action._rootLonelyOrder =
entry.effect.immediateDelta *
1000 +
heuristic +
Math.random() * 0.001;
beneficial.push(
entry.action
);
}
beneficial.sort(
(first, second) =>
first._rootLonelyOrder -
second._rootLonelyOrder
);
pool.lonelyChanges =
beneficial;
pool.lonelyChangeTotal =
beneficial.length;
}
"""
text = replace_between(
text,
helper_start,
helper_end,
new_helpers,
label="改寫孤獨數效果分析",
)
# --------------------------------------------------------------
# 5. 落子階段必須從目前棋盤即時計分。
#
# state.ps 在落子階段不一定已經更新，不能用來判斷新產生的
# 孤獨數扣分。
# --------------------------------------------------------------
old_placement_evaluation = """ function placementEvaluation(
state,
rootPlayer
) {
return rootPerspectiveScore(
state.ps,
rootPlayer
);
}
"""
new_placement_evaluation = """ function placementEvaluation(
state,
rootPlayer
) {
// LONELY_SAFETY_PATCH_V2
//
// state.ps 在落子階段可能仍是舊值，因此必須直接從目前
// 棋盤重新計算，令 rollout 截止時也能看到孤獨數扣分。
const currentScore =
regionScore(state.board);
return rootPerspectiveScore(
currentScore,
rootPlayer
);
}
"""
text = replace_once(
text,
old_placement_evaluation,
new_placement_evaluation,
label="改寫 placementEvaluation",
)
# --------------------------------------------------------------
# 6. 更新優先候選註解。
# --------------------------------------------------------------
old_priority_comment = """ // 根節點首先展開所有會改變孤獨數狀態的合法走法。
// poolRemoveAction 令它們不會在後面的普通抽樣中重複出現。
"""
new_priority_comment = """ // 根節點首先展開已通過安全檢查、而且對根玩家有利的
// 孤獨數戰術。直接製造己方孤獨數的走法不會進入此陣列。
// poolRemoveAction 令它們不會在後面的普通抽樣中重複出現。
"""
text = replace_once(
text,
old_priority_comment,
new_priority_comment,
label="更新根節點優先候選註解",
)
# --------------------------------------------------------------
# 7. 更新 progressive widening 註解及語意。
# --------------------------------------------------------------
old_pool_comment = """ // 只有根節點會填入此陣列。
// 其中包含所有會改變任一非零棋子孤獨數狀態的走法。
lonelyChanges: null,
lonelyChangeTotal: 0
"""
new_pool_comment = """ // 只有根節點會填入此陣列。
// V2 只保存通過安全檢查且立即有利的孤獨數戰術。
lonelyChanges: null,
lonelyChangeTotal: 0
"""
text = replace_once(
text,
old_pool_comment,
new_pool_comment,
label="更新 placement pool 註解",
)
# --------------------------------------------------------------
# 8. alpha-beta 根節點套用相同安全規則。
# --------------------------------------------------------------
text = patch_alpha_beta_root_safety(text)
# --------------------------------------------------------------
# 9. 更新 prepareNode 註解。
# --------------------------------------------------------------
old_prepare_comment = """ // 根節點使用完整合法池，並另外強制排入所有
// 會改變孤獨數狀態的候選；內部節點維持一般抽樣。
"""
new_prepare_comment = """ // 根節點先硬性排除可避免的直接送分棋，再優先排入
// 有利的孤獨數戰術；內部節點維持一般完整規則抽樣。
"""
text = replace_once(
text,
old_prepare_comment,
new_prepare_comment,
label="更新 prepareNode 註解",
)
# --------------------------------------------------------------
# 10. 驗證重要修正全部存在。
# --------------------------------------------------------------
required_fragments = [
"LONELY_SAFETY_PATCH_V2",
"ROOT_LONELY_SAFETY_POLICY_V2",
"function placementImmediateEffect(",
"function isSafeRootPlacementEffect(",
"function filterRootPlacementActions(",
"function applyRootPlacementSafetyPolicy(",
"function isBeneficialLonelyTactic(",
"const currentScore =\n regionScore(state.board);",
"ALPHA_BETA_ROOT_SAFETY_V2",
"const UCT_EXPLORATION_PLACE = 3.20;",
"const UCT_EXPLORATION_EXTRACT = 3.40;",
"const UCT_PRIOR_BIAS = 0.60;",
]
for fragment in required_fragments:
if fragment not in text:
raise RuntimeError(
"修改後缺少必要內容："
f"{fragment}"
)
forbidden_fragments = [
"buildLonelyStateChangingActions(",
"function placementChangesLonelyState(",
"return rootPerspectiveScore(\n state.ps,",
"1.08 * UCT_RAW_SCORE_SCALE",
"1.14 * UCT_RAW_SCORE_SCALE",
"0.18 * UCT_RAW_SCORE_SCALE",
"Math.tanh(",
]
for fragment in forbidden_fragments:
if fragment in text:
raise RuntimeError(
"修改後仍殘留舊邏輯："
f"{fragment}"
)
# 確認上一版的重要修正仍然存在。
inherited_requirements = [
"function rootPerspectiveScore(",
"RAW_FORFEIT_SCORE",
"rootPlacementCandidateTarget(",
"context.rootPlacementSampleSize",
"mode === 'tree'\n ? 0.01\n : 0.06",
"node.value += result;",
]
for fragment in inherited_requirements:
if fragment not in text:
raise RuntimeError(
"上一版的重要修改不存在："
f"{fragment}"
)
return text
def main() -> None:
parser = argparse.ArgumentParser(
description=(
"修正 Battle Number AI 的孤獨數即時計分、"
"根節點安全過濾及 alpha-beta 安全選棋。"
)
)
parser.add_argument(
"input",
nargs="?",
default="battlenumber245.html",
help=(
"輸入 HTML，預設為 "
"battlenumber245.html"
),
)
parser.add_argument(
"output",
nargs="?",
default="battlenumber246.html",
help=(
"輸出 HTML，預設為 "
"battlenumber246.html"
),
)
args = parser.parse_args()
input_path = Path(args.input)
output_path = Path(args.output)
if not input_path.is_file():
raise SystemExit(
f"找不到輸入檔案：{input_path}"
)
try:
source = input_path.read_text(
encoding="utf-8"
)
except UnicodeDecodeError as error:
raise SystemExit(
"輸入檔案不是有效的 UTF-8："
f"{input_path}"
) from error
try:
patched = patch_html(source)
except RuntimeError as error:
raise SystemExit(
f"修改失敗：{error}"
) from error
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
if (
input_path.resolve()
== output_path.resolve()
):
backup_path = input_path.with_suffix(
input_path.suffix + ".bak"
)
shutil.copy2(
input_path,
backup_path,
)
print(
f"已建立備份：{backup_path}"
)
output_path.write_text(
patched,
encoding="utf-8",
newline="\n",
)
print(f"修改完成：{output_path}")
print()
print("已套用以下修正：")
print(
" 1. placementEvaluation 改用目前棋盤的 "
"regionScore"
)
print(
" 2. 精確分析落子前後的孤獨數狀態"
)
print(
" 3. 區分己方／對方的孤獨數建立與消除"
)
print(
" 4. 有安全棋時硬性排除直接製造己方孤獨數的棋"
)
print(
" 5. 有安全棋時硬性排除立即負分棋"
)
print(
" 6. 所有棋都不好時只保留傷害最小的走法"
)
print(
" 7. 只優先展開有利的孤獨數戰術"
)
print(
" 8. alpha-beta 根節點使用相同安全規則"
)
print(
" 9. 降低過高的 UCT exploration constant"
)
print(
" 10. 保留原始分差及根玩家視角 backpropagation"
)
if __name__ == "__main__":
main()將腳本儲存為：
text
patch_battlenumber_lonely_safety.py然後和 battlenumber245.html 放在同一個目錄執行：
bash
python patch_battlenumber_lonely_safety.py會產生：
text
battlenumber246.html也可以指定輸入及輸出檔名：
bash
python patch_battlenumber_lonely_safety.py battlenumber245.html battlenumber246.html這個版本的關鍵不是單純替孤獨數增加一個負權重，而是直接在 MCTS 和 alpha-beta 的根節點建立硬性安全邊界：只要存在不製造己方孤獨數且不立即失分的合法走法，直接送分的棋就不會進入最終候選集合。
提问者QuanAI我會先定位 246 版中的落子安全檢查、得分判定、候選步過濾及 MCTS/rollout 入口，然後依現有程式結構製作可重複執行的 Python 補丁腳本。
下面的 Python 腳本會把 battlenumber246.html 修改為 battlenumber247.html。
主要改進：
- AI 落子後，模擬對方的下一手合法落子。
- 如果新落下的數字棋只剩一個開口，而且對方下一手能用「單一／雙二／角二／圍三」的實邊封住，使該棋成為孤獨數，便標記為「下一手送分」。
- 只要存在安全走法，MCTS 與 alpha-beta 都會硬性排除這類走法。
- 如果所有走法都不安全，依序選擇：
- 立即製造己方孤獨數最少；
- 下一手可能損失的孤獨數分值最小；
- 對方可用來封口的走法數最少；
- 當前即時分差最好。
- 主執行緒的備用 AI 也套用相同規則。
- AI 執行 Worker 結果前再做最後一次安全檢查。
- 不會一概禁止「圍三」；只有當其唯一開口確實能被對方下一手合法封閉時才排除。
將以下內容儲存為 patch_battlenumber_one_ply_lonely.py：
python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
為 battlenumber246.html 加入「對手下一手封口孤獨數」安全檢查。
預設：
輸入：battlenumber246.html
輸出：battlenumber247.html
用法：
python patch_battlenumber_one_ply_lonely.py
或：
python patch_battlenumber_one_ply_lonely.py \
battlenumber246.html \
battlenumber247.html
"""
from __future__ import annotations
import argparse
import sys
from pathlib import Path
PATCH_MARKER = "ONE_PLY_LONELY_REPLY_GUARD_V1"
def replace_once(
text: str,
old: str,
new: str,
label: str,
) -> str:
count = text.count(old)
if count != 1:
raise RuntimeError(
f"{label}：預期找到 1 個替換位置，實際找到 {count} 個。"
"請確認輸入檔案是未套用本補丁的 battlenumber246.html。"
)
return text.replace(old, new, 1)
def replace_exact_count(
text: str,
old: str,
new: str,
expected_count: int,
label: str,
) -> str:
count = text.count(old)
if count != expected_count:
raise RuntimeError(
f"{label}：預期找到 {expected_count} 個替換位置，"
f"實際找到 {count} 個。"
)
return text.replace(old, new)
def patch_html(source: str) -> str:
# ------------------------------------------------------------------
# 0. 加入版本標記
# ------------------------------------------------------------------
source = replace_once(
source,
""" <!-- RANDOMIZED_AI_ACTION_ORDER_PATCH_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
""" <!-- RANDOMIZED_AI_ACTION_ORDER_PATCH_V1 -->
<!-- ONE_PLY_LONELY_REPLY_GUARD_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
"加入補丁版本標記",
)
# ------------------------------------------------------------------
# 1. Worker：加入「對手下一手能否封住新棋」的精確檢查
#
# 使用現有 lonelyClosingInfo：
# - 新棋必須只剩一個真正開口；
# - 開口必須是空格；
# - 對手必須有庫存；
# - 對手落子必須符合實邊衝突及最後非叉零保留規則；
# - 叉零不算封口，因為叉零會取消孤獨數。
# ------------------------------------------------------------------
worker_threat_function = r"""
// ONE_PLY_LONELY_REPLY_GUARD_V1
//
// 檢查一手根節點落子之後，對方是否能在緊接的一手，
// 於新棋唯一剩餘的開口旁落下一枚合法非叉零棋，
// 從而令這枚新棋成為孤獨數。
//
// 此判定不是簡單地禁止所有只有一個開口的棋：
// 只有對方確實有庫存，而且該封口方向及位置符合全部
// 合法落子規則時，才視為下一手送分。
function nextReplyLonelyThreat(
state,
action
) {
const noThreat = {
value: 0,
replies: 0,
cell: -1
};
if (
!state ||
state.done ||
state.phase !== 'place' ||
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
state.board[action.i]
) {
return noThreat;
}
const orient =
action._o !== undefined
? action._o
: orientationId(
action.t,
action.r
);
const type = ORIENT_TYPE[orient];
const value = TRI[type];
// 叉零沒有數值，不屬於孤獨數威脅。
if (value <= 0) {
return noThreat;
}
// 如果這已是第 49 枚棋子，落子階段立即結束，
// 對方不再有下一手落子可以封閉它。
const totalAfter =
state.place0 +
state.place1 +
1;
if (totalAfter >= SIZE) {
return noThreat;
}
const child = cloneState(state);
applyPlacementInPlace(
child,
action
);
if (
child.done ||
child.phase !== 'place'
) {
return noThreat;
}
// lonelyClosingInfo 只在目標棋恰好剩下一個、
// 而且能由相鄰空格落子封閉的開口時回傳資料。
const closingInfo =
lonelyClosingInfo(
child,
action.i
);
if (!closingInfo) {
return noThreat;
}
// 使用下一手行動方的完整合法落子池。
// 這會包含庫存、方向、實邊衝突，以及後手最後一枚
// 非叉零必須保留等規則。
const replyPool =
makePlacementPool(child);
if (replyPool.remaining <= 0) {
return noThreat;
}
let replies = 0;
// 叉零不能用作孤獨數封口：
// 若開口與叉零相鄰，規則上反而不算孤獨數。
for (
let replyOrient = 0;
replyOrient < CROSS_ORIENT;
replyOrient++
) {
if (
!(
EDGE_MASK[replyOrient] &
(
1 <<
closingInfo.requiredEdge
)
)
) {
continue;
}
if (
arrayHasBit(
replyPool.lo,
replyPool.hi,
replyOrient,
closingInfo.cell
)
) {
replies++;
}
}
return {
value:
replies > 0
? value
: 0,
replies,
cell:
replies > 0
? closingInfo.cell
: -1
};
}
"""
source = replace_once(
source,
""" // ROOT_LONELY_SAFETY_POLICY_V2""",
worker_threat_function
+ """ // ROOT_LONELY_SAFETY_POLICY_V2""",
"插入 Worker 下一手孤獨數威脅函式",
)
# ------------------------------------------------------------------
# 2. Worker：placementImmediateEffect 同時計算下一手威脅
# ------------------------------------------------------------------
source = replace_once(
source,
""" const row = Math.floor(
action.i / N
);""",
""" const nextReplyThreat =
nextReplyLonelyThreat(
state,
action
);
const row = Math.floor(
action.i / N
);""",
"在 Worker 落子效果分析中計算下一手威脅",
)
source = replace_once(
source,
""" opponentLonelyResolved,
changesLonelyState
};""",
""" opponentLonelyResolved,
changesLonelyState,
// 新落下的棋是否能被對方下一手合法封成孤獨數。
nextReplyLonelyValue:
nextReplyThreat.value,
// 對方有多少種合法的「方向＋棋種」封口方式。
nextReplyLonelyReplies:
nextReplyThreat.replies
};""",
"把下一手威脅加入 Worker effect",
)
# 非 placement action 的預設 effect 也補齊欄位。
source = replace_once(
source,
""" opponentLonelyResolved: 0,
changesLonelyState: false
}""",
""" opponentLonelyResolved: 0,
changesLonelyState: false,
nextReplyLonelyValue: 0,
nextReplyLonelyReplies: 0
}""",
"補齊非落子 action 的預設威脅欄位",
)
# ------------------------------------------------------------------
# 3. Worker：安全走法必須同時沒有「下一手封口」
# ------------------------------------------------------------------
source = replace_once(
source,
""" effect &&
effect.rootLonelyCreated === 0 &&
effect.immediateDelta >= 0
);""",
""" effect &&
effect.rootLonelyCreated === 0 &&
effect.immediateDelta >= 0 &&
effect.nextReplyLonelyValue === 0
);""",
"更新 Worker 根節點安全條件",
)
# ------------------------------------------------------------------
# 4. Worker：若全部走法都不安全，加入下一手威脅的最小傷害排序
# ------------------------------------------------------------------
old_least_harmful = """ const leastLonelyEntries =
entries.filter(
entry =>
entry.effect.rootLonelyCreated ===
minimumCreated
);
let bestDelta = -Infinity;
for (
const entry of leastLonelyEntries
) {
bestDelta = Math.max(
bestDelta,
entry.effect.immediateDelta
);
}
return leastLonelyEntries.filter(
entry =>
entry.effect.immediateDelta >=
bestDelta - 1e-9
);"""
new_least_harmful = """ const leastLonelyEntries =
entries.filter(
entry =>
entry.effect.rootLonelyCreated ===
minimumCreated
);
// 在直接製造己方孤獨數數量相同時，
// 優先選擇不會在下一手損失高分數字棋的走法。
let minimumReplyValue = Infinity;
for (
const entry of leastLonelyEntries
) {
minimumReplyValue = Math.min(
minimumReplyValue,
Number(
entry.effect
.nextReplyLonelyValue
) || 0
);
}
const leastReplyValueEntries =
leastLonelyEntries.filter(
entry =>
(
Number(
entry.effect
.nextReplyLonelyValue
) || 0
) === minimumReplyValue
);
// 若被封後損失分值相同，令對方可用的封口方式越少越好。
let minimumReplyCount = Infinity;
for (
const entry of
leastReplyValueEntries
) {
minimumReplyCount = Math.min(
minimumReplyCount,
Number(
entry.effect
.nextReplyLonelyReplies
) || 0
);
}
const leastReplyEntries =
leastReplyValueEntries.filter(
entry =>
(
Number(
entry.effect
.nextReplyLonelyReplies
) || 0
) === minimumReplyCount
);
let bestDelta = -Infinity;
for (
const entry of leastReplyEntries
) {
bestDelta = Math.max(
bestDelta,
entry.effect.immediateDelta
);
}
return leastReplyEntries.filter(
entry =>
entry.effect.immediateDelta >=
bestDelta - 1e-9
);"""
source = replace_once(
source,
old_least_harmful,
new_least_harmful,
"更新 Worker 最小傷害排序",
)
# 將威脅資料也放在 action 上，便於除錯及根節點排序檢查。
source = replace_exact_count(
source,
""" action._rootLonelyCreated =
effect.rootLonelyCreated;
entries.push({""",
""" action._rootLonelyCreated =
effect.rootLonelyCreated;
action._rootNextReplyLonelyValue =
effect.nextReplyLonelyValue;
action._rootNextReplyLonelyReplies =
effect.nextReplyLonelyReplies;
entries.push({""",
2,
"把下一手威脅資料保存至根節點 action",
)
# ------------------------------------------------------------------
# 5. 主執行緒：加入與 Worker 相同的局部封口判定
#
# 主要供：
# - Worker 建立失敗時的 fallbackAction；
# - Worker 回傳後的最後安全檢查。
# ------------------------------------------------------------------
main_thread_helpers = r"""
// ONE_PLY_LONELY_REPLY_GUARD_V1_MAIN
//
// 若指定數字棋目前恰好只剩一個可由相鄰空格封閉的開口，
// 回傳封口格及封口棋朝向目標棋所需要的實邊方向。
function lonelyClosingInfoMain(
board,
target
) {
if (
!Array.isArray(board) ||
!Number.isInteger(target) ||
target < 0 ||
target >= SIZE
) {
return null;
}
const tile = board[target];
if (
!tile ||
TRIANGLES[tile.type] <= 0
) {
return null;
}
const row = Math.floor(
target / N
);
const col = target % N;
let openCount = 0;
let openCell = -1;
let openDirection = -1;
for (
let direction = 0;
direction < DIRECTIONS.length;
direction++
) {
const nextRow =
row +
DIRECTIONS[direction][0];
const nextCol =
col +
DIRECTIONS[direction][1];
// 棋盤邊界本身是封閉邊。
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
const next =
nextRow * N + nextCol;
const neighbour =
board[next];
const selfEdge =
tileHasEdge(
tile,
direction
);
// 開口若由叉零封住，規則上不算孤獨數，
// 所以不能當成對方可得分的封口目標。
if (
neighbour &&
neighbour.type === TYPE_CROSS &&
!selfEdge
) {
return null;
}
const neighbourEdge =
neighbour &&
tileHasEdge(
neighbour,
(direction + 2) & 3
);
if (
!selfEdge &&
!neighbourEdge
) {
openCount++;
if (openCount > 1) {
return null;
}
openDirection = direction;
if (!neighbour) {
openCell = next;
} else {
// 開口格已被棋子佔據，下一手不能在此落子封閉。
openCell = -1;
}
}
}
if (
openCount !== 1 ||
openCell < 0
) {
return null;
}
return {
cell: openCell,
// 從封口格看向目標棋所需要的實邊方向。
requiredEdge:
(openDirection + 2) & 3
};
}
// 檢查 action 落下之後，對方是否存在一手合法封口，
// 能令 action 新落下的棋立即成為孤獨數。
function nextReplyLonelyThreatMain(
gameState,
action
) {
const noThreat = {
value: 0,
replies: 0,
cell: -1
};
if (
!gameState ||
gameState.status !== 'playing' ||
gameState.phase !== 'place' ||
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
gameState.board[action.i] ||
action.t === TYPE_CROSS ||
TRIANGLES[action.t] <= 0
) {
return noThreat;
}
const totalAfter =
gameState.placementCount[0] +
gameState.placementCount[1] +
1;
// 第 49 枚落下後直接進入提子，沒有對方下一手落子。
if (totalAfter >= SIZE) {
return noThreat;
}
const player = gameState.turn;
const opponent = 1 - player;
const board =
gameState.board.slice();
board[action.i] = {
player,
type: action.t,
rot: action.r
};
const closingInfo =
lonelyClosingInfoMain(
board,
action.i
);
if (!closingInfo) {
return noThreat;
}
const inventories =
gameState.inventories.map(
row => row.slice()
);
inventories[player][action.t]--;
const placementCount =
gameState.placementCount.slice();
placementCount[player]++;
// 建立只供合法性檢查使用的下一手局面。
const childState = {
...gameState,
board,
inventories,
placementCount,
phase: 'place',
turn: opponent,
status: 'playing'
};
let replies = 0;
// 叉零不能成為得分封口，因為它會取消孤獨數。
for (
let type = 0;
type < TYPE_CROSS;
type++
) {
if (
childState
.inventories[opponent][type] <= 0
) {
continue;
}
for (
const rotation of
UNIQUE_ROTATIONS[type]
) {
const replyTile = {
player: opponent,
type,
rot: rotation
};
if (
!tileHasEdge(
replyTile,
closingInfo.requiredEdge
)
) {
continue;
}
if (
!validatePlacement(
childState,
opponent,
type,
rotation,
closingInfo.cell
)
) {
replies++;
}
}
}
return {
value:
replies > 0
? TRIANGLES[action.t]
: 0,
replies,
cell:
replies > 0
? closingInfo.cell
: -1
};
}
// 主執行緒版根節點安全過濾。
//
// fallbackAction 不能只看落子後的當前分數，
// 否則 Worker 發生錯誤時仍可能選出下一手送分棋。
function filterRootPlacementActionsMain(
gameState,
actions
) {
if (
!Array.isArray(actions) ||
!actions.length
) {
return [];
}
const rootPlayer =
gameState.turn;
const beforeScore =
calculatePlacementScore(
gameState.board
);
const entries = [];
for (const action of actions) {
if (
!action ||
action.kind !== 'place'
) {
continue;
}
const board =
gameState.board.slice();
board[action.i] = {
player: rootPlayer,
type: action.t,
rot: action.r
};
const afterScore =
calculatePlacementScore(
board
);
const immediateDelta =
rootPlayer === 0
? afterScore - beforeScore
: beforeScore - afterScore;
const rootLonelyCreated =
placementCreatesOwnLonelyNumberMain(
gameState,
action
)
? 1
: 0;
const replyThreat =
nextReplyLonelyThreatMain(
gameState,
action
);
entries.push({
action,
immediateDelta,
rootLonelyCreated,
nextReplyLonelyValue:
replyThreat.value,
nextReplyLonelyReplies:
replyThreat.replies
});
}
if (!entries.length) {
return [];
}
// 完全安全：
// 1. 不立即製造己方孤獨數；
// 2. 不令當前分差下降；
// 3. 對方下一手不能把新棋封成孤獨數。
const safeEntries =
entries.filter(
entry =>
entry.rootLonelyCreated === 0 &&
entry.immediateDelta >= 0 &&
entry.nextReplyLonelyValue === 0
);
if (safeEntries.length) {
return safeEntries.map(
entry => entry.action
);
}
// 若沒有完全安全的走法，使用與 Worker 相同的
// 最小傷害優先次序。
let minimumCreated = Infinity;
for (const entry of entries) {
minimumCreated = Math.min(
minimumCreated,
entry.rootLonelyCreated
);
}
const leastCreatedEntries =
entries.filter(
entry =>
entry.rootLonelyCreated ===
minimumCreated
);
let minimumReplyValue = Infinity;
for (
const entry of
leastCreatedEntries
) {
minimumReplyValue = Math.min(
minimumReplyValue,
entry.nextReplyLonelyValue
);
}
const leastReplyValueEntries =
leastCreatedEntries.filter(
entry =>
entry.nextReplyLonelyValue ===
minimumReplyValue
);
let minimumReplyCount = Infinity;
for (
const entry of
leastReplyValueEntries
) {
minimumReplyCount = Math.min(
minimumReplyCount,
entry.nextReplyLonelyReplies
);
}
const leastReplyEntries =
leastReplyValueEntries.filter(
entry =>
entry.nextReplyLonelyReplies ===
minimumReplyCount
);
let bestDelta = -Infinity;
for (
const entry of leastReplyEntries
) {
bestDelta = Math.max(
bestDelta,
entry.immediateDelta
);
}
return leastReplyEntries
.filter(
entry =>
entry.immediateDelta >=
bestDelta - 1e-9
)
.map(
entry => entry.action
);
}
"""
source = replace_once(
source,
""" function calculateLeftoverLonelyScore(inventories, firstPlayer) {""",
main_thread_helpers
+ """ function calculateLeftoverLonelyScore(inventories, firstPlayer) {""",
"插入主執行緒下一手孤獨數安全函式",
)
# ------------------------------------------------------------------
# 6. 主執行緒 fallback：先套用完整根節點安全過濾
# ------------------------------------------------------------------
source = replace_once(
source,
""" // fallback 保留完整合法行動。
// 孤獨數造成的得失由下面的實際分數比較決定。
const actions = allActions;
// 主執行緒使用獨立的 Fisher-Yates shuffle。""",
""" // fallback 也必須套用與 Worker 相同的根節點安全規則：
// 不只排除立即孤獨數，也排除對方下一手能封住新棋的走法。
const filteredActions =
filterRootPlacementActionsMain(
state,
allActions
);
const actions =
filteredActions.length
? filteredActions
: allActions;
// 主執行緒使用獨立的 Fisher-Yates shuffle。""",
"更新 fallbackAction 根節點安全過濾",
)
# ------------------------------------------------------------------
# 7. AI 執行 Worker 結果前，再檢查一次
#
# 正常情況下 Worker 已經排除威脅走法。這一層是保險：
# 若舊 Worker、瀏覽器 Worker 異常或其他分支回傳了危險走法，
# 主執行緒會改用安全 fallback。
# ------------------------------------------------------------------
source = replace_once(
source,
""" }
if (action.kind === 'place') {
commitPlacement(action, 2100);""",
""" }
// ONE_PLY_LONELY_REPLY_GUARD_V1_FINAL_CHECK
//
// Worker 正常情況下已經做過相同檢查。
// 此處作為執行前的最後保險，避免合法但會在下一手
// 被對方封成孤獨數的行動直接進入棋盤。
if (
action &&
action.kind === 'place'
) {
const createsImmediateLonely =
placementCreatesOwnLonelyNumberMain(
state,
action
);
const replyThreat =
nextReplyLonelyThreatMain(
state,
action
);
if (
createsImmediateLonely ||
replyThreat.value > 0
) {
const saferAction =
fallbackAction();
if (
saferAction &&
actionIsLegal(saferAction)
) {
action = saferAction;
}
}
}
if (action.kind === 'place') {
commitPlacement(action, 2100);""",
"加入 AI 行動執行前的最後安全檢查",
)
# ------------------------------------------------------------------
# 8. 基本結果驗證
# ------------------------------------------------------------------
required_fragments = [
"<!-- ONE_PLY_LONELY_REPLY_GUARD_V1 -->",
"function nextReplyLonelyThreat(",
"effect.nextReplyLonelyValue === 0",
"function lonelyClosingInfoMain(",
"function nextReplyLonelyThreatMain(",
"function filterRootPlacementActionsMain(",
"ONE_PLY_LONELY_REPLY_GUARD_V1_FINAL_CHECK",
]
missing = [
fragment
for fragment in required_fragments
if fragment not in source
]
if missing:
raise RuntimeError(
"補丁完成後驗證失敗，缺少以下內容：\n - "
+ "\n - ".join(missing)
)
return source
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description=(
"為 Battle Number 246 版加入"
"「對手下一手封口孤獨數」AI 安全補丁。"
)
)
parser.add_argument(
"input",
nargs="?",
default="battlenumber246.html",
help="輸入 HTML，預設為 battlenumber246.html",
)
parser.add_argument(
"output",
nargs="?",
default="battlenumber247.html",
help="輸出 HTML，預設為 battlenumber247.html",
)
return parser.parse_args()
def main() -> int:
args = parse_args()
input_path = Path(args.input)
output_path = Path(args.output)
if not input_path.is_file():
print(
f"錯誤：找不到輸入檔案：{input_path}",
file=sys.stderr,
)
return 1
try:
source = input_path.read_text(
encoding="utf-8"
)
except Exception as error:
print(
f"錯誤：無法讀取輸入檔案：{error}",
file=sys.stderr,
)
return 1
# 可重複執行：如果已經套用，不再二次插入。
if PATCH_MARKER in source:
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
source,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print(
f"檔案已包含 {PATCH_MARKER}；"
f"未重複修改，已輸出至：{output_path}"
)
return 0
try:
patched = patch_html(source)
except Exception as error:
print(
f"補丁失敗：{error}",
file=sys.stderr,
)
return 1
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
patched,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print("補丁完成。")
print(f"輸入：{input_path}")
print(f"輸出：{output_path}")
print()
print("已加入以下保護：")
print(" 1. MCTS 根節點下一手封口檢查")
print(" 2. alpha-beta 根節點下一手封口檢查")
print(" 3. fallback AI 相同安全過濾")
print(" 4. Worker 結果執行前的最後安全檢查")
print(" 5. 無安全棋時使用最小傷害排序")
return 0
if __name__ == "__main__":
raise SystemExit(main())執行：
bash
python patch_battlenumber_one_ply_lonely.py battlenumber246.html battlenumber247.html此補丁針對的是「新落下的棋在當前並非孤獨數，但只剩一個開口，而且對方下一手能合法封口」的情況。比如「圍三」唯一開口前方是空格，而對方有一枚方向合適且能合法落在該格的「單一」，這手圍三便會從根節點候選中被排除。
提问者補丁失敗：把下一手威脅資料保存至根節點 action：預期找到 2 個替換位置，實際找到 1 個。
QuanAI這表示 battlenumber246.html 中該段程式實際只出現一次，而補丁錯誤地要求必須出現兩次。
這段修改只是把威脅資訊附加到根節點 action 供除錯或後續排序檢查；主要安全過濾仍然是透過 entry.effect.nextReplyLonelyValue 和 entry.effect.nextReplyLonelyReplies 執行，因此改成一次不會削弱核心防護。
請在 Python 補丁中找到：
python
source = replace_exact_count(
source,
""" action._rootLonelyCreated =
effect.rootLonelyCreated;
entries.push({""",
""" action._rootLonelyCreated =
effect.rootLonelyCreated;
action._rootNextReplyLonelyValue =
effect.nextReplyLonelyValue;
action._rootNextReplyLonelyReplies =
effect.nextReplyLonelyReplies;
entries.push({""",
2,
"把下一手威脅資料保存至根節點 action",
)改成：
python
source = replace_once(
source,
""" action._rootLonelyCreated =
effect.rootLonelyCreated;
entries.push({""",
""" action._rootLonelyCreated =
effect.rootLonelyCreated;
action._rootNextReplyLonelyValue =
effect.nextReplyLonelyValue;
action._rootNextReplyLonelyReplies =
effect.nextReplyLonelyReplies;
entries.push({""",
"把下一手威脅資料保存至根節點 action",
)也就是：
replace_exact_count改成replace_once- 刪除參數
2
然後重新執行：
bash
python patch_battlenumber_one_ply_lonely.py battlenumber246.html battlenumber247.html也可以採用兼容性更好的寫法，容許不同版本的 HTML 出現一次或兩次。把原區塊替換為：
python
root_action_anchor = """ action._rootLonelyCreated =
effect.rootLonelyCreated;
entries.push({"""
root_action_replacement = """ action._rootLonelyCreated =
effect.rootLonelyCreated;
action._rootNextReplyLonelyValue =
effect.nextReplyLonelyValue;
action._rootNextReplyLonelyReplies =
effect.nextReplyLonelyReplies;
entries.push({"""
root_action_anchor_count = source.count(
root_action_anchor
)
if root_action_anchor_count not in (1, 2):
raise RuntimeError(
"把下一手威脅資料保存至根節點 action："
"預期找到 1 或 2 個替換位置，"
f"實際找到 {root_action_anchor_count} 個。"
)
source = source.replace(
root_action_anchor,
root_action_replacement,
)推薦使用最後這個兼容版本，因為它同時適用於該定位點出現一次或兩次的 battlenumber246.html 變體。
提问者QuanAI問題的根源是上一版只檢查了：
- 新落下的己方棋是否立即成為孤獨數；
- 新落下的己方棋是否會被對方下一手封成孤獨數。
但沒有檢查：
己方這一步是否把兩個原本分離的開放區域連起來，使對方下一手能封閉一個包含雙方棋子的區域並立即得分。
下面的補丁會模擬候選落子後，對方的全部合法下一手落子，比較對方落子前後的實際區域分數。如果對方有任何下一手能立即令 AI 的分差下降，便把目前候選標記為「下一手送分」。
將以下內容儲存為 patch_battlenumber_reply_scoring.py：
python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
為 battlenumber247.html 加入「對方下一手立即區域得分」安全檢查。
預設：
輸入：battlenumber247.html
輸出：battlenumber248.html
用法：
python patch_battlenumber_reply_scoring.py
或：
python patch_battlenumber_reply_scoring.py \
battlenumber247.html \
battlenumber248.html
"""
from __future__ import annotations
import argparse
import sys
from pathlib import Path
PATCH_MARKER = "OPPONENT_REPLY_SCORING_GUARD_V1"
def replace_once(
text: str,
old: str,
new: str,
label: str,
) -> str:
count = text.count(old)
if count != 1:
raise RuntimeError(
f"{label}：預期找到 1 個替換位置，"
f"實際找到 {count} 個。"
)
return text.replace(old, new, 1)
def replace_section_once(
text: str,
start_marker: str,
end_marker: str,
new_section: str,
label: str,
) -> str:
start_count = text.count(start_marker)
if start_count != 1:
raise RuntimeError(
f"{label}：起始標記預期找到 1 個，"
f"實際找到 {start_count} 個。"
)
start = text.find(start_marker)
end = text.find(end_marker, start + len(start_marker))
if end < 0:
raise RuntimeError(
f"{label}：找不到結束標記。"
)
return (
text[:start]
+ new_section
+ text[end:]
)
def patch_html(source: str) -> str:
# --------------------------------------------------------------
# 0. 加入版本標記
# --------------------------------------------------------------
source = replace_once(
source,
""" <!-- ONE_PLY_LONELY_REPLY_GUARD_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
""" <!-- ONE_PLY_LONELY_REPLY_GUARD_V1 -->
<!-- OPPONENT_REPLY_SCORING_GUARD_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
"加入對方下一手得分補丁標記",
)
# --------------------------------------------------------------
# 1. Worker：模擬對方全部合法下一手，檢查是否能立即得分
# --------------------------------------------------------------
worker_reply_scoring_function = r"""
// OPPONENT_REPLY_SCORING_GUARD_V1
//
// 檢查目前候選落子之後，對方是否存在一手合法落子，
// 能令根玩家的實際區域分差立即下降。
//
// 這與 nextReplyLonelyThreat 不同：
//
// nextReplyLonelyThreat 只檢查新落下的棋本身是否會被封成
// 孤獨數；本函式會重新計算整個棋盤的區域分數，因此也能
// 找到以下情況：
//
// 己方棋的開口連到對方棋的開口，
// 對方下一手再封住另一端，
// 形成一個包含雙方棋子的完整得分區域。
function nextReplyScoringThreat(
state,
action,
rootPlayer
) {
const noThreat = {
loss: 0,
replies: 0,
cell: -1,
orient: -1
};
if (
!state ||
state.done ||
state.phase !== 'place' ||
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
state.board[action.i]
) {
return noThreat;
}
const child = cloneState(state);
applyPlacementInPlace(
child,
action
);
// 第 49 枚棋子落下後已進入提子階段，
// 對方沒有下一手落子。
if (
child.done ||
child.phase !== 'place'
) {
return noThreat;
}
const replyPool =
makePlacementPool(child);
if (replyPool.remaining <= 0) {
return noThreat;
}
const beforeReplyScore =
regionScore(child.board);
const replyPlayer = child.turn;
let maximumLoss = 0;
let threateningReplies = 0;
let bestCell = -1;
let bestOrient = -1;
// 若落子格四周完全沒有棋子，它不可能替對方封閉一個
// 已含有棋子的區域。這個快速判定能減少大量不必要的
// 全棋盤計分。
function cellCanAffectExistingScore(
index
) {
const row = Math.floor(index / N);
const col = index % N;
for (
let direction = 0;
direction < 4;
direction++
) {
const nextRow =
row + D4[direction][0];
const nextCol =
col + D4[direction][1];
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
if (
child.board[
nextRow * N + nextCol
]
) {
return true;
}
}
return false;
}
for (
let replyOrient = 0;
replyOrient < ORIENT_COUNT;
replyOrient++
) {
forEachPairBit(
replyPool.lo[replyOrient],
replyPool.hi[replyOrient],
replyCell => {
if (
!cellCanAffectExistingScore(
replyCell
)
) {
return;
}
const previous =
child.board[replyCell];
child.board[replyCell] =
1 +
(replyPlayer << 4) +
replyOrient;
let afterReplyScore;
try {
afterReplyScore =
regionScore(child.board);
} finally {
child.board[replyCell] =
previous;
}
const rootDelta =
rootPerspectiveScore(
afterReplyScore -
beforeReplyScore,
rootPlayer
);
// 負數表示這手回覆令根玩家分差下降，
// 也就是對方取得了立即利益。
if (rootDelta < -1e-9) {
const loss = -rootDelta;
threateningReplies++;
if (
loss >
maximumLoss + 1e-9
) {
maximumLoss = loss;
bestCell = replyCell;
bestOrient = replyOrient;
}
}
}
);
}
return {
loss: maximumLoss,
replies: threateningReplies,
cell: bestCell,
orient: bestOrient
};
}
"""
source = replace_once(
source,
""" // ROOT_LONELY_SAFETY_POLICY_V2""",
worker_reply_scoring_function
+ """ // ROOT_LONELY_SAFETY_POLICY_V2""",
"插入 Worker 對方下一手得分檢查",
)
# --------------------------------------------------------------
# 2. Worker：placementImmediateEffect 加入得分威脅
# --------------------------------------------------------------
source = replace_once(
source,
""" const nextReplyThreat =
nextReplyLonelyThreat(
state,
action
);
const row = Math.floor(""",
""" const nextReplyThreat =
nextReplyLonelyThreat(
state,
action
);
const nextReplyScoreThreat =
nextReplyScoringThreat(
state,
action,
rootPlayer
);
const row = Math.floor(""",
"在 Worker 落子效果中計算下一手區域得分威脅",
)
source = replace_once(
source,
""" // 對方有多少種合法的「方向＋棋種」封口方式。
nextReplyLonelyReplies:
nextReplyThreat.replies
};""",
""" // 對方有多少種合法的「方向＋棋種」封口方式。
nextReplyLonelyReplies:
nextReplyThreat.replies,
// 對方下一手合法落子最多能令根玩家損失多少分。
// 不限於孤獨數，也包括封閉多人混合區域。
nextReplyScoreLoss:
nextReplyScoreThreat.loss,
// 能令根玩家立即失分的對方合法回覆數。
nextReplyScoringReplies:
nextReplyScoreThreat.replies
};""",
"把下一手區域得分威脅加入 Worker effect",
)
# 非 placement action 的預設 effect 補齊欄位。
source = replace_once(
source,
""" nextReplyLonelyValue: 0,
nextReplyLonelyReplies: 0
}""",
""" nextReplyLonelyValue: 0,
nextReplyLonelyReplies: 0,
nextReplyScoreLoss: 0,
nextReplyScoringReplies: 0
}""",
"補齊 Worker 預設得分威脅欄位",
)
# --------------------------------------------------------------
# 3. Worker：完整安全走法不得讓對方下一手立即得分
# --------------------------------------------------------------
source = replace_once(
source,
""" effect.rootLonelyCreated === 0 &&
effect.immediateDelta >= 0 &&
effect.nextReplyLonelyValue === 0
);""",
""" effect.rootLonelyCreated === 0 &&
effect.immediateDelta >= 0 &&
effect.nextReplyLonelyValue === 0 &&
(
Number(
effect.nextReplyScoreLoss
) || 0
) <= 1e-9
);""",
"更新 Worker 根節點完整安全條件",
)
# --------------------------------------------------------------
# 4. Worker：重寫無安全棋時的最小傷害排序
# --------------------------------------------------------------
worker_least_harmful = r""" function leastHarmfulPlacementEntries(
entries
) {
if (!entries.length) {
return [];
}
let remaining =
entries.slice();
function keepMinimum(
getter
) {
let minimum = Infinity;
for (const entry of remaining) {
minimum = Math.min(
minimum,
Number(getter(entry)) || 0
);
}
remaining =
remaining.filter(
entry =>
Math.abs(
(
Number(
getter(entry)
) || 0
) -
minimum
) <= 1e-9
);
}
// 第一優先：不要立即製造己方孤獨數。
keepMinimum(
entry =>
entry.effect.rootLonelyCreated
);
// 第二優先：令對方下一手最多能取得的分數最小。
//
// 這一項同時涵蓋：
// - 封閉新棋成為孤獨數；
// - 封閉舊棋成為孤獨數；
// - 封閉包含雙方棋子的完整區域。
keepMinimum(
entry =>
entry.effect.nextReplyScoreLoss
);
// 第三優先：能立即得分的對方回覆越少越好。
keepMinimum(
entry =>
entry.effect
.nextReplyScoringReplies
);
// 保留舊版專門針對新落下棋子的安全排序。
keepMinimum(
entry =>
entry.effect
.nextReplyLonelyValue
);
keepMinimum(
entry =>
entry.effect
.nextReplyLonelyReplies
);
// 最後才比較目前這一步本身的即時分差。
let bestDelta = -Infinity;
for (const entry of remaining) {
bestDelta = Math.max(
bestDelta,
entry.effect.immediateDelta
);
}
return remaining.filter(
entry =>
entry.effect.immediateDelta >=
bestDelta - 1e-9
);
}
"""
source = replace_section_once(
source,
""" function leastHarmfulPlacementEntries(""",
""" // 從分析結果中選出根節點允許搜尋的走法。""",
worker_least_harmful,
"重寫 Worker 最小傷害排序",
)
# 即使所有走法都不完全安全，也不要把下一手送分棋
# 當作值得優先展開的有利戰術。
source = replace_once(
source,
""" effect.rootLonelyCreated === 0 &&
effect.opponentLonelyResolved === 0 &&
(""",
""" effect.rootLonelyCreated === 0 &&
effect.opponentLonelyResolved === 0 &&
effect.nextReplyLonelyValue === 0 &&
(
Number(
effect.nextReplyScoreLoss
) || 0
) <= 1e-9 &&
(""",
"禁止把下一手送分棋列為有利孤獨數戰術",
)
# --------------------------------------------------------------
# 5. 主執行緒：加入相同的對方下一手得分檢查
# --------------------------------------------------------------
main_reply_scoring_function = r"""
// OPPONENT_REPLY_SCORING_GUARD_V1_MAIN
//
// 主執行緒版「對方下一手立即得分」檢查。
//
// stopAfterFirst 為 true 時，只要找到一個危險回覆便停止；
// 這供 AI 行動執行前的最後檢查使用。
function nextReplyScoringThreatMain(
gameState,
action,
stopAfterFirst = false
) {
const noThreat = {
loss: 0,
replies: 0,
cell: -1,
type: -1,
rotation: -1
};
if (
!gameState ||
gameState.status !== 'playing' ||
gameState.phase !== 'place' ||
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
gameState.board[action.i]
) {
return noThreat;
}
const totalAfter =
gameState.placementCount[0] +
gameState.placementCount[1] +
1;
if (totalAfter >= SIZE) {
return noThreat;
}
const rootPlayer =
gameState.turn;
const replyPlayer =
1 - rootPlayer;
const board =
gameState.board.slice();
board[action.i] = {
player: rootPlayer,
type: action.t,
rot: action.r
};
const inventories =
gameState.inventories.map(
row => row.slice()
);
inventories[rootPlayer][action.t]--;
const placementCount =
gameState.placementCount.slice();
placementCount[rootPlayer]++;
const childState = {
...gameState,
board,
inventories,
placementCount,
phase: 'place',
turn: replyPlayer,
status: 'playing'
};
const replyActions =
getLegalPlacements(childState);
if (!replyActions.length) {
return noThreat;
}
const beforeReplyScore =
calculatePlacementScore(board);
let maximumLoss = 0;
let threateningReplies = 0;
let bestCell = -1;
let bestType = -1;
let bestRotation = -1;
function cellCanAffectExistingScore(
index
) {
const row =
Math.floor(index / N);
const col = index % N;
for (
let direction = 0;
direction <
DIRECTIONS.length;
direction++
) {
const nextRow =
row +
DIRECTIONS[direction][0];
const nextCol =
col +
DIRECTIONS[direction][1];
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
if (
board[
nextRow * N + nextCol
]
) {
return true;
}
}
return false;
}
for (
const reply of replyActions
) {
if (
!cellCanAffectExistingScore(
reply.i
)
) {
continue;
}
const previous =
board[reply.i];
board[reply.i] = {
player: replyPlayer,
type: reply.t,
rot: reply.r
};
let afterReplyScore;
try {
afterReplyScore =
calculatePlacementScore(
board
);
} finally {
board[reply.i] =
previous;
}
const playerZeroDelta =
afterReplyScore -
beforeReplyScore;
const rootDelta =
rootPlayer === 0
? playerZeroDelta
: -playerZeroDelta;
if (rootDelta < -1e-9) {
const loss = -rootDelta;
threateningReplies++;
if (
loss >
maximumLoss + 1e-9
) {
maximumLoss = loss;
bestCell = reply.i;
bestType = reply.t;
bestRotation = reply.r;
}
if (stopAfterFirst) {
return {
loss: maximumLoss,
replies:
threateningReplies,
cell: bestCell,
type: bestType,
rotation:
bestRotation
};
}
}
}
return {
loss: maximumLoss,
replies: threateningReplies,
cell: bestCell,
type: bestType,
rotation: bestRotation
};
}
"""
source = replace_once(
source,
""" // 主執行緒版根節點安全過濾。""",
main_reply_scoring_function
+ """ // 主執行緒版根節點安全過濾。""",
"插入主執行緒下一手區域得分檢查",
)
# --------------------------------------------------------------
# 6. 主執行緒：重寫 fallback 根節點過濾
#
# 正常情況只對舊安全條件通過的走法執行較昂貴的下一手
# 全部回覆檢查。找到 80 個安全走法後即可停止，因為
# fallback 本來也只會抽樣最多 80 手。
# --------------------------------------------------------------
main_filter_function = r""" function filterRootPlacementActionsMain(
gameState,
actions
) {
if (
!Array.isArray(actions) ||
!actions.length
) {
return [];
}
const rootPlayer =
gameState.turn;
const beforeScore =
calculatePlacementScore(
gameState.board
);
const entries = [];
for (const action of actions) {
if (
!action ||
action.kind !== 'place'
) {
continue;
}
const board =
gameState.board.slice();
board[action.i] = {
player: rootPlayer,
type: action.t,
rot: action.r
};
const afterScore =
calculatePlacementScore(
board
);
const immediateDelta =
rootPlayer === 0
? afterScore - beforeScore
: beforeScore - afterScore;
const rootLonelyCreated =
placementCreatesOwnLonelyNumberMain(
gameState,
action
)
? 1
: 0;
const replyThreat =
nextReplyLonelyThreatMain(
gameState,
action
);
entries.push({
action,
immediateDelta,
rootLonelyCreated,
nextReplyLonelyValue:
replyThreat.value,
nextReplyLonelyReplies:
replyThreat.replies,
// 延遲計算，避免對明顯不安全的落子
// 不必要地模擬對方全部合法回覆。
nextReplyScoreLoss: null,
nextReplyScoringReplies:
null
});
}
if (!entries.length) {
return [];
}
function ensureScoringThreat(
entry
) {
if (
entry.nextReplyScoreLoss !==
null
) {
return;
}
const threat =
nextReplyScoringThreatMain(
gameState,
entry.action,
false
);
entry.nextReplyScoreLoss =
threat.loss;
entry.nextReplyScoringReplies =
threat.replies;
}
// 先找出符合舊版安全條件的候選。
const provisionalSafe =
entries.filter(
entry =>
entry.rootLonelyCreated ===
0 &&
entry.immediateDelta >= 0 &&
entry.nextReplyLonelyValue ===
0
);
// 打亂檢查次序，避免 fallback 永遠偏向固定棋種。
for (
let index =
provisionalSafe.length - 1;
index > 0;
index--
) {
const other =
Math.floor(
Math.random() *
(index + 1)
);
const temporary =
provisionalSafe[index];
provisionalSafe[index] =
provisionalSafe[other];
provisionalSafe[other] =
temporary;
}
const safeEntries = [];
for (
const entry of
provisionalSafe
) {
ensureScoringThreat(entry);
if (
entry.nextReplyScoreLoss <=
1e-9
) {
safeEntries.push(entry);
// fallback 最多只抽樣 80 手，
// 不需要繼續做昂貴的全回覆分析。
if (
safeEntries.length >= 80
) {
break;
}
}
}
if (safeEntries.length) {
return safeEntries.map(
entry => entry.action
);
}
// 沒有完全安全走法時，補算所有候選的下一手威脅，
// 然後使用與 Worker 相同的最小傷害次序。
for (const entry of entries) {
ensureScoringThreat(entry);
}
let remaining =
entries.slice();
function keepMinimum(
getter
) {
let minimum = Infinity;
for (
const entry of remaining
) {
minimum = Math.min(
minimum,
Number(getter(entry)) ||
0
);
}
remaining =
remaining.filter(
entry =>
Math.abs(
(
Number(
getter(entry)
) || 0
) -
minimum
) <= 1e-9
);
}
keepMinimum(
entry =>
entry.rootLonelyCreated
);
keepMinimum(
entry =>
entry.nextReplyScoreLoss
);
keepMinimum(
entry =>
entry
.nextReplyScoringReplies
);
keepMinimum(
entry =>
entry.nextReplyLonelyValue
);
keepMinimum(
entry =>
entry.nextReplyLonelyReplies
);
let bestDelta = -Infinity;
for (
const entry of remaining
) {
bestDelta = Math.max(
bestDelta,
entry.immediateDelta
);
}
return remaining
.filter(
entry =>
entry.immediateDelta >=
bestDelta - 1e-9
)
.map(
entry => entry.action
);
}
"""
source = replace_section_once(
source,
""" function filterRootPlacementActionsMain(""",
""" function calculateLeftoverLonelyScore(""",
main_filter_function,
"重寫主執行緒根節點安全過濾",
)
# --------------------------------------------------------------
# 7. AI 執行 Worker 結果前加入最後檢查
# --------------------------------------------------------------
source = replace_once(
source,
""" const replyThreat =
nextReplyLonelyThreatMain(
state,
action
);
if (""",
""" const replyThreat =
nextReplyLonelyThreatMain(
state,
action
);
const replyScoreThreat =
nextReplyScoringThreatMain(
state,
action,
true
);
if (""",
"在 AI 最後檢查中計算對方下一手得分威脅",
)
source = replace_once(
source,
""" createsImmediateLonely ||
replyThreat.value > 0
) {""",
""" createsImmediateLonely ||
replyThreat.value > 0 ||
replyScoreThreat.loss > 1e-9
) {""",
"在 AI 執行前攔截下一手區域送分棋",
)
# --------------------------------------------------------------
# 8. 結果驗證
# --------------------------------------------------------------
required_fragments = [
"<!-- OPPONENT_REPLY_SCORING_GUARD_V1 -->",
"function nextReplyScoringThreat(",
"nextReplyScoreLoss:",
"nextReplyScoringReplies:",
"effect.nextReplyScoreLoss",
"function nextReplyScoringThreatMain(",
"replyScoreThreat.loss > 1e-9",
]
missing = [
fragment
for fragment in required_fragments
if fragment not in source
]
if missing:
raise RuntimeError(
"補丁完成後驗證失敗，缺少以下內容：\n - "
+ "\n - ".join(missing)
)
return source
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description=(
"為 Battle Number 247 版加入"
"「對方下一手立即區域得分」AI 安全補丁。"
)
)
parser.add_argument(
"input",
nargs="?",
default="battlenumber247.html",
help="輸入 HTML，預設為 battlenumber247.html",
)
parser.add_argument(
"output",
nargs="?",
default="battlenumber248.html",
help="輸出 HTML，預設為 battlenumber248.html",
)
return parser.parse_args()
def main() -> int:
args = parse_args()
input_path = Path(args.input)
output_path = Path(args.output)
if not input_path.is_file():
print(
f"錯誤：找不到輸入檔案：{input_path}",
file=sys.stderr,
)
return 1
try:
source = input_path.read_text(
encoding="utf-8"
)
except Exception as error:
print(
f"錯誤：無法讀取輸入檔案：{error}",
file=sys.stderr,
)
return 1
if PATCH_MARKER in source:
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
source,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print(
f"檔案已包含 {PATCH_MARKER}；"
f"未重複修改，已輸出至：{output_path}"
)
return 0
try:
patched = patch_html(source)
except Exception as error:
print(
f"補丁失敗：{error}",
file=sys.stderr,
)
return 1
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
patched,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print("補丁完成。")
print(f"輸入：{input_path}")
print(f"輸出：{output_path}")
print()
print("新增防護：")
print(" 1. 模擬對方全部合法下一手落子")
print(" 2. 比較對方落子前後的實際區域分數")
print(" 3. 排除替對方建立立即得分機會的根節點走法")
print(" 4. MCTS、alpha-beta、fallback 使用相同規則")
print(" 5. Worker 結果執行前再次檢查")
print(" 6. 無完全安全棋時優先令對方可得分值最小")
return 0
if __name__ == "__main__":
raise SystemExit(main())執行：
bash
python patch_battlenumber_reply_scoring.py battlenumber247.html battlenumber248.html這次的判定不再只看新落下的棋子，而是直接模擬對方下一步的實際計分。因此在範例：
text
q b4l d3l b3r d2n a6l d6m a7l c6t e6m f6u e4u e2u中：
- 分析
e6m時，會發現對方下一手f6u能令己方分差下降 6 分，所以e6m會被排除。 - 分析
e4u時，也會發現e2u所造成的下一手實際得分，因此同樣會被排除。 - 由於模擬的是全部合法回覆，所以即使得分落子不與剛落下的棋直接相鄰，只要這一步間接接通區域並創造下一手得分機會，也能被檢出。
提问者能不能多檢查幾手棋呢？雖然對方不在下一手得分，但是再下一手會得分啊！那MCTS搜尋有什麼用啊？會下出這麼差的棋！
QuanAI可以，而且不能只是把「下一手檢查」機械地改成兩手。你描述的是典型的「搜尋地平線效應」：
text
AI 候選落子 A
→ 對方鋪墊 B（暫時沒有得分）
→ AI 有一次防守機會 C
→ 對方落子 D 得分正確判定必須是：
存在一個對方鋪墊
B，使得不論 AI 如何防守C，對方都存在得分手D。
量詞是：
∃B∀C∃D不能只檢查「存在 B 和 D」，否則會把 AI 明明能在中間擋住的局面也錯判成危險。
為什麼 MCTS 仍會下出這種棋？
MCTS 有用，但它是統計估值器，不是戰術安全證明器。目前這個遊戲特別容易出現以下問題：
-
合法落子分支非常多
空格、棋種與方向組合起來，對方那個關鍵鋪墊手可能只佔很小比例。 -
隨機 rollout 不一定走到正確組合
必須依次出現B → C → D，才能看到後果。隨機模擬通常會被大量無關落子稀釋。 -
UCT 會減少探索表面分數不好的鋪墊手
B當下不得分，甚至看起來很普通，所以不一定獲得足夠模擬次數。 -
平均結果掩蓋最壞結果
對手只有一條強制得分路線，但其餘隨機回覆都很差時，MCTS 的平均值可能仍認為候選落子不錯。 -
固定搜尋深度會產生地平線效應
如果得分恰好出現在搜尋界線之外，AI 只會看見鋪墊，卻看不見後續得分。
所以不能期待單靠增加 MCTS 次數徹底解決。正確做法是：
先用確定性的戰術搜尋排除可被強制得分的走法，再讓 MCTS 在剩餘走法中比較長期優劣。
建議改成四層防護
第一層：立即送分檢查
保留現在的：
text
AI A → 對方 B 得分也就是目前 nextReplyScoringThreat() 的功能。
第二層：兩回合強制得分檢查
新增：
text
AI A
→ 對方每個有威脅的 B
→ AI 每個合法防守 C
→ 對方是否仍有得分 D只有當所有 AI 防守都擋不住時，才把 A 判定為「兩回合強制送分」。
返回資料可設計為：
js
{
forced: true,
loss: 6,
opponentPreparations: 2,
survivingDefenses: 0,
line: [B, C, D]
}其中：
forced：是否為強制得分；loss：最壞情況的分差損失；opponentPreparations：能建立強制威脅的對方鋪墊數；survivingDefenses：AI 可以成功防守的走法數；line：用來除錯的代表性變化。
第三層：靜態延伸搜尋
不能搜尋到固定深度就立刻停止。若葉節點仍存在以下情況，就應繼續搜尋：
- 某個區域只剩一個開口；
- 某個區域只剩兩個可封閉位置；
- 一步能封閉含棋區域；
- 一步能建立雙重封閉威脅；
- 目前局面有立即得分手；
- 最近一步改變了區域連通關係。
這類做法叫做 quiescence search（靜態延伸搜尋）。它能避免恰好在危險鋪墊之後停止。
第四層：MCTS
MCTS 最後才負責：
- 比較沒有明顯戰術漏洞的候選；
- 評估較長期的區域控制；
- 平衡棋子庫存；
- 選擇勝率較高的戰略走法。
流程應當是：
正在绘制流程图…
四層搜尋的核心不是平均值，而是 minimax
假設從根玩家角度計分：
- 對方會選擇令 AI 損失最大的
B； - AI 會選擇最能降低損失的
C； - 對方再選最有利的
D。
可用以下形式計算候選 A 的兩回合最壞損失：
如果只是判定「是否存在強制得分」，则逻辑类似：
js
for (const opponentSetup of opponentMovesAfterA) {
let allDefensesFail = true;
for (const aiDefense of aiMovesAfterSetup) {
const opponentCanScore =
existsImmediateScoringReply(
stateAfterDefense
);
if (!opponentCanScore) {
allDefensesFail = false;
break;
}
}
if (allDefensesFail) {
return {
forced: true,
setup: opponentSetup
};
}
}不过还要处理一个重要情况：
AI 的防守
C可能自己先得分。
所以不能只问 D 是否得分，而应比较完整分差：
text
B 之后分差
C 之后分差
D 之后分差使用根玩家视角的净变化，避免把「AI 先得 8 分、对方再得 2 分」误判成严重送分。
不建议直接遍历所有四层组合
如果每层有几百甚至上千种合法落子，完整搜索会非常昂贵。应加入以下优化。
1. 合并等价落子
如果同一格的多个棋种或旋转产生完全相同的连接方向，应视为同一个拓扑动作。搜索时只保留一个代表动作，最终再映射回实际可用棋子。
等价键可以近似写成：
js
const key =
action.i + ":" +
connectionMask(action.t, action.r);这通常能显著降低分支数。
2. 对方铺垫手优先检查战术相关位置
优先搜索：
- 当前含棋区域的开口；
- 能合并两个含棋区域的位置；
- 与已有棋相邻的位置；
- 能令区域开口数降到 1 或 2 的位置；
- 能制造两个不同得分落点的位置。
但要注意：
如果要给出“绝对安全”结论，最终仍须覆盖全部合法对方落子；战术排序只能用于加速和尽早剪枝，不能直接遗漏其他走法。
3. AI 防守手优先检查
AI 的防守候选应优先包括：
- 自己立即得分的落子；
- 封住对方预定得分格的落子；
- 重新打开或连接到外部区域的落子；
- 拆除对方双重威胁的落子；
- 改变目标区域连通性的落子。
4. Alpha-beta 剪枝
四层搜索是确定性的对抗搜索，适合 alpha-beta，不应再用随机 rollout 判断是否强制得分。
5. 置换表
用以下状态建立缓存：
text
棋盘拓扑
当前玩家
棋子库存
剩余搜索深度缓存：
js
Map<stateKey, {
value,
bound,
depth
}>很多不同落子顺序可能到达相同或等价棋盘，缓存能节省大量计算。
6. 节点和时间上限
例如：
js
const TACTICAL_MAX_DEPTH = 4;
const TACTICAL_MAX_NODES = 120000;
const TACTICAL_TIME_LIMIT_MS = 700;但超时结果不能当作安全证明，应区分：
js
{
status: "safe" // 已证明能防守
}
{
status: "forced" // 已证明对方能强制得分
}
{
status: "unknown" // 时间不足，尚未证明
}根节点排序建议：
text
已证明安全
> 尚未确定
> 已证明强制失分不能把 unknown 错当成 safe。
无完全安全走法时的排序
如果所有候选都能被强制得分，不应随机选择，而应按以下顺序：
- 己方立即产生的孤独数最少；
- 对方强制得分的最坏损失最小；
- 对方完成威胁所需步数最多；
- 对方能建立威胁的铺垫手最少；
- AI 可防守的走法最多；
- 当前一步的即时分差最好；
- 最后才参考 MCTS 长期估值。
也就是说，危险等级不应只有布尔值，最好包含：
js
{
forcedLoss: 6,
distance: 3,
setupCount: 1,
defenseCount: 0
}这样 AI 即使必然失分，也会选择较迟、较少、较难完成的失分路线。
建议的实际深度
如果你说的“再下一手”是对方下一回合得分，那么至少需要检查：
text
根节点 AI 落子
+ 对方铺垫
+ AI 防守
+ 对方得分也就是从根候选之后再搜 3 ply，连根动作合计 4 ply。
不过我更建议：
- 基础战术深度：4 ply；
- 叶节点仍不稳定：延伸到 6 ply；
- 已经稳定、没有立即得分或单开口威胁：交回 MCTS；
- AI 执行最终动作前：再进行一次相同的确定性检查。
结论
MCTS 不是没用，而是它不应该负责证明这种短期战术安全。较可靠的组合是：
确定性 minimax 战术防护 + 静态延伸 + MCTS 长期评估。
上一版补丁只能挡住：
text
AI A → 對方 B 立即得分下一版应当升级成至少能挡住：
text
AI A → 對方 B 鋪墊
→ AI C 防守
→ 對方 D 得分并且只有在对方能击败 AI 的所有合理防守时，才把 A 判定为强制送分。这样既能多看几手，也不会因为“对方理论上两手后能得分、但 AI 明明可以挡住”而过度保守。
提问者QuanAI可以。下面的 Python 補丁會把 battlenumber248.html 修改成 battlenumber249.html，加入：
- 確定性的多層戰術搜尋；
- 基本搜尋線：
text
AI 候選 A
→ 對方鋪墊 B
→ AI 防守 C
→ 對方得分 D- 較長思考時間及較高深度時，延伸搜尋：
text
A → B → C → D → E → F- 正確使用 minimax 量詞：
- 對方節點：存在一手可以強制得分；
- AI 防守節點：所有合法防守都失敗；
- 完整遍歷合法防守，而不是只抽樣一兩手；
- 搜尋結果區分：
safe：已在指定深度內證明可防守；forced：已證明對方能強制得分；unknown：時間或節點不足，不能假裝安全；
- MCTS、alpha-beta、主執行緒 fallback 和執行前檢查使用相同原則；
- 如果全部候選都被證明會失分，優先選擇：
- 強制損失較小；
- 對方需要較多步才得分；
- 當前即時分差較好。
將以下內容儲存為 patch_battlenumber_multi_ply_safety.py：
python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
為 battlenumber248.html 加入多層強制得分戰術搜尋。
預設：
輸入：battlenumber248.html
輸出：battlenumber249.html
用法：
python patch_battlenumber_multi_ply_safety.py
或：
python patch_battlenumber_multi_ply_safety.py \
battlenumber248.html \
battlenumber249.html
"""
from __future__ import annotations
import argparse
import sys
from pathlib import Path
PATCH_MARKER = "MULTI_PLY_FORCED_SCORING_GUARD_V1"
def replace_once(
text: str,
old: str,
new: str,
label: str,
) -> str:
count = text.count(old)
if count != 1:
raise RuntimeError(
f"{label}：預期找到 1 個替換位置，"
f"實際找到 {count} 個。"
)
return text.replace(old, new, 1)
def replace_section_once(
text: str,
start_marker: str,
end_marker: str,
new_section: str,
label: str,
) -> str:
start_count = text.count(start_marker)
if start_count != 1:
raise RuntimeError(
f"{label}：起始標記預期找到 1 個，"
f"實際找到 {start_count} 個。"
)
start = text.find(start_marker)
end = text.find(
end_marker,
start + len(start_marker),
)
if end < 0:
raise RuntimeError(
f"{label}：找不到結束標記。"
)
return (
text[:start]
+ new_section
+ text[end:]
)
def patch_html(source: str) -> str:
# ----------------------------------------------------------
# 0. 版本標記
# ----------------------------------------------------------
source = replace_once(
source,
""" <!-- OPPONENT_REPLY_SCORING_GUARD_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
""" <!-- OPPONENT_REPLY_SCORING_GUARD_V1 -->
<!-- MULTI_PLY_FORCED_SCORING_GUARD_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
"加入多層戰術搜尋版本標記",
)
# ----------------------------------------------------------
# 1. Worker：多層確定性強制得分搜尋
# ----------------------------------------------------------
worker_tactical_code = r"""
// MULTI_PLY_FORCED_SCORING_GUARD_V1
//
// 根節點候選 A 落下後，以確定性 minimax 搜尋：
//
// A → 對方 B → 根玩家 C → 對方 D
//
// 較長思考時間及較高搜尋深度時，可繼續延伸：
//
// A → B → C → D → E → F
//
// 對方節點使用「存在」：
// 只要存在一手能令根玩家最終失分，便是成功威脅。
//
// 根玩家節點使用「所有」：
// 只有所有合法防守都無法避免失分，才算強制得分。
//
// 搜尋結果嚴格區分：
//
// safe：
// 已完整搜尋指定戰術深度，證明可防守。
//
// forced：
// 已找到一條對方強制得分線，而且所有根玩家防守
// 都已被驗證為失敗。
//
// unknown：
// 時間或節點不足，不能當成安全證明。
const TACTICAL_SCORE_EPSILON =
1e-9;
const TACTICAL_DEFAULT_NODE_LIMIT =
180000;
function makeForcedScoringContext(
timeMs,
hardDeadline = Infinity,
depthRounds = 2
) {
const safeTime = Math.max(
100,
Number(timeMs) || 1000
);
const safeDepth = Math.max(
1,
Math.floor(
Number(depthRounds) || 2
)
);
const seconds =
safeTime / 1000;
return {
budgetMs: clamp(
safeTime * 0.24,
180,
1600
),
hardDeadline:
Number.isFinite(hardDeadline)
? hardDeadline
: Infinity,
deadline: null,
nodes: 0,
nodeLimit:
TACTICAL_DEFAULT_NODE_LIMIT,
// 一般至少搜尋至 B-C-D。
// 自訂深度較高而且思考時間足夠時，
// 延伸至 B-C-D-E-F。
maxOpponentTurns:
(
safeDepth >= 5 &&
seconds >= 8
)
? 3
: 2,
candidateLimit: clamp(
14 +
Math.floor(
Math.log2(
Math.max(1, seconds)
)
) *
4,
14,
38
),
safeResultLimit:
seconds >= 8
? 10
: 6,
rootActionCache:
new Map()
};
}
function ensureTacticalDeadline(
context
) {
if (!context) {
return;
}
if (
Number.isFinite(
context.deadline
)
) {
return;
}
context.deadline = Math.min(
context.hardDeadline,
performance.now() +
context.budgetMs
);
}
function tacticalBudgetExceeded(
context,
increment = 1
) {
if (!context) {
return true;
}
ensureTacticalDeadline(context);
context.nodes += increment;
if (
context.nodes >
context.nodeLimit
) {
return true;
}
return (
performance.now() >=
context.deadline
);
}
function tacticalResult(
status,
loss = 0,
distance = 0,
line = []
) {
return {
status,
loss:
Number.isFinite(loss)
? Math.max(0, loss)
: 0,
distance:
Number.isFinite(distance)
? Math.max(
0,
Math.floor(distance)
)
: 0,
line:
Array.isArray(line)
? line
: []
};
}
function publicPlacementAction(
action
) {
if (
!action ||
action.kind !== 'place'
) {
return null;
}
return {
kind: 'place',
i: action.i,
t: action.t,
r: action.r
};
}
function tacticalRootActionKey(
action
) {
const orient =
action._o !== undefined
? action._o
: orientationId(
action.t,
action.r
);
return (
orient * SIZE +
action.i
);
}
function tacticalStateKey(
state,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
nodeKind,
ply
) {
let boardKey = '';
for (
let index = 0;
index < SIZE;
index++
) {
boardKey +=
String.fromCharCode(
state.board[index]
);
}
return [
boardKey,
Array.from(state.inv).join(','),
state.turn,
state.phase,
state.place0,
state.place1,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
nodeKind,
ply
].join('|');
}
function tacticalPlayerZeroScore(
state
) {
if (
state.phase === 'place'
) {
return regionScore(
state.board
);
}
return Number.isFinite(
state.ps
)
? state.ps
: regionScore(
state.board
);
}
function tacticalRootScore(
state,
rootPlayer
) {
return rootPerspectiveScore(
tacticalPlayerZeroScore(state),
rootPlayer
);
}
function tacticalActionOrderValue(
state,
action
) {
const row =
Math.floor(action.i / N);
const col =
action.i % N;
let neighbours = 0;
for (
let direction = 0;
direction < 4;
direction++
) {
const nextRow =
row + D4[direction][0];
const nextCol =
col + D4[direction][1];
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
if (
state.board[
nextRow * N + nextCol
]
) {
neighbours++;
}
}
return (
neighbours * 20 +
localPlacementHeuristic(
state,
action
) +
Math.random() * 0.01
);
}
function orderedTacticalPlacements(
state
) {
const actions =
allPlacementActions(state);
const ordered =
actions.map(
action => ({
action,
order:
tacticalActionOrderValue(
state,
action
)
})
);
ordered.sort(
(first, second) =>
second.order -
first.order
);
return ordered.map(
entry => entry.action
);
}
function tacticalOpponentNode(
state,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
context,
memo,
ply
) {
if (
tacticalBudgetExceeded(
context
)
) {
return tacticalResult(
'unknown'
);
}
if (
state.done ||
state.phase !== 'place'
) {
const loss =
baselineRootScore -
tacticalRootScore(
state,
rootPlayer
);
return loss >
TACTICAL_SCORE_EPSILON
? tacticalResult(
'forced',
loss,
ply
)
: tacticalResult(
'safe'
);
}
const memoKey =
tacticalStateKey(
state,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
'opponent',
ply
);
const memoResult =
memo.get(memoKey);
if (memoResult) {
return memoResult;
}
const actions =
orderedTacticalPlacements(
state
);
// 對方沒有合法落子時直接判負，
// 所以這不是根玩家的得分威脅。
if (!actions.length) {
const result =
tacticalResult('safe');
memo.set(
memoKey,
result
);
return result;
}
let sawUnknown = false;
for (const action of actions) {
if (
tacticalBudgetExceeded(
context
)
) {
sawUnknown = true;
break;
}
const child =
cloneState(state);
applyPlacementInPlace(
child,
action
);
const currentLoss =
baselineRootScore -
tacticalRootScore(
child,
rootPlayer
);
// 對方目前這一步已經令根玩家低於
// 根候選 A 落下後的基準分差。
if (
currentLoss >
TACTICAL_SCORE_EPSILON
) {
const result =
tacticalResult(
'forced',
currentLoss,
ply,
[
publicPlacementAction(
action
)
]
);
memo.set(
memoKey,
result
);
return result;
}
if (
child.done ||
child.phase !== 'place' ||
opponentTurnsLeft <= 1
) {
continue;
}
const continuation =
tacticalRootNode(
child,
rootPlayer,
baselineRootScore,
opponentTurnsLeft - 1,
context,
memo,
ply + 1
);
if (
continuation.status ===
'forced'
) {
const result =
tacticalResult(
'forced',
continuation.loss,
continuation.distance,
[
publicPlacementAction(
action
),
...continuation.line
]
);
memo.set(
memoKey,
result
);
return result;
}
if (
continuation.status ===
'unknown'
) {
sawUnknown = true;
}
}
if (sawUnknown) {
return tacticalResult(
'unknown'
);
}
const result =
tacticalResult('safe');
memo.set(
memoKey,
result
);
return result;
}
function tacticalRootNode(
state,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
context,
memo,
ply
) {
if (
tacticalBudgetExceeded(
context
)
) {
return tacticalResult(
'unknown'
);
}
if (
state.done ||
state.phase !== 'place'
) {
const loss =
baselineRootScore -
tacticalRootScore(
state,
rootPlayer
);
return loss >
TACTICAL_SCORE_EPSILON
? tacticalResult(
'forced',
loss,
ply
)
: tacticalResult(
'safe'
);
}
const memoKey =
tacticalStateKey(
state,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
'root',
ply
);
const memoResult =
memo.get(memoKey);
if (memoResult) {
return memoResult;
}
const actions =
orderedTacticalPlacements(
state
);
// 根玩家沒有合法防守時直接判負。
if (!actions.length) {
const result =
tacticalResult(
'forced',
RAW_FORFEIT_SCORE,
ply
);
memo.set(
memoKey,
result
);
return result;
}
let sawUnknown = false;
let minimumForcedLoss =
Infinity;
let latestForcedDistance = 0;
let representativeLine = [];
for (const action of actions) {
if (
tacticalBudgetExceeded(
context
)
) {
sawUnknown = true;
break;
}
const child =
cloneState(state);
applyPlacementInPlace(
child,
action
);
const currentLoss =
baselineRootScore -
tacticalRootScore(
child,
rootPlayer
);
let continuation;
if (
child.done ||
child.phase !== 'place'
) {
continuation =
currentLoss >
TACTICAL_SCORE_EPSILON
? tacticalResult(
'forced',
currentLoss,
ply
)
: tacticalResult(
'safe'
);
} else if (
currentLoss >
TACTICAL_SCORE_EPSILON
) {
// 這個「防守」自己已令根玩家跌破
// A 落下後的基準，因此不是成功防守。
continuation =
tacticalResult(
'forced',
currentLoss,
ply
);
} else {
continuation =
tacticalOpponentNode(
child,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
context,
memo,
ply + 1
);
}
// 根玩家只需要找到一手成功防守，
// 就能推翻目前對方鋪墊的強制性。
if (
continuation.status ===
'safe'
) {
const result =
tacticalResult(
'safe',
0,
0,
[
publicPlacementAction(
action
),
...continuation.line
]
);
memo.set(
memoKey,
result
);
return result;
}
if (
continuation.status ===
'unknown'
) {
sawUnknown = true;
continue;
}
if (
continuation.loss <
minimumForcedLoss
) {
minimumForcedLoss =
continuation.loss;
representativeLine = [
publicPlacementAction(
action
),
...continuation.line
];
}
latestForcedDistance =
Math.max(
latestForcedDistance,
continuation.distance
);
}
// 只要有一個防守分支尚未搜完，
// 就不能聲稱「所有防守都失敗」。
if (sawUnknown) {
return tacticalResult(
'unknown'
);
}
const result =
tacticalResult(
'forced',
Number.isFinite(
minimumForcedLoss
)
? minimumForcedLoss
: RAW_FORFEIT_SCORE,
latestForcedDistance,
representativeLine
);
memo.set(
memoKey,
result
);
return result;
}
function forcedFutureScoringThreat(
state,
action,
rootPlayer,
context
) {
const noThreat =
tacticalResult('safe');
if (
!context ||
!state ||
state.done ||
state.phase !== 'place' ||
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
state.board[action.i]
) {
return noThreat;
}
const cacheKey =
tacticalRootActionKey(
action
);
const cached =
context.rootActionCache.get(
cacheKey
);
if (cached) {
return cached;
}
if (
tacticalBudgetExceeded(
context,
0
)
) {
return tacticalResult(
'unknown'
);
}
const child =
cloneState(state);
applyPlacementInPlace(
child,
action
);
// A 已經是第 49 枚棋子時，
// 對方沒有後續落子。
if (
child.done ||
child.phase !== 'place'
) {
context.rootActionCache.set(
cacheKey,
noThreat
);
return noThreat;
}
const baselineRootScore =
tacticalRootScore(
child,
rootPlayer
);
const memo = new Map();
const result =
tacticalOpponentNode(
child,
rootPlayer,
baselineRootScore,
context.maxOpponentTurns,
context,
memo,
1
);
// unknown 不寫入永久快取。
// 如果之後仍有時間，允許再次嘗試。
if (
result.status !==
'unknown'
) {
context.rootActionCache.set(
cacheKey,
result
);
}
return result;
}
function rootEntryTacticalOrder(
state,
entry
) {
return (
entry.effect.immediateDelta *
16 +
localPlacementHeuristic(
state,
entry.action
) -
(
Number(
entry.effect
.nextReplyScoringReplies
) || 0
) *
0.15 +
Math.random() * 0.2
);
}
function chooseMultiPlyRootEntries(
state,
entries,
rootPlayer,
context
) {
if (
!entries.length ||
!context
) {
return entries;
}
const ordered =
entries.map(
entry => ({
entry,
order:
rootEntryTacticalOrder(
state,
entry
)
})
);
ordered.sort(
(first, second) =>
second.order -
first.order
);
// 只把這批候選交給 MCTS。
// 每一手仍會完整遍歷其戰術搜尋中的合法防守；
// 此上限控制的是根候選數量，不是防守分支數量。
const candidates =
ordered
.slice(
0,
Math.min(
context.candidateLimit,
ordered.length
)
)
.map(
item => item.entry
);
const provenSafe = [];
const unknown = [];
const forced = [];
for (
const entry of candidates
) {
const result =
forcedFutureScoringThreat(
state,
entry.action,
rootPlayer,
context
);
entry.effect
.futureThreatStatus =
result.status;
entry.effect
.forcedFutureScoreLoss =
result.loss;
entry.effect
.forcedFutureDistance =
result.distance;
entry.effect
.forcedFutureLine =
result.line;
if (
result.status === 'safe'
) {
provenSafe.push(entry);
if (
provenSafe.length >=
context.safeResultLimit
) {
break;
}
} else if (
result.status ===
'forced'
) {
forced.push(entry);
} else {
unknown.push(entry);
}
}
// 已證明安全優先於未完成搜尋。
if (provenSafe.length) {
return provenSafe;
}
// unknown 不能假裝 safe，但也不能當成已證明失敗。
if (unknown.length) {
return unknown;
}
if (!forced.length) {
return candidates;
}
// 全部候選都已證明會失分：
// 先選強制損失最小，再選對方需要較多步才能得分。
let remaining =
forced.slice();
let minimumLoss =
Infinity;
for (
const entry of remaining
) {
minimumLoss = Math.min(
minimumLoss,
Number(
entry.effect
.forcedFutureScoreLoss
) || 0
);
}
remaining =
remaining.filter(
entry =>
Math.abs(
(
Number(
entry.effect
.forcedFutureScoreLoss
) || 0
) -
minimumLoss
) <=
TACTICAL_SCORE_EPSILON
);
let maximumDistance = 0;
for (
const entry of remaining
) {
maximumDistance = Math.max(
maximumDistance,
Number(
entry.effect
.forcedFutureDistance
) || 0
);
}
remaining =
remaining.filter(
entry =>
(
Number(
entry.effect
.forcedFutureDistance
) || 0
) >=
maximumDistance
);
let bestImmediate =
-Infinity;
for (
const entry of remaining
) {
bestImmediate = Math.max(
bestImmediate,
entry.effect.immediateDelta
);
}
return remaining.filter(
entry =>
entry.effect.immediateDelta >=
bestImmediate -
TACTICAL_SCORE_EPSILON
);
}
"""
source = replace_once(
source,
""" // ROOT_LONELY_SAFETY_POLICY_V2""",
worker_tactical_code
+ """ // ROOT_LONELY_SAFETY_POLICY_V2""",
"插入 Worker 多層戰術搜尋",
)
# ----------------------------------------------------------
# 2. Worker 根落子池接收戰術搜尋 context
# ----------------------------------------------------------
source = replace_once(
source,
""" function makeRootPlacementPool(state) {""",
""" function makeRootPlacementPool(
state,
tacticalContext = null
) {""",
"更新 Worker 根落子池函式參數",
)
source = replace_once(
source,
""" applyRootPlacementSafetyPolicy(
state,
pool,
state.turn
);""",
""" applyRootPlacementSafetyPolicy(
state,
pool,
state.turn,
tacticalContext
);""",
"把戰術 context 傳入 Worker 根安全策略",
)
# ----------------------------------------------------------
# 3. Worker：重寫根節點允許走法選擇
# ----------------------------------------------------------
worker_allowed_entries = r""" // 從分析結果中選出根節點允許搜尋的走法。
function allowedRootPlacementEntries(
state,
entries,
rootPlayer,
tacticalContext = null
) {
const onePlySafeEntries =
entries.filter(
entry =>
isSafeRootPlacementEffect(
entry.effect
)
);
if (
onePlySafeEntries.length
) {
return chooseMultiPlyRootEntries(
state,
onePlySafeEntries,
rootPlayer,
tacticalContext
);
}
return leastHarmfulPlacementEntries(
entries
);
}
"""
source = replace_section_once(
source,
""" // 從分析結果中選出根節點允許搜尋的走法。
function allowedRootPlacementEntries(""",
""" // 判斷這一步是否屬於值得優先搜尋的有利孤獨數戰術。""",
worker_allowed_entries,
"重寫 Worker 根節點允許走法選擇",
)
# ----------------------------------------------------------
# 4. Worker：重寫 alpha-beta 根過濾函式
# ----------------------------------------------------------
worker_filter_function = r""" // 對一般 action 陣列套用根節點安全規則。
//
// alpha-beta 根搜尋也使用此函式。
function filterRootPlacementActions(
state,
actions,
rootPlayer,
tacticalContext = null
) {
if (
!Array.isArray(actions) ||
!actions.length
) {
return [];
}
const beforeScore =
regionScore(state.board);
const entries = [];
for (const action of actions) {
if (
!action ||
action.kind !== 'place'
) {
entries.push({
action,
effect: {
immediateDelta: 0,
rootLonelyCreated: 0,
rootLonelyResolved: 0,
opponentLonelyCreated: 0,
opponentLonelyResolved: 0,
changesLonelyState: false,
nextReplyLonelyValue: 0,
nextReplyLonelyReplies: 0,
nextReplyScoreLoss: 0,
nextReplyScoringReplies: 0,
futureThreatStatus:
'safe',
forcedFutureScoreLoss:
0,
forcedFutureDistance:
0
}
});
continue;
}
const effect =
placementImmediateEffect(
state,
action,
rootPlayer,
beforeScore
);
if (!effect) {
continue;
}
action._rootImmediateDelta =
effect.immediateDelta;
action._rootLonelyCreated =
effect.rootLonelyCreated;
action
._rootNextReplyLonelyValue =
effect
.nextReplyLonelyValue;
action
._rootNextReplyLonelyReplies =
effect
.nextReplyLonelyReplies;
entries.push({
action,
effect
});
}
return allowedRootPlacementEntries(
state,
entries,
rootPlayer,
tacticalContext
).map(
entry => entry.action
);
}
"""
source = replace_section_once(
source,
""" // 對一般 action 陣列套用根節點安全規則。
//
// alpha-beta 根搜尋也使用此函式。
function filterRootPlacementActions(""",
""" // 對 MCTS 根節點的 bit-pool 套用相同安全規則。""",
worker_filter_function,
"重寫 Worker alpha-beta 根節點安全過濾",
)
# ----------------------------------------------------------
# 5. Worker：MCTS bit-pool 使用相同多層策略
# ----------------------------------------------------------
source = replace_once(
source,
""" function applyRootPlacementSafetyPolicy(
state,
pool,
rootPlayer
) {""",
""" function applyRootPlacementSafetyPolicy(
state,
pool,
rootPlayer,
tacticalContext = null
) {""",
"更新 Worker bit-pool 安全策略參數",
)
source = replace_once(
source,
""" const allowedEntries =
allowedRootPlacementEntries(
entries
);""",
""" const allowedEntries =
allowedRootPlacementEntries(
state,
entries,
rootPlayer,
tacticalContext
);""",
"讓 Worker bit-pool 套用多層戰術搜尋",
)
source = replace_once(
source,
""" ? makeRootPlacementPool(node.state)
: makePlacementPool(node.state);""",
""" ? makeRootPlacementPool(
node.state,
context.tactical
)
: makePlacementPool(node.state);""",
"讓 MCTS 根節點傳入戰術搜尋 context",
)
# ----------------------------------------------------------
# 6. Worker：alpha-beta 使用共用戰術 context
# ----------------------------------------------------------
source = replace_once(
source,
""" filterRootPlacementActions(
rootState,
actions,
rootPlayer
);""",
""" filterRootPlacementActions(
rootState,
actions,
rootPlayer,
counter.tactical
);""",
"讓 alpha-beta 根過濾使用多層戰術搜尋",
)
source = replace_once(
source,
""" const counter = {
nodes: 0,
rootPhase: rootState.phase
};""",
""" const counter = {
nodes: 0,
rootPhase: rootState.phase,
tactical:
makeForcedScoringContext(
budget,
deadline,
depthRounds
)
};""",
"建立 alpha-beta 戰術搜尋 context",
)
# ----------------------------------------------------------
# 7. Worker：MCTS 搜尋 context 加入戰術搜尋
# ----------------------------------------------------------
source = replace_once(
source,
""" rootPlacementSampleSize:
rootPlacementCandidateTarget(timeMs),
currentNode: null
};""",
""" rootPlacementSampleSize:
rootPlacementCandidateTarget(timeMs),
tactical:
makeForcedScoringContext(
timeMs,
Infinity,
safeDepthRounds
),
currentNode: null
};""",
"建立 MCTS 戰術搜尋 context",
)
# ----------------------------------------------------------
# 8. 主執行緒：多層確定性搜尋
# ----------------------------------------------------------
main_tactical_code = r"""
// MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN
//
// 主執行緒版多層強制得分搜尋。
//
// 主要供：
// 1. Worker 失敗時的 fallback；
// 2. Worker 回傳行動執行前的最後檢查。
const TACTICAL_MAIN_EPSILON =
1e-9;
const TACTICAL_MAIN_FORFEIT_LOSS =
1000;
function makeForcedScoringContextMain(
options = {}
) {
const budgetMs = Math.max(
40,
Number(options.budgetMs) ||
260
);
return {
budgetMs,
deadline:
performance.now() +
budgetMs,
nodes: 0,
nodeLimit: Math.max(
1000,
Number(options.nodeLimit) ||
90000
),
maxOpponentTurns: Math.max(
2,
Math.min(
3,
Math.floor(
Number(
options
.maxOpponentTurns
) || 2
)
)
),
candidateLimit: Math.max(
8,
Math.min(
40,
Math.floor(
Number(
options.candidateLimit
) || 28
)
)
),
safeResultLimit: Math.max(
2,
Math.min(
12,
Math.floor(
Number(
options.safeResultLimit
) || 6
)
)
),
rootActionCache:
new Map()
};
}
function tacticalBudgetExceededMain(
context,
increment = 1
) {
if (!context) {
return true;
}
context.nodes += increment;
return (
context.nodes >
context.nodeLimit ||
performance.now() >=
context.deadline
);
}
function tacticalResultMain(
status,
loss = 0,
distance = 0,
line = []
) {
return {
status,
loss:
Number.isFinite(loss)
? Math.max(0, loss)
: 0,
distance:
Number.isFinite(distance)
? Math.max(
0,
Math.floor(distance)
)
: 0,
line:
Array.isArray(line)
? line
: []
};
}
function publicPlacementActionMain(
action
) {
if (
!action ||
action.kind !== 'place'
) {
return null;
}
return {
kind: 'place',
i: action.i,
t: action.t,
r: action.r
};
}
function tacticalRootActionKeyMain(
action
) {
return [
action.i,
action.t,
normalizedRotation(
action.r
)
].join(':');
}
function cloneTacticalStateMain(
gameState
) {
return {
...gameState,
board:
gameState.board.map(
tile =>
tile
? {
player:
tile.player,
type: tile.type,
rot: tile.rot
}
: null
),
inventories:
gameState.inventories.map(
row => row.slice()
),
placementCount:
gameState
.placementCount
.slice(),
lastPlacements:
Array.isArray(
gameState.lastPlacements
)
? gameState
.lastPlacements
.slice()
: [null, null]
};
}
function applyTacticalPlacementMain(
gameState,
action
) {
const player =
gameState.turn;
gameState.board[action.i] = {
player,
type: action.t,
rot: action.r
};
gameState
.inventories[player][
action.t
]--;
gameState
.placementCount[player]++;
const total =
gameState
.placementCount[0] +
gameState
.placementCount[1];
if (total >= SIZE) {
const placement =
calculatePlacementScore(
gameState.board
) +
calculateLeftoverLonelyScore(
gameState.inventories,
gameState.first
);
gameState.placementScore =
placement;
gameState.placementFinal =
placement;
gameState.phase =
'extract';
gameState.turn =
1 - gameState.first;
} else {
gameState.turn =
1 - player;
}
}
function tacticalPlayerZeroScoreMain(
gameState
) {
if (
gameState.phase === 'place'
) {
return calculatePlacementScore(
gameState.board
);
}
if (
Number.isFinite(
gameState.placementFinal
)
) {
return Number(
gameState.placementFinal
);
}
return (
calculatePlacementScore(
gameState.board
) +
calculateLeftoverLonelyScore(
gameState.inventories,
gameState.first
)
);
}
function tacticalRootScoreMain(
gameState,
rootPlayer
) {
const playerZeroScore =
tacticalPlayerZeroScoreMain(
gameState
);
return rootPlayer === 0
? playerZeroScore
: -playerZeroScore;
}
function tacticalStateKeyMain(
gameState,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
nodeKind,
ply
) {
const boardKey =
gameState.board
.map(
tile =>
tile
? (
1 +
tile.player * 32 +
tile.type * 4 +
normalizedRotation(
tile.rot
)
)
: 0
)
.join(',');
return [
boardKey,
gameState.inventories
.map(
row => row.join(',')
)
.join('/'),
gameState.turn,
gameState.phase,
gameState
.placementCount
.join(','),
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
nodeKind,
ply
].join('|');
}
function tacticalActionOrderMain(
gameState,
action
) {
const row =
Math.floor(
action.i / N
);
const col =
action.i % N;
let neighbours = 0;
for (
let direction = 0;
direction <
DIRECTIONS.length;
direction++
) {
const nextRow =
row +
DIRECTIONS[direction][0];
const nextCol =
col +
DIRECTIONS[direction][1];
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
if (
gameState.board[
nextRow * N + nextCol
]
) {
neighbours++;
}
}
return (
neighbours * 20 +
TRIANGLES[action.t] *
0.15 +
Math.random() * 0.01
);
}
function orderedTacticalPlacementsMain(
gameState
) {
const actions =
getLegalPlacements(
gameState
);
const ordered =
actions.map(
action => ({
action,
order:
tacticalActionOrderMain(
gameState,
action
)
})
);
ordered.sort(
(first, second) =>
second.order -
first.order
);
return ordered.map(
entry => entry.action
);
}
function tacticalOpponentNodeMain(
gameState,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
context,
memo,
ply
) {
if (
tacticalBudgetExceededMain(
context
)
) {
return tacticalResultMain(
'unknown'
);
}
if (
gameState.phase !==
'place' ||
gameState.status !==
'playing'
) {
const loss =
baselineRootScore -
tacticalRootScoreMain(
gameState,
rootPlayer
);
return loss >
TACTICAL_MAIN_EPSILON
? tacticalResultMain(
'forced',
loss,
ply
)
: tacticalResultMain(
'safe'
);
}
const memoKey =
tacticalStateKeyMain(
gameState,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
'opponent',
ply
);
const cached =
memo.get(memoKey);
if (cached) {
return cached;
}
const actions =
orderedTacticalPlacementsMain(
gameState
);
if (!actions.length) {
const result =
tacticalResultMain(
'safe'
);
memo.set(
memoKey,
result
);
return result;
}
let sawUnknown = false;
for (const action of actions) {
if (
tacticalBudgetExceededMain(
context
)
) {
sawUnknown = true;
break;
}
const child =
cloneTacticalStateMain(
gameState
);
applyTacticalPlacementMain(
child,
action
);
const currentLoss =
baselineRootScore -
tacticalRootScoreMain(
child,
rootPlayer
);
if (
currentLoss >
TACTICAL_MAIN_EPSILON
) {
const result =
tacticalResultMain(
'forced',
currentLoss,
ply,
[
publicPlacementActionMain(
action
)
]
);
memo.set(
memoKey,
result
);
return result;
}
if (
child.phase !==
'place' ||
child.status !==
'playing' ||
opponentTurnsLeft <= 1
) {
continue;
}
const continuation =
tacticalRootNodeMain(
child,
rootPlayer,
baselineRootScore,
opponentTurnsLeft - 1,
context,
memo,
ply + 1
);
if (
continuation.status ===
'forced'
) {
const result =
tacticalResultMain(
'forced',
continuation.loss,
continuation.distance,
[
publicPlacementActionMain(
action
),
...continuation.line
]
);
memo.set(
memoKey,
result
);
return result;
}
if (
continuation.status ===
'unknown'
) {
sawUnknown = true;
}
}
if (sawUnknown) {
return tacticalResultMain(
'unknown'
);
}
const result =
tacticalResultMain(
'safe'
);
memo.set(
memoKey,
result
);
return result;
}
function tacticalRootNodeMain(
gameState,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
context,
memo,
ply
) {
if (
tacticalBudgetExceededMain(
context
)
) {
return tacticalResultMain(
'unknown'
);
}
if (
gameState.phase !==
'place' ||
gameState.status !==
'playing'
) {
const loss =
baselineRootScore -
tacticalRootScoreMain(
gameState,
rootPlayer
);
return loss >
TACTICAL_MAIN_EPSILON
? tacticalResultMain(
'forced',
loss,
ply
)
: tacticalResultMain(
'safe'
);
}
const memoKey =
tacticalStateKeyMain(
gameState,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
'root',
ply
);
const cached =
memo.get(memoKey);
if (cached) {
return cached;
}
const actions =
orderedTacticalPlacementsMain(
gameState
);
if (!actions.length) {
const result =
tacticalResultMain(
'forced',
TACTICAL_MAIN_FORFEIT_LOSS,
ply
);
memo.set(
memoKey,
result
);
return result;
}
let sawUnknown = false;
let minimumLoss =
Infinity;
let maximumDistance = 0;
let representativeLine = [];
for (const action of actions) {
if (
tacticalBudgetExceededMain(
context
)
) {
sawUnknown = true;
break;
}
const child =
cloneTacticalStateMain(
gameState
);
applyTacticalPlacementMain(
child,
action
);
const currentLoss =
baselineRootScore -
tacticalRootScoreMain(
child,
rootPlayer
);
let continuation;
if (
child.phase !==
'place' ||
child.status !==
'playing'
) {
continuation =
currentLoss >
TACTICAL_MAIN_EPSILON
? tacticalResultMain(
'forced',
currentLoss,
ply
)
: tacticalResultMain(
'safe'
);
} else if (
currentLoss >
TACTICAL_MAIN_EPSILON
) {
continuation =
tacticalResultMain(
'forced',
currentLoss,
ply
);
} else {
continuation =
tacticalOpponentNodeMain(
child,
rootPlayer,
baselineRootScore,
opponentTurnsLeft,
context,
memo,
ply + 1
);
}
// 找到一手可防守走法，就推翻此強制線。
if (
continuation.status ===
'safe'
) {
const result =
tacticalResultMain(
'safe',
0,
0,
[
publicPlacementActionMain(
action
),
...continuation.line
]
);
memo.set(
memoKey,
result
);
return result;
}
if (
continuation.status ===
'unknown'
) {
sawUnknown = true;
continue;
}
if (
continuation.loss <
minimumLoss
) {
minimumLoss =
continuation.loss;
representativeLine = [
publicPlacementActionMain(
action
),
...continuation.line
];
}
maximumDistance =
Math.max(
maximumDistance,
continuation.distance
);
}
if (sawUnknown) {
return tacticalResultMain(
'unknown'
);
}
const result =
tacticalResultMain(
'forced',
Number.isFinite(
minimumLoss
)
? minimumLoss
: TACTICAL_MAIN_FORFEIT_LOSS,
maximumDistance,
representativeLine
);
memo.set(
memoKey,
result
);
return result;
}
function forcedFutureScoringThreatMain(
gameState,
action,
options = {}
) {
const noThreat =
tacticalResultMain(
'safe'
);
if (
!gameState ||
gameState.status !==
'playing' ||
gameState.phase !==
'place' ||
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
gameState.board[action.i]
) {
return noThreat;
}
const context =
options.context ||
makeForcedScoringContextMain(
options
);
const cacheKey =
tacticalRootActionKeyMain(
action
);
const cached =
context.rootActionCache.get(
cacheKey
);
if (cached) {
return cached;
}
if (
tacticalBudgetExceededMain(
context,
0
)
) {
return tacticalResultMain(
'unknown'
);
}
const rootPlayer =
gameState.turn;
const child =
cloneTacticalStateMain(
gameState
);
applyTacticalPlacementMain(
child,
action
);
if (
child.phase !== 'place' ||
child.status !== 'playing'
) {
context.rootActionCache.set(
cacheKey,
noThreat
);
return noThreat;
}
const baselineRootScore =
tacticalRootScoreMain(
child,
rootPlayer
);
const memo = new Map();
const result =
tacticalOpponentNodeMain(
child,
rootPlayer,
baselineRootScore,
context.maxOpponentTurns,
context,
memo,
1
);
if (
result.status !==
'unknown'
) {
context.rootActionCache.set(
cacheKey,
result
);
}
return result;
}
function chooseMultiPlyRootEntriesMain(
gameState,
entries,
context
) {
if (
!entries.length ||
!context
) {
return entries;
}
const ordered =
entries.map(
entry => ({
entry,
order:
entry.immediateDelta *
16 +
tacticalActionOrderMain(
gameState,
entry.action
) -
(
Number(
entry
.nextReplyScoringReplies
) || 0
) *
0.15 +
Math.random() * 0.2
})
);
ordered.sort(
(first, second) =>
second.order -
first.order
);
const candidates =
ordered
.slice(
0,
Math.min(
context.candidateLimit,
ordered.length
)
)
.map(
item => item.entry
);
const safe = [];
const unknown = [];
const forced = [];
for (
const entry of candidates
) {
const result =
forcedFutureScoringThreatMain(
gameState,
entry.action,
{
context
}
);
entry.futureThreatStatus =
result.status;
entry.forcedFutureScoreLoss =
result.loss;
entry.forcedFutureDistance =
result.distance;
entry.forcedFutureLine =
result.line;
if (
result.status === 'safe'
) {
safe.push(entry);
if (
safe.length >=
context.safeResultLimit
) {
break;
}
} else if (
result.status ===
'forced'
) {
forced.push(entry);
} else {
unknown.push(entry);
}
}
if (safe.length) {
return safe;
}
if (unknown.length) {
return unknown;
}
if (!forced.length) {
return candidates;
}
let remaining =
forced.slice();
let minimumLoss =
Infinity;
for (
const entry of remaining
) {
minimumLoss = Math.min(
minimumLoss,
Number(
entry
.forcedFutureScoreLoss
) || 0
);
}
remaining =
remaining.filter(
entry =>
Math.abs(
(
Number(
entry
.forcedFutureScoreLoss
) || 0
) -
minimumLoss
) <=
TACTICAL_MAIN_EPSILON
);
let maximumDistance = 0;
for (
const entry of remaining
) {
maximumDistance = Math.max(
maximumDistance,
Number(
entry
.forcedFutureDistance
) || 0
);
}
remaining =
remaining.filter(
entry =>
(
Number(
entry
.forcedFutureDistance
) || 0
) >=
maximumDistance
);
let bestImmediate =
-Infinity;
for (
const entry of remaining
) {
bestImmediate = Math.max(
bestImmediate,
entry.immediateDelta
);
}
return remaining.filter(
entry =>
entry.immediateDelta >=
bestImmediate -
TACTICAL_MAIN_EPSILON
);
}
"""
source = replace_once(
source,
""" // 主執行緒版根節點安全過濾。""",
main_tactical_code
+ """ // 主執行緒版根節點安全過濾。""",
"插入主執行緒多層戰術搜尋",
)
# ----------------------------------------------------------
# 9. 主執行緒：重寫 fallback 根安全過濾
# ----------------------------------------------------------
main_filter_function = r""" function filterRootPlacementActionsMain(
gameState,
actions,
options = {}
) {
if (
!Array.isArray(actions) ||
!actions.length
) {
return [];
}
const rootPlayer =
gameState.turn;
const beforeScore =
calculatePlacementScore(
gameState.board
);
const entries = [];
for (const action of actions) {
if (
!action ||
action.kind !== 'place'
) {
continue;
}
const board =
gameState.board.slice();
board[action.i] = {
player: rootPlayer,
type: action.t,
rot: action.r
};
const afterScore =
calculatePlacementScore(
board
);
const immediateDelta =
rootPlayer === 0
? afterScore -
beforeScore
: beforeScore -
afterScore;
const rootLonelyCreated =
placementCreatesOwnLonelyNumberMain(
gameState,
action
)
? 1
: 0;
const replyThreat =
nextReplyLonelyThreatMain(
gameState,
action
);
entries.push({
action,
immediateDelta,
rootLonelyCreated,
nextReplyLonelyValue:
replyThreat.value,
nextReplyLonelyReplies:
replyThreat.replies,
nextReplyScoreLoss:
null,
nextReplyScoringReplies:
null,
futureThreatStatus:
null,
forcedFutureScoreLoss:
0,
forcedFutureDistance:
0
});
}
if (!entries.length) {
return [];
}
function ensureScoringThreat(
entry
) {
if (
entry.nextReplyScoreLoss !==
null
) {
return;
}
const threat =
nextReplyScoringThreatMain(
gameState,
entry.action,
false
);
entry.nextReplyScoreLoss =
threat.loss;
entry.nextReplyScoringReplies =
threat.replies;
}
const provisionalSafe =
entries.filter(
entry =>
entry.rootLonelyCreated ===
0 &&
entry.immediateDelta >= 0 &&
entry.nextReplyLonelyValue ===
0
);
// 打亂同級候選，避免固定棋種次序。
for (
let index =
provisionalSafe.length - 1;
index > 0;
index--
) {
const other =
Math.floor(
Math.random() *
(index + 1)
);
const temporary =
provisionalSafe[index];
provisionalSafe[index] =
provisionalSafe[other];
provisionalSafe[other] =
temporary;
}
const tacticalContext =
makeForcedScoringContextMain({
budgetMs:
Number(
options.tacticalBudgetMs
) || 280,
nodeLimit:
Number(
options.tacticalNodeLimit
) || 100000,
maxOpponentTurns:
Number(
options.maxOpponentTurns
) || 2,
candidateLimit:
Number(
options.candidateLimit
) || 28,
safeResultLimit:
Number(
options.safeResultLimit
) || 6
});
const onePlySafe = [];
// 多層搜尋前，先收集足夠的一手安全候選。
// 根候選數有上限，但每個候選內的防守分支不抽樣。
const collectionLimit =
Math.max(
tacticalContext
.candidateLimit * 2,
32
);
for (
const entry of
provisionalSafe
) {
ensureScoringThreat(entry);
if (
entry.nextReplyScoreLoss <=
TACTICAL_MAIN_EPSILON
) {
onePlySafe.push(entry);
if (
onePlySafe.length >=
collectionLimit
) {
break;
}
}
}
if (onePlySafe.length) {
const selected =
chooseMultiPlyRootEntriesMain(
gameState,
onePlySafe,
tacticalContext
);
if (selected.length) {
return selected.map(
entry => entry.action
);
}
}
// 沒有任何一手安全走法時，維持最小傷害策略。
for (const entry of entries) {
ensureScoringThreat(entry);
}
let remaining =
entries.slice();
function keepMinimum(
getter
) {
let minimum = Infinity;
for (
const entry of remaining
) {
minimum = Math.min(
minimum,
Number(getter(entry)) ||
0
);
}
remaining =
remaining.filter(
entry =>
Math.abs(
(
Number(
getter(entry)
) || 0
) -
minimum
) <=
TACTICAL_MAIN_EPSILON
);
}
keepMinimum(
entry =>
entry.rootLonelyCreated
);
keepMinimum(
entry =>
entry.nextReplyScoreLoss
);
keepMinimum(
entry =>
entry
.nextReplyScoringReplies
);
keepMinimum(
entry =>
entry.nextReplyLonelyValue
);
keepMinimum(
entry =>
entry.nextReplyLonelyReplies
);
let bestDelta = -Infinity;
for (
const entry of remaining
) {
bestDelta = Math.max(
bestDelta,
entry.immediateDelta
);
}
return remaining
.filter(
entry =>
entry.immediateDelta >=
bestDelta -
TACTICAL_MAIN_EPSILON
)
.map(
entry => entry.action
);
}
"""
source = replace_section_once(
source,
""" function filterRootPlacementActionsMain(""",
""" function calculateLeftoverLonelyScore(""",
main_filter_function,
"重寫主執行緒根節點安全過濾",
)
# ----------------------------------------------------------
# 10. fallback 可排除已證明危險的原行動
# ----------------------------------------------------------
source = replace_once(
source,
""" function fallbackAction() {""",
""" function fallbackAction(
excludedPlacementAction = null
) {""",
"讓 fallback 支援排除危險行動",
)
source = replace_once(
source,
""" const allActions =
getLegalPlacements(state);
if (!allActions.length) return null;""",
""" const allActions =
getLegalPlacements(state)
.filter(action => {
if (
!excludedPlacementAction ||
excludedPlacementAction
.kind !== 'place'
) {
return true;
}
return !(
action.i ===
excludedPlacementAction.i &&
action.t ===
excludedPlacementAction.t &&
normalizedRotation(
action.r
) ===
normalizedRotation(
excludedPlacementAction.r
)
);
});
if (!allActions.length) return null;""",
"在 fallback 中排除已證明危險的行動",
)
# ----------------------------------------------------------
# 11. AI 執行 Worker 結果前加入多層最後檢查
# ----------------------------------------------------------
source = replace_once(
source,
""" const replyScoreThreat =
nextReplyScoringThreatMain(
state,
action,
true
);
if (""",
""" const replyScoreThreat =
nextReplyScoringThreatMain(
state,
action,
true
);
// 最後保險：
// 確定性檢查 B-C-D 強制得分線。
// 此處只有「forced」才攔截；
// unknown 不會被錯誤標記成已證明安全。
const futureScoreThreat =
forcedFutureScoringThreatMain(
state,
action,
{
budgetMs: 300,
nodeLimit: 110000,
maxOpponentTurns: 2,
candidateLimit: 1,
safeResultLimit: 1
}
);
if (""",
"在 AI 行動執行前進行多層戰術檢查",
)
source = replace_once(
source,
""" createsImmediateLonely ||
replyThreat.value > 0 ||
replyScoreThreat.loss > 1e-9
) {""",
""" createsImmediateLonely ||
replyThreat.value > 0 ||
replyScoreThreat.loss > 1e-9 ||
futureScoreThreat.status ===
'forced'
) {""",
"攔截已證明的多層強制送分棋",
)
source = replace_once(
source,
""" const saferAction =
fallbackAction();""",
""" const saferAction =
fallbackAction(action);""",
"最後檢查失敗時排除原危險行動",
)
# ----------------------------------------------------------
# 12. 驗證
# ----------------------------------------------------------
required_fragments = [
"<!-- MULTI_PLY_FORCED_SCORING_GUARD_V1 -->",
"function makeForcedScoringContext(",
"function tacticalOpponentNode(",
"function tacticalRootNode(",
"function forcedFutureScoringThreat(",
"function chooseMultiPlyRootEntries(",
"context.tactical",
"counter.tactical",
"function makeForcedScoringContextMain(",
"function tacticalOpponentNodeMain(",
"function tacticalRootNodeMain(",
"function forcedFutureScoringThreatMain(",
"futureScoreThreat.status ===",
"fallbackAction(action)",
]
missing = [
fragment
for fragment in required_fragments
if fragment not in source
]
if missing:
raise RuntimeError(
"補丁完成後驗證失敗，缺少以下內容：\n - "
+ "\n - ".join(missing)
)
# 避免意外重複插入主要函式。
unique_fragments = [
"function forcedFutureScoringThreat(",
"function tacticalOpponentNode(",
"function tacticalRootNode(",
"function forcedFutureScoringThreatMain(",
"function tacticalOpponentNodeMain(",
"function tacticalRootNodeMain(",
]
duplicates = [
fragment
for fragment in unique_fragments
if source.count(fragment) != 1
]
if duplicates:
raise RuntimeError(
"補丁完成後發現重複或缺失函式：\n - "
+ "\n - ".join(duplicates)
)
return source
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description=(
"為 Battle Number 248 加入"
"多層 minimax 強制得分安全搜尋。"
)
)
parser.add_argument(
"input",
nargs="?",
default="battlenumber248.html",
help="輸入 HTML，預設為 battlenumber248.html",
)
parser.add_argument(
"output",
nargs="?",
default="battlenumber249.html",
help="輸出 HTML，預設為 battlenumber249.html",
)
return parser.parse_args()
def main() -> int:
args = parse_args()
input_path = Path(args.input)
output_path = Path(args.output)
if not input_path.is_file():
print(
f"錯誤：找不到輸入檔案：{input_path}",
file=sys.stderr,
)
return 1
try:
source = input_path.read_text(
encoding="utf-8"
)
except Exception as error:
print(
f"錯誤：無法讀取輸入檔案：{error}",
file=sys.stderr,
)
return 1
if PATCH_MARKER in source:
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
source,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print(
f"檔案已包含 {PATCH_MARKER}；"
f"未重複修改，已輸出至：{output_path}"
)
return 0
try:
patched = patch_html(source)
except Exception as error:
print(
f"補丁失敗：{error}",
file=sys.stderr,
)
return 1
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
patched,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print("補丁完成。")
print(f"輸入：{input_path}")
print(f"輸出：{output_path}")
print()
print("新增功能：")
print(" 1. 確定性搜尋 A-B-C-D 強制得分線")
print(" 2. 高深度及長思考時間可延伸至 A-B-C-D-E-F")
print(" 3. 對方節點採 exists，防守節點採 forall")
print(" 4. 完整檢查合法防守，不以隨機 rollout 代替證明")
print(" 5. 搜尋結果區分 safe、forced、unknown")
print(" 6. unknown 不會被誤當成已證明安全")
print(" 7. MCTS、alpha-beta、fallback 共用戰術規則")
print(" 8. Worker 結果執行前再次進行 B-C-D 檢查")
print(" 9. 全部走法皆失分時選擇損失較小、較遲失分者")
return 0
if __name__ == "__main__":
raise SystemExit(main())執行：
bash
python patch_battlenumber_multi_ply_safety.py battlenumber248.html battlenumber249.html搜尋深度的實際含義
一般模式至少檢查：
text
目前 AI 的候選落子 A
對方鋪墊 B
AI 的所有合法防守 C
對方得分 D也就是判定：
∃B∀C∃D當自訂搜尋深度至少為 5 回合，而且思考時間不少於 8 秒時，Worker 會嘗試延伸成：
text
A → B → C → D → E → F因此也能尋找第二次鋪墊後的強制得分。
unknown 的處理
這個補丁不會在搜尋超時時錯誤宣稱安全：
text
safe 已完整證明可防守
forced 已完整證明所有防守都失敗
unknown 尚未完成證明根節點選擇順序是：
text
safe > unknown > forced所以：
- 有已證明安全棋時，只交給 MCTS 安全棋；
- 沒有已證明安全棋但仍有未完成候選時，保留
unknown； - 所有候選都被證明會失分時，才從
forced中選擇損失最小、得分距離最遠的一手。
這樣不會把「沒搜完」錯當成「絕對安全」，同時也不會因為時間不足就任意判死所有走法。
提问者這個版本的「安全棋」是否包含「落子階段己方的棋子因無法落下而判負」？比如當前玩家二有三個「圍三」，而場上只有三個地方能放「圍三」，但是如果對方擠佔了其中一個地方，則玩家二將會因無法合規落下一個「圍三」而判負。
QuanAI**不完全包含。**這個版本只會偵測「搜尋樹中實際走到己方回合時，已經完全沒有合法落子」的情況，不會主動判斷「剩餘棋子數量大於未來可用位置數量，因此遲早必敗」。
目前能偵測的情況
Worker 中的 tacticalRootNode() 有：
javascript
const actions =
orderedTacticalPlacements(state);
if (!actions.length) {
const result =
tacticalResult(
'forced',
RAW_FORFEIT_SCORE,
ply
);
return result;
}主執行緒版本 tacticalRootNodeMain() 也有同樣處理：
javascript
if (!actions.length) {
const result =
tacticalResultMain(
'forced',
TACTICAL_MAIN_FORFEIT_LOSS,
ply
);
return result;
}因此，如果搜尋到：
text
AI 落 A
→ 對方落 B
→ 輪到 AI，但 AI 已經完全沒有合法棋可落它會把 A 判定為 forced，而不是 safe。
相反地，如果沒有合法落子的是對方，程式會把它視為對己方安全，這一點是合理的。
你的「三個圍三、只有三個位置」例子
假設玩家二還有：
text
圍三 × 3場上剛好只有三個位置可以放圍三。對方走了一步，占掉其中一個位置，剩下：
text
圍三 × 3
可用位置 × 2此時玩家二可能仍然有合法落子，因為其中兩個位置還能放圍三。
目前程式只會詢問：
text
現在是否至少有一手合法落子？不會額外推理：
text
剩餘 3 枚圍三只能配對到 2 個位置，
所以即使現在還能下一枚，將來必定有一枚無處可放。因此，這種「庫存容量不足」並不會立即被判定為必敗。
還有搜尋邊界問題
普通設定的搜尋線是：
text
A → B → C → D但目前在對方節點有以下截斷：
javascript
if (
child.done ||
child.phase !== 'place' ||
opponentTurnsLeft <= 1
) {
continue;
}所以普通深度實際上會：
- 檢查 B 之後，己方是否還能走 C；
- 模擬己方 C；
- 模擬對方 D；
- 但 D 落下後不會再進入己方節點檢查 E 是否存在。
也就是說：
text
A → B → C → D
↓
AI 已無合法 E這種情況在普通 maxOpponentTurns = 2 下可能被漏掉，甚至錯誤返回 safe。
較長搜尋：
text
A → B → C → D → E → F可以偵測 D 之後是否還有合法 E，但仍然不檢查 F 之後是否存在 G。因此它仍然只是有限深度安全，而不是落子階段直到結束的安全證明。
尤其執行 Worker 結果前的最後檢查固定使用：
javascript
maxOpponentTurns: 2所以最後保險也存在相同邊界。
結論
| 情況 | 目前版本 |
|---|---|
| 對方下一步後，己方立即完全無合法棋 | 會偵測為 forced |
| 己方仍能走一步，但剩餘特殊棋子的可用位置已不足 | 不會立即偵測 |
| 對方在普通搜尋的最後一步 D 後，使己方無合法 E | 可能漏掉 |
| 更深層才發生無棋可下 | 超出深度就不會偵測 |
| 一直證明到落子階段結束都不會判負 | 沒有做到 |
所以目前的 safe 準確含義應該是：
在已搜尋到的有限深度內，沒有證明對方能造成分數損失或在已展開的己方節點令己方無合法落子。
它不等於：
已證明己方剩餘所有棋子最終都有地方可放。
建議的修正方向
至少應做兩層修正：
1. 修正深度邊界
每次落子後，應該在深度截斷之前先檢查下一位玩家是否有合法落子。這樣即使 D 是搜尋的最後一步，也能發現己方沒有 E：
javascript
const nextActions =
allPlacementActions(child);
if (!nextActions.length) {
if (child.turn === rootPlayer) {
return tacticalResult(
'forced',
RAW_FORFEIT_SCORE,
ply + 1
);
}
// 沒有合法落子的是對方，該分支不是己方的必敗線。
continue;
}主執行緒版本也需要對 getLegalPlacements(child) 做相同處理。
2. 加入剩餘棋子容量檢查
對每種剩餘棋子計算：
text
剩餘數量
對應的可放位置集合簡單情況可以先檢查：
text
某棋種剩餘數量 > 該棋種可用格數你的例子便會得到：
text
圍三剩餘數量 = 3
圍三可用位置 = 2
3 > 2從而立即標記為庫存不可完成。
更完整的版本則應建立「剩餘棋子實例 ↔ 可落位置」的二分圖，使用最大匹配檢查是否能為所有剩餘棋子分配互不衝突的位置。不過，如果某個位置是否合法會隨後續鄰接棋子改變，單純以目前盤面做最大匹配只能作為保守篩選，真正的必敗證明仍需要搜尋。
因此，針對你描述的風險，答案是：現版本只涵蓋立即無棋可下，不完整涵蓋因位置被逐步擠占而造成的未來判負。
提问者QuanAI我会检查附件中的棋谱解析、落子合法性、战术安全搜索与评分判定，定位 d6i 未被识别为未来失 5 分的具体边界错误，再据实际源码生成可校验的一次性 Python 补丁。
找到原因了。這個局面的 5 分損失形成過程是：
text
o → d5l → c4t → d6i → c6t → d7j → e7u → c7q最後被封閉的區域中：
- 玩家一：
o(2) + c4t(3) + c6t(3) + e7u(3) = 11 - 玩家二：
d5l(2) + d6i(1) + d7j(1) + c7q(2) = 6
所以玩家二淨失 5 分。
舊版漏判的原因是：
regionScore()只計算已完全封閉的區域；d6i落下後該區域仍未封閉，所以目前分數仍是 0；- 一般戰術搜尋只看到：
text
A=d6i → B=c6t → C=d7j → D=e7u- 真正產生負 5 分的是下一手
E=c7q； - 因此
d6i被錯誤歸入「目前沒有失分」的安全候選。
下面的補丁增加「狹窄混合區域封閉風險」：
- 找出由棋子開口互相連接的棋子群；
- 若棋子群同時包含雙方棋子；
- 且只剩 1～2 個空格出口；
- 就估算該區域日後封閉時己方可能承受的分差；
- 在其他即時安全條件相同時，硬性保留封閉風險最低的候選。
在指定局面中：
| 候選 | 結果 |
|---|---|
d6i | 留下兩個出口，玩家二在該棋群中落後 2 點，具有封閉風險 |
| 其他不處理該區域的棋 | 原棋群只剩一個出口，玩家二落後 3 點 |
d6 放正確方向的圍三 | 把區域接上並立即封閉，雙方皆為 5 點，風險為 0 |
因此圍三會被硬性排在 d6i 前面。
將以下內容保存為 patch_battlenumber250.py：
python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
修復 battlenumber249.html 中未辨識狹窄未封閉混合區域的問題。
預設：
輸入：battlenumber249.html
輸出：battlenumber250.html
用法：
python patch_battlenumber250.py
或：
python patch_battlenumber250.py \
battlenumber249.html \
battlenumber250.html
"""
from __future__ import annotations
import argparse
import sys
from pathlib import Path
PATCH_MARKER = "NARROW_MIXED_CLOSURE_RISK_GUARD_V1"
def replace_once(
text: str,
old: str,
new: str,
label: str,
) -> str:
count = text.count(old)
if count != 1:
raise RuntimeError(
f"{label}：預期找到 1 個替換位置，"
f"實際找到 {count} 個。"
)
return text.replace(old, new, 1)
def patch_html(source: str) -> str:
# ----------------------------------------------------------
# 1. 加入版本標記
# ----------------------------------------------------------
source = replace_once(
source,
""" <!-- MULTI_PLY_FORCED_SCORING_GUARD_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
""" <!-- MULTI_PLY_FORCED_SCORING_GUARD_V1 -->
<!-- NARROW_MIXED_CLOSURE_RISK_GUARD_V1 -->
<script id="mctsWorkerSource" type="text/plain">""",
"加入狹窄混合區域風險版本標記",
)
# ----------------------------------------------------------
# 2. Worker：加入未封閉混合棋群風險分析
# ----------------------------------------------------------
worker_risk_code = r"""
// NARROW_MIXED_CLOSURE_RISK_GUARD_V1
//
// regionScore 只會計算已經完全封閉的區域。
//
// 因此以下形狀在真正封閉之前，regionScore 仍然是零：
//
// 己方與對方棋子已由開口連成一群，
// 但整個棋群只剩一至兩個空格出口。
//
// 這類狹窄棋群非常容易在數手後被封閉。若根玩家在棋群
// 內的三角形數量較少，就存在尚未反映於目前分數中的
// 潛在損失。
//
// 本函式只分析「已放置棋子之間的開口連通關係」：
//
// - 相鄰兩枚棋子的接觸邊都沒有實邊，視為同一棋群；
// - 棋子開口朝向空格，該空格視為棋群出口；
// - 同一空格即使被兩個開口接觸，也只計算一次；
// - 只評估同時含有雙方棋子的棋群；
// - 只把剩餘一至兩個出口的棋群視為緊急封閉風險。
//
// maximumLoss：
// 單一危險棋群中，根玩家最大的三角形劣勢。
//
// weightedLoss：
// 所有危險棋群的加權總和。
// 出口越少，權重越高。
function narrowMixedClosureRisk(
board,
rootPlayer
) {
const noRisk = {
maximumLoss: 0,
weightedLoss: 0,
components: 0,
minimumOpenCells: 0
};
if (
!board ||
(rootPlayer !== 0 &&
rootPlayer !== 1)
) {
return noRisk;
}
const visited =
new Uint8Array(SIZE);
let maximumLoss = 0;
let weightedLoss = 0;
let components = 0;
let minimumOpenCells =
Infinity;
for (
let start = 0;
start < SIZE;
start++
) {
if (
visited[start] ||
!board[start]
) {
continue;
}
const stack = [start];
visited[start] = 1;
const triangles = [0, 0];
let ownerMask = 0;
const openCells =
new Set();
while (stack.length) {
const index =
stack.pop();
const code =
board[index];
if (!code) {
continue;
}
const player =
tilePlayer(code);
triangles[player] +=
TRI[tileType(code)];
ownerMask |=
1 << player;
const row =
Math.floor(index / N);
const col =
index % N;
for (
let direction = 0;
direction < 4;
direction++
) {
// 棋子本身在這一側有實邊，
// 因而不能由這一側與其他格連通。
if (
codeHasEdge(
code,
direction
)
) {
continue;
}
const nextRow =
row +
D4[direction][0];
const nextCol =
col +
D4[direction][1];
// 棋盤邊界本身是封閉邊，
// 不是棋群出口。
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
const next =
nextRow * N +
nextCol;
const neighbour =
board[next];
if (!neighbour) {
openCells.add(next);
continue;
}
// 鄰棋朝向目前棋子的實邊會封閉連通。
if (
codeHasEdge(
neighbour,
(direction + 2) & 3
)
) {
continue;
}
if (!visited[next]) {
visited[next] = 1;
stack.push(next);
}
}
}
const openCount =
openCells.size;
// 必須同時含有雙方棋子。
if (ownerMask !== 3) {
continue;
}
// 已封閉區域由 regionScore 負責；
// 出口太多的區域尚未形成緊迫封閉風險。
if (
openCount < 1 ||
openCount > 2
) {
continue;
}
const opponent =
1 - rootPlayer;
const deficit =
triangles[opponent] -
triangles[rootPlayer];
if (
deficit <=
TACTICAL_SCORE_EPSILON
) {
continue;
}
components++;
maximumLoss = Math.max(
maximumLoss,
deficit
);
weightedLoss +=
deficit / openCount;
minimumOpenCells = Math.min(
minimumOpenCells,
openCount
);
}
return {
maximumLoss,
weightedLoss,
components,
minimumOpenCells:
Number.isFinite(
minimumOpenCells
)
? minimumOpenCells
: 0
};
}
function narrowClosureEffectValue(
entry,
property
) {
if (
!entry ||
!entry.effect
) {
return 0;
}
const value =
Number(
entry.effect[property]
);
return Number.isFinite(value)
? Math.max(0, value)
: 0;
}
// 在其他一手安全條件相同時，先選擇狹窄混合棋群
// 封閉風險最低的候選。
//
// 比較順序：
// 1. 單一棋群最大潛在損失；
// 2. 所有危險棋群的加權總損失。
function preferLowerNarrowClosureRisk(
entries
) {
if (
!Array.isArray(entries) ||
entries.length <= 1
) {
return entries || [];
}
let bestMaximum =
Infinity;
let bestWeighted =
Infinity;
for (const entry of entries) {
const maximum =
narrowClosureEffectValue(
entry,
'latentClosureMaximumLoss'
);
const weighted =
narrowClosureEffectValue(
entry,
'latentClosureWeightedLoss'
);
if (
maximum <
bestMaximum -
TACTICAL_SCORE_EPSILON
) {
bestMaximum = maximum;
bestWeighted = weighted;
continue;
}
if (
Math.abs(
maximum - bestMaximum
) <=
TACTICAL_SCORE_EPSILON &&
weighted <
bestWeighted -
TACTICAL_SCORE_EPSILON
) {
bestWeighted = weighted;
}
}
return entries.filter(entry => {
const maximum =
narrowClosureEffectValue(
entry,
'latentClosureMaximumLoss'
);
const weighted =
narrowClosureEffectValue(
entry,
'latentClosureWeightedLoss'
);
return (
Math.abs(
maximum - bestMaximum
) <=
TACTICAL_SCORE_EPSILON &&
Math.abs(
weighted - bestWeighted
) <=
TACTICAL_SCORE_EPSILON
);
});
}
"""
source = replace_once(
source,
""" // MULTI_PLY_FORCED_SCORING_GUARD_V1""",
worker_risk_code
+ """ // MULTI_PLY_FORCED_SCORING_GUARD_V1""",
"插入 Worker 狹窄混合區域風險分析",
)
# ----------------------------------------------------------
# 3. Worker：在候選落子後計算封閉風險
# ----------------------------------------------------------
source = replace_once(
source,
""" const afterScore =
regionScore(state.board);
let rootLonelyCreated = 0;""",
""" const afterScore =
regionScore(state.board);
const closureRisk =
narrowMixedClosureRisk(
state.board,
rootPlayer
);
let rootLonelyCreated = 0;""",
"Worker 候選落子後計算狹窄棋群風險",
)
source = replace_once(
source,
""" opponentLonelyResolved,
changesLonelyState,
// 新落下的棋是否能被對方下一手合法封成孤獨數。""",
""" opponentLonelyResolved,
changesLonelyState,
// 尚未反映在 regionScore 中的狹窄混合區域風險。
latentClosureMaximumLoss:
closureRisk.maximumLoss,
latentClosureWeightedLoss:
closureRisk.weightedLoss,
latentClosureComponents:
closureRisk.components,
latentClosureMinimumOpenCells:
closureRisk.minimumOpenCells,
// 新落下的棋是否能被對方下一手合法封成孤獨數。""",
"把 Worker 封閉風險寫入落子效果",
)
# 非落子 action 的預設效果也補齊欄位。
source = replace_once(
source,
""" opponentLonelyResolved: 0,
changesLonelyState: false,
nextReplyLonelyValue: 0,""",
""" opponentLonelyResolved: 0,
changesLonelyState: false,
latentClosureMaximumLoss: 0,
latentClosureWeightedLoss: 0,
latentClosureComponents: 0,
latentClosureMinimumOpenCells: 0,
nextReplyLonelyValue: 0,""",
"補齊 Worker 預設封閉風險欄位",
)
# ----------------------------------------------------------
# 4. Worker：安全候選先按封閉風險硬性縮小
# ----------------------------------------------------------
source = replace_once(
source,
""" if (
onePlySafeEntries.length
) {
return chooseMultiPlyRootEntries(
state,
onePlySafeEntries,
rootPlayer,
tacticalContext
);
}""",
""" if (
onePlySafeEntries.length
) {
// regionScore 尚未計分，不代表該棋形沒有危險。
//
// 例如：
//
// o d5l c4t
//
// 此時若在 d6 落下單一，雖然目前分數仍為零，
// 卻會留下只剩兩個出口的混合棋群。先以潛在封閉
// 損失過濾，才能優先選擇把該區域接上並封住的圍三。
const closurePreferredEntries =
preferLowerNarrowClosureRisk(
onePlySafeEntries
);
return chooseMultiPlyRootEntries(
state,
closurePreferredEntries,
rootPlayer,
tacticalContext
);
}""",
"讓 Worker 安全候選優先降低封閉風險",
)
# ----------------------------------------------------------
# 5. 主執行緒：加入相同風險分析
# ----------------------------------------------------------
main_risk_code = r"""
// NARROW_MIXED_CLOSURE_RISK_GUARD_V1_MAIN
//
// 主執行緒版本。規則與 Worker 的
// narrowMixedClosureRisk 完全相同。
function narrowMixedClosureRiskMain(
board,
rootPlayer
) {
const noRisk = {
maximumLoss: 0,
weightedLoss: 0,
components: 0,
minimumOpenCells: 0
};
if (
!Array.isArray(board) ||
(
rootPlayer !== 0 &&
rootPlayer !== 1
)
) {
return noRisk;
}
const visited =
new Uint8Array(SIZE);
let maximumLoss = 0;
let weightedLoss = 0;
let components = 0;
let minimumOpenCells =
Infinity;
for (
let start = 0;
start < SIZE;
start++
) {
if (
visited[start] ||
!board[start]
) {
continue;
}
const stack = [start];
visited[start] = 1;
const triangles = [0, 0];
let ownerMask = 0;
const openCells =
new Set();
while (stack.length) {
const index =
stack.pop();
const tile =
board[index];
if (!tile) {
continue;
}
triangles[tile.player] +=
TRIANGLES[tile.type];
ownerMask |=
1 << tile.player;
const row =
Math.floor(index / N);
const col =
index % N;
for (
let direction = 0;
direction <
DIRECTIONS.length;
direction++
) {
if (
tileHasEdge(
tile,
direction
)
) {
continue;
}
const nextRow =
row +
DIRECTIONS[
direction
][0];
const nextCol =
col +
DIRECTIONS[
direction
][1];
if (
nextRow < 0 ||
nextRow >= N ||
nextCol < 0 ||
nextCol >= N
) {
continue;
}
const next =
nextRow * N +
nextCol;
const neighbour =
board[next];
if (!neighbour) {
openCells.add(next);
continue;
}
if (
tileHasEdge(
neighbour,
(direction + 2) & 3
)
) {
continue;
}
if (!visited[next]) {
visited[next] = 1;
stack.push(next);
}
}
}
const openCount =
openCells.size;
if (ownerMask !== 3) {
continue;
}
if (
openCount < 1 ||
openCount > 2
) {
continue;
}
const opponent =
1 - rootPlayer;
const deficit =
triangles[opponent] -
triangles[rootPlayer];
if (
deficit <=
TACTICAL_MAIN_EPSILON
) {
continue;
}
components++;
maximumLoss = Math.max(
maximumLoss,
deficit
);
weightedLoss +=
deficit / openCount;
minimumOpenCells = Math.min(
minimumOpenCells,
openCount
);
}
return {
maximumLoss,
weightedLoss,
components,
minimumOpenCells:
Number.isFinite(
minimumOpenCells
)
? minimumOpenCells
: 0
};
}
function narrowMixedClosureRiskAfterPlacementMain(
gameState,
action
) {
if (
!gameState ||
!action ||
action.kind !== 'place' ||
!Number.isInteger(action.i) ||
action.i < 0 ||
action.i >= SIZE ||
gameState.board[action.i]
) {
return {
maximumLoss: 0,
weightedLoss: 0,
components: 0,
minimumOpenCells: 0
};
}
const board =
gameState.board.slice();
board[action.i] = {
player: gameState.turn,
type: action.t,
rot: action.r
};
return narrowMixedClosureRiskMain(
board,
gameState.turn
);
}
function narrowClosureEntryValueMain(
entry,
property
) {
if (!entry) {
return 0;
}
const value =
Number(entry[property]);
return Number.isFinite(value)
? Math.max(0, value)
: 0;
}
function preferLowerNarrowClosureRiskMain(
entries
) {
if (
!Array.isArray(entries) ||
entries.length <= 1
) {
return entries || [];
}
let bestMaximum =
Infinity;
let bestWeighted =
Infinity;
for (const entry of entries) {
const maximum =
narrowClosureEntryValueMain(
entry,
'latentClosureMaximumLoss'
);
const weighted =
narrowClosureEntryValueMain(
entry,
'latentClosureWeightedLoss'
);
if (
maximum <
bestMaximum -
TACTICAL_MAIN_EPSILON
) {
bestMaximum = maximum;
bestWeighted = weighted;
continue;
}
if (
Math.abs(
maximum - bestMaximum
) <=
TACTICAL_MAIN_EPSILON &&
weighted <
bestWeighted -
TACTICAL_MAIN_EPSILON
) {
bestWeighted = weighted;
}
}
return entries.filter(entry => {
const maximum =
narrowClosureEntryValueMain(
entry,
'latentClosureMaximumLoss'
);
const weighted =
narrowClosureEntryValueMain(
entry,
'latentClosureWeightedLoss'
);
return (
Math.abs(
maximum - bestMaximum
) <=
TACTICAL_MAIN_EPSILON &&
Math.abs(
weighted - bestWeighted
) <=
TACTICAL_MAIN_EPSILON
);
});
}
function isNarrowClosureRiskStrictlyLowerMain(
candidate,
current
) {
const candidateMaximum =
Number(candidate?.maximumLoss) ||
0;
const currentMaximum =
Number(current?.maximumLoss) ||
0;
if (
candidateMaximum <
currentMaximum -
TACTICAL_MAIN_EPSILON
) {
return true;
}
if (
candidateMaximum >
currentMaximum +
TACTICAL_MAIN_EPSILON
) {
return false;
}
const candidateWeighted =
Number(candidate?.weightedLoss) ||
0;
const currentWeighted =
Number(current?.weightedLoss) ||
0;
return (
candidateWeighted <
currentWeighted -
TACTICAL_MAIN_EPSILON
);
}
"""
source = replace_once(
source,
""" // MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN""",
main_risk_code
+ """ // MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN""",
"插入主執行緒狹窄混合區域風險分析",
)
# ----------------------------------------------------------
# 6. 主執行緒 fallback：為每個候選計算風險
# ----------------------------------------------------------
source = replace_once(
source,
""" const afterScore =
calculatePlacementScore(
board
);
const immediateDelta =""",
""" const afterScore =
calculatePlacementScore(
board
);
const closureRisk =
narrowMixedClosureRiskMain(
board,
rootPlayer
);
const immediateDelta =""",
"主執行緒候選落子後計算封閉風險",
)
source = replace_once(
source,
""" immediateDelta,
rootLonelyCreated,
nextReplyLonelyValue:""",
""" immediateDelta,
rootLonelyCreated,
latentClosureMaximumLoss:
closureRisk.maximumLoss,
latentClosureWeightedLoss:
closureRisk.weightedLoss,
latentClosureComponents:
closureRisk.components,
latentClosureMinimumOpenCells:
closureRisk.minimumOpenCells,
nextReplyLonelyValue:""",
"把主執行緒封閉風險寫入候選資料",
)
# ----------------------------------------------------------
# 7. 主執行緒安全候選先按封閉風險縮小
# ----------------------------------------------------------
source = replace_once(
source,
""" if (onePlySafe.length) {
const selected =
chooseMultiPlyRootEntriesMain(
gameState,
onePlySafe,
tacticalContext
);
if (selected.length) {""",
""" if (onePlySafe.length) {
const closurePreferred =
preferLowerNarrowClosureRiskMain(
onePlySafe
);
const selected =
chooseMultiPlyRootEntriesMain(
gameState,
closurePreferred,
tacticalContext
);
if (selected.length) {""",
"讓主執行緒安全候選優先降低封閉風險",
)
# ----------------------------------------------------------
# 8. Worker 行動執行前也檢查封閉風險
# ----------------------------------------------------------
source = replace_once(
source,
""" const replyScoreThreat =
nextReplyScoringThreatMain(
state,
action,
true
);
// 最後保險：""",
""" const replyScoreThreat =
nextReplyScoringThreatMain(
state,
action,
true
);
const closureRisk =
narrowMixedClosureRiskAfterPlacementMain(
state,
action
);
// 最後保險：""",
"在最終行動檢查中計算封閉風險",
)
old_final_check = """ if (
createsImmediateLonely ||
replyThreat.value > 0 ||
replyScoreThreat.loss > 1e-9 ||
futureScoreThreat.status ===
'forced'
) {
const saferAction =
fallbackAction(action);
if (
saferAction &&
actionIsLegal(saferAction)
) {
action = saferAction;
}
}"""
new_final_check = """ const immediateOrForcedDanger =
createsImmediateLonely ||
replyThreat.value > 0 ||
replyScoreThreat.loss > 1e-9 ||
futureScoreThreat.status ===
'forced';
const hasNarrowClosureDanger =
closureRisk.maximumLoss >
TACTICAL_MAIN_EPSILON ||
closureRisk.weightedLoss >
TACTICAL_MAIN_EPSILON;
if (
immediateOrForcedDanger ||
hasNarrowClosureDanger
) {
const saferAction =
fallbackAction(action);
if (
saferAction &&
actionIsLegal(saferAction)
) {
if (immediateOrForcedDanger) {
action = saferAction;
} else {
const saferClosureRisk =
narrowMixedClosureRiskAfterPlacementMain(
state,
saferAction
);
// 單純因潛在封閉風險而替換時，
// 新行動必須確實具有更低風險。
if (
isNarrowClosureRiskStrictlyLowerMain(
saferClosureRisk,
closureRisk
)
) {
action = saferAction;
}
}
}
}"""
source = replace_once(
source,
old_final_check,
new_final_check,
"更新 AI 行動執行前的封閉風險攔截",
)
# ----------------------------------------------------------
# 9. 驗證補丁結果
# ----------------------------------------------------------
required_fragments = [
"<!-- NARROW_MIXED_CLOSURE_RISK_GUARD_V1 -->",
"function narrowMixedClosureRisk(",
"function preferLowerNarrowClosureRisk(",
"latentClosureMaximumLoss:",
"latentClosureWeightedLoss:",
"const closurePreferredEntries =",
"function narrowMixedClosureRiskMain(",
"function narrowMixedClosureRiskAfterPlacementMain(",
"function preferLowerNarrowClosureRiskMain(",
"function isNarrowClosureRiskStrictlyLowerMain(",
"const closurePreferred =",
"const hasNarrowClosureDanger =",
"isNarrowClosureRiskStrictlyLowerMain(",
]
missing = [
fragment
for fragment in required_fragments
if fragment not in source
]
if missing:
raise RuntimeError(
"補丁完成後驗證失敗，缺少以下內容：\n - "
+ "\n - ".join(missing)
)
unique_fragments = [
"function narrowMixedClosureRisk(",
"function preferLowerNarrowClosureRisk(",
"function narrowMixedClosureRiskMain(",
"function narrowMixedClosureRiskAfterPlacementMain(",
"function preferLowerNarrowClosureRiskMain(",
"function isNarrowClosureRiskStrictlyLowerMain(",
]
duplicates = [
fragment
for fragment in unique_fragments
if source.count(fragment) != 1
]
if duplicates:
raise RuntimeError(
"補丁完成後發現函式重複或缺失：\n - "
+ "\n - ".join(duplicates)
)
return source
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description=(
"為 Battle Number 249 加入"
"狹窄混合區域封閉風險判定。"
)
)
parser.add_argument(
"input",
nargs="?",
default="battlenumber249.html",
help="輸入 HTML，預設為 battlenumber249.html",
)
parser.add_argument(
"output",
nargs="?",
default="battlenumber250.html",
help="輸出 HTML，預設為 battlenumber250.html",
)
return parser.parse_args()
def main() -> int:
args = parse_args()
input_path = Path(args.input)
output_path = Path(args.output)
if not input_path.is_file():
print(
f"錯誤：找不到輸入檔案：{input_path}",
file=sys.stderr,
)
return 1
try:
source = input_path.read_text(
encoding="utf-8"
)
except Exception as error:
print(
f"錯誤：無法讀取輸入檔案：{error}",
file=sys.stderr,
)
return 1
if PATCH_MARKER in source:
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
source,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print(
f"輸入檔案已包含 {PATCH_MARKER}；"
f"未重複修改，已輸出至：{output_path}"
)
return 0
try:
patched = patch_html(source)
except Exception as error:
print(
f"補丁失敗：{error}",
file=sys.stderr,
)
return 1
try:
output_path.parent.mkdir(
parents=True,
exist_ok=True,
)
output_path.write_text(
patched,
encoding="utf-8",
)
except Exception as error:
print(
f"錯誤：無法寫入輸出檔案：{error}",
file=sys.stderr,
)
return 1
print("補丁完成。")
print(f"輸入：{input_path}")
print(f"輸出：{output_path}")
print()
print("修復內容：")
print(" 1. 偵測只剩一至兩個出口的混合棋群")
print(" 2. 計算己方在該棋群中的潛在封閉分差")
print(" 3. 安全候選先最小化單一棋群最大風險")
print(" 4. 再最小化所有危險棋群的加權總風險")
print(" 5. Worker、alpha-beta、MCTS 與 fallback 使用相同規則")
print(" 6. Worker 行動執行前再次檢查封閉風險")
print()
print("指定局面修復：")
print(" o d5l c4t 之後，d6i 不再視為等價安全棋。")
print(" 正確方向的 d6 圍三會接上並封閉 5：5 區域，")
print(" 其封閉風險為 0，因此優先於 d6i。")
return 0
if __name__ == "__main__":
raise SystemExit(main())執行：
bash
python patch_battlenumber250.py battlenumber249.html battlenumber250.html這次修復不是把指定棋譜寫成特例，也沒有硬編碼 d6。它會普遍處理以下棋形：
text
雙方棋子已經由開口連成一個混合棋群
→ 棋群只剩一至兩個空格出口
→ 己方三角形數量落後
→ 目前 regionScore 因尚未封閉而仍顯示為 0因此相同類型的「現在看似沒失分，但數手後封閉就失分」局面也會一起被攔截。
提问者補丁失敗：插入 Worker 狹窄混合區域風險分析：預期找到 1 個替換位置，實際找到 2 個。
QuanAI失敗原因是縮排造成的「子字串誤匹配」。
腳本搜尋的是：
python
""" // MULTI_PLY_FORCED_SCORING_GUARD_V1"""這串以 6 個空格開頭，但主執行緒中的：
javascript
// MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN以 8 個空格開頭，其中從第 3 個空格開始，也包含「6 個空格＋// MULTI...」這個子字串，因此 str.count() 得到 2。
修正方法
在搜尋字串前加入換行，讓縮排必須從行首開始匹配。
1. 修改 Worker 插入位置
找到：
python
source = replace_once(
source,
""" // MULTI_PLY_FORCED_SCORING_GUARD_V1""",
worker_risk_code
+ """ // MULTI_PLY_FORCED_SCORING_GUARD_V1""",
"插入 Worker 狹窄混合區域風險分析",
)替換成：
python
source = replace_once(
source,
"""
// MULTI_PLY_FORCED_SCORING_GUARD_V1""",
worker_risk_code
+ """ // MULTI_PLY_FORCED_SCORING_GUARD_V1""",
"插入 Worker 狹窄混合區域風險分析",
)關鍵差異是搜尋字串現在包含前面的換行：
python
"""
// MULTI_PLY_FORCED_SCORING_GUARD_V1"""這樣只會匹配真正以 6 個空格開頭的 Worker 標記，不會匹配以 8 個空格開頭的主執行緒標記。
2. 同時加固主執行緒插入位置
找到：
python
source = replace_once(
source,
""" // MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN""",
main_risk_code
+ """ // MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN""",
"插入主執行緒狹窄混合區域風險分析",
)替換成：
python
source = replace_once(
source,
"""
// MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN""",
main_risk_code
+ """ // MULTI_PLY_FORCED_SCORING_GUARD_V1_MAIN""",
"插入主執行緒狹窄混合區域風險分析",
)雖然這一處目前通常只會匹配一次，但加上行首限制會更穩定。
修正後重新執行
bash
python patch_battlenumber250.py battlenumber249.html battlenumber250.html如果之前失敗時沒有成功寫出 battlenumber250.html，直接重新執行即可。若曾生成不完整的輸出檔，建議先刪除：
bash
rm -f battlenumber250.html
python patch_battlenumber250.py battlenumber249.html battlenumber250.htmlWindows 命令提示字元可用：
bat
del battlenumber250.html
python patch_battlenumber250.py battlenumber249.html battlenumber250.html這次只需修改上述兩個搜尋錨點，其他補丁內容不必改動。
提问者這個版本是否可以應付以下場景：當一方已經有多個棋子構成三角形數量很多的棋群，將能連上AI控制方的弱子時，AI能封閉或擋住對方棋子的蔓延和連接。
QuanAI只能部分應付，不能完整處理你描述的場景。
目前這版補丁主要防的是：
雙方棋子已經連成同一棋群，且棋群只剩 1～2 個出口，AI 在棋群內的三角形數量落後。
它不是一般性的「阻止對方大型棋群擴張／連接弱子」判定。
目前可以攔截的情況
narrowMixedClosureRisk() 只有在以下條件全部成立時才會回報風險：
javascript
ownerMask === 3
openCount >= 1
openCount <= 2
opponentTriangles > rootTriangles也就是：
- 對方大型棋群與 AI 弱子已經透過開口連通；
- 連通後屬於雙方混合棋群；
- 整個棋群只剩 1～2 個空格出口；
- AI 在其中的三角形數量落後；
- 存在另一個一手安全候選，能讓該風險更低。
例如：
text
對方大型棋群 ─ 開口 ─ AI 弱子
│
只剩 1～2 個出口此時，如果 AI 有一手棋能封住接觸邊、切斷連通或安全封閉區域，補丁可能會優先選它。
目前無法可靠攔截的情況
1. 雙方尚未連接
例如：
text
對方大型棋群 ─ 空格 ─ AI 弱子若對方下一手可以落在中間空格，把兩邊接起來，目前函式看見的仍是兩個獨立棋群：
- 對方棋群只有對方棋子，
ownerMask !== 3 - AI 弱子棋群只有 AI 棋子，
ownerMask !== 3
兩者都會被跳過：
javascript
if (ownerMask !== 3) {
continue;
}所以目前版本不會把這個中間空格識別為「對方下一手的高價值連接點」。
2. 混合棋群有 3 個以上出口
目前有：
javascript
if (
openCount < 1 ||
openCount > 2
) {
continue;
}因此即使對方棋群很大、AI 弱子很小，只要連通棋群還有 3 個以上出口，就不會被當成緊急風險。
例如：
text
對方 15 點棋群 ─ AI 1 點弱子
│ │ │
出口 出口 出口即使分差很大，也會因 openCount > 2 被忽略。
3. 對方需要兩手才能蔓延到 AI 弱子
目前的風險分析只檢查候選落下之後的靜態棋盤，不會沿著空格分析：
text
對方棋群 → 空格 A → 空格 B → AI 弱子這種兩段以上的「蔓延路徑」不在目前補丁的偵測範圍內。
4. 對方下一手能建立高價值連接，但還不會立即得分
現有的其他防護主要檢查：
- 立即孤獨數；
- 對方下一手得分；
- 多手強迫得分；
- 已經形成的狹窄混合棋群。
如果對方下一手只是把大型棋群接到 AI 弱子，尚未立即封閉、尚未立即得分，則：
javascript
nextReplyScoringThreat(...)很可能仍回傳 0。
但戰略上，AI 其實已經陷入不利。這正是目前缺少的「連接威脅」層。
5. 只看三角形分差，沒有衡量蔓延能力
目前風險值是：
javascript
const deficit =
triangles[opponent] -
triangles[rootPlayer];它沒有進一步考慮：
- 對方棋群有多少個可延伸邊；
- 哪個空格能同時連上多個棋群；
- 對方下一手有哪些棋型和旋轉可完成連接；
- AI 能否用實邊封住接觸方向；
- 該連接點是否是唯一瓶頸；
- 對方連接後能否繼續吞併其他弱子；
- 對方是否能在下一手強制完成連接。
所以「三角形很多」目前只是連通後的分差指標，不是蔓延威脅指標。
結論
目前版本的能力可概括如下：
| 場景 | 是否能可靠處理 |
|---|---|
| 雙方已連通、只剩 1～2 個出口、AI 落後 | 可以 |
| AI 本手能直接封閉既有狹窄混合棋群 | 可以 |
| 對方棋群與 AI 弱子尚隔一個空格 | 不可靠 |
| 對方下一手可透過關鍵空格連接 | 尚未專門處理 |
| 混合棋群有 3 個以上出口 | 不處理 |
| 對方需要兩手以上才能蔓延過來 | 不處理 |
| 多個對方棋群可在同一格匯合 | 不處理 |
| 需要選擇封邊方向來阻止連接 | 只可能間接選到，不保證 |
| 對方連接後尚未立即得分 | 通常不會被現有得分防護攔截 |
因此，對你的問題，準確答案是：
如果對方大型棋群和 AI 弱子已經形成狹窄混合區域，這版可以處理；如果對方尚未連上、只是準備在下一手蔓延或連接，這版通常無法可靠預防。
建議增加的判定
需要再加入一層獨立的：
text
OPPONENT_CLUSTER_CONNECTION_THREAT_GUARD它應該針對每個空格模擬「對方下一手落在此處」：
- 枚舉對方下一手可用棋型及旋轉；
- 判斷該棋能連上哪些既有棋群；
- 計算對方連入的三角形總量；
- 計算被連入的 AI 棋群三角形總量；
- 判斷是否把對方大型棋群接到 AI 弱子；
- 找出這些連接所依賴的關鍵空格或接觸方向；
- 優先選擇能：
- 封住關鍵接觸邊；
- 佔據關鍵空格；
- 把 AI 弱子先行封閉；
- 將弱子接入己方更強棋群；
- 或讓對方無法合法完成連接
的候選。
風險可以概念化為：
connectionRisk=opponentClusterStrength−rootClusterStrength+mergeBonus+futureExpansionBonus而且要比較 AI 落子前後的風險變化：
riskReduction=riskBefore−riskAfter這一點很重要：不能只看 AI 落子後是否仍有風險，而應優先選擇實際消除最多連接威脅的棋。
理想的決策順序
可以把目前的候選篩選順序擴展為：
text
立即送分／孤獨數
↓
對方下一手立即得分
↓
對方強迫得分
↓
對方下一手大型棋群連接弱子
↓
狹窄混合區域封閉風險
↓
MCTS／alpha-beta 評估所以不建議把目前的 NARROW_MIXED_CLOSURE_RISK_GUARD_V1 當作已經涵蓋「阻止大型棋群蔓延」。它只涵蓋其中較狹窄、較接近封閉的一類局面；要完整處理你提出的場景，還需要新增「對方下一手連接模擬」及「關鍵接點封鎖」判定。