evaluation.cpp

算法比较复杂的人机像棋,运行速度也是非常之块的。

// Evaluation.cpp: implementation of the CEvaluation class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Chess.h"
#include "Evaluation.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CEvaluation::CEvaluation()
{
//	m_pThinkThread=AfxBeginThread(threadfunc,this,THREAD_PRIORITY_NORMAL);	//构造器中启动线程
}

CEvaluation::~CEvaluation()
{

}

POSINFO CEvaluation::FindBetter(CChessInfo ci,POSINFO *po)
{
	double	i=0;
	int		j;
	
	for(j=0;j<6;j++)
	{
		MoveTree[j].srcCol = -1;
		MoveTree[j].srcRow = -1;
		Eated[j].ChessPos = 0;
		BestStep[j].srcCol = -1;
		BestStep[j].srcRow = -1;
		BestStep[j].desCol = -1;
		BestStep[j].desRow = -1;
		BestStep[j].ChessPos = 0;
	}

	MoveTree[0] = *po;

	i = Search(-100000000000,100000000000,1,NULL,ci);

	return BestStep[1];
}

void CEvaluation::Update_16Pos(POSINFO *po,CChessInfo *ci,int depth)
{
	int i;

	if(po == NULL) return;
	if(po->eat == 1 && Eated[depth-1].ChessPos ==0)
	{
		Eated[depth-1].ChessPos = ci->ChessMap[po->desRow][po->desCol].ChessPos; 
		ci->ChessMap[po->desRow][po->desCol].ChessPos = po->ChessPos ;
		ci->ChessMap[po->srcRow][po->srcCol].ChessPos = 0;
		EatUpdate(po,ci);
	}
	if(po->eat == 0)
	{
		for(i=0;i<16;i++)
		{
			if (ci->Pos_16[ci->m_Turn][i].ChessPos == 0) break;
			if (po->srcCol == ci->Pos_16[ci->m_Turn][i].srcCol &&
				po->srcRow == ci->Pos_16[ci->m_Turn][i].srcRow)
			{
				ci->Pos_16[ci->m_Turn][i].srcCol = po->desCol;
				ci->Pos_16[ci->m_Turn][i].srcRow = po->desRow;
				ci->ChessMap[po->desRow][po->desCol].ChessPos = po->ChessPos;    
				ci->ChessMap[po->srcRow][po->srcCol].ChessPos = 0;   
			}
		}
	}
}

double CEvaluation::CalcScore(POSINFO *po,CChessInfo *ci,int depth)
{
	double scorered=0,scoreblack=0;
	int		old;
	
	old = ci->m_Turn; 

/*黑方得分*/
	ci->m_Turn = 1;
	scoreblack += Calc_ChessPos(ci);	//位置和子力的得分
	scoreblack += Calc_CanEat(ci,po,depth);	//计算吃子的分数

/*红分得分*/
	ci->m_Turn = 0;
	scorered += Calc_ChessPos(ci);		//位置和子力的得分
	scorered += Calc_CanEat(ci,po,depth);		//计算吃子的分数

	ci->m_Turn = old;
	if(ci->m_Turn ==1 ) return (scorered-scoreblack);
	else return (scoreblack-scorered);
}



double CEvaluation::Calc_ChessPos(CChessInfo *ci)
{
	int	i=0,srcRow,srcCol;
	double score=0;

	for(i=0;i<16;i++)
	{
		if(ci->Pos_16[ci->m_Turn][i].ChessPos ==0 )break;
		srcCol = ci->Pos_16[ci->m_Turn][i].srcCol; 
		srcRow = ci->Pos_16[ci->m_Turn][i].srcRow;
		score += GetChessScore(srcRow,srcCol,ci->Pos_16[ci->m_Turn][i].ChessPos);
		score += CHESSSCORE[ci->Pos_16[ci->m_Turn][i].ChessPos]*15;
	}
	return score;
}

double CEvaluation::Calc_CanEat(CChessInfo *ci,POSINFO *po,int depth)
{
	double score=0;
	int		temp,color;

	temp = po->ChessPos;
	if(temp>=1&&temp<=7) color = 0;
	if(temp>=8&&temp<=14) color =1;

	if(po->eat == 1 && color == ci->m_Turn)
	{
		score += CHESSSCORE[Eated[depth-1].ChessPos]*10;
		score += GetChessScore(po->desRow,po->desCol,Eated[depth].ChessPos); 
		score += GetChessScore(po->desRow,po->desCol,po->ChessPos);
		score -= GetChessScore(po->srcRow,po->srcCol,po->ChessPos); 
	}

	if(color != ci->m_Turn)
	{
		POSINFO *p,*pEat;
		int	count;
		pEat = ci->EnumEatList(count,ci->m_Turn,po);
		for(p=pEat;p;p=p->next)
		{
			if(p->eat == 1 && p->desRow == po->desRow && p->desCol == po->desCol)
			{
				score += CHESSSCORE[po->ChessPos]*15;
				score += GetChessScore(po->desRow,po->desCol,po->ChessPos); 
				score += GetChessScore(p->desRow,p->desCol,p->ChessPos); 
				score -= GetChessScore(p->srcRow,p->srcCol,p->ChessPos);   
			}
		}
		ci->DeletePoint(pEat); 
	}

	return score;
}

double CEvaluation::Search(double alpha, double beta, int depth,POSINFO *po,CChessInfo ci)
{
	int	Count;
	double	val;
	BOOL fFoundPv = FALSE;
	POSINFO		*pHead = NULL,*p = NULL;

	if (depth > m_Depth) return CalcScore(po,&ci,depth);

	if(depth%2 == 1) ci.m_Turn = 1;
	else ci.m_Turn = 0;

	pHead = ci.EnumList(Count,ci.m_Turn);

	for(p = pHead;p;p = p->next)
	{
		MoveTree[depth] = *p;
		if(BestStep[1].srcCol ==-1) BestStep[1] = MoveTree[1];

		Update_16Pos(p,&ci,depth);

		if (fFoundPv)
		{
			val = -Search(-alpha-1,-alpha,depth+1,p,ci);
			if ((val > alpha) && (val < beta))
				val = -Search(-beta,-alpha,depth+1,p,ci);
		}
		else
			val = -Search(-beta,-alpha,depth+1,p,ci);

		UnUpdate_16Pos(p,&ci,depth);
		
		if (val >= beta) {ci.DeletePoint(pHead);return beta;}
        if (val > alpha)
		{
            alpha = val;
            fFoundPv = TRUE;
			BestStep[depth] = MoveTree[depth];
        }
	}
	ci.DeletePoint(pHead);	
	p = NULL;

	if(Count == 0 && depth%2==0) return -1000000000;
	if(Count == 0 && depth%2==1) return 1000000000;
	return alpha;
}

void CEvaluation::UnUpdate_16Pos(POSINFO *po, CChessInfo *ci,int depth)
{
	int i;

	if(po == NULL) return;
	if(po->eat ==1 && Eated[depth-1].ChessPos !=0)
	{
		ci->ChessMap[po->desRow][po->desCol].ChessPos = Eated[depth-1].ChessPos;
		ci->ChessMap[po->srcRow][po->srcCol].ChessPos = po->ChessPos;
		Eated[depth-1].ChessPos = 0;
		EatUpdate(po,ci);
	}
	if(po->eat == 0)
	{
		for(i=0;i<16;i++)
		{
			if (ci->Pos_16[ci->m_Turn][i].ChessPos == 0) break;
			if (po->desCol == ci->Pos_16[ci->m_Turn][i].srcCol &&
				po->desRow == ci->Pos_16[ci->m_Turn][i].srcRow)
			{
				ci->Pos_16[ci->m_Turn][i].srcCol = po->srcCol;
				ci->Pos_16[ci->m_Turn][i].srcRow = po->srcRow;
				ci->ChessMap[po->desRow][po->desCol].ChessPos = 0;    
				ci->ChessMap[po->srcRow][po->srcCol].ChessPos = po->ChessPos;   
			}
		}
	}

}

void CEvaluation::EatUpdate(POSINFO *po, CChessInfo *ci)
{
	int	i,j,r,b,temp;

	for(i=0;i<16;i++)
		{
			ci->Pos_16[RED][i].ChessPos = 0;
			ci->Pos_16[BLA][i].ChessPos = 0;
		}

	for(i=r=b=0;i<10;i++)
		for(j=0;j<11;j++)
		{
			temp = ci->ChessMap[i][j].ChessPos;
			if(temp)
			{
				if(temp>=1&&temp<=7)
				{
					ci->Pos_16[RED][r].srcRow = i;
					ci->Pos_16[RED][r].srcCol = j;
					ci->Pos_16[RED][r].ChessPos = temp;
					r++;
				}
				if(temp>=8&&temp<=14)
				{
					ci->Pos_16[BLA][b].srcRow = i;
					ci->Pos_16[BLA][b].srcCol = j;
					ci->Pos_16[BLA][b].ChessPos = temp;
					b++;
				}
			}
		}
}

double CEvaluation::GetChessScore(int srcRow, int srcCol,int ChessPos)
{
	double score=0;
		switch(ChessPos)
		{
			case	RED_J:
					score = J_VALU[9-srcRow][srcCol];
					break;
			case	BLA_J:
					score = J_VALU[srcRow][srcCol];
					break;
			case	RED_M:
					score = M_VALU[9-srcRow][srcCol];
					break;
			case	BLA_M:
					score = M_VALU[srcRow][srcCol];
					break;
			case	RED_P:
					score = P_VALU[9-srcRow][srcCol];
					break;
			case	BLA_P:
					score = P_VALU[srcRow][srcCol];
					break;
			case	RED_B:
					score = B_VALU[9-srcRow][srcCol];
					break;
			case	BLA_B:
					score = B_VALU[srcRow][srcCol];
					break;
			case	RED_S:
					score = S_VALU[srcRow][srcCol];
					break;
			case	BLA_S:
					score = S_VALU[srcRow][srcCol];
					break;
			case	RED_X:
					score = X_VALU[srcRow][srcCol];
					break;
			case	BLA_X:
					score = X_VALU[srcRow][srcCol];
					break;
			case	RED_K:
					score = K_VALU[srcRow][srcCol];
					break;
			case	BLA_K:
					score = K_VALU[srcRow][srcCol];
					break;
		}
	return score;
}

UINT CEvaluation::threadfunc(LPVOID lpparam)
{
//	CEvaluation* This=(CEvaluation*)(lpparam);	//lpparam为构造器中传过来的"this"指针
//	return This->FindBetter(); 
	return 0;
}