//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Spawn and use functions for editor-placed triggers. // //===========================================================================// #include "cbase.h" #include "ai_basenpc.h" #include "player.h" #include "saverestore.h" #include "gamerules.h" #include "entityapi.h" #include "entitylist.h" #include "ndebugoverlay.h" #include "globalstate.h" #include "filters.h" #include "vstdlib/random.h" #include "triggers.h" #include "saverestoretypes.h" #include "hierarchy.h" #include "bspfile.h" #include "saverestore_utlvector.h" #include "physics_saverestore.h" #include "te_effect_dispatch.h" #include "ammodef.h" #include "iservervehicle.h" #include "movevars_shared.h" #include "physics_prop_ragdoll.h" #include "props.h" #include "RagdollBoogie.h" #include "EntityParticleTrail.h" #include "in_buttons.h" #include "ai_behavior_follow.h" #include "ai_behavior_lead.h" #include "gameinterface.h" #include "ilagcompensationmanager.h" #ifdef HL2_DLL #include "hl2_player.h" #endif // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" #define DEBUG_TRANSITIONS_VERBOSE 2 ConVar g_debug_transitions( "g_debug_transitions", "0", FCVAR_NONE, "Set to 1 and restart the map to be warned if the map has no trigger_transition volumes. Set to 2 to see a dump of all entities & associated results during a transition." ); // Global list of triggers that care about weapon fire // Doesn't need saving, the triggers re-add themselves on restore. CUtlVector< CHandle > g_hWeaponFireTriggers; extern CServerGameDLL g_ServerGameDLL; extern bool g_fGameOver; ConVar showtriggers( "showtriggers", "0", FCVAR_CHEAT, "Shows trigger brushes" ); bool IsTriggerClass( CBaseEntity *pEntity ); // Command to dynamically toggle trigger visibility void Cmd_ShowtriggersToggle_f( const CCommand &args ) { // Loop through the entities in the game and make visible anything derived from CBaseTrigger CBaseEntity *pEntity = gEntList.FirstEnt(); while ( pEntity ) { if ( IsTriggerClass(pEntity) ) { // If a classname is specified, only show triggles of that type if ( args.ArgC() > 1 ) { const char *sClassname = args[1]; if ( sClassname && sClassname[0] ) { if ( !FClassnameIs( pEntity, sClassname ) ) { pEntity = gEntList.NextEnt( pEntity ); continue; } } } if ( pEntity->IsEffectActive( EF_NODRAW ) ) { pEntity->RemoveEffects( EF_NODRAW ); } else { pEntity->AddEffects( EF_NODRAW ); } } pEntity = gEntList.NextEnt( pEntity ); } } static ConCommand showtriggers_toggle( "showtriggers_toggle", Cmd_ShowtriggersToggle_f, "Toggle show triggers", FCVAR_CHEAT ); // Global Savedata for base trigger BEGIN_DATADESC( CBaseTrigger ) // Keyfields DEFINE_KEYFIELD( m_iFilterName, FIELD_STRING, "filtername" ), DEFINE_FIELD( m_hFilter, FIELD_EHANDLE ), DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ), DEFINE_UTLVECTOR( m_hTouchingEntities, FIELD_EHANDLE ), // Inputs DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ), DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ), DEFINE_INPUTFUNC( FIELD_VOID, "DisableAndEndTouch", InputDisableAndEndTouch ), DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ), DEFINE_INPUTFUNC( FIELD_VOID, "TouchTest", InputTouchTest ), DEFINE_INPUTFUNC( FIELD_VOID, "StartTouch", InputStartTouch ), DEFINE_INPUTFUNC( FIELD_VOID, "EndTouch", InputEndTouch ), // Outputs DEFINE_OUTPUT( m_OnStartTouch, "OnStartTouch"), DEFINE_OUTPUT( m_OnStartTouchAll, "OnStartTouchAll"), DEFINE_OUTPUT( m_OnEndTouch, "OnEndTouch"), DEFINE_OUTPUT( m_OnEndTouchAll, "OnEndTouchAll"), DEFINE_OUTPUT( m_OnTouching, "OnTouching" ), DEFINE_OUTPUT( m_OnNotTouching, "OnNotTouching" ), END_DATADESC() LINK_ENTITY_TO_CLASS( trigger, CBaseTrigger ); CBaseTrigger::CBaseTrigger() { AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID ); } //------------------------------------------------------------------------------ // Purpose: Input handler to turn on this trigger. //------------------------------------------------------------------------------ void CBaseTrigger::InputEnable( inputdata_t &inputdata ) { Enable(); } //------------------------------------------------------------------------------ // Purpose: Input handler to turn off this trigger. //------------------------------------------------------------------------------ void CBaseTrigger::InputDisable( inputdata_t &inputdata ) { Disable(); } //------------------------------------------------------------------------------ // Purpose: Input handler to call EndTouch on all touching entities, and then // turn off this trigger //------------------------------------------------------------------------------ void CBaseTrigger::InputDisableAndEndTouch( inputdata_t &inputdata ) { FOR_EACH_VEC_BACK( m_hTouchingEntities, i ) { if ( m_hTouchingEntities[i] ) { EndTouch( m_hTouchingEntities[ i ] ); } else { m_hTouchingEntities.Remove( i ); } } Disable(); } void CBaseTrigger::InputTouchTest( inputdata_t &inputdata ) { TouchTest(); } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ void CBaseTrigger::Spawn() { if ( HasSpawnFlags( SF_TRIGGER_ONLY_PLAYER_ALLY_NPCS ) || HasSpawnFlags( SF_TRIGGER_ONLY_NPCS_IN_VEHICLES ) ) { // Automatically set this trigger to work with NPC's. AddSpawnFlags( SF_TRIGGER_ALLOW_NPCS ); } if ( HasSpawnFlags( SF_TRIGGER_ONLY_CLIENTS_IN_VEHICLES ) ) { AddSpawnFlags( SF_TRIGGER_ALLOW_CLIENTS ); } if ( HasSpawnFlags( SF_TRIGGER_ONLY_CLIENTS_OUT_OF_VEHICLES ) ) { AddSpawnFlags( SF_TRIGGER_ALLOW_CLIENTS ); } BaseClass::Spawn(); } //------------------------------------------------------------------------------ // Cleanup //------------------------------------------------------------------------------ void CBaseTrigger::UpdateOnRemove( void ) { if ( VPhysicsGetObject()) { VPhysicsGetObject()->RemoveTrigger(); } BaseClass::UpdateOnRemove(); } //------------------------------------------------------------------------------ // Purpose: Turns on this trigger. //------------------------------------------------------------------------------ void CBaseTrigger::Enable( void ) { m_bDisabled = false; if ( VPhysicsGetObject()) { VPhysicsGetObject()->EnableCollisions( true ); } if (!IsSolidFlagSet( FSOLID_TRIGGER )) { AddSolidFlags( FSOLID_TRIGGER ); PhysicsTouchTriggers(); } } //------------------------------------------------------------------------------ // Purpose : //------------------------------------------------------------------------------ void CBaseTrigger::Activate( void ) { // Get a handle to my filter entity if there is one if (m_iFilterName != NULL_STRING) { m_hFilter = dynamic_cast(gEntList.FindEntityByName( NULL, m_iFilterName )); } BaseClass::Activate(); } //----------------------------------------------------------------------------- // Purpose: Called after player becomes active in the game //----------------------------------------------------------------------------- void CBaseTrigger::PostClientActive( void ) { BaseClass::PostClientActive(); if ( !m_bDisabled ) { PhysicsTouchTriggers(); } } //------------------------------------------------------------------------------ // Purpose: Turns off this trigger. //------------------------------------------------------------------------------ void CBaseTrigger::Disable( void ) { m_bDisabled = true; if ( VPhysicsGetObject()) { VPhysicsGetObject()->EnableCollisions( false ); } if (IsSolidFlagSet(FSOLID_TRIGGER)) { RemoveSolidFlags( FSOLID_TRIGGER ); PhysicsTouchTriggers(); } } //------------------------------------------------------------------------------ // Purpose: Tests to see if anything is touching this trigger. //------------------------------------------------------------------------------ void CBaseTrigger::TouchTest( void ) { // If the trigger is disabled don't test to see if anything is touching it. if ( !m_bDisabled ) { if ( m_hTouchingEntities.Count() !=0 ) { m_OnTouching.FireOutput( this, this ); } else { m_OnNotTouching.FireOutput( this, this ); } } } //----------------------------------------------------------------------------- // Purpose: Draw any debug text overlays // Output : Current text offset from the top //----------------------------------------------------------------------------- int CBaseTrigger::DrawDebugTextOverlays(void) { int text_offset = BaseClass::DrawDebugTextOverlays(); if (m_debugOverlays & OVERLAY_TEXT_BIT) { // -------------- // Print Target // -------------- char tempstr[255]; if (IsSolidFlagSet(FSOLID_TRIGGER)) { Q_strncpy(tempstr,"State: Enabled",sizeof(tempstr)); } else { Q_strncpy(tempstr,"State: Disabled",sizeof(tempstr)); } EntityText(text_offset,tempstr,0); text_offset++; } return text_offset; } //----------------------------------------------------------------------------- // Purpose: Return true if the specified point is within this zone //----------------------------------------------------------------------------- bool CBaseTrigger::PointIsWithin( const Vector &vecPoint ) { Ray_t ray; trace_t tr; ICollideable *pCollide = CollisionProp(); ray.Init( vecPoint, vecPoint ); enginetrace->ClipRayToCollideable( ray, MASK_ALL, pCollide, &tr ); return ( tr.startsolid ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CBaseTrigger::InitTrigger( ) { SetSolid( GetParent() ? SOLID_VPHYSICS : SOLID_BSP ); AddSolidFlags( FSOLID_NOT_SOLID ); if (m_bDisabled) { RemoveSolidFlags( FSOLID_TRIGGER ); } else { AddSolidFlags( FSOLID_TRIGGER ); } SetMoveType( MOVETYPE_NONE ); SetModel( STRING( GetModelName() ) ); // set size and link into world if ( showtriggers.GetInt() == 0 ) { AddEffects( EF_NODRAW ); } m_hTouchingEntities.Purge(); if ( HasSpawnFlags( SF_TRIG_TOUCH_DEBRIS ) ) { CollisionProp()->AddSolidFlags( FSOLID_TRIGGER_TOUCH_DEBRIS ); } } //----------------------------------------------------------------------------- // Purpose: Returns true if this entity passes the filter criteria, false if not. // Input : pOther - The entity to be filtered. //----------------------------------------------------------------------------- bool CBaseTrigger::PassesTriggerFilters(CBaseEntity *pOther) { // First test spawn flag filters if ( HasSpawnFlags(SF_TRIGGER_ALLOW_ALL) || (HasSpawnFlags(SF_TRIGGER_ALLOW_CLIENTS) && (pOther->GetFlags() & FL_CLIENT)) || (HasSpawnFlags(SF_TRIGGER_ALLOW_NPCS) && (pOther->GetFlags() & FL_NPC)) || (HasSpawnFlags(SF_TRIGGER_ALLOW_PUSHABLES) && FClassnameIs(pOther, "func_pushable")) || (HasSpawnFlags(SF_TRIGGER_ALLOW_PHYSICS) && pOther->GetMoveType() == MOVETYPE_VPHYSICS) #if defined( HL2_EPISODIC ) || defined( TF_DLL ) || ( HasSpawnFlags(SF_TRIG_TOUCH_DEBRIS) && (pOther->GetCollisionGroup() == COLLISION_GROUP_DEBRIS || pOther->GetCollisionGroup() == COLLISION_GROUP_DEBRIS_TRIGGER || pOther->GetCollisionGroup() == COLLISION_GROUP_INTERACTIVE_DEBRIS) ) #endif ) { if ( pOther->GetFlags() & FL_NPC ) { CAI_BaseNPC *pNPC = pOther->MyNPCPointer(); if ( HasSpawnFlags( SF_TRIGGER_ONLY_PLAYER_ALLY_NPCS ) ) { if ( !pNPC || !pNPC->IsPlayerAlly() ) { return false; } } if ( HasSpawnFlags( SF_TRIGGER_ONLY_NPCS_IN_VEHICLES ) ) { if ( !pNPC || !pNPC->IsInAVehicle() ) return false; } } bool bOtherIsPlayer = pOther->IsPlayer(); if ( bOtherIsPlayer ) { CBasePlayer *pPlayer = (CBasePlayer*)pOther; if ( !pPlayer->IsAlive() ) return false; if ( HasSpawnFlags(SF_TRIGGER_ONLY_CLIENTS_IN_VEHICLES) ) { if ( !pPlayer->IsInAVehicle() ) return false; // Make sure we're also not exiting the vehicle at the moment IServerVehicle *pVehicleServer = pPlayer->GetVehicle(); if ( pVehicleServer == NULL ) return false; if ( pVehicleServer->IsPassengerExiting() ) return false; } if ( HasSpawnFlags(SF_TRIGGER_ONLY_CLIENTS_OUT_OF_VEHICLES) ) { if ( pPlayer->IsInAVehicle() ) return false; } if ( HasSpawnFlags( SF_TRIGGER_DISALLOW_BOTS ) ) { if ( pPlayer->IsFakeClient() ) return false; } } CBaseFilter *pFilter = m_hFilter.Get(); return (!pFilter) ? true : pFilter->PassesFilter( this, pOther ); } return false; } //----------------------------------------------------------------------------- // Purpose: Called to simulate what happens when an entity touches the trigger. // Input : pOther - The entity that is touching us. //----------------------------------------------------------------------------- void CBaseTrigger::InputStartTouch( inputdata_t &inputdata ) { //Pretend we just touched the trigger. StartTouch( inputdata.pCaller ); } //----------------------------------------------------------------------------- // Purpose: Called to simulate what happens when an entity leaves the trigger. // Input : pOther - The entity that is touching us. //----------------------------------------------------------------------------- void CBaseTrigger::InputEndTouch( inputdata_t &inputdata ) { //And... pretend we left the trigger. EndTouch( inputdata.pCaller ); } //----------------------------------------------------------------------------- // Purpose: Called when an entity starts touching us. // Input : pOther - The entity that is touching us. //----------------------------------------------------------------------------- void CBaseTrigger::StartTouch(CBaseEntity *pOther) { if (PassesTriggerFilters(pOther) ) { EHANDLE hOther; hOther = pOther; bool bAdded = false; if ( m_hTouchingEntities.Find( hOther ) == m_hTouchingEntities.InvalidIndex() ) { m_hTouchingEntities.AddToTail( hOther ); bAdded = true; } m_OnStartTouch.FireOutput(pOther, this); if ( bAdded && ( m_hTouchingEntities.Count() == 1 ) ) { // First entity to touch us that passes our filters m_OnStartTouchAll.FireOutput( pOther, this ); StartTouchAll(); } } } //----------------------------------------------------------------------------- // Purpose: Called when an entity stops touching us. // Input : pOther - The entity that was touching us. //----------------------------------------------------------------------------- void CBaseTrigger::EndTouch(CBaseEntity *pOther) { if ( IsTouching( pOther ) ) { EHANDLE hOther; hOther = pOther; m_hTouchingEntities.FindAndRemove( hOther ); //FIXME: Without this, triggers fire their EndTouch outputs when they are disabled! //if ( !m_bDisabled ) //{ m_OnEndTouch.FireOutput(pOther, this); //} // If there are no more entities touching this trigger, fire the lost all touches // Loop through the touching entities backwards. Clean out old ones, and look for existing bool bFoundOtherTouchee = false; int iSize = m_hTouchingEntities.Count(); for ( int i = iSize-1; i >= 0; i-- ) { EHANDLE hOther; hOther = m_hTouchingEntities[i]; if ( !hOther ) { m_hTouchingEntities.Remove( i ); } else if ( hOther->IsPlayer() && !hOther->IsAlive() ) { #ifdef STAGING_ONLY if ( !HushAsserts() ) { AssertMsg( false, "Dead player [%s] is still touching this trigger at [%f %f %f]", hOther->GetEntityName().ToCStr(), XYZ( hOther->GetAbsOrigin() ) ); } Warning( "Dead player [%s] is still touching this trigger at [%f %f %f]", hOther->GetEntityName().ToCStr(), XYZ( hOther->GetAbsOrigin() ) ); #endif m_hTouchingEntities.Remove( i ); } else { bFoundOtherTouchee = true; } } //FIXME: Without this, triggers fire their EndTouch outputs when they are disabled! // Didn't find one? if ( !bFoundOtherTouchee /*&& !m_bDisabled*/ ) { m_OnEndTouchAll.FireOutput(pOther, this); EndTouchAll(); } } } //----------------------------------------------------------------------------- // Purpose: Return true if the specified entity is touching us //----------------------------------------------------------------------------- bool CBaseTrigger::IsTouching( const CBaseEntity *pOther ) const { EHANDLE hOther; hOther = pOther; return ( m_hTouchingEntities.Find( hOther ) != m_hTouchingEntities.InvalidIndex() ); } //----------------------------------------------------------------------------- // Purpose: Return a pointer to the first entity of the specified type being touched by this trigger //----------------------------------------------------------------------------- CBaseEntity *CBaseTrigger::GetTouchedEntityOfType( const char *sClassName ) { int iCount = m_hTouchingEntities.Count(); for ( int i = 0; i < iCount; i++ ) { CBaseEntity *pEntity = m_hTouchingEntities[i]; if ( FClassnameIs( pEntity, sClassName ) ) return pEntity; } return NULL; } //----------------------------------------------------------------------------- // Purpose: Toggles this trigger between enabled and disabled. //----------------------------------------------------------------------------- void CBaseTrigger::InputToggle( inputdata_t &inputdata ) { if (IsSolidFlagSet( FSOLID_TRIGGER )) { RemoveSolidFlags(FSOLID_TRIGGER); } else { AddSolidFlags(FSOLID_TRIGGER); } PhysicsTouchTriggers(); } //----------------------------------------------------------------------------- // Purpose: Removes anything that touches it. If the trigger has a targetname, // firing it will toggle state. //----------------------------------------------------------------------------- class CTriggerRemove : public CBaseTrigger { public: DECLARE_CLASS( CTriggerRemove, CBaseTrigger ); void Spawn( void ); void Touch( CBaseEntity *pOther ); DECLARE_DATADESC(); // Outputs COutputEvent m_OnRemove; }; BEGIN_DATADESC( CTriggerRemove ) // Outputs DEFINE_OUTPUT( m_OnRemove, "OnRemove" ), END_DATADESC() LINK_ENTITY_TO_CLASS( trigger_remove, CTriggerRemove ); //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerRemove::Spawn( void ) { BaseClass::Spawn(); InitTrigger(); } //----------------------------------------------------------------------------- // Purpose: Trigger hurt that causes radiation will do a radius check and set // the player's geiger counter level according to distance from center // of trigger. //----------------------------------------------------------------------------- void CTriggerRemove::Touch( CBaseEntity *pOther ) { if (!PassesTriggerFilters(pOther)) return; UTIL_Remove( pOther ); } BEGIN_DATADESC( CTriggerHurt ) // Function Pointers DEFINE_FUNCTION( CTriggerHurtShim::RadiationThinkShim ), DEFINE_FUNCTION( CTriggerHurtShim::HurtThinkShim ), // Fields DEFINE_FIELD( m_flOriginalDamage, FIELD_FLOAT ), DEFINE_KEYFIELD( m_flDamage, FIELD_FLOAT, "damage" ), DEFINE_KEYFIELD( m_flDamageCap, FIELD_FLOAT, "damagecap" ), DEFINE_KEYFIELD( m_bitsDamageInflict, FIELD_INTEGER, "damagetype" ), DEFINE_KEYFIELD( m_damageModel, FIELD_INTEGER, "damagemodel" ), DEFINE_KEYFIELD( m_bNoDmgForce, FIELD_BOOLEAN, "nodmgforce" ), DEFINE_FIELD( m_flLastDmgTime, FIELD_TIME ), DEFINE_FIELD( m_flDmgResetTime, FIELD_TIME ), DEFINE_UTLVECTOR( m_hurtEntities, FIELD_EHANDLE ), // Inputs DEFINE_INPUT( m_flDamage, FIELD_FLOAT, "SetDamage" ), // Outputs DEFINE_OUTPUT( m_OnHurt, "OnHurt" ), DEFINE_OUTPUT( m_OnHurtPlayer, "OnHurtPlayer" ), END_DATADESC() LINK_ENTITY_TO_CLASS( trigger_hurt, CTriggerHurt ); IMPLEMENT_AUTO_LIST( ITriggerHurtAutoList ); //----------------------------------------------------------------------------- // Purpose: Called when spawning, after keyvalues have been handled. //----------------------------------------------------------------------------- void CTriggerHurt::Spawn( void ) { BaseClass::Spawn(); InitTrigger(); m_flOriginalDamage = m_flDamage; SetNextThink( TICK_NEVER_THINK ); SetThink( NULL ); if (m_bitsDamageInflict & DMG_RADIATION) { SetThink ( &CTriggerHurtShim::RadiationThinkShim ); SetNextThink( gpGlobals->curtime + random->RandomFloat(0.0, 0.5) ); } } //----------------------------------------------------------------------------- // Purpose: Trigger hurt that causes radiation will do a radius check and set // the player's geiger counter level according to distance from center // of trigger. //----------------------------------------------------------------------------- void CTriggerHurt::RadiationThink( void ) { // check to see if a player is in pvs // if not, continue Vector vecSurroundMins, vecSurroundMaxs; CollisionProp()->WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs ); CBasePlayer *pPlayer = static_cast(UTIL_FindClientInPVS( vecSurroundMins, vecSurroundMaxs )); if (pPlayer) { // get range to player; float flRange = CollisionProp()->CalcDistanceFromPoint( pPlayer->WorldSpaceCenter() ); flRange *= 3.0f; pPlayer->NotifyNearbyRadiationSource(flRange); } float dt = gpGlobals->curtime - m_flLastDmgTime; if ( dt >= 0.5 ) { HurtAllTouchers( dt ); } SetNextThink( gpGlobals->curtime + 0.25 ); } //----------------------------------------------------------------------------- // Purpose: When touched, a hurt trigger does m_flDamage points of damage each half-second. // Input : pOther - The entity that is touching us. //----------------------------------------------------------------------------- bool CTriggerHurt::HurtEntity( CBaseEntity *pOther, float damage ) { if ( !pOther->m_takedamage || !PassesTriggerFilters(pOther) ) return false; // If player is disconnected, we're probably in this routine via the // PhysicsRemoveTouchedList() function to make sure all Untouch()'s are called for the // player. Calling TakeDamage() in this case can get into the speaking criteria, which // will then loop through the control points and the touched list again. We shouldn't // need to hurt players that are disconnected, so skip all of this... bool bPlayerDisconnected = pOther->IsPlayer() && ( ((CBasePlayer *)pOther)->IsConnected() == false ); if ( bPlayerDisconnected ) return false; if ( damage < 0 ) { pOther->TakeHealth( -damage, m_bitsDamageInflict ); } else { // The damage position is the nearest point on the damaged entity // to the trigger's center. Not perfect, but better than nothing. Vector vecCenter = CollisionProp()->WorldSpaceCenter(); Vector vecDamagePos; pOther->CollisionProp()->CalcNearestPoint( vecCenter, &vecDamagePos ); CTakeDamageInfo info( this, this, damage, m_bitsDamageInflict ); info.SetDamagePosition( vecDamagePos ); if ( !m_bNoDmgForce ) { GuessDamageForce( &info, ( vecDamagePos - vecCenter ), vecDamagePos ); } else { info.SetDamageForce( vec3_origin ); } pOther->TakeDamage( info ); } if (pOther->IsPlayer()) { m_OnHurtPlayer.FireOutput(pOther, this); } else { m_OnHurt.FireOutput(pOther, this); } m_hurtEntities.AddToTail( EHANDLE(pOther) ); //NDebugOverlay::Box( pOther->GetAbsOrigin(), pOther->WorldAlignMins(), pOther->WorldAlignMaxs(), 255,0,0,0,0.5 ); return true; } void CTriggerHurt::HurtThink() { // if I hurt anyone, think again if ( HurtAllTouchers( 0.5 ) <= 0 ) { SetThink(NULL); } else { SetNextThink( gpGlobals->curtime + 0.5f ); } } void CTriggerHurt::EndTouch( CBaseEntity *pOther ) { if (PassesTriggerFilters(pOther)) { EHANDLE hOther; hOther = pOther; // if this guy has never taken damage, hurt him now if ( !m_hurtEntities.HasElement( hOther ) ) { HurtEntity( pOther, m_flDamage * 0.5 ); } } BaseClass::EndTouch( pOther ); } //----------------------------------------------------------------------------- // Purpose: called from RadiationThink() as well as HurtThink() // This function applies damage to any entities currently touching the // trigger // Input : dt - time since last call // Output : int - number of entities actually hurt //----------------------------------------------------------------------------- #define TRIGGER_HURT_FORGIVE_TIME 3.0f // time in seconds int CTriggerHurt::HurtAllTouchers( float dt ) { int hurtCount = 0; // half second worth of damage float fldmg = m_flDamage * dt; m_flLastDmgTime = gpGlobals->curtime; m_hurtEntities.RemoveAll(); touchlink_t *root = ( touchlink_t * )GetDataObject( TOUCHLINK ); if ( root ) { for ( touchlink_t *link = root->nextLink; link != root; link = link->nextLink ) { CBaseEntity *pTouch = link->entityTouched; if ( pTouch ) { if ( HurtEntity( pTouch, fldmg ) ) { hurtCount++; } } } } if( m_damageModel == DAMAGEMODEL_DOUBLE_FORGIVENESS ) { if( hurtCount == 0 ) { if( gpGlobals->curtime > m_flDmgResetTime ) { // Didn't hurt anyone. Reset the damage if it's time. (hence, the forgiveness) m_flDamage = m_flOriginalDamage; } } else { // Hurt someone! double the damage m_flDamage *= 2.0f; if( m_flDamage > m_flDamageCap ) { // Clamp m_flDamage = m_flDamageCap; } // Now, put the damage reset time into the future. The forgive time is how long the trigger // must go without harming anyone in order that its accumulated damage be reset to the amount // set by the level designer. This is a stop-gap for an exploit where players could hop through // slime and barely take any damage because the trigger would reset damage anytime there was no // one in the trigger when this function was called. (sjb) m_flDmgResetTime = gpGlobals->curtime + TRIGGER_HURT_FORGIVE_TIME; } } return hurtCount; } void CTriggerHurt::Touch( CBaseEntity *pOther ) { if ( m_pfnThink == NULL ) { SetThink( &CTriggerHurtShim::HurtThinkShim ); SetNextThink( gpGlobals->curtime ); } } //----------------------------------------------------------------------------- // Purpose: Checks if this point is in any trigger_hurt zones with positive damage //----------------------------------------------------------------------------- bool IsTakingTriggerHurtDamageAtPoint( const Vector &vecPoint ) { for ( int i = 0; i < ITriggerHurtAutoList::AutoList().Count(); i++ ) { // Some maps use trigger_hurt with negative values as healing triggers; don't consider those CTriggerHurt *pTrigger = static_cast( ITriggerHurtAutoList::AutoList()[i] ); if ( !pTrigger->m_bDisabled && pTrigger->PointIsWithin( vecPoint ) && pTrigger->m_flDamage > 0.f ) { return true; } } return false; } // ################################################################################## // >> TriggerMultiple // ################################################################################## LINK_ENTITY_TO_CLASS( trigger_multiple, CTriggerMultiple ); BEGIN_DATADESC( CTriggerMultiple ) // Function Pointers DEFINE_FUNCTION(MultiTouch), DEFINE_FUNCTION(MultiWaitOver ), // Outputs DEFINE_OUTPUT(m_OnTrigger, "OnTrigger") END_DATADESC() //----------------------------------------------------------------------------- // Purpose: Called when spawning, after keyvalues have been handled. //----------------------------------------------------------------------------- void CTriggerMultiple::Spawn( void ) { BaseClass::Spawn(); InitTrigger(); if (m_flWait == 0) { m_flWait = 0.2; } ASSERTSZ(m_iHealth == 0, "trigger_multiple with health"); SetTouch( &CTriggerMultiple::MultiTouch ); } //----------------------------------------------------------------------------- // Purpose: Touch function. Activates the trigger. // Input : pOther - The thing that touched us. //----------------------------------------------------------------------------- void CTriggerMultiple::MultiTouch(CBaseEntity *pOther) { if (PassesTriggerFilters(pOther)) { ActivateMultiTrigger( pOther ); } } //----------------------------------------------------------------------------- // Purpose: // Input : pActivator - //----------------------------------------------------------------------------- void CTriggerMultiple::ActivateMultiTrigger(CBaseEntity *pActivator) { if (GetNextThink() > gpGlobals->curtime) return; // still waiting for reset time m_hActivator = pActivator; m_OnTrigger.FireOutput(m_hActivator, this); if (m_flWait > 0) { SetThink( &CTriggerMultiple::MultiWaitOver ); SetNextThink( gpGlobals->curtime + m_flWait ); } else { // we can't just remove (self) here, because this is a touch function // called while C code is looping through area links... SetTouch( NULL ); SetNextThink( gpGlobals->curtime + 0.1f ); SetThink( &CTriggerMultiple::SUB_Remove ); } } //----------------------------------------------------------------------------- // Purpose: The wait time has passed, so set back up for another activation //----------------------------------------------------------------------------- void CTriggerMultiple::MultiWaitOver( void ) { SetThink( NULL ); } // ################################################################################## // >> TriggerOnce // ################################################################################## class CTriggerOnce : public CTriggerMultiple { DECLARE_CLASS( CTriggerOnce, CTriggerMultiple ); public: void Spawn( void ); }; LINK_ENTITY_TO_CLASS( trigger_once, CTriggerOnce ); void CTriggerOnce::Spawn( void ) { BaseClass::Spawn(); m_flWait = -1; } // ################################################################################## // >> TriggerLook // // Triggers once when player is looking at m_target // // ################################################################################## #define SF_TRIGGERLOOK_FIREONCE 128 #define SF_TRIGGERLOOK_USEVELOCITY 256 class CTriggerLook : public CTriggerOnce { DECLARE_CLASS( CTriggerLook, CTriggerOnce ); public: EHANDLE m_hLookTarget; float m_flFieldOfView; float m_flLookTime; // How long must I look for float m_flLookTimeTotal; // How long have I looked float m_flLookTimeLast; // When did I last look float m_flTimeoutDuration; // Number of seconds after start touch to fire anyway bool m_bTimeoutFired; // True if the OnTimeout output fired since the last StartTouch. EHANDLE m_hActivator; // The entity that triggered us. void Spawn( void ); void Touch( CBaseEntity *pOther ); void StartTouch(CBaseEntity *pOther); void EndTouch( CBaseEntity *pOther ); int DrawDebugTextOverlays(void); DECLARE_DATADESC(); private: void Trigger(CBaseEntity *pActivator, bool bTimeout); void TimeoutThink(); COutputEvent m_OnTimeout; }; LINK_ENTITY_TO_CLASS( trigger_look, CTriggerLook ); BEGIN_DATADESC( CTriggerLook ) DEFINE_FIELD( m_hLookTarget, FIELD_EHANDLE ), DEFINE_FIELD( m_flLookTimeTotal, FIELD_FLOAT ), DEFINE_FIELD( m_flLookTimeLast, FIELD_TIME ), DEFINE_KEYFIELD( m_flTimeoutDuration, FIELD_FLOAT, "timeout" ), DEFINE_FIELD( m_bTimeoutFired, FIELD_BOOLEAN ), DEFINE_FIELD( m_hActivator, FIELD_EHANDLE ), DEFINE_OUTPUT( m_OnTimeout, "OnTimeout" ), DEFINE_FUNCTION( TimeoutThink ), // Inputs DEFINE_INPUT( m_flFieldOfView, FIELD_FLOAT, "FieldOfView" ), DEFINE_INPUT( m_flLookTime, FIELD_FLOAT, "LookTime" ), END_DATADESC() //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerLook::Spawn( void ) { m_hLookTarget = NULL; m_flLookTimeTotal = -1; m_bTimeoutFired = false; BaseClass::Spawn(); } //----------------------------------------------------------------------------- // Purpose: // Input : pOther - //----------------------------------------------------------------------------- void CTriggerLook::StartTouch(CBaseEntity *pOther) { BaseClass::StartTouch(pOther); if (pOther->IsPlayer() && m_flTimeoutDuration) { m_bTimeoutFired = false; m_hActivator = pOther; SetThink(&CTriggerLook::TimeoutThink); SetNextThink(gpGlobals->curtime + m_flTimeoutDuration); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerLook::TimeoutThink(void) { Trigger(m_hActivator, true); } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerLook::EndTouch(CBaseEntity *pOther) { BaseClass::EndTouch(pOther); if (pOther->IsPlayer()) { SetThink(NULL); SetNextThink( TICK_NEVER_THINK ); m_flLookTimeTotal = -1; } } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerLook::Touch(CBaseEntity *pOther) { // Don't fire the OnTrigger if we've already fired the OnTimeout. This will be // reset in OnEndTouch. if (m_bTimeoutFired) return; // -------------------------------- // Make sure we have a look target // -------------------------------- if (m_hLookTarget == NULL) { m_hLookTarget = GetNextTarget(); if (m_hLookTarget == NULL) { return; } } // This is designed for single player only // so we'll always have the same player if (pOther->IsPlayer()) { // ---------------------------------------- // Check that toucher is facing the target // ---------------------------------------- Vector vLookDir; if ( HasSpawnFlags( SF_TRIGGERLOOK_USEVELOCITY ) ) { vLookDir = pOther->GetAbsVelocity(); if ( vLookDir == vec3_origin ) { // See if they're in a vehicle CBasePlayer *pPlayer = (CBasePlayer *)pOther; if ( pPlayer->IsInAVehicle() ) { vLookDir = pPlayer->GetVehicle()->GetVehicleEnt()->GetSmoothedVelocity(); } } VectorNormalize( vLookDir ); } else { vLookDir = ((CBaseCombatCharacter*)pOther)->EyeDirection3D( ); } Vector vTargetDir = m_hLookTarget->GetAbsOrigin() - pOther->EyePosition(); VectorNormalize(vTargetDir); float fDotPr = DotProduct(vLookDir,vTargetDir); if (fDotPr > m_flFieldOfView) { // Is it the first time I'm looking? if (m_flLookTimeTotal == -1) { m_flLookTimeLast = gpGlobals->curtime; m_flLookTimeTotal = 0; } else { m_flLookTimeTotal += gpGlobals->curtime - m_flLookTimeLast; m_flLookTimeLast = gpGlobals->curtime; } if (m_flLookTimeTotal >= m_flLookTime) { Trigger(pOther, false); } } else { m_flLookTimeTotal = -1; } } } //----------------------------------------------------------------------------- // Purpose: Called when the trigger is fired by look logic or timeout. //----------------------------------------------------------------------------- void CTriggerLook::Trigger(CBaseEntity *pActivator, bool bTimeout) { if (bTimeout) { // Fired due to timeout (player never looked at the target). m_OnTimeout.FireOutput(pActivator, this); // Don't fire the OnTrigger for this toucher. m_bTimeoutFired = true; } else { // Fire because the player looked at the target. m_OnTrigger.FireOutput(pActivator, this); m_flLookTimeTotal = -1; // Cancel the timeout think. SetThink(NULL); SetNextThink( TICK_NEVER_THINK ); } if (HasSpawnFlags(SF_TRIGGERLOOK_FIREONCE)) { SetThink(&CTriggerLook::SUB_Remove); SetNextThink(gpGlobals->curtime); } } //----------------------------------------------------------------------------- // Purpose: Draw any debug text overlays // Output : Current text offset from the top //----------------------------------------------------------------------------- int CTriggerLook::DrawDebugTextOverlays(void) { int text_offset = BaseClass::DrawDebugTextOverlays(); if (m_debugOverlays & OVERLAY_TEXT_BIT) { // ---------------- // Print Look time // ---------------- char tempstr[255]; Q_snprintf(tempstr,sizeof(tempstr),"Time: %3.2f",m_flLookTime - MAX(0,m_flLookTimeTotal)); EntityText(text_offset,tempstr,0); text_offset++; } return text_offset; } // ################################################################################## // >> TriggerVolume // ################################################################################## class CTriggerVolume : public CPointEntity // Derive from point entity so this doesn't move across levels { public: DECLARE_CLASS( CTriggerVolume, CPointEntity ); void Spawn( void ); }; LINK_ENTITY_TO_CLASS( trigger_transition, CTriggerVolume ); // Define space that travels across a level transition void CTriggerVolume::Spawn( void ) { SetSolid( SOLID_BSP ); AddSolidFlags( FSOLID_NOT_SOLID ); SetMoveType( MOVETYPE_NONE ); SetModel( STRING( GetModelName() ) ); // set size and link into world if ( showtriggers.GetInt() == 0 ) { AddEffects( EF_NODRAW ); } } #define SF_CHANGELEVEL_NOTOUCH 0x0002 #define SF_CHANGELEVEL_CHAPTER 0x0004 #define cchMapNameMost 32 enum { TRANSITION_VOLUME_SCREENED_OUT = 0, TRANSITION_VOLUME_NOT_FOUND = 1, TRANSITION_VOLUME_PASSED = 2, }; //------------------------------------------------------------------------------ // Reesponsible for changing levels when the player touches it //------------------------------------------------------------------------------ class CChangeLevel : public CBaseTrigger { DECLARE_DATADESC(); public: DECLARE_CLASS( CChangeLevel, CBaseTrigger ); void Spawn( void ); void Activate( void ); bool KeyValue( const char *szKeyName, const char *szValue ); static int ChangeList( levellist_t *pLevelList, int maxList ); private: void TouchChangeLevel( CBaseEntity *pOther ); void ChangeLevelNow( CBaseEntity *pActivator ); void InputChangeLevel( inputdata_t &inputdata ); bool IsEntityInTransition( CBaseEntity *pEntity ); void NotifyEntitiesOutOfTransition(); void WarnAboutActiveLead( void ); static CBaseEntity *FindLandmark( const char *pLandmarkName ); static int AddTransitionToList( levellist_t *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark ); static int InTransitionVolume( CBaseEntity *pEntity, const char *pVolumeName ); // Builds the list of entities to save when moving across a transition static int BuildChangeLevelList( levellist_t *pLevelList, int maxList ); // Builds the list of entities to bring across a particular transition static int BuildEntityTransitionList( CBaseEntity *pLandmarkEntity, const char *pLandmarkName, CBaseEntity **ppEntList, int *pEntityFlags, int nMaxList ); // Adds a single entity to the transition list, if appropriate. Returns the new count static int AddEntityToTransitionList( CBaseEntity *pEntity, int flags, int nCount, CBaseEntity **ppEntList, int *pEntityFlags ); // Adds in all entities depended on by entities near the transition static int AddDependentEntities( int nCount, CBaseEntity **ppEntList, int *pEntityFlags, int nMaxList ); // Figures out save flags for the entity static int ComputeEntitySaveFlags( CBaseEntity *pEntity ); private: char m_szMapName[cchMapNameMost]; // trigger_changelevel only: next map char m_szLandmarkName[cchMapNameMost]; // trigger_changelevel only: landmark on next map bool m_bTouched; // Outputs COutputEvent m_OnChangeLevel; }; LINK_ENTITY_TO_CLASS( trigger_changelevel, CChangeLevel ); // Global Savedata for changelevel trigger BEGIN_DATADESC( CChangeLevel ) DEFINE_AUTO_ARRAY( m_szMapName, FIELD_CHARACTER ), DEFINE_AUTO_ARRAY( m_szLandmarkName, FIELD_CHARACTER ), // DEFINE_FIELD( m_touchTime, FIELD_TIME ), // don't save // DEFINE_FIELD( m_bTouched, FIELD_BOOLEAN ), // Function Pointers DEFINE_FUNCTION( TouchChangeLevel ), DEFINE_INPUTFUNC( FIELD_VOID, "ChangeLevel", InputChangeLevel ), // Outputs DEFINE_OUTPUT( m_OnChangeLevel, "OnChangeLevel"), END_DATADESC() // // Cache user-entity-field values until spawn is called. // bool CChangeLevel::KeyValue( const char *szKeyName, const char *szValue ) { if (FStrEq(szKeyName, "map")) { if (strlen(szValue) >= cchMapNameMost) { Warning( "Map name '%s' too long (32 chars)\n", szValue ); Assert(0); } Q_strncpy(m_szMapName, szValue, sizeof(m_szMapName)); } else if (FStrEq(szKeyName, "landmark")) { if (strlen(szValue) >= cchMapNameMost) { Warning( "Landmark name '%s' too long (32 chars)\n", szValue ); Assert(0); } Q_strncpy(m_szLandmarkName, szValue, sizeof( m_szLandmarkName )); } else return BaseClass::KeyValue( szKeyName, szValue ); return true; } void CChangeLevel::Spawn( void ) { if ( FStrEq( m_szMapName, "" ) ) { Msg( "a trigger_changelevel doesn't have a map" ); } if ( FStrEq( m_szLandmarkName, "" ) ) { Msg( "trigger_changelevel to %s doesn't have a landmark", m_szMapName ); } InitTrigger(); if ( !HasSpawnFlags(SF_CHANGELEVEL_NOTOUCH) ) { SetTouch( &CChangeLevel::TouchChangeLevel ); } // Msg( "TRANSITION: %s (%s)\n", m_szMapName, m_szLandmarkName ); } void CChangeLevel::Activate( void ) { BaseClass::Activate(); if ( gpGlobals->eLoadType == MapLoad_NewGame ) { if ( HasSpawnFlags( SF_CHANGELEVEL_CHAPTER ) ) { VPhysicsInitStatic(); RemoveSolidFlags( FSOLID_NOT_SOLID | FSOLID_TRIGGER ); SetTouch( NULL ); return; } } // Level transitions will bust if they are in solid CBaseEntity *pLandmark = FindLandmark( m_szLandmarkName ); if ( pLandmark ) { int clusterIndex = engine->GetClusterForOrigin( pLandmark->GetAbsOrigin() ); if ( clusterIndex < 0 ) { Warning( "trigger_changelevel to map %s has a landmark embedded in solid!\n" "This will break level transitions!\n", m_szMapName ); } if ( g_debug_transitions.GetInt() ) { if ( !gEntList.FindEntityByClassname( NULL, "trigger_transition" ) ) { Warning( "Map has no trigger_transition volumes for landmark %s\n", m_szLandmarkName ); } } } m_bTouched = false; } static char st_szNextMap[cchMapNameMost]; static char st_szNextSpot[cchMapNameMost]; // Used to show debug for only the transition volume we're currently in static int g_iDebuggingTransition = 0; CBaseEntity *CChangeLevel::FindLandmark( const char *pLandmarkName ) { CBaseEntity *pentLandmark; pentLandmark = gEntList.FindEntityByName( NULL, pLandmarkName ); while ( pentLandmark ) { // Found the landmark if ( FClassnameIs( pentLandmark, "info_landmark" ) ) return pentLandmark; else pentLandmark = gEntList.FindEntityByName( pentLandmark, pLandmarkName ); } Warning( "Can't find landmark %s\n", pLandmarkName ); return NULL; } //----------------------------------------------------------------------------- // Purpose: Allows level transitions to be triggered by buttons, etc. //----------------------------------------------------------------------------- void CChangeLevel::InputChangeLevel( inputdata_t &inputdata ) { // Ignore changelevel transitions if the player's dead or attempting a challenge if ( gpGlobals->maxClients == 1 ) { CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); if ( pPlayer && ( !pPlayer->IsAlive() || pPlayer->GetBonusChallenge() > 0 ) ) return; } ChangeLevelNow( inputdata.pActivator ); } //----------------------------------------------------------------------------- // Purpose: Performs the level change and fires targets. // Input : pActivator - //----------------------------------------------------------------------------- bool CChangeLevel::IsEntityInTransition( CBaseEntity *pEntity ) { int transitionState = InTransitionVolume(pEntity, m_szLandmarkName); if ( transitionState == TRANSITION_VOLUME_SCREENED_OUT ) { return false; } // look for a landmark entity CBaseEntity *pLandmark = FindLandmark( m_szLandmarkName ); if ( !pLandmark ) return false; // Check to make sure it's also in the PVS of landmark byte pvs[MAX_MAP_CLUSTERS/8]; int clusterIndex = engine->GetClusterForOrigin( pLandmark->GetAbsOrigin() ); engine->GetPVSForCluster( clusterIndex, sizeof(pvs), pvs ); Vector vecSurroundMins, vecSurroundMaxs; pEntity->CollisionProp()->WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs ); return engine->CheckBoxInPVS( vecSurroundMins, vecSurroundMaxs, pvs, sizeof( pvs ) ); } void CChangeLevel::NotifyEntitiesOutOfTransition() { CBaseEntity *pEnt = gEntList.FirstEnt(); while ( pEnt ) { // Found the landmark if ( pEnt->ObjectCaps() & FCAP_NOTIFY_ON_TRANSITION ) { variant_t emptyVariant; if ( !(pEnt->ObjectCaps() & (FCAP_ACROSS_TRANSITION|FCAP_FORCE_TRANSITION)) || !IsEntityInTransition( pEnt ) ) { pEnt->AcceptInput( "OutsideTransition", this, this, emptyVariant, 0 ); } else { pEnt->AcceptInput( "InsideTransition", this, this, emptyVariant, 0 ); } } pEnt = gEntList.NextEnt( pEnt ); } } //------------------------------------------------------------------------------ // Purpose : Checks all spawned AIs and prints a warning if any are actively leading // Input : // Output : //------------------------------------------------------------------------------ void CChangeLevel::WarnAboutActiveLead( void ) { int i; CAI_BaseNPC * ai; CAI_BehaviorBase * behavior; for ( i = 0; i < g_AI_Manager.NumAIs(); i++ ) { ai = g_AI_Manager.AccessAIs()[i]; behavior = ai->GetRunningBehavior(); if ( behavior ) { if ( dynamic_cast( behavior ) ) { Warning( "Entity '%s' is still actively leading\n", STRING( ai->GetEntityName() ) ); } } } } void CChangeLevel::ChangeLevelNow( CBaseEntity *pActivator ) { CBaseEntity *pLandmark; levellist_t levels[16]; Assert(!FStrEq(m_szMapName, "")); // Don't work in deathmatch if ( g_pGameRules->IsDeathmatch() ) return; // Some people are firing these multiple times in a frame, disable if ( m_bTouched ) return; m_bTouched = true; CBaseEntity *pPlayer = (pActivator && pActivator->IsPlayer()) ? pActivator : UTIL_GetLocalPlayer(); int transitionState = InTransitionVolume(pPlayer, m_szLandmarkName); if ( transitionState == TRANSITION_VOLUME_SCREENED_OUT ) { DevMsg( 2, "Player isn't in the transition volume %s, aborting\n", m_szLandmarkName ); return; } // look for a landmark entity pLandmark = FindLandmark( m_szLandmarkName ); if ( !pLandmark ) return; // no transition volumes, check PVS of landmark if ( transitionState == TRANSITION_VOLUME_NOT_FOUND ) { byte pvs[MAX_MAP_CLUSTERS/8]; int clusterIndex = engine->GetClusterForOrigin( pLandmark->GetAbsOrigin() ); engine->GetPVSForCluster( clusterIndex, sizeof(pvs), pvs ); if ( pPlayer ) { Vector vecSurroundMins, vecSurroundMaxs; pPlayer->CollisionProp()->WorldSpaceSurroundingBounds( &vecSurroundMins, &vecSurroundMaxs ); bool playerInPVS = engine->CheckBoxInPVS( vecSurroundMins, vecSurroundMaxs, pvs, sizeof( pvs ) ); //Assert( playerInPVS ); if ( !playerInPVS ) { Warning( "Player isn't in the landmark's (%s) PVS, aborting\n", m_szLandmarkName ); #ifndef HL1_DLL // HL1 works even with these errors! return; #endif } } } WarnAboutActiveLead(); g_iDebuggingTransition = 0; st_szNextSpot[0] = 0; // Init landmark to NULL Q_strncpy(st_szNextSpot, m_szLandmarkName,sizeof(st_szNextSpot)); // This object will get removed in the call to engine->ChangeLevel, copy the params into "safe" memory Q_strncpy(st_szNextMap, m_szMapName, sizeof(st_szNextMap)); m_hActivator = pActivator; m_OnChangeLevel.FireOutput(pActivator, this); NotifyEntitiesOutOfTransition(); //// Msg( "Level touches %d levels\n", ChangeList( levels, 16 ) ); if ( g_debug_transitions.GetInt() ) { Msg( "CHANGE LEVEL: %s %s\n", st_szNextMap, st_szNextSpot ); } // If we're debugging, don't actually change level if ( g_debug_transitions.GetInt() == 0 ) { engine->ChangeLevel( st_szNextMap, st_szNextSpot ); } else { // Build a change list so we can see what would be transitioning CSaveRestoreData *pSaveData = SaveInit( 0 ); if ( pSaveData ) { g_pGameSaveRestoreBlockSet->PreSave( pSaveData ); pSaveData->levelInfo.connectionCount = BuildChangeList( pSaveData->levelInfo.levelList, MAX_LEVEL_CONNECTIONS ); g_pGameSaveRestoreBlockSet->PostSave(); } SetTouch( NULL ); } } // // GLOBALS ASSUMED SET: st_szNextMap // void CChangeLevel::TouchChangeLevel( CBaseEntity *pOther ) { CBasePlayer *pPlayer = ToBasePlayer(pOther); if ( !pPlayer ) return; if( pPlayer->IsSinglePlayerGameEnding() ) { // Some semblance of deceleration, but allow player to fall normally. // Also, disable controls. Vector vecVelocity = pPlayer->GetAbsVelocity(); vecVelocity.x *= 0.5f; vecVelocity.y *= 0.5f; pPlayer->SetAbsVelocity( vecVelocity ); pPlayer->AddFlag( FL_FROZEN ); return; } if ( !pPlayer->IsInAVehicle() && pPlayer->GetMoveType() == MOVETYPE_NOCLIP ) { DevMsg("In level transition: %s %s\n", st_szNextMap, st_szNextSpot ); return; } ChangeLevelNow( pOther ); } // Add a transition to the list, but ignore duplicates // (a designer may have placed multiple trigger_changelevels with the same landmark) int CChangeLevel::AddTransitionToList( levellist_t *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark ) { int i; if ( !pLevelList || !pMapName || !pLandmarkName || !pentLandmark ) return 0; // Ignore changelevels to the level we're ready in. Mapmakers love to do this! if ( stricmp( pMapName, STRING(gpGlobals->mapname) ) == 0 ) return 0; for ( i = 0; i < listCount; i++ ) { if ( pLevelList[i].pentLandmark == pentLandmark && stricmp( pLevelList[i].mapName, pMapName ) == 0 ) return 0; } Q_strncpy( pLevelList[listCount].mapName, pMapName, sizeof(pLevelList[listCount].mapName) ); Q_strncpy( pLevelList[listCount].landmarkName, pLandmarkName, sizeof(pLevelList[listCount].landmarkName) ); pLevelList[listCount].pentLandmark = pentLandmark; CBaseEntity *ent = CBaseEntity::Instance( pentLandmark ); Assert( ent ); pLevelList[listCount].vecLandmarkOrigin = ent->GetAbsOrigin(); return 1; } int BuildChangeList( levellist_t *pLevelList, int maxList ) { return CChangeLevel::ChangeList( pLevelList, maxList ); } struct collidelist_t { const CPhysCollide *pCollide; Vector origin; QAngle angles; }; // NOTE: This routine is relatively slow. If you need to use it for per-frame work, consider that fact. // UNDONE: Expand this to the full matrix of solid types on each side and move into enginetrace static bool TestEntityTriggerIntersection_Accurate( CBaseEntity *pTrigger, CBaseEntity *pEntity ) { Assert( pTrigger->GetSolid() == SOLID_BSP ); if ( pTrigger->Intersects( pEntity ) ) // It touches one, it's in the volume { switch ( pEntity->GetSolid() ) { case SOLID_BBOX: { ICollideable *pCollide = pTrigger->CollisionProp(); Ray_t ray; trace_t tr; ray.Init( pEntity->GetAbsOrigin(), pEntity->GetAbsOrigin(), pEntity->WorldAlignMins(), pEntity->WorldAlignMaxs() ); enginetrace->ClipRayToCollideable( ray, MASK_ALL, pCollide, &tr ); if ( tr.startsolid ) return true; } break; case SOLID_BSP: case SOLID_VPHYSICS: { CPhysCollide *pTriggerCollide = modelinfo->GetVCollide( pTrigger->GetModelIndex() )->solids[0]; Assert( pTriggerCollide ); CUtlVector collideList; IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT]; int physicsCount = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) ); if ( physicsCount ) { for ( int i = 0; i < physicsCount; i++ ) { const CPhysCollide *pCollide = pList[i]->GetCollide(); if ( pCollide ) { collidelist_t element; element.pCollide = pCollide; pList[i]->GetPosition( &element.origin, &element.angles ); collideList.AddToTail( element ); } } } else { vcollide_t *pVCollide = modelinfo->GetVCollide( pEntity->GetModelIndex() ); if ( pVCollide && pVCollide->solidCount ) { collidelist_t element; element.pCollide = pVCollide->solids[0]; element.origin = pEntity->GetAbsOrigin(); element.angles = pEntity->GetAbsAngles(); collideList.AddToTail( element ); } } for ( int i = collideList.Count()-1; i >= 0; --i ) { const collidelist_t &element = collideList[i]; trace_t tr; physcollision->TraceCollide( element.origin, element.origin, element.pCollide, element.angles, pTriggerCollide, pTrigger->GetAbsOrigin(), pTrigger->GetAbsAngles(), &tr ); if ( tr.startsolid ) return true; } } break; default: return true; } } return false; } int CChangeLevel::InTransitionVolume( CBaseEntity *pEntity, const char *pVolumeName ) { CBaseEntity *pVolume; if ( pEntity->ObjectCaps() & FCAP_FORCE_TRANSITION ) return TRANSITION_VOLUME_PASSED; // If you're following another entity, follow it through the transition (weapons follow the player) pEntity = pEntity->GetRootMoveParent(); int inVolume = TRANSITION_VOLUME_NOT_FOUND; // Unless we find a trigger_transition, everything is in the volume pVolume = gEntList.FindEntityByName( NULL, pVolumeName ); while ( pVolume ) { if ( pVolume && FClassnameIs( pVolume, "trigger_transition" ) ) { if ( TestEntityTriggerIntersection_Accurate(pVolume, pEntity ) ) // It touches one, it's in the volume return TRANSITION_VOLUME_PASSED; inVolume = TRANSITION_VOLUME_SCREENED_OUT; // Found a trigger_transition, but I don't intersect it -- if I don't find another, don't go! } pVolume = gEntList.FindEntityByName( pVolume, pVolumeName ); } return inVolume; } //------------------------------------------------------------------------------ // Builds the list of entities to save when moving across a transition //------------------------------------------------------------------------------ int CChangeLevel::BuildChangeLevelList( levellist_t *pLevelList, int maxList ) { int nCount = 0; CBaseEntity *pentChangelevel = gEntList.FindEntityByClassname( NULL, "trigger_changelevel" ); while ( pentChangelevel ) { CChangeLevel *pTrigger = dynamic_cast(pentChangelevel); if ( pTrigger ) { // Find the corresponding landmark CBaseEntity *pentLandmark = FindLandmark( pTrigger->m_szLandmarkName ); if ( pentLandmark ) { // Build a list of unique transitions if ( AddTransitionToList( pLevelList, nCount, pTrigger->m_szMapName, pTrigger->m_szLandmarkName, pentLandmark->edict() ) ) { ++nCount; if ( nCount >= maxList ) // FULL!! break; } } } pentChangelevel = gEntList.FindEntityByClassname( pentChangelevel, "trigger_changelevel" ); } return nCount; } //------------------------------------------------------------------------------ // Adds a single entity to the transition list, if appropriate. Returns the new count //------------------------------------------------------------------------------ int CChangeLevel::ComputeEntitySaveFlags( CBaseEntity *pEntity ) { if ( g_iDebuggingTransition == DEBUG_TRANSITIONS_VERBOSE ) { Msg( "Trying %s (%s): ", pEntity->GetClassname(), pEntity->GetDebugName() ); } int caps = pEntity->ObjectCaps(); if ( caps & FCAP_DONT_SAVE ) { if ( g_iDebuggingTransition == DEBUG_TRANSITIONS_VERBOSE ) { Msg( "IGNORED due to being marked \"Don't save\".\n" ); } return 0; } // If this entity can be moved or is global, mark it int flags = 0; if ( caps & FCAP_ACROSS_TRANSITION ) { flags |= FENTTABLE_MOVEABLE; } if ( pEntity->m_iGlobalname != NULL_STRING && !pEntity->IsDormant() ) { flags |= FENTTABLE_GLOBAL; } if ( g_iDebuggingTransition == DEBUG_TRANSITIONS_VERBOSE && !flags ) { Msg( "IGNORED, no across_transition flag & no globalname\n" ); } return flags; } //------------------------------------------------------------------------------ // Adds a single entity to the transition list, if appropriate. Returns the new count //------------------------------------------------------------------------------ inline int CChangeLevel::AddEntityToTransitionList( CBaseEntity *pEntity, int flags, int nCount, CBaseEntity **ppEntList, int *pEntityFlags ) { ppEntList[ nCount ] = pEntity; pEntityFlags[ nCount ] = flags; ++nCount; // If we're debugging, make it visible if ( g_iDebuggingTransition ) { if ( g_iDebuggingTransition == DEBUG_TRANSITIONS_VERBOSE ) { // In verbose mode we've already printed out what the entity is Msg("ADDED.\n"); } else { // In non-verbose mode, we just print this line Msg( "ADDED %s (%s) to transition.\n", pEntity->GetClassname(), pEntity->GetDebugName() ); } pEntity->m_debugOverlays |= (OVERLAY_BBOX_BIT | OVERLAY_NAME_BIT); } return nCount; } //------------------------------------------------------------------------------ // Builds the list of entities to bring across a particular transition //------------------------------------------------------------------------------ int CChangeLevel::BuildEntityTransitionList( CBaseEntity *pLandmarkEntity, const char *pLandmarkName, CBaseEntity **ppEntList, int *pEntityFlags, int nMaxList ) { int iEntity = 0; // Only show debug for the transition to the level we're going to if ( g_debug_transitions.GetInt() && pLandmarkEntity->NameMatches(st_szNextSpot) ) { g_iDebuggingTransition = g_debug_transitions.GetInt(); // Show us where the landmark entity is pLandmarkEntity->m_debugOverlays |= (OVERLAY_PIVOT_BIT | OVERLAY_BBOX_BIT | OVERLAY_NAME_BIT); } else { g_iDebuggingTransition = 0; } // Follow the linked list of entities in the PVS of the transition landmark CBaseEntity *pEntity = NULL; while ( (pEntity = UTIL_EntitiesInPVS( pLandmarkEntity, pEntity)) != NULL ) { int flags = ComputeEntitySaveFlags( pEntity ); if ( !flags ) continue; // Check to make sure the entity isn't screened out by a trigger_transition if ( !InTransitionVolume( pEntity, pLandmarkName ) ) { if ( g_iDebuggingTransition == DEBUG_TRANSITIONS_VERBOSE ) { Msg( "IGNORED, outside transition volume.\n" ); } continue; } if ( iEntity >= nMaxList ) { Warning( "Too many entities across a transition!\n" ); Assert( 0 ); return iEntity; } iEntity = AddEntityToTransitionList( pEntity, flags, iEntity, ppEntList, pEntityFlags ); } return iEntity; } //------------------------------------------------------------------------------ // Tests bits in a bitfield //------------------------------------------------------------------------------ static inline bool IsBitSet( char *pBuf, int nBit ) { return (pBuf[ nBit >> 3 ] & ( 1 << (nBit & 0x7) )) != 0; } static inline void Set( char *pBuf, int nBit ) { pBuf[ nBit >> 3 ] |= 1 << (nBit & 0x7); } //------------------------------------------------------------------------------ // Adds in all entities depended on by entities near the transition //------------------------------------------------------------------------------ #define MAX_ENTITY_BYTE_COUNT (NUM_ENT_ENTRIES >> 3) int CChangeLevel::AddDependentEntities( int nCount, CBaseEntity **ppEntList, int *pEntityFlags, int nMaxList ) { char pEntitiesSaved[MAX_ENTITY_BYTE_COUNT]; memset( pEntitiesSaved, 0, MAX_ENTITY_BYTE_COUNT * sizeof(char) ); // Populate the initial bitfield int i; for ( i = 0; i < nCount; ++i ) { // NOTE: Must use GetEntryIndex because we're saving non-networked entities int nEntIndex = ppEntList[i]->GetRefEHandle().GetEntryIndex(); // We shouldn't already have this entity in the list! Assert( !IsBitSet( pEntitiesSaved, nEntIndex ) ); // Mark the entity as being in the list Set( pEntitiesSaved, nEntIndex ); } IEntitySaveUtils *pSaveUtils = GetEntitySaveUtils(); // Iterate over entities whose dependencies we've not yet processed // NOTE: nCount will change value during this loop in AddEntityToTransitionList for ( i = 0; i < nCount; ++i ) { CBaseEntity *pEntity = ppEntList[i]; // Find dependencies in the hash. int nDepCount = pSaveUtils->GetEntityDependencyCount( pEntity ); if ( !nDepCount ) continue; CBaseEntity **ppDependentEntities = (CBaseEntity**)stackalloc( nDepCount * sizeof(CBaseEntity*) ); pSaveUtils->GetEntityDependencies( pEntity, nDepCount, ppDependentEntities ); for ( int j = 0; j < nDepCount; ++j ) { CBaseEntity *pDependent = ppDependentEntities[j]; if ( !pDependent ) continue; // NOTE: Must use GetEntryIndex because we're saving non-networked entities int nEntIndex = pDependent->GetRefEHandle().GetEntryIndex(); // Don't re-add it if it's already in the list if ( IsBitSet( pEntitiesSaved, nEntIndex ) ) continue; // Mark the entity as being in the list Set( pEntitiesSaved, nEntIndex ); int flags = ComputeEntitySaveFlags( pEntity ); if ( flags ) { if ( nCount >= nMaxList ) { Warning( "Too many entities across a transition!\n" ); Assert( 0 ); return false; } if ( g_debug_transitions.GetInt() ) { Msg( "ADDED DEPENDANCY: %s (%s)\n", pEntity->GetClassname(), pEntity->GetDebugName() ); } nCount = AddEntityToTransitionList( pEntity, flags, nCount, ppEntList, pEntityFlags ); } else { Warning("Warning!! Save dependency is linked to an entity that doesn't want to be saved!\n"); } } } return nCount; } //------------------------------------------------------------------------------ // This builds the list of all transitions on this level and which entities // are in their PVS's and can / should be moved across. //------------------------------------------------------------------------------ // We can only ever move 512 entities across a transition #define MAX_ENTITY 512 // FIXME: This has grown into a complicated beast. Can we make this more elegant? int CChangeLevel::ChangeList( levellist_t *pLevelList, int maxList ) { // Find all of the possible level changes on this BSP int count = BuildChangeLevelList( pLevelList, maxList ); if ( !gpGlobals->pSaveData || ( static_cast(gpGlobals->pSaveData)->NumEntities() == 0 ) ) return count; CSave saveHelper( static_cast(gpGlobals->pSaveData) ); // For each level change, find nearby entities and save them int i; for ( i = 0; i < count; i++ ) { CBaseEntity *pEntList[ MAX_ENTITY ]; int entityFlags[ MAX_ENTITY ]; // First, figure out which entities are near the transition CBaseEntity *pLandmarkEntity = CBaseEntity::Instance( pLevelList[i].pentLandmark ); int iEntity = BuildEntityTransitionList( pLandmarkEntity, pLevelList[i].landmarkName, pEntList, entityFlags, MAX_ENTITY ); // FIXME: Activate if we have a dependency problem on level transition // Next, add in all entities depended on by entities near the transition // iEntity = AddDependentEntities( iEntity, pEntList, entityFlags, MAX_ENTITY ); int j; for ( j = 0; j < iEntity; j++ ) { // Mark entity table with 1<IsSolid() || (pOther->GetMoveType() == MOVETYPE_PUSH || pOther->GetMoveType() == MOVETYPE_NONE ) ) return; if (!PassesTriggerFilters(pOther)) return; // FIXME: If something is hierarchically attached, should we try to push the parent? if (pOther->GetMoveParent()) return; // Transform the push dir into global space Vector vecAbsDir; VectorRotate( m_vecPushDir, EntityToWorldTransform(), vecAbsDir ); // Instant trigger, just transfer velocity and remove if (HasSpawnFlags(SF_TRIG_PUSH_ONCE)) { pOther->ApplyAbsVelocityImpulse( m_flPushSpeed * vecAbsDir ); if ( vecAbsDir.z > 0 ) { pOther->SetGroundEntity( NULL ); } UTIL_Remove( this ); return; } switch( pOther->GetMoveType() ) { case MOVETYPE_NONE: case MOVETYPE_PUSH: case MOVETYPE_NOCLIP: break; case MOVETYPE_VPHYSICS: { IPhysicsObject *pPhys = pOther->VPhysicsGetObject(); if ( pPhys ) { // UNDONE: Assume the velocity is for a 100kg object, scale with mass pPhys->ApplyForceCenter( m_flPushSpeed * vecAbsDir * 100.0f * gpGlobals->frametime ); return; } } break; default: { #if defined( HL2_DLL ) // HACK HACK HL2 players on ladders will only be disengaged if the sf is set, otherwise no push occurs. if ( pOther->IsPlayer() && pOther->GetMoveType() == MOVETYPE_LADDER ) { if ( !HasSpawnFlags(SF_TRIG_PUSH_AFFECT_PLAYER_ON_LADDER) ) { // Ignore the push return; } } #endif Vector vecPush = (m_flPushSpeed * vecAbsDir); if ( ( pOther->GetFlags() & FL_BASEVELOCITY ) && !lagcompensation->IsCurrentlyDoingLagCompensation() ) { vecPush = vecPush + pOther->GetBaseVelocity(); } if ( vecPush.z > 0 && (pOther->GetFlags() & FL_ONGROUND) ) { pOther->SetGroundEntity( NULL ); Vector origin = pOther->GetAbsOrigin(); origin.z += 1.0f; pOther->SetAbsOrigin( origin ); } #ifdef HL1_DLL // Apply the z velocity as a force so it counteracts gravity properly Vector vecImpulse( 0, 0, vecPush.z * 0.025 );//magic hack number pOther->ApplyAbsVelocityImpulse( vecImpulse ); // apply x, y as a base velocity so we travel at constant speed on conveyors vecPush.z = 0; #endif pOther->SetBaseVelocity( vecPush ); pOther->AddFlag( FL_BASEVELOCITY ); } break; } } //----------------------------------------------------------------------------- // Teleport trigger //----------------------------------------------------------------------------- const int SF_TELEPORT_PRESERVE_ANGLES = 0x20; // Preserve angles even when a local landmark is not specified class CTriggerTeleport : public CBaseTrigger { public: DECLARE_CLASS( CTriggerTeleport, CBaseTrigger ); virtual void Spawn( void ) OVERRIDE; virtual void Touch( CBaseEntity *pOther ) OVERRIDE; string_t m_iLandmark; DECLARE_DATADESC(); }; LINK_ENTITY_TO_CLASS( trigger_teleport, CTriggerTeleport ); BEGIN_DATADESC( CTriggerTeleport ) DEFINE_KEYFIELD( m_iLandmark, FIELD_STRING, "landmark" ), END_DATADESC() void CTriggerTeleport::Spawn( void ) { InitTrigger(); } //----------------------------------------------------------------------------- // Purpose: Teleports the entity that touched us to the location of our target, // setting the toucher's angles to our target's angles if they are a // player. // // If a landmark was specified, the toucher is offset from the target // by their initial offset from the landmark and their angles are // left alone. // // Input : pOther - The entity that touched us. //----------------------------------------------------------------------------- void CTriggerTeleport::Touch( CBaseEntity *pOther ) { CBaseEntity *pentTarget = NULL; if (!PassesTriggerFilters(pOther)) { return; } // The activator and caller are the same pentTarget = gEntList.FindEntityByName( pentTarget, m_target, NULL, pOther, pOther ); if (!pentTarget) { return; } // // If a landmark was specified, offset the player relative to the landmark. // CBaseEntity *pentLandmark = NULL; Vector vecLandmarkOffset(0, 0, 0); if (m_iLandmark != NULL_STRING) { // The activator and caller are the same pentLandmark = gEntList.FindEntityByName(pentLandmark, m_iLandmark, NULL, pOther, pOther ); if (pentLandmark) { vecLandmarkOffset = pOther->GetAbsOrigin() - pentLandmark->GetAbsOrigin(); } } pOther->SetGroundEntity( NULL ); Vector tmp = pentTarget->GetAbsOrigin(); if (!pentLandmark && pOther->IsPlayer()) { // make origin adjustments in case the teleportee is a player. (origin in center, not at feet) tmp.z -= pOther->WorldAlignMins().z; } // // Only modify the toucher's angles and zero their velocity if no landmark was specified. // const QAngle *pAngles = NULL; Vector *pVelocity = NULL; #ifdef HL1_DLL Vector vecZero(0,0,0); #endif if (!pentLandmark && !HasSpawnFlags(SF_TELEPORT_PRESERVE_ANGLES) ) { pAngles = &pentTarget->GetAbsAngles(); #ifdef HL1_DLL pVelocity = &vecZero; #else pVelocity = NULL; //BUGBUG - This does not set the player's velocity to zero!!! #endif } tmp += vecLandmarkOffset; pOther->Teleport( &tmp, pAngles, pVelocity ); } LINK_ENTITY_TO_CLASS( info_teleport_destination, CPointEntity ); //----------------------------------------------------------------------------- // Teleport Relative trigger //----------------------------------------------------------------------------- class CTriggerTeleportRelative : public CBaseTrigger { public: DECLARE_CLASS(CTriggerTeleportRelative, CBaseTrigger); virtual void Spawn( void ) OVERRIDE; virtual void Touch( CBaseEntity *pOther ) OVERRIDE; Vector m_TeleportOffset; DECLARE_DATADESC(); }; LINK_ENTITY_TO_CLASS( trigger_teleport_relative, CTriggerTeleportRelative ); BEGIN_DATADESC( CTriggerTeleportRelative ) DEFINE_KEYFIELD( m_TeleportOffset, FIELD_VECTOR, "teleportoffset" ) END_DATADESC() void CTriggerTeleportRelative::Spawn( void ) { InitTrigger(); } void CTriggerTeleportRelative::Touch( CBaseEntity *pOther ) { if ( !PassesTriggerFilters(pOther) ) { return; } const Vector finalPos = m_TeleportOffset + WorldSpaceCenter(); const Vector *momentum = &vec3_origin; pOther->Teleport( &finalPos, NULL, momentum ); } //----------------------------------------------------------------------------- // Purpose: Saves the game when the player touches the trigger. Can be enabled or disabled //----------------------------------------------------------------------------- class CTriggerToggleSave : public CBaseTrigger { public: DECLARE_CLASS( CTriggerToggleSave, CBaseTrigger ); void Spawn( void ); void Touch( CBaseEntity *pOther ); void InputEnable( inputdata_t &inputdata ) { m_bDisabled = false; } void InputDisable( inputdata_t &inputdata ) { m_bDisabled = true; } bool m_bDisabled; // Initial state DECLARE_DATADESC(); }; BEGIN_DATADESC( CTriggerToggleSave ) DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ), DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ), DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ), END_DATADESC() LINK_ENTITY_TO_CLASS( trigger_togglesave, CTriggerToggleSave ); //----------------------------------------------------------------------------- // Purpose: Called when spawning, after keyvalues have been set. //----------------------------------------------------------------------------- void CTriggerToggleSave::Spawn( void ) { if ( g_pGameRules->IsDeathmatch() ) { UTIL_Remove( this ); return; } InitTrigger(); } //----------------------------------------------------------------------------- // Purpose: Performs the autosave when the player touches us. // Input : pOther - //----------------------------------------------------------------------------- void CTriggerToggleSave::Touch( CBaseEntity *pOther ) { if( m_bDisabled ) return; // Only save on clients if ( !pOther->IsPlayer() ) return; // Can be re-enabled m_bDisabled = true; engine->ServerCommand( "autosave\n" ); } //----------------------------------------------------------------------------- // Purpose: Saves the game when the player touches the trigger. //----------------------------------------------------------------------------- class CTriggerSave : public CBaseTrigger { public: DECLARE_CLASS( CTriggerSave, CBaseTrigger ); void Spawn( void ); void Touch( CBaseEntity *pOther ); DECLARE_DATADESC(); bool m_bForceNewLevelUnit; float m_fDangerousTimer; int m_minHitPoints; }; BEGIN_DATADESC( CTriggerSave ) DEFINE_KEYFIELD( m_bForceNewLevelUnit, FIELD_BOOLEAN, "NewLevelUnit" ), DEFINE_KEYFIELD( m_minHitPoints, FIELD_INTEGER, "MinimumHitPoints" ), DEFINE_KEYFIELD( m_fDangerousTimer, FIELD_FLOAT, "DangerousTimer" ), END_DATADESC() LINK_ENTITY_TO_CLASS( trigger_autosave, CTriggerSave ); //----------------------------------------------------------------------------- // Purpose: Called when spawning, after keyvalues have been set. //----------------------------------------------------------------------------- void CTriggerSave::Spawn( void ) { if ( g_pGameRules->IsDeathmatch() ) { UTIL_Remove( this ); return; } InitTrigger(); } //----------------------------------------------------------------------------- // Purpose: Performs the autosave when the player touches us. // Input : pOther - //----------------------------------------------------------------------------- void CTriggerSave::Touch( CBaseEntity *pOther ) { // Only save on clients if ( !pOther->IsPlayer() ) return; if ( m_fDangerousTimer != 0.0f ) { if ( g_ServerGameDLL.m_fAutoSaveDangerousTime != 0.0f && g_ServerGameDLL.m_fAutoSaveDangerousTime >= gpGlobals->curtime ) { // A previous dangerous auto save was waiting to become safe CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 ); if ( pPlayer->GetDeathTime() == 0.0f || pPlayer->GetDeathTime() > gpGlobals->curtime ) { // The player isn't dead, so make the dangerous auto save safe engine->ServerCommand( "autosavedangerousissafe\n" ); } } } // this is a one-way transition - there is no way to return to the previous map. if ( m_bForceNewLevelUnit ) { engine->ClearSaveDir(); } UTIL_Remove( this ); if ( m_fDangerousTimer != 0.0f ) { // There's a dangerous timer. Save if we have enough hitpoints. CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 ); if (pPlayer && pPlayer->GetHealth() >= m_minHitPoints) { engine->ServerCommand( "autosavedangerous\n" ); g_ServerGameDLL.m_fAutoSaveDangerousTime = gpGlobals->curtime + m_fDangerousTimer; } } else { engine->ServerCommand( "autosave\n" ); } } class CTriggerGravity : public CBaseTrigger { public: DECLARE_CLASS( CTriggerGravity, CBaseTrigger ); DECLARE_DATADESC(); void Spawn( void ); void GravityTouch( CBaseEntity *pOther ); }; LINK_ENTITY_TO_CLASS( trigger_gravity, CTriggerGravity ); BEGIN_DATADESC( CTriggerGravity ) // Function Pointers DEFINE_FUNCTION(GravityTouch), END_DATADESC() void CTriggerGravity::Spawn( void ) { BaseClass::Spawn(); InitTrigger(); SetTouch( &CTriggerGravity::GravityTouch ); } void CTriggerGravity::GravityTouch( CBaseEntity *pOther ) { // Only save on clients if ( !pOther->IsPlayer() ) return; pOther->SetGravity( GetGravity() ); } // this is a really bad idea. class CAI_ChangeTarget : public CBaseEntity { public: DECLARE_CLASS( CAI_ChangeTarget, CBaseEntity ); // Input handlers. void InputActivate( inputdata_t &inputdata ); int ObjectCaps( void ) { return BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } DECLARE_DATADESC(); private: string_t m_iszNewTarget; }; LINK_ENTITY_TO_CLASS( ai_changetarget, CAI_ChangeTarget ); BEGIN_DATADESC( CAI_ChangeTarget ) DEFINE_KEYFIELD( m_iszNewTarget, FIELD_STRING, "m_iszNewTarget" ), // Inputs DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ), END_DATADESC() void CAI_ChangeTarget::InputActivate( inputdata_t &inputdata ) { CBaseEntity *pTarget = NULL; while ((pTarget = gEntList.FindEntityByName( pTarget, m_target, NULL, inputdata.pActivator, inputdata.pCaller )) != NULL) { pTarget->m_target = m_iszNewTarget; CAI_BaseNPC *pNPC = pTarget->MyNPCPointer( ); if (pNPC) { pNPC->SetGoalEnt( NULL ); } } } //----------------------------------------------------------------------------- // Purpose: Change an NPC's hint group to something new //----------------------------------------------------------------------------- class CAI_ChangeHintGroup : public CBaseEntity { public: DECLARE_CLASS( CAI_ChangeHintGroup, CBaseEntity ); int ObjectCaps( void ) { return BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } // Input handlers. void InputActivate( inputdata_t &inputdata ); DECLARE_DATADESC(); private: CAI_BaseNPC *FindQualifiedNPC( CAI_BaseNPC *pPrev, CBaseEntity *pActivator, CBaseEntity *pCaller ); int m_iSearchType; string_t m_strSearchName; string_t m_strNewHintGroup; float m_flRadius; bool m_bHintGroupNavLimiting; }; LINK_ENTITY_TO_CLASS( ai_changehintgroup, CAI_ChangeHintGroup ); BEGIN_DATADESC( CAI_ChangeHintGroup ) DEFINE_KEYFIELD( m_iSearchType, FIELD_INTEGER, "SearchType" ), DEFINE_KEYFIELD( m_strSearchName, FIELD_STRING, "SearchName" ), DEFINE_KEYFIELD( m_strNewHintGroup, FIELD_STRING, "NewHintGroup" ), DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "Radius" ), DEFINE_KEYFIELD( m_bHintGroupNavLimiting, FIELD_BOOLEAN, "hintlimiting" ), DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ), END_DATADESC() CAI_BaseNPC *CAI_ChangeHintGroup::FindQualifiedNPC( CAI_BaseNPC *pPrev, CBaseEntity *pActivator, CBaseEntity *pCaller ) { CBaseEntity *pEntity = pPrev; CAI_BaseNPC *pResult = NULL; const char *pszSearchName = STRING(m_strSearchName); while ( !pResult ) { // Find a candidate switch ( m_iSearchType ) { case 0: { pEntity = gEntList.FindEntityByNameWithin( pEntity, pszSearchName, GetLocalOrigin(), m_flRadius, NULL, pActivator, pCaller ); break; } case 1: { pEntity = gEntList.FindEntityByClassnameWithin( pEntity, pszSearchName, GetLocalOrigin(), m_flRadius ); break; } case 2: { pEntity = gEntList.FindEntityInSphere( pEntity, GetLocalOrigin(), ( m_flRadius != 0.0 ) ? m_flRadius : FLT_MAX ); break; } } if ( !pEntity ) return NULL; // Qualify pResult = pEntity->MyNPCPointer(); if ( pResult && m_iSearchType == 2 && (!FStrEq( STRING(pResult->GetHintGroup()), pszSearchName ) ) ) { pResult = NULL; } } return pResult; } void CAI_ChangeHintGroup::InputActivate( inputdata_t &inputdata ) { CAI_BaseNPC *pTarget = NULL; while((pTarget = FindQualifiedNPC( pTarget, inputdata.pActivator, inputdata.pCaller )) != NULL) { pTarget->SetHintGroup( m_strNewHintGroup, m_bHintGroupNavLimiting ); } } #define SF_CAMERA_PLAYER_POSITION 1 #define SF_CAMERA_PLAYER_TARGET 2 #define SF_CAMERA_PLAYER_TAKECONTROL 4 #define SF_CAMERA_PLAYER_INFINITE_WAIT 8 #define SF_CAMERA_PLAYER_SNAP_TO 16 #define SF_CAMERA_PLAYER_NOT_SOLID 32 #define SF_CAMERA_PLAYER_INTERRUPT 64 //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- class CTriggerCamera : public CBaseEntity { public: DECLARE_CLASS( CTriggerCamera, CBaseEntity ); void Spawn( void ); bool KeyValue( const char *szKeyName, const char *szValue ); void Enable( void ); void Disable( void ); void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void FollowTarget( void ); void Move(void); // Always transmit to clients so they know where to move the view to virtual int UpdateTransmitState(); DECLARE_DATADESC(); // Input handlers void InputEnable( inputdata_t &inputdata ); void InputDisable( inputdata_t &inputdata ); private: EHANDLE m_hPlayer; EHANDLE m_hTarget; // used for moving the camera along a path (rail rides) CBaseEntity *m_pPath; string_t m_sPath; float m_flWait; float m_flReturnTime; float m_flStopTime; float m_moveDistance; float m_targetSpeed; float m_initialSpeed; float m_acceleration; float m_deceleration; int m_state; Vector m_vecMoveDir; string_t m_iszTargetAttachment; int m_iAttachmentIndex; bool m_bSnapToGoal; #if HL2_EPISODIC bool m_bInterpolatePosition; // these are interpolation vars used for interpolating the camera over time Vector m_vStartPos, m_vEndPos; float m_flInterpStartTime; const static float kflPosInterpTime; // seconds #endif int m_nPlayerButtons; int m_nOldTakeDamage; private: COutputEvent m_OnEndFollow; }; #if HL2_EPISODIC const float CTriggerCamera::kflPosInterpTime = 2.0f; #endif LINK_ENTITY_TO_CLASS( point_viewcontrol, CTriggerCamera ); BEGIN_DATADESC( CTriggerCamera ) DEFINE_FIELD( m_hPlayer, FIELD_EHANDLE ), DEFINE_FIELD( m_hTarget, FIELD_EHANDLE ), DEFINE_FIELD( m_pPath, FIELD_CLASSPTR ), DEFINE_FIELD( m_sPath, FIELD_STRING ), DEFINE_FIELD( m_flWait, FIELD_FLOAT ), DEFINE_FIELD( m_flReturnTime, FIELD_TIME ), DEFINE_FIELD( m_flStopTime, FIELD_TIME ), DEFINE_FIELD( m_moveDistance, FIELD_FLOAT ), DEFINE_FIELD( m_targetSpeed, FIELD_FLOAT ), DEFINE_FIELD( m_initialSpeed, FIELD_FLOAT ), DEFINE_FIELD( m_acceleration, FIELD_FLOAT ), DEFINE_FIELD( m_deceleration, FIELD_FLOAT ), DEFINE_FIELD( m_state, FIELD_INTEGER ), DEFINE_FIELD( m_vecMoveDir, FIELD_VECTOR ), DEFINE_KEYFIELD( m_iszTargetAttachment, FIELD_STRING, "targetattachment" ), DEFINE_FIELD( m_iAttachmentIndex, FIELD_INTEGER ), DEFINE_FIELD( m_bSnapToGoal, FIELD_BOOLEAN ), #if HL2_EPISODIC DEFINE_KEYFIELD( m_bInterpolatePosition, FIELD_BOOLEAN, "interpolatepositiontoplayer" ), DEFINE_FIELD( m_vStartPos, FIELD_VECTOR ), DEFINE_FIELD( m_vEndPos, FIELD_VECTOR ), DEFINE_FIELD( m_flInterpStartTime, FIELD_TIME ), #endif DEFINE_FIELD( m_nPlayerButtons, FIELD_INTEGER ), DEFINE_FIELD( m_nOldTakeDamage, FIELD_INTEGER ), // Inputs DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ), DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ), // Function Pointers DEFINE_FUNCTION( FollowTarget ), DEFINE_OUTPUT( m_OnEndFollow, "OnEndFollow" ), END_DATADESC() //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerCamera::Spawn( void ) { BaseClass::Spawn(); SetMoveType( MOVETYPE_NOCLIP ); SetSolid( SOLID_NONE ); // Remove model & collisions SetRenderColorA( 0 ); // The engine won't draw this model if this is set to 0 and blending is on m_nRenderMode = kRenderTransTexture; m_state = USE_OFF; m_initialSpeed = m_flSpeed; if ( m_acceleration == 0 ) m_acceleration = 500; if ( m_deceleration == 0 ) m_deceleration = 500; DispatchUpdateTransmitState(); } int CTriggerCamera::UpdateTransmitState() { // always tranmit if currently used by a monitor if ( m_state == USE_ON ) { return SetTransmitState( FL_EDICT_ALWAYS ); } else { return SetTransmitState( FL_EDICT_DONTSEND ); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CTriggerCamera::KeyValue( const char *szKeyName, const char *szValue ) { if (FStrEq(szKeyName, "wait")) { m_flWait = atof(szValue); } else if (FStrEq(szKeyName, "moveto")) { m_sPath = AllocPooledString( szValue ); } else if (FStrEq(szKeyName, "acceleration")) { m_acceleration = atof( szValue ); } else if (FStrEq(szKeyName, "deceleration")) { m_deceleration = atof( szValue ); } else return BaseClass::KeyValue( szKeyName, szValue ); return true; } //------------------------------------------------------------------------------ // Purpose: Input handler to turn on this trigger. //------------------------------------------------------------------------------ void CTriggerCamera::InputEnable( inputdata_t &inputdata ) { m_hPlayer = inputdata.pActivator; Enable(); } //------------------------------------------------------------------------------ // Purpose: Input handler to turn off this trigger. //------------------------------------------------------------------------------ void CTriggerCamera::InputDisable( inputdata_t &inputdata ) { Disable(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerCamera::Enable( void ) { m_state = USE_ON; if ( !m_hPlayer || !m_hPlayer->IsPlayer() ) { m_hPlayer = UTIL_GetLocalPlayer(); } if ( !m_hPlayer ) { DispatchUpdateTransmitState(); return; } Assert( m_hPlayer->IsPlayer() ); CBasePlayer *pPlayer = NULL; if ( m_hPlayer->IsPlayer() ) { pPlayer = ((CBasePlayer*)m_hPlayer.Get()); } else { Warning("CTriggerCamera could not find a player!\n"); return; } // if the player was already under control of a similar trigger, disable the previous trigger. { CBaseEntity *pPrevViewControl = pPlayer->GetViewEntity(); if (pPrevViewControl && pPrevViewControl != pPlayer) { CTriggerCamera *pOtherCamera = dynamic_cast(pPrevViewControl); if ( pOtherCamera ) { if ( pOtherCamera == this ) { // what the hell do you think you are doing? Warning("Viewcontrol %s was enabled twice in a row!\n", GetDebugName()); return; } else { pOtherCamera->Disable(); } } } } m_nPlayerButtons = pPlayer->m_nButtons; // Make the player invulnerable while under control of the camera. This will prevent situations where the player dies while under camera control but cannot restart their game due to disabled player inputs. m_nOldTakeDamage = m_hPlayer->m_takedamage; m_hPlayer->m_takedamage = DAMAGE_NO; if ( HasSpawnFlags( SF_CAMERA_PLAYER_NOT_SOLID ) ) { m_hPlayer->AddSolidFlags( FSOLID_NOT_SOLID ); } m_flReturnTime = gpGlobals->curtime + m_flWait; m_flSpeed = m_initialSpeed; m_targetSpeed = m_initialSpeed; // this pertains to view angles, not translation. if ( HasSpawnFlags( SF_CAMERA_PLAYER_SNAP_TO ) ) { m_bSnapToGoal = true; } if ( HasSpawnFlags(SF_CAMERA_PLAYER_TARGET ) ) { m_hTarget = m_hPlayer; } else { m_hTarget = GetNextTarget(); } // If we don't have a target, ignore the attachment / etc if ( m_hTarget ) { m_iAttachmentIndex = 0; if ( m_iszTargetAttachment != NULL_STRING ) { if ( !m_hTarget->GetBaseAnimating() ) { Warning("%s tried to target an attachment (%s) on target %s, which has no model.\n", GetClassname(), STRING(m_iszTargetAttachment), STRING(m_hTarget->GetEntityName()) ); } else { m_iAttachmentIndex = m_hTarget->GetBaseAnimating()->LookupAttachment( STRING(m_iszTargetAttachment) ); if ( m_iAttachmentIndex <= 0 ) { Warning("%s could not find attachment %s on target %s.\n", GetClassname(), STRING(m_iszTargetAttachment), STRING(m_hTarget->GetEntityName()) ); } } } } if (HasSpawnFlags(SF_CAMERA_PLAYER_TAKECONTROL ) ) { ((CBasePlayer*)m_hPlayer.Get())->EnableControl(FALSE); } if ( m_sPath != NULL_STRING ) { m_pPath = gEntList.FindEntityByName( NULL, m_sPath, NULL, m_hPlayer ); } else { m_pPath = NULL; } m_flStopTime = gpGlobals->curtime; if ( m_pPath ) { if ( m_pPath->m_flSpeed != 0 ) m_targetSpeed = m_pPath->m_flSpeed; m_flStopTime += m_pPath->GetDelay(); } // copy over player information. If we're interpolating from // the player position, do something more elaborate. #if HL2_EPISODIC if (m_bInterpolatePosition) { // initialize the values we'll spline between m_vStartPos = m_hPlayer->EyePosition(); m_vEndPos = GetAbsOrigin(); m_flInterpStartTime = gpGlobals->curtime; UTIL_SetOrigin( this, m_hPlayer->EyePosition() ); SetLocalAngles( QAngle( m_hPlayer->GetLocalAngles().x, m_hPlayer->GetLocalAngles().y, 0 ) ); SetAbsVelocity( vec3_origin ); } else #endif if (HasSpawnFlags(SF_CAMERA_PLAYER_POSITION ) ) { UTIL_SetOrigin( this, m_hPlayer->EyePosition() ); SetLocalAngles( QAngle( m_hPlayer->GetLocalAngles().x, m_hPlayer->GetLocalAngles().y, 0 ) ); SetAbsVelocity( m_hPlayer->GetAbsVelocity() ); } else { SetAbsVelocity( vec3_origin ); } pPlayer->SetViewEntity( this ); // Hide the player's viewmodel if ( pPlayer->GetActiveWeapon() ) { pPlayer->GetActiveWeapon()->AddEffects( EF_NODRAW ); } // Only track if we have a target if ( m_hTarget ) { // follow the player down SetThink( &CTriggerCamera::FollowTarget ); SetNextThink( gpGlobals->curtime ); } m_moveDistance = 0; Move(); DispatchUpdateTransmitState(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerCamera::Disable( void ) { if ( m_hPlayer && m_hPlayer->IsAlive() ) { if ( HasSpawnFlags( SF_CAMERA_PLAYER_NOT_SOLID ) ) { m_hPlayer->RemoveSolidFlags( FSOLID_NOT_SOLID ); } ((CBasePlayer*)m_hPlayer.Get())->SetViewEntity( m_hPlayer ); ((CBasePlayer*)m_hPlayer.Get())->EnableControl(TRUE); // Restore the player's viewmodel if ( ((CBasePlayer*)m_hPlayer.Get())->GetActiveWeapon() ) { ((CBasePlayer*)m_hPlayer.Get())->GetActiveWeapon()->RemoveEffects( EF_NODRAW ); } //return the player to previous takedamage state m_hPlayer->m_takedamage = m_nOldTakeDamage; } m_state = USE_OFF; m_flReturnTime = gpGlobals->curtime; SetThink( NULL ); m_OnEndFollow.FireOutput(this, this); // dvsents2: what is the best name for this output? SetLocalAngularVelocity( vec3_angle ); DispatchUpdateTransmitState(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerCamera::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if ( !ShouldToggle( useType, m_state ) ) return; // Toggle state if ( m_state != USE_OFF ) { Disable(); } else { m_hPlayer = pActivator; Enable(); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerCamera::FollowTarget( ) { if (m_hPlayer == NULL) return; if ( m_hTarget == NULL ) { Disable(); return; } if ( !HasSpawnFlags(SF_CAMERA_PLAYER_INFINITE_WAIT) && (!m_hTarget || m_flReturnTime < gpGlobals->curtime) ) { Disable(); return; } QAngle vecGoal; if ( m_iAttachmentIndex ) { Vector vecOrigin; m_hTarget->GetBaseAnimating()->GetAttachment( m_iAttachmentIndex, vecOrigin ); VectorAngles( vecOrigin - GetAbsOrigin(), vecGoal ); } else { if ( m_hTarget ) { VectorAngles( m_hTarget->GetAbsOrigin() - GetAbsOrigin(), vecGoal ); } else { // Use the viewcontroller's angles vecGoal = GetAbsAngles(); } } // Should we just snap to the goal angles? if ( m_bSnapToGoal ) { SetAbsAngles( vecGoal ); m_bSnapToGoal = false; } else { // UNDONE: Can't we just use UTIL_AngleDiff here? QAngle angles = GetLocalAngles(); if (angles.y > 360) angles.y -= 360; if (angles.y < 0) angles.y += 360; SetLocalAngles( angles ); float dx = vecGoal.x - GetLocalAngles().x; float dy = vecGoal.y - GetLocalAngles().y; if (dx < -180) dx += 360; if (dx > 180) dx = dx - 360; if (dy < -180) dy += 360; if (dy > 180) dy = dy - 360; QAngle vecAngVel; vecAngVel.Init( dx * 40 * gpGlobals->frametime, dy * 40 * gpGlobals->frametime, GetLocalAngularVelocity().z ); SetLocalAngularVelocity(vecAngVel); } if (!HasSpawnFlags(SF_CAMERA_PLAYER_TAKECONTROL)) { SetAbsVelocity( GetAbsVelocity() * 0.8 ); if (GetAbsVelocity().Length( ) < 10.0) { SetAbsVelocity( vec3_origin ); } } SetNextThink( gpGlobals->curtime ); Move(); } void CTriggerCamera::Move() { if ( HasSpawnFlags( SF_CAMERA_PLAYER_INTERRUPT ) ) { if ( m_hPlayer ) { CBasePlayer *pPlayer = ToBasePlayer( m_hPlayer ); if ( pPlayer ) { int buttonsChanged = m_nPlayerButtons ^ pPlayer->m_nButtons; if ( buttonsChanged && pPlayer->m_nButtons ) { Disable(); return; } m_nPlayerButtons = pPlayer->m_nButtons; } } } // In vanilla HL2, the camera is either on a path, or doesn't move. In episodic // we add the capacity for interpolation to the start point. #if HL2_EPISODIC if (m_pPath) #else // Not moving on a path, return if (!m_pPath) return; #endif { // Subtract movement from the previous frame m_moveDistance -= m_flSpeed * gpGlobals->frametime; // Have we moved enough to reach the target? if ( m_moveDistance <= 0 ) { variant_t emptyVariant; m_pPath->AcceptInput( "InPass", this, this, emptyVariant, 0 ); // Time to go to the next target m_pPath = m_pPath->GetNextTarget(); // Set up next corner if ( !m_pPath ) { SetAbsVelocity( vec3_origin ); } else { if ( m_pPath->m_flSpeed != 0 ) m_targetSpeed = m_pPath->m_flSpeed; m_vecMoveDir = m_pPath->GetLocalOrigin() - GetLocalOrigin(); m_moveDistance = VectorNormalize( m_vecMoveDir ); m_flStopTime = gpGlobals->curtime + m_pPath->GetDelay(); } } if ( m_flStopTime > gpGlobals->curtime ) m_flSpeed = UTIL_Approach( 0, m_flSpeed, m_deceleration * gpGlobals->frametime ); else m_flSpeed = UTIL_Approach( m_targetSpeed, m_flSpeed, m_acceleration * gpGlobals->frametime ); float fraction = 2 * gpGlobals->frametime; SetAbsVelocity( ((m_vecMoveDir * m_flSpeed) * fraction) + (GetAbsVelocity() * (1-fraction)) ); } #if HL2_EPISODIC else if (m_bInterpolatePosition) { // get the interpolation parameter [0..1] float tt = (gpGlobals->curtime - m_flInterpStartTime) / kflPosInterpTime; if (tt >= 1.0f) { // we're there, we're done UTIL_SetOrigin( this, m_vEndPos ); SetAbsVelocity( vec3_origin ); m_bInterpolatePosition = false; } else { Assert(tt >= 0); Vector nextPos = ( (m_vEndPos - m_vStartPos) * SimpleSpline(tt) ) + m_vStartPos; // rather than stomping origin, set the velocity so that we get there in the proper time Vector desiredVel = (nextPos - GetAbsOrigin()) * (1.0f / gpGlobals->frametime); SetAbsVelocity( desiredVel ); } } #endif } //----------------------------------------------------------------------------- // Purpose: Starts/stops cd audio tracks //----------------------------------------------------------------------------- class CTriggerCDAudio : public CBaseTrigger { public: DECLARE_CLASS( CTriggerCDAudio, CBaseTrigger ); void Spawn( void ); virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void PlayTrack( void ); void Touch ( CBaseEntity *pOther ); }; LINK_ENTITY_TO_CLASS( trigger_cdaudio, CTriggerCDAudio ); //----------------------------------------------------------------------------- // Purpose: Changes tracks or stops CD when player touches // Input : pOther - The entity that touched us. //----------------------------------------------------------------------------- void CTriggerCDAudio::Touch ( CBaseEntity *pOther ) { if ( !pOther->IsPlayer() ) { return; } PlayTrack(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerCDAudio::Spawn( void ) { BaseClass::Spawn(); InitTrigger(); } void CTriggerCDAudio::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { PlayTrack(); } //----------------------------------------------------------------------------- // Purpose: Issues a client command to play a given CD track. Called from // trigger_cdaudio and target_cdaudio. // Input : iTrack - Track number to play. //----------------------------------------------------------------------------- static void PlayCDTrack( int iTrack ) { edict_t *pClient; // manually find the single player. pClient = engine->PEntityOfEntIndex( 1 ); Assert(gpGlobals->maxClients == 1); // Can't play if the client is not connected! if ( !pClient ) return; // UNDONE: Move this to engine sound if ( iTrack < -1 || iTrack > 30 ) { Warning( "TriggerCDAudio - Track %d out of range\n", iTrack ); return; } if ( iTrack == -1 ) { engine->ClientCommand ( pClient, "cd pause\n"); } else { engine->ClientCommand ( pClient, "cd play %3d\n", iTrack); } } // only plays for ONE client, so only use in single play! void CTriggerCDAudio::PlayTrack( void ) { PlayCDTrack( (int)m_iHealth ); SetTouch( NULL ); UTIL_Remove( this ); } //----------------------------------------------------------------------------- // Purpose: Measures the proximity to a specified entity of any entities within // the trigger, provided they are within a given radius of the specified // entity. The nearest entity distance is output as a number from [0 - 1]. //----------------------------------------------------------------------------- class CTriggerProximity : public CBaseTrigger { public: DECLARE_CLASS( CTriggerProximity, CBaseTrigger ); virtual void Spawn(void); virtual void Activate(void); virtual void StartTouch(CBaseEntity *pOther); virtual void EndTouch(CBaseEntity *pOther); void MeasureThink(void); protected: EHANDLE m_hMeasureTarget; string_t m_iszMeasureTarget; // The entity from which we measure proximities. float m_fRadius; // The radius around the measure target that we measure within. int m_nTouchers; // Number of entities touching us. // Outputs COutputFloat m_NearestEntityDistance; DECLARE_DATADESC(); }; BEGIN_DATADESC( CTriggerProximity ) // Functions DEFINE_FUNCTION(MeasureThink), // Keys DEFINE_KEYFIELD(m_iszMeasureTarget, FIELD_STRING, "measuretarget"), DEFINE_FIELD( m_hMeasureTarget, FIELD_EHANDLE ), DEFINE_KEYFIELD(m_fRadius, FIELD_FLOAT, "radius"), DEFINE_FIELD( m_nTouchers, FIELD_INTEGER ), // Outputs DEFINE_OUTPUT(m_NearestEntityDistance, "NearestEntityDistance"), END_DATADESC() LINK_ENTITY_TO_CLASS(trigger_proximity, CTriggerProximity); LINK_ENTITY_TO_CLASS(logic_proximity, CPointEntity); //----------------------------------------------------------------------------- // Purpose: Called when spawning, after keyvalues have been handled. //----------------------------------------------------------------------------- void CTriggerProximity::Spawn(void) { // Avoid divide by zero in MeasureThink! if (m_fRadius == 0) { m_fRadius = 32; } InitTrigger(); } //----------------------------------------------------------------------------- // Purpose: Called after all entities have spawned and after a load game. // Finds the reference point from which to measure. //----------------------------------------------------------------------------- void CTriggerProximity::Activate(void) { BaseClass::Activate(); m_hMeasureTarget = gEntList.FindEntityByName(NULL, m_iszMeasureTarget ); // // Disable our Touch function if we were given a bad measure target. // if ((m_hMeasureTarget == NULL) || (m_hMeasureTarget->edict() == NULL)) { Warning( "TriggerProximity - Missing measure target or measure target with no origin!\n"); } } //----------------------------------------------------------------------------- // Purpose: Decrements the touch count and cancels the think if the count reaches // zero. // Input : pOther - //----------------------------------------------------------------------------- void CTriggerProximity::StartTouch(CBaseEntity *pOther) { BaseClass::StartTouch( pOther ); if ( PassesTriggerFilters( pOther ) ) { m_nTouchers++; SetThink( &CTriggerProximity::MeasureThink ); SetNextThink( gpGlobals->curtime ); } } //----------------------------------------------------------------------------- // Purpose: Decrements the touch count and cancels the think if the count reaches // zero. // Input : pOther - //----------------------------------------------------------------------------- void CTriggerProximity::EndTouch(CBaseEntity *pOther) { BaseClass::EndTouch( pOther ); if ( PassesTriggerFilters( pOther ) ) { m_nTouchers--; if ( m_nTouchers == 0 ) { SetThink( NULL ); SetNextThink( TICK_NEVER_THINK ); } } } //----------------------------------------------------------------------------- // Purpose: Think function called every frame as long as we have entities touching // us that we care about. Finds the closest entity to the measure // target and outputs the distance as a normalized value from [0..1]. //----------------------------------------------------------------------------- void CTriggerProximity::MeasureThink( void ) { if ( ( m_hMeasureTarget == NULL ) || ( m_hMeasureTarget->edict() == NULL ) ) { SetThink(NULL); SetNextThink( TICK_NEVER_THINK ); return; } // // Traverse our list of touchers and find the entity that is closest to the // measure target. // float fMinDistance = m_fRadius + 100; CBaseEntity *pNearestEntity = NULL; touchlink_t *root = ( touchlink_t * )GetDataObject( TOUCHLINK ); if ( root ) { touchlink_t *pLink = root->nextLink; while ( pLink != root ) { CBaseEntity *pEntity = pLink->entityTouched; // If this is an entity that we care about, check its distance. if ( ( pEntity != NULL ) && PassesTriggerFilters( pEntity ) ) { float flDistance = (pEntity->GetLocalOrigin() - m_hMeasureTarget->GetLocalOrigin()).Length(); if (flDistance < fMinDistance) { fMinDistance = flDistance; pNearestEntity = pEntity; } } pLink = pLink->nextLink; } } // Update our output with the nearest entity distance, normalized to [0..1]. if ( fMinDistance <= m_fRadius ) { fMinDistance /= m_fRadius; if ( fMinDistance != m_NearestEntityDistance.Get() ) { m_NearestEntityDistance.Set( fMinDistance, pNearestEntity, this ); } } SetNextThink( gpGlobals->curtime ); } // ################################################################################## // >> TriggerWind // // Blows physics objects in the trigger // // ################################################################################## #define MAX_WIND_CHANGE 5.0f //------------------------------------------------------------------------------ // Purpose : // Input : // Output : //------------------------------------------------------------------------------ class CPhysicsWind : public IMotionEvent { DECLARE_SIMPLE_DATADESC(); public: simresult_e Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular ) { // If we have no windspeed, we're not doing anything if ( !m_flWindSpeed ) return IMotionEvent::SIM_NOTHING; // Get a cosine modulated noise between 5 and 20 that is object specific int nNoiseMod = 5+(int)pObject%15; // // Turn wind yaw direction into a vector and add noise QAngle vWindAngle = vec3_angle; vWindAngle[1] = m_nWindYaw+(30*cos(nNoiseMod * gpGlobals->curtime + nNoiseMod)); Vector vWind; AngleVectors(vWindAngle,&vWind); // Add lift with noise vWind.z = 1.1 + (1.0 * sin(nNoiseMod * gpGlobals->curtime + nNoiseMod)); linear = 3*vWind*m_flWindSpeed; angular = vec3_origin; return IMotionEvent::SIM_GLOBAL_FORCE; } int m_nWindYaw; float m_flWindSpeed; }; BEGIN_SIMPLE_DATADESC( CPhysicsWind ) DEFINE_FIELD( m_nWindYaw, FIELD_INTEGER ), DEFINE_FIELD( m_flWindSpeed, FIELD_FLOAT ), END_DATADESC() extern short g_sModelIndexSmoke; extern float GetFloorZ(const Vector &origin); #define WIND_THINK_CONTEXT "WindThinkContext" //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- class CTriggerWind : public CBaseVPhysicsTrigger { DECLARE_CLASS( CTriggerWind, CBaseVPhysicsTrigger ); public: DECLARE_DATADESC(); void Spawn( void ); bool KeyValue( const char *szKeyName, const char *szValue ); void OnRestore(); void UpdateOnRemove(); bool CreateVPhysics(); void StartTouch( CBaseEntity *pOther ); void EndTouch( CBaseEntity *pOther ); void WindThink( void ); int DrawDebugTextOverlays( void ); // Input handlers void InputEnable( inputdata_t &inputdata ); void InputSetSpeed( inputdata_t &inputdata ); private: int m_nSpeedBase; // base line for how hard the wind blows int m_nSpeedNoise; // noise added to wind speed +/- int m_nSpeedCurrent;// current wind speed int m_nSpeedTarget; // wind speed I'm approaching int m_nDirBase; // base line for direction the wind blows (yaw) int m_nDirNoise; // noise added to wind direction int m_nDirCurrent; // the current wind direction int m_nDirTarget; // wind direction I'm approaching int m_nHoldBase; // base line for how long to wait before changing wind int m_nHoldNoise; // noise added to how long to wait before changing wind bool m_bSwitch; // when does wind change IPhysicsMotionController* m_pWindController; CPhysicsWind m_WindCallback; }; LINK_ENTITY_TO_CLASS( trigger_wind, CTriggerWind ); BEGIN_DATADESC( CTriggerWind ) DEFINE_FIELD( m_nSpeedCurrent, FIELD_INTEGER), DEFINE_FIELD( m_nSpeedTarget, FIELD_INTEGER), DEFINE_FIELD( m_nDirBase, FIELD_INTEGER), DEFINE_FIELD( m_nDirCurrent, FIELD_INTEGER), DEFINE_FIELD( m_nDirTarget, FIELD_INTEGER), DEFINE_FIELD( m_bSwitch, FIELD_BOOLEAN), DEFINE_FIELD( m_nSpeedBase, FIELD_INTEGER ), DEFINE_KEYFIELD( m_nSpeedNoise, FIELD_INTEGER, "SpeedNoise"), DEFINE_KEYFIELD( m_nDirNoise, FIELD_INTEGER, "DirectionNoise"), DEFINE_KEYFIELD( m_nHoldBase, FIELD_INTEGER, "HoldTime"), DEFINE_KEYFIELD( m_nHoldNoise, FIELD_INTEGER, "HoldNoise"), DEFINE_PHYSPTR( m_pWindController ), DEFINE_EMBEDDED( m_WindCallback ), DEFINE_FUNCTION( WindThink ), DEFINE_INPUTFUNC( FIELD_INTEGER, "SetSpeed", InputSetSpeed ), END_DATADESC() //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerWind::Spawn( void ) { m_bSwitch = true; m_nDirBase = GetLocalAngles().y; BaseClass::Spawn(); m_nSpeedCurrent = m_nSpeedBase; m_nDirCurrent = m_nDirBase; SetContextThink( &CTriggerWind::WindThink, gpGlobals->curtime, WIND_THINK_CONTEXT ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CTriggerWind::KeyValue( const char *szKeyName, const char *szValue ) { // Done here to avoid collision with CBaseEntity's speed key if ( FStrEq(szKeyName, "Speed") ) { m_nSpeedBase = atoi( szValue ); } else return BaseClass::KeyValue( szKeyName, szValue ); return true; } //------------------------------------------------------------------------------ // Create VPhysics //------------------------------------------------------------------------------ bool CTriggerWind::CreateVPhysics() { BaseClass::CreateVPhysics(); m_pWindController = physenv->CreateMotionController( &m_WindCallback ); return true; } //------------------------------------------------------------------------------ // Cleanup //------------------------------------------------------------------------------ void CTriggerWind::UpdateOnRemove() { if ( m_pWindController ) { physenv->DestroyMotionController( m_pWindController ); m_pWindController = NULL; } BaseClass::UpdateOnRemove(); } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerWind::OnRestore() { BaseClass::OnRestore(); if ( m_pWindController ) { m_pWindController->SetEventHandler( &m_WindCallback ); } } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerWind::StartTouch(CBaseEntity *pOther) { if ( !PassesTriggerFilters(pOther) ) return; if ( pOther->IsPlayer() ) return; IPhysicsObject *pPhys = pOther->VPhysicsGetObject(); if ( pPhys) { m_pWindController->AttachObject( pPhys, false ); pPhys->Wake(); } } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerWind::EndTouch(CBaseEntity *pOther) { if ( !PassesTriggerFilters(pOther) ) return; if ( pOther->IsPlayer() ) return; IPhysicsObject *pPhys = pOther->VPhysicsGetObject(); if ( pPhys && m_pWindController ) { m_pWindController->DetachObject( pPhys ); } } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerWind::InputEnable( inputdata_t &inputdata ) { BaseClass::InputEnable( inputdata ); SetContextThink( &CTriggerWind::WindThink, gpGlobals->curtime + 0.1f, WIND_THINK_CONTEXT ); } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerWind::WindThink( void ) { // By default... SetContextThink( &CTriggerWind::WindThink, gpGlobals->curtime + 0.1, WIND_THINK_CONTEXT ); // Is it time to change the wind? if (m_bSwitch) { m_bSwitch = false; // Set new target direction and speed m_nSpeedTarget = m_nSpeedBase + random->RandomInt( -m_nSpeedNoise, m_nSpeedNoise ); m_nDirTarget = UTIL_AngleMod( m_nDirBase + random->RandomInt(-m_nDirNoise, m_nDirNoise) ); } else { bool bDone = true; // either ramp up, or sleep till change if (abs(m_nSpeedTarget - m_nSpeedCurrent) > MAX_WIND_CHANGE) { m_nSpeedCurrent += (m_nSpeedTarget > m_nSpeedCurrent) ? MAX_WIND_CHANGE : -MAX_WIND_CHANGE; bDone = false; } if (abs(m_nDirTarget - m_nDirCurrent) > MAX_WIND_CHANGE) { m_nDirCurrent = UTIL_ApproachAngle( m_nDirTarget, m_nDirCurrent, MAX_WIND_CHANGE ); bDone = false; } if (bDone) { m_nSpeedCurrent = m_nSpeedTarget; SetContextThink( &CTriggerWind::WindThink, m_nHoldBase + random->RandomFloat(-m_nHoldNoise,m_nHoldNoise), WIND_THINK_CONTEXT ); m_bSwitch = true; } } // If we're starting to blow, where we weren't before, wake up all our objects if ( m_nSpeedCurrent ) { m_pWindController->WakeObjects(); } // store the wind data in the controller callback m_WindCallback.m_nWindYaw = m_nDirCurrent; if ( m_bDisabled ) { m_WindCallback.m_flWindSpeed = 0; } else { m_WindCallback.m_flWindSpeed = m_nSpeedCurrent; } } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerWind::InputSetSpeed( inputdata_t &inputdata ) { // Set new speed and mark to switch m_nSpeedBase = inputdata.value.Int(); m_bSwitch = true; } //----------------------------------------------------------------------------- // Purpose: Draw any debug text overlays // Output : Current text offset from the top //----------------------------------------------------------------------------- int CTriggerWind::DrawDebugTextOverlays(void) { int text_offset = BaseClass::DrawDebugTextOverlays(); if (m_debugOverlays & OVERLAY_TEXT_BIT) { // -------------- // Print Target // -------------- char tempstr[255]; Q_snprintf(tempstr,sizeof(tempstr),"Dir: %i (%i)",m_nDirCurrent,m_nDirTarget); EntityText(text_offset,tempstr,0); text_offset++; Q_snprintf(tempstr,sizeof(tempstr),"Speed: %i (%i)",m_nSpeedCurrent,m_nSpeedTarget); EntityText(text_offset,tempstr,0); text_offset++; } return text_offset; } // ################################################################################## // >> TriggerImpact // // Blows physics objects in the trigger // // ################################################################################## #define TRIGGERIMPACT_VIEWKICK_SCALE 0.1 class CTriggerImpact : public CTriggerMultiple { DECLARE_CLASS( CTriggerImpact, CTriggerMultiple ); public: DECLARE_DATADESC(); float m_flMagnitude; float m_flNoise; float m_flViewkick; void Spawn( void ); void StartTouch( CBaseEntity *pOther ); // Inputs void InputSetMagnitude( inputdata_t &inputdata ); void InputImpact( inputdata_t &inputdata ); // Outputs COutputVector m_pOutputForce; // Output force in case anyone else wants to use it // Debug int DrawDebugTextOverlays(void); }; LINK_ENTITY_TO_CLASS( trigger_impact, CTriggerImpact ); BEGIN_DATADESC( CTriggerImpact ) DEFINE_KEYFIELD( m_flMagnitude, FIELD_FLOAT, "Magnitude"), DEFINE_KEYFIELD( m_flNoise, FIELD_FLOAT, "Noise"), DEFINE_KEYFIELD( m_flViewkick, FIELD_FLOAT, "Viewkick"), // Inputs DEFINE_INPUTFUNC( FIELD_VOID, "Impact", InputImpact ), DEFINE_INPUTFUNC( FIELD_FLOAT, "SetMagnitude", InputSetMagnitude ), // Outputs DEFINE_OUTPUT(m_pOutputForce, "ImpactForce"), // Function Pointers DEFINE_FUNCTION( Disable ), END_DATADESC() //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerImpact::Spawn( void ) { // Clamp date in case user made an error m_flNoise = clamp(m_flNoise,0.f,1.f); m_flViewkick = clamp(m_flViewkick,0.f,1.f); // Always start disabled m_bDisabled = true; BaseClass::Spawn(); } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerImpact::InputImpact( inputdata_t &inputdata ) { // Output the force vector in case anyone else wants to use it Vector vDir; AngleVectors( GetLocalAngles(),&vDir ); m_pOutputForce.Set( m_flMagnitude * vDir, inputdata.pActivator, inputdata.pCaller); // Enable long enough to throw objects inside me Enable(); SetNextThink( gpGlobals->curtime + 0.1f ); SetThink(&CTriggerImpact::Disable); } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerImpact::StartTouch(CBaseEntity *pOther) { //If the entity is valid and has physics, hit it if ( ( pOther != NULL ) && ( pOther->VPhysicsGetObject() != NULL ) ) { Vector vDir; AngleVectors( GetLocalAngles(),&vDir ); vDir += RandomVector(-m_flNoise,m_flNoise); pOther->VPhysicsGetObject()->ApplyForceCenter( m_flMagnitude * vDir ); } // If the player, so a view kick if (pOther->IsPlayer() && fabs(m_flMagnitude)>0 ) { Vector vDir; AngleVectors( GetLocalAngles(),&vDir ); float flPunch = -m_flViewkick*m_flMagnitude*TRIGGERIMPACT_VIEWKICK_SCALE; pOther->ViewPunch( QAngle( vDir.y * flPunch, 0, vDir.x * flPunch ) ); } } //------------------------------------------------------------------------------ // Purpose: //------------------------------------------------------------------------------ void CTriggerImpact::InputSetMagnitude( inputdata_t &inputdata ) { m_flMagnitude = inputdata.value.Float(); } //----------------------------------------------------------------------------- // Purpose: Draw any debug text overlays // Output : Current text offset from the top //----------------------------------------------------------------------------- int CTriggerImpact::DrawDebugTextOverlays(void) { int text_offset = BaseClass::DrawDebugTextOverlays(); if (m_debugOverlays & OVERLAY_TEXT_BIT) { char tempstr[255]; Q_snprintf(tempstr,sizeof(tempstr),"Magnitude: %3.2f",m_flMagnitude); EntityText(text_offset,tempstr,0); text_offset++; } return text_offset; } //----------------------------------------------------------------------------- // Purpose: Disables auto movement on players that touch it //----------------------------------------------------------------------------- const int SF_TRIGGER_MOVE_AUTODISABLE = 0x80; // disable auto movement const int SF_TRIGGER_AUTO_DUCK = 0x800; // Duck automatically class CTriggerPlayerMovement : public CBaseTrigger { DECLARE_CLASS( CTriggerPlayerMovement, CBaseTrigger ); public: void Spawn( void ); void StartTouch( CBaseEntity *pOther ); void EndTouch( CBaseEntity *pOther ); DECLARE_DATADESC(); }; BEGIN_DATADESC( CTriggerPlayerMovement ) END_DATADESC() LINK_ENTITY_TO_CLASS( trigger_playermovement, CTriggerPlayerMovement ); //----------------------------------------------------------------------------- // Purpose: Called when spawning, after keyvalues have been handled. //----------------------------------------------------------------------------- void CTriggerPlayerMovement::Spawn( void ) { if( HasSpawnFlags( SF_TRIGGER_ONLY_PLAYER_ALLY_NPCS ) ) { // @Note (toml 01-07-04): fix up spawn flag collision coding error. Remove at some point once all maps fixed up please! DevMsg("*** trigger_playermovement using obsolete spawnflag. Remove and reset with new value for \"Disable auto player movement\"\n" ); RemoveSpawnFlags(SF_TRIGGER_ONLY_PLAYER_ALLY_NPCS); AddSpawnFlags(SF_TRIGGER_MOVE_AUTODISABLE); } BaseClass::Spawn(); InitTrigger(); } // UNDONE: This will not support a player touching more than one of these // UNDONE: Do we care? If so, ref count automovement in the player? void CTriggerPlayerMovement::StartTouch( CBaseEntity *pOther ) { if (!PassesTriggerFilters(pOther)) return; CBasePlayer *pPlayer = ToBasePlayer( pOther ); if ( !pPlayer ) return; if ( HasSpawnFlags( SF_TRIGGER_AUTO_DUCK ) ) { pPlayer->ForceButtons( IN_DUCK ); } // UNDONE: Currently this is the only operation this trigger can do if ( HasSpawnFlags(SF_TRIGGER_MOVE_AUTODISABLE) ) { pPlayer->m_Local.m_bAllowAutoMovement = false; } } void CTriggerPlayerMovement::EndTouch( CBaseEntity *pOther ) { if (!PassesTriggerFilters(pOther)) return; CBasePlayer *pPlayer = ToBasePlayer( pOther ); if ( !pPlayer ) return; if ( HasSpawnFlags( SF_TRIGGER_AUTO_DUCK ) ) { pPlayer->UnforceButtons( IN_DUCK ); } if ( HasSpawnFlags(SF_TRIGGER_MOVE_AUTODISABLE) ) { pPlayer->m_Local.m_bAllowAutoMovement = true; } } //------------------------------------------------------------------------------ // Base VPhysics trigger implementation //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ // Save/load //------------------------------------------------------------------------------ BEGIN_DATADESC( CBaseVPhysicsTrigger ) DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ), DEFINE_KEYFIELD( m_iFilterName, FIELD_STRING, "filtername" ), DEFINE_FIELD( m_hFilter, FIELD_EHANDLE ), DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ), DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ), DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ), END_DATADESC() //------------------------------------------------------------------------------ // Spawn //------------------------------------------------------------------------------ void CBaseVPhysicsTrigger::Spawn() { Precache(); SetSolid( SOLID_VPHYSICS ); AddSolidFlags( FSOLID_NOT_SOLID ); // NOTE: Don't make yourself FSOLID_TRIGGER here or you'll get game // collisions AND vphysics collisions. You don't want any game collisions // so just use FSOLID_NOT_SOLID SetMoveType( MOVETYPE_NONE ); SetModel( STRING( GetModelName() ) ); // set size and link into world if ( showtriggers.GetInt() == 0 ) { AddEffects( EF_NODRAW ); } CreateVPhysics(); } //------------------------------------------------------------------------------ // Create VPhysics //------------------------------------------------------------------------------ bool CBaseVPhysicsTrigger::CreateVPhysics() { IPhysicsObject *pPhysics; if ( !HasSpawnFlags( SF_VPHYSICS_MOTION_MOVEABLE ) ) { pPhysics = VPhysicsInitStatic(); } else { pPhysics = VPhysicsInitShadow( false, false ); } pPhysics->BecomeTrigger(); return true; } //------------------------------------------------------------------------------ // Cleanup //------------------------------------------------------------------------------ void CBaseVPhysicsTrigger::UpdateOnRemove() { if ( VPhysicsGetObject()) { VPhysicsGetObject()->RemoveTrigger(); } BaseClass::UpdateOnRemove(); } //------------------------------------------------------------------------------ // Activate //------------------------------------------------------------------------------ void CBaseVPhysicsTrigger::Activate( void ) { // Get a handle to my filter entity if there is one if (m_iFilterName != NULL_STRING) { m_hFilter = dynamic_cast(gEntList.FindEntityByName( NULL, m_iFilterName )); } BaseClass::Activate(); } //------------------------------------------------------------------------------ // Inputs //------------------------------------------------------------------------------ void CBaseVPhysicsTrigger::InputToggle( inputdata_t &inputdata ) { if ( m_bDisabled ) { InputEnable( inputdata ); } else { InputDisable( inputdata ); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CBaseVPhysicsTrigger::InputEnable( inputdata_t &inputdata ) { if ( m_bDisabled ) { m_bDisabled = false; if ( VPhysicsGetObject()) { VPhysicsGetObject()->EnableCollisions( true ); } } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CBaseVPhysicsTrigger::InputDisable( inputdata_t &inputdata ) { if ( !m_bDisabled ) { m_bDisabled = true; if ( VPhysicsGetObject()) { VPhysicsGetObject()->EnableCollisions( false ); } } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CBaseVPhysicsTrigger::StartTouch( CBaseEntity *pOther ) { } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CBaseVPhysicsTrigger::EndTouch( CBaseEntity *pOther ) { } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CBaseVPhysicsTrigger::PassesTriggerFilters( CBaseEntity *pOther ) { if ( pOther->GetMoveType() != MOVETYPE_VPHYSICS && !pOther->IsPlayer() ) return false; // First test spawn flag filters if ( HasSpawnFlags(SF_TRIGGER_ALLOW_ALL) || (HasSpawnFlags(SF_TRIGGER_ALLOW_CLIENTS) && (pOther->GetFlags() & FL_CLIENT)) || (HasSpawnFlags(SF_TRIGGER_ALLOW_NPCS) && (pOther->GetFlags() & FL_NPC)) || (HasSpawnFlags(SF_TRIGGER_ALLOW_PUSHABLES) && FClassnameIs(pOther, "func_pushable")) || (HasSpawnFlags(SF_TRIGGER_ALLOW_PHYSICS) && pOther->GetMoveType() == MOVETYPE_VPHYSICS)) { bool bOtherIsPlayer = pOther->IsPlayer(); if( HasSpawnFlags(SF_TRIGGER_ONLY_PLAYER_ALLY_NPCS) && !bOtherIsPlayer ) { CAI_BaseNPC *pNPC = pOther->MyNPCPointer(); if( !pNPC || !pNPC->IsPlayerAlly() ) { return false; } } if ( HasSpawnFlags(SF_TRIGGER_ONLY_CLIENTS_IN_VEHICLES) && bOtherIsPlayer ) { if ( !((CBasePlayer*)pOther)->IsInAVehicle() ) return false; } if ( HasSpawnFlags(SF_TRIGGER_ONLY_CLIENTS_OUT_OF_VEHICLES) && bOtherIsPlayer ) { if ( ((CBasePlayer*)pOther)->IsInAVehicle() ) return false; } CBaseFilter *pFilter = m_hFilter.Get(); return (!pFilter) ? true : pFilter->PassesFilter( this, pOther ); } return false; } //===================================================================================================================== //----------------------------------------------------------------------------- // Purpose: VPhysics trigger that changes the motion of vphysics objects that touch it //----------------------------------------------------------------------------- class CTriggerVPhysicsMotion : public CBaseVPhysicsTrigger, public IMotionEvent { DECLARE_CLASS( CTriggerVPhysicsMotion, CBaseVPhysicsTrigger ); public: void Spawn(); void Precache(); virtual void UpdateOnRemove(); bool CreateVPhysics(); void OnRestore(); // UNDONE: Pass trigger event in or change Start/EndTouch. Add ITriggerVPhysics perhaps? // BUGBUG: If a player touches two of these, his movement will screw up. // BUGBUG: If a player uses crouch/uncrouch it will generate touch events and clear the motioncontroller flag void StartTouch( CBaseEntity *pOther ); void EndTouch( CBaseEntity *pOther ); void InputSetVelocityLimitTime( inputdata_t &inputdata ); float LinearLimit(); inline bool HasGravityScale() { return m_gravityScale != 1.0 ? true : false; } inline bool HasAirDensity() { return m_addAirDensity != 0 ? true : false; } inline bool HasLinearLimit() { return LinearLimit() != 0.0f; } inline bool HasLinearScale() { return m_linearScale != 1.0 ? true : false; } inline bool HasAngularLimit() { return m_angularLimit != 0 ? true : false; } inline bool HasAngularScale() { return m_angularScale != 1.0 ? true : false; } inline bool HasLinearForce() { return m_linearForce != 0.0 ? true : false; } DECLARE_DATADESC(); virtual simresult_e Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular ); private: IPhysicsMotionController *m_pController; #ifndef _XBOX EntityParticleTrailInfo_t m_ParticleTrail; #endif //!_XBOX float m_gravityScale; float m_addAirDensity; float m_linearLimit; float m_linearLimitDelta; float m_linearLimitTime; float m_linearLimitStart; float m_linearLimitStartTime; float m_linearScale; float m_angularLimit; float m_angularScale; float m_linearForce; QAngle m_linearForceAngles; }; //------------------------------------------------------------------------------ // Save/load //------------------------------------------------------------------------------ BEGIN_DATADESC( CTriggerVPhysicsMotion ) DEFINE_PHYSPTR( m_pController ), #ifndef _XBOX DEFINE_EMBEDDED( m_ParticleTrail ), #endif //!_XBOX DEFINE_INPUT( m_gravityScale, FIELD_FLOAT, "SetGravityScale" ), DEFINE_INPUT( m_addAirDensity, FIELD_FLOAT, "SetAdditionalAirDensity" ), DEFINE_INPUT( m_linearLimit, FIELD_FLOAT, "SetVelocityLimit" ), DEFINE_INPUT( m_linearLimitDelta, FIELD_FLOAT, "SetVelocityLimitDelta" ), DEFINE_FIELD( m_linearLimitTime, FIELD_FLOAT ), DEFINE_FIELD( m_linearLimitStart, FIELD_TIME ), DEFINE_FIELD( m_linearLimitStartTime, FIELD_TIME ), DEFINE_INPUT( m_linearScale, FIELD_FLOAT, "SetVelocityScale" ), DEFINE_INPUT( m_angularLimit, FIELD_FLOAT, "SetAngVelocityLimit" ), DEFINE_INPUT( m_angularScale, FIELD_FLOAT, "SetAngVelocityScale" ), DEFINE_INPUT( m_linearForce, FIELD_FLOAT, "SetLinearForce" ), DEFINE_INPUT( m_linearForceAngles, FIELD_VECTOR, "SetLinearForceAngles" ), DEFINE_INPUTFUNC( FIELD_STRING, "SetVelocityLimitTime", InputSetVelocityLimitTime ), END_DATADESC() LINK_ENTITY_TO_CLASS( trigger_vphysics_motion, CTriggerVPhysicsMotion ); //------------------------------------------------------------------------------ // Spawn //------------------------------------------------------------------------------ void CTriggerVPhysicsMotion::Spawn() { Precache(); BaseClass::Spawn(); } //------------------------------------------------------------------------------ // Precache //------------------------------------------------------------------------------ void CTriggerVPhysicsMotion::Precache() { #ifndef _XBOX if ( m_ParticleTrail.m_strMaterialName != NULL_STRING ) { PrecacheMaterial( STRING(m_ParticleTrail.m_strMaterialName) ); } #endif //!_XBOX } //------------------------------------------------------------------------------ // Create VPhysics //------------------------------------------------------------------------------ float CTriggerVPhysicsMotion::LinearLimit() { if ( m_linearLimitTime == 0.0f ) return m_linearLimit; float dt = gpGlobals->curtime - m_linearLimitStartTime; if ( dt >= m_linearLimitTime ) { m_linearLimitTime = 0.0; return m_linearLimit; } dt /= m_linearLimitTime; float flLimit = RemapVal( dt, 0.0f, 1.0f, m_linearLimitStart, m_linearLimit ); return flLimit; } //------------------------------------------------------------------------------ // Create VPhysics //------------------------------------------------------------------------------ bool CTriggerVPhysicsMotion::CreateVPhysics() { m_pController = physenv->CreateMotionController( this ); BaseClass::CreateVPhysics(); return true; } //------------------------------------------------------------------------------ // Cleanup //------------------------------------------------------------------------------ void CTriggerVPhysicsMotion::UpdateOnRemove() { if ( m_pController ) { physenv->DestroyMotionController( m_pController ); m_pController = NULL; } BaseClass::UpdateOnRemove(); } //------------------------------------------------------------------------------ // Restore //------------------------------------------------------------------------------ void CTriggerVPhysicsMotion::OnRestore() { BaseClass::OnRestore(); if ( m_pController ) { m_pController->SetEventHandler( this ); } } //------------------------------------------------------------------------------ // Start/End Touch //------------------------------------------------------------------------------ // UNDONE: Pass trigger event in or change Start/EndTouch. Add ITriggerVPhysics perhaps? // BUGBUG: If a player touches two of these, his movement will screw up. // BUGBUG: If a player uses crouch/uncrouch it will generate touch events and clear the motioncontroller flag void CTriggerVPhysicsMotion::StartTouch( CBaseEntity *pOther ) { BaseClass::StartTouch( pOther ); if ( !PassesTriggerFilters(pOther) ) return; CBasePlayer *pPlayer = ToBasePlayer( pOther ); if ( pPlayer ) { pPlayer->SetPhysicsFlag( PFLAG_VPHYSICS_MOTIONCONTROLLER, true ); pPlayer->m_Local.m_bSlowMovement = true; } triggerevent_t event; PhysGetTriggerEvent( &event, this ); if ( event.pObject ) { // these all get done again on save/load, so check m_pController->AttachObject( event.pObject, true ); } // Don't show these particles on the XBox #ifndef _XBOX if ( m_ParticleTrail.m_strMaterialName != NULL_STRING ) { CEntityParticleTrail::Create( pOther, m_ParticleTrail, this ); } #endif if ( pOther->GetBaseAnimating() && pOther->GetBaseAnimating()->IsRagdoll() ) { CRagdollBoogie::IncrementSuppressionCount( pOther ); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerVPhysicsMotion::EndTouch( CBaseEntity *pOther ) { BaseClass::EndTouch( pOther ); if ( !PassesTriggerFilters(pOther) ) return; CBasePlayer *pPlayer = ToBasePlayer( pOther ); if ( pPlayer ) { pPlayer->SetPhysicsFlag( PFLAG_VPHYSICS_MOTIONCONTROLLER, false ); pPlayer->m_Local.m_bSlowMovement = false; } triggerevent_t event; PhysGetTriggerEvent( &event, this ); if ( event.pObject && m_pController ) { m_pController->DetachObject( event.pObject ); } #ifndef _XBOX if ( m_ParticleTrail.m_strMaterialName != NULL_STRING ) { CEntityParticleTrail::Destroy( pOther, m_ParticleTrail ); } #endif //!_XBOX if ( pOther->GetBaseAnimating() && pOther->GetBaseAnimating()->IsRagdoll() ) { CRagdollBoogie::DecrementSuppressionCount( pOther ); } } //------------------------------------------------------------------------------ // Inputs //------------------------------------------------------------------------------ void CTriggerVPhysicsMotion::InputSetVelocityLimitTime( inputdata_t &inputdata ) { m_linearLimitStart = LinearLimit(); m_linearLimitStartTime = gpGlobals->curtime; float args[2]; UTIL_StringToFloatArray( args, 2, inputdata.value.String() ); m_linearLimit = args[0]; m_linearLimitTime = args[1]; } //------------------------------------------------------------------------------ // Apply the forces to the entity //------------------------------------------------------------------------------ IMotionEvent::simresult_e CTriggerVPhysicsMotion::Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular ) { if ( m_bDisabled ) return SIM_NOTHING; linear.Init(); angular.Init(); if ( HasGravityScale() ) { // assume object already has 1.0 gravities applied to it, so apply the additional amount linear.z -= (m_gravityScale-1) * GetCurrentGravity(); } if ( HasLinearForce() ) { Vector vecForceDir; AngleVectors( m_linearForceAngles, &vecForceDir ); VectorMA( linear, m_linearForce, vecForceDir, linear ); } if ( HasAirDensity() || HasLinearLimit() || HasLinearScale() || HasAngularLimit() || HasAngularScale() ) { Vector vel; AngularImpulse angVel; pObject->GetVelocity( &vel, &angVel ); vel += linear * deltaTime; // account for gravity scale Vector unitVel = vel; Vector unitAngVel = angVel; float speed = VectorNormalize( unitVel ); float angSpeed = VectorNormalize( unitAngVel ); float speedScale = 0.0; float angSpeedScale = 0.0; if ( HasAirDensity() ) { float linearDrag = -0.5 * m_addAirDensity * pObject->CalculateLinearDrag( unitVel ) * deltaTime; if ( linearDrag < -1 ) { linearDrag = -1; } speedScale += linearDrag / deltaTime; float angDrag = -0.5 * m_addAirDensity * pObject->CalculateAngularDrag( unitAngVel ) * deltaTime; if ( angDrag < -1 ) { angDrag = -1; } angSpeedScale += angDrag / deltaTime; } if ( HasLinearLimit() && speed > m_linearLimit ) { float flDeltaVel = (LinearLimit() - speed) / deltaTime; if ( m_linearLimitDelta != 0.0f ) { float flMaxDeltaVel = -m_linearLimitDelta / deltaTime; if ( flDeltaVel < flMaxDeltaVel ) { flDeltaVel = flMaxDeltaVel; } } VectorMA( linear, flDeltaVel, unitVel, linear ); } if ( HasAngularLimit() && angSpeed > m_angularLimit ) { angular += ((m_angularLimit - angSpeed)/deltaTime) * unitAngVel; } if ( HasLinearScale() ) { speedScale = ( (speedScale+1) * m_linearScale ) - 1; } if ( HasAngularScale() ) { angSpeedScale = ( (angSpeedScale+1) * m_angularScale ) - 1; } linear += vel * speedScale; angular += angVel * angSpeedScale; } return SIM_GLOBAL_ACCELERATION; } class CServerRagdollTrigger : public CBaseTrigger { DECLARE_CLASS( CServerRagdollTrigger, CBaseTrigger ); public: virtual void StartTouch( CBaseEntity *pOther ); virtual void EndTouch( CBaseEntity *pOther ); virtual void Spawn( void ); }; LINK_ENTITY_TO_CLASS( trigger_serverragdoll, CServerRagdollTrigger ); void CServerRagdollTrigger::Spawn( void ) { BaseClass::Spawn(); InitTrigger(); } void CServerRagdollTrigger::StartTouch(CBaseEntity *pOther) { BaseClass::StartTouch( pOther ); if ( pOther->IsPlayer() ) return; CBaseCombatCharacter *pCombatChar = pOther->MyCombatCharacterPointer(); if ( pCombatChar ) { pCombatChar->m_bForceServerRagdoll = true; } } void CServerRagdollTrigger::EndTouch(CBaseEntity *pOther) { BaseClass::EndTouch( pOther ); if ( pOther->IsPlayer() ) return; CBaseCombatCharacter *pCombatChar = pOther->MyCombatCharacterPointer(); if ( pCombatChar ) { pCombatChar->m_bForceServerRagdoll = false; } } //----------------------------------------------------------------------------- // Purpose: A trigger that adds impulse to touching entities //----------------------------------------------------------------------------- class CTriggerApplyImpulse : public CBaseTrigger { public: DECLARE_CLASS( CTriggerApplyImpulse, CBaseTrigger ); DECLARE_DATADESC(); CTriggerApplyImpulse(); void Spawn( void ); void InputApplyImpulse( inputdata_t& ); private: Vector m_vecImpulseDir; float m_flForce; }; BEGIN_DATADESC( CTriggerApplyImpulse ) DEFINE_KEYFIELD( m_vecImpulseDir, FIELD_VECTOR, "impulse_dir" ), DEFINE_KEYFIELD( m_flForce, FIELD_FLOAT, "force" ), DEFINE_INPUTFUNC( FIELD_VOID, "ApplyImpulse", InputApplyImpulse ), END_DATADESC() LINK_ENTITY_TO_CLASS( trigger_apply_impulse, CTriggerApplyImpulse ); CTriggerApplyImpulse::CTriggerApplyImpulse() { m_flForce = 300.f; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerApplyImpulse::Spawn() { // Convert pushdir from angles to a vector Vector vecAbsDir; QAngle angPushDir = QAngle(m_vecImpulseDir.x, m_vecImpulseDir.y, m_vecImpulseDir.z); AngleVectors(angPushDir, &vecAbsDir); // Transform the vector into entity space VectorIRotate( vecAbsDir, EntityToWorldTransform(), m_vecImpulseDir ); BaseClass::Spawn(); InitTrigger(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTriggerApplyImpulse::InputApplyImpulse( inputdata_t& ) { Vector vecImpulse = m_flForce * m_vecImpulseDir; FOR_EACH_VEC( m_hTouchingEntities, i ) { if ( m_hTouchingEntities[i] ) { m_hTouchingEntities[i]->ApplyAbsVelocityImpulse( vecImpulse ); } } } #ifdef HL1_DLL //---------------------------------------------------------------------------------- // func_friction //---------------------------------------------------------------------------------- class CFrictionModifier : public CBaseTrigger { DECLARE_CLASS( CFrictionModifier, CBaseTrigger ); public: void Spawn( void ); bool KeyValue( const char *szKeyName, const char *szValue ); virtual void StartTouch(CBaseEntity *pOther); virtual void EndTouch(CBaseEntity *pOther); virtual int ObjectCaps( void ) { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } float m_frictionFraction; DECLARE_DATADESC(); }; LINK_ENTITY_TO_CLASS( func_friction, CFrictionModifier ); BEGIN_DATADESC( CFrictionModifier ) DEFINE_FIELD( m_frictionFraction, FIELD_FLOAT ), END_DATADESC() // Modify an entity's friction void CFrictionModifier::Spawn( void ) { BaseClass::Spawn(); InitTrigger(); } // Sets toucher's friction to m_frictionFraction (1.0 = normal friction) bool CFrictionModifier::KeyValue( const char *szKeyName, const char *szValue ) { if (FStrEq(szKeyName, "modifier")) { m_frictionFraction = atof(szValue) / 100.0; } else { BaseClass::KeyValue( szKeyName, szValue ); } return true; } void CFrictionModifier::StartTouch( CBaseEntity *pOther ) { if ( !pOther->IsPlayer() ) // ignore player { pOther->SetFriction( m_frictionFraction ); } } void CFrictionModifier::EndTouch( CBaseEntity *pOther ) { if ( !pOther->IsPlayer() ) // ignore player { pOther->SetFriction( 1.0f ); } } #endif //HL1_DLL bool IsTriggerClass( CBaseEntity *pEntity ) { if ( NULL != dynamic_cast(pEntity) ) return true; if ( NULL != dynamic_cast(pEntity) ) return true; if ( NULL != dynamic_cast(pEntity) ) return true; return false; }