/// <summary>
/// 探查结点
/// </summary>
/// <param name="boardKey">要查找的键值，应该是盘面的zobrist值</param>
/// <returns>找到指定键值的节点时返回该节点；找不到时返回null</returns>
public NodeOfSearch Probe(ulong boardKey)
{
int pos = Rehash(boardKey);
NodeOfSearch node = dict[pos];
if (node.Key == boardKey)
{
return(node);
}
else
{
return(NodeOfSearch.EmptyNode);
}
//byte* arrayPointer = (byte*)dict + pos * Marshal.SizeOf(typeof(NodeOfSearch));
//NodeOfSearch *node = (NodeOfSearch* ) arrayPointer;
//if (node->Key == boardKey)
//{
// node->Encode(out code1, out code2);
// return true;
//}
//code1 = 0;
//code2 = 0;
//return false;
}
/// <summary>
/// 在置换表中记录该结点
/// </summary>
/// <param name="node">结点</param>
public void RecordHash(NodeOfSearch node)
{
int pos = Rehash(node.Key);
dict[pos] = node;
// byte* arrayPointer = (byte*)dict + pos * Marshal.SizeOf(typeof(NodeOfSearch));
// NodeOfSearch* ptrNode = (NodeOfSearch*)arrayPointer;
// ptrNode->Key = node.Key;
// ptrNode->Depth = node.Depth;
// ptrNode->Score = node.Score;
// ptrNode->NodeType = node.NodeType;
// // 置换表的替换策略。
// // 也可能是搜索到了更好的结果！！！
// // (depth=2) a
// // / \
// // (depth=1) b c
// // / \ \
// // (depth=0) d e f (当前搜索的节点是f)
// // 假设b是以前搜索过的节点，已经保存在HASH表中，depth=1
// // 当前搜索的节点是f，depth=0，如果f与b的key在hash表中冲突，
// // 由于b的评估值是经过了更深层的搜索得到的，所以这时不替换b
// if (ptrNode->NodeType != NodeOfSearch.EMPTY_NODES)
// {
// //#ifdef _DEBUG
// // if( node.Key != nodeInTable->Key) {
// // totalCollision++;
// // if(nodeInTable->Depth < node.Depth)
// // countCollision++;
// // }
// //#endif
// return;
// }
// // 更新该节点，只能先删除，再加上了
//// dict.Remove(Rehash(node.Key));
//// dict.Add(Rehash(node.Key), node);
}
/// <summary>
/// 主要变例搜索
/// </summary>
/// <param name="depth">最底部的叶子结点为第0层</param>
/// <param name="alpha"></param>
/// <param name="beta"></param>
/// <returns></returns>
private int PVS(int depth, int alpha, int beta)
{
bool haveFoundPV = false;
ulong boardKey = board.ZobristKey; // Zobrist.ZoristHash(board);
BoardHistory[Ply] = boardKey;
if (IsRepetition(boardKey, Ply, BoardHistory, HalfmoveClock[Ply]))
{
bool redRepCheck = true;
bool blackRepCheck = true;
Board b = new Board(board);
for (int d = 0; d < HalfmoveClock[Ply]; d++)
{
if (Ply - d == 0)
{
break;
}
// TODO: 逻辑不合理的代码：关于将军的判断应该放在Board类中
MoveGenerator g = new MoveGenerator(b);
if (b.IsRedTurn)
{
if (redRepCheck && g.IsBlackKingSafe())
{
redRepCheck = false;
}
}
else
{
if (blackRepCheck && g.IsRedKingSafe())
{
blackRepCheck = false;
}
}
b.UnmakeMove(MoveHistory[Ply - d]);
if (board.ZobristKey == b.ZobristKey)
{
break;
}
}
if (redRepCheck && blackRepCheck)
{
return(0); //双方都长将，平局分数
}
if (redRepCheck)
{
return(-30000 + 100);
}
if (blackRepCheck)
{
return(30000 - 100);
}
return(0); // 双方都是允许着法时
}
// 探查置换表
NodeOfSearch entry = transpositionTable.Probe(boardKey);
// (depth=2) a
// / \
// (depth=1) entry<b> c 这里的b是已经搜索过的节点，已经保存在置换表中，entry.Depth = 1
// / \ \
// (depth=0) d e [f] (当前搜索的节点是f) depth = 0
// ..................
// 假设b是以前搜索过的节点，已经保存在置换表中，entry.depth=1
// 当前搜索的节点是f，depth=0，如果f与b的局面相同，由于b的评估值是经过了更深层的搜索得到的，
// 所以f可以直接用b的评估值，这个结果只会好，不会差，所以应该判断entry.Depth >= depth
if (entry.NodeType != NodeOfSearch.EMPTY_NODES && entry.Depth > depth)
{
switch (entry.NodeType)
{
case NodeOfSearch.PV_NODES:
return(entry.Score);
case NodeOfSearch.CUT_NODES:
// -------------\ /-----------------\
// 评估值的范围 | | 当前搜索窗口 |
//--------------+---------+-----------------+--
// entry.Score <= alpha beta
if (entry.Score <= alpha) // 剪枝！
{
return(alpha);
}
//-------------------------\
// 评估值的范围 |
// /-----------------+---------------\
// | 当前搜| 索窗口 |
//-------+-----------------+---------------+-------
// alpha entry.Score < beta
if (entry.Score < beta) //调整beta即可
{
beta = entry.Score;
}
break;
case NodeOfSearch.ALL_NODES:
// /-----------------\ /-------------
// | 当前搜索窗口 | |评估值的范围
//------+-----------------+------+--------------
// alpha beta <= entry.Score
if (beta <= entry.Score) // 剪枝！
{
return(beta);
}
// /-----------------------
// | 评估值的范围
// /-----------------+---------------\
// | 当前搜| 索窗口 |
//-------+-----------------+---------------+-------
// alpha < entry.Score beta
if (alpha < entry.Score) // 此时只要调整alpha即可
{
alpha = entry.Score;
}
break;
}
}
// 到达叶子节点
if (depth == 0)
{
int valueLeaf = Evaluator.EvaluateAllWithSide(board);
NodeOfSearch nodeLeaf = new NodeOfSearch(boardKey, depth, NodeOfSearch.PV_NODES, valueLeaf);
transpositionTable.RecordHash(nodeLeaf);
return(valueLeaf);
}
int nodeType = NodeOfSearch.ALL_NODES;
Move[] moveList = new Move[200];
int countMove = MoveGenerator.GenAllMoveList(board, moveList);
// 无着可走，说明是终止局面，即被将死
if (countMove == 0)
{
int scoreEndStatus = Evaluator.MIN_EVAL_VALUE + Ply;
NodeOfSearch nodeEnd = new NodeOfSearch(boardKey, depth, NodeOfSearch.PV_NODES, scoreEndStatus);
transpositionTable.RecordHash(nodeEnd);
return(scoreEndStatus);
}
// 利用了置换表中的历史评估数据，进行着法排序
// 局面"9/4a4/3k5/3N5/3N5/r8/9/9/9/4K4 w"
// 用迭代加深算法来测试效果：迭代加深计算到第8层
// DEBUG
// 不排序时1.7秒，探查并对着法排序时：17秒，代价很大
// Release
// 不排序时0.7秒，探查并对着法排序时:7秒
// if(depth == 0)
// SortMovelist(moveList, countMove);
Move bestMove = null;
for (int i = 0; i < countMove; i++)
{
++Ply; // 胜利局面中需要这个变量， -MAX + ply
MoveHistory[Ply] = moveList[i];
HalfmoveClock[Ply] = moveList[i].Irreversible ? 0 : HalfmoveClock[Ply - 1] + 1;
board.MakeMove(moveList[i]);
int score;
if (haveFoundPV)
{
score = -PVS(depth - 1, -alpha - 1, -alpha);
if ((score > alpha) && (score < beta))
{ // 检查失败
score = -PVS(depth - 1, -beta, -alpha);
}
}
else
{
score = -PVS(depth - 1, -beta, -alpha);
}
board.UnmakeMove(moveList[i]);
--Ply;
if (score >= beta)
{
//PrintDebugInfo("发生剪枝！bestScore >= beta: " + bestScore + " >= " + beta);
NodeOfSearch nodeBeta = new NodeOfSearch(boardKey, depth, NodeOfSearch.CUT_NODES, beta, moveList[i]);
transpositionTable.RecordHash(nodeBeta);
return(beta);
}
if (score > alpha)
{
// 这时只是记录alpha值的变化情况，并不写置换表
nodeType = NodeOfSearch.PV_NODES;
alpha = score;
bestMove = moveList[i];
//PrintDebugInfo("修改alpha: " + alpha);
}
if (engine != null && stopWatch.ElapsedMilliseconds > engine.timeLimit)
{
break;
}
}
NodeOfSearch node = new NodeOfSearch(boardKey, depth, nodeType, alpha, bestMove);
transpositionTable.RecordHash(node);
return(alpha);
}
/**********************************************************
* 带置换表的Alphabeta搜索算法的示例代码供参考：
* int AlphaBeta(int depth, int alpha, int beta) {
* int hashf = hashfALPHA;
* if ((val = ProbeHash(depth, alpha, beta)) != valUNKNOWN) {
* // 【valUNKNOWN必须小于-INFINITY或大于INFINITY，否则会跟评价值混淆。】
* return val;
* }
* if (depth == 0) {
* val = Evaluate();
* RecordHash(depth, val, hashfEXACT);
* return val;
* }
* GenerateLegalMoves();
* while (MovesLeft()) {
* MakeNextMove();
* val = -AlphaBeta(depth - 1, -beta, -alpha);
* UnmakeMove();
* if (val >= beta) {
* RecordHash(depth, beta, hashfBETA);
* return beta;
* }
* if (val > alpha) {
* hashf = hashfEXACT;
* alpha = val;
* }
* }
* RecordHash(depth, alpha, hashf);
* return alpha;
* }
*****************************************************************/
/// <summary>
///
/// </summary>
/// <param name="depth">最底部的叶子结点为第0层</param>
/// <param name="alpha"></param>
/// <param name="beta"></param>
/// <returns></returns>
private int NegaAlphaBetaTT(int depth, int alpha, int beta)
{
ulong boardKey = board.ZobristKey; // Zobrist.ZoristHash(board);
BoardHistory[Ply] = boardKey;
if (IsRepetition(boardKey, Ply, BoardHistory, HalfmoveClock[Ply]))
{
bool redRepCheck = true;
bool blackRepCheck = true;
Board b = board;
for (int d = 0; d < HalfmoveClock[Ply]; d++)
{
// TODO: 逻辑不合理的代码：关于将军的判断应该放在Board类中
MoveGenerator g = new MoveGenerator(b);
if (b.IsRedTurn)
{
if (redRepCheck && g.IsBlackKingSafe())
{
redRepCheck = false;
}
}
else
{
if (blackRepCheck && g.IsRedKingSafe())
{
blackRepCheck = false;
}
}
b.UnmakeMove(MoveHistory[Ply - d]);
}
if (redRepCheck && blackRepCheck)
{
return(0); //双方都长将，平局分数
}
if (redRepCheck)
{
return(-30000 + 100);
}
if (blackRepCheck)
{
return(30000 - 100);
}
return(0); // 双方都是允许着法时
}
// 探查置换表
//UInt64 code1, code2;
NodeOfSearch entry = transpositionTable.Probe(boardKey);
// (depth=2) a
// / \
// (depth=1) entry<b> c 这里的b是已经搜索过的节点，已经保存在置换表中，entry.Depth = 1
// / \ \
// (depth=0) d e [f] (当前搜索的节点是f) depth = 0
// ..................
// 假设b是以前搜索过的节点，已经保存在置换表中，entry.depth=1
// 当前搜索的节点是f，depth=0，如果f与b的局面相同，由于b的评估值是经过了更深层的搜索得到的，
// 所以f可以直接用b的评估值，这个结果只会好，不会差，所以应该判断entry.Depth >= depth
if (entry.NodeType != NodeOfSearch.EMPTY_NODES && entry.Depth > depth)
{
//PrintDebugInfo("Hash表命中！" + entry);
switch (entry.NodeType)
{
case NodeOfSearch.PV_NODES:
return(entry.Score);
case NodeOfSearch.CUT_NODES:
// -------------\ /-----------------\
// 评估值的范围 | | 当前搜索窗口 |
//--------------+---------+-----------------+--
// entry.Score <= alpha beta
if (entry.Score <= alpha) // 剪枝！
{
return(alpha);
}
//-------------------------\
// 评估值的范围 |
// /-----------------+---------------\
// | 当前搜| 索窗口 |
//-------+-----------------+---------------+-------
// alpha entry.Score < beta
if (entry.Score < beta) //调整beta即可
{
beta = entry.Score;
}
break;
case NodeOfSearch.ALL_NODES:
// /-----------------\ /-------------
// | 当前搜索窗口 | |评估值的范围
//------+-----------------+------+--------------
// alpha beta <= entry.Score
if (beta <= entry.Score) // 剪枝！
{
return(beta);
}
// /-----------------------
// | 评估值的范围
// /-----------------+---------------\
// | 当前搜| 索窗口 |
//-------+-----------------+---------------+-------
// alpha < entry.Score beta
if (alpha < entry.Score) // 此时只要调整alpha即可
{
alpha = entry.Score;
}
break;
}
}
// 到达叶子节点
if (depth == 0)
{
int valueLeaf = Evaluator.EvaluateAllWithSide(board);
// 应该肯定是EXACT节点吧？
/* if(v0 <= alpha)
* node.Type = NODE_ALPHA;
* else if(v0 >= beta)
* node.Type = NODE_BETA;
* else */
NodeOfSearch nodeLeaf = new NodeOfSearch(boardKey, depth, NodeOfSearch.PV_NODES, valueLeaf);
transpositionTable.RecordHash(nodeLeaf);
//DEBUG(DBG_DEBUG, SPACES[depth] << "到达最大深度:" << " return score: "<< v0);
return(valueLeaf);
}
int nodeType = NodeOfSearch.ALL_NODES;
Move[] moveList = new Move[200];
int countMove = MoveGenerator.GenAllMoveList(board, moveList);
// 无着可走，说明是终止局面，即被将死
if (countMove == 0)
{
// TODO: 杀棋分数调整 http://www.xqbase.com/computer/stepbystep5.htm
// (1) 对于RecordHash：置换表项记录的杀棋步数 = 实际杀棋步数 - 置换表项距离根节点的步数；
// (2) 对于ProbeHash：实际杀棋步数 = 置换表项记录的杀棋步数 + 置换表项距离根节点的步数。
int scoreEndStatus = Evaluator.MIN_EVAL_VALUE + Ply;
NodeOfSearch nodeEnd = new NodeOfSearch(boardKey, depth, NodeOfSearch.PV_NODES, scoreEndStatus);
transpositionTable.RecordHash(nodeEnd);
return(scoreEndStatus);
}
// 利用了置换表中的历史评估数据，进行着法排序
// 局面"9/4a4/3k5/3N5/3N5/r8/9/9/9/4K4 w"
// 用迭代加深算法来测试效果：迭代加深计算到第8层
// DEBUG
// 不排序时1.7秒，探查并对着法排序时：17秒，代价很大
// Release
// 不排序时0.7秒，探查并对着法排序时:7秒
// if(depth == 0)
// SortMovelist(moveList, countMove);
//int bestScore = Evaluator.MIN_EVAL_VALUE + depth;
Move bestMove = null;
for (int i = 0; i < countMove; i++)
{
++Ply; // 胜利局面中需要这个变量， -MAX + ply
MoveHistory[Ply] = moveList[i];
HalfmoveClock[Ply] = moveList[i].Irreversible ? 0 : HalfmoveClock[Ply - 1] + 1;
board.MakeMove(moveList[i]);
int score = -NegaAlphaBetaTT(depth - 1, -beta, -alpha);
board.UnmakeMove(moveList[i]);
--Ply;
//HalfmoveClock[Ply] = moveList[i].Irreversible ? 0 : HalfmoveClock[Ply - 1] + 1;
// 这里负责记录最佳着法
//if (score > bestScore)
//{
// bestScore = score;
// if(depth == 0) bestMove = moveList[i];
//}
if (score >= beta)
{
//PrintDebugInfo("发生剪枝！bestScore >= beta: " + bestScore + " >= " + beta);
// 这里记录refutation move
NodeOfSearch nodeBeta = new NodeOfSearch(boardKey, depth, NodeOfSearch.CUT_NODES, beta, moveList[i]);
transpositionTable.RecordHash(nodeBeta);
return(beta);
}
if (score > alpha)
{
// alpha = bestScore; // alpha = score????
// 这时只是记录alpha值的变化情况，并不写置换表
nodeType = NodeOfSearch.PV_NODES;
alpha = score;
bestMove = moveList[i];
//PrintDebugInfo("修改alpha: " + alpha);
}
}
NodeOfSearch node = new NodeOfSearch(boardKey, depth, nodeType, alpha, bestMove);
transpositionTable.RecordHash(node);
return(alpha);
}