//////////////////////////////////////////////////////////////////////////////// // // Copyright 2016 RWS Inc, All Rights Reserved // // This program is free software; you can redistribute it and/or modify // it under the terms of version 2 of the GNU General Public License as published by // the Free Software Foundation // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // dude.h // Project: Postal // // History: // 01/27/97 JMI Added EditRect() override to make this object clickable. // // 02/07/97 JMI Removed m_pipe and m_sScreenRadius. Added m_sCurRadius // to represent the radius of the dude's current frame. // // 02/10/97 JMI Changed 3D stuff to use the new CAnim3D encapsulation // class. I suppose that eventually we will have several // of these per 3D thing. // // 02/11/97 JMI Moved CAnim3D to thing.h from dude.h. // // 02/11/97 JMI Added an EditHotSpot() override. // // 02/11/97 JMI Added the 3D animation for throwing and an associated // rigid body transform for a grenade. // // 02/12/97 JMI Fixed EditRect(). // // 02/14/97 JMI Moved EditRect() and EditHotSpot() bodies into the CPP. // I was getting annoyed compiling half the project for each // little tweak while experimenting. // // 02/16/97 JMI Added Stand animation member. // // 02/18/97 MJR Added fast velocity members. // // 02/18/97 JMI Added a CBulletFest member, a GetCollisionSphere() // override, and a CSmash member. // // 02/19/97 JMI Added some states. // // 02/19/97 JMI Added proto for new ReleaseGrenade() member. // // 02/19/97 JMI Added StateDamage and m_sHitPoints. // // 02/26/97 JMI Now sets m_sprite.m_pthing = this on construction. // // 03/03/97 JMI Added last persistent state member. // // 03/03/97 JMI Added states for strafing and multiweapon logic. // // 03/03/97 JMI Changed m_pGrenade to m_pWeapon (a CWeapon* instead of // a CGrenade*) so more weapons can be handle generically. // // 03/03/97 JMI Now CDude is based upon CCharacter. // Not much base class functionality utilized yet, though. // // 03/04/97 JMI Now utilizes more of the base class functionality. // All CCharacter::Edit*() functions are used. // Moved stuff I was incorrectly doing in Render() into // Update() so CDude now uses CCharacter::Render(). // // 03/04/97 JMI Added ProcessMessages() to service the message queue. // // 03/05/97 JMI Removed ProcessMessages() (now base class is fine). // // 03/05/97 JMI Removed ReleaseWeapon() now uses CCharacter::ShootWeapon(). // // 03/05/97 JMI Added m_lLastShotTime representing the last time the dude // was shot. // // 03/05/97 JMI Added m_animSuicide. // Made m_sDudeNum public. // Made SetState() public. // Added StartBrainSplat() and m_bBrainSplatted. // // 03/06/97 JMI OnSuicideMsg() override. // // 03/13/97 JMI Added EditModify() member function. // Also, added m_sNumFireBombs/Missiles/Napalms. // Load now takes a version number. // // 03/13/97 JMI Added DrawStatus() member function, // m_lStatusUpdateDoneTime, m_print, and GetWeaponInfo(). // // 03/13/97 JMI Changed default hitpoints to 500. // // 03/14/97 JMI Added ms_dVertVelJump. // // 03/21/97 JMI Added firing over the shoulder weapon animation, // m_animLaunch. // // 03/27/97 JMI Added many animations. // // 04/03/97 JMI Added color index members for font. // // 04/07/97 JMI Added jumps and fall components. // // 04/21/97 JMI Incorporated Mike's new crawler thinger for smooth rubbin' // and slidin' up against schtuff. // // 04/21/97 JMI Added override of WhileBlownUp(). // // 04/24/97 JMI Added shotgun weapon components. // // 04/25/97 JMI Added a state for executing dudes. // // 04/25/97 JMI Added flame thrower weapon support. Required fuel ammo // info and special case on release of flamage. // // 04/28/97 JMI Removed PrepareWeapon() override since the base class // version now handles bullet oriented weapons. // Also, moved FireBullets() to base class, CCharacter. // // 04/29/97 JMI Added m_animPickPut for picking up and putting things down. // Also, added mine weapon. You cannot choose the type now, // though (it's the default which is proximity). // // 04/29/97 JMI Changed DefNumFuel to 10,000. // // 04/30/97 JMI Changed Mine enum value to ProximityMine, TimedMine, // RemoteMine, and BouncingBettyMine. // // 05/02/97 JMI Added m_bGenericEvent1. // // 05/04/97 BRH Change number of CDudes from being baseed on the STL // container size to based on m_asClassNumThings][CDudeID], // now that the STL version of the things lists has been // taken out of realm completely. // // 05/08/97 JMI Added the NoWeapon weapon. // // 05/09/97 JMI Added m_psnd which we use to track which RSnd is // playing our sample. This is useful for weapons like the // flame thrower which play a sound and then keep it looping // until they're done. // // 05/13/97 JMI Added DefNumHeatseekers, Heatseeker, and m_sNumHeatseekers. // // 05/14/97 JMI Added m_u16IdChild, m_szMessages, and Message() proto. // // 05/20/97 BRH Added GetHealth() function for the AI logic tables to // access. // // 05/22/97 JMI Added CDudeAnim3D so we could use Get() but have it not // load textures (they are loaded separately so the dude // color can be changed by the user). // Also, added m_sTextureIndex which is used to determine the // texture this dude is to use for all his animations. // Also, made enums and typedefs public. // // 05/23/97 JMI Update() was nearly a thousand lines and that was just // too damned much. So I broke it up a bit. // Also, changed FireCurrentWeapon() to ArmWeapon() which // takes as a parameter the weapon to arm. // // 05/23/97 JMI m_sTextureIndex is now set in the constructor to 0, just // in case. // // 05/23/97 JMI Changed reference to CThing::CAnim3D to CAnim3D. // Also, enhanced CDudeAnim3D to handle events. // // 05/26/97 JMI Added m_lLastYellTime. // // 05/26/97 JMI Added m_sOrigHitPoints so dude can show percentage based // on initial hitpoints. // // 05/29/97 JMI Added a Revive() function which is the best way to revive // a dude that has died. // Added a timer for changing weapons that use the same input. // // 05/30/97 JMI Added SprayCannon enum and m_inputLast. // // 06/02/97 JMI Added climb state. // // 06/02/97 JMI Removed climb state. // // 06/05/97 JMI Removed m_sHitPoints and m_sNum*. Now uses CThing3d's // m_stockpile instead. // // 06/07/97 JMI Made m_sOrigHitPoints and Init() public. // // 06/08/97 BRH Added targeting sprite to the dude to help show // what he is aiming at. // // 06/09/97 JMI Removed m_inputLast and m_lLastWeaponChangeTime which are // no longer necessary now that we can use the auto-repeat // feature with the new event driven rspGetKeyStatusArray() // used by input.cpp. // Also, added m_animIdle and m_lNextIdleTime. // // 06/11/97 JMI Added handy functions, SetWeapon(), NextWeapon(), and // PrevWeapon(). // // 06/11/97 JMI Added DropPowerUp(). // // 06/12/97 JMI Added ms_apszAmmoNames to differentiate between weapons // and ammo strings. // // 06/12/97 JMI Added m_bUpdateStatus. // // 06/15/97 JMI Added more DefNum* type macros for dudes' stockpiles. // // 06/16/97 JMI Added MessageChange() and m_lMsgUpdateDoneTime. // // 06/16/97 JMI Added parms to make ShootWeapon() comply with virtual // base class version. // Also, m_bClearedStatus. // // 06/16/97 JMI Added m_u16KillerId to track who killed this dude. // // 06/17/97 JMI Added m_u8LastEvent to track the last animation event // and PlayStep() to play a step noise at the proper time. // Also, added OnExecute(). // // 06/25/97 JMI Added m_idVictim. // // 06/25/97 JMI Replaced m_lStatusUpdateDoneTime with // m_lNextStatusUpdateTime and removed m_bUpdateStatus. // // 07/01/97 JMI Added new rigid bodies to CDudeAnim3D and moved its // function defs into dude.cpp. // Also, added m_idFlagItem. // // 07/07/97 JMI DrawStatus() now returns true if it drew to the provide // image. // // 07/15/97 JMI Moved CDude() and ~CDude() from dude.h to dude.cpp. // // 07/15/97 JMI Added TakePowerup(). // // 07/16/97 JMI Made DropPowerUp() return the newly created powerup. // Also, added CreateCheat(). // // 07/16/97 JMI Changed the order of the weapons. // // 07/17/97 JMI Changed m_psnd to m_siLastPlayInstance. // Now uses new SampleMaster interface for volume and play // instance reference. // // 07/18/97 JMI Now UpdateFontColors() takes a CRealm* to match the palette // to the hood of. // // 07/21/97 JMI Now TakePowerUp() returns the powerup if it persisted. // Also, added ms_apszWeaponStatusFormats[]. // // 07/21/97 JMI Added OnWeaponDestroyed() override of CCharacter version. // Also, added m_weaponShooting. // // 07/23/97 JMI Added DefHasNapalmLauncher enum. // // 07/25/97 JMI Added option to Revive() to allow him to revive in-place // (rather than warping in). // Added m_bDead and IsDead() which are true when the dude // is dead. // // 07/25/97 JMI Added StartAnim() which starts a CAnimThing. // // 07/29/97 JMI Added GetCurrentWeapon(). // Made Set/Next/PrevWeapon() functions public. // // 07/29/97 JMI Changed IsDude() to IsDead(). Major typo. // // 07/30/97 JMI Added DefHasDeathWadLauncher and DeathWad. // Also, added m_sDeadMsgNum. // // 08/04/97 JMI Added array of weapon anims, m_aanimWeapons[], and // a sprite for showing the current weapon, m_spriteWeapon. // Also, condensed ms_apszAmmoNames, ms_apszWeaponNames, // ms_apszWeaponStatusFormats, and ms_apszWeaponResNames // into ms_awdWeapons. // // 08/05/97 JMI Added an ID to Message(). The idea being that, when the // same message ID is specified w/i a certain amount of time, // the more recent message is ignored. // // 08/07/97 JMI Added DefHasDoubleBarrel and DoubleBarrel. // Also, added sMinAmmoRequired to weapon details database. // // 08/07/97 JMI Added m_animBackpack and m_spriteBackpack for his backpack // when he has it. // // 08/08/97 JMI Removed m_siLastPlayInstance. // // 08/08/97 JMI Added TossPowerUp(). // Also, changed TakePowerup() to TakePowerUp(). // // 08/10/97 JMI Added m_dLastCrawledToPosX, Z which are the last position // successfully crawled to by the crawler (except on the // first iteration where they are simply set to the dude's // starting point). In TRACENASSERT mode, an ASSERT is // generated if the position gets modified by other than the // crawler. In release mode, it sets him back to the last // successful crawled position. // Added a function to set m_dX, Y, & Z, SetPosition(). // // 08/12/97 JMI Removed unused anims: m_animJump, JumpForward, Land, // LandForward, Fall. // // 08/14/97 BRH Added static collision bits to be passed as the default // bits for weapons that the dude shoots. The default // arguments in the ShootWeapon are unreliable and may // get set to the bits of the base class default args. // Also changed call of WhileHoldingWeapon to include // these default collision bits. // // 08/17/97 JMI Got rid of m_szMessages and all message related functions // and variables from CDude since we are now using the toolbar // for dude status feedback to the user. This includes: // MsgTypeInfo, m_lNextStatusUpdateTime, m_lMsgUpdateDoneTime, // m_print, m_bClearedStatus, m_szMessages[], m_sDeadMsgNum, // ms_amtfMessages[], ms_u8FontForeIndex, ms_u8FontBackIndex, // ms_u8FontShadowIndex, DrawStatus(), StatusChange(), // MessageChange(), Message(), UpdateFontColors(), // CPowerUp::ms_apszPowerUpTypeNames[], // CPowerUp::GetDescription(), and some strings and a string // array in localize.*. // // 08/18/97 JMI Moved StartAnim() from CDude to CThing3d so more things // could use it. // // 08/18/97 JMI Added m_bInvincible which gets set via cheat. // // 08/28/97 BRH Added OnPutMeDownMsg to handle the message sent from the // flag to drop it. // // 08/30/97 JMI Removed m_idFlagItem (now uses the sprite list and, for // flag child sprites, updates them all). // Also, added GetNextFlag(), DropAllFlags(). // // 09/03/97 JMI Changed the ShootWeapon() default parameters to use the // CDude statics for bits (ms_u32CollideBits*). // // 11/21/97 JMI Removed version of ShootWeapon() that took 3 default // parameters and replaced it with a version that takes no // parameters so we could control the defaults from within the // CPP. // // 12/08/97 JMI Added an option for DropPowerUp() to only drop the // currently selected weapon. // //////////////////////////////////////////////////////////////////////////////// #ifndef DUDE_H #define DUDE_H #include "RSPiX.h" #include "realm.h" #include "game.h" #include "weapon.h" #include "character.h" #include "crawler.h" #include "input.h" #include "PowerUp.h" #include "flag.h" // First shot at a dude, which is a player-controlled character class CDude : public CCharacter { //--------------------------------------------------------------------------- // Types, enums, etc. //--------------------------------------------------------------------------- public: // Macros. enum { MaxTextures = 8, DefHitPoints = 500, DefNumBullets = 50, DefNumGrenades = 5, DefNumFireBombs = 5, DefNumMissiles = 3, DefNumNapalms = 3, DefNumShells = 25, DefNumFuel = 50, DefNumMines = 3, DefNumHeatseekers = 3, DefHasMachineGun = 1, DefHasLauncher = 0, DefHasShotgun = 0, DefHasSprayCannon = 0, DefHasFlamer = 0, DefHasNapalmLauncher = 0, DefHasDeathWadLauncher = 0, DefHasDoubleBarrel = 0, DefKevlarLayers = 0, DefHasBackpack = 0 }; typedef enum { CurrentWeapon = -1, NoWeapon, SemiAutomatic, ShotGun, SprayCannon, Grenade, Rocket, Heatseeker, FireBomb, Napalm, FlameThrower, ProximityMine, TimedMine, RemoteMine, BouncingBettyMine, DeathWad, DoubleBarrel, NumWeaponTypes } WeaponType; typedef enum { MsgIdPickedUpPowerUp, MsgIdDontHaveExecuteWeapon, MsgIdDontHaveWeaponButHaveAmmo, MsgIdDontHaveWeaponOrAmmo, MsgIdDontHaveSuicideWeapon, NumMsgTypes } MsgId; typedef struct { char* pszWeaponName; char* pszAmmoName; char* pszStatusFormat; char* pszWeaponResName; short sMinAmmoRequired; } WeaponDetails; // This special version overrides the CAnim3D Get(char*, char*, short). class CDudeAnim3D : public CAnim3D { public: ChanTransform* m_ptransLeft; // Rigid body transforms for left hand. ChanTransform* m_ptransRight; // Rigid body transforms for right hand. ChanTransform* m_ptransBack; // Rigid body transforms for his backpack. // Get the various components of this animation from the resource names // specified in the provided array of pointers to strings. virtual // Overridden here. short Get( // Returns 0 on success. char* pszBaseFileName, // In: Base string for resource filenames. char* pszRigidName, // In: String to add for rigid transform channel // or NULL for none. char* pszEventName, // In: String to add for event states channel // or NULL for none. short sLoopFlags); // In: Looping flags to apply to all channels // in this anim. // Release all resources. virtual // Overridden here. void Release(void); // Returns nothing. }; //--------------------------------------------------------------------------- // Variables //--------------------------------------------------------------------------- public: short m_sDudeNum; // This dude's number for multiplayer mode short m_sTextureIndex; // This dude's texture index. Used as an // index into m_aptextures[]. short m_sOrigHitPoints; // Initial hitpoints. bool m_bTargetingHelpEnabled; // Show targeting sprite when enabled. // INPUT HACK. Normally we can't move in one direction while facing another. Android version // works by reading input while calculating the dude's velocity, but we can't do that with // keyboard input. Thus, these dude-only "twinstick" rotational values. bool m_bUseRotTS; // TRUE if we should use m_dRotTS to calculate velocity instead of m_dRot double m_dRotTS; // Direction we want to go when twinsticking // Actual joystick inputs double m_dJoyMoveVel; double m_dJoyMoveAngle; bool m_bJoyFire; double m_dJoyFireAngle; protected: CDudeAnim3D m_animStand; // Standing animation. CDudeAnim3D m_animRun; // Running animation. CDudeAnim3D m_animThrow; // Throwing animation. CDudeAnim3D m_animDie; // Dying animation. CDudeAnim3D m_animShoot; // Shooting animation. CDudeAnim3D m_animRunShoot; // Running and shooting animation. CDudeAnim3D m_animDamage; // Received damage animation. CDudeAnim3D m_animBurning; // Dude's on fire. CDudeAnim3D m_animStrafe; // Dude strafing with no forward movement. CDudeAnim3D m_animStrafeShoot; // Dude strafing and shooting with no forward movement. CDudeAnim3D m_animSuicide; // Dude commits suicide. CDudeAnim3D m_animLaunch; // Dude launches something with over the shoulder weapon. CDudeAnim3D m_animBlownUp; // Dude gets blown up. CDudeAnim3D m_animGetUp; // Dude gets up. CDudeAnim3D m_animDuck; // Dude ducks. CDudeAnim3D m_animRise; // Dude rises from duck. CDudeAnim3D m_animExecute; // Dude executes a victim/enemy. CDudeAnim3D m_animPickPut; // Dude picks something up or puts something down // depending upon direction played. CDudeAnim3D m_animIdle; // Dude hangs out -- idle animation. CAnim3D m_aanimWeapons[NumWeaponTypes]; // Weapons' anims. CSprite3 m_spriteWeapon; // Weapons' sprite. CAnim3D m_animBackpack; // Backpack's anim. CSprite3 m_spriteBackpack; // Backpack's sprite. ChanTexture* m_aptextures[MaxTextures]; // Colors for all dude animations. State m_statePersistent; // Last persistent state. For example, // StateBurning is persistent. He may get // shot and switch to damage state, but he // should switch back to burning when done. bool m_bBrainSplatted; // If true, brain has been splatted. bool m_bJumpVerticalTrigger; // If true, vertical acceleration for jump // has been applied. bool m_bGenericEvent1; // Generic event that can be used by // any state to note if it has or has not // yet been triggered. long m_lNextBulletTime; // Next time a bullet can be fired. long m_lLastShotTime; // Last time the dude was shot. long m_lLastYellTime; // Last time the dude yelled in pain // from being shot or something. long m_lNextIdleTime; // Idle animation timer. WeaponType m_weapontypeCur; // Dude's current weapon type. WeaponType m_weaponShooting; // The weapon type the dude is currently // shooting (or about to shoot). CCrawler m_crawler; // The device that allows us to slide // along edges and stuff. U16 m_u16IdChild; // ID of generic child item. // Used by State_PickUp currently. CSprite2 m_TargetSprite; // Targeting sprite to show what he is aiming // at. U16 m_u16KillerId; // Instance ID of our killer. U8 m_u8LastEvent; // Last anim event. U16 m_idVictim; // Instance ID of victim to be executed or // used as human shield. bool m_bDead; // true, if dead; false otherwise. double m_dLastCrawledToPosX; // Last position successfully crawled to. double m_dLastCrawledToPosZ; // Last position successfully crawled to. bool m_bInvincible; // Dude does not loose health when invincible. // Tracks file counter so we know when to load/save "common" data static short ms_sFileCount; //--------------------------------------------------------------------------- // Static Variables //--------------------------------------------------------------------------- public: // "Constant" values that we want to be able to tune using the editor static double ms_dAccUser; // Acceleration due to user static double ms_dAccDrag; // Drag on user velocity. static double ms_dMaxVelFore; // Maximum forward velocity static double ms_dMaxVelBack; // Maximum backward velocity static double ms_dMaxVelForeFast; // Maximum forward velocity static double ms_dMaxVelBackFast; // Maximum backward velocity static double ms_dDegPerSec; // Degrees of rotation per second static double ms_dVertVelJump; // Velocity of jump. // Weapon details database. static WeaponDetails ms_awdWeapons[NumWeaponTypes]; // Dude's default stockpile. static CStockPile ms_stockpileDefault; // Dude's default weapon collision bits ie. what its weapons can hit static U32 ms_u32CollideBitsInclude; // Bits that determine a collision static U32 ms_u32CollideBitsDontcare; // Bits that are ignored for collision static U32 ms_u32CollideBitsExclude; // Bits that invalidate collision //--------------------------------------------------------------------------- // Constructor(s) / destructor //--------------------------------------------------------------------------- protected: // Constructor CDude(CRealm* pRealm); public: // Destructor ~CDude(); //--------------------------------------------------------------------------- // Required static functions //--------------------------------------------------------------------------- public: // Construct object static short Construct( // Returns 0 if successfull, non-zero otherwise CRealm* pRealm, // In: Pointer to realm this object belongs to CThing** ppNew) // Out: Pointer to new object { short sResult = 0; *ppNew = new CDude(pRealm); if (*ppNew == 0) { sResult = -1; TRACE("CDude::Construct(): Couldn't construct CDude!\n"); } return sResult; } //--------------------------------------------------------------------------- // Required virtual functions (implimenting them as inlines doesn't pay!) //--------------------------------------------------------------------------- public: // Load object (should call base class version!) short Load( // Returns 0 if successfull, non-zero otherwise RFile* pFile, // In: File to load from bool bEditMode, // In: True for edit mode, false otherwise short sFileCount, // In: File count (unique per file, never 0) ULONG ulFileVersion); // In: File version being loaded. // Save object (should call base class version!) short Save( // Returns 0 if successfull, non-zero otherwise RFile* pFile, // In: File to save to short sFileCount); // In: File count (unique per file, never 0) // Startup object short Startup(void); // Returns 0 if successfull, non-zero otherwise // Shutdown object short Shutdown(void); // Returns 0 if successfull, non-zero otherwise // Suspend object void Suspend(void); // Resume object void Resume(void); // Update object void Update(void); // Render object void Render(void); // Called by editor to init new object at specified position short EditNew( // Returns 0 if successfull, non-zero otherwise short sX, // In: New x coord short sY, // In: New y coord short sZ); // In: New z coord // Called by editor to modify object short EditModify(void); // Returns 0 if successfull, non-zero otherwise //--------------------------------------------------------------------------- // Other functions //--------------------------------------------------------------------------- public: // Return the X position double GetX() {return m_dX;}; // Return the Y position double GetY() {return m_dY;}; // Return the Z position double GetZ() {return m_dZ;}; // Return the dude's hit points short GetHealth() {return m_stockpile.m_sHitPoints;}; // Sets a new state based on supplied state enum. Will set animation ptr // to proper animation for state and reset animation timer. bool SetState( // Returns true if new state realized, false otherwise. State state); // New state. // Gets info on specified weapon. void GetWeaponInfo( // Returns nothing. WeaponType weapon, // In: Weapon type to query. ClassIDType* pidWeapon, // Out: CThing class ID of weapon. short** ppsNum); // Out: Ptr to the weapon's counter. // Determines if supplied position is valid tweaking it if necessary. virtual // Overridden here. bool MakeValidPosition( // Returns true, if new position was validitable. // Returns false, if could not reach new position. double* pdNewX, // In: x position to validate. // Out: New x position. double* pdNewY, // In: y position to validate. // Out: New y position. double* pdNewZ, // In: z position to validate. // Out: New z position. short sVertTolerance = 0); // Vertical tolerance. // Shoot current weapon. // This should be done when the character releases the weapon it's // shooting. virtual // Overriden here. CWeapon* ShootWeapon( // Returns the weapon ptr or NULL. CSmash::Bits bitsInclude, CSmash::Bits bitsDontcare, CSmash::Bits bitsExclude); CWeapon* ShootWeapon(void); // Returns the weapoin ptr or NULL. // Determine if the dude is dead. bool IsDead(void) // Returns true, if dead; false otherwise. { return m_bDead; } // Message handling functions //////////////////////////////////////////// // Handles a Shot_Message. virtual // Override to implement additional functionality. // Call base class to get default functionality. void OnShotMsg( // Returns nothing. Shot_Message* pshotmsg); // In: Message to handle. // Handles an Explosion_Message. virtual // Override to implement additional functionality. // Call base class to get default functionality. void OnExplosionMsg( // Returns nothing. Explosion_Message* pexplosionmsg); // In: Message to handle. // Handles a Burn_Message. virtual // Override to implement additional functionality. // Call base class to get default functionality. void OnBurnMsg( // Returns nothing. Burn_Message* pburnmsg); // In: Message to handle. // Handles an ObjectDelete_Message. virtual // Override to implement additional functionality. // Call base class to get default functionality. void OnDeleteMsg( // Returns nothing. ObjectDelete_Message* pdeletemsg); // In: Message to handle. // Handles a Suicide_Message. virtual // Override to implement additional functionality. // Call base class to get default functionality. void OnSuicideMsg( // Returns nothing. Suicide_Message* psuicidemsg); // In: Message to handle. // Handles a PutMeDown_Message virtual // Override to implement additional functionality // Call base calss to get default functionality void OnPutMeDownMsg( // Returns nothing PutMeDown_Message* pputmedownmsg); //In: Message to handle // State handling functions ///////////////////////////////////////////// // Implements basic functionality while being blown up and returns true // until the state is completed. virtual // Overriden here. bool WhileBlownUp(void); // Returns true until state is complete. // Execute the nearest writhing guy, if any. void OnExecute(void); // Returns nothing. // Implements one-time functionality for when a weapon is destroyed while // we were moving it (i.e., before we let go or ShootWeapon()'ed it). // This can occur when a weapon, while traveling along our rigid body, // enters terrain. virtual // Overriden here. void OnWeaponDestroyed(void); // Other functions ////////////////////////////////////////////////////// // Revive a dead dude. This is a more graceful way than just setting // his state. This will restore hitpoints and make him animate to a // standing position. If bWarp is true, he'll use a warp when available. void Revive( // Returns nothing. bool bWarpIn = true); // In: true, to warp in, false to just get up. // Initialize dude. Must be done before dude is used. short Init(void); // Returns 0 if successfull, non-zero otherwise // Next weapon please. void NextWeapon(void); // Previous weapon please. void PrevWeapon(void); // Set the current weapon. bool SetWeapon( // Returns true if weapon could be set as current. WeaponType weapon, // In: New weapon to attempt to make the current. bool bSetIfNoAmmo = true); // In: true to set weapon (even if no ammo). // Get the current weapon the dude has ready to use. WeaponType GetCurrentWeapon(void); //--------------------------------------------------------------------------- // Internal functions //--------------------------------------------------------------------------- protected: // Kill dude void Kill(void); // Get all required resources short GetResources(void); // Returns 0 if successfull, non-zero otherwise // Free all resources void FreeResources(void); // Update the animation radius based on current frame. void UpdateRadius(void); // Returns and accepts nothing. // Fire specified weapon type. void ArmWeapon( // Returns nothing. WeaponType weapon = CurrentWeapon); // In: Weapon to fire. // Receive damage. void Damage( // Returns nothing. short sHitPoints, // Hit points of damage to do. U16 u16ShooterId); // In: Thing responsible for damage. // Start the brain splat anim on its way. void StartBrainSplat(void); // Returns nothing. // Attempts user motivated state transitions. void ProcessInput( // Returns nothing. double* pdMaxForeVel, // Out: Maximum forward velocity. double* pdMaxBackVel, // Out: Maximum backward velocity. short* psStrafeAngle); // Out: Strafe angle. // Applies accelerations, velocities, reacts to terrain obstructions, etc. void ProcessForces( // Returns nothing. long lCurTime, // In: Current game time. double dMaxForeVel, // Out: Maximum forward velocity. double dMaxBackVel, // Out: Maximum backward velocity. short sStrafeAngle); // Out: Strafe angle. // If the targeting aid is enabled, this function will look for a target // and if it finds one, it will show the Targeting sprite on the target. void ShowTarget(void); // Drop a powerup with the settings described by the specified stockpile. CPowerUp* DropPowerUp( // Returns new powerup on success; NULL on failure. CStockPile* pstockpile, // In: Settings for powerup. bool bCurWeaponOnly); // In: true, if only the current weapon should be // in the powerup; false, if all. // Create a cheat powerup. CPowerUp* CreateCheat( // Returns new powerup on success; NULL on failure. CStockPile* pstockpile); // In: Settings for powerup. // Play a step noise if the event is different from the last. void PlayStep(void); // Returns nothing. // Find someone to execute. bool FindExecutee(void); // Returns true, if we found one; false, otherwise. // Track executee. bool TrackExecutee( // Returns true to persist, false, if we lost the target. double dSeconds); // In: Seconds since last iteration. // Take a powerup. void TakePowerUp( // Returns nothing. CPowerUp** pppowerup); // In: Power up to take from. // Out: Ptr to powerup, if it persisted; NULL otherwise. // Break a powerup open and toss it. void TossPowerUp( // Returns nothing. CPowerUp* ppowerup, // In: Powerup to toss. short sVelocity); // In: Velocity of toss. // Make sure warp can access this function. friend class CWarp; // Sets the dude's position. It is very important that the dude is not // moved by outside things, other than the warp. void SetPosition( // Returns nothing. double dX, // In: New position for dude. double dY, // In: New position for dude. double dZ); // In: New position for dude. // Get the next child flag item after the specified flag item. CFlag* GetNextFlag( // Returns the next flag item after pflag. CFlag* pflag); // In: The flag to get the follower of. // NULL for first child flag. // Drop all child flag items. void DropAllFlags( GameMessage* pmsg); // In: Message to pass to flags. }; #endif //DUDE_H //////////////////////////////////////////////////////////////////////////////// // EOF ////////////////////////////////////////////////////////////////////////////////