/*** * * Copyright (c) 1996-2002, Valve LLC. All rights reserved. * * This product contains software technology licensed from Id * Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc. * All Rights Reserved. * * Use, distribution, and modification of this source code and/or resulting * object code is restricted to non-commercial enhancements to products from * Valve LLC. All other use, distribution, or modification is prohibited * without written permission from Valve LLC. * ****/ /* ===== triggers.cpp ======================================================== spawn and use functions for editor-placed triggers */ //CODIAC - Linux needs this for tolower #include #include "extdll.h" #include "util.h" #include "cbase.h" #include "player.h" #include "saverestore.h" #include "trains.h" // trigger_camera has train functionality #include "gamerules.h" #include "talkmonster.h" #include "weapons.h" //LRC, for trigger_hevcharge #include "movewith.h" //LRC #include "locus.h" //LRC //#include "hgrunt.h" //#include "islave.h" #define SF_TRIGGER_PUSH_START_OFF 2//spawnflag that makes trigger_push spawn turned OFF #define SF_TRIGGER_HURT_TARGETONCE 1// Only fire hurt target once #define SF_TRIGGER_HURT_START_OFF 2//spawnflag that makes trigger_hurt spawn turned OFF #define SF_TRIGGER_HURT_NO_CLIENTS 8// clients may not touch this trigger. #define SF_TRIGGER_HURT_CLIENTONLYFIRE 16// trigger hurt will only fire its target if it is hurting a client #define SF_TRIGGER_HURT_CLIENTONLYTOUCH 32// only clients may touch this trigger. extern DLL_GLOBAL BOOL g_fGameOver; extern void SetMovedir(entvars_t* pev); extern Vector VecBModelOrigin( entvars_t* pevBModel ); class CFrictionModifier : public CBaseEntity { public: void Spawn( void ); void KeyValue( KeyValueData *pkvd ); void EXPORT ChangeFriction( CBaseEntity *pOther ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); virtual int ObjectCaps( void ) { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } static TYPEDESCRIPTION m_SaveData[]; float m_frictionFraction; // Sorry, couldn't resist this name :) }; LINK_ENTITY_TO_CLASS( func_friction, CFrictionModifier ) // Global Savedata for changelevel friction modifier TYPEDESCRIPTION CFrictionModifier::m_SaveData[] = { DEFINE_FIELD( CFrictionModifier, m_frictionFraction, FIELD_FLOAT ), }; IMPLEMENT_SAVERESTORE( CFrictionModifier, CBaseEntity ) // Modify an entity's friction void CFrictionModifier::Spawn( void ) { pev->solid = SOLID_TRIGGER; SET_MODEL( ENT( pev ), STRING( pev->model ) ); // set size and link into world pev->movetype = MOVETYPE_NONE; SetTouch( &CFrictionModifier::ChangeFriction ); } // Sets toucher's friction to m_frictionFraction (1.0 = normal friction) void CFrictionModifier::ChangeFriction( CBaseEntity *pOther ) { if( pOther->pev->movetype != MOVETYPE_BOUNCEMISSILE && pOther->pev->movetype != MOVETYPE_BOUNCE ) pOther->pev->friction = m_frictionFraction; } // Sets toucher's friction to m_frictionFraction (1.0 = normal friction) void CFrictionModifier::KeyValue( KeyValueData *pkvd ) { if( FStrEq(pkvd->szKeyName, "modifier" ) ) { m_frictionFraction = atof( pkvd->szValue ) / 100.0; pkvd->fHandled = TRUE; } else CBaseEntity::KeyValue( pkvd ); } // This trigger will fire when the level spawns (or respawns if not fire once) // It will check a global state before firing. It supports delay and killtargets #define SF_AUTO_FIREONCE 0x0001 #define SF_AUTO_FROMPLAYER 0x0002 class CAutoTrigger : public CBaseDelay { public: void KeyValue( KeyValueData *pkvd ); void Activate( void ); void DesiredAction( void ); int ObjectCaps( void ) { return CBaseDelay::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; private: string_t m_globalstate; USE_TYPE triggerType; }; LINK_ENTITY_TO_CLASS( trigger_auto, CAutoTrigger ) TYPEDESCRIPTION CAutoTrigger::m_SaveData[] = { DEFINE_FIELD( CAutoTrigger, m_globalstate, FIELD_STRING ), DEFINE_FIELD( CAutoTrigger, triggerType, FIELD_INTEGER ), }; IMPLEMENT_SAVERESTORE( CAutoTrigger, CBaseDelay ) void CAutoTrigger::KeyValue( KeyValueData *pkvd ) { if( FStrEq( pkvd->szKeyName, "globalstate" ) ) { m_globalstate = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if( FStrEq( pkvd->szKeyName, "triggerstate" ) ) { int type = atoi( pkvd->szValue ); switch( type ) { case 0: triggerType = USE_OFF; break; case 2: triggerType = USE_TOGGLE; break; default: triggerType = USE_ON; break; } pkvd->fHandled = TRUE; } else CBaseDelay::KeyValue( pkvd ); } void CAutoTrigger::Activate( void ) { // ALERT(at_console, "trigger_auto targetting \"%s\": activate\n", STRING(pev->target)); UTIL_DesiredAction( this ); //LRC - don't think until the player has spawned. CBaseDelay::Activate(); } void CAutoTrigger::DesiredAction( void ) { // ALERT(at_console, "trigger_auto targetting \"%s\": Fire at time %f\n", STRING(pev->target), gpGlobals->time); if( !m_globalstate || gGlobalState.EntityGetState( m_globalstate ) == GLOBAL_ON ) { if (pev->spawnflags & SF_AUTO_FROMPLAYER) { CBaseEntity* pPlayer = UTIL_FindEntityByClassname(NULL, "player"); if (pPlayer) SUB_UseTargets( pPlayer, triggerType, 0 ); else ALERT(at_error,"trigger_auto: \"From Player\" is ticked, but no player found!\n"); } else { SUB_UseTargets( this, triggerType, 0 ); } if( pev->spawnflags & SF_AUTO_FIREONCE ) UTIL_Remove( this ); } } #define SF_RELAY_FIREONCE 0x00000001 #define SF_RELAY_DEBUG 0x00000002 #define SF_RELAY_USESAME 0x80000000 class CTriggerRelay : public CBaseDelay { public: void KeyValue( KeyValueData *pkvd ); void Spawn( void ); void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); int ObjectCaps( void ) { return CBaseDelay::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; private: USE_TYPE m_triggerType; int m_sMaster; string_t m_iszAltTarget; }; LINK_ENTITY_TO_CLASS( trigger_relay, CTriggerRelay ) TYPEDESCRIPTION CTriggerRelay::m_SaveData[] = { DEFINE_FIELD( CTriggerRelay, m_triggerType, FIELD_INTEGER ), DEFINE_FIELD( CTriggerRelay, m_sMaster, FIELD_STRING ), }; IMPLEMENT_SAVERESTORE( CTriggerRelay, CBaseDelay ) void CTriggerRelay::KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "master")) { m_sMaster = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszAltTarget")) { m_iszAltTarget = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "triggerstate")) { int type = atoi( pkvd->szValue ); switch( type ) { case 0: m_triggerType = USE_OFF; break; case 2: m_triggerType = USE_TOGGLE; break; case 4: m_triggerType = USE_KILL; break; case 5: m_triggerType = USE_SAME; break; case 7: m_triggerType = USE_SET; break; default: m_triggerType = USE_ON; break; } pkvd->fHandled = TRUE; } else CBaseDelay::KeyValue( pkvd ); } void CTriggerRelay::Spawn( void ) { } void CTriggerRelay::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if (!UTIL_IsMasterTriggered(m_sMaster,pActivator)) { if (m_iszAltTarget) { //FIXME: the alternate target should really use m_flDelay. if (pev->spawnflags & SF_RELAY_USESAME) FireTargets( STRING(m_iszAltTarget), pActivator, this, useType, 0 ); else FireTargets( STRING(m_iszAltTarget), pActivator, this, m_triggerType, 0 ); if (pev->spawnflags & SF_RELAY_DEBUG) ALERT(at_console,"DEBUG: trigger_relay \"%s\" locked by master %s - fired alternate target %s\n",STRING(pev->targetname), STRING(m_sMaster), STRING(m_iszAltTarget)); if ( pev->spawnflags & SF_RELAY_FIREONCE ) { if (pev->spawnflags & SF_RELAY_DEBUG) ALERT(at_console, "trigger_relay \"%s\" removes itself.\n"); UTIL_Remove( this ); } } else if (pev->spawnflags & SF_RELAY_DEBUG) ALERT(at_console,"DEBUG: trigger_relay \"%s\" wasn't activated: locked by master %s\n",STRING(pev->targetname), STRING(m_sMaster)); return; } if (pev->spawnflags & SF_RELAY_DEBUG) { ALERT(at_console,"DEBUG: trigger_relay \"%s\" was sent %s",STRING(pev->targetname), GetStringForUseType(useType)); if (pActivator) { if (FStringNull(pActivator->pev->targetname)) ALERT(at_console," from \"%s\"", STRING(pActivator->pev->classname)); else ALERT(at_console," from \"%s\"", STRING(pActivator->pev->targetname)); } else ALERT(at_console," (no locus)"); } if (FStringNull(pev->target) && !m_iszKillTarget) { if (pev->spawnflags & SF_RELAY_DEBUG) ALERT(at_console, ".\n"); return; } if (pev->message) value = CalcLocus_Ratio(pActivator, STRING(pev->message)); if (m_triggerType == USE_SAME) { if (pev->spawnflags & SF_RELAY_DEBUG) { if (m_flDelay) ALERT(at_console,": will send %s(same) in %f seconds.\n",GetStringForUseType(useType),m_flDelay); else ALERT(at_console,": sending %s(same) now.\n",GetStringForUseType(useType)); } SUB_UseTargets( pActivator, useType, value ); } else if (m_triggerType == USE_SET) { if (pev->spawnflags & SF_RELAY_DEBUG) { if (m_flDelay) ALERT(at_console,": will send ratio %f in %f seconds.\n",value,m_flDelay); else ALERT(at_console,": sending ratio %f now.\n",value); } SUB_UseTargets( pActivator, m_triggerType, value ); } else { if (pev->spawnflags & SF_RELAY_DEBUG) { if (m_flDelay) ALERT(at_console,": will send %s in %f seconds.\n",GetStringForUseType(m_triggerType),m_flDelay); else ALERT(at_console,": sending %s now.\n",GetStringForUseType(m_triggerType)); } SUB_UseTargets( pActivator, m_triggerType, 0 ); } if( pev->spawnflags & SF_RELAY_FIREONCE ) { //if (pev->spawnflags & SF_RELAY_DEBUG) // ALERT(at_console, "trigger_relay \"%s\" removes itself.\n"); UTIL_Remove( this ); } } //=========================================== //LRC - trigger_rottest, temporary new entity //=========================================== class CTriggerRotTest : public CBaseDelay { public: void PostSpawn( void ); // void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void Think( void ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; private: CBaseEntity* m_pMarker; CBaseEntity* m_pReference; CBaseEntity* m_pBridge; CBaseEntity* m_pHinge; }; LINK_ENTITY_TO_CLASS( trigger_rottest, CTriggerRotTest ); TYPEDESCRIPTION CTriggerRotTest::m_SaveData[] = { DEFINE_FIELD( CTriggerRotTest, m_pMarker, FIELD_CLASSPTR ), DEFINE_FIELD( CTriggerRotTest, m_pReference, FIELD_CLASSPTR ), DEFINE_FIELD( CTriggerRotTest, m_pBridge, FIELD_CLASSPTR ), DEFINE_FIELD( CTriggerRotTest, m_pHinge, FIELD_CLASSPTR ), }; IMPLEMENT_SAVERESTORE(CTriggerRotTest,CBaseDelay); void CTriggerRotTest::PostSpawn( void ) { m_pMarker = UTIL_FindEntityByTargetname(NULL, STRING(pev->target)); m_pReference = UTIL_FindEntityByTargetname(NULL, STRING(pev->netname)); m_pBridge = UTIL_FindEntityByTargetname(NULL, STRING(pev->noise1)); m_pHinge = UTIL_FindEntityByTargetname(NULL, STRING(pev->message)); pev->armorvalue = 0; // initial angle if (pev->armortype == 0) //angle offset pev->armortype = 30; SetNextThink( 1 ); } void CTriggerRotTest::Think( void ) { // ALERT(at_console, "Using angle = %.2f\n", pev->armorvalue); if (m_pReference) { m_pReference->pev->origin = pev->origin; m_pReference->pev->origin.x = m_pReference->pev->origin.x + pev->health; // ALERT(at_console, "Set Reference = %.2f %.2f %.2f\n", m_pReference->pev->origin.x, m_pReference->pev->origin.y, m_pReference->pev->origin.z); } if (m_pMarker) { Vector vecTemp = UTIL_AxisRotationToVec( (m_pHinge->pev->origin - pev->origin).Normalize(), pev->armorvalue ); m_pMarker->pev->origin = pev->origin + pev->health * vecTemp; // ALERT(at_console, "vecTemp = %.2f %.2f %.2f\n", vecTemp.x, vecTemp.y, vecTemp.z); // ALERT(at_console, "Set Marker = %.2f %.2f %.2f\n", m_pMarker->pev->origin.x, m_pMarker->pev->origin.y, m_pMarker->pev->origin.z); } if (m_pBridge) { Vector vecTemp = UTIL_AxisRotationToAngles( (m_pHinge->pev->origin - pev->origin).Normalize(), pev->armorvalue ); m_pBridge->pev->origin = pev->origin; m_pBridge->pev->angles = vecTemp; // ALERT(at_console, "vecTemp = %.2f %.2f %.2f\n", vecTemp.x, vecTemp.y, vecTemp.z); // ALERT(at_console, "Set Marker = %.2f %.2f %.2f\n", m_pMarker->pev->origin.x, m_pMarker->pev->origin.y, m_pMarker->pev->origin.z); } pev->armorvalue += pev->armortype * 0.1f; SetNextThink( 0.1 ); } //********************************************************** // The Multimanager Entity - when fired, will fire up to 16 targets // at specified times. // FLAG: THREAD (create clones when triggered) // FLAG: CLONE (this is a clone for a threaded execution) #define SF_MULTIMAN_CLONE 0x80000000 #define SF_MULTIMAN_SAMETRIG 0x40000000 #define SF_MULTIMAN_TRIGCHOSEN 0x20000000 #define SF_MULTIMAN_THREAD 0x00000001 #define SF_MULTIMAN_LOOP 0x00000004 #define SF_MULTIMAN_ONLYONCE 0x00000008 #define SF_MULTIMAN_SPAWNFIRE 0x00000010 #define SF_MULTIMAN_DEBUG 0x00000020 #define MM_MODE_CHOOSE 1 #define MM_MODE_PERCENT 2 #define MM_MODE_SIMULTANEOUS 3 class CMultiManager : public CBaseEntity//Toggle { public: void KeyValue( KeyValueData *pkvd ); void Spawn( void ); void EXPORT UseThink ( void ); void EXPORT ManagerThink( void ); void EXPORT ManagerUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); #if _DEBUG void EXPORT ManagerReport( void ); #endif BOOL HasTarget( string_t targetname ); int ObjectCaps( void ) { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; STATE m_iState; virtual STATE GetState( void ) { return m_iState; }; int m_cTargets; // the total number of targets in this manager's fire list. int m_index; // Current target float m_startTime;// Time we started firing string_t m_iTargetName[MAX_MULTI_TARGETS];// list if indexes into global string array float m_flTargetDelay[MAX_MULTI_TARGETS];// delay (in seconds) from time of manager fire to target fire float m_flWait; //LRC- minimum length of time to wait float m_flMaxWait; //LRC- random, maximum length of time to wait string_t m_sMaster; //LRC- master int m_iMode; //LRC- 0 = timed, 1 = pick random, 2 = each random int m_iszThreadName; //LRC int m_iszLocusThread; //LRC EHANDLE m_hActivator; private: USE_TYPE m_triggerType; //LRC inline BOOL IsClone( void ) { return ( pev->spawnflags & SF_MULTIMAN_CLONE ) ? TRUE : FALSE; } inline BOOL ShouldClone( void ) { if( IsClone() ) return FALSE; return ( pev->spawnflags & SF_MULTIMAN_THREAD ) ? TRUE : FALSE; } CMultiManager *Clone( void ); }; LINK_ENTITY_TO_CLASS( multi_manager, CMultiManager ) // Global Savedata for multi_manager TYPEDESCRIPTION CMultiManager::m_SaveData[] = { DEFINE_FIELD( CMultiManager, m_cTargets, FIELD_INTEGER ), DEFINE_FIELD( CMultiManager, m_index, FIELD_INTEGER ), DEFINE_FIELD( CMultiManager, m_iState, FIELD_INTEGER ), //LRC DEFINE_FIELD( CMultiManager, m_iMode, FIELD_INTEGER ), //LRC DEFINE_FIELD( CMultiManager, m_startTime, FIELD_TIME ), DEFINE_FIELD( CMultiManager, m_triggerType, FIELD_INTEGER ), //LRC DEFINE_ARRAY( CMultiManager, m_iTargetName, FIELD_STRING, MAX_MULTI_TARGETS ), DEFINE_ARRAY( CMultiManager, m_flTargetDelay, FIELD_FLOAT, MAX_MULTI_TARGETS ), DEFINE_FIELD( CMultiManager, m_sMaster, FIELD_STRING ), //LRC DEFINE_FIELD( CMultiManager, m_hActivator, FIELD_EHANDLE ), DEFINE_FIELD( CMultiManager, m_flWait, FIELD_FLOAT ), //LRC DEFINE_FIELD( CMultiManager, m_flMaxWait, FIELD_FLOAT ), //LRC DEFINE_FIELD( CMultiManager, m_iszThreadName, FIELD_STRING ), //LRC DEFINE_FIELD( CMultiManager, m_iszLocusThread, FIELD_STRING ), //LRC }; IMPLEMENT_SAVERESTORE( CMultiManager, CBaseEntity ) void CMultiManager::KeyValue( KeyValueData *pkvd ) { // UNDONE: Maybe this should do something like this: //CBaseToggle::KeyValue( pkvd ); // if( !pkvd->fHandled ) // ... etc. // //LRC- that would support Delay, Killtarget, Lip, Distance, Wait and Master. // Wait is already supported. I've added master here. To hell with the others. if( FStrEq( pkvd->szKeyName, "wait" ) ) { m_flWait = atof( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "maxwait")) { m_flMaxWait = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "master")) //LRC { m_sMaster = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszThreadName")) //LRC { m_iszThreadName = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszLocusThread")) //LRC { m_iszLocusThread = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "mode")) //LRC { m_iMode = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "triggerstate")) //LRC { switch( atoi( pkvd->szValue ) ) { case 4: pev->spawnflags |= SF_MULTIMAN_SAMETRIG; break; case 1: m_triggerType = USE_ON; break; //LRC- yes, this algorithm is different case 2: m_triggerType = USE_OFF; break; //from the trigger_relay equivalent- case 3: m_triggerType = USE_KILL; break; //trigger_relay's got to stay backwards default: m_triggerType = USE_TOGGLE; break; //compatible. } pev->spawnflags |= SF_MULTIMAN_TRIGCHOSEN; pkvd->fHandled = TRUE; } else // add this field to the target list { // this assumes that additional fields are targetnames and their values are delay values. if( m_cTargets < MAX_MULTI_TARGETS ) { char tmp[128]; UTIL_StripToken( pkvd->szKeyName, tmp ); m_iTargetName[m_cTargets] = ALLOC_STRING( tmp ); m_flTargetDelay[m_cTargets] = atof( pkvd->szValue ); m_cTargets++; pkvd->fHandled = TRUE; } else //LRC - keep a count of how many targets, for the error message { m_cTargets++; } } } void CMultiManager::Spawn( void ) { pev->solid = SOLID_NOT; SetUse( &CMultiManager::ManagerUse ); SetThink( &CMultiManager::ManagerThink ); m_iState = STATE_OFF; //LRC if (m_cTargets > MAX_MULTI_TARGETS) { ALERT(at_console, "WARNING: multi_manager \"%s\" has too many targets (limit is %d, it has %d)\n", STRING(pev->targetname), MAX_MULTI_TARGETS, m_cTargets); m_cTargets = MAX_MULTI_TARGETS; } if (!FBitSet(pev->spawnflags,SF_MULTIMAN_TRIGCHOSEN)) m_triggerType = USE_TOGGLE; // Sort targets // Quick and dirty bubble sort int swapped = 1; while( swapped ) { swapped = 0; for( int i = 1; i < m_cTargets; i++ ) { if( m_flTargetDelay[i] < m_flTargetDelay[i - 1] ) { // Swap out of order elements int name = m_iTargetName[i]; float delay = m_flTargetDelay[i]; m_iTargetName[i] = m_iTargetName[i - 1]; m_flTargetDelay[i] = m_flTargetDelay[i - 1]; m_iTargetName[i - 1] = name; m_flTargetDelay[i - 1] = delay; swapped = 1; } } } if ( pev->spawnflags & SF_MULTIMAN_SPAWNFIRE) { SetThink(&CMultiManager :: UseThink ); SetUse( NULL ); UTIL_DesiredThink( this ); } } BOOL CMultiManager::HasTarget( string_t targetname ) { for( int i = 0; i < m_cTargets; i++ ) if( FStrEq( STRING( targetname ), STRING( m_iTargetName[i] ) ) ) return TRUE; return FALSE; } void CMultiManager :: UseThink ( void ) { SetThink(&CMultiManager :: ManagerThink ); SetUse(&CMultiManager :: ManagerUse ); Use( this, this, USE_TOGGLE, 0 ); } // Designers were using this to fire targets that may or may not exist -- // so I changed it to use the standard target fire code, made it a little simpler. void CMultiManager::ManagerThink( void ) { //LRC- different manager modes if (m_iMode) { // special triggers have no time delay, so we can clean up before firing if (pev->spawnflags & SF_MULTIMAN_LOOP) { // ALERT(at_console,"Manager loops back\n"); // if it's a loop, start again! if (m_flMaxWait) //LRC- random time to wait? m_startTime = RANDOM_FLOAT( m_flWait, m_flMaxWait ); else if (m_flWait) //LRC- constant time to wait? m_startTime = m_flWait; else //LRC- just start immediately. m_startTime = 0; if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": restarting loop.\n", STRING(pev->targetname)); SetNextThink( m_startTime ); m_startTime = m_fNextThink; m_iState = STATE_TURN_ON; // ALERT(at_console, "MM loops, nextthink %f\n", m_fNextThink); } else if ( IsClone() || pev->spawnflags & SF_MULTIMAN_ONLYONCE ) { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": killed.\n", STRING(pev->targetname)); SetThink(&CMultiManager :: SUB_Remove ); SetNextThink( 0.1 ); SetUse( NULL ); } else { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": last burst.\n", STRING(pev->targetname)); m_iState = STATE_OFF; SetThink( NULL ); SetUse(&CMultiManager :: ManagerUse );// allow manager re-use } int i = 0; if (m_iMode == MM_MODE_CHOOSE) // choose one of the members, and fire it { float total = 0; for (i = 0; i < m_cTargets; i++) { total += m_flTargetDelay[i]; } // no weightings given, so just pick one. if (total == 0) { const char *sTarg = STRING(m_iTargetName[RANDOM_LONG(0, m_cTargets-1)]); if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": firing \"%s\" (random choice).\n", STRING(pev->targetname), sTarg); FireTargets(sTarg,m_hActivator,this,m_triggerType,0); } else // pick one by weighting { float chosen = RANDOM_FLOAT(0,total); float curpos = 0; for (i = 0; i < m_cTargets; i++) { curpos += m_flTargetDelay[i]; if (curpos >= chosen) { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": firing \"%s\" (weighted random choice).\n", STRING(pev->targetname), STRING(m_iTargetName[i])); FireTargets(STRING(m_iTargetName[i]),m_hActivator,this,m_triggerType,0); break; } } } } else if (m_iMode == MM_MODE_PERCENT) // try to call each member { for (i = 0; i < m_cTargets; i++) { if ( RANDOM_LONG( 0, 100 ) <= m_flTargetDelay[i] ) { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": firing \"%s\" (%f%% chance).\n", STRING(pev->targetname), STRING(m_iTargetName[i]), m_flTargetDelay[i]); FireTargets(STRING(m_iTargetName[i]),m_hActivator,this,m_triggerType,0); } } } else if (m_iMode == MM_MODE_SIMULTANEOUS) { for (i = 0; i < m_cTargets; i++) { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": firing \"%s\" (simultaneous).\n", STRING(pev->targetname), STRING(m_iTargetName[i])); FireTargets(STRING(m_iTargetName[i]),m_hActivator,this,m_triggerType,0); } } return; } // ok, so m_iMode is 0; we're doing normal time-based stuff. float time; int finalidx; int index = m_index; // store the current index time = gpGlobals->time - m_startTime; // ALERT(at_console,"Manager think for time %f\n",time); // find the last index we're going to fire this time finalidx = m_index; while (finalidx < m_cTargets && m_flTargetDelay[ finalidx ] <= time) finalidx++; if ( finalidx >= m_cTargets )// will we finish firing targets this time? { if (pev->spawnflags & SF_MULTIMAN_LOOP) { // ALERT(at_console,"Manager loops back\n"); // if it's a loop, start again! m_index = 0; if (m_flMaxWait) //LRC- random time to wait? { m_startTime = RANDOM_FLOAT( m_flWait, m_flMaxWait ); m_iState = STATE_TURN_ON; // while we're waiting, we're in state TURN_ON } else if (m_flWait) //LRC- constant time to wait? { m_startTime = m_flWait; m_iState = STATE_TURN_ON; } else //LRC- just start immediately. { m_startTime = 0; m_iState = STATE_ON; } if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": restarting loop.\n", STRING(pev->targetname)); SetNextThink( m_startTime ); m_startTime += gpGlobals->time; } else { m_iState = STATE_OFF; //LRC- STATE_OFF means "yes, we've finished". if ( IsClone() || pev->spawnflags & SF_MULTIMAN_ONLYONCE ) { SetThink(&CMultiManager :: SUB_Remove ); SetNextThink( 0.1 ); SetUse( NULL ); if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": killed.\n", STRING(pev->targetname)); } else { SetThink( NULL ); SetUse( &CMultiManager::ManagerUse );// allow manager re-use if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": last burst.\n", STRING(pev->targetname)); } } } else { m_index = finalidx; m_iState = STATE_ON; //LRC- while we're in STATE_ON we're firing targets, and haven't finished yet. AbsoluteNextThink( m_startTime + m_flTargetDelay[ m_index ] ); } while ( index < m_cTargets && m_flTargetDelay[ index ] <= time ) { // ALERT(at_console,"Manager sends %d to %s\n",m_triggerType,STRING(m_iTargetName[m_index])); if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": firing \"%s\".\n", STRING(pev->targetname), STRING( m_iTargetName[ index ] )); FireTargets( STRING( m_iTargetName[ index ] ), m_hActivator, this, m_triggerType, 0 ); index++; } } CMultiManager *CMultiManager::Clone( void ) { CMultiManager *pMulti = GetClassPtr( (CMultiManager *)NULL ); edict_t *pEdict = pMulti->pev->pContainingEntity; memcpy( pMulti->pev, pev, sizeof(*pev) ); pMulti->pev->pContainingEntity = pEdict; pMulti->pev->spawnflags |= SF_MULTIMAN_CLONE; pMulti->m_cTargets = m_cTargets; if (m_iszThreadName) pMulti->pev->targetname = m_iszThreadName; //LRC pMulti->m_triggerType = m_triggerType; //LRC pMulti->m_iMode = m_iMode; //LRC pMulti->m_flWait = m_flWait; //LRC pMulti->m_flMaxWait = m_flMaxWait; //LRC memcpy( pMulti->m_iTargetName, m_iTargetName, sizeof( m_iTargetName ) ); memcpy( pMulti->m_flTargetDelay, m_flTargetDelay, sizeof( m_flTargetDelay ) ); return pMulti; } // The USE function builds the time table and starts the entity thinking. void CMultiManager::ManagerUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if (pev->spawnflags & SF_MULTIMAN_LOOP) { if (m_iState != STATE_OFF) // if we're on, or turning on... { if (useType != USE_ON) // ...then turn it off if we're asked to. { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": Loop halted on request.\n", STRING(pev->targetname)); m_iState = STATE_OFF; if ( IsClone() || pev->spawnflags & SF_MULTIMAN_ONLYONCE ) { SetThink(&CMultiManager :: SUB_Remove ); SetNextThink( 0.1 ); SetUse( NULL ); if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": loop halted (removing).\n", STRING(pev->targetname)); } else { SetThink( NULL ); if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": loop halted.\n", STRING(pev->targetname)); } } // else we're already on and being told to turn on, so do nothing. else if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": Loop already active.\n", STRING(pev->targetname)); return; } else if (useType == USE_OFF) // it's already off { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": Loop already inactive.\n", STRING(pev->targetname)); return; } // otherwise, start firing targets as normal. } // ALERT(at_console,"Manager used, targetting ["); // for (int i = 0; i < m_cTargets; i++) // { // ALERT(at_console," %s(%f)",STRING(m_iTargetName[i]),m_flTargetDelay[i]); // } // ALERT(at_console," ]\n"); //LRC- "master" support if (!UTIL_IsMasterTriggered(m_sMaster,pActivator)) { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": Can't trigger, locked by master \"%s\".\n", STRING(pev->targetname), STRING(m_sMaster)); return; } // In multiplayer games, clone the MM and execute in the clone (like a thread) // to allow multiple players to trigger the same multimanager if( ShouldClone() ) { CMultiManager *pClone = Clone(); if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": Creating clone.\n", STRING(pev->targetname)); pClone->ManagerUse( pActivator, pCaller, useType, value ); if (m_iszLocusThread) FireTargets( STRING(m_iszLocusThread), pClone, this, USE_TOGGLE, 0 ); return; } m_hActivator = pActivator; m_index = 0; float timeOffset; if (m_flMaxWait) //LRC- random time to wait? { timeOffset = RANDOM_FLOAT( m_flWait, m_flMaxWait ); m_iState = STATE_TURN_ON; // while we're waiting, we're in state TURN_ON } else if (m_flWait) //LRC- constant time to wait? { timeOffset = m_flWait; m_iState = STATE_TURN_ON; } else //LRC- just start immediately. { timeOffset = 0; m_iState = STATE_ON; } m_startTime = timeOffset + gpGlobals->time; // startTime should not be affected by this next bit if (m_cTargets > 0 && !m_iMode && m_flTargetDelay[0] < 0) { // negative wait on the first target? timeOffset += m_flTargetDelay[0]; } if (pev->spawnflags & SF_MULTIMAN_SAMETRIG) //LRC m_triggerType = useType; if (pev->spawnflags & SF_MULTIMAN_LOOP) SetUse(&CMultiManager :: ManagerUse ); // clones won't already have this set else SetUse( NULL );// disable use until all targets have fired if (timeOffset > 0) { if (pev->spawnflags & SF_MULTIMAN_DEBUG) ALERT(at_console, "DEBUG: multi_manager \"%s\": Begin in %f seconds.\n", STRING(pev->targetname), timeOffset); SetThink(&CMultiManager :: ManagerThink ); SetNextThink( timeOffset ); } else { SetThink( &CMultiManager::ManagerThink ); ManagerThink(); } } #if _DEBUG void CMultiManager::ManagerReport( void ) { int cIndex; for( cIndex = 0; cIndex < m_cTargets; cIndex++ ) { ALERT( at_console, "%s %f\n", STRING( m_iTargetName[cIndex] ), m_flTargetDelay[cIndex] ); } } #endif //*********************************************************** //LRC- multi_watcher entity: useful? Well, I think it is. And I'm worth it. :) //*********************************************************** #define SF_SWATCHER_SENDTOGGLE 0x1 #define SF_SWATCHER_DONTSEND_ON 0x2 #define SF_SWATCHER_DONTSEND_OFF 0x4 #define SF_SWATCHER_NOTON 0x8 #define SF_SWATCHER_OFF 0x10 #define SF_SWATCHER_TURN_ON 0x20 #define SF_SWATCHER_TURN_OFF 0x40 #define SF_SWATCHER_IN_USE 0x80 #define SF_SWATCHER_VALID 0x200 #define SWATCHER_LOGIC_AND 0 #define SWATCHER_LOGIC_OR 1 #define SWATCHER_LOGIC_NAND 2 #define SWATCHER_LOGIC_NOR 3 #define SWATCHER_LOGIC_XOR 4 #define SWATCHER_LOGIC_XNOR 5 class CStateWatcher : public CBaseToggle { public: void Spawn ( void ); void EXPORT Think ( void ); void KeyValue( KeyValueData *pkvd ); virtual STATE GetState( void ); virtual STATE GetState( CBaseEntity *pActivator ); virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; int m_fLogic; // Logic by which to combine the targets int m_cTargets; // the total number of targets in this manager's fire list. int m_iTargetName [ MAX_MULTI_TARGETS ];// list of indexes into global string array // CBaseEntity* m_pTargetEnt [ MAX_MULTI_TARGETS ]; BOOL EvalLogic ( CBaseEntity *pEntity ); }; LINK_ENTITY_TO_CLASS( multi_watcher, CStateWatcher ); LINK_ENTITY_TO_CLASS( watcher, CStateWatcher ); TYPEDESCRIPTION CStateWatcher::m_SaveData[] = { DEFINE_FIELD( CStateWatcher, m_fLogic, FIELD_INTEGER ), DEFINE_FIELD( CStateWatcher, m_cTargets, FIELD_INTEGER ), DEFINE_ARRAY( CStateWatcher, m_iTargetName, FIELD_STRING, MAX_MULTI_TARGETS ), // DEFINE_ARRAY( CStateWatcher, m_pTargetEnt, FIELD_CLASSPTR, MAX_MULTI_TARGETS ), }; IMPLEMENT_SAVERESTORE(CStateWatcher,CBaseToggle); void CStateWatcher :: KeyValue( KeyValueData *pkvd ) { char tmp[128]; if (FStrEq(pkvd->szKeyName, "m_fLogic")) { m_fLogic = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszWatch")) { if ( m_cTargets < MAX_MULTI_TARGETS ) { m_iTargetName [ m_cTargets ] = ALLOC_STRING(pkvd->szValue); m_cTargets++; pkvd->fHandled = TRUE; } else { ALERT(at_console,"%s: Too many targets for %s \"%s\" (limit is %d)\n",pkvd->szKeyName,STRING(pev->classname),STRING(pev->targetname), MAX_MULTI_TARGETS); } } else // add this field to the target list { // this assumes that additional fields are targetnames and their values are delay values. if ( m_cTargets < MAX_MULTI_TARGETS ) { UTIL_StripToken( pkvd->szKeyName, tmp ); m_iTargetName [ m_cTargets ] = ALLOC_STRING( tmp ); m_cTargets++; pkvd->fHandled = TRUE; } else { ALERT(at_console,"WARNING - %s: Too many targets for %s \"%s\" (limit is %d)\n",pkvd->szKeyName,STRING(pev->classname),STRING(pev->targetname), MAX_MULTI_TARGETS); } } } void CStateWatcher :: Spawn ( void ) { pev->solid = SOLID_NOT; if (pev->target) SetNextThink( 0.5 ); } STATE CStateWatcher :: GetState( void ) { if (EvalLogic( NULL )) return STATE_ON; else return STATE_OFF; } STATE CStateWatcher :: GetState( CBaseEntity *pActivator ) { // if (pActivator) // ALERT(at_console, "GetState( %s \"%s\" )\n", STRING(pActivator->pev->classname), STRING(pActivator->pev->targetname)); // else // ALERT(at_console, "GetState( NULL )\n"); if (EvalLogic( pActivator )) return STATE_ON; else return STATE_OFF; } void CStateWatcher :: Think ( void ) { SetNextThink( 0.1 ); int oldflag = pev->spawnflags & SF_SWATCHER_VALID; if (EvalLogic( NULL )) pev->spawnflags |= SF_SWATCHER_VALID; else pev->spawnflags &= ~SF_SWATCHER_VALID; if ((pev->spawnflags & SF_SWATCHER_VALID) != oldflag) { // the update changed my state... if (oldflag) { // ...to off. Send "off". // ALERT(at_console,"%s turns off\n",STRING(pev->classname)); if (!FBitSet(pev->spawnflags, SF_SWATCHER_DONTSEND_OFF)) { if (pev->spawnflags & SF_SWATCHER_SENDTOGGLE) SUB_UseTargets(this, USE_TOGGLE, 0); else SUB_UseTargets(this, USE_OFF, 0); } } else { // ...to on. Send "on". // ALERT(at_console,"%s turns on\n",STRING(pev->classname)); if (!FBitSet(pev->spawnflags, SF_SWATCHER_DONTSEND_ON)) { if (pev->spawnflags & SF_SWATCHER_SENDTOGGLE) SUB_UseTargets(this, USE_TOGGLE, 0); else SUB_UseTargets(this, USE_ON, 0); } } } } BOOL CStateWatcher :: EvalLogic ( CBaseEntity *pActivator ) { int i; BOOL b; BOOL xorgot = FALSE; CBaseEntity* pEntity; for (i = 0; i < m_cTargets; i++) { // if (m_pTargetEnt[i] == NULL) // { // pEntity = m_pTargetEnt[i]; // } // else // { pEntity = UTIL_FindEntityByTargetname(NULL,STRING(m_iTargetName[i]), pActivator); if (pEntity != NULL) { // if ((STRING(m_iTargetName[i]))[0] != '*') // don't cache alias values // { // //ALERT(at_console,"Watcher: entity %s cached\n",STRING(m_iTargetName[i])); // m_pTargetEnt[i] = pEntity; // } //else //ALERT(at_console,"Watcher: aliased entity %s not cached\n",STRING(m_iTargetName[i])); } else { //ALERT(at_console,"Watcher: missing entity %s\n",STRING(m_iTargetName[i])); continue; // couldn't find this entity; don't do the test. } // } b = FALSE; switch (pEntity->GetState()) { case STATE_ON: if (!(pev->spawnflags & SF_SWATCHER_NOTON)) b = TRUE; break; case STATE_OFF: if (pev->spawnflags & SF_SWATCHER_OFF) b = TRUE; break; case STATE_TURN_ON: if (pev->spawnflags & SF_SWATCHER_TURN_ON) b = TRUE; break; case STATE_TURN_OFF: if (pev->spawnflags & SF_SWATCHER_TURN_ON) b = TRUE; break; case STATE_IN_USE: if (pev->spawnflags & SF_SWATCHER_IN_USE) b = TRUE; break; } // handle the states for this logic mode if (b) { switch (m_fLogic) { case SWATCHER_LOGIC_OR: // ALERT(at_console,"b is TRUE, OR returns true\n"); return TRUE; case SWATCHER_LOGIC_NOR: // ALERT(at_console,"b is TRUE, NOR returns false\n"); return FALSE; case SWATCHER_LOGIC_XOR: // ALERT(at_console,"b is TRUE, XOR\n"); if (xorgot) return FALSE; xorgot = TRUE; break; case SWATCHER_LOGIC_XNOR: // ALERT(at_console,"b is TRUE, XNOR\n"); if (xorgot) return TRUE; xorgot = TRUE; break; } } else // b is false { switch (m_fLogic) { case SWATCHER_LOGIC_AND: // ALERT(at_console,"b is FALSE, AND returns false\n"); return FALSE; case SWATCHER_LOGIC_NAND: // ALERT(at_console,"b is FALSE, NAND returns true\n"); return TRUE; } } } // handle the default cases for each logic mode switch (m_fLogic) { case SWATCHER_LOGIC_AND: case SWATCHER_LOGIC_NOR: // ALERT(at_console,"final, AND/NOR returns true\n"); return TRUE; case SWATCHER_LOGIC_XOR: // ALERT(at_console,"final, XOR\n"); return xorgot; case SWATCHER_LOGIC_XNOR: // ALERT(at_console,"final, XNOR\n"); return !xorgot; default: // NAND, OR // ALERT(at_console,"final, NAND/OR returns false\n"); return FALSE; } } //*********************************************************** #define SF_WRCOUNT_FIRESTART 0x0001 #define SF_WRCOUNT_STARTED 0x8000 class CWatcherCount : public CBaseToggle { public: void Spawn ( void ); void EXPORT Think ( void ); virtual STATE GetState( void ) { return (pev->spawnflags & SF_SWATCHER_VALID)?STATE_ON:STATE_OFF; }; virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } }; LINK_ENTITY_TO_CLASS( watcher_count, CWatcherCount ); void CWatcherCount :: Spawn ( void ) { pev->solid = SOLID_NOT; SetNextThink( 0.5 ); } void CWatcherCount :: Think ( void ) { SetNextThink( 0.1 ); int iCount = 0; CBaseEntity *pCurrent = NULL; pCurrent = UTIL_FindEntityByTargetname( NULL, STRING(pev->noise) ); while (pCurrent != NULL) { iCount++; pCurrent = UTIL_FindEntityByTargetname( pCurrent, STRING(pev->noise) ); } if( pev->spawnflags & SF_WRCOUNT_STARTED ) { if (iCount > pev->frags) { if (iCount < pev->impulse && pev->frags >= pev->impulse) FireTargets( STRING(pev->netname), this, this, USE_TOGGLE, 0 ); FireTargets( STRING(pev->noise1), this, this, USE_TOGGLE, 0 ); } else if (iCount < pev->frags) { if (iCount >= pev->impulse && pev->frags < pev->impulse) FireTargets( STRING(pev->message), this, this, USE_TOGGLE, 0 ); FireTargets( STRING(pev->noise2), this, this, USE_TOGGLE, 0 ); } } else { pev->spawnflags |= SF_WRCOUNT_STARTED; if (pev->spawnflags & SF_WRCOUNT_FIRESTART) { if (iCount < pev->impulse) FireTargets( STRING(pev->netname), this, this, USE_TOGGLE, 0 ); else FireTargets( STRING(pev->message), this, this, USE_TOGGLE, 0 ); } } pev->frags = iCount; } //*********************************************************** // // Render parameters trigger // // This entity will copy its render parameters (renderfx, rendermode, rendercolor, renderamt) // to its targets when triggered. // // Flags to indicate masking off various render parameters that are normally copied to the targets #define SF_RENDER_MASKFX ( 1 << 0 ) #define SF_RENDER_MASKAMT ( 1 << 1 ) #define SF_RENDER_MASKMODE ( 1 << 2 ) #define SF_RENDER_MASKCOLOR ( 1 << 3 ) //LRC #define SF_RENDER_KILLTARGET (1<<5) #define SF_RENDER_ONLYONCE (1<<6) //LRC- RenderFxFader, a subsidiary entity for RenderFxManager class CRenderFxFader : public CBaseEntity { public: void Spawn( void ); void EXPORT FadeThink ( void ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } static TYPEDESCRIPTION m_SaveData[]; float m_flStartTime; float m_flDuration; float m_flCoarseness; int m_iStartAmt; int m_iOffsetAmt; Vector m_vecStartColor; Vector m_vecOffsetColor; float m_fStartScale; float m_fOffsetScale; EHANDLE m_hTarget; int m_iszAmtFactor; }; TYPEDESCRIPTION CRenderFxFader::m_SaveData[] = { DEFINE_FIELD( CRenderFxFader, m_flStartTime, FIELD_FLOAT), DEFINE_FIELD( CRenderFxFader, m_flDuration, FIELD_FLOAT), DEFINE_FIELD( CRenderFxFader, m_flCoarseness, FIELD_FLOAT), DEFINE_FIELD( CRenderFxFader, m_iStartAmt, FIELD_INTEGER), DEFINE_FIELD( CRenderFxFader, m_iOffsetAmt, FIELD_INTEGER ), DEFINE_FIELD( CRenderFxFader, m_vecStartColor, FIELD_VECTOR ), DEFINE_FIELD( CRenderFxFader, m_vecOffsetColor, FIELD_VECTOR ), DEFINE_FIELD( CRenderFxFader, m_fStartScale, FIELD_FLOAT), DEFINE_FIELD( CRenderFxFader, m_fOffsetScale, FIELD_FLOAT ), DEFINE_FIELD( CRenderFxFader, m_hTarget, FIELD_EHANDLE ), }; IMPLEMENT_SAVERESTORE(CRenderFxFader,CBaseEntity); void CRenderFxFader :: Spawn( void ) { SetThink(&CRenderFxFader :: FadeThink ); } void CRenderFxFader :: FadeThink( void ) { if (((CBaseEntity*)m_hTarget) == NULL) { // ALERT(at_console, "render_fader removed\n"); SUB_Remove(); return; } float flDegree = (gpGlobals->time - m_flStartTime)/m_flDuration; if (flDegree >= 1) { // ALERT(at_console, "render_fader removes self\n"); m_hTarget->pev->renderamt = m_iStartAmt + m_iOffsetAmt; m_hTarget->pev->rendercolor = m_vecStartColor + m_vecOffsetColor; m_hTarget->pev->scale = m_fStartScale + m_fOffsetScale; SUB_UseTargets( m_hTarget, USE_TOGGLE, 0 ); if (pev->spawnflags & SF_RENDER_KILLTARGET) { m_hTarget->SetThink(&CRenderFxFader::SUB_Remove); m_hTarget->SetNextThink(0.1); } m_hTarget = NULL; SetNextThink( 0.1 ); SetThink(&CRenderFxFader ::SUB_Remove); } else { m_hTarget->pev->renderamt = m_iStartAmt + m_iOffsetAmt * flDegree; m_hTarget->pev->rendercolor.x = m_vecStartColor.x + m_vecOffsetColor.x * flDegree; m_hTarget->pev->rendercolor.y = m_vecStartColor.y + m_vecOffsetColor.y * flDegree; m_hTarget->pev->rendercolor.z = m_vecStartColor.z + m_vecOffsetColor.z * flDegree; m_hTarget->pev->scale = m_fStartScale + m_fOffsetScale * flDegree; SetNextThink( m_flCoarseness ); //? } } // RenderFxManager itself class CRenderFxManager : public CPointEntity { public: void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void Affect( CBaseEntity *pEntity, BOOL bIsLocus, CBaseEntity *pActivator ); void KeyValue( KeyValueData *pkvd ); }; LINK_ENTITY_TO_CLASS( env_render, CRenderFxManager ) void CRenderFxManager :: KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_fScale")) { pev->scale = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else CPointEntity::KeyValue( pkvd ); } void CRenderFxManager::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if( !FStringNull( pev->target ) ) { CBaseEntity* pTarget = UTIL_FindEntityByTargetname( NULL, STRING(pev->target), pActivator); BOOL first = TRUE; while ( pTarget != NULL ) { Affect( pTarget, first, pActivator ); first = FALSE; pTarget = UTIL_FindEntityByTargetname( pTarget, STRING(pev->target), pActivator ); } } if( pev->spawnflags & SF_RENDER_ONLYONCE ) { SetThink( &CRenderFxManager::SUB_Remove ); SetNextThink( 0.1f ); } } void CRenderFxManager::Affect( CBaseEntity *pTarget, BOOL bIsFirst, CBaseEntity *pActivator ) { entvars_t *pevTarget = pTarget->pev; float fAmtFactor = 1; if ( pev->message && !FBitSet( pev->spawnflags, SF_RENDER_MASKAMT ) ) fAmtFactor = CalcLocus_Ratio(pActivator, STRING(pev->message)); if( !FBitSet( pev->spawnflags, SF_RENDER_MASKFX ) ) pevTarget->renderfx = pev->renderfx; if( !FBitSet( pev->spawnflags, SF_RENDER_MASKMODE ) ) { //LRC - amt is often 0 when mode is normal. Set it to be fully visible, for fade purposes. if (pev->frags && pevTarget->renderamt == 0 && pevTarget->rendermode == kRenderNormal) pevTarget->renderamt = 255; pevTarget->rendermode = pev->rendermode; } if (pev->frags == 0) // not fading? { if ( !FBitSet( pev->spawnflags, SF_RENDER_MASKAMT ) ) pevTarget->renderamt = pev->renderamt * fAmtFactor; if( !FBitSet( pev->spawnflags, SF_RENDER_MASKCOLOR ) ) pevTarget->rendercolor = pev->rendercolor; if ( pev->scale ) pevTarget->scale = pev->scale; if (bIsFirst) FireTargets( STRING(pev->netname), pTarget, this, USE_TOGGLE, 0 ); } else { //LRC - fade the entity in/out! // (We create seperate fader entities to do this, one for each entity that needs fading.) CRenderFxFader *pFader = GetClassPtr( (CRenderFxFader *)NULL ); pFader->m_hTarget = pTarget; pFader->m_iStartAmt = pevTarget->renderamt; pFader->m_vecStartColor = pevTarget->rendercolor; pFader->m_fStartScale = pevTarget->scale; if (pFader->m_fStartScale == 0) pFader->m_fStartScale = 1; // When we're scaling, 0 is treated as 1. Use 1 as the number to fade from. pFader->pev->spawnflags = pev->spawnflags; if (bIsFirst) pFader->pev->target = pev->netname; if ( !FBitSet( pev->spawnflags, SF_RENDER_MASKAMT ) ) pFader->m_iOffsetAmt = (pev->renderamt * fAmtFactor) - pevTarget->renderamt; else pFader->m_iOffsetAmt = 0; if ( !FBitSet( pev->spawnflags, SF_RENDER_MASKCOLOR ) ) { pFader->m_vecOffsetColor.x = pev->rendercolor.x - pevTarget->rendercolor.x; pFader->m_vecOffsetColor.y = pev->rendercolor.y - pevTarget->rendercolor.y; pFader->m_vecOffsetColor.z = pev->rendercolor.z - pevTarget->rendercolor.z; } else { pFader->m_vecOffsetColor = g_vecZero; } if ( pev->scale ) pFader->m_fOffsetScale = pev->scale - pevTarget->scale; else pFader->m_fOffsetScale = 0; pFader->m_flStartTime = gpGlobals->time; pFader->m_flDuration = pev->frags; pFader->m_flCoarseness = pev->armorvalue; pFader->SetNextThink( 0 ); pFader->Spawn(); } } //*********************************************************** // // EnvCustomize // // Changes various properties of an entity (some properties only apply to monsters.) // #define SF_CUSTOM_AFFECTDEAD 1 #define SF_CUSTOM_ONCE 2 #define SF_CUSTOM_DEBUG 4 #define CUSTOM_FLAG_NOCHANGE 0 #define CUSTOM_FLAG_ON 1 #define CUSTOM_FLAG_OFF 2 #define CUSTOM_FLAG_TOGGLE 3 #define CUSTOM_FLAG_USETYPE 4 #define CUSTOM_FLAG_INVUSETYPE 5 class CEnvCustomize : public CBaseEntity { public: void Spawn( void ); void Precache( void ); void PostSpawn( void ); void DesiredAction( void ); void Use ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void Affect (CBaseEntity *pTarget, USE_TYPE useType); int GetActionFor( int iField, int iActive, USE_TYPE useType, const char *szDebug ); void SetBoneController (float fController, int cnum, CBaseEntity *pTarget); virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } void KeyValue( KeyValueData *pkvd ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; float m_flRadius; int m_iszModel; int m_iClass; int m_iPlayerReact; int m_iPrisoner; int m_iMonsterClip; int m_iVisible; int m_iSolid; int m_iProvoked; int m_voicePitch; int m_iBloodColor; float m_fFramerate; float m_fController0; float m_fController1; float m_fController2; float m_fController3; }; LINK_ENTITY_TO_CLASS( env_customize, CEnvCustomize ); TYPEDESCRIPTION CEnvCustomize::m_SaveData[] = { DEFINE_FIELD( CEnvCustomize, m_flRadius, FIELD_FLOAT), DEFINE_FIELD( CEnvCustomize, m_iszModel, FIELD_STRING), DEFINE_FIELD( CEnvCustomize, m_iClass, FIELD_INTEGER), DEFINE_FIELD( CEnvCustomize, m_iPlayerReact, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_iPrisoner, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_iMonsterClip, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_iVisible, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_iSolid, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_iProvoked, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_voicePitch, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_iBloodColor, FIELD_INTEGER ), DEFINE_FIELD( CEnvCustomize, m_fFramerate, FIELD_FLOAT ), DEFINE_FIELD( CEnvCustomize, m_fController0, FIELD_FLOAT ), DEFINE_FIELD( CEnvCustomize, m_fController1, FIELD_FLOAT ), DEFINE_FIELD( CEnvCustomize, m_fController2, FIELD_FLOAT ), DEFINE_FIELD( CEnvCustomize, m_fController3, FIELD_FLOAT ), }; IMPLEMENT_SAVERESTORE(CEnvCustomize,CBaseEntity); void CEnvCustomize :: KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_iVisible")) { m_iVisible = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iSolid")) { m_iSolid = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszModel")) { m_iszModel = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_voicePitch")) { m_voicePitch = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iPrisoner")) { m_iPrisoner = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iMonsterClip")) { m_iMonsterClip = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iClass")) { m_iClass = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iPlayerReact")) { m_iPlayerReact = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_flRadius")) { m_flRadius = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iProvoked")) { m_iProvoked = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_bloodColor") || FStrEq(pkvd->szKeyName, "m_iBloodColor")) { m_iBloodColor = atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_fFramerate")) { m_fFramerate = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_fController0")) { m_fController0 = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_fController1")) { m_fController1 = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_fController2")) { m_fController2 = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_fController3")) { m_fController3 = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else CBaseEntity::KeyValue( pkvd ); } void CEnvCustomize :: Spawn ( void ) { Precache(); } void CEnvCustomize :: Precache( void ) { if (m_iszModel) PRECACHE_MODEL(STRING(m_iszModel)); } void CEnvCustomize :: PostSpawn( void ) { if (!pev->targetname) { // no name - just take effect when everything's spawned. UTIL_DesiredAction( this ); } } void CEnvCustomize :: DesiredAction ( void ) { Use(this, this, USE_TOGGLE, 0); } void CEnvCustomize :: Use ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if ( FStringNull(pev->target) ) { if ( pActivator ) Affect(pActivator, useType); else if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, "DEBUG: env_customize \"%s\" was fired without a locus!\n", STRING(pev->targetname)); } else { BOOL fail = TRUE; CBaseEntity *pTarget = UTIL_FindEntityByTargetname(NULL, STRING(pev->target), pActivator); while (pTarget) { Affect(pTarget, useType); fail = FALSE; pTarget = UTIL_FindEntityByTargetname(pTarget, STRING(pev->target), pActivator); } pTarget = UTIL_FindEntityByClassname(NULL, STRING(pev->target)); while (pTarget) { Affect(pTarget, useType); fail = FALSE; pTarget = UTIL_FindEntityByClassname(pTarget, STRING(pev->target)); } if (fail && pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, "DEBUG: env_customize \"%s\" does nothing; can't find any entity with name or class \"%s\".\n", STRING(pev->target)); } if (pev->spawnflags & SF_CUSTOM_ONCE) { if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, "DEBUG: env_customize \"%s\" removes itself.\n", STRING(pev->targetname)); UTIL_Remove(this); } } //LRCT extern DLL_GLOBAL ULONG g_ulModelIndexPlayer; void CEnvCustomize :: Affect (CBaseEntity *pTarget, USE_TYPE useType) { CBaseMonster* pMonster = pTarget->MyMonsterPointer(); if (!FBitSet(pev->spawnflags, SF_CUSTOM_AFFECTDEAD) && pMonster && pMonster->m_MonsterState == MONSTERSTATE_DEAD) { if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, "DEBUG: env_customize %s does nothing; can't apply to a corpse.\n", STRING(pev->targetname)); return; } if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, "DEBUG: env_customize \"%s\" affects %s \"%s\": [", STRING(pev->targetname), STRING(pTarget->pev->classname), STRING(pTarget->pev->targetname)); if (m_iszModel) { Vector vecMins, vecMaxs; vecMins = pTarget->pev->mins; vecMaxs = pTarget->pev->maxs; SET_MODEL(pTarget->edict(),STRING(m_iszModel)); // if (pTarget->pev->flags & FL_CLIENT) // g_ulModelIndexPlayer = pTarget->pev->modelindex; UTIL_SetSize(pTarget->pev,vecMins,vecMaxs); if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " model=%s", STRING(m_iszModel)); } SetBoneController( m_fController0, 0, pTarget ); SetBoneController( m_fController1, 1, pTarget ); SetBoneController( m_fController2, 2, pTarget ); SetBoneController( m_fController3, 3, pTarget ); if (m_fFramerate != -1) { //FIXME: check for env_model, stop it from changing its own framerate pTarget->pev->framerate = m_fFramerate; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " framerate=%f", m_fFramerate); } if (pev->body != -1) { pTarget->pev->body = pev->body; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " body = %d", pev->body); } if (pev->skin != -1) { if (pev->skin == -2) { if (pTarget->pev->skin) { pTarget->pev->skin = 0; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " skin=0"); } else { pTarget->pev->skin = 1; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " skin=1"); } } else if (pev->skin == -99) // special option to set CONTENTS_EMPTY { pTarget->pev->skin = -1; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " skin=-1"); } else { pTarget->pev->skin = pev->skin; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " skin=%d", pTarget->pev->skin); } } switch ( GetActionFor(m_iVisible, !(pTarget->pev->effects & EF_NODRAW), useType, "visible")) { case CUSTOM_FLAG_ON: pTarget->pev->effects &= ~EF_NODRAW; break; case CUSTOM_FLAG_OFF: pTarget->pev->effects |= EF_NODRAW; break; } switch ( GetActionFor(m_iSolid, pTarget->pev->solid != SOLID_NOT, useType, "solid")) { case CUSTOM_FLAG_ON: if (*(STRING(pTarget->pev->model)) == '*') pTarget->pev->solid = SOLID_BSP; else pTarget->pev->solid = SOLID_SLIDEBOX; break; case CUSTOM_FLAG_OFF: pTarget->pev->solid = SOLID_NOT; break; } /* if (m_iVisible != CUSTOM_FLAG_NOCHANGE) { if (pTarget->pev->effects & EF_NODRAW && (m_iVisible == CUSTOM_FLAG_TOGGLE || m_iVisible == CUSTOM_FLAG_ON)) { if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " visible=YES"); } else if (m_iVisible != CUSTOM_FLAG_ON) { pTarget->pev->effects |= EF_NODRAW; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " visible=NO"); } } if (m_iSolid != CUSTOM_FLAG_NOCHANGE) { if (pTarget->pev->solid == SOLID_NOT && (m_iSolid == CUSTOM_FLAG_TOGGLE || m_iSolid == CUSTOM_FLAG_ON)) { if (*(STRING(pTarget->pev->model)) == '*') { pTarget->pev->solid = SOLID_BSP; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " solid=YES(bsp)"); } else { pTarget->pev->solid = SOLID_SLIDEBOX; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " solid=YES(point)"); } } else if (m_iSolid != CUSTOM_FLAG_ON) { pTarget->pev->solid = SOLID_NOT; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " solid=NO"); } else if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " solid=unchanged"); } */ if (!pMonster) { if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " ]\n"); return; } if (m_iBloodColor != 0) { pMonster->m_bloodColor = m_iBloodColor; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " bloodcolor=%d", m_iBloodColor); } if (m_voicePitch > 0) { if (FClassnameIs(pTarget->pev,"monster_barney") || FClassnameIs(pTarget->pev,"monster_scientist") || FClassnameIs(pTarget->pev,"monster_sitting_scientist")) { ((CTalkMonster*)pTarget)->m_voicePitch = m_voicePitch; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " voicePitch(talk)=%d", m_voicePitch); } // else if (FClassnameIs(pTarget->pev,"monster_human_grunt") || FClassnameIs(pTarget->pev,"monster_human_grunt_repel")) // ((CHGrunt*)pTarget)->m_voicePitch = m_voicePitch; // else if (FClassnameIs(pTarget->pev,"monster_alien_slave")) // ((CISlave*)pTarget)->m_voicePitch = m_voicePitch; else if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " voicePitch=unchanged"); } if (m_iClass != 0) { pMonster->m_iClass = m_iClass; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " class=%d", m_iClass); if (pMonster->m_hEnemy) { pMonster->m_hEnemy = NULL; // make 'em stop attacking... might be better to use a different signal? pMonster->SetConditions( bits_COND_NEW_ENEMY ); } } if (m_iPlayerReact != -1) { pMonster->m_iPlayerReact = m_iPlayerReact; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " playerreact=%d", m_iPlayerReact); } // SetCustomFlag( m_iPrisoner, pMonster->pev->spawnflags, SF_MONSTER_PRISONER, useType, "prisoner"); switch (GetActionFor(m_iPrisoner, pMonster->pev->spawnflags & SF_MONSTER_PRISONER, useType, "prisoner") ) { case CUSTOM_FLAG_ON: pMonster->pev->spawnflags |= SF_MONSTER_PRISONER; if (pMonster->m_hEnemy) { pMonster->m_hEnemy = NULL; // make 'em stop attacking... might be better to use a different signal? pMonster->SetConditions( bits_COND_NEW_ENEMY ); } break; case CUSTOM_FLAG_OFF: pMonster->pev->spawnflags &= ~SF_MONSTER_PRISONER; break; } /* if (m_iPrisoner != CUSTOM_FLAG_NOCHANGE) { if (pMonster->pev->spawnflags & SF_MONSTER_PRISONER && (m_iPrisoner == CUSTOM_FLAG_TOGGLE || m_iPrisoner == CUSTOM_FLAG_OFF)) { pMonster->pev->spawnflags &= ~SF_MONSTER_PRISONER; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " prisoner=NO"); } else if (m_iPrisoner != CUSTOM_FLAG_OFF) { pMonster->pev->spawnflags |= SF_MONSTER_PRISONER; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " prisoner=YES"); if (pMonster->m_hEnemy) { pMonster->m_hEnemy = NULL; // make 'em stop attacking... might be better to use a different signal? pMonster->SetConditions( bits_COND_NEW_ENEMY ); } } else if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " prisoner=unchanged"); } */ switch (GetActionFor(m_iMonsterClip, pMonster->pev->flags & FL_MONSTERCLIP, useType, "monsterclip") ) { case CUSTOM_FLAG_ON: pMonster->pev->flags |= FL_MONSTERCLIP; break; case CUSTOM_FLAG_OFF: pMonster->pev->flags &= ~FL_MONSTERCLIP; break; } /* if (m_iMonsterClip != CUSTOM_FLAG_NOCHANGE) { if (pMonster->pev->flags & FL_MONSTERCLIP && (m_iMonsterClip == CUSTOM_FLAG_TOGGLE || m_iMonsterClip == CUSTOM_FLAG_OFF)) { pMonster->pev->flags &= ~FL_MONSTERCLIP; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " monsterclip=NO"); } else if (m_iMonsterClip != CUSTOM_FLAG_OFF) { pMonster->pev->flags |= FL_MONSTERCLIP; if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " monsterclip=YES"); } else if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " monsterclip=unchanged"); } */ switch (GetActionFor(m_iProvoked, pMonster->m_afMemory & bits_MEMORY_PROVOKED, useType, "provoked") ) { case CUSTOM_FLAG_ON: pMonster->Remember(bits_MEMORY_PROVOKED); break; case CUSTOM_FLAG_OFF: pMonster->Forget(bits_MEMORY_PROVOKED); break; } /* if (m_iProvoked != CUSTOM_FLAG_NOCHANGE) { if (pMonster->m_afMemory & bits_MEMORY_PROVOKED && (m_iProvoked == CUSTOM_FLAG_TOGGLE || m_iProvoked == CUSTOM_FLAG_OFF)) { pMonster->Forget(bits_MEMORY_PROVOKED); if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " provoked=NO"); } else if (m_iProvoked != CUSTOM_FLAG_OFF) { pMonster->Remember(bits_MEMORY_PROVOKED); if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " provoked=YES"); } else if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " provoked=unchanged"); } */ if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " ]\n"); } int CEnvCustomize::GetActionFor( int iField, int iActive, USE_TYPE useType, const char* szDebug) { int iAction = iField; if (iAction == CUSTOM_FLAG_USETYPE) { if (useType == USE_ON) iAction = CUSTOM_FLAG_ON; else if (useType == USE_OFF) iAction = CUSTOM_FLAG_OFF; else iAction = CUSTOM_FLAG_TOGGLE; } else if (iAction == CUSTOM_FLAG_INVUSETYPE) { if (useType == USE_ON) iAction = CUSTOM_FLAG_OFF; else if (useType == USE_OFF) iAction = CUSTOM_FLAG_ON; else iAction = CUSTOM_FLAG_TOGGLE; } if (iAction == CUSTOM_FLAG_TOGGLE) { if (iActive) iAction = CUSTOM_FLAG_OFF; else iAction = CUSTOM_FLAG_ON; } if (pev->spawnflags & SF_CUSTOM_DEBUG) { if (iAction == CUSTOM_FLAG_ON) ALERT(at_console, " %s=YES", szDebug); else if (iAction == CUSTOM_FLAG_OFF) ALERT(at_console, " %s=NO", szDebug); } return iAction; } void CEnvCustomize::SetBoneController( float fController, int cnum, CBaseEntity *pTarget) { if (fController) //FIXME: the pTarget isn't necessarily a CBaseAnimating. { if (fController == 1024) { ((CBaseAnimating*)pTarget)->SetBoneController( cnum, 0 ); if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " bone%d=0", cnum); } else { ((CBaseAnimating*)pTarget)->SetBoneController( cnum, fController ); if (pev->spawnflags & SF_CUSTOM_DEBUG) ALERT(at_console, " bone%d=%f", cnum, fController); } } } //===================================== // trigger_x entities class CBaseTrigger : public CBaseToggle { public: //LRC - this was very bloated. I moved lots of methods into the // subclasses where they belonged. void InitTrigger( void ); void EXPORT ToggleUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); BOOL CanTouch( entvars_t *pevToucher ); virtual int ObjectCaps( void ) { return CBaseToggle::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } }; LINK_ENTITY_TO_CLASS( trigger, CBaseTrigger ); BOOL CBaseTrigger :: CanTouch( entvars_t *pevToucher ) { if ( !pev->netname ) { // Only touch clients, monsters, or pushables (depending on flags) if (pevToucher->flags & FL_CLIENT) return !(pev->spawnflags & SF_TRIGGER_NOCLIENTS); else if (pevToucher->flags & FL_MONSTER) return pev->spawnflags & SF_TRIGGER_ALLOWMONSTERS; else if (FClassnameIs(pevToucher,"func_pushable")) return pev->spawnflags & SF_TRIGGER_PUSHABLES; else return pev->spawnflags & SF_TRIGGER_EVERYTHING; } else { // If netname is set, it's an entity-specific trigger; we ignore the spawnflags. if (!FClassnameIs(pevToucher, STRING(pev->netname)) && (!pevToucher->targetname || !FStrEq(STRING(pevToucher->targetname), STRING(pev->netname)))) return FALSE; } return TRUE; } // // ToggleUse - If this is the USE function for a trigger, its state will toggle every time it's fired // void CBaseTrigger :: ToggleUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if (pev->solid == SOLID_NOT) {// if the trigger is off, turn it on pev->solid = SOLID_TRIGGER; // Force retouch gpGlobals->force_retouch++; } else {// turn the trigger off pev->solid = SOLID_NOT; } UTIL_SetOrigin( this, pev->origin ); } /* ================ InitTrigger ================ */ void CBaseTrigger::InitTrigger() { // trigger angles are used for one-way touches. An angle of 0 is assumed // to mean no restrictions, so use a yaw of 360 instead. if( pev->angles != g_vecZero ) SetMovedir( pev ); pev->solid = SOLID_TRIGGER; pev->movetype = MOVETYPE_NONE; SET_MODEL( ENT( pev ), STRING( pev->model ) ); // set size and link into world if( CVAR_GET_FLOAT( "showtriggers" ) == 0 ) SetBits( pev->effects, EF_NODRAW ); } //===================================== // // trigger_hurt - hurts anything that touches it. if the trigger has a targetname, firing it will toggle state // class CTriggerHurt : public CBaseTrigger { public: void Spawn( void ); void EXPORT RadiationThink( void ); void EXPORT HurtTouch ( CBaseEntity *pOther ); virtual void KeyValue( KeyValueData *pkvd ); }; LINK_ENTITY_TO_CLASS( trigger_hurt, CTriggerHurt ); void CTriggerHurt :: KeyValue( KeyValueData *pkvd ) { if( FStrEq( pkvd->szKeyName, "damage" ) ) { pev->dmg = atof( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "damagetype")) { m_bitsDamageInflict |= atoi(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "cangib")) { switch (atoi(pkvd->szValue)) { case 1: m_bitsDamageInflict |= DMG_ALWAYSGIB; case 2: m_bitsDamageInflict |= DMG_NEVERGIB; } pkvd->fHandled = TRUE; } else CBaseToggle::KeyValue( pkvd ); } void CTriggerHurt :: Spawn( void ) { InitTrigger(); SetTouch(&CTriggerHurt :: HurtTouch ); if ( !FStringNull ( pev->targetname ) ) { SetUse(&CTriggerHurt :: ToggleUse ); } else { SetUse ( NULL ); } if (m_bitsDamageInflict & DMG_RADIATION) { SetThink(&CTriggerHurt :: RadiationThink ); SetNextThink( RANDOM_FLOAT(0.0, 0.5) ); } if ( FBitSet (pev->spawnflags, SF_TRIGGER_HURT_START_OFF) )// if flagged to Start Turned Off, make trigger nonsolid. pev->solid = SOLID_NOT; UTIL_SetOrigin( this, pev->origin ); // Link into the list } // When touched, a hurt trigger does DMG points of damage each half-second void CTriggerHurt :: HurtTouch ( CBaseEntity *pOther ) { float fldmg; if ( !pOther->pev->takedamage ) return; if ( (pev->spawnflags & SF_TRIGGER_HURT_CLIENTONLYTOUCH) && !pOther->IsPlayer() ) { // this trigger is only allowed to touch clients, and this ain't a client. return; } if ( (pev->spawnflags & SF_TRIGGER_HURT_NO_CLIENTS) && pOther->IsPlayer() ) return; // HACKHACK -- In multiplayer, players touch this based on packet receipt. // So the players who send packets later aren't always hurt. Keep track of // how much time has passed and whether or not you've touched that player if ( g_pGameRules->IsMultiplayer() ) { if ( pev->dmgtime > gpGlobals->time ) { if ( gpGlobals->time != pev->pain_finished ) {// too early to hurt again, and not same frame with a different entity if ( pOther->IsPlayer() ) { int playerMask = 1 << (pOther->entindex() - 1); // If I've already touched this player (this time), then bail out if ( pev->impulse & playerMask ) return; // Mark this player as touched // BUGBUG - There can be only 32 players! pev->impulse |= playerMask; } else { return; } } } else { // New clock, "un-touch" all players pev->impulse = 0; if ( pOther->IsPlayer() ) { int playerMask = 1 << (pOther->entindex() - 1); // Mark this player as touched // BUGBUG - There can be only 32 players! pev->impulse |= playerMask; } } } else // Original code -- single player { if ( pev->dmgtime > gpGlobals->time && gpGlobals->time != pev->pain_finished ) {// too early to hurt again, and not same frame with a different entity return; } } // If this is time_based damage (poison, radiation), override the pev->dmg with a // default for the given damage type. Monsters only take time-based damage // while touching the trigger. Player continues taking damage for a while after // leaving the trigger fldmg = pev->dmg * 0.5f; // 0.5 seconds worth of damage, pev->dmg is damage/second // JAY: Cut this because it wasn't fully realized. Damage is simpler now. #if 0 switch (m_bitsDamageInflict) { default: break; case DMG_POISON: fldmg = POISON_DAMAGE/4; break; case DMG_NERVEGAS: fldmg = NERVEGAS_DAMAGE/4; break; case DMG_RADIATION: fldmg = RADIATION_DAMAGE/4; break; case DMG_PARALYZE: fldmg = PARALYZE_DAMAGE/4; break; // UNDONE: cut this? should slow movement to 50% case DMG_ACID: fldmg = ACID_DAMAGE/4; break; case DMG_SLOWBURN: fldmg = SLOWBURN_DAMAGE/4; break; case DMG_SLOWFREEZE: fldmg = SLOWFREEZE_DAMAGE/4; break; } #endif if ( fldmg < 0 ) pOther->TakeHealth( -fldmg, m_bitsDamageInflict ); else pOther->TakeDamage( pev, pev, fldmg, m_bitsDamageInflict ); // Store pain time so we can get all of the other entities on this frame pev->pain_finished = gpGlobals->time; // Apply damage every half second pev->dmgtime = gpGlobals->time + 0.5f;// half second delay until this trigger can hurt toucher again if ( pev->target ) { // trigger has a target it wants to fire. if ( pev->spawnflags & SF_TRIGGER_HURT_CLIENTONLYFIRE ) { // if the toucher isn't a client, don't fire the target! if ( !pOther->IsPlayer() ) { return; } } SUB_UseTargets( pOther, USE_TOGGLE, 0 ); if ( pev->spawnflags & SF_TRIGGER_HURT_TARGETONCE ) pev->target = 0; } } // 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 ) { edict_t *pentPlayer; CBasePlayer *pPlayer = NULL; float flRange; entvars_t *pevTarget; Vector vecSpot1; Vector vecSpot2; Vector vecRange; Vector origin; Vector view_ofs; // check to see if a player is in pvs // if not, continue // set origin to center of trigger so that this check works origin = pev->origin; view_ofs = pev->view_ofs; pev->origin = (pev->absmin + pev->absmax) * 0.5f; pev->view_ofs = pev->view_ofs * 0.0f; pentPlayer = FIND_CLIENT_IN_PVS(edict()); pev->origin = origin; pev->view_ofs = view_ofs; // reset origin if (!FNullEnt(pentPlayer)) { pPlayer = GetClassPtr( (CBasePlayer *)VARS(pentPlayer)); pevTarget = VARS(pentPlayer); // get range to player; vecSpot1 = (pev->absmin + pev->absmax) * 0.5f; vecSpot2 = (pevTarget->absmin + pevTarget->absmax) * 0.5f; vecRange = vecSpot1 - vecSpot2; flRange = vecRange.Length(); // if player's current geiger counter range is larger // than range to this trigger hurt, reset player's // geiger counter range if (pPlayer->m_flgeigerRange >= flRange) pPlayer->m_flgeigerRange = flRange; } SetNextThink( 0.25f ); } //===================================== // // trigger_hevcharge // charges/discharges the player's suit. if the trigger has a targetname, firing it will toggle state //LRC #define SF_HEVCHARGE_NOANNOUNCE 0x04 class CTriggerHevCharge : public CBaseTrigger { public: void Spawn( void ); void EXPORT ChargeTouch ( CBaseEntity *pOther ); void EXPORT AnnounceThink( void ); }; LINK_ENTITY_TO_CLASS( trigger_hevcharge, CTriggerHevCharge ); void CTriggerHevCharge :: Spawn( void ) { InitTrigger(); SetTouch(&CTriggerHevCharge :: ChargeTouch ); SetThink(&CTriggerHevCharge :: AnnounceThink ); if ( !FStringNull ( pev->targetname ) ) { SetUse(&CTriggerHevCharge :: ToggleUse ); } else { SetUse ( NULL ); } if ( FBitSet (pev->spawnflags, SF_TRIGGER_HURT_START_OFF) )// if flagged to Start Turned Off, make trigger nonsolid. pev->solid = SOLID_NOT; UTIL_SetOrigin( this, pev->origin ); // Link into the list } void CTriggerHevCharge :: ChargeTouch ( CBaseEntity *pOther ) { if (IsLockedByMaster()) return; // check that it's a player with an HEV suit if ( !pOther->IsPlayer() || !FBitSet(pOther->pev->weapons, 1<dmgtime > gpGlobals->time ) return; pev->dmgtime = gpGlobals->time + 0.5f;// half second delay until this trigger can hurt toucher again int iNewArmor = pOther->pev->armorvalue + pev->frags; if (iNewArmor > MAX_NORMAL_BATTERY) iNewArmor = MAX_NORMAL_BATTERY; if (iNewArmor < 0) iNewArmor = 0; if (iNewArmor == pOther->pev->armorvalue) // if no change, we've finished. return; pOther->pev->armorvalue = iNewArmor; //FIXME: support the 'target once' flag if ( pev->target ) { SUB_UseTargets( pOther, USE_TOGGLE, 0 ); } // The suit doesn't say much in multiplayer. Which is convenient, since it lets me be lazy here. if ( g_pGameRules->IsMultiplayer() || pev->spawnflags & SF_HEVCHARGE_NOANNOUNCE) return; // as long as the suit is charging, this think will never actually happen. //ALERT(at_console, "%s ", STRING(pev->targetname)); pev->aiment = ENT(pOther->pev); SetNextThink( 1 ); } void CTriggerHevCharge :: AnnounceThink ( ) { CBasePlayer *pPlayer = (CBasePlayer*)(CBaseEntity::Instance(pev->aiment)); if (!pPlayer || !pPlayer->IsPlayer()) { ALERT(at_error, "trigger_hevcharge: invalid player in Announce!\n"); return; } //copied from item_battery... int pct; char szcharge[64]; // Suit reports new power level // For some reason this wasn't working in release build -- round it. pct = (int)( (float)(pPlayer->pev->armorvalue * 100.0f) * (1.0f/MAX_NORMAL_BATTERY) + 0.5f); pct = (pct / 5); if (pct > 0) pct--; sprintf( szcharge,"!HEV_%1dP", pct ); //ALERT(at_console, "Announce %s\n", szcharge); ((CBasePlayer*)pPlayer)->SetSuitUpdate(szcharge, FALSE, SUIT_REPEAT_OK); } //===================================== // // trigger_monsterjump // class CTriggerMonsterJump : public CBaseTrigger { public: void Spawn( void ); void Touch( CBaseEntity *pOther ); void Think( void ); }; LINK_ENTITY_TO_CLASS( trigger_monsterjump, CTriggerMonsterJump ) void CTriggerMonsterJump::Spawn( void ) { SetMovedir( pev ); InitTrigger(); DontThink(); pev->speed = 200; m_flHeight = 150; if( !FStringNull( pev->targetname ) ) { // if targetted, spawn turned off pev->solid = SOLID_NOT; UTIL_SetOrigin( this, pev->origin ); // Unlink from trigger list SetUse(&CTriggerMonsterJump :: ToggleUse ); } } void CTriggerMonsterJump::Think( void ) { pev->solid = SOLID_NOT;// kill the trigger for now !!!UNDONE UTIL_SetOrigin( this, pev->origin ); // Unlink from trigger list SetThink( NULL ); } void CTriggerMonsterJump::Touch( CBaseEntity *pOther ) { entvars_t *pevOther = pOther->pev; if( !FBitSet( pevOther->flags, FL_MONSTER ) ) { // touched by a non-monster. return; } pevOther->origin.z += 1; if( FBitSet( pevOther->flags, FL_ONGROUND ) ) { // clear the onground so physics don't bitch pevOther->flags &= ~FL_ONGROUND; } // toss the monster! pevOther->velocity = pev->movedir * pev->speed; pevOther->velocity.z += m_flHeight; SetNextThink( 0 ); } //===================================== // // trigger_cdaudio - starts/stops cd audio tracks // class CTriggerCDAudio : public CBaseTrigger { public: 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 ) // // Changes tracks or stops CD when player touches // // !!!HACK - overloaded HEALTH to avoid adding new field void CTriggerCDAudio::Touch( CBaseEntity *pOther ) { if( !pOther->IsPlayer() ) { // only clients may trigger these events return; } PlayTrack(); } void CTriggerCDAudio::Spawn( void ) { InitTrigger(); } void CTriggerCDAudio::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { PlayTrack(); } void PlayCDTrack( int iTrack ) { edict_t *pClient; // manually find the single player. pClient = g_engfuncs.pfnPEntityOfEntIndex( 1 ); // Can't play if the client is not connected! if( !pClient ) return; if( iTrack < -1 || iTrack > 30 ) { ALERT( at_console, "TriggerCDAudio - Track %d out of range\n" ); return; } if( iTrack == -1 ) { CLIENT_COMMAND( pClient, "cd stop\n" ); } else { char string[64]; sprintf( string, "cd play %3d\n", iTrack ); CLIENT_COMMAND( pClient, string ); } } // only plays for ONE client, so only use in single play! void CTriggerCDAudio::PlayTrack( void ) { PlayCDTrack( (int)pev->health ); SetTouch( NULL ); UTIL_Remove( this ); } // This plays a CD track when fired or when the player enters it's radius class CTargetCDAudio : public CPointEntity { public: void Spawn( void ); void KeyValue( KeyValueData *pkvd ); virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void Think( void ); void Play( void ); }; LINK_ENTITY_TO_CLASS( target_cdaudio, CTargetCDAudio ) void CTargetCDAudio::KeyValue( KeyValueData *pkvd ) { if( FStrEq( pkvd->szKeyName, "radius" ) ) { pev->scale = atof( pkvd->szValue ); pkvd->fHandled = TRUE; } else CPointEntity::KeyValue( pkvd ); } void CTargetCDAudio::Spawn( void ) { pev->solid = SOLID_NOT; pev->movetype = MOVETYPE_NONE; if( pev->scale > 0 ) SetNextThink( 1.0 ); } void CTargetCDAudio::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { Play(); } // only plays for ONE client, so only use in single play! void CTargetCDAudio::Think( void ) { edict_t *pClient; // manually find the single player. pClient = g_engfuncs.pfnPEntityOfEntIndex( 1 ); // Can't play if the client is not connected! if( !pClient ) return; SetNextThink( 0.5 ); if( ( pClient->v.origin - pev->origin ).Length() <= pev->scale ) Play(); } void CTargetCDAudio::Play( void ) { PlayCDTrack( (int)pev->health ); UTIL_Remove( this ); } //===================================== //trigger_multiple class CTriggerMultiple : public CBaseTrigger { public: void Spawn( void ); void Precache( void ) { if (!FStringNull(pev->noise)) PRECACHE_SOUND(STRING(pev->noise)); } void EXPORT MultiTouch( CBaseEntity *pOther ); void EXPORT MultiWaitOver( void ); void ActivateMultiTrigger( CBaseEntity *pActivator ); }; LINK_ENTITY_TO_CLASS( trigger_multiple, CTriggerMultiple ) void CTriggerMultiple :: Spawn( void ) { if (m_flWait == 0) m_flWait = 0.2; InitTrigger(); ASSERTSZ(pev->health == 0, "trigger_multiple with health"); SetTouch(&CTriggerMultiple :: MultiTouch ); Precache(); } void CTriggerMultiple :: MultiTouch( CBaseEntity *pOther ) { entvars_t *pevToucher; pevToucher = pOther->pev; if (!CanTouch(pevToucher)) return; #if 0 // if the trigger has an angles field, check player's facing direction if (pev->movedir != g_vecZero) { UTIL_MakeVectors( pevToucher->angles ); if ( DotProduct( gpGlobals->v_forward, pev->movedir ) < 0 ) return; // not facing the right way } #endif ActivateMultiTrigger( pOther ); } // // the trigger was just touched/killed/used // m_hActivator gets set to the activator so it can be held through a delay // so wait for the delay time before firing // void CTriggerMultiple :: ActivateMultiTrigger( CBaseEntity *pActivator ) { if (m_fNextThink > gpGlobals->time) return; // still waiting for reset time if (!UTIL_IsMasterTriggered(m_sMaster,pActivator)) return; if (FClassnameIs(pev, "trigger_secret")) { if ( pev->enemy == NULL || !FClassnameIs(pev->enemy, "player")) return; gpGlobals->found_secrets++; } if (!FStringNull(pev->noise)) EMIT_SOUND(ENT(pev), CHAN_VOICE, STRING(pev->noise), 1, ATTN_NORM); // don't trigger again until reset // pev->takedamage = DAMAGE_NO; m_hActivator = pActivator; SUB_UseTargets( m_hActivator, USE_TOGGLE, 0 ); if ( pev->message && pActivator->IsPlayer() ) { UTIL_ShowMessage( STRING(pev->message), pActivator ); // CLIENT_PRINTF( ENT( pActivator->pev ), print_center, STRING(pev->message) ); } if (m_flWait > 0) { SetThink(&CTriggerMultiple :: MultiWaitOver ); SetNextThink( 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( 0.1 ); SetThink(&CTriggerMultiple :: SUB_Remove ); } } // the wait time has passed, so set back up for another activation void CTriggerMultiple :: MultiWaitOver( void ) { // if (pev->max_health) // { // pev->health = pev->max_health; // pev->takedamage = DAMAGE_YES; // pev->solid = SOLID_BBOX; // } SetThink( NULL ); } //===================================== //trigger_once class CTriggerOnce : public CTriggerMultiple { public: void Spawn( void ); }; LINK_ENTITY_TO_CLASS( trigger_once, CTriggerOnce ); void CTriggerOnce::Spawn( void ) { m_flWait = -1; CTriggerMultiple :: Spawn(); } //=========================================================== //LRC - trigger_inout, a trigger which fires _only_ when // the player enters or leaves it. // If there's more than one entity it can trigger off, then // it will trigger for each one that enters and leaves. //=========================================================== class CTriggerInOut; class CInOutRegister : public CPointEntity { public: // returns true if found in the list BOOL IsRegistered ( CBaseEntity *pValue ); // remove all invalid entries from the list, trigger their targets as appropriate // returns the new list CInOutRegister *Prune( void ); // adds a new entry to the list CInOutRegister *Add( CBaseEntity *pValue ); BOOL IsEmpty( void ) { return m_pNext?FALSE:TRUE; }; virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; CTriggerInOut *m_pField; CInOutRegister *m_pNext; EHANDLE m_hValue; }; class CTriggerInOut : public CBaseTrigger { public: void Spawn( void ); void EXPORT Touch( CBaseEntity *pOther ); void EXPORT Think( void ); void FireOnEntry( CBaseEntity *pOther ); void FireOnLeaving( CBaseEntity *pOther ); void KeyValue( KeyValueData *pkvd ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; STATE GetState() { return m_pRegister->IsEmpty()?STATE_OFF:STATE_ON; } string_t m_iszAltTarget; string_t m_iszBothTarget; CInOutRegister *m_pRegister; }; // CInOutRegister method bodies: TYPEDESCRIPTION CInOutRegister::m_SaveData[] = { DEFINE_FIELD( CInOutRegister, m_pField, FIELD_CLASSPTR ), DEFINE_FIELD( CInOutRegister, m_pNext, FIELD_CLASSPTR ), DEFINE_FIELD( CInOutRegister, m_hValue, FIELD_EHANDLE ), }; IMPLEMENT_SAVERESTORE(CInOutRegister,CPointEntity); LINK_ENTITY_TO_CLASS( inout_register, CInOutRegister ); BOOL CInOutRegister::IsRegistered ( CBaseEntity *pValue ) { if (m_hValue == pValue) return TRUE; else if (m_pNext) return m_pNext->IsRegistered( pValue ); else return FALSE; } CInOutRegister *CInOutRegister::Add( CBaseEntity *pValue ) { if (m_hValue == pValue) { // it's already in the list, don't need to do anything return this; } else if (m_pNext) { // keep looking m_pNext = m_pNext->Add( pValue ); return this; } else { // reached the end of the list; add the new entry, and trigger CInOutRegister *pResult = GetClassPtr( (CInOutRegister*)NULL ); pResult->m_hValue = pValue; pResult->m_pNext = this; pResult->m_pField = m_pField; pResult->pev->classname = MAKE_STRING("inout_register"); // ALERT(at_console, "adding; max %.2f %.2f %.2f, min %.2f %.2f %.2f is inside max %.2f %.2f %.2f, min %.2f %.2f %.2f\n", pResult->m_hValue->pev->absmax.x, pResult->m_hValue->pev->absmax.y, pResult->m_hValue->pev->absmax.z, pResult->m_hValue->pev->absmin.x, pResult->m_hValue->pev->absmin.y, pResult->m_hValue->pev->absmin.z, pResult->m_pField->pev->absmax.x, pResult->m_pField->pev->absmax.y, pResult->m_pField->pev->absmax.z, pResult->m_pField->pev->absmin.x, pResult->m_pField->pev->absmin.y, pResult->m_pField->pev->absmin.z); //LRCT m_pField->FireOnEntry( pValue ); return pResult; } } CInOutRegister *CInOutRegister::Prune( void ) { if ( m_hValue ) { ASSERTSZ(m_pNext != NULL, "invalid InOut registry terminator\n"); if ( m_pField->Intersects(m_hValue) ) { // this entity is still inside the field, do nothing m_pNext = m_pNext->Prune(); return this; } else { // ALERT(at_console, "removing; max %.2f %.2f %.2f, min %.2f %.2f %.2f is outside max %.2f %.2f %.2f, min %.2f %.2f %.2f\n", m_hValue->pev->absmax.x, m_hValue->pev->absmax.y, m_hValue->pev->absmax.z, m_hValue->pev->absmin.x, m_hValue->pev->absmin.y, m_hValue->pev->absmin.z, m_pField->pev->absmax.x, m_pField->pev->absmax.y, m_pField->pev->absmax.z, m_pField->pev->absmin.x, m_pField->pev->absmin.y, m_pField->pev->absmin.z); //LRCT // this entity has just left the field, trigger m_pField->FireOnLeaving( m_hValue ); SetThink(&CInOutRegister:: SUB_Remove ); SetNextThink( 0.1 ); return m_pNext->Prune(); } } else { // this register has a missing or null value if (m_pNext) { // this is an invalid list entry, remove it SetThink(&CInOutRegister:: SUB_Remove ); SetNextThink( 0.1 ); return m_pNext->Prune(); } else { // this is the list terminator, leave it. return this; } } } // CTriggerInOut method bodies: LINK_ENTITY_TO_CLASS( trigger_inout, CTriggerInOut ); TYPEDESCRIPTION CTriggerInOut::m_SaveData[] = { DEFINE_FIELD( CTriggerInOut, m_iszAltTarget, FIELD_STRING ), DEFINE_FIELD( CTriggerInOut, m_iszBothTarget, FIELD_STRING ), DEFINE_FIELD( CTriggerInOut, m_pRegister, FIELD_CLASSPTR ), }; IMPLEMENT_SAVERESTORE(CTriggerInOut,CBaseTrigger); void CTriggerInOut::KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_iszAltTarget")) { m_iszAltTarget = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszBothTarget")) { m_iszBothTarget = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseTrigger::KeyValue( pkvd ); } void CTriggerInOut :: Spawn( void ) { InitTrigger(); // create a null-terminator for the registry m_pRegister = GetClassPtr( (CInOutRegister*)NULL ); m_pRegister->m_hValue = NULL; m_pRegister->m_pNext = NULL; m_pRegister->m_pField = this; m_pRegister->pev->classname = MAKE_STRING("inout_register"); } void CTriggerInOut :: Touch( CBaseEntity *pOther ) { if (!CanTouch(pOther->pev)) return; m_pRegister = m_pRegister->Add(pOther); if (m_fNextThink <= 0 && !m_pRegister->IsEmpty()) SetNextThink( 0.1 ); } void CTriggerInOut :: Think( void ) { // Prune handles all Intersects tests and fires targets as appropriate m_pRegister = m_pRegister->Prune(); if (m_pRegister->IsEmpty()) DontThink(); else SetNextThink( 0.1 ); } void CTriggerInOut :: FireOnEntry( CBaseEntity *pOther ) { if (UTIL_IsMasterTriggered(m_sMaster,pOther)) { FireTargets(STRING(m_iszBothTarget), pOther, this, USE_ON, 0); FireTargets(STRING(pev->target), pOther, this, USE_TOGGLE, 0); } } void CTriggerInOut :: FireOnLeaving( CBaseEntity *pEnt ) { if ( UTIL_IsMasterTriggered(m_sMaster, pEnt) ) { FireTargets(STRING(m_iszBothTarget), pEnt, this, USE_OFF, 0); FireTargets(STRING(m_iszAltTarget), pEnt, this, USE_TOGGLE, 0); } } // ============================== // trigger_counter //After the counter has been triggered "cTriggersLeft" //times (default 2), it will fire all of it's targets and remove itself. class CTriggerCounter : public CTriggerMultiple { public: void Spawn( void ); void EXPORT CounterUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void KeyValue( KeyValueData *pkvd ); }; LINK_ENTITY_TO_CLASS( trigger_counter, CTriggerCounter ); void CTriggerCounter :: KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "count")) { m_cTriggersLeft = (int) atof(pkvd->szValue); pkvd->fHandled = TRUE; } else CTriggerMultiple::KeyValue( pkvd ); } void CTriggerCounter :: Spawn( void ) { // By making the flWait be -1, this counter-trigger will disappear after it's activated // (but of course it needs cTriggersLeft "uses" before that happens). m_flWait = -1; if (m_cTriggersLeft == 0) m_cTriggersLeft = 2; SetUse(&CTriggerCounter :: CounterUse ); } void CTriggerCounter::CounterUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { m_cTriggersLeft--; m_hActivator = pActivator; if( m_cTriggersLeft < 0 ) return; BOOL fTellActivator = (FClassnameIs(m_hActivator->pev, "player") && !FBitSet(pev->spawnflags, SPAWNFLAG_NOMESSAGE)); if( m_cTriggersLeft != 0 ) { if( fTellActivator ) { // UNDONE: I don't think we want these Quakesque messages switch( m_cTriggersLeft ) { case 1: ALERT( at_console, "Only 1 more to go..." ); break; case 2: ALERT( at_console, "Only 2 more to go..." ); break; case 3: ALERT( at_console, "Only 3 more to go..." ); break; default: ALERT( at_console, "There are more to go..." ); break; } } return; } // !!!UNDONE: I don't think we want these Quakesque messages if( fTellActivator ) ALERT( at_console, "Sequence completed!" ); ActivateMultiTrigger( m_hActivator ); } // ====================== TRIGGER_CHANGELEVEL ================================ class CTriggerVolume : public CPointEntity // Derive from point entity so this doesn't move across levels { public: void Spawn( void ); }; LINK_ENTITY_TO_CLASS( trigger_transition, CTriggerVolume ) // Define space that travels across a level transition void CTriggerVolume::Spawn( void ) { pev->solid = SOLID_NOT; pev->movetype = MOVETYPE_NONE; SET_MODEL( ENT( pev ), STRING( pev->model ) ); // set size and link into world pev->model = 0; pev->modelindex = 0; } // Fires a target after level transition and then dies class CFireAndDie : public CBaseDelay { public: void Spawn( void ); void Precache( void ); void Think( void ); int ObjectCaps( void ) { return CBaseDelay::ObjectCaps() | FCAP_FORCE_TRANSITION; } // Always go across transitions }; LINK_ENTITY_TO_CLASS( fireanddie, CFireAndDie ) void CFireAndDie::Spawn( void ) { pev->classname = MAKE_STRING( "fireanddie" ); // Don't call Precache() - it should be called on restore } void CFireAndDie::Precache( void ) { // This gets called on restore SetNextThink( m_flDelay ); } void CFireAndDie::Think( void ) { SUB_UseTargets( this, USE_TOGGLE, 0 ); UTIL_Remove( this ); } #define SF_CHANGELEVEL_USEONLY 0x0002 class CChangeLevel : public CBaseTrigger { public: void Spawn( void ); void KeyValue( KeyValueData *pkvd ); void EXPORT UseChangeLevel( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void EXPORT TriggerChangeLevel( void ); void EXPORT ExecuteChangeLevel( void ); void EXPORT TouchChangeLevel( CBaseEntity *pOther ); void ChangeLevelNow( CBaseEntity *pActivator ); static edict_t *FindLandmark( const char *pLandmarkName ); static int ChangeList( LEVELLIST *pLevelList, int maxList ); static int AddTransitionToList( LEVELLIST *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark ); static int InTransitionVolume( CBaseEntity *pEntity, char *pVolumeName ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; char m_szMapName[cchMapNameMost]; // trigger_changelevel only: next map char m_szLandmarkName[cchMapNameMost]; // trigger_changelevel only: landmark on next map string_t m_changeTarget; float m_changeTargetDelay; }; LINK_ENTITY_TO_CLASS( trigger_changelevel, CChangeLevel ) // Global Savedata for changelevel trigger TYPEDESCRIPTION CChangeLevel::m_SaveData[] = { DEFINE_ARRAY( CChangeLevel, m_szMapName, FIELD_CHARACTER, cchMapNameMost ), DEFINE_ARRAY( CChangeLevel, m_szLandmarkName, FIELD_CHARACTER, cchMapNameMost ), DEFINE_FIELD( CChangeLevel, m_changeTarget, FIELD_STRING ), DEFINE_FIELD( CChangeLevel, m_changeTargetDelay, FIELD_FLOAT ), }; IMPLEMENT_SAVERESTORE( CChangeLevel, CBaseTrigger ) // // Cache user-entity-field values until spawn is called. // void CChangeLevel::KeyValue( KeyValueData *pkvd ) { if( FStrEq( pkvd->szKeyName, "map" ) ) { if( strlen( pkvd->szValue ) >= cchMapNameMost ) ALERT( at_error, "Map name '%s' too long (32 chars)\n", pkvd->szValue ); strcpy( m_szMapName, pkvd->szValue ); //LRC -- don't allow changelevels to contain capital letters; it causes problems // ALERT(at_console, "MapName %s ", m_szMapName); for (int i = 0; m_szMapName[i]; i++) { m_szMapName[i] = tolower(m_szMapName[i]); } // ALERT(at_console, "changed to %s\n", m_szMapName); pkvd->fHandled = TRUE; } else if( FStrEq( pkvd->szKeyName, "landmark" ) ) { if( strlen( pkvd->szValue ) >= cchMapNameMost ) ALERT( at_error, "Landmark name '%s' too long (32 chars)\n", pkvd->szValue ); strcpy( m_szLandmarkName, pkvd->szValue ); pkvd->fHandled = TRUE; } else if( FStrEq( pkvd->szKeyName, "changetarget" ) ) { m_changeTarget = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if( FStrEq( pkvd->szKeyName, "changedelay" ) ) { m_changeTargetDelay = atof( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseTrigger::KeyValue( pkvd ); } /*QUAKED trigger_changelevel (0.5 0.5 0.5) ? NO_INTERMISSION When the player touches this, he gets sent to the map listed in the "map" variable. Unless the NO_INTERMISSION flag is set, the view will go to the info_intermission spot and display stats. */ void CChangeLevel::Spawn( void ) { if( FStrEq( m_szMapName, "" ) ) ALERT( at_console, "a trigger_changelevel doesn't have a map" ); if( FStrEq( m_szLandmarkName, "" ) ) ALERT( at_console, "trigger_changelevel to %s doesn't have a landmark\n", m_szMapName ); if( !FStringNull( pev->targetname ) ) { SetUse( &CChangeLevel::UseChangeLevel ); } InitTrigger(); if( !( pev->spawnflags & SF_CHANGELEVEL_USEONLY ) ) SetTouch( &CChangeLevel::TouchChangeLevel ); //ALERT( at_console, "TRANSITION: %s (%s)\n", m_szMapName, m_szLandmarkName ); } void CChangeLevel::ExecuteChangeLevel( void ) { MESSAGE_BEGIN( MSG_ALL, SVC_CDTRACK ); WRITE_BYTE( 3 ); WRITE_BYTE( 3 ); MESSAGE_END(); MESSAGE_BEGIN( MSG_ALL, SVC_INTERMISSION ); MESSAGE_END(); } FILE_GLOBAL char st_szNextMap[cchMapNameMost]; FILE_GLOBAL char st_szNextSpot[cchMapNameMost]; edict_t *CChangeLevel::FindLandmark( const char *pLandmarkName ) { CBaseEntity *pLandmark; pLandmark = UTIL_FindEntityByTargetname( NULL, pLandmarkName ); while ( pLandmark ) { // Found the landmark if ( FClassnameIs( pLandmark->pev, "info_landmark" ) ) return ENT(pLandmark->pev); else pLandmark = UTIL_FindEntityByTargetname( pLandmark, pLandmarkName ); } ALERT( at_error, "Can't find landmark %s\n", pLandmarkName ); return NULL; } //========================================================= // CChangeLevel :: Use - allows level transitions to be // triggered by buttons, etc. // //========================================================= void CChangeLevel::UseChangeLevel( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { ChangeLevelNow( pActivator ); } void CChangeLevel::ChangeLevelNow( CBaseEntity *pActivator ) { edict_t *pentLandmark; //LEVELLIST 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( gpGlobals->time == pev->dmgtime ) return; pev->dmgtime = gpGlobals->time; CBaseEntity *pPlayer = CBaseEntity::Instance( g_engfuncs.pfnPEntityOfEntIndex( 1 ) ); if( !InTransitionVolume( pPlayer, m_szLandmarkName ) ) { ALERT( at_aiconsole, "Player isn't in the transition volume %s, aborting\n", m_szLandmarkName ); return; } // Create an entity to fire the changetarget if( m_changeTarget ) { CFireAndDie *pFireAndDie = GetClassPtr( (CFireAndDie *)NULL ); if( pFireAndDie ) { // Set target and delay pFireAndDie->pev->target = m_changeTarget; pFireAndDie->m_flDelay = m_changeTargetDelay; pFireAndDie->pev->origin = pPlayer->pev->origin; // Call spawn DispatchSpawn( pFireAndDie->edict() ); } } // This object will get removed in the call to CHANGE_LEVEL, copy the params into "safe" memory strcpy( st_szNextMap, m_szMapName ); m_hActivator = pActivator; SUB_UseTargets( pActivator, USE_TOGGLE, 0 ); st_szNextSpot[0] = 0; // Init landmark to NULL // look for a landmark entity pentLandmark = FindLandmark( m_szLandmarkName ); if( !FNullEnt( pentLandmark ) ) { strcpy( st_szNextSpot, m_szLandmarkName ); gpGlobals->vecLandmarkOffset = VARS( pentLandmark )->origin; } //ALERT( at_console, "Level touches %d levels\n", ChangeList( levels, 16 ) ); ALERT( at_console, "CHANGE LEVEL: %s %s\n", st_szNextMap, st_szNextSpot ); CHANGE_LEVEL( st_szNextMap, st_szNextSpot ); } // // GLOBALS ASSUMED SET: st_szNextMap // void CChangeLevel::TouchChangeLevel( CBaseEntity *pOther ) { if( !FClassnameIs( pOther->pev, "player" ) ) 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 *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark ) { int i; if( !pLevelList || !pMapName || !pLandmarkName || !pentLandmark ) return 0; for( i = 0; i < listCount; i++ ) { if( pLevelList[i].pentLandmark == pentLandmark && strcmp( pLevelList[i].mapName, pMapName ) == 0 ) return 0; } strcpy( pLevelList[listCount].mapName, pMapName ); strcpy( pLevelList[listCount].landmarkName, pLandmarkName ); pLevelList[listCount].pentLandmark = pentLandmark; pLevelList[listCount].vecLandmarkOrigin = VARS( pentLandmark )->origin; return 1; } int BuildChangeList( LEVELLIST *pLevelList, int maxList ) { return CChangeLevel::ChangeList( pLevelList, maxList ); } int CChangeLevel::InTransitionVolume( CBaseEntity *pEntity, char *pVolumeName ) { CBaseEntity *pVolume; if( pEntity->ObjectCaps() & FCAP_FORCE_TRANSITION ) return 1; // If you're following another entity, follow it through the transition (weapons follow the player) if( pEntity->pev->movetype == MOVETYPE_FOLLOW ) { if( pEntity->pev->aiment != NULL ) pEntity = CBaseEntity::Instance( pEntity->pev->aiment ); } int inVolume = 1; // Unless we find a trigger_transition, everything is in the volume pVolume = UTIL_FindEntityByTargetname( NULL, pVolumeName ); while ( pVolume ) { if ( FClassnameIs( pVolume->pev, "trigger_transition" ) ) { if( pVolume->Intersects( pEntity ) ) // It touches one, it's in the volume return 1; else inVolume = 0; // Found a trigger_transition, but I don't intersect it -- if I don't find another, don't go! } pVolume = UTIL_FindEntityByTargetname( pVolume, pVolumeName ); } return inVolume; } // We can only ever move 512 entities across a transition #define MAX_ENTITY 512 // This has grown into a complicated beast // Can we make this more elegant? // This builds the list of all transitions on this level and which entities are in their PVS's and can / should // be moved across. int CChangeLevel::ChangeList( LEVELLIST *pLevelList, int maxList ) { edict_t *pentLandmark; int i, count; count = 0; // Find all of the possible level changes on this BSP CBaseEntity *pChangelevel = UTIL_FindEntityByClassname( NULL, "trigger_changelevel" ); if ( !pChangelevel ) return 0; while ( pChangelevel ) { CChangeLevel *pTrigger; pTrigger = GetClassPtr((CChangeLevel *)pChangelevel->pev); if( pTrigger ) { // Find the corresponding landmark pentLandmark = FindLandmark( pTrigger->m_szLandmarkName ); if( pentLandmark ) { // Build a list of unique transitions if( AddTransitionToList( pLevelList, count, pTrigger->m_szMapName, pTrigger->m_szLandmarkName, pentLandmark ) ) { count++; if( count >= maxList ) // FULL!! break; } } } pChangelevel = UTIL_FindEntityByClassname( pChangelevel, "trigger_changelevel" ); } if( gpGlobals->pSaveData && ( (SAVERESTOREDATA *)gpGlobals->pSaveData)->pTable ) { CSave saveHelper( (SAVERESTOREDATA *)gpGlobals->pSaveData ); for( i = 0; i < count; i++ ) { int j, entityCount = 0; CBaseEntity *pEntList[MAX_ENTITY]; int entityFlags[MAX_ENTITY]; // Follow the linked list of entities in the PVS of the transition landmark edict_t *pent = UTIL_EntitiesInPVS( pLevelList[i].pentLandmark ); // Build a list of valid entities in this linked list (we're going to use pent->v.chain again) while( !FNullEnt( pent ) ) { CBaseEntity *pEntity = CBaseEntity::Instance( pent ); if( pEntity ) { //ALERT( at_console, "Trying %s\n", STRING( pEntity->pev->classname ) ); int caps = pEntity->ObjectCaps(); if( !(caps & FCAP_DONT_SAVE ) ) { int flags = 0; // If this entity can be moved or is global, mark it if( caps & FCAP_ACROSS_TRANSITION ) flags |= FENTTABLE_MOVEABLE; if( pEntity->pev->globalname && !pEntity->IsDormant() ) flags |= FENTTABLE_GLOBAL; if( flags ) { pEntList[entityCount] = pEntity; entityFlags[entityCount] = flags; entityCount++; if( entityCount > MAX_ENTITY ) ALERT( at_error, "Too many entities across a transition!" ); } //else // ALERT( at_console, "Failed %s\n", STRING( pEntity->pev->classname ) ); } //else // ALERT( at_console, "DON'T SAVE %s\n", STRING( pEntity->pev->classname ) ); } pent = pent->v.chain; } for( j = 0; j < entityCount; j++ ) { // Check to make sure the entity isn't screened out by a trigger_transition if( entityFlags[j] && InTransitionVolume( pEntList[j], pLevelList[i].landmarkName ) ) { // Mark entity table with 1<pev->classname ) ); } } } return count; } /* go to the next level for deathmatch only called if a time or frag limit has expired */ void NextLevel( void ) { CBaseEntity* pEnt; CChangeLevel *pChange; // find a trigger_changelevel pEnt = UTIL_FindEntityByClassname(NULL, "trigger_changelevel"); // go back to start if no trigger_changelevel if ( !pEnt ) { gpGlobals->mapname = MAKE_STRING( "start" ); pChange = GetClassPtr( (CChangeLevel *)NULL ); strcpy( pChange->m_szMapName, "start" ); } else pChange = GetClassPtr( (CChangeLevel *)pEnt->pev ); strcpy( st_szNextMap, pChange->m_szMapName ); g_fGameOver = TRUE; pChange->SetNextThink( 0 ); if (pChange->m_fNextThink) { pChange->SetThink( &CChangeLevel::ExecuteChangeLevel ); pChange->SetNextThink( 0.1 ); } } // ============================== LADDER ======================================= #define SF_LADDER_VISIBLE 1 class CLadder : public CBaseTrigger { public: void KeyValue( KeyValueData *pkvd ); void Spawn( void ); void Precache( void ); }; LINK_ENTITY_TO_CLASS( func_ladder, CLadder ) void CLadder::KeyValue( KeyValueData *pkvd ) { CBaseTrigger::KeyValue( pkvd ); } //========================================================= // func_ladder - makes an area vertically negotiable //========================================================= void CLadder::Precache( void ) { // Do all of this in here because we need to 'convert' old saved games pev->solid = SOLID_NOT; pev->skin = CONTENTS_LADDER; if ( CVAR_GET_FLOAT("showtriggers") == 0 && !(pev->spawnflags & SF_LADDER_VISIBLE)) { pev->effects |= EF_NODRAW; //LRC- NODRAW is a better-performance way to stop things being drawn. // (unless... would it prevent client-side movement algorithms from working?) // pev->rendermode = kRenderTransTexture; // pev->renderamt = 0; } else pev->effects &= ~EF_NODRAW; } void CLadder::Spawn( void ) { Precache(); SET_MODEL( ENT( pev ), STRING( pev->model ) ); // set size and link into world pev->movetype = MOVETYPE_PUSH; } // ========================== A TRIGGER THAT PUSHES YOU =============================== class CTriggerPush : public CBaseTrigger { public: void Spawn( void ); void KeyValue( KeyValueData *pkvd ); void Touch( CBaseEntity *pOther ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; int m_iszPushVel; int m_iszPushSpeed; }; LINK_ENTITY_TO_CLASS( trigger_push, CTriggerPush ) TYPEDESCRIPTION CTriggerPush::m_SaveData[] = { DEFINE_FIELD( CTriggerPush, m_iszPushVel, FIELD_STRING ), DEFINE_FIELD( CTriggerPush, m_iszPushSpeed, FIELD_STRING ), }; IMPLEMENT_SAVERESTORE(CTriggerPush,CBaseTrigger) void CTriggerPush::KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_iszPushSpeed")) { m_iszPushSpeed = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszPushVel")) { m_iszPushVel = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseTrigger::KeyValue( pkvd ); } /*QUAKED trigger_push (.5 .5 .5) ? TRIG_PUSH_ONCE Pushes the player */ void CTriggerPush::Spawn() { if( pev->angles == g_vecZero ) pev->angles.y = 360; InitTrigger(); if( pev->speed == 0 ) pev->speed = 100; // this flag was changed and flying barrels on c2a5 stay broken if( FStrEq( STRING( gpGlobals->mapname ), "c2a5" ) && pev->spawnflags & 4 ) pev->spawnflags |= SF_TRIG_PUSH_ONCE; if( FBitSet( pev->spawnflags, SF_TRIGGER_PUSH_START_OFF ) )// if flagged to Start Turned Off, make trigger nonsolid. pev->solid = SOLID_NOT; SetUse(&CTriggerPush :: ToggleUse ); UTIL_SetOrigin( this, pev->origin ); // Link into the list } void CTriggerPush::Touch( CBaseEntity *pOther ) { entvars_t *pevToucher = pOther->pev; // UNDONE: Is there a better way than health to detect things that have physics? (clients/monsters) switch( pevToucher->movetype ) { case MOVETYPE_NONE: case MOVETYPE_PUSH: case MOVETYPE_NOCLIP: case MOVETYPE_FOLLOW: return; } Vector vecPush; if (!FStringNull(m_iszPushVel)) vecPush = CalcLocus_Velocity( this, pOther, STRING(m_iszPushVel) ); else vecPush = pev->movedir; if (!FStringNull(m_iszPushSpeed)) vecPush = vecPush * CalcLocus_Ratio( pOther, STRING(m_iszPushSpeed) ); if (pev->speed) vecPush = vecPush * pev->speed; else vecPush = vecPush * 100; if( pevToucher->solid != SOLID_NOT && pevToucher->solid != SOLID_BSP ) { // Instant trigger, just transfer velocity and remove if( FBitSet( pev->spawnflags, SF_TRIG_PUSH_ONCE ) ) { pevToucher->velocity = pevToucher->velocity + vecPush; if( pevToucher->velocity.z > 0 ) pevToucher->flags &= ~FL_ONGROUND; UTIL_Remove( this ); } else { // Push field, transfer to base velocity if( pevToucher->flags & FL_BASEVELOCITY ) vecPush = vecPush + pevToucher->basevelocity; pevToucher->basevelocity = vecPush; pevToucher->flags |= FL_BASEVELOCITY; //ALERT( at_console, "Vel %f, base %f\n", pevToucher->velocity.z, pevToucher->basevelocity.z ); } } } //=========================================================== //LRC- trigger_bounce //=========================================================== #define SF_BOUNCE_CUTOFF 16 class CTriggerBounce : public CBaseTrigger { public: void Spawn( void ); void Touch( CBaseEntity *pOther ); }; LINK_ENTITY_TO_CLASS( trigger_bounce, CTriggerBounce ); void CTriggerBounce :: Spawn( void ) { SetMovedir(pev); InitTrigger(); } void CTriggerBounce :: Touch( CBaseEntity *pOther ) { if( !UTIL_IsMasterTriggered( m_sMaster, pOther ) ) return; if (!CanTouch(pOther->pev)) return; float dot = DotProduct(pev->movedir, pOther->pev->velocity); if (dot < -pev->armorvalue) { if (pev->spawnflags & SF_BOUNCE_CUTOFF) pOther->pev->velocity = pOther->pev->velocity - (dot + pev->frags*(dot+pev->armorvalue))*pev->movedir; else pOther->pev->velocity = pOther->pev->velocity - (dot + pev->frags*dot)*pev->movedir; SUB_UseTargets( pOther, USE_TOGGLE, 0 ); } } //=========================================================== //LRC- trigger_onsight //=========================================================== #define SF_ONSIGHT_NOLOS 0x00001 #define SF_ONSIGHT_NOGLASS 0x00002 #define SF_ONSIGHT_ACTIVE 0x08000 #define SF_ONSIGHT_DEMAND 0x10000 class CTriggerOnSight : public CBaseDelay { public: void Spawn( void ); void Think( void ); BOOL VisionCheck( void ); BOOL CanSee(CBaseEntity *pLooker, CBaseEntity *pSeen); virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } STATE GetState(); }; LINK_ENTITY_TO_CLASS( trigger_onsight, CTriggerOnSight ); void CTriggerOnSight :: Spawn( void ) { if (pev->target || pev->noise) // if we're going to have to trigger stuff, start thinking SetNextThink( 1 ); else // otherwise, just check whenever someone asks about our state. pev->spawnflags |= SF_ONSIGHT_DEMAND; if (pev->max_health > 0) { pev->health = cos(pev->max_health/2 * M_PI_F/180.0f); // ALERT(at_console, "Cosine is %f\n", pev->health); } } STATE CTriggerOnSight :: GetState( void ) { if (pev->spawnflags & SF_ONSIGHT_DEMAND) return VisionCheck()?STATE_ON:STATE_OFF; else return (pev->spawnflags & SF_ONSIGHT_ACTIVE)?STATE_ON:STATE_OFF; } void CTriggerOnSight :: Think( void ) { // is this a sensible rate? SetNextThink( 0.1 ); // if (!UTIL_IsMasterTriggered(m_sMaster, NULL)) // { // pev->spawnflags &= ~SF_ONSIGHT_ACTIVE; // return; // } if (VisionCheck()) { if (!FBitSet(pev->spawnflags, SF_ONSIGHT_ACTIVE)) { FireTargets(STRING(pev->target), this, this, USE_TOGGLE, 0); FireTargets(STRING(pev->noise1), this, this, USE_ON, 0); pev->spawnflags |= SF_ONSIGHT_ACTIVE; } } else { if (pev->spawnflags & SF_ONSIGHT_ACTIVE) { FireTargets(STRING(pev->noise), this, this, USE_TOGGLE, 0); FireTargets(STRING(pev->noise1), this, this, USE_OFF, 0); pev->spawnflags &= ~SF_ONSIGHT_ACTIVE; } } } BOOL CTriggerOnSight :: VisionCheck( void ) { CBaseEntity *pLooker; if (pev->netname) { pLooker = UTIL_FindEntityByTargetname(NULL, STRING(pev->netname)); if (!pLooker) return FALSE; // if we can't find the eye entity, give up } else { pLooker = UTIL_FindEntityByClassname(NULL, "player"); if (!pLooker) { ALERT(at_error, "trigger_onsight can't find player!?\n"); return FALSE; } } CBaseEntity *pSeen; if (pev->message) pSeen = UTIL_FindEntityByTargetname(NULL, STRING(pev->message)); else return CanSee(pLooker, this); if (!pSeen) { // must be a classname. pSeen = UTIL_FindEntityByClassname(pSeen, STRING(pev->message)); while (pSeen != NULL) { if (CanSee(pLooker, pSeen)) return TRUE; pSeen = UTIL_FindEntityByClassname(pSeen, STRING(pev->message)); } return FALSE; } else { while (pSeen != NULL) { if (CanSee(pLooker, pSeen)) return TRUE; pSeen = UTIL_FindEntityByTargetname(pSeen, STRING(pev->message)); } return FALSE; } } // by the criteria we're using, can the Looker see the Seen entity? BOOL CTriggerOnSight :: CanSee(CBaseEntity *pLooker, CBaseEntity *pSeen) { // out of range? if (pev->frags && (pLooker->pev->origin - pSeen->pev->origin).Length() > pev->frags) return FALSE; // check FOV if appropriate if (pev->max_health < 360) { // copied from CBaseMonster's FInViewCone function Vector2D vec2LOS; float flDot; float flComp = pev->health; UTIL_MakeVectors ( pLooker->pev->angles ); vec2LOS = ( pSeen->pev->origin - pLooker->pev->origin ).Make2D(); vec2LOS = vec2LOS.Normalize(); flDot = DotProduct (vec2LOS , gpGlobals->v_forward.Make2D() ); // ALERT(at_console, "flDot is %f\n", flDot); if ( pev->max_health == -1 ) { CBaseMonster *pMonst = pLooker->MyMonsterPointer(); if (pMonst) flComp = pMonst->m_flFieldOfView; else return FALSE; // not a monster, can't use M-M-M-MonsterVision } // outside field of view if (flDot <= flComp) return FALSE; } // check LOS if appropriate if (!FBitSet(pev->spawnflags, SF_ONSIGHT_NOLOS)) { TraceResult tr; if (SF_ONSIGHT_NOGLASS) UTIL_TraceLine( pLooker->EyePosition(), pSeen->pev->origin, ignore_monsters, ignore_glass, pLooker->edict(), &tr ); else UTIL_TraceLine( pLooker->EyePosition(), pSeen->pev->origin, ignore_monsters, dont_ignore_glass, pLooker->edict(), &tr ); if (tr.flFraction < 1.0f && tr.pHit != pSeen->edict()) return FALSE; } return TRUE; } //====================================== // teleport trigger // // class CTriggerTeleport : public CBaseTrigger { public: void Spawn( void ); void EXPORT TeleportTouch ( CBaseEntity *pOther ); }; LINK_ENTITY_TO_CLASS( trigger_teleport, CTriggerTeleport ) void CTriggerTeleport::Spawn( void ) { InitTrigger(); SetTouch(&CTriggerTeleport :: TeleportTouch ); } void CTriggerTeleport :: TeleportTouch( CBaseEntity *pOther ) { entvars_t* pevToucher = pOther->pev; CBaseEntity *pTarget = NULL; // Only teleport monsters or clients if ( !FBitSet( pevToucher->flags, FL_CLIENT|FL_MONSTER ) ) return; if (!UTIL_IsMasterTriggered(m_sMaster, pOther)) return; if (!CanTouch(pevToucher)) return; pTarget = UTIL_FindEntityByTargetname( pTarget, STRING(pev->target) ); if ( !pTarget ) return; //LRC - landmark based teleports CBaseEntity *pLandmark = UTIL_FindEntityByTargetname( NULL, STRING(pev->message) ); if ( pLandmark ) { Vector vecOriginOffs = pTarget->pev->origin - pLandmark->pev->origin; //ALERT(at_console, "Offs initially: %f %f %f\n", vecOriginOffs.x, vecOriginOffs.y, vecOriginOffs.z); // do we need to rotate the entity? if ( pLandmark->pev->angles != pTarget->pev->angles ) { Vector vecVA; float ydiff = pTarget->pev->angles.y - pLandmark->pev->angles.y; // set new angle to face // ALERT(at_console, "angles = %f %f %f\n", pOther->pev->angles.x, pOther->pev->angles.y, pOther->pev->angles.z); pOther->pev->angles.y += ydiff; if (pOther->IsPlayer()) { // ALERT(at_console, "v_angle = %f %f %f\n", pOther->pev->v_angle.x, pOther->pev->v_angle.y, pOther->pev->v_angle.z); pOther->pev->angles.x = pOther->pev->v_angle.x; // pOther->pev->v_angle.y += ydiff; pOther->pev->fixangle = TRUE; } // set new velocity vecVA = UTIL_VecToAngles(pOther->pev->velocity); vecVA.y += ydiff; UTIL_MakeVectors(vecVA); pOther->pev->velocity = gpGlobals->v_forward * pOther->pev->velocity.Length(); // fix the ugly "angle to vector" behaviour - a legacy from Quake pOther->pev->velocity.z = -pOther->pev->velocity.z; // set new origin Vector vecPlayerOffs = pOther->pev->origin - pLandmark->pev->origin; //ALERT(at_console, "PlayerOffs: %f %f %f\n", vecPlayerOffs.x, vecPlayerOffs.y, vecPlayerOffs.z); vecVA = UTIL_VecToAngles(vecPlayerOffs); UTIL_MakeVectors(vecVA); vecVA.y += ydiff; UTIL_MakeVectors(vecVA); Vector vecPlayerOffsNew = gpGlobals->v_forward * vecPlayerOffs.Length(); vecPlayerOffsNew.z = -vecPlayerOffsNew.z; //ALERT(at_console, "PlayerOffsNew: %f %f %f\n", vecPlayerOffsNew.x, vecPlayerOffsNew.y, vecPlayerOffsNew.z); vecOriginOffs = vecOriginOffs + vecPlayerOffsNew - vecPlayerOffs; //ALERT(at_console, "vecOriginOffs: %f %f %f\n", vecOriginOffs.x, vecOriginOffs.y, vecOriginOffs.z); // vecOriginOffs.y++; } UTIL_SetOrigin( pOther, pOther->pev->origin + vecOriginOffs ); } else { Vector tmp = pTarget->pev->origin; if ( pOther->IsPlayer() ) { tmp.z -= pOther->pev->mins.z;// make origin adjustments in case the teleportee is a player. (origin in center, not at feet) } tmp.z++; UTIL_SetOrigin( pOther, tmp ); pOther->pev->angles = pTarget->pev->angles; pOther->pev->velocity = pOther->pev->basevelocity = g_vecZero; if ( pOther->IsPlayer() ) { pOther->pev->v_angle = pTarget->pev->angles; //LRC pOther->pev->fixangle = TRUE; } } pevToucher->flags &= ~FL_ONGROUND; pevToucher->fixangle = TRUE; FireTargets(STRING(pev->noise), pOther, this, USE_TOGGLE, 0); } LINK_ENTITY_TO_CLASS( info_teleport_destination, CPointEntity ) class CTriggerSave : public CBaseTrigger { public: void Spawn( void ); void EXPORT SaveTouch( CBaseEntity *pOther ); }; LINK_ENTITY_TO_CLASS( trigger_autosave, CTriggerSave ) void CTriggerSave::Spawn( void ) { if( g_pGameRules->IsDeathmatch() ) { REMOVE_ENTITY( ENT( pev ) ); return; } InitTrigger(); SetTouch( &CTriggerSave::SaveTouch ); } void CTriggerSave::SaveTouch( CBaseEntity *pOther ) { if( !UTIL_IsMasterTriggered( m_sMaster, pOther ) ) return; // Only save on clients if( !pOther->IsPlayer() ) return; SetTouch( NULL ); UTIL_Remove( this ); SERVER_COMMAND( "autosave\n" ); } #define SF_ENDSECTION_USEONLY 0x0001 class CTriggerEndSection : public CBaseTrigger { public: void Spawn( void ); void EXPORT EndSectionTouch( CBaseEntity *pOther ); void KeyValue( KeyValueData *pkvd ); void EXPORT EndSectionUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); }; LINK_ENTITY_TO_CLASS( trigger_endsection, CTriggerEndSection ) void CTriggerEndSection::EndSectionUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { // Only save on clients if( pActivator && !pActivator->IsNetClient() ) return; SetUse( NULL ); if( pev->message ) { g_engfuncs.pfnEndSection( STRING( pev->message ) ); } UTIL_Remove( this ); } void CTriggerEndSection::Spawn( void ) { if( g_pGameRules->IsDeathmatch() ) { REMOVE_ENTITY( ENT( pev ) ); return; } InitTrigger(); SetUse( &CTriggerEndSection::EndSectionUse ); // If it is a "use only" trigger, then don't set the touch function. if( !( pev->spawnflags & SF_ENDSECTION_USEONLY ) ) SetTouch( &CTriggerEndSection::EndSectionTouch ); } void CTriggerEndSection::EndSectionTouch( CBaseEntity *pOther ) { // Only save on clients if( !pOther->IsNetClient() ) return; SetTouch( NULL ); if( pev->message ) { g_engfuncs.pfnEndSection( STRING( pev->message ) ); } UTIL_Remove( this ); } void CTriggerEndSection::KeyValue( KeyValueData *pkvd ) { if( FStrEq( pkvd->szKeyName, "section" ) ) { //m_iszSectionName = ALLOC_STRING( pkvd->szValue ); // Store this in message so we don't have to write save/restore for this ent pev->message = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseTrigger::KeyValue( pkvd ); } class CTriggerGravity : public CBaseTrigger { public: void Spawn( void ); void EXPORT GravityTouch( CBaseEntity *pOther ); }; LINK_ENTITY_TO_CLASS( trigger_gravity, CTriggerGravity ) void CTriggerGravity::Spawn( void ) { InitTrigger(); SetTouch( &CTriggerGravity::GravityTouch ); } void CTriggerGravity::GravityTouch( CBaseEntity *pOther ) { // Only save on clients if( !pOther->IsPlayer() ) return; pOther->pev->gravity = pev->gravity; } //=========================================================== //LRC- trigger_startpatrol //=========================================================== class CTriggerSetPatrol : public CBaseDelay { public: void KeyValue( KeyValueData *pkvd ); void Spawn( void ); void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); int ObjectCaps( void ) { return CBaseDelay::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; private: int m_iszPath; }; LINK_ENTITY_TO_CLASS( trigger_startpatrol, CTriggerSetPatrol ); TYPEDESCRIPTION CTriggerSetPatrol::m_SaveData[] = { DEFINE_FIELD( CTriggerSetPatrol, m_iszPath, FIELD_STRING ), }; IMPLEMENT_SAVERESTORE(CTriggerSetPatrol,CBaseDelay); void CTriggerSetPatrol::KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_iszPath")) { m_iszPath = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseDelay::KeyValue( pkvd ); } void CTriggerSetPatrol::Spawn( void ) { } void CTriggerSetPatrol::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { CBaseEntity *pTarget = UTIL_FindEntityByTargetname( NULL, STRING( pev->target ), pActivator ); CBaseEntity *pPath = UTIL_FindEntityByTargetname( NULL, STRING( m_iszPath ), pActivator ); if (pTarget && pPath) { CBaseMonster *pMonster = pTarget->MyMonsterPointer(); if (pMonster) pMonster->StartPatrol(pPath); } } //=========================================================== //LRC- trigger_motion //=========================================================== #define SF_MOTION_DEBUG 1 class CTriggerMotion : public CPointEntity { public: void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; void KeyValue( KeyValueData *pkvd ); int m_iszPosition; int m_iPosMode; int m_iszAngles; int m_iAngMode; int m_iszVelocity; int m_iVelMode; int m_iszAVelocity; int m_iAVelMode; }; LINK_ENTITY_TO_CLASS( trigger_motion, CTriggerMotion ); TYPEDESCRIPTION CTriggerMotion::m_SaveData[] = { DEFINE_FIELD( CTriggerMotion, m_iszPosition, FIELD_STRING ), DEFINE_FIELD( CTriggerMotion, m_iPosMode, FIELD_INTEGER ), DEFINE_FIELD( CTriggerMotion, m_iszAngles, FIELD_STRING ), DEFINE_FIELD( CTriggerMotion, m_iAngMode, FIELD_INTEGER ), DEFINE_FIELD( CTriggerMotion, m_iszVelocity, FIELD_STRING ), DEFINE_FIELD( CTriggerMotion, m_iVelMode, FIELD_INTEGER ), DEFINE_FIELD( CTriggerMotion, m_iszAVelocity, FIELD_STRING ), DEFINE_FIELD( CTriggerMotion, m_iAVelMode, FIELD_INTEGER ), }; IMPLEMENT_SAVERESTORE(CTriggerMotion,CPointEntity); void CTriggerMotion::KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_iszPosition")) { m_iszPosition = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iPosMode")) { m_iPosMode = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszAngles")) { m_iszAngles = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iAngMode")) { m_iAngMode = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszVelocity")) { m_iszVelocity = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iVelMode")) { m_iVelMode = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszAVelocity")) { m_iszAVelocity = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iAVelMode")) { m_iAVelMode = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else CPointEntity::KeyValue( pkvd ); } void CTriggerMotion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { CBaseEntity *pTarget = UTIL_FindEntityByTargetname( NULL, STRING(pev->target), pActivator ); if (pTarget == NULL || pActivator == NULL) return; if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: trigger_motion affects %s \"%s\":\n", STRING(pTarget->pev->classname), STRING(pTarget->pev->targetname)); if (m_iszPosition) { switch (m_iPosMode) { case 0: if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set origin from %f %f %f ", pTarget->pev->origin.x, pTarget->pev->origin.y, pTarget->pev->origin.z); pTarget->pev->origin = CalcLocus_Position( this, pActivator, STRING(m_iszPosition) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->origin.x, pTarget->pev->origin.y, pTarget->pev->origin.z); pTarget->pev->flags &= ~FL_ONGROUND; break; case 1: if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set origin from %f %f %f ", pTarget->pev->origin.x, pTarget->pev->origin.y, pTarget->pev->origin.z); pTarget->pev->origin = pTarget->pev->origin + CalcLocus_Velocity( this, pActivator, STRING(m_iszPosition) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->origin.x, pTarget->pev->origin.y, pTarget->pev->origin.z); pTarget->pev->flags &= ~FL_ONGROUND; break; } } Vector vecTemp; Vector vecVelAngles; if (m_iszAngles) { switch (m_iAngMode) { case 0: vecTemp = CalcLocus_Velocity( this, pActivator, STRING(m_iszAngles) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set angles from %f %f %f ", pTarget->pev->angles.x, pTarget->pev->angles.y, pTarget->pev->angles.z); pTarget->pev->angles = UTIL_VecToAngles( vecTemp ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->angles.x, pTarget->pev->angles.y, pTarget->pev->angles.z); break; case 1: vecTemp = CalcLocus_Velocity( this, pActivator, STRING(m_iszVelocity) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Rotate angles from %f %f %f ", pTarget->pev->angles.x, pTarget->pev->angles.y, pTarget->pev->angles.z); pTarget->pev->angles = pTarget->pev->angles + UTIL_VecToAngles( vecTemp ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->angles.x, pTarget->pev->angles.y, pTarget->pev->angles.z); break; case 2: UTIL_StringToRandomVector( vecTemp, STRING(m_iszAngles) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Rotate angles from %f %f %f ", pTarget->pev->angles.x, pTarget->pev->angles.y, pTarget->pev->angles.z); pTarget->pev->angles = pTarget->pev->angles + vecTemp; if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->angles.x, pTarget->pev->angles.y, pTarget->pev->angles.z); break; } } if (m_iszVelocity) { switch (m_iVelMode) { case 0: if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set velocity from %f %f %f ", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); pTarget->pev->velocity = CalcLocus_Velocity( this, pActivator, STRING(m_iszVelocity) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); break; case 1: if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set velocity from %f %f %f ", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); pTarget->pev->velocity = pTarget->pev->velocity + CalcLocus_Velocity( this, pActivator, STRING(m_iszVelocity) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); break; case 2: vecTemp = CalcLocus_Velocity( this, pActivator, STRING(m_iszVelocity) ); vecVelAngles = UTIL_VecToAngles( vecTemp ) + UTIL_VecToAngles( pTarget->pev->velocity ); UTIL_MakeVectors( vecVelAngles ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Rotate velocity from %f %f %f ", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); pTarget->pev->velocity = pTarget->pev->velocity.Length() * gpGlobals->v_forward; pTarget->pev->velocity.z = -pTarget->pev->velocity.z; //vecToAngles reverses the z angle if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); break; case 3: UTIL_StringToRandomVector( vecTemp, STRING(m_iszVelocity) ); vecVelAngles = vecTemp + UTIL_VecToAngles( pTarget->pev->velocity ); UTIL_MakeVectors( vecVelAngles ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Rotate velocity from %f %f %f ", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); pTarget->pev->velocity = pTarget->pev->velocity.Length() * gpGlobals->v_forward; pTarget->pev->velocity.z = -pTarget->pev->velocity.z; //vecToAngles reverses the z angle if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->velocity.x, pTarget->pev->velocity.y, pTarget->pev->velocity.z); break; } } switch (m_iAVelMode) { case 0: UTIL_StringToRandomVector( vecTemp, STRING(m_iszAVelocity) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set avelocity from %f %f %f ", pTarget->pev->avelocity.x, pTarget->pev->avelocity.y, pTarget->pev->avelocity.z); pTarget->pev->avelocity = vecTemp; if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->avelocity.x, pTarget->pev->avelocity.y, pTarget->pev->avelocity.z); break; case 1: UTIL_StringToRandomVector( vecTemp, STRING(m_iszAVelocity) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set avelocity from %f %f %f ", pTarget->pev->avelocity.x, pTarget->pev->avelocity.y, pTarget->pev->avelocity.z); pTarget->pev->avelocity = pTarget->pev->avelocity + vecTemp; if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", pTarget->pev->avelocity.x, pTarget->pev->avelocity.y, pTarget->pev->avelocity.z); break; } } //=========================================================== //LRC- motion_manager //=========================================================== class CMotionThread : public CPointEntity { public: void Think( void ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; int m_iszPosition; int m_iPosMode; int m_iszFacing; int m_iFaceMode; EHANDLE m_hLocus; EHANDLE m_hTarget; }; LINK_ENTITY_TO_CLASS( motion_thread, CPointEntity ); TYPEDESCRIPTION CMotionThread::m_SaveData[] = { DEFINE_FIELD( CMotionThread, m_iszPosition, FIELD_STRING ), DEFINE_FIELD( CMotionThread, m_iPosMode, FIELD_INTEGER ), DEFINE_FIELD( CMotionThread, m_iszFacing, FIELD_STRING ), DEFINE_FIELD( CMotionThread, m_iFaceMode, FIELD_INTEGER ), DEFINE_FIELD( CMotionThread, m_hLocus, FIELD_EHANDLE ), DEFINE_FIELD( CMotionThread, m_hTarget, FIELD_EHANDLE ), }; IMPLEMENT_SAVERESTORE(CMotionThread,CPointEntity); void CMotionThread::Think( void ) { if( m_hLocus == 0 || m_hTarget == 0 ) { if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "motion_thread expires\n"); SetThink(&CMotionThread:: SUB_Remove ); SetNextThink( 0.1 ); return; } else { SetNextThink( 0 ); // think every frame } if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "motion_thread affects %s \"%s\":\n", STRING(m_hTarget->pev->classname), STRING(m_hTarget->pev->targetname)); Vector vecTemp; if (m_iszPosition) { switch (m_iPosMode) { case 0: // set position if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set origin from %f %f %f ", m_hTarget->pev->origin.x, m_hTarget->pev->origin.y, m_hTarget->pev->origin.z); UTIL_AssignOrigin(m_hTarget, CalcLocus_Position( this, m_hLocus, STRING(m_iszPosition) )); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->origin.x, m_hTarget->pev->origin.y, m_hTarget->pev->origin.z); m_hTarget->pev->flags &= ~FL_ONGROUND; break; case 1: // offset position (= fake velocity) if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Offset origin from %f %f %f ", m_hTarget->pev->origin.x, m_hTarget->pev->origin.y, m_hTarget->pev->origin.z); UTIL_AssignOrigin(m_hTarget, m_hTarget->pev->origin + gpGlobals->frametime * CalcLocus_Velocity( this, m_hLocus, STRING(m_iszPosition) )); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->origin.x, m_hTarget->pev->origin.y, m_hTarget->pev->origin.z); m_hTarget->pev->flags &= ~FL_ONGROUND; break; case 2: // set velocity if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set velocity from %f %f %f ", m_hTarget->pev->velocity.x, m_hTarget->pev->velocity.y, m_hTarget->pev->velocity.z); UTIL_SetVelocity(m_hTarget, CalcLocus_Velocity( this, m_hLocus, STRING(m_iszPosition) )); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->velocity.x, m_hTarget->pev->velocity.y, m_hTarget->pev->velocity.z); break; case 3: // accelerate if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Accelerate from %f %f %f ", m_hTarget->pev->velocity.x, m_hTarget->pev->velocity.y, m_hTarget->pev->velocity.z); UTIL_SetVelocity(m_hTarget, m_hTarget->pev->velocity + gpGlobals->frametime * CalcLocus_Velocity( this, m_hLocus, STRING(m_iszPosition) )); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->velocity.x, m_hTarget->pev->velocity.y, m_hTarget->pev->velocity.z); break; case 4: // follow position if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set velocity (path) from %f %f %f ", m_hTarget->pev->velocity.x, m_hTarget->pev->velocity.y, m_hTarget->pev->velocity.z); UTIL_SetVelocity(m_hTarget, CalcLocus_Position( this, m_hLocus, STRING(m_iszPosition) ) - m_hTarget->pev->origin); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->velocity.x, m_hTarget->pev->velocity.y, m_hTarget->pev->velocity.z); break; } } Vector vecVelAngles; if (m_iszFacing) { switch (m_iFaceMode) { case 0: // set angles vecTemp = CalcLocus_Velocity( this, m_hLocus, STRING(m_iszFacing) ); if (vecTemp != g_vecZero) // if the vector is 0 0 0, don't use it { if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set angles from %f %f %f ", m_hTarget->pev->angles.x, m_hTarget->pev->angles.y, m_hTarget->pev->angles.z); UTIL_SetAngles(m_hTarget, UTIL_VecToAngles( vecTemp )); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->angles.x, m_hTarget->pev->angles.y, m_hTarget->pev->angles.z); } else if (pev->spawnflags & SF_MOTION_DEBUG) { ALERT(at_console, "Zero velocity, don't change angles\n"); } break; case 1: // offset angles (= fake avelocity) vecTemp = CalcLocus_Velocity( this, m_hLocus, STRING(m_iszFacing) ); if (vecTemp != g_vecZero) // if the vector is 0 0 0, don't use it { if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Offset angles from %f %f %f ", m_hTarget->pev->angles.x, m_hTarget->pev->angles.y, m_hTarget->pev->angles.z); UTIL_SetAngles(m_hTarget, m_hTarget->pev->angles + gpGlobals->frametime * UTIL_VecToAngles( vecTemp )); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->angles.x, m_hTarget->pev->angles.y, m_hTarget->pev->angles.z); } else if (pev->spawnflags & SF_MOTION_DEBUG) { ALERT(at_console, "Zero velocity, don't change angles\n"); } break; case 2: // offset angles (= fake avelocity) UTIL_StringToRandomVector( vecVelAngles, STRING(m_iszFacing) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Rotate angles from %f %f %f ", m_hTarget->pev->angles.x, m_hTarget->pev->angles.y, m_hTarget->pev->angles.z); UTIL_SetAngles(m_hTarget, m_hTarget->pev->angles + gpGlobals->frametime * vecVelAngles); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->angles.x, m_hTarget->pev->angles.y, m_hTarget->pev->angles.z); break; case 3: // set avelocity UTIL_StringToRandomVector( vecTemp, STRING(m_iszFacing) ); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Set avelocity from %f %f %f ", m_hTarget->pev->avelocity.x, m_hTarget->pev->avelocity.y, m_hTarget->pev->avelocity.z); UTIL_SetAvelocity(m_hTarget, vecTemp); if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "to %f %f %f\n", m_hTarget->pev->avelocity.x, m_hTarget->pev->avelocity.y, m_hTarget->pev->avelocity.z); break; } } } class CMotionManager : public CPointEntity { public: void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void KeyValue( KeyValueData *pkvd ); void Affect( CBaseEntity *pTarget, CBaseEntity *pActivator ); void PostSpawn( void ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; int m_iszPosition; int m_iPosMode; int m_iszFacing; int m_iFaceMode; }; LINK_ENTITY_TO_CLASS( motion_manager, CMotionManager ); TYPEDESCRIPTION CMotionManager::m_SaveData[] = { DEFINE_FIELD( CMotionManager, m_iszPosition, FIELD_STRING ), DEFINE_FIELD( CMotionManager, m_iPosMode, FIELD_INTEGER ), DEFINE_FIELD( CMotionManager, m_iszFacing, FIELD_STRING ), DEFINE_FIELD( CMotionManager, m_iFaceMode, FIELD_INTEGER ), }; IMPLEMENT_SAVERESTORE(CMotionManager,CPointEntity); void CMotionManager::KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_iszPosition")) { m_iszPosition = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iPosMode")) { m_iPosMode = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszFacing")) { m_iszFacing = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iFaceMode")) { m_iFaceMode = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else CPointEntity::KeyValue( pkvd ); } void CMotionManager::PostSpawn( void ) { if (FStringNull(pev->targetname)) Use( this, this, USE_ON, 0 ); } void CMotionManager::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { CBaseEntity *pTarget = pActivator; if (pev->target) { pTarget = UTIL_FindEntityByTargetname(NULL, STRING(pev->target), pActivator); if (pTarget == NULL) ALERT(at_error, "motion_manager \"%s\" can't find entity \"%s\" to affect\n", STRING(pev->targetname), STRING(pev->target)); else { do { Affect( pTarget, pActivator ); pTarget = UTIL_FindEntityByTargetname(pTarget, STRING(pev->target), pActivator); } while ( pTarget ); } } } void CMotionManager::Affect( CBaseEntity *pTarget, CBaseEntity *pActivator ) { if (pev->spawnflags & SF_MOTION_DEBUG) ALERT(at_console, "DEBUG: Creating MotionThread for %s \"%s\"\n", STRING(pTarget->pev->classname), STRING(pTarget->pev->targetname)); CMotionThread *pThread = GetClassPtr( (CMotionThread*)NULL ); if (pThread == NULL) return; //error? pThread->m_hLocus = pActivator; pThread->m_hTarget = pTarget; pThread->m_iszPosition = m_iszPosition; pThread->m_iPosMode = m_iPosMode; pThread->m_iszFacing = m_iszFacing; pThread->m_iFaceMode = m_iFaceMode; pThread->pev->spawnflags = pev->spawnflags; pThread->SetNextThink( 0 ); } // this is a really bad idea. class CTriggerChangeTarget : public CBaseDelay { public: void KeyValue( KeyValueData *pkvd ); void Spawn( void ); void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); int ObjectCaps( void ) { return CBaseDelay::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; private: string_t m_iszNewTarget; }; LINK_ENTITY_TO_CLASS( trigger_changetarget, CTriggerChangeTarget ) TYPEDESCRIPTION CTriggerChangeTarget::m_SaveData[] = { DEFINE_FIELD( CTriggerChangeTarget, m_iszNewTarget, FIELD_STRING ), }; IMPLEMENT_SAVERESTORE( CTriggerChangeTarget,CBaseDelay ) void CTriggerChangeTarget::KeyValue( KeyValueData *pkvd ) { if( FStrEq( pkvd->szKeyName, "m_iszNewTarget" ) ) { m_iszNewTarget = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseDelay::KeyValue( pkvd ); } void CTriggerChangeTarget::Spawn( void ) { } void CTriggerChangeTarget::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { CBaseEntity *pTarget = UTIL_FindEntityByTargetname( NULL, STRING( pev->target ), pActivator ); if( pTarget ) { if (FStrEq(STRING(m_iszNewTarget), "*locus")) { if (pActivator) pTarget->pev->target = pActivator->pev->targetname; else ALERT(at_error, "trigger_changetarget \"%s\" requires a locus!\n", STRING(pev->targetname)); } else pTarget->pev->target = m_iszNewTarget; CBaseMonster *pMonster = pTarget->MyMonsterPointer(); if( pMonster ) { pMonster->m_pGoalEnt = NULL; } } } //LRC - you thought _that_ was a bad idea? Check this baby out... class CTriggerChangeValue : public CBaseDelay { public: void KeyValue( KeyValueData *pkvd ); void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); int ObjectCaps( void ) { return CBaseDelay::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; private: int m_iszNewValue; }; LINK_ENTITY_TO_CLASS( trigger_changevalue, CTriggerChangeValue ); TYPEDESCRIPTION CTriggerChangeValue::m_SaveData[] = { DEFINE_FIELD( CTriggerChangeValue, m_iszNewValue, FIELD_STRING ), }; IMPLEMENT_SAVERESTORE(CTriggerChangeValue,CBaseDelay); void CTriggerChangeValue::KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "m_iszNewValue")) { m_iszNewValue = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseDelay::KeyValue( pkvd ); } void CTriggerChangeValue::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { CBaseEntity *pTarget = UTIL_FindEntityByTargetname( NULL, STRING( pev->target ), pActivator ); if (pTarget) { KeyValueData mypkvd; mypkvd.szKeyName = STRING(pev->netname); mypkvd.szValue = STRING(m_iszNewValue); mypkvd.fHandled = FALSE; pTarget->KeyValue(&mypkvd); //Error if not handled? } } //===================================================== // trigger_command: activate a console command //===================================================== class CTriggerCommand : public CBaseEntity { public: void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } }; LINK_ENTITY_TO_CLASS( trigger_command, CTriggerCommand ); void CTriggerCommand::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { char szCommand[256]; if (pev->netname) { sprintf( szCommand, "%s\n", STRING(pev->netname) ); SERVER_COMMAND( szCommand ); } } //========================================================= // trigger_changecvar: temporarily set a console variable //========================================================= #define SF_CVAR_ACTIVE 0x80000 class CTriggerChangeCVar : public CBaseEntity { public: void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void EXPORT Think( void ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } static TYPEDESCRIPTION m_SaveData[]; char m_szStoredString[256]; }; LINK_ENTITY_TO_CLASS( trigger_changecvar, CTriggerChangeCVar ); TYPEDESCRIPTION CTriggerChangeCVar::m_SaveData[] = { DEFINE_ARRAY( CTriggerChangeCVar, m_szStoredString, FIELD_CHARACTER, 256 ), }; IMPLEMENT_SAVERESTORE(CTriggerChangeCVar,CBaseEntity); void CTriggerChangeCVar::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { char szCommand[256]; if (!(pev->netname)) return; if (ShouldToggle(useType, pev->spawnflags & SF_CVAR_ACTIVE)) { if (pev->spawnflags & SF_CVAR_ACTIVE) { sprintf( szCommand, "%s \"%s\"\n", STRING(pev->netname), m_szStoredString ); pev->spawnflags &= ~SF_CVAR_ACTIVE; } else { strncpy(m_szStoredString, CVAR_GET_STRING(STRING(pev->netname)), 256); sprintf( szCommand, "%s \"%s\"\n", STRING(pev->netname), STRING(pev->message) ); pev->spawnflags |= SF_CVAR_ACTIVE; if (pev->armorvalue >= 0) { SetNextThink( pev->armorvalue ); } } SERVER_COMMAND( szCommand ); } } void CTriggerChangeCVar::Think( void ) { char szCommand[256]; if (pev->spawnflags & SF_CVAR_ACTIVE) { sprintf( szCommand, "%s %s\n", STRING(pev->netname), m_szStoredString ); SERVER_COMMAND( szCommand ); pev->spawnflags &= ~SF_CVAR_ACTIVE; } } #define SF_CAMERA_PLAYER_POSITION 1 #define SF_CAMERA_PLAYER_TARGET 2 #define SF_CAMERA_PLAYER_TAKECONTROL 4 class CTriggerCamera : public CBaseDelay { public: void Spawn( void ); void KeyValue( KeyValueData *pkvd ); void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void EXPORT FollowTarget( void ); void Move( void ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } static TYPEDESCRIPTION m_SaveData[]; EHANDLE m_hPlayer; EHANDLE m_hTarget; CBaseEntity *m_pentPath; 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; int m_iszViewEntity; }; LINK_ENTITY_TO_CLASS( trigger_camera, CTriggerCamera ) // Global Savedata for changelevel friction modifier TYPEDESCRIPTION CTriggerCamera::m_SaveData[] = { DEFINE_FIELD( CTriggerCamera, m_hPlayer, FIELD_EHANDLE ), DEFINE_FIELD( CTriggerCamera, m_hTarget, FIELD_EHANDLE ), DEFINE_FIELD( CTriggerCamera, m_pentPath, FIELD_CLASSPTR ), DEFINE_FIELD( CTriggerCamera, m_sPath, FIELD_STRING ), DEFINE_FIELD( CTriggerCamera, m_flWait, FIELD_FLOAT ), DEFINE_FIELD( CTriggerCamera, m_flReturnTime, FIELD_TIME ), DEFINE_FIELD( CTriggerCamera, m_flStopTime, FIELD_TIME ), DEFINE_FIELD( CTriggerCamera, m_moveDistance, FIELD_FLOAT ), DEFINE_FIELD( CTriggerCamera, m_targetSpeed, FIELD_FLOAT ), DEFINE_FIELD( CTriggerCamera, m_initialSpeed, FIELD_FLOAT ), DEFINE_FIELD( CTriggerCamera, m_acceleration, FIELD_FLOAT ), DEFINE_FIELD( CTriggerCamera, m_deceleration, FIELD_FLOAT ), DEFINE_FIELD( CTriggerCamera, m_state, FIELD_INTEGER ), DEFINE_FIELD( CTriggerCamera, m_iszViewEntity, FIELD_STRING ), }; IMPLEMENT_SAVERESTORE( CTriggerCamera, CBaseDelay ) void CTriggerCamera::Spawn( void ) { pev->movetype = MOVETYPE_NOCLIP; pev->solid = SOLID_NOT; // Remove model & collisions pev->renderamt = 0; // The engine won't draw this model if this is set to 0 and blending is on pev->rendermode = kRenderTransTexture; m_initialSpeed = pev->speed; if( m_acceleration == 0 ) m_acceleration = 500; if( m_deceleration == 0 ) m_deceleration = 500; } void CTriggerCamera::KeyValue( KeyValueData *pkvd ) { if( FStrEq( pkvd->szKeyName, "wait" ) ) { m_flWait = atof( pkvd->szValue ); pkvd->fHandled = TRUE; } else if( FStrEq(pkvd->szKeyName, "moveto" ) ) { m_sPath = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else if( FStrEq( pkvd->szKeyName, "acceleration" ) ) { m_acceleration = atof( pkvd->szValue ); pkvd->fHandled = TRUE; } else if( FStrEq(pkvd->szKeyName, "deceleration" ) ) { m_deceleration = atof( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iszViewEntity")) { m_iszViewEntity = ALLOC_STRING( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseDelay::KeyValue( pkvd ); } void CTriggerCamera::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { if( !ShouldToggle( useType, m_state ) ) return; // Toggle state m_state = !m_state; if( m_state == 0 ) { m_flReturnTime = gpGlobals->time; return; } if( !pActivator || !pActivator->IsPlayer() ) { pActivator = CBaseEntity::Instance( g_engfuncs.pfnPEntityOfEntIndex( 1 ) ); } m_hPlayer = pActivator; m_flReturnTime = gpGlobals->time + m_flWait; pev->speed = m_initialSpeed; m_targetSpeed = m_initialSpeed; if( FBitSet( pev->spawnflags, SF_CAMERA_PLAYER_TARGET ) ) { m_hTarget = m_hPlayer; } else { m_hTarget = GetNextTarget(); } // Nothing to look at! if( m_hTarget == 0 ) { return; } if( FBitSet( pev->spawnflags, SF_CAMERA_PLAYER_TAKECONTROL ) ) { ( (CBasePlayer *)pActivator )->EnableControl( FALSE ); } if( m_sPath ) { m_pentPath = UTIL_FindEntityByTargetname( NULL, STRING(m_sPath) ); } else { m_pentPath = NULL; } m_flStopTime = gpGlobals->time; if( m_pentPath ) { if( m_pentPath->pev->speed != 0 ) m_targetSpeed = m_pentPath->pev->speed; m_flStopTime += m_pentPath->GetDelay(); } // copy over player information if( FBitSet(pev->spawnflags, SF_CAMERA_PLAYER_POSITION ) ) { UTIL_SetOrigin( this, pActivator->pev->origin + pActivator->pev->view_ofs ); pev->angles.x = -pActivator->pev->angles.x; pev->angles.y = pActivator->pev->angles.y; pev->angles.z = 0; pev->velocity = pActivator->pev->velocity; } else { pev->velocity = Vector( 0, 0, 0 ); } //LRC if (m_iszViewEntity) { CBaseEntity *pEntity = UTIL_FindEntityByTargetname(NULL, STRING(m_iszViewEntity)); if (pEntity) { SET_VIEW( pActivator->edict(), pEntity->edict() ); } } else { SET_VIEW( pActivator->edict(), edict() ); } SET_MODEL( ENT( pev ), STRING( pActivator->pev->model ) ); // follow the player down SetThink( &CTriggerCamera::FollowTarget ); SetNextThink( 0 ); m_moveDistance = 0; Move(); } void CTriggerCamera::FollowTarget() { if( m_hPlayer == 0 ) return; if( m_hTarget == 0 || m_flReturnTime < gpGlobals->time ) { if( m_hPlayer->IsAlive() ) { SET_VIEW( m_hPlayer->edict(), m_hPlayer->edict() ); ( (CBasePlayer *)( (CBaseEntity *)m_hPlayer ) )->EnableControl( TRUE ); } SUB_UseTargets( this, USE_TOGGLE, 0 ); pev->avelocity = Vector( 0, 0, 0 ); m_state = 0; return; } Vector vecGoal = UTIL_VecToAngles( m_hTarget->pev->origin - pev->origin ); vecGoal.x = -vecGoal.x; if( pev->angles.y > 360 ) pev->angles.y -= 360; if( pev->angles.y < 0 ) pev->angles.y += 360; float dx = vecGoal.x - pev->angles.x; float dy = vecGoal.y - pev->angles.y; if( dx < -180 ) dx += 360; if( dx > 180 ) dx = dx - 360; if( dy < -180 ) dy += 360; if( dy > 180 ) dy = dy - 360; pev->avelocity.x = dx * 40 * gpGlobals->frametime; pev->avelocity.y = dy * 40 * gpGlobals->frametime; if( !( FBitSet( pev->spawnflags, SF_CAMERA_PLAYER_TAKECONTROL ) ) ) { pev->velocity = pev->velocity * 0.8f; if( pev->velocity.Length() < 10.0f ) //LRC- whyyyyyy??? pev->velocity = g_vecZero; } SetNextThink( 0 ); Move(); } void CTriggerCamera::Move() { // Not moving on a path, return if( !m_pentPath ) return; // Subtract movement from the previous frame m_moveDistance -= pev->speed * gpGlobals->frametime; // Have we moved enough to reach the target? if( m_moveDistance <= 0 ) { // Fire the passtarget if there is one if( m_pentPath->pev->message ) { FireTargets( STRING( m_pentPath->pev->message ), this, this, USE_TOGGLE, 0 ); if( FBitSet( m_pentPath->pev->spawnflags, SF_CORNER_FIREONCE ) ) m_pentPath->pev->message = 0; } // Time to go to the next target m_pentPath = m_pentPath->GetNextTarget(); // Set up next corner if( !m_pentPath ) { pev->velocity = g_vecZero; } else { if( m_pentPath->pev->speed != 0 ) m_targetSpeed = m_pentPath->pev->speed; Vector delta = m_pentPath->pev->origin - pev->origin; m_moveDistance = delta.Length(); pev->movedir = delta.Normalize(); m_flStopTime = gpGlobals->time + m_pentPath->GetDelay(); } } if( m_flStopTime > gpGlobals->time ) pev->speed = UTIL_Approach( 0, pev->speed, m_deceleration * gpGlobals->frametime ); else pev->speed = UTIL_Approach( m_targetSpeed, pev->speed, m_acceleration * gpGlobals->frametime ); float fraction = 2 * gpGlobals->frametime; pev->velocity = ( ( pev->movedir * pev->speed ) * fraction ) + ( pev->velocity * ( 1 - fraction ) ); }