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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
Winmain.cpp
资源名称：Invasion_src.rar　[点击查看]
上传用户：jiameide
上传日期：2010-03-01
资源大小：525k
文件大小：76k
源码类别：

射击游戏

开发平台：

Visual C++

Winmain.cpp：源码内容
  1. //*******************************************************
  2. //* INVASION - By Maur韈io Teichmann RItter 1998        *
  3. //* Please, respect the copyright                       *
  4. //*******************************************************
  6. #include <windows.h>
  7. #include <windowsx.h>
  8. #include <stdio.h>
  9. #include <math.h>
  10. #include <ddraw.h>
  11. #include "ddutil.h"
  12. #include "dsutil.hpp"
  14. #include "ufo.hpp"
  15. #include "resource.h"
  17. // Define Weapon kinds
  18. #define WP_1_LASER      0
  19. #define WP_2_LASER      1
  20. #define WP_3_LASER      2
  21. #define WP_1_PHOTON     3
  22. #define WP_2_PHOTON     4
  23. #define WP_3_PHOTON     5
  25. // Define Ship States
  26. #define SHIP_OK         0
  27. #define SHIP_EXPLODING  1
  28. #define SHIP_DESTROYED  3
  30. // Define the application states
  31. #define APP_MAINMENU     0
  32. #define APP_GAMESCREEN   1
  33. #define APP_CREDITS      2
  34. #define APP_HELPSCREEN   3
  36. int  iAppState = APP_MAINMENU;
  38. LPDIRECTDRAW7            lpDD;
  39. LPDIRECTDRAWSURFACE7     lpFrontBuffer;
  40. LPDIRECTDRAWSURFACE7     lpBackBuffer;
  41. LPDIRECTDRAWSURFACE7     lpUfo;
  42. LPDIRECTDRAWSURFACE7     lpBkGround;
  43. LPDIRECTDRAWSURFACE7     lpShip;
  44. LPDIRECTDRAWSURFACE7     lpShoot;
  45. LPDIRECTDRAWSURFACE7     lpShoot2;
  46. LPDIRECTDRAWSURFACE7     lpUfoShoot;
  47. LPDIRECTDRAWSURFACE7     lpBoom;
  48. LPDIRECTDRAWSURFACE7     lpShipBoom;
  49. LPDIRECTDRAWSURFACE7     lpAlpha;
  50. LPDIRECTDRAWSURFACE7     lpSelect;
  51. LPDIRECTDRAWSURFACE7     lpStatusBar;
  52. LPDIRECTDRAWSURFACE7     lpExtra;
  53. LPDIRECTDRAWPALETTE     lpArtPalette;
  55. //** INITIAL POINTERS
  56. Ovni*  pUFO    = NULL;
  57. Bullet*  pBullet = NULL;
  58. Extra*  pExtra  = NULL;
  60. unsigned int score;
  61. unsigned int Lastscore;
  64. DWORD dwShipExplode;
  65. int iOption;
  67. LPDIRECTSOUND           lpDS;
  68. HSNDOBJ                 hsoEnter          = NULL;
  69. HSNDOBJ                 hsoShoot          = NULL;
  70. HSNDOBJ                 hsoStop           = NULL;
  71. HSNDOBJ                 hsoBoom           = NULL;
  72. HSNDOBJ                 hsoUfoShoot       = NULL;
  73. HSNDOBJ                 hsoSelect         = NULL;
  74. HSNDOBJ                 hsoGetExtra       = NULL;
  75. HSNDOBJ                 hsoGameOver       = NULL;
  77. BOOL                    bSoundEnabled = FALSE;
  79. BOOL bShipStop = FALSE;
  80. BOOL bShootEnable = TRUE;
  81. BOOL bShoot = FALSE;
  82. BOOL iRepaint = -1;
  85. HWND                    hWndMain;
  86. HINSTANCE               hInst;
  87. BOOL                    bIsActive;
  88. DWORD                   dwTransType;
  89. DWORD                   lastTickCount = 0;
  91. DWORD                   dwFillColor;
  93. //** SHIP VARIABLES
  94. int iShipMov;
  95. int iShipState = 0;
  96. int            iShipPos = 285;
  97. int iWeapon = 0;
  98. int iLastWeapon = -1;
  99. int iPhotonAmmo = 0;
  100. int iLaserAmmo  = 100;
  101. int iLastAmmo = -1;
  102. int iMaxWeapon = 0;
  103. int iShield = 0;
  104. int iLastShield = -1;
  106. //** LEVEL VARIABLES
  107. int        iLevel;
  108. int SHOOTCHANCE  = 1000;
  110. // Defini玢o das fun珲es
  111. int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow );
  112. BOOL RestoreSurfaces( void );
  113. void DestroyGame(void);
  114. BOOL RestoreSurfaces( void );
  115. void bltText(char*  buffer, int  x, int y);
  116. void ShowGameOver();
  117. void DrawBackGround(LPDIRECTDRAWSURFACE7 lpDest, int x, int y, int wx, int wy);
  118. BOOL LoadUfoSurface(int iFlags);
  119. BOOL CleanupAndExit( char *err);
  121. void InitLevel(BOOL bStart)
  122. {
  124. Ovni* pFirst;
  125. Bullet* auxpBullet;
  126. Extra* pAuxExtra;
  128. int i = 0;
  129. int valInc = 1;
  130. int rem;
  131. int iLastExtra = 0;
  132. DWORD tick;
  133. HRESULT hRet;
  134. DDBLTFX     ddbltfx;
  135. char buffer[10];
  137. while(pExtra !=NULL)
  138. {
  139. pAuxExtra = pExtra->GetNext();
  140. delete(pExtra);
  141. pExtra = pAuxExtra;
  142. }
  144. while(pBullet !=NULL)
  145. {
  146. auxpBullet = pBullet->GetNext();
  147. delete(pBullet);
  148. pBullet = auxpBullet;
  149. }
  151. iLevel++;
  152. if (LoadUfoSurface(iLevel) != TRUE)
  153. CleanupAndExit("General Failed loading Ufo... Restart Game !");
  154. switch(iLevel % 6)
  155. {
  156. case 0:
  157. int i;
  158. i = iLevel / 6;
  160. pUFO    = new Ovni;
  161. pFirst = pUFO;
  162. pUFO->SetXY(20,20);
  163. iLastExtra = pUFO->CreateExtra(0);
  164. pUFO->SetInc(i);
  165. pUFO->SetMov(0);
  166. pUFO->iType = 2;
  167. pUFO->SetStr((int)(iLevel /7)+1);
  168. pUFO->SetNext(NULL);
  170. pUFO->SetNext(new Ovni);
  171. pUFO = pUFO->GetNext();
  172. pUFO->SetXY(110,90);
  173. iLastExtra = pUFO->CreateExtra(iLastExtra);
  174. pUFO->SetInc(i);
  175. pUFO->SetMov(0);
  176. pUFO->iType = 2;
  177. pUFO->SetStr((int)(iLevel /7)+1);
  178. pUFO->SetNext(NULL);
  180. pUFO->SetNext(new Ovni);
  181. pUFO = pUFO->GetNext();
  182. pUFO->SetXY(20,160);
  183. iLastExtra = pUFO->CreateExtra(iLastExtra);
  184. pUFO->SetInc(i);
  185. pUFO->SetMov(0);
  186. pUFO->iType = 2;
  187. pUFO->SetStr((int)(iLevel /7)+1);
  188. pUFO->SetNext(NULL);
  190. pUFO->SetNext(new Ovni);
  191. pUFO = pUFO->GetNext();
  192. pUFO->SetXY(540,20);
  193. iLastExtra = pUFO->CreateExtra(iLastExtra);
  194. pUFO->SetInc(i);
  195. pUFO->SetMov(1);
  196. pUFO->iType = 2;
  197. pUFO->SetStr((int)(iLevel /7)+1);
  198. pUFO->SetNext(NULL);
  200. pUFO->SetNext(new Ovni);
  201. pUFO = pUFO->GetNext();
  202. pUFO->SetXY(470,90);
  203. iLastExtra = pUFO->CreateExtra(iLastExtra);
  204. pUFO->SetInc(i);
  205. pUFO->SetMov(1);
  206. pUFO->iType = 2;
  207. pUFO->SetStr((int)(iLevel /7)+1);
  208. pUFO->SetNext(NULL);
  210. pUFO->SetNext(new Ovni);
  211. pUFO = pUFO->GetNext();
  212. pUFO->SetXY(540,160);
  213. iLastExtra = pUFO->CreateExtra(iLastExtra);
  214. pUFO->SetInc(i);
  215. pUFO->SetMov(1);
  216. pUFO->iType = 2;
  217. pUFO->SetStr((int)(iLevel /7)+1);
  218. pUFO->SetNext(NULL);
  219. break;
  220. case 1:
  222. for (i=0; i<3; i++)
  223. {
  224. if (i==0)
  225. {
  226. pUFO    = new Ovni;
  227. pFirst = pUFO;
  229. }
  230. else
  231. {
  232. pUFO->SetNext(new Ovni);
  233. pUFO = pUFO->GetNext();
  234. }
  236. pUFO->SetXY(15 + (i*30),(i * 65)+10);
  237. iLastExtra = pUFO->CreateExtra(iLastExtra);
  238. pUFO->SetInc(1);
  239. pUFO->SetMov(0);
  240. pUFO->SetNext(NULL);
  241. pUFO->SetQtdeDown(1);
  242. pUFO->SetStr((int)(iLevel /7)+1);
  243. }
  245. pUFO->SetNext(new Ovni);
  246. pUFO = pUFO->GetNext();
  247. pUFO->SetXY(45,195);
  248. iLastExtra = pUFO->CreateExtra(iLastExtra);
  249. pUFO->SetInc(1);
  250. pUFO->SetMov(0);
  251. pUFO->SetNext(NULL);
  252. pUFO->SetQtdeDown(1);
  253. pUFO->SetStr((int)(iLevel /7)+1);
  255. pUFO->SetNext(new Ovni);
  256. pUFO = pUFO->GetNext();
  257. pUFO->SetXY(15,260);
  258. iLastExtra = pUFO->CreateExtra(iLastExtra);
  259. pUFO->SetInc(1);
  260. pUFO->SetMov(0);
  261. pUFO->SetNext(NULL);
  262. pUFO->SetQtdeDown(1);
  263. pUFO->SetStr((int)(iLevel /7)+1);
  265. for (i=0; i<3; i++)
  266. {
  267. pUFO->SetNext(new Ovni);
  268. pUFO = pUFO->GetNext();
  270. pUFO->SetXY(560 - (i*30),(i * 65)+10);
  271. iLastExtra = pUFO->CreateExtra(iLastExtra);
  272. pUFO->SetInc(-1);
  273. pUFO->SetMov(0);
  274. pUFO->SetNext(NULL);
  275. pUFO->SetQtdeDown(1);
  276. pUFO->SetStr((int)(iLevel /7)+1);
  277. }
  279. pUFO->SetNext(new Ovni);
  280. pUFO = pUFO->GetNext();
  282. pUFO->SetXY(530,195);
  283. iLastExtra = pUFO->CreateExtra(iLastExtra);
  284. pUFO->SetInc(-1);
  285. pUFO->SetMov(0);
  286. pUFO->SetNext(NULL);
  287. pUFO->SetQtdeDown(1);
  288. pUFO->SetStr((int)(iLevel /7)+1);
  290. pUFO->SetNext(new Ovni);
  291. pUFO = pUFO->GetNext();
  293. pUFO->SetXY(560,260);
  294. iLastExtra = pUFO->CreateExtra(iLastExtra);
  295. pUFO->SetInc(-1);
  296. pUFO->SetMov(0);
  297. pUFO->SetNext(NULL);
  298. pUFO->SetQtdeDown(1);
  299. pUFO->SetStr((int)(iLevel /7)+1);
  301. break;
  303. case 2:
  304. for (i=0; i<5; i++)
  305. {
  306. if (i==0)
  307. {
  308. pUFO    = new Ovni;
  309. pFirst = pUFO;
  310. }
  311. else
  312. {
  313. pUFO->SetNext(new Ovni);
  314. pUFO = pUFO->GetNext();
  315. }
  316. pUFO->SetXY(15 + (i*30),(i * 65)+10);
  317. iLastExtra = pUFO->CreateExtra(iLastExtra);
  318. pUFO->SetInc(1);
  319. pUFO->SetMov(0);
  320. pUFO->SetNext(NULL);
  321. pUFO->SetQtdeDown(1);
  322. pUFO->SetStr((int)(iLevel /7)+1);
  323. }
  325. for (i=0; i<5; i++)
  326. {
  327. pUFO->SetNext(new Ovni);
  328. pUFO = pUFO->GetNext();
  330. pUFO->SetXY(560 - (i*30),(i * 65)+10);
  331. iLastExtra = pUFO->CreateExtra(iLastExtra);
  332. pUFO->SetInc(-1);
  333. pUFO->SetMov(0);
  334. pUFO->SetNext(NULL);
  335. pUFO->SetQtdeDown(1);
  336. pUFO->SetStr((int)(iLevel /7)+1);
  337. }
  338. break;
  339. case 4:
  340. pUFO    = new Ovni;
  341. pFirst = pUFO;
  342. pUFO->SetXY(20,20);
  343. iLastExtra = pUFO->CreateExtra(iLastExtra);
  344. pUFO->SetInc(2);
  345. pUFO->SetMov(2);
  346. pUFO->iType = 1;
  347. pUFO->SetStr((int)(iLevel /7)+1);
  348. pUFO->SetNext(NULL);
  350. pUFO->SetNext(new Ovni);
  351. pUFO = pUFO->GetNext();
  352. pUFO->SetXY(180,180);
  353. iLastExtra = pUFO->CreateExtra(iLastExtra);
  354. pUFO->SetInc(2);
  355. pUFO->SetMov(2);
  356. pUFO->iType = 1;
  357. pUFO->SetStr((int)(iLevel /7)+1);
  358. pUFO->SetNext(NULL);
  361. pUFO->SetNext(new Ovni);
  362. pUFO = pUFO->GetNext();
  363. pUFO->SetXY(530,110);
  364. iLastExtra = pUFO->CreateExtra(iLastExtra);
  365. pUFO->SetInc(2);
  366. pUFO->SetMov(3);
  367. pUFO->iType = 1;
  368. pUFO->SetStr((int)(iLevel /7)+1);
  369. pUFO->SetNext(NULL);
  371. pUFO->SetNext(new Ovni);
  372. pUFO = pUFO->GetNext();
  373. pUFO->SetXY(100,100);
  374. iLastExtra = pUFO->CreateExtra(iLastExtra);
  375. pUFO->SetInc(2);
  376. pUFO->SetMov(1);
  377. pUFO->iType = 1;
  378. pUFO->SetStr((int)(iLevel /7)+1);
  379. pUFO->SetNext(NULL);
  381. pUFO->SetNext(new Ovni);
  382. pUFO = pUFO->GetNext();
  383. pUFO->SetXY(450,190);
  384. iLastExtra = pUFO->CreateExtra(iLastExtra);
  385. pUFO->SetInc(2);
  386. pUFO->SetMov(0);
  387. pUFO->iType = 1;
  388. pUFO->SetStr((int)(iLevel /7)+1);
  389. pUFO->SetNext(NULL);
  390. break;
  392. case 5:
  393. pUFO    = new Ovni;
  394. pFirst = pUFO;
  395. pUFO->SetXY(20,20);
  396. iLastExtra = pUFO->CreateExtra(iLastExtra);
  397. pUFO->SetInc(3);
  398. pUFO->SetMov(2);
  399. pUFO->iType = 1;
  400. pUFO->SetStr((int)(iLevel /7)+1);
  401. pUFO->SetNext(NULL);
  404. pUFO->SetNext(new Ovni);
  405. pUFO = pUFO->GetNext();
  406. pUFO->SetXY(90,90);
  407. iLastExtra = pUFO->CreateExtra(iLastExtra);
  408. pUFO->SetInc(3);
  409. pUFO->SetMov(2);
  410. pUFO->iType = 1;
  411. pUFO->SetStr((int)(iLevel /7)+1);
  412. pUFO->SetNext(NULL);
  414. pUFO->SetNext(new Ovni);
  415. pUFO = pUFO->GetNext();
  416. pUFO->SetXY(20,160);
  417. iLastExtra = pUFO->CreateExtra(iLastExtra);
  418. pUFO->SetInc(3);
  419. pUFO->SetMov(3);
  420. pUFO->iType = 1;
  421. pUFO->SetStr((int)(iLevel /7)+1);
  422. pUFO->SetNext(NULL);
  424. pUFO->SetNext(new Ovni);
  425. pUFO = pUFO->GetNext();
  426. pUFO->SetXY(540,20);
  427. iLastExtra = pUFO->CreateExtra(iLastExtra);
  428. pUFO->SetInc(3);
  429. pUFO->SetMov(3);
  430. pUFO->iType = 1;
  431. pUFO->SetStr((int)(iLevel /7)+1);
  432. pUFO->SetNext(NULL);
  434. pUFO->SetNext(new Ovni);
  435. pUFO = pUFO->GetNext();
  436. pUFO->SetXY(470,90);
  437. iLastExtra = pUFO->CreateExtra(iLastExtra);
  438. pUFO->SetInc(3);
  439. pUFO->SetMov(3);
  440. pUFO->iType = 1;
  441. pUFO->SetStr((int)(iLevel /7)+1);
  442. pUFO->SetNext(NULL);
  444. pUFO->SetNext(new Ovni);
  445. pUFO = pUFO->GetNext();
  446. pUFO->SetXY(540,160);
  447. iLastExtra = pUFO->CreateExtra(iLastExtra);
  448. pUFO->SetInc(3);
  449. pUFO->SetMov(2);
  450. pUFO->iType = 1;
  451. pUFO->SetStr((int)(iLevel /7)+1);
  452. pUFO->SetNext(NULL);
  453. break;
  455. case 3:
  456. for (int j=0;j<3;j++)
  457. {
  458. for (i=0;i<8;i++)
  459. {
  460. if (j==0 && i==0)
  461. {
  462. pUFO    = new Ovni;
  463. pFirst = pUFO;
  464. }
  465. else
  466. {
  467. pUFO->SetNext(new Ovni);
  468. pUFO = pUFO->GetNext();
  469. }
  470. pUFO->SetXY((i * 77)+15,j*80);
  471. iLastExtra = pUFO->CreateExtra(iLastExtra);
  472. pUFO->SetInc(valInc);
  473. pUFO->SetMov(0);
  474. pUFO->SetStr((int)(iLevel /7)+1);
  475. pUFO->SetNext(NULL);
  476. }
  477. //pUFO->SetMov(1);
  478. //pUFO->SetInc (abs(pUFO->GetInc()) * -1);
  479. valInc = valInc * -1;
  480. }
  481. break;
  482. }
  483. pUFO = pFirst;
  486.     ddbltfx.dwSize = sizeof( ddbltfx );
  487.     ddbltfx.dwFillColor = dwFillColor;
  489. while (1)
  490. {
  491. hRet = lpFrontBuffer->Blt(NULL, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  492. if (hRet == DD_OK)
  493. {
  494. break;
  495. }
  496. if (hRet == DDERR_SURFACELOST)
  497. {
  498. hRet = RestoreSurfaces();
  499. if (hRet != DD_OK)
  500. break;
  501. }
  502. if (hRet != DDERR_WASSTILLDRAWING)
  503. break;
  504. }
  505. strcpy(buffer,"LEVEL");
  506. buffer[5] = ' ';
  507.     buffer[6] = iLevel/100 + '0';
  508.     rem = iLevel % 100;
  509.     buffer[7] = rem/10 + '0';
  510.     rem = iLevel % 10;
  511.     buffer[8] = rem + '0';
  512. buffer[9] = '';
  513. bltText(buffer,250,200);
  515. tick = GetTickCount();
  517. while(GetTickCount() - tick < 3000);
  520. iShipState = 0;
  521. iShipMov = 0;
  522. iShipPos = 285;
  523. iLastWeapon = -1;
  524. iLastAmmo = -1;
  525. iLastShield = -1;
  526. Lastscore = -1;
  527. SHOOTCHANCE = 180 - (40 * (int)(iLevel /7));
  528. if (SHOOTCHANCE < 50)
  529. SHOOTCHANCE = 50;
  530. }
  534. void ShowGameOver()
  535. {
  537. DWORD tick;
  538. HRESULT hRet;
  539. DDBLTFX     ddbltfx;
  540. char buffer[10];
  542.     ddbltfx.dwSize = sizeof( ddbltfx );
  543.     ddbltfx.dwFillColor = dwFillColor;
  545. while (1)
  546. {
  547. hRet = lpFrontBuffer->Blt(NULL, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  548. if (hRet == DD_OK)
  549. {
  550. break;
  551. }
  552. if (hRet == DDERR_SURFACELOST)
  553. {
  554. hRet = RestoreSurfaces();
  555. if (hRet != DD_OK)
  556. break;
  557. }
  558. if (hRet != DDERR_WASSTILLDRAWING)
  559. break;
  560. }
  561. strcpy(buffer,"GAME OVER");
  562. buffer[9] = '';
  563. bltText(buffer,250,200);
  565. tick = GetTickCount();
  566. SndObjPlay(hsoGameOver, NULL);
  567. while(GetTickCount() - tick < 3500);
  568. }
  570. void ShowCredits()
  571. {
  573. DWORD tick;
  574. HRESULT hRet;
  575. DDBLTFX     ddbltfx;
  576. char buffer[24];
  578.     ddbltfx.dwSize = sizeof( ddbltfx );
  579.     ddbltfx.dwFillColor = dwFillColor;
  581. while (1)
  582. {
  583. hRet = lpFrontBuffer->Blt(NULL, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  584. if (hRet == DD_OK)
  585. {
  586. break;
  587. }
  588. if (hRet == DDERR_SURFACELOST)
  589. {
  590. hRet = RestoreSurfaces();
  591. if (hRet != DD_OK)
  592. break;
  593. }
  594. if (hRet != DDERR_WASSTILLDRAWING)
  595. break;
  596. }
  597. strcpy(buffer,"THIS GAME IS FREEWARE");
  598. bltText(buffer,145,60);
  600. strcpy(buffer,"IF YOU WANT TO MAIL ME");
  601. bltText(buffer,130,130);
  603. strcpy(buffer,"OR YOU ARE FROM A GAME");
  604. bltText(buffer,120,200);
  606. strcpy(buffer,"COMPANY AND WANT TO");
  607. bltText(buffer,140,270);
  609. strcpy(buffer,"HIRE ME, MY MAIL IS");
  610. bltText(buffer,150,340);
  612. strcpy(buffer,"MAURICIORITTER@HOTMAIL.COM");
  613. bltText(buffer,120,410);
  615. tick = GetTickCount();
  616. // SndObjPlay(hsoGameOver, NULL);
  617. while(GetTickCount() - tick < 6000);
  618. }
  621. void InitializeSound( void )
  622. {
  623.     bSoundEnabled = FALSE;
  624.     if (SUCCEEDED(DirectSoundCreate(NULL, &lpDS, NULL)))
  625.     {
  626. if (SUCCEEDED(lpDS->SetCooperativeLevel(hWndMain,
  627.             DSSCL_NORMAL)))
  628.         {
  629. hsoStop     = SndObjCreate(lpDS, "Stop", 1);
  630. hsoShoot    = SndObjCreate(lpDS, "Shoot",1);
  631. hsoBoom     = SndObjCreate(lpDS, "Boom", 8);
  632. hsoUfoShoot = SndObjCreate(lpDS, "UfoShoot", 8);
  633. hsoEnter    = SndObjCreate(lpDS, "Enter", 1);
  634. hsoSelect   = SndObjCreate(lpDS, "Select", 1);
  635. hsoGetExtra = SndObjCreate(lpDS, "GetExtra", 1);
  636. hsoGameOver = SndObjCreate(lpDS, "GameOver", 1);
  638.             bSoundEnabled = TRUE;
  640.         }
  641.         else
  642.         {
  643.             lpDS->Release();
  644.             lpDS = NULL;
  645.         }
  646.     }
  647. }
  649. void DestroySound( void )
  650. {
  651. // if(!bWantSound)
  652. // return; //No work to be done
  653.     bSoundEnabled = FALSE;
  654.     if (lpDS != NULL)
  655.     {
  656.         SndObjDestroy(hsoEnter);
  657.         hsoEnter = NULL;
  658.         SndObjDestroy(hsoStop);
  659.         hsoStop = NULL;
  660.         SndObjDestroy(hsoShoot);
  661.         hsoShoot = NULL;
  662.         SndObjDestroy(hsoUfoShoot);
  663.         hsoUfoShoot = NULL;
  664.         SndObjDestroy(hsoBoom);
  665.         hsoBoom = NULL;
  666.         SndObjDestroy(hsoSelect);
  667.         hsoSelect = NULL;
  668.         SndObjDestroy(hsoGetExtra);
  669.         hsoGetExtra = NULL;
  670.         SndObjDestroy(hsoGameOver);
  671.         hsoGameOver = NULL;
  672.         lpDS->Release();
  673.         lpDS = NULL;
  674.     }
  675. }
  677. long FAR PASCAL MainWndproc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
  678. {
  679. Bullet* pNewBullet, *pFirstBullet;
  681.     switch( message )
  682.     {
  683.     case WM_TIMER:
  684. switch(wParam)
  685. {
  686. case 1:
  687. bShootEnable = TRUE;
  688. KillTimer(hWnd,1);
  689. break;
  690. }
  691. break;
  692. case WM_ACTIVATEAPP:
  693. iAppState = APP_MAINMENU;
  694.         bIsActive = (BOOL) wParam;
  695. break;
  696.     case WM_KEYDOWN:
  697. // If We are at the help screen an hit any key, go back to MainMenu
  698. if (iAppState == APP_HELPSCREEN)
  699. {
  700. lastTickCount = 0;
  701. iAppState = APP_MAINMENU;
  702. return 0L;
  703. }
  705. switch (wParam)
  706.         {
  707. case VK_RETURN:
  708. if (iAppState == APP_MAINMENU)
  709. {
  710. // if the user hit <enter> at the menu
  711. // change the app setting depending on the user selection
  712. switch(iOption)
  713. {
  714. case 0:
  715. lastTickCount = 0;
  717. SndObjPlay(hsoEnter, FALSE);
  719. // Set the app state to start the game
  720. iAppState = APP_GAMESCREEN;
  722. lastTickCount = 0;
  724. // Reset the score counter, level, ship state and ammo
  725. score = 0;
  726. iLevel = 0;
  727. iShipState = 0;
  728. iWeapon = 0;
  729. iLaserAmmo = 100;
  730. iPhotonAmmo = 0;
  731. iShield = 50;
  732. iMaxWeapon = 0;
  733. Lastscore = 99;
  735. // Initialize Level
  736. InitLevel(TRUE);
  738. break;
  739. case 1:
  740. // User selected the second option, credits
  741. iAppState = APP_CREDITS;
  742. break;
  743. case 2:
  744. // User selected the help screen
  745. iAppState = APP_HELPSCREEN;
  746. lastTickCount = 0;
  747. break;
  748. case 3:
  749. // User want磗 to quit
  750. // Cleanup up everything
  751. DestroyGame();
  752. PostQuitMessage(0);
  753. break;
  754. }
  755. }
  756. else
  757. {
  758. // If we are at the game screen, enter can be used to stop the
  759. // ship
  761. // If the ship is not ok, doen磘 need to stop it, 
  762. if (iShipState != SHIP_OK)
  763. break;
  765. // If the ship is already stopped, get out
  766. if (iShipMov == 0)
  767. break;
  769. // Stop the ship
  770. bShipStop = TRUE;
  771. iShipMov = 0;
  772. }
  773. break;
  775. case VK_CONTROL:
  776. // Control key is used to change the weapon
  778. // If not in game screen, get out
  779. if (iAppState != APP_GAMESCREEN)
  780. break;
  782. // Increment weapon type
  783. iWeapon++;
  785. // If we reached the Maximum weapon avaible for the ship
  786. // reset to the first weapon
  787. if (iWeapon > iMaxWeapon)
  788. iWeapon = 0;
  789. break;
  791. case VK_LEFT:
  792. // If not in game screen, get out
  794. if (iAppState != APP_GAMESCREEN)
  795. break;
  797. // If the ship is not ok, can磘 be moved
  798. if (iShipState != SHIP_OK)
  799. break;
  801. // Set the movement rate to -4 pixel
  802. iShipMov = -4;
  803. break;
  805. case VK_UP:
  807. // Up key is just used in the main menu screen
  808. // If not in main menu, get out
  810. if (iAppState != APP_MAINMENU)
  811. break;
  813. // User hit up key, raise up 1 menu option
  814. iOption--;
  816. // Play the select option sound
  817. SndObjStop(hsoSelect);
  818. SndObjPlay(hsoSelect,NULL);
  820. // If we reach the first option, go the last one
  821. if (iOption < 0)
  822. iOption = 3;
  823. break;
  825. case VK_RIGHT:
  827. // Right key is just used during the game
  828. // If we aren磘 in the game screen, get out
  830. if (iAppState != APP_GAMESCREEN)
  831. break;
  833. // If the ship is not ok, can磘 be moved
  834. if (iShipState != SHIP_OK)
  835. break;
  837. // Set the movement rate to +4 pixels
  838. iShipMov = 4;
  839. break;
  841. case VK_DOWN:
  843. // Down key can be used in the main screen or at the
  844. // the game screen to stp the ship
  845. switch (iAppState)
  846. {
  847. case APP_MAINMENU:
  848. // Select the down key at main menu
  849. // increment option counter
  850. iOption++;
  851. SndObjStop(hsoSelect);
  852. SndObjPlay(hsoSelect,NULL);
  853. if (iOption > 3)
  854. iOption = 0;
  855. break;
  856. case APP_GAMESCREEN:
  857. // Select down key at the game screen, stop the
  858. // ship if it磗 ok and not destroyed
  860. // If the ship is not ok, doen磘 need to stop it, 
  861. if (iShipState != SHIP_OK)
  862. break;
  864. // If the ship is already stopped, get out
  865. if (iShipMov == 0)
  866. break;
  868. bShipStop = TRUE;
  869. iShipMov = 0;
  870. break;
  871. }
  872. break;
  873. case VK_SPACE:
  874. // SPACE BAR is used to shoot during the game screen
  876. // Not at the game screen
  877. if (iAppState != APP_GAMESCREEN)
  878. break;
  880. // If ship is not ok, get out
  881. if (iShipState != SHIP_OK)
  882. break;
  884. // Check if we can shoot or we are waiting for our weapon
  885. // recharge
  886. if (bShootEnable == FALSE)
  887. break;
  889. // Start shooting flag
  890. bShoot = TRUE;
  892. // Check the weapon we are using
  893. switch (iWeapon)
  894. {
  895. case WP_1_LASER:
  896. // using single laser
  898. // if we are out of ammo, get energy from the shields
  899. if (iLaserAmmo == 0)
  900. iShield -= 1;
  901. else
  902. iLaserAmmo--;
  904. // Create a new bullet object and add it to bullet list
  905. pNewBullet = new Bullet;
  906. if (pBullet == NULL)
  907. {
  908. pBullet = pNewBullet;
  909. pNewBullet->SetXY(iShipPos+24, 380);
  910. pBullet->SetType(2);
  911. }
  912. else
  913. {
  914. pFirstBullet = pBullet;
  915. while (pBullet->GetNext() != NULL)
  916. pBullet = pBullet->GetNext();
  917. pBullet->SetNext(pNewBullet);
  918. pNewBullet->SetPrev(pBullet);
  919. pNewBullet->SetXY(iShipPos+24, 380);
  920. pNewBullet->SetType(2);
  921. pBullet = pFirstBullet;
  922. }
  923. break;
  925. case WP_2_LASER:
  927. // If we are out of ammo, not shoot
  928. if (iLaserAmmo < 2)
  929. return 0L;
  931. iLaserAmmo-=2;
  933. // Create a new bullet object and add it to bullet list
  934. pNewBullet = new Bullet;
  935. if (pBullet == NULL)
  936. {
  937. pBullet = pNewBullet;
  938. pNewBullet->SetXY(iShipPos+11, 380);
  939. pNewBullet->SetType(2);
  940. pFirstBullet = pBullet;
  941. }
  942. else
  943. {
  944. pFirstBullet = pBullet;
  945. while (pBullet->GetNext() != NULL)
  946. pBullet = pBullet->GetNext();
  947. pBullet->SetNext(pNewBullet);
  948. pNewBullet->SetPrev(pBullet);
  949. pNewBullet->SetXY(iShipPos+11, 385);
  950. pNewBullet->SetType(2);
  951. pBullet = pFirstBullet;
  952. }
  953. pNewBullet = new Bullet;
  954. pFirstBullet = pBullet;
  955. while (pBullet->GetNext() != NULL)
  956. pBullet = pBullet->GetNext();
  957. pBullet->SetNext(pNewBullet);
  958. pNewBullet->SetPrev(pBullet);
  959. pNewBullet->SetXY(iShipPos+34, 385);
  960. pNewBullet->SetType(2);
  961. pBullet = pFirstBullet;
  962. break;
  964. case WP_3_LASER:
  966. // If we are out of ammo, not shoot
  967. if (iLaserAmmo < 3)
  968. return 0L;
  970. iLaserAmmo-=3;
  972. pNewBullet = new Bullet;
  974. if (pBullet == NULL)
  975. {
  976. pBullet = pNewBullet;
  977. pNewBullet->SetXY(iShipPos+11, 380);
  978. pNewBullet->SetType(2);
  979. pFirstBullet = pBullet;
  980. }
  981. else
  982. {
  983. pFirstBullet = pBullet;
  984. while (pBullet->GetNext() != NULL)
  985. pBullet = pBullet->GetNext();
  986. pBullet->SetNext(pNewBullet);
  987. pNewBullet->SetPrev(pBullet);
  988. pNewBullet->SetXY(iShipPos+11, 385);
  989. pNewBullet->SetType(2);
  990. pBullet = pFirstBullet;
  991. }
  992. pNewBullet = new Bullet;
  993. pFirstBullet = pBullet;
  994. while (pBullet->GetNext() != NULL)
  995. pBullet = pBullet->GetNext();
  996. pBullet->SetNext(pNewBullet);
  997. pNewBullet->SetPrev(pBullet);
  998. pNewBullet->SetXY(iShipPos+35, 385);
  999. pNewBullet->SetType(2);
  1000. pBullet = pFirstBullet;
  1002. pNewBullet = new Bullet;
  1003. pFirstBullet = pBullet;
  1004. while (pBullet->GetNext() != NULL)
  1005. pBullet = pBullet->GetNext();
  1006. pBullet->SetNext(pNewBullet);
  1007. pNewBullet->SetPrev(pBullet);
  1008. pNewBullet->SetXY(iShipPos+23, 380);
  1009. pNewBullet->SetType(2);
  1010. pBullet = pFirstBullet;
  1011. break;
  1014. case  WP_1_PHOTON:
  1017. if (iPhotonAmmo == 0)
  1018. return 0L;
  1020. iPhotonAmmo--;
  1022. pNewBullet = new Bullet;
  1023. if (pBullet == NULL)
  1024. {
  1025. pBullet = pNewBullet;
  1026. pNewBullet->SetXY(iShipPos+24, 380);
  1027. }
  1028. else
  1029. {
  1030. pFirstBullet = pBullet;
  1031. while (pBullet->GetNext() != NULL)
  1032. pBullet = pBullet->GetNext();
  1033. pBullet->SetNext(pNewBullet);
  1034. pNewBullet->SetPrev(pBullet);
  1035. pNewBullet->SetXY(iShipPos+24, 380);
  1036. pBullet = pFirstBullet;
  1037. }
  1038. break;
  1040. case  WP_2_PHOTON:
  1042. if (iPhotonAmmo < 2)
  1043. return 0L;
  1044. iPhotonAmmo-=2;
  1045. pNewBullet = new Bullet;
  1046. if (pBullet == NULL)
  1047. {
  1048. pBullet = pNewBullet;
  1049. pNewBullet->SetXY(iShipPos+11, 380);
  1050. pFirstBullet = pBullet;
  1051. }
  1052. else
  1053. {
  1054. pFirstBullet = pBullet;
  1055. while (pBullet->GetNext() != NULL)
  1056. pBullet = pBullet->GetNext();
  1057. pBullet->SetNext(pNewBullet);
  1058. pNewBullet->SetPrev(pBullet);
  1059. pNewBullet->SetXY(iShipPos+11, 385);
  1060. pBullet = pFirstBullet;
  1061. }
  1062. pNewBullet = new Bullet;
  1063. pFirstBullet = pBullet;
  1064. while (pBullet->GetNext() != NULL)
  1065. pBullet = pBullet->GetNext();
  1066. pBullet->SetNext(pNewBullet);
  1067. pNewBullet->SetPrev(pBullet);
  1068. pNewBullet->SetXY(iShipPos+34, 385);
  1069. pBullet = pFirstBullet;
  1070. break;
  1072. case  WP_3_PHOTON:
  1074. if (iPhotonAmmo < 3)
  1075. return 0L;
  1076. iPhotonAmmo-=3;
  1077. pNewBullet = new Bullet;
  1078. if (pBullet == NULL)
  1079. {
  1080. pBullet = pNewBullet;
  1081. pNewBullet->SetXY(iShipPos+11, 380);
  1082. pFirstBullet = pBullet;
  1083. }
  1084. else
  1085. {
  1086. pFirstBullet = pBullet;
  1087. while (pBullet->GetNext() != NULL)
  1088. pBullet = pBullet->GetNext();
  1089. pBullet->SetNext(pNewBullet);
  1090. pNewBullet->SetPrev(pBullet);
  1091. pNewBullet->SetXY(iShipPos+11, 385);
  1092. pBullet = pFirstBullet;
  1093. }
  1094. pNewBullet = new Bullet;
  1095. pFirstBullet = pBullet;
  1096. while (pBullet->GetNext() != NULL)
  1097. pBullet = pBullet->GetNext();
  1098. pBullet->SetNext(pNewBullet);
  1099. pNewBullet->SetPrev(pBullet);
  1100. pNewBullet->SetXY(iShipPos+35, 385);
  1101. pBullet = pFirstBullet;
  1103. pNewBullet = new Bullet;
  1104. pFirstBullet = pBullet;
  1105. while (pBullet->GetNext() != NULL)
  1106. pBullet = pBullet->GetNext();
  1107. pBullet->SetNext(pNewBullet);
  1108. pNewBullet->SetPrev(pBullet);
  1109. pNewBullet->SetXY(iShipPos+23, 380);
  1110. pBullet = pFirstBullet;
  1111. break;
  1112. }
  1114. SndObjStop(hsoShoot);
  1115. SndObjPlay(hsoShoot,0);
  1116. bShootEnable = FALSE;
  1117. if (iWeapon == 0)
  1118. SetTimer(hWnd,1,400,NULL);
  1119. else
  1120. SetTimer(hWnd,1,680,NULL);
  1121. break;
  1123. case VK_F12:
  1124. case VK_ESCAPE:
  1126. // ESCAPE KEY AND F12 IS THE SAME AS QUIT
  1128. // Quit if main menu, gameover if gamescreen
  1129. if (iAppState == APP_MAINMENU)
  1130. {
  1131. DestroyGame();
  1132. PostQuitMessage(0);
  1133. break;
  1134. }
  1135. else
  1136. {
  1137. Ovni* auxpUFO;
  1138. Bullet* auxpBullet;
  1139. Extra* auxpExtra;
  1141. while(pExtra !=NULL)
  1142. {
  1143. auxpExtra = pExtra->GetNext();
  1144. delete(pExtra);
  1145. pExtra = auxpExtra;
  1146. }
  1148. while(pUFO !=NULL)
  1149. {
  1150. auxpUFO = pUFO->GetNext();
  1151. delete(pUFO);
  1152. pUFO = auxpUFO;
  1153. }
  1155. while(pBullet !=NULL)
  1156. {
  1157. auxpBullet = pBullet->GetNext();
  1158. delete(pBullet);
  1159. pBullet = auxpBullet;
  1160. }
  1162. lastTickCount = 0;
  1163. iAppState = 0;
  1164. }
  1165. break;
  1166.         }
  1167.        break;
  1169. case WM_CREATE:
  1170.         break;
  1172.     case WM_DESTROY:
  1173.         DestroyGame();
  1174.         PostQuitMessage(0);
  1175.         break;
  1177.     default:
  1178.         break;
  1179.     }
  1180.     return DefWindowProc(hWnd, message, wParam, lParam);
  1182. } /* MainWndproc */
  1184. void DrawBackGround(LPDIRECTDRAWSURFACE7 lpDest, int x, int y, int wx, int wy)
  1185. {
  1186. // Blit the background to the destination surface
  1187. RECT rcRect;
  1188. HRESULT hRet;
  1189. rcRect.left = x;
  1190.     rcRect.top = y;
  1191.     rcRect.right = wx;
  1192.     rcRect.bottom = wy;
  1194. while (1)
  1195.     {
  1196.         hRet = lpDest->BltFast(x, y, lpBkGround, &rcRect, FALSE);
  1197.         if (hRet == DD_OK)
  1198.         {
  1199.             break;
  1200.         }
  1201.         if (hRet == DDERR_SURFACELOST)
  1202.         {
  1203.             hRet = RestoreSurfaces();
  1204.             if (hRet != DD_OK)
  1205.                 break;
  1206.         }
  1207.         if (hRet != DDERR_WASSTILLDRAWING)
  1208.             break;
  1209.     }
  1210. }
  1212. void DestroyBullet(Bullet* pDeadBullet)
  1213. {
  1214. HRESULT hRet;
  1215. RECT rcRect;
  1217. // Destroy a bullet in the screen
  1218. rcRect.left = pDeadBullet->GetX();
  1219.     rcRect.top = pDeadBullet->GetY()-6;
  1220.     rcRect.right = pDeadBullet->GetX()+20;
  1221.     rcRect.bottom = pDeadBullet->GetY()+32;
  1223. if (rcRect.bottom > 640)
  1224. rcRect.bottom = 640;
  1225. DrawBackGround(lpBackBuffer, pDeadBullet->GetX(),pDeadBullet->GetY(),pDeadBullet->GetX()+20,pDeadBullet->GetY()+20);
  1227. while (1)
  1228. {
  1229. hRet = lpFrontBuffer->BltFast(pDeadBullet->GetX(), pDeadBullet->GetY()-6, lpBkGround, &rcRect, FALSE);
  1230. if (hRet == DD_OK)
  1231. {
  1232. break;
  1233. }
  1234. if (hRet == DDERR_SURFACELOST)
  1235. {
  1236. hRet = RestoreSurfaces();
  1237. if (hRet != DD_OK)
  1238. break;
  1239. }
  1240. if (hRet != DDERR_WASSTILLDRAWING)
  1241. break;
  1242. }
  1243. }
  1246. void DrawInvalidBackGround()
  1247. {
  1249. // Redraw background
  1250. RECT rcRect;
  1251. HRESULT hRet;
  1252. static y = 0;
  1253. const int iFim = 455;
  1254. if (lastTickCount = 0)
  1255. {
  1256. y =0;
  1257. }
  1258. y += 1;
  1259. if (y>iFim)
  1260. y = 0;
  1262. rcRect.left = 0;
  1263.     rcRect.top = 0;
  1264.     rcRect.right = 640;
  1265.     rcRect.bottom = iFim-y;
  1268. while (1)
  1269.     {
  1270. hRet = lpBackBuffer->BltFast(0, y, lpBkGround, &rcRect, DDBLTFAST_NOCOLORKEY);
  1271.         if (hRet == DD_OK)
  1272.         {
  1273.             break;
  1274.         }
  1275.         if (hRet == DDERR_SURFACELOST)
  1276.         {
  1277.             hRet = RestoreSurfaces();
  1278.             if (hRet != DD_OK)
  1279.                 break;
  1280.         }
  1281.         if (hRet != DDERR_WASSTILLDRAWING)
  1282.             break;
  1283.     }
  1286. rcRect.left = 0;
  1287.     rcRect.top = iFim-y;
  1288.     rcRect.right = 640;
  1289.     rcRect.bottom = iFim;
  1291. while (1)
  1292.     {
  1293.         hRet = lpBackBuffer->BltFast(0, 0, lpBkGround, &rcRect, DDBLTFAST_NOCOLORKEY);
  1294.         if (hRet == DD_OK)
  1295.         {
  1296.             break;
  1297.         }
  1298.         if (hRet == DDERR_SURFACELOST)
  1299.         {
  1300.             hRet = RestoreSurfaces();
  1301.             if (hRet != DD_OK)
  1302.                 break;
  1303.         }
  1304.         if (hRet != DDERR_WASSTILLDRAWING)
  1305.             break;
  1306.     }
  1308. //DrawBackGround(lpBackBuffer,0,y,640,460);
  1309. /* Bullet* pFirstBullet;
  1310. Extra* pFirstExtra;
  1311. Ovni* pFirstUFO;
  1312. int left;
  1313. int right;
  1315. if (iRepaint == -1)
  1316. {
  1317. pFirstExtra = pExtra;
  1318. while (pExtra != NULL)
  1319. {
  1321. pExtra->Repaint(lpBackBuffer,lpBkGround,NULL);
  1322. pExtra = pExtra->GetNext();
  1323. }
  1324. pExtra = pFirstExtra;
  1326. pFirstUFO = pUFO;
  1327. while (pUFO != NULL)
  1328. {
  1330. pUFO->Repaint(lpBackBuffer, lpBkGround, NULL);
  1331. pUFO = pUFO->GetNext();
  1332. }
  1333. pUFO = pFirstUFO;
  1335. pFirstBullet = pBullet;
  1336. while (pBullet != NULL)
  1337. {
  1338. pBullet->Repaint(lpBackBuffer,lpBkGround,NULL);
  1339. //DrawBackGround(iTempX,iTempY-12, iTempX+20, iTempY+34);
  1340. pBullet = pBullet->GetNext();
  1341. }
  1342. pBullet = pFirstBullet;
  1345. left = iShipPos-25;
  1346. if (left < 0)
  1347. left=0;
  1348. right = iShipPos+95;
  1349. if (right > 640)
  1350. right=640;
  1351. DrawBackGround(lpBackBuffer,left,380,right,456);
  1352. }
  1353. else
  1354. {
  1355. DrawBackGround(lpBackBuffer,0,0,640,480);
  1356. iRepaint--;
  1357. iLastWeapon = -1;
  1358. iLastAmmo = -1;
  1359. Lastscore = -1;
  1360. iLastShield = -1;
  1361. }*/
  1362. }
  1364. void DrawExtra()
  1365. {
  1366. // Draw extra objects in the screen (ammo, bonus, etc)
  1368. Extra* pFirstExtra;
  1369. Extra* pNextExtra = NULL;
  1370. Extra* pLastExtra = NULL;
  1371. Extra* pPrevExtra = NULL;
  1373. pFirstExtra = pExtra;
  1374. //因为当前屏幕中可能有多个奖子，所以这里使用while语句就是要将所有的奖子都绘制出来，
  1375. //当前屏幕中的奖子都被保存在同一个奖子链表中，所以绘制所有奖子时要求遍历整个奖子队列
  1376. while (pExtra != NULL)
  1377. {
  1378. //传入的是-3，即每次掉落3个象素点
  1379. pExtra->Move(-3);
  1380. //绘制当前节点奖子
  1381. pExtra->Draw(lpBackBuffer,lpExtra);
  1383. //如果当前的奖子已经掉落到屏幕以外，则调整奖子列表，删除当前奖子节点
  1384. if (pExtra->GetY() > 455)
  1385. {
  1386. //调整奖子链表节点和相关指针
  1387. if (pPrevExtra != NULL)
  1388. pPrevExtra->SetNext( pExtra->GetNext() );
  1389. pNextExtra = pExtra->GetNext();
  1390. if (pNextExtra != NULL)
  1391. pNextExtra->SetPrev(pPrevExtra);
  1392. //如果当前奖子节点位于链表中的第一位置，则还需要再调整链表
  1393. if (pExtra == pFirstExtra)
  1394. pFirstExtra=pExtra->GetNext();
  1395. //删除当前奖子节点
  1396. delete(pExtra);
  1397. //重置当前奖子节点
  1398. pExtra = pNextExtra;
  1399. }
  1400. else
  1401. {
  1402. //遍历奖子链表：当前奖子节点指向链表中下一个节点
  1403. pPrevExtra = pExtra;
  1404. pExtra = pExtra->GetNext();
  1405. }
  1406. }
  1407. pExtra = pFirstExtra;
  1408. }
  1410. void DrawBullet()
  1411. {
  1412. // Draw bullets in the screen
  1413. Bullet* pFirstBullet;
  1414. Bullet* pNextBullet = NULL;
  1415. Bullet* pLastBullet = NULL;
  1416. Bullet* pPrevBullet = NULL;
  1418. pFirstBullet = pBullet;
  1419. while (pBullet != NULL)
  1420. {
  1421. switch(pBullet->GetType())
  1422. {
  1423. case 0:
  1424. pBullet->Move(6);
  1425. pBullet->Draw(lpBackBuffer,lpShoot);
  1426. break;
  1427. case 1:
  1428. pBullet->Move(-6);
  1429. pBullet->Draw(lpBackBuffer,lpUfoShoot);
  1430. break;
  1431. case 2:
  1432. pBullet->Move(10);
  1433. pBullet->Draw(lpBackBuffer,lpShoot2);
  1434. break;
  1435. }
  1437. if ((pBullet->GetY() <= -26) ||
  1438. (pBullet->GetY() > 455))
  1439. {
  1440. if (pPrevBullet != NULL)
  1441. pPrevBullet->SetNext( pBullet->GetNext() );
  1442. pNextBullet = pBullet->GetNext();
  1443. if (pNextBullet != NULL)
  1444. pNextBullet->SetPrev(pPrevBullet);
  1445. if (pBullet == pFirstBullet)
  1446. pFirstBullet=pBullet->GetNext();
  1447. //pBullet->Repaint(lpFrontBuffer,lpBkGround, NULL);
  1448. //pBullet->Repaint(lpBackBuffer,lpBkGround, 1);
  1449. delete(pBullet);
  1450. pBullet = pNextBullet;
  1451. }
  1452. else
  1453. {
  1454. pPrevBullet = pBullet;
  1455. pBullet = pBullet->GetNext();
  1456. }
  1457. }
  1458. pBullet = pFirstBullet;
  1459. }
  1461. int CheckHitExtra(void)
  1462. {
  1463. Extra *pFirstExtra, *pPrevExtra, *pNextExtra;
  1464. int iReturn = 0;
  1466. // Check if the ship get an extra
  1467. pPrevExtra = NULL;
  1468. pNextExtra = NULL;
  1469. pFirstExtra = pExtra;
  1470. while (pExtra != NULL)
  1471. {
  1472. if ((pExtra->GetX() >= iShipPos   &&
  1473. pExtra->GetX()  < iShipPos+54 &&
  1474. pExtra->GetY()  > 385         &&
  1475. pExtra->GetY()  < 425)        &&
  1476. (pExtra->GetType() != 0))
  1477. {
  1478. if (pPrevExtra != NULL)
  1479. pPrevExtra->SetNext( pExtra->GetNext() );
  1480. pNextExtra = pExtra->GetNext();
  1481. if (pNextExtra != NULL)
  1482. pNextExtra->SetPrev(pPrevExtra);
  1483. if (pExtra == pFirstExtra)
  1484. pFirstExtra=pExtra->GetNext();
  1486. iReturn = pExtra->GetType();
  1487. //pExtra->Repaint(lpFrontBuffer,lpBkGround,0);
  1488. //pExtra->Repaint(lpBackBuffer,lpBkGround,1);
  1489. delete(pExtra);
  1490. pExtra = pFirstExtra;
  1491. return iReturn;
  1492. }
  1493. pPrevExtra = pExtra;
  1494. pExtra = pExtra->GetNext();
  1495. }
  1496. pExtra = pFirstExtra;
  1497. return iReturn;
  1498. }
  1501. BOOL CheckHitShip(void)
  1502. {
  1503. Bullet *pFirstBullet, *pPrevBullet, *pNextBullet;;
  1505. // chekc if the ship was hitted
  1507. if (iShipState == 1) 
  1508. return FALSE;
  1510. pPrevBullet = NULL;
  1511. pNextBullet = NULL;
  1512. pFirstBullet = pBullet;
  1513. while (pBullet != NULL)
  1514. {
  1515. if ((pBullet->GetX() >= iShipPos   &&
  1516. pBullet->GetX()  < iShipPos+54 &&
  1517. pBullet->GetY()  > 385         &&
  1518. pBullet->GetY()  < 425)        &&
  1519. (pBullet->GetType() != 0))
  1520. {
  1521. if (pPrevBullet != NULL)
  1522. pPrevBullet->SetNext( pBullet->GetNext() );
  1523. pNextBullet = pBullet->GetNext();
  1524. if (pNextBullet != NULL)
  1525. pNextBullet->SetPrev(pPrevBullet);
  1526. if (pBullet == pFirstBullet)
  1527. pFirstBullet=pBullet->GetNext();
  1528. DestroyBullet(pBullet);
  1529. delete(pBullet);
  1530. pBullet = pFirstBullet;
  1531. return TRUE;
  1532. }
  1533. pPrevBullet = pBullet;
  1534. pBullet = pBullet->GetNext();
  1535. }
  1536. pBullet = pFirstBullet;
  1537. return FALSE;
  1538. }
  1540. void DrawShip()
  1541. {
  1542. static int ArgPosY = 0;
  1543. static int ArgPosX = 0;
  1544. static int inc = 70;
  1546. // draw the ship
  1548.     RECT                        rcRect;
  1549.     HRESULT                     hRet;
  1551.     // DrawUFO();
  1553. rcRect.left = ArgPosX;
  1554. rcRect.top = ArgPosY;
  1555. rcRect.right = ArgPosX + 70;
  1556. rcRect.bottom = ArgPosY + 70;
  1558. if (bShipStop)
  1559. {
  1560. SndObjPlay(hsoStop,0);
  1561. bShipStop = FALSE;
  1562. }
  1564. iShipPos += iShipMov;
  1566. if (iShipPos <= 1) 
  1567. {
  1568. iShipMov = 0;
  1569. iShipPos = 1;
  1570. }
  1571. if (iShipPos >= 569) 
  1572. {
  1573. iShipMov = 0;
  1574. iShipPos = 569;
  1575. }
  1577. if (iShipState == 0 && CheckHitShip() == TRUE)
  1578. {
  1579. iShield = iShield - 20;
  1580. }
  1581. /*
  1582. if (iShield <= 0 && iShipState == 0)
  1583. {
  1584. iShield = 0;
  1585. iShipState = 1;
  1586. iShipMov = 0;
  1587. ArgPosX = 0;
  1588. ArgPosY = 0;
  1589. rcRect.left = ArgPosX;
  1590. rcRect.top = ArgPosY;
  1591. rcRect.right = ArgPosX + 70;
  1592. rcRect.bottom = ArgPosY + 70;
  1593. inc = 70;
  1594. }
  1596. */
  1597. if (iShipState == SHIP_OK &&
  1598. pExtra != NULL)
  1599. {
  1600. int iType;
  1602. // check if we hit an extra
  1603. // if so, select the kinf of extra
  1604. iType = CheckHitExtra();
  1605. switch (iType)
  1606. {
  1607. case 1:
  1608. iPhotonAmmo += 25;
  1609. if (iPhotonAmmo > 999)
  1610. iPhotonAmmo = 999;
  1611. SndObjStop(hsoGetExtra);
  1612. SndObjPlay(hsoGetExtra, NULL);
  1613. break;
  1614. case 2:
  1615. iMaxWeapon++;
  1616. if (iMaxWeapon > 5)
  1617. iMaxWeapon = 5;
  1618. else
  1619. iWeapon = iMaxWeapon;
  1620. SndObjStop(hsoGetExtra);
  1621. SndObjPlay(hsoGetExtra, NULL);
  1622. break;
  1623. case 3:
  1624. score += 100;
  1625. SndObjStop(hsoGetExtra);
  1626. SndObjPlay(hsoGetExtra, NULL);
  1627. break;
  1628. case 4:
  1629. iLaserAmmo += 40;
  1630. if (iLaserAmmo > 999)
  1631. iLaserAmmo = 999;
  1632. SndObjStop(hsoGetExtra);
  1633. SndObjPlay(hsoGetExtra, NULL);
  1634. break;
  1635. case 5:
  1636. iShield += 10;
  1637. if (iShield > 50)
  1638. iShield = 50;
  1639. SndObjStop(hsoGetExtra);
  1640. SndObjPlay(hsoGetExtra, NULL);
  1641. break;
  1643. }
  1645. }
  1647. // Draw the ship sprite
  1648. while (1)
  1649. {
  1650. if (iShipState == 0)
  1651. hRet = lpBackBuffer->BltFast(iShipPos,380, lpShip, &rcRect, TRUE);
  1652. else
  1653. hRet = lpBackBuffer->BltFast(iShipPos,380, lpShipBoom, &rcRect, TRUE);
  1654. if (hRet == DD_OK)
  1655. {
  1656. break;
  1657. }
  1658. if (hRet == DDERR_SURFACELOST)
  1659. {
  1660. hRet = RestoreSurfaces();
  1661. if (hRet != DD_OK)
  1662. break;
  1663. }
  1664. if (hRet != DDERR_WASSTILLDRAWING)
  1665. break;
  1666. }
  1669. switch (iShipState)
  1670. {
  1671. case SHIP_OK:
  1672. ArgPosX += inc;
  1673. if (ArgPosX == 350 && inc > 0)
  1674. {
  1675. ArgPosX = 0;
  1676. ArgPosY += inc;
  1677. if (ArgPosY == 350)
  1678. {
  1679. ArgPosX=280;
  1680. ArgPosY=280;
  1681. inc = -70;
  1682. return;
  1683. }
  1685. }
  1687. if (ArgPosX == -70 && inc < 0)
  1688. {
  1689. ArgPosX = 280;
  1690. ArgPosY += inc;
  1691. if (ArgPosY == -70)
  1692. {
  1693. inc = 70;
  1694. ArgPosX = 0;
  1695. ArgPosY = 0;
  1696. }
  1697. }
  1698. break;
  1699. case SHIP_EXPLODING:
  1700. ArgPosX += inc;
  1701. if (ArgPosX == 490 && inc > 0)
  1702. {
  1703. ArgPosX = 0;
  1704. ArgPosY += inc;
  1705. if (ArgPosY == 210)
  1706. {
  1708. dwShipExplode = GetTickCount();
  1709. iShipState = SHIP_DESTROYED;
  1710. return;
  1711. }
  1712. }
  1713. break;
  1714. }
  1717. }
  1719. BOOL CheckHit(Ovni* pCheckUfo)
  1720. {
  1721. Bullet *pFirstBullet, *pPrevBullet, *pNextBullet;;
  1723. // Check if we have hitted and UFO
  1724. if (pCheckUfo->isExploding() == TRUE) 
  1725. return FALSE;
  1727. pPrevBullet = NULL;
  1728. pNextBullet = NULL;
  1729. pFirstBullet = pBullet;
  1730. while (pBullet != NULL)
  1731. {
  1732. if ((pBullet->GetX() > pCheckUfo->GetX()    &&
  1733. pBullet->GetX() < pCheckUfo->GetX()+64 &&
  1734. pBullet->GetY() > pCheckUfo->GetY()    &&
  1735. pBullet->GetY() < pCheckUfo->GetY()+56) &&
  1736. (pBullet->GetType() != 1))
  1737. {
  1738. pCheckUfo->LowStr(pBullet->GetPower());
  1739. if (pPrevBullet != NULL)
  1740. pPrevBullet->SetNext( pBullet->GetNext() );
  1741. pNextBullet = pBullet->GetNext();
  1742. if (pNextBullet != NULL)
  1743. pNextBullet->SetPrev(pPrevBullet);
  1744. if (pBullet == pFirstBullet)
  1745. pFirstBullet=pBullet->GetNext();
  1746. DestroyBullet(pBullet);
  1747. delete(pBullet);
  1748. pBullet = pFirstBullet;
  1750. if (pCheckUfo->GetStr() <= 0)
  1751. {
  1752. return TRUE;
  1753. }
  1754. else
  1755. {
  1756. score += 1;
  1757. SndObjStop(hsoSelect);
  1758. SndObjPlay(hsoSelect,NULL);
  1759. return FALSE;
  1760. }
  1761. }
  1762. pPrevBullet = pBullet;
  1763. pBullet = pBullet->GetNext();
  1764. }
  1765. pBullet = pFirstBullet;
  1766. return FALSE;
  1767. }
  1769. BOOL CheckCrash(Ovni* pCheck)
  1770. {
  1771. // Check if we have creashed in an UFO
  1772. Ovni *pFirst;
  1773. pFirst = pUFO;
  1774. while(pUFO != NULL)
  1775. {
  1776. if (pUFO->isExploding() == FALSE      &&
  1777. pUFO->GetY() == pCheck->GetY()    &&
  1778. pUFO != pCheck)
  1779. {
  1780. if (pCheck->GetX() < pUFO->GetX())
  1781. {
  1782. if (pUFO->GetX() - pCheck->GetX() <= 70 &&
  1783. (
  1784. (pCheck->GetInc() > 0 && pCheck->iType==0) ||
  1785. (pCheck->GetMov() == 0 && pCheck->iType==2)   )
  1786. )
  1787. return TRUE;
  1788. }
  1789. else
  1790. {
  1791. if (pCheck->GetX() - pUFO->GetX() <= 70 &&
  1792. ((pCheck->GetInc() < 0 &&
  1793. pCheck->iType == 0) ||
  1794. (pCheck->GetMov()==1 &&
  1795. pCheck->iType==2))
  1796. )
  1797. return TRUE;
  1798. }
  1799. }
  1800. pUFO = pUFO->GetNext();
  1801. }
  1802. pUFO = pFirst;
  1803. return FALSE;
  1804. }
  1806. void DrawUfo()
  1807. {
  1808. static int ArgPosY = 0;
  1809. static int ArgPosX = 0;
  1810. DWORD delayshoot;
  1811. Ovni* pFirst, *pNext, *pPrev, *pAux;
  1812. Bullet* pNewBullet, *pFirstBullet;
  1813. Extra* pNewExtra,  *pFirstExtra;
  1814.     
  1815.     pFirst = pUFO;
  1817. // draw all the ufos
  1819. pUFO = pFirst;
  1820. pPrev = NULL;
  1821. while(pUFO != NULL)
  1822. {
  1824. switch (pUFO->isExploding() )
  1825. {
  1826. case FALSE:
  1827. switch (pUFO->iType)
  1828. {
  1829. case 0:
  1830. delayshoot = 100;
  1831. break;
  1832. case 1:
  1833. delayshoot = 10;
  1834. break;
  1835. case 2:
  1836. delayshoot = 70;
  1837. break;
  1838. }
  1839. if (bShoot == TRUE)
  1840. {
  1842. pUFO->Move(iShipPos);
  1843. }
  1844. else
  1845. pUFO->Move(NULL);
  1846. pUFO->Draw(lpBackBuffer,lpUfo,NULL);
  1848. if (CheckHit(pUFO) == TRUE)
  1849. {
  1850. pUFO->SetState(1);
  1851. score += 10;
  1852. //SndObjStop(hsoBoom);
  1853. SndObjPlay(hsoBoom,0);
  1854. }
  1856. if ( (GetTickCount() - pUFO->dwLastShoot) > delayshoot)
  1857. {
  1858. if (rand()%SHOOTCHANCE == 0)
  1859. {
  1860. pUFO->dwLastShoot = GetTickCount();
  1861. pNewBullet = new Bullet;
  1862. if (pBullet == NULL)
  1863. {
  1864. pBullet = pNewBullet;
  1865. pNewBullet->SetType(1);
  1866. pNewBullet->SetXY(pUFO->GetX()+24, pUFO->GetY()+50);
  1867. }
  1868. else
  1869. {
  1870. pFirstBullet = pBullet;
  1871. while (pBullet->GetNext() != NULL)
  1872. pBullet = pBullet->GetNext();
  1873. pBullet->SetNext(pNewBullet);
  1874. pNewBullet->SetPrev(pBullet);
  1875. pNewBullet->SetXY(pUFO->GetX()+24, pUFO->GetY()+50);
  1876. pNewBullet->SetType(1);
  1877. pBullet = pFirstBullet;
  1878. }
  1879. //SndObjStop(hsoUfoShoot);
  1880. SndObjPlay(hsoUfoShoot,0);
  1882. }
  1883. }
  1884. break;
  1885. case TRUE:
  1886. if (pUFO->DestroyMe() == TRUE)
  1887. {
  1888. if (pPrev != NULL)
  1889. pPrev->SetNext(pUFO->GetNext());
  1890. pNext = pUFO->GetNext();
  1891. if (pUFO == pFirst)
  1892. pFirst=pUFO->GetNext();
  1893.  
  1894. //iRepaint = 1;
  1895. //pUFO->Repaint(lpBackBuffer, lpBkGround, 1); 
  1897. delete(pUFO);
  1898. if (pPrev != NULL)
  1899. pUFO = pPrev;
  1900. else
  1901. pUFO = pFirst;
  1902. break;
  1903. }
  1904. else
  1905. {
  1906. pUFO->Draw(lpBackBuffer,lpBoom,0);
  1907. if (pUFO->DropExtra() == TRUE)
  1908. {
  1909. pNewExtra = new Extra;
  1910. if (pExtra == NULL)
  1911. {
  1912. pExtra = pNewExtra;
  1913. pNewExtra->SetXY(pUFO->GetX()+22, pUFO->GetY()+20);
  1914. pNewExtra->SetType(pUFO->GetExtra());
  1915. }
  1916. else
  1917. {
  1918. pFirstExtra = pExtra;
  1919. while (pExtra->GetNext() != NULL)
  1920. pExtra = pExtra->GetNext();
  1921. pExtra->SetNext(pNewExtra);
  1922. pNewExtra->SetPrev(pExtra);
  1923. pNewExtra->SetXY(pUFO->GetX()+22, pUFO->GetY()+20);
  1924. pNewExtra->SetType(pUFO->GetExtra());
  1925. pExtra = pFirstExtra;
  1926. }
  1927. }
  1928. }
  1929. break;
  1930. }
  1931. pPrev = pUFO;
  1932. if (pUFO != NULL)
  1933. pUFO = pUFO->GetNext();
  1934. } //** While UFO-NEXT;
  1936. pUFO = pFirst;
  1937. pAux = pUFO;
  1938. while(pAux != NULL)
  1939. {
  1940. if (CheckCrash(pAux) == TRUE)
  1941. pAux->Crash();
  1942. pAux = pAux->GetNext();
  1943. };
  1944. pUFO = pFirst;
  1945. }
  1947. void bltText(char*  buffer, int  x, int y)
  1948. {
  1950. // Draw text to the screen
  1952. int pos;
  1953. int nextx;
  1954. RECT rcRect;
  1955. HRESULT hRet;
  1957. nextx = x;
  1958. while (*buffer != '')
  1959. {
  1960. if (*buffer != ' ')
  1961. {
  1962. if (*buffer >= 48 &&
  1963. *buffer <= 57)
  1964. pos = (int) *buffer - 48;
  1965. else
  1966. pos = (int) *buffer - 55;
  1967. if (*buffer == '@')
  1968. pos = 36;
  1969. if (*buffer == '-')
  1970. pos = 37;
  1971. if (*buffer == ',')
  1972. pos = 38;
  1973. if (*buffer == '.')
  1974. pos = 39;
  1976. rcRect.left = AA[pos].start;
  1977. rcRect.right = AA[pos].end;
  1978. rcRect.top = 0;
  1979. rcRect.bottom = 15;
  1980. while (1)
  1981. {
  1982. hRet = lpBackBuffer->BltFast(nextx, y, lpAlpha, &rcRect, TRUE);
  1983. if (hRet == DD_OK)
  1984. {
  1985. break;
  1986. }
  1987. if (hRet == DDERR_SURFACELOST)
  1988. {
  1989. hRet = RestoreSurfaces();
  1990. if (hRet != DD_OK)
  1991. break;
  1992. }
  1993. if (hRet != DDERR_WASSTILLDRAWING)
  1994. break;
  1995. }
  1997. while (1)
  1998. {
  1999. hRet = lpFrontBuffer->BltFast(nextx, y, lpAlpha, &rcRect, TRUE);
  2000. if (hRet == DD_OK)
  2001. {
  2002. break;
  2003. }
  2004. if (hRet == DDERR_SURFACELOST)
  2005. {
  2006. hRet = RestoreSurfaces();
  2007. if (hRet != DD_OK)
  2008. break;
  2009. }
  2010. if (hRet != DDERR_WASSTILLDRAWING)
  2011. break;
  2012. }
  2013. nextx += (AA[pos].end - AA[pos].start) + 1;
  2014. }
  2015. else
  2016. nextx += 15;
  2017. buffer++;
  2018. }
  2020. }
  2022. void DrawScore(int x, int y)
  2023. {
  2024. char scorebuf[9];
  2025.     unsigned int        rem;
  2027.     // blt everything in reverse order if we are doing destination transparency
  2028.     // calculate score string
  2029.     scorebuf[0] = score/10000000 + '0';
  2030.     rem = score % 10000000;
  2031.     scorebuf[1] = rem/1000000 + '0';
  2032.     rem = score % 1000000;
  2033.     scorebuf[2] = rem/100000 + '0';
  2034.     rem = score % 100000;
  2035.     scorebuf[3] = rem/10000 + '0';
  2036.     rem = score % 10000;
  2037.     scorebuf[4] = rem/1000 + '0';
  2038.     rem = score % 1000;
  2039.     scorebuf[5] = rem/100 + '0';
  2040.     rem = score % 100;
  2041.     scorebuf[6] = rem/10 + '0';
  2042.     rem = score % 10;
  2043.     scorebuf[7] = rem + '0';
  2044. scorebuf[8] = '';
  2045. bltText(scorebuf, x, y);
  2046. }
  2048. void DrawShield()
  2049. {
  2050. // Draw the shield status
  2051. HRESULT hRet;
  2052. DDBLTFX     ddbltfx;
  2053. RECT rcRect;
  2055. static int    iRed = 0;
  2056. static int    inc = 1;
  2057. static DWORD   lastBlitRed = 0;
  2059.     ddbltfx.dwSize = sizeof( ddbltfx );
  2060. ddbltfx.dwFillColor = RGB(0,0,0);
  2061. rcRect.top = 459;
  2062. rcRect.left = 370;
  2063. rcRect.bottom = 477;
  2064. rcRect.right  = 422;
  2066. if (iLastShield == iShield &&
  2067. iShield > 30)
  2069. return;
  2071. while (1)
  2072. {
  2073. hRet = lpBackBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2074. if (hRet == DD_OK)
  2075. {
  2076. break;
  2077. }
  2078. if (hRet == DDERR_SURFACELOST)
  2079. {
  2080. hRet = RestoreSurfaces();
  2081. if (hRet != DD_OK)
  2082. break;
  2083. }
  2084. if (hRet != DDERR_WASSTILLDRAWING)
  2085. break;
  2086. }
  2088. if (iLastShield != iShield &&
  2089. iShield > 30)
  2090. while (1)
  2091. {
  2092. hRet = lpFrontBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2094. if (hRet == DD_OK)
  2095. {
  2096. break;
  2097. }
  2098. if (hRet == DDERR_SURFACELOST)
  2099. {
  2100. hRet = RestoreSurfaces();
  2101. if (hRet != DD_OK)
  2102. break;
  2103. }
  2104. if (hRet != DDERR_WASSTILLDRAWING)
  2105. break;
  2106. }
  2108.     if (iShield <= 50 &&
  2109. iShield >  30)
  2110. {
  2111. iRed = -2;
  2112. lastBlitRed = 0;
  2113. ddbltfx.dwFillColor = RGB(0,15,0);
  2114. }
  2115.     if (iShield <= 30 &&
  2116. iShield >  20)
  2117. ddbltfx.dwFillColor = RGB(0,255,255);
  2118.     if (iShield <= 20 &&
  2119. iShield >= 0)
  2120. {
  2122. if (GetTickCount() - lastBlitRed > 30)
  2123. {
  2124. iRed += inc;
  2125. if (iRed < 32)
  2126. {
  2127. iRed = 32;
  2128. inc = 4;
  2129. }
  2130. if (iRed > 116)
  2131. {
  2132. iRed = 116;
  2133. inc = -4;
  2134. }
  2135. lastBlitRed = GetTickCount();
  2136. }
  2138. ddbltfx.dwFillColor = RGB(0,iRed,0);
  2139. }
  2141. rcRect.top = 460;
  2142. rcRect.left = 371;
  2143. rcRect.bottom = 477;
  2144. rcRect.right  = 371 + iShield;
  2146. while (1)
  2147. {
  2148. hRet = lpBackBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2150. if (hRet == DD_OK)
  2151. {
  2152. break;
  2153. }
  2154. if (hRet == DDERR_SURFACELOST)
  2155. {
  2156. hRet = RestoreSurfaces();
  2157. if (hRet != DD_OK)
  2158. break;
  2159. }
  2160. if (hRet != DDERR_WASSTILLDRAWING)
  2161. break;
  2162. }
  2164. if (iLastShield != iShield &&
  2165. iShield > 30)
  2166. while (1)
  2167. {
  2168. hRet = lpFrontBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2170. if (hRet == DD_OK)
  2171. {
  2172. break;
  2173. }
  2174. if (hRet == DDERR_SURFACELOST)
  2175. {
  2176. hRet = RestoreSurfaces();
  2177. if (hRet != DD_OK)
  2178. break;
  2179. }
  2180. if (hRet != DDERR_WASSTILLDRAWING)
  2181. break;
  2182. }
  2185. iLastShield = iShield;
  2187. }
  2189. void DrawAmmo()
  2190. {
  2191. char ammobuf[4];
  2192.     unsigned int        rem;
  2193. int iAmmo;
  2195.     // blt everything in reverse order if we are doing destination transparency
  2196.     // calculate score string
  2197. if (iWeapon < 3)
  2198. iAmmo = iLaserAmmo;
  2199. else
  2200. iAmmo = iPhotonAmmo;
  2201.     ammobuf[0] = iAmmo/100 + '0';
  2202.     rem = iAmmo % 100;
  2203.     ammobuf[1] = rem/10 + '0';
  2204.     rem = iAmmo % 10;
  2205.     ammobuf[2] = rem + '0';
  2206. ammobuf[3] = '';
  2207. OutputDebugString("Blit Ammo Buffn");
  2208. bltText(ammobuf, 241, 460);
  2209. }
  2211. void DrawWeapon()
  2212. {
  2213. RECT rcRect;
  2214. HRESULT hRet;
  2216. // Draw the weapon we are using
  2218. rcRect.left = iWeapon * 87;
  2219. rcRect.right = (iWeapon * 87) + 87;
  2220. rcRect.top = 0;
  2221. rcRect.bottom = 20;
  2222. while (1)
  2223. {
  2224. hRet = lpBackBuffer->BltFast(84, 458, lpStatusBar, &rcRect, TRUE);
  2225. if (hRet == DD_OK)
  2226. {
  2227. break;
  2228. }
  2229. if (hRet == DDERR_SURFACELOST)
  2230. {
  2231. hRet = RestoreSurfaces();
  2232. if (hRet != DD_OK)
  2233. break;
  2234. }
  2235. if (hRet != DDERR_WASSTILLDRAWING)
  2236. break;
  2237. }
  2239. while (1)
  2240. {
  2241. hRet = lpFrontBuffer->BltFast(84, 458, lpStatusBar, &rcRect, TRUE);
  2242. if (hRet == DD_OK)
  2243. {
  2244. break;
  2245. }
  2246. if (hRet == DDERR_SURFACELOST)
  2247. {
  2248. hRet = RestoreSurfaces();
  2249. if (hRet != DD_OK)
  2250. break;
  2251. }
  2252. if (hRet != DDERR_WASSTILLDRAWING)
  2253. break;
  2254. }
  2256. }
  2259. void UpdateFrame( void )
  2260. {
  2261.   int ddrval;
  2262.     DWORD                       thisTickCount;
  2263.     RECT                        rcRect;
  2264.     DWORD                       delay = 18;
  2265. static int frame = 0;
  2266. HBITMAP hbm;
  2267. DDBLTFX ddbltfx;
  2268. HRESULT hRet;
  2271. thisTickCount = GetTickCount();
  2273. // Main update function
  2274. if (thisTickCount - dwShipExplode > 2000 &&
  2275. iShipState == 3)
  2276. {
  2277. Ovni* auxpUFO;
  2278. Bullet* auxpBullet;
  2280. while(pUFO !=NULL)
  2281. {
  2282. auxpUFO = pUFO->GetNext();
  2283. delete(pUFO);
  2284. pUFO = auxpUFO;
  2285. }
  2287. while(pBullet !=NULL)
  2288. {
  2289. auxpBullet = pBullet->GetNext();
  2290. delete(pBullet);
  2291. pBullet = auxpBullet;
  2292. }
  2294. ShowGameOver();
  2295. lastTickCount = 0;
  2296. iAppState = 0;
  2297. iShipState = 0;
  2298. }
  2300. switch (iAppState)
  2301. {
  2302. case APP_MAINMENU:
  2304. if ((thisTickCount - lastTickCount) <= delay)
  2305. return;
  2307. if (lastTickCount == 0)
  2308. {
  2310. iOption = 0;
  2311. frame = 0;
  2312. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_INVASION), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2313. if( NULL == hbm )
  2314. return;
  2315. ddrval = DDCopyBitmap(lpFrontBuffer, hbm, 0, 0, 640, 480 );
  2316. if( ddrval != DD_OK )
  2317. {
  2318. DeleteObject( hbm );
  2319. return;
  2320. }
  2322. ddrval = DDCopyBitmap(lpBackBuffer, hbm, 0, 0, 640, 480 );
  2323. if( ddrval != DD_OK )
  2324. {
  2325. DeleteObject( hbm );
  2326. return;
  2327. }
  2329. bltText("START GAME",190,280);
  2330. bltText("CREDITS",190,320);
  2331. bltText("HELP",190,360);
  2332. bltText("QUIT",190,400);
  2334. }
  2336. ddbltfx.dwSize = sizeof( ddbltfx );
  2337. ddbltfx.dwFillColor = dwFillColor;
  2338. rcRect.left = 130;
  2339. rcRect.top = 270;
  2340. rcRect.right = 190;
  2341. rcRect.bottom = 460;
  2343. while (1)
  2344. {
  2345. hRet = lpBackBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2346. if (hRet == DD_OK)
  2347. {
  2348. break;
  2349. }
  2350. if (hRet == DDERR_SURFACELOST)
  2351. {
  2352. hRet = RestoreSurfaces();
  2353. if (hRet != DD_OK)
  2354. break;
  2355. }
  2356. if (hRet != DDERR_WASSTILLDRAWING)
  2357. break;
  2358. }
  2360. rcRect.left   = frame * 32;
  2361. rcRect.right  = (frame * 32) + 32;
  2362. rcRect.top    = 0;
  2363. rcRect.bottom = 20;
  2367. while (1)
  2368. {
  2369. hRet = lpBackBuffer->BltFast(150 , 275+ (40 * iOption),  lpSelect, &rcRect, TRUE);
  2370. if (hRet == DD_OK)
  2371. {
  2372. break;
  2373. }
  2374. if (hRet == DDERR_SURFACELOST)
  2375. {
  2376. hRet = RestoreSurfaces();
  2377. if (hRet != DD_OK)
  2378. break;
  2379. }
  2380. if (hRet != DDERR_WASSTILLDRAWING)
  2381. break;
  2382. }
  2383. frame++;
  2384. if (frame > 19)
  2385. frame = 0;
  2387. while( 1 )
  2388. {
  2389. ddrval = lpFrontBuffer->Flip(NULL, 0 );
  2390. if( ddrval == DD_OK )
  2391. {
  2392. break;
  2393. }
  2394. if( ddrval == DDERR_SURFACELOST )
  2395. {
  2396. if( !RestoreSurfaces() )
  2397. {
  2398. return;
  2399. }
  2400. }
  2401. if( ddrval != DDERR_WASSTILLDRAWING )
  2402. {
  2403. break;
  2404. }
  2405. }
  2407. lastTickCount = thisTickCount;
  2409. return;
  2411. case APP_GAMESCREEN:
  2412. int iAmmo;
  2415. if (lastTickCount == 0)
  2416. {
  2417. bShoot = FALSE;
  2418. rcRect.left = 0;
  2419. rcRect.top = 0;
  2420. rcRect.right = 640;
  2421. rcRect.bottom = 480;
  2423. DrawBackGround(lpBackBuffer,0,455,640,480);
  2424. DrawBackGround(lpFrontBuffer,0,455,640,480);
  2426. }
  2431. DrawShield();
  2432. if (Lastscore != score)
  2433. {
  2435. DrawBackGround(lpBackBuffer,510,460,640,477);
  2436. DrawBackGround(lpFrontBuffer,510,460,640,477);
  2437. DrawScore(510,460);
  2438. Lastscore = score;
  2439. }
  2441. if (iLastWeapon != iWeapon)
  2442. {
  2443. DrawBackGround(lpBackBuffer, 84,458, 172,477);
  2444. DrawBackGround(lpFrontBuffer,84,458, 172,477);
  2445. DrawWeapon();
  2446. iLastWeapon = iWeapon;
  2447. iLastAmmo = -1;
  2448. }
  2450. if (iWeapon < 3)
  2451. iAmmo = iLaserAmmo;
  2452. else
  2453. iAmmo = iPhotonAmmo;
  2454. if (iLastAmmo != iAmmo)
  2455. {
  2457. DrawBackGround(lpBackBuffer,241,459,300,477);
  2458. DrawBackGround(lpFrontBuffer,241,459,300,477);
  2459. DrawAmmo();
  2460. iLastAmmo = iAmmo;
  2461. }
  2465. if ((thisTickCount - lastTickCount) <= delay)
  2466. return;
  2468. if (pUFO   == NULL &&
  2469. pExtra == NULL)
  2470. {
  2471. SndObjPlay(hsoEnter, NULL);
  2472. InitLevel(TRUE);
  2473. DrawBackGround(lpBackBuffer,0,0,640,480);
  2474. DrawBackGround(lpFrontBuffer,0,0,640,480);
  2475. DrawScore(510,459);
  2476. lastTickCount = 0;
  2477. return;
  2478. }
  2480. DrawInvalidBackGround();
  2481. DrawExtra();
  2482. DrawUfo();
  2483. DrawBullet();
  2484. DrawShip();
  2486. bShoot = FALSE;
  2487. while( 1 )
  2488. {
  2489. ddrval = lpFrontBuffer->Flip(NULL, 0 );
  2490. if( ddrval == DD_OK )
  2491. {
  2492. break;
  2493. }
  2494. if( ddrval == DDERR_SURFACELOST )
  2495. {
  2496. if( !RestoreSurfaces() )
  2497. {
  2498. return;
  2499. }
  2500. }
  2501. if( ddrval != DDERR_WASSTILLDRAWING )
  2502. {
  2503. break;
  2504. }
  2505. }
  2507.    lastTickCount = GetTickCount();
  2508.    break;
  2509. case APP_CREDITS:
  2510. ShowCredits();
  2511. iAppState = 0;
  2512. lastTickCount = 0;
  2513. break;
  2514. case APP_HELPSCREEN:
  2515. static BOOL  bBlink;
  2516. static DWORD dwTime;
  2518. if ((thisTickCount - lastTickCount) <= delay+20)
  2519. return;
  2521. if (lastTickCount == 0)
  2522. {
  2523. ddbltfx.dwSize = sizeof( ddbltfx );
  2524. ddbltfx.dwFillColor = RGB(0,0,0);
  2525. rcRect.left = 0;
  2526. rcRect.top = 0;
  2527. rcRect.right = 640;
  2528. rcRect.bottom = 480;
  2530. while (1)
  2531. {
  2532. hRet = lpFrontBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2533. if (hRet == DD_OK)
  2534. {
  2535. break;
  2536. }
  2537. if (hRet == DDERR_SURFACELOST)
  2538. {
  2539. hRet = RestoreSurfaces();
  2540. if (hRet != DD_OK)
  2541. break;
  2542. }
  2543. if (hRet != DDERR_WASSTILLDRAWING)
  2544. break;
  2545. }
  2547. while (1)
  2548. {
  2549. hRet = lpBackBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2550. if (hRet == DD_OK)
  2551. {
  2552. break;
  2553. }
  2554. if (hRet == DDERR_SURFACELOST)
  2555. {
  2556. hRet = RestoreSurfaces();
  2557. if (hRet != DD_OK)
  2558. break;
  2559. }
  2560. if (hRet != DDERR_WASSTILLDRAWING)
  2561. break;
  2562. }
  2563. bltText("PHOTON AMMO",90,45);
  2564. bltText("WEAPON ADVANCE",90,95);
  2565. bltText("100 POINTS BONUS",90,145);
  2566. bltText("LASER AMMO",90,195);
  2567. bltText("SHIELD CHARGE",90,245);
  2568. bltText("LEFT, RIGHT - MOVE SHIP",50,290);
  2569. bltText("DOWN OR ENTER - STOP SHIP",50,325);
  2570. bltText("CTRL - CHANGE WEAPON",50,360);
  2571. bltText("PRESS ANY KEY TO CONTINUE",140,450);
  2572. bBlink = FALSE;
  2573. dwTime = 0;
  2575. }
  2577. ddbltfx.dwSize = sizeof( ddbltfx );
  2578. ddbltfx.dwFillColor = dwFillColor;
  2579. rcRect.left = 50;
  2580. rcRect.top = 40;
  2581. rcRect.right = 75;
  2582. rcRect.bottom = 270;
  2584. while (1)
  2585. {
  2586. hRet = lpBackBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2587. if (hRet == DD_OK)
  2588. {
  2589. break;
  2590. }
  2591. if (hRet == DDERR_SURFACELOST)
  2592. {
  2593. hRet = RestoreSurfaces();
  2594. if (hRet != DD_OK)
  2595. break;
  2596. }
  2597. if (hRet != DDERR_WASSTILLDRAWING)
  2598. break;
  2599. }
  2601. if (bBlink == TRUE)
  2602. {
  2603. ddbltfx.dwSize = sizeof( ddbltfx );
  2604. ddbltfx.dwFillColor = dwFillColor;
  2605. rcRect.left = 0;
  2606. rcRect.top = 450;
  2607. rcRect.right = 640;
  2608. rcRect.bottom = 475;
  2610. while (1)
  2611. {
  2612. hRet = lpBackBuffer->Blt(&rcRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx);
  2613. if (hRet == DD_OK)
  2614. {
  2615. break;
  2616. }
  2617. if (hRet == DDERR_SURFACELOST)
  2618. {
  2619. hRet = RestoreSurfaces();
  2620. if (hRet != DD_OK)
  2621. break;
  2622. }
  2623. if (hRet != DDERR_WASSTILLDRAWING)
  2624. break;
  2625. }
  2626. dwTime = dwTime + 1;
  2627. if (dwTime == 20)
  2628. {
  2629. bltText("PRESS ANY KEY TO CONTINUE",140,450);
  2630. bBlink = FALSE;
  2631. dwTime = 0;
  2632. }
  2633. }
  2634. else
  2635. {
  2636. dwTime = dwTime + 1;
  2637. if (dwTime == 20)
  2638. {
  2639. //bltText("PRESS ANY KEY TO CONTINUE",140,450);
  2640. bBlink = TRUE;
  2641. dwTime = 0;
  2642. }
  2643. }
  2646. rcRect.left   = frame * 25;
  2647. rcRect.right  = (frame * 25) + 25;
  2648. rcRect.top    = 0;
  2649. rcRect.bottom = 25;
  2651. while (1)
  2652. {
  2653. hRet = lpBackBuffer->BltFast(50, 40,  lpExtra, &rcRect, TRUE);
  2654. if (hRet == DD_OK)
  2655. {
  2656. break;
  2657. }
  2658. if (hRet == DDERR_SURFACELOST)
  2659. {
  2660. hRet = RestoreSurfaces();
  2661. if (hRet != DD_OK)
  2662. break;
  2663. }
  2664. if (hRet != DDERR_WASSTILLDRAWING)
  2665. break;
  2666. }
  2669. rcRect.top    = 25;
  2670. rcRect.bottom = 50;
  2672. while (1)
  2673. {
  2674. hRet = lpBackBuffer->BltFast(50, 90,  lpExtra, &rcRect, TRUE);
  2675. if (hRet == DD_OK)
  2676. {
  2677. break;
  2678. }
  2679. if (hRet == DDERR_SURFACELOST)
  2680. {
  2681. hRet = RestoreSurfaces();
  2682. if (hRet != DD_OK)
  2683. break;
  2684. }
  2685. if (hRet != DDERR_WASSTILLDRAWING)
  2686. break;
  2687. }
  2689. rcRect.top    = 50;
  2690. rcRect.bottom = 75;
  2692. while (1)
  2693. {
  2694. hRet = lpBackBuffer->BltFast(50, 140,  lpExtra, &rcRect, TRUE);
  2695. if (hRet == DD_OK)
  2696. {
  2697. break;
  2698. }
  2699. if (hRet == DDERR_SURFACELOST)
  2700. {
  2701. hRet = RestoreSurfaces();
  2702. if (hRet != DD_OK)
  2703. break;
  2704. }
  2705. if (hRet != DDERR_WASSTILLDRAWING)
  2706. break;
  2707. }
  2709. rcRect.top    = 75;
  2710. rcRect.bottom = 100;
  2712. while (1)
  2713. {
  2714. hRet = lpBackBuffer->BltFast(50, 190,  lpExtra, &rcRect, TRUE);
  2715. if (hRet == DD_OK)
  2716. {
  2717. break;
  2718. }
  2719. if (hRet == DDERR_SURFACELOST)
  2720. {
  2721. hRet = RestoreSurfaces();
  2722. if (hRet != DD_OK)
  2723. break;
  2724. }
  2725. if (hRet != DDERR_WASSTILLDRAWING)
  2726. break;
  2727. }
  2729. rcRect.top    = 100;
  2730. rcRect.bottom = 125;
  2732. while (1)
  2733. {
  2734. hRet = lpBackBuffer->BltFast(50, 240,  lpExtra, &rcRect, TRUE);
  2735. if (hRet == DD_OK)
  2736. {
  2737. break;
  2738. }
  2739. if (hRet == DDERR_SURFACELOST)
  2740. {
  2741. hRet = RestoreSurfaces();
  2742. if (hRet != DD_OK)
  2743. break;
  2744. }
  2745. if (hRet != DDERR_WASSTILLDRAWING)
  2746. break;
  2747. }
  2751. frame++;
  2752. if (frame == 19)
  2753. frame = 0;
  2755. while( 1 )
  2756. {
  2757. ddrval = lpFrontBuffer->Flip(NULL, 0 );
  2758. if( ddrval == DD_OK )
  2759. {
  2760. break;
  2761. }
  2762. if( ddrval == DDERR_SURFACELOST )
  2763. {
  2764. if( !RestoreSurfaces() )
  2765. {
  2766. return;
  2767. }
  2768. }
  2769. if( ddrval != DDERR_WASSTILLDRAWING )
  2770. {
  2771. break;
  2772. }
  2773. }
  2775. lastTickCount = thisTickCount;
  2777. return;
  2778. }
  2779.    return;
  2780. }
  2782. void DestroyGame()
  2783. {
  2784. // Destroy game objects
  2785. Ovni* auxpUFO;
  2786. Bullet* auxpBullet;
  2787. Extra* pAuxExtra;
  2789. while(pExtra !=NULL)
  2790. {
  2791. pAuxExtra = pExtra->GetNext();
  2792. delete(pExtra);
  2793. pExtra = pAuxExtra;
  2794. }
  2796. while(pUFO !=NULL)
  2797. {
  2798. auxpUFO = pUFO->GetNext();
  2799. delete(pUFO);
  2800. pUFO = auxpUFO;
  2801. }
  2803. while(pBullet !=NULL)
  2804. {
  2805. auxpBullet = pBullet->GetNext();
  2806. delete(pBullet);
  2807. pBullet = auxpBullet;
  2808. }
  2810.     if( lpBkGround != NULL )
  2811.         lpBkGround->Release();
  2813.     if( lpBackBuffer != NULL )
  2814. lpBackBuffer->Release();
  2816.     if( lpFrontBuffer != NULL )
  2817.         lpFrontBuffer->Release();
  2819.     if( lpUfo != NULL )
  2820.         lpUfo->Release();
  2822.     if( lpShoot != NULL )
  2823.         lpShoot->Release();
  2825.     if( lpShoot2 != NULL )
  2826.         lpShoot2->Release();
  2828. if( lpShip != NULL )
  2829.         lpShip->Release();
  2831.     if( lpBoom != NULL )
  2832.         lpBoom->Release();
  2834.     if( lpUfoShoot != NULL )
  2835.         lpUfoShoot->Release();
  2837.     if( lpAlpha != NULL )
  2838.         lpAlpha->Release();
  2840.     if( lpShipBoom != NULL )
  2841.         lpShipBoom->Release();
  2843.     if( lpArtPalette != NULL )
  2844.         lpArtPalette->Release();
  2846.     if( lpDD != NULL )
  2847.         lpDD->Release();
  2849. DestroySound();
  2850. return;
  2851. }
  2853. BOOL CleanupAndExit( char *err)
  2854. {
  2855. #ifdef DEBUG
  2856.     wsprintf(DebugBuf, "___CleanupAndExit  err = %sn", err );
  2857.     OutputDebugString( DebugBuf );
  2858. #endif
  2860.     // make the cursor visible
  2861.     SetCursor(LoadCursor( NULL, IDC_ARROW ));
  2863. DestroyGame();
  2865.         MessageBox( hWndMain, err, "ERROR", MB_OK );
  2866.     return FALSE;
  2867. }
  2869. // Surface loading functions
  2871. BOOL LoadUfoSurface(int iFlags)
  2872. {
  2873.     HRESULT     ddrval;
  2874.     HBITMAP     hbm;
  2876. ddrval = lpUfo->Restore();
  2877.     if( ddrval != DD_OK )
  2878.         return FALSE;
  2879. ddrval = lpBoom->Restore();
  2880.     if( ddrval != DD_OK )
  2881.         return FALSE;
  2883.     switch(iLevel % 6)
  2884. {
  2885. case 0:
  2886. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_UFO3), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2887. break;
  2888. case 4:
  2889. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_UFO2), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2890. break;
  2891. case 5:
  2892. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_UFO2), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2893. break;
  2894. default:
  2895. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_UFO), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2896. break;
  2897. };
  2898.     if( NULL == hbm )
  2899.         return FALSE;
  2900.     ddrval = DDCopyBitmap(lpUfo, hbm, 0, 0, 350, 700 );
  2901.     if( ddrval != DD_OK )
  2902.     {
  2903.         DeleteObject( hbm );
  2904.         return FALSE;
  2905.     }
  2907.     switch(iLevel % 6)
  2908. {
  2909. case 0:
  2910. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BOOM3), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2911. break;
  2912. case 4:
  2913. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BOOM2), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2914. break;
  2915. case 5:
  2916. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BOOM2), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2917. break;
  2918. default:
  2919. hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BOOM), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2920. break;
  2921. };
  2922.     if( NULL == hbm )
  2923.         return FALSE;
  2924.     ddrval = DDCopyBitmap(lpBoom, hbm, 0, 0, 350, 280);
  2925.     if( ddrval != DD_OK )
  2926.     {
  2927.         DeleteObject( hbm );
  2928.         return FALSE;
  2929.     }
  2931. return TRUE;
  2933. }
  2935. BOOL RestoreSurfaces( void )
  2936. {
  2937.     HRESULT     ddrval;
  2938.     HBITMAP     hbm;
  2940.     ddrval = lpShip->Restore();
  2941.     if( ddrval != DD_OK )
  2942.         return FALSE;
  2944.     ddrval = lpShipBoom->Restore();
  2945.     if( ddrval != DD_OK )
  2946.         return FALSE;
  2948.     ddrval = lpShoot->Restore();
  2949.     if( ddrval != DD_OK )
  2950.         return FALSE;
  2952.     ddrval = lpUfoShoot->Restore();
  2953.     if( ddrval != DD_OK )
  2954.         return FALSE;
  2956.     ddrval = lpBackBuffer->Restore();
  2957.     if( ddrval != DD_OK )
  2958.         return FALSE;
  2960.     ddrval = lpBkGround->Restore();
  2961.     if( ddrval != DD_OK )
  2962.         return FALSE;
  2965.     ddrval = lpFrontBuffer->Restore();
  2966.     if( ddrval != DD_OK )
  2967.         return FALSE;
  2970.     // Create and set the palette for the art bitmap
  2971.     lpArtPalette = DDLoadPalette( lpDD, MAKEINTRESOURCE(IDB_BOOM));
  2972.     if( NULL == lpArtPalette )
  2973.         return CleanupAndExit("DDLoadPalette UFO");
  2975.     // set the palette before loading the art
  2976.     lpFrontBuffer->SetPalette(lpArtPalette );
  2979. if (LoadUfoSurface(iLevel) == FALSE)
  2980. return FALSE;
  2982.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_FUNDO), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2984.     if( NULL == hbm )
  2985.         return FALSE;
  2986.     ddrval = DDCopyBitmap(lpBkGround, hbm, 0, 0, 640, 480 );
  2987.     if( ddrval != DD_OK )
  2988.     {
  2989.         DeleteObject( hbm );
  2990.         return FALSE;
  2991.     }
  2993.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_SHIP), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  2994.     if( NULL == hbm )
  2995.         return FALSE;
  2996.     ddrval = DDCopyBitmap(lpShip, hbm, 0, 0, 350, 350 );
  2997.     if( ddrval != DD_OK )
  2998.     {
  2999.         DeleteObject( hbm );
  3000.         return FALSE;
  3001.     }
  3003.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_SHOOT), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3004.     if( NULL == hbm )
  3005.         return FALSE;
  3006.     ddrval = DDCopyBitmap(lpShoot, hbm, 0, 0, 220, 20);
  3007.     if( ddrval != DD_OK )
  3008.     {
  3009.         DeleteObject( hbm );
  3010.         return FALSE;
  3011.     }
  3013.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_SHOOT2), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3014.     if( NULL == hbm )
  3015.         return FALSE;
  3016.     ddrval = DDCopyBitmap(lpShoot2, hbm, 0, 0, 20, 20);
  3017.     if( ddrval != DD_OK )
  3018.     {
  3019.         DeleteObject( hbm );
  3020.         return FALSE;
  3021.     }
  3025.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_UFOSHOOT), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3026.     if( NULL == hbm )
  3027.         return FALSE;
  3029.     ddrval = DDCopyBitmap(lpUfoShoot, hbm, 0, 0, 400, 20);
  3030.     if( ddrval != DD_OK )
  3031.     {
  3032.         DeleteObject( hbm );
  3033.         return FALSE;
  3034.     }
  3036.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_SHIPEXPLODE), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3037.     if( NULL == hbm )
  3038.         return FALSE;
  3039.     ddrval = DDCopyBitmap(lpShipBoom, hbm, 0, 0, 490, 210);
  3040.     if( ddrval != DD_OK )
  3041.     {
  3042.         DeleteObject( hbm );
  3043.         return FALSE;
  3044.     }
  3046.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_ALPHA), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3047.     if( NULL == hbm )
  3048.         return FALSE;
  3049.     ddrval = DDCopyBitmap(lpAlpha, hbm, 0, 0, 623, 15);
  3050.     if( ddrval != DD_OK )
  3051.     {
  3052.         DeleteObject( hbm );
  3053.         return FALSE;
  3054.     }
  3056.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_SELECT), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3057.     if( NULL == hbm )
  3058.         return FALSE;
  3059.     ddrval = DDCopyBitmap(lpSelect, hbm, 0, 0, 640, 20);
  3060.     if( ddrval != DD_OK )
  3061.     {
  3062.         DeleteObject( hbm );
  3063.         return FALSE;
  3064.     }
  3066.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_STATUSBAR), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3067.     if( NULL == hbm )
  3068.         return FALSE;
  3069.     ddrval = DDCopyBitmap(lpStatusBar, hbm, 0, 0, 522, 20);
  3070.     if( ddrval != DD_OK )
  3071.     {
  3072.         DeleteObject( hbm );
  3073.         return FALSE;
  3074.     }
  3076.     hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_EXTRA), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  3077.     if( NULL == hbm )
  3078.         return FALSE;
  3079.     ddrval = DDCopyBitmap(lpExtra, hbm, 0, 0, 500, 125);
  3080.     if( ddrval != DD_OK )
  3081.     {
  3082.         DeleteObject( hbm );
  3083.         return FALSE;
  3084.     }
  3086.     // set colorfill colors and color keys according to bitmap contents
  3087.     //dwFillColor = DDColorMatch( lpUfo, RGB(0,0,0) );
  3088. dwFillColor = DDColorMatch( lpBackBuffer, RGB(0,0,0) );
  3091. //Get Color Key
  3092. HDC hDC;
  3093. COLORREF rgbColor;
  3095. lpShip->GetDC(&hDC);
  3096. rgbColor = GetPixel(hDC,0,0);
  3097. lpShip->ReleaseDC(hDC);
  3100.     
  3101. DDSetColorKey(lpUfo, RGB(0,0,0));
  3102. DDSetColorKey(lpShip, rgbColor);
  3103. DDSetColorKey(lpShoot, RGB(0,0,0));
  3104. DDSetColorKey(lpShoot2, RGB(0,0,0));
  3105. DDSetColorKey(lpBoom, RGB(0,0,0));
  3106. DDSetColorKey(lpUfoShoot, RGB(0,0,0));
  3107. DDSetColorKey(lpShipBoom, RGB(19,19,19));
  3108. DDSetColorKey(lpAlpha, RGB(0,0,0));
  3109. DDSetColorKey(lpSelect, RGB(0,0,0));
  3110. DDSetColorKey(lpStatusBar, RGB(0,0,0));
  3111. DDSetColorKey(lpExtra, RGB(0,0,0));
  3113.     return TRUE;
  3114. }
  3116. BOOL initApplication( HINSTANCE hInstance, int nCmdShow )
  3117. {
  3118.     WNDCLASS    wc;
  3119.     BOOL        rc;
  3121.     wc.style = CS_DBLCLKS;
  3122.     wc.lpfnWndProc = MainWndproc;
  3123.     wc.cbClsExtra = 0;
  3124.     wc.cbWndExtra = 0;
  3125.     wc.hInstance = hInstance;
  3126.     wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_UFO));
  3127.     wc.hCursor = LoadCursor( NULL, IDC_ARROW );
  3128.     wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
  3129.     wc.lpszMenuName =  NULL;
  3130.     wc.lpszClassName = "InvasionClass";
  3131.     rc = RegisterClass( &wc );
  3132.     if( !rc )
  3133.     {
  3134.         return FALSE;
  3135.     }
  3137.     hWndMain = CreateWindowEx(0,  // WS_EX_TOPMOST,
  3138.         "InvasionClass",
  3139.         "Invasion",
  3140.         WS_VISIBLE | // so we don't have to call ShowWindow
  3141.         WS_POPUP, // |   // non-app window
  3142.         //WS_SYSMENU//so we get an icon in the tray
  3143.         0,
  3144.         0,
  3145.         GetSystemMetrics(SM_CXSCREEN),
  3146.         GetSystemMetrics(SM_CYSCREEN),
  3147.         NULL,
  3148.         NULL,
  3149.         hInstance,
  3150.         NULL );
  3152.     if( !hWndMain )
  3153.     {
  3154.         return FALSE;
  3155.     }
  3157.     UpdateWindow( hWndMain );
  3159.     return TRUE;
  3161. } /* initApplication */
  3164. BOOL InitializeGame( void )
  3165. {
  3166.     DDCAPS ddcaps;
  3167.     HRESULT ddrval;
  3168.     DDSURFACEDESC2 ddsd;
  3169.     DDSCAPS2 ddscaps;
  3170. LPDIRECTDRAW pDD;
  3171.     LPVOID  lpSurface  = NULL;
  3172.     
  3175. ShowCursor(FALSE);
  3176.     srand( GetTickCount() );
  3178. ddrval = DirectDrawCreate( NULL, &pDD, NULL );
  3179.     if( ddrval != DD_OK )
  3180.         return CleanupAndExit("DirectDrawCreate Failed!");
  3182.     // Fetch DirectDraw7 interface
  3183.     ddrval = pDD->QueryInterface(IID_IDirectDraw7, (LPVOID*)&lpDD);
  3184.     if (ddrval != DD_OK)
  3185.         return CleanupAndExit("QueryInterface Failed!");
  3187.     pDD->Release();
  3188.     
  3189. ddrval = lpDD->SetCooperativeLevel(hWndMain, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
  3190.     if( ddrval != DD_OK )
  3191.         return CleanupAndExit("SetCooperativeLevel Failed");
  3193.     // set the mode
  3194.     ddrval = lpDD->SetDisplayMode(640, 480, 16, 0, 0 );
  3195.     if( ddrval != DD_OK )
  3196.         return CleanupAndExit("SetDisplayMode Failed!");
  3198.     // check the color key hardware capabilities
  3199.     dwTransType = DDBLTFAST_SRCCOLORKEY;
  3200.     ddcaps.dwSize = sizeof( ddcaps );
  3202.     // Create surfaces
  3203.     memset( &ddsd, 0, sizeof( ddsd ) );
  3204.     ddsd.dwSize = sizeof( ddsd );
  3205.     ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  3206.     
  3207. ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
  3208.                           DDSCAPS_FLIP |
  3209.                           DDSCAPS_COMPLEX;
  3211.     ddsd.dwBackBufferCount = 1;
  3212.     ddrval = lpDD->CreateSurface(&ddsd, &lpFrontBuffer, NULL );
  3213.     if( ddrval != DD_OK )
  3214.         return CleanupAndExit("CreateSurface FrontBuffer Failed!");
  3217.     // get a pointer to the back buffer
  3218.     
  3219. ZeroMemory(&ddscaps, sizeof(ddscaps));
  3221. ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
  3222.     ddrval = lpFrontBuffer->GetAttachedSurface(
  3223.                 &ddscaps,
  3224.                 &lpBackBuffer);
  3225.     if( ddrval != DD_OK )
  3226. {
  3227.         return CleanupAndExit("GetAttachedSurfaceError");
  3228. }
  3230.     
  3232. // Create a surface for each one of the objects we are going to use in the game
  3233. // Then 碽lit this surfaces to the main surface
  3234. ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
  3235.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3236.   DDSCAPS_VIDEOMEMORY;
  3237. ddsd.dwWidth = 350;
  3238.     ddsd.dwHeight = 700;
  3239.     ddrval = lpDD->CreateSurface(&ddsd, &lpUfo, NULL );
  3240.     if( ddrval != DD_OK )
  3241. {
  3242. if(ddrval == DDERR_OUTOFMEMORY)
  3243. {
  3244. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3245.   DDSCAPS_SYSTEMMEMORY;
  3246. ddrval = lpDD->CreateSurface(&ddsd, &lpUfo, NULL );
  3247. if(ddrval != DD_OK)
  3248. return CleanupAndExit("CreateSurface lpUfo Failed!");
  3249. }
  3250. else
  3251. return CleanupAndExit("CreateSurface lpUfo Failed!");
  3252. }
  3256. dwTransType = DDBLTFAST_NOCOLORKEY;
  3257.     ddsd.dwWidth = 640;
  3258.     ddsd.dwHeight = 480;
  3259.     ddrval = lpDD->CreateSurface(&ddsd, &lpBkGround, NULL );
  3260.     if( ddrval != DD_OK )
  3261. {
  3262. if(ddrval == DDERR_OUTOFMEMORY)
  3263. {
  3264. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3265.   DDSCAPS_SYSTEMMEMORY;
  3266. ddrval = lpDD->CreateSurface(&ddsd, &lpBkGround, NULL );
  3267. if(ddrval != DD_OK)
  3268. return CleanupAndExit("CreateSurface lpUfo Failed!");
  3269. }
  3270. else
  3271. return CleanupAndExit("CreateSurface Background Failed!");
  3272. }
  3275. dwTransType = DDBLTFAST_SRCCOLORKEY;
  3276.     ddsd.dwWidth = 350;
  3277.     ddsd.dwHeight = 350;
  3278.     ddrval = lpDD->CreateSurface(&ddsd, &lpShip, NULL );
  3279.     if( ddrval != DD_OK )
  3280. {
  3281. if(ddrval == DDERR_OUTOFMEMORY)
  3282. {
  3283. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3284.   DDSCAPS_SYSTEMMEMORY;
  3285. ddrval = lpDD->CreateSurface(&ddsd, &lpShip, NULL );
  3286. if(ddrval != DD_OK)
  3287. return CleanupAndExit("CreateSurface Background Failed!");
  3288. }
  3289. else
  3290. return CleanupAndExit("CreateSurface Background Failed!");
  3291. }
  3294.     ddsd.dwWidth = 220;
  3295.     ddsd.dwHeight = 20;
  3296.     ddrval = lpDD->CreateSurface(&ddsd, &lpShoot, NULL );
  3297.     if( ddrval != DD_OK )
  3298. {
  3299. if(ddrval == DDERR_OUTOFMEMORY)
  3300. {
  3301. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3302.   DDSCAPS_SYSTEMMEMORY;
  3303. ddrval = lpDD->CreateSurface(&ddsd, &lpShoot, NULL );
  3304. if(ddrval != DD_OK)
  3305. return CleanupAndExit("CreateSurface Shoot Failed!");
  3306. }
  3307. else
  3308. return CleanupAndExit("CreateSurface Shoot Failed!");
  3309. }
  3311.     ddsd.dwWidth = 20;
  3312.     ddsd.dwHeight = 20;
  3313.     ddrval = lpDD->CreateSurface(&ddsd, &lpShoot2, NULL );
  3314.     if( ddrval != DD_OK )
  3315. {
  3316. if(ddrval == DDERR_OUTOFMEMORY)
  3317. {
  3318. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3319.   DDSCAPS_SYSTEMMEMORY;
  3320. ddrval = lpDD->CreateSurface(&ddsd, &lpShoot2, NULL );
  3321. if(ddrval != DD_OK)
  3322. return CleanupAndExit("CreateSurface Shoot 2 Failed!");
  3323. }
  3324. else
  3325. return CleanupAndExit("CreateSurface  Shoot 2 Failed!");
  3326. }
  3327.     
  3328. ddsd.dwWidth = 350;
  3329.     ddsd.dwHeight = 280;
  3330.     ddrval = lpDD->CreateSurface(&ddsd, &lpBoom, NULL );
  3331.     if( ddrval != DD_OK )
  3332. {
  3333. if(ddrval == DDERR_OUTOFMEMORY)
  3334. {
  3335. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3336.   DDSCAPS_SYSTEMMEMORY;
  3337. ddrval = lpDD->CreateSurface(&ddsd, &lpBoom, NULL );
  3338. if(ddrval != DD_OK)
  3339. return CleanupAndExit("CreateSurface Boom Failed!");
  3340. }
  3341. else
  3342. return CleanupAndExit("CreateSurface  Boom Failed!");
  3343. }
  3345.     ddsd.dwWidth = 400;
  3346.     ddsd.dwHeight = 20;
  3347.     ddrval = lpDD->CreateSurface(&ddsd, &lpUfoShoot, NULL );
  3348.     if( ddrval != DD_OK )
  3349. {
  3350. if(ddrval == DDERR_OUTOFMEMORY)
  3351. {
  3352. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3353.   DDSCAPS_SYSTEMMEMORY;
  3354. ddrval = lpDD->CreateSurface(&ddsd, &lpUfoShoot, NULL );
  3355. if(ddrval != DD_OK)
  3356. return CleanupAndExit("CreateSurface UfoShoot Failed!");
  3357. }
  3358. else
  3359. return CleanupAndExit("CreateSurface  UfoShoot Failed!");
  3360. }
  3362.     ddsd.dwWidth = 490;
  3363.     ddsd.dwHeight = 210;
  3364.     ddrval = lpDD->CreateSurface(&ddsd, &lpShipBoom, NULL );
  3365.     if( ddrval != DD_OK )
  3366. {
  3367. if(ddrval == DDERR_OUTOFMEMORY)
  3368. {
  3369. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3370.   DDSCAPS_SYSTEMMEMORY;
  3371. ddrval = lpDD->CreateSurface(&ddsd, &lpShipBoom, NULL );
  3372. if(ddrval != DD_OK)
  3373. return CleanupAndExit("CreateSurface ShipExplode Failed!");
  3374. }
  3375. else
  3376. return CleanupAndExit("CreateSurface  ShipExplode Failed!");
  3377. }
  3379.     ddsd.dwWidth = 623;
  3380.     ddsd.dwHeight = 15;
  3381.     ddrval = lpDD->CreateSurface(&ddsd, &lpAlpha, NULL );
  3382.     if( ddrval != DD_OK )
  3383. {
  3384. if(ddrval == DDERR_OUTOFMEMORY)
  3385. {
  3386. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3387.   DDSCAPS_SYSTEMMEMORY;
  3388. ddrval = lpDD->CreateSurface(&ddsd, &lpAlpha, NULL );
  3389. if(ddrval != DD_OK)
  3390. return CleanupAndExit("CreateSurface Alphabet Failed!");
  3391. }
  3392. else
  3393. return CleanupAndExit("CreateSurface  Alphabet Failed!");
  3394. }
  3396.     ddsd.dwWidth = 640;
  3397.     ddsd.dwHeight = 20;
  3398.     ddrval = lpDD->CreateSurface(&ddsd, &lpSelect, NULL );
  3399.     if( ddrval != DD_OK )
  3400. {
  3401. if(ddrval == DDERR_OUTOFMEMORY)
  3402. {
  3403. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3404.   DDSCAPS_SYSTEMMEMORY;
  3405. ddrval = lpDD->CreateSurface(&ddsd, &lpSelect, NULL );
  3406. if(ddrval != DD_OK)
  3407. return CleanupAndExit("CreateSurface Selection Failed!");
  3408. }
  3409. else
  3410. return CleanupAndExit("CreateSurface  Selection Failed!");
  3411. }
  3413.     ddsd.dwWidth = 522;
  3414.     ddsd.dwHeight = 20;
  3415.     ddrval = lpDD->CreateSurface(&ddsd, &lpStatusBar, NULL );
  3416.     if( ddrval != DD_OK )
  3417. {
  3418. if(ddrval == DDERR_OUTOFMEMORY)
  3419. {
  3420. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3421.   DDSCAPS_SYSTEMMEMORY;
  3422. ddrval = lpDD->CreateSurface(&ddsd, &lpStatusBar, NULL );
  3423. if(ddrval != DD_OK)
  3424. return CleanupAndExit("CreateSurface StatusBar Failed!");
  3425. }
  3426. else
  3427. return CleanupAndExit("CreateSurface  StatusBar Failed!");
  3428. }
  3430.     ddsd.dwWidth = 500;
  3431.     ddsd.dwHeight = 125;
  3432.     ddrval = lpDD->CreateSurface(&ddsd, &lpExtra, NULL );
  3433.     if( ddrval != DD_OK )
  3434. {
  3435. if(ddrval == DDERR_OUTOFMEMORY)
  3436. {
  3437. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
  3438.   DDSCAPS_SYSTEMMEMORY;
  3439. ddrval = lpDD->CreateSurface(&ddsd, &lpExtra, NULL );
  3440. if(ddrval != DD_OK)
  3441. return CleanupAndExit("CreateSurface Extras Failed!");
  3442. }
  3443. else
  3444. return CleanupAndExit("CreateSurface  Extras Failed!");
  3445. }
  3447.     if( !RestoreSurfaces() )
  3448.         return CleanupAndExit("RestoreSurfaces Failed!");
  3451. return 1;
  3452. }
  3457. int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
  3458.                         int nCmdShow )
  3459. {
  3460.     MSG     msg;
  3462.     // save off application instance
  3463.     hInst = hInstance;
  3465.     if( !initApplication(hInstance, nCmdShow) )
  3466.     {
  3467.         return FALSE;
  3468.     }
  3470.     // Call the initialization procedure
  3471. if( !InitializeGame() )
  3472.     {
  3473.         OutputDebugString("ERROR STARTING THE GAMEn");
  3474. DestroyWindow( hWndMain );
  3475.         return FALSE;
  3476.     }
  3478.     // Initialize Sound Buffer
  3479. InitializeSound();
  3481.     // Go throught the message look
  3482. // When Idle update the screen
  3483. while( 1 )
  3484.     {
  3485.         
  3486. if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
  3487.         {
  3488.             if( !GetMessage( &msg, NULL, 0, 0 ) )
  3489.             {
  3490.                 return msg.wParam;
  3491.             }
  3492.             TranslateMessage(&msg);
  3493.             DispatchMessage(&msg);
  3494.         }
  3495.         else if ( bIsActive )
  3496.         {
  3497.             
  3498. UpdateFrame();
  3499.         }
  3500.         else
  3501.         {
  3502.             WaitMessage();
  3503.         }
  3504.     }
  3506. }