象棋人機對戰

阿新 • • 發佈：2019-01-03

象棋主要演算法程式碼

Eveluation.h
Eveluation.cpp
這一對檔案定義並實現了估值核心類。

#if !defined(AFX_EVELUATION_H__2AF7A221_CB28_11D5_AEC7_5254AB2E22C7__INCLUDED_)
#define AFX_EVELUATION_H__2AF7A221_CB28_11D5_AEC7_5254AB2E22C7__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


#define BASEVALUE_PAWN 100
#define BASEVALUE_BISHOP 250
#define BASEVALUE_ELEPHANT 250
#define BASEVALUE_CAR 500
#define BASEVALUE_HORSE 350
#define BASEVALUE_CANON 350
#define BASEVALUE_KING 10000

#define FLEXIBILITY_PAWN 15
#define FLEXIBILITY_BISHOP 1
#define FLEXIBILITY_ELEPHANT 1
#define FLEXIBILITY_CAR 6
#define FLEXIBILITY_HORSE 12
#define FLEXIBILITY_CANON 6
#define FLEXIBILITY_KING 0

class CEveluation  
{
public:
	CEveluation();
	virtual ~CEveluation();
	
	virtual int Eveluate(BYTE position[10][9], BOOL bIsRedTurn);

protected:
	int GetRelatePiece(BYTE position[10][9],int j, int i);
	BOOL CanTouch(BYTE position[10][9], int nFromX, int nFromY, int nToX, int nToY);	
    void	AddPoint(int x, int y);
	int GetBingValue(int x, int y, BYTE CurSituation[][9]);
	int m_BaseValue[15];
	int m_FlexValue[15];
	short m_AttackPos[10][9];
	BYTE m_GuardPos[10][9];
	BYTE m_FlexibilityPos[10][9];
	int m_chessValue[10][9];
	int nPosCount;
	POINT RelatePos[20];

};

#endif // !defined(AFX_EVELUATION_H__2AF7A221_CB28_11D5_AEC7_5254AB2E22C7__INCLUDED_)

// Eveluation.cpp: implementation of the CEveluation class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "chess.h"
#include "Eveluation.h"

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

const int BA0[10][9]=
{
	{0,  0,  0,  0,  0,  0,  0,  0,  0},
	{90,90,110,120,120,120,110,90,90},
	{90,90,110,120,120,120,110,90,90},
	{70,90,110,110,110,110,110,90,70},
	{70,70,70, 70, 70,  70, 70,70,70},
	{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},
};

const int BA1[10][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},
	{70,70,70, 70, 70,70, 70,70, 70},
	{70,90,110,110,110,110,110,90,70},
	{90,90,110,120,120,120,110,90,90},
	{90,90,110,120,120,120,110,90,90},
	{0,  0, 0,  0,  0,  0,  0,  0,  0},
};

int CEveluation:: GetBingValue(int x, int y, BYTE CurSituation[][9])
{
	if (CurSituation[y][x] == R_PAWN)
		return BA0[y][x];
	
	if (CurSituation[y][x] == B_PAWN)
		return BA1[y][x];

	return 0;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CEveluation::CEveluation()
{
	m_BaseValue[B_KING] = BASEVALUE_KING; 
	m_BaseValue[B_CAR] = BASEVALUE_CAR; 
	m_BaseValue[B_HORSE] = BASEVALUE_HORSE; 
	m_BaseValue[B_BISHOP] = BASEVALUE_BISHOP; 
	m_BaseValue[B_ELEPHANT] = BASEVALUE_ELEPHANT; 
	m_BaseValue[B_CANON] = BASEVALUE_CANON; 
	m_BaseValue[B_PAWN] = BASEVALUE_PAWN; 

	m_BaseValue[R_KING] = BASEVALUE_KING; 
	m_BaseValue[R_CAR] = BASEVALUE_CAR; 
	m_BaseValue[R_HORSE] = BASEVALUE_HORSE; 
	m_BaseValue[R_BISHOP] = BASEVALUE_BISHOP; 
	m_BaseValue[R_ELEPHANT] = BASEVALUE_ELEPHANT; 
	m_BaseValue[R_CANON] = BASEVALUE_CANON; 
	m_BaseValue[R_PAWN] = BASEVALUE_PAWN; 

	m_FlexValue[B_KING] = FLEXIBILITY_KING; 
	m_FlexValue[B_CAR] = FLEXIBILITY_CAR; 
	m_FlexValue[B_HORSE] = FLEXIBILITY_HORSE; 
	m_FlexValue[B_BISHOP] = FLEXIBILITY_BISHOP; 
	m_FlexValue[B_ELEPHANT] = FLEXIBILITY_ELEPHANT; 
	m_FlexValue[B_CANON] = FLEXIBILITY_CANON; 
	m_FlexValue[B_PAWN] = FLEXIBILITY_PAWN; 

	m_FlexValue[R_KING] = FLEXIBILITY_KING; 
	m_FlexValue[R_CAR] = FLEXIBILITY_CAR; 
	m_FlexValue[R_HORSE] = FLEXIBILITY_HORSE; 
	m_FlexValue[R_BISHOP] = FLEXIBILITY_BISHOP; 
	m_FlexValue[R_ELEPHANT] = FLEXIBILITY_ELEPHANT; 
	m_FlexValue[R_CANON] = FLEXIBILITY_CANON; 
	m_FlexValue[R_PAWN] = FLEXIBILITY_PAWN; 

}

CEveluation::~CEveluation()
{
}
int count=0;
int CEveluation::Eveluate(BYTE position[10][9], BOOL bIsRedTurn)
{
	int i, j, k;
	int nChessType, nTargetType;
	count++;

	memset(m_chessValue,0, 360);
	memset(m_AttackPos,0, 180); 
	memset(m_GuardPos,0, 90); 
	memset(m_FlexibilityPos, 0, 90);

	for(i = 0; i < 10; i++)
		for(j = 0; j < 9; j++)
		{
			if(position[i][j] != NOCHESS)
			{
				nChessType = position[i][j];
				GetRelatePiece(position, j, i);
				for (k = 0; k < nPosCount; k++)
				{
					nTargetType = position[RelatePos[k].y][RelatePos[k].x];
					if (nTargetType == NOCHESS)
					{
						m_FlexibilityPos[i][j]++;	
					}
					else
					{
						if (IsSameSide(nChessType, nTargetType))
						{
							m_GuardPos[RelatePos[k].y][RelatePos[k].x]++;
						}else
						{
							m_AttackPos[RelatePos[k].y][RelatePos[k].x]++;
							m_FlexibilityPos[i][j]++;	
							switch (nTargetType)
							{
							case R_KING:
								if (!bIsRedTurn)
									return 18888;
								break;
							case B_KING:
								if (bIsRedTurn)
									return 18888;
								break;
							default:
								m_AttackPos[RelatePos[k].y][RelatePos[k].x] += (30 + (m_BaseValue[nTargetType] - m_BaseValue[nChessType])/10)/10;
								break;
							}
						}
					}
				}
			}
		}

	for(i = 0; i < 10; i++)
		for(j = 0; j < 9; j++)
		{
			if(position[i][j] != NOCHESS)
			{
				nChessType = position[i][j];
				m_chessValue[i][j]++;
				m_chessValue[i][j] += m_FlexValue[nChessType] * m_FlexibilityPos[i][j];
				m_chessValue[i][j] += GetBingValue(j, i, position);
			}
		}
	int nHalfvalue;
	for(i = 0; i < 10; i++)
		for(j = 0; j < 9; j++)
		{
			if(position[i][j] != NOCHESS)
			{
				nChessType = position[i][j];
				nHalfvalue = m_BaseValue[nChessType]/16;
				m_chessValue[i][j] += m_BaseValue[nChessType];
				
				if (IsRed(nChessType))
				{
					if (m_AttackPos[i][j])
					{
						if (bIsRedTurn)
						{
							if (nChessType == R_KING)
							{
								m_chessValue[i][j]-= 20;
							}
							else
							{
								m_chessValue[i][j] -= nHalfvalue * 2;
								if (m_GuardPos[i][j])
									m_chessValue[i][j] += nHalfvalue;
							}
						}
						else
						{
							if (nChessType == R_KING)
								return 18888;
							m_chessValue[i][j] -= nHalfvalue*10;
							if (m_GuardPos[i][j])
								m_chessValue[i][j] += nHalfvalue*9;
						}
						m_chessValue[i][j] -= m_AttackPos[i][j];
					}
					else
					{
						if (m_GuardPos[i][j])
							m_chessValue[i][j] += 5;
					}
				}
				else
				{
					if (m_AttackPos[i][j])
					{
						if (!bIsRedTurn)
						{
							if (nChessType == B_KING)									
							{
								m_chessValue[i][j]-= 20;
							}
							else
							{
								m_chessValue[i][j] -= nHalfvalue * 2;
								if (m_GuardPos[i][j])
									m_chessValue[i][j] += nHalfvalue;
							}
						}
						else
						{
							if (nChessType == B_KING)
								return 18888;
							m_chessValue[i][j] -= nHalfvalue*10;
							if (m_GuardPos[i][j])
								m_chessValue[i][j] += nHalfvalue*9;
						}
						m_chessValue[i][j] -= m_AttackPos[i][j];
					}
					else
					{
						if (m_GuardPos[i][j])
							m_chessValue[i][j] += 5;
					}
				}
			}
		}

	int nRedValue = 0; 
	int	nBlackValue = 0;

	for(i = 0; i < 10; i++)
		for(j = 0; j < 9; j++)
		{
			nChessType = position[i][j];
//			if (nChessType == R_KING || nChessType == B_KING)
//				m_chessValue[i][j] = 10000;	
			if (nChessType != NOCHESS)
			{
				if (IsRed(nChessType))
				{
					nRedValue += m_chessValue[i][j];	
				}
				else
				{
					nBlackValue += m_chessValue[i][j];	
				}
			}
		}
		if (bIsRedTurn)
		{
			return nRedValue - nBlackValue;
		}
		else
		{
			return  nBlackValue-nRedValue ;
		}
}





void CEveluation::AddPoint(int  x, int y)
{
	RelatePos[nPosCount].x = x;
	RelatePos[nPosCount].y = y;
	nPosCount++;
}

int CEveluation::GetRelatePiece(BYTE position[10][9], int j, int i)
{
	nPosCount = 0;
	BYTE nChessID;
	BYTE flag;
	int x,y;
	
	nChessID = position[i][j];
	switch(nChessID)
	{
	case R_KING:
	case B_KING:
		
		for (y = 0; y < 3; y++)
			for (x = 3; x < 6; x++)
				if (CanTouch(position, j, i, x, y))
					AddPoint(x, y);
		for (y = 7; y < 10; y++)
			for (x = 3; x < 6; x++)
				if (CanTouch(position, j, i, x, y))
					AddPoint(x, y);
		break;
						
	case R_BISHOP:
		
		for (y = 7; y < 10; y++)
			for (x = 3; x < 6; x++)
				if (CanTouch(position, j, i, x, y))
					AddPoint(x, y);
		break;
				
	case B_BISHOP:
		
		for (y = 0; y < 3; y++)
			for (x = 3; x < 6; x++)
				if (CanTouch(position, j, i, x, y))
					AddPoint(x, y);
		break;
				
	case R_ELEPHANT:
	case B_ELEPHANT:
		
		x=j+2;
		y=i+2;
		if(x < 9 && y < 10  && CanTouch(position, j, i, x, y))
			AddPoint(x, y);
		
		x=j+2;
		y=i-2;
		if(x < 9 && y>=0  &&  CanTouch(position, j, i, x, y))
			AddPoint(x, y);
		
		x=j-2;
		y=i+2;
		if(x>=0 && y < 10  && CanTouch(position, j, i, x, y))
			AddPoint(x, y);
		
		x=j-2;
		y=i-2;
		if(x>=0 && y>=0  && CanTouch(position, j, i, x, y))
			AddPoint(x, y);
		break;
		
		case R_HORSE:		
		case B_HORSE:		
			x=j+2;
			y=i+1;
			if((x < 9 && y < 10) &&CanTouch(position, j, i, x, y))
				AddPoint(x, y);
					
					x=j+2;
					y=i-1;
					if((x < 9 && y >= 0) &&CanTouch(position, j, i, x, y))
						AddPoint(x, y);
					
					x=j-2;
					y=i+1;
					if((x >= 0 && y < 10) &&CanTouch(position, j, i, x, y))
						AddPoint(x, y);
					
					x=j-2;
					y=i-1;
					if((x >= 0 && y >= 0) &&CanTouch(position, j, i, x, y))
						AddPoint(x, y);
					
					x=j+1;
					y=i+2;
					if((x < 9 && y < 10) &&CanTouch(position, j, i, x, y))
						AddPoint(x, y);
					x=j-1;
					y=i+2;
					if((x >= 0 && y < 10) &&CanTouch(position, j, i, x, y))
						AddPoint(x, y);
					x=j+1;
					y=i-2;
					if((x < 9 && y >= 0) &&CanTouch(position, j, i, x, y))
						AddPoint(x, y);
					x=j-1;
					y=i-2;
					if((x >= 0 && y >= 0) &&CanTouch(position, j, i, x, y))
						AddPoint(x, y);
					break;
					
				case R_CAR:
				case B_CAR:
					x=j+1;
					y=i;
					while(x < 9)
					{
						if( NOCHESS == position[y][x] )
							AddPoint(x, y);
						else
						{
							AddPoint(x, y);
							break;
						}
						x++;
					}
					
					x = j-1;
					y = i;
					while(x >= 0)
					{
						if( NOCHESS == position[y][x] )
							AddPoint(x, y);
						else
						{
							AddPoint(x, y);
							break;
						}
						x--;
					}
					
					x=j;
					y=i+1;//
					while(y < 10)
					{
						if( NOCHESS == position[y][x])
							AddPoint(x, y);
						else
						{
							AddPoint(x, y);
							break;
						}
						y++;
					}
					
					x = j;
					y = i-1;//よ
					while(y>=0)
					{
						if( NOCHESS == position[y][x])
							AddPoint(x, y);
						else
						{
							AddPoint(x, y);
							break;
						}
						y--;
					}
					break;
					
				case R_PAWN:
					y = i - 1;
					x = j;
					
					if(y >= 0)
						AddPoint(x, y);
					
					if(i < 5)
					{
						y=i;
						x=j+1;
						if(x < 9 )
							AddPoint(x, y);
						x=j-1;
						if(x >= 0 )
							AddPoint(x, y);
					}
					break;
					
				case B_PAWN:
					y = i + 1;
					x = j;
					
					if(y < 10 )
						AddPoint(x, y);
					
					if(i > 4)
					{
						y=i;
						x=j+1;
						if(x < 9)
							AddPoint(x, y);
						x=j-1;
						if(x >= 0)
							AddPoint(x, y);
					}
					break;
					
				case B_CANON:
				case R_CANON:
					
					x=j+1;		//
					y=i;
					flag=FALSE;
					while(x < 9)		
					{
						if( NOCHESS == position[y][x] )
						{
							if(!flag)
								AddPoint(x, y);
						}
						else
						{
							if(!flag)
								flag=TRUE;
							else 
							{
								AddPoint(x, y);
								break;
							}
						}
						x++;
					}
					
					x=j-1;
					flag=FALSE;	
					while(x>=0)
					{
						if( NOCHESS == position[y][x] )
						{
							if(!flag)
								AddPoint(x, y);
						}
						else
						{
							if(!flag)
								flag=TRUE;
							else 
							{
								AddPoint(x, y);
								break;
							}
						}
						x--;
					}
					x=j;	
					y=i+1;
					flag=FALSE;
					while(y < 10)
					{
						if( NOCHESS == position[y][x] )
						{
							if(!flag)
								AddPoint(x, y);
						}
						else
						{
							if(!flag)
								flag=TRUE;
							else 
							{
								AddPoint(x, y);
								break;
							}
						}
						y++;
					}
					
					y=i-1;	//
					flag=FALSE;	
					while(y>=0)
					{
						if( NOCHESS == position[y][x] )
						{
							if(!flag)
								AddPoint(x, y);
						}
						else
						{
							if(!flag)
								flag=TRUE;
							else 
							{
								AddPoint(x, y);
								break;
							}
						}
						y--;
					}
					break;
					
				default:
					break;
					
				}
				return nPosCount ;				
}

BOOL CEveluation::CanTouch(BYTE position[10][9], int nFromX, int nFromY, int nToX, int nToY)
{
	int i, j;
	int nMoveChessID, nTargetID;
	
	if (nFromY ==  nToY && nFromX == nToX)
		return FALSE;//目的與源相同
	
	nMoveChessID = position[nFromY][nFromX];
	nTargetID = position[nToY][nToX];
	
	switch(nMoveChessID)
	{
	case B_KING:     
		if (nTargetID == R_KING)//老將見面?
		{
			if (nFromX != nToX)
				return FALSE;
			for (i = nFromY + 1; i < nToY; i++)
				if (position[i][nFromX] != NOCHESS)
					return FALSE;
		}
		else
		{
			if (nToY > 2 || nToX > 5 || nToX < 3)
				return FALSE;//目標點在九宮之外
			if(abs(nFromY - nToY) + abs(nToX - nFromX) > 1) 
				return FALSE;//將帥只走一步直線:
		}
		break;
	case R_BISHOP:   
		
		if (nToY < 7 || nToX > 5 || nToX < 3)
			return FALSE;//士出九宮	
		
		if (abs(nFromY - nToY) != 1 || abs(nToX - nFromX) != 1)
			return FALSE;	//士走斜線
		
		break;
		
	case B_BISHOP:   //黑士
		
		if (nToY > 2 || nToX > 5 || nToX < 3)
			return FALSE;//士出九宮	
		
		if (abs(nFromY - nToY) != 1 || abs(nToX - nFromX) != 1)
			return FALSE;	//士走斜線
		
		break;
		
	case R_ELEPHANT://紅象
		
		if(nToY < 5)
			return FALSE;//相不能過河
		
		if(abs(nFromX-nToX) != 2 || abs(nFromY-nToY) != 2)
			return FALSE;//相走田字
		
		if(position[(nFromY + nToY) / 2][(nFromX + nToX) / 2] != NOCHESS)
			return FALSE;//相眼被塞住了
		
		break;
		
	case B_ELEPHANT://黑象 
		
		if(nToY > 4)
			return FALSE;//相不能過河
		
		if(abs(nFromX-nToX) != 2 || abs(nFromY-nToY) != 2)
			return FALSE;//相走田字
		
		if(position[(nFromY + nToY) / 2][(nFromX + nToX) / 2] != NOCHESS)
			return FALSE;//相眼被塞住了
		
		break;
		
	case B_PAWN:     //黑兵
		
		if(nToY < nFromY)
			return FALSE;//兵不回頭
		
		if( nFromY < 5 && nFromY == nToY)
			return FALSE;//兵過河前只能直走
		
		if(nToY - nFromY + abs(nToX - nFromX) > 1)
			return FALSE;//兵只走一步直線:
		
		break;
		
	case R_PAWN:    //紅兵
		
		if(nToY > nFromY)
			return FALSE;//兵不回頭
		
		if( nFromY > 4 && nFromY == nToY)
			return FALSE;//兵過河前只能直走
		
		if(nFromY - nToY + abs(nToX - nFromX) > 1)
			return FALSE;//兵只走一步直線:
		
		break;
		
	case R_KING:     
		if (nTargetID == B_KING)//老將見面?
		{
			if (nFromX != nToX)
				return FALSE;//兩個將不在同一列
			for (i = nFromY - 1; i > nToY; i--)
				if (position[i][nFromX] != NOCHESS)
					return FALSE;//中間有別的子
		}
		else
		{
			if (nToY < 7 || nToX > 5 || nToX < 3)
				return FALSE;//目標點在九宮之外
			if(abs(nFromY - nToY) + abs(nToX - nFromX) > 1) 
				return FALSE;//將帥只走一步直線:
		}
		break;
		
	case B_CAR:      
	case R_CAR:      
		
		if(nFromY != nToY && nFromX != nToX)
			return FALSE;	//車走直線:
		
		if(nFromY == nToY)
		{
			if(nFromX < nToX)
			{
				for(i = nFromX + 1; i < nToX; i++)
					if(position[nFromY][i] != NOCHESS)
						return FALSE;
			}
			else
			{
				for(i = nToX + 1; i < nFromX; i++)
					if(position[nFromY][i] != NOCHESS)
						return FALSE;
			}
		}
		else
		{
			if(nFromY < nToY)
			{
				for(j = nFromY + 1; j < nToY; j++)
					if(position[j][nFromX] != NOCHESS)
						return FALSE;
			}
			else
			{
				for(j= nToY + 1; j < nFromY; j++)
					if(position[j][nFromX] != NOCHESS)
						return FALSE;
			}
		}
		
		break;
		
	case B_HORSE:    
	case R_HORSE:    
		
		if(!((abs(nToX-nFromX)==1 && abs(nToY-nFromY)==2)
			||(abs(nToX-nFromX)==2&&abs(nToY-nFromY)==1)))
			return FALSE;//馬走日字
		
		if	(nToX-nFromX==2)
		{
			i=nFromX+1;
			j=nFromY;
		}
		else if	(nFromX-nToX==2)
		{
			i=nFromX-1;
			j=nFromY;
		}
		else if	(nToY-nFromY==2)
		{
			i=nFromX;
			j=nFromY+1;
		}
		else if	(nFromY-nToY==2)
		{
			i=nFromX;
			j=nFromY-1;
		}
		
		if(position[j][i] != (BYTE)NOCHESS)
			return FALSE;//絆馬腿
		
		break;
	case B_CANON:    
	case R_CANON:    
		
		if(nFromY!=nToY && nFromX!=nToX)
			return FALSE;	//炮走直線:
		
		//炮不吃子時經過的路線中不能有棋子:------------------
		
		if(position[nToY][nToX] == NOCHESS)
		{
			if(nFromY == nToY)
			{
				if(nFromX < nToX)
				{
					for(i = nFromX + 1; i < nToX; i++)
						if(position[nFromY][i] != NOCHESS)
							return FALSE;
				}
				else
				{
					for(i = nToX + 1; i < nFromX; i++)
						if(position[nFromY][i]!=NOCHESS)
							return FALSE;
				}
			}
			else
			{
				if(nFromY < nToY)
				{
					for(j = nFromY + 1; j < nToY; j++)
						if(position[j][nFromX] != NOCHESS)
							return FALSE;
				}
				else
				{
					for(j = nToY + 1; j < nFromY; j++)
						if(position[j][nFromX] != NOCHESS)
							return FALSE;
				}
			}
		}
		//以上是炮不吃子-------------------------------------
		//吃子時:=======================================
		else	
		{
			int nCount=0;
			if(nFromY == nToY)
			{
				if(nFromX < nToX)
				{
					for(i=nFromX+1;i<nToX;i++)
						if(position[nFromY][i]!=NOCHESS)
							nCount++;
						if(nCount != 1)
							return FALSE;
				}
				else
				{
					for(i=nToX+1;i<nFromX;i++)
						if(position[nFromY][i] != NOCHESS)
							nCount++;
						if(nCount!=1)
							return FALSE;
				}
			}
			else
			{
				if(nFromY<nToY)
				{
					for(j=nFromY+1;j<nToY;j++)
						if(position[j][nFromX]!=NOCHESS)
							nCount++;
						if(nCount!=1)
							return FALSE;
				}
				else
				{
					for(j=nToY+1;j<nFromY;j++)
						if(position[j][nFromX] != NOCHESS)
							nCount++;
						if(nCount!=1)
							return FALSE;
				}
			}
		}
		//以上是炮吃子時================================
		break;
	default:
		return FALSE;
	}
	
	return TRUE;
}

MoveGenerator.h
MoveGenerator.cpp
這一對檔案定義並實現了走法產生器。

//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MOVEGENERATOR_H__54A88FC2_CAFC_11D5_AEC7_5254AB2E22C7__INCLUDED_)
#define AFX_MOVEGENERATOR_H__54A88FC2_CAFC_11D5_AEC7_5254AB2E22C7__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CMoveGenerator  
{
public:
	CMoveGenerator();
	virtual ~CMoveGenerator();
	static BOOL IsValidMove(BYTE position[10][9], int nFromX, int nFromY, int nToX, int nToY);
	int CreatePossibleMove(BYTE position[10][9], int nPly,int nSide);

	CHESSMOVE m_MoveList[10][80];
protected:

	void Gen_KingMove(BYTE position[10][9], int i, int j, int nPly);
	void Gen_RBishopMove(BYTE position[10][9], int i, int j, int nPly);
	void Gen_BBishopMove(BYTE position[10][9], int i, int j, int nPly);
	void Gen_ElephantMove(BYTE position[10][9], int i, int j, int nPly);
	void Gen_HorseMove(BYTE position[10][9],  int i, int j, int nPly);
	void Gen_CarMove(BYTE position[10][9],  int i, int j, int nPly);
	void Gen_RPawnMove(BYTE position[10][9],  int i, int j, int nPly);
	void Gen_BPawnMove(BYTE position[10][9], int i, int j, int nPly);
	void Gen_CanonMove(BYTE position[10][9], int i, int j, int nPly);

	int AddMove(int nFromX,int nToX, int nFromY, int nToY,int nPly);
	int m_nMoveCount;
};

#endif // !defined(AFX_MOVEGENERATOR_H__54A88FC2_CAFC_11D5_AEC7_5254AB2E22C7__INCLUDED_)

//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "chess.h"
#include "MoveGenerator.h"

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

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

CMoveGenerator::CMoveGenerator()
{
	
}

CMoveGenerator::~CMoveGenerator()
{
	
}

int CMoveGenerator::AddMove(int nFromX, int nFromY, int nToX, int nToY,int nPly)
{
	m_MoveList[nPly][m_nMoveCount].From.x = nFromX;
	m_MoveList[nPly][m_nMoveCount].From.y = nFromY;
	m_MoveList[nPly][m_nMoveCount].To.x = nToX;
	m_MoveList[nPly][m_nMoveCount].To.y = nToY;
	m_nMoveCount++;
	return m_nMoveCount;
}

int CMoveGenerator::CreatePossibleMove(BYTE position[10][9], int nPly, int nSide)
{
	int     nChessID;
	int		i,j;
	
	m_nMoveCount = 0;
	for (i = 0; i < 10; i++)
		for (j = 0; j < 9; j++)
		{
			if (position[i][j] != NOCHESS)
			{
				nChessID = position[i][j];
				if (!nSide && IsRed(nChessID))
					continue;
				if (nSide && IsBlack(nChessID))
					continue;
				switch(nChessID)
				{
				case R_KING:
				case B_KING:
					Gen_KingMove(position, i, j, nPly);
					break;
					
				case R_BISHOP:
					Gen_RBishopMove(position, i, j, nPly);
					break;
					
				case B_BISHOP:
					Gen_BBishopMove(position, i, j, nPly);
					break;
					
				case R_ELEPHANT:
				case B_ELEPHANT:
					Gen_ElephantMove(position, i, j, nPly);
					break;
					
				case R_HORSE:		
				case B_HORSE:		
					Gen_HorseMove(position, i, j, nPly);
					break;
					
				case R_CAR:
				case B_CAR:
					Gen_CarMove(position, i, j, nPly);
					break;
					
				case R_PAWN:
					Gen_RPawnMove(position, i, j, nPly);
					break;
					
				case B_PAWN:
					Gen_BPawnMove(position, i, j, nPly);
					break;
					
				case B_CANON:
				case R_CANON:
					Gen_CanonMove(position, i, j, nPly);
					break;
					
				default:
					break;
					
				}
			}
		}
		
		return m_nMoveCount;
}



void CMoveGenerator::Gen_KingMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x,  y;
	for (y = 0; y < 3; y++)
		for (x = 3; x < 6; x++)
			if (IsValidMove(position, j, i, x, y))
				AddMove(j, i, x, y, nPly);

	for (y = 7; y < 10; y++)
		for (x = 3; x < 6; x++)
			if (IsValidMove(position, j, i, x, y))
				AddMove(j, i, x, y, nPly);
}

void CMoveGenerator::Gen_RBishopMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x,  y;
	for (y = 7; y < 10; y++)
		for (x = 3; x < 6; x++)
			if (IsValidMove(position, j, i, x, y))
				AddMove(j, i, x, y, nPly);
}

void CMoveGenerator::Gen_BBishopMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x,  y;
	for (y = 0; y < 3; y++)
		for (x = 3; x < 6; x++)
			if (IsValidMove(position, j, i, x, y))
				AddMove(j, i, x, y, nPly);
}

void CMoveGenerator::Gen_ElephantMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x,  y;

	x=j+2;
	y=i+2;
	if(x < 9 && y < 10  && IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
	x=j+2;
	y=i-2;
	if(x < 9 && y>=0  &&  IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
	x=j-2;
	y=i+2;
	if(x>=0 && y < 10  && IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
	x=j-2;
	y=i-2;
	if(x>=0 && y>=0  && IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
}

void CMoveGenerator::Gen_HorseMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x,  y;

	x=j+2;
	y=i+1;
	if((x < 9 && y < 10) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
	x=j+2;
	y=i-1;
	if((x < 9 && y >= 0) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
	x=j-2;
	y=i+1;
	if((x >= 0 && y < 10) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
	x=j-2;
	y=i-1;
	if((x >= 0 && y >= 0) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
	x=j+1;
	y=i+2;
	if((x < 9 && y < 10) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	x=j-1;
	y=i+2;
	if((x >= 0 && y < 10) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	x=j+1;
	y=i-2;
	if((x < 9 && y >= 0) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	x=j-1;
	y=i-2;
	if((x >= 0 && y >= 0) &&IsValidMove(position, j, i, x, y))
		AddMove(j, i, x, y, nPly);
	
}

void CMoveGenerator::Gen_RPawnMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x, y;
	int nChessID;

	nChessID = position[i][j];

	y = i - 1;
	x = j;
	
	if(y > 0 && !IsSameSide(nChessID, position[y][x]))
		AddMove(j, i, x, y, nPly);
	
	if(i < 5)
	{
		y=i;
		x=j+1;
		if(x < 9 && !IsSameSide(nChessID, position[y][x]))
			AddMove(j, i, x, y, nPly);
		x=j-1;
		if(x >= 0 && !IsSameSide(nChessID, position[y][x]))
			AddMove(j, i, x, y, nPly);
	}
}


void CMoveGenerator::Gen_BPawnMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x, y;
	int nChessID;

	nChessID = position[i][j];

	y = i + 1;
	x = j;
	
	if(y < 10 && !IsSameSide(nChessID, position[y][x]))
		AddMove(j, i, x, y, nPly);
	
	if(i > 4)
	{
		y=i;
		x=j+1;
		if(x < 9 && !IsSameSide(nChessID, position[y][x]))
			AddMove(j, i, x, y, nPly);
		x=j-1;
		if(x >= 0 && !IsSameSide(nChessID, position[y][x]))
			AddMove(j, i, x, y, nPly);
	}
	
}

void CMoveGenerator::Gen_CarMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x,  y;
	int nChessID;

	nChessID = position[i][j];
	
	x=j+1;
	y=i;
	while(x < 9)
	{
		if( NOCHESS == position[y][x] )
			AddMove(j, i, x, y, nPly);
		else
		{
			if(!IsSameSide(nChessID, position[y][x]))
				AddMove(j, i, x, y, nPly);
			break;
		}
		x++;
	}
	
	x = j-1;
	y = i;
	while(x >= 0)
	{
		if( NOCHESS == position[y][x] )
			AddMove(j, i, x, y, nPly);
		else
		{
			if(!IsSameSide(nChessID, position[y][x]))
				AddMove(j, i, x, y, nPly);
			break;
		}
		x--;
	}
	
	x=j;
	y=i+1;//
	while(y < 10)
	{
		if( NOCHESS == position[y][x])
			AddMove(j, i, x, y, nPly);
		else
		{
			if(!IsSameSide(nChessID, position[y][x]))
				AddMove(j, i, x, y, nPly);
			break;
		}
		y++;
	}
	
	x = j;
	y = i-1;//
	while(y>=0)
	{
		if( NOCHESS == position[y][x])
			AddMove(j, i, x, y, nPly);
		else
		{
			if(!IsSameSide(nChessID, position[y][x]))
				AddMove(j, i, x, y, nPly);
			break;
		}
		y--;
	}
}

void CMoveGenerator::Gen_CanonMove(BYTE position[10][9], int i, int j, int nPly)
{
	int x, y;
	BOOL	flag;
	int nChessID;

	nChessID = position[i][j];
	
	x=j+1;		//
	y=i;
	flag=FALSE;
	while(x < 9)		
	{
		if( NOCHESS == position[y][x] )
		{
			if(!flag)
				AddMove(j, i, x, y, nPly);
		}
		else
		{
			if(!flag)
				flag=TRUE;
			else 
			{
				if(!IsSameSide(nChessID, position[y][x]))
					AddMove(j, i, x, y, nPly);
				break;
			}
		}
		x++;
	}
	
	x=j-1;
	flag=FALSE;	
	while(x>=0)
	{
		if( NOCHESS == position[y][x] )
		{
			if(!flag)
				AddMove(j, i, x, y, nPly);
		}
		else
		{
			if(!flag)
				flag=TRUE;
			else 
			{
				if(!IsSameSide(nChessID, position[y][x]))
					AddMove(j, i, x, y, nPly);
				break;
			}
		}
		x--;
	}
	x=j;	
	y=i+1;
	flag=FALSE;
	while(y < 10)
	{
		if( NOCHESS == position[y][x] )
		{
			if(!flag)
				AddMove(j, i, x, y, nPly);
		}
		else
		{
			if(!flag)
				flag=TRUE;
			else 
			{
				if(!IsSameSide(nChessID, position[y][x]))
					AddMove(j, i, x, y, nPly);
				break;
			}
		}
		y++;
	}
	
	y=i-1;	//
	flag=FALSE;	
	while(y>=0)
	{
		if( NOCHESS == position[y][x] )
		{
			if(!flag)
				AddMove(j, i, x, y, nPly);
		}
		else
		{
			if(!flag)
				flag=TRUE;
			else 
			{
				if(!IsSameSide(nChessID, position[y][x]))
					AddMove(j, i, x, y, nPly);
				break;
			}
		}
		y--;
	}
	
}

BOOL CMoveGenerator::IsValidMove(BYTE position[10][9], int nFromX, int nFromY, int nToX, int nToY)
{
	int i, j;
	int nMoveChessID, nTargetID;
	
	if (nFromY ==  nToY && nFromX == nToX)
		return FALSE;//目的與源相同
	
	nMoveChessID = position[nFromY][nFromX];
	nTargetID = position[nToY][nToX];
	
	if (IsSameSide(nMoveChessID, nTargetID))
		return FALSE;//不能吃自己的棋
	
	switch(nMoveChessID)
	{
	case B_KING:     
		if (nTargetID == R_KING)//老將見面?
		{
			if (nFromX != nToX)
				return FALSE;
			for (i = nFromY + 1; i < nToY; i++)
				if (position[i][nFromX] != NOCHESS)
					return FALSE;
		}
		else
		{
			if (nToY > 2 || nToX > 5 || nToX < 3)
				return FALSE;//目標點在九宮之外
			if(abs(nFromY - nToY) + abs(nToX - nFromX) > 1) 
				return FALSE;//將帥只走一步直線:
		}
		break;
	case R_BISHOP:   
		
		if (nToY < 7 || nToX > 5 || nToX < 3)
			return FALSE;//士出九宮	
		
		if (abs(nFromY - nToY) != 1 || abs(nToX - nFromX) != 1)
			return FALSE;	//士走斜線
		
		break;
		
	case B_BISHOP:   //黑士
		
		if (nToY > 2 || nToX > 5 || nToX < 3)
			return FALSE;//士出九宮	
		
		if (abs(nFromY - nToY) != 1 || abs(nToX - nFromX) != 1)
			return FALSE;	//士走斜線
		
		break;
		
	case R_ELEPHANT://紅象
		
		if(nToY < 5)
			return FALSE;//相不能過河
		
		if(abs(nFromX-nToX) != 2 || abs(nFromY-nToY) != 2)
			return FALSE;//相走田字
		
		if(position[(nFromY + nToY) / 2][(nFromX + nToX) / 2] != NOCHESS)
			return FALSE;//相眼被塞住了
		
		break;
		
	case B_ELEPHANT://黑象 
		
		if(nToY > 4)
			return FALSE;//相不能過河
		
		if(abs(nFromX-nToX) != 2 || abs(nFromY-nToY) != 2)
			return FALSE;//相走田字
		
		if(position[(nFromY + nToY) / 2][(nFromX + nToX) / 2] != NOCHESS)
			return FALSE;//相眼被塞住了
		
		break;
		
	case B_PAWN:     //黑兵
		
		if(nToY < nFromY)
			return FALSE;//兵不回頭
		
		if( nFromY < 5 && nFromY == nToY)
			return FALSE;//兵過河前只能直走
		
		if(nToY - nFromY + abs(nToX - nFromX) > 1)
			return FALSE;//兵只走一步直線:
		
		break;
		
	case R_PAWN:    //紅兵
		
		if(nToY > nFromY)
			return FALSE;//兵不回頭
		
		if( nFromY > 4 && nFromY == nToY)
			return FALSE;//兵過河前只能直走
		
		if(nFromY - nToY + abs(nToX - nFromX) > 1)
			return FALSE;//兵只走一步直線:
		
		break;
		
	case R_KING:     
		if (nTargetID == B_KING)//老將見面?
		{
			if (nFromX != nToX)
				return FALSE;//兩個將不在同一列
			for (i = nFromY - 1; i > nToY; i--)
				if (position[i][nFromX] != NOCHESS)
					return FALSE;//中間有別的子
		}
		else
		{
			if (nToY < 7 || nToX > 5 || nToX < 3)
				return FALSE;//目標點在九宮之外
			if(abs(nFromY - nToY) + abs(nToX - nFromX) > 1) 
				return FALSE;//將帥只走一步直線:
		}
		break;
		
	case B_CAR:      
	case R_CAR:      
		
		if(nFromY != nToY && nFromX != nToX)
			return FALSE;	//車走直線:
		
		if(nFromY == nToY)
		{
			if(nFromX < nToX)
			{
				for(i = nFromX + 1; i < nToX; i++)
					if(position[nFromY][i] != NOCHESS)
						return FALSE;
			}
			else
			{
				for(i = nToX + 1; i < nFromX; i++)
					if(position[nFromY][i] != NOCHESS)
						return FALSE;
			}
		}
		else
		{
			if(nFromY < nToY)
			{
				for(j = nFromY + 1; j < nToY; j++)
					if(position[j][nFromX] != NOCHESS)
						return FALSE;
			}
			else
			{
				for(j= nToY + 1; j < nFromY; j++)
					if(position[j][nFromX] != NOCHESS)
						return FALSE;
			}
		}
		
		break;
		
	case B_HORSE:    
	case R_HORSE:    
		
		if(!((abs(nToX-nFromX)==1 && abs(nToY-nFromY)==2)
			||(abs(nToX-nFromX)==2&&abs(nToY-nFromY)==1)))
			return FALSE;//馬走日字
		
		if	(nToX-nFromX==2)
		{
			i=nFromX+1;
			j=nFromY;
		}
		else if	(nFromX-nToX==2)
		{
			i=nFromX-1;
			j=nFromY;
		}
		else if	(nToY-nFromY==2)
		{
			i=nFromX;
			j=nFromY+1;
		}
		else if	(nFromY-nToY==2)
		{
			i=nFromX;
			j=nFromY-1;
		}
		
		if(position[j][i] != NOCHESS)
			return FALSE;//絆馬腿
		
		break;
	
	case B_CANON:    
	case R_CANON:    
		
		if(nFromY!=nToY && nFromX!=nToX)
			return FALSE;	//炮走直線:
		
		//炮不吃子時經過的路線中不能有棋子
		
		if(position[nToY][nToX] == NOCHESS)
		{
			if(nFromY == nToY)
			{
				if(nFromX < nToX)
				{
					for(i = nFromX + 1; i < nToX; i++)
						if(position[nFromY][i] != NOCHESS)
							return FALSE;
				}
				else
				{
					for(i = nToX + 1; i < nFromX; i++)
						if(position[nFromY][i]!=NOCHESS)
							return FALSE;
				}
			}
			else
			{
				if(nFromY < nToY)
				{
					for(j = nFromY + 1; j < nToY; j++)
						if(position[j][nFromX] != NOCHESS)
							return FALSE;
				}
				else
				{
					for(j = nToY + 1; j < nFromY; j++)
						if(position[j][nFromX] != NOCHESS)
							return FALSE;
				}
			}
		}
		//炮吃子時
		else	
		{
			int count=0;
			if(nFromY == nToY)
			{
				if(nFromX < nToX)
				{
					for(i=nFromX+1;i<nToX;i++)
						if(position[nFromY][i]!=NOCHESS)
							count++;
						if(count != 1)
							return FALSE;
				}
				else
				{
					for(i=nToX+1;i<nFromX;i++)
						if(position[nFromY][i] != NOCHESS)
							count++;
						if(count!=1)
							return FALSE;
				}
			}
			else
			{
				if(nFromY<nToY)
				{
					for(j=nFromY+1;j<nToY;j++)
						if(position[j][nFromX]!=NOCHESS)
							count++;
						if(count!=1)
							return FALSE;
				}
				else
				{
					for(j=nToY+1;j<nFromY;j++)
						if(position[j][nFromX] != NOCHESS)
							count++;
						if(count!=1)
							return FALSE;
				}
			}
		}
		break;
	default:
		return FALSE;
	}
	
	return TRUE;
}

完整原始碼，資源以及執行exe連結http://download.csdn.net/download/zhangxiaoyu_sy/9939114

象棋人機對戰

象棋主要演算法程式碼 Eveluation.h Eveluation.cpp這一對檔案定義並實現了估值核心類。 #if !defined(AFX_EVELUATION_H__2AF7A221_CB28_11D5_AEC7_5254AB2E22C7__INCLUDED_)

基於Qt Creator實現中國象棋人機對戰， c++實現

這是自己大一學完c++後，在課程實踐中寫過的一個程式，實現象棋人機對戰的演算法還是有點難的，自己當時差不多也是寫了兩個月左右吧！當時看書又有很多問題得不到解決，所以就在網上找了一個視訊跟著

Python小遊戲井字棋（人機對戰，玩家對戰）

pan urn utf-8 erl ext print cef () nbsp # -*- coding:utf-8 -*-import timeimport random#井字棋人機對戰def drawBoard(board): blank_board = '|

AI智慧人機對戰五子棋(Java實現圖形介面)

簡述這是本學期上完Java課後老師給出的課程設計題目，目的是：熟悉與掌握GUI程式設計；實現五子棋棋盤和棋子的繪製；實現遊戲AI以及對二維陣列的使用。介面效果圖電腦先行，玩家輸贏圖：玩家先行，玩家輸贏圖：整體設計介面設

五子棋專案的實現（三）人機對戰類的具體設計

在之前描述了博弈樹演算法的思想，現在則是關鍵類的設計實現。在具體的過程中我們先要設計一個遍歷棋型演算法，來遍歷整個棋盤中的各種棋型通過最後返回值的不同，來確定不同的棋型當中有評估函式對當前的棋型進行打分。再選取區域性最優的幾個落子點作為下一步擴充套件的節點。 //bwf 棋色

"人機"對戰：電腦太簡單了，我是射手 skr~skr~skr

9月17日，2018 世界人工智慧大會在上海拉開帷幕。在 SAIL 榜單入圍專案中，我看到了小愛同學、小馬智行、微軟小冰、騰訊覓影等等，這不僅讓我大開了眼界，也不禁讓我感慨 AI 的發展神速。猶記得去年在中國烏鎮圍棋峰會上，AlphaGo 與排名世界第一的世界圍棋冠軍柯潔對戰，以 3 比 0 的總比分獲勝，那

人機對戰(猜拳)

# -*- coding: utf-8 -*-# 人和機器猜拳遊戲寫成一個類，有如下幾個函式：# 1）函式1：選擇角色1 曹操 2張飛 3 劉備# 2）函式2：角色猜拳1剪刀 2石頭 3布玩家輸入一個1-3的數字# 3）函式3：電腦出拳隨機產生1個1-3的數字，提示電腦出拳結果# 4）函式4：角色和機器出

井字遊戲人機對戰 java實現

package com.ecnu.Main; /** * 主函式觸發遊戲 */public class MainApplication { public static void main(String[] args){ TicTacToeGame ticTacToeGame = new TicTacToeG

C# winform 簡單五子棋 200行程式碼實現人機對戰

1、功能需求接上篇博文，本文描述簡單人機對戰實現過程，只是簡單實現考慮走一步策略，如果要想實現走多步策略，可以在本文估值演算法的基礎上用極大極小值配合剪枝演算法，實現考慮多步策略，這樣ai會顯得更加聰明，後期如果有時間完善，會更新程式碼。2、介面設計參考上一篇博文的介面。3、

java五子棋人機對戰演算法分析

五子棋人機對戰採用的演算法，目前大都是搜尋樹演算法，用一棵樹來表示棋局發展的種種可能性，這種樹叫做博弈樹(對局樹)。根節點表示對局的開始狀態，每一種可能的走法造成的結果作為其子節點，而對每一個這樣的子節點，考慮另一方的各種可能應對，作為下一層的子節點，這

Java Swing實現的人機對戰三子棋

1.照例，先來看看執行結果吧。 2.演算法思想： 1.普通情況下，當玩家先下時，演算法根據當前情況判斷自己是否能贏。若可以，則直接選擇該情況，否則開始判斷玩家是否有可以贏的位置，若有，則堵死玩家，，若仍沒有，選擇當前最合適的走法，走法較多時，使用隨機

QT五子棋專案詳解之四：AI人機對戰max-min極大極小值博弈演算法

不考慮博弈的演算法怎麼能算是AI呢？max-min極大極小值演算法就是考慮了博弈的演算法。來看一個簡單的例子在這個棋局中，電腦為白旗，白旗走哪一步更好呢，也許使用策略表會告訴你，應該衝4，但是衝4後，玩家就會連成4。這就是考慮了博弈之後，這一步棋就是敗局。這就是為什麼有max

五子棋人機對戰完整程式碼

一，五子棋棋盤棋盤正中一點為“天元”。棋盤兩端的橫線稱端線。棋盤左右最外邊的兩條縱線稱邊線。從兩條端線和兩條邊線向正中發展而縱橫交叉在第四條線形成的四個點稱為“星”。以持黑方為準，棋盤上的縱軸線從左到右用英文字母A~O標記。橫行線從近到遠用阿拉伯數字1~15標記。縱橫軸上的橫

Android實現五子棋遊戲（二）人機對戰實現

下面簡單介紹一下實現人機對戰的思路以及程式碼實現：思路人機對戰的總體思路是通過遍歷所有的無棋子的位置，通過模擬在每個無棋子點落子，並根據其周圍的棋子來獲取該點的兩個優先順序評分：模擬使用者棋子來獲取一個優先順序評分，用於防守（使用者

六子衝棋，六子炮棋，二打一棋，箭棋，炮棋（java單機版）java人機對戰

原始碼及exe檔案帶jre下載：六子衝　　六子衝是流傳於中國民間的一類棋類遊戲。由於這個遊戲對環境的要求不高,孩子們大都是在光滑的地面或石板上畫上方格，以石子或木棍、草節等為棋子，並有簡單的比賽規則: 　　縱橫各四條直線組成一個正方形棋盤，直線相交的地方為落

（Java專案）人機五子棋對戰

本文將在控制檯五子棋的基礎上繼續完善，改寫成具有介面的人機對戰五子棋遊戲。專案主要內容 1、書寫棋盤介面，關鍵是繪製棋盤和棋子 2、點選棋盤下棋，繫結事件，書寫機器落子核心邏輯程式碼。關鍵是判斷輸贏及計算每個空位評分，確定每一步機器落子位置。其他都是細節

使用JavaScript建立模組化的雙人對戰象棋程式

1. 關於這篇文章 2004年，我花兩天時間，用JavaScript和VML建立了一個單機雙人象棋，並且作了簡短的分析。在那個時代，沒有AngularJS，沒有BackBone，沒有所有這些前端MV*框架。甚至沒有jQuery，沒有prototype，沒有mootool

使用Qt開發中國象棋（七）：網路對戰

關於Qt網路程式設計 QTcpServer用於建立TCP伺服器端。當newConnection訊號激發時，我們呼叫指定的槽建立一個通訊的套接字。 QTcpSocket用於建立TCP通訊套接字。當connected訊號激發時，我們向伺服器端傳送訊息，當read

Unity中國象棋（五）——網路對戰的實現（服務端的基本功能）

博主主要是用了socket的方法去實現了伺服器和客戶端之間的通訊，由於樓主對於socket網路程式設計這一方面的基礎相當薄弱，故也是邊學邊學，有些地方的程式碼不夠完善還請大神指正！博主還需學習。首先，先說說服務端方面：服務端採用的是VS的windows form窗體應用

hackerrank Alex對戰Fedor

lose read char view 一個我們如果 void ems 任意門為了在漫長得飛行旅途中娛樂，Alex和Fedor發明了如下的一個簡單的雙人遊戲。遊戲是：首先， Alex畫一個有權無向圖。該圖中可能有多重邊（多重邊的權值可能相同或者不同）。然後

象棋人機對戰

相關推薦