void CPathTrack :: Link( void )
{
edict_t *pentTarget;
if ( !FStringNull(pev->target) )
{
pentTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(pev->target) );
if ( !FNullEnt(pentTarget) )
{
m_pnext = CPathTrack::Instance( pentTarget );
if ( m_pnext ) // If no next pointer, this is the end of a path
{
m_pnext->SetPrevious( this );
}
}
else
ALERT( at_console, "Dead end link %s\n", STRING(pev->target) );
}
// Find "alternate" path
if ( m_altName )
{
pentTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_altName) );
if ( !FNullEnt(pentTarget) )
{
m_paltpath = CPathTrack::Instance( pentTarget );
if ( m_paltpath ) // If no next pointer, this is the end of a path
{
m_paltpath->SetPrevious( this );
}
}
}
}
void COsprey::FlyThink( void )
{
StudioFrameAdvance( );
pev->nextthink = gpGlobals->time + 0.1;
if ( m_pGoalEnt == NULL && !FStringNull(pev->target) )// this monster has a target
{
m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME ( NULL, STRING( pev->target ) ) );
UpdateGoal( );
}
if (gpGlobals->time > m_startTime + m_dTime)
{
if (m_pGoalEnt->pev->speed == 0)
{
SetThink( DeployThink );
}
do {
m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME ( NULL, STRING( m_pGoalEnt->pev->target ) ) );
} while (m_pGoalEnt->pev->speed < 400 && !HasDead());
UpdateGoal( );
}
Flight( );
ShowDamage( );
}
/* <8dd79> ../cstrike/dlls/func_tank.cpp:821 */
CLaser *CFuncTankLaser::GetLaser(void)
{
if (m_pLaser != NULL)
{
return m_pLaser;
}
edict_t *pentLaser;
pentLaser = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->message));
while (!FNullEnt(pentLaser))
{
// Found the landmark
if (FClassnameIs(pentLaser, "env_laser"))
{
m_pLaser = (CLaser *)CBaseEntity::Instance(pentLaser);
break;
}
else
pentLaser = FIND_ENTITY_BY_TARGETNAME(pentLaser, STRING(pev->message));
}
return m_pLaser;
}
void CTriggerSubModel :: ChangeSub ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( FStringNull ( pev->target ) )
return;
edict_t *pentTarget = FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(pev->target) );
if ( FNullEnt(pentTarget) )
{
ALERT ( at_console, "CTriggerSubModel : pas d'entite s appelant %s\n", STRING(pev->target) );
return;
}
CBaseEntity *pTarget = Instance( pentTarget );
if ( pTarget->MyMonsterPointer() == NULL )
{
ALERT ( at_console, "CTriggerSubModel : %s n est pas un monstre\n", STRING(pev->target) );
return;
}
CBaseMonster *pMonster = (CBaseMonster*)pTarget;
pMonster->SetBodygroup( m_iBodygroup, m_iSubmodel);
}
void FireTargets( const char *targetName, CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
edict_t *pentTarget = NULL;
if ( !targetName )
return;
ALERT( at_aiconsole, "Firing: (%s)\n", targetName );
for (;;)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, targetName);
if (FNullEnt(pentTarget))
break;
CBaseEntity *pTarget = CBaseEntity::Instance( pentTarget );
if ( pTarget && !(pTarget->pev->flags & FL_KILLME) ) // Don't use dying ents
{
ALERT( at_aiconsole, "Found: %s, firing (%s)\n", STRING(pTarget->pev->classname), targetName );
if ( strcmp( STRING( pCaller->pev->classname ), "func_breakable" ) == 0 ) {
CBaseEntity *breakable = CBaseEntity::Instance( pCaller->pev );
if ( breakable->killedOrCausedByPlayer ) {
pTarget->auxOwner = breakable->auxOwner;
pTarget->killedOrCausedByPlayer = true;
}
}
pTarget->Use( pActivator, pCaller, useType, value );
}
}
}
void FireTargets(const char *targetName, CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
{
edict_t *pentTarget = NULL;
if (!targetName)
return;
ALERT(at_aiconsole, "Firing: (%s)\n", targetName);
while (1)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, targetName);
if (FNullEnt(pentTarget))
break;
CBaseEntity *pTarget = CBaseEntity::Instance(pentTarget);
if (pTarget && !(pTarget->pev->flags & FL_KILLME))
{
ALERT(at_aiconsole, "Found: %s, firing (%s)\n", STRING(pTarget->pev->classname), targetName);
pTarget->Use(pActivator, pCaller, useType, value);
}
}
}
// find a viable entity
int CCineMonster::FindEntity(void)
{
edict_t *pentTarget;
pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszEntity));
m_hTargetEnt = NULL;
CBaseMonster *pTarget = NULL;
while(!FNullEnt(pentTarget))
{
if(FBitSet(VARS(pentTarget)->flags, FL_MONSTER))
{
pTarget = GetMonsterPointer(pentTarget);
if(pTarget && pTarget->CanPlaySequence(FCanOverrideState(), SS_INTERRUPT_BY_NAME))
{
m_hTargetEnt = pTarget;
return TRUE;
}
ALERT(at_console, "Found %s, but can't play!\n", STRING(m_iszEntity));
}
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
pTarget = NULL;
}
if(!pTarget)
{
CBaseEntity *pEntity = NULL;
while((pEntity = UTIL_FindEntityInSphere(pEntity, pev->origin, m_flRadius)) != NULL)
{
if(FClassnameIs(pEntity->pev, STRING(m_iszEntity)))
{
if(FBitSet(pEntity->pev->flags, FL_MONSTER))
{
pTarget = pEntity->MyMonsterPointer();
if(pTarget && pTarget->CanPlaySequence(FCanOverrideState(), SS_INTERRUPT_IDLE))
{
m_hTargetEnt = pTarget;
return TRUE;
}
}
}
}
}
pTarget = NULL;
m_hTargetEnt = NULL;
return FALSE;
}
void CBaseDelay::SUB_UseTargets(CBaseEntity *pActivator, USE_TYPE useType, float value)
{
if (FStringNull(pev->target) && !m_iszKillTarget)
return;
if (m_flDelay != 0)
{
CBaseDelay *pTemp = GetClassPtr((CBaseDelay *)NULL);
if (pTemp->pev->classname)
RemoveEntityHashValue(pTemp->pev, STRING(pTemp->pev->classname), CLASSNAME);
pTemp->pev->classname = MAKE_STRING("DelayedUse");
AddEntityHashValue(pTemp->pev, STRING(pTemp->pev->classname), CLASSNAME);
pTemp->pev->nextthink = gpGlobals->time + m_flDelay;
pTemp->SetThink(&CBaseDelay::DelayThink);
pTemp->pev->button = (int)useType;
pTemp->m_iszKillTarget = m_iszKillTarget;
pTemp->m_flDelay = 0;
pTemp->pev->target = pev->target;
if (pActivator && pActivator->IsPlayer())
pTemp->pev->owner = pActivator->edict();
else
pTemp->pev->owner = NULL;
return;
}
if (m_iszKillTarget)
{
ALERT(at_aiconsole, "KillTarget: %s\n", STRING(m_iszKillTarget));
edict_t *pentKillTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszKillTarget));
while (!FNullEnt(pentKillTarget))
{
UTIL_Remove(CBaseEntity::Instance(pentKillTarget));
ALERT(at_aiconsole, "killing %s\n", STRING(pentKillTarget->v.classname));
pentKillTarget = FIND_ENTITY_BY_TARGETNAME(pentKillTarget, STRING(m_iszKillTarget));
}
}
if (!FStringNull(pev->target))
FireTargets(STRING(pev->target), pActivator, this, useType, value);
}
// find all the cinematic entities with my targetname and stop them from playing
void CCineMonster::CancelScript(void)
{
ALERT(at_aiconsole, "Cancelling script: %s\n", STRING(m_iszPlay));
if(!pev->targetname)
{
ScriptEntityCancel(edict());
return;
}
edict_t *pentCineTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->targetname));
while(!FNullEnt(pentCineTarget))
{
ScriptEntityCancel(pentCineTarget);
pentCineTarget = FIND_ENTITY_BY_TARGETNAME(pentCineTarget, STRING(pev->targetname));
}
}
CBaseEntity *CBaseEntity::GetNextTarget(void)
{
if(FStringNull(pev->target))
return NULL;
edict_t *pTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->target));
if(FNullEnt(pTarget))
return NULL;
return Instance(pTarget);
}
// Button has returned to start state. Quiesce it.
void CBaseButton::ButtonBackHome()
{
assert(m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_AT_BOTTOM;
if (pev->spawnflags & SF_BUTTON_TOGGLE
#ifdef REGAMEDLL_FIXES
&& m_hActivator
#endif
)
{
//EMIT_SOUND(ENT(pev), CHAN_VOICE, (char *)STRING(pev->noise), 1, ATTN_NORM);
SUB_UseTargets(m_hActivator, USE_TOGGLE, 0);
}
if (!FStringNull(pev->target))
{
edict_t *pentTarget = NULL;
while ((pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->target))) != NULL)
{
if (FNullEnt(pentTarget))
break;
if (!FClassnameIs(pentTarget, "multisource"))
continue;
CBaseEntity *pTarget = CBaseEntity::Instance(pentTarget);
if (pTarget != NULL)
{
pTarget->Use(m_hActivator, this, USE_TOGGLE, 0);
}
}
}
// Re-instate touch method, movement cycle is complete.
// this button only works if USED, not touched!
if (!(pev->spawnflags & SF_BUTTON_TOUCH_ONLY))
{
// All buttons are now use only
SetTouch(NULL);
}
else
SetTouch(&CBaseButton::ButtonTouch);
// reset think for a sparking button
if (pev->spawnflags & SF_BUTTON_SPARK_IF_OFF)
{
SetThink(&CBaseButton::ButtonSpark);
// no hurry.
pev->nextthink = gpGlobals->time + 0.5f;
}
}
// Find an entity that I'm interested in and precache the sounds he'll need in the sequence.
void CCineMonster::Activate(void)
{
edict_t * pentTarget;
CBaseMonster *pTarget;
// The entity name could be a target name or a classname
// Check the targetname
pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszEntity));
pTarget = NULL;
while(!pTarget && !FNullEnt(pentTarget))
{
if(FBitSet(VARS(pentTarget)->flags, FL_MONSTER))
{
pTarget = GetMonsterPointer(pentTarget);
}
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
}
// If no entity with that targetname, check the classname
if(!pTarget)
{
pentTarget = FIND_ENTITY_BY_CLASSNAME(NULL, STRING(m_iszEntity));
while(!pTarget && !FNullEnt(pentTarget))
{
pTarget = GetMonsterPointer(pentTarget);
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
}
}
// Found a compatible entity
if(pTarget)
{
void *pmodel;
pmodel = GET_MODEL_PTR(pTarget->edict());
if(pmodel)
{
// Look through the event list for stuff to precache
SequencePrecache(pmodel, STRING(m_iszIdle));
SequencePrecache(pmodel, STRING(m_iszPlay));
}
}
}
// find all the cinematic entities with my targetname and tell them to wait before starting
void CCineMonster::DelayStart(int state)
{
edict_t *pentCine = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->targetname));
while(!FNullEnt(pentCine))
{
if(FClassnameIs(pentCine, "scripted_sequence"))
{
CCineMonster *pTarget = GetClassPtr((CCineMonster *)VARS(pentCine));
if(state)
{
pTarget->m_iDelay++;
}
else
{
pTarget->m_iDelay--;
if(pTarget->m_iDelay <= 0)
pTarget->m_startTime = gpGlobals->time + 0.05;
}
}
pentCine = FIND_ENTITY_BY_TARGETNAME(pentCine, STRING(pev->targetname));
}
}
void CFuncTankControls::Think(void)
{
edict_t *pTarget = NULL;
do pTarget = FIND_ENTITY_BY_TARGETNAME(pTarget, STRING(pev->target));
while (!FNullEnt(pTarget) && strncmp(STRING(pTarget->v.classname), "func_tank", 9));
if (FNullEnt(pTarget))
{
ALERT(at_console, "No tank %s\n", STRING(pev->target));
return;
}
m_pTank = (CFuncTank*)Instance(pTarget);
}
void CPathCorner :: Touch( CBaseEntity *pOther )
{
entvars_t* pevToucher = pOther->pev;
if ( FBitSet ( pevToucher->flags, FL_MONSTER ) )
{// monsters don't navigate path corners based on touch anymore
return;
}
// If OTHER isn't explicitly looking for this path_corner, bail out
if ( pOther->m_pGoalEnt != this )
{
return;
}
// If OTHER has an enemy, this touch is incidental, ignore
if ( !FNullEnt(pevToucher->enemy) )
{
return; // fighting, not following a path
}
// UNDONE: support non-zero flWait
/*
if (m_flWait != 0)
ALERT(at_warning, "Non-zero path-cornder waits NYI");
*/
// Find the next "stop" on the path, make it the goal of the "toucher".
if (FStringNull(pev->target))
{
ALERT(at_warning, "PathCornerTouch: no next stop specified");
}
pOther->m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(pev->target) ) );
// If "next spot" was not found (does not exist - level design error)
if ( !pOther->m_pGoalEnt )
{
ALERT(at_console, "PathCornerTouch--%s couldn't find next stop in path: %s", STRING(pev->classname), STRING(pev->target));
return;
}
// Turn towards the next stop in the path.
pevToucher->ideal_yaw = UTIL_VecToYaw ( pOther->m_pGoalEnt->pev->origin - pevToucher->origin );
}
/* <8d39a> ../cstrike/dlls/func_tank.cpp:1012 */
void CFuncTankControls::__MAKE_VHOOK(Think)(void)
{
edict_t *pTarget = NULL;
do
{
pTarget = FIND_ENTITY_BY_TARGETNAME(pTarget, STRING(pev->target));
}
while (!FNullEnt(pTarget) && Q_strncmp(STRING(pTarget->v.classname), "func_tank", 9));
if (FNullEnt(pTarget))
{
ALERT(at_console, "No tank %s\n", STRING(pev->target));
return;
}
m_pTank = reinterpret_cast<CFuncTank *>(Instance(pTarget));
}
void CMomentaryRotButton::UpdateTarget( float value )
{
if (!FStringNull(pev->target))
{
edict_t* pentTarget = NULL;
for (;;)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->target));
if (FNullEnt(pentTarget))
break;
CBaseEntity *pEntity = CBaseEntity::Instance(pentTarget);
if ( pEntity )
{
pEntity->Use( this, this, USE_SET, value );
}
}
}
}
bool UTIL_IsMasterTriggered( string_t sMaster, const CBaseEntity* const pActivator )
{
if (sMaster)
{
edict_t *pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(sMaster));
if ( !FNullEnt(pentTarget) )
{
CBaseEntity *pMaster = CBaseEntity::Instance(pentTarget);
if ( pMaster && (pMaster->ObjectCaps() & FCAP_MASTER) )
return pMaster->IsTriggered( pActivator );
}
ALERT(at_console, "Master was null or not a master!\n");
}
// if this isn't a master entity, just say yes.
return true;
}
static cell AMX_NATIVE_CALL find_ent_by_tname(AMX *amx, cell *params) {
int iStart = params[1];
int iLength;
char *szValue = MF_GetAmxString(amx, params[2], 0, &iLength);
edict_t *pStart;
if (iStart == -1) {
pStart = NULL;
} else {
if (!is_ent_valid(iStart))
pStart = NULL;
else
pStart = INDEXENT2(iStart);
}
int iReturnEnt = ENTINDEX(FIND_ENTITY_BY_TARGETNAME(pStart, szValue));
return iReturnEnt;
}
/* <1bbd36> ../cstrike/dlls/vehicle.cpp:1067 */
void CFuncVehicleControls::Find()
{
edict_t *pTarget = NULL;
do
{
pTarget = FIND_ENTITY_BY_TARGETNAME(pTarget, STRING(pev->target));
}
while (!FNullEnt(pTarget) && !FClassnameIs(pTarget, "func_vehicle"));
if (FNullEnt(pTarget))
{
ALERT(at_console, "No vehicle %s\n", STRING(pev->target));
return;
}
CFuncVehicle *pvehicle = CFuncVehicle::Instance(pTarget);
pvehicle->SetControls(pev);
UTIL_Remove(this);
}
void CBaseButton::ButtonBackHome(void)
{
ASSERT(m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_AT_BOTTOM;
if (FBitSet(pev->spawnflags, SF_BUTTON_TOGGLE))
SUB_UseTargets(m_hActivator, USE_TOGGLE, 0);
if (!FStringNull(pev->target))
{
edict_t *pentTarget = NULL;
while (1)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->target));
if (FNullEnt(pentTarget))
break;
if (!FClassnameIs(pentTarget, "multisource"))
continue;
CBaseEntity *pTarget = CBaseEntity::Instance(pentTarget);
if (pTarget)
pTarget->Use(m_hActivator, this, USE_TOGGLE, 0);
}
}
if (!FBitSet(pev->spawnflags, SF_BUTTON_TOUCH_ONLY))
SetTouch(NULL);
else
SetTouch(&CBaseButton::ButtonTouch);
if (FBitSet(pev->spawnflags, SF_BUTTON_SPARK_IF_OFF))
{
SetThink(&CBaseButton::ButtonSpark);
pev->nextthink = gpGlobals->time + 0.5;
}
}
//modif de Julien
void CMomentaryDoor :: Blocked( CBaseEntity *pOther )
{
if ( FBitSet ( pev->spawnflags, SF_MOMENT_DOOR_BLOCK ) )
{
edict_t *pentCherche = NULL;
for ( int i = 0 ; i < 5 ; i++ )
{
pentCherche = FIND_ENTITY_BY_TARGETNAME ( pentCherche, STRING( pev->target ));
if ( FClassnameIs( pentCherche, "momentary_rot_button" ) ) //"momentary_door" ) )
{
CBaseEntity* pDoor = CBaseEntity :: Instance ( pentCherche );
pDoor->pev->target = NULL;
}
}
ClearBits ( pev->spawnflags, SF_MOMENT_DOOR_BLOCK );
FireTargets ( STRING(pev->netname), this, this, USE_ON, 0 );
}
}
void CFuncVehicle::Find()
{
m_ppath = CPathTrack::Instance(FIND_ENTITY_BY_TARGETNAME(nullptr, STRING(pev->target)));
if (!m_ppath)
return;
entvars_t *pevTarget = m_ppath->pev;
if (!FClassnameIs(pevTarget, "path_track"))
{
ALERT(at_error, "func_track_train must be on a path of path_track\n");
m_ppath = nullptr;
return;
}
Vector nextPos = pevTarget->origin;
nextPos.z += m_height;
Vector look = nextPos;
look.z -= m_height;
m_ppath->LookAhead(&look, m_length, 0);
look.z += m_height;
pev->angles = UTIL_VecToAngles(look - nextPos);
pev->angles.y += 180;
if (pev->spawnflags & SF_TRACKTRAIN_NOPITCH)
{
pev->angles.x = 0;
}
UTIL_SetOrigin(pev, nextPos);
NextThink(pev->ltime + 0.1, FALSE);
SetThink(&CFuncVehicle::Next);
pev->speed = m_startSpeed;
UpdateSound();
}
void CRenderFxManager::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if( !FStringNull( pev->target ) )
{
edict_t* pentTarget = NULL;
while( 1 )
{
pentTarget = FIND_ENTITY_BY_TARGETNAME( pentTarget, STRING( pev->target ) );
if( FNullEnt( pentTarget ) )
break;
entvars_t *pevTarget = VARS( pentTarget );
if( !FBitSet( pev->spawnflags, SF_RENDER_MASKFX ) )
pevTarget->renderfx = pev->renderfx;
if( !FBitSet( pev->spawnflags, SF_RENDER_MASKAMT ) )
pevTarget->renderamt = pev->renderamt;
if( !FBitSet( pev->spawnflags, SF_RENDER_MASKMODE ) )
pevTarget->rendermode = pev->rendermode;
if( !FBitSet( pev->spawnflags, SF_RENDER_MASKCOLOR ) )
pevTarget->rendercolor = pev->rendercolor;
}
}
}
void CBigMomma::NodeStart(int iszNextNode)
{
pev->netname = iszNextNode;
CBaseEntity *pTarget = NULL;
if(pev->netname)
{
edict_t *pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->netname));
if(!FNullEnt(pentTarget))
pTarget = Instance(pentTarget);
}
if(!pTarget)
{
ALERT(at_aiconsole, "BM: Finished the path!!\n");
Remember(bits_MEMORY_PATH_FINISHED);
return;
}
Remember(bits_MEMORY_ON_PATH);
m_hTargetEnt = pTarget;
}
void CLightning::BeamUpdateVars( void )
{
int beamType;
int pointStart, pointEnd;
edict_t *pStart = FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(m_iszStartEntity) );
edict_t *pEnd = FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(m_iszEndEntity) );
pointStart = IsPointEntity( CBaseEntity::Instance(pStart) );
pointEnd = IsPointEntity( CBaseEntity::Instance(pEnd) );
pev->skin = 0;
pev->sequence = 0;
pev->rendermode = 0;
pev->flags |= FL_CUSTOMENTITY;
pev->model = m_iszSpriteName;
SetTexture( m_spriteTexture );
beamType = BEAM_ENTS;
if ( pointStart || pointEnd )
{
if ( !pointStart ) // One point entity must be in pStart
{
edict_t *pTemp;
// Swap start & end
pTemp = pStart;
pStart = pEnd;
pEnd = pTemp;
int swap = pointStart;
pointStart = pointEnd;
pointEnd = swap;
}
if ( !pointEnd )
beamType = BEAM_ENTPOINT;
else
beamType = BEAM_POINTS;
}
SetType( beamType );
if ( beamType == BEAM_POINTS || beamType == BEAM_ENTPOINT || beamType == BEAM_HOSE )
{
SetStartPos( pStart->v.origin );
if ( beamType == BEAM_POINTS || beamType == BEAM_HOSE )
SetEndPos( pEnd->v.origin );
else
SetEndEntity( ENTINDEX(pEnd) );
}
else
{
SetStartEntity( ENTINDEX(pStart) );
SetEndEntity( ENTINDEX(pEnd) );
}
RelinkBeam();
SetWidth( m_boltWidth );
SetNoise( m_noiseAmplitude );
SetFrame( m_frameStart );
SetScrollRate( m_speed );
if ( pev->spawnflags & SF_BEAM_SHADEIN )
SetFlags( BEAM_FSHADEIN );
else if ( pev->spawnflags & SF_BEAM_SHADEOUT )
SetFlags( BEAM_FSHADEOUT );
}
/* <6a465> ../cstrike/dlls/doors.cpp:817 */
void CBaseDoor::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
{
edict_t *pentTarget = NULL;
CBaseDoor *pDoor = NULL;
const float checkBlockedInterval = 0.25f;
// Hurt the blocker a little.
if (pev->dmg != 0.0f)
{
pOther->TakeDamage(pev, pev, pev->dmg, DMG_CRUSH);
}
if (gpGlobals->time - m_lastBlockedTimestamp < checkBlockedInterval)
{
return;
}
m_lastBlockedTimestamp = gpGlobals->time;
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (m_flWait >= 0)
{
if (m_toggle_state == TS_GOING_DOWN)
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// Block all door pieces with the same targetname here.
if (!FStringNull(pev->targetname))
{
while (true)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->targetname));
if (VARS(pentTarget) != pev)
{
if (FNullEnt(pentTarget))
break;
if (FClassnameIs(pentTarget, "func_door") || FClassnameIs(pentTarget, "func_door_rotating"))
{
pDoor = GetClassPtr((CBaseDoor *)VARS(pentTarget));
if (pDoor->m_flWait >= 0)
{
if (pDoor->pev->velocity == pev->velocity && pDoor->pev->avelocity == pev->velocity)
{
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if (FClassnameIs(pentTarget, "func_door"))
{
// set origin to realign normal doors
pDoor->pev->origin = pev->origin;
// stop!
pDoor->pev->velocity = g_vecZero;
}
else
{
// set angles to realign rotating doors
pDoor->pev->angles = pev->angles;
pDoor->pev->avelocity = g_vecZero;
}
}
if (!(pev->spawnflags & SF_DOOR_SILENT))
{
STOP_SOUND(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseMoving));
}
if (pDoor->m_toggle_state == TS_GOING_DOWN)
pDoor->DoorGoUp();
else
pDoor->DoorGoDown();
}
}
}
}
}
}
void CBaseDoor::Blocked( CBaseEntity *pOther )
{
edict_t *pentTarget = NULL;
CBaseDoor *pDoor = NULL;
// Hurt the blocker a little.
if ( pev->dmg )
pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH );
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (m_flWait >= 0)
{
if (m_toggle_state == TS_GOING_DOWN)
{
DoorGoUp();
}
else
{
DoorGoDown();
}
}
// Block all door pieces with the same targetname here.
if ( !FStringNull ( pev->targetname ) )
{
for (;;)
{
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(pev->targetname));
if ( VARS( pentTarget ) != pev )
{
if (FNullEnt(pentTarget))
break;
if ( FClassnameIs ( pentTarget, "func_door" ) || FClassnameIs ( pentTarget, "func_door_rotating" ) )
{
pDoor = GetClassPtr( (CBaseDoor *) VARS(pentTarget) );
if ( pDoor->m_flWait >= 0)
{
if (pDoor->pev->velocity == pev->velocity && pDoor->pev->avelocity == pev->velocity)
{
// this is the most hacked, evil, bastardized thing I've ever seen. kjb
if ( FClassnameIs ( pentTarget, "func_door" ) )
{// set origin to realign normal doors
pDoor->pev->origin = pev->origin;
pDoor->pev->velocity = g_vecZero;// stop!
}
else
{// set angles to realign rotating doors
pDoor->pev->angles = pev->angles;
pDoor->pev->avelocity = g_vecZero;
}
}
if ( pDoor->m_toggle_state == TS_GOING_DOWN)
pDoor->DoorGoUp();
else
pDoor->DoorGoDown();
}
}
}
}
}
}
void CBaseDelay :: SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value )
{
//
// exit immediatly if we don't have a target or kill target
//
if (FStringNull(pev->target) && !m_iszKillTarget)
return;
//
// check for a delay
//
if (m_flDelay != 0)
{
// create a temp object to fire at a later time
CBaseDelay *pTemp = GetClassPtr( (CBaseDelay *)NULL);
pTemp->pev->classname = MAKE_STRING("DelayedUse");
pTemp->pev->nextthink = gpGlobals->time + m_flDelay;
pTemp->SetThink( &CBaseDelay::DelayThink );
// Save the useType
pTemp->pev->button = (int)useType;
pTemp->m_iszKillTarget = m_iszKillTarget;
pTemp->m_flDelay = 0; // prevent "recursion"
pTemp->pev->target = pev->target;
// HACKHACK
// This wasn't in the release build of Half-Life. We should have moved m_hActivator into this class
// but changing member variable hierarchy would break save/restore without some ugly code.
// This code is not as ugly as that code
if ( pActivator && pActivator->IsPlayer() ) // If a player activates, then save it
{
pTemp->pev->owner = pActivator->edict();
}
else
{
pTemp->pev->owner = NULL;
}
return;
}
//
// kill the killtargets
//
if ( m_iszKillTarget )
{
edict_t *pentKillTarget = NULL;
ALERT( at_aiconsole, "KillTarget: %s\n", STRING(m_iszKillTarget) );
pentKillTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_iszKillTarget) );
while ( !FNullEnt(pentKillTarget) )
{
UTIL_Remove( CBaseEntity::Instance(pentKillTarget) );
ALERT( at_aiconsole, "killing %s\n", STRING( pentKillTarget->v.classname ) );
pentKillTarget = FIND_ENTITY_BY_TARGETNAME( pentKillTarget, STRING(m_iszKillTarget) );
}
}
//
// fire targets
//
if (!FStringNull(pev->target))
{
FireTargets( STRING(pev->target), pActivator, this, useType, value );
}
}
void CBaseDelay :: SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value )
{
//
// exit immediatly if we don't have a target or kill target or message
//
if (FStringNull(pev->target) && FStringNull(m_iszKillTarget) && FStringNull(pev->message))
return;
//
// check for a delay
//
if (m_flDelay != 0)
{
// create a temp object to fire at a later time
CBaseDelay *pTemp = GetClassPtr( (CBaseDelay *)NULL);
pTemp->pev->classname = MAKE_STRING("DelayedUse");
pTemp->pev->nextthink = gpGlobals->time + m_flDelay;
pTemp->SetThink( &CBaseDelay::DelayThink );
// Save the useType
pTemp->pev->button = (int)useType;
pTemp->m_iszKillTarget = m_iszKillTarget;
pTemp->m_flDelay = 0; // prevent "recursion"
pTemp->pev->target = pev->target;
pTemp->m_hActivator = pActivator;
return;
}
//
// print the message
//
if (pActivator->IsPlayer() && !FStringNull( pev->message ))
{
CenterPrint( pActivator->pev, STRING( pev->message ));
if(FStringNull( pev->noise ))
EMIT_SOUND(ENT(pActivator->pev), CHAN_VOICE, "misc/talk.wav", 1, ATTN_NORM);
}
//
// kill the killtargets
//
if ( m_iszKillTarget )
{
edict_t *pentKillTarget = NULL;
ALERT( at_aiconsole, "KillTarget: %s\n", STRING(m_iszKillTarget) );
pentKillTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_iszKillTarget) );
while ( !FNullEnt(pentKillTarget) )
{
UTIL_Remove( CBaseEntity::Instance(pentKillTarget) );
ALERT( at_aiconsole, "killing %s\n", STRING( pentKillTarget->v.classname ) );
pentKillTarget = FIND_ENTITY_BY_TARGETNAME( pentKillTarget, STRING(m_iszKillTarget) );
}
}
//
// fire targets
//
if (!FStringNull(pev->target))
{
FireTargets( STRING(pev->target), pActivator, this, useType, value );
}
}
