From f56bb35301836e56582a575a75864392a0177875 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20P=2E=20Tjern=C3=B8?= Date: Mon, 2 Dec 2013 19:31:46 -0800 Subject: Fix line endings. WHAMMY. --- mp/src/game/server/baseentity.cpp | 14948 ++++++++++++++++++------------------ 1 file changed, 7474 insertions(+), 7474 deletions(-) (limited to 'mp/src/game/server/baseentity.cpp') diff --git a/mp/src/game/server/baseentity.cpp b/mp/src/game/server/baseentity.cpp index 48f1a4a7..edc00977 100644 --- a/mp/src/game/server/baseentity.cpp +++ b/mp/src/game/server/baseentity.cpp @@ -1,7474 +1,7474 @@ -//========= Copyright Valve Corporation, All rights reserved. ============// -// -// Purpose: The base class from which all game entities are derived. -// -//===========================================================================// - -#include "cbase.h" -#include "globalstate.h" -#include "isaverestore.h" -#include "client.h" -#include "decals.h" -#include "gamerules.h" -#include "entityapi.h" -#include "entitylist.h" -#include "eventqueue.h" -#include "hierarchy.h" -#include "basecombatweapon.h" -#include "const.h" -#include "player.h" // For debug draw sending -#include "ndebugoverlay.h" -#include "physics.h" -#include "model_types.h" -#include "team.h" -#include "sendproxy.h" -#include "IEffects.h" -#include "vstdlib/random.h" -#include "baseentity.h" -#include "collisionutils.h" -#include "coordsize.h" -#include "animation.h" -#include "tier1/strtools.h" -#include "engine/IEngineSound.h" -#include "physics_saverestore.h" -#include "saverestore_utlvector.h" -#include "bone_setup.h" -#include "vcollide_parse.h" -#include "filters.h" -#include "te_effect_dispatch.h" -#include "AI_Criteria.h" -#include "AI_ResponseSystem.h" -#include "world.h" -#include "globals.h" -#include "saverestoretypes.h" -#include "SkyCamera.h" -#include "sceneentity.h" -#include "game.h" -#include "tier0/vprof.h" -#include "ai_basenpc.h" -#include "iservervehicle.h" -#include "eventlist.h" -#include "scriptevent.h" -#include "SoundEmitterSystem/isoundemittersystembase.h" -#include "UtlCachedFileData.h" -#include "utlbuffer.h" -#include "positionwatcher.h" -#include "movetype_push.h" -#include "tier0/icommandline.h" -#include "vphysics/friction.h" -#include -#include "datacache/imdlcache.h" -#include "ModelSoundsCache.h" -#include "env_debughistory.h" -#include "tier1/utlstring.h" -#include "utlhashtable.h" - -#if defined( TF_DLL ) -#include "tf_gamerules.h" -#endif - -// memdbgon must be the last include file in a .cpp file!!! -#include "tier0/memdbgon.h" - -extern bool g_bTestMoveTypeStepSimulation; -extern ConVar sv_vehicle_autoaim_scale; - -// Init static class variables -bool CBaseEntity::m_bInDebugSelect = false; // Used for selection in debug overlays -int CBaseEntity::m_nDebugPlayer = -1; // Player doing the selection - -// This can be set before creating an entity to force it to use a particular edict. -edict_t *g_pForceAttachEdict = NULL; - -bool CBaseEntity::m_bDebugPause = false; // Whether entity i/o is paused. -int CBaseEntity::m_nDebugSteps = 1; // Number of entity outputs to fire before pausing again. -bool CBaseEntity::sm_bDisableTouchFuncs = false; // Disables PhysicsTouch and PhysicsStartTouch function calls -bool CBaseEntity::sm_bAccurateTriggerBboxChecks = true; // set to false for legacy behavior in ep1 - -int CBaseEntity::m_nPredictionRandomSeed = -1; -CBasePlayer *CBaseEntity::m_pPredictionPlayer = NULL; - -// Used to make sure nobody calls UpdateTransmitState directly. -int g_nInsideDispatchUpdateTransmitState = 0; - -// When this is false, throw an assert in debug when GetAbsAnything is called. Used when hierachy is incomplete/invalid. -bool CBaseEntity::s_bAbsQueriesValid = true; - - -ConVar sv_netvisdist( "sv_netvisdist", "10000", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Test networking visibility distance" ); - -// This table encodes edict data. -void SendProxy_AnimTime( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID ) -{ - CBaseEntity *pEntity = (CBaseEntity *)pStruct; - -#if defined( _DEBUG ) - CBaseAnimating *pAnimating = pEntity->GetBaseAnimating(); - Assert( pAnimating ); - - if ( pAnimating ) - { - Assert( !pAnimating->IsUsingClientSideAnimation() ); - } -#endif - - int ticknumber = TIME_TO_TICKS( pEntity->m_flAnimTime ); - // Tickbase is current tick rounded down to closes 100 ticks - int tickbase = gpGlobals->GetNetworkBase( gpGlobals->tickcount, pEntity->entindex() ); - int addt = 0; - // If it's within the last tick interval through the current one, then we can encode it - if ( ticknumber >= ( tickbase - 100 ) ) - { - addt = ( ticknumber - tickbase ) & 0xFF; - } - - pOut->m_Int = addt; -} - -// This table encodes edict data. -void SendProxy_SimulationTime( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID ) -{ - CBaseEntity *pEntity = (CBaseEntity *)pStruct; - - int ticknumber = TIME_TO_TICKS( pEntity->m_flSimulationTime ); - // tickbase is current tick rounded down to closest 100 ticks - int tickbase = gpGlobals->GetNetworkBase( gpGlobals->tickcount, pEntity->entindex() ); - int addt = 0; - if ( ticknumber >= tickbase ) - { - addt = ( ticknumber - tickbase ) & 0xff; - } - - pOut->m_Int = addt; -} - -void* SendProxy_ClientSideAnimation( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ) -{ - CBaseEntity *pEntity = (CBaseEntity *)pStruct; - CBaseAnimating *pAnimating = pEntity->GetBaseAnimating(); - - if ( pAnimating && !pAnimating->IsUsingClientSideAnimation() ) - return (void*)pVarData; - else - return NULL; // Don't send animtime unless the client needs it. -} -REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_ClientSideAnimation ); - - -BEGIN_SEND_TABLE_NOBASE( CBaseEntity, DT_AnimTimeMustBeFirst ) - // NOTE: Animtime must be sent before origin and angles ( from pev ) because it has a - // proxy on the client that stores off the old values before writing in the new values and - // if it is sent after the new values, then it will only have the new origin and studio model, etc. - // interpolation will be busted - SendPropInt (SENDINFO(m_flAnimTime), 8, SPROP_UNSIGNED|SPROP_CHANGES_OFTEN|SPROP_ENCODED_AGAINST_TICKCOUNT, SendProxy_AnimTime), -END_SEND_TABLE() - -#if !defined( NO_ENTITY_PREDICTION ) -BEGIN_SEND_TABLE_NOBASE( CBaseEntity, DT_PredictableId ) - SendPropPredictableId( SENDINFO( m_PredictableID ) ), - SendPropInt( SENDINFO( m_bIsPlayerSimulated ), 1, SPROP_UNSIGNED ), -END_SEND_TABLE() - - -static void* SendProxy_SendPredictableId( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ) -{ - CBaseEntity *pEntity = (CBaseEntity *)pStruct; - if ( !pEntity || !pEntity->m_PredictableID->IsActive() ) - return NULL; - - int id_player_index = pEntity->m_PredictableID->GetPlayer(); - pRecipients->SetOnly( id_player_index ); - - return ( void * )pVarData; -} -REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendPredictableId ); -#endif - -void SendProxy_Origin( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) -{ - CBaseEntity *entity = (CBaseEntity*)pStruct; - Assert( entity ); - - const Vector *v; - - if ( !entity->UseStepSimulationNetworkOrigin( &v ) ) - { - v = &entity->GetLocalOrigin(); - } - - pOut->m_Vector[ 0 ] = v->x; - pOut->m_Vector[ 1 ] = v->y; - pOut->m_Vector[ 2 ] = v->z; -} - -//-------------------------------------------------------------------------------------------------------- -// Used when breaking up origin, note we still have to deal with StepSimulation -//-------------------------------------------------------------------------------------------------------- -void SendProxy_OriginXY( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) -{ - CBaseEntity *entity = (CBaseEntity*)pStruct; - Assert( entity ); - - const Vector *v; - - if ( !entity->UseStepSimulationNetworkOrigin( &v ) ) - { - v = &entity->GetLocalOrigin(); - } - - pOut->m_Vector[ 0 ] = v->x; - pOut->m_Vector[ 1 ] = v->y; -} - -//-------------------------------------------------------------------------------------------------------- -// Used when breaking up origin, note we still have to deal with StepSimulation -//-------------------------------------------------------------------------------------------------------- -void SendProxy_OriginZ( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) -{ - CBaseEntity *entity = (CBaseEntity*)pStruct; - Assert( entity ); - - const Vector *v; - - if ( !entity->UseStepSimulationNetworkOrigin( &v ) ) - { - v = &entity->GetLocalOrigin(); - } - - pOut->m_Float = v->z; -} - - -void SendProxy_Angles( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) -{ - CBaseEntity *entity = (CBaseEntity*)pStruct; - Assert( entity ); - - const QAngle *a; - - if ( !entity->UseStepSimulationNetworkAngles( &a ) ) - { - a = &entity->GetLocalAngles(); - } - - pOut->m_Vector[ 0 ] = anglemod( a->x ); - pOut->m_Vector[ 1 ] = anglemod( a->y ); - pOut->m_Vector[ 2 ] = anglemod( a->z ); -} - -// This table encodes the CBaseEntity data. -IMPLEMENT_SERVERCLASS_ST_NOBASE( CBaseEntity, DT_BaseEntity ) - SendPropDataTable( "AnimTimeMustBeFirst", 0, &REFERENCE_SEND_TABLE(DT_AnimTimeMustBeFirst), SendProxy_ClientSideAnimation ), - SendPropInt (SENDINFO(m_flSimulationTime), SIMULATION_TIME_WINDOW_BITS, SPROP_UNSIGNED|SPROP_CHANGES_OFTEN|SPROP_ENCODED_AGAINST_TICKCOUNT, SendProxy_SimulationTime), - -#if PREDICTION_ERROR_CHECK_LEVEL > 1 - SendPropVector (SENDINFO(m_vecOrigin), -1, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ), -#else - SendPropVector (SENDINFO(m_vecOrigin), -1, SPROP_COORD|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ), -#endif - - SendPropInt (SENDINFO( m_ubInterpolationFrame ), NOINTERP_PARITY_MAX_BITS, SPROP_UNSIGNED ), - SendPropModelIndex(SENDINFO(m_nModelIndex)), - SendPropDataTable( SENDINFO_DT( m_Collision ), &REFERENCE_SEND_TABLE(DT_CollisionProperty) ), - SendPropInt (SENDINFO(m_nRenderFX), 8, SPROP_UNSIGNED ), - SendPropInt (SENDINFO(m_nRenderMode), 8, SPROP_UNSIGNED ), - SendPropInt (SENDINFO(m_fEffects), EF_MAX_BITS, SPROP_UNSIGNED), - SendPropInt (SENDINFO(m_clrRender), 32, SPROP_UNSIGNED), - SendPropInt (SENDINFO(m_iTeamNum), TEAMNUM_NUM_BITS, 0), - SendPropInt (SENDINFO(m_CollisionGroup), 5, SPROP_UNSIGNED), - SendPropFloat (SENDINFO(m_flElasticity), 0, SPROP_COORD), - SendPropFloat (SENDINFO(m_flShadowCastDistance), 12, SPROP_UNSIGNED ), - SendPropEHandle (SENDINFO(m_hOwnerEntity)), - SendPropEHandle (SENDINFO(m_hEffectEntity)), - SendPropEHandle (SENDINFO_NAME(m_hMoveParent, moveparent)), - SendPropInt (SENDINFO(m_iParentAttachment), NUM_PARENTATTACHMENT_BITS, SPROP_UNSIGNED), - - SendPropInt (SENDINFO_NAME( m_MoveType, movetype ), MOVETYPE_MAX_BITS, SPROP_UNSIGNED ), - SendPropInt (SENDINFO_NAME( m_MoveCollide, movecollide ), MOVECOLLIDE_MAX_BITS, SPROP_UNSIGNED ), -#if PREDICTION_ERROR_CHECK_LEVEL > 1 - SendPropVector (SENDINFO(m_angRotation), -1, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0, HIGH_DEFAULT, SendProxy_Angles ), -#else - SendPropQAngles (SENDINFO(m_angRotation), 13, SPROP_CHANGES_OFTEN, SendProxy_Angles ), -#endif - - SendPropInt ( SENDINFO( m_iTextureFrameIndex ), 8, SPROP_UNSIGNED ), - -#if !defined( NO_ENTITY_PREDICTION ) - SendPropDataTable( "predictable_id", 0, &REFERENCE_SEND_TABLE( DT_PredictableId ), SendProxy_SendPredictableId ), -#endif - - // FIXME: Collapse into another flag field? - SendPropInt (SENDINFO(m_bSimulatedEveryTick), 1, SPROP_UNSIGNED ), - SendPropInt (SENDINFO(m_bAnimatedEveryTick), 1, SPROP_UNSIGNED ), - SendPropBool( SENDINFO( m_bAlternateSorting )), - -#ifdef TF_DLL - SendPropArray3( SENDINFO_ARRAY3(m_nModelIndexOverrides), SendPropInt( SENDINFO_ARRAY(m_nModelIndexOverrides), SP_MODEL_INDEX_BITS, SPROP_UNSIGNED ) ), -#endif - -END_SEND_TABLE() - - -// dynamic models -class CBaseEntityModelLoadProxy -{ -protected: - class Handler : public IModelLoadCallback - { - public: - explicit Handler( CBaseEntity *pEntity ) : m_pEntity(pEntity) { } - virtual void OnModelLoadComplete( const model_t *pModel ); - CBaseEntity* m_pEntity; - }; - Handler* m_pHandler; - -public: - explicit CBaseEntityModelLoadProxy( CBaseEntity *pEntity ) : m_pHandler( new Handler( pEntity ) ) { } - ~CBaseEntityModelLoadProxy() { delete m_pHandler; } - void Register( int nModelIndex ) const { modelinfo->RegisterModelLoadCallback( nModelIndex, m_pHandler ); } - operator CBaseEntity * () const { return m_pHandler->m_pEntity; } - -private: - CBaseEntityModelLoadProxy( const CBaseEntityModelLoadProxy& ); - CBaseEntityModelLoadProxy& operator=( const CBaseEntityModelLoadProxy& ); -}; - -static CUtlHashtable< CBaseEntityModelLoadProxy, empty_t, PointerHashFunctor, PointerEqualFunctor, CBaseEntity * > sg_DynamicLoadHandlers; - -void CBaseEntityModelLoadProxy::Handler::OnModelLoadComplete( const model_t *pModel ) -{ - m_pEntity->OnModelLoadComplete( pModel ); - sg_DynamicLoadHandlers.Remove( m_pEntity ); // NOTE: destroys *this! -} - - -CBaseEntity::CBaseEntity( bool bServerOnly ) -{ - COMPILE_TIME_ASSERT( MOVETYPE_LAST < (1 << MOVETYPE_MAX_BITS) ); - COMPILE_TIME_ASSERT( MOVECOLLIDE_COUNT < (1 << MOVECOLLIDE_MAX_BITS) ); - -#ifdef _DEBUG - // necessary since in debug, we initialize vectors to NAN for debugging - m_vecAngVelocity.Init(); -// m_vecAbsAngVelocity.Init(); - m_vecViewOffset.Init(); - m_vecBaseVelocity.GetForModify().Init(); - m_vecVelocity.Init(); - m_vecAbsVelocity.Init(); -#endif - - m_bAlternateSorting = false; - m_CollisionGroup = COLLISION_GROUP_NONE; - m_iParentAttachment = 0; - CollisionProp()->Init( this ); - NetworkProp()->Init( this ); - - // NOTE: THIS MUST APPEAR BEFORE ANY SetMoveType() or SetNextThink() calls - AddEFlags( EFL_NO_THINK_FUNCTION | EFL_NO_GAME_PHYSICS_SIMULATION | EFL_USE_PARTITION_WHEN_NOT_SOLID ); - - // clear debug overlays - m_debugOverlays = 0; - m_pTimedOverlay = NULL; - m_pPhysicsObject = NULL; - m_flElasticity = 1.0f; - m_flShadowCastDistance = m_flDesiredShadowCastDistance = 0; - SetRenderColor( 255, 255, 255, 255 ); - m_iTeamNum = m_iInitialTeamNum = TEAM_UNASSIGNED; - m_nLastThinkTick = gpGlobals->tickcount; - m_nSimulationTick = -1; - SetIdentityMatrix( m_rgflCoordinateFrame ); - m_pBlocker = NULL; -#if _DEBUG - m_iCurrentThinkContext = NO_THINK_CONTEXT; -#endif - m_nWaterTouch = m_nSlimeTouch = 0; - - SetSolid( SOLID_NONE ); - ClearSolidFlags(); - - m_nModelIndex = 0; - m_bDynamicModelAllowed = false; - m_bDynamicModelPending = false; - m_bDynamicModelSetBounds = false; - - SetMoveType( MOVETYPE_NONE ); - SetOwnerEntity( NULL ); - SetCheckUntouch( false ); - SetModelIndex( 0 ); - SetModelName( NULL_STRING ); - m_nTransmitStateOwnedCounter = 0; - - SetCollisionBounds( vec3_origin, vec3_origin ); - ClearFlags(); - - SetFriction( 1.0f ); - - if ( bServerOnly ) - { - AddEFlags( EFL_SERVER_ONLY ); - } - NetworkProp()->MarkPVSInformationDirty(); - -#ifndef _XBOX - AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID ); -#endif -} - -//----------------------------------------------------------------------------- -// Purpose: Scale up our physics hull and test against the new one -// Input : *pNewCollide - New collision hull -//----------------------------------------------------------------------------- -void CBaseEntity::SetScaledPhysics( IPhysicsObject *pNewObject ) -{ - if ( pNewObject ) - { - AddSolidFlags( FSOLID_CUSTOMBOXTEST | FSOLID_CUSTOMRAYTEST ); - } - else - { - RemoveSolidFlags( FSOLID_CUSTOMBOXTEST | FSOLID_CUSTOMRAYTEST ); - } -} - -extern bool g_bDisableEhandleAccess; - -//----------------------------------------------------------------------------- -// Purpose: See note below -//----------------------------------------------------------------------------- -CBaseEntity::~CBaseEntity( ) -{ - // FIXME: This can't be called from UpdateOnRemove! There's at least one - // case where friction sounds are added between the call to UpdateOnRemove + ~CBaseEntity - PhysCleanupFrictionSounds( this ); - - Assert( !IsDynamicModelIndex( m_nModelIndex ) ); - Verify( !sg_DynamicLoadHandlers.Remove( this ) ); - - // In debug make sure that we don't call delete on an entity without setting - // the disable flag first! - // EHANDLE accessors will check, in debug, for access to entities during destruction of - // another entity. - // That kind of operation should only occur in UpdateOnRemove calls - // Deletion should only occur via UTIL_Remove(Immediate) calls, not via naked delete calls - Assert( g_bDisableEhandleAccess ); - - VPhysicsDestroyObject(); - - // Need to remove references to this entity before EHANDLES go null - { - g_bDisableEhandleAccess = false; - CBaseEntity::PhysicsRemoveTouchedList( this ); - CBaseEntity::PhysicsRemoveGroundList( this ); - SetGroundEntity( NULL ); // remove us from the ground entity if we are on it - DestroyAllDataObjects(); - g_bDisableEhandleAccess = true; - - // Remove this entity from the ent list (NOTE: This Makes EHANDLES go NULL) - gEntList.RemoveEntity( GetRefEHandle() ); - } -} - -void CBaseEntity::PostConstructor( const char *szClassname ) -{ - if ( szClassname ) - { - SetClassname(szClassname); - } - - Assert( m_iClassname != NULL_STRING && STRING(m_iClassname) != NULL ); - - // Possibly get an edict, and add self to global list of entites. - if ( IsEFlagSet( EFL_SERVER_ONLY ) ) - { - gEntList.AddNonNetworkableEntity( this ); - } - else - { - // Certain entities set up their edicts in the constructor - if ( !IsEFlagSet( EFL_NO_AUTO_EDICT_ATTACH ) ) - { - NetworkProp()->AttachEdict( g_pForceAttachEdict ); - g_pForceAttachEdict = NULL; - } - - // Some ents like the player override the AttachEdict function and do it at a different time. - // While precaching, they don't ever have an edict, so we don't need to add them to - // the entity list in that case. - if ( edict() ) - { - gEntList.AddNetworkableEntity( this, entindex() ); - - // Cache our IServerNetworkable pointer for the engine for fast access. - if ( edict() ) - edict()->m_pNetworkable = NetworkProp(); - } - } - - CheckHasThinkFunction( false ); - CheckHasGamePhysicsSimulation(); -} - -//----------------------------------------------------------------------------- -// Purpose: Called after player becomes active in the game -//----------------------------------------------------------------------------- -void CBaseEntity::PostClientActive( void ) -{ -} - -//----------------------------------------------------------------------------- -// Purpose: Verifies that this entity's data description is valid in debug builds. -//----------------------------------------------------------------------------- -#ifdef _DEBUG -typedef CUtlVector< const char * > KeyValueNameList_t; - -static void AddDataMapFieldNamesToList( KeyValueNameList_t &list, datamap_t *pDataMap ) -{ - while (pDataMap != NULL) - { - for (int i = 0; i < pDataMap->dataNumFields; i++) - { - typedescription_t *pField = &pDataMap->dataDesc[i]; - - if (pField->fieldType == FIELD_EMBEDDED) - { - AddDataMapFieldNamesToList( list, pField->td ); - continue; - } - - if (pField->flags & FTYPEDESC_KEY) - { - list.AddToTail( pField->externalName ); - } - } - - pDataMap = pDataMap->baseMap; - } -} - -void CBaseEntity::ValidateDataDescription(void) -{ - // Multiple key fields that have the same name are not allowed - it creates an - // ambiguity when trying to parse keyvalues and outputs. - datamap_t *pDataMap = GetDataDescMap(); - if ((pDataMap == NULL) || pDataMap->bValidityChecked) - return; - - pDataMap->bValidityChecked = true; - - // Let's generate a list of all keyvalue strings in the entire hierarchy... - KeyValueNameList_t names(128); - AddDataMapFieldNamesToList( names, pDataMap ); - - for (int i = names.Count(); --i > 0; ) - { - for (int j = i - 1; --j >= 0; ) - { - if (!Q_stricmp(names[i], names[j])) - { - DevMsg( "%s has multiple data description entries for \"%s\"\n", STRING(m_iClassname), names[i]); - break; - } - } - } -} -#endif // _DEBUG - - -//----------------------------------------------------------------------------- -// Sets the collision bounds + the size -//----------------------------------------------------------------------------- -void CBaseEntity::SetCollisionBounds( const Vector& mins, const Vector &maxs ) -{ - m_Collision.SetCollisionBounds( mins, maxs ); -} - - -void CBaseEntity::StopFollowingEntity( ) -{ - if( !IsFollowingEntity() ) - { -// Assert( IsEffectActive( EF_BONEMERGE ) == 0 ); - return; - } - - SetParent( NULL ); - RemoveEffects( EF_BONEMERGE ); - RemoveSolidFlags( FSOLID_NOT_SOLID ); - SetMoveType( MOVETYPE_NONE ); - CollisionRulesChanged(); -} - -bool CBaseEntity::IsFollowingEntity() -{ - return IsEffectActive( EF_BONEMERGE ) && (GetMoveType() == MOVETYPE_NONE) && GetMoveParent(); -} - -CBaseEntity *CBaseEntity::GetFollowedEntity() -{ - if (!IsFollowingEntity()) - return NULL; - return GetMoveParent(); -} - -void CBaseEntity::SetClassname( const char *className ) -{ - m_iClassname = AllocPooledString( className ); -} - -void CBaseEntity::SetModelIndex( int index ) -{ - if ( IsDynamicModelIndex( index ) && !(GetBaseAnimating() && m_bDynamicModelAllowed) ) - { - AssertMsg( false, "dynamic model support not enabled on server entity" ); - index = -1; - } - - if ( index != m_nModelIndex ) - { - if ( m_bDynamicModelPending ) - { - sg_DynamicLoadHandlers.Remove( this ); - } - - modelinfo->ReleaseDynamicModel( m_nModelIndex ); - modelinfo->AddRefDynamicModel( index ); - m_nModelIndex = index; - - m_bDynamicModelSetBounds = false; - - if ( IsDynamicModelIndex( index ) ) - { - m_bDynamicModelPending = true; - sg_DynamicLoadHandlers[ sg_DynamicLoadHandlers.Insert( this ) ].Register( index ); - } - else - { - m_bDynamicModelPending = false; - OnNewModel(); - } - } - DispatchUpdateTransmitState(); -} - -void CBaseEntity::ClearModelIndexOverrides( void ) -{ -#ifdef TF_DLL - for ( int index = 0 ; index < MAX_VISION_MODES ; index++ ) - { - m_nModelIndexOverrides.Set( index, 0 ); - } -#endif -} - -void CBaseEntity::SetModelIndexOverride( int index, int nValue ) -{ -#ifdef TF_DLL - if ( ( index >= VISION_MODE_NONE ) && ( index < MAX_VISION_MODES ) ) - { - if ( nValue != m_nModelIndexOverrides[index] ) - { - m_nModelIndexOverrides.Set( index, nValue ); - } - } -#endif -} - -// position to shoot at -Vector CBaseEntity::BodyTarget( const Vector &posSrc, bool bNoisy) -{ - return WorldSpaceCenter( ); -} - -// return the position of my head. someone's trying to attack it. -Vector CBaseEntity::HeadTarget( const Vector &posSrc ) -{ - return EyePosition(); -} - - -struct TimedOverlay_t -{ - char *msg; - int msgEndTime; - int msgStartTime; - TimedOverlay_t *pNextTimedOverlay; -}; - -//----------------------------------------------------------------------------- -// Purpose: Display an error message on the entity -// Input : -// Output : -//----------------------------------------------------------------------------- -void CBaseEntity::AddTimedOverlay( const char *msg, int endTime ) -{ - TimedOverlay_t *pNewTO = new TimedOverlay_t; - int len = strlen(msg); - pNewTO->msg = new char[len + 1]; - Q_strncpy(pNewTO->msg,msg, len+1); - pNewTO->msgEndTime = gpGlobals->curtime + endTime; - pNewTO->msgStartTime = gpGlobals->curtime; - pNewTO->pNextTimedOverlay = m_pTimedOverlay; - m_pTimedOverlay = pNewTO; -} - -//----------------------------------------------------------------------------- -// Purpose: Send debug overlay box to the client -// Input : -// Output : -//----------------------------------------------------------------------------- -void CBaseEntity::DrawBBoxOverlay( float flDuration ) -{ - if (edict()) - { - NDebugOverlay::EntityBounds(this, 255, 100, 0, 0, flDuration ); - - if ( CollisionProp()->IsSolidFlagSet( FSOLID_USE_TRIGGER_BOUNDS ) ) - { - Vector vecTriggerMins, vecTriggerMaxs; - CollisionProp()->WorldSpaceTriggerBounds( &vecTriggerMins, &vecTriggerMaxs ); - Vector center = 0.5f * (vecTriggerMins + vecTriggerMaxs); - Vector extents = vecTriggerMaxs - center; - NDebugOverlay::Box(center, -extents, extents, 0, 255, 255, 0, flDuration ); - } - } -} - - -void CBaseEntity::DrawAbsBoxOverlay() -{ - int red = 0; - int green = 200; - - if ( VPhysicsGetObject() && VPhysicsGetObject()->IsAsleep() ) - { - red = 90; - green = 120; - } - - if (edict()) - { - // Surrounding boxes are axially aligned, so ignore angles - Vector vecSurroundMins, vecSurroundMaxs; - CollisionProp()->WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs ); - Vector center = 0.5f * (vecSurroundMins + vecSurroundMaxs); - Vector extents = vecSurroundMaxs - center; - NDebugOverlay::Box(center, -extents, extents, red, green, 0, 0 ,0); - } -} - -void CBaseEntity::DrawRBoxOverlay() -{ - -} - -//----------------------------------------------------------------------------- -// Purpose: Draws an axis overlay at the origin and angles of the entity -//----------------------------------------------------------------------------- -void CBaseEntity::SendDebugPivotOverlay( void ) -{ - if ( edict() ) - { - NDebugOverlay::Axis( GetAbsOrigin(), GetAbsAngles(), 20, true, 0 ); - } -} - -//------------------------------------------------------------------------------ -// Purpose : Add new entity positioned overlay text -// Input : How many lines to offset text from origin -// The text to print -// How long to display text -// The color of the text -// Output : -//------------------------------------------------------------------------------ -void CBaseEntity::EntityText( int text_offset, const char *text, float duration, int r, int g, int b, int a ) -{ - Vector origin; - Vector vecLocalCenter; - - VectorAdd( m_Collision.OBBMins(), m_Collision.OBBMaxs(), vecLocalCenter ); - vecLocalCenter *= 0.5f; - - if ( ( m_Collision.GetCollisionAngles() == vec3_angle ) || ( vecLocalCenter == vec3_origin ) ) - { - VectorAdd( vecLocalCenter, m_Collision.GetCollisionOrigin(), origin ); - } - else - { - VectorTransform( vecLocalCenter, m_Collision.CollisionToWorldTransform(), origin ); - } - - NDebugOverlay::EntityTextAtPosition( origin, text_offset, text, duration, r, g, b, a ); -} - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CBaseEntity::DrawTimedOverlays(void) -{ - // Draw name first if I have an overlay or am in message mode - if ((m_debugOverlays & OVERLAY_MESSAGE_BIT)) - { - char tempstr[512]; - Q_snprintf( tempstr, sizeof( tempstr ), "[%s]", GetDebugName() ); - EntityText(0,tempstr, 0); - } - - // Now draw overlays - TimedOverlay_t* pTO = m_pTimedOverlay; - TimedOverlay_t* pNextTO = NULL; - TimedOverlay_t* pLastTO = NULL; - int nCount = 1; // Offset by one - while (pTO) - { - pNextTO = pTO->pNextTimedOverlay; - - // Remove old messages unless messages are paused - if ((!CBaseEntity::Debug_IsPaused() && gpGlobals->curtime > pTO->msgEndTime) || - (nCount > 10)) - { - if (pLastTO) - { - pLastTO->pNextTimedOverlay = pNextTO; - } - else - { - m_pTimedOverlay = pNextTO; - } - - delete pTO->msg; - delete pTO; - } - else - { - int nAlpha = 0; - - // If messages aren't paused fade out - if (!CBaseEntity::Debug_IsPaused()) - { - nAlpha = 255*((gpGlobals->curtime - pTO->msgStartTime)/(pTO->msgEndTime - pTO->msgStartTime)); - } - int r = 185; - int g = 145; - int b = 145; - - // Brighter when new message - if (nAlpha < 50) - { - r = 255; - g = 205; - b = 205; - } - if (nAlpha < 0) nAlpha = 0; - EntityText(nCount,pTO->msg, 0.0, r, g, b, 255-nAlpha); - nCount++; - - pLastTO = pTO; - } - pTO = pNextTO; - } -} - -//----------------------------------------------------------------------------- -// Purpose: Draw all overlays (should be implemented by subclass to add -// any additional non-text overlays) -// Input : -// Output : Current text offset from the top -//----------------------------------------------------------------------------- -void CBaseEntity::DrawDebugGeometryOverlays(void) -{ - DrawTimedOverlays(); - DrawDebugTextOverlays(); - - if (m_debugOverlays & OVERLAY_NAME_BIT) - { - EntityText(0,GetDebugName(), 0); - } - if (m_debugOverlays & OVERLAY_BBOX_BIT) - { - DrawBBoxOverlay(); - } - if (m_debugOverlays & OVERLAY_ABSBOX_BIT ) - { - DrawAbsBoxOverlay(); - } - if (m_debugOverlays & OVERLAY_PIVOT_BIT) - { - SendDebugPivotOverlay(); - } - if( m_debugOverlays & OVERLAY_RBOX_BIT ) - { - DrawRBoxOverlay(); - } - if ( m_debugOverlays & (OVERLAY_BBOX_BIT|OVERLAY_PIVOT_BIT) ) - { - // draw mass center - if ( VPhysicsGetObject() ) - { - Vector massCenter = VPhysicsGetObject()->GetMassCenterLocalSpace(); - Vector worldPos; - VPhysicsGetObject()->LocalToWorld( &worldPos, massCenter ); - NDebugOverlay::Cross3D( worldPos, 12, 255, 0, 0, false, 0 ); - DebugDrawContactPoints(VPhysicsGetObject()); - if ( GetMoveType() != MOVETYPE_VPHYSICS ) - { - Vector pos; - QAngle angles; - VPhysicsGetObject()->GetPosition( &pos, &angles ); - float dist = (pos - GetAbsOrigin()).Length(); - - Vector axis; - float deltaAngle; - RotationDeltaAxisAngle( angles, GetAbsAngles(), axis, deltaAngle ); - if ( dist > 2 || fabsf(deltaAngle) > 2 ) - { - Vector mins, maxs; - physcollision->CollideGetAABB( &mins, &maxs, VPhysicsGetObject()->GetCollide(), vec3_origin, vec3_angle ); - NDebugOverlay::BoxAngles( pos, mins, maxs, angles, 255, 255, 0, 16, 0 ); - } - } - } - } - if ( m_debugOverlays & OVERLAY_SHOW_BLOCKSLOS ) - { - if ( BlocksLOS() ) - { - NDebugOverlay::EntityBounds(this, 255, 255, 255, 0, 0 ); - } - } - if ( m_debugOverlays & OVERLAY_AUTOAIM_BIT && (GetFlags()&FL_AIMTARGET) && AI_GetSinglePlayer() != NULL ) - { - // Crude, but it gets the point across. - Vector vecCenter = GetAutoAimCenter(); - Vector vecRight, vecUp, vecDiag; - CBasePlayer *pPlayer = AI_GetSinglePlayer(); - float radius = GetAutoAimRadius(); - - QAngle angles = pPlayer->EyeAngles(); - AngleVectors( angles, NULL, &vecRight, &vecUp ); - - int r,g,b; - - if( ((int)gpGlobals->curtime) % 2 == 1 ) - { - r = 255; - g = 255; - b = 255; - - if( pPlayer->GetActiveWeapon() != NULL ) - radius *= pPlayer->GetActiveWeapon()->WeaponAutoAimScale(); - - } - else - { - r = 255;g=0;b=0; - - if( !ShouldAttractAutoAim(pPlayer) ) - { - g = 255; - } - } - - if( pPlayer->IsInAVehicle() ) - { - radius *= sv_vehicle_autoaim_scale.GetFloat(); - } - - NDebugOverlay::Line( vecCenter, vecCenter + vecRight * radius, r, g, b, true, 0.1 ); - NDebugOverlay::Line( vecCenter, vecCenter - vecRight * radius, r, g, b, true, 0.1 ); - NDebugOverlay::Line( vecCenter, vecCenter + vecUp * radius, r, g, b, true, 0.1 ); - NDebugOverlay::Line( vecCenter, vecCenter - vecUp * radius, r, g, b, true, 0.1 ); - - vecDiag = vecRight + vecUp; - VectorNormalize( vecDiag ); - NDebugOverlay::Line( vecCenter - vecDiag * radius, vecCenter + vecDiag * radius, r, g, b, true, 0.1 ); - - vecDiag = vecRight - vecUp; - VectorNormalize( vecDiag ); - NDebugOverlay::Line( vecCenter - vecDiag * radius, vecCenter + vecDiag * radius, r, g, b, true, 0.1 ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Draw any text overlays (override in subclass to add additional text) -// Output : Current text offset from the top -//----------------------------------------------------------------------------- -int CBaseEntity::DrawDebugTextOverlays(void) -{ - int offset = 1; - if (m_debugOverlays & OVERLAY_TEXT_BIT) - { - char tempstr[512]; - Q_snprintf( tempstr, sizeof(tempstr), "(%d) Name: %s (%s)", entindex(), GetDebugName(), GetClassname() ); - EntityText(offset,tempstr, 0); - offset++; - - if( m_iGlobalname != NULL_STRING ) - { - Q_snprintf( tempstr, sizeof(tempstr), "GLOBALNAME: %s", STRING(m_iGlobalname) ); - EntityText(offset,tempstr, 0); - offset++; - } - - Vector vecOrigin = GetAbsOrigin(); - Q_snprintf( tempstr, sizeof(tempstr), "Position: %0.1f, %0.1f, %0.1f\n", vecOrigin.x, vecOrigin.y, vecOrigin.z ); - EntityText( offset, tempstr, 0 ); - offset++; - - if( GetModelName() != NULL_STRING || GetBaseAnimating() ) - { - Q_snprintf(tempstr, sizeof(tempstr), "Model:%s", STRING(GetModelName()) ); - EntityText(offset,tempstr,0); - offset++; - } - - if( m_hDamageFilter.Get() != NULL ) - { - Q_snprintf( tempstr, sizeof(tempstr), "DAMAGE FILTER:%s", m_hDamageFilter->GetDebugName() ); - EntityText( offset,tempstr,0 ); - offset++; - } - } - - if (m_debugOverlays & OVERLAY_VIEWOFFSET) - { - NDebugOverlay::Cross3D( EyePosition(), 16, 255, 0, 0, true, 0.05f ); - } - - return offset; -} - - -void CBaseEntity::SetParent( string_t newParent, CBaseEntity *pActivator, int iAttachment ) -{ - // find and notify the new parent - CBaseEntity *pParent = gEntList.FindEntityByName( NULL, newParent, NULL, pActivator ); - - // debug check - if ( newParent != NULL_STRING && pParent == NULL ) - { - Msg( "Entity %s(%s) has bad parent %s\n", STRING(m_iClassname), GetDebugName(), STRING(newParent) ); - } - else - { - // make sure there isn't any ambiguity - if ( gEntList.FindEntityByName( pParent, newParent, NULL, pActivator ) ) - { - Msg( "Entity %s(%s) has ambigious parent %s\n", STRING(m_iClassname), GetDebugName(), STRING(newParent) ); - } - SetParent( pParent, iAttachment ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Move our points from parent to worldspace -// Input : *pParent - Parent to use as reference -//----------------------------------------------------------------------------- -void CBaseEntity::TransformStepData_ParentToWorld( CBaseEntity *pParent ) -{ - // Fix up our step simulation points to be in the proper local space - StepSimulationData *step = (StepSimulationData *) GetDataObject( STEPSIMULATION ); - if ( step != NULL ) - { - // Convert our positions - UTIL_ParentToWorldSpace( pParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); - UTIL_ParentToWorldSpace( pParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Move step data between two parent-spaces -// Input : *pOldParent - parent we were attached to -// *pNewParent - parent we're now attached to -//----------------------------------------------------------------------------- -void CBaseEntity::TransformStepData_ParentToParent( CBaseEntity *pOldParent, CBaseEntity *pNewParent ) -{ - // Fix up our step simulation points to be in the proper local space - StepSimulationData *step = (StepSimulationData *) GetDataObject( STEPSIMULATION ); - if ( step != NULL ) - { - // Convert our positions - UTIL_ParentToWorldSpace( pOldParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); - UTIL_WorldToParentSpace( pNewParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); - - UTIL_ParentToWorldSpace( pOldParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); - UTIL_WorldToParentSpace( pNewParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: After parenting to an object, we need to also correctly translate our -// step stimulation positions and angles into that parent space. Otherwise -// we end up splining between two different world spaces. -//----------------------------------------------------------------------------- -void CBaseEntity::TransformStepData_WorldToParent( CBaseEntity *pParent ) -{ - // Fix up our step simulation points to be in the proper local space - StepSimulationData *step = (StepSimulationData *) GetDataObject( STEPSIMULATION ); - if ( step != NULL ) - { - // Convert our positions - UTIL_WorldToParentSpace( pParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); - UTIL_WorldToParentSpace( pParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Sets the movement parent of this entity. This entity will be moved -// to a local coordinate calculated from its current absolute offset -// from the parent entity and will then follow the parent entity. -// Input : pParentEntity - This entity's new parent in the movement hierarchy. -//----------------------------------------------------------------------------- -void CBaseEntity::SetParent( CBaseEntity *pParentEntity, int iAttachment ) -{ - // If they didn't specify an attachment, use our current - if ( iAttachment == -1 ) - { - iAttachment = m_iParentAttachment; - } - - bool bWasNotParented = ( GetParent() == NULL ); - CBaseEntity *pOldParent = m_pParent; - - // notify the old parent of the loss - UnlinkFromParent( this ); - - // set the new name - m_pParent = pParentEntity; - - if ( m_pParent == this ) - { - // should never set parent to 'this' - makes no sense - Assert(0); - m_pParent = NULL; - } - - if ( m_pParent == NULL ) - { - m_iParent = NULL_STRING; - - // Transform step data from parent to worldspace - TransformStepData_ParentToWorld( pOldParent ); - return; - } - - m_iParent = m_pParent->m_iName; - - RemoveSolidFlags( FSOLID_ROOT_PARENT_ALIGNED ); - if ( pParentEntity ) - { - if ( const_cast(pParentEntity)->GetRootMoveParent()->GetSolid() == SOLID_BSP ) - { - AddSolidFlags( FSOLID_ROOT_PARENT_ALIGNED ); - } - else - { - if ( GetSolid() == SOLID_BSP ) - { - // Must be SOLID_VPHYSICS because parent might rotate - SetSolid( SOLID_VPHYSICS ); - } - } - } - // set the move parent if we have one - if ( edict() ) - { - // add ourselves to the list - LinkChild( m_pParent, this ); - - m_iParentAttachment = (char)iAttachment; - - EntityMatrix matrix, childMatrix; - matrix.InitFromEntity( const_cast(pParentEntity), m_iParentAttachment ); // parent->world - childMatrix.InitFromEntityLocal( this ); // child->world - Vector localOrigin = matrix.WorldToLocal( GetLocalOrigin() ); - - // I have the axes of local space in world space. (childMatrix) - // I want to compute those world space axes in the parent's local space - // and set that transform (as angles) on the child's object so the net - // result is that the child is now in parent space, but still oriented the same way - VMatrix tmp = matrix.Transpose(); // world->parent - tmp.MatrixMul( childMatrix, matrix ); // child->parent - QAngle angles; - MatrixToAngles( matrix, angles ); - SetLocalAngles( angles ); - UTIL_SetOrigin( this, localOrigin ); - - // Move our step data into the correct space - if ( bWasNotParented ) - { - // Transform step data from world to parent-space - TransformStepData_WorldToParent( this ); - } - else - { - // Transform step data between parent-spaces - TransformStepData_ParentToParent( pOldParent, this ); - } - } - if ( VPhysicsGetObject() ) - { - if ( VPhysicsGetObject()->IsStatic()) - { - if ( VPhysicsGetObject()->IsAttachedToConstraint(false) ) - { - Warning("SetParent on static object, all constraints attached to %s (%s)will now be broken!\n", GetDebugName(), GetClassname() ); - } - VPhysicsDestroyObject(); - VPhysicsInitShadow(false, false); - } - } - CollisionRulesChanged(); -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -void CBaseEntity::ValidateEntityConnections() -{ - if ( m_target == NULL_STRING ) - return; - - if ( ClassMatches( "scripted_*" ) || - ClassMatches( "trigger_relay" ) || - ClassMatches( "trigger_auto" ) || - ClassMatches( "path_*" ) || - ClassMatches( "monster_*" ) || - ClassMatches( "trigger_teleport" ) || - ClassMatches( "func_train" ) || - ClassMatches( "func_tracktrain" ) || - ClassMatches( "func_plat*" ) || - ClassMatches( "npc_*" ) || - ClassMatches( "info_big*" ) || - ClassMatches( "env_texturetoggle" ) || - ClassMatches( "env_render" ) || - ClassMatches( "func_areaportalwindow") || - ClassMatches( "point_view*") || - ClassMatches( "func_traincontrols" ) || - ClassMatches( "multisource" ) || - ClassMatches( "xen_plant*" ) ) - return; - - datamap_t *dmap = GetDataDescMap(); - while ( dmap ) - { - int fields = dmap->dataNumFields; - for ( int i = 0; i < fields; i++ ) - { - typedescription_t *dataDesc = &dmap->dataDesc[i]; - if ( ( dataDesc->fieldType == FIELD_CUSTOM ) && ( dataDesc->flags & FTYPEDESC_OUTPUT ) ) - { - CBaseEntityOutput *pOutput = (CBaseEntityOutput *)((int)this + (int)dataDesc->fieldOffset[0]); - if ( pOutput->NumberOfElements() ) - return; - } - } - - dmap = dmap->baseMap; - } - - Vector vecLoc = WorldSpaceCenter(); - Warning("---------------------------------\n"); - Warning( "Entity %s - (%s) has a target and NO OUTPUTS\n", GetDebugName(), GetClassname() ); - Warning( "Location %f %f %f\n", vecLoc.x, vecLoc.y, vecLoc.z ); - Warning("---------------------------------\n"); -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -void CBaseEntity::FireNamedOutput( const char *pszOutput, variant_t variant, CBaseEntity *pActivator, CBaseEntity *pCaller, float flDelay ) -{ - if ( pszOutput == NULL ) - return; - - datamap_t *dmap = GetDataDescMap(); - while ( dmap ) - { - int fields = dmap->dataNumFields; - for ( int i = 0; i < fields; i++ ) - { - typedescription_t *dataDesc = &dmap->dataDesc[i]; - if ( ( dataDesc->fieldType == FIELD_CUSTOM ) && ( dataDesc->flags & FTYPEDESC_OUTPUT ) ) - { - CBaseEntityOutput *pOutput = ( CBaseEntityOutput * )( ( int )this + ( int )dataDesc->fieldOffset[0] ); - if ( !Q_stricmp( dataDesc->externalName, pszOutput ) ) - { - pOutput->FireOutput( variant, pActivator, pCaller, flDelay ); - return; - } - } - } - - dmap = dmap->baseMap; - } -} - -void CBaseEntity::Activate( void ) -{ -#ifdef DEBUG - extern bool g_bCheckForChainedActivate; - extern bool g_bReceivedChainedActivate; - - if ( g_bCheckForChainedActivate && g_bReceivedChainedActivate ) - { - Assert( !"Multiple calls to base class Activate()\n" ); - } - g_bReceivedChainedActivate = true; -#endif - - // NOTE: This forces a team change so that stuff in the level - // that starts out on a team correctly changes team - if (m_iInitialTeamNum) - { - ChangeTeam( m_iInitialTeamNum ); - } - - // Get a handle to my damage filter entity if there is one. - if ( m_iszDamageFilterName != NULL_STRING ) - { - m_hDamageFilter = gEntList.FindEntityByName( NULL, m_iszDamageFilterName ); - } - - // Add any non-null context strings to our context vector - if ( m_iszResponseContext != NULL_STRING ) - { - AddContext( m_iszResponseContext.ToCStr() ); - } - -#ifdef HL1_DLL - ValidateEntityConnections(); -#endif //HL1_DLL -} - -//////////////////////////// old CBaseEntity stuff /////////////////////////////////// - - -// give health. -// Returns the amount of health actually taken. -int CBaseEntity::TakeHealth( float flHealth, int bitsDamageType ) -{ - if ( !edict() || m_takedamage < DAMAGE_YES ) - return 0; - - int iMax = GetMaxHealth(); - -// heal - if ( m_iHealth >= iMax ) - return 0; - - const int oldHealth = m_iHealth; - - m_iHealth += flHealth; - - if (m_iHealth > iMax) - m_iHealth = iMax; - - return m_iHealth - oldHealth; -} - -// inflict damage on this entity. bitsDamageType indicates type of damage inflicted, ie: DMG_CRUSH - -int CBaseEntity::OnTakeDamage( const CTakeDamageInfo &info ) -{ - Vector vecTemp; - - if ( !edict() || !m_takedamage ) - return 0; - - if ( info.GetInflictor() ) - { - vecTemp = info.GetInflictor()->WorldSpaceCenter() - ( WorldSpaceCenter() ); - } - else - { - vecTemp.Init( 1, 0, 0 ); - } - - // this global is still used for glass and other non-NPC killables, along with decals. - g_vecAttackDir = vecTemp; - VectorNormalize(g_vecAttackDir); - - // save damage based on the target's armor level - - // figure momentum add (don't let hurt brushes or other triggers move player) - - // physics objects have their own calcs for this: (don't let fire move things around!) - if ( !IsEFlagSet( EFL_NO_DAMAGE_FORCES ) ) - { - if ( ( GetMoveType() == MOVETYPE_VPHYSICS ) ) - { - VPhysicsTakeDamage( info ); - } - else - { - if ( info.GetInflictor() && (GetMoveType() == MOVETYPE_WALK || GetMoveType() == MOVETYPE_STEP) && - !info.GetAttacker()->IsSolidFlagSet(FSOLID_TRIGGER) ) - { - Vector vecDir, vecInflictorCentroid; - vecDir = WorldSpaceCenter( ); - vecInflictorCentroid = info.GetInflictor()->WorldSpaceCenter( ); - vecDir -= vecInflictorCentroid; - VectorNormalize( vecDir ); - - float flForce = info.GetDamage() * ((32 * 32 * 72.0) / (WorldAlignSize().x * WorldAlignSize().y * WorldAlignSize().z)) * 5; - - if (flForce > 1000.0) - flForce = 1000.0; - ApplyAbsVelocityImpulse( vecDir * flForce ); - } - } - } - - if ( m_takedamage != DAMAGE_EVENTS_ONLY ) - { - // do the damage - m_iHealth -= info.GetDamage(); - if (m_iHealth <= 0) - { - Event_Killed( info ); - return 0; - } - } - - return 1; -} - -//----------------------------------------------------------------------------- -// Purpose: Scale damage done and call OnTakeDamage -//----------------------------------------------------------------------------- -void CBaseEntity::TakeDamage( const CTakeDamageInfo &inputInfo ) -{ - if ( !g_pGameRules ) - return; - - bool bHasPhysicsForceDamage = !g_pGameRules->Damage_NoPhysicsForce( inputInfo.GetDamageType() ); - if ( bHasPhysicsForceDamage && inputInfo.GetDamageType() != DMG_GENERIC ) - { - // If you hit this assert, you've called TakeDamage with a damage type that requires a physics damage - // force & position without specifying one or both of them. Decide whether your damage that's causing - // this is something you believe should impart physics force on the receiver. If it is, you need to - // setup the damage force & position inside the CTakeDamageInfo (Utility functions for this are in - // takedamageinfo.cpp. If you think the damage shouldn't cause force (unlikely!) then you can set the - // damage type to DMG_GENERIC, or | DMG_CRUSH if you need to preserve the damage type for purposes of HUD display. - - if ( inputInfo.GetDamageForce() == vec3_origin || inputInfo.GetDamagePosition() == vec3_origin ) - { - static int warningCount = 0; - if ( ++warningCount < 10 ) - { - if ( inputInfo.GetDamageForce() == vec3_origin ) - { - DevWarning( "CBaseEntity::TakeDamage: with inputInfo.GetDamageForce() == vec3_origin\n" ); - } - if ( inputInfo.GetDamagePosition() == vec3_origin ) - { - DevWarning( "CBaseEntity::TakeDamage: with inputInfo.GetDamagePosition() == vec3_origin\n" ); - } - } - } - } - - // Make sure our damage filter allows the damage. - if ( !PassesDamageFilter( inputInfo )) - { - return; - } - - if( !g_pGameRules->AllowDamage(this, inputInfo) ) - { - return; - } - - if ( PhysIsInCallback() ) - { - PhysCallbackDamage( this, inputInfo ); - } - else - { - CTakeDamageInfo info = inputInfo; - - // Scale the damage by the attacker's modifier. - if ( info.GetAttacker() ) - { - info.ScaleDamage( info.GetAttacker()->GetAttackDamageScale( this ) ); - } - - // Scale the damage by my own modifiers - info.ScaleDamage( GetReceivedDamageScale( info.GetAttacker() ) ); - - //Msg("%s took %.2f Damage, at %.2f\n", GetClassname(), info.GetDamage(), gpGlobals->curtime ); - - OnTakeDamage( info ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Returns a value that scales all damage done by this entity. -//----------------------------------------------------------------------------- -float CBaseEntity::GetAttackDamageScale( CBaseEntity *pVictim ) -{ - float flScale = 1; - FOR_EACH_LL( m_DamageModifiers, i ) - { - if ( !m_DamageModifiers[i]->IsDamageDoneToMe() ) - { - flScale *= m_DamageModifiers[i]->GetModifier(); - } - } - return flScale; -} - -//----------------------------------------------------------------------------- -// Purpose: Returns a value that scales all damage done to this entity -//----------------------------------------------------------------------------- -float CBaseEntity::GetReceivedDamageScale( CBaseEntity *pAttacker ) -{ - float flScale = 1; - FOR_EACH_LL( m_DamageModifiers, i ) - { - if ( m_DamageModifiers[i]->IsDamageDoneToMe() ) - { - flScale *= m_DamageModifiers[i]->GetModifier(); - } - } - return flScale; -} - - -//----------------------------------------------------------------------------- -// Purpose: Applies forces to our physics object in response to damage. -//----------------------------------------------------------------------------- -int CBaseEntity::VPhysicsTakeDamage( const CTakeDamageInfo &info ) -{ - // don't let physics impacts or fire cause objects to move (again) - bool bNoPhysicsForceDamage = g_pGameRules->Damage_NoPhysicsForce( info.GetDamageType() ); - if ( bNoPhysicsForceDamage || info.GetDamageType() == DMG_GENERIC ) - return 1; - - Assert(VPhysicsGetObject() != NULL); - if ( VPhysicsGetObject() ) - { - Vector force = info.GetDamageForce(); - Vector offset = info.GetDamagePosition(); - - // If you hit this assert, you've called TakeDamage with a damage type that requires a physics damage - // force & position without specifying one or both of them. Decide whether your damage that's causing - // this is something you believe should impart physics force on the receiver. If it is, you need to - // setup the damage force & position inside the CTakeDamageInfo (Utility functions for this are in - // takedamageinfo.cpp. If you think the damage shouldn't cause force (unlikely!) then you can set the - // damage type to DMG_GENERIC, or | DMG_CRUSH if you need to preserve the damage type for purposes of HUD display. -#if !defined( TF_DLL ) - Assert( force != vec3_origin && offset != vec3_origin ); -#else - // this was spamming the console for Payload maps in TF (trigger_hurt entity on the front of the cart) - if ( !TFGameRules() || TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT ) - { - Assert( force != vec3_origin && offset != vec3_origin ); - } -#endif - - unsigned short gameFlags = VPhysicsGetObject()->GetGameFlags(); - if ( gameFlags & FVPHYSICS_PLAYER_HELD ) - { - // if the player is holding the object, use it's real mass (player holding reduced the mass) - CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); - if ( pPlayer ) - { - float mass = pPlayer->GetHeldObjectMass( VPhysicsGetObject() ); - if ( mass != 0.0f ) - { - float ratio = VPhysicsGetObject()->GetMass() / mass; - force *= ratio; - } - } - } - else if ( (gameFlags & FVPHYSICS_PART_OF_RAGDOLL) && (gameFlags & FVPHYSICS_CONSTRAINT_STATIC) ) - { - IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT]; - int count = VPhysicsGetObjectList( pList, ARRAYSIZE(pList) ); - for ( int i = 0; i < count; i++ ) - { - if ( !(pList[i]->GetGameFlags() & FVPHYSICS_CONSTRAINT_STATIC) ) - { - pList[i]->ApplyForceOffset( force, offset ); - return 1; - } - } - - } - VPhysicsGetObject()->ApplyForceOffset( force, offset ); - } - - return 1; -} - - // Character killed (only fired once) -void CBaseEntity::Event_Killed( const CTakeDamageInfo &info ) -{ - if( info.GetAttacker() ) - { - info.GetAttacker()->Event_KilledOther(this, info); - } - - m_takedamage = DAMAGE_NO; - m_lifeState = LIFE_DEAD; - UTIL_Remove( this ); -} - -//----------------------------------------------------------------------------- -// Purpose: helper method to send a game event when this entity is killed. Note: -// gets called specifically for particular entities (mostly NPC), this -// does not get called for every entity -//----------------------------------------------------------------------------- -void CBaseEntity::SendOnKilledGameEvent( const CTakeDamageInfo &info ) -{ - IGameEvent *event = gameeventmanager->CreateEvent( "entity_killed" ); - if ( event ) - { - event->SetInt( "entindex_killed", entindex() ); - if ( info.GetAttacker()) - { - event->SetInt( "entindex_attacker", info.GetAttacker()->entindex() ); - } - if ( info.GetInflictor()) - { - event->SetInt( "entindex_inflictor", info.GetInflictor()->entindex() ); - } - event->SetInt( "damagebits", info.GetDamageType() ); - gameeventmanager->FireEvent( event ); - } -} - - -bool CBaseEntity::HasTarget( string_t targetname ) -{ - if( targetname != NULL_STRING && m_target != NULL_STRING ) - return FStrEq(STRING(targetname), STRING(m_target) ); - else - return false; -} - - -CBaseEntity *CBaseEntity::GetNextTarget( void ) -{ - if ( !m_target ) - return NULL; - return gEntList.FindEntityByName( NULL, m_target ); -} - -class CThinkContextsSaveDataOps : public CDefSaveRestoreOps -{ - virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) - { - AssertMsg( fieldInfo.pTypeDesc->fieldSize == 1, "CThinkContextsSaveDataOps does not support arrays"); - - // Write out the vector - CUtlVector< thinkfunc_t > *pUtlVector = (CUtlVector< thinkfunc_t > *)fieldInfo.pField; - SaveUtlVector( pSave, pUtlVector, FIELD_EMBEDDED ); - - // Get our owner - CBaseEntity *pOwner = (CBaseEntity*)fieldInfo.pOwner; - - pSave->StartBlock(); - // Now write out all the functions - for ( int i = 0; i < pUtlVector->Size(); i++ ) - { -#ifdef WIN32 - void **ppV = (void**)&((*pUtlVector)[i].m_pfnThink); -#else - BASEPTR *ppV = &((*pUtlVector)[i].m_pfnThink); -#endif - bool bHasFunc = (*ppV != NULL); - pSave->WriteBool( &bHasFunc, 1 ); - if ( bHasFunc ) - { - pSave->WriteFunction( pOwner->GetDataDescMap(), "m_pfnThink", (inputfunc_t **)ppV, 1 ); - } - } - pSave->EndBlock(); - } - - virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) - { - AssertMsg( fieldInfo.pTypeDesc->fieldSize == 1, "CThinkContextsSaveDataOps does not support arrays"); - - // Read in the vector - CUtlVector< thinkfunc_t > *pUtlVector = (CUtlVector< thinkfunc_t > *)fieldInfo.pField; - RestoreUtlVector( pRestore, pUtlVector, FIELD_EMBEDDED ); - - // Get our owner - CBaseEntity *pOwner = (CBaseEntity*)fieldInfo.pOwner; - - pRestore->StartBlock(); - // Now read in all the functions - for ( int i = 0; i < pUtlVector->Size(); i++ ) - { - bool bHasFunc; - pRestore->ReadBool( &bHasFunc, 1 ); -#ifdef WIN32 - void **ppV = (void**)&((*pUtlVector)[i].m_pfnThink); -#else - BASEPTR *ppV = &((*pUtlVector)[i].m_pfnThink); - Q_memset( (void *)ppV, 0x0, sizeof(inputfunc_t) ); -#endif - if ( bHasFunc ) - { - SaveRestoreRecordHeader_t header; - pRestore->ReadHeader( &header ); - pRestore->ReadFunction( pOwner->GetDataDescMap(), (inputfunc_t **)ppV, 1, header.size ); - } - else - { - *ppV = NULL; - } - } - pRestore->EndBlock(); - } - - virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) - { - CUtlVector< thinkfunc_t > *pUtlVector = (CUtlVector< thinkfunc_t > *)fieldInfo.pField; - return ( pUtlVector->Count() == 0 ); - } - - virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) - { - BASEPTR pFunc = *((BASEPTR*)fieldInfo.pField); - pFunc = NULL; - } -}; -CThinkContextsSaveDataOps g_ThinkContextsSaveDataOps; -ISaveRestoreOps *thinkcontextFuncs = &g_ThinkContextsSaveDataOps; - -BEGIN_SIMPLE_DATADESC( thinkfunc_t ) - - DEFINE_FIELD( m_iszContext, FIELD_STRING ), - // DEFINE_FIELD( m_pfnThink, FIELD_FUNCTION ), // Manually written - DEFINE_FIELD( m_nNextThinkTick, FIELD_TICK ), - DEFINE_FIELD( m_nLastThinkTick, FIELD_TICK ), - -END_DATADESC() - -BEGIN_SIMPLE_DATADESC( ResponseContext_t ) - - DEFINE_FIELD( m_iszName, FIELD_STRING ), - DEFINE_FIELD( m_iszValue, FIELD_STRING ), - DEFINE_FIELD( m_fExpirationTime, FIELD_TIME ), - -END_DATADESC() - -BEGIN_DATADESC_NO_BASE( CBaseEntity ) - - DEFINE_KEYFIELD( m_iClassname, FIELD_STRING, "classname" ), - DEFINE_GLOBAL_KEYFIELD( m_iGlobalname, FIELD_STRING, "globalname" ), - DEFINE_KEYFIELD( m_iParent, FIELD_STRING, "parentname" ), - - DEFINE_KEYFIELD( m_iHammerID, FIELD_INTEGER, "hammerid" ), // save ID numbers so that entities can be tracked between save/restore and vmf - - DEFINE_KEYFIELD( m_flSpeed, FIELD_FLOAT, "speed" ), - DEFINE_KEYFIELD( m_nRenderFX, FIELD_CHARACTER, "renderfx" ), - DEFINE_KEYFIELD( m_nRenderMode, FIELD_CHARACTER, "rendermode" ), - - // Consider moving to CBaseAnimating? - DEFINE_FIELD( m_flPrevAnimTime, FIELD_TIME ), - DEFINE_FIELD( m_flAnimTime, FIELD_TIME ), - DEFINE_FIELD( m_flSimulationTime, FIELD_TIME ), - DEFINE_FIELD( m_nLastThinkTick, FIELD_TICK ), - - DEFINE_KEYFIELD( m_nNextThinkTick, FIELD_TICK, "nextthink" ), - DEFINE_KEYFIELD( m_fEffects, FIELD_INTEGER, "effects" ), - DEFINE_KEYFIELD( m_clrRender, FIELD_COLOR32, "rendercolor" ), - DEFINE_GLOBAL_KEYFIELD( m_nModelIndex, FIELD_SHORT, "modelindex" ), -#if !defined( NO_ENTITY_PREDICTION ) - // DEFINE_FIELD( m_PredictableID, CPredictableId ), -#endif - DEFINE_FIELD( touchStamp, FIELD_INTEGER ), - DEFINE_CUSTOM_FIELD( m_aThinkFunctions, thinkcontextFuncs ), - // m_iCurrentThinkContext (not saved, debug field only, and think transient to boot) - - DEFINE_UTLVECTOR(m_ResponseContexts, FIELD_EMBEDDED), - DEFINE_KEYFIELD( m_iszResponseContext, FIELD_STRING, "ResponseContext" ), - - DEFINE_FIELD( m_pfnThink, FIELD_FUNCTION ), - DEFINE_FIELD( m_pfnTouch, FIELD_FUNCTION ), - DEFINE_FIELD( m_pfnUse, FIELD_FUNCTION ), - DEFINE_FIELD( m_pfnBlocked, FIELD_FUNCTION ), - DEFINE_FIELD( m_pfnMoveDone, FIELD_FUNCTION ), - - DEFINE_FIELD( m_lifeState, FIELD_CHARACTER ), - DEFINE_FIELD( m_takedamage, FIELD_CHARACTER ), - DEFINE_KEYFIELD( m_iMaxHealth, FIELD_INTEGER, "max_health" ), - DEFINE_KEYFIELD( m_iHealth, FIELD_INTEGER, "health" ), - // DEFINE_FIELD( m_pLink, FIELD_CLASSPTR ), - DEFINE_KEYFIELD( m_target, FIELD_STRING, "target" ), - - DEFINE_KEYFIELD( m_iszDamageFilterName, FIELD_STRING, "damagefilter" ), - DEFINE_FIELD( m_hDamageFilter, FIELD_EHANDLE ), - - DEFINE_FIELD( m_debugOverlays, FIELD_INTEGER ), - - DEFINE_GLOBAL_FIELD( m_pParent, FIELD_EHANDLE ), - DEFINE_FIELD( m_iParentAttachment, FIELD_CHARACTER ), - DEFINE_GLOBAL_FIELD( m_hMoveParent, FIELD_EHANDLE ), - DEFINE_GLOBAL_FIELD( m_hMoveChild, FIELD_EHANDLE ), - DEFINE_GLOBAL_FIELD( m_hMovePeer, FIELD_EHANDLE ), - - DEFINE_FIELD( m_iEFlags, FIELD_INTEGER ), - - DEFINE_FIELD( m_iName, FIELD_STRING ), - DEFINE_EMBEDDED( m_Collision ), - DEFINE_EMBEDDED( m_Network ), - - DEFINE_FIELD( m_MoveType, FIELD_CHARACTER ), - DEFINE_FIELD( m_MoveCollide, FIELD_CHARACTER ), - DEFINE_FIELD( m_hOwnerEntity, FIELD_EHANDLE ), - DEFINE_FIELD( m_CollisionGroup, FIELD_INTEGER ), - DEFINE_PHYSPTR( m_pPhysicsObject), - DEFINE_FIELD( m_flElasticity, FIELD_FLOAT ), - DEFINE_KEYFIELD( m_flShadowCastDistance, FIELD_FLOAT, "shadowcastdist" ), - DEFINE_FIELD( m_flDesiredShadowCastDistance, FIELD_FLOAT ), - - DEFINE_INPUT( m_iInitialTeamNum, FIELD_INTEGER, "TeamNum" ), - DEFINE_FIELD( m_iTeamNum, FIELD_INTEGER ), - -// DEFINE_FIELD( m_bSentLastFrame, FIELD_INTEGER ), - - DEFINE_FIELD( m_hGroundEntity, FIELD_EHANDLE ), - DEFINE_FIELD( m_flGroundChangeTime, FIELD_TIME ), - DEFINE_GLOBAL_KEYFIELD( m_ModelName, FIELD_MODELNAME, "model" ), - - DEFINE_KEYFIELD( m_vecBaseVelocity, FIELD_VECTOR, "basevelocity" ), - DEFINE_FIELD( m_vecAbsVelocity, FIELD_VECTOR ), - DEFINE_KEYFIELD( m_vecAngVelocity, FIELD_VECTOR, "avelocity" ), -// DEFINE_FIELD( m_vecAbsAngVelocity, FIELD_VECTOR ), - DEFINE_ARRAY( m_rgflCoordinateFrame, FIELD_FLOAT, 12 ), // NOTE: MUST BE IN LOCAL SPACE, NOT POSITION_VECTOR!!! (see CBaseEntity::Restore) - - DEFINE_KEYFIELD( m_nWaterLevel, FIELD_CHARACTER, "waterlevel" ), - DEFINE_FIELD( m_nWaterType, FIELD_CHARACTER ), - DEFINE_FIELD( m_pBlocker, FIELD_EHANDLE ), - - DEFINE_KEYFIELD( m_flGravity, FIELD_FLOAT, "gravity" ), - DEFINE_KEYFIELD( m_flFriction, FIELD_FLOAT, "friction" ), - - // Local time is local to each object. It doesn't need to be re-based if the clock - // changes. Therefore it is saved as a FIELD_FLOAT, not a FIELD_TIME - DEFINE_KEYFIELD( m_flLocalTime, FIELD_FLOAT, "ltime" ), - DEFINE_FIELD( m_flVPhysicsUpdateLocalTime, FIELD_FLOAT ), - DEFINE_FIELD( m_flMoveDoneTime, FIELD_FLOAT ), - -// DEFINE_FIELD( m_nPushEnumCount, FIELD_INTEGER ), - - DEFINE_FIELD( m_vecAbsOrigin, FIELD_POSITION_VECTOR ), - DEFINE_KEYFIELD( m_vecVelocity, FIELD_VECTOR, "velocity" ), - DEFINE_KEYFIELD( m_iTextureFrameIndex, FIELD_CHARACTER, "texframeindex" ), - DEFINE_FIELD( m_bSimulatedEveryTick, FIELD_BOOLEAN ), - DEFINE_FIELD( m_bAnimatedEveryTick, FIELD_BOOLEAN ), - DEFINE_FIELD( m_bAlternateSorting, FIELD_BOOLEAN ), - DEFINE_KEYFIELD( m_spawnflags, FIELD_INTEGER, "spawnflags" ), - DEFINE_FIELD( m_nTransmitStateOwnedCounter, FIELD_CHARACTER ), - DEFINE_FIELD( m_angAbsRotation, FIELD_VECTOR ), - DEFINE_FIELD( m_vecOrigin, FIELD_VECTOR ), // NOTE: MUST BE IN LOCAL SPACE, NOT POSITION_VECTOR!!! (see CBaseEntity::Restore) - DEFINE_FIELD( m_angRotation, FIELD_VECTOR ), - - DEFINE_KEYFIELD( m_vecViewOffset, FIELD_VECTOR, "view_ofs" ), - - DEFINE_FIELD( m_fFlags, FIELD_INTEGER ), -#if !defined( NO_ENTITY_PREDICTION ) -// DEFINE_FIELD( m_bIsPlayerSimulated, FIELD_INTEGER ), -// DEFINE_FIELD( m_hPlayerSimulationOwner, FIELD_EHANDLE ), -#endif - // DEFINE_FIELD( m_pTimedOverlay, TimedOverlay_t* ), - DEFINE_FIELD( m_nSimulationTick, FIELD_TICK ), - // DEFINE_FIELD( m_RefEHandle, CBaseHandle ), - -// DEFINE_FIELD( m_nWaterTouch, FIELD_INTEGER ), -// DEFINE_FIELD( m_nSlimeTouch, FIELD_INTEGER ), - DEFINE_FIELD( m_flNavIgnoreUntilTime, FIELD_TIME ), - -// DEFINE_FIELD( m_bToolRecording, FIELD_BOOLEAN ), -// DEFINE_FIELD( m_ToolHandle, FIELD_INTEGER ), - - // NOTE: This is tricky. TeamNum must be saved, but we can't directly - // read it in, because we can only set it after the team entity has been read in, - // which may or may not actually occur before the entity is parsed. - // Therefore, we set the TeamNum from the InitialTeamNum in Activate - DEFINE_INPUTFUNC( FIELD_INTEGER, "SetTeam", InputSetTeam ), - - DEFINE_INPUTFUNC( FIELD_VOID, "Kill", InputKill ), - DEFINE_INPUTFUNC( FIELD_VOID, "KillHierarchy", InputKillHierarchy ), - DEFINE_INPUTFUNC( FIELD_VOID, "Use", InputUse ), - DEFINE_INPUTFUNC( FIELD_INTEGER, "Alpha", InputAlpha ), - DEFINE_INPUTFUNC( FIELD_BOOLEAN, "AlternativeSorting", InputAlternativeSorting ), - DEFINE_INPUTFUNC( FIELD_COLOR32, "Color", InputColor ), - DEFINE_INPUTFUNC( FIELD_STRING, "SetParent", InputSetParent ), - DEFINE_INPUTFUNC( FIELD_STRING, "SetParentAttachment", InputSetParentAttachment ), - DEFINE_INPUTFUNC( FIELD_STRING, "SetParentAttachmentMaintainOffset", InputSetParentAttachmentMaintainOffset ), - DEFINE_INPUTFUNC( FIELD_VOID, "ClearParent", InputClearParent ), - DEFINE_INPUTFUNC( FIELD_STRING, "SetDamageFilter", InputSetDamageFilter ), - - DEFINE_INPUTFUNC( FIELD_VOID, "EnableDamageForces", InputEnableDamageForces ), - DEFINE_INPUTFUNC( FIELD_VOID, "DisableDamageForces", InputDisableDamageForces ), - - DEFINE_INPUTFUNC( FIELD_STRING, "DispatchEffect", InputDispatchEffect ), - DEFINE_INPUTFUNC( FIELD_STRING, "DispatchResponse", InputDispatchResponse ), - - // Entity I/O methods to alter context - DEFINE_INPUTFUNC( FIELD_STRING, "AddContext", InputAddContext ), - DEFINE_INPUTFUNC( FIELD_STRING, "RemoveContext", InputRemoveContext ), - DEFINE_INPUTFUNC( FIELD_STRING, "ClearContext", InputClearContext ), - - DEFINE_INPUTFUNC( FIELD_VOID, "DisableShadow", InputDisableShadow ), - DEFINE_INPUTFUNC( FIELD_VOID, "EnableShadow", InputEnableShadow ), - - DEFINE_INPUTFUNC( FIELD_STRING, "AddOutput", InputAddOutput ), - - DEFINE_INPUTFUNC( FIELD_STRING, "FireUser1", InputFireUser1 ), - DEFINE_INPUTFUNC( FIELD_STRING, "FireUser2", InputFireUser2 ), - DEFINE_INPUTFUNC( FIELD_STRING, "FireUser3", InputFireUser3 ), - DEFINE_INPUTFUNC( FIELD_STRING, "FireUser4", InputFireUser4 ), - - DEFINE_OUTPUT( m_OnUser1, "OnUser1" ), - DEFINE_OUTPUT( m_OnUser2, "OnUser2" ), - DEFINE_OUTPUT( m_OnUser3, "OnUser3" ), - DEFINE_OUTPUT( m_OnUser4, "OnUser4" ), - - // Function Pointers - DEFINE_FUNCTION( SUB_Remove ), - DEFINE_FUNCTION( SUB_DoNothing ), - DEFINE_FUNCTION( SUB_StartFadeOut ), - DEFINE_FUNCTION( SUB_StartFadeOutInstant ), - DEFINE_FUNCTION( SUB_FadeOut ), - DEFINE_FUNCTION( SUB_Vanish ), - DEFINE_FUNCTION( SUB_CallUseToggle ), - DEFINE_THINKFUNC( ShadowCastDistThink ), - - DEFINE_FIELD( m_hEffectEntity, FIELD_EHANDLE ), - - //DEFINE_FIELD( m_DamageModifiers, FIELD_?? ), // can't save? - // DEFINE_FIELD( m_fDataObjectTypes, FIELD_INTEGER ), - -#ifdef TF_DLL - DEFINE_ARRAY( m_nModelIndexOverrides, FIELD_INTEGER, MAX_VISION_MODES ), -#endif - -END_DATADESC() - -// For code error checking -extern bool g_bReceivedChainedUpdateOnRemove; - -//----------------------------------------------------------------------------- -// Purpose: Called just prior to object destruction -// Entities that need to unlink themselves from other entities should do the unlinking -// here rather than in their destructor. The reason why is that when the global entity list -// is told to Clear(), it first takes a pass through all active entities and calls UTIL_Remove -// on each such entity. Then it calls the delete function on each deleted entity in the list. -// In the old code, the objects were simply destroyed in order and there was no guarantee that the -// destructor of one object would not try to access another object that might already have been -// destructed (especially since the entity list order is more or less random!). -// NOTE: You should never call delete directly on an entity (there's an assert now), see note -// at CBaseEntity::~CBaseEntity for more information. -// -// NOTE: You should chain to BaseClass::UpdateOnRemove after doing your own cleanup code, e.g.: -// -// void CDerived::UpdateOnRemove( void ) -// { -// ... cleanup code -// ... -// -// BaseClass::UpdateOnRemove(); -// } -// -// In general, this function updates global tables that need to know about entities being removed -//----------------------------------------------------------------------------- -void CBaseEntity::UpdateOnRemove( void ) -{ - g_bReceivedChainedUpdateOnRemove = true; - - // Virtual call to shut down any looping sounds. - StopLoopingSounds(); - - // Notifies entity listeners, etc - gEntList.NotifyRemoveEntity( GetRefEHandle() ); - - if ( edict() ) - { - AddFlag( FL_KILLME ); - if ( GetFlags() & FL_GRAPHED ) - { - /* <> - // this entity was a LinkEnt in the world node graph, so we must remove it from - // the graph since we are removing it from the world. - for ( int i = 0 ; i < WorldGraph.m_cLinks ; i++ ) - { - if ( WorldGraph.m_pLinkPool [ i ].m_pLinkEnt == pev ) - { - // if this link has a link ent which is the same ent that is removing itself, remove it! - WorldGraph.m_pLinkPool [ i ].m_pLinkEnt = NULL; - } - } - */ - } - } - - if ( m_iGlobalname != NULL_STRING ) - { - // NOTE: During level shutdown the global list will suppress this - // it assumes your changing levels or the game will end - // causing the whole list to be flushed - GlobalEntity_SetState( m_iGlobalname, GLOBAL_DEAD ); - } - - VPhysicsDestroyObject(); - - // This is only here to allow the MOVETYPE_NONE to be set without the - // assertion triggering. Why do we bother setting the MOVETYPE to none here? - RemoveEffects( EF_BONEMERGE ); - SetMoveType(MOVETYPE_NONE); - - // If we have a parent, unlink from it. - UnlinkFromParent( this ); - - // Any children still connected are orphans, mark all for delete - CUtlVector childrenList; - GetAllChildren( this, childrenList ); - if ( childrenList.Count() ) - { - DevMsg( 2, "Warning: Deleting orphaned children of %s\n", GetClassname() ); - for ( int i = childrenList.Count()-1; i >= 0; --i ) - { - UTIL_Remove( childrenList[i] ); - } - } - - SetGroundEntity( NULL ); - - if ( m_bDynamicModelPending ) - { - sg_DynamicLoadHandlers.Remove( this ); - } - - if ( IsDynamicModelIndex( m_nModelIndex ) ) - { - modelinfo->ReleaseDynamicModel( m_nModelIndex ); // no-op if not dynamic - m_nModelIndex = -1; - } -} - -//----------------------------------------------------------------------------- -// capabilities -//----------------------------------------------------------------------------- -int CBaseEntity::ObjectCaps( void ) -{ -#if 1 - model_t *pModel = GetModel(); - bool bIsBrush = ( pModel && modelinfo->GetModelType( pModel ) == mod_brush ); - - // We inherit our parent's use capabilities so that we can forward use commands - // to our parent. - CBaseEntity *pParent = GetParent(); - if ( pParent ) - { - int caps = pParent->ObjectCaps(); - - if ( !bIsBrush ) - caps &= ( FCAP_ACROSS_TRANSITION | FCAP_IMPULSE_USE | FCAP_CONTINUOUS_USE | FCAP_ONOFF_USE | FCAP_DIRECTIONAL_USE ); - else - caps &= ( FCAP_IMPULSE_USE | FCAP_CONTINUOUS_USE | FCAP_ONOFF_USE | FCAP_DIRECTIONAL_USE ); - - if ( pParent->IsPlayer() ) - caps |= FCAP_ACROSS_TRANSITION; - - return caps; - } - else if ( !bIsBrush ) - { - return FCAP_ACROSS_TRANSITION; - } - - return 0; -#else - // We inherit our parent's use capabilities so that we can forward use commands - // to our parent. - int parentCaps = 0; - if (GetParent()) - { - parentCaps = GetParent()->ObjectCaps(); - parentCaps &= ( FCAP_IMPULSE_USE | FCAP_CONTINUOUS_USE | FCAP_ONOFF_USE | FCAP_DIRECTIONAL_USE ); - } - - model_t *pModel = GetModel(); - if ( pModel && modelinfo->GetModelType( pModel ) == mod_brush ) - return parentCaps; - - return FCAP_ACROSS_TRANSITION | parentCaps; -#endif -} - -void CBaseEntity::StartTouch( CBaseEntity *pOther ) -{ - // notify parent - if ( m_pParent != NULL ) - m_pParent->StartTouch( pOther ); -} - -void CBaseEntity::Touch( CBaseEntity *pOther ) -{ - if ( m_pfnTouch ) - (this->*m_pfnTouch)( pOther ); - - // notify parent of touch - if ( m_pParent != NULL ) - m_pParent->Touch( pOther ); -} - -void CBaseEntity::EndTouch( CBaseEntity *pOther ) -{ - // notify parent - if ( m_pParent != NULL ) - { - m_pParent->EndTouch( pOther ); - } -} - - -//----------------------------------------------------------------------------- -// Purpose: Dispatches blocked events to this entity's blocked handler, set via SetBlocked. -// Input : pOther - The entity that is blocking us. -//----------------------------------------------------------------------------- -void CBaseEntity::Blocked( CBaseEntity *pOther ) -{ - if ( m_pfnBlocked ) - { - (this->*m_pfnBlocked)( pOther ); - } - - // - // Forward the blocked event to our parent, if any. - // - if ( m_pParent != NULL ) - { - m_pParent->Blocked( pOther ); - } -} - - -//----------------------------------------------------------------------------- -// Purpose: Dispatches use events to this entity's use handler, set via SetUse. -// Input : pActivator - -// pCaller - -// useType - -// value - -//----------------------------------------------------------------------------- -void CBaseEntity::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) -{ - if ( m_pfnUse != NULL ) - { - (this->*m_pfnUse)( pActivator, pCaller, useType, value ); - } - else - { - // - // We don't handle use events. Forward to our parent, if any. - // - if ( m_pParent != NULL ) - { - m_pParent->Use( pActivator, pCaller, useType, value ); - } - } -} - -static CBaseEntity *FindPhysicsBlocker( IPhysicsObject *pPhysics, physicspushlist_t &list, const Vector &pushVel ) -{ - IPhysicsFrictionSnapshot *pSnapshot = pPhysics->CreateFrictionSnapshot(); - CBaseEntity *pBlocker = NULL; - float maxForce = 0; - while ( pSnapshot->IsValid() ) - { - IPhysicsObject *pOther = pSnapshot->GetObject(1); - CBaseEntity *pOtherEntity = static_cast(pOther->GetGameData()); - bool inList = false; - for ( int i = 0; i < list.pushedCount; i++ ) - { - if ( pOtherEntity == list.pushedEnts[i] ) - { - inList = true; - break; - } - } - - Vector normal; - pSnapshot->GetSurfaceNormal(normal); - float dot = DotProduct( pushVel, pSnapshot->GetNormalForce() * normal ); - if ( !pBlocker || (!inList && dot > maxForce) ) - { - pBlocker = pOtherEntity; - if ( !inList ) - { - maxForce = dot; - } - } - - pSnapshot->NextFrictionData(); - } - pPhysics->DestroyFrictionSnapshot( pSnapshot ); - - return pBlocker; -} - - -struct pushblock_t -{ - physicspushlist_t *pList; - CBaseEntity *pRootParent; - CBaseEntity *pBlockedEntity; - float moveBackFraction; - float movetime; -}; - -static void ComputePushStartMatrix( matrix3x4_t &start, CBaseEntity *pEntity, const pushblock_t ¶ms ) -{ - Vector localOrigin; - QAngle localAngles; - if ( params.pList ) - { - localOrigin = params.pList->localOrigin; - localAngles = params.pList->localAngles; - } - else - { - localOrigin = params.pRootParent->GetAbsOrigin() - params.pRootParent->GetAbsVelocity() * params.movetime; - localAngles = params.pRootParent->GetAbsAngles() - params.pRootParent->GetLocalAngularVelocity() * params.movetime; - } - matrix3x4_t xform, delta; - AngleMatrix( localAngles, localOrigin, xform ); - - matrix3x4_t srcInv; - // xform = src(-1) * dest - MatrixInvert( params.pRootParent->EntityToWorldTransform(), srcInv ); - ConcatTransforms( xform, srcInv, delta ); - ConcatTransforms( delta, pEntity->EntityToWorldTransform(), start ); -} - -#define DEBUG_PUSH_MESSAGES 0 -static void CheckPushedEntity( CBaseEntity *pEntity, pushblock_t ¶ms ) -{ - IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject(); - if ( !pPhysics ) - return; - // somehow we've got a static or motion disabled physics object in hierarchy! - // This is not allowed! Don't test blocking in that case. - Assert(pPhysics->IsMoveable()); - if ( !pPhysics->IsMoveable() || !pPhysics->GetShadowController() ) - { -#if DEBUG_PUSH_MESSAGES - Msg("Blocking %s, not moveable!\n", pEntity->GetClassname()); -#endif - return; - } - - bool checkrot = true; - bool checkmove = true; - Vector origin; - QAngle angles; - pPhysics->GetShadowPosition( &origin, &angles ); - float fraction = -1.0f; - - matrix3x4_t parentDelta; - if ( pEntity == params.pRootParent ) - { - if ( pEntity->GetLocalAngularVelocity() == vec3_angle ) - checkrot = false; - if ( pEntity->GetLocalVelocity() == vec3_origin) - checkmove = false; - } - else - { -#if DEBUG_PUSH_MESSAGES - if ( pPhysics->IsAttachedToConstraint(false)) - { - Msg("Warning, hierarchical entity is attached to a constraint %s\n", pEntity->GetClassname()); - } -#endif - } - - if ( checkmove ) - { - // project error onto the axis of movement - Vector dir = pEntity->GetAbsVelocity(); - float speed = VectorNormalize(dir); - Vector targetPos; - pPhysics->GetShadowController()->GetTargetPosition( &targetPos, NULL ); - float targetAmount = DotProduct(targetPos, dir); - float currentAmount = DotProduct(origin, dir); - float entityAmount = DotProduct(pEntity->GetAbsOrigin(), dir); - - // if target and entity origin are not in sync, then the position of the entity was updated - // by something outside of push physics - if ( (targetAmount - entityAmount) > 1 ) - { - pEntity->UpdatePhysicsShadowToCurrentPosition(0); -#if DEBUG_PUSH_MESSAGES - Warning("Someone slammed the position of a %s\n", pEntity->GetClassname() ); -#endif - } - else - { - float dist = targetAmount - currentAmount; - if ( dist > 1 ) - { - #if DEBUG_PUSH_MESSAGES - const char *pName = pEntity->GetClassname(); - Msg( "%s blocked by %.2f units\n", pName, dist ); - #endif - float movementAmount = targetAmount - (speed * params.movetime); - if ( pEntity == params.pRootParent ) - { - if ( params.pList ) - { - Vector localVel = pEntity->GetLocalVelocity(); - VectorNormalize(localVel); - float localTargetAmt = DotProduct(pEntity->GetLocalOrigin(), localVel); - movementAmount = targetAmount + DotProduct(params.pList->localOrigin, localVel) - localTargetAmt; - } - } - else - { - matrix3x4_t start; - ComputePushStartMatrix( start, pEntity, params ); - Vector startPos; - MatrixPosition( start, startPos ); - movementAmount = DotProduct(startPos, dir); - } - float expectedDist = targetAmount - movementAmount; - // compute the fraction to move back the AI to match the physics - if ( expectedDist <= 0 ) - { - fraction = 1; - } - else - { - fraction = dist / expectedDist; - fraction = clamp(fraction, 0.f, 1.f); - } - } - } - } - - if ( checkrot ) - { - Vector axis; - float deltaAngle; - RotationDeltaAxisAngle( angles, pEntity->GetAbsAngles(), axis, deltaAngle ); - if ( fabsf(deltaAngle) > 0.5f ) - { - Vector targetAxis; - QAngle targetRot; - float deltaTargetAngle; - pPhysics->GetShadowController()->GetTargetPosition( NULL, &targetRot ); - RotationDeltaAxisAngle( angles, targetRot, targetAxis, deltaTargetAngle ); - if ( fabsf(deltaTargetAngle) > 0.01f ) - { - float expectedDist = deltaAngle; -#if DEBUG_PUSH_MESSAGES - const char *pName = pEntity->GetClassname(); - Msg( "%s blocked by %.2f degrees\n", pName, deltaAngle ); - if ( pPhysics->IsAsleep() ) - { - Msg("Asleep while blocked?\n"); - } - if ( pPhysics->GetGameFlags() & FVPHYSICS_PENETRATING ) - { - Msg("Blocking for penetration!\n"); - } -#endif - if ( pEntity == params.pRootParent ) - { - expectedDist = pEntity->GetLocalAngularVelocity().Length() * params.movetime; - } - else - { - matrix3x4_t start; - ComputePushStartMatrix( start, pEntity, params ); - Vector startAxis; - float startAngle; - Vector startPos; - QAngle startAngles; - MatrixAngles( start, startAngles, startPos ); - RotationDeltaAxisAngle( startAngles, pEntity->GetAbsAngles(), startAxis, startAngle ); - expectedDist = startAngle * DotProduct( startAxis, axis ); - } - - float t = expectedDist != 0.0f ? fabsf(deltaAngle / expectedDist) : 1.0f; - t = clamp(t,0.f,1.f); - fraction = MAX(fraction, t); - } - else - { - pEntity->UpdatePhysicsShadowToCurrentPosition(0); -#if DEBUG_PUSH_MESSAGES - Warning("Someone slammed the position of a %s\n", pEntity->GetClassname() ); -#endif - } - } - } - if ( fraction >= params.moveBackFraction ) - { - params.moveBackFraction = fraction; - params.pBlockedEntity = pEntity; - } -} - -void CBaseEntity::VPhysicsUpdatePusher( IPhysicsObject *pPhysics ) -{ - float movetime = m_flLocalTime - m_flVPhysicsUpdateLocalTime; - if (movetime <= 0) - return; - - // only reconcile pushers on the final vphysics tick - if ( !PhysIsFinalTick() ) - return; - - Vector origin; - QAngle angles; - - // physics updated the shadow, so check to see if I got blocked - // NOTE: SOLID_BSP cannont compute consistent collisions wrt vphysics, so - // don't allow vphysics to block. Assume game physics has handled it. - if ( GetSolid() != SOLID_BSP && pPhysics->GetShadowPosition( &origin, &angles ) ) - { - CUtlVector list; - GetAllInHierarchy( this, list ); - //NDebugOverlay::BoxAngles( origin, CollisionProp()->OBBMins(), CollisionProp()->OBBMaxs(), angles, 255,0,0,0, gpGlobals->frametime); - - physicspushlist_t *pList = NULL; - if ( HasDataObjectType(PHYSICSPUSHLIST) ) - { - pList = (physicspushlist_t *)GetDataObject( PHYSICSPUSHLIST ); - Assert(pList); - } - bool checkrot = (GetLocalAngularVelocity() != vec3_angle) ? true : false; - bool checkmove = (GetLocalVelocity() != vec3_origin) ? true : false; - - pushblock_t params; - params.pRootParent = this; - params.pList = pList; - params.pBlockedEntity = NULL; - params.moveBackFraction = 0.0f; - params.movetime = movetime; - for ( int i = 0; i < list.Count(); i++ ) - { - if ( list[i]->IsSolid() ) - { - CheckPushedEntity( list[i], params ); - } - } - - float physLocalTime = m_flLocalTime; - if ( params.pBlockedEntity ) - { - float moveback = movetime * params.moveBackFraction; - if ( moveback > 0 ) - { - physLocalTime = m_flLocalTime - moveback; - // add 1% noise for bouncing in collision. - if ( physLocalTime <= (m_flVPhysicsUpdateLocalTime + movetime * 0.99f) ) - { - CBaseEntity *pBlocked = NULL; - IPhysicsObject *pOther; - if ( params.pBlockedEntity->VPhysicsGetObject()->GetContactPoint( NULL, &pOther ) ) - { - pBlocked = static_cast(pOther->GetGameData()); - } - // UNDONE: Need to traverse hierarchy here? Shouldn't. - if ( pList ) - { - SetLocalOrigin( pList->localOrigin ); - SetLocalAngles( pList->localAngles ); - physLocalTime = pList->localMoveTime; - for ( int i = 0; i < pList->pushedCount; i++ ) - { - CBaseEntity *pEntity = pList->pushedEnts[i]; - if ( !pEntity ) - continue; - - pEntity->SetAbsOrigin( pEntity->GetAbsOrigin() - pList->pushVec[i] ); - } - CBaseEntity *pPhysicsBlocker = FindPhysicsBlocker( VPhysicsGetObject(), *pList, pList->pushVec[0] ); - if ( pPhysicsBlocker ) - { - pBlocked = pPhysicsBlocker; - } - } - else - { - Vector origin = GetLocalOrigin(); - QAngle angles = GetLocalAngles(); - - if ( checkmove ) - { - origin -= GetLocalVelocity() * moveback; - } - if ( checkrot ) - { - // BUGBUG: This is pretty hack-tastic! - angles -= GetLocalAngularVelocity() * moveback; - } - - SetLocalOrigin( origin ); - SetLocalAngles( angles ); - } - - if ( pBlocked ) - { - Blocked( pBlocked ); - } - m_flLocalTime = physLocalTime; - } - } - } - } - - // this data is no longer useful, free the memory - if ( HasDataObjectType(PHYSICSPUSHLIST) ) - { - DestroyDataObject( PHYSICSPUSHLIST ); - } - - m_flVPhysicsUpdateLocalTime = m_flLocalTime; - if ( m_flMoveDoneTime <= m_flLocalTime && m_flMoveDoneTime > 0 ) - { - SetMoveDoneTime( -1 ); - MoveDone(); - } -} - - -void CBaseEntity::SetMoveDoneTime( float flDelay ) -{ - if (flDelay >= 0) - { - m_flMoveDoneTime = GetLocalTime() + flDelay; - } - else - { - m_flMoveDoneTime = -1; - } - CheckHasGamePhysicsSimulation(); -} - -//----------------------------------------------------------------------------- -// Purpose: Relinks all of a parents children into the collision tree -//----------------------------------------------------------------------------- -void CBaseEntity::PhysicsRelinkChildren( float dt ) -{ - CBaseEntity *child; - - // iterate through all children - for ( child = FirstMoveChild(); child != NULL; child = child->NextMovePeer() ) - { - if ( child->IsSolid() || child->IsSolidFlagSet(FSOLID_TRIGGER) ) - { - child->PhysicsTouchTriggers(); - } - - // - // Update their physics shadows. We should never have any children of - // movetype VPHYSICS. - // - if ( child->GetMoveType() != MOVETYPE_VPHYSICS ) - { - child->UpdatePhysicsShadowToCurrentPosition( dt ); - } - else if ( child->GetOwnerEntity() != this ) - { - // the only case where this is valid is if this entity is an attached ragdoll. - // So assert here to catch the non-ragdoll case. - Assert( 0 ); - } - - if ( child->FirstMoveChild() ) - { - child->PhysicsRelinkChildren(dt); - } - } -} - -void CBaseEntity::PhysicsTouchTriggers( const Vector *pPrevAbsOrigin ) -{ - edict_t *pEdict = edict(); - if ( pEdict && !IsWorld() ) - { - Assert(CollisionProp()); - bool isTriggerCheckSolids = IsSolidFlagSet( FSOLID_TRIGGER ); - bool isSolidCheckTriggers = IsSolid() && !isTriggerCheckSolids; // NOTE: Moving triggers (items, ammo etc) are not - // checked against other triggers to reduce the number of touchlinks created - if ( !(isSolidCheckTriggers || isTriggerCheckSolids) ) - return; - - if ( GetSolid() == SOLID_BSP ) - { - if ( !GetModel() && Q_strlen( STRING( GetModelName() ) ) == 0 ) - { - Warning( "Inserted %s with no model\n", GetClassname() ); - return; - } - } - - SetCheckUntouch( true ); - if ( isSolidCheckTriggers ) - { - engine->SolidMoved( pEdict, CollisionProp(), pPrevAbsOrigin, sm_bAccurateTriggerBboxChecks ); - } - if ( isTriggerCheckSolids ) - { - engine->TriggerMoved( pEdict, sm_bAccurateTriggerBboxChecks ); - } - } -} - -void CBaseEntity::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent ) -{ -} - - - -void CBaseEntity::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) -{ - // filter out ragdoll props hitting other parts of itself too often - // UNDONE: Store a sound time for this entity (not just this pair of objects) - // and filter repeats on that? - int otherIndex = !index; - CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex]; - - // Don't make sounds / effects if neither entity is MOVETYPE_VPHYSICS. The game - // physics should have done so. - if ( GetMoveType() != MOVETYPE_VPHYSICS && pHitEntity->GetMoveType() != MOVETYPE_VPHYSICS ) - return; - - if ( pEvent->deltaCollisionTime < 0.5 && (pHitEntity == this) ) - return; - - // don't make noise for hidden/invisible/sky materials - surfacedata_t *phit = physprops->GetSurfaceData( pEvent->surfaceProps[otherIndex] ); - const surfacedata_t *pprops = physprops->GetSurfaceData( pEvent->surfaceProps[index] ); - if ( phit->game.material == 'X' || pprops->game.material == 'X' ) - return; - - if ( pHitEntity == this ) - { - PhysCollisionSound( this, pEvent->pObjects[index], CHAN_BODY, pEvent->surfaceProps[index], pEvent->surfaceProps[otherIndex], pEvent->deltaCollisionTime, pEvent->collisionSpeed ); - } - else - { - PhysCollisionSound( this, pEvent->pObjects[index], CHAN_STATIC, pEvent->surfaceProps[index], pEvent->surfaceProps[otherIndex], pEvent->deltaCollisionTime, pEvent->collisionSpeed ); - } - PhysCollisionScreenShake( pEvent, index ); - -#if HL2_EPISODIC - // episodic does something different for when advisor shields are struck - if ( phit->game.material == 'Z' || pprops->game.material == 'Z') - { - PhysCollisionWarpEffect( pEvent, phit ); - } - else - { - PhysCollisionDust( pEvent, phit ); - } -#else - PhysCollisionDust( pEvent, phit ); -#endif -} - -void CBaseEntity::VPhysicsFriction( IPhysicsObject *pObject, float energy, int surfaceProps, int surfacePropsHit ) -{ - PhysFrictionSound( this, pObject, energy, surfaceProps, surfacePropsHit ); -} - - -void CBaseEntity::VPhysicsSwapObject( IPhysicsObject *pSwap ) -{ - if ( !pSwap ) - { - PhysRemoveShadow(this); - } - - if ( !m_pPhysicsObject ) - { - Warning( "Bad vphysics swap for %s\n", STRING(m_iClassname) ); - } - m_pPhysicsObject = pSwap; -} - - -// Tells the physics shadow to update it's target to the current position -void CBaseEntity::UpdatePhysicsShadowToCurrentPosition( float deltaTime ) -{ - if ( GetMoveType() != MOVETYPE_VPHYSICS ) - { - IPhysicsObject *pPhys = VPhysicsGetObject(); - if ( pPhys ) - { - pPhys->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, deltaTime ); - } - } -} - -int CBaseEntity::VPhysicsGetObjectList( IPhysicsObject **pList, int listMax ) -{ - IPhysicsObject *pPhys = VPhysicsGetObject(); - if ( pPhys ) - { - // multi-object entities must implement this function - Assert( !(pPhys->GetGameFlags() & FVPHYSICS_MULTIOBJECT_ENTITY) ); - if ( listMax > 0 ) - { - pList[0] = pPhys; - return 1; - } - } - return 0; -} - -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -bool CBaseEntity::VPhysicsIsFlesh( void ) -{ - IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT]; - int count = VPhysicsGetObjectList( pList, ARRAYSIZE(pList) ); - for ( int i = 0; i < count; i++ ) - { - int material = pList[i]->GetMaterialIndex(); - const surfacedata_t *pSurfaceData = physprops->GetSurfaceData( material ); - // Is flesh ?, don't allow pickup - if ( pSurfaceData->game.material == CHAR_TEX_ANTLION || pSurfaceData->game.material == CHAR_TEX_FLESH || pSurfaceData->game.material == CHAR_TEX_BLOODYFLESH || pSurfaceData->game.material == CHAR_TEX_ALIENFLESH ) - return true; - } - return false; -} - -bool CBaseEntity::Intersects( CBaseEntity *pOther ) -{ - if ( !edict() || !pOther->edict() ) - return false; - - CCollisionProperty *pMyProp = CollisionProp(); - CCollisionProperty *pOtherProp = pOther->CollisionProp(); - - return IsOBBIntersectingOBB( - pMyProp->GetCollisionOrigin(), pMyProp->GetCollisionAngles(), pMyProp->OBBMins(), pMyProp->OBBMaxs(), - pOtherProp->GetCollisionOrigin(), pOtherProp->GetCollisionAngles(), pOtherProp->OBBMins(), pOtherProp->OBBMaxs() ); -} - -extern ConVar ai_LOS_mode; - -//========================================================= -// FVisible - returns true if a line can be traced from -// the caller's eyes to the target -//========================================================= -bool CBaseEntity::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker ) -{ - VPROF( "CBaseEntity::FVisible" ); - - if ( pEntity->GetFlags() & FL_NOTARGET ) - return false; - -#if HL1_DLL - // FIXME: only block LOS through opaque water - // don't look through water - if ((m_nWaterLevel != 3 && pEntity->m_nWaterLevel == 3) - || (m_nWaterLevel == 3 && pEntity->m_nWaterLevel == 0)) - return false; -#endif - - Vector vecLookerOrigin = EyePosition();//look through the caller's 'eyes' - Vector vecTargetOrigin = pEntity->EyePosition(); - - trace_t tr; - if ( !IsXbox() && ai_LOS_mode.GetBool() ) - { - UTIL_TraceLine(vecLookerOrigin, vecTargetOrigin, traceMask, this, COLLISION_GROUP_NONE, &tr); - } - else - { - // If we're doing an LOS search, include NPCs. - if ( traceMask == MASK_BLOCKLOS ) - { - traceMask = MASK_BLOCKLOS_AND_NPCS; - } - - // Player sees through nodraw - if ( IsPlayer() ) - { - traceMask &= ~CONTENTS_BLOCKLOS; - } - - // Use the custom LOS trace filter - CTraceFilterLOS traceFilter( this, COLLISION_GROUP_NONE, pEntity ); - UTIL_TraceLine( vecLookerOrigin, vecTargetOrigin, traceMask, &traceFilter, &tr ); - } - - if (tr.fraction != 1.0 || tr.startsolid ) - { - // If we hit the entity we're looking for, it's visible - if ( tr.m_pEnt == pEntity ) - return true; - - // Got line of sight on the vehicle the player is driving! - if ( pEntity && pEntity->IsPlayer() ) - { - CBasePlayer *pPlayer = assert_cast( pEntity ); - if ( tr.m_pEnt == pPlayer->GetVehicleEntity() ) - return true; - } - - if (ppBlocker) - { - *ppBlocker = tr.m_pEnt; - } - - return false;// Line of sight is not established - } - - return true;// line of sight is valid. -} - -//========================================================= -// FVisible - returns true if a line can be traced from -// the caller's eyes to the wished position. -//========================================================= -bool CBaseEntity::FVisible( const Vector &vecTarget, int traceMask, CBaseEntity **ppBlocker ) -{ -#if HL1_DLL - - // don't look through water - // FIXME: only block LOS through opaque water - bool inWater = ( UTIL_PointContents( vecTarget ) & (CONTENTS_SLIME|CONTENTS_WATER) ) ? true : false; - - // Don't allow it if we're straddling two areas - if ( ( m_nWaterLevel == 3 && !inWater ) || ( m_nWaterLevel != 3 && inWater ) ) - return false; - -#endif - - trace_t tr; - Vector vecLookerOrigin = EyePosition();// look through the caller's 'eyes' - - if ( ai_LOS_mode.GetBool() ) - { - UTIL_TraceLine( vecLookerOrigin, vecTarget, traceMask, this, COLLISION_GROUP_NONE, &tr); - } - else - { - // If we're doing an LOS search, include NPCs. - if ( traceMask == MASK_BLOCKLOS ) - { - traceMask = MASK_BLOCKLOS_AND_NPCS; - } - - // Player sees through nodraw and blocklos - if ( IsPlayer() ) - { - traceMask |= CONTENTS_IGNORE_NODRAW_OPAQUE; - traceMask &= ~CONTENTS_BLOCKLOS; - } - - // Use the custom LOS trace filter - CTraceFilterLOS traceFilter( this, COLLISION_GROUP_NONE ); - UTIL_TraceLine( vecLookerOrigin, vecTarget, traceMask, &traceFilter, &tr ); - } - - if (tr.fraction != 1.0) - { - if (ppBlocker) - { - *ppBlocker = tr.m_pEnt; - } - return false;// Line of sight is not established - } - - return true;// line of sight is valid. -} - -extern ConVar ai_debug_los; -//----------------------------------------------------------------------------- -// Purpose: Turn on prop LOS debugging mode -//----------------------------------------------------------------------------- -void CC_AI_LOS_Debug( IConVar *var, const char *pOldString, float flOldValue ) -{ - int iLOSMode = ai_debug_los.GetInt(); - for ( CBaseEntity *pEntity = gEntList.FirstEnt(); pEntity != NULL; pEntity = gEntList.NextEnt(pEntity) ) - { - if ( iLOSMode == 1 && pEntity->IsSolid() ) - { - pEntity->m_debugOverlays |= OVERLAY_SHOW_BLOCKSLOS; - } - else if ( iLOSMode == 2 ) - { - pEntity->m_debugOverlays |= OVERLAY_SHOW_BLOCKSLOS; - } - else - { - pEntity->m_debugOverlays &= ~OVERLAY_SHOW_BLOCKSLOS; - } - } -} -ConVar ai_debug_los("ai_debug_los", "0", FCVAR_CHEAT, "NPC Line-Of-Sight debug mode. If 1, solid entities that block NPC LOC will be highlighted with white bounding boxes. If 2, it'll show non-solid entities that would do it if they were solid.", CC_AI_LOS_Debug ); - - -Class_T CBaseEntity::Classify ( void ) -{ - return CLASS_NONE; -} - -float CBaseEntity::GetAutoAimRadius() -{ - if( g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE ) - return 48.0f; - else - return 24.0f; -} - -//----------------------------------------------------------------------------- -// Changes the shadow cast distance over time -//----------------------------------------------------------------------------- -void CBaseEntity::ShadowCastDistThink( ) -{ - SetShadowCastDistance( m_flDesiredShadowCastDistance ); - SetContextThink( NULL, gpGlobals->curtime, "ShadowCastDistThink" ); -} - -void CBaseEntity::SetShadowCastDistance( float flDesiredDistance, float flDelay ) -{ - m_flDesiredShadowCastDistance = flDesiredDistance; - if ( m_flDesiredShadowCastDistance != m_flShadowCastDistance ) - { - SetContextThink( &CBaseEntity::ShadowCastDistThink, gpGlobals->curtime + flDelay, "ShadowCastDistThink" ); - } -} - - -/* -================ -TraceAttack -================ -*/ - -//----------------------------------------------------------------------------- -// Purpose: Returns whether a damage info can damage this entity. -//----------------------------------------------------------------------------- -bool CBaseEntity::PassesDamageFilter( const CTakeDamageInfo &info ) -{ - if (m_hDamageFilter) - { - CBaseFilter *pFilter = (CBaseFilter *)(m_hDamageFilter.Get()); - return pFilter->PassesDamageFilter(info); - } - - return true; -} - -FORCEINLINE bool NamesMatch( const char *pszQuery, string_t nameToMatch ) -{ - if ( nameToMatch == NULL_STRING ) - return (!pszQuery || *pszQuery == 0 || *pszQuery == '*'); - - const char *pszNameToMatch = STRING(nameToMatch); - - // If the pointers are identical, we're identical - if ( pszNameToMatch == pszQuery ) - return true; - - while ( *pszNameToMatch && *pszQuery ) - { - unsigned char cName = *pszNameToMatch; - unsigned char cQuery = *pszQuery; - // simple ascii case conversion - if ( cName == cQuery ) - ; - else if ( cName - 'A' <= (unsigned char)'Z' - 'A' && cName - 'A' + 'a' == cQuery ) - ; - else if ( cName - 'a' <= (unsigned char)'z' - 'a' && cName - 'a' + 'A' == cQuery ) - ; - else - break; - ++pszNameToMatch; - ++pszQuery; - } - - if ( *pszQuery == 0 && *pszNameToMatch == 0 ) - return true; - - // @TODO (toml 03-18-03): Perhaps support real wildcards. Right now, only thing supported is trailing * - if ( *pszQuery == '*' ) - return true; - - return false; -} - -bool CBaseEntity::NameMatchesComplex( const char *pszNameOrWildcard ) -{ - if ( !Q_stricmp( "!player", pszNameOrWildcard) ) - return IsPlayer(); - - return NamesMatch( pszNameOrWildcard, m_iName ); -} - -bool CBaseEntity::ClassMatchesComplex( const char *pszClassOrWildcard ) -{ - return NamesMatch( pszClassOrWildcard, m_iClassname ); -} - -void CBaseEntity::MakeDormant( void ) -{ - AddEFlags( EFL_DORMANT ); - - // disable thinking for dormant entities - SetThink( NULL ); - - if ( !edict() ) - return; - - SETBITS( m_iEFlags, EFL_DORMANT ); - - // Don't touch - AddSolidFlags( FSOLID_NOT_SOLID ); - // Don't move - SetMoveType( MOVETYPE_NONE ); - // Don't draw - AddEffects( EF_NODRAW ); - // Don't think - SetNextThink( TICK_NEVER_THINK ); -} - -int CBaseEntity::IsDormant( void ) -{ - return IsEFlagSet( EFL_DORMANT ); -} - - -bool CBaseEntity::IsInWorld( void ) const -{ - if ( !edict() ) - return true; - - // position - if (GetAbsOrigin().x >= MAX_COORD_INTEGER) return false; - if (GetAbsOrigin().y >= MAX_COORD_INTEGER) return false; - if (GetAbsOrigin().z >= MAX_COORD_INTEGER) return false; - if (GetAbsOrigin().x <= MIN_COORD_INTEGER) return false; - if (GetAbsOrigin().y <= MIN_COORD_INTEGER) return false; - if (GetAbsOrigin().z <= MIN_COORD_INTEGER) return false; - // speed - if (GetAbsVelocity().x >= 2000) return false; - if (GetAbsVelocity().y >= 2000) return false; - if (GetAbsVelocity().z >= 2000) return false; - if (GetAbsVelocity().x <= -2000) return false; - if (GetAbsVelocity().y <= -2000) return false; - if (GetAbsVelocity().z <= -2000) return false; - - return true; -} - - -bool CBaseEntity::IsViewable( void ) -{ - if ( IsEffectActive( EF_NODRAW ) ) - { - return false; - } - - if (IsBSPModel()) - { - if (GetMoveType() != MOVETYPE_NONE) - { - return true; - } - } - else if (GetModelIndex() != 0) - { - // check for total transparency??? - return true; - } - return false; -} - - -int CBaseEntity::ShouldToggle( USE_TYPE useType, int currentState ) -{ - if ( useType != USE_TOGGLE && useType != USE_SET ) - { - if ( (currentState && useType == USE_ON) || (!currentState && useType == USE_OFF) ) - return 0; - } - return 1; -} - - -// NOTE: szName must be a pointer to constant memory, e.g. "NPC_class" because the entity -// will keep a pointer to it after this call. -CBaseEntity *CBaseEntity::Create( const char *szName, const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner ) -{ - CBaseEntity *pEntity = CreateNoSpawn( szName, vecOrigin, vecAngles, pOwner ); - - DispatchSpawn( pEntity ); - return pEntity; -} - - - -// NOTE: szName must be a pointer to constant memory, e.g. "NPC_class" because the entity -// will keep a pointer to it after this call. -CBaseEntity * CBaseEntity::CreateNoSpawn( const char *szName, const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner ) -{ - CBaseEntity *pEntity = CreateEntityByName( szName ); - if ( !pEntity ) - { - Assert( !"CreateNoSpawn: only works for CBaseEntities" ); - return NULL; - } - - pEntity->SetLocalOrigin( vecOrigin ); - pEntity->SetLocalAngles( vecAngles ); - pEntity->SetOwnerEntity( pOwner ); - - gEntList.NotifyCreateEntity( pEntity ); - - return pEntity; -} - -Vector CBaseEntity::GetSoundEmissionOrigin() const -{ - return WorldSpaceCenter(); -} - - -//----------------------------------------------------------------------------- -// Purpose: Saves the current object out to disk, by iterating through the objects -// data description hierarchy -// Input : &save - save buffer which the class data is written to -// Output : int - 0 if the save failed, 1 on success -//----------------------------------------------------------------------------- -int CBaseEntity::Save( ISave &save ) -{ - // loop through the data description list, saving each data desc block - int status = SaveDataDescBlock( save, GetDataDescMap() ); - - return status; -} - -//----------------------------------------------------------------------------- -// Purpose: Recursively saves all the classes in an object, in reverse order (top down) -// Output : int 0 on failure, 1 on success -//----------------------------------------------------------------------------- -int CBaseEntity::SaveDataDescBlock( ISave &save, datamap_t *dmap ) -{ - return save.WriteAll( this, dmap ); -} - -//----------------------------------------------------------------------------- -// Purpose: Restores the current object from disk, by iterating through the objects -// data description hierarchy -// Input : &restore - restore buffer which the class data is read from -// Output : int - 0 if the restore failed, 1 on success -//----------------------------------------------------------------------------- -int CBaseEntity::Restore( IRestore &restore ) -{ - // This is essential to getting the spatial partition info correct - CollisionProp()->DestroyPartitionHandle(); - - // loops through the data description list, restoring each data desc block in order - int status = RestoreDataDescBlock( restore, GetDataDescMap() ); - - // --------------------------------------------------------------- - // HACKHACK: We don't know the space of these vectors until now - // if they are worldspace, fix them up. - // --------------------------------------------------------------- - { - CGameSaveRestoreInfo *pGameInfo = restore.GetGameSaveRestoreInfo(); - Vector parentSpaceOffset = pGameInfo->modelSpaceOffset; - if ( !GetParent() ) - { - // parent is the world, so parent space is worldspace - // so update with the worldspace leveltransition transform - parentSpaceOffset += pGameInfo->GetLandmark(); - } - - // NOTE: Do *not* use GetAbsOrigin() here because it will - // try to recompute m_rgflCoordinateFrame! - MatrixSetColumn( m_vecAbsOrigin, 3, m_rgflCoordinateFrame ); - - m_vecOrigin += parentSpaceOffset; - } - - // Gotta do this after the coordframe is set up as it depends on it. - - // By definition, the surrounding bounds are dirty - // Also, twiddling with the flags here ensures it gets added to the KD tree dirty list - // (We don't want to use the saved version of this flag) - RemoveEFlags( EFL_DIRTY_SPATIAL_PARTITION ); - CollisionProp()->MarkSurroundingBoundsDirty(); - - if ( edict() && GetModelIndex() != 0 && GetModelName() != NULL_STRING && restore.GetPrecacheMode() ) - { - PrecacheModel( STRING( GetModelName() ) ); - - //Adrian: We should only need to do this after we precache. No point in setting the model again. - SetModelIndex( modelinfo->GetModelIndex( STRING(GetModelName() ) ) ); - } - - // Restablish ground entity - if ( m_hGroundEntity != NULL ) - { - m_hGroundEntity->AddEntityToGroundList( this ); - } - - return status; -} - - -//----------------------------------------------------------------------------- -// handler to do stuff before you are saved -//----------------------------------------------------------------------------- -void CBaseEntity::OnSave( IEntitySaveUtils *pUtils ) -{ - // Here, we must force recomputation of all abs data so it gets saved correctly - // We can't leave the dirty bits set because the loader can't cope with it. - CalcAbsolutePosition(); - CalcAbsoluteVelocity(); -} - -//----------------------------------------------------------------------------- -// handler to do stuff after you are restored -//----------------------------------------------------------------------------- -void CBaseEntity::OnRestore() -{ -#if defined( PORTAL ) || defined( HL2_EPISODIC ) || defined ( HL2_DLL ) || defined( HL2_LOSTCOAST ) - // We had a short period during the 2013 beta where the FL_* flags had a bogus value near the top, so detect - // these bad saves and just give up. Only saves from the short beta period should have been effected. - if ( GetFlags() & FL_FAKECLIENT ) - { - char szMsg[256]; - V_snprintf( szMsg, sizeof(szMsg), "\nInvalid save, unable to load. Please run \"map %s\" to restart this level manually\n\n", gpGlobals->mapname.ToCStr() ); - Msg( "%s", szMsg ); - - engine->ServerCommand("wait;wait;disconnect;showconsole\n"); - } -#endif - - SimThink_EntityChanged( this ); - - // touchlinks get recomputed - if ( IsEFlagSet( EFL_CHECK_UNTOUCH ) ) - { - RemoveEFlags( EFL_CHECK_UNTOUCH ); - SetCheckUntouch( true ); - } - - // disable touch functions while we recreate the touch links between entities - // NOTE: We don't do this on transitions, because we'd miss the OnStartTouch call! -#if !defined(HL2_DLL) || ( defined(HL2_DLL) && defined(HL2_EPISODIC) ) - CBaseEntity::sm_bDisableTouchFuncs = ( gpGlobals->eLoadType != MapLoad_Transition ); - PhysicsTouchTriggers(); - CBaseEntity::sm_bDisableTouchFuncs = false; -#endif // HL2_EPISODIC - - //Adrian: If I'm restoring with these fields it means I've become a client side ragdoll. - //Don't create another one, just wait until is my time of being removed. - if ( GetFlags() & FL_TRANSRAGDOLL ) - { - m_nRenderFX = kRenderFxNone; - AddEffects( EF_NODRAW ); - RemoveFlag( FL_DISSOLVING | FL_ONFIRE ); - } - - if ( m_pParent ) - { - CBaseEntity *pChild = m_pParent->FirstMoveChild(); - while ( pChild ) - { - if ( pChild == this ) - break; - pChild = pChild->NextMovePeer(); - } - if ( pChild != this ) - { -#if _DEBUG - // generally this means you've got something marked FCAP_DONT_SAVE - // in a hierarchy. That's probably ok given this fixup, but the hierarhcy - // linked list is just saved/loaded in-place - Warning("Fixing up parent on %s\n", GetClassname() ); -#endif - // We only need to be back in the parent's list because we're already in the right place and with the right data - LinkChild( m_pParent, this ); - } - } - - // We're not save/loading the PVS dirty state. Assume everything is dirty after a restore - NetworkProp()->MarkPVSInformationDirty(); -} - - -//----------------------------------------------------------------------------- -// Purpose: Recursively restores all the classes in an object, in reverse order (top down) -// Output : int 0 on failure, 1 on success -//----------------------------------------------------------------------------- -int CBaseEntity::RestoreDataDescBlock( IRestore &restore, datamap_t *dmap ) -{ - return restore.ReadAll( this, dmap ); -} - -//----------------------------------------------------------------------------- - -bool CBaseEntity::ShouldSavePhysics() -{ - return true; -} - -//----------------------------------------------------------------------------- - -#include "tier0/memdbgoff.h" - -//----------------------------------------------------------------------------- -// CBaseEntity new/delete -// allocates and frees memory for itself from the engine-> -// All fields in the object are all initialized to 0. -//----------------------------------------------------------------------------- -void *CBaseEntity::operator new( size_t stAllocateBlock ) -{ - // call into engine to get memory - Assert( stAllocateBlock != 0 ); - return engine->PvAllocEntPrivateData(stAllocateBlock); -}; - -void *CBaseEntity::operator new( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine ) -{ - // call into engine to get memory - Assert( stAllocateBlock != 0 ); - return engine->PvAllocEntPrivateData(stAllocateBlock); -} - -void CBaseEntity::operator delete( void *pMem ) -{ - // get the engine to free the memory - engine->FreeEntPrivateData( pMem ); -} - -#include "tier0/memdbgon.h" - - -#ifdef _DEBUG -void CBaseEntity::FunctionCheck( void *pFunction, const char *name ) -{ -#ifdef USES_SAVERESTORE - // Note, if you crash here and your class is using multiple inheritance, it is - // probably the case that CBaseEntity (or a descendant) is not the first - // class in your list of ancestors, which it must be. - if (pFunction && !UTIL_FunctionToName( GetDataDescMap(), (inputfunc_t *)pFunction ) ) - { - Warning( "FUNCTION NOT IN TABLE!: %s:%s (%08lx)\n", STRING(m_iClassname), name, (unsigned long)pFunction ); - Assert(0); - } -#endif -} -#endif - - -bool CBaseEntity::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace ) -{ - return false; -} - -//----------------------------------------------------------------------------- -// Perform hitbox test, returns true *if hitboxes were tested at all*!! -//----------------------------------------------------------------------------- -bool CBaseEntity::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ) -{ - return false; -} - - -void CBaseEntity::SetOwnerEntity( CBaseEntity* pOwner ) -{ - if ( m_hOwnerEntity.Get() != pOwner ) - { - m_hOwnerEntity = pOwner; - - CollisionRulesChanged(); - } -} - -void CBaseEntity::SetMoveType( MoveType_t val, MoveCollide_t moveCollide ) -{ -#ifdef _DEBUG - // Make sure the move type + move collide are compatible... - if ((val != MOVETYPE_FLY) && (val != MOVETYPE_FLYGRAVITY)) - { - Assert( moveCollide == MOVECOLLIDE_DEFAULT ); - } - - if ( m_MoveType == MOVETYPE_VPHYSICS && val != m_MoveType ) - { - if ( VPhysicsGetObject() && val != MOVETYPE_NONE ) - { - // What am I supposed to do with the physics object if - // you're changing away from MOVETYPE_VPHYSICS without making the object - // shadow? This isn't likely to work, assert. - // You probably meant to call VPhysicsInitShadow() instead of VPhysicsInitNormal()! - Assert( VPhysicsGetObject()->GetShadowController() ); - } - } -#endif - - if ( m_MoveType == val ) - { - m_MoveCollide = moveCollide; - return; - } - - // This is needed to the removal of MOVETYPE_FOLLOW: - // We can't transition from follow to a different movetype directly - // or the leaf code will break. - Assert( !IsEffectActive( EF_BONEMERGE ) ); - m_MoveType = val; - m_MoveCollide = moveCollide; - - CollisionRulesChanged(); - - switch( m_MoveType ) - { - case MOVETYPE_WALK: - { - SetSimulatedEveryTick( true ); - SetAnimatedEveryTick( true ); - } - break; - case MOVETYPE_STEP: - { - // This will probably go away once I remove the cvar that controls the test code - SetSimulatedEveryTick( g_bTestMoveTypeStepSimulation ? true : false ); - SetAnimatedEveryTick( false ); - } - break; - case MOVETYPE_FLY: - case MOVETYPE_FLYGRAVITY: - { - // Initialize our water state, because these movetypes care about transitions in/out of water - UpdateWaterState(); - } - break; - default: - { - SetSimulatedEveryTick( true ); - SetAnimatedEveryTick( false ); - } - } - - // This will probably go away or be handled in a better way once I remove the cvar that controls the test code - CheckStepSimulationChanged(); - CheckHasGamePhysicsSimulation(); -} - -void CBaseEntity::Spawn( void ) -{ -} - - -CBaseEntity* CBaseEntity::Instance( const CBaseHandle &hEnt ) -{ - return gEntList.GetBaseEntity( hEnt ); -} - -int CBaseEntity::GetTransmitState( void ) -{ - edict_t *ed = edict(); - - if ( !ed ) - return 0; - - return ed->m_fStateFlags; -} - -int CBaseEntity::SetTransmitState( int nFlag) -{ - edict_t *ed = edict(); - - if ( !ed ) - return 0; - - // clear current flags = check ShouldTransmit() - ed->ClearTransmitState(); - - int oldFlags = ed->m_fStateFlags; - ed->m_fStateFlags |= nFlag; - - // Tell the engine (used for a network backdoor optimization). - if ( (oldFlags & FL_EDICT_DONTSEND) != (ed->m_fStateFlags & FL_EDICT_DONTSEND) ) - engine->NotifyEdictFlagsChange( entindex() ); - - return ed->m_fStateFlags; -} - -int CBaseEntity::UpdateTransmitState() -{ - // If you get this assert, you should be calling DispatchUpdateTransmitState - // instead of UpdateTransmitState. - Assert( g_nInsideDispatchUpdateTransmitState > 0 ); - - // If an object is the moveparent of something else, don't skip it just because it's marked EF_NODRAW or else - // the client won't have a proper origin for the child since the hierarchy won't be correctly transmitted down - if ( IsEffectActive( EF_NODRAW ) && - !m_hMoveChild.Get() ) - { - return SetTransmitState( FL_EDICT_DONTSEND ); - } - - if ( !IsEFlagSet( EFL_FORCE_CHECK_TRANSMIT ) ) - { - if ( !GetModelIndex() || !GetModelName() ) - { - return SetTransmitState( FL_EDICT_DONTSEND ); - } - } - - // Always send the world - if ( GetModelIndex() == 1 ) - { - return SetTransmitState( FL_EDICT_ALWAYS ); - } - - if ( IsEFlagSet( EFL_IN_SKYBOX ) ) - { - return SetTransmitState( FL_EDICT_ALWAYS ); - } - - // by default cull against PVS - return SetTransmitState( FL_EDICT_PVSCHECK ); -} - -int CBaseEntity::DispatchUpdateTransmitState() -{ - edict_t *ed = edict(); - if ( m_nTransmitStateOwnedCounter != 0 ) - return ed ? ed->m_fStateFlags : 0; - - g_nInsideDispatchUpdateTransmitState++; - int ret = UpdateTransmitState(); - g_nInsideDispatchUpdateTransmitState--; - - return ret; -} - -//----------------------------------------------------------------------------- -// Purpose: Note, an entity can override the send table ( e.g., to send less data or to send minimal data for -// objects ( prob. players ) that are not in the pvs. -// Input : **ppSendTable - -// *recipient - -// *pvs - -// Output : Returns true on success, false on failure. -//----------------------------------------------------------------------------- -int CBaseEntity::ShouldTransmit( const CCheckTransmitInfo *pInfo ) -{ - int fFlags = DispatchUpdateTransmitState(); - - if ( fFlags & FL_EDICT_PVSCHECK ) - { - return FL_EDICT_PVSCHECK; - } - else if ( fFlags & FL_EDICT_ALWAYS ) - { - return FL_EDICT_ALWAYS; - } - else if ( fFlags & FL_EDICT_DONTSEND ) - { - return FL_EDICT_DONTSEND; - } - -// if ( IsToolRecording() ) -// { -// return FL_EDICT_ALWAYS; -// } - - CBaseEntity *pRecipientEntity = CBaseEntity::Instance( pInfo->m_pClientEnt ); - - Assert( pRecipientEntity->IsPlayer() ); - - CBasePlayer *pRecipientPlayer = static_cast( pRecipientEntity ); - - - // FIXME: Refactor once notion of "team" is moved into HL2 code - // Team rules may tell us that we should - if ( pRecipientPlayer->GetTeam() ) - { - if ( pRecipientPlayer->GetTeam()->ShouldTransmitToPlayer( pRecipientPlayer, this )) - return FL_EDICT_ALWAYS; - } - - -/*#ifdef INVASION_DLL - // Check test network vis distance stuff. Eventually network LOD will do this. - float flTestDistSqr = pRecipientEntity->GetAbsOrigin().DistToSqr( WorldSpaceCenter() ); - if ( flTestDistSqr > sv_netvisdist.GetFloat() * sv_netvisdist.GetFloat() ) - return TRANSMIT_NO; // TODO doesn't work with HLTV -#endif*/ - - // by default do a PVS check - - return FL_EDICT_PVSCHECK; -} - - -//----------------------------------------------------------------------------- -// Rules about which entities need to transmit along with me -//----------------------------------------------------------------------------- -void CBaseEntity::SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways ) -{ - int index = entindex(); - - // Are we already marked for transmission? - if ( pInfo->m_pTransmitEdict->Get( index ) ) - return; - - CServerNetworkProperty *pNetworkParent = NetworkProp()->GetNetworkParent(); - - pInfo->m_pTransmitEdict->Set( index ); - - // HLTV/Replay need to know if this entity is culled by PVS limits - if ( pInfo->m_pTransmitAlways ) - { - // in HLTV/Replay mode always transmit entitys with move-parents - // HLTV/Replay can't resolve the mode-parents relationships - if ( bAlways || pNetworkParent ) - { - // tell HLTV/Replay that this entity is always transmitted - pInfo->m_pTransmitAlways->Set( index ); - } - else - { - // HLTV/Replay will PVS cull this entity, so update the - // node/cluster infos if necessary - m_Network.RecomputePVSInformation(); - } - } - - // Force our aiment and move parent to be sent. - if ( pNetworkParent ) - { - CBaseEntity *pMoveParent = pNetworkParent->GetBaseEntity(); - pMoveParent->SetTransmit( pInfo, bAlways ); - } -} - - -//----------------------------------------------------------------------------- -// Returns which skybox the entity is in -//----------------------------------------------------------------------------- -CSkyCamera *CBaseEntity::GetEntitySkybox() -{ - int area = engine->GetArea( WorldSpaceCenter() ); - - CSkyCamera *pCur = GetSkyCameraList(); - while ( pCur ) - { - if ( engine->CheckAreasConnected( area, pCur->m_skyboxData.area ) ) - return pCur; - - pCur = pCur->m_pNext; - } - - return NULL; -} - -bool CBaseEntity::DetectInSkybox() -{ - if ( GetEntitySkybox() != NULL ) - { - AddEFlags( EFL_IN_SKYBOX ); - return true; - } - - RemoveEFlags( EFL_IN_SKYBOX ); - return false; -} - - -//------------------------------------------------------------------------------ -// Computes a world-aligned bounding box that surrounds everything in the entity -//------------------------------------------------------------------------------ -void CBaseEntity::ComputeWorldSpaceSurroundingBox( Vector *pMins, Vector *pMaxs ) -{ - // Should never get here.. only use USE_GAME_CODE with bounding boxes - // if you have an implementation for this method - Assert( 0 ); -} - - -//------------------------------------------------------------------------------ -// Purpose : If name exists returns name, otherwise returns classname -// Input : -// Output : -//------------------------------------------------------------------------------ -const char *CBaseEntity::GetDebugName(void) -{ - if ( this == NULL ) - return "<>"; - - if ( m_iName != NULL_STRING ) - { - return STRING(m_iName); - } - else - { - return STRING(m_iClassname); - } -} - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CBaseEntity::DrawInputOverlay(const char *szInputName, CBaseEntity *pCaller, variant_t Value) -{ - char bigstring[1024]; - if ( Value.FieldType() == FIELD_INTEGER ) - { - Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s,%d) <-- (%s)\n", gpGlobals->curtime, szInputName, Value.Int(), pCaller ? pCaller->GetDebugName() : NULL); - } - else if ( Value.FieldType() == FIELD_STRING ) - { - Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s,%s) <-- (%s)\n", gpGlobals->curtime, szInputName, Value.String(), pCaller ? pCaller->GetDebugName() : NULL); - } - else - { - Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s) <-- (%s)\n", gpGlobals->curtime, szInputName, pCaller ? pCaller->GetDebugName() : NULL); - } - AddTimedOverlay(bigstring, 10.0); - - if ( Value.FieldType() == FIELD_INTEGER ) - { - DevMsg( 2, "input: (%s,%d) -> (%s,%s), from (%s)\n", szInputName, Value.Int(), STRING(m_iClassname), GetDebugName(), pCaller ? pCaller->GetDebugName() : NULL); - } - else if ( Value.FieldType() == FIELD_STRING ) - { - DevMsg( 2, "input: (%s,%s) -> (%s,%s), from (%s)\n", szInputName, Value.String(), STRING(m_iClassname), GetDebugName(), pCaller ? pCaller->GetDebugName() : NULL); - } - else - DevMsg( 2, "input: (%s) -> (%s,%s), from (%s)\n", szInputName, STRING(m_iClassname), GetDebugName(), pCaller ? pCaller->GetDebugName() : NULL); -} - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CBaseEntity::DrawOutputOverlay(CEventAction *ev) -{ - // Print to entity - char bigstring[1024]; - if ( ev->m_flDelay ) - { - Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s) --> (%s),%.1f) \n", gpGlobals->curtime, STRING(ev->m_iTargetInput), STRING(ev->m_iTarget), ev->m_flDelay); - } - else - { - Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s) --> (%s)\n", gpGlobals->curtime, STRING(ev->m_iTargetInput), STRING(ev->m_iTarget)); - } - AddTimedOverlay(bigstring, 10.0); - - // Now print to the console - if ( ev->m_flDelay ) - { - DevMsg( 2, "output: (%s,%s) -> (%s,%s,%.1f)\n", STRING(m_iClassname), GetDebugName(), STRING(ev->m_iTarget), STRING(ev->m_iTargetInput), ev->m_flDelay ); - } - else - { - DevMsg( 2, "output: (%s,%s) -> (%s,%s)\n", STRING(m_iClassname), GetDebugName(), STRING(ev->m_iTarget), STRING(ev->m_iTargetInput) ); - } -} - - -//----------------------------------------------------------------------------- -// Entity events... these are events targetted to a particular entity -// Each event defines its own well-defined event data structure -//----------------------------------------------------------------------------- -void CBaseEntity::OnEntityEvent( EntityEvent_t event, void *pEventData ) -{ - switch( event ) - { - case ENTITY_EVENT_WATER_TOUCH: - { - int nContents = (int)pEventData; - if ( !nContents || (nContents & CONTENTS_WATER) ) - { - ++m_nWaterTouch; - } - if ( nContents & CONTENTS_SLIME ) - { - ++m_nSlimeTouch; - } - } - break; - - case ENTITY_EVENT_WATER_UNTOUCH: - { - int nContents = (int)pEventData; - if ( !nContents || (nContents & CONTENTS_WATER) ) - { - --m_nWaterTouch; - } - if ( nContents & CONTENTS_SLIME ) - { - --m_nSlimeTouch; - } - } - break; - - default: - return; - } - - // Only do this for vphysics objects - if ( GetMoveType() != MOVETYPE_VPHYSICS ) - return; - - int nNewContents = 0; - if ( m_nWaterTouch > 0 ) - { - nNewContents |= CONTENTS_WATER; - } - - if ( m_nSlimeTouch > 0 ) - { - nNewContents |= CONTENTS_SLIME; - } - - if (( nNewContents & MASK_WATER ) == 0) - { - SetWaterLevel( 0 ); - SetWaterType( CONTENTS_EMPTY ); - return; - } - - SetWaterLevel( 1 ); - SetWaterType( nNewContents ); -} - - -ConVar ent_messages_draw( "ent_messages_draw", "0", FCVAR_CHEAT, "Visualizes all entity input/output activity." ); - - -//----------------------------------------------------------------------------- -// Purpose: calls the appropriate message mapped function in the entity according -// to the fired action. -// Input : char *szInputName - input destination -// *pActivator - entity which initiated this sequence of actions -// *pCaller - entity from which this event is sent -// Output : Returns true on success, false on failure. -//----------------------------------------------------------------------------- -bool CBaseEntity::AcceptInput( const char *szInputName, CBaseEntity *pActivator, CBaseEntity *pCaller, variant_t Value, int outputID ) -{ - if ( ent_messages_draw.GetBool() ) - { - if ( pCaller != NULL ) - { - NDebugOverlay::Line( pCaller->GetAbsOrigin(), GetAbsOrigin(), 255, 255, 255, false, 3 ); - NDebugOverlay::Box( pCaller->GetAbsOrigin(), Vector(-4, -4, -4), Vector(4, 4, 4), 255, 0, 0, 0, 3 ); - } - - NDebugOverlay::Text( GetAbsOrigin(), szInputName, false, 3 ); - NDebugOverlay::Box( GetAbsOrigin(), Vector(-4, -4, -4), Vector(4, 4, 4), 0, 255, 0, 0, 3 ); - } - - // loop through the data description list, restoring each data desc block - for ( datamap_t *dmap = GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) - { - // search through all the actions in the data description, looking for a match - for ( int i = 0; i < dmap->dataNumFields; i++ ) - { - if ( dmap->dataDesc[i].flags & FTYPEDESC_INPUT ) - { - if ( !Q_stricmp(dmap->dataDesc[i].externalName, szInputName) ) - { - // found a match - - char szBuffer[256]; - // mapper debug message - if (pCaller != NULL) - { - Q_snprintf( szBuffer, sizeof(szBuffer), "(%0.2f) input %s: %s.%s(%s)\n", gpGlobals->curtime, STRING(pCaller->m_iName), GetDebugName(), szInputName, Value.String() ); - } - else - { - Q_snprintf( szBuffer, sizeof(szBuffer), "(%0.2f) input : %s.%s(%s)\n", gpGlobals->curtime, GetDebugName(), szInputName, Value.String() ); - } - DevMsg( 2, "%s", szBuffer ); - ADD_DEBUG_HISTORY( HISTORY_ENTITY_IO, szBuffer ); - - if (m_debugOverlays & OVERLAY_MESSAGE_BIT) - { - DrawInputOverlay(szInputName,pCaller,Value); - } - - // convert the value if necessary - if ( Value.FieldType() != dmap->dataDesc[i].fieldType ) - { - if ( !(Value.FieldType() == FIELD_VOID && dmap->dataDesc[i].fieldType == FIELD_STRING) ) // allow empty strings - { - if ( !Value.Convert( (fieldtype_t)dmap->dataDesc[i].fieldType ) ) - { - // bad conversion - Warning( "!! ERROR: bad input/output link:\n!! %s(%s,%s) doesn't match type from %s(%s)\n", - STRING(m_iClassname), GetDebugName(), szInputName, - ( pCaller != NULL ) ? STRING(pCaller->m_iClassname) : "", - ( pCaller != NULL ) ? STRING(pCaller->m_iName) : "" ); - return false; - } - } - } - - // call the input handler, or if there is none just set the value - inputfunc_t pfnInput = dmap->dataDesc[i].inputFunc; - - if ( pfnInput ) - { - // Package the data into a struct for passing to the input handler. - inputdata_t data; - data.pActivator = pActivator; - data.pCaller = pCaller; - data.value = Value; - data.nOutputID = outputID; - - (this->*pfnInput)( data ); - } - else if ( dmap->dataDesc[i].flags & FTYPEDESC_KEY ) - { - // set the value directly - Value.SetOther( ((char*)this) + dmap->dataDesc[i].fieldOffset[ TD_OFFSET_NORMAL ]); - - // TODO: if this becomes evil and causes too many full entity updates, then we should make - // a macro like this: - // - // define MAKE_INPUTVAR(x) void Note##x##Modified() { x.GetForModify(); } - // - // Then the datadesc points at that function and we call it here. The only pain is to add - // that function for all the DEFINE_INPUT calls. - NetworkStateChanged(); - } - - return true; - } - } - } - } - - DevMsg( 2, "unhandled input: (%s) -> (%s,%s)\n", szInputName, STRING(m_iClassname), GetDebugName()/*,", from (%s,%s)" STRING(pCaller->m_iClassname), STRING(pCaller->m_iName)*/ ); - return false; -} - -//----------------------------------------------------------------------------- -// Purpose: Input handler for the entity alpha. -// Input : nAlpha - Alpha value (0 - 255). -//----------------------------------------------------------------------------- -void CBaseEntity::InputAlpha( inputdata_t &inputdata ) -{ - SetRenderColorA( clamp( inputdata.value.Int(), 0, 255 ) ); -} - - -//----------------------------------------------------------------------------- -// Activate alternative sorting -//----------------------------------------------------------------------------- -void CBaseEntity::InputAlternativeSorting( inputdata_t &inputdata ) -{ - m_bAlternateSorting = inputdata.value.Bool(); -} - - -//----------------------------------------------------------------------------- -// Purpose: Input handler for the entity color. Ignores alpha since that is handled -// by a separate input handler. -// Input : Color32 new value for color (alpha is ignored). -//----------------------------------------------------------------------------- -void CBaseEntity::InputColor( inputdata_t &inputdata ) -{ - color32 clr = inputdata.value.Color32(); - - SetRenderColor( clr.r, clr.g, clr.b ); -} - - -//----------------------------------------------------------------------------- -// Purpose: Called whenever the entity is 'Used'. This can be when a player hits -// use, or when an entity targets it without an output name (legacy entities) -//----------------------------------------------------------------------------- -void CBaseEntity::InputUse( inputdata_t &inputdata ) -{ - Use( inputdata.pActivator, inputdata.pCaller, (USE_TYPE)inputdata.nOutputID, 0 ); -} - - -//----------------------------------------------------------------------------- -// Purpose: Reads an output variable, by string name, from an entity -// Input : char *varName - the string name of the variable -// variant_t *var - the value is stored here -// Output : Returns true on success, false on failure. -//----------------------------------------------------------------------------- -bool CBaseEntity::ReadKeyField( const char *varName, variant_t *var ) -{ - if ( !varName ) - return false; - - // loop through the data description list, restoring each data desc block - for ( datamap_t *dmap = GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) - { - // search through all the readable fields in the data description, looking for a match - for ( int i = 0; i < dmap->dataNumFields; i++ ) - { - if ( dmap->dataDesc[i].flags & (FTYPEDESC_OUTPUT | FTYPEDESC_KEY) ) - { - if ( !Q_stricmp(dmap->dataDesc[i].externalName, varName) ) - { - var->Set( dmap->dataDesc[i].fieldType, ((char*)this) + dmap->dataDesc[i].fieldOffset[ TD_OFFSET_NORMAL ] ); - return true; - } - } - } - } - - return false; -} - - -//----------------------------------------------------------------------------- -// Purpose: Sets the damage filter on the object -//----------------------------------------------------------------------------- -void CBaseEntity::InputEnableDamageForces( inputdata_t &inputdata ) -{ - RemoveEFlags( EFL_NO_DAMAGE_FORCES ); -} - -void CBaseEntity::InputDisableDamageForces( inputdata_t &inputdata ) -{ - AddEFlags( EFL_NO_DAMAGE_FORCES ); -} - - -//----------------------------------------------------------------------------- -// Purpose: Sets the damage filter on the object -//----------------------------------------------------------------------------- -void CBaseEntity::InputSetDamageFilter( inputdata_t &inputdata ) -{ - // Get a handle to my damage filter entity if there is one. - m_iszDamageFilterName = inputdata.value.StringID(); - if ( m_iszDamageFilterName != NULL_STRING ) - { - m_hDamageFilter = gEntList.FindEntityByName( NULL, m_iszDamageFilterName ); - } - else - { - m_hDamageFilter = NULL; - } -} - -//----------------------------------------------------------------------------- -// Purpose: Dispatch effects on this entity -//----------------------------------------------------------------------------- -void CBaseEntity::InputDispatchEffect( inputdata_t &inputdata ) -{ - const char *sEffect = inputdata.value.String(); - if ( sEffect && sEffect[0] ) - { - CEffectData data; - GetInputDispatchEffectPosition( sEffect, data.m_vOrigin, data.m_vAngles ); - AngleVectors( data.m_vAngles, &data.m_vNormal ); - data.m_vStart = data.m_vOrigin; - data.m_nEntIndex = entindex(); - - // Clip off leading attachment point numbers - while ( sEffect[0] >= '0' && sEffect[0] <= '9' ) - { - sEffect++; - } - DispatchEffect( sEffect, data ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Returns the origin at which to play an inputted dispatcheffect -//----------------------------------------------------------------------------- -void CBaseEntity::GetInputDispatchEffectPosition( const char *sInputString, Vector &pOrigin, QAngle &pAngles ) -{ - pOrigin = GetAbsOrigin(); - pAngles = GetAbsAngles(); -} - -//----------------------------------------------------------------------------- -// Purpose: Marks the entity for deletion -//----------------------------------------------------------------------------- -void CBaseEntity::InputKill( inputdata_t &inputdata ) -{ - // tell owner ( if any ) that we're dead.This is mostly for NPCMaker functionality. - CBaseEntity *pOwner = GetOwnerEntity(); - if ( pOwner ) - { - pOwner->DeathNotice( this ); - SetOwnerEntity( NULL ); - } - - UTIL_Remove( this ); -} - -void CBaseEntity::InputKillHierarchy( inputdata_t &inputdata ) -{ - CBaseEntity *pChild, *pNext; - for ( pChild = FirstMoveChild(); pChild; pChild = pNext ) - { - pNext = pChild->NextMovePeer(); - pChild->InputKillHierarchy( inputdata ); - } - - // tell owner ( if any ) that we're dead. This is mostly for NPCMaker functionality. - CBaseEntity *pOwner = GetOwnerEntity(); - if ( pOwner ) - { - pOwner->DeathNotice( this ); - SetOwnerEntity( NULL ); - } - - UTIL_Remove( this ); -} - -//------------------------------------------------------------------------------ -// Purpose: Input handler for changing this entity's movement parent. -//------------------------------------------------------------------------------ -void CBaseEntity::InputSetParent( inputdata_t &inputdata ) -{ - // If we had a parent attachment, clear it, because it's no longer valid. - if ( m_iParentAttachment ) - { - m_iParentAttachment = 0; - } - - SetParent( inputdata.value.StringID(), inputdata.pActivator ); -} - -//------------------------------------------------------------------------------ -// Purpose: -//------------------------------------------------------------------------------ -void CBaseEntity::SetParentAttachment( const char *szInputName, const char *szAttachment, bool bMaintainOffset ) -{ - // Must have a parent - if ( !m_pParent ) - { - Warning("ERROR: Tried to %s for entity %s (%s), but it has no parent.\n", szInputName, GetClassname(), GetDebugName() ); - return; - } - - // Valid only on CBaseAnimating - CBaseAnimating *pAnimating = m_pParent->GetBaseAnimating(); - if ( !pAnimating ) - { - Warning("ERROR: Tried to %s for entity %s (%s), but its parent has no model.\n", szInputName, GetClassname(), GetDebugName() ); - return; - } - - // Lookup the attachment - int iAttachment = pAnimating->LookupAttachment( szAttachment ); - if ( iAttachment <= 0 ) - { - Warning("ERROR: Tried to %s for entity %s (%s), but it has no attachment named %s.\n", szInputName, GetClassname(), GetDebugName(), szAttachment ); - return; - } - - m_iParentAttachment = iAttachment; - SetParent( m_pParent, m_iParentAttachment ); - - // Now move myself directly onto the attachment point - SetMoveType( MOVETYPE_NONE ); - - if ( !bMaintainOffset ) - { - SetLocalOrigin( vec3_origin ); - SetLocalAngles( vec3_angle ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Input handler for changing this entity's movement parent's attachment point -//----------------------------------------------------------------------------- -void CBaseEntity::InputSetParentAttachment( inputdata_t &inputdata ) -{ - SetParentAttachment( "SetParentAttachment", inputdata.value.String(), false ); -} - -//----------------------------------------------------------------------------- -// Purpose: Input handler for changing this entity's movement parent's attachment point -//----------------------------------------------------------------------------- -void CBaseEntity::InputSetParentAttachmentMaintainOffset( inputdata_t &inputdata ) -{ - SetParentAttachment( "SetParentAttachmentMaintainOffset", inputdata.value.String(), true ); -} - -//------------------------------------------------------------------------------ -// Purpose: Input handler for clearing this entity's movement parent. -//------------------------------------------------------------------------------ -void CBaseEntity::InputClearParent( inputdata_t &inputdata ) -{ - SetParent( NULL ); -} - - -//------------------------------------------------------------------------------ -// Purpose : Returns velcocity of base entity. If physically simulated gets -// velocity from physics object -// Input : -// Output : -//------------------------------------------------------------------------------ -void CBaseEntity::GetVelocity(Vector *vVelocity, AngularImpulse *vAngVelocity) -{ - if (GetMoveType()==MOVETYPE_VPHYSICS && m_pPhysicsObject) - { - m_pPhysicsObject->GetVelocity(vVelocity,vAngVelocity); - } - else - { - if (vVelocity != NULL) - { - *vVelocity = GetAbsVelocity(); - } - if (vAngVelocity != NULL) - { - QAngle tmp = GetLocalAngularVelocity(); - QAngleToAngularImpulse( tmp, *vAngVelocity ); - } - } -} - -bool CBaseEntity::IsMoving() -{ - Vector velocity; - GetVelocity( &velocity, NULL ); - return velocity != vec3_origin; -} - -//----------------------------------------------------------------------------- -// Purpose: Retrieves the coordinate frame for this entity. -// Input : forward - Receives the entity's forward vector. -// right - Receives the entity's right vector. -// up - Receives the entity's up vector. -//----------------------------------------------------------------------------- -void CBaseEntity::GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const -{ - // This call is necessary to cause m_rgflCoordinateFrame to be recomputed - const matrix3x4_t &entityToWorld = EntityToWorldTransform(); - - if (pForward != NULL) - { - MatrixGetColumn( entityToWorld, 0, *pForward ); - } - - if (pRight != NULL) - { - MatrixGetColumn( entityToWorld, 1, *pRight ); - *pRight *= -1.0f; - } - - if (pUp != NULL) - { - MatrixGetColumn( entityToWorld, 2, *pUp ); - } -} - - -//----------------------------------------------------------------------------- -// Purpose: Sets the model, validates that it's of the appropriate type -// Input : *szModelName - -//----------------------------------------------------------------------------- -void CBaseEntity::SetModel( const char *szModelName ) -{ - int modelIndex = modelinfo->GetModelIndex( szModelName ); - const model_t *model = modelinfo->GetModel( modelIndex ); - if ( model && modelinfo->GetModelType( model ) != mod_brush ) - { - Msg( "Setting CBaseEntity to non-brush model %s\n", szModelName ); - } - UTIL_SetModel( this, szModelName ); -} - -//------------------------------------------------------------------------------ - -CStudioHdr *CBaseEntity::OnNewModel() -{ - // Do nothing. - return NULL; -} - - -//================================================================================ -// TEAM HANDLING -//================================================================================ -void CBaseEntity::InputSetTeam( inputdata_t &inputdata ) -{ - ChangeTeam( inputdata.value.Int() ); -} - -//----------------------------------------------------------------------------- -// Purpose: Put the entity in the specified team -//----------------------------------------------------------------------------- -void CBaseEntity::ChangeTeam( int iTeamNum ) -{ - m_iTeamNum = iTeamNum; -} - -//----------------------------------------------------------------------------- -// Get the Team this entity is on -//----------------------------------------------------------------------------- -CTeam *CBaseEntity::GetTeam( void ) const -{ - return GetGlobalTeam( m_iTeamNum ); -} - - -//----------------------------------------------------------------------------- -// Purpose: Returns true if these players are both in at least one team together -//----------------------------------------------------------------------------- -bool CBaseEntity::InSameTeam( CBaseEntity *pEntity ) const -{ - if ( !pEntity ) - return false; - - return ( pEntity->GetTeam() == GetTeam() ); -} - -//----------------------------------------------------------------------------- -// Purpose: Returns the string name of the players team -//----------------------------------------------------------------------------- -const char *CBaseEntity::TeamID( void ) const -{ - if ( GetTeam() == NULL ) - return ""; - - return GetTeam()->GetName(); -} - -//----------------------------------------------------------------------------- -// Purpose: Returns true if the player is on the same team -//----------------------------------------------------------------------------- -bool CBaseEntity::IsInTeam( CTeam *pTeam ) const -{ - return ( GetTeam() == pTeam ); -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -int CBaseEntity::GetTeamNumber( void ) const -{ - return m_iTeamNum; -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -bool CBaseEntity::IsInAnyTeam( void ) const -{ - return ( GetTeam() != NULL ); -} - -//----------------------------------------------------------------------------- -// Purpose: Returns the type of damage that this entity inflicts. -//----------------------------------------------------------------------------- -int CBaseEntity::GetDamageType() const -{ - return DMG_GENERIC; -} - - -//----------------------------------------------------------------------------- -// process notification -//----------------------------------------------------------------------------- - -void CBaseEntity::NotifySystemEvent( CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t ¶ms ) -{ -} - - -//----------------------------------------------------------------------------- -// Purpose: Holds an entity's previous abs origin and angles at the time of -// teleportation. Used for child & constrained entity fixup to prevent -// lazy updates of abs origins and angles from messing things up. -//----------------------------------------------------------------------------- -struct TeleportListEntry_t -{ - CBaseEntity *pEntity; - Vector prevAbsOrigin; - QAngle prevAbsAngles; -}; - - -static void TeleportEntity( CBaseEntity *pSourceEntity, TeleportListEntry_t &entry, const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity ) -{ - CBaseEntity *pTeleport = entry.pEntity; - Vector prevOrigin = entry.prevAbsOrigin; - QAngle prevAngles = entry.prevAbsAngles; - - int nSolidFlags = pTeleport->GetSolidFlags(); - pTeleport->AddSolidFlags( FSOLID_NOT_SOLID ); - - // I'm teleporting myself - if ( pSourceEntity == pTeleport ) - { - if ( newAngles ) - { - pTeleport->SetLocalAngles( *newAngles ); - if ( pTeleport->IsPlayer() ) - { - CBasePlayer *pPlayer = (CBasePlayer *)pTeleport; - pPlayer->SnapEyeAngles( *newAngles ); - } - } - - if ( newVelocity ) - { - pTeleport->SetAbsVelocity( *newVelocity ); - pTeleport->SetBaseVelocity( vec3_origin ); - } - - if ( newPosition ) - { - pTeleport->IncrementInterpolationFrame(); - UTIL_SetOrigin( pTeleport, *newPosition ); - } - } - else - { - // My parent is teleporting, just update my position & physics - pTeleport->CalcAbsolutePosition(); - } - IPhysicsObject *pPhys = pTeleport->VPhysicsGetObject(); - bool rotatePhysics = false; - - // handle physics objects / shadows - if ( pPhys ) - { - if ( newVelocity ) - { - pPhys->SetVelocity( newVelocity, NULL ); - } - const QAngle *rotAngles = &pTeleport->GetAbsAngles(); - // don't rotate physics on players or bbox entities - if (pTeleport->IsPlayer() || pTeleport->GetSolid() == SOLID_BBOX ) - { - rotAngles = &vec3_angle; - } - else - { - rotatePhysics = true; - } - - pPhys->SetPosition( pTeleport->GetAbsOrigin(), *rotAngles, true ); - } - - g_pNotify->ReportTeleportEvent( pTeleport, prevOrigin, prevAngles, rotatePhysics ); - - pTeleport->SetSolidFlags( nSolidFlags ); -} - - -//----------------------------------------------------------------------------- -// Purpose: Recurses an entity hierarchy and fills out a list of all entities -// in the hierarchy with their current origins and angles. -// -// This list is necessary to keep lazy updates of abs origins and angles -// from messing up our child/constrained entity fixup. -//----------------------------------------------------------------------------- -static void BuildTeleportList_r( CBaseEntity *pTeleport, CUtlVector &teleportList ) -{ - TeleportListEntry_t entry; - - entry.pEntity = pTeleport; - entry.prevAbsOrigin = pTeleport->GetAbsOrigin(); - entry.prevAbsAngles = pTeleport->GetAbsAngles(); - - teleportList.AddToTail( entry ); - - CBaseEntity *pList = pTeleport->FirstMoveChild(); - while ( pList ) - { - BuildTeleportList_r( pList, teleportList ); - pList = pList->NextMovePeer(); - } -} - - -static CUtlVector g_TeleportStack; -void CBaseEntity::Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity ) -{ - if ( g_TeleportStack.Find( this ) >= 0 ) - return; - int index = g_TeleportStack.AddToTail( this ); - - CUtlVector teleportList; - BuildTeleportList_r( this, teleportList ); - - int i; - for ( i = 0; i < teleportList.Count(); i++) - { - TeleportEntity( this, teleportList[i], newPosition, newAngles, newVelocity ); - } - - for (i = 0; i < teleportList.Count(); i++) - { - teleportList[i].pEntity->CollisionRulesChanged(); - } - - Assert( g_TeleportStack[index] == this ); - g_TeleportStack.FastRemove( index ); - - // FIXME: add an initializer function to StepSimulationData - StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); - if (step) - { - Q_memset( step, 0, sizeof( *step ) ); - } -} - -// Stuff implemented for weapon prediction code -void CBaseEntity::SetSize( const Vector &vecMin, const Vector &vecMax ) -{ - UTIL_SetSize( this, vecMin, vecMax ); -} - -CStudioHdr *ModelSoundsCache_LoadModel( const char *filename ) -{ - // Load the file - int idx = engine->PrecacheModel( filename, true ); - if ( idx != -1 ) - { - model_t *mdl = (model_t *)modelinfo->GetModel( idx ); - if ( mdl ) - { - CStudioHdr *studioHdr = new CStudioHdr( modelinfo->GetStudiomodel( mdl ), mdlcache ); - if ( studioHdr->IsValid() ) - { - return studioHdr; - } - } - } - return NULL; -} - -void ModelSoundsCache_FinishModel( CStudioHdr *hdr ) -{ - Assert( hdr ); - delete hdr; -} - -void ModelSoundsCache_PrecacheScriptSound( const char *soundname ) -{ - CBaseEntity::PrecacheScriptSound( soundname ); -} - -static CUtlCachedFileData< CModelSoundsCache > g_ModelSoundsCache( "modelsounds.cache", MODELSOUNDSCACHE_VERSION, 0, UTL_CACHED_FILE_USE_FILESIZE, false ); - -void ClearModelSoundsCache() -{ - if ( IsX360() ) - { - return; - } - - g_ModelSoundsCache.Reload(); -} - -//----------------------------------------------------------------------------- -// Purpose: -// Output : Returns true on success, false on failure. -//----------------------------------------------------------------------------- -bool ModelSoundsCacheInit() -{ - if ( IsX360() ) - { - return true; - } - - return g_ModelSoundsCache.Init(); -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -void ModelSoundsCacheShutdown() -{ - if ( IsX360() ) - { - return; - } - - g_ModelSoundsCache.Shutdown(); -} - -static CUtlSymbolTable g_ModelSoundsSymbolHelper( 0, 32, true ); -class CModelSoundsCacheSaver: public CAutoGameSystem -{ -public: - CModelSoundsCacheSaver( const char *name ) : CAutoGameSystem( name ) - { - } - virtual void LevelInitPostEntity() - { - if ( IsX360() ) - { - return; - } - - if ( g_ModelSoundsCache.IsDirty() ) - { - g_ModelSoundsCache.Save(); - } - } - virtual void LevelShutdownPostEntity() - { - if ( IsX360() ) - { - // Unforunate that this table must persist through duration of level. - // It is the common case that PrecacheModel() still gets called (and needs this table), - // after LevelInitPostEntity, as PrecacheModel() redundantly precaches. - g_ModelSoundsSymbolHelper.RemoveAll(); - return; - } - - if ( g_ModelSoundsCache.IsDirty() ) - { - g_ModelSoundsCache.Save(); - } - } -}; - -static CModelSoundsCacheSaver g_ModelSoundsCacheSaver( "CModelSoundsCacheSaver" ); - -//#define WATCHACCESS -#if defined( WATCHACCESS ) - -static bool g_bWatching = true; - -void ModelLogFunc( const char *fileName, const char *accessType ) -{ - if ( g_bWatching && !CBaseEntity::IsPrecacheAllowed() ) - { - if ( Q_stristr( fileName, ".vcd" ) ) - { - Msg( "%s\n", fileName ); - } - } -} - -class CWatchForModelAccess: public CAutoGameSystem -{ -public: - virtual bool Init() - { - filesystem->AddLoggingFunc(&ModelLogFunc); - return true; - } - - virtual void Shutdown() - { - filesystem->RemoveLoggingFunc(&ModelLogFunc); - } - -}; - -static CWatchForModelAccess g_WatchForModels; - -#endif - -// HACK: This must match the #define in cl_animevent.h in the client .dll code!!! -#define CL_EVENT_SOUND 5004 -#define CL_EVENT_FOOTSTEP_LEFT 6004 -#define CL_EVENT_FOOTSTEP_RIGHT 6005 -#define CL_EVENT_MFOOTSTEP_LEFT 6006 -#define CL_EVENT_MFOOTSTEP_RIGHT 6007 - -//----------------------------------------------------------------------------- -// Precache model sound. Requires a local symbol table to prevent -// a very expensive call to PrecacheScriptSound(). -//----------------------------------------------------------------------------- -void CBaseEntity::PrecacheSoundHelper( const char *pName ) -{ - if ( !IsX360() ) - { - // 360 only - Assert( 0 ); - return; - } - - if ( !pName || !pName[0] ) - { - return; - } - - if ( UTL_INVAL_SYMBOL == g_ModelSoundsSymbolHelper.Find( pName ) ) - { - g_ModelSoundsSymbolHelper.AddString( pName ); - - // very expensive, only call when required - PrecacheScriptSound( pName ); - } -} - -//----------------------------------------------------------------------------- -// Precache model components -//----------------------------------------------------------------------------- -void CBaseEntity::PrecacheModelComponents( int nModelIndex ) -{ - - model_t *pModel = (model_t *)modelinfo->GetModel( nModelIndex ); - if ( !pModel || modelinfo->GetModelType( pModel ) != mod_studio ) - { - return; - } - - // sounds - if ( IsPC() ) - { - const char *name = modelinfo->GetModelName( pModel ); - if ( !g_ModelSoundsCache.EntryExists( name ) ) - { - char extension[ 8 ]; - Q_ExtractFileExtension( name, extension, sizeof( extension ) ); - - if ( Q_stristr( extension, "mdl" ) ) - { - DevMsg( 2, "Late precache of %s, need to rebuild modelsounds.cache\n", name ); - } - else - { - if ( !extension[ 0 ] ) - { - Warning( "Precache of %s ambigious (no extension specified)\n", name ); - } - else - { - Warning( "Late precache of %s (file missing?)\n", name ); - } - return; - } - } - - CModelSoundsCache *entry = g_ModelSoundsCache.Get( name ); - Assert( entry ); - if ( entry ) - { - entry->PrecacheSoundList(); - } - } - - // particles - { - // Check keyvalues for auto-emitting particles - KeyValues *pModelKeyValues = new KeyValues(""); - KeyValues::AutoDelete autodelete_pModelKeyValues( pModelKeyValues ); - if ( pModelKeyValues->LoadFromBuffer( modelinfo->GetModelName( pModel ), modelinfo->GetModelKeyValueText( pModel ) ) ) - { - KeyValues *pParticleEffects = pModelKeyValues->FindKey("Particles"); - if ( pParticleEffects ) - { - // Start grabbing the sounds and slotting them in - for ( KeyValues *pSingleEffect = pParticleEffects->GetFirstSubKey(); pSingleEffect; pSingleEffect = pSingleEffect->GetNextKey() ) - { - const char *pParticleEffectName = pSingleEffect->GetString( "name", "" ); - PrecacheParticleSystem( pParticleEffectName ); - } - } - } - } - - // model anim event owned components - { - // Check animevents for particle events - CStudioHdr studioHdr( modelinfo->GetStudiomodel( pModel ), mdlcache ); - if ( studioHdr.IsValid() ) - { - // force animation event resolution!!! - VerifySequenceIndex( &studioHdr ); - - int nSeqCount = studioHdr.GetNumSeq(); - for ( int i = 0; i < nSeqCount; ++i ) - { - mstudioseqdesc_t &seq = studioHdr.pSeqdesc( i ); - int nEventCount = seq.numevents; - for ( int j = 0; j < nEventCount; ++j ) - { - mstudioevent_t *pEvent = seq.pEvent( j ); - - if ( !( pEvent->type & AE_TYPE_NEWEVENTSYSTEM ) || ( pEvent->type & AE_TYPE_CLIENT ) ) - { - if ( pEvent->event == AE_CL_CREATE_PARTICLE_EFFECT ) - { - char token[256]; - const char *pOptions = pEvent->pszOptions(); - nexttoken( token, pOptions, ' ' ); - if ( token ) - { - PrecacheParticleSystem( token ); - } - continue; - } - } - - // 360 precaches the model sounds now at init time, the cost is now ~250 msecs worst case. - // The disk based solution was not needed. Now at runtime partly due to already crawling the sequences - // for the particles and the expensive part was redundant PrecacheScriptSound(), which is now prevented - // by a local symbol table. - if ( IsX360() ) - { - switch ( pEvent->event ) - { - default: - { - if ( ( pEvent->type & AE_TYPE_NEWEVENTSYSTEM ) && ( pEvent->event == AE_SV_PLAYSOUND ) ) - { - PrecacheSoundHelper( pEvent->pszOptions() ); - } - } - break; - case CL_EVENT_FOOTSTEP_LEFT: - case CL_EVENT_FOOTSTEP_RIGHT: - { - char soundname[256]; - char const *options = pEvent->pszOptions(); - if ( !options || !options[0] ) - { - options = "NPC_CombineS"; - } - - Q_snprintf( soundname, sizeof( soundname ), "%s.RunFootstepLeft", options ); - PrecacheSoundHelper( soundname ); - Q_snprintf( soundname, sizeof( soundname ), "%s.RunFootstepRight", options ); - PrecacheSoundHelper( soundname ); - Q_snprintf( soundname, sizeof( soundname ), "%s.FootstepLeft", options ); - PrecacheSoundHelper( soundname ); - Q_snprintf( soundname, sizeof( soundname ), "%s.FootstepRight", options ); - PrecacheSoundHelper( soundname ); - } - break; - case AE_CL_PLAYSOUND: - { - if ( !( pEvent->type & AE_TYPE_CLIENT ) ) - break; - - if ( pEvent->pszOptions()[0] ) - { - PrecacheSoundHelper( pEvent->pszOptions() ); - } - else - { - Warning( "-- Error --: empty soundname, .qc error on AE_CL_PLAYSOUND in model %s, sequence %s, animevent # %i\n", - studioHdr.GetRenderHdr()->pszName(), seq.pszLabel(), j+1 ); - } - } - break; - case CL_EVENT_SOUND: - case SCRIPT_EVENT_SOUND: - case SCRIPT_EVENT_SOUND_VOICE: - { - PrecacheSoundHelper( pEvent->pszOptions() ); - } - break; - } - } - } - } - } - } -} - - - -//----------------------------------------------------------------------------- -// Purpose: Add model to level precache list -// Input : *name - model name -// Output : int -- model index for model -//----------------------------------------------------------------------------- -int CBaseEntity::PrecacheModel( const char *name, bool bPreload ) -{ - if ( !name || !*name ) - { - Msg( "Attempting to precache model, but model name is NULL\n"); - return -1; - } - - // Warn on out of order precache - if ( !CBaseEntity::IsPrecacheAllowed() ) - { - if ( !engine->IsModelPrecached( name ) ) - { - Assert( !"CBaseEntity::PrecacheModel: too late" ); - Warning( "Late precache of %s\n", name ); - } - } -#if defined( WATCHACCESS ) - else - { - g_bWatching = false; - } -#endif - - int idx = engine->PrecacheModel( name, bPreload ); - if ( idx != -1 ) - { - PrecacheModelComponents( idx ); - } - -#if defined( WATCHACCESS ) - g_bWatching = true; -#endif - - return idx; -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -void CBaseEntity::Remove( ) -{ - UTIL_Remove( this ); -} - -// Entity degugging console commands -extern CBaseEntity *FindPickerEntity( CBasePlayer *pPlayer ); -extern void SetDebugBits( CBasePlayer* pPlayer, const char *name, int bit ); -extern CBaseEntity *GetNextCommandEntity( CBasePlayer *pPlayer, const char *name, CBaseEntity *ent ); - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void ConsoleFireTargets( CBasePlayer *pPlayer, const char *name) -{ - // If no name was given use the picker - if (FStrEq(name,"")) - { - CBaseEntity *pEntity = FindPickerEntity( pPlayer ); - if ( pEntity && !pEntity->IsMarkedForDeletion()) - { - Msg( "[%03d] Found: %s, firing\n", gpGlobals->tickcount%1000, pEntity->GetDebugName()); - pEntity->Use( pPlayer, pPlayer, USE_TOGGLE, 0 ); - return; - } - } - // Otherwise use name or classname - FireTargets( name, pPlayer, pPlayer, USE_TOGGLE, 0 ); -} - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_Name( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_NAME_BIT); -} -static ConCommand ent_name("ent_name", CC_Ent_Name, 0, FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Ent_Text( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_TEXT_BIT); -} -static ConCommand ent_text("ent_text", CC_Ent_Text, "Displays text debugging information about the given entity(ies) on top of the entity (See Overlay Text)\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Ent_BBox( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_BBOX_BIT); -} -static ConCommand ent_bbox("ent_bbox", CC_Ent_BBox, "Displays the movement bounding box for the given entity(ies) in orange. Some entites will also display entity specific overlays.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - - -//------------------------------------------------------------------------------ -void CC_Ent_AbsBox( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_ABSBOX_BIT); -} -static ConCommand ent_absbox("ent_absbox", CC_Ent_AbsBox, "Displays the total bounding box for the given entity(s) in green. Some entites will also display entity specific overlays.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - - -//------------------------------------------------------------------------------ -void CC_Ent_RBox( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_RBOX_BIT); -} -static ConCommand ent_rbox("ent_rbox", CC_Ent_RBox, "Displays the total bounding box for the given entity(s) in green. Some entites will also display entity specific overlays.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Ent_AttachmentPoints( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_ATTACHMENTS_BIT); -} -static ConCommand ent_attachments("ent_attachments", CC_Ent_AttachmentPoints, "Displays the attachment points on an entity.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Ent_ViewOffset( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_VIEWOFFSET); -} -static ConCommand ent_viewoffset("ent_viewoffset", CC_Ent_ViewOffset, "Displays the eye position for the given entity(ies) in red.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Ent_Remove( const CCommand& args ) -{ - CBaseEntity *pEntity = NULL; - - // If no name was given set bits based on the picked - if ( FStrEq( args[1],"") ) - { - pEntity = FindPickerEntity( UTIL_GetCommandClient() ); - } - else - { - int index = atoi( args[1] ); - if ( index ) - { - pEntity = CBaseEntity::Instance( index ); - } - else - { - // Otherwise set bits based on name or classname - CBaseEntity *ent = NULL; - while ( (ent = gEntList.NextEnt(ent)) != NULL ) - { - if ( (ent->GetEntityName() != NULL_STRING && FStrEq(args[1], STRING(ent->GetEntityName()))) || - (ent->m_iClassname != NULL_STRING && FStrEq(args[1], STRING(ent->m_iClassname))) || - (ent->GetClassname()!=NULL && FStrEq(args[1], ent->GetClassname()))) - { - pEntity = ent; - break; - } - } - } - } - - // Found one? - if ( pEntity ) - { - Msg( "Removed %s(%s)\n", STRING(pEntity->m_iClassname), pEntity->GetDebugName() ); - UTIL_Remove( pEntity ); - } -} -static ConCommand ent_remove("ent_remove", CC_Ent_Remove, "Removes the given entity(s)\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Ent_RemoveAll( const CCommand& args ) -{ - // If no name was given remove based on the picked - if ( args.ArgC() < 2 ) - { - Msg( "Removes all entities of the specified type\n\tArguments: {entity_name} / {class_name}\n" ); - } - else - { - // Otherwise remove based on name or classname - int iCount = 0; - CBaseEntity *ent = NULL; - while ( (ent = gEntList.NextEnt(ent)) != NULL ) - { - if ( (ent->GetEntityName() != NULL_STRING && FStrEq(args[1], STRING(ent->GetEntityName()))) || - (ent->m_iClassname != NULL_STRING && FStrEq(args[1], STRING(ent->m_iClassname))) || - (ent->GetClassname()!=NULL && FStrEq(args[1], ent->GetClassname()))) - { - UTIL_Remove( ent ); - iCount++; - } - } - - if ( iCount ) - { - Msg( "Removed %d %s's\n", iCount, args[1] ); - } - else - { - Msg( "No %s found.\n", args[1] ); - } - } -} -static ConCommand ent_remove_all("ent_remove_all", CC_Ent_RemoveAll, "Removes all entities of the specified type\n\tArguments: {entity_name} / {class_name} ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Ent_SetName( const CCommand& args ) -{ - CBaseEntity *pEntity = NULL; - - if ( args.ArgC() < 1 ) - { - CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); - if (!pPlayer) - return; - - ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_setname \n" ); - } - else - { - // If no name was given set bits based on the picked - if ( FStrEq( args[2],"") ) - { - pEntity = FindPickerEntity( UTIL_GetCommandClient() ); - } - else - { - // Otherwise set bits based on name or classname - CBaseEntity *ent = NULL; - while ( (ent = gEntList.NextEnt(ent)) != NULL ) - { - if ( (ent->GetEntityName() != NULL_STRING && FStrEq(args[1], STRING(ent->GetEntityName()))) || - (ent->m_iClassname != NULL_STRING && FStrEq(args[1], STRING(ent->m_iClassname))) || - (ent->GetClassname()!=NULL && FStrEq(args[1], ent->GetClassname()))) - { - pEntity = ent; - break; - } - } - } - - // Found one? - if ( pEntity ) - { - Msg( "Set the name of %s to %s\n", STRING(pEntity->m_iClassname), args[1] ); - pEntity->SetName( AllocPooledString( args[1] ) ); - } - } -} -static ConCommand ent_setname("ent_setname", CC_Ent_SetName, "Sets the targetname of the given entity(s)\n\tArguments: {new entity name} {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Find_Ent( const CCommand& args ) -{ - if ( args.ArgC() < 2 ) - { - Msg( "Total entities: %d (%d edicts)\n", gEntList.NumberOfEntities(), gEntList.NumberOfEdicts() ); - Msg( "Format: find_ent \n" ); - return; - } - - int iCount = 0; - const char *pszSubString = args[1]; - Msg("Searching for entities with class/target name containing substring: '%s'\n", pszSubString ); - - CBaseEntity *ent = NULL; - while ( (ent = gEntList.NextEnt(ent)) != NULL ) - { - const char *pszClassname = ent->GetClassname(); - const char *pszTargetname = STRING(ent->GetEntityName()); - - bool bMatches = false; - if ( pszClassname && pszClassname[0] ) - { - if ( Q_stristr( pszClassname, pszSubString ) ) - { - bMatches = true; - } - } - - if ( !bMatches && pszTargetname && pszTargetname[0] ) - { - if ( Q_stristr( pszTargetname, pszSubString ) ) - { - bMatches = true; - } - } - - if ( bMatches ) - { - iCount++; - Msg(" '%s' : '%s' (entindex %d) \n", ent->GetClassname(), ent->GetEntityName().ToCStr(), ent->entindex() ); - } - } - - Msg("Found %d matches.\n", iCount); -} -static ConCommand find_ent("find_ent", CC_Find_Ent, "Find and list all entities with classnames or targetnames that contain the specified substring.\nFormat: find_ent \n", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -void CC_Find_Ent_Index( const CCommand& args ) -{ - if ( args.ArgC() < 2 ) - { - Msg( "Format: find_ent_index \n" ); - return; - } - - int iIndex = atoi(args[1]); - CBaseEntity *pEnt = UTIL_EntityByIndex( iIndex ); - if ( pEnt ) - { - Msg(" '%s' : '%s' (entindex %d) \n", pEnt->GetClassname(), pEnt->GetEntityName().ToCStr(), iIndex ); - } - else - { - Msg("Found no entity at %d.\n", iIndex); - } -} -static ConCommand find_ent_index("find_ent_index", CC_Find_Ent_Index, "Display data for entity matching specified index.\nFormat: find_ent_index \n", FCVAR_CHEAT); - -// Purpose : -//------------------------------------------------------------------------------ -void CC_Ent_Dump( const CCommand& args ) -{ - CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); - if (!pPlayer) - { - return; - } - - if ( args.ArgC() < 2 ) - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_dump \n" ); - } - else - { - // iterate through all the ents of this name, printing out their details - CBaseEntity *ent = NULL; - bool bFound = false; - while ( ( ent = gEntList.FindEntityByName(ent, args[1] ) ) != NULL ) - { - bFound = true; - for ( datamap_t *dmap = ent->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) - { - // search through all the actions in the data description, printing out details - for ( int i = 0; i < dmap->dataNumFields; i++ ) - { - variant_t var; - if ( ent->ReadKeyField( dmap->dataDesc[i].externalName, &var) ) - { - char buf[256]; - buf[0] = 0; - switch( var.FieldType() ) - { - case FIELD_STRING: - Q_strncpy( buf, var.String() ,sizeof(buf)); - break; - case FIELD_INTEGER: - if ( var.Int() ) - Q_snprintf( buf,sizeof(buf), "%d", var.Int() ); - break; - case FIELD_FLOAT: - if ( var.Float() ) - Q_snprintf( buf,sizeof(buf), "%.2f", var.Float() ); - break; - case FIELD_EHANDLE: - { - // get the entities name - if ( var.Entity() ) - { - Q_snprintf( buf,sizeof(buf), "%s", STRING(var.Entity()->GetEntityName()) ); - } - } - break; - } - - // don't print out the duplicate keys - if ( !Q_stricmp("parentname",dmap->dataDesc[i].externalName) || !Q_stricmp("targetname",dmap->dataDesc[i].externalName) ) - continue; - - // don't print out empty keys - if ( buf[0] ) - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs(" %s: %s\n", dmap->dataDesc[i].externalName, buf) ); - } - } - } - } - } - - if ( !bFound ) - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, "ent_dump: no such entity" ); - } - } -} -static ConCommand ent_dump("ent_dump", CC_Ent_Dump, "Usage:\n ent_dump \n", FCVAR_CHEAT); - - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_FireTarget( const CCommand& args ) -{ - ConsoleFireTargets(UTIL_GetCommandClient(),args[1]); -} -static ConCommand firetarget("firetarget", CC_Ent_FireTarget, 0, FCVAR_CHEAT); - -static bool UtlStringLessFunc( const CUtlString &lhs, const CUtlString &rhs ) -{ - return Q_stricmp( lhs.String(), rhs.String() ) < 0; -} - -class CEntFireAutoCompletionFunctor : public ICommandCallback, public ICommandCompletionCallback -{ -public: - virtual void CommandCallback( const CCommand &command ) - { - CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); - if (!pPlayer) - { - return; - } - - // fires a command from the console - if ( command.ArgC() < 2 ) - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_fire [action] [value] [delay]\n" ); - } - else - { - const char *target = "", *action = "Use"; - variant_t value; - int delay = 0; - - target = STRING( AllocPooledString(command.Arg( 1 ) ) ); - - // Don't allow them to run anything on a point_servercommand unless they're the host player. Otherwise they can ent_fire - // and run any command on the server. Admittedly, they can only do the ent_fire if sv_cheats is on, but - // people complained about users resetting the rcon password if the server briefly turned on cheats like this: - // give point_servercommand - // ent_fire point_servercommand command "rcon_password mynewpassword" - // - // Robin: Unfortunately, they get around point_servercommand checks with this: - // ent_create point_servercommand; ent_setname mine; ent_fire mine command "rcon_password mynewpassword" - // So, I'm removing the ability for anyone to execute ent_fires on dedicated servers (we can't check to see if - // this command is going to connect with a point_servercommand entity here, because they could delay the event and create it later). - if ( engine->IsDedicatedServer() ) - { - // We allow people with disabled autokick to do it, because they already have rcon. - if ( pPlayer->IsAutoKickDisabled() == false ) - return; - } - else if ( gpGlobals->maxClients > 1 ) - { - // On listen servers with more than 1 player, only allow the host to issue ent_fires. - CBasePlayer *pHostPlayer = UTIL_GetListenServerHost(); - if ( pPlayer != pHostPlayer ) - return; - } - - if ( command.ArgC() >= 3 ) - { - action = STRING( AllocPooledString(command.Arg( 2 )) ); - } - if ( command.ArgC() >= 4 ) - { - value.SetString( AllocPooledString(command.Arg( 3 )) ); - } - if ( command.ArgC() >= 5 ) - { - delay = atoi( command.Arg( 4 ) ); - } - - g_EventQueue.AddEvent( target, action, value, delay, pPlayer, pPlayer ); - } - } - - virtual int CommandCompletionCallback( const char *partial, CUtlVector< CUtlString > &commands ) - { - if ( !g_pGameRules ) - { - return 0; - } - - const char *cmdname = "ent_fire"; - - char *substring = (char *)partial; - if ( Q_strstr( partial, cmdname ) ) - { - substring = (char *)partial + strlen( cmdname ) + 1; - } - - int checklen = 0; - char *space = Q_strstr( substring, " " ); - if ( space ) - { - return EntFire_AutoCompleteInput( partial, commands );; - } - else - { - checklen = Q_strlen( substring ); - } - - CUtlRBTree< CUtlString > symbols( 0, 0, UtlStringLessFunc ); - - CBaseEntity *pos = NULL; - while ( ( pos = gEntList.NextEnt( pos ) ) != NULL ) - { - // Check target name against partial string - if ( pos->GetEntityName() == NULL_STRING ) - continue; - - if ( Q_strnicmp( STRING( pos->GetEntityName() ), substring, checklen ) ) - continue; - - CUtlString sym = STRING( pos->GetEntityName() ); - int idx = symbols.Find( sym ); - if ( idx == symbols.InvalidIndex() ) - { - symbols.Insert( sym ); - } - - // Too many - if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS ) - break; - } - - // Now fill in the results - for ( int i = symbols.FirstInorder(); i != symbols.InvalidIndex(); i = symbols.NextInorder( i ) ) - { - const char *name = symbols[ i ].String(); - - char buf[ 512 ]; - Q_strncpy( buf, name, sizeof( buf ) ); - Q_strlower( buf ); - - CUtlString command; - command = CFmtStr( "%s %s", cmdname, buf ); - commands.AddToTail( command ); - } - - return symbols.Count(); - } -private: - int EntFire_AutoCompleteInput( const char *partial, CUtlVector< CUtlString > &commands ) - { - const char *cmdname = "ent_fire"; - - char *substring = (char *)partial; - if ( Q_strstr( partial, cmdname ) ) - { - substring = (char *)partial + strlen( cmdname ) + 1; - } - - int checklen = 0; - char *space = Q_strstr( substring, " " ); - if ( !space ) - { - Assert( !"CC_EntFireAutoCompleteInputFunc is broken\n" ); - return 0; - } - - checklen = Q_strlen( substring ); - - char targetEntity[ 256 ]; - targetEntity[0] = 0; - int nEntityNameLength = (space-substring); - Q_strncat( targetEntity, substring, sizeof( targetEntity ), nEntityNameLength ); - - // Find the target entity by name - CBaseEntity *target = gEntList.FindEntityByName( NULL, targetEntity ); - if ( target == NULL ) - return 0; - - CUtlRBTree< CUtlString > symbols( 0, 0, UtlStringLessFunc ); - - // Find the next portion of the text chain, if any (removing space) - int nInputNameLength = (checklen-nEntityNameLength-1); - - // Starting past the last space, this is the remainder of the string - char *inputPartial = ( checklen > nEntityNameLength ) ? (space+1) : NULL; - - for ( datamap_t *dmap = target->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) - { - // Make sure we don't keep adding things in if the satisfied the limit - if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS ) - break; - - int c = dmap->dataNumFields; - for ( int i = 0; i < c; i++ ) - { - typedescription_t *field = &dmap->dataDesc[ i ]; - - // Only want inputs - if ( !( field->flags & FTYPEDESC_INPUT ) ) - continue; - - // Only want input functions - if ( field->flags & FTYPEDESC_SAVE ) - continue; - - // See if we've got a partial string for the input name already - if ( inputPartial != NULL ) - { - if ( Q_strnicmp( inputPartial, field->externalName, nInputNameLength ) ) - continue; - } - - CUtlString sym = field->externalName; - - int idx = symbols.Find( sym ); - if ( idx == symbols.InvalidIndex() ) - { - symbols.Insert( sym ); - } - - // Too many items have been added - if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS ) - break; - } - } - - // Now fill in the results - for ( int i = symbols.FirstInorder(); i != symbols.InvalidIndex(); i = symbols.NextInorder( i ) ) - { - const char *name = symbols[ i ].String(); - - char buf[ 512 ]; - Q_strncpy( buf, name, sizeof( buf ) ); - Q_strlower( buf ); - - CUtlString command; - command = CFmtStr( "%s %s %s", cmdname, targetEntity, buf ); - commands.AddToTail( command ); - } - - return symbols.Count(); - } -}; - -static CEntFireAutoCompletionFunctor g_EntFireAutoComplete; -static ConCommand ent_fire("ent_fire", &g_EntFireAutoComplete, "Usage:\n ent_fire [action] [value] [delay]\n", FCVAR_CHEAT, &g_EntFireAutoComplete ); - -void CC_Ent_CancelPendingEntFires( const CCommand& args ) -{ - if ( !UTIL_IsCommandIssuedByServerAdmin() ) - return; - - CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); - if (!pPlayer) - return; - - g_EventQueue.CancelEvents( pPlayer ); -} -static ConCommand ent_cancelpendingentfires("ent_cancelpendingentfires", CC_Ent_CancelPendingEntFires, "Cancels all ent_fire created outputs that are currently waiting for their delay to expire." ); - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_Info( const CCommand& args ) -{ - CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); - if (!pPlayer) - { - return; - } - - if ( args.ArgC() < 2 ) - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_info \n" ); - } - else - { - // iterate through all the ents printing out their details - CBaseEntity *ent = CreateEntityByName( args[1] ); - - if ( ent ) - { - datamap_t *dmap; - for ( dmap = ent->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) - { - // search through all the actions in the data description, printing out details - for ( int i = 0; i < dmap->dataNumFields; i++ ) - { - if ( dmap->dataDesc[i].flags & FTYPEDESC_OUTPUT ) - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs(" output: %s\n", dmap->dataDesc[i].externalName) ); - } - } - } - - for ( dmap = ent->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) - { - // search through all the actions in the data description, printing out details - for ( int i = 0; i < dmap->dataNumFields; i++ ) - { - if ( dmap->dataDesc[i].flags & FTYPEDESC_INPUT ) - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs(" input: %s\n", dmap->dataDesc[i].externalName) ); - } - } - } - - delete ent; - } - else - { - ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs("no such entity %s\n", args[1]) ); - } - } -} -static ConCommand ent_info("ent_info", CC_Ent_Info, "Usage:\n ent_info \n", FCVAR_CHEAT); - - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_Messages( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_MESSAGE_BIT); -} -static ConCommand ent_messages("ent_messages", CC_Ent_Messages ,"Toggles input/output message display for the selected entity(ies). The name of the entity will be displayed as well as any messages that it sends or receives.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at", FCVAR_CHEAT); - - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_Pause( void ) -{ - if (CBaseEntity::Debug_IsPaused()) - { - Msg( "Resuming entity I/O events\n" ); - CBaseEntity::Debug_Pause(false); - } - else - { - Msg( "Pausing entity I/O events\n" ); - CBaseEntity::Debug_Pause(true); - } -} -static ConCommand ent_pause("ent_pause", CC_Ent_Pause, "Toggles pausing of input/output message processing for entities. When turned on processing of all message will stop. Any messages displayed with 'ent_messages' will stop fading and be displayed indefinitely. To step through the messages one by one use 'ent_step'.", FCVAR_CHEAT); - - -//------------------------------------------------------------------------------ -// Purpose : Enables the entity picker, revelaing debug information about the -// entity under the crosshair. -// Input : an optional command line argument "full" enables all debug info. -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_Picker( void ) -{ - CBaseEntity::m_bInDebugSelect = CBaseEntity::m_bInDebugSelect ? false : true; - - // Remember the player that's making this request - CBaseEntity::m_nDebugPlayer = UTIL_GetCommandClientIndex(); -} -static ConCommand picker("picker", CC_Ent_Picker, "Toggles 'picker' mode. When picker is on, the bounding box, pivot and debugging text is displayed for whatever entity the player is looking at.\n\tArguments: full - enables all debug information", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_Pivot( const CCommand& args ) -{ - SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_PIVOT_BIT); -} -static ConCommand ent_pivot("ent_pivot", CC_Ent_Pivot, "Displays the pivot for the given entity(ies).\n\t(y=up=green, z=forward=blue, x=left=red). \n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -// Purpose : -// Input : -// Output : -//------------------------------------------------------------------------------ -void CC_Ent_Step( const CCommand& args ) -{ - int nSteps = atoi(args[1]); - if (nSteps <= 0) - { - nSteps = 1; - } - CBaseEntity::Debug_SetSteps(nSteps); -} -static ConCommand ent_step("ent_step", CC_Ent_Step, "When 'ent_pause' is set this will step through one waiting input / output message at a time.", FCVAR_CHEAT); - -void CBaseEntity::SetCheckUntouch( bool check ) -{ - // Invalidate touchstamp - if ( check ) - { - touchStamp++; - if ( !IsEFlagSet( EFL_CHECK_UNTOUCH ) ) - { - AddEFlags( EFL_CHECK_UNTOUCH ); - EntityTouch_Add( this ); - } - } - else - { - RemoveEFlags( EFL_CHECK_UNTOUCH ); - } -} - -model_t *CBaseEntity::GetModel( void ) -{ - return (model_t *)modelinfo->GetModel( GetModelIndex() ); -} - - -//----------------------------------------------------------------------------- -// Purpose: Calculates the absolute position of an edict in the world -// assumes the parent's absolute origin has already been calculated -//----------------------------------------------------------------------------- -void CBaseEntity::CalcAbsolutePosition( void ) -{ - if (!IsEFlagSet( EFL_DIRTY_ABSTRANSFORM )) - return; - - RemoveEFlags( EFL_DIRTY_ABSTRANSFORM ); - - // Plop the entity->parent matrix into m_rgflCoordinateFrame - AngleMatrix( m_angRotation, m_vecOrigin, m_rgflCoordinateFrame ); - - CBaseEntity *pMoveParent = GetMoveParent(); - if ( !pMoveParent ) - { - // no move parent, so just copy existing values - m_vecAbsOrigin = m_vecOrigin; - m_angAbsRotation = m_angRotation; - if ( HasDataObjectType( POSITIONWATCHER ) ) - { - ReportPositionChanged( this ); - } - return; - } - - // concatenate with our parent's transform - matrix3x4_t tmpMatrix, scratchSpace; - ConcatTransforms( GetParentToWorldTransform( scratchSpace ), m_rgflCoordinateFrame, tmpMatrix ); - MatrixCopy( tmpMatrix, m_rgflCoordinateFrame ); - - // pull our absolute position out of the matrix - MatrixGetColumn( m_rgflCoordinateFrame, 3, m_vecAbsOrigin ); - - // if we have any angles, we have to extract our absolute angles from our matrix - if (( m_angRotation == vec3_angle ) && ( m_iParentAttachment == 0 )) - { - // just copy our parent's absolute angles - VectorCopy( pMoveParent->GetAbsAngles(), m_angAbsRotation ); - } - else - { - MatrixAngles( m_rgflCoordinateFrame, m_angAbsRotation ); - } - if ( HasDataObjectType( POSITIONWATCHER ) ) - { - ReportPositionChanged( this ); - } -} - -void CBaseEntity::CalcAbsoluteVelocity() -{ - if (!IsEFlagSet( EFL_DIRTY_ABSVELOCITY )) - return; - - RemoveEFlags( EFL_DIRTY_ABSVELOCITY ); - - CBaseEntity *pMoveParent = GetMoveParent(); - if ( !pMoveParent ) - { - m_vecAbsVelocity = m_vecVelocity; - return; - } - - // This transforms the local velocity into world space - VectorRotate( m_vecVelocity, pMoveParent->EntityToWorldTransform(), m_vecAbsVelocity ); - - // Now add in the parent abs velocity - m_vecAbsVelocity += pMoveParent->GetAbsVelocity(); -} - -// FIXME: While we're using (dPitch, dYaw, dRoll) as our local angular velocity -// representation, we can't actually solve this problem -/* -void CBaseEntity::CalcAbsoluteAngularVelocity() -{ - if (!IsEFlagSet( EFL_DIRTY_ABSANGVELOCITY )) - return; - - RemoveEFlags( EFL_DIRTY_ABSANGVELOCITY ); - - CBaseEntity *pMoveParent = GetMoveParent(); - if ( !pMoveParent ) - { - m_vecAbsAngVelocity = m_vecAngVelocity; - return; - } - - // This transforms the local ang velocity into world space - matrix3x4_t angVelToParent, angVelToWorld; - AngleMatrix( m_vecAngVelocity, angVelToParent ); - ConcatTransforms( pMoveParent->EntityToWorldTransform(), angVelToParent, angVelToWorld ); - MatrixAngles( angVelToWorld, m_vecAbsAngVelocity ); -} -*/ - -//----------------------------------------------------------------------------- -// Computes the abs position of a point specified in local space -//----------------------------------------------------------------------------- -void CBaseEntity::ComputeAbsPosition( const Vector &vecLocalPosition, Vector *pAbsPosition ) -{ - CBaseEntity *pMoveParent = GetMoveParent(); - if ( !pMoveParent ) - { - *pAbsPosition = vecLocalPosition; - } - else - { - VectorTransform( vecLocalPosition, pMoveParent->EntityToWorldTransform(), *pAbsPosition ); - } -} - - -//----------------------------------------------------------------------------- -// Computes the abs position of a point specified in local space -//----------------------------------------------------------------------------- -void CBaseEntity::ComputeAbsDirection( const Vector &vecLocalDirection, Vector *pAbsDirection ) -{ - CBaseEntity *pMoveParent = GetMoveParent(); - if ( !pMoveParent ) - { - *pAbsDirection = vecLocalDirection; - } - else - { - VectorRotate( vecLocalDirection, pMoveParent->EntityToWorldTransform(), *pAbsDirection ); - } -} - - -matrix3x4_t& CBaseEntity::GetParentToWorldTransform( matrix3x4_t &tempMatrix ) -{ - CBaseEntity *pMoveParent = GetMoveParent(); - if ( !pMoveParent ) - { - Assert( false ); - SetIdentityMatrix( tempMatrix ); - return tempMatrix; - } - - if ( m_iParentAttachment != 0 ) - { - MDLCACHE_CRITICAL_SECTION(); - - CBaseAnimating *pAnimating = pMoveParent->GetBaseAnimating(); - if ( pAnimating && pAnimating->GetAttachment( m_iParentAttachment, tempMatrix ) ) - { - return tempMatrix; - } - } - - // If we fall through to here, then just use the move parent's abs origin and angles. - return pMoveParent->EntityToWorldTransform(); -} - - -//----------------------------------------------------------------------------- -// These methods recompute local versions as well as set abs versions -//----------------------------------------------------------------------------- -void CBaseEntity::SetAbsOrigin( const Vector& absOrigin ) -{ - AssertMsg( absOrigin.IsValid(), "Invalid origin set" ); - - // This is necessary to get the other fields of m_rgflCoordinateFrame ok - CalcAbsolutePosition(); - - if ( m_vecAbsOrigin == absOrigin ) - return; - - // All children are invalid, but we are not - InvalidatePhysicsRecursive( POSITION_CHANGED ); - RemoveEFlags( EFL_DIRTY_ABSTRANSFORM ); - - m_vecAbsOrigin = absOrigin; - - MatrixSetColumn( absOrigin, 3, m_rgflCoordinateFrame ); - - Vector vecNewOrigin; - CBaseEntity *pMoveParent = GetMoveParent(); - if (!pMoveParent) - { - vecNewOrigin = absOrigin; - } - else - { - matrix3x4_t tempMat; - matrix3x4_t &parentTransform = GetParentToWorldTransform( tempMat ); - - // Moveparent case: transform the abs position into local space - VectorITransform( absOrigin, parentTransform, vecNewOrigin ); - } - - if (m_vecOrigin != vecNewOrigin) - { - m_vecOrigin = vecNewOrigin; - SetSimulationTime( gpGlobals->curtime ); - } -} - -void CBaseEntity::SetAbsAngles( const QAngle& absAngles ) -{ - // This is necessary to get the other fields of m_rgflCoordinateFrame ok - CalcAbsolutePosition(); - - // FIXME: The normalize caused problems in server code like momentary_rot_button that isn't - // handling things like +/-180 degrees properly. This should be revisited. - //QAngle angleNormalize( AngleNormalize( absAngles.x ), AngleNormalize( absAngles.y ), AngleNormalize( absAngles.z ) ); - - if ( m_angAbsRotation == absAngles ) - return; - - // All children are invalid, but we are not - InvalidatePhysicsRecursive( ANGLES_CHANGED ); - RemoveEFlags( EFL_DIRTY_ABSTRANSFORM ); - - m_angAbsRotation = absAngles; - AngleMatrix( absAngles, m_rgflCoordinateFrame ); - MatrixSetColumn( m_vecAbsOrigin, 3, m_rgflCoordinateFrame ); - - QAngle angNewRotation; - CBaseEntity *pMoveParent = GetMoveParent(); - if (!pMoveParent) - { - angNewRotation = absAngles; - } - else - { - if ( m_angAbsRotation == pMoveParent->GetAbsAngles() ) - { - angNewRotation.Init( ); - } - else - { - // Moveparent case: transform the abs transform into local space - matrix3x4_t worldToParent, localMatrix; - MatrixInvert( pMoveParent->EntityToWorldTransform(), worldToParent ); - ConcatTransforms( worldToParent, m_rgflCoordinateFrame, localMatrix ); - MatrixAngles( localMatrix, angNewRotation ); - } - } - - if (m_angRotation != angNewRotation) - { - m_angRotation = angNewRotation; - SetSimulationTime( gpGlobals->curtime ); - } -} - -void CBaseEntity::SetAbsVelocity( const Vector &vecAbsVelocity ) -{ - if ( m_vecAbsVelocity == vecAbsVelocity ) - return; - - // The abs velocity won't be dirty since we're setting it here - // All children are invalid, but we are not - InvalidatePhysicsRecursive( VELOCITY_CHANGED ); - RemoveEFlags( EFL_DIRTY_ABSVELOCITY ); - - m_vecAbsVelocity = vecAbsVelocity; - - // NOTE: Do *not* do a network state change in this case. - // m_vecVelocity is only networked for the player, which is not manual mode - CBaseEntity *pMoveParent = GetMoveParent(); - if (!pMoveParent) - { - m_vecVelocity = vecAbsVelocity; - return; - } - - // First subtract out the parent's abs velocity to get a relative - // velocity measured in world space - Vector relVelocity; - VectorSubtract( vecAbsVelocity, pMoveParent->GetAbsVelocity(), relVelocity ); - - // Transform relative velocity into parent space - Vector vNew; - VectorIRotate( relVelocity, pMoveParent->EntityToWorldTransform(), vNew ); - m_vecVelocity = vNew; -} - -// FIXME: While we're using (dPitch, dYaw, dRoll) as our local angular velocity -// representation, we can't actually solve this problem -/* -void CBaseEntity::SetAbsAngularVelocity( const QAngle &vecAbsAngVelocity ) -{ - // The abs velocity won't be dirty since we're setting it here - // All children are invalid, but we are not - InvalidatePhysicsRecursive( EFL_DIRTY_ABSANGVELOCITY ); - RemoveEFlags( EFL_DIRTY_ABSANGVELOCITY ); - - m_vecAbsAngVelocity = vecAbsAngVelocity; - - CBaseEntity *pMoveParent = GetMoveParent(); - if (!pMoveParent) - { - m_vecAngVelocity = vecAbsAngVelocity; - return; - } - - // NOTE: We *can't* subtract out parent ang velocity, it's nonsensical - matrix3x4_t entityToWorld; - AngleMatrix( vecAbsAngVelocity, entityToWorld ); - - // Moveparent case: transform the abs relative angular vel into local space - matrix3x4_t worldToParent, localMatrix; - MatrixInvert( pMoveParent->EntityToWorldTransform(), worldToParent ); - ConcatTransforms( worldToParent, entityToWorld, localMatrix ); - MatrixAngles( localMatrix, m_vecAngVelocity ); -} -*/ - -//----------------------------------------------------------------------------- -// Methods that modify local physics state, and let us know to compute abs state later -//----------------------------------------------------------------------------- -void CBaseEntity::SetLocalOrigin( const Vector& origin ) -{ - // Safety check against NaN's or really huge numbers - if ( !IsEntityPositionReasonable( origin ) ) - { - if ( CheckEmitReasonablePhysicsSpew() ) - { - Warning( "Bad SetLocalOrigin(%f,%f,%f) on %s\n", origin.x, origin.y, origin.z, GetDebugName() ); - } - Assert( false ); - return; - } - -// if ( !origin.IsValid() ) -// { -// AssertMsg( 0, "Bad origin set" ); -// return; -// } - - if (m_vecOrigin != origin) - { - // Sanity check to make sure the origin is valid. -#ifdef _DEBUG - float largeVal = 1024 * 128; - Assert( origin.x >= -largeVal && origin.x <= largeVal ); - Assert( origin.y >= -largeVal && origin.y <= largeVal ); - Assert( origin.z >= -largeVal && origin.z <= largeVal ); -#endif - - InvalidatePhysicsRecursive( POSITION_CHANGED ); - m_vecOrigin = origin; - SetSimulationTime( gpGlobals->curtime ); - } -} - -void CBaseEntity::SetLocalAngles( const QAngle& angles ) -{ - // NOTE: The angle normalize is a little expensive, but we can save - // a bunch of time in interpolation if we don't have to invalidate everything - // and sometimes it's off by a normalization amount - - // FIXME: The normalize caused problems in server code like momentary_rot_button that isn't - // handling things like +/-180 degrees properly. This should be revisited. - //QAngle angleNormalize( AngleNormalize( angles.x ), AngleNormalize( angles.y ), AngleNormalize( angles.z ) ); - - // Safety check against NaN's or really huge numbers - if ( !IsEntityQAngleReasonable( angles ) ) - { - if ( CheckEmitReasonablePhysicsSpew() ) - { - Warning( "Bad SetLocalAngles(%f,%f,%f) on %s\n", angles.x, angles.y, angles.z, GetDebugName() ); - } - Assert( false ); - return; - } - - if (m_angRotation != angles) - { - InvalidatePhysicsRecursive( ANGLES_CHANGED ); - m_angRotation = angles; - SetSimulationTime( gpGlobals->curtime ); - } -} - -void CBaseEntity::SetLocalVelocity( const Vector &inVecVelocity ) -{ - Vector vecVelocity = inVecVelocity; - - // Safety check against receive a huge impulse, which can explode physics - switch ( CheckEntityVelocity( vecVelocity ) ) - { - case -1: - Warning( "Discarding SetLocalVelocity(%f,%f,%f) on %s\n", vecVelocity.x, vecVelocity.y, vecVelocity.z, GetDebugName() ); - Assert( false ); - return; - case 0: - if ( CheckEmitReasonablePhysicsSpew() ) - { - Warning( "Clamping SetLocalVelocity(%f,%f,%f) on %s\n", inVecVelocity.x, inVecVelocity.y, inVecVelocity.z, GetDebugName() ); - } - break; - } - - if (m_vecVelocity != vecVelocity) - { - InvalidatePhysicsRecursive( VELOCITY_CHANGED ); - m_vecVelocity = vecVelocity; - } -} - -void CBaseEntity::SetLocalAngularVelocity( const QAngle &vecAngVelocity ) -{ - // Safety check against NaN's or really huge numbers - if ( !IsEntityQAngleVelReasonable( vecAngVelocity ) ) - { - if ( CheckEmitReasonablePhysicsSpew() ) - { - Warning( "Bad SetLocalAngularVelocity(%f,%f,%f) on %s\n", vecAngVelocity.x, vecAngVelocity.y, vecAngVelocity.z, GetDebugName() ); - } - Assert( false ); - return; - } - - if (m_vecAngVelocity != vecAngVelocity) - { -// InvalidatePhysicsRecursive( EFL_DIRTY_ABSANGVELOCITY ); - m_vecAngVelocity = vecAngVelocity; - } -} - - -//----------------------------------------------------------------------------- -// Sets the local position from a transform -//----------------------------------------------------------------------------- -void CBaseEntity::SetLocalTransform( const matrix3x4_t &localTransform ) -{ - // FIXME: Should angles go away? Should we just use transforms? - Vector vecLocalOrigin; - QAngle vecLocalAngles; - MatrixGetColumn( localTransform, 3, vecLocalOrigin ); - MatrixAngles( localTransform, vecLocalAngles ); - SetLocalOrigin( vecLocalOrigin ); - SetLocalAngles( vecLocalAngles ); -} - - -//----------------------------------------------------------------------------- -// Is the entity floating? -//----------------------------------------------------------------------------- -bool CBaseEntity::IsFloating() -{ - if ( !IsEFlagSet(EFL_TOUCHING_FLUID) ) - return false; - - IPhysicsObject *pObject = VPhysicsGetObject(); - if ( !pObject ) - return false; - - int nMaterialIndex = pObject->GetMaterialIndex(); - - float flDensity; - float flThickness; - float flFriction; - float flElasticity; - physprops->GetPhysicsProperties( nMaterialIndex, &flDensity, - &flThickness, &flFriction, &flElasticity ); - - // FIXME: This really only works for water at the moment.. - // Owing the check for density == 1000 - return (flDensity < 1000.0f); -} - - -//----------------------------------------------------------------------------- -// Purpose: Created predictable and sets up Id. Note that persist is ignored on the server. -// Input : *classname - -// *module - -// line - -// persist - -// Output : CBaseEntity -//----------------------------------------------------------------------------- -CBaseEntity *CBaseEntity::CreatePredictedEntityByName( const char *classname, const char *module, int line, bool persist /* = false */ ) -{ -#if !defined( NO_ENTITY_PREDICTION ) - CBasePlayer *player = CBaseEntity::GetPredictionPlayer(); - Assert( player ); - - CBaseEntity *ent = NULL; - - int command_number = player->CurrentCommandNumber(); - int player_index = player->entindex() - 1; - - CPredictableId testId; - testId.Init( player_index, command_number, classname, module, line ); - - ent = CreateEntityByName( classname ); - // No factory??? - if ( !ent ) - return NULL; - - ent->SetPredictionEligible( true ); - - // Set up "shared" id number - ent->m_PredictableID.GetForModify().SetRaw( testId.GetRaw() ); - - return ent; -#else - return NULL; -#endif - -} - -void CBaseEntity::SetPredictionEligible( bool canpredict ) -{ -// Nothing in game code m_bPredictionEligible = canpredict; -} - -//----------------------------------------------------------------------------- -// These could be virtual, but only the player is overriding them -// NOTE: If you make any of these virtual, remove this implementation!!! -//----------------------------------------------------------------------------- -void CBaseEntity::AddPoints( int score, bool bAllowNegativeScore ) -{ - CBasePlayer *pPlayer = ToBasePlayer(this); - if ( pPlayer ) - { - pPlayer->CBasePlayer::AddPoints( score, bAllowNegativeScore ); - } -} - -void CBaseEntity::AddPointsToTeam( int score, bool bAllowNegativeScore ) -{ - CBasePlayer *pPlayer = ToBasePlayer(this); - if ( pPlayer ) - { - pPlayer->CBasePlayer::AddPointsToTeam( score, bAllowNegativeScore ); - } -} - -void CBaseEntity::ViewPunch( const QAngle &angleOffset ) -{ - CBasePlayer *pPlayer = ToBasePlayer(this); - if ( pPlayer ) - { - pPlayer->CBasePlayer::ViewPunch( angleOffset ); - } -} - -void CBaseEntity::VelocityPunch( const Vector &vecForce ) -{ - CBasePlayer *pPlayer = ToBasePlayer(this); - if ( pPlayer ) - { - pPlayer->CBasePlayer::VelocityPunch( vecForce ); - } -} -//----------------------------------------------------------------------------- - - -//----------------------------------------------------------------------------- -// Purpose: Tell clients to remove all decals from this entity -//----------------------------------------------------------------------------- -void CBaseEntity::RemoveAllDecals( void ) -{ - EntityMessageBegin( this ); - WRITE_BYTE( BASEENTITY_MSG_REMOVE_DECALS ); - MessageEnd(); -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : set - -//----------------------------------------------------------------------------- -void CBaseEntity::ModifyOrAppendCriteria( AI_CriteriaSet& set ) -{ - // TODO - // Append chapter/day? - - set.AppendCriteria( "randomnum", UTIL_VarArgs("%d", RandomInt(0,100)) ); - // Append map name - set.AppendCriteria( "map", gpGlobals->mapname.ToCStr() ); - // Append our classname and game name - set.AppendCriteria( "classname", GetClassname() ); - set.AppendCriteria( "name", GetEntityName().ToCStr() ); - - // Append our health - set.AppendCriteria( "health", UTIL_VarArgs( "%i", GetHealth() ) ); - - float healthfrac = 0.0f; - if ( GetMaxHealth() > 0 ) - { - healthfrac = (float)GetHealth() / (float)GetMaxHealth(); - } - - set.AppendCriteria( "healthfrac", UTIL_VarArgs( "%.3f", healthfrac ) ); - - // Go through all the global states and append them - - for ( int i = 0; i < GlobalEntity_GetNumGlobals(); i++ ) - { - const char *szGlobalName = GlobalEntity_GetName(i); - int iGlobalState = (int)GlobalEntity_GetStateByIndex(i); - set.AppendCriteria( szGlobalName, UTIL_VarArgs( "%i", iGlobalState ) ); - } - - // Append anything from I/O or keyvalues pairs - AppendContextToCriteria( set ); - - if( hl2_episodic.GetBool() ) - { - set.AppendCriteria( "episodic", "1" ); - } - - // Append anything from world I/O/keyvalues with "world" as prefix - CWorld *world = dynamic_cast< CWorld * >( CBaseEntity::Instance( engine->PEntityOfEntIndex( 0 ) ) ); - if ( world ) - { - world->AppendContextToCriteria( set, "world" ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : set - -// "" - -//----------------------------------------------------------------------------- -void CBaseEntity::AppendContextToCriteria( AI_CriteriaSet& set, const char *prefix /*= ""*/ ) -{ - RemoveExpiredConcepts(); - - int c = GetContextCount(); - int i; - - char sz[ 128 ]; - for ( i = 0; i < c; i++ ) - { - const char *name = GetContextName( i ); - const char *value = GetContextValue( i ); - - Q_snprintf( sz, sizeof( sz ), "%s%s", prefix, name ); - - set.AppendCriteria( sz, value ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: Removes expired concepts from list -// Output : -//----------------------------------------------------------------------------- -void CBaseEntity::RemoveExpiredConcepts( void ) -{ - int c = GetContextCount(); - int i; - - for ( i = 0; i < c; i++ ) - { - if ( ContextExpired( i ) ) - { - m_ResponseContexts.Remove( i ); - c--; - i--; - continue; - } - } -} - -//----------------------------------------------------------------------------- -// Purpose: Get current context count -// Output : int -//----------------------------------------------------------------------------- -int CBaseEntity::GetContextCount() const -{ - return m_ResponseContexts.Count(); -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : index - -// Output : const char -//----------------------------------------------------------------------------- -const char *CBaseEntity::GetContextName( int index ) const -{ - if ( index < 0 || index >= m_ResponseContexts.Count() ) - { - Assert( 0 ); - return ""; - } - - return m_ResponseContexts[ index ].m_iszName.ToCStr(); -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : index - -// Output : const char -//----------------------------------------------------------------------------- -const char *CBaseEntity::GetContextValue( int index ) const -{ - if ( index < 0 || index >= m_ResponseContexts.Count() ) - { - Assert( 0 ); - return ""; - } - - return m_ResponseContexts[ index ].m_iszValue.ToCStr(); -} - -//----------------------------------------------------------------------------- -// Purpose: Check if context has expired -// Input : index - -// Output : bool -//----------------------------------------------------------------------------- -bool CBaseEntity::ContextExpired( int index ) const -{ - if ( index < 0 || index >= m_ResponseContexts.Count() ) - { - Assert( 0 ); - return true; - } - - if ( !m_ResponseContexts[ index ].m_fExpirationTime ) - { - return false; - } - - return ( m_ResponseContexts[ index ].m_fExpirationTime <= gpGlobals->curtime ); -} - -//----------------------------------------------------------------------------- -// Purpose: Search for index of named context string -// Input : *name - -// Output : int -//----------------------------------------------------------------------------- -int CBaseEntity::FindContextByName( const char *name ) const -{ - int c = m_ResponseContexts.Count(); - for ( int i = 0; i < c; i++ ) - { - if ( FStrEq( name, GetContextName( i ) ) ) - return i; - } - - return -1; -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : inputdata - -//----------------------------------------------------------------------------- -void CBaseEntity::InputAddContext( inputdata_t& inputdata ) -{ - const char *contextName = inputdata.value.String(); - AddContext( contextName ); -} - - -//----------------------------------------------------------------------------- -// Purpose: User inputs. These fire the corresponding user outputs, and are -// a means of forwarding messages through !activator to a target known -// known by !activator but not by the targetting entity. -// -// For example, say you have three identical trains, following the same -// path. Each train has a sprite in hierarchy with it that needs to -// toggle on/off as it passes each path_track. You would hook each train's -// OnUser1 output to it's sprite's Toggle input, then connect each path_track's -// OnPass output to !activator's FireUser1 input. -//----------------------------------------------------------------------------- -void CBaseEntity::InputFireUser1( inputdata_t& inputdata ) -{ - m_OnUser1.FireOutput( inputdata.pActivator, this ); -} - - -void CBaseEntity::InputFireUser2( inputdata_t& inputdata ) -{ - m_OnUser2.FireOutput( inputdata.pActivator, this ); -} - - -void CBaseEntity::InputFireUser3( inputdata_t& inputdata ) -{ - m_OnUser3.FireOutput( inputdata.pActivator, this ); -} - - -void CBaseEntity::InputFireUser4( inputdata_t& inputdata ) -{ - m_OnUser4.FireOutput( inputdata.pActivator, this ); -} - - -//----------------------------------------------------------------------------- -// Purpose: -// Input : *contextName - -//----------------------------------------------------------------------------- -void CBaseEntity::AddContext( const char *contextName ) -{ - char key[ 128 ]; - char value[ 128 ]; - float duration; - - const char *p = contextName; - while ( p ) - { - duration = 0.0f; - p = SplitContext( p, key, sizeof( key ), value, sizeof( value ), &duration ); - if ( duration ) - { - duration += gpGlobals->curtime; - } - - int iIndex = FindContextByName( key ); - if ( iIndex != -1 ) - { - // Set the existing context to the new value - m_ResponseContexts[iIndex].m_iszValue = AllocPooledString( value ); - m_ResponseContexts[iIndex].m_fExpirationTime = duration; - continue; - } - - ResponseContext_t newContext; - newContext.m_iszName = AllocPooledString( key ); - newContext.m_iszValue = AllocPooledString( value ); - newContext.m_fExpirationTime = duration; - - m_ResponseContexts.AddToTail( newContext ); - } -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : inputdata - -//----------------------------------------------------------------------------- -void CBaseEntity::InputRemoveContext( inputdata_t& inputdata ) -{ - const char *contextName = inputdata.value.String(); - int idx = FindContextByName( contextName ); - if ( idx == -1 ) - return; - - m_ResponseContexts.Remove( idx ); -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : inputdata - -//----------------------------------------------------------------------------- -void CBaseEntity::InputClearContext( inputdata_t& inputdata ) -{ - m_ResponseContexts.RemoveAll(); -} - -//----------------------------------------------------------------------------- -// Purpose: -// Output : IResponseSystem -//----------------------------------------------------------------------------- -IResponseSystem *CBaseEntity::GetResponseSystem() -{ - return NULL; -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : inputdata - -//----------------------------------------------------------------------------- -void CBaseEntity::InputDispatchResponse( inputdata_t& inputdata ) -{ - DispatchResponse( inputdata.value.String() ); -} - -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -void CBaseEntity::InputDisableShadow( inputdata_t &inputdata ) -{ - AddEffects( EF_NOSHADOW ); -} - -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -void CBaseEntity::InputEnableShadow( inputdata_t &inputdata ) -{ - RemoveEffects( EF_NOSHADOW ); -} - -//----------------------------------------------------------------------------- -// Purpose: An input to add a new connection from this entity -// Input : &inputdata - -//----------------------------------------------------------------------------- -void CBaseEntity::InputAddOutput( inputdata_t &inputdata ) -{ - char sOutputName[MAX_PATH]; - Q_strncpy( sOutputName, inputdata.value.String(), sizeof(sOutputName) ); - char *sChar = strchr( sOutputName, ' ' ); - if ( sChar ) - { - *sChar = '\0'; - // Now replace all the :'s in the string with ,'s. - // Has to be done this way because Hammer doesn't allow ,'s inside parameters. - char *sColon = strchr( sChar+1, ':' ); - while ( sColon ) - { - *sColon = ','; - sColon = strchr( sChar+1, ':' ); - } - KeyValue( sOutputName, sChar+1 ); - } - else - { - Warning("AddOutput input fired with bad string. Format: ,,,,\n"); - } -} - -//----------------------------------------------------------------------------- -// Purpose: -// Input : *conceptName - -//----------------------------------------------------------------------------- -void CBaseEntity::DispatchResponse( const char *conceptName ) -{ - IResponseSystem *rs = GetResponseSystem(); - if ( !rs ) - return; - - AI_CriteriaSet set; - // Always include the concept name - set.AppendCriteria( "concept", conceptName, CONCEPT_WEIGHT ); - // Let NPC fill in most match criteria - ModifyOrAppendCriteria( set ); - - // Append local player criteria to set,too - CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); - if( pPlayer ) - pPlayer->ModifyOrAppendPlayerCriteria( set ); - - // Now that we have a criteria set, ask for a suitable response - AI_Response result; - bool found = rs->FindBestResponse( set, result ); - if ( !found ) - { - return; - } - - // Handle the response here... - char response[ 256 ]; - result.GetResponse( response, sizeof( response ) ); - switch ( result.GetType() ) - { - case RESPONSE_SPEAK: - { - EmitSound( response ); - } - break; - case RESPONSE_SENTENCE: - { - int sentenceIndex = SENTENCEG_Lookup( response ); - if( sentenceIndex == -1 ) - { - // sentence not found - break; - } - - // FIXME: Get pitch from npc? - CPASAttenuationFilter filter( this ); - CBaseEntity::EmitSentenceByIndex( filter, entindex(), CHAN_VOICE, sentenceIndex, 1, result.GetSoundLevel(), 0, PITCH_NORM ); - } - break; - case RESPONSE_SCENE: - { - // Try to fire scene w/o an actor - InstancedScriptedScene( NULL, response ); - } - break; - case RESPONSE_PRINT: - { - - } - break; - default: - // Don't know how to handle .vcds!!! - break; - } -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -void CBaseEntity::DumpResponseCriteria( void ) -{ - Msg("----------------------------------------------\n"); - Msg("RESPONSE CRITERIA FOR: %s (%s)\n", GetClassname(), GetDebugName() ); - - AI_CriteriaSet set; - // Let NPC fill in most match criteria - ModifyOrAppendCriteria( set ); - - // Append local player criteria to set,too - CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); - if ( pPlayer ) - { - pPlayer->ModifyOrAppendPlayerCriteria( set ); - } - - // Now dump it all to console - set.Describe(); -} - -//------------------------------------------------------------------------------ -void CC_Ent_Show_Response_Criteria( const CCommand& args ) -{ - CBaseEntity *pEntity = NULL; - while ( (pEntity = GetNextCommandEntity( UTIL_GetCommandClient(), args[1], pEntity )) != NULL ) - { - pEntity->DumpResponseCriteria(); - } -} -static ConCommand ent_show_response_criteria("ent_show_response_criteria", CC_Ent_Show_Response_Criteria, "Print, to the console, an entity's current criteria set used to select responses.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -// Purpose: Show an entity's autoaim radius -//------------------------------------------------------------------------------ -void CC_Ent_Autoaim( const CCommand& args ) -{ - SetDebugBits( UTIL_GetCommandClient(),args[1], OVERLAY_AUTOAIM_BIT ); -} -static ConCommand ent_autoaim("ent_autoaim", CC_Ent_Autoaim, "Displays the entity's autoaim radius.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at", FCVAR_CHEAT ); - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- -CAI_BaseNPC *CBaseEntity::MyNPCPointer( void ) -{ - if ( IsNPC() ) - return assert_cast(this); - - return NULL; -} - -ConVar step_spline( "step_spline", "0" ); - -//----------------------------------------------------------------------------- -// Purpose: Run one tick's worth of faked simulation -// Input : *step - -//----------------------------------------------------------------------------- -void CBaseEntity::ComputeStepSimulationNetwork( StepSimulationData *step ) -{ - if ( !step ) - { - Assert( !"ComputeStepSimulationNetworkOriginAndAngles with NULL step\n" ); - return; - } - - // Don't run again if we've already calculated this tick - if ( step->m_nLastProcessTickCount == gpGlobals->tickcount ) - { - return; - } - - step->m_nLastProcessTickCount = gpGlobals->tickcount; - - // Origin - // It's inactive - if ( step->m_bOriginActive ) - { - // First see if any external code moved the entity - if ( GetStepOrigin() != step->m_Next.vecOrigin ) - { - step->m_bOriginActive = false; - } - else - { - // Compute interpolated info based on tick interval - float frac = 1.0f; - int tickdelta = step->m_Next.nTickCount - step->m_Previous.nTickCount; - if ( tickdelta > 0 ) - { - frac = (float)( gpGlobals->tickcount - step->m_Previous.nTickCount ) / (float) tickdelta; - frac = clamp( frac, 0.0f, 1.0f ); - } - - if (step->m_Previous2.nTickCount == 0 || step->m_Previous2.nTickCount >= step->m_Previous.nTickCount) - { - Vector delta = step->m_Next.vecOrigin - step->m_Previous.vecOrigin; - VectorMA( step->m_Previous.vecOrigin, frac, delta, step->m_vecNetworkOrigin ); - } - else if (!step_spline.GetBool()) - { - StepSimulationStep *pOlder = &step->m_Previous; - StepSimulationStep *pNewer = &step->m_Next; - - if (step->m_Discontinuity.nTickCount > step->m_Previous.nTickCount) - { - if (gpGlobals->tickcount > step->m_Discontinuity.nTickCount) - { - pOlder = &step->m_Discontinuity; - } - else - { - pNewer = &step->m_Discontinuity; - } - - tickdelta = pNewer->nTickCount - pOlder->nTickCount; - if ( tickdelta > 0 ) - { - frac = (float)( gpGlobals->tickcount - pOlder->nTickCount ) / (float) tickdelta; - frac = clamp( frac, 0.0f, 1.0f ); - } - } - - Vector delta = pNewer->vecOrigin - pOlder->vecOrigin; - VectorMA( pOlder->vecOrigin, frac, delta, step->m_vecNetworkOrigin ); - } - else - { - Hermite_Spline( step->m_Previous2.vecOrigin, step->m_Previous.vecOrigin, step->m_Next.vecOrigin, frac, step->m_vecNetworkOrigin ); - } - } - } - - // Angles - if ( step->m_bAnglesActive ) - { - // See if external code changed the orientation of the entity - if ( GetStepAngles() != step->m_angNextRotation ) - { - step->m_bAnglesActive = false; - } - else - { - // Compute interpolated info based on tick interval - float frac = 1.0f; - int tickdelta = step->m_Next.nTickCount - step->m_Previous.nTickCount; - if ( tickdelta > 0 ) - { - frac = (float)( gpGlobals->tickcount - step->m_Previous.nTickCount ) / (float) tickdelta; - frac = clamp( frac, 0.0f, 1.0f ); - } - - if (step->m_Previous2.nTickCount == 0 || step->m_Previous2.nTickCount >= step->m_Previous.nTickCount) - { - // Pure blend between start/end orientations - Quaternion outangles; - QuaternionBlend( step->m_Previous.qRotation, step->m_Next.qRotation, frac, outangles ); - QuaternionAngles( outangles, step->m_angNetworkAngles ); - } - else if (!step_spline.GetBool()) - { - StepSimulationStep *pOlder = &step->m_Previous; - StepSimulationStep *pNewer = &step->m_Next; - - if (step->m_Discontinuity.nTickCount > step->m_Previous.nTickCount) - { - if (gpGlobals->tickcount > step->m_Discontinuity.nTickCount) - { - pOlder = &step->m_Discontinuity; - } - else - { - pNewer = &step->m_Discontinuity; - } - - tickdelta = pNewer->nTickCount - pOlder->nTickCount; - if ( tickdelta > 0 ) - { - frac = (float)( gpGlobals->tickcount - pOlder->nTickCount ) / (float) tickdelta; - frac = clamp( frac, 0.0f, 1.0f ); - } - } - - // Pure blend between start/end orientations - Quaternion outangles; - QuaternionBlend( pOlder->qRotation, pNewer->qRotation, frac, outangles ); - QuaternionAngles( outangles, step->m_angNetworkAngles ); - } - else - { - // FIXME: enable spline interpolation when turning is debounced. - Quaternion outangles; - Hermite_Spline( step->m_Previous2.qRotation, step->m_Previous.qRotation, step->m_Next.qRotation, frac, outangles ); - QuaternionAngles( outangles, step->m_angNetworkAngles ); - } - } - } - -} - - -//----------------------------------------------------------------------------- -bool CBaseEntity::UseStepSimulationNetworkOrigin( const Vector **out_v ) -{ - Assert( out_v ); - - - if ( g_bTestMoveTypeStepSimulation && - GetMoveType() == MOVETYPE_STEP && - HasDataObjectType( STEPSIMULATION ) ) - { - StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); - ComputeStepSimulationNetwork( step ); - *out_v = &step->m_vecNetworkOrigin; - - return step->m_bOriginActive; - } - - return false; -} - -//----------------------------------------------------------------------------- -bool CBaseEntity::UseStepSimulationNetworkAngles( const QAngle **out_a ) -{ - Assert( out_a ); - - if ( g_bTestMoveTypeStepSimulation && - GetMoveType() == MOVETYPE_STEP && - HasDataObjectType( STEPSIMULATION ) ) - { - StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); - ComputeStepSimulationNetwork( step ); - *out_a = &step->m_angNetworkAngles; - return step->m_bAnglesActive; - } - return false; -} - -//----------------------------------------------------------------------------- -// Purpose: -//----------------------------------------------------------------------------- - -bool CBaseEntity::AddStepDiscontinuity( float flTime, const Vector &vecOrigin, const QAngle &vecAngles ) -{ - if ((GetMoveType() != MOVETYPE_STEP ) || !HasDataObjectType( STEPSIMULATION ) ) - { - return false; - } - - StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); - - if (!step) - { - Assert( 0 ); - return false; - } - - step->m_Discontinuity.nTickCount = TIME_TO_TICKS( flTime ); - step->m_Discontinuity.vecOrigin = vecOrigin; - AngleQuaternion( vecAngles, step->m_Discontinuity.qRotation ); - - return true; -} - - -Vector CBaseEntity::GetStepOrigin( void ) const -{ - return GetLocalOrigin(); -} - -QAngle CBaseEntity::GetStepAngles( void ) const -{ - return GetLocalAngles(); -} - -//----------------------------------------------------------------------------- -// Purpose: For each client who appears to be a valid recipient, checks the client has disabled CC and if so, removes them from -// the recipient list. -// Input : filter - -//----------------------------------------------------------------------------- -void CBaseEntity::RemoveRecipientsIfNotCloseCaptioning( CRecipientFilter& filter ) -{ - int c = filter.GetRecipientCount(); - for ( int i = c - 1; i >= 0; --i ) - { - int playerIndex = filter.GetRecipientIndex( i ); - - CBasePlayer *player = static_cast< CBasePlayer * >( CBaseEntity::Instance( playerIndex ) ); - if ( !player ) - continue; -#if !defined( _XBOX ) - const char *cvarvalue = engine->GetClientConVarValue( playerIndex, "closecaption" ); - Assert( cvarvalue ); - if ( !cvarvalue[ 0 ] ) - continue; - - int value = atoi( cvarvalue ); -#else - static ConVar *s_pCloseCaption = NULL; - if ( !s_pCloseCaption ) - { - s_pCloseCaption = cvar->FindVar( "closecaption" ); - if ( !s_pCloseCaption ) - { - Error( "XBOX couldn't find closecaption convar!!!" ); - } - } - - int value = s_pCloseCaption->GetInt(); -#endif - // No close captions? - if ( value == 0 ) - { - filter.RemoveRecipient( player ); - } - } -} - -//----------------------------------------------------------------------------- -// Purpose: Wrapper to emit a sentence and also a close caption token for the sentence as appropriate. -// Input : filter - -// iEntIndex - -// iChannel - -// iSentenceIndex - -// flVolume - -// iSoundlevel - -// iFlags - -// iPitch - -// bUpdatePositions - -// soundtime - -//----------------------------------------------------------------------------- -void CBaseEntity::EmitSentenceByIndex( IRecipientFilter& filter, int iEntIndex, int iChannel, int iSentenceIndex, - float flVolume, soundlevel_t iSoundlevel, int iFlags /*= 0*/, int iPitch /*=PITCH_NORM*/, - const Vector *pOrigin /*=NULL*/, const Vector *pDirection /*=NULL*/, - bool bUpdatePositions /*=true*/, float soundtime /*=0.0f*/ ) -{ - CUtlVector< Vector > dummy; - enginesound->EmitSentenceByIndex( filter, iEntIndex, iChannel, iSentenceIndex, - flVolume, iSoundlevel, iFlags, iPitch, 0, pOrigin, pDirection, &dummy, bUpdatePositions, soundtime ); -} - - -void CBaseEntity::SetRefEHandle( const CBaseHandle &handle ) -{ - m_RefEHandle = handle; - if ( edict() ) - { - COMPILE_TIME_ASSERT( NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS <= 8*sizeof( edict()->m_NetworkSerialNumber ) ); - edict()->m_NetworkSerialNumber = (m_RefEHandle.GetSerialNumber() & (1 << NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS) - 1); - } -} - - -bool CPointEntity::KeyValue( const char *szKeyName, const char *szValue ) -{ - if ( FStrEq( szKeyName, "mins" ) || FStrEq( szKeyName, "maxs" ) ) - { - Warning("Warning! Can't specify mins/maxs for point entities! (%s)\n", GetClassname() ); - return true; - } - - return BaseClass::KeyValue( szKeyName, szValue ); -} - -bool CServerOnlyPointEntity::KeyValue( const char *szKeyName, const char *szValue ) -{ - if ( FStrEq( szKeyName, "mins" ) || FStrEq( szKeyName, "maxs" ) ) - { - Warning("Warning! Can't specify mins/maxs for point entities! (%s)\n", GetClassname() ); - return true; - } - - return BaseClass::KeyValue( szKeyName, szValue ); -} - -bool CLogicalEntity::KeyValue( const char *szKeyName, const char *szValue ) -{ - if ( FStrEq( szKeyName, "mins" ) || FStrEq( szKeyName, "maxs" ) ) - { - Warning("Warning! Can't specify mins/maxs for point entities! (%s)\n", GetClassname() ); - return true; - } - - return BaseClass::KeyValue( szKeyName, szValue ); -} - - -//----------------------------------------------------------------------------- -// Purpose: Sets the entity invisible, and makes it remove itself on the next frame -//----------------------------------------------------------------------------- -void CBaseEntity::RemoveDeferred( void ) -{ - // Set our next think to remove us - SetThink( &CBaseEntity::SUB_Remove ); - SetNextThink( gpGlobals->curtime + 0.1f ); - - // Hide us completely - AddEffects( EF_NODRAW ); - AddSolidFlags( FSOLID_NOT_SOLID ); - SetMoveType( MOVETYPE_NONE ); -} - -#define MIN_CORPSE_FADE_TIME 10.0 -#define MIN_CORPSE_FADE_DIST 256.0 -#define MAX_CORPSE_FADE_DIST 1500.0 - -// -// fade out - slowly fades a entity out, then removes it. -// -// DON'T USE ME FOR GIBS AND STUFF IN MULTIPLAYER! -// SET A FUTURE THINK AND A RENDERMODE!! -void CBaseEntity::SUB_StartFadeOut( float delay, bool notSolid ) -{ - SetThink( &CBaseEntity::SUB_FadeOut ); - SetNextThink( gpGlobals->curtime + delay ); - SetRenderColorA( 255 ); - m_nRenderMode = kRenderNormal; - - if ( notSolid ) - { - AddSolidFlags( FSOLID_NOT_SOLID ); - SetLocalAngularVelocity( vec3_angle ); - } -} - -void CBaseEntity::SUB_StartFadeOutInstant() -{ - SUB_StartFadeOut( 0, true ); -} - -//----------------------------------------------------------------------------- -// Purpose: Vanish when players aren't looking -//----------------------------------------------------------------------------- -void CBaseEntity::SUB_Vanish( void ) -{ - //Always think again next frame - SetNextThink( gpGlobals->curtime + 0.1f ); - - CBasePlayer *pPlayer; - - //Get all players - for ( int i = 1; i <= gpGlobals->maxClients; i++ ) - { - //Get the next client - if ( ( pPlayer = UTIL_PlayerByIndex( i ) ) != NULL ) - { - Vector corpseDir = (GetAbsOrigin() - pPlayer->WorldSpaceCenter() ); - - float flDistSqr = corpseDir.LengthSqr(); - //If the player is close enough, don't fade out - if ( flDistSqr < (MIN_CORPSE_FADE_DIST*MIN_CORPSE_FADE_DIST) ) - return; - - // If the player's far enough away, we don't care about looking at it - if ( flDistSqr < (MAX_CORPSE_FADE_DIST*MAX_CORPSE_FADE_DIST) ) - { - VectorNormalize( corpseDir ); - - Vector plForward; - pPlayer->EyeVectors( &plForward ); - - float dot = plForward.Dot( corpseDir ); - - if ( dot > 0.0f ) - return; - } - } - } - - //If we're here, then we can vanish safely - m_iHealth = 0; - SetThink( &CBaseEntity::SUB_Remove ); -} - -void CBaseEntity::SUB_PerformFadeOut( void ) -{ - float dt = gpGlobals->frametime; - if ( dt > 0.1f ) - { - dt = 0.1f; - } - m_nRenderMode = kRenderTransTexture; - int speed = MAX(1,256*dt); // fade out over 1 second - SetRenderColorA( UTIL_Approach( 0, m_clrRender->a, speed ) ); -} - -bool CBaseEntity::SUB_AllowedToFade( void ) -{ - if( VPhysicsGetObject() ) - { - if( VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD || GetEFlags() & EFL_IS_BEING_LIFTED_BY_BARNACLE ) - return false; - } - - // on Xbox, allow these to fade out -#ifndef _XBOX - CBasePlayer *pPlayer = ( AI_IsSinglePlayer() ) ? UTIL_GetLocalPlayer() : NULL; - - if ( pPlayer && pPlayer->FInViewCone( this ) ) - return false; -#endif - - return true; -} - -//----------------------------------------------------------------------------- -// Purpose: Fade out slowly -//----------------------------------------------------------------------------- -void CBaseEntity::SUB_FadeOut( void ) -{ - if ( SUB_AllowedToFade() == false ) - { - SetNextThink( gpGlobals->curtime + 1 ); - SetRenderColorA( 255 ); - return; - } - - SUB_PerformFadeOut(); - - if ( m_clrRender->a == 0 ) - { - UTIL_Remove(this); - } - else - { - SetNextThink( gpGlobals->curtime ); - } -} - - -inline bool AnyPlayersInHierarchy_R( CBaseEntity *pEnt ) -{ - if ( pEnt->IsPlayer() ) - return true; - - for ( CBaseEntity *pCur = pEnt->FirstMoveChild(); pCur; pCur=pCur->NextMovePeer() ) - { - if ( AnyPlayersInHierarchy_R( pCur ) ) - return true; - } - - return false; -} - - -void CBaseEntity::RecalcHasPlayerChildBit() -{ - if ( AnyPlayersInHierarchy_R( this ) ) - AddEFlags( EFL_HAS_PLAYER_CHILD ); - else - RemoveEFlags( EFL_HAS_PLAYER_CHILD ); -} - - -bool CBaseEntity::DoesHavePlayerChild() -{ - return IsEFlagSet( EFL_HAS_PLAYER_CHILD ); -} - - -//------------------------------------------------------------------------------ -void CBaseEntity::IncrementInterpolationFrame() -{ - m_ubInterpolationFrame = (m_ubInterpolationFrame + 1) % NOINTERP_PARITY_MAX; -} - -//------------------------------------------------------------------------------ - -void CBaseEntity::OnModelLoadComplete( const model_t* model ) -{ - Assert( m_bDynamicModelPending && IsDynamicModelIndex( m_nModelIndex ) ); - Assert( model == modelinfo->GetModel( m_nModelIndex ) ); - - m_bDynamicModelPending = false; - - if ( m_bDynamicModelSetBounds ) - { - m_bDynamicModelSetBounds = false; - SetCollisionBoundsFromModel(); - } - - OnNewModel(); -} - -//------------------------------------------------------------------------------ - -void CBaseEntity::SetCollisionBoundsFromModel() -{ - if ( IsDynamicModelLoading() ) - { - m_bDynamicModelSetBounds = true; - return; - } - - if ( const model_t *pModel = GetModel() ) - { - Vector mns, mxs; - modelinfo->GetModelBounds( pModel, mns, mxs ); - UTIL_SetSize( this, mns, mxs ); - } -} - - -//------------------------------------------------------------------------------ -// Purpose: Create an NPC of the given type -//------------------------------------------------------------------------------ -void CC_Ent_Create( const CCommand& args ) -{ - MDLCACHE_CRITICAL_SECTION(); - - CBasePlayer *pPlayer = UTIL_GetCommandClient(); - if (!pPlayer) - { - return; - } - - // Don't allow regular users to create point_servercommand entities for the same reason as blocking ent_fire - if ( !Q_stricmp( args[1], "point_servercommand" ) ) - { - if ( engine->IsDedicatedServer() ) - { - // We allow people with disabled autokick to do it, because they already have rcon. - if ( pPlayer->IsAutoKickDisabled() == false ) - return; - } - else if ( gpGlobals->maxClients > 1 ) - { - // On listen servers with more than 1 player, only allow the host to create point_servercommand. - CBasePlayer *pHostPlayer = UTIL_GetListenServerHost(); - if ( pPlayer != pHostPlayer ) - return; - } - } - - bool allowPrecache = CBaseEntity::IsPrecacheAllowed(); - CBaseEntity::SetAllowPrecache( true ); - - // Try to create entity - CBaseEntity *entity = dynamic_cast< CBaseEntity * >( CreateEntityByName(args[1]) ); - if (entity) - { - entity->Precache(); - - // Pass in any additional parameters. - for ( int i = 2; i + 1 < args.ArgC(); i += 2 ) - { - const char *pKeyName = args[i]; - const char *pValue = args[i+1]; - entity->KeyValue( pKeyName, pValue ); - } - - DispatchSpawn(entity); - - // Now attempt to drop into the world - trace_t tr; - Vector forward; - pPlayer->EyeVectors( &forward ); - UTIL_TraceLine(pPlayer->EyePosition(), - pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_SOLID, - pPlayer, COLLISION_GROUP_NONE, &tr ); - if ( tr.fraction != 1.0 ) - { - // Raise the end position a little up off the floor, place the npc and drop him down - tr.endpos.z += 12; - entity->Teleport( &tr.endpos, NULL, NULL ); - UTIL_DropToFloor( entity, MASK_SOLID ); - } - - entity->Activate(); - } - CBaseEntity::SetAllowPrecache( allowPrecache ); -} -static ConCommand ent_create("ent_create", CC_Ent_Create, "Creates an entity of the given type where the player is looking. Additional parameters can be passed in in the form: ent_create ... ", FCVAR_GAMEDLL | FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -// Purpose: Teleport a specified entity to where the player is looking -//------------------------------------------------------------------------------ -bool CC_GetCommandEnt( const CCommand& args, CBaseEntity **ent, Vector *vecTargetPoint, QAngle *vecPlayerAngle ) -{ - // Find the entity - *ent = NULL; - // First try using it as an entindex - int iEntIndex = atoi( args[1] ); - if ( iEntIndex ) - { - *ent = CBaseEntity::Instance( iEntIndex ); - } - else - { - // Try finding it by name - *ent = gEntList.FindEntityByName( NULL, args[1] ); - - if ( !*ent ) - { - // Finally, try finding it by classname - *ent = gEntList.FindEntityByClassname( NULL, args[1] ); - } - } - - if ( !*ent ) - { - Msg( "Couldn't find any entity named '%s'\n", args[1] ); - return false; - } - - CBasePlayer *pPlayer = UTIL_GetCommandClient(); - if ( vecTargetPoint ) - { - trace_t tr; - Vector forward; - pPlayer->EyeVectors( &forward ); - UTIL_TraceLine(pPlayer->EyePosition(), - pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_NPCSOLID, - pPlayer, COLLISION_GROUP_NONE, &tr ); - - if ( tr.fraction != 1.0 ) - { - *vecTargetPoint = tr.endpos; - } - } - - if ( vecPlayerAngle ) - { - *vecPlayerAngle = pPlayer->EyeAngles(); - } - - return true; -} - -//------------------------------------------------------------------------------ -// Purpose: Teleport a specified entity to where the player is looking -//------------------------------------------------------------------------------ -void CC_Ent_Teleport( const CCommand& args ) -{ - if ( args.ArgC() < 2 ) - { - Msg( "Format: ent_teleport \n" ); - return; - } - - CBaseEntity *pEnt; - Vector vecTargetPoint; - if ( CC_GetCommandEnt( args, &pEnt, &vecTargetPoint, NULL ) ) - { - pEnt->Teleport( &vecTargetPoint, NULL, NULL ); - } -} - -static ConCommand ent_teleport("ent_teleport", CC_Ent_Teleport, "Teleport the specified entity to where the player is looking.\n\tFormat: ent_teleport ", FCVAR_CHEAT); - -//------------------------------------------------------------------------------ -// Purpose: Orient a specified entity to match the player's angles -//------------------------------------------------------------------------------ -void CC_Ent_Orient( const CCommand& args ) -{ - if ( args.ArgC() < 2 ) - { - Msg( "Format: ent_orient \n" ); - return; - } - - CBaseEntity *pEnt; - QAngle vecPlayerAngles; - if ( CC_GetCommandEnt( args, &pEnt, NULL, &vecPlayerAngles ) ) - { - QAngle vecEntAngles = pEnt->GetAbsAngles(); - if ( args.ArgC() == 3 && !Q_strncmp( args[2], "allangles", 9 ) ) - { - vecEntAngles = vecPlayerAngles; - } - else - { - vecEntAngles[YAW] = vecPlayerAngles[YAW]; - } - - pEnt->SetAbsAngles( vecEntAngles ); - } -} - -static ConCommand ent_orient("ent_orient", CC_Ent_Orient, "Orient the specified entity to match the player's angles. By default, only orients target entity's YAW. Use the 'allangles' option to orient on all axis.\n\tFormat: ent_orient ", FCVAR_CHEAT); +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: The base class from which all game entities are derived. +// +//===========================================================================// + +#include "cbase.h" +#include "globalstate.h" +#include "isaverestore.h" +#include "client.h" +#include "decals.h" +#include "gamerules.h" +#include "entityapi.h" +#include "entitylist.h" +#include "eventqueue.h" +#include "hierarchy.h" +#include "basecombatweapon.h" +#include "const.h" +#include "player.h" // For debug draw sending +#include "ndebugoverlay.h" +#include "physics.h" +#include "model_types.h" +#include "team.h" +#include "sendproxy.h" +#include "IEffects.h" +#include "vstdlib/random.h" +#include "baseentity.h" +#include "collisionutils.h" +#include "coordsize.h" +#include "animation.h" +#include "tier1/strtools.h" +#include "engine/IEngineSound.h" +#include "physics_saverestore.h" +#include "saverestore_utlvector.h" +#include "bone_setup.h" +#include "vcollide_parse.h" +#include "filters.h" +#include "te_effect_dispatch.h" +#include "AI_Criteria.h" +#include "AI_ResponseSystem.h" +#include "world.h" +#include "globals.h" +#include "saverestoretypes.h" +#include "SkyCamera.h" +#include "sceneentity.h" +#include "game.h" +#include "tier0/vprof.h" +#include "ai_basenpc.h" +#include "iservervehicle.h" +#include "eventlist.h" +#include "scriptevent.h" +#include "SoundEmitterSystem/isoundemittersystembase.h" +#include "UtlCachedFileData.h" +#include "utlbuffer.h" +#include "positionwatcher.h" +#include "movetype_push.h" +#include "tier0/icommandline.h" +#include "vphysics/friction.h" +#include +#include "datacache/imdlcache.h" +#include "ModelSoundsCache.h" +#include "env_debughistory.h" +#include "tier1/utlstring.h" +#include "utlhashtable.h" + +#if defined( TF_DLL ) +#include "tf_gamerules.h" +#endif + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +extern bool g_bTestMoveTypeStepSimulation; +extern ConVar sv_vehicle_autoaim_scale; + +// Init static class variables +bool CBaseEntity::m_bInDebugSelect = false; // Used for selection in debug overlays +int CBaseEntity::m_nDebugPlayer = -1; // Player doing the selection + +// This can be set before creating an entity to force it to use a particular edict. +edict_t *g_pForceAttachEdict = NULL; + +bool CBaseEntity::m_bDebugPause = false; // Whether entity i/o is paused. +int CBaseEntity::m_nDebugSteps = 1; // Number of entity outputs to fire before pausing again. +bool CBaseEntity::sm_bDisableTouchFuncs = false; // Disables PhysicsTouch and PhysicsStartTouch function calls +bool CBaseEntity::sm_bAccurateTriggerBboxChecks = true; // set to false for legacy behavior in ep1 + +int CBaseEntity::m_nPredictionRandomSeed = -1; +CBasePlayer *CBaseEntity::m_pPredictionPlayer = NULL; + +// Used to make sure nobody calls UpdateTransmitState directly. +int g_nInsideDispatchUpdateTransmitState = 0; + +// When this is false, throw an assert in debug when GetAbsAnything is called. Used when hierachy is incomplete/invalid. +bool CBaseEntity::s_bAbsQueriesValid = true; + + +ConVar sv_netvisdist( "sv_netvisdist", "10000", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Test networking visibility distance" ); + +// This table encodes edict data. +void SendProxy_AnimTime( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID ) +{ + CBaseEntity *pEntity = (CBaseEntity *)pStruct; + +#if defined( _DEBUG ) + CBaseAnimating *pAnimating = pEntity->GetBaseAnimating(); + Assert( pAnimating ); + + if ( pAnimating ) + { + Assert( !pAnimating->IsUsingClientSideAnimation() ); + } +#endif + + int ticknumber = TIME_TO_TICKS( pEntity->m_flAnimTime ); + // Tickbase is current tick rounded down to closes 100 ticks + int tickbase = gpGlobals->GetNetworkBase( gpGlobals->tickcount, pEntity->entindex() ); + int addt = 0; + // If it's within the last tick interval through the current one, then we can encode it + if ( ticknumber >= ( tickbase - 100 ) ) + { + addt = ( ticknumber - tickbase ) & 0xFF; + } + + pOut->m_Int = addt; +} + +// This table encodes edict data. +void SendProxy_SimulationTime( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID ) +{ + CBaseEntity *pEntity = (CBaseEntity *)pStruct; + + int ticknumber = TIME_TO_TICKS( pEntity->m_flSimulationTime ); + // tickbase is current tick rounded down to closest 100 ticks + int tickbase = gpGlobals->GetNetworkBase( gpGlobals->tickcount, pEntity->entindex() ); + int addt = 0; + if ( ticknumber >= tickbase ) + { + addt = ( ticknumber - tickbase ) & 0xff; + } + + pOut->m_Int = addt; +} + +void* SendProxy_ClientSideAnimation( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ) +{ + CBaseEntity *pEntity = (CBaseEntity *)pStruct; + CBaseAnimating *pAnimating = pEntity->GetBaseAnimating(); + + if ( pAnimating && !pAnimating->IsUsingClientSideAnimation() ) + return (void*)pVarData; + else + return NULL; // Don't send animtime unless the client needs it. +} +REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_ClientSideAnimation ); + + +BEGIN_SEND_TABLE_NOBASE( CBaseEntity, DT_AnimTimeMustBeFirst ) + // NOTE: Animtime must be sent before origin and angles ( from pev ) because it has a + // proxy on the client that stores off the old values before writing in the new values and + // if it is sent after the new values, then it will only have the new origin and studio model, etc. + // interpolation will be busted + SendPropInt (SENDINFO(m_flAnimTime), 8, SPROP_UNSIGNED|SPROP_CHANGES_OFTEN|SPROP_ENCODED_AGAINST_TICKCOUNT, SendProxy_AnimTime), +END_SEND_TABLE() + +#if !defined( NO_ENTITY_PREDICTION ) +BEGIN_SEND_TABLE_NOBASE( CBaseEntity, DT_PredictableId ) + SendPropPredictableId( SENDINFO( m_PredictableID ) ), + SendPropInt( SENDINFO( m_bIsPlayerSimulated ), 1, SPROP_UNSIGNED ), +END_SEND_TABLE() + + +static void* SendProxy_SendPredictableId( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ) +{ + CBaseEntity *pEntity = (CBaseEntity *)pStruct; + if ( !pEntity || !pEntity->m_PredictableID->IsActive() ) + return NULL; + + int id_player_index = pEntity->m_PredictableID->GetPlayer(); + pRecipients->SetOnly( id_player_index ); + + return ( void * )pVarData; +} +REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendPredictableId ); +#endif + +void SendProxy_Origin( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) +{ + CBaseEntity *entity = (CBaseEntity*)pStruct; + Assert( entity ); + + const Vector *v; + + if ( !entity->UseStepSimulationNetworkOrigin( &v ) ) + { + v = &entity->GetLocalOrigin(); + } + + pOut->m_Vector[ 0 ] = v->x; + pOut->m_Vector[ 1 ] = v->y; + pOut->m_Vector[ 2 ] = v->z; +} + +//-------------------------------------------------------------------------------------------------------- +// Used when breaking up origin, note we still have to deal with StepSimulation +//-------------------------------------------------------------------------------------------------------- +void SendProxy_OriginXY( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) +{ + CBaseEntity *entity = (CBaseEntity*)pStruct; + Assert( entity ); + + const Vector *v; + + if ( !entity->UseStepSimulationNetworkOrigin( &v ) ) + { + v = &entity->GetLocalOrigin(); + } + + pOut->m_Vector[ 0 ] = v->x; + pOut->m_Vector[ 1 ] = v->y; +} + +//-------------------------------------------------------------------------------------------------------- +// Used when breaking up origin, note we still have to deal with StepSimulation +//-------------------------------------------------------------------------------------------------------- +void SendProxy_OriginZ( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) +{ + CBaseEntity *entity = (CBaseEntity*)pStruct; + Assert( entity ); + + const Vector *v; + + if ( !entity->UseStepSimulationNetworkOrigin( &v ) ) + { + v = &entity->GetLocalOrigin(); + } + + pOut->m_Float = v->z; +} + + +void SendProxy_Angles( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID ) +{ + CBaseEntity *entity = (CBaseEntity*)pStruct; + Assert( entity ); + + const QAngle *a; + + if ( !entity->UseStepSimulationNetworkAngles( &a ) ) + { + a = &entity->GetLocalAngles(); + } + + pOut->m_Vector[ 0 ] = anglemod( a->x ); + pOut->m_Vector[ 1 ] = anglemod( a->y ); + pOut->m_Vector[ 2 ] = anglemod( a->z ); +} + +// This table encodes the CBaseEntity data. +IMPLEMENT_SERVERCLASS_ST_NOBASE( CBaseEntity, DT_BaseEntity ) + SendPropDataTable( "AnimTimeMustBeFirst", 0, &REFERENCE_SEND_TABLE(DT_AnimTimeMustBeFirst), SendProxy_ClientSideAnimation ), + SendPropInt (SENDINFO(m_flSimulationTime), SIMULATION_TIME_WINDOW_BITS, SPROP_UNSIGNED|SPROP_CHANGES_OFTEN|SPROP_ENCODED_AGAINST_TICKCOUNT, SendProxy_SimulationTime), + +#if PREDICTION_ERROR_CHECK_LEVEL > 1 + SendPropVector (SENDINFO(m_vecOrigin), -1, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ), +#else + SendPropVector (SENDINFO(m_vecOrigin), -1, SPROP_COORD|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ), +#endif + + SendPropInt (SENDINFO( m_ubInterpolationFrame ), NOINTERP_PARITY_MAX_BITS, SPROP_UNSIGNED ), + SendPropModelIndex(SENDINFO(m_nModelIndex)), + SendPropDataTable( SENDINFO_DT( m_Collision ), &REFERENCE_SEND_TABLE(DT_CollisionProperty) ), + SendPropInt (SENDINFO(m_nRenderFX), 8, SPROP_UNSIGNED ), + SendPropInt (SENDINFO(m_nRenderMode), 8, SPROP_UNSIGNED ), + SendPropInt (SENDINFO(m_fEffects), EF_MAX_BITS, SPROP_UNSIGNED), + SendPropInt (SENDINFO(m_clrRender), 32, SPROP_UNSIGNED), + SendPropInt (SENDINFO(m_iTeamNum), TEAMNUM_NUM_BITS, 0), + SendPropInt (SENDINFO(m_CollisionGroup), 5, SPROP_UNSIGNED), + SendPropFloat (SENDINFO(m_flElasticity), 0, SPROP_COORD), + SendPropFloat (SENDINFO(m_flShadowCastDistance), 12, SPROP_UNSIGNED ), + SendPropEHandle (SENDINFO(m_hOwnerEntity)), + SendPropEHandle (SENDINFO(m_hEffectEntity)), + SendPropEHandle (SENDINFO_NAME(m_hMoveParent, moveparent)), + SendPropInt (SENDINFO(m_iParentAttachment), NUM_PARENTATTACHMENT_BITS, SPROP_UNSIGNED), + + SendPropInt (SENDINFO_NAME( m_MoveType, movetype ), MOVETYPE_MAX_BITS, SPROP_UNSIGNED ), + SendPropInt (SENDINFO_NAME( m_MoveCollide, movecollide ), MOVECOLLIDE_MAX_BITS, SPROP_UNSIGNED ), +#if PREDICTION_ERROR_CHECK_LEVEL > 1 + SendPropVector (SENDINFO(m_angRotation), -1, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0, HIGH_DEFAULT, SendProxy_Angles ), +#else + SendPropQAngles (SENDINFO(m_angRotation), 13, SPROP_CHANGES_OFTEN, SendProxy_Angles ), +#endif + + SendPropInt ( SENDINFO( m_iTextureFrameIndex ), 8, SPROP_UNSIGNED ), + +#if !defined( NO_ENTITY_PREDICTION ) + SendPropDataTable( "predictable_id", 0, &REFERENCE_SEND_TABLE( DT_PredictableId ), SendProxy_SendPredictableId ), +#endif + + // FIXME: Collapse into another flag field? + SendPropInt (SENDINFO(m_bSimulatedEveryTick), 1, SPROP_UNSIGNED ), + SendPropInt (SENDINFO(m_bAnimatedEveryTick), 1, SPROP_UNSIGNED ), + SendPropBool( SENDINFO( m_bAlternateSorting )), + +#ifdef TF_DLL + SendPropArray3( SENDINFO_ARRAY3(m_nModelIndexOverrides), SendPropInt( SENDINFO_ARRAY(m_nModelIndexOverrides), SP_MODEL_INDEX_BITS, SPROP_UNSIGNED ) ), +#endif + +END_SEND_TABLE() + + +// dynamic models +class CBaseEntityModelLoadProxy +{ +protected: + class Handler : public IModelLoadCallback + { + public: + explicit Handler( CBaseEntity *pEntity ) : m_pEntity(pEntity) { } + virtual void OnModelLoadComplete( const model_t *pModel ); + CBaseEntity* m_pEntity; + }; + Handler* m_pHandler; + +public: + explicit CBaseEntityModelLoadProxy( CBaseEntity *pEntity ) : m_pHandler( new Handler( pEntity ) ) { } + ~CBaseEntityModelLoadProxy() { delete m_pHandler; } + void Register( int nModelIndex ) const { modelinfo->RegisterModelLoadCallback( nModelIndex, m_pHandler ); } + operator CBaseEntity * () const { return m_pHandler->m_pEntity; } + +private: + CBaseEntityModelLoadProxy( const CBaseEntityModelLoadProxy& ); + CBaseEntityModelLoadProxy& operator=( const CBaseEntityModelLoadProxy& ); +}; + +static CUtlHashtable< CBaseEntityModelLoadProxy, empty_t, PointerHashFunctor, PointerEqualFunctor, CBaseEntity * > sg_DynamicLoadHandlers; + +void CBaseEntityModelLoadProxy::Handler::OnModelLoadComplete( const model_t *pModel ) +{ + m_pEntity->OnModelLoadComplete( pModel ); + sg_DynamicLoadHandlers.Remove( m_pEntity ); // NOTE: destroys *this! +} + + +CBaseEntity::CBaseEntity( bool bServerOnly ) +{ + COMPILE_TIME_ASSERT( MOVETYPE_LAST < (1 << MOVETYPE_MAX_BITS) ); + COMPILE_TIME_ASSERT( MOVECOLLIDE_COUNT < (1 << MOVECOLLIDE_MAX_BITS) ); + +#ifdef _DEBUG + // necessary since in debug, we initialize vectors to NAN for debugging + m_vecAngVelocity.Init(); +// m_vecAbsAngVelocity.Init(); + m_vecViewOffset.Init(); + m_vecBaseVelocity.GetForModify().Init(); + m_vecVelocity.Init(); + m_vecAbsVelocity.Init(); +#endif + + m_bAlternateSorting = false; + m_CollisionGroup = COLLISION_GROUP_NONE; + m_iParentAttachment = 0; + CollisionProp()->Init( this ); + NetworkProp()->Init( this ); + + // NOTE: THIS MUST APPEAR BEFORE ANY SetMoveType() or SetNextThink() calls + AddEFlags( EFL_NO_THINK_FUNCTION | EFL_NO_GAME_PHYSICS_SIMULATION | EFL_USE_PARTITION_WHEN_NOT_SOLID ); + + // clear debug overlays + m_debugOverlays = 0; + m_pTimedOverlay = NULL; + m_pPhysicsObject = NULL; + m_flElasticity = 1.0f; + m_flShadowCastDistance = m_flDesiredShadowCastDistance = 0; + SetRenderColor( 255, 255, 255, 255 ); + m_iTeamNum = m_iInitialTeamNum = TEAM_UNASSIGNED; + m_nLastThinkTick = gpGlobals->tickcount; + m_nSimulationTick = -1; + SetIdentityMatrix( m_rgflCoordinateFrame ); + m_pBlocker = NULL; +#if _DEBUG + m_iCurrentThinkContext = NO_THINK_CONTEXT; +#endif + m_nWaterTouch = m_nSlimeTouch = 0; + + SetSolid( SOLID_NONE ); + ClearSolidFlags(); + + m_nModelIndex = 0; + m_bDynamicModelAllowed = false; + m_bDynamicModelPending = false; + m_bDynamicModelSetBounds = false; + + SetMoveType( MOVETYPE_NONE ); + SetOwnerEntity( NULL ); + SetCheckUntouch( false ); + SetModelIndex( 0 ); + SetModelName( NULL_STRING ); + m_nTransmitStateOwnedCounter = 0; + + SetCollisionBounds( vec3_origin, vec3_origin ); + ClearFlags(); + + SetFriction( 1.0f ); + + if ( bServerOnly ) + { + AddEFlags( EFL_SERVER_ONLY ); + } + NetworkProp()->MarkPVSInformationDirty(); + +#ifndef _XBOX + AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID ); +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: Scale up our physics hull and test against the new one +// Input : *pNewCollide - New collision hull +//----------------------------------------------------------------------------- +void CBaseEntity::SetScaledPhysics( IPhysicsObject *pNewObject ) +{ + if ( pNewObject ) + { + AddSolidFlags( FSOLID_CUSTOMBOXTEST | FSOLID_CUSTOMRAYTEST ); + } + else + { + RemoveSolidFlags( FSOLID_CUSTOMBOXTEST | FSOLID_CUSTOMRAYTEST ); + } +} + +extern bool g_bDisableEhandleAccess; + +//----------------------------------------------------------------------------- +// Purpose: See note below +//----------------------------------------------------------------------------- +CBaseEntity::~CBaseEntity( ) +{ + // FIXME: This can't be called from UpdateOnRemove! There's at least one + // case where friction sounds are added between the call to UpdateOnRemove + ~CBaseEntity + PhysCleanupFrictionSounds( this ); + + Assert( !IsDynamicModelIndex( m_nModelIndex ) ); + Verify( !sg_DynamicLoadHandlers.Remove( this ) ); + + // In debug make sure that we don't call delete on an entity without setting + // the disable flag first! + // EHANDLE accessors will check, in debug, for access to entities during destruction of + // another entity. + // That kind of operation should only occur in UpdateOnRemove calls + // Deletion should only occur via UTIL_Remove(Immediate) calls, not via naked delete calls + Assert( g_bDisableEhandleAccess ); + + VPhysicsDestroyObject(); + + // Need to remove references to this entity before EHANDLES go null + { + g_bDisableEhandleAccess = false; + CBaseEntity::PhysicsRemoveTouchedList( this ); + CBaseEntity::PhysicsRemoveGroundList( this ); + SetGroundEntity( NULL ); // remove us from the ground entity if we are on it + DestroyAllDataObjects(); + g_bDisableEhandleAccess = true; + + // Remove this entity from the ent list (NOTE: This Makes EHANDLES go NULL) + gEntList.RemoveEntity( GetRefEHandle() ); + } +} + +void CBaseEntity::PostConstructor( const char *szClassname ) +{ + if ( szClassname ) + { + SetClassname(szClassname); + } + + Assert( m_iClassname != NULL_STRING && STRING(m_iClassname) != NULL ); + + // Possibly get an edict, and add self to global list of entites. + if ( IsEFlagSet( EFL_SERVER_ONLY ) ) + { + gEntList.AddNonNetworkableEntity( this ); + } + else + { + // Certain entities set up their edicts in the constructor + if ( !IsEFlagSet( EFL_NO_AUTO_EDICT_ATTACH ) ) + { + NetworkProp()->AttachEdict( g_pForceAttachEdict ); + g_pForceAttachEdict = NULL; + } + + // Some ents like the player override the AttachEdict function and do it at a different time. + // While precaching, they don't ever have an edict, so we don't need to add them to + // the entity list in that case. + if ( edict() ) + { + gEntList.AddNetworkableEntity( this, entindex() ); + + // Cache our IServerNetworkable pointer for the engine for fast access. + if ( edict() ) + edict()->m_pNetworkable = NetworkProp(); + } + } + + CheckHasThinkFunction( false ); + CheckHasGamePhysicsSimulation(); +} + +//----------------------------------------------------------------------------- +// Purpose: Called after player becomes active in the game +//----------------------------------------------------------------------------- +void CBaseEntity::PostClientActive( void ) +{ +} + +//----------------------------------------------------------------------------- +// Purpose: Verifies that this entity's data description is valid in debug builds. +//----------------------------------------------------------------------------- +#ifdef _DEBUG +typedef CUtlVector< const char * > KeyValueNameList_t; + +static void AddDataMapFieldNamesToList( KeyValueNameList_t &list, datamap_t *pDataMap ) +{ + while (pDataMap != NULL) + { + for (int i = 0; i < pDataMap->dataNumFields; i++) + { + typedescription_t *pField = &pDataMap->dataDesc[i]; + + if (pField->fieldType == FIELD_EMBEDDED) + { + AddDataMapFieldNamesToList( list, pField->td ); + continue; + } + + if (pField->flags & FTYPEDESC_KEY) + { + list.AddToTail( pField->externalName ); + } + } + + pDataMap = pDataMap->baseMap; + } +} + +void CBaseEntity::ValidateDataDescription(void) +{ + // Multiple key fields that have the same name are not allowed - it creates an + // ambiguity when trying to parse keyvalues and outputs. + datamap_t *pDataMap = GetDataDescMap(); + if ((pDataMap == NULL) || pDataMap->bValidityChecked) + return; + + pDataMap->bValidityChecked = true; + + // Let's generate a list of all keyvalue strings in the entire hierarchy... + KeyValueNameList_t names(128); + AddDataMapFieldNamesToList( names, pDataMap ); + + for (int i = names.Count(); --i > 0; ) + { + for (int j = i - 1; --j >= 0; ) + { + if (!Q_stricmp(names[i], names[j])) + { + DevMsg( "%s has multiple data description entries for \"%s\"\n", STRING(m_iClassname), names[i]); + break; + } + } + } +} +#endif // _DEBUG + + +//----------------------------------------------------------------------------- +// Sets the collision bounds + the size +//----------------------------------------------------------------------------- +void CBaseEntity::SetCollisionBounds( const Vector& mins, const Vector &maxs ) +{ + m_Collision.SetCollisionBounds( mins, maxs ); +} + + +void CBaseEntity::StopFollowingEntity( ) +{ + if( !IsFollowingEntity() ) + { +// Assert( IsEffectActive( EF_BONEMERGE ) == 0 ); + return; + } + + SetParent( NULL ); + RemoveEffects( EF_BONEMERGE ); + RemoveSolidFlags( FSOLID_NOT_SOLID ); + SetMoveType( MOVETYPE_NONE ); + CollisionRulesChanged(); +} + +bool CBaseEntity::IsFollowingEntity() +{ + return IsEffectActive( EF_BONEMERGE ) && (GetMoveType() == MOVETYPE_NONE) && GetMoveParent(); +} + +CBaseEntity *CBaseEntity::GetFollowedEntity() +{ + if (!IsFollowingEntity()) + return NULL; + return GetMoveParent(); +} + +void CBaseEntity::SetClassname( const char *className ) +{ + m_iClassname = AllocPooledString( className ); +} + +void CBaseEntity::SetModelIndex( int index ) +{ + if ( IsDynamicModelIndex( index ) && !(GetBaseAnimating() && m_bDynamicModelAllowed) ) + { + AssertMsg( false, "dynamic model support not enabled on server entity" ); + index = -1; + } + + if ( index != m_nModelIndex ) + { + if ( m_bDynamicModelPending ) + { + sg_DynamicLoadHandlers.Remove( this ); + } + + modelinfo->ReleaseDynamicModel( m_nModelIndex ); + modelinfo->AddRefDynamicModel( index ); + m_nModelIndex = index; + + m_bDynamicModelSetBounds = false; + + if ( IsDynamicModelIndex( index ) ) + { + m_bDynamicModelPending = true; + sg_DynamicLoadHandlers[ sg_DynamicLoadHandlers.Insert( this ) ].Register( index ); + } + else + { + m_bDynamicModelPending = false; + OnNewModel(); + } + } + DispatchUpdateTransmitState(); +} + +void CBaseEntity::ClearModelIndexOverrides( void ) +{ +#ifdef TF_DLL + for ( int index = 0 ; index < MAX_VISION_MODES ; index++ ) + { + m_nModelIndexOverrides.Set( index, 0 ); + } +#endif +} + +void CBaseEntity::SetModelIndexOverride( int index, int nValue ) +{ +#ifdef TF_DLL + if ( ( index >= VISION_MODE_NONE ) && ( index < MAX_VISION_MODES ) ) + { + if ( nValue != m_nModelIndexOverrides[index] ) + { + m_nModelIndexOverrides.Set( index, nValue ); + } + } +#endif +} + +// position to shoot at +Vector CBaseEntity::BodyTarget( const Vector &posSrc, bool bNoisy) +{ + return WorldSpaceCenter( ); +} + +// return the position of my head. someone's trying to attack it. +Vector CBaseEntity::HeadTarget( const Vector &posSrc ) +{ + return EyePosition(); +} + + +struct TimedOverlay_t +{ + char *msg; + int msgEndTime; + int msgStartTime; + TimedOverlay_t *pNextTimedOverlay; +}; + +//----------------------------------------------------------------------------- +// Purpose: Display an error message on the entity +// Input : +// Output : +//----------------------------------------------------------------------------- +void CBaseEntity::AddTimedOverlay( const char *msg, int endTime ) +{ + TimedOverlay_t *pNewTO = new TimedOverlay_t; + int len = strlen(msg); + pNewTO->msg = new char[len + 1]; + Q_strncpy(pNewTO->msg,msg, len+1); + pNewTO->msgEndTime = gpGlobals->curtime + endTime; + pNewTO->msgStartTime = gpGlobals->curtime; + pNewTO->pNextTimedOverlay = m_pTimedOverlay; + m_pTimedOverlay = pNewTO; +} + +//----------------------------------------------------------------------------- +// Purpose: Send debug overlay box to the client +// Input : +// Output : +//----------------------------------------------------------------------------- +void CBaseEntity::DrawBBoxOverlay( float flDuration ) +{ + if (edict()) + { + NDebugOverlay::EntityBounds(this, 255, 100, 0, 0, flDuration ); + + if ( CollisionProp()->IsSolidFlagSet( FSOLID_USE_TRIGGER_BOUNDS ) ) + { + Vector vecTriggerMins, vecTriggerMaxs; + CollisionProp()->WorldSpaceTriggerBounds( &vecTriggerMins, &vecTriggerMaxs ); + Vector center = 0.5f * (vecTriggerMins + vecTriggerMaxs); + Vector extents = vecTriggerMaxs - center; + NDebugOverlay::Box(center, -extents, extents, 0, 255, 255, 0, flDuration ); + } + } +} + + +void CBaseEntity::DrawAbsBoxOverlay() +{ + int red = 0; + int green = 200; + + if ( VPhysicsGetObject() && VPhysicsGetObject()->IsAsleep() ) + { + red = 90; + green = 120; + } + + if (edict()) + { + // Surrounding boxes are axially aligned, so ignore angles + Vector vecSurroundMins, vecSurroundMaxs; + CollisionProp()->WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs ); + Vector center = 0.5f * (vecSurroundMins + vecSurroundMaxs); + Vector extents = vecSurroundMaxs - center; + NDebugOverlay::Box(center, -extents, extents, red, green, 0, 0 ,0); + } +} + +void CBaseEntity::DrawRBoxOverlay() +{ + +} + +//----------------------------------------------------------------------------- +// Purpose: Draws an axis overlay at the origin and angles of the entity +//----------------------------------------------------------------------------- +void CBaseEntity::SendDebugPivotOverlay( void ) +{ + if ( edict() ) + { + NDebugOverlay::Axis( GetAbsOrigin(), GetAbsAngles(), 20, true, 0 ); + } +} + +//------------------------------------------------------------------------------ +// Purpose : Add new entity positioned overlay text +// Input : How many lines to offset text from origin +// The text to print +// How long to display text +// The color of the text +// Output : +//------------------------------------------------------------------------------ +void CBaseEntity::EntityText( int text_offset, const char *text, float duration, int r, int g, int b, int a ) +{ + Vector origin; + Vector vecLocalCenter; + + VectorAdd( m_Collision.OBBMins(), m_Collision.OBBMaxs(), vecLocalCenter ); + vecLocalCenter *= 0.5f; + + if ( ( m_Collision.GetCollisionAngles() == vec3_angle ) || ( vecLocalCenter == vec3_origin ) ) + { + VectorAdd( vecLocalCenter, m_Collision.GetCollisionOrigin(), origin ); + } + else + { + VectorTransform( vecLocalCenter, m_Collision.CollisionToWorldTransform(), origin ); + } + + NDebugOverlay::EntityTextAtPosition( origin, text_offset, text, duration, r, g, b, a ); +} + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CBaseEntity::DrawTimedOverlays(void) +{ + // Draw name first if I have an overlay or am in message mode + if ((m_debugOverlays & OVERLAY_MESSAGE_BIT)) + { + char tempstr[512]; + Q_snprintf( tempstr, sizeof( tempstr ), "[%s]", GetDebugName() ); + EntityText(0,tempstr, 0); + } + + // Now draw overlays + TimedOverlay_t* pTO = m_pTimedOverlay; + TimedOverlay_t* pNextTO = NULL; + TimedOverlay_t* pLastTO = NULL; + int nCount = 1; // Offset by one + while (pTO) + { + pNextTO = pTO->pNextTimedOverlay; + + // Remove old messages unless messages are paused + if ((!CBaseEntity::Debug_IsPaused() && gpGlobals->curtime > pTO->msgEndTime) || + (nCount > 10)) + { + if (pLastTO) + { + pLastTO->pNextTimedOverlay = pNextTO; + } + else + { + m_pTimedOverlay = pNextTO; + } + + delete pTO->msg; + delete pTO; + } + else + { + int nAlpha = 0; + + // If messages aren't paused fade out + if (!CBaseEntity::Debug_IsPaused()) + { + nAlpha = 255*((gpGlobals->curtime - pTO->msgStartTime)/(pTO->msgEndTime - pTO->msgStartTime)); + } + int r = 185; + int g = 145; + int b = 145; + + // Brighter when new message + if (nAlpha < 50) + { + r = 255; + g = 205; + b = 205; + } + if (nAlpha < 0) nAlpha = 0; + EntityText(nCount,pTO->msg, 0.0, r, g, b, 255-nAlpha); + nCount++; + + pLastTO = pTO; + } + pTO = pNextTO; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Draw all overlays (should be implemented by subclass to add +// any additional non-text overlays) +// Input : +// Output : Current text offset from the top +//----------------------------------------------------------------------------- +void CBaseEntity::DrawDebugGeometryOverlays(void) +{ + DrawTimedOverlays(); + DrawDebugTextOverlays(); + + if (m_debugOverlays & OVERLAY_NAME_BIT) + { + EntityText(0,GetDebugName(), 0); + } + if (m_debugOverlays & OVERLAY_BBOX_BIT) + { + DrawBBoxOverlay(); + } + if (m_debugOverlays & OVERLAY_ABSBOX_BIT ) + { + DrawAbsBoxOverlay(); + } + if (m_debugOverlays & OVERLAY_PIVOT_BIT) + { + SendDebugPivotOverlay(); + } + if( m_debugOverlays & OVERLAY_RBOX_BIT ) + { + DrawRBoxOverlay(); + } + if ( m_debugOverlays & (OVERLAY_BBOX_BIT|OVERLAY_PIVOT_BIT) ) + { + // draw mass center + if ( VPhysicsGetObject() ) + { + Vector massCenter = VPhysicsGetObject()->GetMassCenterLocalSpace(); + Vector worldPos; + VPhysicsGetObject()->LocalToWorld( &worldPos, massCenter ); + NDebugOverlay::Cross3D( worldPos, 12, 255, 0, 0, false, 0 ); + DebugDrawContactPoints(VPhysicsGetObject()); + if ( GetMoveType() != MOVETYPE_VPHYSICS ) + { + Vector pos; + QAngle angles; + VPhysicsGetObject()->GetPosition( &pos, &angles ); + float dist = (pos - GetAbsOrigin()).Length(); + + Vector axis; + float deltaAngle; + RotationDeltaAxisAngle( angles, GetAbsAngles(), axis, deltaAngle ); + if ( dist > 2 || fabsf(deltaAngle) > 2 ) + { + Vector mins, maxs; + physcollision->CollideGetAABB( &mins, &maxs, VPhysicsGetObject()->GetCollide(), vec3_origin, vec3_angle ); + NDebugOverlay::BoxAngles( pos, mins, maxs, angles, 255, 255, 0, 16, 0 ); + } + } + } + } + if ( m_debugOverlays & OVERLAY_SHOW_BLOCKSLOS ) + { + if ( BlocksLOS() ) + { + NDebugOverlay::EntityBounds(this, 255, 255, 255, 0, 0 ); + } + } + if ( m_debugOverlays & OVERLAY_AUTOAIM_BIT && (GetFlags()&FL_AIMTARGET) && AI_GetSinglePlayer() != NULL ) + { + // Crude, but it gets the point across. + Vector vecCenter = GetAutoAimCenter(); + Vector vecRight, vecUp, vecDiag; + CBasePlayer *pPlayer = AI_GetSinglePlayer(); + float radius = GetAutoAimRadius(); + + QAngle angles = pPlayer->EyeAngles(); + AngleVectors( angles, NULL, &vecRight, &vecUp ); + + int r,g,b; + + if( ((int)gpGlobals->curtime) % 2 == 1 ) + { + r = 255; + g = 255; + b = 255; + + if( pPlayer->GetActiveWeapon() != NULL ) + radius *= pPlayer->GetActiveWeapon()->WeaponAutoAimScale(); + + } + else + { + r = 255;g=0;b=0; + + if( !ShouldAttractAutoAim(pPlayer) ) + { + g = 255; + } + } + + if( pPlayer->IsInAVehicle() ) + { + radius *= sv_vehicle_autoaim_scale.GetFloat(); + } + + NDebugOverlay::Line( vecCenter, vecCenter + vecRight * radius, r, g, b, true, 0.1 ); + NDebugOverlay::Line( vecCenter, vecCenter - vecRight * radius, r, g, b, true, 0.1 ); + NDebugOverlay::Line( vecCenter, vecCenter + vecUp * radius, r, g, b, true, 0.1 ); + NDebugOverlay::Line( vecCenter, vecCenter - vecUp * radius, r, g, b, true, 0.1 ); + + vecDiag = vecRight + vecUp; + VectorNormalize( vecDiag ); + NDebugOverlay::Line( vecCenter - vecDiag * radius, vecCenter + vecDiag * radius, r, g, b, true, 0.1 ); + + vecDiag = vecRight - vecUp; + VectorNormalize( vecDiag ); + NDebugOverlay::Line( vecCenter - vecDiag * radius, vecCenter + vecDiag * radius, r, g, b, true, 0.1 ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Draw any text overlays (override in subclass to add additional text) +// Output : Current text offset from the top +//----------------------------------------------------------------------------- +int CBaseEntity::DrawDebugTextOverlays(void) +{ + int offset = 1; + if (m_debugOverlays & OVERLAY_TEXT_BIT) + { + char tempstr[512]; + Q_snprintf( tempstr, sizeof(tempstr), "(%d) Name: %s (%s)", entindex(), GetDebugName(), GetClassname() ); + EntityText(offset,tempstr, 0); + offset++; + + if( m_iGlobalname != NULL_STRING ) + { + Q_snprintf( tempstr, sizeof(tempstr), "GLOBALNAME: %s", STRING(m_iGlobalname) ); + EntityText(offset,tempstr, 0); + offset++; + } + + Vector vecOrigin = GetAbsOrigin(); + Q_snprintf( tempstr, sizeof(tempstr), "Position: %0.1f, %0.1f, %0.1f\n", vecOrigin.x, vecOrigin.y, vecOrigin.z ); + EntityText( offset, tempstr, 0 ); + offset++; + + if( GetModelName() != NULL_STRING || GetBaseAnimating() ) + { + Q_snprintf(tempstr, sizeof(tempstr), "Model:%s", STRING(GetModelName()) ); + EntityText(offset,tempstr,0); + offset++; + } + + if( m_hDamageFilter.Get() != NULL ) + { + Q_snprintf( tempstr, sizeof(tempstr), "DAMAGE FILTER:%s", m_hDamageFilter->GetDebugName() ); + EntityText( offset,tempstr,0 ); + offset++; + } + } + + if (m_debugOverlays & OVERLAY_VIEWOFFSET) + { + NDebugOverlay::Cross3D( EyePosition(), 16, 255, 0, 0, true, 0.05f ); + } + + return offset; +} + + +void CBaseEntity::SetParent( string_t newParent, CBaseEntity *pActivator, int iAttachment ) +{ + // find and notify the new parent + CBaseEntity *pParent = gEntList.FindEntityByName( NULL, newParent, NULL, pActivator ); + + // debug check + if ( newParent != NULL_STRING && pParent == NULL ) + { + Msg( "Entity %s(%s) has bad parent %s\n", STRING(m_iClassname), GetDebugName(), STRING(newParent) ); + } + else + { + // make sure there isn't any ambiguity + if ( gEntList.FindEntityByName( pParent, newParent, NULL, pActivator ) ) + { + Msg( "Entity %s(%s) has ambigious parent %s\n", STRING(m_iClassname), GetDebugName(), STRING(newParent) ); + } + SetParent( pParent, iAttachment ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Move our points from parent to worldspace +// Input : *pParent - Parent to use as reference +//----------------------------------------------------------------------------- +void CBaseEntity::TransformStepData_ParentToWorld( CBaseEntity *pParent ) +{ + // Fix up our step simulation points to be in the proper local space + StepSimulationData *step = (StepSimulationData *) GetDataObject( STEPSIMULATION ); + if ( step != NULL ) + { + // Convert our positions + UTIL_ParentToWorldSpace( pParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); + UTIL_ParentToWorldSpace( pParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Move step data between two parent-spaces +// Input : *pOldParent - parent we were attached to +// *pNewParent - parent we're now attached to +//----------------------------------------------------------------------------- +void CBaseEntity::TransformStepData_ParentToParent( CBaseEntity *pOldParent, CBaseEntity *pNewParent ) +{ + // Fix up our step simulation points to be in the proper local space + StepSimulationData *step = (StepSimulationData *) GetDataObject( STEPSIMULATION ); + if ( step != NULL ) + { + // Convert our positions + UTIL_ParentToWorldSpace( pOldParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); + UTIL_WorldToParentSpace( pNewParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); + + UTIL_ParentToWorldSpace( pOldParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); + UTIL_WorldToParentSpace( pNewParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: After parenting to an object, we need to also correctly translate our +// step stimulation positions and angles into that parent space. Otherwise +// we end up splining between two different world spaces. +//----------------------------------------------------------------------------- +void CBaseEntity::TransformStepData_WorldToParent( CBaseEntity *pParent ) +{ + // Fix up our step simulation points to be in the proper local space + StepSimulationData *step = (StepSimulationData *) GetDataObject( STEPSIMULATION ); + if ( step != NULL ) + { + // Convert our positions + UTIL_WorldToParentSpace( pParent, step->m_Previous2.vecOrigin, step->m_Previous2.qRotation ); + UTIL_WorldToParentSpace( pParent, step->m_Previous.vecOrigin, step->m_Previous.qRotation ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Sets the movement parent of this entity. This entity will be moved +// to a local coordinate calculated from its current absolute offset +// from the parent entity and will then follow the parent entity. +// Input : pParentEntity - This entity's new parent in the movement hierarchy. +//----------------------------------------------------------------------------- +void CBaseEntity::SetParent( CBaseEntity *pParentEntity, int iAttachment ) +{ + // If they didn't specify an attachment, use our current + if ( iAttachment == -1 ) + { + iAttachment = m_iParentAttachment; + } + + bool bWasNotParented = ( GetParent() == NULL ); + CBaseEntity *pOldParent = m_pParent; + + // notify the old parent of the loss + UnlinkFromParent( this ); + + // set the new name + m_pParent = pParentEntity; + + if ( m_pParent == this ) + { + // should never set parent to 'this' - makes no sense + Assert(0); + m_pParent = NULL; + } + + if ( m_pParent == NULL ) + { + m_iParent = NULL_STRING; + + // Transform step data from parent to worldspace + TransformStepData_ParentToWorld( pOldParent ); + return; + } + + m_iParent = m_pParent->m_iName; + + RemoveSolidFlags( FSOLID_ROOT_PARENT_ALIGNED ); + if ( pParentEntity ) + { + if ( const_cast(pParentEntity)->GetRootMoveParent()->GetSolid() == SOLID_BSP ) + { + AddSolidFlags( FSOLID_ROOT_PARENT_ALIGNED ); + } + else + { + if ( GetSolid() == SOLID_BSP ) + { + // Must be SOLID_VPHYSICS because parent might rotate + SetSolid( SOLID_VPHYSICS ); + } + } + } + // set the move parent if we have one + if ( edict() ) + { + // add ourselves to the list + LinkChild( m_pParent, this ); + + m_iParentAttachment = (char)iAttachment; + + EntityMatrix matrix, childMatrix; + matrix.InitFromEntity( const_cast(pParentEntity), m_iParentAttachment ); // parent->world + childMatrix.InitFromEntityLocal( this ); // child->world + Vector localOrigin = matrix.WorldToLocal( GetLocalOrigin() ); + + // I have the axes of local space in world space. (childMatrix) + // I want to compute those world space axes in the parent's local space + // and set that transform (as angles) on the child's object so the net + // result is that the child is now in parent space, but still oriented the same way + VMatrix tmp = matrix.Transpose(); // world->parent + tmp.MatrixMul( childMatrix, matrix ); // child->parent + QAngle angles; + MatrixToAngles( matrix, angles ); + SetLocalAngles( angles ); + UTIL_SetOrigin( this, localOrigin ); + + // Move our step data into the correct space + if ( bWasNotParented ) + { + // Transform step data from world to parent-space + TransformStepData_WorldToParent( this ); + } + else + { + // Transform step data between parent-spaces + TransformStepData_ParentToParent( pOldParent, this ); + } + } + if ( VPhysicsGetObject() ) + { + if ( VPhysicsGetObject()->IsStatic()) + { + if ( VPhysicsGetObject()->IsAttachedToConstraint(false) ) + { + Warning("SetParent on static object, all constraints attached to %s (%s)will now be broken!\n", GetDebugName(), GetClassname() ); + } + VPhysicsDestroyObject(); + VPhysicsInitShadow(false, false); + } + } + CollisionRulesChanged(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseEntity::ValidateEntityConnections() +{ + if ( m_target == NULL_STRING ) + return; + + if ( ClassMatches( "scripted_*" ) || + ClassMatches( "trigger_relay" ) || + ClassMatches( "trigger_auto" ) || + ClassMatches( "path_*" ) || + ClassMatches( "monster_*" ) || + ClassMatches( "trigger_teleport" ) || + ClassMatches( "func_train" ) || + ClassMatches( "func_tracktrain" ) || + ClassMatches( "func_plat*" ) || + ClassMatches( "npc_*" ) || + ClassMatches( "info_big*" ) || + ClassMatches( "env_texturetoggle" ) || + ClassMatches( "env_render" ) || + ClassMatches( "func_areaportalwindow") || + ClassMatches( "point_view*") || + ClassMatches( "func_traincontrols" ) || + ClassMatches( "multisource" ) || + ClassMatches( "xen_plant*" ) ) + return; + + datamap_t *dmap = GetDataDescMap(); + while ( dmap ) + { + int fields = dmap->dataNumFields; + for ( int i = 0; i < fields; i++ ) + { + typedescription_t *dataDesc = &dmap->dataDesc[i]; + if ( ( dataDesc->fieldType == FIELD_CUSTOM ) && ( dataDesc->flags & FTYPEDESC_OUTPUT ) ) + { + CBaseEntityOutput *pOutput = (CBaseEntityOutput *)((int)this + (int)dataDesc->fieldOffset[0]); + if ( pOutput->NumberOfElements() ) + return; + } + } + + dmap = dmap->baseMap; + } + + Vector vecLoc = WorldSpaceCenter(); + Warning("---------------------------------\n"); + Warning( "Entity %s - (%s) has a target and NO OUTPUTS\n", GetDebugName(), GetClassname() ); + Warning( "Location %f %f %f\n", vecLoc.x, vecLoc.y, vecLoc.z ); + Warning("---------------------------------\n"); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseEntity::FireNamedOutput( const char *pszOutput, variant_t variant, CBaseEntity *pActivator, CBaseEntity *pCaller, float flDelay ) +{ + if ( pszOutput == NULL ) + return; + + datamap_t *dmap = GetDataDescMap(); + while ( dmap ) + { + int fields = dmap->dataNumFields; + for ( int i = 0; i < fields; i++ ) + { + typedescription_t *dataDesc = &dmap->dataDesc[i]; + if ( ( dataDesc->fieldType == FIELD_CUSTOM ) && ( dataDesc->flags & FTYPEDESC_OUTPUT ) ) + { + CBaseEntityOutput *pOutput = ( CBaseEntityOutput * )( ( int )this + ( int )dataDesc->fieldOffset[0] ); + if ( !Q_stricmp( dataDesc->externalName, pszOutput ) ) + { + pOutput->FireOutput( variant, pActivator, pCaller, flDelay ); + return; + } + } + } + + dmap = dmap->baseMap; + } +} + +void CBaseEntity::Activate( void ) +{ +#ifdef DEBUG + extern bool g_bCheckForChainedActivate; + extern bool g_bReceivedChainedActivate; + + if ( g_bCheckForChainedActivate && g_bReceivedChainedActivate ) + { + Assert( !"Multiple calls to base class Activate()\n" ); + } + g_bReceivedChainedActivate = true; +#endif + + // NOTE: This forces a team change so that stuff in the level + // that starts out on a team correctly changes team + if (m_iInitialTeamNum) + { + ChangeTeam( m_iInitialTeamNum ); + } + + // Get a handle to my damage filter entity if there is one. + if ( m_iszDamageFilterName != NULL_STRING ) + { + m_hDamageFilter = gEntList.FindEntityByName( NULL, m_iszDamageFilterName ); + } + + // Add any non-null context strings to our context vector + if ( m_iszResponseContext != NULL_STRING ) + { + AddContext( m_iszResponseContext.ToCStr() ); + } + +#ifdef HL1_DLL + ValidateEntityConnections(); +#endif //HL1_DLL +} + +//////////////////////////// old CBaseEntity stuff /////////////////////////////////// + + +// give health. +// Returns the amount of health actually taken. +int CBaseEntity::TakeHealth( float flHealth, int bitsDamageType ) +{ + if ( !edict() || m_takedamage < DAMAGE_YES ) + return 0; + + int iMax = GetMaxHealth(); + +// heal + if ( m_iHealth >= iMax ) + return 0; + + const int oldHealth = m_iHealth; + + m_iHealth += flHealth; + + if (m_iHealth > iMax) + m_iHealth = iMax; + + return m_iHealth - oldHealth; +} + +// inflict damage on this entity. bitsDamageType indicates type of damage inflicted, ie: DMG_CRUSH + +int CBaseEntity::OnTakeDamage( const CTakeDamageInfo &info ) +{ + Vector vecTemp; + + if ( !edict() || !m_takedamage ) + return 0; + + if ( info.GetInflictor() ) + { + vecTemp = info.GetInflictor()->WorldSpaceCenter() - ( WorldSpaceCenter() ); + } + else + { + vecTemp.Init( 1, 0, 0 ); + } + + // this global is still used for glass and other non-NPC killables, along with decals. + g_vecAttackDir = vecTemp; + VectorNormalize(g_vecAttackDir); + + // save damage based on the target's armor level + + // figure momentum add (don't let hurt brushes or other triggers move player) + + // physics objects have their own calcs for this: (don't let fire move things around!) + if ( !IsEFlagSet( EFL_NO_DAMAGE_FORCES ) ) + { + if ( ( GetMoveType() == MOVETYPE_VPHYSICS ) ) + { + VPhysicsTakeDamage( info ); + } + else + { + if ( info.GetInflictor() && (GetMoveType() == MOVETYPE_WALK || GetMoveType() == MOVETYPE_STEP) && + !info.GetAttacker()->IsSolidFlagSet(FSOLID_TRIGGER) ) + { + Vector vecDir, vecInflictorCentroid; + vecDir = WorldSpaceCenter( ); + vecInflictorCentroid = info.GetInflictor()->WorldSpaceCenter( ); + vecDir -= vecInflictorCentroid; + VectorNormalize( vecDir ); + + float flForce = info.GetDamage() * ((32 * 32 * 72.0) / (WorldAlignSize().x * WorldAlignSize().y * WorldAlignSize().z)) * 5; + + if (flForce > 1000.0) + flForce = 1000.0; + ApplyAbsVelocityImpulse( vecDir * flForce ); + } + } + } + + if ( m_takedamage != DAMAGE_EVENTS_ONLY ) + { + // do the damage + m_iHealth -= info.GetDamage(); + if (m_iHealth <= 0) + { + Event_Killed( info ); + return 0; + } + } + + return 1; +} + +//----------------------------------------------------------------------------- +// Purpose: Scale damage done and call OnTakeDamage +//----------------------------------------------------------------------------- +void CBaseEntity::TakeDamage( const CTakeDamageInfo &inputInfo ) +{ + if ( !g_pGameRules ) + return; + + bool bHasPhysicsForceDamage = !g_pGameRules->Damage_NoPhysicsForce( inputInfo.GetDamageType() ); + if ( bHasPhysicsForceDamage && inputInfo.GetDamageType() != DMG_GENERIC ) + { + // If you hit this assert, you've called TakeDamage with a damage type that requires a physics damage + // force & position without specifying one or both of them. Decide whether your damage that's causing + // this is something you believe should impart physics force on the receiver. If it is, you need to + // setup the damage force & position inside the CTakeDamageInfo (Utility functions for this are in + // takedamageinfo.cpp. If you think the damage shouldn't cause force (unlikely!) then you can set the + // damage type to DMG_GENERIC, or | DMG_CRUSH if you need to preserve the damage type for purposes of HUD display. + + if ( inputInfo.GetDamageForce() == vec3_origin || inputInfo.GetDamagePosition() == vec3_origin ) + { + static int warningCount = 0; + if ( ++warningCount < 10 ) + { + if ( inputInfo.GetDamageForce() == vec3_origin ) + { + DevWarning( "CBaseEntity::TakeDamage: with inputInfo.GetDamageForce() == vec3_origin\n" ); + } + if ( inputInfo.GetDamagePosition() == vec3_origin ) + { + DevWarning( "CBaseEntity::TakeDamage: with inputInfo.GetDamagePosition() == vec3_origin\n" ); + } + } + } + } + + // Make sure our damage filter allows the damage. + if ( !PassesDamageFilter( inputInfo )) + { + return; + } + + if( !g_pGameRules->AllowDamage(this, inputInfo) ) + { + return; + } + + if ( PhysIsInCallback() ) + { + PhysCallbackDamage( this, inputInfo ); + } + else + { + CTakeDamageInfo info = inputInfo; + + // Scale the damage by the attacker's modifier. + if ( info.GetAttacker() ) + { + info.ScaleDamage( info.GetAttacker()->GetAttackDamageScale( this ) ); + } + + // Scale the damage by my own modifiers + info.ScaleDamage( GetReceivedDamageScale( info.GetAttacker() ) ); + + //Msg("%s took %.2f Damage, at %.2f\n", GetClassname(), info.GetDamage(), gpGlobals->curtime ); + + OnTakeDamage( info ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Returns a value that scales all damage done by this entity. +//----------------------------------------------------------------------------- +float CBaseEntity::GetAttackDamageScale( CBaseEntity *pVictim ) +{ + float flScale = 1; + FOR_EACH_LL( m_DamageModifiers, i ) + { + if ( !m_DamageModifiers[i]->IsDamageDoneToMe() ) + { + flScale *= m_DamageModifiers[i]->GetModifier(); + } + } + return flScale; +} + +//----------------------------------------------------------------------------- +// Purpose: Returns a value that scales all damage done to this entity +//----------------------------------------------------------------------------- +float CBaseEntity::GetReceivedDamageScale( CBaseEntity *pAttacker ) +{ + float flScale = 1; + FOR_EACH_LL( m_DamageModifiers, i ) + { + if ( m_DamageModifiers[i]->IsDamageDoneToMe() ) + { + flScale *= m_DamageModifiers[i]->GetModifier(); + } + } + return flScale; +} + + +//----------------------------------------------------------------------------- +// Purpose: Applies forces to our physics object in response to damage. +//----------------------------------------------------------------------------- +int CBaseEntity::VPhysicsTakeDamage( const CTakeDamageInfo &info ) +{ + // don't let physics impacts or fire cause objects to move (again) + bool bNoPhysicsForceDamage = g_pGameRules->Damage_NoPhysicsForce( info.GetDamageType() ); + if ( bNoPhysicsForceDamage || info.GetDamageType() == DMG_GENERIC ) + return 1; + + Assert(VPhysicsGetObject() != NULL); + if ( VPhysicsGetObject() ) + { + Vector force = info.GetDamageForce(); + Vector offset = info.GetDamagePosition(); + + // If you hit this assert, you've called TakeDamage with a damage type that requires a physics damage + // force & position without specifying one or both of them. Decide whether your damage that's causing + // this is something you believe should impart physics force on the receiver. If it is, you need to + // setup the damage force & position inside the CTakeDamageInfo (Utility functions for this are in + // takedamageinfo.cpp. If you think the damage shouldn't cause force (unlikely!) then you can set the + // damage type to DMG_GENERIC, or | DMG_CRUSH if you need to preserve the damage type for purposes of HUD display. +#if !defined( TF_DLL ) + Assert( force != vec3_origin && offset != vec3_origin ); +#else + // this was spamming the console for Payload maps in TF (trigger_hurt entity on the front of the cart) + if ( !TFGameRules() || TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT ) + { + Assert( force != vec3_origin && offset != vec3_origin ); + } +#endif + + unsigned short gameFlags = VPhysicsGetObject()->GetGameFlags(); + if ( gameFlags & FVPHYSICS_PLAYER_HELD ) + { + // if the player is holding the object, use it's real mass (player holding reduced the mass) + CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); + if ( pPlayer ) + { + float mass = pPlayer->GetHeldObjectMass( VPhysicsGetObject() ); + if ( mass != 0.0f ) + { + float ratio = VPhysicsGetObject()->GetMass() / mass; + force *= ratio; + } + } + } + else if ( (gameFlags & FVPHYSICS_PART_OF_RAGDOLL) && (gameFlags & FVPHYSICS_CONSTRAINT_STATIC) ) + { + IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT]; + int count = VPhysicsGetObjectList( pList, ARRAYSIZE(pList) ); + for ( int i = 0; i < count; i++ ) + { + if ( !(pList[i]->GetGameFlags() & FVPHYSICS_CONSTRAINT_STATIC) ) + { + pList[i]->ApplyForceOffset( force, offset ); + return 1; + } + } + + } + VPhysicsGetObject()->ApplyForceOffset( force, offset ); + } + + return 1; +} + + // Character killed (only fired once) +void CBaseEntity::Event_Killed( const CTakeDamageInfo &info ) +{ + if( info.GetAttacker() ) + { + info.GetAttacker()->Event_KilledOther(this, info); + } + + m_takedamage = DAMAGE_NO; + m_lifeState = LIFE_DEAD; + UTIL_Remove( this ); +} + +//----------------------------------------------------------------------------- +// Purpose: helper method to send a game event when this entity is killed. Note: +// gets called specifically for particular entities (mostly NPC), this +// does not get called for every entity +//----------------------------------------------------------------------------- +void CBaseEntity::SendOnKilledGameEvent( const CTakeDamageInfo &info ) +{ + IGameEvent *event = gameeventmanager->CreateEvent( "entity_killed" ); + if ( event ) + { + event->SetInt( "entindex_killed", entindex() ); + if ( info.GetAttacker()) + { + event->SetInt( "entindex_attacker", info.GetAttacker()->entindex() ); + } + if ( info.GetInflictor()) + { + event->SetInt( "entindex_inflictor", info.GetInflictor()->entindex() ); + } + event->SetInt( "damagebits", info.GetDamageType() ); + gameeventmanager->FireEvent( event ); + } +} + + +bool CBaseEntity::HasTarget( string_t targetname ) +{ + if( targetname != NULL_STRING && m_target != NULL_STRING ) + return FStrEq(STRING(targetname), STRING(m_target) ); + else + return false; +} + + +CBaseEntity *CBaseEntity::GetNextTarget( void ) +{ + if ( !m_target ) + return NULL; + return gEntList.FindEntityByName( NULL, m_target ); +} + +class CThinkContextsSaveDataOps : public CDefSaveRestoreOps +{ + virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) + { + AssertMsg( fieldInfo.pTypeDesc->fieldSize == 1, "CThinkContextsSaveDataOps does not support arrays"); + + // Write out the vector + CUtlVector< thinkfunc_t > *pUtlVector = (CUtlVector< thinkfunc_t > *)fieldInfo.pField; + SaveUtlVector( pSave, pUtlVector, FIELD_EMBEDDED ); + + // Get our owner + CBaseEntity *pOwner = (CBaseEntity*)fieldInfo.pOwner; + + pSave->StartBlock(); + // Now write out all the functions + for ( int i = 0; i < pUtlVector->Size(); i++ ) + { +#ifdef WIN32 + void **ppV = (void**)&((*pUtlVector)[i].m_pfnThink); +#else + BASEPTR *ppV = &((*pUtlVector)[i].m_pfnThink); +#endif + bool bHasFunc = (*ppV != NULL); + pSave->WriteBool( &bHasFunc, 1 ); + if ( bHasFunc ) + { + pSave->WriteFunction( pOwner->GetDataDescMap(), "m_pfnThink", (inputfunc_t **)ppV, 1 ); + } + } + pSave->EndBlock(); + } + + virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) + { + AssertMsg( fieldInfo.pTypeDesc->fieldSize == 1, "CThinkContextsSaveDataOps does not support arrays"); + + // Read in the vector + CUtlVector< thinkfunc_t > *pUtlVector = (CUtlVector< thinkfunc_t > *)fieldInfo.pField; + RestoreUtlVector( pRestore, pUtlVector, FIELD_EMBEDDED ); + + // Get our owner + CBaseEntity *pOwner = (CBaseEntity*)fieldInfo.pOwner; + + pRestore->StartBlock(); + // Now read in all the functions + for ( int i = 0; i < pUtlVector->Size(); i++ ) + { + bool bHasFunc; + pRestore->ReadBool( &bHasFunc, 1 ); +#ifdef WIN32 + void **ppV = (void**)&((*pUtlVector)[i].m_pfnThink); +#else + BASEPTR *ppV = &((*pUtlVector)[i].m_pfnThink); + Q_memset( (void *)ppV, 0x0, sizeof(inputfunc_t) ); +#endif + if ( bHasFunc ) + { + SaveRestoreRecordHeader_t header; + pRestore->ReadHeader( &header ); + pRestore->ReadFunction( pOwner->GetDataDescMap(), (inputfunc_t **)ppV, 1, header.size ); + } + else + { + *ppV = NULL; + } + } + pRestore->EndBlock(); + } + + virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) + { + CUtlVector< thinkfunc_t > *pUtlVector = (CUtlVector< thinkfunc_t > *)fieldInfo.pField; + return ( pUtlVector->Count() == 0 ); + } + + virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) + { + BASEPTR pFunc = *((BASEPTR*)fieldInfo.pField); + pFunc = NULL; + } +}; +CThinkContextsSaveDataOps g_ThinkContextsSaveDataOps; +ISaveRestoreOps *thinkcontextFuncs = &g_ThinkContextsSaveDataOps; + +BEGIN_SIMPLE_DATADESC( thinkfunc_t ) + + DEFINE_FIELD( m_iszContext, FIELD_STRING ), + // DEFINE_FIELD( m_pfnThink, FIELD_FUNCTION ), // Manually written + DEFINE_FIELD( m_nNextThinkTick, FIELD_TICK ), + DEFINE_FIELD( m_nLastThinkTick, FIELD_TICK ), + +END_DATADESC() + +BEGIN_SIMPLE_DATADESC( ResponseContext_t ) + + DEFINE_FIELD( m_iszName, FIELD_STRING ), + DEFINE_FIELD( m_iszValue, FIELD_STRING ), + DEFINE_FIELD( m_fExpirationTime, FIELD_TIME ), + +END_DATADESC() + +BEGIN_DATADESC_NO_BASE( CBaseEntity ) + + DEFINE_KEYFIELD( m_iClassname, FIELD_STRING, "classname" ), + DEFINE_GLOBAL_KEYFIELD( m_iGlobalname, FIELD_STRING, "globalname" ), + DEFINE_KEYFIELD( m_iParent, FIELD_STRING, "parentname" ), + + DEFINE_KEYFIELD( m_iHammerID, FIELD_INTEGER, "hammerid" ), // save ID numbers so that entities can be tracked between save/restore and vmf + + DEFINE_KEYFIELD( m_flSpeed, FIELD_FLOAT, "speed" ), + DEFINE_KEYFIELD( m_nRenderFX, FIELD_CHARACTER, "renderfx" ), + DEFINE_KEYFIELD( m_nRenderMode, FIELD_CHARACTER, "rendermode" ), + + // Consider moving to CBaseAnimating? + DEFINE_FIELD( m_flPrevAnimTime, FIELD_TIME ), + DEFINE_FIELD( m_flAnimTime, FIELD_TIME ), + DEFINE_FIELD( m_flSimulationTime, FIELD_TIME ), + DEFINE_FIELD( m_nLastThinkTick, FIELD_TICK ), + + DEFINE_KEYFIELD( m_nNextThinkTick, FIELD_TICK, "nextthink" ), + DEFINE_KEYFIELD( m_fEffects, FIELD_INTEGER, "effects" ), + DEFINE_KEYFIELD( m_clrRender, FIELD_COLOR32, "rendercolor" ), + DEFINE_GLOBAL_KEYFIELD( m_nModelIndex, FIELD_SHORT, "modelindex" ), +#if !defined( NO_ENTITY_PREDICTION ) + // DEFINE_FIELD( m_PredictableID, CPredictableId ), +#endif + DEFINE_FIELD( touchStamp, FIELD_INTEGER ), + DEFINE_CUSTOM_FIELD( m_aThinkFunctions, thinkcontextFuncs ), + // m_iCurrentThinkContext (not saved, debug field only, and think transient to boot) + + DEFINE_UTLVECTOR(m_ResponseContexts, FIELD_EMBEDDED), + DEFINE_KEYFIELD( m_iszResponseContext, FIELD_STRING, "ResponseContext" ), + + DEFINE_FIELD( m_pfnThink, FIELD_FUNCTION ), + DEFINE_FIELD( m_pfnTouch, FIELD_FUNCTION ), + DEFINE_FIELD( m_pfnUse, FIELD_FUNCTION ), + DEFINE_FIELD( m_pfnBlocked, FIELD_FUNCTION ), + DEFINE_FIELD( m_pfnMoveDone, FIELD_FUNCTION ), + + DEFINE_FIELD( m_lifeState, FIELD_CHARACTER ), + DEFINE_FIELD( m_takedamage, FIELD_CHARACTER ), + DEFINE_KEYFIELD( m_iMaxHealth, FIELD_INTEGER, "max_health" ), + DEFINE_KEYFIELD( m_iHealth, FIELD_INTEGER, "health" ), + // DEFINE_FIELD( m_pLink, FIELD_CLASSPTR ), + DEFINE_KEYFIELD( m_target, FIELD_STRING, "target" ), + + DEFINE_KEYFIELD( m_iszDamageFilterName, FIELD_STRING, "damagefilter" ), + DEFINE_FIELD( m_hDamageFilter, FIELD_EHANDLE ), + + DEFINE_FIELD( m_debugOverlays, FIELD_INTEGER ), + + DEFINE_GLOBAL_FIELD( m_pParent, FIELD_EHANDLE ), + DEFINE_FIELD( m_iParentAttachment, FIELD_CHARACTER ), + DEFINE_GLOBAL_FIELD( m_hMoveParent, FIELD_EHANDLE ), + DEFINE_GLOBAL_FIELD( m_hMoveChild, FIELD_EHANDLE ), + DEFINE_GLOBAL_FIELD( m_hMovePeer, FIELD_EHANDLE ), + + DEFINE_FIELD( m_iEFlags, FIELD_INTEGER ), + + DEFINE_FIELD( m_iName, FIELD_STRING ), + DEFINE_EMBEDDED( m_Collision ), + DEFINE_EMBEDDED( m_Network ), + + DEFINE_FIELD( m_MoveType, FIELD_CHARACTER ), + DEFINE_FIELD( m_MoveCollide, FIELD_CHARACTER ), + DEFINE_FIELD( m_hOwnerEntity, FIELD_EHANDLE ), + DEFINE_FIELD( m_CollisionGroup, FIELD_INTEGER ), + DEFINE_PHYSPTR( m_pPhysicsObject), + DEFINE_FIELD( m_flElasticity, FIELD_FLOAT ), + DEFINE_KEYFIELD( m_flShadowCastDistance, FIELD_FLOAT, "shadowcastdist" ), + DEFINE_FIELD( m_flDesiredShadowCastDistance, FIELD_FLOAT ), + + DEFINE_INPUT( m_iInitialTeamNum, FIELD_INTEGER, "TeamNum" ), + DEFINE_FIELD( m_iTeamNum, FIELD_INTEGER ), + +// DEFINE_FIELD( m_bSentLastFrame, FIELD_INTEGER ), + + DEFINE_FIELD( m_hGroundEntity, FIELD_EHANDLE ), + DEFINE_FIELD( m_flGroundChangeTime, FIELD_TIME ), + DEFINE_GLOBAL_KEYFIELD( m_ModelName, FIELD_MODELNAME, "model" ), + + DEFINE_KEYFIELD( m_vecBaseVelocity, FIELD_VECTOR, "basevelocity" ), + DEFINE_FIELD( m_vecAbsVelocity, FIELD_VECTOR ), + DEFINE_KEYFIELD( m_vecAngVelocity, FIELD_VECTOR, "avelocity" ), +// DEFINE_FIELD( m_vecAbsAngVelocity, FIELD_VECTOR ), + DEFINE_ARRAY( m_rgflCoordinateFrame, FIELD_FLOAT, 12 ), // NOTE: MUST BE IN LOCAL SPACE, NOT POSITION_VECTOR!!! (see CBaseEntity::Restore) + + DEFINE_KEYFIELD( m_nWaterLevel, FIELD_CHARACTER, "waterlevel" ), + DEFINE_FIELD( m_nWaterType, FIELD_CHARACTER ), + DEFINE_FIELD( m_pBlocker, FIELD_EHANDLE ), + + DEFINE_KEYFIELD( m_flGravity, FIELD_FLOAT, "gravity" ), + DEFINE_KEYFIELD( m_flFriction, FIELD_FLOAT, "friction" ), + + // Local time is local to each object. It doesn't need to be re-based if the clock + // changes. Therefore it is saved as a FIELD_FLOAT, not a FIELD_TIME + DEFINE_KEYFIELD( m_flLocalTime, FIELD_FLOAT, "ltime" ), + DEFINE_FIELD( m_flVPhysicsUpdateLocalTime, FIELD_FLOAT ), + DEFINE_FIELD( m_flMoveDoneTime, FIELD_FLOAT ), + +// DEFINE_FIELD( m_nPushEnumCount, FIELD_INTEGER ), + + DEFINE_FIELD( m_vecAbsOrigin, FIELD_POSITION_VECTOR ), + DEFINE_KEYFIELD( m_vecVelocity, FIELD_VECTOR, "velocity" ), + DEFINE_KEYFIELD( m_iTextureFrameIndex, FIELD_CHARACTER, "texframeindex" ), + DEFINE_FIELD( m_bSimulatedEveryTick, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bAnimatedEveryTick, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bAlternateSorting, FIELD_BOOLEAN ), + DEFINE_KEYFIELD( m_spawnflags, FIELD_INTEGER, "spawnflags" ), + DEFINE_FIELD( m_nTransmitStateOwnedCounter, FIELD_CHARACTER ), + DEFINE_FIELD( m_angAbsRotation, FIELD_VECTOR ), + DEFINE_FIELD( m_vecOrigin, FIELD_VECTOR ), // NOTE: MUST BE IN LOCAL SPACE, NOT POSITION_VECTOR!!! (see CBaseEntity::Restore) + DEFINE_FIELD( m_angRotation, FIELD_VECTOR ), + + DEFINE_KEYFIELD( m_vecViewOffset, FIELD_VECTOR, "view_ofs" ), + + DEFINE_FIELD( m_fFlags, FIELD_INTEGER ), +#if !defined( NO_ENTITY_PREDICTION ) +// DEFINE_FIELD( m_bIsPlayerSimulated, FIELD_INTEGER ), +// DEFINE_FIELD( m_hPlayerSimulationOwner, FIELD_EHANDLE ), +#endif + // DEFINE_FIELD( m_pTimedOverlay, TimedOverlay_t* ), + DEFINE_FIELD( m_nSimulationTick, FIELD_TICK ), + // DEFINE_FIELD( m_RefEHandle, CBaseHandle ), + +// DEFINE_FIELD( m_nWaterTouch, FIELD_INTEGER ), +// DEFINE_FIELD( m_nSlimeTouch, FIELD_INTEGER ), + DEFINE_FIELD( m_flNavIgnoreUntilTime, FIELD_TIME ), + +// DEFINE_FIELD( m_bToolRecording, FIELD_BOOLEAN ), +// DEFINE_FIELD( m_ToolHandle, FIELD_INTEGER ), + + // NOTE: This is tricky. TeamNum must be saved, but we can't directly + // read it in, because we can only set it after the team entity has been read in, + // which may or may not actually occur before the entity is parsed. + // Therefore, we set the TeamNum from the InitialTeamNum in Activate + DEFINE_INPUTFUNC( FIELD_INTEGER, "SetTeam", InputSetTeam ), + + DEFINE_INPUTFUNC( FIELD_VOID, "Kill", InputKill ), + DEFINE_INPUTFUNC( FIELD_VOID, "KillHierarchy", InputKillHierarchy ), + DEFINE_INPUTFUNC( FIELD_VOID, "Use", InputUse ), + DEFINE_INPUTFUNC( FIELD_INTEGER, "Alpha", InputAlpha ), + DEFINE_INPUTFUNC( FIELD_BOOLEAN, "AlternativeSorting", InputAlternativeSorting ), + DEFINE_INPUTFUNC( FIELD_COLOR32, "Color", InputColor ), + DEFINE_INPUTFUNC( FIELD_STRING, "SetParent", InputSetParent ), + DEFINE_INPUTFUNC( FIELD_STRING, "SetParentAttachment", InputSetParentAttachment ), + DEFINE_INPUTFUNC( FIELD_STRING, "SetParentAttachmentMaintainOffset", InputSetParentAttachmentMaintainOffset ), + DEFINE_INPUTFUNC( FIELD_VOID, "ClearParent", InputClearParent ), + DEFINE_INPUTFUNC( FIELD_STRING, "SetDamageFilter", InputSetDamageFilter ), + + DEFINE_INPUTFUNC( FIELD_VOID, "EnableDamageForces", InputEnableDamageForces ), + DEFINE_INPUTFUNC( FIELD_VOID, "DisableDamageForces", InputDisableDamageForces ), + + DEFINE_INPUTFUNC( FIELD_STRING, "DispatchEffect", InputDispatchEffect ), + DEFINE_INPUTFUNC( FIELD_STRING, "DispatchResponse", InputDispatchResponse ), + + // Entity I/O methods to alter context + DEFINE_INPUTFUNC( FIELD_STRING, "AddContext", InputAddContext ), + DEFINE_INPUTFUNC( FIELD_STRING, "RemoveContext", InputRemoveContext ), + DEFINE_INPUTFUNC( FIELD_STRING, "ClearContext", InputClearContext ), + + DEFINE_INPUTFUNC( FIELD_VOID, "DisableShadow", InputDisableShadow ), + DEFINE_INPUTFUNC( FIELD_VOID, "EnableShadow", InputEnableShadow ), + + DEFINE_INPUTFUNC( FIELD_STRING, "AddOutput", InputAddOutput ), + + DEFINE_INPUTFUNC( FIELD_STRING, "FireUser1", InputFireUser1 ), + DEFINE_INPUTFUNC( FIELD_STRING, "FireUser2", InputFireUser2 ), + DEFINE_INPUTFUNC( FIELD_STRING, "FireUser3", InputFireUser3 ), + DEFINE_INPUTFUNC( FIELD_STRING, "FireUser4", InputFireUser4 ), + + DEFINE_OUTPUT( m_OnUser1, "OnUser1" ), + DEFINE_OUTPUT( m_OnUser2, "OnUser2" ), + DEFINE_OUTPUT( m_OnUser3, "OnUser3" ), + DEFINE_OUTPUT( m_OnUser4, "OnUser4" ), + + // Function Pointers + DEFINE_FUNCTION( SUB_Remove ), + DEFINE_FUNCTION( SUB_DoNothing ), + DEFINE_FUNCTION( SUB_StartFadeOut ), + DEFINE_FUNCTION( SUB_StartFadeOutInstant ), + DEFINE_FUNCTION( SUB_FadeOut ), + DEFINE_FUNCTION( SUB_Vanish ), + DEFINE_FUNCTION( SUB_CallUseToggle ), + DEFINE_THINKFUNC( ShadowCastDistThink ), + + DEFINE_FIELD( m_hEffectEntity, FIELD_EHANDLE ), + + //DEFINE_FIELD( m_DamageModifiers, FIELD_?? ), // can't save? + // DEFINE_FIELD( m_fDataObjectTypes, FIELD_INTEGER ), + +#ifdef TF_DLL + DEFINE_ARRAY( m_nModelIndexOverrides, FIELD_INTEGER, MAX_VISION_MODES ), +#endif + +END_DATADESC() + +// For code error checking +extern bool g_bReceivedChainedUpdateOnRemove; + +//----------------------------------------------------------------------------- +// Purpose: Called just prior to object destruction +// Entities that need to unlink themselves from other entities should do the unlinking +// here rather than in their destructor. The reason why is that when the global entity list +// is told to Clear(), it first takes a pass through all active entities and calls UTIL_Remove +// on each such entity. Then it calls the delete function on each deleted entity in the list. +// In the old code, the objects were simply destroyed in order and there was no guarantee that the +// destructor of one object would not try to access another object that might already have been +// destructed (especially since the entity list order is more or less random!). +// NOTE: You should never call delete directly on an entity (there's an assert now), see note +// at CBaseEntity::~CBaseEntity for more information. +// +// NOTE: You should chain to BaseClass::UpdateOnRemove after doing your own cleanup code, e.g.: +// +// void CDerived::UpdateOnRemove( void ) +// { +// ... cleanup code +// ... +// +// BaseClass::UpdateOnRemove(); +// } +// +// In general, this function updates global tables that need to know about entities being removed +//----------------------------------------------------------------------------- +void CBaseEntity::UpdateOnRemove( void ) +{ + g_bReceivedChainedUpdateOnRemove = true; + + // Virtual call to shut down any looping sounds. + StopLoopingSounds(); + + // Notifies entity listeners, etc + gEntList.NotifyRemoveEntity( GetRefEHandle() ); + + if ( edict() ) + { + AddFlag( FL_KILLME ); + if ( GetFlags() & FL_GRAPHED ) + { + /* <> + // this entity was a LinkEnt in the world node graph, so we must remove it from + // the graph since we are removing it from the world. + for ( int i = 0 ; i < WorldGraph.m_cLinks ; i++ ) + { + if ( WorldGraph.m_pLinkPool [ i ].m_pLinkEnt == pev ) + { + // if this link has a link ent which is the same ent that is removing itself, remove it! + WorldGraph.m_pLinkPool [ i ].m_pLinkEnt = NULL; + } + } + */ + } + } + + if ( m_iGlobalname != NULL_STRING ) + { + // NOTE: During level shutdown the global list will suppress this + // it assumes your changing levels or the game will end + // causing the whole list to be flushed + GlobalEntity_SetState( m_iGlobalname, GLOBAL_DEAD ); + } + + VPhysicsDestroyObject(); + + // This is only here to allow the MOVETYPE_NONE to be set without the + // assertion triggering. Why do we bother setting the MOVETYPE to none here? + RemoveEffects( EF_BONEMERGE ); + SetMoveType(MOVETYPE_NONE); + + // If we have a parent, unlink from it. + UnlinkFromParent( this ); + + // Any children still connected are orphans, mark all for delete + CUtlVector childrenList; + GetAllChildren( this, childrenList ); + if ( childrenList.Count() ) + { + DevMsg( 2, "Warning: Deleting orphaned children of %s\n", GetClassname() ); + for ( int i = childrenList.Count()-1; i >= 0; --i ) + { + UTIL_Remove( childrenList[i] ); + } + } + + SetGroundEntity( NULL ); + + if ( m_bDynamicModelPending ) + { + sg_DynamicLoadHandlers.Remove( this ); + } + + if ( IsDynamicModelIndex( m_nModelIndex ) ) + { + modelinfo->ReleaseDynamicModel( m_nModelIndex ); // no-op if not dynamic + m_nModelIndex = -1; + } +} + +//----------------------------------------------------------------------------- +// capabilities +//----------------------------------------------------------------------------- +int CBaseEntity::ObjectCaps( void ) +{ +#if 1 + model_t *pModel = GetModel(); + bool bIsBrush = ( pModel && modelinfo->GetModelType( pModel ) == mod_brush ); + + // We inherit our parent's use capabilities so that we can forward use commands + // to our parent. + CBaseEntity *pParent = GetParent(); + if ( pParent ) + { + int caps = pParent->ObjectCaps(); + + if ( !bIsBrush ) + caps &= ( FCAP_ACROSS_TRANSITION | FCAP_IMPULSE_USE | FCAP_CONTINUOUS_USE | FCAP_ONOFF_USE | FCAP_DIRECTIONAL_USE ); + else + caps &= ( FCAP_IMPULSE_USE | FCAP_CONTINUOUS_USE | FCAP_ONOFF_USE | FCAP_DIRECTIONAL_USE ); + + if ( pParent->IsPlayer() ) + caps |= FCAP_ACROSS_TRANSITION; + + return caps; + } + else if ( !bIsBrush ) + { + return FCAP_ACROSS_TRANSITION; + } + + return 0; +#else + // We inherit our parent's use capabilities so that we can forward use commands + // to our parent. + int parentCaps = 0; + if (GetParent()) + { + parentCaps = GetParent()->ObjectCaps(); + parentCaps &= ( FCAP_IMPULSE_USE | FCAP_CONTINUOUS_USE | FCAP_ONOFF_USE | FCAP_DIRECTIONAL_USE ); + } + + model_t *pModel = GetModel(); + if ( pModel && modelinfo->GetModelType( pModel ) == mod_brush ) + return parentCaps; + + return FCAP_ACROSS_TRANSITION | parentCaps; +#endif +} + +void CBaseEntity::StartTouch( CBaseEntity *pOther ) +{ + // notify parent + if ( m_pParent != NULL ) + m_pParent->StartTouch( pOther ); +} + +void CBaseEntity::Touch( CBaseEntity *pOther ) +{ + if ( m_pfnTouch ) + (this->*m_pfnTouch)( pOther ); + + // notify parent of touch + if ( m_pParent != NULL ) + m_pParent->Touch( pOther ); +} + +void CBaseEntity::EndTouch( CBaseEntity *pOther ) +{ + // notify parent + if ( m_pParent != NULL ) + { + m_pParent->EndTouch( pOther ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Dispatches blocked events to this entity's blocked handler, set via SetBlocked. +// Input : pOther - The entity that is blocking us. +//----------------------------------------------------------------------------- +void CBaseEntity::Blocked( CBaseEntity *pOther ) +{ + if ( m_pfnBlocked ) + { + (this->*m_pfnBlocked)( pOther ); + } + + // + // Forward the blocked event to our parent, if any. + // + if ( m_pParent != NULL ) + { + m_pParent->Blocked( pOther ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Dispatches use events to this entity's use handler, set via SetUse. +// Input : pActivator - +// pCaller - +// useType - +// value - +//----------------------------------------------------------------------------- +void CBaseEntity::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) +{ + if ( m_pfnUse != NULL ) + { + (this->*m_pfnUse)( pActivator, pCaller, useType, value ); + } + else + { + // + // We don't handle use events. Forward to our parent, if any. + // + if ( m_pParent != NULL ) + { + m_pParent->Use( pActivator, pCaller, useType, value ); + } + } +} + +static CBaseEntity *FindPhysicsBlocker( IPhysicsObject *pPhysics, physicspushlist_t &list, const Vector &pushVel ) +{ + IPhysicsFrictionSnapshot *pSnapshot = pPhysics->CreateFrictionSnapshot(); + CBaseEntity *pBlocker = NULL; + float maxForce = 0; + while ( pSnapshot->IsValid() ) + { + IPhysicsObject *pOther = pSnapshot->GetObject(1); + CBaseEntity *pOtherEntity = static_cast(pOther->GetGameData()); + bool inList = false; + for ( int i = 0; i < list.pushedCount; i++ ) + { + if ( pOtherEntity == list.pushedEnts[i] ) + { + inList = true; + break; + } + } + + Vector normal; + pSnapshot->GetSurfaceNormal(normal); + float dot = DotProduct( pushVel, pSnapshot->GetNormalForce() * normal ); + if ( !pBlocker || (!inList && dot > maxForce) ) + { + pBlocker = pOtherEntity; + if ( !inList ) + { + maxForce = dot; + } + } + + pSnapshot->NextFrictionData(); + } + pPhysics->DestroyFrictionSnapshot( pSnapshot ); + + return pBlocker; +} + + +struct pushblock_t +{ + physicspushlist_t *pList; + CBaseEntity *pRootParent; + CBaseEntity *pBlockedEntity; + float moveBackFraction; + float movetime; +}; + +static void ComputePushStartMatrix( matrix3x4_t &start, CBaseEntity *pEntity, const pushblock_t ¶ms ) +{ + Vector localOrigin; + QAngle localAngles; + if ( params.pList ) + { + localOrigin = params.pList->localOrigin; + localAngles = params.pList->localAngles; + } + else + { + localOrigin = params.pRootParent->GetAbsOrigin() - params.pRootParent->GetAbsVelocity() * params.movetime; + localAngles = params.pRootParent->GetAbsAngles() - params.pRootParent->GetLocalAngularVelocity() * params.movetime; + } + matrix3x4_t xform, delta; + AngleMatrix( localAngles, localOrigin, xform ); + + matrix3x4_t srcInv; + // xform = src(-1) * dest + MatrixInvert( params.pRootParent->EntityToWorldTransform(), srcInv ); + ConcatTransforms( xform, srcInv, delta ); + ConcatTransforms( delta, pEntity->EntityToWorldTransform(), start ); +} + +#define DEBUG_PUSH_MESSAGES 0 +static void CheckPushedEntity( CBaseEntity *pEntity, pushblock_t ¶ms ) +{ + IPhysicsObject *pPhysics = pEntity->VPhysicsGetObject(); + if ( !pPhysics ) + return; + // somehow we've got a static or motion disabled physics object in hierarchy! + // This is not allowed! Don't test blocking in that case. + Assert(pPhysics->IsMoveable()); + if ( !pPhysics->IsMoveable() || !pPhysics->GetShadowController() ) + { +#if DEBUG_PUSH_MESSAGES + Msg("Blocking %s, not moveable!\n", pEntity->GetClassname()); +#endif + return; + } + + bool checkrot = true; + bool checkmove = true; + Vector origin; + QAngle angles; + pPhysics->GetShadowPosition( &origin, &angles ); + float fraction = -1.0f; + + matrix3x4_t parentDelta; + if ( pEntity == params.pRootParent ) + { + if ( pEntity->GetLocalAngularVelocity() == vec3_angle ) + checkrot = false; + if ( pEntity->GetLocalVelocity() == vec3_origin) + checkmove = false; + } + else + { +#if DEBUG_PUSH_MESSAGES + if ( pPhysics->IsAttachedToConstraint(false)) + { + Msg("Warning, hierarchical entity is attached to a constraint %s\n", pEntity->GetClassname()); + } +#endif + } + + if ( checkmove ) + { + // project error onto the axis of movement + Vector dir = pEntity->GetAbsVelocity(); + float speed = VectorNormalize(dir); + Vector targetPos; + pPhysics->GetShadowController()->GetTargetPosition( &targetPos, NULL ); + float targetAmount = DotProduct(targetPos, dir); + float currentAmount = DotProduct(origin, dir); + float entityAmount = DotProduct(pEntity->GetAbsOrigin(), dir); + + // if target and entity origin are not in sync, then the position of the entity was updated + // by something outside of push physics + if ( (targetAmount - entityAmount) > 1 ) + { + pEntity->UpdatePhysicsShadowToCurrentPosition(0); +#if DEBUG_PUSH_MESSAGES + Warning("Someone slammed the position of a %s\n", pEntity->GetClassname() ); +#endif + } + else + { + float dist = targetAmount - currentAmount; + if ( dist > 1 ) + { + #if DEBUG_PUSH_MESSAGES + const char *pName = pEntity->GetClassname(); + Msg( "%s blocked by %.2f units\n", pName, dist ); + #endif + float movementAmount = targetAmount - (speed * params.movetime); + if ( pEntity == params.pRootParent ) + { + if ( params.pList ) + { + Vector localVel = pEntity->GetLocalVelocity(); + VectorNormalize(localVel); + float localTargetAmt = DotProduct(pEntity->GetLocalOrigin(), localVel); + movementAmount = targetAmount + DotProduct(params.pList->localOrigin, localVel) - localTargetAmt; + } + } + else + { + matrix3x4_t start; + ComputePushStartMatrix( start, pEntity, params ); + Vector startPos; + MatrixPosition( start, startPos ); + movementAmount = DotProduct(startPos, dir); + } + float expectedDist = targetAmount - movementAmount; + // compute the fraction to move back the AI to match the physics + if ( expectedDist <= 0 ) + { + fraction = 1; + } + else + { + fraction = dist / expectedDist; + fraction = clamp(fraction, 0.f, 1.f); + } + } + } + } + + if ( checkrot ) + { + Vector axis; + float deltaAngle; + RotationDeltaAxisAngle( angles, pEntity->GetAbsAngles(), axis, deltaAngle ); + if ( fabsf(deltaAngle) > 0.5f ) + { + Vector targetAxis; + QAngle targetRot; + float deltaTargetAngle; + pPhysics->GetShadowController()->GetTargetPosition( NULL, &targetRot ); + RotationDeltaAxisAngle( angles, targetRot, targetAxis, deltaTargetAngle ); + if ( fabsf(deltaTargetAngle) > 0.01f ) + { + float expectedDist = deltaAngle; +#if DEBUG_PUSH_MESSAGES + const char *pName = pEntity->GetClassname(); + Msg( "%s blocked by %.2f degrees\n", pName, deltaAngle ); + if ( pPhysics->IsAsleep() ) + { + Msg("Asleep while blocked?\n"); + } + if ( pPhysics->GetGameFlags() & FVPHYSICS_PENETRATING ) + { + Msg("Blocking for penetration!\n"); + } +#endif + if ( pEntity == params.pRootParent ) + { + expectedDist = pEntity->GetLocalAngularVelocity().Length() * params.movetime; + } + else + { + matrix3x4_t start; + ComputePushStartMatrix( start, pEntity, params ); + Vector startAxis; + float startAngle; + Vector startPos; + QAngle startAngles; + MatrixAngles( start, startAngles, startPos ); + RotationDeltaAxisAngle( startAngles, pEntity->GetAbsAngles(), startAxis, startAngle ); + expectedDist = startAngle * DotProduct( startAxis, axis ); + } + + float t = expectedDist != 0.0f ? fabsf(deltaAngle / expectedDist) : 1.0f; + t = clamp(t,0.f,1.f); + fraction = MAX(fraction, t); + } + else + { + pEntity->UpdatePhysicsShadowToCurrentPosition(0); +#if DEBUG_PUSH_MESSAGES + Warning("Someone slammed the position of a %s\n", pEntity->GetClassname() ); +#endif + } + } + } + if ( fraction >= params.moveBackFraction ) + { + params.moveBackFraction = fraction; + params.pBlockedEntity = pEntity; + } +} + +void CBaseEntity::VPhysicsUpdatePusher( IPhysicsObject *pPhysics ) +{ + float movetime = m_flLocalTime - m_flVPhysicsUpdateLocalTime; + if (movetime <= 0) + return; + + // only reconcile pushers on the final vphysics tick + if ( !PhysIsFinalTick() ) + return; + + Vector origin; + QAngle angles; + + // physics updated the shadow, so check to see if I got blocked + // NOTE: SOLID_BSP cannont compute consistent collisions wrt vphysics, so + // don't allow vphysics to block. Assume game physics has handled it. + if ( GetSolid() != SOLID_BSP && pPhysics->GetShadowPosition( &origin, &angles ) ) + { + CUtlVector list; + GetAllInHierarchy( this, list ); + //NDebugOverlay::BoxAngles( origin, CollisionProp()->OBBMins(), CollisionProp()->OBBMaxs(), angles, 255,0,0,0, gpGlobals->frametime); + + physicspushlist_t *pList = NULL; + if ( HasDataObjectType(PHYSICSPUSHLIST) ) + { + pList = (physicspushlist_t *)GetDataObject( PHYSICSPUSHLIST ); + Assert(pList); + } + bool checkrot = (GetLocalAngularVelocity() != vec3_angle) ? true : false; + bool checkmove = (GetLocalVelocity() != vec3_origin) ? true : false; + + pushblock_t params; + params.pRootParent = this; + params.pList = pList; + params.pBlockedEntity = NULL; + params.moveBackFraction = 0.0f; + params.movetime = movetime; + for ( int i = 0; i < list.Count(); i++ ) + { + if ( list[i]->IsSolid() ) + { + CheckPushedEntity( list[i], params ); + } + } + + float physLocalTime = m_flLocalTime; + if ( params.pBlockedEntity ) + { + float moveback = movetime * params.moveBackFraction; + if ( moveback > 0 ) + { + physLocalTime = m_flLocalTime - moveback; + // add 1% noise for bouncing in collision. + if ( physLocalTime <= (m_flVPhysicsUpdateLocalTime + movetime * 0.99f) ) + { + CBaseEntity *pBlocked = NULL; + IPhysicsObject *pOther; + if ( params.pBlockedEntity->VPhysicsGetObject()->GetContactPoint( NULL, &pOther ) ) + { + pBlocked = static_cast(pOther->GetGameData()); + } + // UNDONE: Need to traverse hierarchy here? Shouldn't. + if ( pList ) + { + SetLocalOrigin( pList->localOrigin ); + SetLocalAngles( pList->localAngles ); + physLocalTime = pList->localMoveTime; + for ( int i = 0; i < pList->pushedCount; i++ ) + { + CBaseEntity *pEntity = pList->pushedEnts[i]; + if ( !pEntity ) + continue; + + pEntity->SetAbsOrigin( pEntity->GetAbsOrigin() - pList->pushVec[i] ); + } + CBaseEntity *pPhysicsBlocker = FindPhysicsBlocker( VPhysicsGetObject(), *pList, pList->pushVec[0] ); + if ( pPhysicsBlocker ) + { + pBlocked = pPhysicsBlocker; + } + } + else + { + Vector origin = GetLocalOrigin(); + QAngle angles = GetLocalAngles(); + + if ( checkmove ) + { + origin -= GetLocalVelocity() * moveback; + } + if ( checkrot ) + { + // BUGBUG: This is pretty hack-tastic! + angles -= GetLocalAngularVelocity() * moveback; + } + + SetLocalOrigin( origin ); + SetLocalAngles( angles ); + } + + if ( pBlocked ) + { + Blocked( pBlocked ); + } + m_flLocalTime = physLocalTime; + } + } + } + } + + // this data is no longer useful, free the memory + if ( HasDataObjectType(PHYSICSPUSHLIST) ) + { + DestroyDataObject( PHYSICSPUSHLIST ); + } + + m_flVPhysicsUpdateLocalTime = m_flLocalTime; + if ( m_flMoveDoneTime <= m_flLocalTime && m_flMoveDoneTime > 0 ) + { + SetMoveDoneTime( -1 ); + MoveDone(); + } +} + + +void CBaseEntity::SetMoveDoneTime( float flDelay ) +{ + if (flDelay >= 0) + { + m_flMoveDoneTime = GetLocalTime() + flDelay; + } + else + { + m_flMoveDoneTime = -1; + } + CheckHasGamePhysicsSimulation(); +} + +//----------------------------------------------------------------------------- +// Purpose: Relinks all of a parents children into the collision tree +//----------------------------------------------------------------------------- +void CBaseEntity::PhysicsRelinkChildren( float dt ) +{ + CBaseEntity *child; + + // iterate through all children + for ( child = FirstMoveChild(); child != NULL; child = child->NextMovePeer() ) + { + if ( child->IsSolid() || child->IsSolidFlagSet(FSOLID_TRIGGER) ) + { + child->PhysicsTouchTriggers(); + } + + // + // Update their physics shadows. We should never have any children of + // movetype VPHYSICS. + // + if ( child->GetMoveType() != MOVETYPE_VPHYSICS ) + { + child->UpdatePhysicsShadowToCurrentPosition( dt ); + } + else if ( child->GetOwnerEntity() != this ) + { + // the only case where this is valid is if this entity is an attached ragdoll. + // So assert here to catch the non-ragdoll case. + Assert( 0 ); + } + + if ( child->FirstMoveChild() ) + { + child->PhysicsRelinkChildren(dt); + } + } +} + +void CBaseEntity::PhysicsTouchTriggers( const Vector *pPrevAbsOrigin ) +{ + edict_t *pEdict = edict(); + if ( pEdict && !IsWorld() ) + { + Assert(CollisionProp()); + bool isTriggerCheckSolids = IsSolidFlagSet( FSOLID_TRIGGER ); + bool isSolidCheckTriggers = IsSolid() && !isTriggerCheckSolids; // NOTE: Moving triggers (items, ammo etc) are not + // checked against other triggers to reduce the number of touchlinks created + if ( !(isSolidCheckTriggers || isTriggerCheckSolids) ) + return; + + if ( GetSolid() == SOLID_BSP ) + { + if ( !GetModel() && Q_strlen( STRING( GetModelName() ) ) == 0 ) + { + Warning( "Inserted %s with no model\n", GetClassname() ); + return; + } + } + + SetCheckUntouch( true ); + if ( isSolidCheckTriggers ) + { + engine->SolidMoved( pEdict, CollisionProp(), pPrevAbsOrigin, sm_bAccurateTriggerBboxChecks ); + } + if ( isTriggerCheckSolids ) + { + engine->TriggerMoved( pEdict, sm_bAccurateTriggerBboxChecks ); + } + } +} + +void CBaseEntity::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent ) +{ +} + + + +void CBaseEntity::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ) +{ + // filter out ragdoll props hitting other parts of itself too often + // UNDONE: Store a sound time for this entity (not just this pair of objects) + // and filter repeats on that? + int otherIndex = !index; + CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex]; + + // Don't make sounds / effects if neither entity is MOVETYPE_VPHYSICS. The game + // physics should have done so. + if ( GetMoveType() != MOVETYPE_VPHYSICS && pHitEntity->GetMoveType() != MOVETYPE_VPHYSICS ) + return; + + if ( pEvent->deltaCollisionTime < 0.5 && (pHitEntity == this) ) + return; + + // don't make noise for hidden/invisible/sky materials + surfacedata_t *phit = physprops->GetSurfaceData( pEvent->surfaceProps[otherIndex] ); + const surfacedata_t *pprops = physprops->GetSurfaceData( pEvent->surfaceProps[index] ); + if ( phit->game.material == 'X' || pprops->game.material == 'X' ) + return; + + if ( pHitEntity == this ) + { + PhysCollisionSound( this, pEvent->pObjects[index], CHAN_BODY, pEvent->surfaceProps[index], pEvent->surfaceProps[otherIndex], pEvent->deltaCollisionTime, pEvent->collisionSpeed ); + } + else + { + PhysCollisionSound( this, pEvent->pObjects[index], CHAN_STATIC, pEvent->surfaceProps[index], pEvent->surfaceProps[otherIndex], pEvent->deltaCollisionTime, pEvent->collisionSpeed ); + } + PhysCollisionScreenShake( pEvent, index ); + +#if HL2_EPISODIC + // episodic does something different for when advisor shields are struck + if ( phit->game.material == 'Z' || pprops->game.material == 'Z') + { + PhysCollisionWarpEffect( pEvent, phit ); + } + else + { + PhysCollisionDust( pEvent, phit ); + } +#else + PhysCollisionDust( pEvent, phit ); +#endif +} + +void CBaseEntity::VPhysicsFriction( IPhysicsObject *pObject, float energy, int surfaceProps, int surfacePropsHit ) +{ + PhysFrictionSound( this, pObject, energy, surfaceProps, surfacePropsHit ); +} + + +void CBaseEntity::VPhysicsSwapObject( IPhysicsObject *pSwap ) +{ + if ( !pSwap ) + { + PhysRemoveShadow(this); + } + + if ( !m_pPhysicsObject ) + { + Warning( "Bad vphysics swap for %s\n", STRING(m_iClassname) ); + } + m_pPhysicsObject = pSwap; +} + + +// Tells the physics shadow to update it's target to the current position +void CBaseEntity::UpdatePhysicsShadowToCurrentPosition( float deltaTime ) +{ + if ( GetMoveType() != MOVETYPE_VPHYSICS ) + { + IPhysicsObject *pPhys = VPhysicsGetObject(); + if ( pPhys ) + { + pPhys->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, deltaTime ); + } + } +} + +int CBaseEntity::VPhysicsGetObjectList( IPhysicsObject **pList, int listMax ) +{ + IPhysicsObject *pPhys = VPhysicsGetObject(); + if ( pPhys ) + { + // multi-object entities must implement this function + Assert( !(pPhys->GetGameFlags() & FVPHYSICS_MULTIOBJECT_ENTITY) ); + if ( listMax > 0 ) + { + pList[0] = pPhys; + return 1; + } + } + return 0; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +bool CBaseEntity::VPhysicsIsFlesh( void ) +{ + IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT]; + int count = VPhysicsGetObjectList( pList, ARRAYSIZE(pList) ); + for ( int i = 0; i < count; i++ ) + { + int material = pList[i]->GetMaterialIndex(); + const surfacedata_t *pSurfaceData = physprops->GetSurfaceData( material ); + // Is flesh ?, don't allow pickup + if ( pSurfaceData->game.material == CHAR_TEX_ANTLION || pSurfaceData->game.material == CHAR_TEX_FLESH || pSurfaceData->game.material == CHAR_TEX_BLOODYFLESH || pSurfaceData->game.material == CHAR_TEX_ALIENFLESH ) + return true; + } + return false; +} + +bool CBaseEntity::Intersects( CBaseEntity *pOther ) +{ + if ( !edict() || !pOther->edict() ) + return false; + + CCollisionProperty *pMyProp = CollisionProp(); + CCollisionProperty *pOtherProp = pOther->CollisionProp(); + + return IsOBBIntersectingOBB( + pMyProp->GetCollisionOrigin(), pMyProp->GetCollisionAngles(), pMyProp->OBBMins(), pMyProp->OBBMaxs(), + pOtherProp->GetCollisionOrigin(), pOtherProp->GetCollisionAngles(), pOtherProp->OBBMins(), pOtherProp->OBBMaxs() ); +} + +extern ConVar ai_LOS_mode; + +//========================================================= +// FVisible - returns true if a line can be traced from +// the caller's eyes to the target +//========================================================= +bool CBaseEntity::FVisible( CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker ) +{ + VPROF( "CBaseEntity::FVisible" ); + + if ( pEntity->GetFlags() & FL_NOTARGET ) + return false; + +#if HL1_DLL + // FIXME: only block LOS through opaque water + // don't look through water + if ((m_nWaterLevel != 3 && pEntity->m_nWaterLevel == 3) + || (m_nWaterLevel == 3 && pEntity->m_nWaterLevel == 0)) + return false; +#endif + + Vector vecLookerOrigin = EyePosition();//look through the caller's 'eyes' + Vector vecTargetOrigin = pEntity->EyePosition(); + + trace_t tr; + if ( !IsXbox() && ai_LOS_mode.GetBool() ) + { + UTIL_TraceLine(vecLookerOrigin, vecTargetOrigin, traceMask, this, COLLISION_GROUP_NONE, &tr); + } + else + { + // If we're doing an LOS search, include NPCs. + if ( traceMask == MASK_BLOCKLOS ) + { + traceMask = MASK_BLOCKLOS_AND_NPCS; + } + + // Player sees through nodraw + if ( IsPlayer() ) + { + traceMask &= ~CONTENTS_BLOCKLOS; + } + + // Use the custom LOS trace filter + CTraceFilterLOS traceFilter( this, COLLISION_GROUP_NONE, pEntity ); + UTIL_TraceLine( vecLookerOrigin, vecTargetOrigin, traceMask, &traceFilter, &tr ); + } + + if (tr.fraction != 1.0 || tr.startsolid ) + { + // If we hit the entity we're looking for, it's visible + if ( tr.m_pEnt == pEntity ) + return true; + + // Got line of sight on the vehicle the player is driving! + if ( pEntity && pEntity->IsPlayer() ) + { + CBasePlayer *pPlayer = assert_cast( pEntity ); + if ( tr.m_pEnt == pPlayer->GetVehicleEntity() ) + return true; + } + + if (ppBlocker) + { + *ppBlocker = tr.m_pEnt; + } + + return false;// Line of sight is not established + } + + return true;// line of sight is valid. +} + +//========================================================= +// FVisible - returns true if a line can be traced from +// the caller's eyes to the wished position. +//========================================================= +bool CBaseEntity::FVisible( const Vector &vecTarget, int traceMask, CBaseEntity **ppBlocker ) +{ +#if HL1_DLL + + // don't look through water + // FIXME: only block LOS through opaque water + bool inWater = ( UTIL_PointContents( vecTarget ) & (CONTENTS_SLIME|CONTENTS_WATER) ) ? true : false; + + // Don't allow it if we're straddling two areas + if ( ( m_nWaterLevel == 3 && !inWater ) || ( m_nWaterLevel != 3 && inWater ) ) + return false; + +#endif + + trace_t tr; + Vector vecLookerOrigin = EyePosition();// look through the caller's 'eyes' + + if ( ai_LOS_mode.GetBool() ) + { + UTIL_TraceLine( vecLookerOrigin, vecTarget, traceMask, this, COLLISION_GROUP_NONE, &tr); + } + else + { + // If we're doing an LOS search, include NPCs. + if ( traceMask == MASK_BLOCKLOS ) + { + traceMask = MASK_BLOCKLOS_AND_NPCS; + } + + // Player sees through nodraw and blocklos + if ( IsPlayer() ) + { + traceMask |= CONTENTS_IGNORE_NODRAW_OPAQUE; + traceMask &= ~CONTENTS_BLOCKLOS; + } + + // Use the custom LOS trace filter + CTraceFilterLOS traceFilter( this, COLLISION_GROUP_NONE ); + UTIL_TraceLine( vecLookerOrigin, vecTarget, traceMask, &traceFilter, &tr ); + } + + if (tr.fraction != 1.0) + { + if (ppBlocker) + { + *ppBlocker = tr.m_pEnt; + } + return false;// Line of sight is not established + } + + return true;// line of sight is valid. +} + +extern ConVar ai_debug_los; +//----------------------------------------------------------------------------- +// Purpose: Turn on prop LOS debugging mode +//----------------------------------------------------------------------------- +void CC_AI_LOS_Debug( IConVar *var, const char *pOldString, float flOldValue ) +{ + int iLOSMode = ai_debug_los.GetInt(); + for ( CBaseEntity *pEntity = gEntList.FirstEnt(); pEntity != NULL; pEntity = gEntList.NextEnt(pEntity) ) + { + if ( iLOSMode == 1 && pEntity->IsSolid() ) + { + pEntity->m_debugOverlays |= OVERLAY_SHOW_BLOCKSLOS; + } + else if ( iLOSMode == 2 ) + { + pEntity->m_debugOverlays |= OVERLAY_SHOW_BLOCKSLOS; + } + else + { + pEntity->m_debugOverlays &= ~OVERLAY_SHOW_BLOCKSLOS; + } + } +} +ConVar ai_debug_los("ai_debug_los", "0", FCVAR_CHEAT, "NPC Line-Of-Sight debug mode. If 1, solid entities that block NPC LOC will be highlighted with white bounding boxes. If 2, it'll show non-solid entities that would do it if they were solid.", CC_AI_LOS_Debug ); + + +Class_T CBaseEntity::Classify ( void ) +{ + return CLASS_NONE; +} + +float CBaseEntity::GetAutoAimRadius() +{ + if( g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE ) + return 48.0f; + else + return 24.0f; +} + +//----------------------------------------------------------------------------- +// Changes the shadow cast distance over time +//----------------------------------------------------------------------------- +void CBaseEntity::ShadowCastDistThink( ) +{ + SetShadowCastDistance( m_flDesiredShadowCastDistance ); + SetContextThink( NULL, gpGlobals->curtime, "ShadowCastDistThink" ); +} + +void CBaseEntity::SetShadowCastDistance( float flDesiredDistance, float flDelay ) +{ + m_flDesiredShadowCastDistance = flDesiredDistance; + if ( m_flDesiredShadowCastDistance != m_flShadowCastDistance ) + { + SetContextThink( &CBaseEntity::ShadowCastDistThink, gpGlobals->curtime + flDelay, "ShadowCastDistThink" ); + } +} + + +/* +================ +TraceAttack +================ +*/ + +//----------------------------------------------------------------------------- +// Purpose: Returns whether a damage info can damage this entity. +//----------------------------------------------------------------------------- +bool CBaseEntity::PassesDamageFilter( const CTakeDamageInfo &info ) +{ + if (m_hDamageFilter) + { + CBaseFilter *pFilter = (CBaseFilter *)(m_hDamageFilter.Get()); + return pFilter->PassesDamageFilter(info); + } + + return true; +} + +FORCEINLINE bool NamesMatch( const char *pszQuery, string_t nameToMatch ) +{ + if ( nameToMatch == NULL_STRING ) + return (!pszQuery || *pszQuery == 0 || *pszQuery == '*'); + + const char *pszNameToMatch = STRING(nameToMatch); + + // If the pointers are identical, we're identical + if ( pszNameToMatch == pszQuery ) + return true; + + while ( *pszNameToMatch && *pszQuery ) + { + unsigned char cName = *pszNameToMatch; + unsigned char cQuery = *pszQuery; + // simple ascii case conversion + if ( cName == cQuery ) + ; + else if ( cName - 'A' <= (unsigned char)'Z' - 'A' && cName - 'A' + 'a' == cQuery ) + ; + else if ( cName - 'a' <= (unsigned char)'z' - 'a' && cName - 'a' + 'A' == cQuery ) + ; + else + break; + ++pszNameToMatch; + ++pszQuery; + } + + if ( *pszQuery == 0 && *pszNameToMatch == 0 ) + return true; + + // @TODO (toml 03-18-03): Perhaps support real wildcards. Right now, only thing supported is trailing * + if ( *pszQuery == '*' ) + return true; + + return false; +} + +bool CBaseEntity::NameMatchesComplex( const char *pszNameOrWildcard ) +{ + if ( !Q_stricmp( "!player", pszNameOrWildcard) ) + return IsPlayer(); + + return NamesMatch( pszNameOrWildcard, m_iName ); +} + +bool CBaseEntity::ClassMatchesComplex( const char *pszClassOrWildcard ) +{ + return NamesMatch( pszClassOrWildcard, m_iClassname ); +} + +void CBaseEntity::MakeDormant( void ) +{ + AddEFlags( EFL_DORMANT ); + + // disable thinking for dormant entities + SetThink( NULL ); + + if ( !edict() ) + return; + + SETBITS( m_iEFlags, EFL_DORMANT ); + + // Don't touch + AddSolidFlags( FSOLID_NOT_SOLID ); + // Don't move + SetMoveType( MOVETYPE_NONE ); + // Don't draw + AddEffects( EF_NODRAW ); + // Don't think + SetNextThink( TICK_NEVER_THINK ); +} + +int CBaseEntity::IsDormant( void ) +{ + return IsEFlagSet( EFL_DORMANT ); +} + + +bool CBaseEntity::IsInWorld( void ) const +{ + if ( !edict() ) + return true; + + // position + if (GetAbsOrigin().x >= MAX_COORD_INTEGER) return false; + if (GetAbsOrigin().y >= MAX_COORD_INTEGER) return false; + if (GetAbsOrigin().z >= MAX_COORD_INTEGER) return false; + if (GetAbsOrigin().x <= MIN_COORD_INTEGER) return false; + if (GetAbsOrigin().y <= MIN_COORD_INTEGER) return false; + if (GetAbsOrigin().z <= MIN_COORD_INTEGER) return false; + // speed + if (GetAbsVelocity().x >= 2000) return false; + if (GetAbsVelocity().y >= 2000) return false; + if (GetAbsVelocity().z >= 2000) return false; + if (GetAbsVelocity().x <= -2000) return false; + if (GetAbsVelocity().y <= -2000) return false; + if (GetAbsVelocity().z <= -2000) return false; + + return true; +} + + +bool CBaseEntity::IsViewable( void ) +{ + if ( IsEffectActive( EF_NODRAW ) ) + { + return false; + } + + if (IsBSPModel()) + { + if (GetMoveType() != MOVETYPE_NONE) + { + return true; + } + } + else if (GetModelIndex() != 0) + { + // check for total transparency??? + return true; + } + return false; +} + + +int CBaseEntity::ShouldToggle( USE_TYPE useType, int currentState ) +{ + if ( useType != USE_TOGGLE && useType != USE_SET ) + { + if ( (currentState && useType == USE_ON) || (!currentState && useType == USE_OFF) ) + return 0; + } + return 1; +} + + +// NOTE: szName must be a pointer to constant memory, e.g. "NPC_class" because the entity +// will keep a pointer to it after this call. +CBaseEntity *CBaseEntity::Create( const char *szName, const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner ) +{ + CBaseEntity *pEntity = CreateNoSpawn( szName, vecOrigin, vecAngles, pOwner ); + + DispatchSpawn( pEntity ); + return pEntity; +} + + + +// NOTE: szName must be a pointer to constant memory, e.g. "NPC_class" because the entity +// will keep a pointer to it after this call. +CBaseEntity * CBaseEntity::CreateNoSpawn( const char *szName, const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner ) +{ + CBaseEntity *pEntity = CreateEntityByName( szName ); + if ( !pEntity ) + { + Assert( !"CreateNoSpawn: only works for CBaseEntities" ); + return NULL; + } + + pEntity->SetLocalOrigin( vecOrigin ); + pEntity->SetLocalAngles( vecAngles ); + pEntity->SetOwnerEntity( pOwner ); + + gEntList.NotifyCreateEntity( pEntity ); + + return pEntity; +} + +Vector CBaseEntity::GetSoundEmissionOrigin() const +{ + return WorldSpaceCenter(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Saves the current object out to disk, by iterating through the objects +// data description hierarchy +// Input : &save - save buffer which the class data is written to +// Output : int - 0 if the save failed, 1 on success +//----------------------------------------------------------------------------- +int CBaseEntity::Save( ISave &save ) +{ + // loop through the data description list, saving each data desc block + int status = SaveDataDescBlock( save, GetDataDescMap() ); + + return status; +} + +//----------------------------------------------------------------------------- +// Purpose: Recursively saves all the classes in an object, in reverse order (top down) +// Output : int 0 on failure, 1 on success +//----------------------------------------------------------------------------- +int CBaseEntity::SaveDataDescBlock( ISave &save, datamap_t *dmap ) +{ + return save.WriteAll( this, dmap ); +} + +//----------------------------------------------------------------------------- +// Purpose: Restores the current object from disk, by iterating through the objects +// data description hierarchy +// Input : &restore - restore buffer which the class data is read from +// Output : int - 0 if the restore failed, 1 on success +//----------------------------------------------------------------------------- +int CBaseEntity::Restore( IRestore &restore ) +{ + // This is essential to getting the spatial partition info correct + CollisionProp()->DestroyPartitionHandle(); + + // loops through the data description list, restoring each data desc block in order + int status = RestoreDataDescBlock( restore, GetDataDescMap() ); + + // --------------------------------------------------------------- + // HACKHACK: We don't know the space of these vectors until now + // if they are worldspace, fix them up. + // --------------------------------------------------------------- + { + CGameSaveRestoreInfo *pGameInfo = restore.GetGameSaveRestoreInfo(); + Vector parentSpaceOffset = pGameInfo->modelSpaceOffset; + if ( !GetParent() ) + { + // parent is the world, so parent space is worldspace + // so update with the worldspace leveltransition transform + parentSpaceOffset += pGameInfo->GetLandmark(); + } + + // NOTE: Do *not* use GetAbsOrigin() here because it will + // try to recompute m_rgflCoordinateFrame! + MatrixSetColumn( m_vecAbsOrigin, 3, m_rgflCoordinateFrame ); + + m_vecOrigin += parentSpaceOffset; + } + + // Gotta do this after the coordframe is set up as it depends on it. + + // By definition, the surrounding bounds are dirty + // Also, twiddling with the flags here ensures it gets added to the KD tree dirty list + // (We don't want to use the saved version of this flag) + RemoveEFlags( EFL_DIRTY_SPATIAL_PARTITION ); + CollisionProp()->MarkSurroundingBoundsDirty(); + + if ( edict() && GetModelIndex() != 0 && GetModelName() != NULL_STRING && restore.GetPrecacheMode() ) + { + PrecacheModel( STRING( GetModelName() ) ); + + //Adrian: We should only need to do this after we precache. No point in setting the model again. + SetModelIndex( modelinfo->GetModelIndex( STRING(GetModelName() ) ) ); + } + + // Restablish ground entity + if ( m_hGroundEntity != NULL ) + { + m_hGroundEntity->AddEntityToGroundList( this ); + } + + return status; +} + + +//----------------------------------------------------------------------------- +// handler to do stuff before you are saved +//----------------------------------------------------------------------------- +void CBaseEntity::OnSave( IEntitySaveUtils *pUtils ) +{ + // Here, we must force recomputation of all abs data so it gets saved correctly + // We can't leave the dirty bits set because the loader can't cope with it. + CalcAbsolutePosition(); + CalcAbsoluteVelocity(); +} + +//----------------------------------------------------------------------------- +// handler to do stuff after you are restored +//----------------------------------------------------------------------------- +void CBaseEntity::OnRestore() +{ +#if defined( PORTAL ) || defined( HL2_EPISODIC ) || defined ( HL2_DLL ) || defined( HL2_LOSTCOAST ) + // We had a short period during the 2013 beta where the FL_* flags had a bogus value near the top, so detect + // these bad saves and just give up. Only saves from the short beta period should have been effected. + if ( GetFlags() & FL_FAKECLIENT ) + { + char szMsg[256]; + V_snprintf( szMsg, sizeof(szMsg), "\nInvalid save, unable to load. Please run \"map %s\" to restart this level manually\n\n", gpGlobals->mapname.ToCStr() ); + Msg( "%s", szMsg ); + + engine->ServerCommand("wait;wait;disconnect;showconsole\n"); + } +#endif + + SimThink_EntityChanged( this ); + + // touchlinks get recomputed + if ( IsEFlagSet( EFL_CHECK_UNTOUCH ) ) + { + RemoveEFlags( EFL_CHECK_UNTOUCH ); + SetCheckUntouch( true ); + } + + // disable touch functions while we recreate the touch links between entities + // NOTE: We don't do this on transitions, because we'd miss the OnStartTouch call! +#if !defined(HL2_DLL) || ( defined(HL2_DLL) && defined(HL2_EPISODIC) ) + CBaseEntity::sm_bDisableTouchFuncs = ( gpGlobals->eLoadType != MapLoad_Transition ); + PhysicsTouchTriggers(); + CBaseEntity::sm_bDisableTouchFuncs = false; +#endif // HL2_EPISODIC + + //Adrian: If I'm restoring with these fields it means I've become a client side ragdoll. + //Don't create another one, just wait until is my time of being removed. + if ( GetFlags() & FL_TRANSRAGDOLL ) + { + m_nRenderFX = kRenderFxNone; + AddEffects( EF_NODRAW ); + RemoveFlag( FL_DISSOLVING | FL_ONFIRE ); + } + + if ( m_pParent ) + { + CBaseEntity *pChild = m_pParent->FirstMoveChild(); + while ( pChild ) + { + if ( pChild == this ) + break; + pChild = pChild->NextMovePeer(); + } + if ( pChild != this ) + { +#if _DEBUG + // generally this means you've got something marked FCAP_DONT_SAVE + // in a hierarchy. That's probably ok given this fixup, but the hierarhcy + // linked list is just saved/loaded in-place + Warning("Fixing up parent on %s\n", GetClassname() ); +#endif + // We only need to be back in the parent's list because we're already in the right place and with the right data + LinkChild( m_pParent, this ); + } + } + + // We're not save/loading the PVS dirty state. Assume everything is dirty after a restore + NetworkProp()->MarkPVSInformationDirty(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Recursively restores all the classes in an object, in reverse order (top down) +// Output : int 0 on failure, 1 on success +//----------------------------------------------------------------------------- +int CBaseEntity::RestoreDataDescBlock( IRestore &restore, datamap_t *dmap ) +{ + return restore.ReadAll( this, dmap ); +} + +//----------------------------------------------------------------------------- + +bool CBaseEntity::ShouldSavePhysics() +{ + return true; +} + +//----------------------------------------------------------------------------- + +#include "tier0/memdbgoff.h" + +//----------------------------------------------------------------------------- +// CBaseEntity new/delete +// allocates and frees memory for itself from the engine-> +// All fields in the object are all initialized to 0. +//----------------------------------------------------------------------------- +void *CBaseEntity::operator new( size_t stAllocateBlock ) +{ + // call into engine to get memory + Assert( stAllocateBlock != 0 ); + return engine->PvAllocEntPrivateData(stAllocateBlock); +}; + +void *CBaseEntity::operator new( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine ) +{ + // call into engine to get memory + Assert( stAllocateBlock != 0 ); + return engine->PvAllocEntPrivateData(stAllocateBlock); +} + +void CBaseEntity::operator delete( void *pMem ) +{ + // get the engine to free the memory + engine->FreeEntPrivateData( pMem ); +} + +#include "tier0/memdbgon.h" + + +#ifdef _DEBUG +void CBaseEntity::FunctionCheck( void *pFunction, const char *name ) +{ +#ifdef USES_SAVERESTORE + // Note, if you crash here and your class is using multiple inheritance, it is + // probably the case that CBaseEntity (or a descendant) is not the first + // class in your list of ancestors, which it must be. + if (pFunction && !UTIL_FunctionToName( GetDataDescMap(), (inputfunc_t *)pFunction ) ) + { + Warning( "FUNCTION NOT IN TABLE!: %s:%s (%08lx)\n", STRING(m_iClassname), name, (unsigned long)pFunction ); + Assert(0); + } +#endif +} +#endif + + +bool CBaseEntity::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace ) +{ + return false; +} + +//----------------------------------------------------------------------------- +// Perform hitbox test, returns true *if hitboxes were tested at all*!! +//----------------------------------------------------------------------------- +bool CBaseEntity::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr ) +{ + return false; +} + + +void CBaseEntity::SetOwnerEntity( CBaseEntity* pOwner ) +{ + if ( m_hOwnerEntity.Get() != pOwner ) + { + m_hOwnerEntity = pOwner; + + CollisionRulesChanged(); + } +} + +void CBaseEntity::SetMoveType( MoveType_t val, MoveCollide_t moveCollide ) +{ +#ifdef _DEBUG + // Make sure the move type + move collide are compatible... + if ((val != MOVETYPE_FLY) && (val != MOVETYPE_FLYGRAVITY)) + { + Assert( moveCollide == MOVECOLLIDE_DEFAULT ); + } + + if ( m_MoveType == MOVETYPE_VPHYSICS && val != m_MoveType ) + { + if ( VPhysicsGetObject() && val != MOVETYPE_NONE ) + { + // What am I supposed to do with the physics object if + // you're changing away from MOVETYPE_VPHYSICS without making the object + // shadow? This isn't likely to work, assert. + // You probably meant to call VPhysicsInitShadow() instead of VPhysicsInitNormal()! + Assert( VPhysicsGetObject()->GetShadowController() ); + } + } +#endif + + if ( m_MoveType == val ) + { + m_MoveCollide = moveCollide; + return; + } + + // This is needed to the removal of MOVETYPE_FOLLOW: + // We can't transition from follow to a different movetype directly + // or the leaf code will break. + Assert( !IsEffectActive( EF_BONEMERGE ) ); + m_MoveType = val; + m_MoveCollide = moveCollide; + + CollisionRulesChanged(); + + switch( m_MoveType ) + { + case MOVETYPE_WALK: + { + SetSimulatedEveryTick( true ); + SetAnimatedEveryTick( true ); + } + break; + case MOVETYPE_STEP: + { + // This will probably go away once I remove the cvar that controls the test code + SetSimulatedEveryTick( g_bTestMoveTypeStepSimulation ? true : false ); + SetAnimatedEveryTick( false ); + } + break; + case MOVETYPE_FLY: + case MOVETYPE_FLYGRAVITY: + { + // Initialize our water state, because these movetypes care about transitions in/out of water + UpdateWaterState(); + } + break; + default: + { + SetSimulatedEveryTick( true ); + SetAnimatedEveryTick( false ); + } + } + + // This will probably go away or be handled in a better way once I remove the cvar that controls the test code + CheckStepSimulationChanged(); + CheckHasGamePhysicsSimulation(); +} + +void CBaseEntity::Spawn( void ) +{ +} + + +CBaseEntity* CBaseEntity::Instance( const CBaseHandle &hEnt ) +{ + return gEntList.GetBaseEntity( hEnt ); +} + +int CBaseEntity::GetTransmitState( void ) +{ + edict_t *ed = edict(); + + if ( !ed ) + return 0; + + return ed->m_fStateFlags; +} + +int CBaseEntity::SetTransmitState( int nFlag) +{ + edict_t *ed = edict(); + + if ( !ed ) + return 0; + + // clear current flags = check ShouldTransmit() + ed->ClearTransmitState(); + + int oldFlags = ed->m_fStateFlags; + ed->m_fStateFlags |= nFlag; + + // Tell the engine (used for a network backdoor optimization). + if ( (oldFlags & FL_EDICT_DONTSEND) != (ed->m_fStateFlags & FL_EDICT_DONTSEND) ) + engine->NotifyEdictFlagsChange( entindex() ); + + return ed->m_fStateFlags; +} + +int CBaseEntity::UpdateTransmitState() +{ + // If you get this assert, you should be calling DispatchUpdateTransmitState + // instead of UpdateTransmitState. + Assert( g_nInsideDispatchUpdateTransmitState > 0 ); + + // If an object is the moveparent of something else, don't skip it just because it's marked EF_NODRAW or else + // the client won't have a proper origin for the child since the hierarchy won't be correctly transmitted down + if ( IsEffectActive( EF_NODRAW ) && + !m_hMoveChild.Get() ) + { + return SetTransmitState( FL_EDICT_DONTSEND ); + } + + if ( !IsEFlagSet( EFL_FORCE_CHECK_TRANSMIT ) ) + { + if ( !GetModelIndex() || !GetModelName() ) + { + return SetTransmitState( FL_EDICT_DONTSEND ); + } + } + + // Always send the world + if ( GetModelIndex() == 1 ) + { + return SetTransmitState( FL_EDICT_ALWAYS ); + } + + if ( IsEFlagSet( EFL_IN_SKYBOX ) ) + { + return SetTransmitState( FL_EDICT_ALWAYS ); + } + + // by default cull against PVS + return SetTransmitState( FL_EDICT_PVSCHECK ); +} + +int CBaseEntity::DispatchUpdateTransmitState() +{ + edict_t *ed = edict(); + if ( m_nTransmitStateOwnedCounter != 0 ) + return ed ? ed->m_fStateFlags : 0; + + g_nInsideDispatchUpdateTransmitState++; + int ret = UpdateTransmitState(); + g_nInsideDispatchUpdateTransmitState--; + + return ret; +} + +//----------------------------------------------------------------------------- +// Purpose: Note, an entity can override the send table ( e.g., to send less data or to send minimal data for +// objects ( prob. players ) that are not in the pvs. +// Input : **ppSendTable - +// *recipient - +// *pvs - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +int CBaseEntity::ShouldTransmit( const CCheckTransmitInfo *pInfo ) +{ + int fFlags = DispatchUpdateTransmitState(); + + if ( fFlags & FL_EDICT_PVSCHECK ) + { + return FL_EDICT_PVSCHECK; + } + else if ( fFlags & FL_EDICT_ALWAYS ) + { + return FL_EDICT_ALWAYS; + } + else if ( fFlags & FL_EDICT_DONTSEND ) + { + return FL_EDICT_DONTSEND; + } + +// if ( IsToolRecording() ) +// { +// return FL_EDICT_ALWAYS; +// } + + CBaseEntity *pRecipientEntity = CBaseEntity::Instance( pInfo->m_pClientEnt ); + + Assert( pRecipientEntity->IsPlayer() ); + + CBasePlayer *pRecipientPlayer = static_cast( pRecipientEntity ); + + + // FIXME: Refactor once notion of "team" is moved into HL2 code + // Team rules may tell us that we should + if ( pRecipientPlayer->GetTeam() ) + { + if ( pRecipientPlayer->GetTeam()->ShouldTransmitToPlayer( pRecipientPlayer, this )) + return FL_EDICT_ALWAYS; + } + + +/*#ifdef INVASION_DLL + // Check test network vis distance stuff. Eventually network LOD will do this. + float flTestDistSqr = pRecipientEntity->GetAbsOrigin().DistToSqr( WorldSpaceCenter() ); + if ( flTestDistSqr > sv_netvisdist.GetFloat() * sv_netvisdist.GetFloat() ) + return TRANSMIT_NO; // TODO doesn't work with HLTV +#endif*/ + + // by default do a PVS check + + return FL_EDICT_PVSCHECK; +} + + +//----------------------------------------------------------------------------- +// Rules about which entities need to transmit along with me +//----------------------------------------------------------------------------- +void CBaseEntity::SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways ) +{ + int index = entindex(); + + // Are we already marked for transmission? + if ( pInfo->m_pTransmitEdict->Get( index ) ) + return; + + CServerNetworkProperty *pNetworkParent = NetworkProp()->GetNetworkParent(); + + pInfo->m_pTransmitEdict->Set( index ); + + // HLTV/Replay need to know if this entity is culled by PVS limits + if ( pInfo->m_pTransmitAlways ) + { + // in HLTV/Replay mode always transmit entitys with move-parents + // HLTV/Replay can't resolve the mode-parents relationships + if ( bAlways || pNetworkParent ) + { + // tell HLTV/Replay that this entity is always transmitted + pInfo->m_pTransmitAlways->Set( index ); + } + else + { + // HLTV/Replay will PVS cull this entity, so update the + // node/cluster infos if necessary + m_Network.RecomputePVSInformation(); + } + } + + // Force our aiment and move parent to be sent. + if ( pNetworkParent ) + { + CBaseEntity *pMoveParent = pNetworkParent->GetBaseEntity(); + pMoveParent->SetTransmit( pInfo, bAlways ); + } +} + + +//----------------------------------------------------------------------------- +// Returns which skybox the entity is in +//----------------------------------------------------------------------------- +CSkyCamera *CBaseEntity::GetEntitySkybox() +{ + int area = engine->GetArea( WorldSpaceCenter() ); + + CSkyCamera *pCur = GetSkyCameraList(); + while ( pCur ) + { + if ( engine->CheckAreasConnected( area, pCur->m_skyboxData.area ) ) + return pCur; + + pCur = pCur->m_pNext; + } + + return NULL; +} + +bool CBaseEntity::DetectInSkybox() +{ + if ( GetEntitySkybox() != NULL ) + { + AddEFlags( EFL_IN_SKYBOX ); + return true; + } + + RemoveEFlags( EFL_IN_SKYBOX ); + return false; +} + + +//------------------------------------------------------------------------------ +// Computes a world-aligned bounding box that surrounds everything in the entity +//------------------------------------------------------------------------------ +void CBaseEntity::ComputeWorldSpaceSurroundingBox( Vector *pMins, Vector *pMaxs ) +{ + // Should never get here.. only use USE_GAME_CODE with bounding boxes + // if you have an implementation for this method + Assert( 0 ); +} + + +//------------------------------------------------------------------------------ +// Purpose : If name exists returns name, otherwise returns classname +// Input : +// Output : +//------------------------------------------------------------------------------ +const char *CBaseEntity::GetDebugName(void) +{ + if ( this == NULL ) + return "<>"; + + if ( m_iName != NULL_STRING ) + { + return STRING(m_iName); + } + else + { + return STRING(m_iClassname); + } +} + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CBaseEntity::DrawInputOverlay(const char *szInputName, CBaseEntity *pCaller, variant_t Value) +{ + char bigstring[1024]; + if ( Value.FieldType() == FIELD_INTEGER ) + { + Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s,%d) <-- (%s)\n", gpGlobals->curtime, szInputName, Value.Int(), pCaller ? pCaller->GetDebugName() : NULL); + } + else if ( Value.FieldType() == FIELD_STRING ) + { + Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s,%s) <-- (%s)\n", gpGlobals->curtime, szInputName, Value.String(), pCaller ? pCaller->GetDebugName() : NULL); + } + else + { + Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s) <-- (%s)\n", gpGlobals->curtime, szInputName, pCaller ? pCaller->GetDebugName() : NULL); + } + AddTimedOverlay(bigstring, 10.0); + + if ( Value.FieldType() == FIELD_INTEGER ) + { + DevMsg( 2, "input: (%s,%d) -> (%s,%s), from (%s)\n", szInputName, Value.Int(), STRING(m_iClassname), GetDebugName(), pCaller ? pCaller->GetDebugName() : NULL); + } + else if ( Value.FieldType() == FIELD_STRING ) + { + DevMsg( 2, "input: (%s,%s) -> (%s,%s), from (%s)\n", szInputName, Value.String(), STRING(m_iClassname), GetDebugName(), pCaller ? pCaller->GetDebugName() : NULL); + } + else + DevMsg( 2, "input: (%s) -> (%s,%s), from (%s)\n", szInputName, STRING(m_iClassname), GetDebugName(), pCaller ? pCaller->GetDebugName() : NULL); +} + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CBaseEntity::DrawOutputOverlay(CEventAction *ev) +{ + // Print to entity + char bigstring[1024]; + if ( ev->m_flDelay ) + { + Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s) --> (%s),%.1f) \n", gpGlobals->curtime, STRING(ev->m_iTargetInput), STRING(ev->m_iTarget), ev->m_flDelay); + } + else + { + Q_snprintf( bigstring,sizeof(bigstring), "%3.1f (%s) --> (%s)\n", gpGlobals->curtime, STRING(ev->m_iTargetInput), STRING(ev->m_iTarget)); + } + AddTimedOverlay(bigstring, 10.0); + + // Now print to the console + if ( ev->m_flDelay ) + { + DevMsg( 2, "output: (%s,%s) -> (%s,%s,%.1f)\n", STRING(m_iClassname), GetDebugName(), STRING(ev->m_iTarget), STRING(ev->m_iTargetInput), ev->m_flDelay ); + } + else + { + DevMsg( 2, "output: (%s,%s) -> (%s,%s)\n", STRING(m_iClassname), GetDebugName(), STRING(ev->m_iTarget), STRING(ev->m_iTargetInput) ); + } +} + + +//----------------------------------------------------------------------------- +// Entity events... these are events targetted to a particular entity +// Each event defines its own well-defined event data structure +//----------------------------------------------------------------------------- +void CBaseEntity::OnEntityEvent( EntityEvent_t event, void *pEventData ) +{ + switch( event ) + { + case ENTITY_EVENT_WATER_TOUCH: + { + int nContents = (int)pEventData; + if ( !nContents || (nContents & CONTENTS_WATER) ) + { + ++m_nWaterTouch; + } + if ( nContents & CONTENTS_SLIME ) + { + ++m_nSlimeTouch; + } + } + break; + + case ENTITY_EVENT_WATER_UNTOUCH: + { + int nContents = (int)pEventData; + if ( !nContents || (nContents & CONTENTS_WATER) ) + { + --m_nWaterTouch; + } + if ( nContents & CONTENTS_SLIME ) + { + --m_nSlimeTouch; + } + } + break; + + default: + return; + } + + // Only do this for vphysics objects + if ( GetMoveType() != MOVETYPE_VPHYSICS ) + return; + + int nNewContents = 0; + if ( m_nWaterTouch > 0 ) + { + nNewContents |= CONTENTS_WATER; + } + + if ( m_nSlimeTouch > 0 ) + { + nNewContents |= CONTENTS_SLIME; + } + + if (( nNewContents & MASK_WATER ) == 0) + { + SetWaterLevel( 0 ); + SetWaterType( CONTENTS_EMPTY ); + return; + } + + SetWaterLevel( 1 ); + SetWaterType( nNewContents ); +} + + +ConVar ent_messages_draw( "ent_messages_draw", "0", FCVAR_CHEAT, "Visualizes all entity input/output activity." ); + + +//----------------------------------------------------------------------------- +// Purpose: calls the appropriate message mapped function in the entity according +// to the fired action. +// Input : char *szInputName - input destination +// *pActivator - entity which initiated this sequence of actions +// *pCaller - entity from which this event is sent +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CBaseEntity::AcceptInput( const char *szInputName, CBaseEntity *pActivator, CBaseEntity *pCaller, variant_t Value, int outputID ) +{ + if ( ent_messages_draw.GetBool() ) + { + if ( pCaller != NULL ) + { + NDebugOverlay::Line( pCaller->GetAbsOrigin(), GetAbsOrigin(), 255, 255, 255, false, 3 ); + NDebugOverlay::Box( pCaller->GetAbsOrigin(), Vector(-4, -4, -4), Vector(4, 4, 4), 255, 0, 0, 0, 3 ); + } + + NDebugOverlay::Text( GetAbsOrigin(), szInputName, false, 3 ); + NDebugOverlay::Box( GetAbsOrigin(), Vector(-4, -4, -4), Vector(4, 4, 4), 0, 255, 0, 0, 3 ); + } + + // loop through the data description list, restoring each data desc block + for ( datamap_t *dmap = GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) + { + // search through all the actions in the data description, looking for a match + for ( int i = 0; i < dmap->dataNumFields; i++ ) + { + if ( dmap->dataDesc[i].flags & FTYPEDESC_INPUT ) + { + if ( !Q_stricmp(dmap->dataDesc[i].externalName, szInputName) ) + { + // found a match + + char szBuffer[256]; + // mapper debug message + if (pCaller != NULL) + { + Q_snprintf( szBuffer, sizeof(szBuffer), "(%0.2f) input %s: %s.%s(%s)\n", gpGlobals->curtime, STRING(pCaller->m_iName), GetDebugName(), szInputName, Value.String() ); + } + else + { + Q_snprintf( szBuffer, sizeof(szBuffer), "(%0.2f) input : %s.%s(%s)\n", gpGlobals->curtime, GetDebugName(), szInputName, Value.String() ); + } + DevMsg( 2, "%s", szBuffer ); + ADD_DEBUG_HISTORY( HISTORY_ENTITY_IO, szBuffer ); + + if (m_debugOverlays & OVERLAY_MESSAGE_BIT) + { + DrawInputOverlay(szInputName,pCaller,Value); + } + + // convert the value if necessary + if ( Value.FieldType() != dmap->dataDesc[i].fieldType ) + { + if ( !(Value.FieldType() == FIELD_VOID && dmap->dataDesc[i].fieldType == FIELD_STRING) ) // allow empty strings + { + if ( !Value.Convert( (fieldtype_t)dmap->dataDesc[i].fieldType ) ) + { + // bad conversion + Warning( "!! ERROR: bad input/output link:\n!! %s(%s,%s) doesn't match type from %s(%s)\n", + STRING(m_iClassname), GetDebugName(), szInputName, + ( pCaller != NULL ) ? STRING(pCaller->m_iClassname) : "", + ( pCaller != NULL ) ? STRING(pCaller->m_iName) : "" ); + return false; + } + } + } + + // call the input handler, or if there is none just set the value + inputfunc_t pfnInput = dmap->dataDesc[i].inputFunc; + + if ( pfnInput ) + { + // Package the data into a struct for passing to the input handler. + inputdata_t data; + data.pActivator = pActivator; + data.pCaller = pCaller; + data.value = Value; + data.nOutputID = outputID; + + (this->*pfnInput)( data ); + } + else if ( dmap->dataDesc[i].flags & FTYPEDESC_KEY ) + { + // set the value directly + Value.SetOther( ((char*)this) + dmap->dataDesc[i].fieldOffset[ TD_OFFSET_NORMAL ]); + + // TODO: if this becomes evil and causes too many full entity updates, then we should make + // a macro like this: + // + // define MAKE_INPUTVAR(x) void Note##x##Modified() { x.GetForModify(); } + // + // Then the datadesc points at that function and we call it here. The only pain is to add + // that function for all the DEFINE_INPUT calls. + NetworkStateChanged(); + } + + return true; + } + } + } + } + + DevMsg( 2, "unhandled input: (%s) -> (%s,%s)\n", szInputName, STRING(m_iClassname), GetDebugName()/*,", from (%s,%s)" STRING(pCaller->m_iClassname), STRING(pCaller->m_iName)*/ ); + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Input handler for the entity alpha. +// Input : nAlpha - Alpha value (0 - 255). +//----------------------------------------------------------------------------- +void CBaseEntity::InputAlpha( inputdata_t &inputdata ) +{ + SetRenderColorA( clamp( inputdata.value.Int(), 0, 255 ) ); +} + + +//----------------------------------------------------------------------------- +// Activate alternative sorting +//----------------------------------------------------------------------------- +void CBaseEntity::InputAlternativeSorting( inputdata_t &inputdata ) +{ + m_bAlternateSorting = inputdata.value.Bool(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Input handler for the entity color. Ignores alpha since that is handled +// by a separate input handler. +// Input : Color32 new value for color (alpha is ignored). +//----------------------------------------------------------------------------- +void CBaseEntity::InputColor( inputdata_t &inputdata ) +{ + color32 clr = inputdata.value.Color32(); + + SetRenderColor( clr.r, clr.g, clr.b ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Called whenever the entity is 'Used'. This can be when a player hits +// use, or when an entity targets it without an output name (legacy entities) +//----------------------------------------------------------------------------- +void CBaseEntity::InputUse( inputdata_t &inputdata ) +{ + Use( inputdata.pActivator, inputdata.pCaller, (USE_TYPE)inputdata.nOutputID, 0 ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Reads an output variable, by string name, from an entity +// Input : char *varName - the string name of the variable +// variant_t *var - the value is stored here +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CBaseEntity::ReadKeyField( const char *varName, variant_t *var ) +{ + if ( !varName ) + return false; + + // loop through the data description list, restoring each data desc block + for ( datamap_t *dmap = GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) + { + // search through all the readable fields in the data description, looking for a match + for ( int i = 0; i < dmap->dataNumFields; i++ ) + { + if ( dmap->dataDesc[i].flags & (FTYPEDESC_OUTPUT | FTYPEDESC_KEY) ) + { + if ( !Q_stricmp(dmap->dataDesc[i].externalName, varName) ) + { + var->Set( dmap->dataDesc[i].fieldType, ((char*)this) + dmap->dataDesc[i].fieldOffset[ TD_OFFSET_NORMAL ] ); + return true; + } + } + } + } + + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the damage filter on the object +//----------------------------------------------------------------------------- +void CBaseEntity::InputEnableDamageForces( inputdata_t &inputdata ) +{ + RemoveEFlags( EFL_NO_DAMAGE_FORCES ); +} + +void CBaseEntity::InputDisableDamageForces( inputdata_t &inputdata ) +{ + AddEFlags( EFL_NO_DAMAGE_FORCES ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the damage filter on the object +//----------------------------------------------------------------------------- +void CBaseEntity::InputSetDamageFilter( inputdata_t &inputdata ) +{ + // Get a handle to my damage filter entity if there is one. + m_iszDamageFilterName = inputdata.value.StringID(); + if ( m_iszDamageFilterName != NULL_STRING ) + { + m_hDamageFilter = gEntList.FindEntityByName( NULL, m_iszDamageFilterName ); + } + else + { + m_hDamageFilter = NULL; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Dispatch effects on this entity +//----------------------------------------------------------------------------- +void CBaseEntity::InputDispatchEffect( inputdata_t &inputdata ) +{ + const char *sEffect = inputdata.value.String(); + if ( sEffect && sEffect[0] ) + { + CEffectData data; + GetInputDispatchEffectPosition( sEffect, data.m_vOrigin, data.m_vAngles ); + AngleVectors( data.m_vAngles, &data.m_vNormal ); + data.m_vStart = data.m_vOrigin; + data.m_nEntIndex = entindex(); + + // Clip off leading attachment point numbers + while ( sEffect[0] >= '0' && sEffect[0] <= '9' ) + { + sEffect++; + } + DispatchEffect( sEffect, data ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Returns the origin at which to play an inputted dispatcheffect +//----------------------------------------------------------------------------- +void CBaseEntity::GetInputDispatchEffectPosition( const char *sInputString, Vector &pOrigin, QAngle &pAngles ) +{ + pOrigin = GetAbsOrigin(); + pAngles = GetAbsAngles(); +} + +//----------------------------------------------------------------------------- +// Purpose: Marks the entity for deletion +//----------------------------------------------------------------------------- +void CBaseEntity::InputKill( inputdata_t &inputdata ) +{ + // tell owner ( if any ) that we're dead.This is mostly for NPCMaker functionality. + CBaseEntity *pOwner = GetOwnerEntity(); + if ( pOwner ) + { + pOwner->DeathNotice( this ); + SetOwnerEntity( NULL ); + } + + UTIL_Remove( this ); +} + +void CBaseEntity::InputKillHierarchy( inputdata_t &inputdata ) +{ + CBaseEntity *pChild, *pNext; + for ( pChild = FirstMoveChild(); pChild; pChild = pNext ) + { + pNext = pChild->NextMovePeer(); + pChild->InputKillHierarchy( inputdata ); + } + + // tell owner ( if any ) that we're dead. This is mostly for NPCMaker functionality. + CBaseEntity *pOwner = GetOwnerEntity(); + if ( pOwner ) + { + pOwner->DeathNotice( this ); + SetOwnerEntity( NULL ); + } + + UTIL_Remove( this ); +} + +//------------------------------------------------------------------------------ +// Purpose: Input handler for changing this entity's movement parent. +//------------------------------------------------------------------------------ +void CBaseEntity::InputSetParent( inputdata_t &inputdata ) +{ + // If we had a parent attachment, clear it, because it's no longer valid. + if ( m_iParentAttachment ) + { + m_iParentAttachment = 0; + } + + SetParent( inputdata.value.StringID(), inputdata.pActivator ); +} + +//------------------------------------------------------------------------------ +// Purpose: +//------------------------------------------------------------------------------ +void CBaseEntity::SetParentAttachment( const char *szInputName, const char *szAttachment, bool bMaintainOffset ) +{ + // Must have a parent + if ( !m_pParent ) + { + Warning("ERROR: Tried to %s for entity %s (%s), but it has no parent.\n", szInputName, GetClassname(), GetDebugName() ); + return; + } + + // Valid only on CBaseAnimating + CBaseAnimating *pAnimating = m_pParent->GetBaseAnimating(); + if ( !pAnimating ) + { + Warning("ERROR: Tried to %s for entity %s (%s), but its parent has no model.\n", szInputName, GetClassname(), GetDebugName() ); + return; + } + + // Lookup the attachment + int iAttachment = pAnimating->LookupAttachment( szAttachment ); + if ( iAttachment <= 0 ) + { + Warning("ERROR: Tried to %s for entity %s (%s), but it has no attachment named %s.\n", szInputName, GetClassname(), GetDebugName(), szAttachment ); + return; + } + + m_iParentAttachment = iAttachment; + SetParent( m_pParent, m_iParentAttachment ); + + // Now move myself directly onto the attachment point + SetMoveType( MOVETYPE_NONE ); + + if ( !bMaintainOffset ) + { + SetLocalOrigin( vec3_origin ); + SetLocalAngles( vec3_angle ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Input handler for changing this entity's movement parent's attachment point +//----------------------------------------------------------------------------- +void CBaseEntity::InputSetParentAttachment( inputdata_t &inputdata ) +{ + SetParentAttachment( "SetParentAttachment", inputdata.value.String(), false ); +} + +//----------------------------------------------------------------------------- +// Purpose: Input handler for changing this entity's movement parent's attachment point +//----------------------------------------------------------------------------- +void CBaseEntity::InputSetParentAttachmentMaintainOffset( inputdata_t &inputdata ) +{ + SetParentAttachment( "SetParentAttachmentMaintainOffset", inputdata.value.String(), true ); +} + +//------------------------------------------------------------------------------ +// Purpose: Input handler for clearing this entity's movement parent. +//------------------------------------------------------------------------------ +void CBaseEntity::InputClearParent( inputdata_t &inputdata ) +{ + SetParent( NULL ); +} + + +//------------------------------------------------------------------------------ +// Purpose : Returns velcocity of base entity. If physically simulated gets +// velocity from physics object +// Input : +// Output : +//------------------------------------------------------------------------------ +void CBaseEntity::GetVelocity(Vector *vVelocity, AngularImpulse *vAngVelocity) +{ + if (GetMoveType()==MOVETYPE_VPHYSICS && m_pPhysicsObject) + { + m_pPhysicsObject->GetVelocity(vVelocity,vAngVelocity); + } + else + { + if (vVelocity != NULL) + { + *vVelocity = GetAbsVelocity(); + } + if (vAngVelocity != NULL) + { + QAngle tmp = GetLocalAngularVelocity(); + QAngleToAngularImpulse( tmp, *vAngVelocity ); + } + } +} + +bool CBaseEntity::IsMoving() +{ + Vector velocity; + GetVelocity( &velocity, NULL ); + return velocity != vec3_origin; +} + +//----------------------------------------------------------------------------- +// Purpose: Retrieves the coordinate frame for this entity. +// Input : forward - Receives the entity's forward vector. +// right - Receives the entity's right vector. +// up - Receives the entity's up vector. +//----------------------------------------------------------------------------- +void CBaseEntity::GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const +{ + // This call is necessary to cause m_rgflCoordinateFrame to be recomputed + const matrix3x4_t &entityToWorld = EntityToWorldTransform(); + + if (pForward != NULL) + { + MatrixGetColumn( entityToWorld, 0, *pForward ); + } + + if (pRight != NULL) + { + MatrixGetColumn( entityToWorld, 1, *pRight ); + *pRight *= -1.0f; + } + + if (pUp != NULL) + { + MatrixGetColumn( entityToWorld, 2, *pUp ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the model, validates that it's of the appropriate type +// Input : *szModelName - +//----------------------------------------------------------------------------- +void CBaseEntity::SetModel( const char *szModelName ) +{ + int modelIndex = modelinfo->GetModelIndex( szModelName ); + const model_t *model = modelinfo->GetModel( modelIndex ); + if ( model && modelinfo->GetModelType( model ) != mod_brush ) + { + Msg( "Setting CBaseEntity to non-brush model %s\n", szModelName ); + } + UTIL_SetModel( this, szModelName ); +} + +//------------------------------------------------------------------------------ + +CStudioHdr *CBaseEntity::OnNewModel() +{ + // Do nothing. + return NULL; +} + + +//================================================================================ +// TEAM HANDLING +//================================================================================ +void CBaseEntity::InputSetTeam( inputdata_t &inputdata ) +{ + ChangeTeam( inputdata.value.Int() ); +} + +//----------------------------------------------------------------------------- +// Purpose: Put the entity in the specified team +//----------------------------------------------------------------------------- +void CBaseEntity::ChangeTeam( int iTeamNum ) +{ + m_iTeamNum = iTeamNum; +} + +//----------------------------------------------------------------------------- +// Get the Team this entity is on +//----------------------------------------------------------------------------- +CTeam *CBaseEntity::GetTeam( void ) const +{ + return GetGlobalTeam( m_iTeamNum ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns true if these players are both in at least one team together +//----------------------------------------------------------------------------- +bool CBaseEntity::InSameTeam( CBaseEntity *pEntity ) const +{ + if ( !pEntity ) + return false; + + return ( pEntity->GetTeam() == GetTeam() ); +} + +//----------------------------------------------------------------------------- +// Purpose: Returns the string name of the players team +//----------------------------------------------------------------------------- +const char *CBaseEntity::TeamID( void ) const +{ + if ( GetTeam() == NULL ) + return ""; + + return GetTeam()->GetName(); +} + +//----------------------------------------------------------------------------- +// Purpose: Returns true if the player is on the same team +//----------------------------------------------------------------------------- +bool CBaseEntity::IsInTeam( CTeam *pTeam ) const +{ + return ( GetTeam() == pTeam ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseEntity::GetTeamNumber( void ) const +{ + return m_iTeamNum; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseEntity::IsInAnyTeam( void ) const +{ + return ( GetTeam() != NULL ); +} + +//----------------------------------------------------------------------------- +// Purpose: Returns the type of damage that this entity inflicts. +//----------------------------------------------------------------------------- +int CBaseEntity::GetDamageType() const +{ + return DMG_GENERIC; +} + + +//----------------------------------------------------------------------------- +// process notification +//----------------------------------------------------------------------------- + +void CBaseEntity::NotifySystemEvent( CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t ¶ms ) +{ +} + + +//----------------------------------------------------------------------------- +// Purpose: Holds an entity's previous abs origin and angles at the time of +// teleportation. Used for child & constrained entity fixup to prevent +// lazy updates of abs origins and angles from messing things up. +//----------------------------------------------------------------------------- +struct TeleportListEntry_t +{ + CBaseEntity *pEntity; + Vector prevAbsOrigin; + QAngle prevAbsAngles; +}; + + +static void TeleportEntity( CBaseEntity *pSourceEntity, TeleportListEntry_t &entry, const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity ) +{ + CBaseEntity *pTeleport = entry.pEntity; + Vector prevOrigin = entry.prevAbsOrigin; + QAngle prevAngles = entry.prevAbsAngles; + + int nSolidFlags = pTeleport->GetSolidFlags(); + pTeleport->AddSolidFlags( FSOLID_NOT_SOLID ); + + // I'm teleporting myself + if ( pSourceEntity == pTeleport ) + { + if ( newAngles ) + { + pTeleport->SetLocalAngles( *newAngles ); + if ( pTeleport->IsPlayer() ) + { + CBasePlayer *pPlayer = (CBasePlayer *)pTeleport; + pPlayer->SnapEyeAngles( *newAngles ); + } + } + + if ( newVelocity ) + { + pTeleport->SetAbsVelocity( *newVelocity ); + pTeleport->SetBaseVelocity( vec3_origin ); + } + + if ( newPosition ) + { + pTeleport->IncrementInterpolationFrame(); + UTIL_SetOrigin( pTeleport, *newPosition ); + } + } + else + { + // My parent is teleporting, just update my position & physics + pTeleport->CalcAbsolutePosition(); + } + IPhysicsObject *pPhys = pTeleport->VPhysicsGetObject(); + bool rotatePhysics = false; + + // handle physics objects / shadows + if ( pPhys ) + { + if ( newVelocity ) + { + pPhys->SetVelocity( newVelocity, NULL ); + } + const QAngle *rotAngles = &pTeleport->GetAbsAngles(); + // don't rotate physics on players or bbox entities + if (pTeleport->IsPlayer() || pTeleport->GetSolid() == SOLID_BBOX ) + { + rotAngles = &vec3_angle; + } + else + { + rotatePhysics = true; + } + + pPhys->SetPosition( pTeleport->GetAbsOrigin(), *rotAngles, true ); + } + + g_pNotify->ReportTeleportEvent( pTeleport, prevOrigin, prevAngles, rotatePhysics ); + + pTeleport->SetSolidFlags( nSolidFlags ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Recurses an entity hierarchy and fills out a list of all entities +// in the hierarchy with their current origins and angles. +// +// This list is necessary to keep lazy updates of abs origins and angles +// from messing up our child/constrained entity fixup. +//----------------------------------------------------------------------------- +static void BuildTeleportList_r( CBaseEntity *pTeleport, CUtlVector &teleportList ) +{ + TeleportListEntry_t entry; + + entry.pEntity = pTeleport; + entry.prevAbsOrigin = pTeleport->GetAbsOrigin(); + entry.prevAbsAngles = pTeleport->GetAbsAngles(); + + teleportList.AddToTail( entry ); + + CBaseEntity *pList = pTeleport->FirstMoveChild(); + while ( pList ) + { + BuildTeleportList_r( pList, teleportList ); + pList = pList->NextMovePeer(); + } +} + + +static CUtlVector g_TeleportStack; +void CBaseEntity::Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity ) +{ + if ( g_TeleportStack.Find( this ) >= 0 ) + return; + int index = g_TeleportStack.AddToTail( this ); + + CUtlVector teleportList; + BuildTeleportList_r( this, teleportList ); + + int i; + for ( i = 0; i < teleportList.Count(); i++) + { + TeleportEntity( this, teleportList[i], newPosition, newAngles, newVelocity ); + } + + for (i = 0; i < teleportList.Count(); i++) + { + teleportList[i].pEntity->CollisionRulesChanged(); + } + + Assert( g_TeleportStack[index] == this ); + g_TeleportStack.FastRemove( index ); + + // FIXME: add an initializer function to StepSimulationData + StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); + if (step) + { + Q_memset( step, 0, sizeof( *step ) ); + } +} + +// Stuff implemented for weapon prediction code +void CBaseEntity::SetSize( const Vector &vecMin, const Vector &vecMax ) +{ + UTIL_SetSize( this, vecMin, vecMax ); +} + +CStudioHdr *ModelSoundsCache_LoadModel( const char *filename ) +{ + // Load the file + int idx = engine->PrecacheModel( filename, true ); + if ( idx != -1 ) + { + model_t *mdl = (model_t *)modelinfo->GetModel( idx ); + if ( mdl ) + { + CStudioHdr *studioHdr = new CStudioHdr( modelinfo->GetStudiomodel( mdl ), mdlcache ); + if ( studioHdr->IsValid() ) + { + return studioHdr; + } + } + } + return NULL; +} + +void ModelSoundsCache_FinishModel( CStudioHdr *hdr ) +{ + Assert( hdr ); + delete hdr; +} + +void ModelSoundsCache_PrecacheScriptSound( const char *soundname ) +{ + CBaseEntity::PrecacheScriptSound( soundname ); +} + +static CUtlCachedFileData< CModelSoundsCache > g_ModelSoundsCache( "modelsounds.cache", MODELSOUNDSCACHE_VERSION, 0, UTL_CACHED_FILE_USE_FILESIZE, false ); + +void ClearModelSoundsCache() +{ + if ( IsX360() ) + { + return; + } + + g_ModelSoundsCache.Reload(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool ModelSoundsCacheInit() +{ + if ( IsX360() ) + { + return true; + } + + return g_ModelSoundsCache.Init(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void ModelSoundsCacheShutdown() +{ + if ( IsX360() ) + { + return; + } + + g_ModelSoundsCache.Shutdown(); +} + +static CUtlSymbolTable g_ModelSoundsSymbolHelper( 0, 32, true ); +class CModelSoundsCacheSaver: public CAutoGameSystem +{ +public: + CModelSoundsCacheSaver( const char *name ) : CAutoGameSystem( name ) + { + } + virtual void LevelInitPostEntity() + { + if ( IsX360() ) + { + return; + } + + if ( g_ModelSoundsCache.IsDirty() ) + { + g_ModelSoundsCache.Save(); + } + } + virtual void LevelShutdownPostEntity() + { + if ( IsX360() ) + { + // Unforunate that this table must persist through duration of level. + // It is the common case that PrecacheModel() still gets called (and needs this table), + // after LevelInitPostEntity, as PrecacheModel() redundantly precaches. + g_ModelSoundsSymbolHelper.RemoveAll(); + return; + } + + if ( g_ModelSoundsCache.IsDirty() ) + { + g_ModelSoundsCache.Save(); + } + } +}; + +static CModelSoundsCacheSaver g_ModelSoundsCacheSaver( "CModelSoundsCacheSaver" ); + +//#define WATCHACCESS +#if defined( WATCHACCESS ) + +static bool g_bWatching = true; + +void ModelLogFunc( const char *fileName, const char *accessType ) +{ + if ( g_bWatching && !CBaseEntity::IsPrecacheAllowed() ) + { + if ( Q_stristr( fileName, ".vcd" ) ) + { + Msg( "%s\n", fileName ); + } + } +} + +class CWatchForModelAccess: public CAutoGameSystem +{ +public: + virtual bool Init() + { + filesystem->AddLoggingFunc(&ModelLogFunc); + return true; + } + + virtual void Shutdown() + { + filesystem->RemoveLoggingFunc(&ModelLogFunc); + } + +}; + +static CWatchForModelAccess g_WatchForModels; + +#endif + +// HACK: This must match the #define in cl_animevent.h in the client .dll code!!! +#define CL_EVENT_SOUND 5004 +#define CL_EVENT_FOOTSTEP_LEFT 6004 +#define CL_EVENT_FOOTSTEP_RIGHT 6005 +#define CL_EVENT_MFOOTSTEP_LEFT 6006 +#define CL_EVENT_MFOOTSTEP_RIGHT 6007 + +//----------------------------------------------------------------------------- +// Precache model sound. Requires a local symbol table to prevent +// a very expensive call to PrecacheScriptSound(). +//----------------------------------------------------------------------------- +void CBaseEntity::PrecacheSoundHelper( const char *pName ) +{ + if ( !IsX360() ) + { + // 360 only + Assert( 0 ); + return; + } + + if ( !pName || !pName[0] ) + { + return; + } + + if ( UTL_INVAL_SYMBOL == g_ModelSoundsSymbolHelper.Find( pName ) ) + { + g_ModelSoundsSymbolHelper.AddString( pName ); + + // very expensive, only call when required + PrecacheScriptSound( pName ); + } +} + +//----------------------------------------------------------------------------- +// Precache model components +//----------------------------------------------------------------------------- +void CBaseEntity::PrecacheModelComponents( int nModelIndex ) +{ + + model_t *pModel = (model_t *)modelinfo->GetModel( nModelIndex ); + if ( !pModel || modelinfo->GetModelType( pModel ) != mod_studio ) + { + return; + } + + // sounds + if ( IsPC() ) + { + const char *name = modelinfo->GetModelName( pModel ); + if ( !g_ModelSoundsCache.EntryExists( name ) ) + { + char extension[ 8 ]; + Q_ExtractFileExtension( name, extension, sizeof( extension ) ); + + if ( Q_stristr( extension, "mdl" ) ) + { + DevMsg( 2, "Late precache of %s, need to rebuild modelsounds.cache\n", name ); + } + else + { + if ( !extension[ 0 ] ) + { + Warning( "Precache of %s ambigious (no extension specified)\n", name ); + } + else + { + Warning( "Late precache of %s (file missing?)\n", name ); + } + return; + } + } + + CModelSoundsCache *entry = g_ModelSoundsCache.Get( name ); + Assert( entry ); + if ( entry ) + { + entry->PrecacheSoundList(); + } + } + + // particles + { + // Check keyvalues for auto-emitting particles + KeyValues *pModelKeyValues = new KeyValues(""); + KeyValues::AutoDelete autodelete_pModelKeyValues( pModelKeyValues ); + if ( pModelKeyValues->LoadFromBuffer( modelinfo->GetModelName( pModel ), modelinfo->GetModelKeyValueText( pModel ) ) ) + { + KeyValues *pParticleEffects = pModelKeyValues->FindKey("Particles"); + if ( pParticleEffects ) + { + // Start grabbing the sounds and slotting them in + for ( KeyValues *pSingleEffect = pParticleEffects->GetFirstSubKey(); pSingleEffect; pSingleEffect = pSingleEffect->GetNextKey() ) + { + const char *pParticleEffectName = pSingleEffect->GetString( "name", "" ); + PrecacheParticleSystem( pParticleEffectName ); + } + } + } + } + + // model anim event owned components + { + // Check animevents for particle events + CStudioHdr studioHdr( modelinfo->GetStudiomodel( pModel ), mdlcache ); + if ( studioHdr.IsValid() ) + { + // force animation event resolution!!! + VerifySequenceIndex( &studioHdr ); + + int nSeqCount = studioHdr.GetNumSeq(); + for ( int i = 0; i < nSeqCount; ++i ) + { + mstudioseqdesc_t &seq = studioHdr.pSeqdesc( i ); + int nEventCount = seq.numevents; + for ( int j = 0; j < nEventCount; ++j ) + { + mstudioevent_t *pEvent = seq.pEvent( j ); + + if ( !( pEvent->type & AE_TYPE_NEWEVENTSYSTEM ) || ( pEvent->type & AE_TYPE_CLIENT ) ) + { + if ( pEvent->event == AE_CL_CREATE_PARTICLE_EFFECT ) + { + char token[256]; + const char *pOptions = pEvent->pszOptions(); + nexttoken( token, pOptions, ' ' ); + if ( token ) + { + PrecacheParticleSystem( token ); + } + continue; + } + } + + // 360 precaches the model sounds now at init time, the cost is now ~250 msecs worst case. + // The disk based solution was not needed. Now at runtime partly due to already crawling the sequences + // for the particles and the expensive part was redundant PrecacheScriptSound(), which is now prevented + // by a local symbol table. + if ( IsX360() ) + { + switch ( pEvent->event ) + { + default: + { + if ( ( pEvent->type & AE_TYPE_NEWEVENTSYSTEM ) && ( pEvent->event == AE_SV_PLAYSOUND ) ) + { + PrecacheSoundHelper( pEvent->pszOptions() ); + } + } + break; + case CL_EVENT_FOOTSTEP_LEFT: + case CL_EVENT_FOOTSTEP_RIGHT: + { + char soundname[256]; + char const *options = pEvent->pszOptions(); + if ( !options || !options[0] ) + { + options = "NPC_CombineS"; + } + + Q_snprintf( soundname, sizeof( soundname ), "%s.RunFootstepLeft", options ); + PrecacheSoundHelper( soundname ); + Q_snprintf( soundname, sizeof( soundname ), "%s.RunFootstepRight", options ); + PrecacheSoundHelper( soundname ); + Q_snprintf( soundname, sizeof( soundname ), "%s.FootstepLeft", options ); + PrecacheSoundHelper( soundname ); + Q_snprintf( soundname, sizeof( soundname ), "%s.FootstepRight", options ); + PrecacheSoundHelper( soundname ); + } + break; + case AE_CL_PLAYSOUND: + { + if ( !( pEvent->type & AE_TYPE_CLIENT ) ) + break; + + if ( pEvent->pszOptions()[0] ) + { + PrecacheSoundHelper( pEvent->pszOptions() ); + } + else + { + Warning( "-- Error --: empty soundname, .qc error on AE_CL_PLAYSOUND in model %s, sequence %s, animevent # %i\n", + studioHdr.GetRenderHdr()->pszName(), seq.pszLabel(), j+1 ); + } + } + break; + case CL_EVENT_SOUND: + case SCRIPT_EVENT_SOUND: + case SCRIPT_EVENT_SOUND_VOICE: + { + PrecacheSoundHelper( pEvent->pszOptions() ); + } + break; + } + } + } + } + } + } +} + + + +//----------------------------------------------------------------------------- +// Purpose: Add model to level precache list +// Input : *name - model name +// Output : int -- model index for model +//----------------------------------------------------------------------------- +int CBaseEntity::PrecacheModel( const char *name, bool bPreload ) +{ + if ( !name || !*name ) + { + Msg( "Attempting to precache model, but model name is NULL\n"); + return -1; + } + + // Warn on out of order precache + if ( !CBaseEntity::IsPrecacheAllowed() ) + { + if ( !engine->IsModelPrecached( name ) ) + { + Assert( !"CBaseEntity::PrecacheModel: too late" ); + Warning( "Late precache of %s\n", name ); + } + } +#if defined( WATCHACCESS ) + else + { + g_bWatching = false; + } +#endif + + int idx = engine->PrecacheModel( name, bPreload ); + if ( idx != -1 ) + { + PrecacheModelComponents( idx ); + } + +#if defined( WATCHACCESS ) + g_bWatching = true; +#endif + + return idx; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseEntity::Remove( ) +{ + UTIL_Remove( this ); +} + +// Entity degugging console commands +extern CBaseEntity *FindPickerEntity( CBasePlayer *pPlayer ); +extern void SetDebugBits( CBasePlayer* pPlayer, const char *name, int bit ); +extern CBaseEntity *GetNextCommandEntity( CBasePlayer *pPlayer, const char *name, CBaseEntity *ent ); + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void ConsoleFireTargets( CBasePlayer *pPlayer, const char *name) +{ + // If no name was given use the picker + if (FStrEq(name,"")) + { + CBaseEntity *pEntity = FindPickerEntity( pPlayer ); + if ( pEntity && !pEntity->IsMarkedForDeletion()) + { + Msg( "[%03d] Found: %s, firing\n", gpGlobals->tickcount%1000, pEntity->GetDebugName()); + pEntity->Use( pPlayer, pPlayer, USE_TOGGLE, 0 ); + return; + } + } + // Otherwise use name or classname + FireTargets( name, pPlayer, pPlayer, USE_TOGGLE, 0 ); +} + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_Name( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_NAME_BIT); +} +static ConCommand ent_name("ent_name", CC_Ent_Name, 0, FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Ent_Text( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_TEXT_BIT); +} +static ConCommand ent_text("ent_text", CC_Ent_Text, "Displays text debugging information about the given entity(ies) on top of the entity (See Overlay Text)\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Ent_BBox( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_BBOX_BIT); +} +static ConCommand ent_bbox("ent_bbox", CC_Ent_BBox, "Displays the movement bounding box for the given entity(ies) in orange. Some entites will also display entity specific overlays.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + + +//------------------------------------------------------------------------------ +void CC_Ent_AbsBox( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_ABSBOX_BIT); +} +static ConCommand ent_absbox("ent_absbox", CC_Ent_AbsBox, "Displays the total bounding box for the given entity(s) in green. Some entites will also display entity specific overlays.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + + +//------------------------------------------------------------------------------ +void CC_Ent_RBox( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_RBOX_BIT); +} +static ConCommand ent_rbox("ent_rbox", CC_Ent_RBox, "Displays the total bounding box for the given entity(s) in green. Some entites will also display entity specific overlays.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Ent_AttachmentPoints( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_ATTACHMENTS_BIT); +} +static ConCommand ent_attachments("ent_attachments", CC_Ent_AttachmentPoints, "Displays the attachment points on an entity.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Ent_ViewOffset( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_VIEWOFFSET); +} +static ConCommand ent_viewoffset("ent_viewoffset", CC_Ent_ViewOffset, "Displays the eye position for the given entity(ies) in red.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Ent_Remove( const CCommand& args ) +{ + CBaseEntity *pEntity = NULL; + + // If no name was given set bits based on the picked + if ( FStrEq( args[1],"") ) + { + pEntity = FindPickerEntity( UTIL_GetCommandClient() ); + } + else + { + int index = atoi( args[1] ); + if ( index ) + { + pEntity = CBaseEntity::Instance( index ); + } + else + { + // Otherwise set bits based on name or classname + CBaseEntity *ent = NULL; + while ( (ent = gEntList.NextEnt(ent)) != NULL ) + { + if ( (ent->GetEntityName() != NULL_STRING && FStrEq(args[1], STRING(ent->GetEntityName()))) || + (ent->m_iClassname != NULL_STRING && FStrEq(args[1], STRING(ent->m_iClassname))) || + (ent->GetClassname()!=NULL && FStrEq(args[1], ent->GetClassname()))) + { + pEntity = ent; + break; + } + } + } + } + + // Found one? + if ( pEntity ) + { + Msg( "Removed %s(%s)\n", STRING(pEntity->m_iClassname), pEntity->GetDebugName() ); + UTIL_Remove( pEntity ); + } +} +static ConCommand ent_remove("ent_remove", CC_Ent_Remove, "Removes the given entity(s)\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Ent_RemoveAll( const CCommand& args ) +{ + // If no name was given remove based on the picked + if ( args.ArgC() < 2 ) + { + Msg( "Removes all entities of the specified type\n\tArguments: {entity_name} / {class_name}\n" ); + } + else + { + // Otherwise remove based on name or classname + int iCount = 0; + CBaseEntity *ent = NULL; + while ( (ent = gEntList.NextEnt(ent)) != NULL ) + { + if ( (ent->GetEntityName() != NULL_STRING && FStrEq(args[1], STRING(ent->GetEntityName()))) || + (ent->m_iClassname != NULL_STRING && FStrEq(args[1], STRING(ent->m_iClassname))) || + (ent->GetClassname()!=NULL && FStrEq(args[1], ent->GetClassname()))) + { + UTIL_Remove( ent ); + iCount++; + } + } + + if ( iCount ) + { + Msg( "Removed %d %s's\n", iCount, args[1] ); + } + else + { + Msg( "No %s found.\n", args[1] ); + } + } +} +static ConCommand ent_remove_all("ent_remove_all", CC_Ent_RemoveAll, "Removes all entities of the specified type\n\tArguments: {entity_name} / {class_name} ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Ent_SetName( const CCommand& args ) +{ + CBaseEntity *pEntity = NULL; + + if ( args.ArgC() < 1 ) + { + CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); + if (!pPlayer) + return; + + ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_setname \n" ); + } + else + { + // If no name was given set bits based on the picked + if ( FStrEq( args[2],"") ) + { + pEntity = FindPickerEntity( UTIL_GetCommandClient() ); + } + else + { + // Otherwise set bits based on name or classname + CBaseEntity *ent = NULL; + while ( (ent = gEntList.NextEnt(ent)) != NULL ) + { + if ( (ent->GetEntityName() != NULL_STRING && FStrEq(args[1], STRING(ent->GetEntityName()))) || + (ent->m_iClassname != NULL_STRING && FStrEq(args[1], STRING(ent->m_iClassname))) || + (ent->GetClassname()!=NULL && FStrEq(args[1], ent->GetClassname()))) + { + pEntity = ent; + break; + } + } + } + + // Found one? + if ( pEntity ) + { + Msg( "Set the name of %s to %s\n", STRING(pEntity->m_iClassname), args[1] ); + pEntity->SetName( AllocPooledString( args[1] ) ); + } + } +} +static ConCommand ent_setname("ent_setname", CC_Ent_SetName, "Sets the targetname of the given entity(s)\n\tArguments: {new entity name} {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Find_Ent( const CCommand& args ) +{ + if ( args.ArgC() < 2 ) + { + Msg( "Total entities: %d (%d edicts)\n", gEntList.NumberOfEntities(), gEntList.NumberOfEdicts() ); + Msg( "Format: find_ent \n" ); + return; + } + + int iCount = 0; + const char *pszSubString = args[1]; + Msg("Searching for entities with class/target name containing substring: '%s'\n", pszSubString ); + + CBaseEntity *ent = NULL; + while ( (ent = gEntList.NextEnt(ent)) != NULL ) + { + const char *pszClassname = ent->GetClassname(); + const char *pszTargetname = STRING(ent->GetEntityName()); + + bool bMatches = false; + if ( pszClassname && pszClassname[0] ) + { + if ( Q_stristr( pszClassname, pszSubString ) ) + { + bMatches = true; + } + } + + if ( !bMatches && pszTargetname && pszTargetname[0] ) + { + if ( Q_stristr( pszTargetname, pszSubString ) ) + { + bMatches = true; + } + } + + if ( bMatches ) + { + iCount++; + Msg(" '%s' : '%s' (entindex %d) \n", ent->GetClassname(), ent->GetEntityName().ToCStr(), ent->entindex() ); + } + } + + Msg("Found %d matches.\n", iCount); +} +static ConCommand find_ent("find_ent", CC_Find_Ent, "Find and list all entities with classnames or targetnames that contain the specified substring.\nFormat: find_ent \n", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +void CC_Find_Ent_Index( const CCommand& args ) +{ + if ( args.ArgC() < 2 ) + { + Msg( "Format: find_ent_index \n" ); + return; + } + + int iIndex = atoi(args[1]); + CBaseEntity *pEnt = UTIL_EntityByIndex( iIndex ); + if ( pEnt ) + { + Msg(" '%s' : '%s' (entindex %d) \n", pEnt->GetClassname(), pEnt->GetEntityName().ToCStr(), iIndex ); + } + else + { + Msg("Found no entity at %d.\n", iIndex); + } +} +static ConCommand find_ent_index("find_ent_index", CC_Find_Ent_Index, "Display data for entity matching specified index.\nFormat: find_ent_index \n", FCVAR_CHEAT); + +// Purpose : +//------------------------------------------------------------------------------ +void CC_Ent_Dump( const CCommand& args ) +{ + CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); + if (!pPlayer) + { + return; + } + + if ( args.ArgC() < 2 ) + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_dump \n" ); + } + else + { + // iterate through all the ents of this name, printing out their details + CBaseEntity *ent = NULL; + bool bFound = false; + while ( ( ent = gEntList.FindEntityByName(ent, args[1] ) ) != NULL ) + { + bFound = true; + for ( datamap_t *dmap = ent->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) + { + // search through all the actions in the data description, printing out details + for ( int i = 0; i < dmap->dataNumFields; i++ ) + { + variant_t var; + if ( ent->ReadKeyField( dmap->dataDesc[i].externalName, &var) ) + { + char buf[256]; + buf[0] = 0; + switch( var.FieldType() ) + { + case FIELD_STRING: + Q_strncpy( buf, var.String() ,sizeof(buf)); + break; + case FIELD_INTEGER: + if ( var.Int() ) + Q_snprintf( buf,sizeof(buf), "%d", var.Int() ); + break; + case FIELD_FLOAT: + if ( var.Float() ) + Q_snprintf( buf,sizeof(buf), "%.2f", var.Float() ); + break; + case FIELD_EHANDLE: + { + // get the entities name + if ( var.Entity() ) + { + Q_snprintf( buf,sizeof(buf), "%s", STRING(var.Entity()->GetEntityName()) ); + } + } + break; + } + + // don't print out the duplicate keys + if ( !Q_stricmp("parentname",dmap->dataDesc[i].externalName) || !Q_stricmp("targetname",dmap->dataDesc[i].externalName) ) + continue; + + // don't print out empty keys + if ( buf[0] ) + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs(" %s: %s\n", dmap->dataDesc[i].externalName, buf) ); + } + } + } + } + } + + if ( !bFound ) + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, "ent_dump: no such entity" ); + } + } +} +static ConCommand ent_dump("ent_dump", CC_Ent_Dump, "Usage:\n ent_dump \n", FCVAR_CHEAT); + + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_FireTarget( const CCommand& args ) +{ + ConsoleFireTargets(UTIL_GetCommandClient(),args[1]); +} +static ConCommand firetarget("firetarget", CC_Ent_FireTarget, 0, FCVAR_CHEAT); + +static bool UtlStringLessFunc( const CUtlString &lhs, const CUtlString &rhs ) +{ + return Q_stricmp( lhs.String(), rhs.String() ) < 0; +} + +class CEntFireAutoCompletionFunctor : public ICommandCallback, public ICommandCompletionCallback +{ +public: + virtual void CommandCallback( const CCommand &command ) + { + CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); + if (!pPlayer) + { + return; + } + + // fires a command from the console + if ( command.ArgC() < 2 ) + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_fire [action] [value] [delay]\n" ); + } + else + { + const char *target = "", *action = "Use"; + variant_t value; + int delay = 0; + + target = STRING( AllocPooledString(command.Arg( 1 ) ) ); + + // Don't allow them to run anything on a point_servercommand unless they're the host player. Otherwise they can ent_fire + // and run any command on the server. Admittedly, they can only do the ent_fire if sv_cheats is on, but + // people complained about users resetting the rcon password if the server briefly turned on cheats like this: + // give point_servercommand + // ent_fire point_servercommand command "rcon_password mynewpassword" + // + // Robin: Unfortunately, they get around point_servercommand checks with this: + // ent_create point_servercommand; ent_setname mine; ent_fire mine command "rcon_password mynewpassword" + // So, I'm removing the ability for anyone to execute ent_fires on dedicated servers (we can't check to see if + // this command is going to connect with a point_servercommand entity here, because they could delay the event and create it later). + if ( engine->IsDedicatedServer() ) + { + // We allow people with disabled autokick to do it, because they already have rcon. + if ( pPlayer->IsAutoKickDisabled() == false ) + return; + } + else if ( gpGlobals->maxClients > 1 ) + { + // On listen servers with more than 1 player, only allow the host to issue ent_fires. + CBasePlayer *pHostPlayer = UTIL_GetListenServerHost(); + if ( pPlayer != pHostPlayer ) + return; + } + + if ( command.ArgC() >= 3 ) + { + action = STRING( AllocPooledString(command.Arg( 2 )) ); + } + if ( command.ArgC() >= 4 ) + { + value.SetString( AllocPooledString(command.Arg( 3 )) ); + } + if ( command.ArgC() >= 5 ) + { + delay = atoi( command.Arg( 4 ) ); + } + + g_EventQueue.AddEvent( target, action, value, delay, pPlayer, pPlayer ); + } + } + + virtual int CommandCompletionCallback( const char *partial, CUtlVector< CUtlString > &commands ) + { + if ( !g_pGameRules ) + { + return 0; + } + + const char *cmdname = "ent_fire"; + + char *substring = (char *)partial; + if ( Q_strstr( partial, cmdname ) ) + { + substring = (char *)partial + strlen( cmdname ) + 1; + } + + int checklen = 0; + char *space = Q_strstr( substring, " " ); + if ( space ) + { + return EntFire_AutoCompleteInput( partial, commands );; + } + else + { + checklen = Q_strlen( substring ); + } + + CUtlRBTree< CUtlString > symbols( 0, 0, UtlStringLessFunc ); + + CBaseEntity *pos = NULL; + while ( ( pos = gEntList.NextEnt( pos ) ) != NULL ) + { + // Check target name against partial string + if ( pos->GetEntityName() == NULL_STRING ) + continue; + + if ( Q_strnicmp( STRING( pos->GetEntityName() ), substring, checklen ) ) + continue; + + CUtlString sym = STRING( pos->GetEntityName() ); + int idx = symbols.Find( sym ); + if ( idx == symbols.InvalidIndex() ) + { + symbols.Insert( sym ); + } + + // Too many + if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS ) + break; + } + + // Now fill in the results + for ( int i = symbols.FirstInorder(); i != symbols.InvalidIndex(); i = symbols.NextInorder( i ) ) + { + const char *name = symbols[ i ].String(); + + char buf[ 512 ]; + Q_strncpy( buf, name, sizeof( buf ) ); + Q_strlower( buf ); + + CUtlString command; + command = CFmtStr( "%s %s", cmdname, buf ); + commands.AddToTail( command ); + } + + return symbols.Count(); + } +private: + int EntFire_AutoCompleteInput( const char *partial, CUtlVector< CUtlString > &commands ) + { + const char *cmdname = "ent_fire"; + + char *substring = (char *)partial; + if ( Q_strstr( partial, cmdname ) ) + { + substring = (char *)partial + strlen( cmdname ) + 1; + } + + int checklen = 0; + char *space = Q_strstr( substring, " " ); + if ( !space ) + { + Assert( !"CC_EntFireAutoCompleteInputFunc is broken\n" ); + return 0; + } + + checklen = Q_strlen( substring ); + + char targetEntity[ 256 ]; + targetEntity[0] = 0; + int nEntityNameLength = (space-substring); + Q_strncat( targetEntity, substring, sizeof( targetEntity ), nEntityNameLength ); + + // Find the target entity by name + CBaseEntity *target = gEntList.FindEntityByName( NULL, targetEntity ); + if ( target == NULL ) + return 0; + + CUtlRBTree< CUtlString > symbols( 0, 0, UtlStringLessFunc ); + + // Find the next portion of the text chain, if any (removing space) + int nInputNameLength = (checklen-nEntityNameLength-1); + + // Starting past the last space, this is the remainder of the string + char *inputPartial = ( checklen > nEntityNameLength ) ? (space+1) : NULL; + + for ( datamap_t *dmap = target->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) + { + // Make sure we don't keep adding things in if the satisfied the limit + if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS ) + break; + + int c = dmap->dataNumFields; + for ( int i = 0; i < c; i++ ) + { + typedescription_t *field = &dmap->dataDesc[ i ]; + + // Only want inputs + if ( !( field->flags & FTYPEDESC_INPUT ) ) + continue; + + // Only want input functions + if ( field->flags & FTYPEDESC_SAVE ) + continue; + + // See if we've got a partial string for the input name already + if ( inputPartial != NULL ) + { + if ( Q_strnicmp( inputPartial, field->externalName, nInputNameLength ) ) + continue; + } + + CUtlString sym = field->externalName; + + int idx = symbols.Find( sym ); + if ( idx == symbols.InvalidIndex() ) + { + symbols.Insert( sym ); + } + + // Too many items have been added + if ( symbols.Count() >= COMMAND_COMPLETION_MAXITEMS ) + break; + } + } + + // Now fill in the results + for ( int i = symbols.FirstInorder(); i != symbols.InvalidIndex(); i = symbols.NextInorder( i ) ) + { + const char *name = symbols[ i ].String(); + + char buf[ 512 ]; + Q_strncpy( buf, name, sizeof( buf ) ); + Q_strlower( buf ); + + CUtlString command; + command = CFmtStr( "%s %s %s", cmdname, targetEntity, buf ); + commands.AddToTail( command ); + } + + return symbols.Count(); + } +}; + +static CEntFireAutoCompletionFunctor g_EntFireAutoComplete; +static ConCommand ent_fire("ent_fire", &g_EntFireAutoComplete, "Usage:\n ent_fire [action] [value] [delay]\n", FCVAR_CHEAT, &g_EntFireAutoComplete ); + +void CC_Ent_CancelPendingEntFires( const CCommand& args ) +{ + if ( !UTIL_IsCommandIssuedByServerAdmin() ) + return; + + CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); + if (!pPlayer) + return; + + g_EventQueue.CancelEvents( pPlayer ); +} +static ConCommand ent_cancelpendingentfires("ent_cancelpendingentfires", CC_Ent_CancelPendingEntFires, "Cancels all ent_fire created outputs that are currently waiting for their delay to expire." ); + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_Info( const CCommand& args ) +{ + CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); + if (!pPlayer) + { + return; + } + + if ( args.ArgC() < 2 ) + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, "Usage:\n ent_info \n" ); + } + else + { + // iterate through all the ents printing out their details + CBaseEntity *ent = CreateEntityByName( args[1] ); + + if ( ent ) + { + datamap_t *dmap; + for ( dmap = ent->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) + { + // search through all the actions in the data description, printing out details + for ( int i = 0; i < dmap->dataNumFields; i++ ) + { + if ( dmap->dataDesc[i].flags & FTYPEDESC_OUTPUT ) + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs(" output: %s\n", dmap->dataDesc[i].externalName) ); + } + } + } + + for ( dmap = ent->GetDataDescMap(); dmap != NULL; dmap = dmap->baseMap ) + { + // search through all the actions in the data description, printing out details + for ( int i = 0; i < dmap->dataNumFields; i++ ) + { + if ( dmap->dataDesc[i].flags & FTYPEDESC_INPUT ) + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs(" input: %s\n", dmap->dataDesc[i].externalName) ); + } + } + } + + delete ent; + } + else + { + ClientPrint( pPlayer, HUD_PRINTCONSOLE, UTIL_VarArgs("no such entity %s\n", args[1]) ); + } + } +} +static ConCommand ent_info("ent_info", CC_Ent_Info, "Usage:\n ent_info \n", FCVAR_CHEAT); + + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_Messages( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_MESSAGE_BIT); +} +static ConCommand ent_messages("ent_messages", CC_Ent_Messages ,"Toggles input/output message display for the selected entity(ies). The name of the entity will be displayed as well as any messages that it sends or receives.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at", FCVAR_CHEAT); + + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_Pause( void ) +{ + if (CBaseEntity::Debug_IsPaused()) + { + Msg( "Resuming entity I/O events\n" ); + CBaseEntity::Debug_Pause(false); + } + else + { + Msg( "Pausing entity I/O events\n" ); + CBaseEntity::Debug_Pause(true); + } +} +static ConCommand ent_pause("ent_pause", CC_Ent_Pause, "Toggles pausing of input/output message processing for entities. When turned on processing of all message will stop. Any messages displayed with 'ent_messages' will stop fading and be displayed indefinitely. To step through the messages one by one use 'ent_step'.", FCVAR_CHEAT); + + +//------------------------------------------------------------------------------ +// Purpose : Enables the entity picker, revelaing debug information about the +// entity under the crosshair. +// Input : an optional command line argument "full" enables all debug info. +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_Picker( void ) +{ + CBaseEntity::m_bInDebugSelect = CBaseEntity::m_bInDebugSelect ? false : true; + + // Remember the player that's making this request + CBaseEntity::m_nDebugPlayer = UTIL_GetCommandClientIndex(); +} +static ConCommand picker("picker", CC_Ent_Picker, "Toggles 'picker' mode. When picker is on, the bounding box, pivot and debugging text is displayed for whatever entity the player is looking at.\n\tArguments: full - enables all debug information", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_Pivot( const CCommand& args ) +{ + SetDebugBits(UTIL_GetCommandClient(),args[1],OVERLAY_PIVOT_BIT); +} +static ConCommand ent_pivot("ent_pivot", CC_Ent_Pivot, "Displays the pivot for the given entity(ies).\n\t(y=up=green, z=forward=blue, x=left=red). \n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +// Purpose : +// Input : +// Output : +//------------------------------------------------------------------------------ +void CC_Ent_Step( const CCommand& args ) +{ + int nSteps = atoi(args[1]); + if (nSteps <= 0) + { + nSteps = 1; + } + CBaseEntity::Debug_SetSteps(nSteps); +} +static ConCommand ent_step("ent_step", CC_Ent_Step, "When 'ent_pause' is set this will step through one waiting input / output message at a time.", FCVAR_CHEAT); + +void CBaseEntity::SetCheckUntouch( bool check ) +{ + // Invalidate touchstamp + if ( check ) + { + touchStamp++; + if ( !IsEFlagSet( EFL_CHECK_UNTOUCH ) ) + { + AddEFlags( EFL_CHECK_UNTOUCH ); + EntityTouch_Add( this ); + } + } + else + { + RemoveEFlags( EFL_CHECK_UNTOUCH ); + } +} + +model_t *CBaseEntity::GetModel( void ) +{ + return (model_t *)modelinfo->GetModel( GetModelIndex() ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Calculates the absolute position of an edict in the world +// assumes the parent's absolute origin has already been calculated +//----------------------------------------------------------------------------- +void CBaseEntity::CalcAbsolutePosition( void ) +{ + if (!IsEFlagSet( EFL_DIRTY_ABSTRANSFORM )) + return; + + RemoveEFlags( EFL_DIRTY_ABSTRANSFORM ); + + // Plop the entity->parent matrix into m_rgflCoordinateFrame + AngleMatrix( m_angRotation, m_vecOrigin, m_rgflCoordinateFrame ); + + CBaseEntity *pMoveParent = GetMoveParent(); + if ( !pMoveParent ) + { + // no move parent, so just copy existing values + m_vecAbsOrigin = m_vecOrigin; + m_angAbsRotation = m_angRotation; + if ( HasDataObjectType( POSITIONWATCHER ) ) + { + ReportPositionChanged( this ); + } + return; + } + + // concatenate with our parent's transform + matrix3x4_t tmpMatrix, scratchSpace; + ConcatTransforms( GetParentToWorldTransform( scratchSpace ), m_rgflCoordinateFrame, tmpMatrix ); + MatrixCopy( tmpMatrix, m_rgflCoordinateFrame ); + + // pull our absolute position out of the matrix + MatrixGetColumn( m_rgflCoordinateFrame, 3, m_vecAbsOrigin ); + + // if we have any angles, we have to extract our absolute angles from our matrix + if (( m_angRotation == vec3_angle ) && ( m_iParentAttachment == 0 )) + { + // just copy our parent's absolute angles + VectorCopy( pMoveParent->GetAbsAngles(), m_angAbsRotation ); + } + else + { + MatrixAngles( m_rgflCoordinateFrame, m_angAbsRotation ); + } + if ( HasDataObjectType( POSITIONWATCHER ) ) + { + ReportPositionChanged( this ); + } +} + +void CBaseEntity::CalcAbsoluteVelocity() +{ + if (!IsEFlagSet( EFL_DIRTY_ABSVELOCITY )) + return; + + RemoveEFlags( EFL_DIRTY_ABSVELOCITY ); + + CBaseEntity *pMoveParent = GetMoveParent(); + if ( !pMoveParent ) + { + m_vecAbsVelocity = m_vecVelocity; + return; + } + + // This transforms the local velocity into world space + VectorRotate( m_vecVelocity, pMoveParent->EntityToWorldTransform(), m_vecAbsVelocity ); + + // Now add in the parent abs velocity + m_vecAbsVelocity += pMoveParent->GetAbsVelocity(); +} + +// FIXME: While we're using (dPitch, dYaw, dRoll) as our local angular velocity +// representation, we can't actually solve this problem +/* +void CBaseEntity::CalcAbsoluteAngularVelocity() +{ + if (!IsEFlagSet( EFL_DIRTY_ABSANGVELOCITY )) + return; + + RemoveEFlags( EFL_DIRTY_ABSANGVELOCITY ); + + CBaseEntity *pMoveParent = GetMoveParent(); + if ( !pMoveParent ) + { + m_vecAbsAngVelocity = m_vecAngVelocity; + return; + } + + // This transforms the local ang velocity into world space + matrix3x4_t angVelToParent, angVelToWorld; + AngleMatrix( m_vecAngVelocity, angVelToParent ); + ConcatTransforms( pMoveParent->EntityToWorldTransform(), angVelToParent, angVelToWorld ); + MatrixAngles( angVelToWorld, m_vecAbsAngVelocity ); +} +*/ + +//----------------------------------------------------------------------------- +// Computes the abs position of a point specified in local space +//----------------------------------------------------------------------------- +void CBaseEntity::ComputeAbsPosition( const Vector &vecLocalPosition, Vector *pAbsPosition ) +{ + CBaseEntity *pMoveParent = GetMoveParent(); + if ( !pMoveParent ) + { + *pAbsPosition = vecLocalPosition; + } + else + { + VectorTransform( vecLocalPosition, pMoveParent->EntityToWorldTransform(), *pAbsPosition ); + } +} + + +//----------------------------------------------------------------------------- +// Computes the abs position of a point specified in local space +//----------------------------------------------------------------------------- +void CBaseEntity::ComputeAbsDirection( const Vector &vecLocalDirection, Vector *pAbsDirection ) +{ + CBaseEntity *pMoveParent = GetMoveParent(); + if ( !pMoveParent ) + { + *pAbsDirection = vecLocalDirection; + } + else + { + VectorRotate( vecLocalDirection, pMoveParent->EntityToWorldTransform(), *pAbsDirection ); + } +} + + +matrix3x4_t& CBaseEntity::GetParentToWorldTransform( matrix3x4_t &tempMatrix ) +{ + CBaseEntity *pMoveParent = GetMoveParent(); + if ( !pMoveParent ) + { + Assert( false ); + SetIdentityMatrix( tempMatrix ); + return tempMatrix; + } + + if ( m_iParentAttachment != 0 ) + { + MDLCACHE_CRITICAL_SECTION(); + + CBaseAnimating *pAnimating = pMoveParent->GetBaseAnimating(); + if ( pAnimating && pAnimating->GetAttachment( m_iParentAttachment, tempMatrix ) ) + { + return tempMatrix; + } + } + + // If we fall through to here, then just use the move parent's abs origin and angles. + return pMoveParent->EntityToWorldTransform(); +} + + +//----------------------------------------------------------------------------- +// These methods recompute local versions as well as set abs versions +//----------------------------------------------------------------------------- +void CBaseEntity::SetAbsOrigin( const Vector& absOrigin ) +{ + AssertMsg( absOrigin.IsValid(), "Invalid origin set" ); + + // This is necessary to get the other fields of m_rgflCoordinateFrame ok + CalcAbsolutePosition(); + + if ( m_vecAbsOrigin == absOrigin ) + return; + + // All children are invalid, but we are not + InvalidatePhysicsRecursive( POSITION_CHANGED ); + RemoveEFlags( EFL_DIRTY_ABSTRANSFORM ); + + m_vecAbsOrigin = absOrigin; + + MatrixSetColumn( absOrigin, 3, m_rgflCoordinateFrame ); + + Vector vecNewOrigin; + CBaseEntity *pMoveParent = GetMoveParent(); + if (!pMoveParent) + { + vecNewOrigin = absOrigin; + } + else + { + matrix3x4_t tempMat; + matrix3x4_t &parentTransform = GetParentToWorldTransform( tempMat ); + + // Moveparent case: transform the abs position into local space + VectorITransform( absOrigin, parentTransform, vecNewOrigin ); + } + + if (m_vecOrigin != vecNewOrigin) + { + m_vecOrigin = vecNewOrigin; + SetSimulationTime( gpGlobals->curtime ); + } +} + +void CBaseEntity::SetAbsAngles( const QAngle& absAngles ) +{ + // This is necessary to get the other fields of m_rgflCoordinateFrame ok + CalcAbsolutePosition(); + + // FIXME: The normalize caused problems in server code like momentary_rot_button that isn't + // handling things like +/-180 degrees properly. This should be revisited. + //QAngle angleNormalize( AngleNormalize( absAngles.x ), AngleNormalize( absAngles.y ), AngleNormalize( absAngles.z ) ); + + if ( m_angAbsRotation == absAngles ) + return; + + // All children are invalid, but we are not + InvalidatePhysicsRecursive( ANGLES_CHANGED ); + RemoveEFlags( EFL_DIRTY_ABSTRANSFORM ); + + m_angAbsRotation = absAngles; + AngleMatrix( absAngles, m_rgflCoordinateFrame ); + MatrixSetColumn( m_vecAbsOrigin, 3, m_rgflCoordinateFrame ); + + QAngle angNewRotation; + CBaseEntity *pMoveParent = GetMoveParent(); + if (!pMoveParent) + { + angNewRotation = absAngles; + } + else + { + if ( m_angAbsRotation == pMoveParent->GetAbsAngles() ) + { + angNewRotation.Init( ); + } + else + { + // Moveparent case: transform the abs transform into local space + matrix3x4_t worldToParent, localMatrix; + MatrixInvert( pMoveParent->EntityToWorldTransform(), worldToParent ); + ConcatTransforms( worldToParent, m_rgflCoordinateFrame, localMatrix ); + MatrixAngles( localMatrix, angNewRotation ); + } + } + + if (m_angRotation != angNewRotation) + { + m_angRotation = angNewRotation; + SetSimulationTime( gpGlobals->curtime ); + } +} + +void CBaseEntity::SetAbsVelocity( const Vector &vecAbsVelocity ) +{ + if ( m_vecAbsVelocity == vecAbsVelocity ) + return; + + // The abs velocity won't be dirty since we're setting it here + // All children are invalid, but we are not + InvalidatePhysicsRecursive( VELOCITY_CHANGED ); + RemoveEFlags( EFL_DIRTY_ABSVELOCITY ); + + m_vecAbsVelocity = vecAbsVelocity; + + // NOTE: Do *not* do a network state change in this case. + // m_vecVelocity is only networked for the player, which is not manual mode + CBaseEntity *pMoveParent = GetMoveParent(); + if (!pMoveParent) + { + m_vecVelocity = vecAbsVelocity; + return; + } + + // First subtract out the parent's abs velocity to get a relative + // velocity measured in world space + Vector relVelocity; + VectorSubtract( vecAbsVelocity, pMoveParent->GetAbsVelocity(), relVelocity ); + + // Transform relative velocity into parent space + Vector vNew; + VectorIRotate( relVelocity, pMoveParent->EntityToWorldTransform(), vNew ); + m_vecVelocity = vNew; +} + +// FIXME: While we're using (dPitch, dYaw, dRoll) as our local angular velocity +// representation, we can't actually solve this problem +/* +void CBaseEntity::SetAbsAngularVelocity( const QAngle &vecAbsAngVelocity ) +{ + // The abs velocity won't be dirty since we're setting it here + // All children are invalid, but we are not + InvalidatePhysicsRecursive( EFL_DIRTY_ABSANGVELOCITY ); + RemoveEFlags( EFL_DIRTY_ABSANGVELOCITY ); + + m_vecAbsAngVelocity = vecAbsAngVelocity; + + CBaseEntity *pMoveParent = GetMoveParent(); + if (!pMoveParent) + { + m_vecAngVelocity = vecAbsAngVelocity; + return; + } + + // NOTE: We *can't* subtract out parent ang velocity, it's nonsensical + matrix3x4_t entityToWorld; + AngleMatrix( vecAbsAngVelocity, entityToWorld ); + + // Moveparent case: transform the abs relative angular vel into local space + matrix3x4_t worldToParent, localMatrix; + MatrixInvert( pMoveParent->EntityToWorldTransform(), worldToParent ); + ConcatTransforms( worldToParent, entityToWorld, localMatrix ); + MatrixAngles( localMatrix, m_vecAngVelocity ); +} +*/ + +//----------------------------------------------------------------------------- +// Methods that modify local physics state, and let us know to compute abs state later +//----------------------------------------------------------------------------- +void CBaseEntity::SetLocalOrigin( const Vector& origin ) +{ + // Safety check against NaN's or really huge numbers + if ( !IsEntityPositionReasonable( origin ) ) + { + if ( CheckEmitReasonablePhysicsSpew() ) + { + Warning( "Bad SetLocalOrigin(%f,%f,%f) on %s\n", origin.x, origin.y, origin.z, GetDebugName() ); + } + Assert( false ); + return; + } + +// if ( !origin.IsValid() ) +// { +// AssertMsg( 0, "Bad origin set" ); +// return; +// } + + if (m_vecOrigin != origin) + { + // Sanity check to make sure the origin is valid. +#ifdef _DEBUG + float largeVal = 1024 * 128; + Assert( origin.x >= -largeVal && origin.x <= largeVal ); + Assert( origin.y >= -largeVal && origin.y <= largeVal ); + Assert( origin.z >= -largeVal && origin.z <= largeVal ); +#endif + + InvalidatePhysicsRecursive( POSITION_CHANGED ); + m_vecOrigin = origin; + SetSimulationTime( gpGlobals->curtime ); + } +} + +void CBaseEntity::SetLocalAngles( const QAngle& angles ) +{ + // NOTE: The angle normalize is a little expensive, but we can save + // a bunch of time in interpolation if we don't have to invalidate everything + // and sometimes it's off by a normalization amount + + // FIXME: The normalize caused problems in server code like momentary_rot_button that isn't + // handling things like +/-180 degrees properly. This should be revisited. + //QAngle angleNormalize( AngleNormalize( angles.x ), AngleNormalize( angles.y ), AngleNormalize( angles.z ) ); + + // Safety check against NaN's or really huge numbers + if ( !IsEntityQAngleReasonable( angles ) ) + { + if ( CheckEmitReasonablePhysicsSpew() ) + { + Warning( "Bad SetLocalAngles(%f,%f,%f) on %s\n", angles.x, angles.y, angles.z, GetDebugName() ); + } + Assert( false ); + return; + } + + if (m_angRotation != angles) + { + InvalidatePhysicsRecursive( ANGLES_CHANGED ); + m_angRotation = angles; + SetSimulationTime( gpGlobals->curtime ); + } +} + +void CBaseEntity::SetLocalVelocity( const Vector &inVecVelocity ) +{ + Vector vecVelocity = inVecVelocity; + + // Safety check against receive a huge impulse, which can explode physics + switch ( CheckEntityVelocity( vecVelocity ) ) + { + case -1: + Warning( "Discarding SetLocalVelocity(%f,%f,%f) on %s\n", vecVelocity.x, vecVelocity.y, vecVelocity.z, GetDebugName() ); + Assert( false ); + return; + case 0: + if ( CheckEmitReasonablePhysicsSpew() ) + { + Warning( "Clamping SetLocalVelocity(%f,%f,%f) on %s\n", inVecVelocity.x, inVecVelocity.y, inVecVelocity.z, GetDebugName() ); + } + break; + } + + if (m_vecVelocity != vecVelocity) + { + InvalidatePhysicsRecursive( VELOCITY_CHANGED ); + m_vecVelocity = vecVelocity; + } +} + +void CBaseEntity::SetLocalAngularVelocity( const QAngle &vecAngVelocity ) +{ + // Safety check against NaN's or really huge numbers + if ( !IsEntityQAngleVelReasonable( vecAngVelocity ) ) + { + if ( CheckEmitReasonablePhysicsSpew() ) + { + Warning( "Bad SetLocalAngularVelocity(%f,%f,%f) on %s\n", vecAngVelocity.x, vecAngVelocity.y, vecAngVelocity.z, GetDebugName() ); + } + Assert( false ); + return; + } + + if (m_vecAngVelocity != vecAngVelocity) + { +// InvalidatePhysicsRecursive( EFL_DIRTY_ABSANGVELOCITY ); + m_vecAngVelocity = vecAngVelocity; + } +} + + +//----------------------------------------------------------------------------- +// Sets the local position from a transform +//----------------------------------------------------------------------------- +void CBaseEntity::SetLocalTransform( const matrix3x4_t &localTransform ) +{ + // FIXME: Should angles go away? Should we just use transforms? + Vector vecLocalOrigin; + QAngle vecLocalAngles; + MatrixGetColumn( localTransform, 3, vecLocalOrigin ); + MatrixAngles( localTransform, vecLocalAngles ); + SetLocalOrigin( vecLocalOrigin ); + SetLocalAngles( vecLocalAngles ); +} + + +//----------------------------------------------------------------------------- +// Is the entity floating? +//----------------------------------------------------------------------------- +bool CBaseEntity::IsFloating() +{ + if ( !IsEFlagSet(EFL_TOUCHING_FLUID) ) + return false; + + IPhysicsObject *pObject = VPhysicsGetObject(); + if ( !pObject ) + return false; + + int nMaterialIndex = pObject->GetMaterialIndex(); + + float flDensity; + float flThickness; + float flFriction; + float flElasticity; + physprops->GetPhysicsProperties( nMaterialIndex, &flDensity, + &flThickness, &flFriction, &flElasticity ); + + // FIXME: This really only works for water at the moment.. + // Owing the check for density == 1000 + return (flDensity < 1000.0f); +} + + +//----------------------------------------------------------------------------- +// Purpose: Created predictable and sets up Id. Note that persist is ignored on the server. +// Input : *classname - +// *module - +// line - +// persist - +// Output : CBaseEntity +//----------------------------------------------------------------------------- +CBaseEntity *CBaseEntity::CreatePredictedEntityByName( const char *classname, const char *module, int line, bool persist /* = false */ ) +{ +#if !defined( NO_ENTITY_PREDICTION ) + CBasePlayer *player = CBaseEntity::GetPredictionPlayer(); + Assert( player ); + + CBaseEntity *ent = NULL; + + int command_number = player->CurrentCommandNumber(); + int player_index = player->entindex() - 1; + + CPredictableId testId; + testId.Init( player_index, command_number, classname, module, line ); + + ent = CreateEntityByName( classname ); + // No factory??? + if ( !ent ) + return NULL; + + ent->SetPredictionEligible( true ); + + // Set up "shared" id number + ent->m_PredictableID.GetForModify().SetRaw( testId.GetRaw() ); + + return ent; +#else + return NULL; +#endif + +} + +void CBaseEntity::SetPredictionEligible( bool canpredict ) +{ +// Nothing in game code m_bPredictionEligible = canpredict; +} + +//----------------------------------------------------------------------------- +// These could be virtual, but only the player is overriding them +// NOTE: If you make any of these virtual, remove this implementation!!! +//----------------------------------------------------------------------------- +void CBaseEntity::AddPoints( int score, bool bAllowNegativeScore ) +{ + CBasePlayer *pPlayer = ToBasePlayer(this); + if ( pPlayer ) + { + pPlayer->CBasePlayer::AddPoints( score, bAllowNegativeScore ); + } +} + +void CBaseEntity::AddPointsToTeam( int score, bool bAllowNegativeScore ) +{ + CBasePlayer *pPlayer = ToBasePlayer(this); + if ( pPlayer ) + { + pPlayer->CBasePlayer::AddPointsToTeam( score, bAllowNegativeScore ); + } +} + +void CBaseEntity::ViewPunch( const QAngle &angleOffset ) +{ + CBasePlayer *pPlayer = ToBasePlayer(this); + if ( pPlayer ) + { + pPlayer->CBasePlayer::ViewPunch( angleOffset ); + } +} + +void CBaseEntity::VelocityPunch( const Vector &vecForce ) +{ + CBasePlayer *pPlayer = ToBasePlayer(this); + if ( pPlayer ) + { + pPlayer->CBasePlayer::VelocityPunch( vecForce ); + } +} +//----------------------------------------------------------------------------- + + +//----------------------------------------------------------------------------- +// Purpose: Tell clients to remove all decals from this entity +//----------------------------------------------------------------------------- +void CBaseEntity::RemoveAllDecals( void ) +{ + EntityMessageBegin( this ); + WRITE_BYTE( BASEENTITY_MSG_REMOVE_DECALS ); + MessageEnd(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : set - +//----------------------------------------------------------------------------- +void CBaseEntity::ModifyOrAppendCriteria( AI_CriteriaSet& set ) +{ + // TODO + // Append chapter/day? + + set.AppendCriteria( "randomnum", UTIL_VarArgs("%d", RandomInt(0,100)) ); + // Append map name + set.AppendCriteria( "map", gpGlobals->mapname.ToCStr() ); + // Append our classname and game name + set.AppendCriteria( "classname", GetClassname() ); + set.AppendCriteria( "name", GetEntityName().ToCStr() ); + + // Append our health + set.AppendCriteria( "health", UTIL_VarArgs( "%i", GetHealth() ) ); + + float healthfrac = 0.0f; + if ( GetMaxHealth() > 0 ) + { + healthfrac = (float)GetHealth() / (float)GetMaxHealth(); + } + + set.AppendCriteria( "healthfrac", UTIL_VarArgs( "%.3f", healthfrac ) ); + + // Go through all the global states and append them + + for ( int i = 0; i < GlobalEntity_GetNumGlobals(); i++ ) + { + const char *szGlobalName = GlobalEntity_GetName(i); + int iGlobalState = (int)GlobalEntity_GetStateByIndex(i); + set.AppendCriteria( szGlobalName, UTIL_VarArgs( "%i", iGlobalState ) ); + } + + // Append anything from I/O or keyvalues pairs + AppendContextToCriteria( set ); + + if( hl2_episodic.GetBool() ) + { + set.AppendCriteria( "episodic", "1" ); + } + + // Append anything from world I/O/keyvalues with "world" as prefix + CWorld *world = dynamic_cast< CWorld * >( CBaseEntity::Instance( engine->PEntityOfEntIndex( 0 ) ) ); + if ( world ) + { + world->AppendContextToCriteria( set, "world" ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : set - +// "" - +//----------------------------------------------------------------------------- +void CBaseEntity::AppendContextToCriteria( AI_CriteriaSet& set, const char *prefix /*= ""*/ ) +{ + RemoveExpiredConcepts(); + + int c = GetContextCount(); + int i; + + char sz[ 128 ]; + for ( i = 0; i < c; i++ ) + { + const char *name = GetContextName( i ); + const char *value = GetContextValue( i ); + + Q_snprintf( sz, sizeof( sz ), "%s%s", prefix, name ); + + set.AppendCriteria( sz, value ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Removes expired concepts from list +// Output : +//----------------------------------------------------------------------------- +void CBaseEntity::RemoveExpiredConcepts( void ) +{ + int c = GetContextCount(); + int i; + + for ( i = 0; i < c; i++ ) + { + if ( ContextExpired( i ) ) + { + m_ResponseContexts.Remove( i ); + c--; + i--; + continue; + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Get current context count +// Output : int +//----------------------------------------------------------------------------- +int CBaseEntity::GetContextCount() const +{ + return m_ResponseContexts.Count(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : index - +// Output : const char +//----------------------------------------------------------------------------- +const char *CBaseEntity::GetContextName( int index ) const +{ + if ( index < 0 || index >= m_ResponseContexts.Count() ) + { + Assert( 0 ); + return ""; + } + + return m_ResponseContexts[ index ].m_iszName.ToCStr(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : index - +// Output : const char +//----------------------------------------------------------------------------- +const char *CBaseEntity::GetContextValue( int index ) const +{ + if ( index < 0 || index >= m_ResponseContexts.Count() ) + { + Assert( 0 ); + return ""; + } + + return m_ResponseContexts[ index ].m_iszValue.ToCStr(); +} + +//----------------------------------------------------------------------------- +// Purpose: Check if context has expired +// Input : index - +// Output : bool +//----------------------------------------------------------------------------- +bool CBaseEntity::ContextExpired( int index ) const +{ + if ( index < 0 || index >= m_ResponseContexts.Count() ) + { + Assert( 0 ); + return true; + } + + if ( !m_ResponseContexts[ index ].m_fExpirationTime ) + { + return false; + } + + return ( m_ResponseContexts[ index ].m_fExpirationTime <= gpGlobals->curtime ); +} + +//----------------------------------------------------------------------------- +// Purpose: Search for index of named context string +// Input : *name - +// Output : int +//----------------------------------------------------------------------------- +int CBaseEntity::FindContextByName( const char *name ) const +{ + int c = m_ResponseContexts.Count(); + for ( int i = 0; i < c; i++ ) + { + if ( FStrEq( name, GetContextName( i ) ) ) + return i; + } + + return -1; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : inputdata - +//----------------------------------------------------------------------------- +void CBaseEntity::InputAddContext( inputdata_t& inputdata ) +{ + const char *contextName = inputdata.value.String(); + AddContext( contextName ); +} + + +//----------------------------------------------------------------------------- +// Purpose: User inputs. These fire the corresponding user outputs, and are +// a means of forwarding messages through !activator to a target known +// known by !activator but not by the targetting entity. +// +// For example, say you have three identical trains, following the same +// path. Each train has a sprite in hierarchy with it that needs to +// toggle on/off as it passes each path_track. You would hook each train's +// OnUser1 output to it's sprite's Toggle input, then connect each path_track's +// OnPass output to !activator's FireUser1 input. +//----------------------------------------------------------------------------- +void CBaseEntity::InputFireUser1( inputdata_t& inputdata ) +{ + m_OnUser1.FireOutput( inputdata.pActivator, this ); +} + + +void CBaseEntity::InputFireUser2( inputdata_t& inputdata ) +{ + m_OnUser2.FireOutput( inputdata.pActivator, this ); +} + + +void CBaseEntity::InputFireUser3( inputdata_t& inputdata ) +{ + m_OnUser3.FireOutput( inputdata.pActivator, this ); +} + + +void CBaseEntity::InputFireUser4( inputdata_t& inputdata ) +{ + m_OnUser4.FireOutput( inputdata.pActivator, this ); +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *contextName - +//----------------------------------------------------------------------------- +void CBaseEntity::AddContext( const char *contextName ) +{ + char key[ 128 ]; + char value[ 128 ]; + float duration; + + const char *p = contextName; + while ( p ) + { + duration = 0.0f; + p = SplitContext( p, key, sizeof( key ), value, sizeof( value ), &duration ); + if ( duration ) + { + duration += gpGlobals->curtime; + } + + int iIndex = FindContextByName( key ); + if ( iIndex != -1 ) + { + // Set the existing context to the new value + m_ResponseContexts[iIndex].m_iszValue = AllocPooledString( value ); + m_ResponseContexts[iIndex].m_fExpirationTime = duration; + continue; + } + + ResponseContext_t newContext; + newContext.m_iszName = AllocPooledString( key ); + newContext.m_iszValue = AllocPooledString( value ); + newContext.m_fExpirationTime = duration; + + m_ResponseContexts.AddToTail( newContext ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : inputdata - +//----------------------------------------------------------------------------- +void CBaseEntity::InputRemoveContext( inputdata_t& inputdata ) +{ + const char *contextName = inputdata.value.String(); + int idx = FindContextByName( contextName ); + if ( idx == -1 ) + return; + + m_ResponseContexts.Remove( idx ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : inputdata - +//----------------------------------------------------------------------------- +void CBaseEntity::InputClearContext( inputdata_t& inputdata ) +{ + m_ResponseContexts.RemoveAll(); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : IResponseSystem +//----------------------------------------------------------------------------- +IResponseSystem *CBaseEntity::GetResponseSystem() +{ + return NULL; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : inputdata - +//----------------------------------------------------------------------------- +void CBaseEntity::InputDispatchResponse( inputdata_t& inputdata ) +{ + DispatchResponse( inputdata.value.String() ); +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CBaseEntity::InputDisableShadow( inputdata_t &inputdata ) +{ + AddEffects( EF_NOSHADOW ); +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CBaseEntity::InputEnableShadow( inputdata_t &inputdata ) +{ + RemoveEffects( EF_NOSHADOW ); +} + +//----------------------------------------------------------------------------- +// Purpose: An input to add a new connection from this entity +// Input : &inputdata - +//----------------------------------------------------------------------------- +void CBaseEntity::InputAddOutput( inputdata_t &inputdata ) +{ + char sOutputName[MAX_PATH]; + Q_strncpy( sOutputName, inputdata.value.String(), sizeof(sOutputName) ); + char *sChar = strchr( sOutputName, ' ' ); + if ( sChar ) + { + *sChar = '\0'; + // Now replace all the :'s in the string with ,'s. + // Has to be done this way because Hammer doesn't allow ,'s inside parameters. + char *sColon = strchr( sChar+1, ':' ); + while ( sColon ) + { + *sColon = ','; + sColon = strchr( sChar+1, ':' ); + } + KeyValue( sOutputName, sChar+1 ); + } + else + { + Warning("AddOutput input fired with bad string. Format: ,,,,\n"); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *conceptName - +//----------------------------------------------------------------------------- +void CBaseEntity::DispatchResponse( const char *conceptName ) +{ + IResponseSystem *rs = GetResponseSystem(); + if ( !rs ) + return; + + AI_CriteriaSet set; + // Always include the concept name + set.AppendCriteria( "concept", conceptName, CONCEPT_WEIGHT ); + // Let NPC fill in most match criteria + ModifyOrAppendCriteria( set ); + + // Append local player criteria to set,too + CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); + if( pPlayer ) + pPlayer->ModifyOrAppendPlayerCriteria( set ); + + // Now that we have a criteria set, ask for a suitable response + AI_Response result; + bool found = rs->FindBestResponse( set, result ); + if ( !found ) + { + return; + } + + // Handle the response here... + char response[ 256 ]; + result.GetResponse( response, sizeof( response ) ); + switch ( result.GetType() ) + { + case RESPONSE_SPEAK: + { + EmitSound( response ); + } + break; + case RESPONSE_SENTENCE: + { + int sentenceIndex = SENTENCEG_Lookup( response ); + if( sentenceIndex == -1 ) + { + // sentence not found + break; + } + + // FIXME: Get pitch from npc? + CPASAttenuationFilter filter( this ); + CBaseEntity::EmitSentenceByIndex( filter, entindex(), CHAN_VOICE, sentenceIndex, 1, result.GetSoundLevel(), 0, PITCH_NORM ); + } + break; + case RESPONSE_SCENE: + { + // Try to fire scene w/o an actor + InstancedScriptedScene( NULL, response ); + } + break; + case RESPONSE_PRINT: + { + + } + break; + default: + // Don't know how to handle .vcds!!! + break; + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseEntity::DumpResponseCriteria( void ) +{ + Msg("----------------------------------------------\n"); + Msg("RESPONSE CRITERIA FOR: %s (%s)\n", GetClassname(), GetDebugName() ); + + AI_CriteriaSet set; + // Let NPC fill in most match criteria + ModifyOrAppendCriteria( set ); + + // Append local player criteria to set,too + CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); + if ( pPlayer ) + { + pPlayer->ModifyOrAppendPlayerCriteria( set ); + } + + // Now dump it all to console + set.Describe(); +} + +//------------------------------------------------------------------------------ +void CC_Ent_Show_Response_Criteria( const CCommand& args ) +{ + CBaseEntity *pEntity = NULL; + while ( (pEntity = GetNextCommandEntity( UTIL_GetCommandClient(), args[1], pEntity )) != NULL ) + { + pEntity->DumpResponseCriteria(); + } +} +static ConCommand ent_show_response_criteria("ent_show_response_criteria", CC_Ent_Show_Response_Criteria, "Print, to the console, an entity's current criteria set used to select responses.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +// Purpose: Show an entity's autoaim radius +//------------------------------------------------------------------------------ +void CC_Ent_Autoaim( const CCommand& args ) +{ + SetDebugBits( UTIL_GetCommandClient(),args[1], OVERLAY_AUTOAIM_BIT ); +} +static ConCommand ent_autoaim("ent_autoaim", CC_Ent_Autoaim, "Displays the entity's autoaim radius.\n\tArguments: {entity_name} / {class_name} / no argument picks what player is looking at", FCVAR_CHEAT ); + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CAI_BaseNPC *CBaseEntity::MyNPCPointer( void ) +{ + if ( IsNPC() ) + return assert_cast(this); + + return NULL; +} + +ConVar step_spline( "step_spline", "0" ); + +//----------------------------------------------------------------------------- +// Purpose: Run one tick's worth of faked simulation +// Input : *step - +//----------------------------------------------------------------------------- +void CBaseEntity::ComputeStepSimulationNetwork( StepSimulationData *step ) +{ + if ( !step ) + { + Assert( !"ComputeStepSimulationNetworkOriginAndAngles with NULL step\n" ); + return; + } + + // Don't run again if we've already calculated this tick + if ( step->m_nLastProcessTickCount == gpGlobals->tickcount ) + { + return; + } + + step->m_nLastProcessTickCount = gpGlobals->tickcount; + + // Origin + // It's inactive + if ( step->m_bOriginActive ) + { + // First see if any external code moved the entity + if ( GetStepOrigin() != step->m_Next.vecOrigin ) + { + step->m_bOriginActive = false; + } + else + { + // Compute interpolated info based on tick interval + float frac = 1.0f; + int tickdelta = step->m_Next.nTickCount - step->m_Previous.nTickCount; + if ( tickdelta > 0 ) + { + frac = (float)( gpGlobals->tickcount - step->m_Previous.nTickCount ) / (float) tickdelta; + frac = clamp( frac, 0.0f, 1.0f ); + } + + if (step->m_Previous2.nTickCount == 0 || step->m_Previous2.nTickCount >= step->m_Previous.nTickCount) + { + Vector delta = step->m_Next.vecOrigin - step->m_Previous.vecOrigin; + VectorMA( step->m_Previous.vecOrigin, frac, delta, step->m_vecNetworkOrigin ); + } + else if (!step_spline.GetBool()) + { + StepSimulationStep *pOlder = &step->m_Previous; + StepSimulationStep *pNewer = &step->m_Next; + + if (step->m_Discontinuity.nTickCount > step->m_Previous.nTickCount) + { + if (gpGlobals->tickcount > step->m_Discontinuity.nTickCount) + { + pOlder = &step->m_Discontinuity; + } + else + { + pNewer = &step->m_Discontinuity; + } + + tickdelta = pNewer->nTickCount - pOlder->nTickCount; + if ( tickdelta > 0 ) + { + frac = (float)( gpGlobals->tickcount - pOlder->nTickCount ) / (float) tickdelta; + frac = clamp( frac, 0.0f, 1.0f ); + } + } + + Vector delta = pNewer->vecOrigin - pOlder->vecOrigin; + VectorMA( pOlder->vecOrigin, frac, delta, step->m_vecNetworkOrigin ); + } + else + { + Hermite_Spline( step->m_Previous2.vecOrigin, step->m_Previous.vecOrigin, step->m_Next.vecOrigin, frac, step->m_vecNetworkOrigin ); + } + } + } + + // Angles + if ( step->m_bAnglesActive ) + { + // See if external code changed the orientation of the entity + if ( GetStepAngles() != step->m_angNextRotation ) + { + step->m_bAnglesActive = false; + } + else + { + // Compute interpolated info based on tick interval + float frac = 1.0f; + int tickdelta = step->m_Next.nTickCount - step->m_Previous.nTickCount; + if ( tickdelta > 0 ) + { + frac = (float)( gpGlobals->tickcount - step->m_Previous.nTickCount ) / (float) tickdelta; + frac = clamp( frac, 0.0f, 1.0f ); + } + + if (step->m_Previous2.nTickCount == 0 || step->m_Previous2.nTickCount >= step->m_Previous.nTickCount) + { + // Pure blend between start/end orientations + Quaternion outangles; + QuaternionBlend( step->m_Previous.qRotation, step->m_Next.qRotation, frac, outangles ); + QuaternionAngles( outangles, step->m_angNetworkAngles ); + } + else if (!step_spline.GetBool()) + { + StepSimulationStep *pOlder = &step->m_Previous; + StepSimulationStep *pNewer = &step->m_Next; + + if (step->m_Discontinuity.nTickCount > step->m_Previous.nTickCount) + { + if (gpGlobals->tickcount > step->m_Discontinuity.nTickCount) + { + pOlder = &step->m_Discontinuity; + } + else + { + pNewer = &step->m_Discontinuity; + } + + tickdelta = pNewer->nTickCount - pOlder->nTickCount; + if ( tickdelta > 0 ) + { + frac = (float)( gpGlobals->tickcount - pOlder->nTickCount ) / (float) tickdelta; + frac = clamp( frac, 0.0f, 1.0f ); + } + } + + // Pure blend between start/end orientations + Quaternion outangles; + QuaternionBlend( pOlder->qRotation, pNewer->qRotation, frac, outangles ); + QuaternionAngles( outangles, step->m_angNetworkAngles ); + } + else + { + // FIXME: enable spline interpolation when turning is debounced. + Quaternion outangles; + Hermite_Spline( step->m_Previous2.qRotation, step->m_Previous.qRotation, step->m_Next.qRotation, frac, outangles ); + QuaternionAngles( outangles, step->m_angNetworkAngles ); + } + } + } + +} + + +//----------------------------------------------------------------------------- +bool CBaseEntity::UseStepSimulationNetworkOrigin( const Vector **out_v ) +{ + Assert( out_v ); + + + if ( g_bTestMoveTypeStepSimulation && + GetMoveType() == MOVETYPE_STEP && + HasDataObjectType( STEPSIMULATION ) ) + { + StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); + ComputeStepSimulationNetwork( step ); + *out_v = &step->m_vecNetworkOrigin; + + return step->m_bOriginActive; + } + + return false; +} + +//----------------------------------------------------------------------------- +bool CBaseEntity::UseStepSimulationNetworkAngles( const QAngle **out_a ) +{ + Assert( out_a ); + + if ( g_bTestMoveTypeStepSimulation && + GetMoveType() == MOVETYPE_STEP && + HasDataObjectType( STEPSIMULATION ) ) + { + StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); + ComputeStepSimulationNetwork( step ); + *out_a = &step->m_angNetworkAngles; + return step->m_bAnglesActive; + } + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- + +bool CBaseEntity::AddStepDiscontinuity( float flTime, const Vector &vecOrigin, const QAngle &vecAngles ) +{ + if ((GetMoveType() != MOVETYPE_STEP ) || !HasDataObjectType( STEPSIMULATION ) ) + { + return false; + } + + StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION ); + + if (!step) + { + Assert( 0 ); + return false; + } + + step->m_Discontinuity.nTickCount = TIME_TO_TICKS( flTime ); + step->m_Discontinuity.vecOrigin = vecOrigin; + AngleQuaternion( vecAngles, step->m_Discontinuity.qRotation ); + + return true; +} + + +Vector CBaseEntity::GetStepOrigin( void ) const +{ + return GetLocalOrigin(); +} + +QAngle CBaseEntity::GetStepAngles( void ) const +{ + return GetLocalAngles(); +} + +//----------------------------------------------------------------------------- +// Purpose: For each client who appears to be a valid recipient, checks the client has disabled CC and if so, removes them from +// the recipient list. +// Input : filter - +//----------------------------------------------------------------------------- +void CBaseEntity::RemoveRecipientsIfNotCloseCaptioning( CRecipientFilter& filter ) +{ + int c = filter.GetRecipientCount(); + for ( int i = c - 1; i >= 0; --i ) + { + int playerIndex = filter.GetRecipientIndex( i ); + + CBasePlayer *player = static_cast< CBasePlayer * >( CBaseEntity::Instance( playerIndex ) ); + if ( !player ) + continue; +#if !defined( _XBOX ) + const char *cvarvalue = engine->GetClientConVarValue( playerIndex, "closecaption" ); + Assert( cvarvalue ); + if ( !cvarvalue[ 0 ] ) + continue; + + int value = atoi( cvarvalue ); +#else + static ConVar *s_pCloseCaption = NULL; + if ( !s_pCloseCaption ) + { + s_pCloseCaption = cvar->FindVar( "closecaption" ); + if ( !s_pCloseCaption ) + { + Error( "XBOX couldn't find closecaption convar!!!" ); + } + } + + int value = s_pCloseCaption->GetInt(); +#endif + // No close captions? + if ( value == 0 ) + { + filter.RemoveRecipient( player ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Wrapper to emit a sentence and also a close caption token for the sentence as appropriate. +// Input : filter - +// iEntIndex - +// iChannel - +// iSentenceIndex - +// flVolume - +// iSoundlevel - +// iFlags - +// iPitch - +// bUpdatePositions - +// soundtime - +//----------------------------------------------------------------------------- +void CBaseEntity::EmitSentenceByIndex( IRecipientFilter& filter, int iEntIndex, int iChannel, int iSentenceIndex, + float flVolume, soundlevel_t iSoundlevel, int iFlags /*= 0*/, int iPitch /*=PITCH_NORM*/, + const Vector *pOrigin /*=NULL*/, const Vector *pDirection /*=NULL*/, + bool bUpdatePositions /*=true*/, float soundtime /*=0.0f*/ ) +{ + CUtlVector< Vector > dummy; + enginesound->EmitSentenceByIndex( filter, iEntIndex, iChannel, iSentenceIndex, + flVolume, iSoundlevel, iFlags, iPitch, 0, pOrigin, pDirection, &dummy, bUpdatePositions, soundtime ); +} + + +void CBaseEntity::SetRefEHandle( const CBaseHandle &handle ) +{ + m_RefEHandle = handle; + if ( edict() ) + { + COMPILE_TIME_ASSERT( NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS <= 8*sizeof( edict()->m_NetworkSerialNumber ) ); + edict()->m_NetworkSerialNumber = (m_RefEHandle.GetSerialNumber() & (1 << NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS) - 1); + } +} + + +bool CPointEntity::KeyValue( const char *szKeyName, const char *szValue ) +{ + if ( FStrEq( szKeyName, "mins" ) || FStrEq( szKeyName, "maxs" ) ) + { + Warning("Warning! Can't specify mins/maxs for point entities! (%s)\n", GetClassname() ); + return true; + } + + return BaseClass::KeyValue( szKeyName, szValue ); +} + +bool CServerOnlyPointEntity::KeyValue( const char *szKeyName, const char *szValue ) +{ + if ( FStrEq( szKeyName, "mins" ) || FStrEq( szKeyName, "maxs" ) ) + { + Warning("Warning! Can't specify mins/maxs for point entities! (%s)\n", GetClassname() ); + return true; + } + + return BaseClass::KeyValue( szKeyName, szValue ); +} + +bool CLogicalEntity::KeyValue( const char *szKeyName, const char *szValue ) +{ + if ( FStrEq( szKeyName, "mins" ) || FStrEq( szKeyName, "maxs" ) ) + { + Warning("Warning! Can't specify mins/maxs for point entities! (%s)\n", GetClassname() ); + return true; + } + + return BaseClass::KeyValue( szKeyName, szValue ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the entity invisible, and makes it remove itself on the next frame +//----------------------------------------------------------------------------- +void CBaseEntity::RemoveDeferred( void ) +{ + // Set our next think to remove us + SetThink( &CBaseEntity::SUB_Remove ); + SetNextThink( gpGlobals->curtime + 0.1f ); + + // Hide us completely + AddEffects( EF_NODRAW ); + AddSolidFlags( FSOLID_NOT_SOLID ); + SetMoveType( MOVETYPE_NONE ); +} + +#define MIN_CORPSE_FADE_TIME 10.0 +#define MIN_CORPSE_FADE_DIST 256.0 +#define MAX_CORPSE_FADE_DIST 1500.0 + +// +// fade out - slowly fades a entity out, then removes it. +// +// DON'T USE ME FOR GIBS AND STUFF IN MULTIPLAYER! +// SET A FUTURE THINK AND A RENDERMODE!! +void CBaseEntity::SUB_StartFadeOut( float delay, bool notSolid ) +{ + SetThink( &CBaseEntity::SUB_FadeOut ); + SetNextThink( gpGlobals->curtime + delay ); + SetRenderColorA( 255 ); + m_nRenderMode = kRenderNormal; + + if ( notSolid ) + { + AddSolidFlags( FSOLID_NOT_SOLID ); + SetLocalAngularVelocity( vec3_angle ); + } +} + +void CBaseEntity::SUB_StartFadeOutInstant() +{ + SUB_StartFadeOut( 0, true ); +} + +//----------------------------------------------------------------------------- +// Purpose: Vanish when players aren't looking +//----------------------------------------------------------------------------- +void CBaseEntity::SUB_Vanish( void ) +{ + //Always think again next frame + SetNextThink( gpGlobals->curtime + 0.1f ); + + CBasePlayer *pPlayer; + + //Get all players + for ( int i = 1; i <= gpGlobals->maxClients; i++ ) + { + //Get the next client + if ( ( pPlayer = UTIL_PlayerByIndex( i ) ) != NULL ) + { + Vector corpseDir = (GetAbsOrigin() - pPlayer->WorldSpaceCenter() ); + + float flDistSqr = corpseDir.LengthSqr(); + //If the player is close enough, don't fade out + if ( flDistSqr < (MIN_CORPSE_FADE_DIST*MIN_CORPSE_FADE_DIST) ) + return; + + // If the player's far enough away, we don't care about looking at it + if ( flDistSqr < (MAX_CORPSE_FADE_DIST*MAX_CORPSE_FADE_DIST) ) + { + VectorNormalize( corpseDir ); + + Vector plForward; + pPlayer->EyeVectors( &plForward ); + + float dot = plForward.Dot( corpseDir ); + + if ( dot > 0.0f ) + return; + } + } + } + + //If we're here, then we can vanish safely + m_iHealth = 0; + SetThink( &CBaseEntity::SUB_Remove ); +} + +void CBaseEntity::SUB_PerformFadeOut( void ) +{ + float dt = gpGlobals->frametime; + if ( dt > 0.1f ) + { + dt = 0.1f; + } + m_nRenderMode = kRenderTransTexture; + int speed = MAX(1,256*dt); // fade out over 1 second + SetRenderColorA( UTIL_Approach( 0, m_clrRender->a, speed ) ); +} + +bool CBaseEntity::SUB_AllowedToFade( void ) +{ + if( VPhysicsGetObject() ) + { + if( VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD || GetEFlags() & EFL_IS_BEING_LIFTED_BY_BARNACLE ) + return false; + } + + // on Xbox, allow these to fade out +#ifndef _XBOX + CBasePlayer *pPlayer = ( AI_IsSinglePlayer() ) ? UTIL_GetLocalPlayer() : NULL; + + if ( pPlayer && pPlayer->FInViewCone( this ) ) + return false; +#endif + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Fade out slowly +//----------------------------------------------------------------------------- +void CBaseEntity::SUB_FadeOut( void ) +{ + if ( SUB_AllowedToFade() == false ) + { + SetNextThink( gpGlobals->curtime + 1 ); + SetRenderColorA( 255 ); + return; + } + + SUB_PerformFadeOut(); + + if ( m_clrRender->a == 0 ) + { + UTIL_Remove(this); + } + else + { + SetNextThink( gpGlobals->curtime ); + } +} + + +inline bool AnyPlayersInHierarchy_R( CBaseEntity *pEnt ) +{ + if ( pEnt->IsPlayer() ) + return true; + + for ( CBaseEntity *pCur = pEnt->FirstMoveChild(); pCur; pCur=pCur->NextMovePeer() ) + { + if ( AnyPlayersInHierarchy_R( pCur ) ) + return true; + } + + return false; +} + + +void CBaseEntity::RecalcHasPlayerChildBit() +{ + if ( AnyPlayersInHierarchy_R( this ) ) + AddEFlags( EFL_HAS_PLAYER_CHILD ); + else + RemoveEFlags( EFL_HAS_PLAYER_CHILD ); +} + + +bool CBaseEntity::DoesHavePlayerChild() +{ + return IsEFlagSet( EFL_HAS_PLAYER_CHILD ); +} + + +//------------------------------------------------------------------------------ +void CBaseEntity::IncrementInterpolationFrame() +{ + m_ubInterpolationFrame = (m_ubInterpolationFrame + 1) % NOINTERP_PARITY_MAX; +} + +//------------------------------------------------------------------------------ + +void CBaseEntity::OnModelLoadComplete( const model_t* model ) +{ + Assert( m_bDynamicModelPending && IsDynamicModelIndex( m_nModelIndex ) ); + Assert( model == modelinfo->GetModel( m_nModelIndex ) ); + + m_bDynamicModelPending = false; + + if ( m_bDynamicModelSetBounds ) + { + m_bDynamicModelSetBounds = false; + SetCollisionBoundsFromModel(); + } + + OnNewModel(); +} + +//------------------------------------------------------------------------------ + +void CBaseEntity::SetCollisionBoundsFromModel() +{ + if ( IsDynamicModelLoading() ) + { + m_bDynamicModelSetBounds = true; + return; + } + + if ( const model_t *pModel = GetModel() ) + { + Vector mns, mxs; + modelinfo->GetModelBounds( pModel, mns, mxs ); + UTIL_SetSize( this, mns, mxs ); + } +} + + +//------------------------------------------------------------------------------ +// Purpose: Create an NPC of the given type +//------------------------------------------------------------------------------ +void CC_Ent_Create( const CCommand& args ) +{ + MDLCACHE_CRITICAL_SECTION(); + + CBasePlayer *pPlayer = UTIL_GetCommandClient(); + if (!pPlayer) + { + return; + } + + // Don't allow regular users to create point_servercommand entities for the same reason as blocking ent_fire + if ( !Q_stricmp( args[1], "point_servercommand" ) ) + { + if ( engine->IsDedicatedServer() ) + { + // We allow people with disabled autokick to do it, because they already have rcon. + if ( pPlayer->IsAutoKickDisabled() == false ) + return; + } + else if ( gpGlobals->maxClients > 1 ) + { + // On listen servers with more than 1 player, only allow the host to create point_servercommand. + CBasePlayer *pHostPlayer = UTIL_GetListenServerHost(); + if ( pPlayer != pHostPlayer ) + return; + } + } + + bool allowPrecache = CBaseEntity::IsPrecacheAllowed(); + CBaseEntity::SetAllowPrecache( true ); + + // Try to create entity + CBaseEntity *entity = dynamic_cast< CBaseEntity * >( CreateEntityByName(args[1]) ); + if (entity) + { + entity->Precache(); + + // Pass in any additional parameters. + for ( int i = 2; i + 1 < args.ArgC(); i += 2 ) + { + const char *pKeyName = args[i]; + const char *pValue = args[i+1]; + entity->KeyValue( pKeyName, pValue ); + } + + DispatchSpawn(entity); + + // Now attempt to drop into the world + trace_t tr; + Vector forward; + pPlayer->EyeVectors( &forward ); + UTIL_TraceLine(pPlayer->EyePosition(), + pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_SOLID, + pPlayer, COLLISION_GROUP_NONE, &tr ); + if ( tr.fraction != 1.0 ) + { + // Raise the end position a little up off the floor, place the npc and drop him down + tr.endpos.z += 12; + entity->Teleport( &tr.endpos, NULL, NULL ); + UTIL_DropToFloor( entity, MASK_SOLID ); + } + + entity->Activate(); + } + CBaseEntity::SetAllowPrecache( allowPrecache ); +} +static ConCommand ent_create("ent_create", CC_Ent_Create, "Creates an entity of the given type where the player is looking. Additional parameters can be passed in in the form: ent_create ... ", FCVAR_GAMEDLL | FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +// Purpose: Teleport a specified entity to where the player is looking +//------------------------------------------------------------------------------ +bool CC_GetCommandEnt( const CCommand& args, CBaseEntity **ent, Vector *vecTargetPoint, QAngle *vecPlayerAngle ) +{ + // Find the entity + *ent = NULL; + // First try using it as an entindex + int iEntIndex = atoi( args[1] ); + if ( iEntIndex ) + { + *ent = CBaseEntity::Instance( iEntIndex ); + } + else + { + // Try finding it by name + *ent = gEntList.FindEntityByName( NULL, args[1] ); + + if ( !*ent ) + { + // Finally, try finding it by classname + *ent = gEntList.FindEntityByClassname( NULL, args[1] ); + } + } + + if ( !*ent ) + { + Msg( "Couldn't find any entity named '%s'\n", args[1] ); + return false; + } + + CBasePlayer *pPlayer = UTIL_GetCommandClient(); + if ( vecTargetPoint ) + { + trace_t tr; + Vector forward; + pPlayer->EyeVectors( &forward ); + UTIL_TraceLine(pPlayer->EyePosition(), + pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_NPCSOLID, + pPlayer, COLLISION_GROUP_NONE, &tr ); + + if ( tr.fraction != 1.0 ) + { + *vecTargetPoint = tr.endpos; + } + } + + if ( vecPlayerAngle ) + { + *vecPlayerAngle = pPlayer->EyeAngles(); + } + + return true; +} + +//------------------------------------------------------------------------------ +// Purpose: Teleport a specified entity to where the player is looking +//------------------------------------------------------------------------------ +void CC_Ent_Teleport( const CCommand& args ) +{ + if ( args.ArgC() < 2 ) + { + Msg( "Format: ent_teleport \n" ); + return; + } + + CBaseEntity *pEnt; + Vector vecTargetPoint; + if ( CC_GetCommandEnt( args, &pEnt, &vecTargetPoint, NULL ) ) + { + pEnt->Teleport( &vecTargetPoint, NULL, NULL ); + } +} + +static ConCommand ent_teleport("ent_teleport", CC_Ent_Teleport, "Teleport the specified entity to where the player is looking.\n\tFormat: ent_teleport ", FCVAR_CHEAT); + +//------------------------------------------------------------------------------ +// Purpose: Orient a specified entity to match the player's angles +//------------------------------------------------------------------------------ +void CC_Ent_Orient( const CCommand& args ) +{ + if ( args.ArgC() < 2 ) + { + Msg( "Format: ent_orient \n" ); + return; + } + + CBaseEntity *pEnt; + QAngle vecPlayerAngles; + if ( CC_GetCommandEnt( args, &pEnt, NULL, &vecPlayerAngles ) ) + { + QAngle vecEntAngles = pEnt->GetAbsAngles(); + if ( args.ArgC() == 3 && !Q_strncmp( args[2], "allangles", 9 ) ) + { + vecEntAngles = vecPlayerAngles; + } + else + { + vecEntAngles[YAW] = vecPlayerAngles[YAW]; + } + + pEnt->SetAbsAngles( vecEntAngles ); + } +} + +static ConCommand ent_orient("ent_orient", CC_Ent_Orient, "Orient the specified entity to match the player's angles. By default, only orients target entity's YAW. Use the 'allangles' option to orient on all axis.\n\tFormat: ent_orient ", FCVAR_CHEAT); -- cgit v1.2.3