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

//=========================================================// GetSchedule - Decides which type of schedule best suits// the monster's current state and conditions. Then calls// monster's member function to get a pointer to a schedule// of the proper type.//=========================================================Schedule_t *CController :: GetSchedule ( void ){	switch	( m_MonsterState )	{	case MONSTERSTATE_IDLE:		break;	case MONSTERSTATE_ALERT:		break;	case MONSTERSTATE_COMBAT:		{			Vector vecTmp = Intersect( Vector( 0, 0, 0 ), Vector( 100, 4, 7 ), Vector( 2, 10, -3 ), 20.0 );			// dead enemy			if ( HasConditions ( bits_COND_LIGHT_DAMAGE ) )			{				// m_iFrustration++;			}			if ( HasConditions ( bits_COND_HEAVY_DAMAGE ) )			{				// m_iFrustration++;			}		}		break;	}	return CSquadMonster :: GetSchedule();}

//=========================================================// FScheduleValid - returns TRUE as long as the current// schedule is still the proper schedule to be executing,// taking into account all conditions//=========================================================BOOL CBaseMonster :: FScheduleValid ( void ){	if ( m_pSchedule == NULL )	{		// schedule is empty, and therefore not valid.		return FALSE;	}	if ( HasConditions( m_pSchedule->iInterruptMask | bits_COND_SCHEDULE_DONE | bits_COND_TASK_FAILED ) )	{#ifdef DEBUG		if ( HasConditions ( bits_COND_TASK_FAILED ) && m_failSchedule == SCHED_NONE )		{			// fail! Send a visual indicator.			Vector tmp = pev->origin;			tmp.z = pev->absmax.z + 16;			UTIL_Sparks( tmp );		}#endif // DEBUG		// some condition has interrupted the schedule, or the schedule is done		return FALSE;	}		return TRUE;}

//=========================================================// GetSchedule //=========================================================Schedule_t *CHoundeye :: GetSchedule( void ){	switch	( m_MonsterState )	{	case MONSTERSTATE_COMBAT:		{// dead enemy			if ( HasConditions( bits_COND_ENEMY_DEAD ) )			{				// call base class, all code to handle dead enemies is centralized there.				return CBaseMonster :: GetSchedule();			}			if ( HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )			{				if ( RANDOM_FLOAT( 0 , 1 ) <= 0.4 )				{					TraceResult tr;					UTIL_MakeVectors( pev->angles );					UTIL_TraceHull( pev->origin, pev->origin + gpGlobals->v_forward * -128, dont_ignore_monsters, head_hull, ENT( pev ), &tr );					if ( tr.flFraction == 1.0 )					{						// it's clear behind, so the hound will jump						return GetScheduleOfType ( SCHED_HOUND_HOP_RETREAT );					}				}				return GetScheduleOfType ( SCHED_TAKE_COVER_FROM_ENEMY );			}			if ( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )			{				if ( OccupySlot ( bits_SLOTS_HOUND_ATTACK ) )				{					return GetScheduleOfType ( SCHED_RANGE_ATTACK1 );				}				return GetScheduleOfType ( SCHED_HOUND_AGITATED );			}			break;		}	default:		break;	}	return CSquadMonster :: GetSchedule();}

//=========================================================// CheckRangeAttack2 - toss grenade is enemy gets in the way and is too close. //=========================================================BOOL CHAssassin :: CheckRangeAttack2 ( float flDot, float flDist ){	m_fThrowGrenade = FALSE;	if ( !FBitSet ( m_hEnemy->pev->flags, FL_ONGROUND ) )	{		// don't throw grenades at anything that isn't on the ground!		return FALSE;	}	// don't get grenade happy unless the player starts to piss you off	if ( m_iFrustration <= 2)		return FALSE;	if ( m_flNextGrenadeCheck < gpGlobals->time && !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDist <= 512 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */ )	{		Vector vecToss = VecCheckThrow( pev, GetGunPosition( ), m_hEnemy->Center(), flDist, 0.5 ); // use dist as speed to get there in 1 second		if ( vecToss != g_vecZero )		{			m_vecTossVelocity = vecToss;			// throw a hand grenade			m_fThrowGrenade = TRUE;			return TRUE;		}	}	return FALSE;}

//=========================================================// CheckRangeAttack1 //// !!!LATER - we may want to load balance this. Several// tracelines are done, so we may not want to do this every// server frame. Definitely not while firing. //=========================================================BOOL CAGrunt :: CheckRangeAttack1 ( float flDot, float flDist ){	if ( gpGlobals->time < m_flNextHornetAttackCheck )	{		return m_fCanHornetAttack;	}	if ( HasConditions( bits_COND_SEE_ENEMY ) && flDist >= AGRUNT_MELEE_DIST && flDist <= 1024 && flDot >= 0.5 && NoFriendlyFire() )	{		TraceResult	tr;		Vector	vecArmPos, vecArmDir;		// verify that a shot fired from the gun will hit the enemy before the world.		// !!!LATER - we may wish to do something different for projectile weapons as opposed to instant-hit		UTIL_MakeVectors( pev->angles );		GetAttachment( 0, vecArmPos, vecArmDir );//		UTIL_TraceLine( vecArmPos, vecArmPos + gpGlobals->v_forward * 256, ignore_monsters, ENT(pev), &tr);		UTIL_TraceLine( vecArmPos, m_hEnemy->BodyTarget(vecArmPos), dont_ignore_monsters, ENT(pev), &tr);		if ( tr.flFraction == 1.0 || tr.pHit == m_hEnemy->edict() )		{			m_flNextHornetAttackCheck = gpGlobals->time + RANDOM_FLOAT( 2, 5 );			m_fCanHornetAttack = TRUE;			return m_fCanHornetAttack;		}	}		m_flNextHornetAttackCheck = gpGlobals->time + 0.2;// don't check for half second if this check wasn't successful	m_fCanHornetAttack = FALSE;	return m_fCanHornetAttack;}

//=========================================================// GetSchedule - Decides which type of schedule best suits// the monster's current state and conditions. Then calls// monster's member function to get a pointer to a schedule// of the proper type.//=========================================================Schedule_t *CLuciole :: GetSchedule ( void ){	switch	( m_MonsterState )	{	case MONSTERSTATE_IDLE:		break;	case MONSTERSTATE_ALERT:		break;	case MONSTERSTATE_COMBAT:		{			if ( HasConditions(bits_COND_NEW_ENEMY) )	// une seule réorganisation par ennemi			{			//	if ( VARS(m_hEnemy) != VARS(Leader()->m_hEnemy) )				{					ReorganiseSquad ();				}			}/*			if ( gpGlobals->time - m_flLastAttack < ATTACK_DELAY && IsLeader() )				return GetScheduleOfType ( SCHED_TAKE_COVER_FROM_ENEMY );			else*/				return GetScheduleOfType ( SCHED_CHASE_ENEMY );		}		break;	}	return CBaseMonster :: GetSchedule();}

//=========================================================// If there's a player around, watch him.//=========================================================void CTalkMonster :: PrescheduleThink ( void ){	if ( !HasConditions ( bits_COND_SEE_CLIENT ) )	{		SetConditions ( bits_COND_CLIENT_UNSEEN );	}}

//=========================================================// CheckMeleeAttack1 - alien grunts zap the crap out of // any enemy that gets too close. //=========================================================BOOL CAGrunt :: CheckMeleeAttack1 ( float flDot, float flDist ){	if ( HasConditions ( bits_COND_SEE_ENEMY ) && flDist <= AGRUNT_MELEE_DIST && flDot >= 0.6 && m_hEnemy != NULL )	{		return TRUE;	}	return FALSE;}

//=========================================================// CheckMeleeAttack2 - bullsquid is a big guy, so has a longer// melee range than most monsters. This is the bite attack.// this attack will not be performed if the tailwhip attack// is valid.//=========================================================BOOL CBullsquid :: CheckMeleeAttack2 ( float flDot, float flDist ){	if ( flDist <= 85 && flDot >= 0.7 && !HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )		// The player & bullsquid can be as much as their bboxes	{										// apart (48 * sqrt(3)) and he can still attack (85 is a little more than 48*sqrt(3))		return TRUE;	}	return FALSE;}

//=========================================================//=========================================================Schedule_t* CAGrunt :: GetScheduleOfType ( int Type ) {	switch	( Type )	{	case SCHED_TAKE_COVER_FROM_ENEMY:		return &slAGruntTakeCoverFromEnemy[ 0 ];		break;		case SCHED_RANGE_ATTACK1:		if ( HasConditions( bits_COND_SEE_ENEMY ) )		{			//normal attack			return &slAGruntRangeAttack1[ 0 ];		}		else		{			// attack an unseen enemy			// return &slAGruntHiddenRangeAttack[ 0 ];			return &slAGruntRangeAttack1[ 0 ];		}		break;	case SCHED_AGRUNT_THREAT_DISPLAY:		return &slAGruntThreatDisplay[ 0 ];		break;	case SCHED_AGRUNT_SUPPRESS:		return &slAGruntSuppress[ 0 ];		break;	case SCHED_STANDOFF:		return &slAGruntStandoff[ 0 ];		break;	case SCHED_VICTORY_DANCE:		return &slAGruntVictoryDance[ 0 ];		break;	case SCHED_FAIL:		// no fail schedule specified, so pick a good generic one.		{			if ( m_hEnemy != NULL )			{				// I have an enemy				// !!!LATER - what if this enemy is really far away and i'm chasing him?				// this schedule will make me stop, face his last known position for 2 				// seconds, and then try to move again				return &slAGruntCombatFail[ 0 ];			}			return &slAGruntFail[ 0 ];		}		break;	}	return CSquadMonster :: GetScheduleOfType( Type );}

//=========================================================// FCanCheckAttacks - this is overridden for alien grunts// because they can use their smart weapons against unseen// enemies. Base class doesn't attack anyone it can't see.//=========================================================BOOL CAGrunt :: FCanCheckAttacks ( void ){	if ( !HasConditions( bits_COND_ENEMY_TOOFAR ) )	{		return TRUE;	}	else	{		return FALSE;	}}

void CGargantua :: PrescheduleThink( void ){	if ( !HasConditions( bits_COND_SEE_ENEMY ) )	{		m_seeTime = gpGlobals->time + 5;		EyeOff();	}	else		EyeOn( 200 );		EyeUpdate();}

//=========================================================// GetSchedule - Decides which type of schedule best suits// the monster's current state and conditions. Then calls// monster's member function to get a pointer to a schedule// of the proper type.//=========================================================Schedule_t *CAGrunt :: GetSchedule ( void ){	if ( HasConditions(bits_COND_HEAR_SOUND) )	{		CSound *pSound;		pSound = PBestSound();		ASSERT( pSound != NULL );		if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )		{			// dangerous sound nearby!			return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );		}	}	switch	( m_MonsterState )	{	case MONSTERSTATE_COMBAT:		{// dead enemy			if ( HasConditions( bits_COND_ENEMY_DEAD ) )			{				// call base class, all code to handle dead enemies is centralized there.				return CBaseMonster :: GetSchedule();			}			if ( HasConditions(bits_COND_NEW_ENEMY) )			{				return GetScheduleOfType( SCHED_WAKE_ANGRY );			}	// zap player!			if ( HasConditions ( bits_COND_CAN_MELEE_ATTACK1 ) )			{				AttackSound();// this is a total hack. Should be parto f the schedule				return GetScheduleOfType ( SCHED_MELEE_ATTACK1 );			}			if ( HasConditions ( bits_COND_HEAVY_DAMAGE ) )			{				return GetScheduleOfType( SCHED_SMALL_FLINCH );			}	// can attack			if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) && OccupySlot ( bits_SLOTS_AGRUNT_HORNET ) )			{				return GetScheduleOfType ( SCHED_RANGE_ATTACK1 );			}			if ( OccupySlot ( bits_SLOT_AGRUNT_CHASE ) )			{				return GetScheduleOfType ( SCHED_CHASE_ENEMY );			}			return GetScheduleOfType ( SCHED_STANDOFF );		}	}	return CSquadMonster :: GetSchedule();}

//=========================================================// GetSchedule//=========================================================Schedule_t* CIchthyosaur::GetSchedule(){	// ALERT( at_console, "GetSchedule( )/n" );	switch(m_MonsterState)	{	case MONSTERSTATE_IDLE:		m_flightSpeed = 80;		return GetScheduleOfType( SCHED_IDLE_WALK );	case MONSTERSTATE_ALERT:		m_flightSpeed = 150;		return GetScheduleOfType( SCHED_IDLE_WALK );	case MONSTERSTATE_COMBAT:		m_flMaxSpeed = 400;		// eat them		if ( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )		{			return GetScheduleOfType( SCHED_MELEE_ATTACK1 );		}		// chase them down and eat them		if ( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )		{			return GetScheduleOfType( SCHED_CHASE_ENEMY );		}		if ( HasConditions( bits_COND_HEAVY_DAMAGE ) )		{			m_bOnAttack = TRUE;		}		if ( pev->health < pev->max_health - 20 )		{			m_bOnAttack = TRUE;		}		return GetScheduleOfType( SCHED_STANDOFF );	}	return CFlyingMonster :: GetSchedule();}

//=========================================================//=========================================================Schedule_t *CISlave :: GetSchedule( void ){	ClearBeams( );/*	if (pev->spawnflags)	{		pev->spawnflags = 0;		return GetScheduleOfType( SCHED_RELOAD );	}*/	if ( HasConditions( bits_COND_HEAR_SOUND ) )	{		CSound *pSound;		pSound = PBestSound();		ASSERT( pSound != NULL );		if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )			return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );		if ( pSound->m_iType & bits_SOUND_COMBAT )			m_afMemory |= bits_MEMORY_PROVOKED;	}	switch (m_MonsterState)	{	case MONSTERSTATE_COMBAT:// dead enemy		if ( HasConditions( bits_COND_ENEMY_DEAD ) )		{			// call base class, all code to handle dead enemies is centralized there.			return CBaseMonster :: GetSchedule();		}		if (pev->health < 20 || m_iBravery < 0)		{			if (!HasConditions( bits_COND_CAN_MELEE_ATTACK1 ))			{				m_failSchedule = SCHED_CHASE_ENEMY;				if (HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE))				{					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );				}				if ( HasConditions ( bits_COND_SEE_ENEMY ) && HasConditions ( bits_COND_ENEMY_FACING_ME ) )				{					// ALERT( at_console, "exposed/n");					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );				}			}		}		break;	default:		break;	}	return CSquadMonster::GetSchedule( );}

Schedule_t *CISlave :: GetScheduleOfType ( int Type ) {	switch	( Type )	{	case SCHED_FAIL:		if (HasConditions( bits_COND_CAN_MELEE_ATTACK1 ))		{			return CSquadMonster :: GetScheduleOfType( SCHED_MELEE_ATTACK1 ); ;		}		break;	case SCHED_RANGE_ATTACK1:		return slSlaveAttack1;	case SCHED_RANGE_ATTACK2:		return slSlaveAttack1;	}	return CSquadMonster :: GetScheduleOfType( Type );}

//=========================================================// CheckRangeAttack1  - drop a cap in their ass////=========================================================BOOL CHAssassin :: CheckRangeAttack1 ( float flDot, float flDist ){	if ( !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDist > 64 && flDist <= 2048 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */ )	{		TraceResult	tr;		Vector vecSrc = GetGunPosition();		// verify that a bullet fired from the gun will hit the enemy before the world.		UTIL_TraceLine( vecSrc, m_hEnemy->BodyTarget(vecSrc), dont_ignore_monsters, ENT(pev), &tr);		if ( tr.flFraction == 1 || tr.pHit == m_hEnemy->edict() )		{			return TRUE;		}	}	return FALSE;}

// try to smell somethingvoid CTalkMonster :: TrySmellTalk( void ){	if ( !FOkToSpeak() )		return;	// clear smell bits periodically	if ( gpGlobals->time > m_flLastSaidSmelled  )	{//		ALERT ( at_aiconsole, "Clear smell bits/n" );		ClearBits(m_bitsSaid, bit_saidSmelled);	}	// smelled something?	if (!FBitSet(m_bitsSaid, bit_saidSmelled) && HasConditions ( bits_COND_SMELL ))	{		PlaySentence( m_szGrp[TLK_SMELL], RANDOM_FLOAT(2.8, 3.2), VOL_NORM, ATTN_IDLE );		m_flLastSaidSmelled = gpGlobals->time + 60;// don't talk about the stinky for a while.		SetBits(m_bitsSaid, bit_saidSmelled);	}}

//=========================================================// GetIdealState - surveys the Conditions information available// and finds the best new state for a monster.//=========================================================MONSTERSTATE CSquadMonster :: GetIdealState ( void ){    int	iConditions;    iConditions = IScheduleFlags();    // If no schedule conditions, the new ideal state is probably the reason we're in here.    switch ( m_MonsterState )    {    case MONSTERSTATE_IDLE:    case MONSTERSTATE_ALERT:        if ( HasConditions ( bits_COND_NEW_ENEMY ) && InSquad() )        {            SquadMakeEnemy ( m_hEnemy );        }        break;    }    return CBaseMonster :: GetIdealState();}

//=========================================================// RunTask //=========================================================void CHAssassin :: RunTask ( Task_t *pTask ){	switch ( pTask->iTask )	{	case TASK_ASSASSIN_FALL_TO_GROUND:		MakeIdealYaw( m_vecEnemyLKP );		ChangeYaw( pev->yaw_speed );		if (m_fSequenceFinished)		{			if (pev->velocity.z > 0)			{				pev->sequence = LookupSequence( "fly_up" );			}			else if (HasConditions ( bits_COND_SEE_ENEMY ))			{				pev->sequence = LookupSequence( "fly_attack" );				pev->frame = 0;			}			else			{				pev->sequence = LookupSequence( "fly_down" );				pev->frame = 0;			}						ResetSequenceInfo( );			SetYawSpeed();		}		if (pev->flags & FL_ONGROUND)		{			// ALERT( at_console, "on ground/n");			TaskComplete( );		}		break;	default: 		CBaseMonster :: RunTask ( pTask );		break;	}}

//=========================================================// HandleAnimEvent - catches the monster-specific messages// that occur when tagged animation frames are played.//// Returns number of events handled, 0 if none.//=========================================================void CAGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent ){	switch( pEvent->event )	{	case AGRUNT_AE_HORNET1:	case AGRUNT_AE_HORNET2:	case AGRUNT_AE_HORNET3:	case AGRUNT_AE_HORNET4:	case AGRUNT_AE_HORNET5:		{			// m_vecEnemyLKP should be center of enemy body			Vector vecArmPos, vecArmDir;			Vector vecDirToEnemy;			Vector angDir;			if (HasConditions( bits_COND_SEE_ENEMY))			{				vecDirToEnemy = ( ( m_vecEnemyLKP ) - pev->origin );				angDir = UTIL_VecToAngles( vecDirToEnemy );				vecDirToEnemy = vecDirToEnemy.Normalize();			}			else			{				angDir = pev->angles;				UTIL_MakeAimVectors( angDir );				vecDirToEnemy = gpGlobals->v_forward;			}			pev->effects = EF_MUZZLEFLASH;			// make angles +-180			if (angDir.x > 180)			{				angDir.x = angDir.x - 360;			}			SetBlending( 0, angDir.x );			GetAttachment( 0, vecArmPos, vecArmDir );			vecArmPos = vecArmPos + vecDirToEnemy * 32;			MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecArmPos );				WRITE_BYTE( TE_SPRITE );				WRITE_COORD( vecArmPos.x );	// pos				WRITE_COORD( vecArmPos.y );					WRITE_COORD( vecArmPos.z );					WRITE_SHORT( iAgruntMuzzleFlash );		// model				WRITE_BYTE( 6 );				// size * 10				WRITE_BYTE( 128 );			// brightness			MESSAGE_END();			CBaseEntity *pHornet = CBaseEntity::Create( "hornet", vecArmPos, UTIL_VecToAngles( vecDirToEnemy ), edict() );			UTIL_MakeVectors ( pHornet->pev->angles );			pHornet->pev->velocity = gpGlobals->v_forward * 300;												switch ( RANDOM_LONG ( 0 , 2 ) )			{				case 0:	EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, "agrunt/ag_fire1.wav", 1.0, ATTN_NORM, 0, 100 );	break;				case 1:	EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, "agrunt/ag_fire2.wav", 1.0, ATTN_NORM, 0, 100 );	break;				case 2:	EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, "agrunt/ag_fire3.wav", 1.0, ATTN_NORM, 0, 100 );	break;			}			CBaseMonster *pHornetMonster = pHornet->MyMonsterPointer();			if ( pHornetMonster )			{				pHornetMonster->m_hEnemy = m_hEnemy;			}		}		break;	case AGRUNT_AE_LEFT_FOOT:		switch (RANDOM_LONG(0,1))		{		// left foot		case 0:	EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder2.wav", 1, ATTN_NORM, 0, 70 );	break;		case 1:	EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder4.wav", 1, ATTN_NORM, 0, 70 );	break;		}		break;	case AGRUNT_AE_RIGHT_FOOT:		// right foot		switch (RANDOM_LONG(0,1))		{		case 0:	EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder1.wav", 1, ATTN_NORM, 0, 70 );	break;		case 1:	EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder3.wav", 1, ATTN_NORM, 0 ,70);	break;		}		break;	case AGRUNT_AE_LEFT_PUNCH:		{			CBaseEntity *pHurt = CheckTraceHullAttack( AGRUNT_MELEE_DIST, gSkillData.agruntDmgPunch, DMG_CLUB );						if ( pHurt )//.........这里部分代码省略.........

//.........这里部分代码省略.........		if (pInflictor)		{			vecDir = ( pInflictor->Center() - Vector ( 0, 0, 10 ) - Center() ).Normalize();			vecDir = g_vecAttackDir = vecDir.Normalize();		}	}	// add to the damage total for clients, which will be sent as a single	// message at the end of the frame	// todo: remove after combining shotgun blasts?	if ( IsPlayer() )	{		if ( pevInflictor )			pev->dmg_inflictor = ENT(pevInflictor);		pev->dmg_take += flTake;		// check for godmode or invincibility		if ( pev->flags & FL_GODMODE )		{			return 0;		}	}	// if this is a player, move him around!	if ( ( !FNullEnt( pevInflictor ) ) && (pev->movetype == MOVETYPE_WALK) && (!pevAttacker || pevAttacker->solid != SOLID_TRIGGER) )	{		pev->velocity = pev->velocity + vecDir * -DamageForce( flDamage );	}	// do the damage	pev->health -= flTake;	// HACKHACK Don't kill monsters in a script.  Let them break their scripts first	if ( m_MonsterState == MONSTERSTATE_SCRIPT )	{		SetConditions( bits_COND_LIGHT_DAMAGE );		return 0;	}	if ( pev->health <= 0 )	{		g_pevLastInflictor = pevInflictor;		if ( bitsDamageType & DMG_ALWAYSGIB )		{			Killed( pevAttacker, GIB_ALWAYS );		}		else if ( bitsDamageType & DMG_NEVERGIB )		{			Killed( pevAttacker, GIB_NEVER );		}		else		{			Killed( pevAttacker, GIB_NORMAL );		}		g_pevLastInflictor = NULL;		return 0;	}	// react to the damage (get mad)	if ( (pev->flags & FL_MONSTER) && !FNullEnt(pevAttacker) )	{		if ( pevAttacker->flags & (FL_MONSTER | FL_CLIENT) )		{// only if the attack was a monster or client!						// enemy's last known position is somewhere down the vector that the attack came from.			if (pevInflictor)			{				if (m_hEnemy == NULL || pevInflictor == m_hEnemy->pev || !HasConditions(bits_COND_SEE_ENEMY))				{					m_vecEnemyLKP = pevInflictor->origin;				}			}			else			{				m_vecEnemyLKP = pev->origin + ( g_vecAttackDir * 64 ); 			}			MakeIdealYaw( m_vecEnemyLKP );			// add pain to the conditions 			// !!!HACKHACK - fudged for now. Do we want to have a virtual function to determine what is light and 			// heavy damage per monster class?			if ( flDamage > 0 )			{				SetConditions(bits_COND_LIGHT_DAMAGE);			}			if ( flDamage >= 20 )			{				SetConditions(bits_COND_HEAVY_DAMAGE);			}		}	}	return 1;}

//// TentacleThink//void CTentacle :: Cycle( void ){	// ALERT( at_console, "%s %.2f %d %d/n", STRING( pev->targetname ), pev->origin.z, m_MonsterState, m_IdealMonsterState );	pev->nextthink = gpGlobals-> time + 0.1;	// ALERT( at_console, "%s %d %d %d %f %f/n", STRING( pev->targetname ), pev->sequence, m_iGoalAnim, m_iDir, pev->framerate, pev->health );	if (m_MonsterState == MONSTERSTATE_SCRIPT || m_IdealMonsterState == MONSTERSTATE_SCRIPT)	{		pev->angles.y = m_flInitialYaw;		pev->ideal_yaw = m_flInitialYaw;			ClearConditions( IgnoreConditions() );		MonsterThink( );		m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;		return;	}	DispatchAnimEvents( );	StudioFrameAdvance( );	ChangeYaw( pev->yaw_speed );	CSound *pSound;	Listen( );	// Listen will set this if there's something in my sound list	if ( HasConditions( bits_COND_HEAR_SOUND ) )		pSound = PBestSound();	else		pSound = NULL;	if ( pSound )	{		Vector vecDir;		if (gpGlobals->time - m_flPrevSoundTime < 0.5)		{			float dt = gpGlobals->time - m_flPrevSoundTime;			vecDir = pSound->m_vecOrigin + (pSound->m_vecOrigin - m_vecPrevSound) / dt - pev->origin;		}		else		{			vecDir = pSound->m_vecOrigin - pev->origin;		}		m_flPrevSoundTime = gpGlobals->time;		m_vecPrevSound = pSound->m_vecOrigin;		m_flSoundYaw = UTIL_VecToYaw ( vecDir ) - m_flInitialYaw;		m_iSoundLevel = Level( vecDir.z );		if (m_flSoundYaw < -180)			m_flSoundYaw += 360;		if (m_flSoundYaw > 180)			m_flSoundYaw -= 360;		// ALERT( at_console, "sound %d %.0f/n", m_iSoundLevel, m_flSoundYaw );		if (m_flSoundTime < gpGlobals->time)		{			// play "I hear new something" sound			char *sound;				switch( RANDOM_LONG(0,1) )			{			case 0: sound = "tentacle/te_alert1.wav"; break;			case 1: sound = "tentacle/te_alert2.wav"; break;			}			// UTIL_EmitAmbientSound(ENT(pev), pev->origin + Vector( 0, 0, MyHeight()), sound, 1.0, ATTN_NORM, 0, 100);		}		m_flSoundTime = gpGlobals->time + RANDOM_FLOAT( 5.0, 10.0 );	}	// clip ideal_yaw	float dy = m_flSoundYaw;	switch( pev->sequence )	{	case TENTACLE_ANIM_Floor_Rear:	case TENTACLE_ANIM_Floor_Rear_Idle:	case TENTACLE_ANIM_Lev1_Rear:	case TENTACLE_ANIM_Lev1_Rear_Idle:	case TENTACLE_ANIM_Lev2_Rear:	case TENTACLE_ANIM_Lev2_Rear_Idle:	case TENTACLE_ANIM_Lev3_Rear:	case TENTACLE_ANIM_Lev3_Rear_Idle:		if (dy < 0 && dy > -m_flMaxYaw)			dy = -m_flMaxYaw;		if (dy > 0 && dy < m_flMaxYaw)			dy = m_flMaxYaw;		break;	default:		if (dy < -m_flMaxYaw)			dy = -m_flMaxYaw;		if (dy > m_flMaxYaw)			dy = m_flMaxYaw;	}	pev->ideal_yaw = m_flInitialYaw + dy;//.........这里部分代码省略.........

//=========================================================// GetScheduleOfType //=========================================================Schedule_t* CHoundeye :: GetScheduleOfType ( int Type ) {	if ( m_fAsleep )	{		// if the hound is sleeping, must wake and stand!		if ( HasConditions( bits_COND_HEAR_SOUND ) )		{			CSound *pWakeSound;			pWakeSound = PBestSound();			ASSERT( pWakeSound != NULL );			if ( pWakeSound )			{				MakeIdealYaw ( pWakeSound->m_vecOrigin );				if ( FLSoundVolume ( pWakeSound ) >= HOUNDEYE_SOUND_STARTLE_VOLUME )				{					// awakened by a loud sound					return &slHoundWakeUrgent[ 0 ];				}			}			// sound was not loud enough to scare the bejesus out of houndeye			return &slHoundWakeLazy[ 0 ];		}		else if ( HasConditions( bits_COND_NEW_ENEMY ) )		{			// get up fast, to fight.			return &slHoundWakeUrgent[ 0 ];		}		else		{			// hound is waking up on its own			return &slHoundWakeLazy[ 0 ];		}	}	switch	( Type )	{	case SCHED_IDLE_STAND:		{			// we may want to sleep instead of stand!			if ( InSquad() && !IsLeader() && !m_fAsleep && RANDOM_LONG(0,29) < 1 )			{				return &slHoundSleep[ 0 ];			}			else			{				return CSquadMonster :: GetScheduleOfType( Type );			}		}	case SCHED_RANGE_ATTACK1:		{			return &slHoundRangeAttack[ 0 ];/*			if ( InSquad() )			{				return &slHoundRangeAttack[ RANDOM_LONG( 0, 1 ) ];			}			return &slHoundRangeAttack[ 1 ];*/		}	case SCHED_SPECIAL_ATTACK1:		{			return &slHoundSpecialAttack1[ 0 ];		}	case SCHED_GUARD:		{			return &slHoundGuardPack[ 0 ];		}	case SCHED_HOUND_AGITATED:		{			return &slHoundAgitated[ 0 ];		}	case SCHED_HOUND_HOP_RETREAT:		{			return &slHoundHopRetreat[ 0 ];		}	case SCHED_FAIL:		{			if ( m_MonsterState == MONSTERSTATE_COMBAT )			{				if ( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )				{					// client in PVS					return &slHoundCombatFailPVS[ 0 ];				}				else				{					// client has taken off! 					return &slHoundCombatFailNoPVS[ 0 ];				}			}			else			{				return CSquadMonster :: GetScheduleOfType ( Type );			}//.........这里部分代码省略.........

Schedule_t* CTalkMonster :: GetScheduleOfType ( int Type ){	switch( Type )	{	case SCHED_MOVE_AWAY:		return slMoveAway;	case SCHED_MOVE_AWAY_FOLLOW:		return slMoveAwayFollow;	case SCHED_MOVE_AWAY_FAIL:		return slMoveAwayFail;	case SCHED_TARGET_FACE:		// speak during 'use'		if (RANDOM_LONG(0,99) < 2)			//ALERT ( at_console, "target chase speak/n" );			return slIdleSpeakWait;		else			return slIdleStand;			case SCHED_IDLE_STAND:		{				// if never seen player, try to greet him			if (!FBitSet(m_bitsSaid, bit_saidHelloPlayer))			{				return slIdleHello;			}			// sustained light wounds?			if (!FBitSet(m_bitsSaid, bit_saidWoundLight) && ( GetHealth() <= ( GetMaxHealth() * 0.75)))			{				//SENTENCEG_PlayRndSz( this, m_szGrp[TLK_WOUND], 1.0, ATTN_IDLE, 0, GetVoicePitch() );				//CTalkMonster::g_talkWaitTime = gpGlobals->time + RANDOM_FLOAT(2.8, 3.2);				PlaySentence( m_szGrp[TLK_WOUND], RANDOM_FLOAT(2.8, 3.2), VOL_NORM, ATTN_IDLE );				SetBits(m_bitsSaid, bit_saidWoundLight);				return slIdleStand;			}			// sustained heavy wounds?			else if (!FBitSet(m_bitsSaid, bit_saidWoundHeavy) && ( GetHealth() <= ( GetMaxHealth() * 0.5)))			{				//SENTENCEG_PlayRndSz( this, m_szGrp[TLK_MORTAL], 1.0, ATTN_IDLE, 0, GetVoicePitch() );				//CTalkMonster::g_talkWaitTime = gpGlobals->time + RANDOM_FLOAT(2.8, 3.2);				PlaySentence( m_szGrp[TLK_MORTAL], RANDOM_FLOAT(2.8, 3.2), VOL_NORM, ATTN_IDLE );				SetBits(m_bitsSaid, bit_saidWoundHeavy);				return slIdleStand;			}			// talk about world			if (FOkToSpeak() && RANDOM_LONG(0,m_nSpeak * 2) == 0)			{				//ALERT ( at_console, "standing idle speak/n" );				return slIdleSpeak;			}						if ( !IsTalking() && HasConditions ( bits_COND_SEE_CLIENT ) && RANDOM_LONG( 0, 6 ) == 0 )			{				edict_t *pPlayer = g_engfuncs.pfnPEntityOfEntIndex( 1 );				if ( pPlayer )				{					// watch the client.					UTIL_MakeVectors ( pPlayer->v.angles );					if ( ( pPlayer->v.origin - GetAbsOrigin() ).Length2D() < TLK_STARE_DIST	&& 						 UTIL_DotPoints( pPlayer->v.origin, GetAbsOrigin(), gpGlobals->v_forward ) >= m_flFieldOfView )					{						// go into the special STARE schedule if the player is close, and looking at me too.						return &slTlkIdleWatchClient[ 1 ];					}					return slTlkIdleWatchClient;				}			}			else			{				if (IsTalking())					// look at who we're talking to					return slTlkIdleEyecontact;				else					// regular standing idle					return slIdleStand;			}			// NOTE - caller must first CTalkMonster::GetScheduleOfType, 			// then check result and decide what to return ie: if sci gets back			// slIdleStand, return slIdleSciStand		}		break;	}	return CBaseMonster::GetScheduleOfType( Type );}

//=========================================================// RunTask //=========================================================void CController :: RunTask ( Task_t *pTask ){	if (m_flShootEnd > gpGlobals->time)	{		Vector vecHand, vecAngle;				GetAttachment( 2, vecHand, vecAngle );			while (m_flShootTime < m_flShootEnd && m_flShootTime < gpGlobals->time)		{			Vector vecSrc = vecHand + pev->velocity * (m_flShootTime - gpGlobals->time);			Vector vecDir;						if (m_pCine != NULL || m_hEnemy != NULL)			{				if (m_pCine != NULL) // LRC- is this a script that's telling it to fire?				{					if (m_hTargetEnt != NULL && m_pCine->PreciseAttack())					{						vecDir = (m_hTargetEnt->pev->origin - pev->origin).Normalize() * gSkillData.controllerSpeedBall;					}					else					{						UTIL_MakeVectors(pev->angles);						vecDir = gpGlobals->v_forward * gSkillData.controllerSpeedBall;					}				}				else if (m_hEnemy != NULL)				{					if (HasConditions( bits_COND_SEE_ENEMY ))					{						m_vecEstVelocity = m_vecEstVelocity * 0.5 + m_hEnemy->pev->velocity * 0.5;					}					else					{						m_vecEstVelocity = m_vecEstVelocity * 0.8;					}					vecDir = Intersect( vecSrc, m_hEnemy->BodyTarget( pev->origin ), m_vecEstVelocity, gSkillData.controllerSpeedBall );				}				float delta = 0.03490; // +-2 degree				vecDir = vecDir + Vector( RANDOM_FLOAT( -delta, delta ), RANDOM_FLOAT( -delta, delta ), RANDOM_FLOAT( -delta, delta ) ) * gSkillData.controllerSpeedBall;				vecSrc = vecSrc + vecDir * (gpGlobals->time - m_flShootTime);				CBaseMonster *pBall = (CBaseMonster*)Create( "controller_energy_ball", vecSrc, pev->angles, edict() );				pBall->pev->velocity = vecDir;			}			m_flShootTime += 0.2;		}		if (m_flShootTime > m_flShootEnd)		{			m_iBall[0] = 64;			m_iBallTime[0] = m_flShootEnd;			m_iBall[1] = 64;			m_iBallTime[1] = m_flShootEnd;			m_fInCombat = FALSE;		}	}	switch ( pTask->iTask )	{	case TASK_WAIT_FOR_MOVEMENT:	case TASK_WAIT:	case TASK_WAIT_FACE_ENEMY:	case TASK_WAIT_PVS:		MakeIdealYaw( m_vecEnemyLKP );		ChangeYaw( pev->yaw_speed );		if (m_fSequenceFinished)		{			m_fInCombat = FALSE;		}		CSquadMonster :: RunTask ( pTask );		if (!m_fInCombat)		{			if (HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ))			{				pev->sequence = LookupActivity( ACT_RANGE_ATTACK1 );				pev->frame = 0;				ResetSequenceInfo( );				m_fInCombat = TRUE;			}			else if (HasConditions ( bits_COND_CAN_RANGE_ATTACK2 ))			{				pev->sequence = LookupActivity( ACT_RANGE_ATTACK2 );				pev->frame = 0;				ResetSequenceInfo( );				m_fInCombat = TRUE;			}			else			{				int iFloat = LookupFloat( );				if (m_fSequenceFinished || iFloat != pev->sequence)//.........这里部分代码省略.........

//=========================================================// MaintainSchedule - does all the per-think schedule maintenance.// ensures that the monster leaves this function with a valid// schedule!//=========================================================void CBaseMonster :: MaintainSchedule ( void ){	Schedule_t	*pNewSchedule;	int			i;	// UNDONE: Tune/fix this 10... This is just here so infinite loops are impossible	for ( i = 0; i < 10; i++ )	{		if ( m_pSchedule != NULL && TaskIsComplete() )		{			NextScheduledTask();                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   		}	// validate existing schedule 		if ( !FScheduleValid() || m_MonsterState != m_IdealMonsterState )		{			// if we come into this block of code, the schedule is going to have to be changed.			// if the previous schedule was interrupted by a condition, GetIdealState will be 			// called. Else, a schedule finished normally.			// Notify the monster that his schedule is changing			ScheduleChange();			// Call GetIdealState if we're not dead and one or more of the following...			// - in COMBAT state with no enemy (it died?)			// - conditions bits (excluding SCHEDULE_DONE) indicate interruption,			// - schedule is done but schedule indicates it wants GetIdealState called			//   after successful completion (by setting bits_COND_SCHEDULE_DONE in iInterruptMask)			// DEAD & SCRIPT are not suggestions, they are commands!			if ( m_IdealMonsterState != MONSTERSTATE_DEAD && 				 (m_IdealMonsterState != MONSTERSTATE_SCRIPT || m_IdealMonsterState == m_MonsterState) )			{				// if we're here, then either we're being told to do something (besides dying or playing a script)				// or our current schedule (besides dying) is invalid. -- LRC				if (	(m_afConditions && !HasConditions(bits_COND_SCHEDULE_DONE)) ||						(m_pSchedule && (m_pSchedule->iInterruptMask & bits_COND_SCHEDULE_DONE)) ||						((m_MonsterState == MONSTERSTATE_COMBAT) && (m_hEnemy == NULL))	)				{					GetIdealState();				}			}			if ( HasConditions( bits_COND_TASK_FAILED ) && m_MonsterState == m_IdealMonsterState )			{				if ( m_failSchedule != SCHED_NONE )					pNewSchedule = GetScheduleOfType( m_failSchedule );				else					pNewSchedule = GetScheduleOfType( SCHED_FAIL );				// schedule was invalid because the current task failed to start or complete				ALERT ( at_aiconsole, "Schedule Failed at %d!/n", m_iScheduleIndex );				ChangeSchedule( pNewSchedule );			}			else			{				SetState( m_IdealMonsterState );				if ( m_MonsterState == MONSTERSTATE_SCRIPT || m_MonsterState == MONSTERSTATE_DEAD )				{					pNewSchedule = CBaseMonster::GetSchedule();				}				else					pNewSchedule = GetSchedule();				ChangeSchedule( pNewSchedule );			}		}		if ( m_iTaskStatus == TASKSTATUS_NEW )		{				Task_t *pTask = GetTask();			ASSERT( pTask != NULL );			TaskBegin();			StartTask( pTask );		}		// UNDONE: Twice?!!!		if ( m_Activity != m_IdealActivity )		{			SetActivity ( m_IdealActivity );		}				if ( !TaskIsComplete() && m_iTaskStatus != TASKSTATUS_NEW )			break;	}	if ( TaskIsRunning() )	{		Task_t *pTask = GetTask();		ASSERT( pTask != NULL );		RunTask( pTask );	}	// UNDONE: We have to do this so that we have an animation set to blend to if RunTask changes the animation	// RunTask() will always change animations at the end of a script!	// Don't do this twice	if ( m_Activity != m_IdealActivity )	{		SetActivity ( m_IdealActivity );//.........这里部分代码省略.........

//=========================================================// GetSchedule - Decides which type of schedule best suits// the monster's current state and conditions. Then calls// monster's member function to get a pointer to a schedule// of the proper type.//=========================================================Schedule_t *CHAssassin :: GetSchedule ( void ){	switch	( m_MonsterState )	{	case MONSTERSTATE_IDLE:	case MONSTERSTATE_ALERT:		{			if ( HasConditions ( bits_COND_HEAR_SOUND ))			{				CSound *pSound;				pSound = PBestSound();				ASSERT( pSound != NULL );				if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )				{					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );				}				if ( pSound && (pSound->m_iType & bits_SOUND_COMBAT) )				{					return GetScheduleOfType( SCHED_INVESTIGATE_SOUND );				}			}		}		break;	case MONSTERSTATE_COMBAT:		{// dead enemy			if ( HasConditions( bits_COND_ENEMY_DEAD ) )			{				// call base class, all code to handle dead enemies is centralized there.				return CBaseMonster :: GetSchedule();			}			// flying?			if ( pev->movetype == MOVETYPE_TOSS)			{				if (pev->flags & FL_ONGROUND)				{					// ALERT( at_console, "landed/n");					// just landed					pev->movetype = MOVETYPE_STEP;					return GetScheduleOfType ( SCHED_ASSASSIN_JUMP_LAND );				}				else				{					// ALERT( at_console, "jump/n");					// jump or jump/shoot					if ( m_MonsterState == MONSTERSTATE_COMBAT )						return GetScheduleOfType ( SCHED_ASSASSIN_JUMP );					else						return GetScheduleOfType ( SCHED_ASSASSIN_JUMP_ATTACK );				}			}			if ( HasConditions ( bits_COND_HEAR_SOUND ))			{				CSound *pSound;				pSound = PBestSound();				ASSERT( pSound != NULL );				if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )				{					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );				}			}			if ( HasConditions ( bits_COND_LIGHT_DAMAGE ) )			{				m_iFrustration++;			}			if ( HasConditions ( bits_COND_HEAVY_DAMAGE ) )			{				m_iFrustration++;			}		// jump player!			if ( HasConditions ( bits_COND_CAN_MELEE_ATTACK1 ) )			{				// ALERT( at_console, "melee attack 1/n");				return GetScheduleOfType ( SCHED_MELEE_ATTACK1 );			}		// throw grenade			if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK2 ) )			{				// ALERT( at_console, "range attack 2/n");				return GetScheduleOfType ( SCHED_RANGE_ATTACK2 );			}		// spotted			if ( HasConditions ( bits_COND_SEE_ENEMY ) && HasConditions ( bits_COND_ENEMY_FACING_ME ) )			{				// ALERT( at_console, "exposed/n");//.........这里部分代码省略.........

//=========================================================// GetSchedule - Decides which type of schedule best suits// the monster's current state and conditions. Then calls// monster's member function to get a pointer to a schedule// of the proper type.//=========================================================Schedule_t *CBaseMonster :: GetSchedule ( void ){	switch	( m_MonsterState )	{	case MONSTERSTATE_PRONE:		{			return GetScheduleOfType( SCHED_BARNACLE_VICTIM_GRAB );			break;		}	case MONSTERSTATE_NONE:		{			ALERT ( at_aiconsole, "MONSTERSTATE IS NONE!/n" );			break;		}	case MONSTERSTATE_IDLE:		{			if ( HasConditions ( bits_COND_HEAR_SOUND ) )			{				return GetScheduleOfType( SCHED_ALERT_FACE );			}			else if ( FRouteClear() )			{				// no valid route!				return GetScheduleOfType( SCHED_IDLE_STAND );			}			else			{				// valid route. Get moving				return GetScheduleOfType( SCHED_IDLE_WALK );			}			break;		}	case MONSTERSTATE_ALERT:		{			if ( HasConditions( bits_COND_ENEMY_DEAD ) && LookupActivity( ACT_VICTORY_DANCE ) != ACTIVITY_NOT_AVAILABLE )			{				return GetScheduleOfType ( SCHED_VICTORY_DANCE );			}			if ( HasConditions(bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE) )			{				if ( fabs( FlYawDiff() ) < (1.0 - m_flFieldOfView) * 60 ) // roughly in the correct direction				{					return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ORIGIN );				}				else				{					return GetScheduleOfType( SCHED_ALERT_SMALL_FLINCH );				}			}			else if ( HasConditions ( bits_COND_HEAR_SOUND ) )			{				return GetScheduleOfType( SCHED_ALERT_FACE );			}			else			{				return GetScheduleOfType( SCHED_ALERT_STAND );			}			break;		}	case MONSTERSTATE_COMBAT:		{			if ( HasConditions( bits_COND_ENEMY_DEAD ) )			{				// clear the current (dead) enemy and try to find another.				m_hEnemy = NULL;				if ( GetEnemy() )				{					ClearConditions( bits_COND_ENEMY_DEAD );					return GetSchedule();				}				else				{					SetState( MONSTERSTATE_ALERT );					return GetSchedule();				}			}			if ( HasConditions(bits_COND_NEW_ENEMY) )			{				return GetScheduleOfType ( SCHED_WAKE_ANGRY );			}			else if (HasConditions(bits_COND_LIGHT_DAMAGE) && !HasMemory( bits_MEMORY_FLINCHED) )			{				return GetScheduleOfType( SCHED_SMALL_FLINCH );			}			else if ( !HasConditions(bits_COND_SEE_ENEMY) )			{				// we can't see the enemy				if ( !HasConditions(bits_COND_ENEMY_OCCLUDED) )				{					// enemy is unseen, but not occluded!//.........这里部分代码省略.........

//=========================================================// MonsterThink, overridden for roaches.//=========================================================void CRoach :: MonsterThink( void  ){	if ( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )		pev->nextthink = gpGlobals->time + RANDOM_FLOAT(1,1.5);	else		pev->nextthink = gpGlobals->time + 0.1;// keep monster thinking	float flInterval = StudioFrameAdvance( ); // animate	if ( !m_fLightHacked )	{		// if light value hasn't been collection for the first time yet, 		// suspend the creature for a second so the world finishes spawning, then we'll collect the light level.		pev->nextthink = gpGlobals->time + 1;		m_fLightHacked = TRUE;		return;	}	else if ( m_flLastLightLevel < 0 )	{		// collect light level for the first time, now that all of the lightmaps in the roach's area have been calculated.		m_flLastLightLevel = GETENTITYILLUM( ENT( pev ) );	}	switch ( m_iMode )	{	case	ROACH_IDLE:	case	ROACH_EAT:		{			// if not moving, sample environment to see if anything scary is around. Do a radius search 'look' at random.			if ( RANDOM_LONG(0,3) == 1 )			{				Look( 150 );				if (HasConditions(bits_COND_SEE_FEAR))				{					// if see something scary					//ALERT ( at_aiconsole, "Scared/n" );					Eat( 30 +  ( RANDOM_LONG(0,14) ) );// roach will ignore food for 30 to 45 seconds					PickNewDest( ROACH_SCARED_BY_ENT );					SetActivity ( ACT_WALK );				}				else if ( RANDOM_LONG(0,149) == 1 )				{					// if roach doesn't see anything, there's still a chance that it will move. (boredom)					//ALERT ( at_aiconsole, "Bored/n" );					PickNewDest( ROACH_BORED );					SetActivity ( ACT_WALK );					if ( m_iMode == ROACH_EAT )					{						// roach will ignore food for 30 to 45 seconds if it got bored while eating. 						Eat( 30 +  ( RANDOM_LONG(0,14) ) );					}				}			}				// don't do this stuff if eating!			if ( m_iMode == ROACH_IDLE )			{				if ( FShouldEat() )				{					Listen();				}				if ( GETENTITYILLUM( ENT(pev) ) > m_flLastLightLevel )				{					// someone turned on lights!					//ALERT ( at_console, "Lights!/n" );					PickNewDest( ROACH_SCARED_BY_LIGHT );					SetActivity ( ACT_WALK );				}				else if ( HasConditions(bits_COND_SMELL_FOOD) )				{					CSound *pSound;					pSound = CSoundEnt::SoundPointerForIndex( m_iAudibleList );					// roach smells food and is just standing around. Go to food unless food isn't on same z-plane.					if ( pSound && abs( pSound->m_vecOrigin.z - pev->origin.z ) <= 3 )					{						PickNewDest( ROACH_SMELL_FOOD );						SetActivity ( ACT_WALK );					}				}			}			break;		}	case	ROACH_SCARED_BY_LIGHT:		{			// if roach was scared by light, then stop if we're over a spot at least as dark as where we started!			if ( GETENTITYILLUM( ENT( pev ) ) <= m_flLastLightLevel )			{				SetActivity ( ACT_IDLE );				m_flLastLightLevel = GETENTITYILLUM( ENT ( pev ) );// make this our new light level.			}			break;		}//.........这里部分代码省略.........