board.cpp

搜索算法部分使用minmax递归

#include "stdafx.h"
#include "Othello.h"

#include "Board.h"

CBoard::CBoard() {
	m_Color[BLACK] = "./res/black.bmp";
	m_Color[WHITE] = "./res/white.bmp";
	m_Drop[BLACK] = "./res/dropblack.bmp";
	m_Drop[WHITE] = "./res/dropwhite.bmp";
	m_HintName[BLACK] = "./res/canblack.bmp";
	m_HintName[WHITE] = "./res/canwhite.bmp";
	CString num;
	for(int i=1;i<4;i++) {
		num.Format("%d",i);
		m_W2B[i] = "./res/white"+num+".bmp";
		m_B2W[i] = "./res/black"+num+".bmp";
	}
	m_W2B[0] = m_W2B[4] = m_B2W[8] = m_B2W[9]= "./res/white.bmp";
	m_B2W[0] = m_B2W[4] = m_W2B[8]= m_W2B[9] ="./res/black.bmp";
	for(i=5;i<8;i++) {
		num.Format("%d",(i-4));
		m_B2W[i] = "./res/white"+num+".bmp";
		m_W2B[i] = "./res/black"+num+".bmp";
	}
/*
	m_W2B[0] = m_W2B[4] = m_B2W[5] = m_B2W[9] = "./res/white.bmp";
	m_B2W[0] = m_B2W[4] = m_W2B[5] = m_W2B[9]= "./res/black.bmp";
	for(i=6;i<9;i++) {
		num.Format("%d",(i-5));
		m_B2W[i] = "./res/white"+num+".bmp";
		m_W2B[i] = "./res/black"+num+".bmp";
	}*/
	m_Rotate[WHITE] = m_B2W;
	m_Rotate[BLACK] = m_W2B;	

	Reset();
	m_Hint = m_Turn = BLACK;

}

CBoard::~CBoard() {
}

void CBoard::Reset() {
	for(int i=0;i<8;i++) {
		for(int j=0;j<8;j++) {
			m_State[i][j] = SPACE;
		}
	}
	m_State[3][4] = BLACK;
	m_State[4][3] = BLACK;
	m_State[3][3] = WHITE;
	m_State[4][4] = WHITE;
	oldX = oldY = -1;

}

int CBoard::Get(int x,int y) {
	return m_State[x][y];
}


void CBoard::Drop(int x,int y,int state) {
	m_State[x][y] = m_Turn = state;
	oldX = x;
	oldY = y;

}
void CBoard::Change(int x,int y,int state) {
	m_State[x][y] = ROTATE;
}

bool CBoard::SetState(int x,int y,	int state) {
	if(state==ENABLE || state==SPACE) {
		m_State[x][y] = state;
		return true;
	}
	else 
		return false;
}

void CBoard::Clean() {
	int other;
	if(m_Turn == BLACK)
		other = WHITE;
	else
		other = BLACK;

	for(int i=0;i<8;i++) {
		for(int j=0;j<8;j++) {
			if(m_State[i][j] == ROTATE) {
				m_State[i][j] = m_Turn;
			}
		}
	}
}
void CBoard::Draw(CDC* pDC,int height,int num) {
//	if(num==9)
//		num=0;
	BITMAP bm;
	int r = height*5/60;
	CBitmap black,white,dropBlack,dropWhite,can,rotate;

	HBITMAP hchess = (HBITMAP)LoadImage(NULL,_T(m_Color[BLACK]),
		IMAGE_BITMAP,r,r,LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE);
	black.Attach(hchess);
	black.GetBitmap(&bm);
	hchess = (HBITMAP)LoadImage(NULL,_T(m_Color[WHITE]),
		IMAGE_BITMAP,r,r,LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE);
	white.Attach(hchess);
	white.GetBitmap(&bm);
	hchess = (HBITMAP)LoadImage(NULL,_T(m_Drop[BLACK]),
		IMAGE_BITMAP,r,r,LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE);
	dropBlack.Attach(hchess);
	dropBlack.GetBitmap(&bm);
	hchess = (HBITMAP)LoadImage(NULL,_T(m_Drop[WHITE]),
		IMAGE_BITMAP,r,r,LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE);
	dropWhite.Attach(hchess);
	dropWhite.GetBitmap(&bm);
//	if(num!=0) {
		hchess = (HBITMAP)LoadImage(NULL,_T(m_Rotate[m_Turn][num]),
			IMAGE_BITMAP,r,r,LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE);
		rotate.Attach(hchess);
		rotate.GetBitmap(&bm);
//	}

	if(m_Hint!=SPACE) {
		hchess = (HBITMAP)LoadImage(NULL,_T(m_HintName[m_Hint]),
			IMAGE_BITMAP,r,r,LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE);
		can.Attach(hchess);
		can.GetBitmap(&bm);
	}

	CBitmap board;
	HBITMAP hBoard = (HBITMAP)LoadImage(NULL,_T("./res/board.bmp"),
		IMAGE_BITMAP,height*8/6,height,LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE);
	board.Attach(hBoard);
	board.GetBitmap(&bm);

//	CBitmap *rotate[2];
//	rotate[0]=&black;

	CDC boardDC,blackDC,whiteDC,dropBlackDC,dropWhiteDC,canDC,rotateDC;

	blackDC.CreateCompatibleDC(pDC);
	whiteDC.CreateCompatibleDC(pDC);
	dropBlackDC.CreateCompatibleDC(pDC);
	dropWhiteDC.CreateCompatibleDC(pDC);
//	if(num!=0) {
		rotateDC.CreateCompatibleDC(pDC);
//	}
	if(m_Hint!=SPACE) {
		canDC.CreateCompatibleDC(pDC);
	}

	blackDC.SelectObject(&black);
	whiteDC.SelectObject(&white);
	dropBlackDC.SelectObject(&dropBlack);
	dropWhiteDC.SelectObject(&dropWhite);
//	if(num!=0) {
		rotateDC.SelectObject(&rotate);
//	}
	if(m_Hint!=SPACE) {
		canDC.SelectObject(&can);
	}

	chessDC[BLACK] = &blackDC;
	chessDC[WHITE] = &whiteDC;
	chessDC[DROPBLACK] = &dropBlackDC;
	chessDC[DROPWHITE] = &dropWhiteDC;
	if(m_Hint!=SPACE) {
		chessDC[ENABLE] = &canDC;
	}

	boardDC.CreateCompatibleDC(pDC);
	boardDC.SelectObject(&board);

/*	CDC rotateDC,*dc[2];

	rotateDC.CreateCompatibleDC(pDC);
	dc[BLACK] = &rotateDC;
*/
	int x,y;
	for(int i=0;i<8;i++) {
		for(int j=0;j<8;j++) {	
			x = (i+1)*height/10+height/106;
			y = (j+1)*height/10+height/106;
			int state = m_State[i][j];
			if(state == WHITE || state == BLACK) {
				boardDC.StretchBlt(x,y,height*8/6,height,chessDC[state],0,0,bm.bmWidth,bm.bmHeight,SRCCOPY);
			}
			if(state == ROTATE) {
				boardDC.StretchBlt(x,y,height*8/6,height,&rotateDC,0,0,bm.bmWidth,bm.bmHeight,SRCCOPY);
			}
			if(m_Hint!=SPACE) {
				if(state ==ENABLE)
					boardDC.StretchBlt(x,y,height*8/6,height,chessDC[state],0,0,bm.bmWidth,bm.bmHeight,SRCCOPY);
			}
		}
	}
	if(oldX!=-1) {
		x = (oldX+1)*height/10+height/106;
		y = (oldY+1)*height/10+height/106;
		int state = m_State[oldX][oldY] + (DROPBLACK-BLACK);
		boardDC.StretchBlt(x,y,height*8/6,height,chessDC[state],0,0,bm.bmWidth,bm.bmHeight,SRCCOPY);
	}
	pDC->StretchBlt(0,0,height*8/6,height,&boardDC,0,0,bm.bmWidth,bm.bmHeight,SRCCOPY);
	
	black.DeleteObject();
	white.DeleteObject();
	dropBlack.DeleteObject();
	dropWhite.DeleteObject();
//	if(num!=0) {
		rotate.DeleteObject();
//	}
	if(m_Hint!=SPACE) {
		can.DeleteObject();
	}
	board.DeleteObject();
	if(m_Hint!=SPACE) {
		canDC.DeleteDC();
	}

	blackDC.DeleteDC();
	whiteDC.DeleteDC();
	boardDC.DeleteDC();
	dropBlackDC.DeleteDC();
	dropWhiteDC.DeleteDC();
//	if(num!=0) {
		rotateDC.DeleteDC();
//	}
}