monkey24.h

简易扫雷

//吴志刚 2003  ewuzg2163.com//
#include <windows.h>
//#include <commctrl.h>
#include "resource/resource.h"
/////////////////////////////////
#define STATUS_NORMAL   0
#define STATUS_MARKED   1
#define STATUS_REVEALED 2
#define STATUS_BOMB     -1
/////////////////////////////////
#define TYPE_BEGINNER  0
#define TYPE_MIDDLE    1
#define TYPE_MASTER    2
#define TYPE_USER      3
//////////////////////////////////
#define FACE_PRESS     0
#define FACE_WIN       1
#define FACE_LOST      2
#define FACE_ALERT     3
#define FACE_NORMAL    4
#define FACE_WH        24
///////////////////////////////////
#define CYNUMBMP      23
#define CXNUMBMP      13

#define MAPINITX     20
#define MAPINITY     (20+CYNUMBMP)
#define BLOCKBMPCX   20
#define BLOCKBMPCY   20

#define MAXCOUNTX     10
#define MAXCOUNTY     10
#define MAXBOMBCOUNT  10

#define MMAXCOUNTX    16
#define MMAXCOUNTY    16
#define MMAXBOMBCOUNT 30

#define HMAXCOUNTX    24
#define HMAXCOUNTY    16
#define HMAXBOMBCOUNT 50

////////////////////global////////////////////
//POINT      BombInfoMatrix[MAXCOUNTY][MAXCOUNTX];
POINT**    BombInfoMatrix;
HBITMAP    bmpNumList[9];
HBITMAP    pNumBmp[11];
HBITMAP    bmpFace;

HBITMAP    bmpBomb;
HBITMAP    bmpBlock;
HBITMAP    bmpMark;
HINSTANCE  g_hinst;
BOOL	   g_bPlaying;
int nMarkedCount,nRightMarkedCount;
int g_nTimecount;
int g_nBlockCX,g_nBlockCY,g_nBombCount;
int g_nGameLev;
RECT  rcMap;
RECT  rcFace;
BOOL  bTimeSetted;
TCHAR szProfilePath[MAX_PATH];

//////////////////////////////////////////////
void M24_LoadAllBmp()
{
	bmpNumList[0]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BLACK));
	bmpNumList[1]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN1));
	bmpNumList[2]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN2));
	bmpNumList[3]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN3));
	bmpNumList[4]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN4));
	bmpNumList[5]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN5));
	bmpNumList[6]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN6));
	bmpNumList[7]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN7));
	bmpNumList[8]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BMPN8));

	bmpBomb=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BOMB));
	bmpBlock=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BLOCK));
	bmpMark=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_MARK));

	pNumBmp[0]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN0));
	pNumBmp[1]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN1));
	pNumBmp[2]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN2));
	pNumBmp[3]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN3));
	pNumBmp[4]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN4));
	pNumBmp[5]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN5));
	pNumBmp[6]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN6));
	pNumBmp[7]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN7));
	pNumBmp[8]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN8));
	pNumBmp[9]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCN9));

	pNumBmp[10]=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_BCNBACK));

	bmpFace=LoadBitmap(g_hinst,MAKEINTRESOURCE(IDB_FACES));
}
///////////////////////////////////////
BOOL AllocBombInfoMatrix()
{
	int j;
	BombInfoMatrix=new POINT*[g_nBlockCY];
	if(BombInfoMatrix==NULL)
		return FALSE;

	for(j=0;j<g_nBlockCY;j++)
	{
		BombInfoMatrix[j]=new POINT[g_nBlockCX];
		if(BombInfoMatrix[j]==NULL)
			return FALSE;
	}
	return TRUE;
}
///////////////////////////////////////
void FreeBombInfoMatrix()
{
	if(BombInfoMatrix!=NULL)
	{
		int j;
		for(j=0;j<g_nBlockCY;j++)
		{
			delete [g_nBlockCX]BombInfoMatrix[j];
		}
		delete 	[g_nBlockCY]BombInfoMatrix;
	}
}
/////////////////////////////////////
void InitBombInfoMatrix()
{
	int i,j,k,temp;
	int* maxblock;
	maxblock=new int[g_nBlockCX*g_nBlockCY];//用于产生随机位置

	for(j=0;j<g_nBlockCY;j++)
	{
		for(i=0;i<g_nBlockCX;i++)
		{
			BombInfoMatrix[j][i].x=0;
			BombInfoMatrix[j][i].y=STATUS_NORMAL;
			//BombInfoMatrix[j][i].y=STATUS_REVEALED;
		}
	}

	for(i=0;i<g_nBlockCX*g_nBlockCY;i++)
		maxblock[i]=i;
	temp=g_nBlockCX*g_nBlockCY;
    for(k=1;k<=g_nBombCount;k++)//产生MAXBOMBCOUNT个随机位置
	{
		j=rand()%temp;	
		BombInfoMatrix[maxblock[j]/g_nBlockCX][maxblock[j]%g_nBlockCX].x=-1;
		maxblock[j]=maxblock[temp-1];
		temp--;
	}
	delete [g_nBlockCX*g_nBlockCY]maxblock;
	//////////////////查询周围八个位置//////////////////////
	for(j=0;j<g_nBlockCY;j++)
	{
		for(i=0;i<g_nBlockCX;i++)
		{
			if(BombInfoMatrix[j][i].x!=-1)
			{
				temp=0;
				////////////////////////////////////////
				if((i-1>=0)&&(j-1>=0))//1
				{
					if(BombInfoMatrix[j-1][i-1].x==-1)
						temp++;
				}
				if(j-1>=0)//2
				{
					if(BombInfoMatrix[j-1][i].x==-1)
						temp++;
				}
				if((i+1<g_nBlockCX)&&(j-1>=0))//3
				{
					if(BombInfoMatrix[j-1][i+1].x==-1)
						temp++;				
				}
				if(i+1<g_nBlockCX)//4
				{
					if(BombInfoMatrix[j][i+1].x==-1)
						temp++;
				}
				if((i+1<g_nBlockCX)&&(j+1<g_nBlockCY))//5
				{
					if(BombInfoMatrix[j+1][i+1].x==-1)
						temp++;
				}
				if(j+1<g_nBlockCY)//6
				{
					if(BombInfoMatrix[j+1][i].x==-1)
						temp++;
				}
				if((i-1>=0)&&(j+1<g_nBlockCY))//7
				{
					if(BombInfoMatrix[j+1][i-1].x==-1)
						temp++;
				}
				if(i-1>=0)//8
				{
					if(BombInfoMatrix[j][i-1].x==-1)
						temp++;
				}
				BombInfoMatrix[j][i].x=temp;
			}//check the nobomb block
		}
	}
}
/////////////////////////////////////////////////////////////////
void DrawSingleBlock(int indexX,int indexY,HDC hdcMap,BOOL bInitXY)
{
	if((indexX<0)||(indexX>=g_nBlockCX)||(indexY<0)||(indexY>=g_nBlockCY))
		return;
	HDC hdcMem=CreateCompatibleDC(hdcMap);
	if(BombInfoMatrix[indexY][indexX].y==STATUS_NORMAL)
	{
		SelectObject(hdcMem,bmpBlock);
	}
	else if(BombInfoMatrix[indexY][indexX].y==STATUS_MARKED)
	{
		SelectObject(hdcMem,bmpMark);
	}
	else if(BombInfoMatrix[indexY][indexX].y==STATUS_BOMB)
	{
		SelectObject(hdcMem,bmpBomb);
	}
	else if(BombInfoMatrix[indexY][indexX].y==STATUS_REVEALED)
	{
		if(BombInfoMatrix[indexY][indexX].x==-1)
			SelectObject(hdcMem,bmpBomb);
		else
			SelectObject(hdcMem, bmpNumList[BombInfoMatrix[indexY][indexX].x]);
	}
	int ix,iy;

	if(bInitXY)
	{
		ix=indexX*BLOCKBMPCX+MAPINITX;
		iy=indexY*BLOCKBMPCY+MAPINITY;
	}
	else
	{
		ix=indexX*BLOCKBMPCX;
		iy=indexY*BLOCKBMPCY;
	}

	BitBlt(hdcMap,
			ix,iy,
			BLOCKBMPCX,BLOCKBMPCY,
			hdcMem,0,0,SRCCOPY);   
    DeleteDC(hdcMem) ;		
}
////////////////////////////////////////////////
void RevealNeighbor(int indexX,int indexY)
{
	if((indexX<0)||(indexY<0)||(indexX>=g_nBlockCX)||(indexY>=g_nBlockCY))
		return;
	if((BombInfoMatrix[indexY][indexX].x!=0)||
		(BombInfoMatrix[indexY][indexX].y!=STATUS_NORMAL))
		return;

	BombInfoMatrix[indexY][indexX].y=STATUS_REVEALED;

	int i;
	POINT pt;
	POINT spt[8];
	spt[0].x=-1;spt[0].y=-1;
	spt[1].x=0 ;spt[1].y=-1;
	spt[2].x=1 ;spt[2].y=-1;
	spt[3].x=1 ;spt[3].y=0;
	spt[4].x=1 ;spt[4].y=1;
	spt[5].x=0 ;spt[5].y=1;
	spt[6].x=-1;spt[6].y=1;
	spt[7].x=-1 ;spt[7].y=0;
	///////////////////////////////////////////
	for(i=0;i<8;i++)
	{
		pt.x=indexX+spt[i].x;
		pt.y=indexY+spt[i].y;
		if((pt.x>=0)&&(pt.y>=0)&&(pt.x<g_nBlockCX)&&(pt.y<g_nBlockCY))
		{
			if(BombInfoMatrix[pt.y][pt.x].x>0)
				BombInfoMatrix[pt.y][pt.x].y=STATUS_REVEALED;
			else if(BombInfoMatrix[pt.y][pt.x].x==0)
			{
				RevealNeighbor(pt.x,pt.y);//递归
			}
		}
	}
}
////////////////////////////////
void AdjustWndRect(HWND hWnd)
{
	int cx,cy;
	
	cx=BLOCKBMPCX*(g_nBlockCX+2)+3*GetSystemMetrics(SM_CXBORDER);
	cy=BLOCKBMPCY*(g_nBlockCY+2)+
		GetSystemMetrics(SM_CYCAPTION)+
		GetSystemMetrics(SM_CYMENU)+
		2*GetSystemMetrics(SM_CYBORDER)+CYNUMBMP;
	rcFace.top=10;
	rcFace.bottom=35;
	rcFace.left=(cx-25)/2;
	rcFace.right=rcFace.left+25;
	SetWindowPos(hWnd,NULL,0,0,cx,cy,SWP_NOMOVE);
}
////////////////////////////////////
void DrawARNumber(HDC hdc,int nNum, int initX, int initY)
{
	HDC  memDC;
	int pEachNum[3];
	int nW,nH;
	int i;
	nW=13;
	nH=23;
	if(nNum<0)
		nNum=0;

	for(i=0;i<3;i++)
		pEachNum[i]=10;
	i=2;
	do
	{
		pEachNum[i]=nNum%10;
		nNum=int(nNum/10);
		i--;
	}while(nNum>0);

	memDC=CreateCompatibleDC(hdc);
	for(i=2;i>=0;i--)
	{
		SelectObject(memDC,pNumBmp[pEachNum[i]]);
		BitBlt(hdc,initX-(3-i)*nW,initY,nW,nH,memDC,0,0,SRCCOPY);
	}
	DeleteDC(memDC);
}
void DrawBombCount(HDC hdc,int nBomb)
{
	DrawARNumber(hdc,nBomb,20+3*CXNUMBMP,10);
}

void DrawTimeCount(HDC hdc,int nBomb)
{
	DrawARNumber(hdc,nBomb,g_nBlockCX*BLOCKBMPCX+BLOCKBMPCX,10);
}
/////////////////WM_LBUTTONUP///////////////
BOOL OnLButtonUp(int indexX,int indexY)
{
	if((indexX<0)||(indexY<0)||(indexX>=g_nBlockCX)||(indexY>=g_nBlockCY))
		return FALSE;
	if(BombInfoMatrix[indexY][indexX].y!=STATUS_NORMAL)
		return FALSE;
	else
	{
		if(BombInfoMatrix[indexY][indexX].x>0)
			BombInfoMatrix[indexY][indexX].y=STATUS_REVEALED;
		else if(BombInfoMatrix[indexY][indexX].x==0)
			RevealNeighbor(indexX,indexY);
		else if(BombInfoMatrix[indexY][indexX].x==-1)
		{
			int i,j;
			g_bPlaying=FALSE;
			for(i=0;i<g_nBlockCX;i++)
			{
				for(j=0;j<g_nBlockCY;j++)
				{
					if(BombInfoMatrix[j][i].x==-1)
						BombInfoMatrix[j][i].y=STATUS_BOMB;
				}
			}
		}
		return TRUE;
	}
}
/////////////////////////////////////////////
BOOL OnRButtonUp(int indexX,int indexY,HWND hWnd)
{
	if((indexX<0)||(indexY<0)||(indexX>=g_nBlockCX)||(indexY>=g_nBlockCY))
		return FALSE;
	HDC hdcTemp=GetDC(hWnd);
	if(BombInfoMatrix[indexY][indexX].y==STATUS_MARKED)
	{
		BombInfoMatrix[indexY][indexX].y=STATUS_NORMAL;
		nMarkedCount--;
		if(BombInfoMatrix[indexY][indexX].x==-1)
			nRightMarkedCount--;
		DrawSingleBlock(indexX,indexY,hdcTemp,TRUE);
		DrawBombCount(hdcTemp,g_nBombCount-nMarkedCount);
		ReleaseDC(hWnd,hdcTemp);
		return FALSE;
	}
	else if(BombInfoMatrix[indexY][indexX].y==STATUS_NORMAL)
	{
		if(nMarkedCount<g_nBombCount)
		{
			BombInfoMatrix[indexY][indexX].y=STATUS_MARKED;
			nMarkedCount++;
			if(BombInfoMatrix[indexY][indexX].x==-1)
				nRightMarkedCount++;
			DrawSingleBlock(indexX,indexY,hdcTemp,TRUE);
			DrawBombCount(hdcTemp,g_nBombCount-nMarkedCount);
			ReleaseDC(hWnd,hdcTemp);
			if(nRightMarkedCount==g_nBombCount)
				return TRUE;
		}
		return FALSE;
	}
	return FALSE;
}
///////////////////////////////////////
void SetCountTimer(HWND hwnd)
{
	if(bTimeSetted)
		KillTimer(hwnd,1);
	SetTimer(hwnd,1,1000,NULL);
	bTimeSetted=TRUE;
}
///////////////////////////////////
void DrawFace(HDC hdc,int nType)
{
	HDC  memDC;
	memDC=CreateCompatibleDC(hdc);
	SelectObject(memDC,bmpFace);
	BitBlt(hdc,rcFace.left,rcFace.top,FACE_WH,FACE_WH,memDC,0,nType*FACE_WH,SRCCOPY);
	DeleteDC(memDC);
}
/////////////////////////////////
void DrawTheMap(HDC hdc)
{
	int i,j;
	HBITMAP tempBmpMap=CreateCompatibleBitmap(hdc,g_nBlockCX*BLOCKBMPCX,g_nBlockCY*BLOCKBMPCY);
	HDC memDC;
	memDC=CreateCompatibleDC(hdc);
	SelectObject(memDC,tempBmpMap);
	for(i=0;i<g_nBlockCX;i++)
		for(j=0;j<g_nBlockCY;j++)
			DrawSingleBlock(i,j,memDC,FALSE);
	BitBlt(hdc,MAPINITX,MAPINITY,
		   g_nBlockCX*BLOCKBMPCX,g_nBlockCY*BLOCKBMPCY,
		   memDC,0,0,SRCCOPY);
	
	DeleteDC(memDC);
	DeleteObject(tempBmpMap);
}
////////////////////////////////////
void WriteGameSetting()
{
	char szBuf[10];
	wsprintf(szBuf,TEXT("%d"),g_nGameLev);
	WritePrivateProfileString(TEXT("SETTING"),TEXT("GameType"),szBuf,szProfilePath);
	wsprintf(szBuf,TEXT("%d"),g_nBlockCX);
	WritePrivateProfileString(TEXT("SETTING"),TEXT("MapCX"),szBuf,szProfilePath);
	wsprintf(szBuf,TEXT("%d"),g_nBlockCY);
	WritePrivateProfileString(TEXT("SETTING"),TEXT("MapCY"),szBuf,szProfilePath);
	wsprintf(szBuf,TEXT("%d"),g_nBombCount);
	WritePrivateProfileString(TEXT("SETTING"),TEXT("Bombs"),szBuf,szProfilePath);
}
//////////////////////////////////
void GetGameSetting()
{
	g_nGameLev=GetPrivateProfileInt(TEXT("SETTING"),TEXT("GameType"),TYPE_BEGINNER,szProfilePath);
	if(g_nGameLev==TYPE_USER)
	{
		g_nBlockCX=GetPrivateProfileInt(TEXT("SETTING"),TEXT("MapCX"),MAXCOUNTX,szProfilePath);
		g_nBlockCY=GetPrivateProfileInt(TEXT("SETTING"),TEXT("MapCY"),MAXCOUNTY,szProfilePath);
		g_nBombCount=GetPrivateProfileInt(TEXT("SETTING"),TEXT("Bombs"),MAXBOMBCOUNT,szProfilePath);	
	}
}
/////////////////////////////////