chessboard.cpp

一个简单的华容道的算法；很适合初学者学习参考。

// chessBoard.cpp: implementation of the ChessBoard class.
//
//////////////////////////////////////////////////////////////////////

#include "chessBoard.h"


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

ChessBoard::ChessBoard()
{

}

ChessBoard::ChessBoard(Chess* ch,int size)
{
	for(int i=0; i<size; i++)
	{
		chess[i]=ch[i];
	}
}

ChessBoard::~ChessBoard()
{

}

bool ChessBoard::CanDown(int index)
{
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
		if(((ch.chessPosition.y+2==chess[11].chessPosition.y)
			&&(ch.chessPosition.x==chess[11].chessPosition.x))
			||((ch.chessPosition.y+2==chess[10].chessPosition.y))
			&&(ch.chessPosition.x==chess[10].chessPosition.x))
		{
			return true;
		}
		else return false;break;
	case 2: //横放
		if(  (chess[10].chessPosition.y==chess[11].chessPosition.y)&&
			abs((chess[10].chessPosition.x-chess[11].chessPosition.x))==1 &&
			((ch.chessPosition.x*2+1)==(chess[10].chessPosition.x+chess[11].chessPosition.x)) &&
			(ch.chessPosition.y+1==chess[10].chessPosition.y)
			)
		{
			return true;
		}
		else return false;break;
	case 3: //卒
		if(ch.chessPosition.Down().equal(chess[11].chessPosition)||ch.chessPosition.Down().equal(chess[10].chessPosition))
		{
			return true;
		}
		else return false;break;
	case 4: //曹
		if(  (chess[10].chessPosition.y==chess[11].chessPosition.y)&&
			abs(chess[10].chessPosition.x-chess[11].chessPosition.x)==1 &&
			((ch.chessPosition.x*2+1)==(chess[10].chessPosition.x+chess[11].chessPosition.x)) &&
			(ch.chessPosition.y+2==chess[10].chessPosition.y)
			)
		{
			return true;
		}
		else return false;break;
	}
	return false;
}

bool ChessBoard::CanUp(int index)
{
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
		if(ch.chessPosition.Up().equal(chess[10].chessPosition)
		|| ch.chessPosition.Up().equal(chess[11].chessPosition))
		{
			return true;
		}
		else return false;
		break;
	case 2: //横
	        if( abs(chess[10].chessPosition.x-chess[11].chessPosition.x)==1
	        && chess[10].chessPosition.y==chess[11].chessPosition.y 
	        && ch.chessPosition.y-1==chess[10].chessPosition.y 
	        && ch.chessPosition.x*2+1==chess[10].chessPosition.x+chess[11].chessPosition.x )
	        {
	        	return true;
	        }
	        else return false;
		break;
	case 3: //卒
	        if(ch.chessPosition.Up().equal(chess[10].chessPosition)
	        || ch.chessPosition.Up().equal(chess[11].chessPosition))
	        {
	        	return true;
	        }
	        else return false;
		break;
	case 4: //曹
	        if( abs(chess[10].chessPosition.x-chess[11].chessPosition.x)==1
	        && chess[10].chessPosition.y==chess[11].chessPosition.y 
	        && ch.chessPosition.y-1==chess[10].chessPosition.y 
	        && ch.chessPosition.x*2+1==chess[10].chessPosition.x+chess[11].chessPosition.x )
		{
	        	return true;
	        }
	        else return false;
		break;
	}
}

bool ChessBoard::CanLeft(int index)
{
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
		if( chess[10].chessPosition.x==chess[11].chessPosition.x
		 && abs(chess[10].chessPosition.y-chess[11].chessPosition.y)==1
		 && ch.chessPosition.x-1==chess[10].chessPosition.x
		 && ch.chessPosition.y*2+1==chess[10].chessPosition.y+chess[11].chessPosition.y )
		{
			return true;
		}
		else return false;
		break;
	case 2: //横
	        if(ch.chessPosition.Left().equal(chess[10].chessPosition)
	         || ch.chessPosition.Left().equal(chess[11].chessPosition))
	        {
	        	return true;
	        }
	        else return false;
		break;
	case 3: //卒
	        if(ch.chessPosition.Left().equal(chess[10].chessPosition)
	         || ch.chessPosition.Left().equal(chess[11].chessPosition))
	        {
	        	return true;
	        }
	        else return false;
		break;
	case 4: //曹
	        if( chess[10].chessPosition.x==chess[11].chessPosition.x
		 && abs(chess[10].chessPosition.y-chess[11].chessPosition.y)==1
		 && ch.chessPosition.x-1==chess[10].chessPosition.x
		 && ch.chessPosition.y*2+1==chess[10].chessPosition.y+chess[11].chessPosition.y )
		{
			return true;
		}
		else return false;
		break;
	}
}

bool ChessBoard::CanRight(int index)
{
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
		if( chess[10].chessPosition.x==chess[11].chessPosition.x
		 && abs(chess[10].chessPosition.y-chess[11].chessPosition.y)==1
		 && ch.chessPosition.x+1==chess[10].chessPosition.x
		 && ch.chessPosition.y*2+1==chess[10].chessPosition.y+chess[11].chessPosition.y )
		{
			return true;
		}
		else return false;
		break;
	case 2: //横
	        if(ch.chessPosition.Right().Right().equal(chess[10].chessPosition)
	         || ch.chessPosition.Right().Right().equal(chess[11].chessPosition))
	        {
	        	return true;
	        }
	        else return false;
		break;
	case 3: //卒
	        if(ch.chessPosition.Right().equal(chess[10].chessPosition)
	         || ch.chessPosition.Right().equal(chess[11].chessPosition))
	        {
	        	return true;
	        }
	        else return false;
		break;
	case 4: //曹
	        if( chess[10].chessPosition.x==chess[11].chessPosition.x
		 && abs(chess[10].chessPosition.y-chess[11].chessPosition.y)==1
		 && ch.chessPosition.x+2==chess[10].chessPosition.x
		 && ch.chessPosition.y*2+1==chess[10].chessPosition.y+chess[11].chessPosition.y )
		{
			return true;
		}
		else return false;
		break;
	}
}

void ChessBoard::Down(int index)
{
	chess[index].chessPosition.y+=1;
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
		{
			if(ch.chessPosition.x==chess[10].chessPosition.x
				&&ch.chessPosition.y+1==chess[10].chessPosition.y)
			{
				chess[10].chessPosition.y-=2;
			}
			else
				chess[11].chessPosition.y-=2;
			break;
		}
	case 2: //横放
		{
			chess[10].chessPosition.y-=1;
			chess[11].chessPosition.y-=1;
			break;
		}
	case 3: //卒
		{
			if((ch.chessPosition.x == chess[10].chessPosition.x)
				&&(ch.chessPosition.y == chess[10].chessPosition.y))
				chess[10].chessPosition.y-=1;
			else
				chess[11].chessPosition.y-=1;
			break;
		}
	case 4: //曹
		{
			chess[10].chessPosition.y-=2;
			chess[11].chessPosition.y-=2;
			break;
		}
	}
}

void ChessBoard::Up(int index)
{
	chess[index].chessPosition.y-=1;
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
	        {
	        	if(ch.chessPosition.equal(chess[10].chessPosition))
	        	{
	        		chess[10].chessPosition.y+=2;
	        	}
	        	else
	        		chess[11].chessPosition.y+=2;
	                break;
	        }
	case 2: //横放
		{
			chess[10].chessPosition.y+=1;
			chess[11].chessPosition.y+=1;
			break;
	        }
	case 3: //卒
		{
			if(ch.chessPosition.equal(chess[10].chessPosition))
			{
				chess[10].chessPosition.y+=1;
			}
			else
				chess[11].chessPosition.y+=1;
			break;
	        }
	case 4: //曹
		{
			chess[10].chessPosition.y+=2;
			chess[11].chessPosition.y+=2;
			break;
	        }
	}
}

void ChessBoard::Left(int index)
{
	chess[index].chessPosition.x-=1;
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
		{
			chess[10].chessPosition.x+=1;
			chess[11].chessPosition.x+=1;
			break;
		}
	case 2: //横放
		{
			if(ch.chessPosition.equal(chess[10].chessPosition))
			{
				chess[10].chessPosition.x+=2;
			}
			else
				chess[11].chessPosition.x+=2;
			break;
		}
	case 3: //卒
		{
			if(ch.chessPosition.equal(chess[10].chessPosition))
			{
				chess[10].chessPosition.x+=1;
			}
			else
				chess[11].chessPosition.x+=1;
			break;
		}
	case 4: //曹
		{
			chess[10].chessPosition.x+=2;
			chess[11].chessPosition.x+=2;
			break;
		}
	}
}

void ChessBoard::Right(int index)
{
	chess[index].chessPosition.x+=1;
	Chess ch=chess[index];
	switch(ch.chessType)
	{
	case 1: //竖放
		{
			chess[10].chessPosition.x-=1;
			chess[11].chessPosition.x-=1;
			break;
		}
	case 2: //横放
		{
			if(ch.chessPosition.Right().equal(chess[10].chessPosition))
			{
				chess[10].chessPosition.x-=2;
			}
			else
				chess[11].chessPosition.x-=2;
			break;
		}
	case 3: //卒
		{
			if(ch.chessPosition.equal(chess[10].chessPosition))
			{
				chess[10].chessPosition.x-=1;
			}
			else
				chess[11].chessPosition.x-=1;
			break;
		}
	case 4: //曹
		{
			chess[10].chessPosition.x-=2;
			chess[11].chessPosition.x-=2;
			break;
		}
	}	
}

bool ChessBoard::IsOK()
{
	return chess[5].chessPosition.x==1 && chess[5].chessPosition.y==3;
}

int ChessBoard::GetHead()
{
	int result=chess[0].chessPosition.x*268435456+chess[0].chessPosition.y*33554432
		      +chess[1].chessPosition.x*8388608+chess[1].chessPosition.y*1048576
			  +chess[2].chessPosition.x*262144+chess[2].chessPosition.y*32768
			  +chess[3].chessPosition.x*8192+chess[3].chessPosition.y*1024
			  +chess[4].chessPosition.x*256+chess[4].chessPosition.y*32
			  +chess[5].chessPosition.x*8+chess[5].chessPosition.y;
	return result;
}

int ChessBoard::GetTail()
{
	int result=chess[6].chessPosition.x*268435456+chess[6].chessPosition.y*33554432
		      +chess[7].chessPosition.x*8388608+chess[7].chessPosition.y*1048576
			  +chess[8].chessPosition.x*262144+chess[8].chessPosition.y*32768
			  +chess[9].chessPosition.x*8192+chess[9].chessPosition.y*1024
			  +chess[10].chessPosition.x*256+chess[10].chessPosition.y*32
			  +chess[11].chessPosition.x*8+chess[11].chessPosition.y;
	return result;
}

void ChessBoard::operator =(ChessBoard cb)
{
	for(int i=0; i<12; i++)
	{
		chess[i].chessPosition = cb.chess[i].chessPosition;
	}
}

ChessBoard::ChessBoard(int vHead,int vTail)
{

	chess[0].chessPosition.x=vHead/(1<<28);
	chess[0].chessPosition.y=vHead%(1<<28)/(1<<25);
//	cout<<cb.GetHead()/1024/1024/256<<endl                    //x0
//      <<cb.GetHead()%(1024*1024*256)/(1024*1024*32)<<endl       //y0
	chess[1].chessPosition.x=vHead%(1<<25)/(1<<23);
	chess[1].chessPosition.y=vHead%(1<<23)/(1<<20);
//	<<cb.GetHead()%(1024*1024*32)/(1024*1024*8)<<endl         //x1 
//	<<cb.GetHead()%(1024*1024*8)/(1024*1024)<<endl            //y1
	chess[2].chessPosition.x=vHead%(1<<20)/(1<<18);
	chess[2].chessPosition.y=vHead%(1<<18)/(1<<15);
//	<<cb.GetHead()%(1024*1024)/(1024*256)<<endl               //x2 
//	<<cb.GetHead()%(1024*256)/(1024*32)<<endl                 //y2
	chess[3].chessPosition.x=vHead%(1<<15)/(1<<13);
	chess[3].chessPosition.y=vHead%(1<<13)/(1<<10);
//	<<cb.GetHead()%(1024*32)/(1024*8)<<endl                   //x3
//	<<cb.GetHead()%(1024*8)/1024<<endl                        //y3
	chess[4].chessPosition.x=vHead%(1<<10)/(1<<8);
	chess[4].chessPosition.y=vHead%(1<<8)/(1<<5);
//	<<cb.GetHead()%1024/256<<endl                             //x4 
//	<<cb.GetHead()%256/32<<endl                               //y4   
	chess[5].chessPosition.x=vHead%(1<<5)/(1<<3);
	chess[5].chessPosition.y=vHead%(1<<3);
//	<<cb.GetHead()%32/8<<endl                                 //x5  
//      <<cb.GetHead()%8<<endl                                    //y5
//	<<endl;
	chess[6].chessPosition.x=vTail/(1<<28);
	chess[6].chessPosition.y=vTail%(1<<28)/(1<<25);
	chess[7].chessPosition.x=vTail%(1<<25)/(1<<23);
	chess[7].chessPosition.y=vTail%(1<<23)/(1<<20);
	chess[8].chessPosition.x=vTail%(1<<20)/(1<<18);
	chess[8].chessPosition.y=vTail%(1<<18)/(1<<15);
	chess[9].chessPosition.x=vTail%(1<<15)/(1<<13);
	chess[9].chessPosition.y=vTail%(1<<13)/(1<<10);
	chess[10].chessPosition.x=vTail%(1<<10)/(1<<8);
	chess[10].chessPosition.y=vTail%(1<<8)/(1<<5);
	chess[11].chessPosition.x=vTail%(1<<5)/(1<<3);
	chess[11].chessPosition.y=vTail%(1<<3);	
}