int CAlphaBeta_TTEngine::AlphaBeta(int nDepth, int alpha, int beta)
{
int score;
int Count,i;
BYTE type;
int side;
i=IsGameOver(CurPosition,nDepth);
if(i!=0)
return i;
//察看当前节点是否在置换表中有有效数据
side=(m_nMaxDepth-nDepth)%2;
score=LookUpHashTable(alpha,beta,nDepth,side);
if(score!=66666)
return score;//命中，直接返回表中的值
//叶子节点取估值
if(nDepth<=0)
{
score=m_pEval->Eveluate(CurPosition,side,m_nUserChessColor);
EnterHashTable(exact,score,nDepth,side);//将求得的估值放进置换表
return score;
}
Count=m_pMG->CreatePossibleMove(CurPosition,nDepth,side,m_nUserChessColor);
if(nDepth==m_nMaxDepth)
{
//在根节点设定进度条
progress->setTotalSteps(Count);
progress->setProgress(1);
}
int eval_is_exact=0;//数据类型标志
for(i=0;i<Count;i++)//对当前节点的下一步每一可能的走法
{
if(nDepth==m_nMaxDepth)
progress->nextStep();
Hash_MakeMove(&m_pMG->m_MoveList[nDepth][i],CurPosition);//产生该走法所对应子节点的哈希值
type=MakeMove(&m_pMG->m_MoveList[nDepth][i]); //产生子节点
score=-AlphaBeta(nDepth-1,-beta,-alpha);//递归搜索子节点
Hash_UnMakeMove(&m_pMG->m_MoveList[nDepth][i],type,CurPosition);//恢复当前节点的哈希值
UnMakeMove(&m_pMG->m_MoveList[nDepth][i],type); //撤销子节点
if(score>=beta)//beta剪枝
{
EnterHashTable(lower_bound,score,nDepth,side);//将节点下边界存入置换表
return score;//返回下边界
}
if(score>alpha)
{
alpha=score; //取最大值
eval_is_exact=1;//设定确切值标志
if(nDepth==m_nMaxDepth)
m_cmBestMove=m_pMG->m_MoveList[nDepth][i];
}
}
//将搜索结果放进置换表
if(eval_is_exact)
EnterHashTable(exact,alpha,nDepth,side); //确切值
else
EnterHashTable(upper_bound,alpha,nDepth,side);//上边界
return alpha;//返回最佳值/上界
}
int CNegaScout::NegaScout(int depth, int alpha, int beta)
{
int Count,i;
BYTE type;
int a,b,t;
int side;
int score;
i = IsGameOver(CurPosition, depth);
if (i != 0)
return i;
side = (m_nMaxDepth-depth)%2;
score = LookUpHashTable(alpha, beta, depth, side);
if (score != 66666)
return score;
if (depth <= 0) //叶子节点取估值
{
score = m_pEval->Eveluate(CurPosition, side );
EnterHashTable(exact, score, depth, side );
return score;
}
Count = m_pMG->CreatePossibleMove(CurPosition, depth, side);
for (i=0;i<Count;i++)
{
m_pMG->m_MoveList[depth][i].Score =
GetHistoryScore(&m_pMG->m_MoveList[depth][i]);
}
MergeSort(m_pMG->m_MoveList[depth], Count, 0);
int bestmove=0;
a = alpha;
b = beta;
int eval_is_exact = 0;
for ( i = 0; i < Count; i++ )
{
Hash_MakeMove(&m_pMG->m_MoveList[depth][i], CurPosition);
type = MakeMove(&m_pMG->m_MoveList[depth][i]);
t = -NegaScout(depth-1 , -b, -a );
if (t > a && t < beta && i > 0)
{
a = -NegaScout (depth-1, -beta, -t ); /* re-search */
eval_is_exact = 1;
if(depth == m_nMaxDepth)
m_cmBestMove = m_pMG->m_MoveList[depth][i];
bestmove = i;
}
Hash_UnMakeMove(&m_pMG->m_MoveList[depth][i],type, CurPosition);
UnMakeMove(&m_pMG->m_MoveList[depth][i],type);
if (a < t)
{
eval_is_exact = 1;
a=t;
if(depth == m_nMaxDepth)
m_cmBestMove = m_pMG->m_MoveList[depth][i];
}
if ( a >= beta )
{
EnterHashTable(lower_bound, a, depth,side);
EnterHistoryScore(&m_pMG->m_MoveList[depth][i], depth);
return a;
}
b = a + 1; /* set new null window */
}
EnterHistoryScore(&m_pMG->m_MoveList[depth][bestmove], depth);
if (eval_is_exact)
EnterHashTable(exact, a, depth,side);
else
EnterHashTable(upper_bound, a, depth,side);
return a;
}
int CNegaScout_TT_HH::NegaScout(int depth, int alpha, int beta)
{
bool bIsSure = false;
int Count,i;
int a,b,t;
int side;
int score;
int mtype = (m_nMaxDepth%2 == depth%2) ? (-1) : (1);
CPublicToMakeMove ptmm;
i = IsGameOver(CurPosition, depth,mtype);
if (i != 0)
return i;
side = (m_nMaxDepth-depth)%2;
score = LookUpHashTable(alpha, beta, depth, side);
if (score != 6666666)
{
G_nCountTTHH++;
return score;
}
if (depth <= 0) //叶子节点取估值
{
int Now1 = GetTickCount();
score = m_pEval->Eveluate(CurPosition,mtype,(m_nMaxDepth-depth)%2);
ETime += GetTickCount() - Now1;
EnterHashTable(exact, score, depth, side );
return score;
}
int Now2 = GetTickCount();
Count = m_pMG->CreatePossibleMove(CurPosition, depth, mtype);
GTime += GetTickCount() - Now2;
if(1 == Count && depth == m_nMaxDepth)
{
m_cmBestMove = m_pMG->m_nMoveList[depth][0];
return 0;
}
for (i=0;i<Count;i++)
{
m_pMG->m_nMoveList[depth][i].Score =
GetHistoryScore(&m_pMG->m_nMoveList[depth][i]);
}
MergeSort(m_pMG->m_nMoveList[depth], Count, 0);
int bestmove=-1;
a = alpha;
b = beta;
int eval_is_exact = 0;
for ( i = 0; i < Count; i++ )
{
Hash_MakeMove(&m_pMG->m_nMoveList[depth][i], CurPosition);
MakeMove(&m_pMG->m_nMoveList[depth][i],ptmm);
t = -NegaScout(depth-1 , -b, -a);
if (t > a && t < beta && i > 0)
{
a = -NegaScout (depth-1, -beta, -t); /* re-search */
eval_is_exact = 1;
if(depth == m_nMaxDepth)
{
bIsSure = true;
Hash_UnMakeMove(&m_pMG->m_nMoveList[depth][i],CurPosition);
UnMakeMove(&m_pMG->m_nMoveList[depth][i],ptmm);
m_cmBestMove = m_pMG->m_nMoveList[depth][i];
}
bestmove = i;
}
if(bIsSure == false)
{
Hash_UnMakeMove(&m_pMG->m_nMoveList[depth][i],CurPosition);
UnMakeMove(&m_pMG->m_nMoveList[depth][i],ptmm);
}
else
{
bIsSure = false;
}
if (a < t)
{
eval_is_exact = 1;
a=t;
if(depth == m_nMaxDepth)
m_cmBestMove = m_pMG->m_nMoveList[depth][i];
}
if ( a >= beta )
{
EnterHashTable(lower_bound, a, depth,side);
EnterHistoryScore(&m_pMG->m_nMoveList[depth][i], depth);
return a;
}
b = a + 1; /* set new null window */
}
if (bestmove != -1)
EnterHistoryScore(&m_pMG->m_nMoveList[depth][bestmove], depth);
if (eval_is_exact)
EnterHashTable(exact, a, depth,side);
else
EnterHashTable(upper_bound, a, depth,side);
return a;
}
int CNegaScout_TT_HH::NegaScout(int iDepth, int iAlpha, int iBeta)
{
int iCount,iGameOver;
BYTE byChess;
int a,b,t;
int iSide;
int iScore;
int i;
iGameOver=IsGameOver(byCurChessBoard, iDepth);
if(iGameOver!=0)
return iGameOver;
iSide=(m_iMaxDepth-iDepth)%2;//计算当前节点的类型，极大0/极小1
iScore=LookUpHashTable(iAlpha,iBeta,iDepth,iSide);
if(iScore!=66666)
return iScore;
if(iDepth<=0)//叶子节点取估值
{
iScore=m_pEval->Eveluate(byCurChessBoard,iSide);
EnterHashTable(Exact,iScore,iDepth,iSide);//将估值存入置换表
return iScore;
}
iCount=m_pMG->CreatePossibleMove(byCurChessBoard,iDepth,iSide,m_nUserChessColor);
if(iDepth==m_iMaxDepth)
{
//在根节点设定进度条
m_pThinkProgress->SetRange(0,iCount);
m_pThinkProgress->SetStep(1);
}
for(i=0;i<iCount;i++)
m_pMG->m_MoveList[iDepth][i].iScore=GetHistoryScore(&m_pMG->m_MoveList[iDepth][i]);
MergeSort(m_pMG->m_MoveList[iDepth],iCount,0);
int bestmove=-1;
a=iAlpha;
b=iBeta;
int eval_is_exact=0;
for(i=0;i<iCount;i++)
{
if(iDepth==m_iMaxDepth)
m_pThinkProgress->StepIt();//走进度条
Hash_MakeMove(&m_pMG->m_MoveList[iDepth][i],byCurChessBoard);
byChess=MakeMove(&m_pMG->m_MoveList[iDepth][i]);
t=-NegaScout(iDepth-1,-b,-a);
if(t>a && t<iBeta && i>0)
{
//对于第一个后的节点，如果上面的搜索failhigh
a=-NegaScout(iDepth-1,-iBeta,-t);//递归搜索子节点
eval_is_exact=1;//设数据类型为精确值
if(iDepth==m_iMaxDepth)
m_cmBestMove=m_pMG->m_MoveList[iDepth][i];
bestmove=i;
}
Hash_UnMakeMove(&m_pMG->m_MoveList[iDepth][i],byChess,byCurChessBoard);
UnMakeMove(&m_pMG->m_MoveList[iDepth][i],byChess);
if(a<t)
{
eval_is_exact=1;
a=t;
if(iDepth==m_iMaxDepth)
m_cmBestMove=m_pMG->m_MoveList[iDepth][i];
}
if(a>=iBeta)
{
EnterHashTable(LowerBound,a,iDepth,iSide);
EnterHistoryScore(&m_pMG->m_MoveList[iDepth][i],iDepth);
return a;
}
b=a+1;//set new null window
}
if(bestmove!=-1)
EnterHistoryScore(&m_pMG->m_MoveList[iDepth][bestmove],iDepth);
if(eval_is_exact)
EnterHashTable(Exact,a,iDepth,iSide);
else
EnterHashTable(UpperBound,a,iDepth,iSide);
return a;
}
