扫雷游戏源码.txt

MTK平台上用的扫雷游戏源码

#include "MMI_features.h"
#include "GameDefs.h"
#include "GameInc.h"

#include "gdi_include.h"

#include "mine.h"

//-------------------------------------GAME_MINE--------------------------------
//#define GAME_MINE

#if 1
//def GAME_MINE

#define Total_Col     12 //行
#define Total_Row     11 //列 


#define Total_BlockNum   (Total_Row * Total_Col)

#define Block_PexlWidth     16
#define Block_PexlHeight    16

#define Start_PexlPOS_X     0
#define Start_PexlPOS_Y     20

#define  mine_trace(log) kal_prompt_trace log

typedef enum{ 
    MS_Blank,  //白板
    MS_NUM1,   // 数字1
    MS_NUM2,   // 数字2
    MS_NUM3,   // 数字3
    MS_NUM4,   // 数字4
    MS_NUM5,   // 数字5
    MS_NUM6,   // 数字6
    MS_NUM7,   // 数字7
    MS_NUM8,   // 数字8     
    MS_MINE,   // 地雷
    MS_EXPLODE,   // 爆炸的地雷
    MS_FLAG,   // 红旗
    MS_OPEN,  //打开的数字
    MS_QUEST,  // ?
    MS_MAX     
    } MINESTATUS;

typedef enum{ 
    Block_CLOSEED,
    Block_OPENED 
   }e_OPENED;

typedef struct{ 
    int Pos_X,Pos_Y;       // 位置坐标
    MINESTATUS MineStatus; // 内容
    e_OPENED OpenedStatus; //是否打开
     }__MineStruct;

__MineStruct TotalMineData[Total_BlockNum];

gdi_handle background, foreground;
#define  SCR_ID_MINE_MAIN        5370  //SCR_ID_CALC_APP
#define  SCR_ID_MINE_VICTORY       (SCR_ID_MINE_MAIN + 1)
#define  SCR_ID_MINE_FAILED       (SCR_ID_MINE_MAIN + 2)


#define MINE_MIN_LEVEL 1
#define MINE_MAX_LEVEL 4

static char MineLevel=MINE_MIN_LEVEL;

#define MINE_NUM_LEVEL1    10
#define MINE_NUM_LEVEL2    15
#define MINE_NUM_LEVEL3    20
#define MINE_NUM_LEVEL4    25

static short TotalMineNum;// 总的地雷数
static short IsGameOver=FALSE;
static short OpenedBlockNum=0;// 打开了多少个方块
//按下时候点的键,用于画面恢复
static short DownClickedBlockNum=0;


static void Mine_Base_Draw(int POS_X,int POS_Y,int BM_ID)
{
pixtel_UI_lock_double_buffer();
pixtel_UI_reset_clip();
pixtel_UI_show_image((S32) POS_X,(S32) POS_Y,(UI_image_type) GetImage(BM_ID));
pixtel_UI_unlock_double_buffer();
pixtel_UI_BLT_double_buffer(0,0,176 - 1,220 - 1); 
}

static void Mine_Draw(int POS_X,int POS_Y,int BM_ID)
{
pixtel_UI_show_image((S32) POS_X,(S32) POS_Y,(UI_image_type) GetImage(BM_ID));
}


static void Mine_DrawAll(void)
{
int i;
mine_trace((MOD_MMI,"\n[Mine->Mine_DrawAll in]\n"));

pixtel_UI_lock_double_buffer();
pixtel_UI_reset_clip();

// background
Mine_Draw(Start_PexlPOS_X,Start_PexlPOS_Y,IMG_ID_MINE_BIG_BKG);

for(i=0; i<Total_BlockNum; i++)
{
  if(TotalMineData[i].OpenedStatus == Block_CLOSEED)
  {
   Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y, IMG_ID_MINE_NORMAL_BLOCK );
  }
  else
  {
   //mine_trace((MOD_MMI,"\n[Mine->MineStatus=%d,x=%d,y=%d]\n", TotalMineData[i].MineStatus, TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y));
   switch(TotalMineData[i].MineStatus)
   {
    case MS_Blank:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_BALNK );
     break;
    }
    case MS_MINE:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_MINE);
     break;
    }
    case MS_EXPLODE:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_EXPLODE);
     break;
    }

    case MS_NUM1:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM1);
     break;
    }
    case MS_NUM2:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM2);
     break;
    }
    case MS_NUM3:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM3);
     break;
    }
    case MS_NUM4:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM4);
     break;
    }
    case MS_NUM5:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM5);
     break;
    }
    case MS_NUM6:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM6);
     break;
    }
    case MS_NUM7:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM7);
     break;
    }
    case MS_NUM8:
    {
     Mine_Draw(TotalMineData[i].Pos_X, TotalMineData[i].Pos_Y,IMG_ID_MINE_NUM7);
     break;
    }    
   }
  }
}

pixtel_UI_unlock_double_buffer();
pixtel_UI_BLT_double_buffer(0,0,176 - 1,220 - 1);
}

/*
打开某个块
*/
static void Mine_VictoryScreen(void);
static void Mine_OpenABlock(int Num)
{
if((Num<0) || (Num>=Total_BlockNum))
{
  return;
}
if(TotalMineData[Num].OpenedStatus == Block_OPENED)
{
  return;
}

TotalMineData[Num].OpenedStatus = Block_OPENED; 
OpenedBlockNum++;
mine_trace((MOD_MMI,"\n[Mine->Mine_OpenABlock, OpenedBlockNum=%d]\n",OpenedBlockNum));
if(OpenedBlockNum >= (Total_BlockNum - TotalMineNum))
{
  if(TotalMineData[Num].MineStatus != MS_MINE)
  {
   Mine_VictoryScreen();
  }
  OpenedBlockNum =0;
}
}


static int Mine_GetRight(int nCurMine)
{
if ((nCurMine+1)%Total_Row >0)
{
  return nCurMine+1;
}
else
{
  return -1;
}
}

static int Mine_GetLeft(int nCurMine)
{
if (nCurMine%Total_Row>0)
{
  return nCurMine-1;
}
else
{
  return -1;
}
}

static int Mine_GetTop(int nCurMine)
{
if (nCurMine >= Total_Row)
{
  return (nCurMine - Total_Row);
}
else
{
  return -1;
}
}

static int Mine_GetBot(int nCurMine)
{
if (nCurMine < (Total_BlockNum - Total_Row))
{
  return (nCurMine + Total_Row);
}
else
{
  return -1;
}
}

/*
根据指定范围随机产生一个数字
*/
static int Mine_RandNum(int MinNum, int MaxNum)
{
  static int RandResult;
  int i;
  int randtemp;
  
  if(MinNum > MaxNum)
  {
   return -1;
  }
//
  return RandResult;
}


/*
随机计算一个数字作为Mine的位置返回
*/
static int Mine_RandPos(void)
{
static int RandMinePosNum;
int i;

//

return RandMinePosNum;
}


static int Mine_IniMineData(void)
{
int i=0;
for(i=0;  i<Total_BlockNum;  i++)
{
  TotalMineData[i].Pos_X =  Start_PexlPOS_X + i%Total_Row*16;
  TotalMineData[i].Pos_Y =  Start_PexlPOS_Y + i/Total_Row*16;
  TotalMineData[i].MineStatus  =   MS_Blank;
  TotalMineData[i].OpenedStatus =  Block_CLOSEED;
}
IsGameOver=FALSE;
OpenedBlockNum=0;
}

/*
设置第 i 个的状态
Num 从0开始
*/
static int Mine_SetStatus(int Num, int Status)
{
//mine_trace((MOD_MMI,"\n[Mine->Mine_SetStatus in, Num=%d, Status=%d]\n",Num, Status));
if((Num<0) || (Num>=Total_BlockNum))
{
  return;
}
if((Status<0) || (Status>MS_MAX))
{
  return;
}

TotalMineData[Num].MineStatus   = Status;
}

/*
notice: Mine_Generate之前，要先做 Mine_IniMineData 动作，保证 MS_Blank 状态
*/
static void Mine_Generate(void)
{
int i=0;
int CurMinePosNum;
int NewPosNum;//新的位置数
int RandomMin;

switch(MineLevel)
{
  case 1:
  {
   RandomMin =MINE_NUM_LEVEL1;
   break;
  }
  case 2:
  {
   RandomMin =MINE_NUM_LEVEL2;
   break;
  }
  case 3:
  {
   RandomMin =MINE_NUM_LEVEL3;
   break;
  }
  case 4:
  {
   RandomMin =MINE_NUM_LEVEL4;
   break;
  }
  default:
  {
   RandomMin =MINE_NUM_LEVEL1;
   break;
  }
}
}


static void Mine_Create(void)
{
Mine_IniMineData();
Mine_Generate();
Mine_DrawAll();
} 

static void Mine_JudgeBlankAndDoClickedHandle(int PosNum);

static void Mine_ClickedBlankHandle(int ClickedMinePosNum)
{
  //int i=0;

}


/*
only deal with click on blank
*/
static void Mine_JudgeBlankAndDoClickedHandle(int PosNum)
{
mine_trace((MOD_MMI,"\n[Mine->Mine_JudgeBlankAndDoClickedHandle, PosNum=%d]\n",PosNum));
if(TotalMineData[PosNum].MineStatus == MS_Blank)
{
  mine_trace((MOD_MMI,"\n[ is blank]\n"));
  if(TotalMineData[PosNum].OpenedStatus == Block_CLOSEED)
  {
   Mine_ClickedBlankHandle(PosNum);
  }
}
else
{
  return;
}
}

//----------------------test-------------------------------
//#define TempTEST

#ifdef TempTEST
static char testflag=0;
static int test_Mine_IniMineData(void)
{
int i=0;
}


/*
notice: Mine_Generate之前，要先做 Mine_IniMineData 动作，保证 MS_Blank 状态
*/
static void test_Mine_Generate(int inMineNum)
{
int i=0;
int CurMinePosNum;
int NewPosNum;//新的位置数
   
}

#endif


static void Mine_VictoryScreen(void)
{
mine_trace((MOD_MMI,"\n[Mine->Mine_VictoryScreen in]\n"));
IsGameOver=TRUE;
EntryNewScreen(SCR_ID_MINE_VICTORY,NULL,Mine_VictoryScreen,NULL);
MineLevel++;
if((MineLevel <MINE_MIN_LEVEL) || (MineLevel >MINE_MAX_LEVEL))
{
  MineLevel=MINE_MIN_LEVEL;
}
ClearAllKeyHandler();
//left key
SetLeftSoftkeyFunction(GoBackHistory,KEY_EVENT_UP);
//right key
SetRightSoftkeyFunction(GoBackHistory,KEY_EVENT_UP);
Mine_DrawAll();
Mine_Base_Draw(176/2, 220/2, IMG_ID_MINE_SUCCESS);
return;
}

static void Mine_FailedScreen(void)
{
mine_trace((MOD_MMI,"\n[Mine->Mine_FailedScreen in]\n"));
IsGameOver=TRUE;
EntryNewScreen(SCR_ID_MINE_FAILED,NULL,Mine_FailedScreen,NULL);
ClearAllKeyHandler();
//left key
SetLeftSoftkeyFunction(GoBackHistory,KEY_EVENT_UP);
//right key
SetRightSoftkeyFunction(GoBackHistory,KEY_EVENT_UP);
Mine_DrawAll();
Mine_Base_Draw(176/2, 220/2, IMG_ID_MINE_FAILED);
return;
}


static void Mine_KeyDownEvent(mmi_pen_point_struct  pos)
{
int temp_row_x; // x方向上有几列
int temp_Line_y;// y方向上有几行
int ClickedBlockNum;

//-------------相对于起始点的位置判定坐标-----------------

temp_row_x =  (pos.x - Start_PexlPOS_X)/ Block_PexlWidth;
temp_Line_y = (pos.y - Start_PexlPOS_Y);

if((temp_row_x >= Total_Row) || (temp_Line_y >= Total_Col))
{
  return;
}

ClickedBlockNum= temp_Line_y * Total_Row + temp_row_x;


mine_trace((MOD_MMI,"\n[Mine->Mine_KeyDownEvent in, x=%d, y=%d, x2=%d, y2=%d, num=%d]\n",pos.x, pos.y, temp_row_x,temp_Line_y,ClickedBlockNum));

if(TotalMineData[ClickedBlockNum].OpenedStatus == Block_OPENED)
{//已经打开了就不要再打开了
  return;
}

DownClickedBlockNum = ClickedBlockNum;
Mine_Base_Draw(TotalMineData[ClickedBlockNum].Pos_X, TotalMineData[ClickedBlockNum].Pos_Y,IMG_ID_MINE_BALNK );
return;
}

static void Mine_KeyUpEvent(mmi_pen_point_struct  pos)
{
int temp_row_x; // x方向上有几列
int temp_Line_y;// y方向上有几行
int ClickedBlockNum;

if(DownClickedBlockNum!=0)
{// 不在按下的地方弹起，则恢复到以前的状态
  Mine_Base_Draw(TotalMineData[DownClickedBlockNum].Pos_X, TotalMineData[DownClickedBlockNum].Pos_Y,IMG_ID_MINE_NORMAL_BLOCK);
  DownClickedBlockNum=0;
}

//-------------相对于起始点的位置判定坐标-----------------

temp_row_x =  (pos.x - Start_PexlPOS_X);
temp_Line_y = (pos.y - Start_PexlPOS_Y);

if((temp_row_x < Total_Row) || (temp_Line_y >= Total_Col))
{
  return;
}

ClickedBlockNum= temp_Line_y * Total_Row + temp_row_x;

#ifdef TempTEST
if(1==testflag)
{

}
#endif

mine_trace((MOD_MMI,"\n[Mine->Mine_KeyUpEvent in, x=%d, y=%d, x2=%d, y2=%d, num=%d]\n",pos.x, pos.y, temp_row_x,temp_Line_y,ClickedBlockNum));

if(TotalMineData[ClickedBlockNum].OpenedStatus == Block_OPENED)
{//已经打开了就不要再打开了
  return;
}

if(TotalMineData[ClickedBlockNum].MineStatus == MS_MINE)
{
  int i;
  //DisplayPopup((PU8)GetString(STR_ID_MINE_FAILED), IMG_GLOBAL_ERROR, 0, 1000, ERROR_TONE);
  TotalMineData[ClickedBlockNum].MineStatus = MS_EXPLODE;
  Mine_OpenABlock(ClickedBlockNum);
  
  for(i=0; i<Total_BlockNum; i++)
  {
   if(TotalMineData[i].MineStatus == MS_MINE)
   {
    Mine_OpenABlock(i);
   }
  } 
  Mine_FailedScreen();
}
else if(TotalMineData[ClickedBlockNum].MineStatus == MS_Blank)
{
  Mine_ClickedBlankHandle(ClickedBlockNum);
}
else
{
  Mine_OpenABlock(ClickedBlockNum);
}

if(TRUE==IsGameOver)
{//失败/或成功了就不在画了
  return;
}
Mine_DrawAll();
}

static void Mine_LeftKey_Handle(void)
{
return;
}

static void Mine_RightKey_Handle(void)
{
GoBackHistory();
return;
}

// again
static void Mine_SendKey_Handle(void)
{
//Mine_Create();
#ifdef TempTEST
if(1==testflag)
{
  testflag =0;
}
else
{
  testflag =1;
}
#endif

return;
}


static void Mine_Keys_Reg(void)
{
ClearAllKeyHandler();
//left key and send key
SetLeftSoftkeyFunction(Mine_LeftKey_Handle,KEY_EVENT_UP);
SetKeyHandler(Mine_SendKey_Handle,KEY_SEND,KEY_EVENT_DOWN);
SetKeyHandler(Mine_SendKey_Handle,KEY_LSK,KEY_EVENT_DOWN);

//right key
SetRightSoftkeyFunction(Mine_RightKey_Handle,KEY_EVENT_UP);
}


void Mine_Entry(void)
{
mine_trace((MOD_MMI,"\n[Mine->Mine_Entry in]\n"));
EntryNewScreen(SCR_ID_MINE_MAIN ,NULL,Mine_Entry,NULL);
Mine_Create();
Mine_Keys_Reg();
/*设置触摸屏按键处理*/
mmi_pen_register_down_handler(Mine_KeyDownEvent);
mmi_pen_register_up_handler(Mine_KeyUpEvent);
} 


#endif