#include "Eveluation.h"
#include "Stone.h"
#include <QPainter>
#include <QMouseEvent>
#include <QDebug>
/* 位置重要性价值表,此表从中间向外,越往外价值越低*/
int PosValue[GRID_NUM][GRID_NUM]=
{
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
{0,1,2,2,2,2,2,2,2,2,2,2,2,1,0},
{0,1,2,3,3,3,3,3,3,3,3,3,2,1,0},
{0,1,2,3,4,4,4,4,4,4,4,3,2,1,0},
{0,1,2,3,4,5,5,5,5,5,4,3,2,1,0},
{0,1,2,3,4,5,6,6,6,5,4,3,2,1,0},
{0,1,2,3,4,5,6,7,6,5,4,3,2,1,0},
{0,1,2,3,4,5,6,6,6,5,4,3,2,1,0},
{0,1,2,3,4,5,5,5,5,5,4,3,2,1,0},
{0,1,2,3,4,4,4,4,4,4,4,3,2,1,0},
{0,1,2,3,3,3,3,3,3,3,3,3,2,1,0},
{0,1,2,2,2,2,2,2,2,2,2,2,2,1,0},
{0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
};
int count = 0; //全局变量,用以统计估值函数的执行遍数
Eveluation::Eveluation()
{
}
Eveluation::~Eveluation()
{
}
/*
估值函数
position是要估值的棋盘
bIsWhiteTurn是轮到谁走棋的标志,TRUE是白,FALSE是黑
*/
int Eveluation::CalScore(int position[][GRID_NUM], bool bIsWhiteTurn)
{
int i, j, k;
int nStoneType;
count++;
/* 清空棋型分析结果*/
for(int row=0; row<GRID_NUM; row++)
{
for(int col=0; col<GRID_NUM;col++)
{
for(int k=0; k<4; k++)
{
TypeRecord[row][col][k] = 0;
}
}
}
for(int row=0; row<3; row++)
{
for(int col=0; col<20;col++)
{
TypeCount[row][col] = 0;
}
}
for(int i=0; i<30; i++)
{
m_LineRecord[i] = 0;
}
//memset(TypeRecord, 0, 15*15*4*sizeof(int));
//memset(TypeCount, 0, 30*sizeof(int));
/* 对棋盘上所有棋子在 源 个方向上进行分析*/
for(i=0; i<GRID_NUM; i++)
{
for(j=0; j<GRID_NUM; j++)
{
if(position[i][j] != 0)
{
/*如果水平方向上没有分析过*/
if(TypeRecord[i][j][0] == TOBEANALSIS)
{
AnalysisHorizon(position, i, j);
}
/*如果垂直方向上没有分析过*/
if(TypeRecord[i][j][1] == TOBEANALSIS)
{
AnalysisVertical(position, i, j);
}
/*如果左斜方向上没有分析过*/
if(TypeRecord[i][j][2] == TOBEANALSIS)
{
AnalysisLeft(position, i, j);
}
/*如果右斜方向上没有分析过*/
if(TypeRecord[i][j][3] == TOBEANALSIS)
{
AnalysisRight(position, i, j);
}
}
}
}
/*对分析结果进行统计,得到每种棋型的数量*/
for(i=0; i<GRID_NUM; i++)
{
for(j=0; j<GRID_NUM; j++)
{
for(k=0; k<4; k++)
{
nStoneType = position[i][j];
if(nStoneType != 0)
{
switch(TypeRecord[i][j][k])
{
case FIVE: //五连
TypeCount[nStoneType][FIVE]++;
//qDebug() << i << j <<endl;
break;
case FOUR: //活四
TypeCount[nStoneType][FOUR]++;
break;
case SFOUR: // 冲四
TypeCount[nStoneType][SFOUR]++;
break;
case THREE: //活三
TypeCount[nStoneType][THREE]++;
break;
case STHREE://眠三
TypeCount[nStoneType][STHREE]++;
break;
case TWO: // 活二
TypeCount[nStoneType][TWO]++;
break;
case STWO: //眠二
TypeCount[nStoneType][STWO]++;
break;
default:
break;
}
}
}
}
}
/* 如果已五连,返回极值*/
if(bIsWhiteTurn)
{
if(TypeCount[BLACK][FIVE])
{
return -9999;
}
if(TypeCount[WHITE][FIVE])
{
return 9999;
}
}
else
{
if(TypeCount[BLACK][FIVE])
{
return -9999;
}
if(TypeCount[WHITE][FIVE])
{
return 9999;
}
}
/*两个冲四等于一个活四*/
if(TypeCount[WHITE][SFOUR] > 1)
{
TypeCount[WHITE][FOUR]++;
TypeCount[WHITE][SFOUR] -= 2;
}
if(TypeCount[BLACK][SFOUR] > 1)
{
TypeCount[BLACK][FOUR]++;
TypeCount[BLACK][SFOUR] -= 2;
}
int WValue = 0, BValue = 0;
if(bIsWhiteTurn)//轮到白棋走
{
if(TypeCount[WHITE][FOUR])//活四,白胜返回极值
{
return -9990;
}
if(TypeCount[WHITE][SFOUR])//冲四,白胜返回极值
{
return -9980;
}
if(TypeCount[BLACK][FOUR])//白无冲四活四,而黑有活四,黑胜返回极值
{
return 9970;
}
/*而黑有冲四和活三,黑胜返回极值*/
if(TypeCount[BLACK][SFOUR] && TypeCount[BLACK][THREE])
{
return 9960;
}
/*白有活三而黑没有四,白胜返回极值*/
if(TypeCount[WHITE][THREE] && TypeCount[BLACK][SFOUR] == 0)
{
return -9950;
}
/*黑的活三多于一个,而白无四和三,黑胜返回极值*/
if(TypeCount[BLACK][THREE] > 1 && TypeCount[WHITE][SFOUR] == 0 &&
TypeCount[WHITE][THREE] == 0 && TypeCount[WHITE][STHREE] == 0)
{
return 9940;
}
/*白活三多于一个,白棋价值加2000*/
if(TypeCount[WHITE][THREE] > 1)
{
WValue += 500;
}
else
{
if(TypeCount[WHITE][THREE])
{
WValue += 100;
}
}
/*黑的活三多于一个,黑棋价值加500*/
if(TypeCount[BLACK][THREE] > 1)
{
BValue += 2000;
}
else
{
if(TypeCount[BLACK][THREE])
{
BValue += 200;
}
}
/* 每个眠三加10*/
if(TypeCount[WHITE][STHREE])
{
WValue += TypeCount[WHITE][STHREE] * 10;
}
if(TypeCount[BLACK][STHREE])
{
BValue += TypeCount[BLACK][STHREE] * 10;
}
/*每个活二加4*/
if(TypeCount[WHITE][TWO])
{
WValue += TypeCount[WHITE][TWO] * 4;
}
if(TypeCount[BLACK][TWO])
{
BValue += TypeCount[BLACK][TWO] * 4;
}
/*每个眠二加1*/
if(TypeCount[WHITE][STWO])
{
WValue += TypeCount[WHITE][STWO] * 4;
}
if(TypeCount[BLACK][STWO])
{
BValue += TypeCount[BLACK][STWO] * 4;
}
}
else
{// 轮到黑棋走
if(TypeCount[BLACK][FOUR])//活四,黑胜返回极值
{
return -9990;
}
if(TypeCount[BLACK][SFOUR])//冲四,黑胜返回极值
{
return -9980;
}
if(TypeCount[WHITE][FOUR])//活四,白胜返回极值
{
return 9970;
}
/*冲四并活三,白胜返回极值*/
if(TypeCount[WHITE][SFOUR] && TypeCount[WHITE][THREE])
{
return 9960;
}