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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
CSuperBrickBreaker.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：70k
源码类别：

游戏

开发平台：

Visual C++

CSuperBrickBreaker.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////////////
  2. /// File:    CSuperBrickBreaker.cpp
  3. /// Purpose: Implementation of CSuperBrickBreaker Class
  4. ///////////////////////////////////////////////////////////////////////////////
  5. /// Configuation Management
  6. /// 
  7. /// Who         When          Description
  8. /// ===========================================================================
  9. /// R. Walter   28-Dec-2003   Initial Version/Release
  10. ///
  11. ///////////////////////////////////////////////////////////////////////////////
  12. /// Copyright 2003: Robert Walter   All rights reserved
  13. ///////////////////////////////////////////////////////////////////////////////
  16. /// HEADER FILE INCLUDES //////////////////////////////////////////////////////
  17. #include <stdio.h>
  18. #include "CSuperBrickBreaker.h"
  21. /// CLASS CONSTRUCTORS / DESTRUCTORS //////////////////////////////////////////
  23. ///////////////////////////////////////////////////////////////////////////////
  24. /// Method:  CSuperBrickBreaker --> default constructor
  25. /// Purpose: Initialize member variables
  26. ///////////////////////////////////////////////////////////////////////////////
  27. /// Receives: nothing
  28. /// Returns:  nothing
  29. ///////////////////////////////////////////////////////////////////////////////
  30. CSuperBrickBreaker::CSuperBrickBreaker()
  31. {
  32. m_game_state      = GS_INITIALIZE;
  33. m_game_type       = SBB_STANDARD;
  34. m_paused_state    = PS_RESUME;
  35. m_gameover_state  = GO_PLAYAGAIN;
  37. m_hit_top_boun_fg = false;
  39. m_new_level_fg = false;
  41. m_score = 0;
  43. m_file_stream.open("sbb_log.txt");
  45. return;
  46. }
  48. ///////////////////////////////////////////////////////////////////////////////
  49. /// Method:  ~CSuperBrickBreaker --> class destructor
  50. /// Purpose: Uninitialize member variables
  51. ///////////////////////////////////////////////////////////////////////////////
  52. /// Receives: nothing
  53. /// Returns:  nothing
  54. ///////////////////////////////////////////////////////////////////////////////
  55. CSuperBrickBreaker::~CSuperBrickBreaker()
  56. {
  57. m_file_stream.close();
  59.     return;
  60. }
  62. ///////////////////////////////////////////////////////////////////////////////
  63. /// Method:  BallRectIntersect
  64. /// Purpose: Determine the passed ball rect intersects the passed rectangle
  65. ///////////////////////////////////////////////////////////////////////////////
  66. /// Receives: RECT describing current position of ball
  67. ///           RECT describing brick or paddle being tested for interesection
  68. /// Returns:  EIntersect describing how ball rect intersected rectangle
  69. ///////////////////////////////////////////////////////////////////////////////
  70. EIntersect CSuperBrickBreaker::BallRectIntersect(RECT p_ball_rect, RECT p_rect)
  71. {
  72. bool l_contains_top_left  = false;
  73. bool l_contains_top_right = false;
  74. bool l_contains_bot_left  = false;
  75. bool l_contains_bot_right = false;
  77. // check if top-left corner of the ball is in the rectangle
  78. l_contains_top_left = ( (p_ball_rect.top  >= p_rect.top)  && (p_ball_rect.top  <= p_rect.bottom) &&
  79.                     (p_ball_rect.left >= p_rect.left) && (p_ball_rect.left <= p_rect.right) ) ;
  81. // check if top-right corner of the ball is in the rectangle
  82. l_contains_top_right = ( (p_ball_rect.top   >= p_rect.top)  && (p_ball_rect.top   <= p_rect.bottom) &&
  83.                      (p_ball_rect.right >= p_rect.left) && (p_ball_rect.right <= p_rect.right) ) ;
  85. // check if bottom-left corner of the ball is in the rectangle
  86. l_contains_bot_left = ( (p_ball_rect.bottom >= p_rect.top)  && (p_ball_rect.bottom <= p_rect.bottom) &&
  87.                     (p_ball_rect.left   >= p_rect.left) && (p_ball_rect.left   <= p_rect.right) ) ;
  89. // check if bottom-right corner of the ball is in the rectangle
  90. l_contains_bot_right = ( (p_ball_rect.bottom >= p_rect.top)  && (p_ball_rect.bottom <= p_rect.bottom) &&
  91.                      (p_ball_rect.right  >= p_rect.left) && (p_ball_rect.right  <= p_rect.right) ) ;
  93. if ( (l_contains_top_left) && (l_contains_top_right) )
  94. {
  95. return(IS_BOTTOM);
  96. }
  97. else if ( (l_contains_top_right) && (l_contains_bot_right) ) 
  98. {
  99. return(IS_LEFT);
  100. }
  101. else if ( (l_contains_bot_right) && (l_contains_bot_left) ) 
  102. {
  103. return(IS_TOP);
  104. }
  105. else if ( (l_contains_bot_left) && (l_contains_top_left) )
  106. {
  107. return(IS_RIGHT);
  108. }
  109. else if (l_contains_top_left)
  110. {
  111. // only the top left corner 'penetrated' the rectangle
  112. // if the top-left corner is farther from the bottom of the
  113. // rectangle than the right side, assume the ball interected
  114. // the right
  115. if  ( (p_rect.bottom - p_ball_rect.top) >= (p_rect.right - p_ball_rect.left) )
  116. {
  117. return(IS_RIGHT);
  118. }
  119. else
  120. {
  121. return(IS_BOTTOM);
  122. }
  123. }
  124. else if (l_contains_top_right)
  125. {
  126.         // only the top right corner 'penetrated' the rectangle
  127. // if the top-right corner is farther from the bottom of the
  128. // rectangle than the left side, assume the ball interected
  129. // the left
  130. if  ( (p_rect.bottom - p_ball_rect.top) >= (p_ball_rect.right - p_rect.left) )
  131. {
  132. return(IS_LEFT);
  133. }
  134. else
  135. {
  136. return(IS_BOTTOM);
  137. }
  138. }
  139. else if (l_contains_bot_right)
  140. {
  141.         // only the bottom right corner 'penetrated' the rectangle
  142. // if the bottom-right corner is farther from the top of the
  143. // rectangle than the left side, assume the ball interected
  144. // the left
  145. if  ( (p_ball_rect.bottom - p_rect.top) >= (p_ball_rect.right - p_rect.left) )
  146. {
  147. return(IS_LEFT);
  148. }
  149. else
  150. {
  151. return(IS_BOTTOM);
  152. }
  153. }
  154. else if (l_contains_bot_left)
  155. {
  156. // only the bottom left corner 'penetrated' the rectangle
  157. // if the bottom-left corner is farther from the top of the
  158. // rectangle than the right side, assume the ball interected
  159. // the right
  160. if  ( (p_ball_rect.bottom - p_rect.top) >= (p_rect.right - p_ball_rect.left) )
  161. {
  162. return(IS_RIGHT);
  163. }
  164. else
  165. {
  166. return(IS_BOTTOM);
  167. }
  168. }
  170. return(IS_NONE);
  171. }
  174. ///////////////////////////////////////////////////////////////////////////////
  175. /// Method:  CheckHitBrick
  176. /// Purpose: Determines if the ball (based on passed rectangle) hit a brick
  177. ///////////////////////////////////////////////////////////////////////////////
  178. /// Receives: RECT structure of current positon of a ball
  179. /// Returns:  EIntersect value describing how ball hit a brick
  180. ///////////////////////////////////////////////////////////////////////////////
  181. EIntersect CSuperBrickBreaker::CheckHitBrick(const RECT p_ball_rect, TBrick* p_hit_brick)
  182. {
  183. bool l_is_brick = IsBrickAtBallLocation(p_ball_rect, p_hit_brick);
  184. if (l_is_brick)
  185. {
  186. EIntersect l_intersect = IS_NONE;
  188. if (p_hit_brick->state == BS_NORMAL)
  189. {
  191. // determine which side of the brick the ball intersected.
  192. l_intersect = BallRectIntersect(p_ball_rect, p_hit_brick->rect);
  193. return(l_intersect);
  194. }
  195. }
  197. return(IS_NONE);
  198. }
  200. ///////////////////////////////////////////////////////////////////////////////
  201. /// Method:  CheckHitPaddle
  202. /// Purpose: Determines if the ball (based on passed rectangle) hit the paddle
  203. ///////////////////////////////////////////////////////////////////////////////
  204. /// Receives: RECT structure of current positon of a ball
  205. /// Returns:  EIntersect value describing how ball hit the paddle
  206. ///////////////////////////////////////////////////////////////////////////////
  207. EIntersect CSuperBrickBreaker::CheckHitPaddle(const RECT p_ball_rect)
  208. {
  209. TBallCorner m_ball_corner[4];
  210. EIntersect  l_result = IS_NONE;
  212. /*************************
  213. ** top left corner
  214. *************************/
  215. m_ball_corner[0].x = p_ball_rect.left;
  216. m_ball_corner[0].y = p_ball_rect.top;
  218.     /*************************
  219. ** top right corner
  220. *************************/
  221. m_ball_corner[1].x = p_ball_rect.right;
  222. m_ball_corner[1].y = p_ball_rect.top;
  224. /*************************
  225. ** bottom right corner
  226. *************************/
  227. m_ball_corner[2].x = p_ball_rect.right;
  228. m_ball_corner[2].y = p_ball_rect.bottom;
  230. /*************************
  231. ** bottom left corner
  232. *************************/
  233. m_ball_corner[3].x = p_ball_rect.left;
  234. m_ball_corner[3].y = p_ball_rect.bottom;
  236. int  j = 0;
  237. bool l_hit_paddle = false;
  238. RECT l_paddle_rect;
  240. ///////////////////////////////////////////////////////////////////////////
  241. /// loop through each of the ball corners to determine if the ball 
  242. /// struck the paddle
  243. ///////////////////////////////////////////////////////////////////////////
  244. while (j < 4)
  245. {
  246. l_hit_paddle = m_paddle.IsPaddleAtPosition
  247.            (
  248.        /* x */           m_ball_corner[j].x, 
  249.    /* y */           m_ball_corner[j].y, 
  250.    /* paddle rect */ &l_paddle_rect
  251.    );
  252. ///////////////////////////////////////////////////////////////////////
  253. /// if the ball hit the paddle, determine how (ie. which side) the
  254. /// ball intersected
  255. ///////////////////////////////////////////////////////////////////////
  256. if (l_hit_paddle)
  257. {
  258. l_result = BallRectIntersect(p_ball_rect, l_paddle_rect);
  259. if (l_result != IS_NONE)
  260. {
  261. return(l_result);
  262. }
  263. }
  265. j++;
  266. }
  268. return(l_result);
  269. }
  271. ///////////////////////////////////////////////////////////////////////////////
  272. /// Method:  DrawBalls
  273. /// Purpose: Draw the Super Brick Breaker game balls
  274. ///////////////////////////////////////////////////////////////////////////////
  275. /// Receives: nothing
  276. /// Returns:  true if balls successfully drawn, otherwise false
  277. ///////////////////////////////////////////////////////////////////////////////
  278. bool CSuperBrickBreaker::DrawBalls()
  279. {
  280. // draw all FREE and CAPTIVE balls 
  281. for (int i = 0; i < m_num_balls; i++)
  282. {
  283. if ( (m_ball[i].GetState() == FREE) || (m_ball[i].GetState() == CAPTIVE) )
  284. {
  286.             m_ball_rect = m_ball[i].GetBallRect();
  288. bool br = false;
  289. br = DrawRectangle(&m_ball_rect, m_white_clr);
  290. if (!br)
  291. {
  292. return(false);
  293. }
  295. }
  296. }
  298. return true;
  299. }
  301. ///////////////////////////////////////////////////////////////////////////////
  302. /// Method:  DrawBoundary
  303. /// Purpose: Draw the Super Brick Breaker boundary
  304. ///////////////////////////////////////////////////////////////////////////////
  305. /// Receives: nothing
  306. /// Returns:  true if bounday successfully drawn, otherwise false
  307. ///////////////////////////////////////////////////////////////////////////////
  308. bool CSuperBrickBreaker::DrawBoundary()
  309. {
  310. // draw left boundary
  311. bool br = false;
  313. // draw main boundary rectangles
  314. br = DrawRectangle(&m_left_boun_rect, m_boundary_clr);
  315. if (!br) 
  316. {
  317. return(false);
  318. }
  319. br = DrawRectangle(&m_top_boun_rect, m_boundary_clr);
  320. if (!br) 
  321. {
  322. return(false);
  323. }
  324. br = DrawRectangle(&m_right_boun_rect, m_boundary_clr);
  325. if (!br) 
  326. {
  327. return(false);
  328. }
  330. // draw 'light' 3d rectangles on boundary
  331. br = DrawRectangle(&m_left_3d_light_rect, m_3d_light_clr);
  332. if (!br) 
  333. {
  334. return(false);
  335. }
  336. br = DrawRectangle(&m_top_3d_light_rect, m_3d_light_clr);
  337. if (!br) 
  338. {
  339. return(false);
  340. }
  341. br = DrawRectangle(&m_right_3d_light_rect, m_3d_light_clr);
  342. if (!br) 
  343. {
  344. return(false);
  345. }
  347. // draw 'shadow' 3d rectangles on boundary
  348. br = DrawRectangle(&m_left_3d_shadow_rect, m_3d_shadow_clr);
  349. if (!br) 
  350. {
  351. return(false);
  352. }
  353. br = DrawRectangle(&m_top_3d_shadow_rect, m_3d_shadow_clr);
  354. if (!br) 
  355. {
  356. return(false);
  357. }
  358. br = DrawRectangle(&m_right_3d_shadow_rect, m_3d_shadow_clr);
  359. if (!br) 
  360. {
  361. return(false);
  362. }
  364. return(true);
  365. };
  367. ///////////////////////////////////////////////////////////////////////////////
  368. /// Method:  DrawBricks
  369. /// Purpose: Draw the Super Brick Breaker game bricks
  370. ///////////////////////////////////////////////////////////////////////////////
  371. /// Receives: nothing
  372. /// Returns:  true if bricks successfully drawn, otherwise false
  373. ///////////////////////////////////////////////////////////////////////////////
  374. bool CSuperBrickBreaker::DrawBricks()
  375. {
  376. int l_brick_cnt = m_bricks.GetBrickCount();
  378. for (int i = 0; i < l_brick_cnt; i++)
  379. {
  380. TBrick l_brick = m_bricks.GetBrick(i);
  382. bool br = false;
  384. if (l_brick.state == BS_NORMAL)
  385. {
  386. br = DrawRectangle(&l_brick.rect, l_brick.color);
  387. if (!br)
  388. {
  389. return(false);
  390. }
  392. br = Draw3DFrame(l_brick.rect);
  393. if (!br)
  394. {
  395. return(false);
  396. }
  397. }
  398. }
  400. return(true);
  401. }
  403. ///////////////////////////////////////////////////////////////////////////////
  404. /// Method:  DrawGameOverMenu
  405. /// Purpose: Draw the 'game over' menu in the playing area on top of 
  406. ///          bricks
  407. ///////////////////////////////////////////////////////////////////////////////
  408. /// Receives: nothing
  409. /// Returns:  true if the menu is successfully drawn, otherwise false
  410. ///////////////////////////////////////////////////////////////////////////////
  411. bool CSuperBrickBreaker::DrawGameOverMenu()
  412. {
  413. bool br = false;
  415. ///////////////////////////////////////////////////////////////////////////
  416. /// draw the game over shadow text
  417. ///////////////////////////////////////////////////////////////////////////
  418. br = DrawGDIText
  419.  (
  420.      /* text */ "Game Over", 
  421.  /* red */  212,
  422.  /* green */ 208, 
  423.  /* blue */ 200, 
  424.  /* font */ m_menu_font, 
  425.  /* x */ 172,
  426.  /* y */ 77
  427.  );
  428.     if (!br)
  429. {
  430. return(false);
  431. }
  433. ///////////////////////////////////////////////////////////////////////////
  434. /// draw the game over text
  435. ///////////////////////////////////////////////////////////////////////////
  436. br = DrawGDIText
  437.  (
  438.      /* text */ "Game Over", 
  439.  /* red */  255,
  440.  /* green */ 255, 
  441.  /* blue */ 255, 
  442.  /* font */ m_menu_font, 
  443.  /* x */ 170,
  444.  /* y */ 75
  445.  );
  446.     if (!br)
  447. {
  448. return(false);
  449. }
  451.     ///////////////////////////////////////////////////////////////////////////
  452. /// draw the play again shadow text
  453. ///////////////////////////////////////////////////////////////////////////
  454. br = DrawGDIText
  455.  (
  456.      /* text */ "Play Again", 
  457.  /* red */  212,
  458.  /* green */ 208, 
  459.  /* blue */ 200, 
  460.  /* font */ m_menu_font, 
  461.  /* x */ 289,
  462.  /* y */ 152
  463.  );
  464.     if (!br)
  465. {
  466. return(false);
  467. }
  469. ///////////////////////////////////////////////////////////////////////////
  470. /// draw the play again text
  471. ///////////////////////////////////////////////////////////////////////////
  472. br = DrawGDIText
  473.  (
  474.      /* text */ "Play Again", 
  475.  /* red */  255,
  476.  /* green */ 255, 
  477.  /* blue */ 255, 
  478.  /* font */ m_menu_font, 
  479.  /* x */ 287,
  480.  /* y */ 150
  481.  );
  482.     if (!br)
  483. {
  484. return(false);
  485. }
  487. ///////////////////////////////////////////////////////////////////////////
  488. /// draw the main menu shadow text
  489. ///////////////////////////////////////////////////////////////////////////
  490. br = DrawGDIText
  491.  (
  492.      /* text */ "Main Menu", 
  493.  /* red */  212,
  494.  /* green */ 208, 
  495.  /* blue */ 200, 
  496.  /* font */ m_menu_font, 
  497.  /* x */ 289,
  498.  /* y */ 207
  499.  );
  500.     if (!br)
  501. {
  502. return(false);
  503. }
  505. ///////////////////////////////////////////////////////////////////////////
  506. /// draw the main menu text
  507. ///////////////////////////////////////////////////////////////////////////
  508. br = DrawGDIText
  509.  (
  510.      /* text */ "Main Menu", 
  511.  /* red */  255,
  512.  /* green */ 255, 
  513.  /* blue */ 255, 
  514.  /* font */ m_menu_font, 
  515.  /* x */ 287,
  516.  /* y */ 205
  517.  );
  518.     if (!br)
  519. {
  520. return(false);
  521. }
  523. int l_menu_x = 0;
  524. int l_menu_y = 0;
  526. if (m_gameover_state == GO_PLAYAGAIN)
  527. {
  528. l_menu_x = 230;
  529. l_menu_y = 150;
  530. }
  531. else if (m_gameover_state == GO_MAINMENU)
  532. {
  533. l_menu_x = 230;
  534. l_menu_y = 205;
  535. }
  536. else
  537. {
  538. return(false);
  539. }
  541. ///////////////////////////////////////////////////////////////////////////
  542. /// draw the 'chosen (->)' game shadow
  543. ///////////////////////////////////////////////////////////////////////////
  544.     br = DrawGDIText
  545.  (
  546.      /* text */ "->", 
  547.  /* red */  212,
  548.  /* green */ 208, 
  549.  /* blue */ 200, 
  550.  /* font */ m_menu_font, 
  551.  /* x */ l_menu_x + 2,
  552.  /* y */ l_menu_y + 2
  553.  );
  554.     if (!br)
  555. {
  556. return(false);
  557. }
  559. ///////////////////////////////////////////////////////////////////////////
  560. /// draw the 'chosen (->)' game
  561. ///////////////////////////////////////////////////////////////////////////
  562. br = DrawGDIText
  563.  (
  564.      /* text */ "->", 
  565.  /* red */  255,
  566.  /* green */ 255, 
  567.  /* blue */ 255, 
  568.  /* font */ m_menu_font, 
  569.  /* x */ l_menu_x,
  570.  /* y */ l_menu_y
  571.  );
  572.     if (!br)
  573. {
  574. return(false);
  575. }
  577. return(true);
  578. }
  580. ///////////////////////////////////////////////////////////////////////////////
  581. /// Method:  DrawHeadingLine
  582. /// Purpose: Draw the Super Brick Breaker heading line
  583. ///          - game title
  584. ///          - turns remaining
  585. ///          - current level
  586. ///          - current score
  587. ///////////////////////////////////////////////////////////////////////////////
  588. /// Receives: nothing
  589. /// Returns:  true if heading line successfully drawn, otherwise false
  590. ///////////////////////////////////////////////////////////////////////////////
  591. bool CSuperBrickBreaker::DrawHeadingLine()
  592. {
  593. char       l_text[200];
  594. ostrstream l_stream(l_text, sizeof(l_text));
  596. l_stream << "SUPER BRICK BREAKER            TURNS   " << m_game_turns_remaining 
  597.      << "          LEVEL   " << m_level << "        SCORE      " 
  598.  << m_score << ends;
  600.     StartGDIDrawing();
  602. bool br = false;
  604. br = DrawGDIText
  605.  (
  606.      /* text */ l_text, 
  607.  /* red */  255,
  608.  /* green */ 255, 
  609.  /* blue */ 255, 
  610.  /* font */ m_plain_font, 
  611.  /* x */ 2,
  612.  /* y */ 2
  613.  );
  614.     if (!br)
  615. {
  616. return(false);
  617. }
  619. EndGDIDrawing();
  621. return(true);
  622. }
  624. ///////////////////////////////////////////////////////////////////////////////
  625. /// Method:  DrawMainMenu
  626. /// Purpose: Draw the main menu in the playing area on top of 
  627. ///          bricks
  628. ///////////////////////////////////////////////////////////////////////////////
  629. /// Receives: nothing
  630. /// Returns:  true if the main menu is successfully drawn, otherwise false
  631. ///////////////////////////////////////////////////////////////////////////////
  632. bool CSuperBrickBreaker::DrawMainMenu()
  633. {
  634.     bool br = false;
  636. ///////////////////////////////////////////////////////////////////////////
  637. /// draw the 'Standard' game shadow text
  638. ///////////////////////////////////////////////////////////////////////////
  639. br = DrawGDIText
  640.  (
  641.      /* text */ "Standard", 
  642.  /* red */  212,
  643.  /* green */ 208, 
  644.  /* blue */ 200, 
  645.  /* font */ m_menu_font, 
  646.  /* x */ 315,
  647.  /* y */ 152
  648.  );
  649.     if (!br)
  650. {
  651. return(false);
  652. }
  654. ///////////////////////////////////////////////////////////////////////////
  655. /// draw the 'Standard' game text
  656. ///////////////////////////////////////////////////////////////////////////
  657. br = DrawGDIText
  658.  (
  659.      /* text */ "Standard", 
  660.  /* red */  255,
  661.  /* green */ 255, 
  662.  /* blue */ 255, 
  663.  /* font */ m_menu_font, 
  664.  /* x */ 312,
  665.  /* y */ 150
  666.  );
  667.     if (!br)
  668. {
  669. return(false);
  670. }
  672. ///////////////////////////////////////////////////////////////////////////
  673. /// draw the 'Double' game shadow text
  674. ///////////////////////////////////////////////////////////////////////////
  675. br = DrawGDIText
  676.  (
  677.      /* text */ "Double", 
  678.  /* red */  212,
  679.  /* green */ 208, 
  680.  /* blue */ 200, 
  681.  /* font */ m_menu_font, 
  682.  /* x */ 314,
  683.  /* y */ 207
  684.  );
  685.     if (!br)
  686. {
  687. return(false);
  688. }
  690. ///////////////////////////////////////////////////////////////////////////
  691. /// draw the 'Double' game text
  692. ///////////////////////////////////////////////////////////////////////////
  693. br = DrawGDIText
  694.  (
  695.      /* text */ "Double", 
  696.  /* red */  255,
  697.  /* green */ 255, 
  698.  /* blue */ 255, 
  699.  /* font */ m_menu_font, 
  700.  /* x */ 312,
  701.  /* y */ 205
  702.  );
  703.     if (!br)
  704. {
  705. return(false);
  706. }
  708. ///////////////////////////////////////////////////////////////////////////
  709. /// draw the 'Escape' game shadow text
  710. ///////////////////////////////////////////////////////////////////////////
  711. br = DrawGDIText
  712.  (
  713.      /* text */ "Escape", 
  714.  /* red */  212,
  715.  /* green */ 208, 
  716.  /* blue */ 200, 
  717.  /* font */ m_menu_font, 
  718.  /* x */ 314,
  719.  /* y */ 262
  720.  );
  721.     if (!br)
  722. {
  723. return(false);
  724. }
  726. ///////////////////////////////////////////////////////////////////////////
  727. /// draw the 'Escape' game text
  728. ///////////////////////////////////////////////////////////////////////////
  729. br = DrawGDIText
  730.  (
  731.      /* text */ "Escape", 
  732.  /* red */  255,
  733.  /* green */ 255, 
  734.  /* blue */ 255, 
  735.  /* font */ m_menu_font, 
  736.  /* x */ 312,
  737.  /* y */ 260
  738.  );
  739.     if (!br)
  740. {
  741. return(false);
  742. }
  744. int l_game_menu_x = 0;
  745. int l_game_menu_y = 0;
  747. if (m_game_type == SBB_STANDARD)
  748. {
  749. l_game_menu_x = 255;
  750. l_game_menu_y = 150;
  751. }
  752. else if (m_game_type == SBB_DOUBLE)
  753. {
  754. l_game_menu_x = 255;
  755. l_game_menu_y = 205;
  756. }
  757. else if (m_game_type == SBB_ESCAPE)
  758. {
  759. l_game_menu_x = 255;
  760. l_game_menu_y = 260;
  761. }
  762. else
  763. {
  764. return(false);
  765. }
  767. ///////////////////////////////////////////////////////////////////////////
  768. /// draw the 'chosen (->)' game shadow
  769. ///////////////////////////////////////////////////////////////////////////
  770.     br = DrawGDIText
  771.  (
  772.      /* text */ "->", 
  773.  /* red */  212,
  774.  /* green */ 208, 
  775.  /* blue */ 200, 
  776.  /* font */ m_menu_font, 
  777.  /* x */ l_game_menu_x + 2,
  778.  /* y */ l_game_menu_y + 2
  779.  );
  780.     if (!br)
  781. {
  782. return(false);
  783. }
  785. ///////////////////////////////////////////////////////////////////////////
  786. /// draw the 'chosen (->)' game
  787. ///////////////////////////////////////////////////////////////////////////
  788. br = DrawGDIText
  789.  (
  790.      /* text */ "->", 
  791.  /* red */  255,
  792.  /* green */ 255, 
  793.  /* blue */ 255, 
  794.  /* font */ m_menu_font, 
  795.  /* x */ l_game_menu_x,
  796.  /* y */ l_game_menu_y
  797.  );
  798.     if (!br)
  799. {
  800. return(false);
  801. }
  804. return(true);
  805. };
  807. ///////////////////////////////////////////////////////////////////////////////
  808. /// Method:  DrawPaddle
  809. /// Purpose: Draw the paddle in the playing area
  810. ///////////////////////////////////////////////////////////////////////////////
  811. /// Receives: nothing
  812. /// Returns:  true if paddle successfully drawn, otherwise false
  813. ///////////////////////////////////////////////////////////////////////////////
  814. bool CSuperBrickBreaker::DrawPaddle()
  815. {
  816. bool br = false;
  818. m_paddle.GetPaddleRects(&m_paddle_cnt, m_paddle_rects);
  820. for (int i = 0; i < m_paddle_cnt; i++)
  821. {
  822. br = DrawRectangle(&m_paddle_rects[i], m_boundary_clr);
  823. if (!br)
  824. {
  825. return(false);
  826. }
  828. br = Draw3DFrame(m_paddle_rects[i]);
  829. if (!br)
  830. {
  831. return(false);
  832. }
  833. }
  835. return(true);
  836. }
  838. ///////////////////////////////////////////////////////////////////////////////
  839. /// Method:  DrawPausedMenu
  840. /// Purpose: Draw the 'game paused' menu in the playing area on top of 
  841. ///          bricks
  842. ///////////////////////////////////////////////////////////////////////////////
  843. /// Receives: nothing
  844. /// Returns:  true if the menu is successfully drawn, otherwise false
  845. ///////////////////////////////////////////////////////////////////////////////
  846. bool CSuperBrickBreaker::DrawPausedMenu()
  847. {
  848.     bool br = false;
  850. ///////////////////////////////////////////////////////////////////////////
  851. /// draw the game paused shadow text
  852. ///////////////////////////////////////////////////////////////////////////
  853. br = DrawGDIText
  854.  (
  855.      /* text */ "Game Paused", 
  856.  /* red */  212,
  857.  /* green */ 208, 
  858.  /* blue */ 200, 
  859.  /* font */ m_menu_font, 
  860.  /* x */ 242,
  861.  /* y */ 77
  862.  );
  863.     if (!br)
  864. {
  865. return(false);
  866. }
  868. ///////////////////////////////////////////////////////////////////////////
  869. /// draw the game paused text
  870. ///////////////////////////////////////////////////////////////////////////
  871. br = DrawGDIText
  872.  (
  873.      /* text */ "Game Paused", 
  874.  /* red */  255,
  875.  /* green */ 255, 
  876.  /* blue */ 255, 
  877.  /* font */ m_menu_font, 
  878.  /* x */ 240,
  879.  /* y */ 75
  880.  );
  881.     if (!br)
  882. {
  883. return(false);
  884. }
  886. ///////////////////////////////////////////////////////////////////////////
  887. /// draw the resume game shadow text
  888. ///////////////////////////////////////////////////////////////////////////
  889. br = DrawGDIText
  890.  (
  891.      /* text */ "Resume Game", 
  892.  /* red */  212,
  893.  /* green */ 208, 
  894.  /* blue */ 200, 
  895.  /* font */ m_menu_font, 
  896.  /* x */ 314,
  897.  /* y */ 152
  898.  );
  899.     if (!br)
  900. {
  901. return(false);
  902. }
  904. ///////////////////////////////////////////////////////////////////////////
  905. /// draw the resume game text
  906. ///////////////////////////////////////////////////////////////////////////
  907. br = DrawGDIText
  908.  (
  909.      /* text */ "Resume Game", 
  910.  /* red */  255,
  911.  /* green */ 255, 
  912.  /* blue */ 255, 
  913.  /* font */ m_menu_font, 
  914.  /* x */ 312,
  915.  /* y */ 150
  916.  );
  917.     if (!br)
  918. {
  919. return(false);
  920. }
  922. ///////////////////////////////////////////////////////////////////////////
  923. /// draw the main menu shadow text
  924. ///////////////////////////////////////////////////////////////////////////
  925. br = DrawGDIText
  926.  (
  927.      /* text */ "Main Menu", 
  928.  /* red */  212,
  929.  /* green */ 208, 
  930.  /* blue */ 200, 
  931.  /* font */ m_menu_font, 
  932.  /* x */ 314,
  933.  /* y */ 207
  934.  );
  935.     if (!br)
  936. {
  937. return(false);
  938. }
  940. ///////////////////////////////////////////////////////////////////////////
  941. /// draw the main menu text
  942. ///////////////////////////////////////////////////////////////////////////
  943. br = DrawGDIText
  944.  (
  945.      /* text */ "Main Menu", 
  946.  /* red */  255,
  947.  /* green */ 255, 
  948.  /* blue */ 255, 
  949.  /* font */ m_menu_font, 
  950.  /* x */ 312,
  951.  /* y */ 205
  952.  );
  953.     if (!br)
  954. {
  955. return(false);
  956. }
  958. int l_menu_x = 0;
  959. int l_menu_y = 0;
  961. if (m_paused_state == PS_RESUME)
  962. {
  963. l_menu_x = 255;
  964. l_menu_y = 150;
  965. }
  966. else if (m_paused_state == PS_MAINMENU)
  967. {
  968. l_menu_x = 255;
  969. l_menu_y = 205;
  970. }
  971. else
  972. {
  973. return(false);
  974. }
  976. ///////////////////////////////////////////////////////////////////////////
  977. /// draw the 'chosen (->)' game shadow
  978. ///////////////////////////////////////////////////////////////////////////
  979.     br = DrawGDIText
  980.  (
  981.      /* text */ "->", 
  982.  /* red */  212,
  983.  /* green */ 208, 
  984.  /* blue */ 200, 
  985.  /* font */ m_menu_font, 
  986.  /* x */ l_menu_x + 2,
  987.  /* y */ l_menu_y + 2
  988.  );
  989.     if (!br)
  990. {
  991. return(false);
  992. }
  994. ///////////////////////////////////////////////////////////////////////////
  995. /// draw the 'chosen (->)' game
  996. ///////////////////////////////////////////////////////////////////////////
  997. br = DrawGDIText
  998.  (
  999.      /* text */ "->", 
  1000.  /* red */  255,
  1001.  /* green */ 255, 
  1002.  /* blue */ 255, 
  1003.  /* font */ m_menu_font, 
  1004.  /* x */ l_menu_x,
  1005.  /* y */ l_menu_y
  1006.  );
  1007.     if (!br)
  1008. {
  1009. return(false);
  1010. }
  1012. return(true);
  1013. }
  1015. ///////////////////////////////////////////////////////////////////////////////
  1016. /// Method:  DrawStartNextTurn
  1017. /// Purpose: Draw the 'READY' text before actually beginning the next turn
  1018. ///////////////////////////////////////////////////////////////////////////////
  1019. /// Receives: nothing
  1020. /// Returns:  true if the text is successfully drawn, otherwise false
  1021. ///////////////////////////////////////////////////////////////////////////////
  1022. bool CSuperBrickBreaker::DrawStartNextTurn()
  1023. {
  1024. bool br = false;
  1026. ///////////////////////////////////////////////////////////////////////////
  1027. /// draw the 'READY!' shadow text
  1028. ///////////////////////////////////////////////////////////////////////////
  1029. br = DrawGDIText
  1030.  (
  1031.      /* text */ "READY!", 
  1032.  /* red */  212,
  1033.  /* green */ 208, 
  1034.  /* blue */ 200, 
  1035.  /* font */ m_menu_font, 
  1036.  /* x */ 302,
  1037.  /* y */ 282
  1038.  );
  1039.     if (!br)
  1040. {
  1041. return(false);
  1042. }
  1044. ///////////////////////////////////////////////////////////////////////////
  1045. /// draw the 'READY!' text
  1046. ///////////////////////////////////////////////////////////////////////////
  1047. br = DrawGDIText
  1048.  (
  1049.      /* text */ "READY!", 
  1050.  /* red */  255,
  1051.  /* green */ 255, 
  1052.  /* blue */ 255, 
  1053.  /* font */ m_menu_font, 
  1054.  /* x */ 300,
  1055.  /* y */ 280
  1056.  );
  1057.     if (!br)
  1058. {
  1059. return(false);
  1060. }
  1062. return(true);
  1063. }
  1065. ///////////////////////////////////////////////////////////////////////////////
  1066. /// Method:  Draw3DFrame
  1067. /// Purpose: Draw a 3D frame around the passed rectangle
  1068. ///          NOTE: the frame is drawn around the INSIDE of the rectangle
  1069. ///////////////////////////////////////////////////////////////////////////////
  1070. /// Receives: rectangle around frame will be drawn
  1071. /// Returns:  true if frame successfully drawn, otherwise false
  1072. ///////////////////////////////////////////////////////////////////////////////
  1073. bool CSuperBrickBreaker::Draw3DFrame(const RECT p_rect)
  1074. {
  1075. RECT l_frame_rect;
  1076. bool br = false;
  1078. // first - draw left light frame
  1079. l_frame_rect.left = p_rect.left;
  1080. l_frame_rect.top  = p_rect.top;
  1081. l_frame_rect.right = p_rect.left + 1;
  1082. l_frame_rect.bottom = p_rect.bottom;
  1084. br = DrawRectangle(&l_frame_rect, m_3d_light_clr);
  1085. if (!br)
  1086. {
  1087. return(false);
  1088. }
  1090. // second - draw top light frame
  1091. l_frame_rect.left = p_rect.left;
  1092. l_frame_rect.top  = p_rect.top;
  1093. l_frame_rect.right = p_rect.right;
  1094. l_frame_rect.bottom = p_rect.top + 1;
  1096. br = DrawRectangle(&l_frame_rect, m_3d_light_clr);
  1097. if (!br)
  1098. {
  1099. return(false);
  1100. }
  1102. // third - draw right shadow frame
  1103. l_frame_rect.left = p_rect.right - 1;
  1104. l_frame_rect.top = p_rect.top;
  1105. l_frame_rect.right = p_rect.right;
  1106. l_frame_rect.bottom = p_rect.bottom;
  1108. br = DrawRectangle(&l_frame_rect, m_3d_shadow_clr);
  1109. if (!br)
  1110. {
  1111. return(false);
  1112. }
  1114. // last - draw bottom shadow frame
  1115. l_frame_rect.left = p_rect.left + 1;
  1116. l_frame_rect.top = p_rect.bottom - 1;
  1117. l_frame_rect.right = p_rect.right;
  1118. l_frame_rect.bottom = p_rect.bottom;
  1120. br = DrawRectangle(&l_frame_rect, m_3d_shadow_clr);
  1121. if (!br)
  1122. {
  1123. return(false);
  1124. }
  1126. return true;
  1127. }
  1129. ///////////////////////////////////////////////////////////////////////////////
  1130. /// Method:  GameInitialize
  1131. /// Purpose: Initialize any variable required by this game object
  1132. ///////////////////////////////////////////////////////////////////////////////
  1133. /// Receives: nothing
  1134. /// Returns:  true if game objects successfully initialized, otherwise false
  1135. ///////////////////////////////////////////////////////////////////////////////
  1136. bool CSuperBrickBreaker::GameInitialize()
  1137. {
  1138. // initialize color variables
  1139. InitializeColors();
  1141. m_menu_font = CreateFont 
  1142.      (
  1143.     /* height */ 60,
  1144.   /* width  */ 0, 
  1145.   /* escapement */ 0, 
  1146.   /* orientation */ 0, 
  1147.   /* weight */ FW_HEAVY, 
  1148.   /* italic */ FALSE, 
  1149.   /* underline */ FALSE, 
  1150.   /* strikeout */ FALSE, 
  1151.   /* char set */ DEFAULT_CHARSET, 
  1152.   /* output precision */ OUT_CHARACTER_PRECIS, 
  1153.   /* clip precision */ CLIP_DEFAULT_PRECIS, 
  1154.   /* font quality */ DEFAULT_QUALITY, 
  1155.   /* pitch and family */ DEFAULT_PITCH | FF_DONTCARE, 
  1156.   /* typeface name */ "MS Sans Serif"
  1157.   );
  1159. m_plain_font = CreateFont 
  1160.      (
  1161.     /* height */ 24,
  1162.   /* width  */ 0, 
  1163.   /* escapement */ 0, 
  1164.   /* orientation */ 0, 
  1165.   /* weight */ FW_HEAVY, 
  1166.   /* italic */ FALSE, 
  1167.   /* underline */ FALSE, 
  1168.   /* strikeout */ FALSE, 
  1169.   /* char set */ DEFAULT_CHARSET, 
  1170.   /* output precision */ OUT_CHARACTER_PRECIS, 
  1171.   /* clip precision */ CLIP_DEFAULT_PRECIS, 
  1172.   /* font quality */ DEFAULT_QUALITY, 
  1173.   /* pitch and family */ DEFAULT_PITCH | FF_DONTCARE, 
  1174.   /* typeface name */ "MS Sans Serif"
  1175.   );
  1177.     // initialize boundary rectangles
  1178. InitializePlayingArea();
  1180. // set the base properties for the bricks
  1181. // they are the same for all games
  1182.     m_bricks.SetTopLeftPosition(/* x */ DEFAULT_BRICK_START_X, /* y */ DEFAULT_BRICK_START_Y);
  1183.     m_bricks.SetBrickProperties
  1184.      (
  1185.      /* width */    DEFAULT_BRICK_WIDTH,
  1186.  /* height */   DEFAULT_BRICK_HEIGHT,
  1187.  /* h space */  DEFAULT_BRICK_HOR_SPACE,
  1188.  /* v_space  */ DEFAULT_BRICK_VER_SPACE
  1189.  );
  1191. bool br = false;
  1192. br = ProcessStateChange(/* new state */ GS_MAINMENU);
  1193. if (!br)
  1194. {
  1195. return(false);
  1196. }
  1198. return(true);
  1199. }
  1201. ///////////////////////////////////////////////////////////////////////////////
  1202. /// Method:  GameMain
  1203. /// Purpose: Perform the next game logic loop
  1204. ///////////////////////////////////////////////////////////////////////////////
  1205. /// Receives: nothing
  1206. /// Returns:  true if game loop successfully processed, otherwise false
  1207. ///////////////////////////////////////////////////////////////////////////////
  1208. bool CSuperBrickBreaker::GameMain()
  1209. {
  1210. bool br = false;
  1212.     ///////////////////////////////////////////////////////////////////////////
  1213. /// ensure we are in a 'Game Main' acceptable state:
  1214. /// - we cannot be in GS_INITIALIZE
  1215. ///////////////////////////////////////////////////////////////////////////
  1216. if (m_game_state == GS_INITIALIZE)
  1217. {
  1218. return(false);
  1219. }
  1221. ///////////////////////////////////////////////////////////////////////////
  1222. /// process the keyboard data (ie. move paddle, pause game, etc)
  1223. ///////////////////////////////////////////////////////////////////////////
  1224. br = ProcessKeyboard();
  1225. if (!br)
  1226. {
  1227. return(false);
  1228. }
  1230. ///////////////////////////////////////////////////////////////////////////
  1231. /// process the game objects -> if the game is not paused or awaiting the
  1232. /// start of the next turn
  1233. /// - move the paddle
  1234. /// - move the ball(s)
  1235. ///////////////////////////////////////////////////////////////////////////
  1236. if ( (m_game_state != GS_STARTTURN) && (m_game_state != GS_GAMEPAUSED) && (m_game_state != GS_GAMEOVER) )
  1237. {
  1238. br = ProcessPaddle();
  1239. if (!br)
  1240. {
  1241. return(false);
  1242. }
  1243. br = ProcessBalls();
  1244. if (!br)
  1245. {
  1246. return(false);
  1247. }
  1248. }
  1250. ///////////////////////////////////////////////////////////////////////////
  1251. /// start the next frame (scene)
  1252. ///////////////////////////////////////////////////////////////////////////
  1253. br = StartScene(m_black_clr);
  1254. if (!br)
  1255. {
  1256. return(false);
  1257. }
  1259. ///////////////////////////////////////////////////////////////////////////
  1260. /// draw the parts of the playing area not based on the 
  1261. /// current state of the game
  1262. /// - Boundary
  1263. /// - Bricks
  1264. /// - Paddle
  1265. /// - Score
  1266. /// - Turns Remaining
  1267. ///////////////////////////////////////////////////////////////////////////
  1268. br = DrawBoundary();
  1269. if (!br)
  1270. {
  1271. return(false);
  1272. }
  1274. br = DrawBricks();
  1275. if (!br)
  1276. {
  1277. return(false);
  1278. }
  1280. br = DrawPaddle();
  1281. if (!br)
  1282. {
  1283. return(false);
  1284. }
  1286. br = DrawBalls();
  1287. if (!br)
  1288. {
  1289. return(false);
  1290. }
  1292. br = DrawHeadingLine();
  1293. if (!br)
  1294. {
  1295. return(false);
  1296. }
  1298. ///////////////////////////////////////////////////////////////////////////
  1299. /// draw the playing area based on the current state
  1300. /// of the game
  1301. ///////////////////////////////////////////////////////////////////////////
  1302. switch(m_game_state)
  1303. {
  1304. case GS_MAINMENU:
  1305. {
  1306.             ///////////////////////////////////////////////////////////////////////////
  1307. /// draw the main menu text with the current item highlighted
  1308. ///////////////////////////////////////////////////////////////////////////
  1309. StartGDIDrawing();
  1310. br = DrawMainMenu();
  1311. if (!br)
  1312. {
  1313. return(false);
  1314. }
  1315. EndGDIDrawing();
  1316. } break;
  1318. case GS_STARTTURN:
  1319. {
  1320.             ///////////////////////////////////////////////////////////////////////////
  1321. /// draw the main menu text with the current item highlighted
  1322. ///////////////////////////////////////////////////////////////////////////
  1323. StartGDIDrawing();
  1324. br = DrawStartNextTurn();
  1325. if (!br)
  1326. {
  1327. return(false);
  1328. }
  1329. EndGDIDrawing();
  1330. } break;
  1332. case GS_GAMEPLAY:
  1333. {
  1334.             ///////////////////////////////////////////////////////////////////////////
  1335. /// no extra things to do
  1336. ///////////////////////////////////////////////////////////////////////////
  1337. } break;
  1339. case GS_GAMEPAUSED:
  1340. {
  1341.             ///////////////////////////////////////////////////////////////////////////
  1342. /// draw the paused menu
  1343. ///////////////////////////////////////////////////////////////////////////
  1344. StartGDIDrawing();
  1345. br = DrawPausedMenu();
  1346. if (!br)
  1347. {
  1348. return(false);
  1349. }
  1350. EndGDIDrawing();
  1352. } break;
  1354. case GS_GAMEOVER:
  1355. {
  1356.             ///////////////////////////////////////////////////////////////////////////
  1357. /// draw the game over menu
  1358. ///////////////////////////////////////////////////////////////////////////
  1359. StartGDIDrawing();
  1360. br = DrawGameOverMenu();
  1361. if (!br)
  1362. {
  1363. return(false);
  1364. }
  1365. EndGDIDrawing();
  1367. } break;
  1368. }
  1370.     ///////////////////////////////////////////////////////////////////////////
  1371. /// 'mark' the end of this frame and flip the back buffer
  1372. ///////////////////////////////////////////////////////////////////////////
  1373. br = EndScene();
  1374. if (!br)
  1375. {
  1376. return(false);
  1377. }
  1379. return(true);
  1380. }
  1382. ///////////////////////////////////////////////////////////////////////////////
  1383. /// Method:  GameShutdown
  1384. /// Purpose: Uninitialize any variable required by this game object
  1385. ///////////////////////////////////////////////////////////////////////////////
  1386. /// Receives: nothing
  1387. /// Returns:  true if game objects successfully uninitialized, otherwise false
  1388. ///////////////////////////////////////////////////////////////////////////////
  1389. bool CSuperBrickBreaker::GameShutdown()
  1390. {
  1391. return true;
  1392. };
  1394. ///////////////////////////////////////////////////////////////////////////////
  1395. /// Method:  InitializeBalls
  1396. /// Purpose: Set the 'ball' variables for the game
  1397. ///////////////////////////////////////////////////////////////////////////////
  1398. /// Receives: nothing
  1399. /// Returns:  nothing
  1400. ///////////////////////////////////////////////////////////////////////////////
  1401. void CSuperBrickBreaker::InitializeBalls()
  1402. {
  1403. m_balls_in_play = 0;
  1404. m_hit_top_boun_fg = false;
  1406. int m_temp_x = 23;
  1407. int m_temp_y = 295;
  1409. srand(GetTickCount());
  1410. m_temp_x += (rand()%120);
  1411. m_temp_y += (rand()%50);
  1414. m_ball[0].SetXPos(m_temp_x);
  1415. m_ball[0].SetYPos(m_temp_y);
  1416. m_ball[0].SetXVel(2);
  1417. m_ball[0].SetYVel(2);
  1418. m_ball[0].SetVelMultiplier(1);
  1419. m_ball[0].SetState(IDLE);
  1421. switch(m_game_type)
  1422. {
  1423. case SBB_STANDARD:
  1424. {
  1425. // no extra initialization required
  1426. } break;
  1428. case SBB_DOUBLE:
  1429. {
  1430. m_first_paddle_hit = false;
  1432. m_ball[1].SetXPos(23);
  1433. m_ball[1].SetYPos(295);
  1434. m_ball[1].SetXVel(2);
  1435. m_ball[1].SetYVel(2);
  1436. m_ball[1].SetVelMultiplier(1);
  1437. m_ball[1].SetState(IDLE);
  1438. } break;
  1440. case SBB_ESCAPE:
  1441. {
  1442. RECT m_ball_rect;
  1444. m_ball_rect.top = DEFAULT_BRICK_START_Y + (2 * (DEFAULT_BRICK_HEIGHT + DEFAULT_BRICK_VER_SPACE) ) - DEFAULT_BRICK_VER_SPACE;
  1445. m_ball_rect.left = DEFAULT_BRICK_START_X + (2 * (DEFAULT_BRICK_WIDTH + DEFAULT_BRICK_HOR_SPACE) ) - DEFAULT_BRICK_HOR_SPACE;
  1446. m_ball_rect.right = m_ball_rect.left + (2 * (DEFAULT_BRICK_WIDTH + DEFAULT_BRICK_HOR_SPACE) ) + DEFAULT_BRICK_HOR_SPACE;
  1447. m_ball_rect.bottom = m_ball_rect.top + (2 * (DEFAULT_BRICK_HEIGHT + DEFAULT_BRICK_VER_SPACE) ) + DEFAULT_BRICK_VER_SPACE;
  1449. if (m_game_turns_remaining < 5)
  1450. {
  1451. if ((m_ball[1].GetState() != CAPTIVE) && (!m_new_level_fg))
  1452. {
  1453. // the ball has been freed and has been lost, do nothing
  1454. }
  1455. else
  1456. {
  1457. m_ball[1].SetXPos(151);
  1458. m_ball[1].SetYPos(133);
  1459. m_ball[1].SetXVel(2);
  1460. m_ball[1].SetYVel(2);
  1461. m_ball[1].SetVelMultiplier(2);
  1462. m_ball[1].SetCaptiveRect(m_ball_rect);
  1463. }
  1464. }
  1465. else
  1466. {
  1467. m_ball[1].SetXPos(151);
  1468. m_ball[1].SetYPos(133);
  1469. m_ball[1].SetXVel(2);
  1470. m_ball[1].SetYVel(2);
  1471. m_ball[1].SetVelMultiplier(2);
  1472. m_ball[1].SetState(CAPTIVE);
  1473. m_ball[1].SetCaptiveRect(m_ball_rect);
  1474. }
  1476. m_ball_rect.top = DEFAULT_BRICK_START_Y + (2 * (DEFAULT_BRICK_HEIGHT + DEFAULT_BRICK_VER_SPACE) ) - DEFAULT_BRICK_VER_SPACE;
  1477. m_ball_rect.left = DEFAULT_BRICK_START_X + (8 * (DEFAULT_BRICK_WIDTH + DEFAULT_BRICK_HOR_SPACE) ) - DEFAULT_BRICK_HOR_SPACE;
  1478. m_ball_rect.right = m_ball_rect.left + (2 * (DEFAULT_BRICK_WIDTH + DEFAULT_BRICK_HOR_SPACE) ) + DEFAULT_BRICK_HOR_SPACE;
  1479. m_ball_rect.bottom = m_ball_rect.top + (2 * (DEFAULT_BRICK_HEIGHT + DEFAULT_BRICK_VER_SPACE) ) + DEFAULT_BRICK_VER_SPACE;
  1481. if (m_game_turns_remaining < 5)
  1482. {
  1483. if ((m_ball[2].GetState() != CAPTIVE) && (!m_new_level_fg))
  1484. {
  1485. // do nothing
  1486. }
  1487. else
  1488. {
  1489. m_ball[2].SetXPos(634);
  1490. m_ball[2].SetYPos(133);
  1491. m_ball[2].SetXVel(-2);
  1492. m_ball[2].SetYVel(2);
  1493. m_ball[2].SetVelMultiplier(2);
  1494. m_ball[2].SetCaptiveRect(m_ball_rect);
  1495. }
  1496. }
  1497. else
  1498. {
  1499. m_ball[2].SetXPos(634);
  1500. m_ball[2].SetYPos(133);
  1501. m_ball[2].SetXVel(-2);
  1502. m_ball[2].SetYVel(2);
  1503. m_ball[2].SetVelMultiplier(2);
  1504. //m_ball[2].SetState(CAPTIVE);
  1505. m_ball[2].SetCaptiveRect(m_ball_rect);
  1506. }
  1507. } break;
  1509. }
  1511. return;
  1512. };
  1514. ///////////////////////////////////////////////////////////////////////////////
  1515. /// Method:  InitializeBricks
  1516. /// Purpose: Set the 'bricks' variables for the game
  1517. ///////////////////////////////////////////////////////////////////////////////
  1518. /// Receives: nothing
  1519. /// Returns:  nothing
  1520. ///////////////////////////////////////////////////////////////////////////////
  1521. void CSuperBrickBreaker::InitializeBricks()
  1522. {
  1523. ///////////////////////////////////////////////////////////////////////////
  1524. /// reset the bricks based on the current game settings
  1525. ///////////////////////////////////////////////////////////////////////////
  1526. m_bricks.SetRowColProperties
  1527.      (
  1528.      /* num rows */   DEFAULT_BRICK_ROWS,
  1529.  /* num cols */   DEFAULT_BRICK_COLS,
  1530.  /* row colors */ m_brick_colors,
  1531.  /* row points */ m_brick_points,
  1532.  /* row vel */    m_brick_reflect_vel
  1533.  );
  1534. m_bricks.InitializeBricks();
  1536. ///////////////////////////////////////////////////////////////////////////
  1537. /// if we are playing ESCAPE, remove the bricks that 'hold' the 
  1538. /// two captive balls
  1539. ///////////////////////////////////////////////////////////////////////////
  1540. if (m_game_type == SBB_ESCAPE)
  1541. {
  1542. m_bricks.SetBrickState(/* row */ 3, /* col */ 3, /* state */ BS_SKIP);
  1543. m_bricks.SetBrickState(/* row */ 3, /* col */ 4, /* state */ BS_SKIP);
  1544. m_bricks.SetBrickState(/* row */ 4, /* col */ 3, /* state */ BS_SKIP);
  1545. m_bricks.SetBrickState(/* row */ 4, /* col */ 4, /* state */ BS_SKIP);
  1547. m_bricks.SetBrickState(/* row */ 3, /* col */  9, /* state */ BS_SKIP);
  1548. m_bricks.SetBrickState(/* row */ 3, /* col */ 10, /* state */ BS_SKIP);
  1549. m_bricks.SetBrickState(/* row */ 4, /* col */  9, /* state */ BS_SKIP);
  1550. m_bricks.SetBrickState(/* row */ 4, /* col */ 10, /* state */ BS_SKIP);
  1551. }
  1553. return;
  1554. }
  1556. ///////////////////////////////////////////////////////////////////////////////
  1557. /// Method:  InitializeColors
  1558. /// Purpose: Set the color variables from the DirectDraw color masks
  1559. ///////////////////////////////////////////////////////////////////////////////
  1560. /// Receives: nothing
  1561. /// Returns:  nothing
  1562. ///////////////////////////////////////////////////////////////////////////////
  1563. void CSuperBrickBreaker::InitializeColors()
  1564. {
  1565.     m_3d_light_clr  = RGBto16BitColor(/* red */ 255, /* green */ 255, /* blue */ 255);
  1566.     m_3d_shadow_clr = RGBto16BitColor(/* red */ 132, /* green */ 130, /* blue */ 132);
  1567.     m_black_clr     = RGBto16BitColor(/* red */   0, /* green */   0, /* blue */   0);
  1568.     m_blue_clr      = RGBto16BitColor(/* red */   0, /* green */   0, /* blue */ 255);
  1569.     m_boundary_clr  = RGBto16BitColor(/* red */ 214, /* green */ 211, /* blue */ 206);
  1570.     m_green_clr     = RGBto16BitColor(/* red */   0, /* green */ 130, /* blue */   0);
  1571.     m_red_clr       = RGBto16BitColor(/* red */ 255, /* green */   0, /* blue */   0);
  1572.     m_yellow_clr    = RGBto16BitColor(/* red */ 255, /* green */ 255, /* blue */   0);
  1573.     m_white_clr     = RGBto16BitColor(/* red */ 255, /* green */ 255, /* blue */ 255);
  1575. return;
  1576. };
  1578. ///////////////////////////////////////////////////////////////////////////////
  1579. /// Method:  InitializeNewGame
  1580. /// Purpose: Reset all the game variables based on the current game type
  1581. ///////////////////////////////////////////////////////////////////////////////
  1582. /// Receives: nothing
  1583. /// Returns:  nothing
  1584. ///////////////////////////////////////////////////////////////////////////////
  1585. void CSuperBrickBreaker::InitializeNewGame()
  1586. {
  1587. m_score = 0;
  1588. m_level = 1;
  1590. switch(m_game_type)
  1591. {
  1592. case SBB_STANDARD:
  1593. {
  1594. m_num_balls = 1;
  1595. m_game_turns_remaining = 5;
  1596. } break;
  1598. case SBB_DOUBLE:
  1599. {
  1600. m_num_balls = 2;
  1601.     m_game_turns_remaining = 3;
  1602. } break;
  1604. case SBB_ESCAPE:
  1605. {
  1606. m_num_balls = 3;
  1607.     m_game_turns_remaining = 5;
  1608. } break;
  1609. }
  1611. InitializeBalls();
  1612. InitializeNewLevel();
  1613. InitializeBricks();
  1614. InitializePaddle();
  1615. };
  1617. ///////////////////////////////////////////////////////////////////////////////
  1618. /// Method:  InitializeNewLevel
  1619. /// Purpose: Intialize the bricks and balls for the start of a new level
  1620. ///////////////////////////////////////////////////////////////////////////////
  1621. /// Receives: nothing
  1622. /// Returns:  nothing
  1623. /////////////////////////////////////////////////////////////////////////////// 
  1624. void CSuperBrickBreaker::InitializeNewLevel()
  1625. {
  1626. m_brick_colors[0] = m_red_clr;
  1627. m_brick_colors[1] = m_red_clr;
  1628. m_brick_colors[2] = m_yellow_clr;
  1629. m_brick_colors[3] = m_yellow_clr;
  1630. m_brick_colors[4] = m_green_clr;
  1631. m_brick_colors[5] = m_green_clr;
  1632. m_brick_colors[6] = m_blue_clr;
  1633. m_brick_colors[7] = m_blue_clr;
  1635. if (m_level >= 3)
  1636. {
  1637. int m_stop = m_level;
  1639. if (m_level > 7)
  1640. {
  1641. m_stop = 7;
  1642. }
  1643. for (int i = 0; i < m_stop; i++)
  1644. {
  1645.     m_brick_colors[i] = m_red_clr;
  1646. }
  1647.     }
  1649. for (int i = 0; i <= 7; i++)
  1650. {
  1651. if (m_brick_colors[i] == m_red_clr)
  1652. {
  1653. m_brick_points[i] = 16;
  1654. m_brick_reflect_vel[i] = 4;
  1655. }
  1656. else if (m_brick_colors[i] == m_yellow_clr)
  1657. {
  1658. m_brick_points[i] = 8;
  1659. m_brick_reflect_vel[i] = 3;
  1660. }
  1661. else if (m_brick_colors[i] == m_green_clr)
  1662. {
  1663. m_brick_points[i] = 4;
  1664. m_brick_reflect_vel[i] = 2;
  1665. }
  1666. else if (m_brick_colors[i] == m_blue_clr)
  1667. {
  1668. m_brick_points[i] = 2;
  1669. m_brick_reflect_vel[i] = 1;
  1670. }
  1671. }
  1673. switch(m_game_type)
  1674. {
  1675. case SBB_STANDARD:
  1676. {
  1677. // no extra initialization required
  1678. } break;
  1680. case SBB_DOUBLE:
  1681. {
  1682. // no extra initialization required
  1683. } break;
  1685. case SBB_ESCAPE:
  1686. {
  1687.     m_ball[1].SetState(CAPTIVE);
  1688. m_ball[2].SetState(CAPTIVE);
  1689. } break;
  1691. }
  1692. }
  1694. ///////////////////////////////////////////////////////////////////////////////
  1695. /// Method:  InitializePaddle
  1696. /// Purpose: Set the required default paddle properties and limits
  1697. ///////////////////////////////////////////////////////////////////////////////
  1698. /// Receives: nothing
  1699. /// Returns:  nothing
  1700. ///////////////////////////////////////////////////////////////////////////////
  1701. void CSuperBrickBreaker::InitializePaddle()
  1702. {
  1703. int l_cnt = 1;
  1705. switch(m_game_type) 
  1706. {
  1707. case SBB_STANDARD:
  1708.   {
  1709.      l_cnt = PADDLE_COUNT_STANDARD;
  1710.   }
  1711.   break;
  1712. case SBB_DOUBLE:
  1713.   {
  1714.      l_cnt = PADDLE_COUNT_DOUBLE;
  1715.   }
  1716.   break;
  1717. case SBB_ESCAPE:
  1718.   {
  1719.      l_cnt = PADDLE_COUNT_ESCAPE;
  1720.   }
  1721.   break;
  1722. }
  1723. m_paddle.SetBaseProperties
  1724.      (
  1725.      /* p_cnt*/        l_cnt, 
  1726.  /* p_hor_space */ DEFAULT_PADDLE_HOR_SPACE, 
  1727.  /* p_length */    DEFAULT_PADDLE_STANDARD_LENGTH, 
  1728.  /* p_height */    DEFAULT_PADDLE_HEIGHT
  1729.  );
  1730. m_paddle.SetPaddleLimits
  1731.      (
  1732.      /* p_min_limit */    23, 
  1733.  /* p_max_limit */    776, 
  1734.  /* p_bottom_limit */ 597
  1735.   );
  1736. };
  1738. ///////////////////////////////////////////////////////////////////////////////
  1739. /// Method:  InitializePlayingArea
  1740. /// Purpose: Set the boundary (playing area) rect variables
  1741. ///////////////////////////////////////////////////////////////////////////////
  1742. /// Receives: nothing
  1743. /// Returns:  nothing
  1744. ///////////////////////////////////////////////////////////////////////////////
  1745. void CSuperBrickBreaker::InitializePlayingArea()
  1746. {
  1747.     m_left_boun_rect.left   =   0;
  1748. m_left_boun_rect.top    =  30;
  1749. m_left_boun_rect.right  =  23;
  1750. m_left_boun_rect.bottom = 599;
  1752.     m_top_boun_rect.left   =   0;
  1753. m_top_boun_rect.top    =  30;
  1754. m_top_boun_rect.right  = 799;
  1755. m_top_boun_rect.bottom =  53;
  1757. m_right_boun_rect.left   = 776;
  1758. m_right_boun_rect.top    =  30;
  1759. m_right_boun_rect.right  = 799;
  1760. m_right_boun_rect.bottom = 599;
  1762. m_left_3d_light_rect.left   =   0;
  1763. m_left_3d_light_rect.top    =  30;
  1764. m_left_3d_light_rect.right  =   1;
  1765. m_left_3d_light_rect.bottom = 599;
  1767. m_left_3d_shadow_rect.left   =  22;
  1768. m_left_3d_shadow_rect.top    =  53;
  1769. m_left_3d_shadow_rect.right  =  23;
  1770. m_left_3d_shadow_rect.bottom = 599;
  1772. m_top_3d_light_rect.left   =   0;
  1773. m_top_3d_light_rect.top    =  30;
  1774. m_top_3d_light_rect.right  = 799;
  1775. m_top_3d_light_rect.bottom =  31;
  1777. m_top_3d_shadow_rect.left   =  22;
  1778. m_top_3d_shadow_rect.top    =  52;
  1779. m_top_3d_shadow_rect.right  = 776;
  1780. m_top_3d_shadow_rect.bottom =  53;
  1782. m_right_3d_light_rect.left   = 776;
  1783. m_right_3d_light_rect.top    =  53;
  1784. m_right_3d_light_rect.right  = 777;
  1785. m_right_3d_light_rect.bottom = 599;
  1787. m_right_3d_shadow_rect.left   = 798;
  1788. m_right_3d_shadow_rect.top    =  30;
  1789. m_right_3d_shadow_rect.right  = 799;
  1790. m_right_3d_shadow_rect.bottom = 599;
  1792.     m_playing_area_rect.left = 23;
  1793. m_playing_area_rect.top = 53;
  1794. m_playing_area_rect.right = 776;
  1795. m_playing_area_rect.bottom = 598;
  1797. return;
  1798. };
  1800. ///////////////////////////////////////////////////////////////////////////////
  1801. /// Method:  IsBrickAtBallLocation
  1802. /// Purpose: Determine if a brick is currently at the location of the ball
  1803. ///////////////////////////////////////////////////////////////////////////////
  1804. /// Receives: RECT describing current position of a ball
  1805. /// Returns:  true if a brick (with a NORMAL state) exists at the ball location
  1806. ///           pointer to TBrick structure of the brick that exists at the location
  1807. ///////////////////////////////////////////////////////////////////////////////
  1808. bool CSuperBrickBreaker::IsBrickAtBallLocation(const RECT p_ball_rect, TBrick* l_hit_brick)
  1809. {
  1810. TBallCorner l_ball_corner[4];
  1811. EIntersect  l_result = IS_NONE;
  1813. /*************************
  1814. ** top left corner
  1815. *************************/
  1816. l_ball_corner[0].x = p_ball_rect.left;
  1817. l_ball_corner[0].y = p_ball_rect.top;
  1819.     /*************************
  1820. ** top right corner
  1821. *************************/
  1822. l_ball_corner[1].x = p_ball_rect.right;
  1823. l_ball_corner[1].y = p_ball_rect.top;
  1825. /*************************
  1826. ** bottom right corner
  1827. *************************/
  1828. l_ball_corner[2].x = p_ball_rect.right;
  1829. l_ball_corner[2].y = p_ball_rect.bottom;
  1831. /*************************
  1832. ** bottom left corner
  1833. *************************/
  1834. l_ball_corner[3].x = p_ball_rect.left;
  1835. l_ball_corner[3].y = p_ball_rect.bottom;
  1837. int  j = 0;
  1839. ///////////////////////////////////////////////////////////////////////////
  1840. /// loop through each of the ball corners to determine if the ball 
  1841. /// struck the paddle
  1842. ///////////////////////////////////////////////////////////////////////////
  1843. while (j < 4)
  1844. {
  1845. bool l_is_brick = m_bricks.IsBrickAtPosition
  1846.          (
  1847.          /* x */     l_ball_corner[j].x, 
  1848.  /* y */     l_ball_corner[j].y, 
  1849.  /* brick */ l_hit_brick 
  1850.  );
  1851. if (l_is_brick)
  1852. {
  1853. if (( (l_ball_corner[j].x >= l_hit_brick->rect.left) && (l_ball_corner[j].x <= l_hit_brick->rect.right) )
  1854.     &&  ( (l_ball_corner[j].y >= l_hit_brick->rect.top)  && (l_ball_corner[j].y <= l_hit_brick->rect.bottom) )
  1855. && (l_hit_brick->state == BS_NORMAL) )
  1856. {
  1857.     return(true);
  1858. }
  1859. }
  1860. j++;
  1861. }
  1863. return(false);
  1864. }
  1867. ///////////////////////////////////////////////////////////////////////////////
  1868. /// Method:  ProcessBalls
  1869. /// Purpose: Set the 'ball' variables for the next frame
  1870. ///////////////////////////////////////////////////////////////////////////////
  1871. /// Receives: nothing
  1872. /// Returns:  true if the balls were handled (moved) successfully
  1873. ///////////////////////////////////////////////////////////////////////////////
  1874. bool CSuperBrickBreaker::ProcessBalls()
  1875. {
  1876. bool br = false;
  1879. if (m_game_state == GS_GAMEPAUSED)
  1880. {
  1881. return(true);
  1882. }
  1884. ///////////////////////////////////////////////////////////////////////////
  1885. /// loop through each ball
  1886. ///////////////////////////////////////////////////////////////////////////
  1887.     for (int i = 0; i < m_num_balls; i++)
  1888. {
  1889. int l_x_pos = m_ball[i].GetXPos();
  1890. int l_y_pos = m_ball[i].GetYPos();
  1891. int l_x_vel = m_ball[i].GetVelMultiplier() * m_ball[i].GetXVel();
  1892. int l_y_vel = m_ball[i].GetVelMultiplier() * m_ball[i].GetYVel();
  1894. RECT l_ball_rect;
  1897. EBallState l_ball_state = m_ball[i].GetState();
  1899. EIntersect l_intersect = IS_NONE;
  1901. if ( (l_ball_state == FREE) || (l_ball_state == CAPTIVE) )
  1902. {
  1903. ///////////////////////////////////////////////////////////////////////
  1904. /// set new ball position based on current velocity
  1905. ///////////////////////////////////////////////////////////////////////
  1906. l_x_pos += l_x_vel;
  1907. l_y_pos += l_y_vel;
  1908. m_ball[i].SetXYPos(l_x_pos, l_y_pos);
  1910. l_ball_rect.top    = l_y_pos;
  1911. l_ball_rect.left   = l_x_pos;
  1912. l_ball_rect.right  = l_x_pos + BALL_WIDTH;
  1913. l_ball_rect.bottom = l_y_pos + BALL_HEIGHT;
  1915.             ///////////////////////////////////////////////////////////////////////
  1916. /// process the ball as a free ball
  1917. ///////////////////////////////////////////////////////////////////////
  1918. if (l_ball_state == FREE)
  1919. {
  1920. ///////////////////////////////////////////////////////////////////
  1921. /// determine if the ball hit one of the playing area boundaries
  1922. ///////////////////////////////////////////////////////////////////
  1923.                 if (l_ball_rect.left <= m_playing_area_rect.left)
  1924. {
  1925. l_x_pos = m_playing_area_rect.left;
  1926. l_intersect = IS_RIGHT; // ie. intersect right side of left boundary
  1927. }
  1928.  if (l_ball_rect.right >= m_playing_area_rect.right)
  1929. {
  1930. l_x_pos = m_playing_area_rect.right - BALL_WIDTH;
  1931. l_intersect = IS_LEFT;
  1932. }
  1933.  if (l_ball_rect.top <= m_playing_area_rect.top)
  1934. {
  1935. l_y_pos = m_playing_area_rect.top;
  1936. l_intersect = IS_BOTTOM;
  1938. if (!m_hit_top_boun_fg)
  1939. {
  1940. m_hit_top_boun_fg = true;
  1941. m_paddle.SetLength(DEFAULT_PADDLE_SHORT_LENGTH);
  1942. }
  1943. }
  1944.  if (l_ball_rect.bottom >= m_playing_area_rect.bottom)
  1945. {
  1946. --m_balls_in_play;
  1947. m_ball[i].SetState(LOST);
  1949. if (m_balls_in_play == 0)
  1950. {
  1951. if (m_game_turns_remaining == 0)
  1952. {
  1953. ProcessStateChange(/* new state */ GS_GAMEOVER);
  1954. return(true);
  1955. }
  1956. else
  1957. {
  1958. --m_game_turns_remaining;
  1959. ProcessStateChange(/* new state */ GS_STARTTURN);
  1960. return(true);
  1961. }
  1962. }
  1963. }
  1965. ///////////////////////////////////////////////////////////////////
  1966. /// determine if the ball hit the paddle
  1967. ///////////////////////////////////////////////////////////////////
  1968. if (l_intersect == IS_NONE) // didn't hit the boundary
  1969. {
  1970. l_intersect = CheckHitPaddle(l_ball_rect);
  1971. if (l_intersect != IS_NONE)
  1972. {
  1973. // if we are playing 'Double' release the second ball on
  1974. // first hit of the paddle
  1975. if ( (!m_first_paddle_hit) && (m_game_type == SBB_DOUBLE) )
  1976. {
  1977. m_first_paddle_hit = true;
  1979. if (m_game_type == SBB_DOUBLE)
  1980. {
  1981. m_ball[1].SetState(FREE);
  1982. m_balls_in_play++;
  1983. }
  1984. }
  1985. }
  1986. }
  1988. ///////////////////////////////////////////////////////////////////
  1989. /// determine if the ball hit a brick
  1990. ///////////////////////////////////////////////////////////////////
  1991. if (l_intersect == IS_NONE) // didn't hit boundary or paddle
  1992. {
  1993. TBrick l_hit_brick;
  1994. l_intersect = CheckHitBrick(l_ball_rect, &l_hit_brick);
  1995. if (l_intersect != IS_NONE)
  1996. {
  1997. m_bricks.SetBrickState(l_hit_brick.row, l_hit_brick.col, BS_HIT);
  1998. m_score += l_hit_brick.point_value;
  1999. if (m_ball[i].GetVelMultiplier() > l_hit_brick.reflect_vel)
  2000. {
  2001. m_ball[i].SetVelMultiplier(m_ball[i].GetVelMultiplier() - 1);
  2002. }
  2003. else
  2004. {
  2005. m_ball[i].SetVelMultiplier(l_hit_brick.reflect_vel);
  2006. }
  2008. if (m_bricks.GetBricksRemaining() == 0)
  2009. {
  2010. m_new_level_fg = true;
  2011. m_level++;
  2012. InitializeNewLevel();
  2013. InitializeBalls();
  2014. InitializeBricks();
  2015. ProcessStateChange(/* new state */ GS_STARTTURN);
  2016. return(true);
  2017. }
  2018. }
  2019. }
  2021. if (l_intersect != IS_NONE)
  2022. {
  2023. m_ball[i].SetXYPos(l_x_pos, l_y_pos);
  2024. }
  2025. }
  2026. ///////////////////////////////////////////////////////////////////////
  2027. /// process the ball as a captive ball
  2028. ///////////////////////////////////////////////////////////////////////
  2029. else if (l_ball_state == CAPTIVE)
  2030. {
  2031. RECT   l_captive_rect = m_ball[i].GetCaptiveRect();
  2032. TBrick l_hit_brick;
  2034. int l_temp_x = 0;
  2035. int l_temp_y = 0;
  2036. if (l_ball_rect.left <= l_captive_rect.left)
  2037. {
  2038. l_intersect = IS_RIGHT;
  2039. l_temp_x = l_captive_rect.left;
  2040. l_temp_y = l_y_pos;
  2041. }
  2042. else if (l_ball_rect.top <= l_captive_rect.top)
  2043. {
  2044. l_intersect = IS_BOTTOM;
  2045. l_temp_x = l_x_pos;
  2046. l_temp_y = l_captive_rect.top;
  2047. }
  2048. else if (l_ball_rect.right >= l_captive_rect.right)
  2049. {
  2050. l_intersect = IS_LEFT;
  2051. l_temp_x = (l_captive_rect.right - BALL_WIDTH);
  2052. l_temp_y = l_y_pos;
  2053. }
  2054. else if (l_ball_rect.bottom >= l_captive_rect.bottom)
  2055. {
  2056. l_intersect = IS_TOP;
  2057. l_temp_x = l_x_pos;
  2058. l_temp_y = (l_captive_rect.bottom - BALL_HEIGHT);
  2059. }
  2061. if (l_intersect != IS_NONE)
  2062. {
  2063. bool l_is_brick = IsBrickAtBallLocation(l_ball_rect, &l_hit_brick);
  2064. if (l_is_brick)
  2065. {
  2067. if (l_hit_brick.state == BS_NORMAL)
  2068. {
  2069. // ball is still captive, set position to hit boundary
  2070. m_ball[i].SetXYPos(l_temp_x, l_temp_y);
  2071. }
  2072. else if (l_hit_brick.state == BS_NORMAL)
  2073. {
  2074. m_ball[i].SetState(FREE);
  2075. m_balls_in_play++;
  2076. }
  2077. }
  2078. else 
  2079. {
  2080. l_intersect = IS_NONE;
  2081. m_ball[i].SetState(FREE);
  2082. m_balls_in_play++;
  2083. }
  2084. }
  2085. }
  2087. if ( (l_intersect == IS_TOP) || (l_intersect == IS_BOTTOM) )
  2088. {
  2089.     m_ball[i].ReflectY();
  2090. }
  2091. else if ( (l_intersect == IS_LEFT) || (l_intersect == IS_RIGHT) )
  2092. {
  2093.     m_ball[i].ReflectX();
  2094. }
  2096. }
  2097. }
  2099. return(true);
  2100. };
  2102. ///////////////////////////////////////////////////////////////////////////////
  2103. /// Method:  ProcessKeyboard
  2104. /// Purpose: Process the DirectInput keyboard state information based 
  2105. ///          the current state of the game
  2106. ///////////////////////////////////////////////////////////////////////////////
  2107. /// Receives: nothing
  2108. /// Returns:  nothing
  2109. ///////////////////////////////////////////////////////////////////////////////
  2110. bool CSuperBrickBreaker::ProcessKeyboard()
  2111. {
  2112. bool br = false;
  2114. ///////////////////////////////////////////////////////////////////////////
  2115. /// retrieve the keyboard data from DirectInput
  2116. ///////////////////////////////////////////////////////////////////////////
  2117. br = GetKeyboardState(m_key_state);
  2118. if (!br)
  2119. {
  2120. return(false);
  2121. }
  2123. ///////////////////////////////////////////////////////////////////////////
  2124. /// interpret the keyboard data based on the current state
  2125. /// of the game
  2126. ///////////////////////////////////////////////////////////////////////////
  2127. switch(m_game_state)
  2128. {
  2129. case GS_MAINMENU:  /// the main menu is currently displayed to the player
  2130. {
  2131. ///////////////////////////////////////////////////////////////////////////
  2132.         /// user pressed escape --> end the game
  2133.         ///////////////////////////////////////////////////////////////////////////
  2134.             if (m_key_state[DIK_ESCAPE] & 0x80)
  2135. {
  2137. PostQuitMessage(0);
  2138. }
  2139.             ///////////////////////////////////////////////////////////////////////////
  2140.         /// user pressed up arrow --> set next game type
  2141.         ///////////////////////////////////////////////////////////////////////////
  2142. else if (m_key_state[DIK_UP] & 0x80)
  2143. {
  2144. switch(m_game_type)
  2145. {
  2146. case SBB_STANDARD:
  2147. {
  2148. m_game_type = SBB_ESCAPE;
  2149. } break;
  2151. case SBB_DOUBLE:
  2152. {
  2153. m_game_type = SBB_STANDARD;
  2154. } break;
  2156. case SBB_ESCAPE:
  2157. {
  2158. m_game_type = SBB_DOUBLE;
  2159. } break;
  2160. }
  2161. InitializeNewGame();
  2162. }
  2163. ///////////////////////////////////////////////////////////////////////////
  2164.         /// user pressed down arrow --> set next game type
  2165.         ///////////////////////////////////////////////////////////////////////////
  2166.             else if (m_key_state[DIK_DOWN] & 0x80)
  2167. {
  2168. switch(m_game_type)
  2169. {
  2170. case SBB_STANDARD:
  2171. {
  2172. m_game_type = SBB_DOUBLE;
  2173. } break;
  2175. case SBB_DOUBLE:
  2176. {
  2177. m_game_type = SBB_ESCAPE;
  2178. } break;
  2180. case SBB_ESCAPE:
  2181. {
  2182. m_game_type = SBB_STANDARD;
  2183. } break;
  2184. }
  2185. InitializeNewGame();
  2186. }
  2187. ///////////////////////////////////////////////////////////////////////////
  2188.         /// user pressed return or space bar --> start game based 
  2189. /// on currently selected game
  2190.         ///////////////////////////////////////////////////////////////////////////
  2191. else if ( (m_key_state[DIK_RETURN] & 0x80) || (m_key_state[DIK_SPACE] & 0x80) )
  2192. {
  2193. --m_game_turns_remaining;
  2194.                 br = ProcessStateChange(/* new state */ GS_STARTTURN);
  2195. if (!br)
  2196. {
  2197. return(false);
  2198. }
  2199. }
  2201. } break;
  2203. case GS_STARTTURN: /// the READY message is displayed to warn player of start
  2204.                /// of the next turn (or start of the game)
  2205. {
  2207. ///////////////////////////////////////////////////////////////////////////
  2208.         /// user pressed return or space bar --> move into game play state
  2209.         ///////////////////////////////////////////////////////////////////////////
  2210. if ( (m_key_state[DIK_RETURN] & 0x80) || (m_key_state[DIK_SPACE] & 0x80) )
  2211. {
  2212.                 br = ProcessStateChange(/* new state */ GS_GAMEPLAY);
  2213. if (!br)
  2214. {
  2215. return(false);
  2216. }
  2217. }
  2218. } break;
  2220. case GS_GAMEPLAY:  /// we are in a 'general' state of play (ie. the balls are 
  2221.                /// still in play and there are bricks remaining
  2222. {
  2223.             ///////////////////////////////////////////////////////////////////////////
  2224.         /// user pressed escape --> go to 'game paused' state
  2225.         ///////////////////////////////////////////////////////////////////////////
  2226.             if (m_key_state[DIK_ESCAPE] & 0x80)
  2227. {
  2228. br = ProcessStateChange(/* new state */ GS_GAMEPAUSED);
  2229. if (!br)
  2230. {
  2231. return(false);
  2232. }
  2233. //PostQuitMessage(0);
  2234. }
  2236. ///////////////////////////////////////////////////////////////////////////
  2237.         /// user pressed left arrow --> set negative paddle velocity
  2238.         ///////////////////////////////////////////////////////////////////////////
  2239. if (m_key_state[DIK_LEFT] & 0x80)
  2240. {
  2241. m_paddle.SetXVel(-PADDLE_VELOCITY);
  2242. }
  2243. ///////////////////////////////////////////////////////////////////////////
  2244.         /// user pressed right arrow --> set positive paddle velocity
  2245.         ///////////////////////////////////////////////////////////////////////////
  2246. else if (m_key_state[DIK_RIGHT] & 0x80)
  2247. {
  2248. m_paddle.SetXVel(PADDLE_VELOCITY);
  2249. }
  2250. } break;
  2252. case GS_GAMEPAUSED:
  2253. {
  2254.             ///////////////////////////////////////////////////////////////////////////
  2255.         /// user pressed up arrow --> set next paused menu selection
  2256.         ///////////////////////////////////////////////////////////////////////////
  2257. if (m_key_state[DIK_UP] & 0x80)
  2258. {
  2259. switch(m_paused_state)
  2260. {
  2261. case PS_RESUME:
  2262. {
  2263. m_paused_state = PS_MAINMENU;
  2264. } break;
  2266. case PS_MAINMENU:
  2267. {
  2268. m_paused_state = PS_RESUME;
  2269. } break;
  2271. }
  2272. }
  2273. ///////////////////////////////////////////////////////////////////////////
  2274.         /// user pressed down arrow --> set next game type
  2275.         ///////////////////////////////////////////////////////////////////////////
  2276.             else if (m_key_state[DIK_DOWN] & 0x80)
  2277. {
  2278. switch(m_paused_state)
  2279. {
  2280. case PS_RESUME:
  2281. {
  2282. m_paused_state = PS_MAINMENU;
  2283. } break;
  2285. case PS_MAINMENU:
  2286. {
  2287. m_paused_state = PS_RESUME;
  2288. } break;
  2290. }
  2291. }
  2292. ///////////////////////////////////////////////////////////////////////////
  2293.         /// user pressed return or space bar --> take next action based
  2294. /// on selected option
  2295.         ///////////////////////////////////////////////////////////////////////////
  2296. else if ( (m_key_state[DIK_RETURN] & 0x80) || (m_key_state[DIK_SPACE] & 0x80) )
  2297. {
  2298. switch(m_paused_state)
  2299. {
  2300. case PS_RESUME:
  2301. {
  2302. br = ProcessStateChange(/* new state */ GS_GAMEPLAY);
  2303. if (!br)
  2304. {
  2305. return(false);
  2306. }
  2307. } break;
  2309. case PS_MAINMENU:
  2310. {
  2311. br = ProcessStateChange(/* new state */ GS_MAINMENU);
  2312. if (!br)
  2313. {
  2314. return(false);
  2315. }
  2316. } break;
  2318. }
  2320. }
  2321. } break;
  2323. case GS_GAMEOVER:
  2324. {
  2325.             ///////////////////////////////////////////////////////////////////////////
  2326.         /// user pressed up arrow --> set next game over menu selection
  2327.         ///////////////////////////////////////////////////////////////////////////
  2328. if (m_key_state[DIK_UP] & 0x80)
  2329. {
  2330. switch(m_gameover_state)
  2331. {
  2332. case GO_PLAYAGAIN:
  2333. {
  2334. m_gameover_state = GO_MAINMENU;
  2335. } break;
  2337. case GO_MAINMENU:
  2338. {
  2339. m_gameover_state = GO_PLAYAGAIN;
  2340. } break;
  2342. }
  2343. }
  2344. ///////////////////////////////////////////////////////////////////////////
  2345.         /// user pressed down arrow --> set next game type
  2346.         ///////////////////////////////////////////////////////////////////////////
  2347.             else if (m_key_state[DIK_DOWN] & 0x80)
  2348. {
  2349. switch(m_gameover_state)
  2350. {
  2351. case GO_PLAYAGAIN:
  2352. {
  2353. m_gameover_state = GO_MAINMENU;
  2354. } break;
  2356. case GO_MAINMENU:
  2357. {
  2358. m_gameover_state = GO_PLAYAGAIN;
  2359. } break;
  2361. }
  2362. }
  2363. ///////////////////////////////////////////////////////////////////////////
  2364.         /// user pressed return or space bar --> take next action based
  2365. /// on selected option
  2366.         ///////////////////////////////////////////////////////////////////////////
  2367. else if ( (m_key_state[DIK_RETURN] & 0x80) || (m_key_state[DIK_SPACE] & 0x80) )
  2368. {
  2369. switch(m_gameover_state)
  2370. {
  2371. case GO_PLAYAGAIN:
  2372. {
  2373. InitializeNewGame();
  2374. br = ProcessStateChange(/* new state */ GS_STARTTURN);
  2375. if (!br)
  2376. {
  2377. return(false);
  2378. }
  2379. } break;
  2381. case GO_MAINMENU:
  2382. {
  2383. InitializeNewGame();
  2384. br = ProcessStateChange(/* new state */ GS_MAINMENU);
  2385. if (!br)
  2386. {
  2387. return(false);
  2388. }
  2389. } break;
  2391. }
  2393. }
  2394. } break;
  2396.     default: 
  2397. {
  2399. }
  2400. };
  2402. return(true);
  2403. }
  2405. ///////////////////////////////////////////////////////////////////////////////
  2406. /// Method:  ProcessPaddle
  2407. /// Purpose: Set the 'paddle' variables for the next frame
  2408. ///////////////////////////////////////////////////////////////////////////////
  2409. /// Receives: nothing
  2410. /// Returns:  true if the paddle was handled (moved) successfully
  2411. ///////////////////////////////////////////////////////////////////////////////
  2412. bool CSuperBrickBreaker::ProcessPaddle()
  2413. {
  2414.     ///////////////////////////////////////////////////////////////////////////
  2415. /// retrieve the current paddle position and velocity values
  2416. ///////////////////////////////////////////////////////////////////////////
  2417. int l_x_pos = m_paddle.GetXPos();
  2418. int l_x_vel = m_paddle.GetXVel();
  2419. int l_length = m_paddle.GetLength();
  2420. int l_paddle_right = (l_x_pos + l_length);
  2422. ///////////////////////////////////////////////////////////////////////////
  2423. /// set new paddle position based on current velocity
  2424. ///////////////////////////////////////////////////////////////////////////
  2425. l_x_pos += l_x_vel;
  2427. ///////////////////////////////////////////////////////////////////////////
  2428. /// ensure new paddle position is within game playing area
  2429. ///////////////////////////////////////////////////////////////////////////
  2430. if (l_x_vel < 0) // we are moving to the left
  2431. {
  2432. if (l_x_pos < m_playing_area_rect.left)
  2433. {
  2434. l_x_pos = m_playing_area_rect.left;
  2435. }
  2436. }
  2437.     else if (l_x_vel > 0) // we are moving to the right
  2438. {
  2439. if (l_paddle_right >= m_playing_area_rect.right)
  2440. {
  2441. l_x_pos = (m_playing_area_rect.right - l_length);
  2442. }
  2443. }
  2445. ///////////////////////////////////////////////////////////////////////////
  2446. /// move paddle to new location and reset velocity to zero
  2447. ///////////////////////////////////////////////////////////////////////////
  2448. if (l_x_vel != 0)
  2449. {
  2450. m_paddle.SetXPos(l_x_pos); 
  2451. m_paddle.SetXVel(0);
  2452. }
  2454. return(true);
  2455. };
  2457. ///////////////////////////////////////////////////////////////////////////////
  2458. /// Method:  ProcessStateChange
  2459. /// Purpose: Check the state change is valid and set the variables for the
  2460. ///          state change
  2461. ///////////////////////////////////////////////////////////////////////////////
  2462. /// Receives: nothing
  2463. /// Returns:  true if the state change was processed (moved) successfully
  2464. ///////////////////////////////////////////////////////////////////////////////
  2465. bool CSuperBrickBreaker::ProcessStateChange(EGameState m_new_game_state)
  2466. {
  2467. EGameState l_old_state = m_game_state;
  2469. m_game_state = m_new_game_state;
  2471. switch(m_new_game_state)
  2472. {
  2473. case GS_MAINMENU:
  2474. {
  2475. SetFrameRate(10);
  2476. InitializeNewGame();
  2477. } break;
  2479. case GS_STARTTURN:
  2480. {
  2481. if (m_game_state == GS_GAMEPAUSED)
  2482. {
  2483. InitializeNewGame();
  2484. }
  2485. SetFrameRate(10);
  2486. InitializeBalls();
  2487. InitializePaddle();
  2488. } break;
  2490. case GS_GAMEPLAY:
  2491. {
  2492. m_ball[0].SetState(FREE);
  2494. SetFrameRate(20);
  2495. m_balls_in_play = 1;
  2496. } break;
  2499. case GS_GAMEPAUSED:
  2500. {
  2501. SetFrameRate(10);
  2502. m_paused_state = PS_RESUME;
  2503. } break;
  2505. case GS_GAMEOVER:
  2506. {
  2507. m_gameover_state = GO_PLAYAGAIN;
  2508. for (int i = 0; i < m_num_balls; i++)
  2509. {
  2510. if (m_ball[i].GetState() == FREE)
  2511. {
  2512. m_ball[i].SetState(IDLE);
  2513. }
  2514. }
  2515. SetFrameRate(10);
  2516. }
  2517. }
  2519. return(true);
  2520. }
  2522. /// END OF FILE ///////////////////////////////////////////////////////////////