mine.c

brew3.1做的挖雷游戏

#include "mine.h"
///////////////////////////////////////////////////////////////////////////////////////////////
//						STATIC FUNCTION DECLARE
///////////////////////////////////////////////////////////////////////////////////////////////
#define	MSGOFFSET_SUCCESS   212
#define	MSGOFFSET_TIMER     10
#define	MSGOFFSET_FAILURE   365
#define	MARGIN_RECT			3

#define MINEUI_OUTRECTCOLOR	MAKE_RGB(150,150,200)
#define MINEUI_INRECTCOLOR		MAKE_RGB(200,200,255)

#define MINEUI_GRIDCOLOR	MAKE_RGB(200,200,250)
#define MINEUI_FILLCOLOR	MAKE_RGB(211,211,211)
#define MINEUI_SELIIEMCOLOR	MAKE_RGB(180,180,200)
#define MINEUI_CUROR		MAKE_RGB(255,10,10)
#define MINEUI_FRAME		MAKE_RGB(0,0,0)

#define MINEASSERTNULL(p) {if(NULL==p) return FALSE;}

static boolean WINMINE_Draw(IWinmine* pMine);
static boolean WINMINE_DrawElement(IWinmine* pMine,int x,int y,boolean bSel);
static boolean WINMINE_DrawCuror(IWinmine* pMine,AEERect* rt);
static boolean WINMINE_DrawMine(IWinmine* pMine,AEERect* rt);
static boolean WINMINE_DrawBlast(IWinmine* pMine,AEERect* rt);
static boolean WINMINE_DrawBanner(IWinmine* pMine,AEERect* rt);
static boolean WINMINE_DrawNumber(IWinmine* pMine,AEERect* rt,char* pText);
static boolean WINMINE_DrawFrame(IWinmine* pMine,AEERect* rt,int x,int y);

static boolean WINMINE_SUCCESSHDL(IWinmine* pMine);
static boolean WINMINE_FAILUREHDL(IWinmine* pMine);
static boolean WINMINE_BLANKHDL(IWinmine* pMine,int x,int y);
static boolean WINMINE_ShowMsg(IWinmine* pMine,int nType);
static void	WINMINE_SaveScore(IWinmine* pMine);
static void	WINMINE_BlankElementHDL(IWinmine* pMine,int x,int y);
static void	WINMINE_MsgTimerHDL(IWinmine* pMine);
///////////////////////////////////////////////////////////////////////////////////////////////
//						PUBLIC FUNCDEFINE
///////////////////////////////////////////////////////////////////////////////////////////////

IWinmine*	IWINMINE_CreateInstance()
{
	IWinmine* pMine=MALLOCREC(IWinmine);
	if(pMine)
	{
		AEEDeviceInfo di;

		pMine->m_pApp=(AEEApplet*)GETAPPINSTANCE();
		
		ISHELL_GetDeviceInfo(pMine->m_pApp->m_pIShell, &di);
		pMine->m_GameRect.x=pMine->m_GameRect.y=0;
		pMine->m_GameRect.dx=di.cxScreen;
		pMine->m_GameRect.dy=di.cyScreen;

		pMine->m_PlayRect.x=pMine->m_GameRect.x+MARGIN_RECT;
		pMine->m_PlayRect.dx=pMine->m_GameRect.dx-2*MARGIN_RECT;	
		pMine->m_PlayRect.dy=pMine->m_PlayRect.dx;
		pMine->m_PlayRect.y=pMine->m_GameRect.dy+pMine->m_GameRect.y-pMine->m_PlayRect.dy-MARGIN_RECT;

		pMine->m_MenuRect.x=pMine->m_PlayRect.x;
		pMine->m_MenuRect.dx=pMine->m_PlayRect.dx;
		pMine->m_MenuRect.y=pMine->m_GameRect.y+MARGIN_RECT;
		pMine->m_MenuRect.dy=pMine->m_GameRect.dy-pMine->m_PlayRect.dy-3*MARGIN_RECT;

		pMine->m_ElementWide=pMine->m_PlayRect.dx/MINE_LINE_NUM;
		pMine->m_ElementHeight=pMine->m_PlayRect.dy/MINE_COLU_NUM;
		pMine->m_OffsetX=pMine->m_PlayRect.x+(pMine->m_PlayRect.dx-pMine->m_ElementWide*MINE_LINE_NUM)/2;
		pMine->m_OffsetY=pMine->m_PlayRect.y+(pMine->m_PlayRect.dy-pMine->m_ElementHeight*MINE_COLU_NUM)/2;

		pMine->m_pImage=ISHELL_LoadImage(pMine->m_pApp->m_pIShell,"test.bmp");
		if(pMine->m_pImage)
			IIMAGE_SetDrawSize(pMine->m_pImage,pMine->m_MenuRect.dx-4,pMine->m_MenuRect.dy-4);

		pMine->m_pGameImage=ISHELL_LoadImage(pMine->m_pApp->m_pIShell,"x.bmp");
		if(pMine->m_pGameImage)
			IIMAGE_SetDrawSize(pMine->m_pGameImage,pMine->m_ElementWide-4,pMine->m_ElementHeight-4);

		ISHELL_CreateInstance(pMine->m_pApp->m_pIShell,AEECLSID_GRAPHICS,(void**)&pMine->m_pGraphic);
		pMine->m_pMusic=IMINEMUSIC_CreateInstance(pMine->m_pApp->m_pIShell);
	}
	return pMine;
}
boolean IWINMINE_Release(IWinmine* pMine)
{
	MINEASSERTNULL(pMine);
	ISHELL_CancelTimer(pMine->m_pApp->m_pIShell,(PFNNOTIFY) WINMINE_MsgTimerHDL, pMine);		
	if(pMine->m_pImage)
	{
		IIMAGE_Release(pMine->m_pImage);
		pMine->m_pImage=NULL;
	}
	if(pMine->m_pGameImage)
	{
		IIMAGE_Release(pMine->m_pGameImage);
		pMine->m_pGameImage=NULL;
	}
	if(pMine->m_pMusic)
	{
		IMINEMUSIC_Release(pMine->m_pMusic);
		pMine->m_pMusic=NULL;
	}
	if(pMine->m_pGraphic)
	{
		IGRAPHICS_Release(pMine->m_pGraphic);
		pMine->m_pGraphic=NULL;
	}
	return TRUE;
}
boolean IWINMINE_Start(IWinmine* pMine)
{
	byte   z;
	int x,y;
	TScore score;
	uint16 mineNum=0;
	
	MINEASSERTNULL(pMine);
	//zero list data
	for(x=0;x<MINE_LINE_NUM;x++)
		for(y=0;y<MINE_COLU_NUM;y++)
	{
		pMine->m_Data[x][y].m_bSel=FALSE;

		pMine->m_Data[x][y].m_Stat=0;
		
	}
	//generate the mine
	while(mineNum<MINE_NUM)
	{
		//x point
		GETRAND(&z,sizeof(z));
		x=z*MINE_LINE_NUM/256;
		//y point
		GETRAND(&z,sizeof(z));
		y=z*MINE_LINE_NUM/256;
		//check available
		if(MINE_FLAGE==pMine->m_Data[x][y].m_Stat)
			continue;
		pMine->m_Data[x][y].m_Stat=MINE_FLAGE;
		mineNum++;
		//set around grid
		if((x-1>=0)&&(y-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x-1][y-1].m_Stat))
			pMine->m_Data[x-1][y-1].m_Stat++;
		if((x-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x-1][y].m_Stat))
			pMine->m_Data[x-1][y].m_Stat++;
		if((x-1>=0)&&(y+1<MINE_COLU_NUM)&&(MINE_FLAGE!=pMine->m_Data[x-1][y+1].m_Stat))
			pMine->m_Data[x-1][y+1].m_Stat++;
		
		if((y-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x][y-1].m_Stat))
			pMine->m_Data[x][y-1].m_Stat++;
		if((y+1<MINE_COLU_NUM)&&(MINE_FLAGE!=pMine->m_Data[x][y+1].m_Stat))
			pMine->m_Data[x][y+1].m_Stat++;
		
		if((x+1<MINE_LINE_NUM)&&(y-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x+1][y-1].m_Stat))
			pMine->m_Data[x+1][y-1].m_Stat++;
		if((x+1<MINE_LINE_NUM)&&(MINE_FLAGE!=pMine->m_Data[x+1][y].m_Stat))
			pMine->m_Data[x+1][y].m_Stat++;
		if((x+1<MINE_LINE_NUM)&&(y+1<MINE_COLU_NUM)&&(MINE_FLAGE!=pMine->m_Data[x+1][y+1].m_Stat))
			pMine->m_Data[x+1][y+1].m_Stat++;		
	}
	//other value
	pMine->m_PointX=MINE_LINE_NUM/2;
	pMine->m_PointY=MINE_COLU_NUM/2;
	pMine->m_Count=0;
	pMine->m_TimerCount=MINE_GAMETIMER;
	pMine->m_Result=STAT_START;
	//Score
	if(SUCCESS!=ISHELL_GetAppPrefs(pMine->m_pApp->m_pIShell,1,&score,sizeof(score)))	
		pMine->m_MaxScore=0;
	else
		pMine->m_MaxScore=score.m_nScore;		
	//draw list
	WINMINE_Draw(pMine);
	WINMINE_ShowMsg(pMine,0);
	IMINEMUSIC_Start(pMine->m_pMusic,MMT_START);
	return TRUE;

}
boolean		IWINMINE_HandleEvent(IWinmine* pMine, uint16 wParam)
{
	MINEASSERTNULL(pMine);

	if(STAT_START!=pMine->m_Result)
		return FALSE;

	switch(wParam)
	{
	case AVK_LEFT:
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
		pMine->m_PointX--;
		if(pMine->m_PointX<0) 
			pMine->m_PointX=MINE_LINE_NUM-1;
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
		break;
	case AVK_RIGHT:
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
		pMine->m_PointX++;
		if(MINE_LINE_NUM==pMine->m_PointX) 
			pMine->m_PointX=0;
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
		break;
	case AVK_UP:
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
		pMine->m_PointY--;
		if(pMine->m_PointY<0) 
			pMine->m_PointY=MINE_COLU_NUM-1;
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
		break;
	case AVK_DOWN:
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
		pMine->m_PointY++;
		if(MINE_COLU_NUM==pMine->m_PointY) 
			pMine->m_PointY=0;
		WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
		break;
	case AVK_SELECT:
		if(pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel)
			return TRUE;
		pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel=TRUE;	

		switch(pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_Stat)
		{
		case MINE_FLAGE:
			WINMINE_FAILUREHDL(pMine);
			break;
		case 0:
			WINMINE_BLANKHDL(pMine,pMine->m_PointX,pMine->m_PointY);
		default:
			WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);			
		}
		break;
	case AVK_CLR:
		if(pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel)
			return TRUE;
		pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel=TRUE;	
		if(MINE_FLAGE!=pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_Stat)
			WINMINE_FAILUREHDL(pMine);
		else
		{
			pMine->m_Count++;
			if(MINE_NUM==pMine->m_Count)
				WINMINE_SUCCESSHDL(pMine);
			else
				WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);	
		}
		break;
	case AVK_1:
		return WINMINE_SUCCESSHDL(pMine);
	case AVK_3:
		return WINMINE_FAILUREHDL(pMine);
	default:
		return FALSE;
	}
	IDISPLAY_Update(pMine->m_pApp->m_pIDisplay); 
	return TRUE;
}
boolean		IWINMINE_Pause(IWinmine* pMine)
{
	MINEASSERTNULL(pMine);
	ISHELL_CancelTimer(pMine->m_pApp->m_pIShell,(PFNNOTIFY) WINMINE_MsgTimerHDL, pMine);
	return TRUE;
}
boolean IWINMINE_GetMaxScore(IWinmine* pMine,TScore* score)
{
	MINEASSERTNULL(pMine);
	if(SUCCESS==ISHELL_GetAppPrefs(pMine->m_pApp->m_pIShell,1,&score,sizeof(score)))
		return TRUE;
	else
		return FALSE;
}
boolean		IWINMINE_ResetMaxScore(IWinmine* pMine)
{
	uint32 sec;
	TScore score;

	MINEASSERTNULL(pMine);
	sec=GETTIMESECONDS();
	GETJULIANDATE(sec,&(score.m_Date));
	score.m_nScore=0;
	ISHELL_SetAppPrefs(pMine->m_pApp->m_pIShell,1,&score,sizeof(score));
	return TRUE;
}
boolean	IWINMINE_GetPlayRect(IWinmine* pMine,AEERect *rt)
{
	if(pMine)
		*rt=pMine->m_PlayRect;
	return TRUE;
}
boolean	IWINMINE_DrawIntroScreen(IWinmine* pMine)
{
	IBitmap* image;
	uint32 time1;
	
	MINEASSERTNULL(pMine);
	// Draw the Background 
	image = ISHELL_LoadBitmap(pMine->m_pApp->m_pIShell,"flash.bmp");
	
	if(image)
	{
		IDISPLAY_ClearScreen(pMine->m_pApp->m_pIDisplay);	
		IDISPLAY_BitBlt(pMine->m_pApp->m_pIDisplay, 
						0,0,
						pMine->m_GameRect.dx,
						pMine->m_GameRect.dy,					
						image, 
						0,0,
						AEE_RO_COPY);	
		IBITMAP_Release(image);
		// FALSE parameter forces an immediate screen update
		IDISPLAY_UpdateEx(pMine->m_pApp->m_pIDisplay,FALSE);
//		IMINEMUSIC_Start(pMine->m_pMusic,MMT_FLASH);			
		// wait at least 1.5 seconds on intro screen
		time1= GETUPTIMEMS();
		while( (GETUPTIMEMS() - time1) < 500) {}
	}
	return TRUE;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//						STATIC FUNCTION DEFINE
///////////////////////////////////////////////////////////////////////////////////////////////
static boolean WINMINE_Draw(IWinmine* pMine)
{
	int x,y;
	AEERect gamerect,playrect,menurect;
	MINEASSERTNULL(pMine);
//draw the frame
	gamerect=pMine->m_GameRect;
	playrect=pMine->m_PlayRect;
	menurect=pMine->m_MenuRect;
	
	IDISPLAY_DrawFrame(pMine->m_pApp->m_pIDisplay,&gamerect,AEE_FT_RAISED,MINEUI_OUTRECTCOLOR);
	IDISPLAY_DrawFrame(pMine->m_pApp->m_pIDisplay,&playrect,AEE_FT_LOWERED,MINEUI_INRECTCOLOR);
	IDISPLAY_DrawFrame(pMine->m_pApp->m_pIDisplay,&menurect,AEE_FT_LOWERED,MINEUI_FILLCOLOR);	
//draw the playrect
	for(x=0;x<MINE_LINE_NUM;x++)
		for(y=0;y<MINE_COLU_NUM;y++)
			WINMINE_DrawElement(pMine,x,y,FALSE);
	WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
//Update
	IDISPLAY_Update(pMine->m_pApp->m_pIDisplay); 
	return TRUE;
}
static boolean WINMINE_SUCCESSHDL(IWinmine* pMine)
{
	int x,y;
	MINEASSERTNULL(pMine);
	pMine->m_Result=STAT_SUCCESS;	
	for(x=0;x<MINE_LINE_NUM;x++)