前面已經講過了棋局表示、着法生成、搜索算法（包括搜索輔助）， 在象棋程序中若是說搜索算法是心臟，那麼局面評估就是大腦。搜索算法負責驅動整個程序，而局面評估則負責對搜索的內容進行判斷評價。於是搜索與局面評估是整個程序的核心。算法
首先，先介紹一下在局面評估中須要考慮的因素。就不一樣的棋類可能要考慮的因素略有差別。在中國象棋中所要考慮的最基本的幾個因素包括以下四點：數組
一、子力總和數據結構
子力是指某一棋子自己所具備的價值。通俗地講就是一個棋子它值個什麼價。例如，車值500的話，那可能馬值300，卒值80等等。因此在評估局面時，咱們首先要考慮雙方的子力總和的對比。好比紅方擁有士象全加車馬炮，而黑方只有殘士象加雙馬，則紅方明顯佔優。ide
二、棋子位置（控制區域）函數
棋子位置（或稱控制區域）是指某一方的棋子在棋盤上所佔據（控制）的位置。例如，沉底炮、過河卒、以及車佔士角等都是較好的棋子位置狀態，而窩心馬等則是較差的棋子位置狀態。post
三、棋子的機動性lua
棋子的機動性指棋子的靈活度（可移動性）。例如，起始位置的車機動性較差，因此咱們下棋講究早出車。一樣四面被憋馬腿的死馬機動性也較差。.net
四、棋子的相互關係（包括攻擊關係和保護關係）隊列
這一點的分析較爲複雜，由於一個棋子與不一樣的子之間每每存在多重關係。如：一個馬可能在對方的炮的攻擊之下同時它又攻擊着對方的車。遊戲
在個人程序中，估值函數最後返回的是雙方總分的差值，而各方的總分就是上面所提到的四個因素的打分的總和。
對於子力打分和控制區域打分，只要遍歷棋盤，當遇到棋子時簡單地去查事先定義好的「子力價值表」和「控制區域價值表」，取出相對應的值進行累加便可（這些具體值參考了前人的程序並做了適當的調整,從此仍應根據電腦下棋所反映出的實際問題對這些值做適當修改）。對於機動性打分，須要求出各個子總共有多少種走法，而後根據各個子所不一樣的機動性價值每多一種走法就加一次相應的分數。
對棋子相互關係的打分，我先定義了一個關係表的結構類型
typedef struct _relationtable{
BYTE nCChessID ;
int nUAttackCount ;
int nUGuardCount ;
BYTE UnderAttack[5];
BYTE UnderGurad[5];
} RelationTable;
RelationTable RelationOfMan[9][10]; // 關係表
其中nCChessID代表棋子類型，nUAttackCount和nUGuardCount分別記錄該正攻擊該子的棋子數量和正保護該子的棋子數量，UnderAttack[5]和UnderGuard[5]則存放攻擊該子和保護該子的具體棋子的類型。因考慮實戰中很難出現同時有超過五個棋子攻擊/保護一個子的狀況，故數組下標設定爲5。
當遍歷一遍棋盤以後，子力打分、控制區域打分和機動性打分均可以完成，而關係表也能夠填完。以後，再根據關係表來具體考察棋子的相互關係，進行關係打分。
分析關係時，首先，對王的攻擊保護應分離出來單獨考慮，由於對王的保護沒有任何意義，一旦王被吃掉整個遊戲就結束了。
其次，對一個普通子，當它既受到攻擊又受到保護的時候要注意以下幾個問題：
一、 攻擊者子力小於被攻擊者子力,攻擊方將願意換子。好比，一個車正遭受一個炮的攻擊，那麼任何對車的保護都將失去意義——對方確定樂意用一個炮來換一個車。
二、 多攻擊單保護的狀況，而且攻擊者最小子力小於被攻擊者子力與保護者子力之和,則攻擊方可能以一子換兩子。
三、 三攻擊兩保護的狀況，而且攻擊者子力較小的兩者之和小於被攻擊者子力與保護者子力之和,則攻擊方可能以兩子換三子。
四、 攻擊方與保護方數量相同，而且攻擊者子力小於被攻擊者子力與保護者子力之和再減去保護者中最大子力,則攻擊方可能以n子換n子。
可能上面這幾條說的你們有點暈，待會結合具體程序可能更易於理解。固然，上述四條只是覆蓋了最多見的幾種狀況，覆蓋並不全面。並且，並無直接地從新考慮雙方兌子以後的控制區域及機動性變化狀況（之因此說沒有直接考慮，是由於搜索繼續展開結點後仍會考慮這些因素，只是目前小生尚不知這樣效果是否受影響）。因此，若是下一步要對程序進行改進的話，應當在此多作文章……
下面是CChessEvaluate.h的代碼實現：
// CChessEvaluate.h
////////////////////// Type Define ////////////////////////////////////////////
typedef struct _relationtable{
BYTE nCChessID ;
int nUAttackCount ;
int nUGuardCount ;
BYTE UnderAttack[5];
BYTE UnderGurad[5];
} RelationTable;
/////////////////// Data Define ///////////////////////////////////////////////
POINT PointList[20]; // 目標點隊列
int nPointCount; // 目標點數目
RelationTable RelationOfMan[9][10]; // 關係表
const int MaxValue = 10000; // 最大極值（最小極值爲最大極值的負值）
//各子的基本價值（子力價值）
// 將， 士， 象， 馬， 車， 炮， 卒
const int BasicValues[15] = { 0, 0, 250, 250, 300, 500, 300, 80,
0, 250, 250, 300, 500, 300, 80 };
//各子的機動性價值（每多一步走法所加的分）
// 將， 士， 象， 馬， 車， 炮， 卒
const int MobilityValues[8] = { 0, 0, 1, 1, 12, 6, 6, 15 };
//各子的控制區域價值（所在的位置的價值）
const int PositionValues[8][90] = {
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
},
{ // 帥
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, -8, -9, 0, 0, 0, 0, 0, 0, 0,
5, -8, -9, 0, 0, 0, 0, 0, 0, 0,
1, -8, -9, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
},
{ // 士
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 3, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
},
{ // 相
0, 0, -2, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, -2, 0, 0, 0, 0, 0, 0, 0
},
{ // 馬
0, -3, 5, 4, 2, 2, 5, 4, 2, 2,
-3, 2, 4, 6, 10, 12, 20, 10, 8, 2,
2, 4, 6, 10, 13, 11, 12, 11, 15, 2,
0, 5, 7, 7, 14, 15, 19, 15, 9, 8,
2,-10, 4, 10, 15, 16, 12, 11, 6, 2,
0, 5, 7, 7, 14, 15, 19, 15, 9, 8,
2, 4, 6, 10, 13, 11, 12, 11, 15, 2,
-3, 2, 4, 6, 10, 12, 20, 10, 8, 2,
0, -3, 5, 4, 2, 2, 5, 4, 2, 2
},
{ // 車
-6, 5, -2, 4, 8, 8, 6, 6, 6, 6,
6, 8, 8, 9, 12, 11, 13, 8, 12, 8,
4, 6, 4, 4, 12, 11, 13, 7, 9, 7,
12, 12, 12, 12, 14, 14, 16, 14, 16, 13,
0, 0, 12, 14, 15, 15, 16, 16, 33, 14,
12, 12, 12, 12, 14, 14, 16, 14, 16, 13,
4, 6, 4, 4, 12, 11, 13, 7, 9, 7,
6, 8, 8, 9, 12, 11, 13, 8, 12, 8,
-6, 5, -2, 4, 8, 8, 6, 6, 6, 6
},
{ // 炮
0, 0, 1, 0, -1, 0, 0, 1, 2, 4,
0, 1, 0, 0, 0, 0, 3, 1, 2, 4,
1, 2, 4, 0, 3, 0, 3, 0, 0, 0,
3, 2, 3, 0, 0, 0, 2, -5, -4, -5,
3, 2, 5, 0, 4, 4, 4, -4, -7, -6,
3, 2, 3, 0, 0, 0, 2, -5, -4, -5,
1, 2, 4, 0, 3, 0, 3, 0, 0, 0,
0, 1, 0, 0, 0, 0, 3, 1, 2, 4,
0, 0, 1, 0, -1, 0, 0, 1, 2, 4
},
{ // 兵
0, 0, 0, -2, 3, 10, 20, 20, 20, 0,
0, 0, 0, 0, 0, 18, 27, 30, 30, 0,
0, 0, 0, -2, 4, 22, 30, 45, 50, 0,
0, 0, 0, 0, 0, 35, 40, 55, 65, 2,
0, 0, 0, 6, 7, 40, 42, 55, 70, 4,
0, 0, 0, 0, 0, 35, 40, 55, 65, 2,
0, 0, 0, -2, 4, 22, 30, 45, 50, 0,
0, 0, 0, 0, 0, 18, 27, 30, 30, 0,
0, 0, 0, -2, 3, 10, 20, 20, 20, 0
}
};
/////////////////// Function Prototype ////////////////////////////////////////
// 估值函數，返回對當前局面的估值。fWhoseTurn標誌當前輪到哪一方走棋
int Eveluate( int fWhoseTurn );
// 將目標點加入PointList隊列
inline void AddPointToQueue( BYTE x, BYTE y );
////////////////// Programmer-Defined Function ////////////////////////////////
int Eveluate( int fWhoseTurn )
{
int RedValues = 0; // 紅方總的分值
int BlackValues = 0; // 黑方總的分值
int nBasicVal[2] = { 0 , 0 }; // 雙方的子力值
int nMobilityVal[2] = { 0 , 0 }; // 雙方的機動性值
int nPositionVal[2] = { 0 , 0 }; // 雙方的控制區域值
int nRelationVal[2] = { 0 , 0 }; // 雙方的關係值（攻擊或保護）
BYTE nCChessID;
BYTE nTargetType;
int fSide;
int nPosition;
int i;
bool bHaveHalf;
//**** Reset RelationTable ****
memset( RelationOfMan, 0, sizeof(RelationTable)*90 );
int x, y;
for( x = 0; x <= 8; x ++ )
for( y = 0; y <= 9; y ++ )
{
if( CChessBoard[x][y] != 0 )
{
nCChessID = CChessBoard[x][y];
fSide = SideOfMan[ nCChessID ];
//+++++++++++求得棋子的基本價值以及它所佔據的位置的價值+++++++++++++++++
nPosition = x * 10 + y * 9 ;
if( fSide == RED )
{
nBasicVal[fSide] += BasicValues[nCChessID];
nPositionVal[fSide] += PositionValues[nCChessID][nPosition];
}
else
{
nBasicVal[fSide] += BasicValues[nCChessID];
nPositionVal[fSide] += PositionValues[nCChessID - 7][89 - nPosition];
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//求得棋子的全部目標位置（移動到的、攻擊的、保護的）
nPointCount = 0;
switch( nCChessID )
{
case RED_K:
// 將帥碰面
i = IsKingFaceToFace( x, y, fSide );
if( i != -1 )
AddPointToQueue( x, i );
//向前
if( y < 2 )
AddPointToQueue( x, y + 1 );
//向後
if( y > 0 )
AddPointToQueue( x, y - 1 );
//向左
if( x > 3 )
AddPointToQueue( x - 1, y );
//向右
if( x < 5 )
AddPointToQueue( x + 1, y );
break;
case BLACK_K:
// 將帥碰面
i = IsKingFaceToFace( x, y, fSide );
if( i != -1 )
AddPointToQueue( x, i );
//向前
if( y > 7 )
AddPointToQueue( x, y - 1 );
//向後
if( y < 9 )
AddPointToQueue( x, y + 1 );
//向左
if( x < 5 )
AddPointToQueue( x + 1, y );
//向右
if( x > 3 )
AddPointToQueue( x - 1, y );
break;
case RED_J: // fall through
case BLACK_J:
//縱向
for( i = y + 1; i <= 9; i ++ )
{
AddPointToQueue( x, i );
if( HaveMan( x, i ) )
break;
}
for( i = y - 1; i >= 0; i -- )
{
AddPointToQueue( x, i );
if( HaveMan( x, i ) )
break;
}
//橫向
for( i = x - 1; i >= 0; i -- )
{
AddPointToQueue( i, y );
if( HaveMan( i, y ) )
break;
}
for( i = x + 1; i <= 8; i ++ )
{
AddPointToQueue( i, y );
if( HaveMan( i, y ) )
break;
}
break;
case RED_M: // fall through
case BLACK_M:
if( y <= 7 && ! HaveMan( x, y + 1 ) )
{
//11點方向(相對紅馬)
if( x > 0 )
AddPointToQueue( x - 1, y + 2 );
//1點方向
if( x < 8 )
AddPointToQueue( x + 1, y + 2 );
}
if( x <= 6 && ! HaveMan( x + 1, y ) )
{
//2點方向
if( y < 9 )
AddPointToQueue( x + 2, y + 1 );
//4點方向
if( y > 0 )
AddPointToQueue( x + 2, y - 1 );
}
if( y >= 2 && ! HaveMan( x, y - 1 ) )
{
//5點方向
if( x < 8 )
AddPointToQueue( x + 1, y - 2 );
//7點方向
if( x > 0 )
AddPointToQueue( x - 1, y - 2 );
}
if( x >= 2 && ! HaveMan( x - 1, y ) )
{
//8點方向
if( y > 0 )
AddPointToQueue( x - 2, y - 1 );
//10點方向
if( y < 9 )
AddPointToQueue( x - 2, y + 1 );
}
break;
case RED_P: // fall through
case BLACK_P:
//縱向
bHaveHalf = false; //標誌還沒有發現中間子
for( i = y + 1; i <= 9; i ++ )
{
if( ! bHaveHalf ) // 無中間子
{
if( ! HaveMan( x, i ) )
{
AddPointToQueue( x, i );
}
else // if( HaveMan( x, i ) )
{
bHaveHalf = true;
}
}
else // 已有中間子
{
if( HaveMan( x, i ) )
{
AddPointToQueue( x, i );
break;
}
}
}
bHaveHalf = false; //標誌還沒有發現中間子
for( i = y - 1; i >= 0; i -- )
{
if( ! bHaveHalf ) // 無中間子
{
if( ! HaveMan( x, i ) )
{
AddPointToQueue( x, i );
}
else // if( HaveMan( x, i ) )
{
bHaveHalf = true;
}
}
else // 已有中間子
{
if( HaveMan( x, i ) )
{
AddPointToQueue( x, i );
break;
}
}
}
//橫向
bHaveHalf = false; //標誌還沒有發現中間子
for( i = x - 1; i >= 0; i -- )
{
if( ! bHaveHalf ) // 無中間子
{
if( ! HaveMan( i, y ) )
{
AddPointToQueue( i, y );
}
else // if( HaveMan( i, y ) )
{
bHaveHalf = true;
}
}
else // 已有中間子
{
if( HaveMan( i, y ) )
{
AddPointToQueue( i, y );
break;
}
}
}
bHaveHalf = false; //標誌還沒有發現中間子
for( i = x + 1; i <= 8; i ++ )
{
if( ! bHaveHalf ) // 無中間子
{
if( ! HaveMan( i, y ) )
{
AddPointToQueue( i, y );
}
else // if( HaveMan( i, y ) )
{
bHaveHalf = true;
}
}
else // 已有中間子
{
if( HaveMan( i, y ) )
{
AddPointToQueue( i, y );
break;
}
}
}
break;
case RED_X:
if( x == 0 )
{
if( ! HaveMan(1, 3) )
AddPointToQueue( 2, 4 );
if( ! HaveMan(1, 1) )
AddPointToQueue( 2, 0 );
}
else if( x == 2 )
{
if( y == 4 )
{
if( ! HaveMan(1, 3) )
AddPointToQueue( 0, 2 );
if( ! HaveMan(3, 3) )
AddPointToQueue( 4, 2 );
}
else // y == 0
{
if( ! HaveMan(1, 1) )
AddPointToQueue( 0, 2 );
if( ! HaveMan(3, 1) )
AddPointToQueue( 4, 2 );
}
}
else if( x == 4 )
{
if( ! HaveMan(3, 3) )
AddPointToQueue( 2, 4 );
if( ! HaveMan(3, 1) )
AddPointToQueue( 2, 0 );
if( ! HaveMan(5, 3) )
AddPointToQueue( 6, 4 );
if( ! HaveMan(5, 1) )
AddPointToQueue( 6, 0 );
}
else if( x == 6 )
{
if( y == 4 )
{
if( ! HaveMan(5, 3) )
AddPointToQueue( 4, 2 );
if( ! HaveMan(7, 3) )
AddPointToQueue( 8, 2 );
}
else // y == 0
{
if( ! HaveMan(5, 1) )
AddPointToQueue( 4, 2 );
if( ! HaveMan(7, 1) )
AddPointToQueue( 8, 2 );
}
}
else // x == 8
{
if( ! HaveMan(7, 3) )
AddPointToQueue( 6, 4 );
if( ! HaveMan(7, 1) )
AddPointToQueue( 6, 0 );
}
break;
case BLACK_X:
if( x == 0 )
{
if( ! HaveMan(1, 6) )
AddPointToQueue( 2, 5 );
if( ! HaveMan(1, 8 ) )
AddPointToQueue( 2, 9 );
}
else if( x == 2 )
{
if( y == 5 )
{
if( ! HaveMan(1, 6) )
AddPointToQueue( 0, 7 );
if( ! HaveMan(3, 6) )
AddPointToQueue( 4, 7 );
}
else // y == 9
{
if( ! HaveMan(1, 8 ) )
AddPointToQueue( 0, 7 );
if( ! HaveMan(3, 8 ) )
AddPointToQueue( 4, 7 );
}
}
else if( x == 4 )
{
if( ! HaveMan(3, 6) )
AddPointToQueue( 2, 5 );
if( ! HaveMan(3, 8 ) )
AddPointToQueue( 2, 9 );
if( ! HaveMan(5, 6) )
AddPointToQueue( 6, 5 );
if( ! HaveMan(5, 8 ) )
AddPointToQueue( 6, 9 );
}
else if( x == 6 )
{
if( y == 5 )
{
if( ! HaveMan(5, 6) )
AddPointToQueue( 4, 7 );
if( ! HaveMan(7, 6) )
AddPointToQueue( 8, 7 );
}
else // y == 9
{
if( ! HaveMan(5, 8 ) )
AddPointToQueue( 4, 7 );
if( ! HaveMan(7, 8 ) )
AddPointToQueue( 8, 7 );
}
}
else // x == 8
{
if( ! HaveMan(7, 6) )
AddPointToQueue( 6, 5 );
if( ! HaveMan(7, 8 ) )
AddPointToQueue( 6, 9 );
}
break;
case RED_S:
if( x == 3 )
{
AddPointToQueue( 4, 1 );
}
else if( x == 4 )
{
AddPointToQueue( 3, 2 );
AddPointToQueue( 3, 0 );
AddPointToQueue( 5, 2 );
AddPointToQueue( 5, 0 );
}
else // x == 5
{
AddPointToQueue( 4, 1 );
}
break;
case BLACK_S:
if( x == 3 )
{
AddPointToQueue( 4, 8 );
}
else if( x == 4 )
{
AddPointToQueue( 3, 7 );
AddPointToQueue( 3, 9 );
AddPointToQueue( 5, 7 );
AddPointToQueue( 5, 9 );
}
else // x == 5
{
AddPointToQueue( 4, 8 );
}
break;
case RED_B:
//向前
if( y < 9 )
AddPointToQueue( x, y + 1 );
if( y >= 5 ) //兵已過河
{
//向左
if( x > 0 )
AddPointToQueue( x - 1, y );
//向右
if( x < 8 )
AddPointToQueue( x + 1, y );
}
break;
case BLACK_B:
//向前
if( y > 0 )
AddPointToQueue( x, y - 1 );
if( y <= 4 ) //兵已過河
{
//向右
if( x > 0 )
AddPointToQueue( x - 1, y );
//向左
if( x < 8 )
AddPointToQueue( x + 1, y );
}
break;
} // end switch
for( i = 0; i < nPointCount; i ++ )
{
//保存目標位置的棋子情況
nTargetType = CChessBoard[ PointList[i].x ][ PointList[i].y ];
//++++++++++++++求得棋子的機動性價值++++++++++++++++++++++++++++++++++
// 目標位置爲空，機動性加分
if( nTargetType == 0 )
{
if( fSide == RED )
nMobilityVal[fSide] += MobilityValues[nCChessID];
else
nMobilityVal[fSide] += MobilityValues[nCChessID - 7];
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 目標位置爲對方棋子，將信息存入RelationOfMan中的UnderAttack
else if( SideOfMan[nTargetType] != fSide )
{
//對王受攻擊的狀況做單獨處理
if( nTargetType == RED_K )
{
if( fWhoseTurn == BLACK ) // 紅帥即將被將死
{
return MaxValue - 10; // 返回失敗極值（已驗證應爲 MaxValue ）
// 減去10表示此種狀況稍好於王已經被吃的狀況
}
else // 僅僅是將軍而已，關係值扣一點分
{
nRelationVal[RED] -= 20;
continue;
}
}
if( nTargetType == BLACK_K )
{
if( fWhoseTurn == RED ) // 黑將即將被將死
{
return MaxValue - 10; // 返回失敗極值（已驗證應爲 MaxValue ）
// 減去10表示此種狀況稍好於王已經被吃的狀況
}
else // 僅僅是將軍而已，關係值扣一點分
{
nRelationVal[BLACK] -= 20;
continue;
}
}
RelationOfMan[ PointList[i].x ][ PointList[i].y ]
.nCChessID = nTargetType ;
RelationOfMan[ PointList[i].x ][ PointList[i].y ]
.UnderAttack[RelationOfMan[ PointList[i].x ][ PointList[i].y ].nUAttackCount++]
= nCChessID ;
}
// 目標位置爲己方棋子，將信息存入RelationOfMan中的UnderGuard
else // if( SideOfMan[nTargetType] == fSide )
{
// 若受保護的是王，則不進行處理。由於王受保護毫無心義
if( nTargetType == RED_K || nTargetType == BLACK_K )
continue;
RelationOfMan[ PointList[i].x ][ PointList[i].y ]
.nCChessID = nTargetType ;
RelationOfMan[ PointList[i].x ][ PointList[i].y ]
.UnderGurad[RelationOfMan[ PointList[i].x ][ PointList[i].y ].nUGuardCount ++]
= nCChessID ;
}
} // end for( i = 0; i < nPointCount; i ++ )
} // end if( CChessBoard[x][y] != 0 )
} // end for x 0 to 8, y 0 to 9
//+++++++++++求得棋子的關係價值（受攻擊和受保護）++++++++++++++++++++++
for( x = 0; x <= 8; x ++ )
for( y = 0; y <= 9; y ++ )
{
int nAttack = 0; //用於記錄攻擊方總子力
int nGuard = 0; //用於記錄保護方總子力
int nMinAttack = 777; //用於記錄攻擊方最小子力
int nMaxAttack = 0; //用於記錄攻擊方最大子力
//int nMinGuard = 777; //用於記錄保護方最小子力
int nMaxGuard = 0; //用於記錄保護方最大子力
int nflagValue = 777; //用於表記是否有攻擊方子力低於被攻擊者,
//如有則其值爲攻擊方中最低子力
int nUnitValue; // 單位價值
if( RelationOfMan[x][y].nCChessID != 0 )
{
nCChessID = RelationOfMan[x][y].nCChessID;
fSide = SideOfMan[nCChessID];
nUnitValue = BasicValues[nCChessID] >> 3; // 單位價值取基本價值的1/8
// 統計攻擊方的子力
for( i = 0; i < RelationOfMan[x][y].nUAttackCount; i ++ )
{
// 查看是否有攻擊者子力小於被攻擊者子力,如有記錄其中子力最小的
if( BasicValues[ RelationOfMan[x][y].UnderAttack[i] ]
< BasicValues[nCChessID]
&& BasicValues[ RelationOfMan[x][y].UnderAttack[i] ] < nflagValue )
{
nflagValue = BasicValues[ RelationOfMan[x][y].UnderAttack[i] ] ;
}
if( BasicValues[ RelationOfMan[x][y].UnderAttack[i] ] < nMinAttack )
nMinAttack = BasicValues[ RelationOfMan[x][y].UnderAttack[i] ];
if( BasicValues[ RelationOfMan[x][y].UnderAttack[i] ] > nMaxAttack )
nMaxAttack = BasicValues[ RelationOfMan[x][y].UnderAttack[i] ];
nAttack += BasicValues[ RelationOfMan[x][y].UnderAttack[i] ];
}
// 統計防守方的子力
for( i = 0; i < RelationOfMan[x][y].nUGuardCount; i ++ )
{
//if( BasicValues[ RelationOfMan[x][y].UnderGurad[i] ] < nMinGuard )
// nMinGuard = BasicValues[ RelationOfMan[x][y].UnderGurad[i] ];
if( BasicValues[ RelationOfMan[x][y].UnderGurad[i] ] > nMaxGuard )
nMaxGuard = BasicValues[ RelationOfMan[x][y].UnderGurad[i] ];
nGuard += BasicValues[ RelationOfMan[x][y].UnderGurad[i] ];
}
if( nAttack == 0 ) // 沒受攻擊，而是隻有保護
{
nRelationVal[fSide] += 5 * RelationOfMan[x][y].nUGuardCount ;
}
else // 遭受攻擊
{
if( nGuard == 0) // 沒有保護
{
if( fWhoseTurn != fSide ) // 輪到對方行棋
{
nRelationVal[fSide] -= 5 * nUnitValue ;
}
else // 輪到己方行棋
{
nRelationVal[fSide] -= nUnitValue ;
}
}
else // 有保護
{
// 攻擊者子力小於被攻擊者子力,對方將願意換子
if( nflagValue != 777 )
{
if( fWhoseTurn != fSide ) // 輪到對方行棋
{
nRelationVal[fSide] -= 5 * nUnitValue ;
nRelationVal[1 - fSide] -= 5 * ( nflagValue >> 3 );
}
else // 輪到己方行棋
{
nRelationVal[fSide] -= nUnitValue ;
nRelationVal[1 - fSide] -= ( nflagValue >> 3 );
}
}
// 多攻擊單保護的狀況而且攻擊者最小子力小於被攻擊者子力與
// 保護者子力之和,則對方可能以一子換兩子
else if( RelationOfMan[x][y].nUGuardCount == 1
&& RelationOfMan[x][y].nUAttackCount > 1
&& nMinAttack < BasicValues[nCChessID] + nGuard )
{
if( fWhoseTurn != fSide ) // 輪到對方行棋
{
nRelationVal[fSide] -= 5 * nUnitValue ;
nRelationVal[fSide] -= 5 * ( nGuard >> 3 );
nRelationVal[1 - fSide] -= 5 * ( nMinAttack >> 3 );
}
else // 輪到己方行棋
{
nRelationVal[fSide] -= nUnitValue ;
nRelationVal[fSide] -= ( nGuard >> 3 );
nRelationVal[1 - fSide] -= ( nMinAttack >> 3 );
}
}
// 三攻擊兩保護的狀況而且攻擊者子力較小的兩者之和小於被攻擊者子力與
// 保護者子力之和,則對方可能以兩子換三子
else if( RelationOfMan[x][y].nUGuardCount == 2
&& RelationOfMan[x][y].nUAttackCount == 3
&& (nAttack - nMaxAttack) < (BasicValues[nCChessID] + nGuard) )
{
if( fWhoseTurn != fSide ) // 輪到對方行棋
{
nRelationVal[fSide] -= 5 * nUnitValue ;
nRelationVal[fSide] -= 5 * ( nGuard >> 3 );
nRelationVal[1 - fSide] -= 5 * ((nAttack - nMaxAttack) >> 3);
}
else // 輪到己方行棋
{
nRelationVal[fSide] -= nUnitValue ;
nRelationVal[fSide] -= ( nGuard >> 3 );
nRelationVal[1 - fSide] -= ( ( nAttack - nMaxAttack ) >> 3 );
}
}
// 攻擊方與保護方數量相同而且攻擊者子力小於被攻擊者子力與保護者子力
// 之和,再減去保護者中最大子力,則對方可能以n子換n子
else if( RelationOfMan[x][y].nUAttackCount
== RelationOfMan[x][y].nUGuardCount
&& nAttack < BasicValues[nCChessID] + nGuard - nMaxGuard )
{
if( fWhoseTurn != fSide ) // 輪到對方行棋
{
nRelationVal[fSide] -= 5 * nUnitValue ;
nRelationVal[fSide] -= 5 * ( ( nGuard - nMaxGuard ) >> 3 );
nRelationVal[1 - fSide] -= 5 * ( nAttack >> 3 );
}
else // 輪到己方行棋
{
nRelationVal[fSide] -= nUnitValue ;
nRelationVal[fSide] -= ( ( nGuard - nMaxGuard ) >> 3 );
nRelationVal[1 - fSide] -= ( nAttack >> 3 );
}
}
else
{
//上述狀況已基本涵蓋最多見狀況,於是其它狀況暫時不作考慮
}
} // end 有保護
} // end 遭受攻擊
} // end if( RelationOfMan[x][y].nCChessID != 0 )
} // end for x 0 to 8, y 0 to 9
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 統計紅方總分值
RedValues = nBasicVal[RED] + nPositionVal[RED]
+ nMobilityVal[RED] + nRelationVal[RED] ;
// 統計黑方總分值
BlackValues = nBasicVal[BLACK] + nPositionVal[BLACK]
+ nMobilityVal[BLACK] + nRelationVal[BLACK] ;
if( fWhoseTurn == RED )
return ( RedValues - BlackValues ) + rand()%5 ; //此處 +rand()%X 是經過
else //加一個不會對分值形成大的影響的隨機量以期電腦在應對同
return ( BlackValues - RedValues ) + rand()%5 ; //一種下法時不會每次都有
//相同的迴應。這樣作以及X取5是否合適還有待實踐檢驗……
}
inline void AddPointToQueue( BYTE x, BYTE y )
{
PointList[nPointCount].x = x ;
PointList[nPointCount].y = y ;
nPointCount ++;
}
// end of CChessEvaluate.h