diff options
Diffstat (limited to 'game/server/tf/tf_obj.h')
| -rw-r--r-- | game/server/tf/tf_obj.h | 513 |
1 files changed, 513 insertions, 0 deletions
diff --git a/game/server/tf/tf_obj.h b/game/server/tf/tf_obj.h new file mode 100644 index 0000000..ecde348 --- /dev/null +++ b/game/server/tf/tf_obj.h @@ -0,0 +1,513 @@ +//========= 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 "ihasbuildpoints.h" +#include "iscorer.h" +#include "baseobject_shared.h" +#include "utlmap.h" +#include "props_shared.h" +#include "tf_achievementdata.h" +//#include "tf_player.h" + +class CTFPlayer; +class CTFTeam; +class CRopeKeyframe; +class CVGuiScreen; +class KeyValues; +class CTFWrench; +class CTFAmmoPack; +class CObjectSapper; +struct animevent_t; + +#define WRENCH_DMG_VS_SAPPER 65 +#define OBJ_MAX_UPGRADE_LEVEL 3 +#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 + +#define SF_BASEOBJ_INVULN (1<<1) +#define LAST_SF_BASEOBJ SF_BASEOBJ_INVULN + +DECLARE_AUTO_LIST( IBaseObjectAutoList ); + +enum +{ + SHIELD_NONE = 0, + SHIELD_NORMAL, // 33% damage taken, no tracking + SHIELD_MAX, // 10% damage taken, tracking +}; + +#define SHIELD_NORMAL_VALUE 0.33f +#define SHIELD_MAX_VALUE 0.10f + +// ------------------------------------------------------------------------ // +// Resupply object that's built by the player +// ------------------------------------------------------------------------ // +class CBaseObject : public CBaseCombatCharacter, public IHasBuildPoints, public IScorer, public IBaseObjectAutoList +{ + 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 CTFPlayer *GetOwner( void ); + + // Creation + virtual void Precache(); + virtual void Spawn( void ); + virtual void FirstSpawn( void ); + + virtual bool ShouldCollide( int collisionGroup, int contentsMask ) const; + + virtual void SetBuilder( CTFPlayer *pBuilder ); + virtual void SetType( int iObjectType ); + int ObjectType( ) const; + + virtual int BloodColor( void ) { return BLOOD_COLOR_MECH; } + + // Building + virtual float GetTotalTime( void ); + virtual void StartPlacement( CTFPlayer *pPlayer ); + void StopPlacement( void ); + bool FindNearestBuildPoint( CBaseEntity *pEntity, CBasePlayer *pBuilder, float &flNearestPoint, Vector &vecNearestBuildPoint, bool bIgnoreChecks = false ); + bool FindBuildPointOnPlayer( CTFPlayer *pTFPlayer, CBasePlayer *pBuilder, float &flNearestPoint, Vector &vecNearestBuildPoint ); + bool VerifyCorner( const Vector &vBottomCenter, float xOffset, float yOffset ); + virtual float GetNearbyObjectCheckRadius( void ) { return 30.0; } + bool UpdatePlacement( void ); + bool UpdateAttachmentPlacement( CBaseObject *pObjectOverride = NULL ); + bool IsValidPlacement( void ) const; + + virtual bool IsPlacementPosValid( void ); + bool FindSnapToBuildPos( CBaseObject *pObjectOverride = NULL ); + + void ReattachChildren( void ); + + // I've finished building the specified object on the specified build point + virtual int FindObjectOnBuildPoint( CBaseObject *pObject ); + + virtual bool StartBuilding( CBaseEntity *pPlayer ); + virtual void SetStartBuildingModel( void ) {} + void BuildingThink( void ); + void SetControlPanelsActive( bool bState ); + virtual void FinishedBuilding( void ); + bool IsBuilding( void ) { return m_bBuilding; } + bool IsPlacing( void ) { return m_bPlacing; } + virtual bool IsUpgrading( void ) const { return false; } + bool MustBeBuiltOnAttachmentPoint( void ) const; + bool IsCarried( void ) const { return m_bCarried; } + virtual void OnEndBeingCarried( CBaseEntity *pBuilder ) {} + + // 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( CTFPlayer *pSender, const CCommand &args ); + + // Damage + void SetHealth( float flHealth ); + float GetHealth() { return m_flHealth; } + virtual void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator ); + virtual int OnTakeDamage( const CTakeDamageInfo &info ); + bool PassDamageOntoChildren( const CTakeDamageInfo &info, float *flDamageLeftOver ); + virtual bool Construct( float flHealth ); + + void OnConstructionHit( CTFPlayer *pPlayer, CTFWrench *pWrench, Vector hitLoc ); + virtual float GetConstructionMultiplier( void ); + + // Destruction + virtual void DetonateObject( void ); + virtual bool ShouldAutoRemove( void ); + virtual void Explode( void ); + virtual void Killed( const CTakeDamageInfo &info ); + virtual void DestroyObject( void ); // Silent cleanup + virtual bool IsDying( void ) { return m_bDying; } + void DestroyScreens( void ); + + // Data + virtual Class_T Classify( void ); + virtual int GetType( void ) const; + virtual CTFPlayer *GetBuilder( void ) const; + CTFTeam *GetTFTeam( void ) { return (CTFTeam*)GetTeam(); }; + + // ID functions + virtual bool IsAnUpgrade( void ) { return false; } + virtual bool IsHostileUpgrade( void ) { return false; } // Attaches to enemy buildings + + // Inputs + void InputSetHealth( inputdata_t &inputdata ); + void InputAddHealth( inputdata_t &inputdata ); + void InputRemoveHealth( inputdata_t &inputdata ); + void InputSetSolidToPlayer( inputdata_t &inputdata ); + void InputSetBuilder( inputdata_t &inputdata ); + void InputShow( inputdata_t &inputdata ); + void InputHide( inputdata_t &inputdata ); + virtual void InputEnable( inputdata_t &inputdata ); + virtual void InputDisable( inputdata_t &inputdata ); + + // Wrench hits + virtual bool InputWrenchHit( CTFPlayer *pPlayer, CTFWrench *pWrench, Vector hitLoc ); + virtual bool OnWrenchHit( CTFPlayer *pPlayer, CTFWrench *pWrench, Vector hitLoc ); + virtual bool CheckUpgradeOnHit( CTFPlayer *pPlayer ); + virtual bool Command_Repair( CTFPlayer *pActivator, float flRepairMod ); + virtual void DoWrenchHitEffect( Vector hitLoc, bool bRepairHit, bool bUpgradeHit ); + + virtual bool ShouldBeMiniBuilding( CTFPlayer* pPlayer ); + virtual void MakeMiniBuilding( CTFPlayer* pPlayer ); + virtual void MakeDisposableBuilding( CTFPlayer *pPlayer ); + + virtual void ChangeTeam( int iTeamNum ) OVERRIDE; // Assign this entity to a team. + + // Handling object inactive + virtual bool ShouldBeActive( void ); + + // Sappers + CObjectSapper* GetSapper( void ); + bool HasSapper( void ); + bool IsPlasmaDisabled( void ); + void OnAddSapper( void ); + void OnRemoveSapper( void ); + + // Returns the object flags + int GetObjectFlags() const { return m_fObjectFlags; } + void SetObjectFlags( int flags ) { m_fObjectFlags = flags; } + + virtual void OnGoActive( void ); + virtual void OnGoInactive( void ); + + // Disabling + bool IsDisabled( void ) { return m_bDisabled || m_bCarried; } + virtual void UpdateDisabledState( void ); + void SetDisabled( bool bDisabled ); + virtual void OnStartDisabled( void ); + virtual void OnEndDisabled( void ); + void SetPlasmaDisabled( float flDuration ); + + // Animation + virtual void PlayStartupAnimation( void ); + + Activity GetActivity( ) const; + void SetActivity( Activity act ); + void SetObjectSequence( int sequence ); + + // Object points + void SpawnObjectPoints( void ); + + // Derive to customize an object's attached version + virtual void SetupAttachedVersion( void ) { return; } + + virtual int DrawDebugTextOverlays( void ); + + void RotateBuildAngles( void ); + + virtual bool ShouldPlayersAvoid( void ); + + void IncrementKills( void ) { m_iKills++; } + int GetKills() { return m_iKills; } + + void IncrementAssists( void ) { m_iAssists++; } + int GetAssists() { return m_iAssists; } + + void CreateObjectGibs( void ); + CTFAmmoPack* CreateAmmoPack( const char *pchModel, int nMetal ); + virtual void SetModel( const char *pModel ); + + const char *GetResponseRulesModifier( void ); + + // Map Placed + virtual void Activate( void ); + virtual void InitializeMapPlacedObject( void ); + + bool CannotDie() const { return m_bCannotDie; } + void SetCannotDie( bool bCannotDie ) { m_bCannotDie = bCannotDie; } + + // Upgrading + virtual bool CanBeUpgraded( CTFPlayer *pPlayer ); + virtual void StartUpgrading( void ); + virtual void FinishUpgrading( void ); + void UpgradeThink( void ); + virtual int GetUpgradeLevel( void ) const { return m_iUpgradeLevel; } + int GetUpgradeMetal( void ) const { return m_iUpgradeMetal; } + int GetHighestUpgradeLevel( void ) { return Min( (int)m_iHighestUpgradeLevel, GetMaxUpgradeLevel() ); } + void SetHighestUpgradeLevel( int nLevel ) { m_iHighestUpgradeLevel = Min( nLevel, GetMaxUpgradeLevel() ); } + void ApplyHealthUpgrade( void ); + virtual int GetBaseHealth( void ) = 0; + void DoQuickBuild( bool bForceMax = false ); + bool ShouldQuickBuild( void ); + void DoReverseBuild( void ); + float GetReversesBuildingConstructionSpeed( void ); + virtual int GetMaxUpgradeLevel( void ) { return OBJ_MAX_UPGRADE_LEVEL; } + + // Carrying + virtual void MakeCarriedObject( CTFPlayer *pCarrier ); + virtual void DropCarriedObject( CTFPlayer* pCarrier ); + + void ForceQuickBuild() { m_bForceQuickBuild = true; } + + virtual int GetMiniBuildingStartingHealth( void ) { return 100; } + + virtual int GetMaxHealthForCurrentLevel( void ); + bool IsUsingReverseBuild( void ){ return ( GetReversesBuildingConstructionSpeed() != 0.0f ); } + void ResetPlacement( void ); + + virtual bool TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ); + + // IScorer interface + virtual CBasePlayer *GetScorer( void ) { return ( CBasePlayer *)GetBuilder(); } + virtual CBasePlayer *GetAssistant( void ) { return NULL; } + + // Achievement tracking + // Achievement data storage + CAchievementData m_AchievementData; + + // 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); } + CBaseEntity *GetBuiltOnObject( void ){ return m_hBuiltOnEntity.Get(); } + void AttachObjectToObject( CBaseEntity *pEntity, int iPoint, Vector &vecOrigin ); + virtual void DetachObjectFromObject( void ); + CBaseObject *GetParentObject( void ); + CBaseEntity *GetParentEntity( void ); + + virtual void SetObjectMode( int iVal ) { m_iObjectMode = iVal; } + int GetObjectMode( void ) const { return m_iObjectMode; } + + float GetConstructionStartTime( void ) { return m_flConstructionStartTime; } + +// IHasBuildPoints + 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(); + virtual CBaseEntity *GetFirstFriendlyObjectOnMe( void ); + virtual CBaseObject *GetObjectOfTypeOnMe( int iObjectType ); + virtual void RemoveAllObjects( void ); + +// IServerNetworkable. + virtual int UpdateTransmitState( void ); + virtual int ShouldTransmit( const CCheckTransmitInfo *pInfo ); + virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways ); + + bool IsMiniBuilding( void ) const { return m_bMiniBuilding; } + bool IsDisposableBuilding( void ) const { return m_bDisposableBuilding; } + + virtual bool ShouldBlockNav() const OVERRIDE { return false; } + + bool IsMapPlaced( void ){ return m_bWasMapPlaced; } + + virtual int GetShieldLevel() { return SHIELD_NONE; } + + virtual bool CanBeRepaired() const { return !IsDisposableBuilding(); } +protected: + + virtual bool CanBeUpgraded() const { return !( IsDisposableBuilding() || IsMiniBuilding() ); } + + virtual int GetUpgradeMetalRequired(); + + // Show/hide vgui screens. + bool ShowVGUIScreen( int panelIndex, bool bShow ); + + // Spawns the various control panels + void SpawnControlPanels(); + + virtual void DetermineAnimation( void ); + virtual void DeterminePlaybackRate( void ); + + void UpdateDesiredBuildRotation( float flFrameTime ); + + bool CalculatePlacementPos( void ); + bool EstimateValidBuildPos( void ); + +private: + // Purpose: Spawn any objects specified inside the mdl + void SpawnEntityOnBuildPoint( const char *pEntityName, int iAttachmentNumber ); + + //bool TestPositionForPlayerBlock( Vector vecBuildOrigin, CBasePlayer *pPlayer ); + //void RecursiveTestBuildSpace( int iNode, bool *bNodeClear, bool *bNodeVisited ); + +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( CTFPlayer, m_hBuilder ); + + // Placement + Vector m_vecBuildOrigin; + Vector m_vecBuildCenterOfMass; + CNetworkVector( m_vecBuildMaxs ); + CNetworkVector( m_vecBuildMins ); + CNetworkHandle( CBaseEntity, m_hBuiltOnEntity ); + int m_iBuiltOnPoint; + + 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; + + // Map placed objects + CNetworkVar( bool, m_bWasMapPlaced ); + + float GetCarryDeployTime() { return m_flCarryDeployTime; } + +public: + // Upgrade Level ( 1, 2, 3 ) + CNetworkVar( int, m_iUpgradeLevel ); + CNetworkVar( int, m_iUpgradeMetal ); + CNetworkVar( int, m_iUpgradeMetalRequired ); + CNetworkVar( int, m_iHighestUpgradeLevel ); + int m_nDefaultUpgradeLevel; + float m_flUpgradeCompleteTime; // Time when the upgrade animation will complete + +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 ); + + CNetworkVar( int , m_iObjectMode ); + + // Disabled + CNetworkVar( bool, m_bDisabled ); + + // Building + CNetworkVar( bool, m_bPlacing ); // True while the object's being placed + CNetworkVar( bool, m_bBuilding ); // True while the object's still constructing itself + +protected: + 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) + float m_flConstructionStartTime; + +protected: + // Carried + CNetworkVar( bool, m_bCarried ); + CNetworkVar( bool, m_bCarryDeploy ); + + CNetworkVar( bool, m_bMiniBuilding ); + CNetworkVar( bool, m_bDisposableBuilding ); + + float m_flPlasmaDisableTime; + CNetworkVar( bool, m_bPlasmaDisable ); + +private: + int m_iHealthOnPickup; + float m_flCarryDeployTime; + + CNetworkVar( float, m_flPercentageConstructed ); // Used to send to client + float m_flHealth; // Health during construction. Needed a float due to small increases in health. + + // Sapper on me + CNetworkVar( bool, m_bHasSapper ); + + // Build points + CUtlVector<BuildPoint_t> m_BuildPoints; + + // Maps player ent index to repair expire time + struct constructor_t + { + float flHitTime; // Time this constructor last hit me + float flValue; // Speed value of this constructor. Defaults to 1.0, but some constructors are worth more. + }; + CUtlMap<int, constructor_t> m_ConstructorList; + + // Result of last placement test + bool m_bPlacementOK; // last placement state + + CNetworkVar( int, m_iKills ); + CNetworkVar( int, m_iAssists ); + + CNetworkVar( int, m_iDesiredBuildRotations ); // Number of times we've rotated, used to calc final rotation + float m_flCurrentBuildRotation; + + // Gibs. + CUtlVector<breakmodel_t> m_aGibs; + + CNetworkVar( bool, m_bServerOverridePlacement ); + + // for ACHIEVEMENT_TF_ENGINEER_TANK_DAMAGE + int m_iLifetimeDamage; + + bool m_bCannotDie; + bool m_bQuickBuild; + + // used when calculating the placement position + Vector m_vecBuildForward; + float m_flBuildDistance; + + bool m_bForceQuickBuild; +}; + +extern short g_sModelIndexFireball; // holds the index for the fireball + +#endif // TF_OBJ_H |