//========= 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, 0 ) ), #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(); } if ( IsPlayer() ) { // Tell the client being teleported IGameEvent *event = gameeventmanager->CreateEvent( "base_player_teleported" ); if ( event ) { event->SetInt( "entindex", entindex() ); gameeventmanager->FireEventClientSide( event ); } } 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); 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);