diff options
Diffstat (limited to 'game/server/tf2/tf_obj.h')
| -rw-r--r-- | game/server/tf2/tf_obj.h | 492 |
1 files changed, 492 insertions, 0 deletions
diff --git a/game/server/tf2/tf_obj.h b/game/server/tf2/tf_obj.h new file mode 100644 index 0000000..b53002d --- /dev/null +++ b/game/server/tf2/tf_obj.h @@ -0,0 +1,492 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Base Object built by a player +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef TF_OBJ_H +#define TF_OBJ_H +#ifdef _WIN32 +#pragma once +#endif + +#include "baseentity.h" +#include "tf_func_resource.h" +#include "ihasbuildpoints.h" +#include "baseobject_shared.h" +#include "info_vehicle_bay.h" + +class CBaseTFPlayer; +class CTFTeam; +class CRopeKeyframe; +class CBaseTechnology; +class CGrenadeObjectSapper; +class CObjectPowerPack; +class CVGuiScreen; +class CResourceZone; +class KeyValues; +class CObjectBuffStation; +struct animevent_t; + +#define OBJECT_REPAIR_RATE 10 // Health healed per second while repairing + +// Construction +#define OBJECT_CONSTRUCTION_INTERVAL 0.1 +#define OBJECT_CONSTRUCTION_STARTINGHEALTH 0.1 + + +extern ConVar object_verbose; +extern ConVar obj_child_range_factor; + +#if defined( _DEBUG ) +#define TRACE_OBJECT( str ) \ +if ( object_verbose.GetInt() ) \ +{ \ + Msg( "%s", str ); \ +} +#else +#define TRACE_OBJECT( string ) +#endif + + +// ------------------------------------------------------------------------ // +// Resupply object that's built by the player +// ------------------------------------------------------------------------ // +class CBaseObject : public CBaseCombatCharacter, public IHasBuildPoints +{ + DECLARE_CLASS( CBaseObject, CBaseCombatCharacter ); +public: + CBaseObject(); + + virtual void UpdateOnRemove( void ); + + DECLARE_SERVERCLASS(); + DECLARE_DATADESC(); + + virtual bool IsBaseObject( void ) const { return true; } + + virtual void BaseObjectThink( void ); + virtual void LostPowerThink( void ); + virtual CBaseTFPlayer *GetOwner( void ); + + // Creation + virtual void Precache(); + virtual void Spawn( void ); + virtual void Activate( void ); + void InitializeMapPlacedObject( void ); + + virtual void SetBuilder( CBaseTFPlayer *pBuilder, bool moveobjects = false ); + virtual void SetupTeamModel( void ) { return; } + virtual void SetType( int iObjectType ); + int ObjectType( ) const; + + virtual int BloodColor( void ) { return BLOOD_COLOR_MECH; } + + // Building + virtual float GetTotalTime( void ); + virtual void StartPlacement( CBaseTFPlayer *pPlayer ); + void StopPlacement( void ); + bool FindNearestBuildPoint( CBaseEntity *pEntity, Vector vecBuildOrigin, float &flNearestPoint, Vector &vecNearestBuildPoint ); + virtual bool CalculatePlacement( CBaseTFPlayer *pPlayer ); + bool CheckBuildPoint( Vector vecPoint, Vector &vecTrace, Vector *vecOutPoint=NULL ); + bool VerifyCorner( const Vector &vBottomCenter, float xOffset, float yOffset ); + virtual bool CheckBuildOrigin( CBaseTFPlayer *pPlayer, const Vector &vecBuildOrigin, bool bSnappedToPoint = false ); + void AttemptToFindPower( void ); + void AttemptToFindBuffStation( void ); + void AttemptToActivateBuffStation( void ); + virtual float GetNearbyObjectCheckRadius( void ) { return 30.0; } + bool UpdatePlacement( CBaseTFPlayer *pPlayer ); + virtual bool ShouldAttachToParent( void ) { return true; } + void SetVehicleBay( CVGuiScreenVehicleBay *pBay ) { m_hVehicleBay = pBay; } + + // Sort of a hack for walkers - vehicles are pre-rotated by 90 degrees and walkers need to undo this. + virtual void AdjustInitialBuildAngles(); + + // Exit points for mounted vehicles.... + virtual void GetExitPoint( CBaseEntity *pPlayer, int nBuildPoint, Vector *pExitPoint, QAngle *pAngles ); + + // I've finished building the specified object on the specified build point + virtual int FindObjectOnBuildPoint( CBaseObject *pObject ); + + // This gives an object a chance to prevent itself from being built when the user clicks the + // attack button during placement. Barbed wire uses this to change which object the barbed wire + // is attached to. + virtual bool PreStartBuilding(); + + virtual bool StartBuilding( CBaseEntity *pPlayer ); + void BuildingThink( void ); + void SetControlPanelsActive( bool bState ); + virtual void FinishedBuilding( void ); + bool IsBuilding( void ) { return m_bBuilding; }; + bool IsPlacing( void ) { return m_bPlacing; }; + bool MustBeBuiltInResourceZone( void ) const; + bool MustBeBuiltInConstructionYard( void ) const; + virtual bool MustNotBeBuiltInConstructionYard( void ) const; + bool MustBeBuiltOnAttachmentPoint( void ) const; + + void AlignToGround( Vector vecOrigin ); + + // Returns information about the various control panels + virtual void GetControlPanelInfo( int nPanelIndex, const char *&pPanelName ); + virtual void GetControlPanelClassName( int nPanelIndex, const char *&pPanelName ); + + // Client commands sent by clicking on various panels.... + // NOTE: pArg->Argv(0) == pCmd, pArg->Argv(1) == the first argument + virtual bool ClientCommand( CBaseTFPlayer *pSender, const CCommand &args ); + + // Damage + void SetHealth( float flHealth ); + virtual void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr ); + virtual int OnTakeDamage( const CTakeDamageInfo &info ); + bool PassDamageOntoChildren( const CTakeDamageInfo &info, float *flDamageLeftOver ); + virtual float GetRepairTime( void ); + virtual bool UpdateRepair( float flRepairTime ); + virtual bool Repair( float flHealth ); + + // Powerups + virtual bool CanPowerupEver( int iPowerup ); + virtual bool CanPowerupNow( int iPowerup ); + virtual void PowerupStart( int iPowerup, float flAmount, CBaseEntity *pAttacker, CDamageModifier *pDamageModifier ); + virtual void PowerupEnd( int iPowerup ); + + // Destruction + virtual bool ShouldAutoRemove( void ); + virtual void Killed( void ); + virtual void DestroyObject( void ); // Silent cleanup + virtual bool IsDying( void ) { return m_bDying; } + + // Data + virtual Class_T Classify( void ); + virtual int GetType( void ); + virtual CBaseTFPlayer *GetBuilder( void ); + virtual CBaseTFPlayer *GetOriginalBuilder( void ); + CTFTeam *GetTFTeam( void ) { return (CTFTeam*)GetTeam(); }; + + // ID functions + virtual bool IsAnUpgrade( void ) { return false; } + virtual bool IsAVehicle( void ) { return false; } + virtual bool IsSentrygun() { return false; } + virtual bool WantsCoverFromSentryGun() { return false; } + virtual bool WantsCover() { return false; } + + // Inputs + void InputSetHealth( inputdata_t &inputdata ); + void InputAddHealth( inputdata_t &inputdata ); + void InputRemoveHealth( inputdata_t &inputdata ); + void InputSetMinDisabledHealth( inputdata_t &inputdata ); + void InputSetSolidToPlayer( inputdata_t &inputdata ); + + // Pickup + virtual int ObjectCaps( void ); + virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); + virtual void PickupObject( void ); + virtual bool CanBeRemovedBy( CBaseTFPlayer *pPlayer ); + virtual bool CanBeRotatedBy( CBaseTFPlayer *pPlayer ); + + virtual void ChangeTeam( int iTeamNum ) OVERRIDE; // Assign this entity to a team. + + virtual void ChangeBuilder( CBaseTFPlayer *pNewBuilder, bool moveobjects ); + virtual const char *GetWeaponClassnameForObject( void ); + virtual void AddItemsNeededForObject( CBaseTFPlayer *pNewOwner ); + + // Objects that are damaged/disabled can return false here when checked for being available + virtual bool ComputeEMPDamageState( void ) { return true; } + + // Handling object inactive + virtual bool ShouldBeActive( void ); + + // Technology + virtual void GainedNewTechnology( CBaseTechnology *pTechnology ); + + // Sappers + bool HasSapper( void ); + bool HasSapperFromPlayer( CBaseTFPlayer *pPlayer ); + void AddSapper( CGrenadeObjectSapper *pSapper ); + void RemoveSapper( CGrenadeObjectSapper *pSapper ); + + // Called when the builder rotates this object... + virtual void ObjectMoved( ); + + // Minibase stuff + virtual bool WasMapPlaced( void ); + virtual CRopeKeyframe *ConnectCableTo( CBaseObject *pObject, int iLocalAttachment, int iTargetAttachment ); + virtual bool HasCableTo( CBaseObject *pObject ); + virtual int GetCableAttachment( void ); + + // Returns the object flags + int GetObjectFlags() const { return m_fObjectFlags; } + void SetObjectFlags( int flags ) { m_fObjectFlags = flags; } + + CResourceZone *GetResourceZone() { return m_hResourceZone.Get(); } + int RopeCount() const { return m_aRopes.Count(); } + + // Power handling (Human objects need power to operate) + bool IsPowered( void ); + void SetPowerPack( CObjectPowerPack *pPack ); + CObjectPowerPack *GetPowerPack( void ) { return m_hPowerPack; }; + + void AttemptToGoActive( void ); + virtual void OnGoActive( void ); + virtual void OnGoInactive( void ); + + // Buffed objects (objects that connect to a medic's buff station) + bool IsHookedAndBuffed( void ); + virtual bool CanBeHookedToBuffStation( void ); + void SetBuffStation( CObjectBuffStation *pBuffStation, bool bPlacing ); + CObjectBuffStation *GetBuffStation( void ); + + virtual void BuffStationActivate( void ); + virtual void BuffStationDeactivate( void ); + + // Deterioration + void StartDeteriorating( void ); + void StopDeteriorating( void ); + bool IsDeteriorating( void ) { return m_bDeteriorating; }; + void DeterioratingThink( void ); + + // Disabling + void SetDisabled( bool bDisabled ); + bool IsDisabled( void ) { return m_bDisabled; } + + // Animation + virtual void PlayStartupAnimation( void ); + + Activity GetActivity( ) const; + void SetActivity( Activity act ); + void SetObjectSequence( int sequence ); + + virtual void OnActivityChanged( Activity act ); + + // Object points + void SpawnObjectPoints( void ); + + // Derive to customize an object's attached version + virtual void SetupAttachedVersion( void ) { return; } + virtual void SetupUnattachedVersion( void ) { return; } + + QAngle ConvertAbsAnglesToLocal( QAngle vecLocalAngles ); + +public: + // VulnerablePoints + void CreateVulnerablePoints( void ); + void AddVulnerablePoint( const char* szHitboxName, float Multiplier ); + float FindVulnerablePointMultiplier( int nGroup, int nBox ); + + // Build points + CUtlVector<VulnerablePoint_t> m_VulnerablePoints; + + virtual bool TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ); + +public: + // Client/Server shared build point code + void CreateBuildPoints( void ); + void AddAndParseBuildPoint( int iAttachmentNumber, KeyValues *pkvBuildPoint ); + virtual int AddBuildPoint( int iAttachmentNum ); + virtual void AddValidObjectToBuildPoint( int iPoint, int iObjectType ); + virtual CBaseObject *GetBuildPointObject( int iPoint ); + bool IsBuiltOnAttachment( void ) { return (m_hBuiltOnEntity.Get() != NULL); } + void AttachObjectToObject( const CBaseEntity *pEntity, int iPoint, Vector &vecOrigin ); + void DetachObjectFromObject( void ); + CBaseObject *GetParentObject( void ); + void SetBuildPointPassenger( int iPoint, int iPassenger ); + int GetBuildPointPassenger( int iPoint ) const; + + virtual float GetSapperAttachTime( void ); + +// IHasBuildPoints +public: + virtual int GetNumBuildPoints( void ) const; + virtual bool GetBuildPoint( int iPoint, Vector &vecOrigin, QAngle &vecAngles ); + virtual int GetBuildPointAttachmentIndex( int iPoint ) const; + virtual bool CanBuildObjectOnBuildPoint( int iPoint, int iObjectType ); + virtual void SetObjectOnBuildPoint( int iPoint, CBaseObject *pObject ); + virtual float GetMaxSnapDistance( int iBuildPoint ); + virtual bool ShouldCheckForMovement( void ) { return true; } + virtual int GetNumObjectsOnMe( void ); + virtual CBaseEntity *GetFirstObjectOnMe( void ); + virtual CBaseObject *GetObjectOfTypeOnMe( int iObjectType ); + virtual void RemoveAllObjects( void ); + + +// IServerNetworkable. +public: + + virtual int ShouldTransmit( const CCheckTransmitInfo *pInfo ); + virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways ); + + +protected: + // Clean off the object of offensive material, returns true if it found anything + bool RemoveEnemyAttachments( CBaseEntity *pActivator ); + void RemoveAnalyzer( CBaseEntity *pRemovingEntity ); + void RemoveAllSappers( CBaseEntity *pRemovingEntity ); + + void GiveNamedTechnology( CBaseTFPlayer *pRecipient, const char *techname ); + + // Show/hide vgui screens. + bool ShowVGUIScreen( int panelIndex, bool bShow ); + +private: + void DetermineAnimation( void ); + + // Spawns the various control panels + void SpawnControlPanels(); + + // Purpose: Spawn any objects specified inside the mdl + void SpawnEntityOnBuildPoint( const char *pEntityName, int iAttachmentNumber ); + + // Various commands sent by control panels + void DismantleCommand( CBaseTFPlayer *pSender ); + void YawCommand( CBaseTFPlayer *pSender, float flYaw ); + void TakeControlCommand( CBaseTFPlayer *pSender ); + +protected: + enum OBJSOLIDTYPE + { + SOLID_TO_PLAYER_USE_DEFAULT = 0, + SOLID_TO_PLAYER_YES, + SOLID_TO_PLAYER_NO, + }; + + bool IsSolidToPlayers( void ) const; + + // object flags.... + CNetworkVar( int, m_fObjectFlags ); + CNetworkHandle( CBaseTFPlayer, m_hBuilder ); + + // Zone we're in (valid only for objects that sit in zones) + CNetworkHandle( CResourceZone, m_hResourceZone ); + + // Combat Objects + char *m_szAmmoName; // Ammo used by players to build me + + // Cables + CUtlVector< CHandle<CRopeKeyframe> > m_aRopes; + + // Placement + Vector m_vecBuildOrigin; + Vector m_vecBuildMins; + Vector m_vecBuildMaxs; + CNetworkHandle( CBaseEntity, m_hBuiltOnEntity ); + int m_iBuiltOnPoint; + + bool m_bInvulnerable; + bool m_bCantDie; + float m_flRepairMultiplier; + bool m_bDying; + + // Outputs + COutputEvent m_OnDestroyed; + COutputEvent m_OnDamaged; + COutputEvent m_OnRepaired; + + COutputEvent m_OnBecomingDisabled; + COutputEvent m_OnBecomingReenabled; + + COutputFloat m_OnObjectHealthChanged; + + // Control panel + typedef CHandle<CVGuiScreen> ScreenHandle_t; + CUtlVector<ScreenHandle_t> m_hScreens; + +private: + // Make sure we pick up changes to these. + IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_iHealth ); + IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_takedamage ); + + Activity m_Activity; + + CNetworkVar( int, m_iObjectType ); + + + // True if players shouldn't do collision avoidance, but should just collide exactly with the object. + OBJSOLIDTYPE m_SolidToPlayers; + void SetSolidToPlayers( OBJSOLIDTYPE stp, bool force = false ); + + // True if this was a map placed object, not a player built one + bool m_bWasMapPlaced; + + // Disabled + CNetworkVar( bool, m_bDisabled ); + + // Vehicle bays + CHandle<CVGuiScreenVehicleBay> m_hVehicleBay; + + // Building + CNetworkVar( bool, m_bPlacing ); // True while the object's being placed + CNetworkVar( bool, m_bBuilding ); // True while the object's still constructing itself + float m_flConstructionTimeLeft; // Current time left in construction + float m_flTotalConstructionTime; // Total construction time (the value of GetTotalTime() at the time construction + // started, ie, incase you teleport out of a construction yard) + + CNetworkVar( float, m_flPercentageConstructed ); // Used to send to client + float m_flHealth; // Health during construction. Needed a float due to small increases in health. + + // Repair capping + float m_flLastRepairTime; + float m_flNextRepairMultiplier; + float m_flRepairedSinceLastTime; + + // Sappers on me + CNetworkVar( bool, m_bHasSapper ); + typedef CHandle<CGrenadeObjectSapper> SapperHandle; + CUtlVector< SapperHandle > m_hSappers; + + // Power handling (Human objects need power to operate) + CHandle< CObjectPowerPack > m_hPowerPack; + + // Buff Station + CHandle< CObjectBuffStation > m_hBuffStation; + bool m_bBuffActivated; + + // Deterioration + CNetworkVar( bool, m_bDeteriorating ); + float m_flStartedDeterioratingAt; + CHandle<CBaseTFPlayer> m_hOriginalBuilder; + + // Build points + CUtlVector<BuildPoint_t> m_BuildPoints; + + // Store the last time I took damage from an enemy. Use this to know whether to drop resources + // when I die, because I only want to drop resources if I was "destroyed" by an enemy, not if I deteriorated. + float m_flLastRealDamage; + + // Amount of resources the player who built me paid for me + int m_iAmountPlayerPaidForMe; + + // Attack notification sounds + string_t m_iszUnderAttackSound; + + // If non-zero then if health gets below this amount, the object becomes disabled + float m_flMinDisableHealth; + + // If not NULL, then when going disabled, swith to this model + string_t m_iszDisabledModel; + string_t m_iszEnabledModel; +}; + +inline bool CBaseObject::CanBeHookedToBuffStation( void ) +{ + return false; +} + +inline CObjectBuffStation *CBaseObject::GetBuffStation( void ) +{ + return m_hBuffStation.Get(); +} + +inline void CBaseObject::BuffStationActivate( void ) +{ + m_bBuffActivated = true; +} + +inline void CBaseObject::BuffStationDeactivate( void ) +{ + m_bBuffActivated = false; +} + +extern short g_sModelIndexFireball; // holds the index for the fireball + + +#endif // TF_OBJ_H |