514 lines
17 KiB
C++
514 lines
17 KiB
C++
//========= 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
|