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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他智力游戏 > 查看源码
MineWnd.cpp
资源名称：gamesourec6.rar　[点击查看]
上传用户：hbrsgg1
上传日期：2014-05-08
资源大小：2826k
文件大小：38k
源码类别：

其他智力游戏

开发平台：

C/C++

MineWnd.cpp：源码内容
  1. /*++
  3. Copyright (c) 2004-2005  Micro-soft
  5. Module Name:
  7.     MineWnd.cpp
  9. Abstract:
  11.        the mian Frame of the Mine-Game, we should do the most draw-work here,
  12. surely,the size and style of the window should set here too. 
  14. Author:
  15. Microsoft's Engineer - Unknown Name
  17.     improved by Weijian Luo (Arthur Luo)   15-Jun-2005
  19. E-mail: skybluehacker@yahoo.com.cn
  21. Revision History:      1.0
  23. --*/
  24. #include "stdafx.h"
  25. #include "Mine.h"
  26. #include "MineWnd.h"
  27. #include "MineDefs.h"
  28. #include "Mmsystem.h"
  29. #include "DlgNewRecord.h"
  30. #include "DlgHero.h"
  31. #include "DlgCustom.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. extern CMineApp theApp;
  40. #define ID_TIMER_EVENT WM_USER + 1
  41. /////////////////////////////////////////////////////////////////////////////
  43. CMineWnd::CMineWnd()
  44. {
  45. m_pSndDead = NULL;
  46. m_pSndVictory = NULL;
  47. m_pSndClock = NULL;
  48. m_uTimer = 0;
  49. m_brsBG.CreateSolidBrush(COLOR_GRAY);
  51. LoadConfig();
  52. if (m_bSoundful) LoadWaveSrc();
  53. InitGame();
  54. }
  56. CMineWnd::~CMineWnd()
  57. {
  58. FreeMines();
  59. FreeWaveSrc();
  60. SaveConfig();
  61. }
  63. BEGIN_MESSAGE_MAP(CMineWnd, CWnd)
  64. //{{AFX_MSG_MAP(CMineWnd)
  65. ON_WM_PAINT()
  66. ON_WM_SHOWWINDOW()
  67. ON_WM_TIMER()
  68. ON_WM_LBUTTONUP()
  69. ON_WM_RBUTTONUP()
  70. ON_WM_LBUTTONDOWN()
  71. ON_WM_RBUTTONDOWN()
  72. ON_WM_MOUSEMOVE()
  73. ON_COMMAND(IDM_START, OnMemuStart)
  74. ON_COMMAND(IDM_PRIMARY, OnMemuPrimary)
  75. ON_COMMAND(IDM_SECOND, OnMemuSecond)
  76. ON_COMMAND(IDM_ADVANCE, OnMemuAdvance)
  77. ON_COMMAND(IDM_CUSTOM, OnMemuCustom)
  78. ON_COMMAND(IDM_MARK, OnMemuMark)
  79. ON_COMMAND(IDM_COLOR, OnMemuColor)
  80. ON_COMMAND(IDM_SOUND, OnMemuSound)
  81. ON_COMMAND(IDM_EXIT, OnMemuExit)
  82. ON_COMMAND(IDM_HELP_LIST, OnMemuHelpList)
  83. ON_COMMAND(IDM_HELP_FIND, OnMemuHelpFind)
  84. ON_COMMAND(IDM_HELP_USE, OnMemuHelpUse)
  85. ON_COMMAND(IDM_ABOUT, OnMemuAbout)
  86. ON_WM_KEYDOWN()
  87. ON_WM_INITMENU()
  88. ON_WM_CLOSE()
  89. ON_COMMAND(IDM_HERO, OnMemuHero)
  90. ON_COMMAND(IDM_CHEAT, OnMemuCheat)
  91. //}}AFX_MSG_MAP
  92. END_MESSAGE_MAP()
  93. /////////////////////////////////////////////////////////////////////////////
  95. //
  96. //载入配置
  97. //
  98. void CMineWnd::LoadConfig()
  99. {
  100. //----------获取本地目录-------------*/
  101. char exeFullPath[MAX_PATH];
  102. CString strPath;
  103. GetModuleFileName(NULL, exeFullPath, MAX_PATH);
  104. strPath = CString(exeFullPath);
  105. strPath = strPath.Left(strPath.ReverseFind('\'));
  106. //-----------------------------------*/
  107. strPath += "\config.ini";
  109. char strPrimary[80];
  110. char strSecond[80];
  111. char strAdvance[80];
  113. m_uXNum = GetPrivateProfileInt("WINDOW","XNum", 10,strPath);
  114. m_uYNum = GetPrivateProfileInt("WINDOW","YNum", 10,strPath);
  116. m_uMineNum = GetPrivateProfileInt("MINE","MineNum", 10,strPath);
  117. m_uLevel = GetPrivateProfileInt("MINE","Level", 0,strPath);
  119. m_uPrimary = GetPrivateProfileInt("SCORE","Primary", 999,strPath);
  120. m_uSecond  = GetPrivateProfileInt("SCORE","Second", 999,strPath);
  121. m_uAdvance = GetPrivateProfileInt("SCORE","Advance", 999,strPath);
  123. GetPrivateProfileString("HOLDER","PrimaryHolder", "匿名",strPrimary,80,strPath);
  124. GetPrivateProfileString("HOLDER","SecondHolder", "匿名",strSecond,80,strPath);
  125. GetPrivateProfileString("HOLDER","AdvanceHolder", "匿名",strAdvance,80,strPath);
  127. m_szPrimary = strPrimary;
  128. m_szSecond = strSecond;
  129. m_szAdvance  = strAdvance;
  131. m_bMarkful = GetPrivateProfileInt("CONFIG","Markful", 0,strPath);
  132. m_bColorful = GetPrivateProfileInt("CONFIG","Colorful", 1,strPath);
  133. m_bSoundful = GetPrivateProfileInt("CONFIG","Soundful", 1,strPath);
  134. }
  136. //
  137. // 保存
  138. //
  139. void CMineWnd::SaveConfig()
  140. {
  142. //----------获取本地目录-------------*/
  143. char exeFullPath[MAX_PATH];
  144. CString strPath;
  145. GetModuleFileName(NULL, exeFullPath, MAX_PATH);
  146. strPath = CString(exeFullPath);
  147. strPath = strPath.Left(strPath.ReverseFind('\'));
  148. //-----------------------------------*/
  149. strPath += "\config.ini";
  152. //雷区行列数
  153.    CString strXNum,strYNum;
  154.    //雷数 选择级别
  155.    CString strMineNum,strLevel;
  156.    //记录保持分数
  157.    CString strPrimary,strSecond,strAdvance;
  158.    //记录保持者
  159.    CString strPrimaryHolder,strSecondHolder,strAdvanceHolder;
  160.    //其他配置
  161.    CString strMarkful,strColorful,strSoundful;
  162.    
  163.    
  164.    strXNum.Format("%u",m_uXNum);
  165.    strYNum.Format("%u",m_uYNum);
  166.    
  167.    strMineNum.Format("%u",m_uMineNum);
  168.    strLevel.Format("%u",m_uLevel);
  169.    
  170.    strPrimary.Format("%u",m_uPrimary);
  171.    strSecond.Format("%u",m_uSecond);
  172.    strAdvance.Format("%u",m_uAdvance);
  173.    
  174.    strPrimaryHolder.Format("%s",m_szPrimary);
  175.    strSecondHolder.Format("%s",m_szSecond);
  176.    strAdvanceHolder.Format("%s",m_szAdvance);
  177.    
  178.    strMarkful.Format("%d",m_bMarkful);
  179.    strColorful.Format("%d",m_bColorful);
  180.    strSoundful.Format("%d",m_bSoundful);
  181.    
  182.    
  183.    WritePrivateProfileString("WINDOW","XNum", strXNum,strPath);
  184.    WritePrivateProfileString("WINDOW","YNum", strYNum,strPath);
  185.    
  186.    WritePrivateProfileString("MINE","MineNum", strMineNum,strPath);
  187.    WritePrivateProfileString("MINE","Level", strLevel,strPath);
  188.    
  189.    WritePrivateProfileString("SCORE","Primary", strPrimary,strPath);
  190.    WritePrivateProfileString("SCORE","Second", strSecond,strPath);
  191.    WritePrivateProfileString("SCORE","Advance", strAdvance,strPath);
  192.    
  193.    WritePrivateProfileString("HOLDER","PrimaryHolder", strPrimaryHolder,strPath);
  194.    WritePrivateProfileString("HOLDER","SecondHolder", strSecondHolder,strPath);
  195.    WritePrivateProfileString("HOLDER","AdvanceHolder", strAdvanceHolder,strPath);
  196.    
  197.    WritePrivateProfileString("CONFIG","Markful", strMarkful,strPath);
  198.    WritePrivateProfileString("CONFIG","Colorful", strColorful,strPath);
  199.    WritePrivateProfileString("CONFIG","Soundful", strSoundful,strPath);
  200.    
  201. }
  203. //
  204. //载入位图
  205. //
  206. void CMineWnd::LoadBitmap()
  207. {
  208. if (m_bColorful)
  209. {
  210. m_clrDark = COLOR_DARK_GRAY;
  211. m_bmpMine.DeleteObject();
  212. m_bmpMine.LoadBitmap(IDB_MINE_COLOR);
  213. m_bmpNumber.DeleteObject();
  214. m_bmpNumber.LoadBitmap(IDB_NUM_COLOR);
  215. m_bmpButton.DeleteObject();
  216. m_bmpButton.LoadBitmap(IDB_BTN_COLOR);
  217. }
  218. else 
  219. {
  220. m_clrDark = COLOR_BLACK;
  221. m_bmpMine.DeleteObject();
  222. m_bmpMine.LoadBitmap(IDB_MINE_GRAY);
  223. m_bmpNumber.DeleteObject();
  224. m_bmpNumber.LoadBitmap(IDB_NUM_GRAY);
  225. m_bmpButton.DeleteObject();
  226. m_bmpButton.LoadBitmap(IDB_BTN_GRAY);
  227. }
  228. }
  230. //
  231. //  游戏的初始化
  232. //
  233. void CMineWnd::InitGame()
  234. {
  235. //位图的初始化
  236. LoadBitmap();
  237. m_nLeaveNum = m_uMineNum;
  238. m_uSpendTime = 0;
  239. m_uBtnState = BUTTON_NORMAL;
  240. m_uGameState = GS_WAIT;
  242. if (m_uTimer) 
  243. {
  244. KillTimer(ID_TIMER_EVENT);
  245. m_uTimer = 0;
  246. }
  247. m_pNewMine = NULL;
  248. m_pOldMine = NULL;
  250. FreeMines();
  251. //初始化地图
  252. for (UINT i = 0; i<m_uYNum; i++) 
  253. {
  254. for (UINT j = 0; j<m_uXNum; j++)
  255. {
  256. m_pMines[i][j].uRow = i;
  257. m_pMines[i][j].uCol = j;
  258. m_pMines[i][j].uState = STATE_NORMAL;
  259. m_pMines[i][j].uAttrib = ATTRIB_EMPTY;
  260. m_pMines[i][j].uOldState = STATE_NORMAL;
  261. }
  262. }
  263. }
  265. //
  266. // 布雷
  267. //
  268. void CMineWnd::LayMines(UINT row, UINT col)
  269. {
  270. //埋下随机种子
  271. srand( (unsigned)time( NULL ) );
  272. UINT i, j;
  274. for(UINT index = 0; index < m_uMineNum;) 
  275. {
  276. //取随即数
  277. i = rand() % m_uYNum;
  278. j = rand() % m_uXNum;
  280. if (i == row && j == col) continue;
  281. if(m_pMines[i][j].uAttrib != ATTRIB_MINE) 
  282. {
  283. m_pMines[i][j].uAttrib = ATTRIB_MINE;//修改属性为雷
  285. index++;
  286. }
  287. }
  288. }
  290. //
  291. //雷方块拓展(对于周围无雷的空白区域)
  292. //
  293. void CMineWnd::ExpandMines(UINT row, UINT col)
  294. {
  295. UINT i, j;
  296. UINT minRow = (row == 0) ? 0 : row - 1;
  297. UINT maxRow = row + 2;
  298. UINT minCol = (col == 0) ? 0 : col - 1;
  299. UINT maxCol = col + 2;
  300. UINT around = GetAroundNum(row, col);
  303. m_pMines[row][col].uState = 15 - around;
  304. m_pMines[row][col].uOldState = 15 - around;
  306. // “打开”该区域，重绘
  307. DrawSpecialMine(row, col);
  309. //对周围一个雷都没有的空白区域
  310. if (around == 0)
  311. {
  312. for (i = minRow; i < maxRow; i++) 
  313. {
  314. for (j = minCol; j < maxCol; j++) 
  315. {//对于周围可以拓展的区域进行的规拓展
  316. if (!(i == row && j == col) && 
  317. m_pMines[i][j].uState == STATE_NORMAL
  318. && m_pMines[i][j].uAttrib != ATTRIB_MINE) 
  319. {
  321. if (!IsInMineArea(i, j)) continue;
  322. ExpandMines(i, j);
  323. }
  324. }
  325. }
  326. }
  327. }
  330. //
  331. //  获取某个小方块区域相邻8个区域的雷个数
  332. //
  333. UINT CMineWnd::GetAroundNum(UINT row, UINT col)
  334. {
  335. UINT i, j;
  336. UINT around = 0;
  337. UINT minRow = (row == 0) ? 0 : row - 1;
  338. UINT maxRow = row + 2;
  339. UINT minCol = (col == 0) ? 0 : col - 1;
  340. UINT maxCol = col + 2;
  342. for (i = minRow; i < maxRow; i++) 
  343. {
  344. for (j = minCol; j < maxCol; j++)
  345. {
  346. if (!IsInMineArea(i, j)) continue;
  347. if (m_pMines[i][j].uAttrib == ATTRIB_MINE) around++;
  348. }
  349. }
  350. return around;
  351. }
  353. //
  354. //  获取某个小方块区域相邻8个区域的已标志状态数
  355. //
  356. UINT CMineWnd::GetAroundFlags(UINT row, UINT col)
  357. {
  358. UINT i, j;
  359. UINT flags = 0;
  360. UINT minRow = (row == 0) ? 0 : row - 1;
  361. UINT maxRow = row + 2;
  362. UINT minCol = (col == 0) ? 0 : col - 1;
  363. UINT maxCol = col + 2;
  365. for (i = minRow; i < maxRow; i++) 
  366. {
  367. for (j = minCol; j < maxCol; j++)
  368. {
  369. if (!IsInMineArea(i, j)) continue;
  370. if (m_pMines[i][j].uState == STATE_FLAG) flags++;
  371. }
  372. }
  373. return flags;
  374. }
  375. //
  376. //判断是否为雷
  377. //
  378. BOOL CMineWnd::IsMine(UINT row, UINT col)
  379. {
  380. return (m_pMines[row][col].uAttrib == ATTRIB_MINE);
  381. }
  383. //判断是否在雷区域
  384. BOOL CMineWnd::IsInMineArea(UINT row, UINT col)
  385. {
  386. return (row >= 0 && row < m_uYNum && col >= 0 && col < m_uXNum);
  387. }
  389. //
  390. //  失败处理
  391. //
  392. void CMineWnd::Dead(UINT row, UINT col)
  393. {
  394. //按钮所在的区域
  395. CRect rcBtn(m_uBtnRect[1], 15, m_uBtnRect[2], 39);
  396. //雷区所在的区域
  397. CRect rcMineArea(MINE_AREA_LEFT, MINE_AREA_TOP, 
  398. MINE_AREA_LEFT + m_uXNum * MINE_WIDTH, 
  399. MINE_AREA_TOP + m_uYNum * MINE_HEIGHT);
  401. UINT i, j;
  403. if (m_pMines[row][col].uAttrib == ATTRIB_MINE) 
  404. {//失败－－点中雷
  405. for (i = 0; i < m_uYNum; i++)
  406. {
  407. for (j = 0; j < m_uXNum; j++)
  408. {
  409. m_pMines[row][col].uState = STATE_BLAST;
  410. m_pMines[row][col].uOldState = STATE_BLAST;
  411. if (m_pMines[i][j].uAttrib == ATTRIB_MINE
  412. && m_pMines[i][j].uState != STATE_FLAG) 
  413. {
  414. m_pMines[i][j].uState = STATE_MINE;
  415. m_pMines[i][j].uOldState = STATE_MINE;
  416. }
  417. }
  418. }
  419. }
  420. else {//失败－－错误雷
  421. for (i = 0; i < m_uYNum; i++)
  422. {
  423. for (j = 0; j < m_uXNum; j++) 
  424. {
  425. m_pMines[row][col].uState = STATE_ERROR;
  426. m_pMines[row][col].uOldState = STATE_ERROR;
  427. if (m_pMines[i][j].uAttrib == ATTRIB_MINE
  428. && m_pMines[i][j].uState != STATE_FLAG)
  429. {
  430. m_pMines[i][j].uState = STATE_MINE;
  431. m_pMines[i][j].uOldState = STATE_MINE;
  432. }
  433. }
  434. }
  435. }
  436. //失败处理
  437. InvalidateRect(rcMineArea);
  438. m_uBtnState = BUTTON_DEAD;
  439. InvalidateRect(rcBtn);
  440. m_uGameState = GS_DEAD;
  442. if (m_uTimer != 0) 
  443. {//将定时器去激活
  444. KillTimer(ID_TIMER_EVENT);
  445. m_uTimer = 0;
  446. }
  448. if (m_bSoundful) 
  449. {//失败声音播放
  450. sndPlaySound((LPCTSTR)LockResource(m_pSndDead), SND_MEMORY | SND_ASYNC | SND_NODEFAULT);
  451. }
  452. }
  454. //
  455. //  胜利判断并处理
  456. //
  457. BOOL CMineWnd::Victory()
  458. {
  459. UINT i, j;
  460. CRect rcBtn(m_uBtnRect[1], 15, m_uBtnRect[2], 39);
  462. // 检测是否胜利
  463. for (i = 0; i < m_uYNum; i++)
  464. {
  465. for (j = 0; j < m_uXNum; j++) 
  466. {
  467. if (m_pMines[i][j].uState == STATE_NORMAL) return FALSE;
  468. if (m_pMines[i][j].uState == STATE_DICEY) return FALSE;
  469. }
  470. }
  472. //胜利则作胜利处理
  473. m_uBtnState = BUTTON_VICTORY;
  474. m_uGameState = GS_VICTORY;
  475. Invalidate();
  476. if (m_uTimer != 0) 
  477. {//将定时器去激活
  478. KillTimer(ID_TIMER_EVENT);
  479. m_uTimer = 0;
  480. }
  481. //胜利声音
  482. if (m_bSoundful)
  483. {
  484. sndPlaySound((LPCTSTR)LockResource(m_pSndVictory), 
  485. SND_MEMORY | SND_ASYNC | SND_NODEFAULT);
  486. }
  488. //英雄榜
  489. UINT uRecord;
  490. if (m_uLevel == LEVEL_PRIMARY) uRecord = m_uPrimary;
  491. else if (m_uLevel == LEVEL_SECONDRY) uRecord = m_uSecond;
  492. else if (m_uLevel == LEVEL_ADVANCE) uRecord = m_uAdvance;
  493. if (uRecord > m_uSpendTime) 
  494. {
  495. CDlgNewRecord dlg;
  496. dlg.SetLevel(m_uLevel);
  497. dlg.DoModal();
  498. switch(m_uLevel)
  499. {
  500. case LEVEL_PRIMARY:
  501. m_uPrimary = m_uSpendTime;
  502. m_szPrimary = dlg.GetName();
  503. break;
  504. case LEVEL_SECONDRY:
  505. m_uSecond = m_uSpendTime;
  506. m_szSecond = dlg.GetName();
  507. break;
  508. case LEVEL_ADVANCE:
  509. m_uAdvance = m_uSpendTime;
  510. m_szAdvance = dlg.GetName();
  511. break;
  512. case LEVEL_CUSTOM:
  513. return TRUE;
  514. default: 
  515. break;
  516. }
  517. OnMemuHero();
  518. }
  520. return TRUE;
  521. }
  522. //
  523. // 鼠标右键，根据原先不同的标记作状态循环修改
  524. // 以便用户可以修改其原先标志
  525. //
  526. void CMineWnd::OnLRBtnDown(UINT row, UINT col)
  527. {
  528. UINT i, j;
  529. UINT minRow = (row == 0) ? 0 : row - 1;
  530. UINT maxRow = row + 2;
  531. UINT minCol = (col == 0) ? 0 : col - 1;
  532. UINT maxCol = col + 2;
  534. for (i = minRow; i < maxRow; i++) 
  535. {
  536. for (j = minCol; j < maxCol; j++) 
  537. {
  538. if (!IsInMineArea(i, j)) continue;
  539. // if (i == row && j == col) continue;
  540. if (m_pMines[i][j].uState == STATE_NORMAL) 
  541. {
  542. m_pMines[i][j].uState = STATE_EMPTY;
  543. }
  544. else if (m_pMines[i][j].uState == STATE_DICEY)
  545. {
  546. m_pMines[i][j].uState = STATE_DICEY_DOWN;
  547. }
  548. }
  549. }
  550. }
  552. void CMineWnd::OnLRBtnUp(UINT row, UINT col)
  553. {
  554. UINT i, j;
  555. UINT minRow = (row == 0) ? 0 : row - 1;
  556. UINT maxRow = row + 2;
  557. UINT minCol = (col == 0) ? 0 : col - 1;
  558. UINT maxCol = col + 2;
  560. for (i = minRow; i < maxRow; i++) 
  561. {
  562. for (j = minCol; j < maxCol; j++)
  563. {
  564. if (!IsInMineArea(i, j)) continue;
  565. // if (i == row && j == col) continue;
  566. if (m_pMines[i][j].uOldState == STATE_NORMAL) 
  567. {
  568. m_pMines[i][j].uState = STATE_NORMAL;
  569. }
  570. else if (m_pMines[i][j].uOldState == STATE_DICEY) 
  571. {
  572. m_pMines[i][j].uState = STATE_DICEY;
  573. }
  574. }
  575. }
  576. // Invalidate();
  577. }
  580. //展开拓展周围8个方向
  581. void CMineWnd::OpenAround(UINT row, UINT col)
  582. {
  583. //如果周围相邻的标志雷数 != 周围相邻的雷数 则返回
  584. if (GetAroundFlags(row, col) != GetAroundNum(row, col)) return;
  586. UINT i, j;
  587. UINT around = 0;
  588. UINT minRow = (row == 0) ? 0 : row - 1;
  589. UINT maxRow = row + 2;
  590. UINT minCol = (col == 0) ? 0 : col - 1;
  591. UINT maxCol = col + 2;
  593. for (i = minRow; i < maxRow; i++) 
  594. {
  595. for (j = minCol; j < maxCol; j++) 
  596. {
  597. if (!IsInMineArea(i, j)) continue;
  598. if (m_pMines[i][j].uState == STATE_NORMAL) 
  599. {//如果该区域为正常区域
  601. //拓展该雷区
  602. ExpandMines(i, j);
  603. around = GetAroundNum(i, j);
  604. m_pMines[i][j].uState = 15 - around;
  605. m_pMines[i][j].uOldState = 15 - around;
  606. }
  607. }
  608. }
  610. // 判断是否胜利，是则将地图中所有雷标识出来
  611. if (Victory())
  612. {
  613. for (i = 0; i < m_uYNum; i++) 
  614. {
  615. for (j = 0; j < m_uXNum; j++)
  616. {
  617. if (m_pMines[i][j].uAttrib == ATTRIB_MINE)
  618. {
  619. m_pMines[i][j].uState = STATE_FLAG;
  620. m_pMines[i][j].uOldState = STATE_FLAG;
  621. }
  622. }
  623. }
  624. m_nLeaveNum = 0;
  625. Invalidate();
  626. }
  627. }
  629. BOOL CMineWnd::ErrorAroundFlag(UINT row, UINT col)
  630. {
  631. //如果周围相邻的标志雷数 != 周围相邻的雷数 则返回
  632. if (GetAroundFlags(row, col) != GetAroundNum(row, col)) return FALSE;
  634. UINT i, j;
  635. UINT minRow = (row == 0) ? 0 : row - 1;
  636. UINT maxRow = row + 2;
  637. UINT minCol = (col == 0) ? 0 : col - 1;
  638. UINT maxCol = col + 2;
  640. for (i = minRow; i < maxRow; i++) 
  641. {
  642. for (j = minCol; j < maxCol; j++) 
  643. {
  644. if (!IsInMineArea(i, j)) continue;
  645. if (m_pMines[i][j].uState == STATE_FLAG)
  646. {
  647. if (m_pMines[i][j].uAttrib != ATTRIB_MINE)
  648. {
  649. Dead(i, j);
  650. return TRUE;
  651. }
  652. }
  653. }
  654. }
  656. return FALSE;
  657. }
  659. void CMineWnd::OpenByCheat()
  660. {
  661. UINT i, j;
  662. for (i = 0; i < m_uYNum; i++)
  663. {
  664. for (j = 0; j < m_uXNum; j++)
  665. {
  666. if (m_pMines[i][j].uState == STATE_FLAG) continue;
  667. OpenAround(i, j);
  668. }
  669. }
  670. }
  672. void CMineWnd::FreeMines()
  673. {
  674. // if (m_pMines) {
  675. // delete[] m_pMines;
  676. // m_pMines = NULL;
  677. // }
  678. // for (UINT row = 0; row<m_uYNum; row++) {
  679. // if (m_pMines[row]) {
  680. // delete []m_pMines[m_uXNum];
  681. // delete m_pMines[row];
  682. // }
  683. // }
  684. }
  686. void CMineWnd::SizeWindow( void )
  687. {
  688. UINT uWidth = DEFAULT_FRAME_X + m_uXNum * MINE_WIDTH +
  689. LINE_WIDTH_0 * 3 + SIDE_WIDTH_0 + SIDE_WIDTH_1; 
  690. UINT uHeight = DEFAULT_FRAME_Y + m_uYNum * MINE_HEIGHT + 
  691. LINE_WIDTH_0 * 3 + SIDE_WIDTH_0 * 2 + SIDE_WIDTH_1 + SHELL_S_H;
  692. SetWindowPos(&wndTopMost, 0, 0, uWidth, uHeight, 
  693. SWP_NOZORDER | SWP_NOMOVE | SWP_NOCOPYBITS); // SWP_NOCOPYBITS does not do function？？？
  695. GetClientRect(&m_rcClient);
  696. // Button Position
  697. m_uBtnRect[0] = m_rcClient.right / 2 - 12; // the left side of the start(state) button without 3d border
  698. m_uBtnRect[1] = m_rcClient.right / 2 - 13; // the left side of the start(state) button with 3d border
  699. m_uBtnRect[2] = m_rcClient.right / 2 + 12; // the right side of the start(state) button 
  701. // Number Position
  702. m_uNumRect[0] = m_rcClient.right - 55; // the left side of the spend time rect with 3d border
  703. m_uNumRect[1] = m_rcClient.right - 15; // the right side of the spend time rect
  704. m_uNumRect[2] = m_rcClient.right - 54; // the left side of the spend time rect without 3d border
  705. // m_uNumRect[3] = m_rcClient.right - 41;
  706. // m_uNumRect[4] = m_rcClient.right - 28;
  708. // Shell Position
  709. m_uShellRcX[0] = m_rcClient.right; //
  710. m_uShellRcX[1] = m_rcClient.right - 14; // the width of the small(big) shell
  712. m_uShellRcY[0] = m_rcClient.bottom; // 
  713. m_uShellRcY[1] = m_rcClient.bottom - SHELL_L_START_Y - 5; // the height of the big shell
  714. }
  716. //
  717. // 绘制笑脸按钮图
  718. //
  719. void CMineWnd::DrawButton(CPaintDC &dc)
  720. {
  721. CDC cdc;
  722. cdc.CreateCompatibleDC(&dc);
  723. cdc.SelectObject(m_bmpButton);
  724. dc.StretchBlt(m_uBtnRect[0], 16, 24, 24, &cdc, 0, 24 * m_uBtnState, 24, 24, SRCCOPY);
  726. dc.Draw3dRect(m_uBtnRect[1], 15, 26, 26, m_clrDark, m_clrDark);
  728. }
  730. //
  731. // 绘制数字
  732. //
  733. void CMineWnd::DrawNumber(CPaintDC &dc)
  734. {
  735. CDC dcMemory;
  736. dcMemory.CreateCompatibleDC(&dc);
  737. dcMemory.SelectObject(m_bmpNumber);
  739. dc.Draw3dRect(16, 15, 41, 25, m_clrDark, COLOR_WHITE);
  740. dc.Draw3dRect(m_uNumRect[0], 15, 41, 25, m_clrDark, COLOR_WHITE);
  741. int num;
  743. // draw remaining mine numbers
  744. num = (m_nLeaveNum<0) ? 11 : m_nLeaveNum/100;
  745. dc.StretchBlt(17, 16, 13, 23, &dcMemory, 0, 276-23*(num+1), 13, 23, SRCCOPY);
  746. num = (m_nLeaveNum < 0) ? -(m_nLeaveNum-num*100)/10 : (m_nLeaveNum-num*100)/10;
  747. dc.StretchBlt(30, 16, 13, 23, &dcMemory, 0, 276-23*(num+1), 13, 23, SRCCOPY);
  748. num = (m_nLeaveNum<0) ? -m_nLeaveNum%10 : m_nLeaveNum%10;
  749. dc.StretchBlt(43, 16, 13, 23, &dcMemory, 0, 276-23*(num+1), 13, 23, SRCCOPY);
  751. // draw take seconds
  752. num = m_uSpendTime / 100;
  753. dc.StretchBlt(m_uNumRect[0], 16, 13, 23, &dcMemory, 0, 276-23*(num+1), 13, 23, SRCCOPY);
  754. num = (m_uSpendTime-num*100)/10;
  755. dc.StretchBlt(m_uNumRect[0] + 13, 16, 13, 23, &dcMemory, 0, 276-23*(num+1), 13, 23, SRCCOPY);
  756. num = m_uSpendTime%10;
  757. dc.StretchBlt(m_uNumRect[0]+26, 16, 13, 23, &dcMemory, 0, 276-23*(num+1), 13, 23, SRCCOPY);
  758. }
  760. //
  761. // 绘制外壳
  762. //
  763. void CMineWnd::DrawShell(CPaintDC &dc)
  764. {
  765. // 绘画2条白条
  766. dc.FillSolidRect(0, 0, m_uShellRcX[0], LINE_WIDTH_0, COLOR_WHITE);
  767. dc.FillSolidRect(0, 0, LINE_WIDTH_0, m_uShellRcY[0], COLOR_WHITE);
  769. // 画小的外壳
  770. dc.Draw3dRect(SHELL_S_START_X, SHELL_S_START_Y, 
  771. m_uShellRcX[1], SHELL_S_H, m_clrDark, COLOR_WHITE);
  772. dc.Draw3dRect(SHELL_S_START_X + 1, SHELL_S_START_Y + 1, 
  773. m_uShellRcX[1] - 2, SHELL_S_H - 2, m_clrDark, COLOR_WHITE);
  775. // 画大的外壳
  776. dc.Draw3dRect(SHELL_L_START_X, SHELL_L_START_Y,
  777. m_uShellRcX[1], m_uShellRcY[1], m_clrDark, COLOR_WHITE);
  778. dc.Draw3dRect(SHELL_L_START_X + 1, SHELL_L_START_Y + 1,
  779. m_uShellRcX[1] - 2, m_uShellRcY[1] - 2, m_clrDark, COLOR_WHITE);
  780. dc.Draw3dRect(SHELL_L_START_X + 2, SHELL_L_START_Y + 2, 
  781. m_uShellRcX[1] - 4, m_uShellRcY[1] - 4, m_clrDark, COLOR_WHITE);
  782. }
  784. //
  785. // 绘制雷区
  786. //
  787. void CMineWnd::DrawMineArea(CPaintDC &dc)
  788. {
  789. CDC dcMemory; //用作内存设备
  790. dcMemory.CreateCompatibleDC(&dc); //使得这个设备与dc兼容
  791. dcMemory.SelectObject(m_bmpMine); //将内存设备与位图资源关联
  793. for (UINT i = 0; i<m_uYNum; i++) 
  794. {
  795. for (UINT j = 0; j<m_uXNum; j++) 
  796. {//根据[i][j]区域的雷方块状态拷贝相应的图像到[i][j]雷区的特定区域
  797. dc.StretchBlt(MINEAREA_FRAME_X+16*j, MINEAREA_FRAME_Y+16*i, 
  798. 16, 16, &dcMemory, 0, 16*m_pMines[i][j].uState, 16, 16, SRCCOPY);
  799. }
  800. }
  801. }
  803. //
  804. // 绘制按下扫雷后的数字
  805. //
  806. void CMineWnd::DrawDownNum(MINEWND* mine, UINT num)
  807. {
  808. mine->uState = 15 - num;
  809. mine->uOldState = 15 - num;
  810. CRect rcMine(mine->uCol * 16, mine->uRow * 16, (mine->uCol+1) *16, (mine->uRow+1) * 16);
  811. InvalidateRect(rcMine);
  812. }
  814. //重新绘制雷区域的某个方块
  815. void CMineWnd::DrawSpecialMine(UINT row, UINT col)
  816. {
  817. CRect rcMine(col * 16, row * 16, (col+1) * 16, (row+1) * 16);
  818. InvalidateRect(rcMine);
  819. }
  821. //
  822. //  获取体图中(x,y)区域的雷信息
  823. //
  824. MINEWND* CMineWnd::GetMine(long x, long y)
  825. {
  826. //保证参数合格
  827. if (x < MINEAREA_FRAME_X || y < MINEAREA_FRAME_Y) 
  828. {
  829. return NULL;
  830. }
  832. //根据坐标值算出该小方块所在地图的行和列
  833. UINT uCol = (UINT)(x-MINEAREA_FRAME_X) / 16;
  834. UINT uRow = (UINT)(y-MINEAREA_FRAME_Y) / 16;
  835. //返回该区域的雷信息
  836. return &m_pMines[uRow][uCol];
  837. }
  839. void CMineWnd::SetCheckedLevel()
  840. {
  841. if (m_pSubMenu)
  842. {
  843. m_pSubMenu->CheckMenuItem(IDM_PRIMARY, MF_UNCHECKED | MF_BYCOMMAND);
  844. m_pSubMenu->CheckMenuItem(IDM_SECOND, MF_UNCHECKED | MF_BYCOMMAND);
  845. m_pSubMenu->CheckMenuItem(IDM_ADVANCE, MF_UNCHECKED | MF_BYCOMMAND);
  846. m_pSubMenu->CheckMenuItem(IDM_CUSTOM, MF_UNCHECKED | MF_BYCOMMAND);
  847. switch(m_uLevel)
  848. {
  849. case LEVEL_PRIMARY:
  850. m_pSubMenu->CheckMenuItem(IDM_PRIMARY, MF_CHECKED | MF_BYCOMMAND);
  851. break;
  852. case LEVEL_SECONDRY:
  853. m_pSubMenu->CheckMenuItem(IDM_SECOND, MF_CHECKED | MF_BYCOMMAND);
  854. break;
  855. case LEVEL_ADVANCE:
  856. m_pSubMenu->CheckMenuItem(IDM_ADVANCE, MF_CHECKED | MF_BYCOMMAND);
  857. break;
  858. case LEVEL_CUSTOM:
  859. m_pSubMenu->CheckMenuItem(IDM_CUSTOM, MF_CHECKED | MF_BYCOMMAND);
  860. break;
  861. default: 
  862. break;
  863. }
  864. }
  865. }
  867. void CMineWnd::SetCheckedMark()
  868. {
  869. if (m_pSubMenu) {
  870. if (m_bMarkful) {
  871. m_pSubMenu->CheckMenuItem(IDM_MARK, MF_CHECKED | MF_BYCOMMAND);
  872. }
  873. else {
  874. m_pSubMenu->CheckMenuItem(IDM_MARK, MF_UNCHECKED | MF_BYCOMMAND);
  875. }
  876. }
  877. }
  879. void CMineWnd::SetCheckedColor()
  880. {
  881. if (m_pSubMenu)
  882. {
  883. if (m_bColorful)
  884. {
  885. m_pSubMenu->CheckMenuItem(IDM_COLOR, MF_CHECKED | MF_BYCOMMAND);
  886. }
  887. else 
  888. {
  889. m_pSubMenu->CheckMenuItem(IDM_COLOR, MF_UNCHECKED | MF_BYCOMMAND);
  890. }
  891. }
  892. }
  894. void CMineWnd::SetCheckedSound()
  895. {
  896. if (m_pSubMenu)
  897. {
  898. if (m_bSoundful) 
  899. {
  900. m_pSubMenu->CheckMenuItem(IDM_SOUND, MF_CHECKED | MF_BYCOMMAND);
  901. }
  902. else 
  903. {
  904. m_pSubMenu->CheckMenuItem(IDM_SOUND, MF_UNCHECKED | MF_BYCOMMAND);
  905. }
  906. }
  907. }
  909. void CMineWnd::SetCheckedCheat()
  910. {
  911. if (m_pSubMenu)
  912. {
  913. // if (m_bCheat) 
  914. // {
  915. // m_pSubMenu->CheckMenuItem(IDM_CHEAT, MF_CHECKED | MF_BYCOMMAND);
  916. // }
  917. // else 
  918. // {
  919. m_pSubMenu->CheckMenuItem(IDM_CHEAT, MF_UNCHECKED | MF_BYCOMMAND);
  920. // }
  921. }
  922. }
  924. void CMineWnd::LoadWaveSrc()
  925. {
  926. HMODULE hMdl;
  927. hMdl = AfxGetResourceHandle();
  928. HRSRC hSrc;
  930. hSrc = FindResource(hMdl, MAKEINTRESOURCE(IDR_WAVE_DEAD), _T("WAVE"));
  931. m_pSndDead = LoadResource(hMdl, hSrc);
  932. hSrc = FindResource(hMdl, MAKEINTRESOURCE(IDR_WAVE_VICTORY), _T("WAVE"));
  933. m_pSndVictory = LoadResource(hMdl, hSrc);
  934. hSrc = FindResource(hMdl, MAKEINTRESOURCE(IDR_WAVE_CLOCK), _T("WAVE"));
  935. m_pSndClock = LoadResource(hMdl, hSrc);
  936. }
  938. void CMineWnd::FreeWaveSrc()
  939. {
  940. if (m_pSndDead)
  941. {
  942. FreeResource(m_pSndDead);
  943. m_pSndDead = NULL;
  944. }
  945. if (m_pSndVictory) 
  946. {
  947. FreeResource(m_pSndVictory);
  948. m_pSndVictory = NULL;
  949. }
  950. if (m_pSndClock)
  951. {
  952. FreeResource(m_pSndClock);
  953. m_pSndClock = NULL;
  954. }
  955. }
  957. void CMineWnd::ResetRecord()
  958. {
  959. m_uPrimary = DEFAULT_RECORD;
  960. m_szPrimary = DEFAULT_HOLDER;
  961. m_uSecond= DEFAULT_RECORD;
  962. m_szSecond = DEFAULT_HOLDER;
  963. m_uAdvance = DEFAULT_RECORD;
  964. m_szAdvance = DEFAULT_HOLDER;
  965. }
  967. void CMineWnd::SetCustom(UINT xNum, UINT yNum, UINT mNum)
  968. {
  969. m_uXNum = xNum;
  970. m_uYNum = yNum;
  971. m_uMineNum = mNum;
  972. }
  974. void CMineWnd::OnPaint() 
  975. {
  977. CPaintDC dc(this);    // 用以屏幕显示的设备
  978. CDC dcMemory;  // 内存设备
  980. CBitmap bitmap;
  982. if (!dc.IsPrinting()) 
  983. {
  985. // 与dc设备兼容
  986. if (dcMemory.CreateCompatibleDC(&dc))
  987. {
  988. // 使得bitmap与实际显示的设备兼容
  989. if (bitmap.CreateCompatibleBitmap(&dc, m_rcClient.right, m_rcClient.bottom))
  990. {
  991. // 内存设备选择物件－位图
  992. dcMemory.SelectObject(&bitmap);
  993. //绘制背景框
  994. dcMemory.FillRect(&m_rcClient, &m_brsBG);
  996. DrawButton((CPaintDC&) dcMemory);//笑脸按钮绘图
  997. DrawNumber((CPaintDC&) dcMemory);//文字绘图(计时器文字和剩余雷数文字)
  998. DrawShell((CPaintDC&) dcMemory);//3D效果外壳绘图
  999. DrawMineArea((CPaintDC&) dcMemory);//雷区绘图
  1002. // 将内存设备的内容拷贝到实际屏幕显示的设备
  1003. dc.BitBlt(m_rcClient.left, m_rcClient.top, m_rcClient.right, m_rcClient.bottom, &dcMemory, 0, 0, SRCCOPY);
  1004. bitmap.DeleteObject();
  1005. }
  1006. }
  1007. }
  1008. }
  1010. void CMineWnd::OnShowWindow(BOOL bShow, UINT nStatus) 
  1011. {
  1012. SizeWindow();
  1013. CWnd::OnShowWindow(bShow, nStatus);
  1014. }
  1016. void CMineWnd::OnTimer(UINT nIDEvent) 
  1017. {
  1018. if (nIDEvent == ID_TIMER_EVENT)
  1019. {
  1020. if (m_bSoundful) 
  1021. {
  1022. sndPlaySound((LPCTSTR)LockResource(m_pSndClock), SND_MEMORY | SND_ASYNC | SND_NODEFAULT);
  1023. }
  1024. m_uSpendTime++;
  1025. CRect rcNum(m_uNumRect[0], 15, m_uNumRect[1], 39);
  1026. // InvalidateRect(rcNum);
  1027. Invalidate();
  1028. if (m_uSpendTime >= DEFAULT_RECORD) 
  1029. {
  1030. KillTimer(ID_TIMER_EVENT);
  1031. m_uTimer = 0;
  1032. }
  1033. }
  1035. CWnd::OnTimer(nIDEvent);
  1036. }
  1038. void CMineWnd::OnLButtonDown(UINT nFlags, CPoint point) 
  1039. {
  1040. //按钮所在的区域
  1041. CRect rcBtn(m_uBtnRect[1], 15, m_uBtnRect[2], 39);
  1042. //雷区所在的区域
  1043. CRect rcMineArea(MINE_AREA_LEFT, MINE_AREA_TOP, 
  1044. MINE_AREA_LEFT + m_uXNum * MINE_WIDTH, MINE_AREA_TOP + m_uYNum * MINE_HEIGHT);
  1046. SetCapture(); // capture the mouse cursor
  1047. m_bClickBtn = FALSE;
  1048. m_bLRBtnDown = FALSE;
  1050. if (rcBtn.PtInRect(point)) 
  1051. {// click in the button area
  1052. m_bClickBtn = TRUE;
  1053. m_uBtnState = BUTTON_DOWN;
  1054. InvalidateRect(rcBtn);
  1055. }
  1056. else if (rcMineArea.PtInRect(point))
  1057. {// click in the mine area
  1058. // change mine state by gamestate
  1059. switch(m_uGameState) 
  1060. {
  1061. case GS_WAIT: case GS_RUN:
  1062. m_pNewMine = GetMine(point.x, point.y);
  1063. if (!m_pNewMine) return;
  1064. if (m_pNewMine->uState == STATE_NORMAL)
  1065. {
  1066. m_pNewMine->uState = STATE_EMPTY;
  1067. }
  1068. if (m_pNewMine->uState == STATE_DICEY)
  1069. {
  1070. m_pNewMine->uState = STATE_DICEY_DOWN;
  1071. }
  1072. m_pOldMine = m_pNewMine;
  1073. break;
  1074. case GS_DEAD: case GS_VICTORY:
  1075. return;
  1076. break;
  1077. default :
  1078. break;
  1079. }
  1080. m_uBtnState = BUTTON_CLICK;
  1081. InvalidateRect(rcBtn);
  1082. // both of the left button and the right button are pushing down 
  1083. if (nFlags == (MK_LBUTTON | MK_RBUTTON)) 
  1084. {
  1085. m_bLRBtnDown = TRUE;
  1086. OnLRBtnDown(m_pOldMine->uRow, m_pOldMine->uCol);
  1087. }
  1088. InvalidateRect(rcMineArea);
  1089. }
  1090. else 
  1091. { // click in other area
  1092. if (m_uGameState == GS_WAIT || m_uGameState == GS_RUN)
  1093. {
  1094. m_uBtnState = BUTTON_CLICK;
  1095. InvalidateRect(rcBtn);
  1096. }
  1097. }
  1099. CWnd::OnLButtonDown(nFlags, point);
  1100. }
  1102. void CMineWnd::OnLButtonUp(UINT nFlags, CPoint point) 
  1103. {
  1104. //笑脸图按钮所在的区域
  1105. CRect rcBtn(m_uBtnRect[1], 15, m_uBtnRect[2], 39);
  1106. //雷区所在的区域
  1107. CRect rcMineArea(MINE_AREA_LEFT, MINE_AREA_TOP, 
  1108. MINE_AREA_LEFT + m_uXNum * MINE_WIDTH, 
  1109. MINE_AREA_TOP + m_uYNum * MINE_HEIGHT);
  1111. if (rcBtn.PtInRect(point)) 
  1112. {// 点击笑脸图
  1114. Invalidate();
  1115. InitGame();
  1116. }
  1117. else if (rcMineArea.PtInRect(point)) 
  1118. {//点击雷区域
  1119. CString value;
  1120. UINT around = 0;
  1122. //根据不同的游戏状态作处理
  1123. switch(m_uGameState) 
  1124. {
  1125. //游戏进行状态
  1126. case GS_WAIT: case GS_RUN:
  1127. // first get the MINEWND which if pushing down
  1128. m_pOldMine = GetMine(point.x, point.y);
  1129. if (!m_pOldMine) 
  1130. {
  1131. ReleaseCapture();
  1132. return;
  1133. }
  1134. // do normal process
  1135. // judge whether the lr button are both pushed down
  1136. //检测判断当前状态是否为左右鼠标同时按下
  1137. if (m_bLRBtnDown) 
  1138. {
  1139. m_bLRBtnDown = FALSE;
  1140. OnLRBtnUp(m_pOldMine->uRow, m_pOldMine->uCol);
  1141. if (m_uGameState == GS_WAIT)
  1142. {
  1143. m_uBtnState = BUTTON_NORMAL;
  1144. Invalidate();
  1145. ReleaseCapture();
  1146. return;
  1147. }
  1148. // if the around flags number equal to the around mines number, expand.
  1149. //假若周围已经标识的雷＝周围真正的雷数，拓展
  1150. if (m_pOldMine->uState != STATE_FLAG)
  1151. {
  1152. OpenAround(m_pOldMine->uRow, m_pOldMine->uCol);
  1153. }
  1154. // check whether the MINEWND around the special MINEWND is a mine, if it is then dead.
  1155. if (ErrorAroundFlag(m_pOldMine->uRow, m_pOldMine->uCol))
  1156. {
  1158. Dead(m_pOldMine->uRow, m_pOldMine->uCol);
  1159. ReleaseCapture();
  1160. return;
  1161. }
  1162. }
  1163. else 
  1164. {
  1165. // start the game, init the mines area
  1166. //如果游戏尚未开始，点击左键启动游戏
  1167. if (m_uGameState == GS_WAIT) 
  1168. {
  1169. if (m_uTimer)
  1170. {
  1171. KillTimer(ID_TIMER_EVENT);
  1172. m_uTimer = 0;
  1173. }
  1174. // the following five lines refresh the remining mine num rect immediately 
  1175. // when click in the mine area at the first time
  1176. m_uSpendTime = 1;
  1177. Invalidate();
  1178. if (m_bSoundful) 
  1179. {
  1180. sndPlaySound((LPCTSTR)LockResource(m_pSndClock), SND_MEMORY | SND_ASYNC | SND_NODEFAULT);
  1181. }
  1182. //启动定时器
  1183. m_uTimer = SetTimer(ID_TIMER_EVENT, 1000, NULL);
  1184. //布雷
  1185. LayMines(m_pOldMine->uRow, m_pOldMine->uCol); // lay all the mines down 
  1186. //改变游戏状态为"运行/GS_RUN"
  1187. m_uGameState = GS_RUN;
  1189. }
  1191. if (m_pOldMine->uOldState == STATE_NORMAL)
  1192. {//当该雷区域为正常未作标记才打开
  1193. // first judge if the special MINEWND is a mine
  1194. //如果该区域为雷，则死亡
  1195. if (IsMine(m_pOldMine->uRow, m_pOldMine->uCol)) 
  1196. {
  1197. Dead(m_pOldMine->uRow, m_pOldMine->uCol);
  1198. ReleaseCapture();
  1199. return;
  1200. }
  1201. // the special MINEWND is not a mine 
  1202. //不是雷的时候，获取其周围的雷数目
  1203. around = GetAroundNum(m_pOldMine->uRow, m_pOldMine->uCol);
  1204. // 如果为空白区域，拓展，否则打开该区域（显示周围有多少雷数）
  1205. if (around == 0) ExpandMines(m_pOldMine->uRow, m_pOldMine->uCol);
  1206. else DrawDownNum(m_pOldMine, around);
  1207. }
  1208. else if (m_pOldMine->uOldState == STATE_DICEY)
  1209. {//标志为“？”问号的时候
  1210. m_pOldMine->uState = STATE_DICEY;
  1211. }
  1213. //判断是否为胜利
  1214. if (Victory())
  1215. {
  1216. Invalidate();
  1217. ReleaseCapture();
  1218. return;
  1219. }
  1220. }
  1221. break;
  1222. case GS_VICTORY:
  1223. case GS_DEAD:
  1224. ReleaseCapture(); // release the cursor
  1225. return;
  1226. default :
  1227. break;
  1228. }
  1229. m_uBtnState = BUTTON_NORMAL;
  1230. Invalidate();
  1231. }
  1232. else 
  1233. {//点击非雷区域
  1234. if (m_uGameState == GS_WAIT || m_uGameState == GS_RUN)
  1235. {
  1236. m_uBtnState = BUTTON_NORMAL;
  1237. InvalidateRect(rcBtn);
  1238. }
  1239. }
  1241. ReleaseCapture(); // release the cursor
  1242. CWnd::OnLButtonUp(nFlags, point);
  1243. }
  1245. void CMineWnd::OnRButtonDown(UINT nFlags, CPoint point) 
  1246. {
  1247. //笑脸图按钮所在的区域
  1248. CRect rcBtn(m_uBtnRect[1], 15, m_uBtnRect[2], 39);
  1249. //雷区所在的区域
  1250. CRect rcMineArea(MINE_AREA_LEFT, MINE_AREA_TOP, 
  1251. MINE_AREA_LEFT + m_uXNum * MINE_WIDTH, 
  1252. MINE_AREA_TOP + m_uYNum * MINE_HEIGHT);
  1254. m_bLRBtnDown = FALSE;
  1256. if (rcMineArea.PtInRect(point)) 
  1257. {//点击雷区域
  1258. if (m_uGameState == GS_WAIT || m_uGameState == GS_RUN) 
  1259. {
  1260. m_pNewMine = GetMine(point.x, point.y);
  1261. if (!m_pNewMine) return;
  1262. // both of the left button and the right button are pushing down 
  1263. if (nFlags == (MK_LBUTTON | MK_RBUTTON))
  1264. {
  1265. m_bLRBtnDown = TRUE;
  1266. OnLRBtnDown(m_pNewMine->uRow, m_pNewMine->uCol);
  1267. }
  1268. else
  1269. {
  1270. switch(m_pNewMine->uState) 
  1271. {
  1272. case STATE_NORMAL:
  1273. m_pNewMine->uState = STATE_FLAG;
  1274. m_pNewMine->uOldState = STATE_FLAG;
  1275. m_nLeaveNum--;
  1276. break;
  1277. case STATE_FLAG:
  1278. m_pNewMine->uState = STATE_DICEY;
  1279. m_pNewMine->uOldState = STATE_DICEY;
  1280. m_nLeaveNum++;
  1281. break;
  1282. case STATE_DICEY:
  1283. m_pNewMine->uState = STATE_NORMAL;
  1284. m_pNewMine->uOldState = STATE_NORMAL;
  1285. break;
  1286. default: 
  1287. break;
  1288. }
  1289. }
  1290. Invalidate();
  1292. }
  1293. }
  1295. CWnd::OnRButtonDown(nFlags, point);
  1296. }
  1298. void CMineWnd::OnRButtonUp(UINT nFlags, CPoint point) 
  1299. {
  1300. CRect rcBtn(m_uBtnRect[1], 15, m_uBtnRect[2], 39);
  1301. CRect rcMineArea(MINE_AREA_LEFT, MINE_AREA_TOP, 
  1302. MINE_AREA_LEFT + m_uXNum * MINE_WIDTH, MINE_AREA_TOP + m_uYNum * MINE_HEIGHT);
  1304. m_pOldMine = GetMine(point.x, point.y);
  1305. if (!m_pOldMine) return;
  1306. // judge whether the lr button are both pushed down
  1307. if (m_bLRBtnDown) 
  1308. {
  1309. m_bLRBtnDown = FALSE;
  1310. OnLRBtnUp(m_pOldMine->uRow, m_pOldMine->uCol);
  1311. if (m_uGameState == GS_WAIT) 
  1312. {
  1313. m_uBtnState = BUTTON_NORMAL;
  1314. Invalidate();
  1315. return;
  1316. }
  1317. // if the around flags number equal to the around mines number, expand.
  1318. if (m_pOldMine->uState != STATE_FLAG)
  1319. {
  1320. OpenAround(m_pOldMine->uRow, m_pOldMine->uCol);
  1321. }
  1322. // check whether the MINEWND around the special MINEWND is a mine, if it is then dead.
  1323. if (ErrorAroundFlag(m_pOldMine->uRow, m_pOldMine->uCol))
  1324. {
  1325. // Dead(m_pOldMine->uRow, m_pOldMine->uCol);
  1326. // ReleaseCapture();
  1327. return;
  1328. }
  1329. }
  1330. else
  1331. {
  1332. Victory();
  1333. }
  1335. CWnd::OnRButtonUp(nFlags, point);
  1336. }
  1338. void CMineWnd::OnMouseMove(UINT nFlags, CPoint point) 
  1339. {
  1340. if (nFlags == MK_LBUTTON || nFlags == (MK_LBUTTON | MK_RBUTTON))
  1341. {
  1342. CRect rcBtn(m_uBtnRect[1], 15, m_uBtnRect[2], 39);
  1343. CRect rcMineArea(MINE_AREA_LEFT, MINE_AREA_TOP, 
  1344. MINE_AREA_LEFT + m_uXNum * MINE_WIDTH, MINE_AREA_TOP + m_uYNum * MINE_HEIGHT);
  1346. if (rcBtn.PtInRect(point)) 
  1347. { // point in button area
  1348. switch(m_uGameState)
  1349. {
  1350. case GS_RUN:
  1351. m_uBtnState = (m_bClickBtn) ? BUTTON_DOWN : BUTTON_CLICK;
  1352. break;
  1353. case GS_DEAD: case GS_VICTORY:
  1354. if (m_bClickBtn) m_uBtnState = BUTTON_DOWN;
  1355. break;
  1356. default: 
  1357. break;
  1358. }
  1359. InvalidateRect(rcBtn);
  1360. }
  1361. else if (rcMineArea.PtInRect(point)) 
  1362. { // point in mine area
  1363. switch(m_uGameState) 
  1364. {
  1365. case GS_RUN:
  1366. m_pNewMine = GetMine(point.x, point.y);
  1367. if (!m_pNewMine || !m_pOldMine) return;
  1368. if (m_pNewMine->uCol != m_pOldMine->uCol ||
  1369. m_pNewMine->uRow != m_pOldMine->uRow) 
  1370. {
  1371. // change the new mine rect state
  1372. switch(m_pNewMine->uState)
  1373. {
  1374. case STATE_NORMAL:
  1375. m_pNewMine->uState = STATE_EMPTY;
  1376. break;
  1377. case STATE_DICEY:
  1378. m_pNewMine->uState = STATE_DICEY_DOWN;
  1379. break;
  1380. }
  1381. // resume the old mine rect state
  1382. switch(m_pOldMine->uOldState) 
  1383. {
  1384. case STATE_NORMAL:
  1385. m_pOldMine->uState = STATE_NORMAL;
  1386. break;
  1387. case STATE_DICEY:
  1388. m_pOldMine->uState = STATE_DICEY;
  1389. break;
  1390. default :
  1391. break;
  1392. }
  1393. // judge whether the lr button are pushed down
  1394. if (m_bLRBtnDown) 
  1395. {
  1396. OnLRBtnUp(m_pOldMine->uRow, m_pOldMine->uCol);
  1397. OnLRBtnDown(m_pNewMine->uRow, m_pNewMine->uCol);
  1398. }
  1399. m_pOldMine = m_pNewMine;
  1400. }
  1401. InvalidateRect(rcMineArea);
  1402. break;
  1403. case GS_VICTORY: case GS_DEAD:
  1404. return;
  1405. default: 
  1406. break;
  1407. }
  1408. }
  1409. else
  1410. { // point in other area
  1411. switch(m_uGameState) 
  1412. {
  1413.  case GS_RUN:
  1414. m_uBtnState = (m_bClickBtn) ? BUTTON_NORMAL : BUTTON_CLICK;
  1415. if (m_pNewMine) 
  1416. {
  1417. if (m_pNewMine->uOldState == STATE_NORMAL)
  1418. {
  1419. m_pNewMine->uState = STATE_NORMAL;
  1420. }
  1421. else if (m_pNewMine->uOldState == STATE_DICEY)
  1422. {
  1423. m_pNewMine->uState = STATE_DICEY;
  1424. }
  1425. }
  1426. break;
  1427. case GS_DEAD: 
  1428. m_uBtnState = BUTTON_DEAD;
  1429. break;
  1430. case GS_VICTORY:
  1431. m_uBtnState = BUTTON_VICTORY;
  1432. break;
  1433. default: 
  1434. break;
  1435. }
  1436. Invalidate();
  1437. }
  1438. }
  1440. CWnd::OnMouseMove(nFlags, point);
  1441. }
  1443. void CMineWnd::OnMemuStart() 
  1444. {
  1445. InitGame();
  1446. Invalidate();
  1447. }
  1449. void CMineWnd::OnMemuPrimary() 
  1450. {
  1451. m_uLevel = LEVEL_PRIMARY;
  1452. m_uXNum = PRIMARY_XNUM;
  1453. m_uYNum = PRIMARY_YNUM;
  1454. m_uMineNum = PRIMARY_MINENUM;
  1456. SetCheckedLevel();
  1457. InitGame();
  1458. Invalidate();
  1459. SizeWindow();
  1460. }
  1462. void CMineWnd::OnMemuSecond() 
  1463. {
  1464. m_uLevel = LEVEL_SECONDRY;
  1465. m_uXNum = SECONDRY_XNUM;
  1466. m_uYNum = SECONDRY_YNUM;
  1467. m_uMineNum = SECONDRY_MINENUM;
  1469. SetCheckedLevel();
  1470. InitGame();
  1471. Invalidate();
  1472. SizeWindow();
  1473. }
  1475. void CMineWnd::OnMemuAdvance() 
  1476. {
  1477. m_uLevel = LEVEL_ADVANCE;
  1478. m_uXNum = ADVANCE_XNUM;
  1479. m_uYNum = ADVANCE_YNUM;
  1480. m_uMineNum = ADVANCE_MINENUM;
  1482. SetCheckedLevel();
  1483. InitGame();
  1484. Invalidate();
  1485. SizeWindow();
  1486. }
  1488. void CMineWnd::OnMemuCustom() 
  1489. {
  1490. m_uLevel = LEVEL_CUSTOM;
  1491. SetCheckedLevel();
  1492. CDlgCustom dlg;
  1493. dlg.InitData(m_uXNum, m_uYNum, m_uMineNum);
  1494. dlg.DoModal();
  1496. InitGame();
  1497. Invalidate();
  1498. SizeWindow();
  1499. }
  1501. void CMineWnd::OnMemuCheat() 
  1502. {
  1503. // m_bCheat = !m_bCheat;
  1504. // SetCheckedCheat();
  1505. // Invalidate();
  1506. }
  1508. void CMineWnd::OnMemuMark() 
  1509. {
  1510. m_bMarkful = !m_bMarkful;
  1511. SetCheckedMark();
  1512. Invalidate();
  1513. }
  1515. void CMineWnd::OnMemuColor() 
  1516. {
  1517. m_bColorful = !m_bColorful;
  1518. LoadBitmap();
  1519. SetCheckedColor();
  1520. Invalidate();
  1521. }
  1523. void CMineWnd::OnMemuSound() 
  1524. {
  1525. m_bSoundful = !m_bSoundful;
  1526. SetCheckedSound();
  1527. if (m_bSoundful) 
  1528. {
  1529. LoadWaveSrc();
  1530. }
  1531. else
  1532. {
  1533. FreeWaveSrc();
  1534. }
  1535. }
  1537. void CMineWnd::OnMemuHero() 
  1538. {
  1539. CDlgHero dlg;
  1540. dlg.SetBRecord(m_uPrimary);
  1541. dlg.SetBHolder(m_szPrimary);
  1542. dlg.SetIRecord(m_uSecond);
  1543. dlg.SetIHolder(m_szSecond);
  1544. dlg.SetERecord(m_uAdvance);
  1545. dlg.SetEHolder(m_szAdvance);
  1546. dlg.DoModal();
  1547. }
  1549. void CMineWnd::OnMemuExit() 
  1550. {
  1551. PostQuitMessage(0);
  1552. }
  1554. void CMineWnd::OnMemuHelpList() 
  1555. {
  1556. ::WinExec("HH WINMINE.CHM", SW_SHOW);
  1557. }
  1559. void CMineWnd::OnMemuHelpFind() 
  1560. {
  1561. ::WinExec("HH WINMINE.CHM", SW_SHOW);
  1562. }
  1564. void CMineWnd::OnMemuHelpUse() 
  1565. {
  1566. ::WinExec("HH NTHelp.CHM", SW_SHOW);
  1567. }
  1569. void CMineWnd::OnMemuAbout() 
  1570. {
  1571. ShellAbout(this->m_hWnd, "扫雷", "skybluehacker@yahoo.com.cn",NULL);
  1572. }
  1574. void CMineWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1575. {
  1576. switch(nChar)
  1577. {
  1578. case VK_F1:
  1579. OnMemuHelpList();
  1580. break;
  1581. case VK_F2:
  1582. OnMemuStart();
  1583. break;
  1584. default: 
  1585. break;
  1586. }
  1588. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  1589. }
  1591. void CMineWnd::OnInitMenu(CMenu* pMenu) 
  1592. {
  1593. CWnd::OnInitMenu(pMenu);
  1594. if ((m_pSubMenu = pMenu->GetSubMenu(0)) == 0) 
  1595. {
  1596. AfxMessageBox("初始化菜单失败！");
  1597. PostQuitMessage(0);
  1598. }
  1599. else
  1600. {
  1601. SetCheckedLevel();
  1602. SetCheckedMark();
  1603. SetCheckedColor();
  1604. SetCheckedSound();
  1605. // SetCheckedCheat();
  1606. }
  1607. }
  1609. void CMineWnd::OnMemuClose() 
  1610. {
  1611. SaveConfig();
  1612. KillTimer(ID_TIMER_EVENT);
  1614. CWnd::OnClose();
  1615. }