自学教程：C++ FIND_ENTITY_BY_TARGETNAME函数代码示例

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 entityint 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 playingvoid 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;	}}

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

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

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