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

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

射击游戏

开发平台：

Visual C++

Ufo.hpp：源码内容
  1. //*******************************************************
  2. //* INVASION - By Maur韈io Teichmann RItter 1998        *
  3. //* Please, respect the copyright                       *
  4. //*******************************************************
  7. // OVNI is the same thing as UFO but in portuguese
  8. // since i磎 brazilian, i think that was better to use the "local" name
  11. // Here a define a class for each one of the game objects (UFO, BULLET, EXTRA)
  12. class Ovni {
  13. private:
  14. int    x;
  15. int    y;
  16. int    mov;
  17. int    AmDown;
  18. int    inc;
  19. int    iExtra;
  20. int    iFrame;
  22. RECT   rcLastPos;
  23. int    ArgPosX;
  24. int    ArgPosY;
  25. int    iExplosionFrame;
  26. int    iQtdeDown;
  27. int    iState;
  28. int    iStr;
  30. Ovni*   Next;
  31. public:
  33. int    iType;
  34. DWORD  dwLastShoot;
  35. Ovni()
  36. {
  37. inc = 1;
  38. x = 0;
  39. y = 0;
  40. AmDown = 0;
  41. mov = 0;
  42. iState = 0;
  43. iExplosionFrame = 0;
  44. dwLastShoot     = 1000 + (rand() % 500);
  45. iType = 0;
  46. iStr = 1;
  47. ArgPosY = 0;
  48. ArgPosX = 0;
  49. iQtdeDown = 80;
  50. }
  52. int GetStr()
  53. {
  54. return iStr;
  55. }
  57. void SetStr(int iQtde)
  58. {
  59. iStr = iQtde;
  60. }
  62. void LowStr(int iQtde)
  63. {
  64. iStr -= iQtde;
  65. }
  67. void SetQtdeDown(int iNewQtde)
  68. {
  69. iQtdeDown = iNewQtde;
  70. }
  72. int CreateExtra(int iFlags)
  73. {
  74. int iPercent;
  76. iPercent = rand() % 150;
  77. iExtra = 0;
  78. if ((iPercent == 0 || iPercent == 25 || iPercent == 45) &&
  79. (iFlags != 2))
  80. iExtra = 2;
  81. if (iPercent > 0 && iPercent < 11)
  82. iExtra = 3;
  83. if (iPercent > 10 && iPercent < 25)
  84. iExtra = 1;
  85. if (iPercent > 25 && iPercent < 45)
  86. iExtra = 4;
  87. if (iPercent == 45 || iPercent == 46)
  88. iExtra = 5;
  89. return iExtra;
  90. }
  92. int GetExtra()
  93. {
  94. return iExtra;
  95. }
  97. void SetAmDown(int newAmDown)
  98. {
  99. AmDown = newAmDown;
  100. }
  102. int GetAmDown(void)
  103. {
  104. return AmDown;
  105. }
  108. void SetInc(int newInc)
  109. {
  110. inc = newInc;
  111. }
  113. int GetInc(void)
  114. {
  115. return inc;
  116. }
  118. void SetMov(int newmov)
  119. {
  120. mov = newmov;
  121. }
  123. int GetMov(void)
  124. {
  126. return mov;
  127. }
  129. void SetXY(int newx, int newy)
  130. {
  131. x = newx;
  132. y = newy;
  133. rcLastPos.top    = y;
  134. rcLastPos.left   = x;
  135. rcLastPos.bottom = y + 70;
  136. rcLastPos.right  = x + 70;
  137. if (rcLastPos.bottom > 460)
  138. rcLastPos.bottom = 460;
  139. if (rcLastPos.left > 640)
  140. rcLastPos.left = 640;
  141. }
  143. Ovni* GetNext(void)
  144. {
  145. return Next;
  146. }
  148. void SetNext(Ovni* nxUfo)
  149. {
  150. Next = nxUfo;
  151. }
  153. int GetX(void)
  154. {
  155. return x;
  156. }
  158. int GetY(void)
  159. {
  160. return y;
  161. }
  163. void SetState(int iNewState)
  164. {
  165. iState = iNewState;
  166. }
  168. void Crash()
  169. {
  170. switch (iType)
  171. {
  172. case 0:
  173. inc = inc * (-1);
  174. break;
  175. case 2:
  176. if (mov == 1)
  177. mov = 0;
  178. else
  179. mov = 1;
  180. break;
  181. }
  182. }
  184. int Move(int iFlags)
  185. {
  186. rcLastPos.top    = y;
  187. rcLastPos.left   = x;
  188. rcLastPos.bottom = y + 70;
  189. rcLastPos.right  = x + 70;
  190. if (rcLastPos.bottom > 460)
  191. rcLastPos.bottom = 460;
  192. if (rcLastPos.right > 640)
  193. rcLastPos.right = 640;
  194. if (rcLastPos.left < 0)
  195. rcLastPos.left = 0;
  196. if (rcLastPos.top < 0)
  197. rcLastPos.top = 0;
  198. switch(iType)
  199. {
  200. case 0:
  201. switch (mov)
  202. {
  203. case 0:
  204. x += inc;
  205. if (y > 300)
  206. {
  207. if (inc > 0)
  208. {
  209. if (x>650)
  210. {
  211. x = 11;
  212. y = -70;
  213. mov = 1;
  214. inc = 1;
  215. AmDown = 0;
  216. }
  217. }
  218. else
  219. {
  220. if (x<-80)
  221. {
  222. x = 560;
  223. y = -70;
  224. mov = 1;
  225. inc = 1;
  226. AmDown = 0;
  227. }
  228. }
  229. }
  230. else
  231. {
  232. if (x == 560 ||
  233. x == 10)
  234. {
  235. AmDown = 0;
  236. mov = 1;
  237. inc = 1;
  238. }
  239. }
  240. break;
  241. case 1:
  242. y += inc;
  243. AmDown += inc;
  244. if (y > 0)
  245. if (AmDown >= iQtdeDown)
  246. {
  247. mov = 0;
  248. if (x == 0)
  249. {
  250. inc = abs(inc);
  251. }
  253. if (x == 560)
  254. {
  255. inc = abs(inc) * (-1);
  256. }
  257. }
  258. break;
  259. }
  260. break;
  261. case 1:
  262. switch(mov)
  263. {
  264. case 0:
  265. x -= inc;
  266. y -= inc;
  267. if (x <= 0)
  268. {
  269. x = 0;
  270. mov = 1;
  271. }
  272. if (y <= 0)
  273. {
  274. y = 0;
  275. mov = 3;
  276. }
  277. break;
  278. case 1:
  279. x += inc;
  280. y -= inc;
  281. if (x >= 560)
  282. {
  283. x = 560;
  284. mov = 0;
  285. }
  286. if (y <= 0)
  287. {
  288. y = 0;
  289. mov = 2;
  290. }
  291. break;
  292. case 2:
  293. x += inc;
  294. y += inc;
  295. if (x >= 560)
  296. {
  297. x = 560;
  298. mov = 3;
  299. }
  300. if (y >= 300)
  301. {
  302. y = 300;
  303. mov = 1;
  304. }
  305. break;
  306. case 3:
  307. x -= inc;
  308. y += inc;
  309. if (x <= 0)
  310. {
  311. x = 0;
  312. mov = 2;
  313. }
  314. if (y >= 300)
  315. {
  316. y = 300;
  317. mov = 0;
  318. }
  319. break;
  320. }
  321. break;
  322. case 2:
  323. switch(mov)
  324. {
  325. case 0:
  326. if (x <= iFlags )
  327. {
  328.     if (iFlags != NULL)
  329. mov = 1;
  330. else
  331. x += inc;
  332. }
  333. else
  334. x +=inc;
  335. if (x >= 650)
  336. {
  337. x = -80;
  338. mov = 0;
  339. }
  340. break;
  341. case 1:
  342. if (x >= iFlags)
  343.     if (iFlags != NULL)
  344. mov = 0;
  345. else
  346. x -= inc;
  347. else
  348. x -=inc;
  349. if (x <= -80)
  350. {
  351. x = 650;
  352. mov = 1;
  353. }
  354. break;
  355. }
  356. break;
  357. }
  358. return TRUE;
  359. }
  361. BOOL isExploding()
  362. {
  363. if (iState == 0)
  364. return FALSE;
  365. else
  366. return TRUE;
  367. }
  369. BOOL DropExtra()
  370. {
  371. if (iState == 1 &&
  372. iExplosionFrame == 12 &&
  373. iExtra != 0
  374. )
  375. return TRUE;
  376. else
  377. return FALSE;
  378. }
  380. BOOL DestroyMe()
  381. {
  382. if (iState == 1 &&
  383. iExplosionFrame == 20)
  384. return TRUE;
  385. return FALSE;
  386. }
  388. /* BOOL Repaint(LPDIRECTDRAWSURFACE7 lpDest, LPDIRECTDRAWSURFACE7 lpSource, int iFlags)
  389. {
  390. HRESULT hRet;
  392. if (iFlags == 1 ||
  393. (iState == 1 && iExplosionFrame > 0))
  394. {
  395. rcLastPos.top    = y - 2;
  396. rcLastPos.left   = x - 2;
  397. rcLastPos.bottom = y + 74;
  398. rcLastPos.right  = x + 74;
  399. if (rcLastPos.bottom > 460)
  400. rcLastPos.bottom = 460;
  401. if (rcLastPos.right > 640)
  402. rcLastPos.right = 640;
  403. if (rcLastPos.top < 0)
  404. rcLastPos.top = 0;
  405. if (rcLastPos.left < 0)
  406. rcLastPos.left = 0;
  407. }
  409. while (1)
  410. {
  411. hRet = lpDest->BltFast(rcLastPos.left, rcLastPos.top, lpSource, &rcLastPos, DDBLTFAST_NOCOLORKEY | DDBLTFAST_WAIT);
  412. if (hRet == DD_OK)
  413. {
  414. break;
  415. }
  416. if (hRet == DDERR_SURFACELOST)
  417. {
  418. return FALSE;
  419. }
  420. if (hRet != DDERR_WASSTILLDRAWING)
  421. break;
  422. }
  423. return TRUE;
  424. }
  425. */
  426. BOOL Draw(LPDIRECTDRAWSURFACE7 lpDest, LPDIRECTDRAWSURFACE7 lpSource, int iFlags)
  427. {
  428. RECT rcRect;
  429. HRESULT hRet;
  430. int iDiffRight;
  431. int iDiffLeft;
  432. int iDiffBottom;
  434. switch(iState)
  435. {
  436. case 0:
  437. rcRect.left = ArgPosX;
  438. rcRect.top = ArgPosY;
  439. rcRect.right = ArgPosX + 70;
  440. rcRect.bottom = ArgPosY + 70;
  442. if (x+70>640)
  443. {
  444. iDiffRight = x+70-640;
  445. rcRect.right -= iDiffRight;
  446. }
  447. else
  448. iDiffLeft = 0;
  450. if (x<0)
  451. {
  452. iDiffLeft = x * (-1);
  453. rcRect.left += iDiffLeft;
  454. }
  455. else
  456. iDiffLeft = 0;
  457. if (y < 0)
  458. {
  459. iDiffBottom = y * (-1);
  460. rcRect.top += iDiffBottom;
  461. }
  462. else
  463. iDiffBottom = 0;
  464. break;
  465. case 1:
  466. iDiffBottom = 0;
  467. if (iExplosionFrame < 5)
  468. {
  469. ArgPosX = iExplosionFrame * 70;
  470. ArgPosY = 0;
  471. }
  472. if (iExplosionFrame > 4 &&
  473. iExplosionFrame < 9)
  474. {
  475. ArgPosX = (iExplosionFrame-5) * 70;
  476. ArgPosY = 70;
  477. }
  478. if (iExplosionFrame > 9 &&
  479. iExplosionFrame < 14)
  480. {
  481. ArgPosX = (iExplosionFrame-10) * 70;
  482. ArgPosY = 140;
  483. }
  484. if (iExplosionFrame > 14 &&
  485. iExplosionFrame < 20)
  486. {
  487. ArgPosX = (iExplosionFrame-15) * 70;
  488. ArgPosY = 210;
  489. }
  491. rcRect.left = ArgPosX;
  492. rcRect.top = ArgPosY;
  493. rcRect.right = ArgPosX + 70;
  494. rcRect.bottom = ArgPosY + 70;
  495. if (x+70>640)
  496. {
  497. iDiffRight = x+70-640;
  498. rcRect.right -= iDiffRight;
  499. }
  500. else
  501. iDiffLeft = 0;
  503. if (x<0)
  504. {
  505. iDiffLeft = x * (-1);
  506. rcRect.left += iDiffLeft;
  507. }
  508. else
  509. iDiffLeft = 0;
  510. if (y < 0)
  511. {
  512. iDiffBottom = y * (-1);
  513. rcRect.top += iDiffBottom;
  514. }
  515. else
  516. iDiffBottom = 0;
  517. iExplosionFrame++;
  518. break;
  519. }
  521. while (1)
  522. {
  523. hRet = lpDest->BltFast(x+iDiffLeft, y+iDiffBottom, lpSource, &rcRect, TRUE);
  524. if (hRet == DD_OK)
  525. {
  526. hRet = TRUE;
  527. break;
  528. }
  529. if (hRet == DDERR_SURFACELOST)
  530. {
  531. hRet = FALSE;
  532. break;
  533. }
  534. if (hRet != DDERR_WASSTILLDRAWING)
  535. {
  536. hRet = TRUE;
  537. break;
  538. }
  539. }
  541. ArgPosX += 70;
  542. if (ArgPosX == 350)
  543. {
  544. ArgPosX = 0;
  545. ArgPosY += 70;
  546. if (ArgPosY == 700)
  547. ArgPosY = 0;
  548. }
  549. return hRet;
  550. }
  551. };
  553. class Bullet
  554. {
  555. private:
  556. int x;
  557. int y;
  558. RECT rcLastPos;
  559. int iType;
  561. Bullet* pNext;
  562. Bullet* pPrev;
  564. public:
  565. int frame;
  566. Bullet()
  567. {
  568. x = 0;
  569. y = 0;
  570. pNext = NULL;
  571. pPrev = NULL;
  572. frame = 0;
  573. iType = 0;
  574. rcLastPos.left   = 0;
  575. rcLastPos.top    = 0;
  576. rcLastPos.right  = 0;
  577. rcLastPos.bottom = 0;
  578. };
  580. int GetType()
  581. {
  582. return iType;
  583. }
  585. void SetType(int iNewType)
  586. {
  587. iType = iNewType;
  588. }
  590. int GetX()
  591. {
  592. return x;
  593. }
  595. int GetY()
  596. {
  597. return y;
  598. }
  600. int GetPower()
  601. {
  602. switch(iType)
  603. {
  604. case 0:
  605. return 2;
  606. break;
  607. case 2:
  608. return 1;
  609. break;
  610. }
  611. return 1;
  612. }
  614. void Move(int Qtde)
  615. {
  616. rcLastPos.left   = x;
  617. rcLastPos.top    = y;
  618. rcLastPos.right  = x + 20;
  619. rcLastPos.bottom = y + 20;
  620. if (rcLastPos.top < 0)
  621. rcLastPos.top = 0;
  622. if (rcLastPos.bottom > 455)
  623. rcLastPos.bottom = 455;
  624. y -= Qtde;
  625. }
  627. void SetXY(int nx, int ny)
  628. {
  629. rcLastPos.left   = nx;
  630. rcLastPos.top    = ny;
  631. rcLastPos.right  = nx + 20;
  632. rcLastPos.bottom = ny + 20;
  633. x = nx;
  634. y = ny;
  635. }
  637. Bullet* GetNext()
  638. {
  639. return pNext;
  640. }
  642. Bullet* GetPrev()
  643. {
  644. return pPrev;
  645. }
  647. void SetNext(Bullet* nNext)
  648. {
  649. pNext = nNext;
  650. }
  652. void SetPrev(Bullet* nPrev)
  653. {
  654. pPrev = nPrev;
  655. }
  657. BOOL Draw(LPDIRECTDRAWSURFACE7 lpOrigin, LPDIRECTDRAWSURFACE7 lpSource)
  658. {
  659. RECT rcRect;
  660. HRESULT hRet;
  661. int iClipTop;
  662. int iClipBottom;
  664. if (y < 0)
  665. iClipTop = y * -1;
  666. else
  667. iClipTop = 0;
  669. if (y+20 > 455)
  670. iClipBottom = y+20-455;
  671. else
  672. iClipBottom = 0;
  674. if (iType == 2)
  675. frame = 0;
  676. rcRect.left = frame * 20;
  677. rcRect.top = 0 + iClipTop;
  678. rcRect.right = frame * 20 + 20;
  679. rcRect.bottom = 20 - iClipBottom;
  681. frame++;
  683. if (frame == 11 && iType == 0)
  684. frame = 0;
  685. if (frame == 20 && iType == 1)
  686. frame = 0;
  688. while (1)
  689. {
  690. hRet = lpOrigin->BltFast(x + iClipTop, y, lpSource, &rcRect, DDBLTFAST_SRCCOLORKEY);
  692. if (hRet == DD_OK)
  693. {
  694. break;
  695. }
  696. if (hRet == DDERR_SURFACELOST)
  697. {
  698. return FALSE;
  699. }
  700. if (hRet != DDERR_WASSTILLDRAWING)
  701. break;
  702. }
  703. return TRUE;
  704. }
  705. // Flags:
  706. //
  707. // 1 - Draw background
  708. // 2 - Draw bullet
  710. /*
  712. BOOL Repaint(LPDIRECTDRAWSURFACE7 lpOrigin, LPDIRECTDRAWSURFACE7 lpSource, int iFlags)
  713. {
  714. HRESULT hRet;
  715. int iCorrection = 0;
  717. if (iFlags == 1)
  718. {
  719. rcLastPos.top    = y;
  720. rcLastPos.left   = x;
  721. rcLastPos.bottom = y + 20;
  722. rcLastPos.right  = x + 20;
  723. if (rcLastPos.bottom > 460)
  724. rcLastPos.bottom = 460;
  725. }
  727. while (1)
  728. {
  729. hRet = lpOrigin->BltFast(rcLastPos.left, rcLastPos.top, lpSource, &rcLastPos, DDBLTFAST_NOCOLORKEY | DDBLTFAST_WAIT);
  730. if (hRet == DD_OK)
  731. {
  732. break;
  733. }
  734. if (hRet == DDERR_SURFACELOST)
  735. {
  736. return FALSE;
  737. }
  738. if (hRet != DDERR_WASSTILLDRAWING)
  739. break;
  740. }
  741. return TRUE;
  742. }
  743. */
  744. };
  751. //处理奖子类型的类，奖子定义在图extras.bmp中，它是一副500×125的图像，有五种类型的奖子，每种奖子有20帧，
  752. //平均每个奖子是25*25的分辨率。
  753. class Extra
  754. {
  755. private:
  756. int x;
  757. int y;
  758. RECT rcLastPos;
  759. int iType; //奖子类型，从extras.bmp可以看出共有5种类型
  761. Extra* pNext;
  762. Extra* pPrev;
  764. public:
  765. int frame;//帧编号，从extras.bmp可以看出共有20帧
  766. Extra()
  767. {
  768. x = 0;
  769. y = 0;
  770. pNext = NULL;
  771. pPrev = NULL;
  772. frame = 0;
  773. iType = 0;
  774. rcLastPos.left   = 0;
  775. rcLastPos.top    = 0;
  776. rcLastPos.right  = 0;
  777. rcLastPos.bottom = 0;
  778. };
  780. int GetType()
  781. {
  782. return iType;
  783. }
  785. void SetType(int iNewType)
  786. {
  787. iType = iNewType;
  788. }
  790. int GetX()
  791. {
  792. return x;
  793. }
  795. int GetY()
  796. {
  797. return y;
  798. }
  800. void Move(int Qtde)
  801. {
  802. rcLastPos.left   = x;
  803. rcLastPos.top    = y;
  804. rcLastPos.right  = x + 25;
  805. rcLastPos.bottom = y + 25;
  806. if (rcLastPos.bottom > 455)
  807. rcLastPos.bottom = 455;
  808. //Qtde是一个负值，因为这种奖子都是垂直下落的，即y值需要不断增加
  809. y -= Qtde;
  810. }
  812. void SetXY(int nx, int ny)
  813. {
  814. rcLastPos.left   = nx;
  815. rcLastPos.top    = ny;
  816. rcLastPos.right  = nx + 25;
  817. rcLastPos.bottom = ny + 25;
  818. x = nx;
  819. y = ny;
  820. }
  822. Extra* GetNext()
  823. {
  824. return pNext;
  825. }
  827. Extra* GetPrev()
  828. {
  829. return pPrev;
  830. }
  832. void SetNext(Extra* nNext)
  833. {
  834. pNext = nNext;
  835. }
  837. void SetPrev(Extra* nPrev)
  838. {
  839. pPrev = nPrev;
  840. }
  842. BOOL Draw(LPDIRECTDRAWSURFACE7 lpOrigin, LPDIRECTDRAWSURFACE7 lpSource)
  843. {
  844. RECT rcRect;
  845. HRESULT hRet;
  846. int iClipTop;
  847. int iClipBottom;
  849. if (y < 0)
  850. iClipTop = y * -1;
  851. else
  852. iClipTop = 0;
  854. if (y+25 > 455)
  855. iClipBottom = y+25-455;
  856. else
  857. iClipBottom = 0;
  859. rcRect.left = frame * 25;
  860. rcRect.top = ((iType - 1) * 25) + iClipTop;
  861. rcRect.right = frame * 25 + 25;
  862. rcRect.bottom = ((iType - 1) * 25) + 25 - iClipBottom;
  863. //帧数编号加1
  864. frame++;
  865. if (frame == 20)
  866. frame = 0;
  868. while (1)
  869. {
  870. hRet = lpOrigin->BltFast(x , y, lpSource, &rcRect, DDBLTFAST_SRCCOLORKEY);
  872. if (hRet == DD_OK)
  873. {
  874. break;
  875. }
  876. if (hRet == DDERR_SURFACELOST)
  877. {
  878. return FALSE;
  879. }
  880. if (hRet != DDERR_WASSTILLDRAWING)
  881. break;
  882. }
  883. return TRUE;
  884. }
  885. // Flags:
  886. //
  887. // 1 - Draw background
  888. // 2 - Draw bullet
  890. /*
  891. BOOL Repaint(LPDIRECTDRAWSURFACE lpDest, LPDIRECTDRAWSURFACE lpSource, int iFlags)
  892. {
  893. HRESULT hRet;
  894. int iCorrection = 0;
  896. if (iFlags == 1)
  897. {
  898. rcLastPos.top    = y;
  899. rcLastPos.left   = x;
  900. rcLastPos.bottom = y + 25;
  901. rcLastPos.right  = x + 25;
  902. if (rcLastPos.bottom > 455)
  903. rcLastPos.bottom = 455;
  904. }
  906. while (1)
  907. {
  908. hRet = lpDest->BltFast(rcLastPos.left, rcLastPos.top, lpSource, &rcLastPos, DDBLTFAST_NOCOLORKEY | DDBLTFAST_WAIT);
  909. if (hRet == DD_OK)
  910. {
  911. break;
  912. }
  913. if (hRet == DDERR_SURFACELOST)
  914. {
  915. return FALSE;
  916. }
  917. if (hRet != DDERR_WASSTILLDRAWING)
  918. break;
  919. }
  920. return TRUE;
  921. }
  922. */
  923. };
  925. // The alpha strucute is used to map the alphabet bitmap, so that we can
  926. // bli the alphabet to the screen
  928. struct Alpha
  929. {
  930. unsigned int start;
  931. unsigned int end;
  932. };
  934. const Alpha AA[40] = 
  935. {
  936. {0,14},{19,27},{31,46},{47,61},{65,78},{80,94},
  937. {96,110},{114,125},{128,143},{145,159},{160,175},
  938. {176,191},{193,206},{207,222},{224,237},{238,252},{253,267},
  939. {269,284},{285,291},{292,307},{308,323},{324,338},{340,364},
  940. {365,380},{382,397},{398,413},{414,429},{430,444},{447,460},
  941. {464,475},{477,492},{494,508},{509,533},{533,548},{550,564},
  942. {564,579},{579,599},{600,610},{611,615},{617,620}
  943. };