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

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

游戏

开发平台：

Visual C++

Main.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: Main.cpp
  3. //
  4. //-----------------------------------------------------------------------------
  5. #define STRICT
  6. #include <windows.h>
  7. #include <ddraw.h>
  8. #include <dshow.h>
  9. #include <mmsystem.h>
  10. #include <math.h>
  11. #include <fstream>
  12. #include <list>
  13. #include "resource.h"
  14. #include "DSUtil.h"
  15. #include "ddutil.h"
  16. #include "Maze.h"
  17. #include "Sprite.h"
  18. #include "SpriteManager.h"
  19. #include "GameErrors.h"
  20. #include "InputLayer.h"
  21. #include "Keyboard.h"
  22. #include "ijl.h"  // Intel JPEG header file
  23. //#define DISPLAY_STATUS
  24. #undef DISPLAY_STATUS
  25. //-----------------------------------------------------------------------------
  26. // Defines, constants, and global variables
  27. //-----------------------------------------------------------------------------
  28. #define SAFE_DELETE(p)  { if(p) { delete (p);     (p)=NULL; } }
  29. #define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }
  31. #define TITLE "Adventure in Abit"
  32. #define SPLASHFILENAME "AdvInAbat.jpg"
  33. #define CHOICEFILENAME "choose.jpg"
  34. #define GAMEOVERBADFILENAME "GameOver.jpg"
  35. #define GAMEOVERGOODFILENAME "Finish.jpg"
  37. #define SCREEN_WIDTH    1024
  38. #define SCREEN_HEIGHT   768
  39. #define SCREEN_BPP      16
  40. #define SPRITE_WIDTH    64
  41. #define SPRITE_HEIGHT   64
  42. #define MAZETEXTURE_WIDTH    32
  43. #define MAZETEXTURE_HEIGHT   32
  45. #define TYPE_PLAYER   1
  46. #define TYPE_ENEMY1 2
  47. #define TYPE_ENEMY2 3
  48. #define TYPE_ENEMY3 4
  49. #define TYPE_ENEMY4 5
  50. #define TYPE_POO    10
  51. #define TYPE_SPECIAL 11
  52. #define TYPE_BULLET  12
  54. #define ST_STAND_STILL 1 
  55. #define ST_WALK_UP     2
  56. #define ST_WALK_DOWN   3
  57. #define ST_WALK_LEFT   4
  58. #define ST_WALK_RIGHT  5
  59. #define ST_DEFAULT     6
  60. #define ST_KEY         7
  61. #define ST_DOOR        8
  62. #define ST_FOOD1       9
  63. #define ST_FOOD2       (ST_FOOD1+1)
  64. #define ST_FOOD3       (ST_FOOD1+2)
  65. #define ST_FOOD4       (ST_FOOD1+3)
  66. #define ST_FOOD5       (ST_FOOD1+4)
  67. #define ST_FOOD6       (ST_FOOD1+5)
  69. #define GAMESTATE_SPLASHSCREEN 0
  70. #define GAMESTATE_CHOICE       1
  71. #define GAMESTATE_RUNNING      2
  72. #define GAMESTATE_GAMEOVERBAD  3
  73. #define GAMESTATE_GAMEOVERGOOD 4
  75. #define POO_DELAY   500
  76. #define INVULNERABLE_DELAY  200
  77. #define NO_OF_LIFE     4
  78. #define NO_OF_SPECIALS 5
  80. #define GAMESTATUS_TEXT "Dead Pigs:%d Dead Enemies:%d"
  81. char g_szGameStatus[200];
  83. #define LIFE_LEFT_TEXT "Lives:%d"
  84. char g_szLifeLeft[100];
  86. #define GAMESCORE_TEXT "Score:%06d"
  87. char g_szScore[100];
  89. CDisplay*            g_pDisplay        = NULL;
  90. #ifdef DISPLAY_STATUS
  91. CSurface*            g_pTextSurface    = NULL;  
  92. #endif
  93. CSurface*            g_pLifeTextSurface = NULL;  
  94. CSurface*            g_pScoreTextSurface = NULL;  
  95. CSurface*            g_pLevelTextSurface = NULL;  
  96. CSurface*            g_pMazeSurface    = NULL;  
  97. CSurface*            g_pSpriteSurface  = NULL;
  98. CSurface*            g_pSplashSurface  = NULL;
  99. RECT                 g_rcWindow;            
  100. RECT                 g_rcViewport;          
  101. RECT                 g_rcScreen;            
  102. BOOL                 g_bWindowed   = false;  
  103. BOOL                 g_bActive     = FALSE;
  104. DWORD                g_dwLastTick;
  105. CMaze                g_Maze(MAKEINTRESOURCE(IDB_TEXTURE));
  106. CSprite              g_PigSprite;
  107. CSprite              g_RabbitSprite;
  108. CSprite              g_SheepSprite;
  109. CSprite*             g_pPlayerSprite = NULL;
  110. CSprite              g_Enemy1Sprite;
  111. CSprite              g_Enemy2Sprite;
  112. CSprite              g_Enemy3Sprite;
  113. CSprite              g_Enemy4Sprite;
  114. CSprite              g_Enemy5Sprite;
  115. CSprite              g_PigPooSprite;
  116. CSprite              g_RabbitPooSprite;
  117. CSprite              g_SheepPooSprite;
  118. CSprite*              g_pPooSprite= NULL;
  119. CSprite              g_SpecialSprite;
  120. CSprite              g_BulletSprite;
  121. CSpriteManager       g_EnemySpriteManager;
  122. CSound*              g_pSplashSound = NULL;
  123. CSound*              g_pPickupSound = NULL;
  124. CSoundManager*       g_pSoundManager = NULL;
  125. int                  g_nGameState = GAMESTATE_SPLASHSCREEN;
  126. int                  g_nPigDead = 0;
  127. int                  g_nEnemyDead = 0;
  128. long                 g_nPooDelay = 0;
  129. long                 g_nNoOfEnemies = 10;
  130. long                 g_nLivesLeft = NO_OF_LIFE;
  131. long                 g_nNoOfSpecials = NO_OF_SPECIALS;
  132. long                 g_nScore = 0;
  134. struct SLEVEL {
  135. char  szLevelFile[100];
  136. int   nNoOfEnemys;
  137. }* g_pLevel;
  139. long                 g_nNoOfLevels;
  140. long                 g_nCurrLevel=0;
  143. HINSTANCE g_hInstance;
  144. HWND      g_hMainWnd;
  146. //-----------------------------------------------------------------------------
  147. // Function-prototypes
  148. //-----------------------------------------------------------------------------
  149. LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam );
  150. HRESULT WinInit( HINSTANCE hInst, int nCmdShow, HWND* phWnd, HACCEL* phAccel );
  151. HRESULT InitDirectDraw( HWND hWnd );
  152. VOID    FreeDirectDraw();
  153. HRESULT InitDirectDrawMode( HWND hWnd, BOOL bWindowed );
  154. HRESULT ProcessNextFrame( HWND hWnd );
  155. HRESULT DisplayFrame();
  156. HRESULT RestoreSurfaces();
  157. bool LoadJPEG(bool bFromFile, LPCTSTR szName,  CSurface** ppSurface);
  158. void DisplaySplashScreen(bool bDisplay);
  159. void InitSprites();
  160. void InitLevel();
  161. void MoveCharacterRelative(long dX, long dY);
  163. struct SHandleInput: public iKeyboardReceiver
  164. {
  165. SHandleInput() {
  166. cInputLayer::Create( g_hInstance, g_hMainWnd, 
  167. true, true, false );
  168. Input()->GetKeyboard()->SetReceiver( this );
  169. }
  170. ~SHandleInput() {
  171. cInputLayer::Destroy();
  172. }
  173. void KeyUp( int key ) 
  174. {
  175. switch(g_nGameState) 
  176. {
  177. case GAMESTATE_SPLASHSCREEN: 
  178. {
  179. switch( key )
  180. {
  182. case DIK_SPACE:
  183. {
  184. g_nGameState=GAMESTATE_CHOICE;
  185. g_pSplashSound->Stop();
  186. LoadJPEG(true, CHOICEFILENAME,  &g_pSplashSurface);
  188. break;
  189. }
  190. }
  192. }
  193. break;
  195. case GAMESTATE_CHOICE:
  196. {
  197. bool bKeyHit = false;
  199. switch( key )
  200. {
  201. case DIK_1: g_pPlayerSprite = &g_PigSprite; 
  202. g_pPooSprite = &g_PigPooSprite;
  203. bKeyHit = true; break;
  204. case DIK_2: g_pPlayerSprite = &g_RabbitSprite;
  205. g_pPooSprite = &g_RabbitPooSprite;
  206. bKeyHit = true;break;
  207. case DIK_3: g_pPlayerSprite = &g_SheepSprite; 
  208. g_pPooSprite = &g_SheepPooSprite;
  209. bKeyHit = true; break;
  210. }
  211. if (bKeyHit) {
  212. g_nGameState=GAMESTATE_RUNNING;
  213. InitLevel();
  214. }
  215. }
  216. break;
  218. case GAMESTATE_RUNNING: 
  219. {
  220. switch( key )
  221. {
  222. // move up
  223. case DIK_UP:
  224. case DIK_NUMPAD8:
  225. // move down
  226. case DIK_DOWN:
  227. case DIK_NUMPAD2:
  228. // turn right
  229. case DIK_RIGHT:
  230. case DIK_NUMPAD6:
  231. // turn left
  232. case DIK_LEFT:
  233. case DIK_NUMPAD4:
  234. g_pPlayerSprite->SetState(ST_STAND_STILL);
  235. g_pPlayerSprite->m_Movement.m_dx = g_pPlayerSprite->m_Movement.m_dy =0;
  236. break;
  237. }
  238. }
  239. break;
  240. case GAMESTATE_GAMEOVERGOOD: 
  241. case GAMESTATE_GAMEOVERBAD: 
  242. {
  243. switch( key )
  244. {
  246. case DIK_SPACE:
  247. {
  248. g_nGameState=GAMESTATE_SPLASHSCREEN;
  249. g_nLivesLeft = NO_OF_LIFE;
  250. g_nScore=0;
  251. g_nCurrLevel=0;
  253. break;
  254. }
  255. }
  257. }
  258. break;
  260. }
  261. }
  264. void KeyDown( int key )
  265. {
  266. switch(g_nGameState) {
  269. case GAMESTATE_RUNNING: 
  270. {
  271. switch( key )
  272. {
  274. // move up
  275. case DIK_UP:
  276. case DIK_NUMPAD8:
  277. {
  278. g_pPlayerSprite->SetState(ST_WALK_UP);
  279. g_pPlayerSprite->m_Movement.m_dy = -2;
  280. g_pPlayerSprite->m_Movement.m_dx = 0;
  281. break;
  282. }
  284. // move down
  285. case DIK_DOWN:
  286. case DIK_NUMPAD2:
  287. {
  288. g_pPlayerSprite->SetState(ST_WALK_DOWN);
  289. g_pPlayerSprite->m_Movement.m_dy = 2;
  290. g_pPlayerSprite->m_Movement.m_dx = 0;
  291. break;
  292. }
  294. // Shoot
  295. case DIK_SPACE:
  296. {
  297. if (g_nPooDelay == 0 && g_pPlayerSprite->GetState()!= ST_KILL) {
  298. RECT rc = g_pPlayerSprite->GetRect();
  299. g_pPooSprite->MoveTo(rc.left,rc.top);
  300. g_nPooDelay = POO_DELAY;
  301. g_pPooSprite->SetState(ST_DEFAULT);
  302. }
  303. break;
  304. }
  306. // turn right
  307. case DIK_RIGHT:
  308. case DIK_NUMPAD6:
  309. {
  310. g_pPlayerSprite->SetState(ST_WALK_RIGHT); 
  311. g_pPlayerSprite->m_Movement.m_dx = 2;
  312. g_pPlayerSprite->m_Movement.m_dy = 0;
  313. break;
  314. }
  316. // turn left
  317. case DIK_LEFT:
  318. case DIK_NUMPAD4:
  319. {
  320. g_pPlayerSprite->SetState(ST_WALK_LEFT);
  321. g_pPlayerSprite->m_Movement.m_dx = -2;
  322. g_pPlayerSprite->m_Movement.m_dy = 0;
  323. break;
  324. }
  325. }
  326. }
  327. }
  328. }
  329. } *  g_pHandleInput = NULL;
  335. //-----------------------------------------------------------------------------
  336. // Name: WinMain()
  337. // Desc: Entry point to the program. Initializes everything and calls
  338. //       UpdateFrame() when idle from the message pump.
  339. //-----------------------------------------------------------------------------
  340. int APIENTRY WinMain( HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR pCmdLine, int nCmdShow )
  341. {
  342.     MSG    msg;
  343.     HWND   hWnd;
  344.     HACCEL hAccel;
  346.     srand( GetTickCount() );
  348. wsprintf((char*)g_szGameStatus, (char*)GAMESTATUS_TEXT,0,0);
  349. wsprintf((char*)g_szLifeLeft, (char*)LIFE_LEFT_TEXT,g_nLivesLeft -1);
  350. wsprintf((char*)g_szScore, (char*)GAMESCORE_TEXT,g_nScore);
  352. g_hInstance = hInst;
  354. char szName[200];
  355. std::fstream LevelData("config.txt",std::ios::in );
  356.     LevelData.getline(szName,200);
  358. // Read number of horizontal lines
  359. LevelData >> g_nNoOfLevels;   // Number of Horizontal rows
  360. g_pLevel = new SLEVEL[g_nNoOfLevels];
  361. if (g_pLevel == NULL)
  362. return -1;
  363. for (int nI = 0; nI < g_nNoOfLevels; nI++) {
  364. LevelData >> g_pLevel[nI].szLevelFile;
  365. LevelData >> g_pLevel[nI].nNoOfEnemys;
  366. }
  368.     if( FAILED( WinInit( hInst, nCmdShow, &hWnd, &hAccel ) ) )
  369.         return FALSE;
  372.     if( FAILED( InitDirectDraw( hWnd ) ) )
  373.     {
  374.         MessageBox( hWnd, TEXT("DirectDraw init failed. ")
  375. TEXT("The program will now exit. "), TEXT("Maze Test program"), 
  376. MB_ICONERROR | MB_OK );
  377.         return FALSE;
  378.     }
  379. InitSprites();
  381.     g_dwLastTick = timeGetTime();
  383.     while( TRUE )
  384.     {
  385.         // Look for messages, if none are found then 
  386.         // update the state and display it
  387.         if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
  388.         {
  389.             if( 0 == GetMessage(&msg, NULL, 0, 0 ) )
  390.             {
  391.                 // WM_QUIT was posted, so exit
  392. FreeDirectDraw();
  393. CoUninitialize();
  394. delete[] g_pLevel;
  395.                 return (int)msg.wParam;
  396.             }
  398.             // Translate and dispatch the message
  399.             if( 0 == TranslateAccelerator( hWnd, hAccel, &msg ) )
  400.             {
  401.                 TranslateMessage( &msg ); 
  402.                 DispatchMessage( &msg );
  403.             }
  404.         }
  405.         else
  406.         {
  407.             if( g_bActive )
  408.             {
  409.                 // Move the sprites, blt them to the back buffer, then 
  410.                 // flip or blt the back buffer to the primary buffer
  411.                 if( FAILED( ProcessNextFrame( hWnd ) ) )
  412.                 {
  413.                     SAFE_DELETE( g_pDisplay );
  415.                     MessageBox( hWnd, TEXT("Displaying the next frame failed. ")
  416. TEXT("The program will now exit. "), TEXT("Adv In Abt"), 
  417. MB_ICONERROR | MB_OK );
  418.                     return FALSE;
  419.                 }
  420.             }
  421.             else
  422.             {
  423.                 // Go to sleep if we have nothing else to do
  424.                 WaitMessage();
  426.                 // Ignore time spent inactive 
  427.                 g_dwLastTick = timeGetTime();
  428.             }
  429.         }
  430.     }
  432. }
  437. //-----------------------------------------------------------------------------
  438. // Name: WinInit()
  439. // Desc: Init the window
  440. //-----------------------------------------------------------------------------
  441. HRESULT WinInit( HINSTANCE hInst, int nCmdShow, HWND* phWnd, HACCEL* phAccel )
  442. {
  443.     WNDCLASSEX wc;
  444.     HWND       hWnd;
  445.     HACCEL     hAccel;
  447.     // Register the window class
  448.     wc.cbSize        = sizeof(wc);
  449.     wc.lpszClassName = TEXT("AdvInAbatWndClass");
  450.     wc.lpfnWndProc   = MainWndProc;
  451.     wc.style         = CS_VREDRAW | CS_HREDRAW;
  452.     wc.hInstance     = hInst;
  453.     wc.hIcon         = LoadIcon( hInst, MAKEINTRESOURCE(IDI_MAIN) );
  454.     wc.hIconSm       = LoadIcon( hInst, MAKEINTRESOURCE(IDI_MAIN) );
  455.     wc.hCursor       = LoadCursor( NULL, IDC_ARROW );
  456.     wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
  457.     wc.lpszMenuName  = 0;//MAKEINTRESOURCE(IDR_MENU);
  458.     wc.cbClsExtra    = 0;
  459.     wc.cbWndExtra    = 0;
  461.     if( RegisterClassEx( &wc ) == 0 ) {
  462. LPVOID lpMsgBuf;
  463. FormatMessage( 
  464. FORMAT_MESSAGE_ALLOCATE_BUFFER | 
  465. FORMAT_MESSAGE_FROM_SYSTEM | 
  466. FORMAT_MESSAGE_IGNORE_INSERTS,
  467. NULL,
  468. GetLastError(),
  469. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  470. (LPTSTR) &lpMsgBuf,
  471. 0,
  472. NULL 
  473. );
  474. OutputDebugString( (LPCTSTR)lpMsgBuf);
  475. // Free the buffer.
  476. LocalFree( lpMsgBuf );
  477.         return E_FAIL;
  478. }
  480.     // Load keyboard accelerators
  481.     hAccel = LoadAccelerators( hInst, MAKEINTRESOURCE(IDR_MAIN_ACCEL) );
  483.     // Calculate the proper size for the window given a client of 640x480
  484.     DWORD dwFrameWidth    = GetSystemMetrics( SM_CXSIZEFRAME );
  485.     DWORD dwFrameHeight   = GetSystemMetrics( SM_CYSIZEFRAME );
  486.     DWORD dwMenuHeight    = GetSystemMetrics( SM_CYMENU );
  487.     DWORD dwCaptionHeight = GetSystemMetrics( SM_CYCAPTION );
  488.     DWORD dwWindowWidth   = SCREEN_WIDTH  + dwFrameWidth * 2;
  489.     DWORD dwWindowHeight  = SCREEN_HEIGHT + dwFrameHeight * 2 + 
  490. dwMenuHeight + dwCaptionHeight;
  492.     // Create and show the main window
  493.     DWORD dwStyle = WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX;
  494.     hWnd = CreateWindowEx( 0, TEXT("AdvInAbatWndClass"), 
  495. TEXT("Maze Test program"),
  496. dwStyle, CW_USEDEFAULT, CW_USEDEFAULT,
  497. dwWindowWidth, dwWindowHeight, NULL, NULL, hInst, NULL );
  498.     if( hWnd == NULL )
  499. return E_FAIL;
  501.     ShowWindow( hWnd, nCmdShow );
  502.     UpdateWindow( hWnd );
  504.     // Save the window size/pos for switching modes
  505.     GetWindowRect( hWnd, &g_rcWindow );
  507.     *phWnd   = hWnd;
  508.     *phAccel = hAccel;
  510. g_hMainWnd = hWnd;
  511.     return S_OK;
  512. }
  514. HFONT GetGameFont()
  515. {
  516. HFONT      hFont ;
  517. LOGFONT    lf ;
  519. lf.lfHeight         = 40;
  520. lf.lfWidth          = 20;
  521. lf.lfEscapement     = 0 ;
  522. lf.lfOrientation    = 0 ;
  523. lf.lfWeight         = 0 ;
  524. lf.lfItalic         = false ; 
  525. lf.lfUnderline      = false; 
  526. lf.lfStrikeOut      = false; 
  527. lf.lfCharSet        = DEFAULT_CHARSET ;
  528. lf.lfOutPrecision   = 0 ;
  529. lf.lfClipPrecision  = 0 ;
  530. lf.lfQuality        = 0 ;
  531. lf.lfPitchAndFamily = 0 ;
  533. lstrcpy (lf.lfFaceName, "Times New Roman") ;
  535. hFont = CreateFontIndirect (&lf) ;
  536. // hfont = (HFONT)GetStockObject(ANSI_VAR_FONT); 
  537. return hFont;
  538. }
  540. //-----------------------------------------------------------------------------
  541. // Name: InitDirectDraw()
  542. // Desc: Create the DirectDraw object, and init the surfaces
  543. //-----------------------------------------------------------------------------
  544. HRESULT InitDirectDraw( HWND hWnd )
  545. {
  546.     HRESULT hr;
  548.     // Initialize all the surfaces we need
  549.     if( FAILED( hr = InitDirectDrawMode( hWnd, g_bWindowed ) ) )
  550.         return hr;
  552.     // Create a static IDirectSound in the CSound class.  
  553.     // Set coop level to DSSCL_PRIORITY, and set primary buffer 
  554.     // format to stereo, 22kHz and 16-bit output.
  555.     g_pSoundManager = new CSoundManager();
  557.     if( FAILED(hr= g_pSoundManager->Initialize( hWnd, DSSCL_PRIORITY, 2, 22050, 16 ) ) )
  558.     {
  559.         MessageBox( 0, "Error initializing DirectSound.  Game will now exit.", 
  560. "Game", MB_OK | MB_ICONERROR );
  561.         return hr;
  562.     }
  564. g_pSoundManager->Create(&g_pPickupSound,"PickUp");
  565. g_pHandleInput = new SHandleInput();
  567.     return S_OK;
  568. }
  573. //-----------------------------------------------------------------------------
  574. // Name: InitDirectDrawMode()
  575. // Desc: Called when the user wants to toggle between full-screen and windowed 
  576. //       to create all the needed DDraw surfaces and set the coop level
  577. //-----------------------------------------------------------------------------
  578. HRESULT InitDirectDrawMode( HWND hWnd, BOOL bWindowed )
  579. {
  580.     HRESULT         hr;
  581.     LPDIRECTDRAWPALETTE pDDPal   = NULL; 
  583.     // Release all existing surfaces
  584. SAFE_DELETE( g_pMazeSurface);  
  585. #ifdef DISPLAY_STATUS
  586.     SAFE_DELETE( g_pTextSurface );
  587. #endif
  588. SAFE_DELETE( g_pLifeTextSurface );
  589. SAFE_DELETE( g_pScoreTextSurface );
  590. SAFE_DELETE( g_pLevelTextSurface );
  591. SAFE_DELETE( g_pSpriteSurface );
  592. SAFE_DELETE ( g_pSplashSurface);
  593. SAFE_DELETE( g_pDisplay );
  595.     //在满屏模式和窗口模式下，主页面和后台页面的创建方式是不同的
  596.     g_pDisplay = new CDisplay();
  597. //窗口模式
  598.     if( bWindowed )
  599.     {
  600.         if( FAILED( hr = g_pDisplay->CreateWindowedDisplay( hWnd, SCREEN_WIDTH, 
  601. SCREEN_HEIGHT ) ) )
  602.             return hr;
  604.         // 在窗口方式中添加系统菜单
  605.         DWORD dwStyle = GetWindowLong( hWnd, GWL_STYLE );
  606.         dwStyle |= WS_SYSMENU;
  607.         SetWindowLong( hWnd, GWL_STYLE, dwStyle );
  609.         // Show the menu in windowed mode 
  610. #ifdef _WIN64
  611.         HINSTANCE hInst = (HINSTANCE) GetWindowLongPtr( hWnd, GWLP_HINSTANCE );
  612. #else
  613.         HINSTANCE hInst = (HINSTANCE) GetWindowLong( hWnd, GWL_HINSTANCE );
  614. #endif
  615.         HMENU hMenu = LoadMenu( hInst, MAKEINTRESOURCE( IDR_MENU ) );
  616.         SetMenu( hWnd, hMenu );
  617.     }
  618.     else//满屏显示
  619.     {
  620.         if( FAILED( hr = g_pDisplay->CreateFullScreenDisplay( hWnd, SCREEN_WIDTH, 
  621. SCREEN_HEIGHT, SCREEN_BPP ) ) )
  622.         {
  623.             MessageBox( hWnd, TEXT("This display card does not support 640x480x8. "),
  624. TEXT("DirectDraw Sample"), MB_ICONERROR | MB_OK );
  625.             return hr;
  626.         }
  628.         // 无效菜单
  629.         SetMenu( hWnd, NULL );
  631.         // 从窗口方式中删除系统菜单
  632. /*
  633.         DWORD dwStyle = GetWindowLong( hWnd, GWL_STYLE );
  634.         dwStyle &= ~WS_SYSMENU;
  635.         SetWindowLong( hWnd, GWL_STYLE, dwStyle );       
  636. */
  637.     }
  640. // 创建一个页面，在上面绘制文本
  641. #ifdef DISPLAY_STATUS
  642. if( FAILED( hr = g_pDisplay->CreateSurfaceFromText( &g_pTextSurface, NULL, (char*)g_szGameStatus, 
  643. RGB(0,0,0), RGB(255, 255, 0) ) ) )
  644. return hr;
  645. #endif
  646. HFONT hFont = GetGameFont();
  647. if( FAILED( hr = g_pDisplay->CreateSurfaceFromText( &g_pLifeTextSurface, hFont, (char*)g_szLifeLeft, 
  648. RGB(0,0,0), RGB(255, 255, 0) ) ) )
  649. return hr;
  650. if( FAILED( hr = g_pDisplay->CreateSurfaceFromText( &g_pScoreTextSurface, hFont, (char*)g_szScore, 
  651. RGB(0,0,0), RGB(255, 255, 0) ) ) )
  652. return hr;
  655.     // Create a surface, and draw a bitmap resource on it.  The surface must 
  656.     // be newly created every time the screen mode is switched since it 
  657.     // uses the pixel format of the primary surface
  658. // Create a surface, and draw text to it.  
  659. if( FAILED( hr = g_pDisplay->CreateSurface( &g_pMazeSurface, SCREEN_WIDTH, SCREEN_HEIGHT) ))
  660. return hr;
  662. if( FAILED( hr = g_pDisplay->CreateSurfaceFromBitmap( &g_pSpriteSurface, MAKEINTRESOURCE(IDB_SPRITE),0, 0) ))
  663. return hr;
  665. g_pSpriteSurface->SetColorKey(RGB(0,0,0));
  666. g_Maze.Draw(g_pMazeSurface);
  668. if (g_nGameState == GAMESTATE_SPLASHSCREEN) {
  669. LoadJPEG(true, SPLASHFILENAME,  &g_pSplashSurface);
  670. }
  671. if (g_nGameState == GAMESTATE_CHOICE) {
  672. LoadJPEG(true, CHOICEFILENAME,  &g_pSplashSurface);
  673. }
  675. if (g_nGameState == GAMESTATE_GAMEOVERGOOD) {
  676. LoadJPEG(true, GAMEOVERGOODFILENAME,  &g_pSplashSurface);
  677. }
  678. if (g_nGameState == GAMESTATE_GAMEOVERBAD) {
  679. LoadJPEG(true, GAMEOVERBADFILENAME,  &g_pSplashSurface);
  680. }
  681. if (g_nGameState == GAMESTATE_RUNNING){
  682. g_pDisplay->CreateSurfaceFromText( &g_pLevelTextSurface, hFont, g_Maze.GetName(), 
  683. RGB(0,0,0), RGB(255, 255, 0) ) ;
  685. }
  686. DeleteObject(hFont);
  687.     return S_OK;
  688. }
  690. inline bool IsHit(RECT& rc)
  691. {
  692. return g_Maze.IsHit(rc);
  693. }
  695. void BulletFindPath(CSprite* pSprite)
  696. {
  697. pSprite->SetState(ST_KILL);
  698. }
  700. void FindPath(CSprite* pSprite)
  701. {
  702. int nH = rand()%2;
  703. int nV = rand()%2;
  704. int nNRnd = rand()%3;
  705. if (nNRnd) {
  707. if (abs(g_pPlayerSprite->m_ptLocation.x - pSprite->m_ptLocation.x) > 
  708. abs(g_pPlayerSprite->m_ptLocation.y - pSprite->m_ptLocation.y))
  710. {
  711. pSprite->m_Movement.m_dy = 0;
  712. if (g_pPlayerSprite->m_ptLocation.x < pSprite->m_ptLocation.x) {
  713. pSprite->m_Movement.m_dx= -1 * (rand()%2+1);
  714. pSprite->SetState(ST_WALK_LEFT);
  716. } else {
  717. pSprite->m_Movement.m_dx= 1 * (rand()%2+1);
  718. pSprite->SetState(ST_WALK_RIGHT);
  719. }
  720. } else {
  721. pSprite->m_Movement.m_dx = 0;
  722. if (g_pPlayerSprite->m_ptLocation.y < pSprite->m_ptLocation.y) {
  723. pSprite->m_Movement.m_dy= -1 * (rand()%2+1);
  724. pSprite->SetState(ST_WALK_UP);
  725. } else {
  726. pSprite->m_Movement.m_dy= 1 * (rand()%2+1);
  727. pSprite->SetState(ST_WALK_DOWN);
  728. }
  729. }
  730. } else {
  731. if (nV) {
  732. pSprite->m_Movement.m_dx = 0;
  733. if (nH) {
  734. pSprite->m_Movement.m_dy = 1 * (rand()%2+1);
  735. pSprite->SetState(ST_WALK_DOWN);
  736. } else {
  737. pSprite->m_Movement.m_dy = -1 * (rand()%2+1);
  738. pSprite->SetState(ST_WALK_UP);
  739. }
  740. } else {
  741. pSprite->m_Movement.m_dy = 0;
  742. if (nH) {
  743. pSprite->m_Movement.m_dx = 1 * (rand()%2+1);
  744. pSprite->SetState(ST_WALK_RIGHT);
  745. } else {
  746. pSprite->m_Movement.m_dx = -1 * (rand()%2+1);
  747. pSprite->SetState(ST_WALK_LEFT);
  748. }
  750. }
  751. }
  753. if (pSprite->GetType() == TYPE_ENEMY4) {
  754. if (g_BulletSprite.GetState() == ST_DEAD && pSprite->GetState() != ST_KILL 
  755. && pSprite->GetState() != ST_DEAD) {
  756. RECT rc = pSprite->GetRect();
  757. g_BulletSprite.MoveTo(rc.left,rc.top);
  758. g_BulletSprite.SetState(ST_DEFAULT);
  759. switch (pSprite->GetState()) {
  760. case ST_WALK_UP:
  761. g_BulletSprite.m_Movement.m_dx =0;
  762. g_BulletSprite.m_Movement.m_dy = -3;
  763. break;
  764. case ST_WALK_DOWN:
  765. g_BulletSprite.m_Movement.m_dx =0;
  766. g_BulletSprite.m_Movement.m_dy = 3;
  767. break;
  768. case ST_WALK_LEFT:
  769. g_BulletSprite.m_Movement.m_dx =-3;
  770. g_BulletSprite.m_Movement.m_dy = 0;
  771. break;
  772. case ST_WALK_RIGHT:
  773. g_BulletSprite.m_Movement.m_dx =3;
  774. g_BulletSprite.m_Movement.m_dy = 0;
  775. break;
  776. }
  777. }
  778. }
  779. }
  781. void DeadPig(CSprite* pSprite)
  782. {
  783. ++g_nPigDead;
  784. --g_nLivesLeft;
  785. #ifdef DISPLAY_STATUS
  786. wsprintf((char*)g_szGameStatus, (char*)GAMESTATUS_TEXT, g_nPigDead, g_nEnemyDead);
  787.     SAFE_DELETE( g_pTextSurface );
  788.     g_pDisplay->CreateSurfaceFromText( &g_pTextSurface, NULL, (char*)g_szGameStatus, 
  789. RGB(0,0,0), RGB(255, 255, 0) );
  790. #endif
  792. SAFE_DELETE( g_pLifeTextSurface );
  793. wsprintf((char*)g_szLifeLeft, (char*)LIFE_LEFT_TEXT, g_nLivesLeft-1);
  794. HFONT hFont = GetGameFont();
  795.     g_pDisplay->CreateSurfaceFromText( &g_pLifeTextSurface, hFont , (char*)g_szLifeLeft, 
  796. RGB(0,0,0), RGB(255, 255, 0) );
  797. DeleteObject(hFont);
  799. g_pPlayerSprite->MoveTo(1 * MAZETEXTURE_WIDTH, 19 * MAZETEXTURE_HEIGHT);
  800. g_pPlayerSprite->SetState(ST_WALK_UP);
  801. g_pPlayerSprite->m_Movement.m_nInvulnerable=INVULNERABLE_DELAY;
  802. if (g_nLivesLeft == 0) {
  803. g_nLivesLeft = NO_OF_LIFE;
  804. g_nGameState = GAMESTATE_GAMEOVERBAD;
  805. LoadJPEG(true, GAMEOVERBADFILENAME,  &g_pSplashSurface);
  806. }
  808. }
  810. void DeadEnemy(CSprite* pSprite)
  811. {
  812. ++g_nEnemyDead;
  813. #ifdef DISPLAY_STATUS
  814. wsprintf((char*)g_szGameStatus, (char*)GAMESTATUS_TEXT, g_nPigDead, g_nEnemyDead);
  815.     SAFE_DELETE( g_pTextSurface );
  816.     g_pDisplay->CreateSurfaceFromText( &g_pTextSurface, NULL, (char*)g_szGameStatus, 
  817. RGB(0,0,0), RGB(255, 255, 0) );
  818. #endif
  819. g_nScore += pSprite->m_nPoints;
  820. SAFE_DELETE( g_pScoreTextSurface );
  821. wsprintf((char*)g_szScore, (char*)GAMESCORE_TEXT, g_nScore);
  822. HFONT hFont = GetGameFont();
  824.     g_pDisplay->CreateSurfaceFromText( &g_pScoreTextSurface, hFont, (char*)g_szScore, 
  825. RGB(0,0,0), RGB(255, 255, 0) );
  826. DeleteObject(hFont);
  828. if (g_nNoOfEnemies) {
  829. g_nNoOfEnemies--;
  830. pSprite->SetState(ST_WALK_LEFT);
  831. POINT pt = g_Maze.GetRandDeployPoint();
  832. pt.x *= MAZETEXTURE_WIDTH;
  833. pt.y *= MAZETEXTURE_HEIGHT;
  834. pSprite->MoveTo(pt);
  835. (*pSprite->m_Movement.m_pfnFindPath)(pSprite);
  836. pSprite->m_Movement.m_nInvulnerable=INVULNERABLE_DELAY;
  837. }
  838. }
  839. bool KillSpecial(CSprite* pSprite)
  840. {
  841. if (pSprite->GetState() == ST_DOOR) {
  842. InitLevel();
  843. return false;
  844. }
  845. return true;
  846. }
  848. void DeadSpecial(CSprite* pSprite)
  849. {
  850. static long nSpecialState = ST_FOOD1;
  851. g_nScore += pSprite->m_nPoints;
  852. SAFE_DELETE( g_pScoreTextSurface );
  853. wsprintf((char*)g_szScore, (char*)GAMESCORE_TEXT, g_nScore);
  854. HFONT hFont = GetGameFont();
  855. g_pDisplay->CreateSurfaceFromText( &g_pScoreTextSurface, hFont, (char*)g_szScore, 
  856. RGB(0,0,0), RGB(255, 255, 0) );
  857. DeleteObject(hFont);
  858. if (g_nNoOfSpecials) {
  859. pSprite->SetState(rand()%6 + ST_FOOD1);
  860. POINT pt = g_Maze.GetRandDeployPoint();
  861. pt.x *= MAZETEXTURE_WIDTH;
  862. pt.y *= MAZETEXTURE_HEIGHT;
  863. pSprite->MoveTo(pt);
  864. nSpecialState = ST_FOOD1;
  865. --g_nNoOfSpecials;
  866. } else {
  867. switch (nSpecialState) {
  868. case ST_FOOD1:
  869. pSprite->SetState(ST_KEY);
  870. POINT pt = g_Maze.GetRandDeployPoint();
  871. pt.x *= MAZETEXTURE_WIDTH;
  872. pt.y *= MAZETEXTURE_HEIGHT;
  873. pSprite->MoveTo(pt);
  874. nSpecialState = ST_KEY;
  875. break;
  876. case ST_KEY:
  877. pSprite->SetState(ST_DOOR);
  878. pt = g_Maze.GetRandDeployPoint();
  879. pt.x *= MAZETEXTURE_WIDTH;
  880. pt.y *= MAZETEXTURE_HEIGHT;
  881. pSprite->MoveTo(pt);
  882. nSpecialState = ST_DOOR;
  883. break;
  884. case ST_DOOR:
  885. InitLevel();
  886. }
  887. }
  888. }
  890. //初始化精灵，它负责创建猪精灵，兔精灵，羊精灵，敌人精灵，特殊精灵和子弹精灵。
  891. void InitSprites()
  892. {
  893. const int nHeight = SPRITE_HEIGHT;
  894. const int nWidth = SPRITE_WIDTH;
  895. POINT pt;
  896. RECT rcBounding;
  897. // ---------------- 猪精灵----------------- //
  898. g_PigSprite.CreateSprite(&g_pSpriteSurface, TYPE_PLAYER, nHeight,nWidth);
  899. pt.x = 5*64; pt.y =7*64 ;
  900. g_PigSprite.AddState(ST_STAND_STILL, pt, 2, 60);
  901. rcBounding.top = 0;
  902. rcBounding.bottom = nHeight-10;
  903. rcBounding.left = 10;
  904. rcBounding.right= nWidth - 20;
  905. pt.x = 6*64; pt.y =4*64;
  906. g_PigSprite.AddState(ST_WALK_UP, pt, 3, 10,&rcBounding);
  907. rcBounding.top = 10;
  908. rcBounding.bottom = nHeight-10;
  910. pt.x = 64*9;pt.y = 4*64;
  911. g_PigSprite.AddState(ST_WALK_DOWN, pt, 3, 10,&rcBounding);
  913. rcBounding.top = 10;
  914. rcBounding.bottom = nHeight - 20;
  915. rcBounding.left = 0;
  916. rcBounding.right=nWidth - 10;
  917. pt.x = 3*64;pt.y = 4*64;
  918. // g_pPlayerSprite->AddState(ST_WALK_LEFT, pt, 2, 20,"WavPigWalk",true);
  919. g_PigSprite.AddState(ST_WALK_LEFT, pt, 3, 10,&rcBounding);
  920. pt.x = 64*0;pt.y = 4*64;
  921. rcBounding.left = 10;
  922. rcBounding.right=nWidth-10;
  924. g_PigSprite.AddState(ST_WALK_RIGHT, pt, 3, 10,&rcBounding);
  925. pt.x = 64 * 8; pt.y = 7 * 64;
  926. g_PigSprite.AddState(ST_KILL, pt, 4, 20);
  927. g_PigSprite.MoveTo(1 * MAZETEXTURE_WIDTH, 19 * MAZETEXTURE_HEIGHT);
  928. g_PigSprite.m_pfnDead = DeadPig;
  929. g_PigSprite.m_Movement.m_pfnCollision = IsHit;
  931. g_PigPooSprite.CreateSprite(&g_pSpriteSurface, TYPE_POO, nHeight,nWidth);
  932. rcBounding.top = rcBounding.left = 20;
  933. rcBounding.right=rcBounding.bottom = nHeight - 40;
  934. pt.x = 0*64;pt.y = 7*64;
  935. g_PigPooSprite.AddState(ST_DEFAULT, pt, 3, 50,&rcBounding);
  936. pt.x = 11*64;pt.y = 10*64;
  937. g_PigPooSprite.AddState(ST_DEAD, pt, 3, 50,&rcBounding);
  938. g_PigPooSprite.SetState(ST_DEFAULT);
  940. // --------------- 兔精灵 --------------- //
  941. g_RabbitSprite.CreateSprite(&g_pSpriteSurface, TYPE_PLAYER, nHeight,nWidth);
  942. pt.x = 5*64; pt.y =8*64 ;
  943. g_RabbitSprite.AddState(ST_STAND_STILL, pt, 2, 60);
  944. rcBounding.top = 0;
  945. rcBounding.bottom = nHeight-10;
  946. rcBounding.left = 10;
  947. rcBounding.right= nWidth - 20;
  948. pt.x = 6*64; pt.y =5*64;
  949. g_RabbitSprite.AddState(ST_WALK_UP, pt, 3, 10,&rcBounding);
  950. rcBounding.top = 10;
  951. rcBounding.bottom = nHeight-10;
  953. pt.x = 64*9;pt.y = 5*64;
  954. g_RabbitSprite.AddState(ST_WALK_DOWN, pt, 3, 10,&rcBounding);
  956. rcBounding.top = 10;
  957. rcBounding.bottom = nHeight - 20;
  958. rcBounding.left = 0;
  959. rcBounding.right=nWidth - 10;
  960. pt.x = 3*64;pt.y = 5*64;
  961. g_RabbitSprite.AddState(ST_WALK_LEFT, pt, 3, 10,&rcBounding);
  962. pt.x = 64*0;pt.y = 5*64;
  963. rcBounding.left = 10;
  964. rcBounding.right=nWidth-10;
  966. g_RabbitSprite.AddState(ST_WALK_RIGHT, pt, 3, 10,&rcBounding);
  967. pt.x = 64 * 8; pt.y = 8 * 64;
  968. g_RabbitSprite.AddState(ST_KILL, pt, 4, 20);
  969. g_RabbitSprite.MoveTo(1 * MAZETEXTURE_WIDTH, 19 * MAZETEXTURE_HEIGHT);
  970. g_RabbitSprite.m_pfnDead = DeadPig;
  971. g_RabbitSprite.m_Movement.m_pfnCollision = IsHit;
  973. g_RabbitPooSprite.CreateSprite(&g_pSpriteSurface, TYPE_POO, nHeight,nWidth);
  974. rcBounding.top = rcBounding.left = 20;
  975. rcBounding.right=rcBounding.bottom = nHeight - 40;
  976. pt.x = 0*64;pt.y = 8*64;
  977. g_RabbitPooSprite.AddState(ST_DEFAULT, pt, 3, 50,&rcBounding);
  978. pt.x = 11*64;pt.y = 10*64;
  979. g_RabbitPooSprite.AddState(ST_DEAD, pt, 3, 50,&rcBounding);
  980. g_RabbitPooSprite.SetState(ST_DEFAULT);
  982. // --------------- 羊精灵----------------//
  983. g_SheepSprite.CreateSprite(&g_pSpriteSurface, TYPE_PLAYER, nHeight,nWidth);
  984. pt.x = 5*64; pt.y =9*64 ;
  985. g_SheepSprite.AddState(ST_STAND_STILL, pt, 2, 60);
  986. rcBounding.top = 0;
  987. rcBounding.bottom = nHeight-10;
  988. rcBounding.left = 10;
  989. rcBounding.right= nWidth - 20;
  990. pt.x = 6*64; pt.y =6*64;
  991. g_SheepSprite.AddState(ST_WALK_UP, pt, 3, 10,&rcBounding);
  992. rcBounding.top = 10;
  993. rcBounding.bottom = nHeight-10;
  995. pt.x = 64*9;pt.y = 6*64;
  996. g_SheepSprite.AddState(ST_WALK_DOWN, pt, 3, 10,&rcBounding);
  998. rcBounding.top = 10;
  999. rcBounding.bottom = nHeight - 20;
  1000. rcBounding.left = 0;
  1001. rcBounding.right=nWidth - 10;
  1002. pt.x = 3*64;pt.y = 6*64;
  1003. g_SheepSprite.AddState(ST_WALK_LEFT, pt, 3, 10,&rcBounding);
  1004. pt.x = 64*0;pt.y = 6*64;
  1005. rcBounding.left = 10;
  1006. rcBounding.right=nWidth-10;
  1008. g_SheepSprite.AddState(ST_WALK_RIGHT, pt, 3, 10,&rcBounding);
  1009. pt.x = 64 * 8; pt.y = 9 * 64;
  1010. g_SheepSprite.AddState(ST_KILL, pt, 4, 20);
  1011. g_SheepSprite.MoveTo(1 * MAZETEXTURE_WIDTH, 19 * MAZETEXTURE_HEIGHT);
  1012. g_SheepSprite.m_pfnDead = DeadPig;
  1013. g_SheepSprite.m_Movement.m_pfnCollision = IsHit;
  1015. g_SheepPooSprite.CreateSprite(&g_pSpriteSurface, TYPE_POO, nHeight,nWidth);
  1016. rcBounding.top = rcBounding.left = 20;
  1017. rcBounding.right=rcBounding.bottom = nHeight - 40;
  1018. pt.x = 0*64;pt.y = 9*64;
  1019. g_SheepPooSprite.AddState(ST_DEFAULT, pt, 3, 50,&rcBounding);
  1020. pt.x = 11*64;pt.y = 10*64;
  1021. g_SheepPooSprite.AddState(ST_DEAD, pt, 3, 50,&rcBounding);
  1022. g_SheepPooSprite.SetState(ST_DEFAULT);
  1024. // --------------- 敌人精灵--------------------//
  1026. //敌人精灵管理器
  1027. g_EnemySpriteManager.SetCollAndPathFn(IsHit, FindPath);
  1029. rcBounding.left =  10;
  1030. rcBounding.top =0;
  1031. rcBounding.right = SPRITE_WIDTH - 20;
  1032. rcBounding.bottom = SPRITE_HEIGHT ;
  1034.     g_Enemy1Sprite.CreateSprite(&g_pSpriteSurface, TYPE_ENEMY1, nHeight,nWidth);
  1035. pt.x = 6*64;pt.y = 0*64;
  1036. g_Enemy1Sprite.AddState(ST_WALK_UP, pt, 2, 20,&rcBounding);
  1037. pt.x = 3*64;pt.y = 0*64;
  1038. g_Enemy1Sprite.AddState(ST_WALK_LEFT, pt, 3, 20,&rcBounding);
  1039. pt.x = 0*64;pt.y = 0*64;
  1040. g_Enemy1Sprite.AddState(ST_WALK_RIGHT, pt, 3, 20,&rcBounding);
  1041. pt.x = 8*64;pt.y = 0*64;
  1042. g_Enemy1Sprite.AddState(ST_WALK_DOWN, pt, 2, 20,&rcBounding);
  1043. pt.x = 10*64;pt.y = 0*64;
  1044. g_Enemy1Sprite.AddState(ST_KILL, pt, 3, 100);
  1045. g_Enemy1Sprite.m_pfnDead= DeadEnemy;
  1046. g_Enemy1Sprite.m_nPoints = 100;
  1049.     g_Enemy2Sprite.CreateSprite(&g_pSpriteSurface, TYPE_ENEMY2, nHeight,nWidth);
  1050. pt.x = 6*64;pt.y = 1*64;
  1051. g_Enemy2Sprite.AddState(ST_WALK_UP, pt, 2, 20,&rcBounding);
  1052. pt.x = 3*64;pt.y = 1*64;
  1053. g_Enemy2Sprite.AddState(ST_WALK_LEFT, pt, 3, 20,&rcBounding);
  1054. pt.x = 0*64;pt.y = 1*64;
  1055. g_Enemy2Sprite.AddState(ST_WALK_RIGHT, pt, 3, 20,&rcBounding);
  1056. pt.x = 8*64;pt.y = 1*64;
  1057. g_Enemy2Sprite.AddState(ST_WALK_DOWN, pt, 2, 20,&rcBounding);
  1058. pt.x = 10*64;pt.y = 1*64;
  1059. g_Enemy2Sprite.AddState(ST_KILL, pt, 3, 100);
  1060. g_Enemy2Sprite.m_pfnDead= DeadEnemy;
  1061. g_Enemy2Sprite.m_nPoints = 100;
  1063.     g_Enemy3Sprite.CreateSprite(&g_pSpriteSurface, TYPE_ENEMY3, nHeight,nWidth);
  1064. pt.x = 6*64;pt.y = 2*64;
  1065. g_Enemy3Sprite.AddState(ST_WALK_UP, pt, 2, 20,&rcBounding);
  1066. pt.x = 3*64;pt.y = 2*64;
  1067. g_Enemy3Sprite.AddState(ST_WALK_LEFT, pt, 3, 20,&rcBounding);
  1068. pt.x = 0*64;pt.y = 2*64;
  1069. g_Enemy3Sprite.AddState(ST_WALK_RIGHT, pt, 3, 20,&rcBounding);
  1070. pt.x = 8*64;pt.y = 2*64;
  1071. g_Enemy3Sprite.AddState(ST_WALK_DOWN, pt, 2, 20,&rcBounding);
  1072. pt.x = 10*64;pt.y = 2*64;
  1073. g_Enemy3Sprite.AddState(ST_KILL, pt, 3, 100);
  1074. g_Enemy3Sprite.m_pfnDead= DeadEnemy;
  1075. g_Enemy3Sprite.m_nPoints = 100;
  1076. g_EnemySpriteManager.AddSprite(&g_Enemy3Sprite);
  1078.     g_Enemy4Sprite.CreateSprite(&g_pSpriteSurface, TYPE_ENEMY4, nHeight,nWidth);
  1079. pt.x = 6*64;pt.y = 3*64;
  1080. g_Enemy4Sprite.AddState(ST_WALK_UP, pt, 2, 20,&rcBounding);
  1081. pt.x = 3*64;pt.y = 3*64;
  1082. g_Enemy4Sprite.AddState(ST_WALK_LEFT, pt, 3, 20,&rcBounding);
  1083. pt.x = 0*64;pt.y = 3*64;
  1084. g_Enemy4Sprite.AddState(ST_WALK_RIGHT, pt, 3, 20,&rcBounding);
  1085. pt.x = 8*64;pt.y = 3*64;
  1086. g_Enemy4Sprite.AddState(ST_WALK_DOWN, pt, 2, 20,&rcBounding);
  1087. pt.x = 10*64;pt.y =3*64;
  1088. g_Enemy4Sprite.AddState(ST_KILL, pt, 3, 100);
  1089. g_Enemy4Sprite.m_pfnDead= DeadEnemy;
  1090. g_Enemy4Sprite.m_nPoints = 200;
  1091. g_EnemySpriteManager.AddSprite(&g_Enemy4Sprite);
  1093.     g_Enemy5Sprite.CreateSprite(&g_pSpriteSurface, TYPE_ENEMY4, nHeight,nWidth);
  1094. pt.x = 6*64;pt.y = 3*64;
  1095. g_Enemy5Sprite.AddState(ST_WALK_UP, pt, 2, 20,&rcBounding);
  1096. pt.x = 3*64;pt.y = 3*64;
  1097. g_Enemy5Sprite.AddState(ST_WALK_LEFT, pt, 3, 20,&rcBounding);
  1098. pt.x = 0*64;pt.y = 3*64;
  1099. g_Enemy5Sprite.AddState(ST_WALK_RIGHT, pt, 3, 20,&rcBounding);
  1100. pt.x = 8*64;pt.y = 3*64;
  1101. g_Enemy5Sprite.AddState(ST_WALK_DOWN, pt, 2, 20,&rcBounding);
  1102. pt.x = 10*64;pt.y =3*64;
  1103. g_Enemy5Sprite.AddState(ST_KILL, pt, 3, 100);
  1104. g_Enemy5Sprite.m_pfnDead= DeadEnemy;
  1105. g_Enemy5Sprite.m_nPoints = 200;
  1106. g_EnemySpriteManager.AddSprite(&g_Enemy5Sprite);
  1109. //其它精灵
  1110. g_SpecialSprite.CreateSprite(&g_pSpriteSurface, TYPE_SPECIAL, nHeight,nWidth);
  1111. pt.x = 5*64;pt.y = 10*64;
  1112. g_SpecialSprite.AddState(ST_FOOD1, pt, 1, 100);
  1113. pt.x = 6*64;pt.y = 10*64;
  1114. g_SpecialSprite.AddState(ST_FOOD2, pt, 1, 100);
  1115. pt.x = 7*64;pt.y = 10*64;
  1116. g_SpecialSprite.AddState(ST_FOOD3, pt, 1, 100);
  1117. pt.x = 8*64;pt.y = 10*64;
  1118. g_SpecialSprite.AddState(ST_FOOD4, pt, 1, 100);
  1119. pt.x = 9*64;pt.y = 10*64;
  1120. g_SpecialSprite.AddState(ST_FOOD5, pt, 1, 100);
  1121. pt.x = 10*64;pt.y = 10*64;
  1122. g_SpecialSprite.AddState(ST_FOOD6, pt, 1, 100);
  1124. pt.x = 3*64;pt.y = 8*64;
  1125. g_SpecialSprite.AddState(ST_KEY, pt, 2, 50);
  1126. pt.x = 2*64;pt.y = 10*64;
  1127. g_SpecialSprite.AddState(ST_DOOR, pt, 3, 30);
  1128. pt.x = 3*64;pt.y = 7*64;
  1129. g_SpecialSprite.AddState(ST_KILL, pt, 2, 100);
  1130. g_SpecialSprite.m_nPoints = 200;
  1131. g_SpecialSprite.m_pfnDead = DeadSpecial;
  1132. g_SpecialSprite.m_pfnKill = KillSpecial;
  1134. // ----------子弹精灵------------  //
  1135. g_BulletSprite.CreateSprite(&g_pSpriteSurface, TYPE_BULLET, nHeight,nWidth);
  1136. rcBounding.top = rcBounding.left = 20;
  1137. rcBounding.right=rcBounding.bottom = nHeight - 40;
  1138. pt.x = 0*64;pt.y = 10*64;
  1139. g_BulletSprite.AddState(ST_DEFAULT, pt, 2, 30, &rcBounding);
  1140. pt.x = 11*64;pt.y = 10*64;
  1141. g_BulletSprite.AddState(ST_KILL, pt, 1, 10);
  1142. g_BulletSprite.m_Movement.m_pfnCollision = IsHit;
  1143. g_BulletSprite.m_Movement.m_nPathFindDelay = 5000;
  1144. g_BulletSprite.m_Movement.m_pfnFindPath=BulletFindPath;
  1146. g_BulletSprite.SetState(ST_KILL);
  1147. /*
  1148. g_Enemy1Sprite.EnableBorder(true);
  1149. g_Enemy2Sprite.EnableBorder(true);
  1150. g_Enemy3Sprite.EnableBorder(true);
  1151. g_PigSprite.EnableBorder(true);
  1152. g_RabbitSprite.EnableBorder(true);
  1153. g_SheepSprite.EnableBorder(true);
  1154. g_BulletSprite.EnableBorder(true);
  1155. */
  1156. }
  1158. void InitLevel()
  1159. {
  1160. if (g_nCurrLevel+1 > g_nNoOfLevels) {
  1161. g_nGameState = GAMESTATE_GAMEOVERGOOD;
  1162. LoadJPEG(true, GAMEOVERGOODFILENAME,  &g_pSplashSurface);
  1163. return;
  1164. }
  1165. int nNoOfEnemies = g_pLevel[g_nCurrLevel].nNoOfEnemys;
  1166. g_Maze.LoadMaze(g_pLevel[g_nCurrLevel++].szLevelFile);
  1167. g_nNoOfEnemies = 10;
  1169. SAFE_DELETE( g_pScoreTextSurface );
  1170. wsprintf((char*)g_szScore, (char*)GAMESCORE_TEXT, g_nScore);
  1171. HFONT hFont = GetGameFont();
  1172.     g_pDisplay->CreateSurfaceFromText( &g_pScoreTextSurface, hFont, (char*)g_szScore, 
  1173. RGB(0,0,0), RGB(255, 255, 0) );
  1175. /*
  1176. OutputDebugString("n-----------n");
  1177. char szDebug[100];
  1178. wsprintf (szDebug,"g_nRows %d, g_nCols :%d Sizeof %dn",g_nRows,g_nCols,sizeof(short[g_nCols][g_nRows]));
  1179. OutputDebugString(szDebug);
  1180. for (int i=0; i < g_nRows; i++) {
  1181. for(int j=0; j <g_nCols; j++) {
  1182. if (g_nPathArray[i][j] !=0) 
  1183. szDebug[j]='1';
  1184. else
  1185. szDebug[j]='0';
  1186. }
  1187. szDebug[j]='n';
  1188. szDebug[j+1]='';
  1189. OutputDebugString(szDebug);
  1190. }
  1191. OutputDebugString("-----------n");
  1192. */
  1193.     g_nNoOfSpecials = NO_OF_SPECIALS;
  1195. SAFE_DELETE(g_pLevelTextSurface);
  1196.     g_pDisplay->CreateSurfaceFromText( &g_pLevelTextSurface, hFont, g_Maze.GetName(), 
  1197. RGB(0,0,0), RGB(255, 255, 0) ) ;
  1199. POINT pt= { 0*64, 3*64 };
  1200. g_pPlayerSprite->MoveTo(1 * MAZETEXTURE_WIDTH, 19 * MAZETEXTURE_HEIGHT);
  1201.     g_pPlayerSprite->SetState(ST_WALK_UP, true);
  1202. g_pPlayerSprite->m_Movement.m_dx=0;
  1203. g_pPlayerSprite->m_Movement.m_dy=0;
  1205. g_pPlayerSprite->m_Movement.m_nInvulnerable=INVULNERABLE_DELAY;
  1206. g_pPooSprite->SetState(ST_DEAD, true);
  1208. g_EnemySpriteManager.Destroy();
  1210. if (nNoOfEnemies) {
  1211. nNoOfEnemies--;
  1212. pt= g_Maze.GetRandDeployPoint();
  1213. pt.x *= MAZETEXTURE_WIDTH;
  1214. pt.y *= MAZETEXTURE_HEIGHT;
  1215. g_Enemy1Sprite.MoveTo(pt);
  1216. g_Enemy1Sprite.m_Movement.m_dx = -1;
  1217. g_Enemy1Sprite.m_Movement.m_nPathFindDelay = 1000;
  1218. g_Enemy1Sprite.SetState(ST_WALK_LEFT, true);
  1219. g_EnemySpriteManager.AddSprite(&g_Enemy1Sprite);
  1220. }
  1222. if (nNoOfEnemies) {
  1223. nNoOfEnemies--;
  1224. pt= g_Maze.GetRandDeployPoint();
  1225. pt.x *= MAZETEXTURE_WIDTH;
  1226. pt.y *= MAZETEXTURE_HEIGHT;
  1227. g_Enemy2Sprite.MoveTo(pt);
  1228. g_Enemy2Sprite.m_Movement.m_dx = 1;
  1229. g_Enemy2Sprite.m_Movement.m_nPathFindDelay = 500;
  1230. g_Enemy2Sprite.SetState(ST_WALK_RIGHT, true);
  1231. g_EnemySpriteManager.AddSprite(&g_Enemy2Sprite);
  1232. }
  1233. if (nNoOfEnemies) {
  1234. nNoOfEnemies--;
  1235. pt= g_Maze.GetRandDeployPoint();
  1236. pt.x *= MAZETEXTURE_WIDTH;
  1237. pt.y *= MAZETEXTURE_HEIGHT;
  1238. g_Enemy3Sprite.MoveTo(pt);
  1239. g_Enemy3Sprite.m_Movement.m_dy = 1;
  1240. g_Enemy3Sprite.m_Movement.m_nPathFindDelay = 300;
  1241. g_Enemy3Sprite.SetState(ST_WALK_DOWN, true);
  1242. g_EnemySpriteManager.AddSprite(&g_Enemy3Sprite);
  1243. }
  1244. if (nNoOfEnemies) {
  1245. nNoOfEnemies--;
  1246. pt= g_Maze.GetRandDeployPoint();
  1247. pt.x *= MAZETEXTURE_WIDTH;
  1248. pt.y *= MAZETEXTURE_HEIGHT;
  1249. g_Enemy4Sprite.MoveTo(pt);
  1250. g_Enemy4Sprite.m_Movement.m_dy = -1;
  1251. g_Enemy4Sprite.m_Movement.m_nPathFindDelay = 200;
  1252. g_Enemy4Sprite.SetState(ST_WALK_UP, true);
  1253. g_EnemySpriteManager.AddSprite(&g_Enemy4Sprite);
  1254. }
  1256. if (nNoOfEnemies) {
  1257. nNoOfEnemies--;
  1258. pt= g_Maze.GetRandDeployPoint();
  1259. pt.x *= MAZETEXTURE_WIDTH;
  1260. pt.y *= MAZETEXTURE_HEIGHT;
  1261. g_Enemy5Sprite.MoveTo(pt);
  1262. g_Enemy5Sprite.m_Movement.m_dy = 1;
  1263. g_Enemy5Sprite.m_Movement.m_nPathFindDelay = 200;
  1264. g_Enemy5Sprite.SetState(ST_WALK_DOWN, true);
  1265. g_EnemySpriteManager.AddSprite(&g_Enemy5Sprite);
  1266. }
  1269. pt= g_Maze.GetRandDeployPoint();
  1270. pt.x *= MAZETEXTURE_WIDTH;
  1271. pt.y *= MAZETEXTURE_HEIGHT;
  1272. g_SpecialSprite.MoveTo(pt);
  1273. g_SpecialSprite.SetState(ST_FOOD1, true);
  1275. // SIZE szDim = { 64,64};
  1276. // g_Maze.DisplayGrid(true);
  1277. // g_Maze.DisplayDeployRects(szDim);
  1278. g_Maze.Draw(g_pMazeSurface);
  1280. SAFE_DELETE( g_pLifeTextSurface );
  1281. wsprintf((char*)g_szLifeLeft, (char*)LIFE_LEFT_TEXT, g_nLivesLeft - 1);
  1282.     g_pDisplay->CreateSurfaceFromText( &g_pLifeTextSurface, hFont, (char*)g_szLifeLeft, 
  1283. RGB(0,0,0), RGB(255, 255, 0) );
  1285. DeleteObject(hFont);
  1286. }
  1289. //-----------------------------------------------------------------------------
  1290. // Name: FreeDirectDraw()
  1291. // Desc: Release all the DirectDraw objects
  1292. //-----------------------------------------------------------------------------
  1293. VOID FreeDirectDraw()
  1294. {
  1295. #ifdef DISPLAY_STATUS
  1296.     SAFE_DELETE( g_pTextSurface );
  1297. #endif
  1298. SAFE_DELETE( g_pLifeTextSurface );
  1299. SAFE_DELETE( g_pScoreTextSurface );
  1300. SAFE_DELETE( g_pLevelTextSurface );
  1301.     SAFE_DELETE( g_pMazeSurface );
  1302. SAFE_DELETE( g_pSpriteSurface );
  1303. SAFE_DELETE( g_pSplashSurface);
  1304.     SAFE_DELETE( g_pDisplay );
  1306. SAFE_DELETE( g_pSplashSound );
  1307. SAFE_DELETE( g_pPickupSound );
  1308.     SAFE_DELETE( g_pSoundManager );
  1309. SAFE_DELETE( g_pHandleInput );
  1310. }
  1315. //-----------------------------------------------------------------------------
  1316. // Name: MainWndProc()
  1317. // Desc: The main window procedure
  1318. //-----------------------------------------------------------------------------
  1319. LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
  1320. {
  1321.     switch (msg)
  1322.     {
  1323. case WM_COMMAND:
  1324. switch( LOWORD(wParam) )
  1325. {
  1326. case IDM_TOGGLEFULLSCREEN: //Alt+回车快捷键的消息处理函数
  1327. //这个快捷键用来切换满屏/窗口模式，这是满屏程序常用的快捷键
  1328. if( g_bWindowed )
  1329. GetWindowRect( hWnd, &g_rcWindow );
  1330. g_bWindowed = !g_bWindowed;
  1332. //初始化绘制模式
  1333. if( FAILED( InitDirectDrawMode( hWnd, g_bWindowed ) ) )
  1334. {
  1335. SAFE_DELETE( g_pDisplay );
  1336. MessageBox( hWnd, TEXT("InitDirectDraw() failed. ")
  1337. TEXT("The sample will now exit. "), TEXT("DirectDraw Sample"), 
  1338. MB_ICONERROR | MB_OK );
  1339. PostMessage( hWnd, WM_CLOSE, 0, 0 );
  1340. }
  1341. return 0L;
  1342. case IDM_PAUSE: //Pause快捷键的消息处理函数
  1343. g_bActive = true - g_bActive;
  1344. return 0L;
  1345. case IDM_EXIT: //Esc快捷键的消息处理函数
  1346. PostMessage( hWnd, WM_CLOSE, 0, 0 );
  1347. return 0L;
  1348. }
  1349. break; // Continue with default processing
  1351.         case WM_GETMINMAXINFO: //窗口模式下的消息
  1352.             {
  1353. //不允许改变窗口大小，固定窗口尺寸
  1354.                 MINMAXINFO* pMinMax = (MINMAXINFO*) lParam;
  1356.                 DWORD dwFrameWidth    = GetSystemMetrics( SM_CXSIZEFRAME );
  1357.                 DWORD dwFrameHeight   = GetSystemMetrics( SM_CYSIZEFRAME );
  1358.                 DWORD dwMenuHeight    = GetSystemMetrics( SM_CYMENU );
  1359.                 DWORD dwCaptionHeight = GetSystemMetrics( SM_CYCAPTION );
  1361.                 pMinMax->ptMinTrackSize.x = SCREEN_WIDTH  + dwFrameWidth * 2;
  1362.                 pMinMax->ptMinTrackSize.y = SCREEN_HEIGHT + dwFrameHeight * 2 + 
  1363. dwMenuHeight + dwCaptionHeight;
  1365.                 pMinMax->ptMaxTrackSize.x = pMinMax->ptMinTrackSize.x;
  1366.                 pMinMax->ptMaxTrackSize.y = pMinMax->ptMinTrackSize.y;
  1367.             }
  1368.             return 0L;
  1370.         case WM_MOVE: //窗口模式下的消息
  1371. //移动窗口
  1372.             if( g_pDisplay )
  1373.                 g_pDisplay->UpdateBounds();
  1374.             return 0L;
  1375.         case WM_SIZE: //检测游戏是否失去了窗口焦点
  1376.             if( SIZE_MAXHIDE==wParam || SIZE_MINIMIZED==wParam )
  1377.                 g_bActive = FALSE;
  1378.             else
  1379.                 g_bActive = TRUE;
  1381.             if( g_pDisplay )
  1382.                 g_pDisplay->UpdateBounds();
  1383.             break;
  1384.         case WM_SETCURSOR: //光标消息
  1385.             // 在全屏模式下隐藏光标
  1386.             if( !g_bWindowed )
  1387.             {
  1388.                 SetCursor( NULL );
  1389.                 return TRUE;
  1390.             }
  1391.             break; 
  1392.         case WM_QUERYNEWPALETTE: //
  1393.             if( g_pDisplay && g_pDisplay->GetFrontBuffer() )            
  1394.             {
  1395.                 // If we are in windowed mode with a desktop resolution in 8 bit 
  1396.                 // color, then the palette we created during init has changed 
  1397.                 // since then.  So get the palette back from the primary 
  1398.                 // DirectDraw surface, and set it again so that DirectDraw 
  1399.                 // realises the palette, then release it again. 
  1400.                 LPDIRECTDRAWPALETTE pDDPal = NULL; 
  1401.                 g_pDisplay->GetFrontBuffer()->GetPalette( &pDDPal );
  1402.                 g_pDisplay->GetFrontBuffer()->SetPalette( pDDPal );
  1403.                 SAFE_RELEASE( pDDPal );
  1404.             }
  1405.             break;
  1406.         case WM_EXITMENULOOP: //忽略在菜单上花费的时间
  1407.             g_dwLastTick = timeGetTime();
  1408.             break;
  1409.         case WM_EXITSIZEMOVE: //忽略移动窗口的时间
  1410.             g_dwLastTick = timeGetTime();
  1411.             break;
  1412. case WM_SYSCOMMAND: //防止全屏模式下的移动/变尺和调电
  1413.             switch( wParam )
  1414.             {
  1415. case SC_MOVE:
  1416. case SC_SIZE:
  1417. case SC_MAXIMIZE:
  1418. case SC_MONITORPOWER:
  1419. if( !g_bWindowed )
  1420. return TRUE;
  1421.             }
  1422.             break;
  1423. case WM_DESTROY: //清除，结束游戏
  1424. FreeDirectDraw();
  1425. PostQuitMessage( 0 );
  1426. return 0L;
  1427. break;
  1428.     }
  1429.     return DefWindowProc(hWnd, msg, wParam, lParam);
  1430. }
  1435. //-----------------------------------------------------------------------------
  1436. // Name: ProcessNextFrame()
  1437. // Desc: Move the sprites, blt them to the back buffer, then 
  1438. //       flip or blt the back buffer to the primary buffer
  1439. //-----------------------------------------------------------------------------
  1440. HRESULT ProcessNextFrame( HWND hWnd )
  1441. {
  1442.     HRESULT hr;
  1444.     // Figure how much time has passed since the last time
  1445.     DWORD dwCurrTick = timeGetTime();
  1446.     DWORD dwTickDiff = dwCurrTick - g_dwLastTick;
  1448.     // Don't update if no time has passed 
  1449.     if( dwTickDiff == 0 )
  1450. return S_OK; 
  1452. g_dwLastTick = dwCurrTick;
  1455. dwTickDiff = 17 - dwTickDiff;
  1457.   if (dwTickDiff > 0 && dwTickDiff < 17)
  1458.   Sleep(dwTickDiff);
  1460. // Sleep(10);
  1462.     // Check the cooperative level before rendering
  1463.     if( FAILED( hr = g_pDisplay->GetDirectDraw()->TestCooperativeLevel() ) )
  1464.     {
  1465.         switch( hr )
  1466.         {
  1467. case DDERR_EXCLUSIVEMODEALREADYSET:
  1468. case DDERR_NOEXCLUSIVEMODE:
  1469. // Do nothing because some other app has exclusive mode
  1470. Sleep(10);
  1471. return S_OK;
  1473. case DDERR_WRONGMODE:
  1474. // The display mode changed on us. Update the
  1475. // DirectDraw surfaces accordingly
  1476. return InitDirectDrawMode( hWnd, g_bWindowed );
  1477.         }
  1478.         return hr;
  1479.     }
  1481.     // Display the sprites on the screen
  1482.     if( FAILED( hr = DisplayFrame() ) )
  1483.     {
  1484.         if( hr != DDERR_SURFACELOST )
  1485.             return hr;
  1487.         // The surfaces were lost so restore them 
  1488.         RestoreSurfaces();
  1489.     }
  1491.     return S_OK;
  1492. }
  1499. //-----------------------------------------------------------------------------
  1500. // Name: DisplayFrame()
  1501. // Desc: Blts a the sprites to the back buffer, then it blts or flips the 
  1502. //       back buffer onto the primary buffer.
  1503. //-----------------------------------------------------------------------------
  1504. HRESULT DisplayFrame()
  1505. {
  1506.     HRESULT hr;
  1509. if( Input() )
  1510. Input()->UpdateDevices();
  1512.     // Fill the back buffer with black, ignoring errors until the flip
  1513.     g_pDisplay->Clear( 0 );
  1515. switch (g_nGameState)
  1516. {
  1517. case GAMESTATE_SPLASHSCREEN:
  1518. {
  1519. if (g_pSplashSound == NULL) {
  1520. g_pSoundManager->Create( &g_pSplashSound, "WavSplashScreen", 0, GUID_NULL );
  1521. }
  1522. if (g_pSplashSound->IsSoundPlaying() == false) {
  1523. g_pSplashSound->Play(0,DSBPLAY_LOOPING);
  1524. LoadJPEG(true, SPLASHFILENAME,  &g_pSplashSurface);
  1525. }
  1526. g_pDisplay->Blt(0,0, g_pSplashSurface, NULL);
  1527. break;
  1528. }
  1529. case GAMESTATE_CHOICE:
  1530. {
  1531. g_pDisplay->Blt(0,0, g_pSplashSurface, NULL);
  1532. break;
  1533. }
  1536. case GAMESTATE_RUNNING:
  1537. {
  1538. LPDIRECTDRAWSURFACE7 lpdds = g_pDisplay->GetBackBuffer();
  1540. if (g_nPooDelay)
  1541. --g_nPooDelay;
  1542. else {
  1543. g_pPooSprite->SetState(ST_DEAD);
  1544. }
  1545. g_pDisplay->Blt( 0, 0, g_pMazeSurface, NULL );
  1548. // Blt the help text on the backbuffer, ignoring errors until the flip
  1549. #ifdef DISPLAY_STATUS
  1550. g_pDisplay->Blt( 10, 10, g_pTextSurface, NULL );
  1551. #endif
  1552. g_pDisplay->Blt( 10, 710, g_pLifeTextSurface, NULL );
  1553. g_pDisplay->Blt( SCREEN_WIDTH - g_pScoreTextSurface->GetSurfaceDesc().dwWidth - 10, 710, g_pScoreTextSurface, NULL );
  1554. g_pDisplay->Blt( SCREEN_WIDTH/2 - g_pLevelTextSurface->GetSurfaceDesc().dwWidth/2, 710, g_pLevelTextSurface, NULL );
  1557. g_pPooSprite->Update();
  1558. g_pPlayerSprite->Update();
  1559. g_SpecialSprite.Update();
  1560. g_EnemySpriteManager.Update();
  1561. g_BulletSprite.Update();
  1562. g_EnemySpriteManager.KillSpritesColliWith(g_pPooSprite);
  1564. if (g_pPlayerSprite->m_Movement.m_nInvulnerable == 0) {
  1565. if (g_EnemySpriteManager.IsHit(g_pPlayerSprite->GetRect()) || g_BulletSprite.IsHit(g_pPlayerSprite->GetRect())) {
  1566. g_pPlayerSprite->SetState(ST_KILL);
  1567. g_BulletSprite.SetState(ST_KILL);
  1568. g_pPlayerSprite->m_Movement.m_dx = g_pPlayerSprite->m_Movement.m_dy =0;
  1569. }
  1571. }
  1572. if (g_SpecialSprite.IsHit(g_pPlayerSprite->GetRect()) && g_SpecialSprite.GetState()!=ST_KILL) {
  1573. g_pPickupSound->Play(0,0);
  1574. g_SpecialSprite.SetState(ST_KILL);
  1575. }
  1577. g_pPooSprite->Draw(lpdds);
  1578. g_SpecialSprite.Draw(lpdds);
  1579. g_pPlayerSprite->Draw(lpdds);
  1580. g_BulletSprite.Draw(lpdds);
  1581. g_EnemySpriteManager.Draw(lpdds);
  1582. break;
  1583. }
  1584. case GAMESTATE_GAMEOVERGOOD:
  1585. case GAMESTATE_GAMEOVERBAD:
  1586. {
  1587. g_pDisplay->Blt(0,0, g_pSplashSurface, NULL);
  1588. }
  1589. }
  1590. // Flip or blt the back buffer onto the primary buffer
  1591. if( FAILED( hr = g_pDisplay->Present() ) )
  1592. return hr;
  1594. return S_OK;
  1595. }
  1600. //-----------------------------------------------------------------------------
  1601. // Name: RestoreSurfaces()
  1602. // Desc: Restore all the surfaces, and redraw the sprite surfaces.
  1603. //-----------------------------------------------------------------------------
  1604. HRESULT RestoreSurfaces()
  1605. {
  1606.     HRESULT hr;
  1607.     LPDIRECTDRAWPALETTE  pDDPal = NULL; 
  1609.     if( FAILED( hr = g_pDisplay->GetDirectDraw()->RestoreAllSurfaces() ) )
  1610.         return hr;
  1613. // No need to re-create the surface, just re-draw it.
  1614. #ifdef DISPLAY_STATUS
  1615. if( FAILED( hr = g_pTextSurface->DrawText( NULL, (char*)g_szGameStatus, 
  1616. 0, 0, RGB(0,0,0), RGB(255, 255, 0) ) ) )
  1617. return hr;
  1618. #endif
  1620. if( FAILED( hr = g_pLifeTextSurface->DrawText( NULL, (char*)g_szLifeLeft, 
  1621. 0, 0, RGB(0,0,0), RGB(255, 255, 0) ) ) )
  1622. return hr;
  1624. if( FAILED( hr = g_pScoreTextSurface->DrawText( NULL, (char*)g_szScore, 
  1625. 0, 0, RGB(0,0,0), RGB(255, 255, 0) ) ) )
  1626. return hr;
  1627. if( FAILED( hr = g_pLevelTextSurface->DrawText( NULL, g_Maze.GetName(), 
  1628. 0, 0, RGB(0,0,0), RGB(255, 255, 0) ) ) )
  1629. return hr;
  1632. g_Maze.Draw(g_pMazeSurface);
  1633. if( FAILED( hr = g_pSpriteSurface->DrawBitmap( "Sprite.bmp"/*MAKEINTRESOURCE( IDB_SPRITE )*/,
  1634. 0, 0 ) ) )
  1635.         return hr;
  1637. if (g_nGameState == GAMESTATE_SPLASHSCREEN) {
  1638. LoadJPEG(true, SPLASHFILENAME,  &g_pSplashSurface);
  1639. }
  1640. if (g_nGameState == GAMESTATE_CHOICE) {
  1641. LoadJPEG(true, CHOICEFILENAME,  &g_pSplashSurface);
  1642. }
  1643. if (g_nGameState == GAMESTATE_GAMEOVERGOOD) {
  1644. LoadJPEG(true, GAMEOVERGOODFILENAME,  &g_pSplashSurface);
  1645. }
  1646. if (g_nGameState == GAMESTATE_GAMEOVERBAD) {
  1647. LoadJPEG(true, GAMEOVERBADFILENAME,  &g_pSplashSurface);
  1648. }
  1650.     return S_OK;
  1651. }
  1652. //16Bit Color conversion macros
  1653. #define RGB555(r, g, b) ((r >> 3) | ((g >> 3) << 5) | ((b >> 3) << 10))
  1654. #define RGB565(r, g, b) ((r >> 3) | ((g >> 2) << 5) | ((b >> 3) << 11))
  1656. //16Bit Color Formats
  1657. #define PF_555  1
  1658. #define PF_565  2
  1660. //Color modes
  1661. #define C16BIT  16
  1662. #define C24BIT  24
  1663. #define C32BIT  32
  1666. //*************
  1667. //* Load JPEG *
  1668. //*************
  1669. bool LoadJPEG(bool bFromFile, LPCTSTR szName,  CSurface** ppSurface)
  1670. {
  1671. //Error handle
  1672. IJLERR jerr;
  1673. int  nPixelFormat = PF_555;
  1674. //Create the JPEG object
  1675. JPEG_CORE_PROPERTIES jcprops;
  1677. DDPIXELFORMAT DDPixelFormat;
  1678. ZeroMemory(&DDPixelFormat, sizeof(DDPixelFormat));
  1679. DDPixelFormat.dwSize = sizeof(DDPixelFormat);
  1681. HRESULT Result = g_pDisplay->GetBackBuffer()->GetPixelFormat(&DDPixelFormat);
  1682. if(Result != DD_OK)
  1683. {
  1684. MessageBox(g_hMainWnd, "Failed to retrieve pixel format", TITLE, MB_OK);
  1685. return false;
  1686. }
  1689. //Get green bitmask and set pixel format    
  1690. if((DDPixelFormat.dwGBitMask / 32) == 31)
  1691. nPixelFormat = PF_555;
  1692. else if((DDPixelFormat.dwGBitMask / 32) == 63)
  1693. nPixelFormat = PF_565;
  1696. //Initialize the JPEG object
  1697. jerr = ijlInit(&jcprops);
  1698. if (jerr != IJL_OK)
  1699. {
  1700. MessageBox(g_hMainWnd, "IJLInit problem", TITLE, MB_OK);
  1701. return false;
  1702. }
  1704. //Load from File or Resource?
  1705. if (bFromFile)
  1706. {
  1707. //Set the IJL data source as a filename
  1708. jcprops.JPGFile = szName;
  1710. //Read JPEG parameters from the file
  1711. jerr = ijlRead(&jcprops, IJL_JFILE_READPARAMS);
  1712. }
  1713. else //(Location == FROM_RESOURCE) or integer ID of resource
  1714. {
  1715. //Resource variables
  1716. BYTE* pmem;
  1717. HGLOBAL hmem;
  1718. DWORD size;
  1719. HRSRC hres;
  1722. hres = FindResource(NULL, szName, "JPEG");
  1723. if (hres)
  1724. {
  1725. size = SizeofResource(NULL, hres);
  1726. if (!size)
  1727. {
  1728. MessageBox(g_hMainWnd, "Error retrieving resource size",
  1729. TITLE, MB_OK);
  1730. return false;
  1731. }
  1732. hmem = LoadResource(NULL, hres);
  1733. if (hmem == NULL)
  1734. {
  1735. MessageBox(g_hMainWnd, "Error loading resource", TITLE, MB_OK);
  1736. return false;
  1737. }
  1738. pmem = (BYTE *)LockResource(hmem);
  1739. if (pmem == NULL)
  1740. {
  1741. MessageBox(g_hMainWnd, "Error locking resource", TITLE, MB_OK);
  1742. return false;
  1743. }
  1744. }
  1745. else
  1746. {
  1747. MessageBox(g_hMainWnd, "JPEG resource not found", TITLE, MB_OK);
  1748. return false;
  1749. }
  1751. //Set the IJL data source as the resource buffer
  1752. jcprops.JPGFile      = NULL;
  1753. jcprops.JPGBytes     = pmem;
  1754. jcprops.JPGSizeBytes = size;
  1756. //Read JPEG parameters from the buffer
  1757. jerr = ijlRead(&jcprops, IJL_JBUFF_READPARAMS);
  1758. }
  1760. //Make sure Parameter read was successful
  1761. if (jerr != IJL_OK)
  1762. {
  1763. MessageBox(g_hMainWnd, "Error reading JPEG parameters", TITLE, MB_OK);
  1764. return false;
  1765. }
  1767. //Prepare a 24Bit buffer to receive image data
  1768. BYTE *buffer24;
  1770. //Determine the required size
  1771. long szbuff24 = (jcprops.JPGWidth * C24BIT + 7) / 8
  1772. * jcprops.JPGHeight;
  1774. //Resize the buffer
  1775. buffer24 = new BYTE [szbuff24];
  1776. if (buffer24 == NULL)
  1777. {
  1778. MessageBox(g_hMainWnd, "Memory Allocation Error", TITLE, MB_OK);
  1779. return false;
  1780. }
  1782. //Set up the DIB specification for the JPEG decoder
  1783. jcprops.DIBWidth    = jcprops.JPGWidth;
  1784. jcprops.DIBHeight   = jcprops.JPGHeight; //Implies a bottom-up DIB.
  1785. jcprops.DIBChannels = 3;
  1786. jcprops.DIBColor    = IJL_BGR;
  1787. jcprops.DIBPadBytes = IJL_DIB_PAD_BYTES(jcprops.JPGWidth,3);
  1788. jcprops.DIBBytes    = reinterpret_cast<BYTE*>(buffer24);
  1790. //Set the JPG color space ... this will always be somewhat of an
  1791. //educated guess at best because JPEG is "color blind" (i.e.,
  1792. //nothing in the bit stream tells you what color space the data was
  1793. //encoded from. However, in this example we assume that we are
  1794. //reading JFIF files which means that 3 channel images are in the
  1795. //YCbCr color space and 1 channel images are in the Y color space.
  1796. switch(jcprops.JPGChannels)
  1797. {
  1798. case 1: jcprops.JPGColor = IJL_G;
  1799. break;
  1801. case 3: jcprops.JPGColor = IJL_YCBCR;
  1802. break;
  1804. default:
  1805. //This catches everything else, but no color twist will be
  1806. //performed by the IJL.
  1807. jcprops.DIBColor = (IJL_COLOR)IJL_OTHER;
  1808. jcprops.JPGColor = (IJL_COLOR)IJL_OTHER;
  1809. break;
  1810. }
  1812. //Read JPEG image data into our 24bit buffer
  1813. if (bFromFile)
  1814. jerr = ijlRead(&jcprops, IJL_JFILE_READWHOLEIMAGE);
  1815. else
  1816. jerr = ijlRead(&jcprops, IJL_JBUFF_READWHOLEIMAGE);
  1818. //Make sure the read was successful
  1819. if (jerr != IJL_OK)
  1820. {
  1821. MessageBox(g_hMainWnd, "Error reading JPEG image", TITLE, MB_OK);
  1822. return false;
  1823. }
  1825. HBITMAP hbm;
  1827. //Convert to current CLRMODE
  1828. if (DDPixelFormat.dwRGBBitCount == C16BIT)
  1829. {
  1830. //Create a 16bit buffer
  1831. WORD *buffer16;
  1832. long szbuff16;
  1834. //determine the size of our buffer
  1835. szbuff16 = ((jcprops.JPGWidth * C16BIT + 7) / 8)
  1836. * jcprops.JPGHeight;
  1838. //resize the buffer and make sure resize works
  1839. buffer16 = new WORD [szbuff16];
  1840. if (buffer16 == NULL)
  1841. {
  1842. MessageBox(g_hMainWnd, "Error creating 16Bit buffer", TITLE, MB_OK);
  1843. return false;
  1844. }
  1846. //Start at the beginning of the buffer
  1847. long j = 0;
  1849. //Step through the 24bit buffer
  1850. //Retrieve 3 channels at a time and convert their values to 16bit
  1851. for (long i = 0; i < szbuff24; i += 3)   
  1852. {
  1853. //Check the pixel format and write the color data
  1854. //to the 16bit buffer. After the write, advance the
  1855. //16bit buffer by one.
  1856. if (nPixelFormat == PF_555)
  1857. buffer16[j++] = RGB555(buffer24[i], buffer24[i + 1],
  1858. buffer24[i + 2]);
  1859. else
  1860. buffer16[j++] = RGB565(buffer24[i], buffer24[i + 1],
  1861. buffer24[i + 2]);
  1862. }
  1864. //Create the bitmap using the new 16bit buffer   
  1865. hbm = CreateBitmap (jcprops.JPGWidth, jcprops.JPGHeight, 1,
  1866. C16BIT, buffer16);
  1867. if(hbm == NULL)
  1868. {
  1869. MessageBox(g_hMainWnd, "Failed to create 16Bit Bitmap", TITLE, MB_OK);
  1870. return false;
  1871. }
  1873. //remove the new buffer
  1874. delete buffer16;
  1875. }
  1876. else if (DDPixelFormat.dwRGBBitCount == C24BIT)
  1877. {
  1878. //The data we have from the JPEG is already 24bit
  1879. //Just create the new bitmap from our buffer
  1880. hbm = CreateBitmap (jcprops.JPGWidth, jcprops.JPGHeight, 1,
  1881. C24BIT, buffer24);
  1882. if(hbm == NULL)
  1883. {
  1884. MessageBox(g_hMainWnd, "Failed to create 24Bit Bitmap", TITLE, MB_OK);
  1885. return false;
  1886. }
  1887. }
  1888. else if (DDPixelFormat.dwRGBBitCount == C32BIT)
  1889. {
  1890. //Create a 32bit buffer
  1891. BYTE *buffer32;
  1892. long szbuff32;
  1894. //determine the size of our buffer
  1895. szbuff32 = ((jcprops.JPGWidth * C32BIT + 7) / 8)
  1896. * jcprops.JPGHeight;
  1898. //resize the buffer and make sure resize works
  1899. buffer32 = new BYTE [szbuff32];
  1900. if (buffer32 == NULL)
  1901. {
  1902. MessageBox(g_hMainWnd, "Error creating 32Bit buffer", TITLE, MB_OK);
  1903. return false;
  1904. }
  1906. //Start at the beginning of the 24bit buffer
  1907. long j = 0;
  1909. //Step through the 32bit buffer, copying the 3 Channels from
  1910. //the 24bit buffer. However, at the end of each channel, we
  1911. //have to write an extra byte for the 32bit image's alpha
  1912. //channel
  1913. for (long i = 0; i < szbuff32; i += 4)   
  1914. {
  1915. buffer32[i + 0] = buffer24[j++]; //Blue channel
  1916. buffer32[i + 1] = buffer24[j++]; //Green channel
  1917. buffer32[i + 2] = buffer24[j++]; //Red channel
  1918. buffer32[i + 3] = (BYTE)0x00;    //Alpha channel
  1919. }
  1921. //Create the bitmap using the new 32bit buffer   
  1922. hbm = CreateBitmap (jcprops.JPGWidth, jcprops.JPGHeight, 1,
  1923. C32BIT, buffer32);
  1924. if(hbm == NULL)
  1925. {
  1926. MessageBox(g_hMainWnd, "Failed to create 32Bit Bitmap",
  1927. TITLE, MB_OK);
  1928. return false;
  1929. }
  1931. //remove the 32bit buffer
  1932. delete buffer32;
  1933. }
  1934. else
  1935. {
  1936. MessageBox(g_hMainWnd,
  1937. "Palettized modes not supported. Use a 16, 24, or 32 Bit display.",
  1938. TITLE, MB_OK);
  1939. return false;
  1940. }
  1942. //remove the old buffer
  1943. delete buffer24;
  1945. //If DirectDraw Surface is NULL, create it
  1946. if (*ppSurface == NULL)
  1947. {
  1948. //Create the surface from our surface description
  1949. Result = g_pDisplay->CreateSurface(ppSurface,jcprops.JPGWidth,jcprops.JPGHeight );
  1950. if(Result != DD_OK)
  1951. {
  1952. MessageBox(g_hMainWnd, "Could not create surface", TITLE, MB_OK);
  1953. return false;
  1954. }
  1955. }
  1957. //Copy bitmap data to DirectDraw Surface
  1958. (*ppSurface)->DrawBitmap(hbm, 0, 0, 0, 0);
  1960. // clean up and destroy the JPEG Decompressor
  1961. ijlFree(&jcprops);
  1962. DeleteObject(hbm);
  1963. return true;
  1964. }