TankObj.h
上传用户:royluo
上传日期:2007-01-05
资源大小:1584k
文件大小:8k
源码类别:

游戏

开发平台:

Visual C++

  1. /*****************************************************************************
  2. *                                                                             
  3. *   TankObj.h
  4. *                                                                             
  5. *   Electrical Engineering Faculty - Software Lab                             
  6. *   Spring semester 1998                                                      
  7. *                                                                             
  8. *   Tanks game                                                                
  9. *                                                                             
  10. *   Module description: Implements the tank game object.
  11. *                       
  12. *                                                                             
  13. *   Authors: Eran Yariv - 28484475                                           
  14. *            Moshe Zur  - 24070856                                           
  15. *                                                                            
  16. *                                                                            
  17. *   Date: 23/09/98                                                           
  18. *                                                                            
  19. ******************************************************************************/
  20. #ifndef _TANK_OBJECT_H_
  21. #define _TANK_OBJECT_H_
  22. #include "GameConsts.h"
  23. #include "GameObject.h"
  24. #include "ImageManager.h"
  25. #include "ManouverSet.h"
  26. #include "Timer.h"
  27. #include "GameObjectsList.h"
  28. #include "MsgQueue.h"
  29. #include "TanksDlg.h"
  30. #include "CyclicBuf.h"
  31. typedef struct {
  32.     int iBulletXOffset,
  33.         iBulletYOffset,
  34.         iShellXOffset,
  35.         iShellYOffset,
  36.         iMineXOffset,
  37.         iMineYOffset;
  38. } DirOffsetType;
  39. struct PosEntry {
  40.     PosEntry (DWORD dwTime = -1, UINT uXPos = -1, UINT uYPos = -1) :
  41.         m_dwTime (dwTime), m_uXPos(uXPos), m_uYPos(uYPos) {};
  42.     DWORD m_dwTime;
  43.     UINT  m_uXPos;
  44.     UINT  m_uYPos;
  45. };
  46. class CTankObj : public CMovingGameObject
  47. {
  48. public:
  49.     CTankObj (  UINT uID, UINT uXPos, UINT uYPos, UINT uDirIndex,
  50.                 BOOL bLocal = FALSE, 
  51.                 UINT uShieldLevel = TANK_INIT_SHIELD_LEVEL, 
  52.                 UINT uShells = TANK_INIT_SHELLS,
  53.                 UINT uBullets = TANK_INIT_BULLETS, 
  54.                 UINT uMines = TANK_INIT_MINES, 
  55.                 BYTE bFireRateBonusSecsLeft = 0   );
  56.     ~CTankObj ();
  57.     UINT                GetID ();
  58.     UINT                GetShieldLevel ();
  59.     UINT                GetShellsCount ();
  60.     UINT                GetBulletsCount ();
  61.     UINT                GetMinesCount ();
  62.     UINT                SetShieldLevel (UINT uShield);
  63.     UINT                SetShellsCount (UINT uShells);
  64.     UINT                SetBulletsCount (UINT uBullets);
  65.     UINT                SetMinesCount (UINT uMines);
  66.     StateType           CalcState (DWORD dwCurTime);
  67.     ObjectHeightType    GetHeight();
  68.     HIMAGE              GetImage();
  69.     CRect             & GetUpdateRectangle();
  70.     BOOL                GetFastFire();
  71.     CReaction           React(CGameObject *pTo);
  72.     GameObjectType      GetType();
  73.     BOOL                IsLocal ();
  74.     BOOL                IsZombie ();
  75.     void                SetZombie (BOOL);
  76.         // Ask tank to relinquish input manouver set and ignore user requests
  77.     void                RelinquishInput ();     
  78.         // Ask tank to regain input manouver set and obey user requests
  79.     void                RegainInput (BOOL bBomberLaunched);         
  80.     CManouverSet&       GetManouverSet () const;
  81.     void                EatBonus (BonusType, DWORD dwEatTime);
  82.     BOOL                IsExploding ();
  83.     void                Kill(); // Start exploding the tank
  84.     UINT                GetDirection ();    // Get current tank direction
  85.     WORD                GetStateCheckSum(); // Gets check sum (16 bits) of shield level, ammo level and fast fire rate
  86.     void                GetStatus(CMessage::MessageData &MsgData);
  87.     void                GetStatusAndPos(CMessage::MessageData &MsgData);
  88.     void                SetPos (DWORD dwTime, int XPos, int YPos);
  89.     void                SetStatus(CMessage::MessageData &MsgData);
  90. private:
  91.         // images:
  92.     HIMAGE              m_hTankImage;               // handle to a bitmap of a live tank
  93.     HIMAGE              m_hExplodedTankImage;       // handle to a bitmap of an exploding tank
  94.     HIMAGE              m_hZombieOverlay;           // Zombie overlay image    
  95.     HIMAGE            * m_pCurrentImage;            // points to one of the handles above
  96.         // keyboard:                    
  97.     CManouverSet      & m_ManouverSet;              // points to manouver set in game manager
  98.         // manouvers:                   
  99.     DWORD               m_dwLastBulletFiredTick;    // last time a bullet was fired
  100.     BOOL                BulletsEnabled(DWORD);      // function to control the bullet fire rate
  101.     void                FireBullet(DWORD);          // fuction to handle a fired bullet
  102.     DWORD               m_dwLastShellFiredTick;     // last time a shell was fired
  103.     DWORD               m_dwLastMineDropTick;       // last time mine was dropped
  104.     BOOL                MinesEnabled(DWORD);        // Controls the mine fire rate
  105.     BOOL                ShellsEnabled(DWORD);       // function to control the shell fire rate
  106.     void                FireShell(DWORD);           // function to handle a fired shell
  107.     BOOL                DropMine(DWORD);            // function to handle a dropped mine
  108.     void                LaunchBomber();             // function to handle launching a new bomber
  109.     WORD                PackBits (WORD wVal, WORD wNumBits);    // Get best representation with a given number of bits
  110.     DWORD               m_dwFireRateBonusLastTick;  // the last tick for the fire rate bonus to remain active
  111.     DWORD               m_dwBulletFireDelay;        // current delay between bullets
  112.     DWORD               m_dwShellFireDelay;         // current delay between shells
  113.     DWORD               m_dwLastRotationTime;
  114.         // properties:
  115.     UINT                m_uTankID;
  116.     UINT                m_uShieldLevel;
  117.     UINT                m_uShells;
  118.     UINT                m_uBullets;
  119.     UINT                m_uMines;
  120.     BOOL                m_bLocal;                   // Are we a local or remote tank?
  121.     BOOL                m_bUseManouverSet;          // Do we have control of the manouver set?
  122.     BOOL                m_bBomberAvail;             // Do we have a bomber at our disposal?
  123.     BOOL                m_bBomberInSetup;           // Did we just launch a bomber in setup mode?
  124.     BOOL                m_bZombie;                  // Is tank zombie (slow network connection)?
  125.         // aliases:
  126.     CTanksDlg         * m_pDlgWnd;
  127.     CImageManager     & m_ImageManager;
  128.     CGameObjectsList  & m_ObjList;
  129.     CMsgQueue         & m_MsgQueue;
  130.     CCommManager      & m_CommManager;
  131.     TIMER_CLASS       & m_Timer;
  132.     static const DirOffsetType m_SpawnOffsets [];
  133.     // Manouver set posting to the server:
  134.     CManouverSet        m_PrevManouverSet; // Previous manouver set
  135.     void                SendManouverSet ( CManouverSet &ms );
  136.     // Setting a new position is tricky, doing it only after a mismatch checksum:
  137.     BOOL                m_bForceNewPos;   // Are we forced with a new position and direction ?
  138.     int                 m_iNewForcedXPos;
  139.     int                 m_iNewForcedYPos;
  140.     UINT                m_uNewForcedDir;
  141.     // This cyclic buffer holds the history table of the recent tanks positions:
  142.     CCyclicBuffer<PosEntry, MAX_POS_TABLE> m_PosTable;
  143. };
  144. #include "TankObj.inl"
  145. #endif