开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > BREW编程 > 查看源码
mine.c
资源名称：brewmine3.rar　[点击查看]
上传用户：yulinhuamu
上传日期：2009-12-26
资源大小：7287k
文件大小：20k
源码类别：

BREW编程

开发平台：

Visual C++

mine.c：源码内容
  1. #include "mine.h"
  2. ///////////////////////////////////////////////////////////////////////////////////////////////
  3. // STATIC FUNCTION DECLARE
  4. ///////////////////////////////////////////////////////////////////////////////////////////////
  5. #define MSGOFFSET_SUCCESS   212
  6. #define MSGOFFSET_TIMER     10
  7. #define MSGOFFSET_FAILURE   365
  8. #define MARGIN_RECT 3
  10. #define MINEUI_OUTRECTCOLOR MAKE_RGB(150,150,200)
  11. #define MINEUI_INRECTCOLOR MAKE_RGB(200,200,255)
  13. #define MINEUI_GRIDCOLOR MAKE_RGB(200,200,250)
  14. #define MINEUI_FILLCOLOR MAKE_RGB(211,211,211)
  15. #define MINEUI_SELIIEMCOLOR MAKE_RGB(180,180,200)
  16. #define MINEUI_CUROR MAKE_RGB(255,10,10)
  17. #define MINEUI_FRAME MAKE_RGB(0,0,0)
  19. #define MINEASSERTNULL(p) {if(NULL==p) return FALSE;}
  21. static boolean WINMINE_Draw(IWinmine* pMine);
  22. static boolean WINMINE_DrawElement(IWinmine* pMine,int x,int y,boolean bSel);
  23. static boolean WINMINE_DrawCuror(IWinmine* pMine,AEERect* rt);
  24. static boolean WINMINE_DrawMine(IWinmine* pMine,AEERect* rt);
  25. static boolean WINMINE_DrawBlast(IWinmine* pMine,AEERect* rt);
  26. static boolean WINMINE_DrawBanner(IWinmine* pMine,AEERect* rt);
  27. static boolean WINMINE_DrawNumber(IWinmine* pMine,AEERect* rt,char* pText);
  28. static boolean WINMINE_DrawFrame(IWinmine* pMine,AEERect* rt,int x,int y);
  30. static boolean WINMINE_SUCCESSHDL(IWinmine* pMine);
  31. static boolean WINMINE_FAILUREHDL(IWinmine* pMine);
  32. static boolean WINMINE_BLANKHDL(IWinmine* pMine,int x,int y);
  33. static boolean WINMINE_ShowMsg(IWinmine* pMine,int nType);
  34. static void WINMINE_SaveScore(IWinmine* pMine);
  35. static void WINMINE_BlankElementHDL(IWinmine* pMine,int x,int y);
  36. static void WINMINE_MsgTimerHDL(IWinmine* pMine);
  37. ///////////////////////////////////////////////////////////////////////////////////////////////
  38. // PUBLIC FUNCDEFINE
  39. ///////////////////////////////////////////////////////////////////////////////////////////////
  41. IWinmine* IWINMINE_CreateInstance()
  42. {
  43. IWinmine* pMine=MALLOCREC(IWinmine);
  44. if(pMine)
  45. {
  46. AEEDeviceInfo di;
  48. pMine->m_pApp=(AEEApplet*)GETAPPINSTANCE();
  50. ISHELL_GetDeviceInfo(pMine->m_pApp->m_pIShell, &di);
  51. pMine->m_GameRect.x=pMine->m_GameRect.y=0;
  52. pMine->m_GameRect.dx=di.cxScreen;
  53. pMine->m_GameRect.dy=di.cyScreen;
  55. pMine->m_PlayRect.x=pMine->m_GameRect.x+MARGIN_RECT;
  56. pMine->m_PlayRect.dx=pMine->m_GameRect.dx-2*MARGIN_RECT;
  57. pMine->m_PlayRect.dy=pMine->m_PlayRect.dx;
  58. pMine->m_PlayRect.y=pMine->m_GameRect.dy+pMine->m_GameRect.y-pMine->m_PlayRect.dy-MARGIN_RECT;
  60. pMine->m_MenuRect.x=pMine->m_PlayRect.x;
  61. pMine->m_MenuRect.dx=pMine->m_PlayRect.dx;
  62. pMine->m_MenuRect.y=pMine->m_GameRect.y+MARGIN_RECT;
  63. pMine->m_MenuRect.dy=pMine->m_GameRect.dy-pMine->m_PlayRect.dy-3*MARGIN_RECT;
  65. pMine->m_ElementWide=pMine->m_PlayRect.dx/MINE_LINE_NUM;
  66. pMine->m_ElementHeight=pMine->m_PlayRect.dy/MINE_COLU_NUM;
  67. pMine->m_OffsetX=pMine->m_PlayRect.x+(pMine->m_PlayRect.dx-pMine->m_ElementWide*MINE_LINE_NUM)/2;
  68. pMine->m_OffsetY=pMine->m_PlayRect.y+(pMine->m_PlayRect.dy-pMine->m_ElementHeight*MINE_COLU_NUM)/2;
  70. pMine->m_pImage=ISHELL_LoadImage(pMine->m_pApp->m_pIShell,"test.bmp");
  71. if(pMine->m_pImage)
  72. IIMAGE_SetDrawSize(pMine->m_pImage,pMine->m_MenuRect.dx-4,pMine->m_MenuRect.dy-4);
  74. pMine->m_pGameImage=ISHELL_LoadImage(pMine->m_pApp->m_pIShell,"x.bmp");
  75. if(pMine->m_pGameImage)
  76. IIMAGE_SetDrawSize(pMine->m_pGameImage,pMine->m_ElementWide-4,pMine->m_ElementHeight-4);
  78. ISHELL_CreateInstance(pMine->m_pApp->m_pIShell,AEECLSID_GRAPHICS,(void**)&pMine->m_pGraphic);
  79. pMine->m_pMusic=IMINEMUSIC_CreateInstance(pMine->m_pApp->m_pIShell);
  80. }
  81. return pMine;
  82. }
  83. boolean IWINMINE_Release(IWinmine* pMine)
  84. {
  85. MINEASSERTNULL(pMine);
  86. ISHELL_CancelTimer(pMine->m_pApp->m_pIShell,(PFNNOTIFY) WINMINE_MsgTimerHDL, pMine);
  87. if(pMine->m_pImage)
  88. {
  89. IIMAGE_Release(pMine->m_pImage);
  90. pMine->m_pImage=NULL;
  91. }
  92. if(pMine->m_pGameImage)
  93. {
  94. IIMAGE_Release(pMine->m_pGameImage);
  95. pMine->m_pGameImage=NULL;
  96. }
  97. if(pMine->m_pMusic)
  98. {
  99. IMINEMUSIC_Release(pMine->m_pMusic);
  100. pMine->m_pMusic=NULL;
  101. }
  102. if(pMine->m_pGraphic)
  103. {
  104. IGRAPHICS_Release(pMine->m_pGraphic);
  105. pMine->m_pGraphic=NULL;
  106. }
  107. return TRUE;
  108. }
  109. boolean IWINMINE_Start(IWinmine* pMine)
  110. {
  111. byte   z;
  112. int x,y;
  113. TScore score;
  114. uint16 mineNum=0;
  116. MINEASSERTNULL(pMine);
  117. //zero list data
  118. for(x=0;x<MINE_LINE_NUM;x++)
  119. for(y=0;y<MINE_COLU_NUM;y++)
  120. {
  121. pMine->m_Data[x][y].m_bSel=FALSE;
  123. pMine->m_Data[x][y].m_Stat=0;
  125. }
  126. //generate the mine
  127. while(mineNum<MINE_NUM)
  128. {
  129. //x point
  130. GETRAND(&z,sizeof(z));
  131. x=z*MINE_LINE_NUM/256;
  132. //y point
  133. GETRAND(&z,sizeof(z));
  134. y=z*MINE_LINE_NUM/256;
  135. //check available
  136. if(MINE_FLAGE==pMine->m_Data[x][y].m_Stat)
  137. continue;
  138. pMine->m_Data[x][y].m_Stat=MINE_FLAGE;
  139. mineNum++;
  140. //set around grid
  141. if((x-1>=0)&&(y-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x-1][y-1].m_Stat))
  142. pMine->m_Data[x-1][y-1].m_Stat++;
  143. if((x-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x-1][y].m_Stat))
  144. pMine->m_Data[x-1][y].m_Stat++;
  145. if((x-1>=0)&&(y+1<MINE_COLU_NUM)&&(MINE_FLAGE!=pMine->m_Data[x-1][y+1].m_Stat))
  146. pMine->m_Data[x-1][y+1].m_Stat++;
  148. if((y-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x][y-1].m_Stat))
  149. pMine->m_Data[x][y-1].m_Stat++;
  150. if((y+1<MINE_COLU_NUM)&&(MINE_FLAGE!=pMine->m_Data[x][y+1].m_Stat))
  151. pMine->m_Data[x][y+1].m_Stat++;
  153. if((x+1<MINE_LINE_NUM)&&(y-1>=0)&&(MINE_FLAGE!=pMine->m_Data[x+1][y-1].m_Stat))
  154. pMine->m_Data[x+1][y-1].m_Stat++;
  155. if((x+1<MINE_LINE_NUM)&&(MINE_FLAGE!=pMine->m_Data[x+1][y].m_Stat))
  156. pMine->m_Data[x+1][y].m_Stat++;
  157. if((x+1<MINE_LINE_NUM)&&(y+1<MINE_COLU_NUM)&&(MINE_FLAGE!=pMine->m_Data[x+1][y+1].m_Stat))
  158. pMine->m_Data[x+1][y+1].m_Stat++;
  159. }
  160. //other value
  161. pMine->m_PointX=MINE_LINE_NUM/2;
  162. pMine->m_PointY=MINE_COLU_NUM/2;
  163. pMine->m_Count=0;
  164. pMine->m_TimerCount=MINE_GAMETIMER;
  165. pMine->m_Result=STAT_START;
  166. //Score
  167. if(SUCCESS!=ISHELL_GetAppPrefs(pMine->m_pApp->m_pIShell,1,&score,sizeof(score)))
  168. pMine->m_MaxScore=0;
  169. else
  170. pMine->m_MaxScore=score.m_nScore;
  171. //draw list
  172. WINMINE_Draw(pMine);
  173. WINMINE_ShowMsg(pMine,0);
  174. IMINEMUSIC_Start(pMine->m_pMusic,MMT_START);
  175. return TRUE;
  177. }
  178. boolean IWINMINE_HandleEvent(IWinmine* pMine, uint16 wParam)
  179. {
  180. MINEASSERTNULL(pMine);
  182. if(STAT_START!=pMine->m_Result)
  183. return FALSE;
  185. switch(wParam)
  186. {
  187. case AVK_LEFT:
  188. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
  189. pMine->m_PointX--;
  190. if(pMine->m_PointX<0) 
  191. pMine->m_PointX=MINE_LINE_NUM-1;
  192. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
  193. break;
  194. case AVK_RIGHT:
  195. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
  196. pMine->m_PointX++;
  197. if(MINE_LINE_NUM==pMine->m_PointX) 
  198. pMine->m_PointX=0;
  199. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
  200. break;
  201. case AVK_UP:
  202. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
  203. pMine->m_PointY--;
  204. if(pMine->m_PointY<0) 
  205. pMine->m_PointY=MINE_COLU_NUM-1;
  206. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
  207. break;
  208. case AVK_DOWN:
  209. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,FALSE);
  210. pMine->m_PointY++;
  211. if(MINE_COLU_NUM==pMine->m_PointY) 
  212. pMine->m_PointY=0;
  213. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
  214. break;
  215. case AVK_SELECT:
  216. if(pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel)
  217. return TRUE;
  218. pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel=TRUE;
  220. switch(pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_Stat)
  221. {
  222. case MINE_FLAGE:
  223. WINMINE_FAILUREHDL(pMine);
  224. break;
  225. case 0:
  226. WINMINE_BLANKHDL(pMine,pMine->m_PointX,pMine->m_PointY);
  227. default:
  228. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
  229. }
  230. break;
  231. case AVK_CLR:
  232. if(pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel)
  233. return TRUE;
  234. pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_bSel=TRUE;
  235. if(MINE_FLAGE!=pMine->m_Data[pMine->m_PointX][pMine->m_PointY].m_Stat)
  236. WINMINE_FAILUREHDL(pMine);
  237. else
  238. {
  239. pMine->m_Count++;
  240. if(MINE_NUM==pMine->m_Count)
  241. WINMINE_SUCCESSHDL(pMine);
  242. else
  243. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
  244. }
  245. break;
  246. case AVK_1:
  247. return WINMINE_SUCCESSHDL(pMine);
  248. case AVK_3:
  249. return WINMINE_FAILUREHDL(pMine);
  250. default:
  251. return FALSE;
  252. }
  253. IDISPLAY_Update(pMine->m_pApp->m_pIDisplay); 
  254. return TRUE;
  255. }
  256. boolean IWINMINE_Pause(IWinmine* pMine)
  257. {
  258. MINEASSERTNULL(pMine);
  259. ISHELL_CancelTimer(pMine->m_pApp->m_pIShell,(PFNNOTIFY) WINMINE_MsgTimerHDL, pMine);
  260. return TRUE;
  261. }
  262. boolean IWINMINE_GetMaxScore(IWinmine* pMine,TScore* score)
  263. {
  264. MINEASSERTNULL(pMine);
  265. if(SUCCESS==ISHELL_GetAppPrefs(pMine->m_pApp->m_pIShell,1,&score,sizeof(score)))
  266. return TRUE;
  267. else
  268. return FALSE;
  269. }
  270. boolean IWINMINE_ResetMaxScore(IWinmine* pMine)
  271. {
  272. uint32 sec;
  273. TScore score;
  275. MINEASSERTNULL(pMine);
  276. sec=GETTIMESECONDS();
  277. GETJULIANDATE(sec,&(score.m_Date));
  278. score.m_nScore=0;
  279. ISHELL_SetAppPrefs(pMine->m_pApp->m_pIShell,1,&score,sizeof(score));
  280. return TRUE;
  281. }
  282. boolean IWINMINE_GetPlayRect(IWinmine* pMine,AEERect *rt)
  283. {
  284. if(pMine)
  285. *rt=pMine->m_PlayRect;
  286. return TRUE;
  287. }
  288. boolean IWINMINE_DrawIntroScreen(IWinmine* pMine)
  289. {
  290. IBitmap* image;
  291. uint32 time1;
  293. MINEASSERTNULL(pMine);
  294. // Draw the Background 
  295. image = ISHELL_LoadBitmap(pMine->m_pApp->m_pIShell,"flash.bmp");
  297. if(image)
  298. {
  299. IDISPLAY_ClearScreen(pMine->m_pApp->m_pIDisplay);
  300. IDISPLAY_BitBlt(pMine->m_pApp->m_pIDisplay, 
  301. 0,0,
  302. pMine->m_GameRect.dx,
  303. pMine->m_GameRect.dy,
  304. image, 
  305. 0,0,
  306. AEE_RO_COPY);
  307. IBITMAP_Release(image);
  308. // FALSE parameter forces an immediate screen update
  309. IDISPLAY_UpdateEx(pMine->m_pApp->m_pIDisplay,FALSE);
  310. // IMINEMUSIC_Start(pMine->m_pMusic,MMT_FLASH);
  311. // wait at least 1.5 seconds on intro screen
  312. time1= GETUPTIMEMS();
  313. while( (GETUPTIMEMS() - time1) < 500) {}
  314. }
  315. return TRUE;
  316. }
  317. ///////////////////////////////////////////////////////////////////////////////////////////////
  318. // STATIC FUNCTION DEFINE
  319. ///////////////////////////////////////////////////////////////////////////////////////////////
  320. static boolean WINMINE_Draw(IWinmine* pMine)
  321. {
  322. int x,y;
  323. AEERect gamerect,playrect,menurect;
  324. MINEASSERTNULL(pMine);
  325. //draw the frame
  326. gamerect=pMine->m_GameRect;
  327. playrect=pMine->m_PlayRect;
  328. menurect=pMine->m_MenuRect;
  330. IDISPLAY_DrawFrame(pMine->m_pApp->m_pIDisplay,&gamerect,AEE_FT_RAISED,MINEUI_OUTRECTCOLOR);
  331. IDISPLAY_DrawFrame(pMine->m_pApp->m_pIDisplay,&playrect,AEE_FT_LOWERED,MINEUI_INRECTCOLOR);
  332. IDISPLAY_DrawFrame(pMine->m_pApp->m_pIDisplay,&menurect,AEE_FT_LOWERED,MINEUI_FILLCOLOR);
  333. //draw the playrect
  334. for(x=0;x<MINE_LINE_NUM;x++)
  335. for(y=0;y<MINE_COLU_NUM;y++)
  336. WINMINE_DrawElement(pMine,x,y,FALSE);
  337. WINMINE_DrawElement(pMine,pMine->m_PointX,pMine->m_PointY,TRUE);
  338. //Update
  339. IDISPLAY_Update(pMine->m_pApp->m_pIDisplay); 
  340. return TRUE;
  341. }
  342. static boolean WINMINE_SUCCESSHDL(IWinmine* pMine)
  343. {
  344. int x,y;
  345. MINEASSERTNULL(pMine);
  346. pMine->m_Result=STAT_SUCCESS;
  347. for(x=0;x<MINE_LINE_NUM;x++)
  348. for(y=0;y<MINE_COLU_NUM;y++)
  349. {
  350. pMine->m_Data[x][y].m_bSel=TRUE;
  351. WINMINE_DrawElement(pMine,x,y,FALSE);
  352. }
  353. WINMINE_SaveScore(pMine);
  354. WINMINE_ShowMsg(pMine,1);
  355. IMINEMUSIC_Start(pMine->m_pMusic,MMT_SUCCESS);
  356. return TRUE;
  357. }
  358. static boolean WINMINE_FAILUREHDL(IWinmine* pMine)
  359. {
  360. int x,y;
  361. MINEASSERTNULL(pMine);
  362. pMine->m_Result=STAT_FAILURE;
  363. for(x=0;x<MINE_LINE_NUM;x++)
  364. for(y=0;y<MINE_COLU_NUM;y++)
  365. {
  366. pMine->m_Data[x][y].m_bSel=TRUE;
  367. WINMINE_DrawElement(pMine,x,y,FALSE);
  368. }
  369. WINMINE_ShowMsg(pMine,2);
  370. IMINEMUSIC_Start(pMine->m_pMusic,MMT_FAILURE);
  371. return TRUE;
  372. }
  373. static boolean WINMINE_BLANKHDL(IWinmine* pMine,int x,int y)
  374. {
  375. MINEASSERTNULL(pMine);
  377. if((x-1>=0)&&(y-1>=0))
  378. WINMINE_BlankElementHDL(pMine,x-1,y-1);
  379. if(x-1>=0)
  380. WINMINE_BlankElementHDL(pMine,x-1,y);
  381. if((x-1>=0)&&(y+1<MINE_COLU_NUM))
  382. WINMINE_BlankElementHDL(pMine,x-1,y+1);
  384. if(y-1>=0)
  385. WINMINE_BlankElementHDL(pMine,x,y-1);
  386. if(y+1<MINE_COLU_NUM)
  387. WINMINE_BlankElementHDL(pMine,x,y+1);
  389. if((x+1<MINE_LINE_NUM)&&(y-1>=0))
  390. WINMINE_BlankElementHDL(pMine,x+1,y-1);
  391. if(x+1<MINE_LINE_NUM)
  392. WINMINE_BlankElementHDL(pMine,x+1,y);
  393. if((x+1<MINE_LINE_NUM)&&(y+1<MINE_COLU_NUM))
  394. WINMINE_BlankElementHDL(pMine,x+1,y+1);
  395. return TRUE;
  396. }
  397. static void WINMINE_BlankElementHDL(IWinmine* pMine,int x,int y)
  398. {
  399. if(FALSE==pMine->m_Data[x][y].m_bSel)
  400. {
  401. pMine->m_Data[x][y].m_bSel=TRUE;
  402. WINMINE_DrawElement(pMine,x,y,FALSE);
  403. if(0==pMine->m_Data[x][y].m_Stat)
  404. WINMINE_BLANKHDL(pMine,x,y);
  405. }
  406. }
  407. static boolean WINMINE_ShowMsg(IWinmine* pMine,int nType)
  408. {
  409. AECHAR wBuf[32];
  410. char       cBuf[32];
  411. AEERect rt;
  412. RGBVAL col;
  413. MINEASSERTNULL(pMine);
  415. rt.x=pMine->m_MenuRect.x+2;
  416. rt.y=pMine->m_MenuRect.y+2;
  417. rt.dx=pMine->m_MenuRect.dx-4;
  418. rt.dy=pMine->m_MenuRect.dy-4;
  419. ISHELL_CancelTimer(pMine->m_pApp->m_pIShell,(PFNNOTIFY) WINMINE_MsgTimerHDL, pMine);
  421. switch(nType)
  422. {
  423. case 0://time
  424. //get the timer value
  425. if(0==pMine->m_TimerCount)
  426. {
  427. return WINMINE_FAILUREHDL(pMine);
  428. }
  429. else
  430. {
  431. SPRINTF(cBuf,"Best:%3d   score:%3d",pMine->m_MaxScore,pMine->m_TimerCount);
  432. STRTOWSTR(cBuf,wBuf,64);
  433. }
  434. pMine->m_TimerCount--;
  435. //show image
  436. col=IDISPLAY_SetColor(pMine->m_pApp->m_pIDisplay, CLR_USER_TEXT,MAKE_RGB(0,0,205));
  437. if(pMine->m_pImage)
  438. {
  439. IIMAGE_SetOffset(pMine->m_pImage,MSGOFFSET_TIMER,2);
  440. IIMAGE_Draw(pMine->m_pImage,rt.x,rt.y);
  441. IDISPLAY_DrawText(pMine->m_pApp->m_pIDisplay,AEE_FONT_NORMAL,wBuf,
  442. -1,0,0,&rt,IDF_ALIGN_CENTER |IDF_ALIGN_MIDDLE|IDF_RECT_FRAME|IDF_TEXT_TRANSPARENT);
  443. }
  444. else
  445. IDISPLAY_DrawText(pMine->m_pApp->m_pIDisplay,AEE_FONT_NORMAL,wBuf,
  446. -1,0,0,&rt,IDF_ALIGN_CENTER |IDF_ALIGN_MIDDLE|IDF_RECT_FRAME|IDF_RECT_FILL );
  447. IDISPLAY_SetColor(pMine->m_pApp->m_pIDisplay, CLR_USER_TEXT,col);
  448. //set timer
  449. ISHELL_SetTimer(pMine->m_pApp->m_pIShell,1000,(PFNNOTIFY) WINMINE_MsgTimerHDL, pMine);
  450. break;
  451. case 1://sucess
  452. if(pMine->m_pImage)
  453. {
  454. IIMAGE_SetOffset(pMine->m_pImage,MSGOFFSET_SUCCESS,10);
  455. IIMAGE_Draw(pMine->m_pImage,rt.x,rt.y);
  456. }
  457. else
  458. {
  459. STRTOWSTR("SUCCESS",wBuf,20);
  460. IDISPLAY_DrawText(pMine->m_pApp->m_pIDisplay,AEE_FONT_BOLD,wBuf,
  461. -1,0,0,&rt,IDF_ALIGN_CENTER |IDF_ALIGN_MIDDLE|IDF_RECT_FRAME|IDF_RECT_FILL );
  462. }
  463. break;
  464. case 2://failure
  465. if(pMine->m_pImage)
  466. {
  467. IIMAGE_SetOffset(pMine->m_pImage,MSGOFFSET_FAILURE,10);
  468. IIMAGE_Draw(pMine->m_pImage,rt.x,rt.y);
  469. }
  470. else
  471. {
  472. STRTOWSTR("FAILURE",wBuf,20);
  473. IDISPLAY_DrawText(pMine->m_pApp->m_pIDisplay,AEE_FONT_BOLD,wBuf,
  474. -1,0,0,&rt,IDF_ALIGN_CENTER |IDF_ALIGN_MIDDLE|IDF_RECT_FRAME|IDF_RECT_FILL );
  475. }
  476. break;
  477. default://error
  478. return FALSE;
  479. }
  480. IDISPLAY_Update(pMine->m_pApp->m_pIDisplay);
  481. return TRUE;
  482. }
  483. static void WINMINE_MsgTimerHDL(IWinmine* pMine)
  484. {
  485. WINMINE_ShowMsg(pMine,0);
  486. }
  487. static boolean WINMINE_DrawElement(IWinmine* pMine,int x,int y,boolean bSel)
  488. {
  489. AEERect rt,rtbak;
  490. MINEASSERTNULL(pMine);
  492. rt.dx=pMine->m_ElementWide;
  493. rt.dy=pMine->m_ElementHeight;
  495. rt.x=x*rt.dx+pMine->m_OffsetX;
  496. rt.y=y*rt.dy+pMine->m_OffsetY;
  498. rtbak=rt;
  500. if(FALSE==pMine->m_Data[x][y].m_bSel)
  501. WINMINE_DrawFrame(pMine,&rtbak,x,y);
  502. else
  503. {
  504. char cBuf[2];
  506. switch(pMine->m_Data[x][y].m_Stat)
  507. {
  508. case MINE_FLAGE:
  509. switch(pMine->m_Result)
  510. {
  511. case STAT_START:
  512. WINMINE_DrawFrame(pMine,&rtbak,x,y);
  513. WINMINE_DrawBanner(pMine,&rt);
  514. break;
  515. case STAT_SUCCESS:
  516. IDISPLAY_DrawRect(pMine->m_pApp->m_pIDisplay,&rtbak,MINEUI_FRAME,MINEUI_FILLCOLOR,IDF_RECT_FRAME|IDF_RECT_FILL);
  517. WINMINE_DrawMine(pMine,&rt);
  518. break;
  519. default:
  520. IDISPLAY_DrawRect(pMine->m_pApp->m_pIDisplay,&rtbak,MINEUI_FRAME,MINEUI_FILLCOLOR,IDF_RECT_FRAME|IDF_RECT_FILL);
  521. WINMINE_DrawBlast(pMine,&rt);
  522. }
  523. break;
  524. case 0:
  525. WINMINE_DrawNumber(pMine,&rt," ");
  526. break;
  527. default:
  528. SPRINTF(cBuf,"%d",pMine->m_Data[x][y].m_Stat);
  529. WINMINE_DrawNumber(pMine,&rt,cBuf);
  530. }
  531. }
  532. if(bSel)
  533. WINMINE_DrawCuror(pMine,&rt);
  534. return TRUE;
  535. }
  537. static boolean WINMINE_DrawCuror(IWinmine* pMine,AEERect* rt)
  538. {
  539. AEEEllipse ellipse;
  541. if(pMine->m_pGraphic)
  542. {
  543. ellipse.cx=rt->x+rt->dx/2;
  544. ellipse.cy=rt->y+rt->dy/2;
  545. ellipse.wx=rt->dx/2-2;
  546. ellipse.wy=rt->dy/2-2;
  548. IGRAPHICS_SetColor(pMine->m_pGraphic,255,0,0,255);
  549. IGRAPHICS_DrawEllipse(pMine->m_pGraphic,&ellipse);
  550. IGRAPHICS_SetColor(pMine->m_pGraphic,0,0,0,255);
  551. }
  552. return TRUE;
  553. }
  554. static boolean WINMINE_DrawMine(IWinmine* pMine,AEERect* rt)
  555. {
  556. AEECircle circle;
  558. if(pMine->m_pGraphic)
  559. {
  560. circle.cx=rt->x+rt->dx/2;
  561. circle.cy=rt->y+rt->dy/2;
  562. circle.r=(rt->dx>rt->y)?rt->y:rt->dx;
  563. circle.r=circle.r/2-4;
  564. IGRAPHICS_SetFillMode(pMine->m_pGraphic,TRUE);
  565. IGRAPHICS_SetFillColor(pMine->m_pGraphic,0,0,0,255);
  566. IGRAPHICS_DrawCircle(pMine->m_pGraphic,&circle);
  568. circle.r/=2;
  569. circle.cx-=circle.r;
  570. circle.cy-=circle.r;
  572. IGRAPHICS_SetFillColor(pMine->m_pGraphic,205,205,205,255);
  573. IGRAPHICS_DrawCircle(pMine->m_pGraphic,&circle);
  574. IGRAPHICS_SetFillMode(pMine->m_pGraphic,FALSE);
  575. }
  576. return TRUE;
  577. }
  578. static boolean WINMINE_DrawBlast(IWinmine* pMine,AEERect* rt)
  579. {
  580. AEELine line;
  581. int x,y,z;
  582. int16    lineLen=1; 
  584. x=rt->dx/2+rt->x;
  585. y=rt->dy/2+rt->y;
  586. z=(rt->dx>rt->dy)?(rt->dy/2):(rt->dx/2);
  587. //横线
  588. line.sx=rt->x+2;
  589. line.sy=y;
  590. line.ex=rt->x+rt->dx-2;
  591. line.ey=y;
  592. IGRAPHICS_DrawLine(pMine->m_pGraphic,&line);
  593. //竖线
  594. line.sx=x;
  595. line.sy=rt->y+2;
  596. line.ex=x;
  597. line.ey=rt->y+rt->dy-2;
  598. IGRAPHICS_DrawLine(pMine->m_pGraphic,&line);
  599. //Z
  600. z=z*3/5;
  601. //左斜线
  602. line.sx=x-z;
  603. line.sy=y-z;
  604. line.ex=x+z;
  605. line.ey=y+z;
  606. IGRAPHICS_DrawLine(pMine->m_pGraphic,&line);
  607. //右斜线
  608. line.sx=x+z;
  609. line.sy=y-z;
  610. line.ex=x-z;
  611. line.ey=y+z;
  612. IGRAPHICS_DrawLine(pMine->m_pGraphic,&line);
  613. //地雷
  614. WINMINE_DrawMine(pMine,rt);
  615. return TRUE;
  616. }
  617. static boolean WINMINE_DrawBanner(IWinmine* pMine,AEERect* rt)
  618. {
  619. AEERect rect;
  620. AEETriangle triagle;
  621. AEELine line;
  622. int nHeight=2;
  623. int x=rt->x+rt->dx/2;
  624. int z=rt->dx/3;
  626. IGRAPHICS_SetFillMode(pMine->m_pGraphic,TRUE);
  627. IGRAPHICS_SetFillColor(pMine->m_pGraphic,0,0,0,255);
  628. //mast
  629. line.sx=line.ex=x;
  630. line.sy=rt->y+2;
  631. line.ey=rt->y+rt->dy-4;
  632. IGRAPHICS_DrawLine(pMine->m_pGraphic,&line);
  633. //pedestal
  634. rect.x=x-z;
  635. rect.y=rt->y+rt->dy-nHeight-2;
  636. rect.dx=z*2;
  637. rect.dy=nHeight;
  638. IGRAPHICS_DrawRect(pMine->m_pGraphic,&rect);
  640. z/=2;
  641. rect.x=x-z;
  642. rect.y-=nHeight-1;
  643. rect.dx=z*2;
  644. rect.dy=nHeight;
  645. IGRAPHICS_DrawRect(pMine->m_pGraphic,&rect);
  646. //flage 
  647. triagle.x0=line.sx;
  648. triagle.y0=line.sy;
  649. triagle.x1=line.sx;
  650. triagle.y1=line.sy+(line.ey-line.sy)/2;
  651. triagle.x2=rt->x+2;
  652. triagle.y2=line.sy+(line.ey-line.sy)/4;
  653. IGRAPHICS_SetFillColor(pMine->m_pGraphic,255,0,0,255);
  654. IGRAPHICS_DrawTriangle(pMine->m_pGraphic,&triagle);
  655. IGRAPHICS_SetFillMode(pMine->m_pGraphic,FALSE);
  656. return TRUE;
  657. }
  658. static boolean WINMINE_DrawNumber(IWinmine* pMine,AEERect* rt,char* pText)
  659. {
  660. AECHAR wBuf[4];
  661. RGBVAL col=IDISPLAY_SetColor(pMine->m_pApp->m_pIDisplay,CLR_USER_BACKGROUND,MINEUI_FILLCOLOR);
  662. STRTOWSTR(pText,wBuf,4);
  663. IDISPLAY_DrawText(pMine->m_pApp->m_pIDisplay,AEE_FONT_BOLD,wBuf,
  664. -1,0,0,rt,IDF_ALIGN_CENTER |IDF_ALIGN_MIDDLE|IDF_RECT_FRAME|IDF_RECT_FILL);
  665. IDISPLAY_SetColor(pMine->m_pApp->m_pIDisplay,CLR_USER_BACKGROUND,col);
  666. return TRUE;
  667. }
  668. static boolean WINMINE_DrawFrame(IWinmine* pMine,AEERect* rt,int x,int y)
  669. {
  670. int cx=rt->x+2;
  671. int cy=rt->y+2;
  672. IDISPLAY_DrawFrame(pMine->m_pApp->m_pIDisplay,rt,AEE_FT_RAISED,MINEUI_FILLCOLOR);
  673. if(pMine->m_pGameImage)
  674. {
  675. IIMAGE_SetOffset(pMine->m_pGameImage,x*pMine->m_ElementWide,y*pMine->m_ElementHeight);
  676. IIMAGE_Draw(pMine->m_pGameImage,cx,cy);
  677. }
  678. return TRUE;
  679. }
  681. static void WINMINE_SaveScore(IWinmine* pMine)
  682. {
  683. TScore score;
  684. uint32 sec;
  685. if(pMine->m_TimerCount>pMine->m_MaxScore)
  686. {
  687. sec=GETTIMESECONDS();
  688. GETJULIANDATE(sec,&(score.m_Date));
  689. score.m_nScore=pMine->m_TimerCount;
  690. ISHELL_SetAppPrefs(pMine->m_pApp->m_pIShell,1,&score,sizeof(score));
  691. }
  692. }