Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

513 lines
17 KiB

//========= 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