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 ); } }