guestnum_gameing.c

可以进行猜数字的游戏

/*===========================================================================

FILE: GuestNum_Gameing.c
===========================================================================*/


/*===============================================================================
INCLUDES AND VARIABLE DEFINITIONS
=============================================================================== */
#include "GuestNum.h"



#define GAMEINGTITLE "Please Input Num:"

//Str Buff Size
#define GAMEINGSTRBUFFSIZE	100
//Input Text Pos
#define GAMEINGINPUT_X		45
#define GAMEINGINPUT_Y		15
//Inpot Box Pos
#define GAMEINGINPUTBOX_X	44
#define GAMEINGINPUTBOX_Y	13
#define GAMEINGINPUTBOX_DX	34
#define GAMEINGINPUTBOX_DY	16
//Tips Len Pos
#define GAMEINGHLINE		120
#define GAMEINGHLINE_X		0
#define GAMEINGHLINE_Y		30
#define GAMEINGVLINE		114
#define GAMEINGVLINE_X		60
#define GAMEINGVLINE_Y		30
//Input Num Max
#define GAMEINGINPUTNUMMAX	4
//Tip Str Len
#define GAMEINGTIPLEN		10
//Tip Str Format
#define GAMEINGTIPFORMAT	"**** 0A0B"

//GAMEING status 
struct GuestNumGameing
{
	AECHAR			  szRandNum[5];					//Rand Num Str
	AECHAR			  szInputNum[5];				//Input Num Str
	int				  nInputNumCount;				//Input Count
	int				  nTipIndex;					//Tip Pos Index
	int				  nTipA;						//Tip A
	int				  nTipB;						//Tip B

	int				  nCaiDan;						//
};


typedef struct GameingTipPos GameingTipPos;
struct GameingTipPos
{
	int				  nPosX;						//Tip X Pos
	int				  nPosY;						//Tip Y Pos
};

//Tip Pos Index Enum
enum {
	GAMEINGTIPINDEX01 = 0,
	GAMEINGTIPINDEX02,
	GAMEINGTIPINDEX03,
	GAMEINGTIPINDEX04,
	GAMEINGTIPINDEX05,
	GAMEINGTIPINDEX06,
	GAMEINGTIPINDEX07,
	GAMEINGTIPINDEX08,
	GAMEINGTIPINDEX09,
	GAMEINGTIPINDEX10,
	GAMEINGTIPINDEX11,
	GAMEINGTIPINDEX12,
	GAMEINGTIPINDEX13,
	GAMEINGTIPINDEX14,
	GAMEINGTIPINDEX15,
	GAMEINGTIPINDEX16,
	GAMEINGTIPINDEX17,
	GAMEINGTIPINDEX18,
	GAMEINGTIPINDEX19,
	GAMEINGTIPINDEX20,

	GAMEINGTIPINDEXMAX
};
/*-------------------------------------------------------------------
Function Prototypes
-------------------------------------------------------------------*/
static int GAMEING_Open(GuestNum *pMe);
static int GAMEING_Draw(GuestNum *pMe);

static boolean GAMEING_DrawTip(GuestNum * pMe);
static boolean GAMEING_DrawInputNum(GuestNum * pMe, uint16 wParam);
static boolean GAMEING_ClearInputBox(GuestNum * pMe);
static boolean GAMEING_CalTip(GuestNum * pMe);
static boolean GAMEING_GetRand(GuestNum * pMe);
static boolean GAMEING_ClearInput(GuestNum * pMe);

static boolean GAMEING_GetTipPos(GameingTipPos *psTipPos, int nTipIndex);

//Cai Dan Fun
static void GAMEING_CaiDan(GuestNum * pMe, AEEEvent eCode, uint16 wParam, uint32 dwParam);

/*===============================================================================
FUNCTION DEFINITIONS
=============================================================================== */
int GAMEING_InitData(GuestNum *pMe)
{
	int nRet = 0;

	//Init Gameing Status
	pMe->psGameing = MALLOC(sizeof(GuestNumGameing));
	if (NULL == pMe->psGameing)
	{
		return FALSE;
	}
	MEMSET((void*)pMe->psGameing, 0, sizeof(GuestNumGameing));

	//Init Guest Count
	pMe->nGuestNumCount = 0;

	//Init Guset Flag
	pMe->bWin = FALSE;

	//Init Guest Num
	MEMSET((void*)pMe->szNum, 0, sizeof(AECHAR)*GUESTNUMSTRBUFSIZE);

	//Init Cai Dan Count
	pMe->psGameing->nCaiDan = 0;

	nRet = GAMEING_Open(pMe);
	return nRet;
}

static int GAMEING_Open(GuestNum *pMe)
{
	int nRet = 0;

	//Creat Rand Num
	GAMEING_GetRand(pMe);

	nRet = GAMEING_Draw(pMe);
	return nRet;
}

int GAMEING_Close(GuestNum *pMe)
{
	FREEIF(pMe->psGameing);
	return AEE_SUCCESS;
}

static int GAMEING_Draw(GuestNum *pMe)
{
	AECHAR szTemp[GAMEINGSTRBUFFSIZE];
	AEERect sRect;

	//Clear Screen
	IDISPLAY_ClearScreen(pMe->m_pIDisplay);
	pMe->m_pIImage = ISHELL_LoadImage(pMe->m_pIShell, "frame.bmp");
	IIMAGE_Draw(pMe->m_pIImage, 0, 30);
	IDISPLAY_UpdateEx(pMe->m_pIDisplay, FALSE);
	

	//Set Title
	STRTOWSTR(GAMEINGTITLE, szTemp, GAMEINGSTRBUFFSIZE);
	//Draw Title
	IDISPLAY_DrawText(pMe->m_pIDisplay, AEE_FONT_BOLD, szTemp, -1, 0, 0, NULL, IDF_TEXT_TRANSPARENT);

	//Set Input Box
	SETAEERECT(&sRect, GAMEINGINPUTBOX_X, GAMEINGINPUTBOX_Y, GAMEINGINPUTBOX_DX, GAMEINGINPUTBOX_DY);
	//Draw Input Box
	IDISPLAY_DrawRect(pMe->m_pIDisplay, (const AEERect *)&sRect, 0, 0, IDF_RECT_FRAME);

	//Draw Tips Line
	IDISPLAY_DrawHLine(pMe->m_pIDisplay, GAMEINGHLINE_X, GAMEINGHLINE_Y, GAMEINGHLINE);
	IDISPLAY_DrawVLine(pMe->m_pIDisplay, GAMEINGVLINE_X, GAMEINGVLINE_Y, GAMEINGVLINE);

	IDISPLAY_Update(pMe->m_pIDisplay);

	return AEE_SUCCESS;
}

boolean GAMEING_HandleEvt(GuestNum * pMe, AEEEvent eCode, uint16 wParam, uint32 dwParam)
{
	if (EVT_KEY != eCode)
	{
		return FALSE;
	}

	//Cai Dan
	GAMEING_CaiDan(pMe, eCode, wParam, dwParam);

	switch (wParam)
	{
	case AVK_SELECT:
		//All Num Input Test
		if (GAMEINGINPUTNUMMAX != pMe->psGameing->nInputNumCount)
		{
			return TRUE;
		}

		//Guest Count + 1
		pMe->nGuestNumCount++;

		//Cal Tip By Input Num
		if (FALSE == GAMEING_CalTip(pMe))
		{
			//Draw Tip
			GAMEING_DrawTip(pMe);

			//Clear Input Box
			GAMEING_ClearInputBox(pMe);
		}
		else
		{
			//Close Me
			GAMEING_Close(pMe);

			//Open GameIng Status
			ISHELL_PostEvent(pMe->m_pIShell, AEECLSID_GuestNum, EVT_COMMAND, GUESTNUM_SCORE, NULL);
		}

		return TRUE;
	
	case AVK_CLR:

		//Clear Lost Input Num
		GAMEING_ClearInput(pMe);

		return TRUE;

	case AVK_0:
	case AVK_1:
	case AVK_2:
	case AVK_3:
	case AVK_4:
	case AVK_5:
	case AVK_6:
	case AVK_7:
	case AVK_8:
	case AVK_9:
		//Draw Input Num
		GAMEING_DrawInputNum(pMe, wParam);

		return TRUE;

	default:
		break;
	}

	return FALSE;
}

//Draw Input Num
static boolean GAMEING_DrawInputNum(GuestNum * pMe, uint16 wParam)
{
	AECHAR szTempChar = '0';
	uint8 i;

	if (GAMEINGINPUTNUMMAX <= pMe->psGameing->nInputNumCount)
	{
		return FALSE;
	}

	//Input Num To Char
	szTempChar = wParam - AVK_0 + (int)szTempChar;

	//Input Test
	for (i = 0; i < pMe->psGameing->nInputNumCount; i++)
	{
		if (szTempChar == pMe->psGameing->szInputNum[i])
		{
			return TRUE;
		}
	}

	//Set Input Num to Str
	pMe->psGameing->szInputNum[pMe->psGameing->nInputNumCount] = szTempChar;

	//Input Num Const + 1
	pMe->psGameing->nInputNumCount++;

	//Draw Input Num Str
	IDISPLAY_DrawText(pMe->m_pIDisplay, AEE_FONT_BOLD, pMe->psGameing->szInputNum, -1, GAMEINGINPUT_X, GAMEINGINPUT_Y, NULL, NULL);
	IDISPLAY_Update(pMe->m_pIDisplay);

	return TRUE;
}

//Clear Input Num
static boolean GAMEING_ClearInputBox(GuestNum * pMe)
{
	AECHAR szTempChar[GAMEINGTIPLEN];
	int nConst = 0;

	//Clear Str
	for (nConst = 0; nConst < GAMEINGINPUTNUMMAX; nConst++)
	{
		pMe->psGameing->szInputNum[nConst] = '\0';
	}
	//Clear Const
	pMe->psGameing->nInputNumCount = 0;

	//Draw NULL Str
	STRTOWSTR("       ", szTempChar, 20);
	IDISPLAY_DrawText(pMe->m_pIDisplay, AEE_FONT_BOLD, szTempChar, -1, GAMEINGINPUT_X, GAMEINGINPUT_Y, NULL, NULL);
	IDISPLAY_Update(pMe->m_pIDisplay);

	return TRUE;
}

//Cal Tip By Input Num
static boolean GAMEING_CalTip(GuestNum * pMe)
{
	boolean bRet = FALSE;
	uint8 i,j;

	//Init Tip A
	pMe->psGameing->nTipA = 0;
	//Cal Tip A
	for (i = 0; i < GAMEINGINPUTNUMMAX; i++)
	{
		if (pMe->psGameing->szRandNum[i] == pMe->psGameing->szInputNum[i])
		{
			pMe->psGameing->nTipA++;
		}
	}

	//Init Tip B
	pMe->psGameing->nTipB = 0;
	//Cal Tip B
	for (i = 0; i < GAMEINGINPUTNUMMAX; i++)
	{
		for (j = 0; j < GAMEINGINPUTNUMMAX; j++)
		{
			if (pMe->psGameing->szRandNum[i] == pMe->psGameing->szInputNum[j])
			{
				pMe->psGameing->nTipB++;
			}
		}
	}
	pMe->psGameing->nTipB = pMe->psGameing->nTipB - pMe->psGameing->nTipA;

	//Guest Num is Flase  (test)
	if (GAMEINGINPUTNUMMAX == pMe->psGameing->nTipA)
	{
		pMe->bWin = TRUE;
	}
	else
	{
		pMe->bWin = FALSE;
	}

	//Max Guest
	if (GAMEINGTIPINDEXMAX <= pMe->psGameing->nTipIndex || TRUE == pMe->bWin)
	{
		return TRUE;
	}

	return bRet;
}

//Draw Tip
static boolean GAMEING_DrawTip(GuestNum * pMe)
{
	GameingTipPos sTipPos;
	AECHAR szTip[GAMEINGTIPLEN];
	int i = 0;

	//Init Str Buff
	MEMSET((void*)szTip,       0, sizeof(AECHAR)*GAMEINGTIPLEN);

	//Set Tip Format Str
	STRTOWSTR(GAMEINGTIPFORMAT, szTip, sizeof(AECHAR)*GAMEINGTIPLEN);

	//Set Tip Str
	for (i = 0; i < GAMEINGINPUTNUMMAX; i++)
	{
		szTip[i] = pMe->psGameing->szInputNum[i];
	}
	szTip[5] = pMe->psGameing->nTipA + '0';
	szTip[7] = pMe->psGameing->nTipB + '0';

	//Get Tip Pos
	GAMEING_GetTipPos(&sTipPos, pMe->psGameing->nTipIndex);

	//Set Next Tip Index
	pMe->psGameing->nTipIndex++;

	//Draw Tip
	IDISPLAY_DrawText(pMe->m_pIDisplay, AEE_FONT_NORMAL, szTip, -1, sTipPos.nPosX, sTipPos.nPosY, NULL, IDF_TEXT_TRANSPARENT);
	IDISPLAY_Update(pMe->m_pIDisplay);

	return TRUE;
}

//Get Tip Pos By Index
static boolean GAMEING_GetTipPos(GameingTipPos *psTipPos, int nTipIndex)
{
	//Tip Pos Table
	const GameingTipPos sTipPos[GAMEINGTIPINDEXMAX] = {
		 2, 32,    2, 43,    2, 54 ,    2, 65 ,    2, 76 , 
		 2, 87,    2, 98,    2, 109,    2, 120,    2, 131, 
		63, 32,   63, 43,   63, 54 ,   63, 65 ,   63, 76 , 
		63, 87,   63, 98,   63, 109,   63, 120,   63, 131
	};

	psTipPos->nPosX = sTipPos[nTipIndex].nPosX;
	psTipPos->nPosY = sTipPos[nTipIndex].nPosY;

	return TRUE;
}


//Get Rand Num And Num To Str
static boolean GAMEING_GetRand(GuestNum * pMe)
{
	AECHAR szSource[11] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '/0'};
	uint8 ucRand = 0;
	uint8 i;

	//Get 4 Rand Num
	for(i = 0; i < GAMEINGINPUTNUMMAX; i++)
	{
		//Get Rand Num
		GETRAND(&ucRand, sizeof(ucRand));
		ucRand = ucRand % (10 - i);

		//Save Rand Num
		pMe->psGameing->szRandNum[i] = szSource[ucRand];
		pMe->szNum[i] = pMe->psGameing->szRandNum[i];

		//Del Num
		szSource[ucRand] = szSource[10 - i - 1];
	}

	return TRUE;
}

//Clear Key
static boolean GAMEING_ClearInput(GuestNum * pMe)
{
	AECHAR szTempChar[GAMEINGTIPLEN];

	if (0 >= pMe->psGameing->nInputNumCount)
	{
		pMe->psGameing->nInputNumCount = 0;
		return TRUE;
	}
	//Clear Lost Input Num
	pMe->psGameing->nInputNumCount--;
	pMe->psGameing->szInputNum[pMe->psGameing->nInputNumCount] = '\0';

	//Draw NULL Str
	STRTOWSTR("       ", szTempChar, 20);
	IDISPLAY_DrawText(pMe->m_pIDisplay, AEE_FONT_BOLD, szTempChar, -1, GAMEINGINPUT_X, GAMEINGINPUT_Y, NULL, NULL);
	IDISPLAY_UpdateEx(pMe->m_pIDisplay, FALSE);

	//Draw Input Num Str
	IDISPLAY_DrawText(pMe->m_pIDisplay, AEE_FONT_BOLD, pMe->psGameing->szInputNum, -1, GAMEINGINPUT_X, GAMEINGINPUT_Y, NULL, NULL);
	IDISPLAY_Update(pMe->m_pIDisplay);

	return TRUE;
}


//Cai Dan Fun
static void GAMEING_CaiDan(GuestNum * pMe, AEEEvent eCode, uint16 wParam, uint32 dwParam)
{
	const int nCaiDanConst = 12;
	// Cai Dan Key Define
	const uint16 usCaiDan[12] = {AVK_UP, 
								AVK_UP, 
								AVK_DOWN, 
								AVK_DOWN, 
								AVK_LEFT, 
								AVK_RIGHT, 
								AVK_LEFT, 
								AVK_RIGHT,
								AVK_POUND,
								AVK_STAR,
								AVK_POUND,
								AVK_STAR
	};

	//Cai Dan Const
	if (wParam != usCaiDan[pMe->psGameing->nCaiDan])
	{
		pMe->psGameing->nCaiDan = 0;
	}
	else
	{
		pMe->psGameing->nCaiDan++;
	}

	if (nCaiDanConst == pMe->psGameing->nCaiDan)
	{
		//Set Input Num to Str
		WSTRNCOPYN(pMe->psGameing->szInputNum, GAMEINGINPUTNUMMAX + 1, pMe->psGameing->szRandNum, -1);

		//Input Num Const + 1
		pMe->psGameing->nInputNumCount = GAMEINGINPUTNUMMAX;

		//Draw Input Num Str
		IDISPLAY_DrawText(pMe->m_pIDisplay, AEE_FONT_BOLD, pMe->psGameing->szInputNum, -1, GAMEINGINPUT_X, GAMEINGINPUT_Y, NULL, NULL);
		IDISPLAY_Update(pMe->m_pIDisplay);
	}
}