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

void M_ReactToDamage(edict_t *targ, edict_t *attacker){	if(!(attacker->client) && !(attacker->svflags & SVF_MONSTER))		return;			if(attacker == targ || attacker == targ->enemy)		return;			// if we are a good guy monster and our attacker is a player	// or another good guy, do not get mad at them	if(targ->monsterinfo.aiflags & AI_GOOD_GUY){		if(attacker->client ||(attacker->monsterinfo.aiflags & AI_GOOD_GUY))			return;	}		// we now know that we are not both good guys		// if attacker is a client, get mad at them because he's good and we're not	if(attacker->client){		// this can only happen in coop(both new and old enemies are clients)		// only switch if can't see the current enemy		if(targ->enemy && targ->enemy->client){			if(visible(targ, targ->enemy)){				targ->oldenemy = attacker;				return;			}			targ->oldenemy = targ->enemy;		}		targ->enemy = attacker;		if(!(targ->monsterinfo.aiflags & AI_DUCKED))			FoundTarget(targ);		return;	}		// it's the same base(walk/swim/fly) type and a different classname and it's not a tank	//(they spray too much), get mad at them	if(((targ->flags &(FL_FLY | FL_SWIM)) ==(attacker->flags &(FL_FLY | FL_SWIM))) &&			(strcmp(targ->classname, attacker->classname) != 0) &&			(strcmp(attacker->classname, "monster_tank") != 0) &&			(strcmp(attacker->classname, "monster_supertank") != 0) &&			(strcmp(attacker->classname, "monster_makron") != 0) &&			(strcmp(attacker->classname, "monster_jorg") != 0)){		if(targ->enemy)			if(targ->enemy->client)				targ->oldenemy = targ->enemy;		targ->enemy = attacker;		if(!(targ->monsterinfo.aiflags & AI_DUCKED))			FoundTarget(targ);	} else		// otherwise get mad at whoever they are mad at(help our buddy)	{		if(targ->enemy)			if(targ->enemy->client)				targ->oldenemy = targ->enemy;		targ->enemy = attacker->enemy;		FoundTarget(targ);	}}

/*=============GetMadAtAttackerT_Damage calls this when a monster is hurt=============*/void GetMadAtAttacker( gedict_t *attacker ){	if ( !attacker || attacker == world )		return; // ignore world attacks	if ( k_bloodfest && attacker->ct != ctPlayer)		return; // in bloodfest mode get mad only on players.	if ( attacker == self )		return; // do not mad on self.		if ( attacker == PROG_TO_EDICT( self->s.v.enemy ))		return; // alredy mad on this.	// get mad unless of the same class (except for soldiers)	if (   streq( self->s.v.classname, attacker->s.v.classname )		&& strneq( self->s.v.classname, "monster_army" ) 	)		return; 	// OK, we are MAD!	// remember current enemy if it was "player enemy", later we restore it	if ( PROG_TO_EDICT( self->s.v.enemy )->ct == ctPlayer )		self->oldenemy = PROG_TO_EDICT( self->s.v.enemy );	// set new enemy	self->s.v.enemy = EDICT_TO_PROG( attacker );	FoundTarget ();}

void medic_run (edict_t *self){	monster_done_dodge (self);	if (!(self->monsterinfo.aiflags & AI_MEDIC))	{		edict_t	*ent;		ent = medic_FindDeadMonster(self);		if (ent)		{			self->oldenemy = self->enemy;			self->enemy = ent;			self->enemy->monsterinfo.healer = self;			self->monsterinfo.aiflags |= AI_MEDIC;			FoundTarget (self);			return;		}	}//	else if (!canReach(self, self->enemy))//	{//		abortHeal (self, 0);//	}	if (self->monsterinfo.aiflags & AI_STAND_GROUND)		self->monsterinfo.currentmove = &medic_move_stand;	else		self->monsterinfo.currentmove = &medic_move_run;}

voidmedic_search(edict_t *self){	edict_t *ent;	if (!self)	{		return;	}	gi.sound(self, CHAN_VOICE, sound_search, 1, ATTN_IDLE, 0);	if (!self->oldenemy)	{		ent = medic_FindDeadMonster(self);		if (ent)		{			self->oldenemy = self->enemy;			self->enemy = ent;			self->enemy->owner = self;			self->monsterinfo.aiflags |= AI_MEDIC;			FoundTarget(self);		}	}}

/*================monster_useUsing a monster makes it angry at the current activator================*/void monster_use (edict_t *self, edict_t *other, edict_t *activator){	if (self->enemy)		return;	if (self->health <= 0)		return;	if (activator->flags & FL_NOTARGET)		return;	if (!(activator->client) && !(activator->monsterinfo.aiflags & AI_GOOD_GUY))		return;	if (activator->flags & FL_DISGUISED)		return;	// if monster is "used" by player, turn off good guy stuff	if (activator->client)	{		self->spawnflags &= ~SF_MONSTER_GOODGUY;		self->monsterinfo.aiflags &= ~(AI_GOOD_GUY + AI_FOLLOW_LEADER);		if(self->dmgteam && !Q_strcasecmp(self->dmgteam,"player"))			self->dmgteam = NULL;	}// delay reaction so if the monster is teleported, its sound is still heard	self->enemy = activator;	FoundTarget (self);}

voidmedic_run(edict_t *self){	if (!self)	{		return;	}	if (!(self->monsterinfo.aiflags & AI_MEDIC))	{		edict_t *ent;		ent = medic_FindDeadMonster(self);		if (ent)		{			self->oldenemy = self->enemy;			self->enemy = ent;			self->enemy->owner = self;			self->monsterinfo.aiflags |= AI_MEDIC;			FoundTarget(self);			return;		}	}	if (self->monsterinfo.aiflags & AI_STAND_GROUND)	{		self->monsterinfo.currentmove = &medic_move_stand;	}	else	{		self->monsterinfo.currentmove = &medic_move_run;	}}

voidstalker_dodge(edict_t *self, edict_t *attacker, float eta, trace_t *tr /* unused */){	if (!self || !attacker)	{		return;	}	if (!self->groundentity || (self->health <= 0))	{		return;	}	if (!self->enemy)	{		self->enemy = attacker;		FoundTarget(self);		return;	}	if ((eta < 0.1) || (eta > 5))	{		return;	}	/* this will override the foundtarget call of stalker_run */	stalker_dodge_jump(self);}

void monster_triggered_spawn (edict_t *self){	self->s.origin[2] += 1;	MonsterKillBox (self);	self->solid = SOLID_BBOX;	self->movetype = MOVETYPE_STEP;	self->svflags &= ~SVF_NOCLIENT;	self->air_finished = level.time + 12;	gi.linkentity (self);	monster_start_go (self);	if (self->enemy && !(self->spawnflags & 1) && !(self->enemy->flags & FL_NOTARGET))	{		FoundTarget (self);	}	else	{		self->enemy = NULL;	}	// some sort of spawn effect	// TODO good enough?	self->s.event = EV_PLAYER_TELEPORT;	MonsterPlayerKillBox(self);}

edict_t *medic_FindDeadMonster (edict_t *self){	edict_t	*ent = NULL;	edict_t	*best = NULL;	while ((ent = findradius(ent, self->s.origin, 1024)) != NULL)	{		if (ent == self)			continue;		if (!(ent->svflags & SVF_MONSTER))			continue;		if (ent->monsterinfo.aiflags & AI_GOOD_GUY)			continue;		if (ent->owner)			continue;		if (ent->health > 0)			continue;		if (ent->nextthink && (ent->think != M_FliesOff) && (ent->think != M_FliesOn))			continue;		// check to make sure we haven't bailed on this guy already		if ((ent->monsterinfo.badMedic1 == self) || (ent->monsterinfo.badMedic2 == self))			continue;		if (!visible(self, ent))			continue;		if (embedded(ent))			continue;		if (!canReach(self,ent))			continue;		if (!best)		{			best = ent;			continue;		}		if (ent->max_health <= best->max_health)			continue;		best = ent;	}	if(best)	{		self->oldenemy = self->enemy;		self->enemy = best;		self->enemy->owner = best;		self->monsterinfo.aiflags |= AI_MEDIC;		self->monsterinfo.aiflags &= ~AI_MEDIC_PATROL;		self->monsterinfo.medicTries = 0;		self->movetarget = self->goalentity = NULL;		self->enemy->monsterinfo.healer = self;		self->timestamp = level.time + MEDIC_TRY_TIME;		FoundTarget (self);		if(developer->value)			gi.dprintf("medic found dead monster: %s at %s/n",			best->classname,vtos(best->s.origin));	}	return best;}

/*================monster_use Using a monster makes it angry at the current activator================*/void monster_use(edict_t *self, edict_t *other, edict_t *activator){	if(self->enemy)		return;	if(self->health <= 0)		return;	if(activator->flags & FL_NOTARGET)		return;	if(!(activator->client) && !(activator->monsterinfo.aiflags & AI_GOOD_GUY))		return;			// delay reaction so if the monster is teleported, its sound is still heard	self->enemy = activator;	FoundTarget(self);}

void medic_idle(edict_t * self){	edict_t *ent;	gi.sound(self, CHAN_VOICE, sound_idle1, 1, ATTN_IDLE, 0);	ent = medic_FindDeadMonster(self);	if (ent) {		self->enemy = ent;		self->enemy->owner = self;		self->monsterinfo.aiflags |= AI_MEDIC;		FoundTarget(self);	}}

voidWidowSpawn(edict_t *self){	vec3_t f, r, u, offset, startpoint, spawnpoint;	edict_t *ent, *designated_enemy;	int i;	if (!self)	{		return;	}	AngleVectors(self->s.angles, f, r, u);	for (i = 0; i < 2; i++)	{		VectorCopy(spawnpoints[i], offset);		G_ProjectSource2(self->s.origin, offset, f, r, u, startpoint);		if (FindSpawnPoint(startpoint, stalker_mins, stalker_maxs, spawnpoint,					64))		{			ent = CreateGroundMonster(spawnpoint, self->s.angles, stalker_mins, stalker_maxs,					"monster_stalker", 256);			if (!ent)			{				continue;			}			self->monsterinfo.monster_used++;			ent->monsterinfo.commander = self;			ent->nextthink = level.time;			ent->think(ent);			ent->monsterinfo.aiflags |= /* AI_SPAWNED_WIDOW | */ AI_DO_NOT_COUNT | AI_IGNORE_SHOTS;			designated_enemy = self->enemy;			if ((designated_enemy->inuse) && (designated_enemy->health > 0))			{				ent->enemy = designated_enemy;				FoundTarget(ent);				ent->monsterinfo.attack(ent);			}		}	}}

int fixbot_search (edict_t *self){	edict_t	*ent;	if (!self->goalentity)	{		ent = fixbot_FindDeadMonster(self);		if (ent)		{			self->oldenemy = self->enemy;			self->enemy = ent;			self->enemy->owner = self;			self->monsterinfo.aiflags |= AI_MEDIC;			FoundTarget (self);			return (1);		}	}	return (0);}

/*=====================hintpath_stopMakes a monster stop following hint_paths.=====================*/void hintpath_stop (edict_t *monster){	monster->movetarget = monster->goalentity = NULL;	monster->monsterinfo.last_hint_time = level.time;	monster->monsterinfo.goal_hint = NULL;	monster->monsterinfo.aiflags &= ~AI_HINT_PATH;	// If we don't have an enemy to get mad at, just stand around like an unactivated monster.	if (!has_valid_enemy(monster))	{		monster->enemy = NULL;		monster->monsterinfo.pausetime = level.time + 100000000;		monster->monsterinfo.stand (monster);	}	else if (visible(monster, monster->enemy)) 	// attack if we can see our foe		FoundTarget (monster);	else // keep pursuing		HuntTarget (monster);}

void stalker_dodge (edict_t *self, edict_t *attacker, float eta, trace_t *tr){	if (!self->groundentity || self->health <= 0)		return;	if (!self->enemy)	{		self->enemy = attacker;		FoundTarget(self);		return;	}		// PMM - don't bother if it's going to hit anyway; fix for weird in-your-face etas (I was	// seeing numbers like 13 and 14)	if ((eta < 0.1) || (eta > 5))		return;	// this will override the foundtarget call of stalker_run	stalker_dodge_jump(self);}

void medic_StopPatrolling (edict_t *self){	self->goalentity = NULL;	self->movetarget = NULL;	self->monsterinfo.aiflags &= ~AI_MEDIC_PATROL;	if (!(self->monsterinfo.aiflags & AI_MEDIC))	{		if(medic_FindDeadMonster(self))			return;	}	if (has_valid_enemy(self))	{		if (visible(self, self->enemy))		{			FoundTarget (self);			return;		}		HuntTarget (self);		return;	}	if(self->monsterinfo.aiflags & AI_MEDIC)		abortHeal(self,false);}

void medic_search (edict_t *self){	edict_t	*ent;	// PMM - commander sounds	if (self->mass == 400)		gi.sound (self, CHAN_VOICE, sound_search, 1, ATTN_IDLE, 0);	else		gi.sound (self, CHAN_VOICE, commander_sound_search, 1, ATTN_IDLE, 0);	if (!self->oldenemy)	{		ent = medic_FindDeadMonster(self);		if (ent)		{			self->oldenemy = self->enemy;			self->enemy = ent;			self->enemy->monsterinfo.healer = self;			self->monsterinfo.aiflags |= AI_MEDIC;			FoundTarget (self);		}	}}

//.........这里部分代码省略.........	Vector vecTargetCenter;	float flMinDist2 = 1100.0f * 1100.0f;	CBaseEntity *pTargetCurrent = NULL;	CBaseEntity *pTargetOld = m_hEnemy.Get();	float flOldTargetDist2 = FLT_MAX;	// Sentries will try to target players first, then objects.  However, if the enemy held was an object it will continue	// to try and attack it first.	for (int i = 0; i < pTeamList.Size(); i++)	{		int nTeamCount = pTeamList[i]->GetNumPlayers();		for (int iPlayer = 0; iPlayer < nTeamCount; ++iPlayer)		{			CTFPlayer *pTargetPlayer = static_cast<CTFPlayer*>(pTeamList[i]->GetPlayer(iPlayer));			if (pTargetPlayer == NULL)				continue;			// Make sure the player is alive.			if (!pTargetPlayer->IsAlive())				continue;			if (pTargetPlayer->GetFlags() & FL_NOTARGET)				continue;			vecTargetCenter = pTargetPlayer->GetAbsOrigin();			vecTargetCenter += pTargetPlayer->GetViewOffset();			VectorSubtract(vecTargetCenter, vecSentryOrigin, vecSegment);			float flDist2 = vecSegment.LengthSqr();			// Store the current target distance if we come across it			if (pTargetPlayer == pTargetOld)			{				flOldTargetDist2 = flDist2;			}			// Check to see if the target is closer than the already validated target.			if (flDist2 > flMinDist2)				continue;			// It is closer, check to see if the target is valid.			if (ValidTargetPlayer(pTargetPlayer, vecSentryOrigin, vecTargetCenter))			{				flMinDist2 = flDist2;				pTargetCurrent = pTargetPlayer;			}		}		// If we already have a target, don't check objects.		if (pTargetCurrent == NULL)		{			int nTeamObjectCount = pTeamList[i]->GetNumObjects();			for (int iObject = 0; iObject < nTeamObjectCount; ++iObject)			{				CBaseObject *pTargetObject = pTeamList[i]->GetObject(iObject);				if (!pTargetObject)					continue;				vecTargetCenter = pTargetObject->GetAbsOrigin();				vecTargetCenter += pTargetObject->GetViewOffset();				VectorSubtract(vecTargetCenter, vecSentryOrigin, vecSegment);				float flDist2 = vecSegment.LengthSqr();				// Store the current target distance if we come across it				if (pTargetObject == pTargetOld)				{					flOldTargetDist2 = flDist2;				}				// Check to see if the target is closer than the already validated target.				if (flDist2 > flMinDist2)					continue;				// It is closer, check to see if the target is valid.				if (ValidTargetObject(pTargetObject, vecSentryOrigin, vecTargetCenter))				{					flMinDist2 = flDist2;					pTargetCurrent = pTargetObject;				}			}		}		// We have a target.		if (pTargetCurrent)		{			if (pTargetCurrent != pTargetOld)			{				// flMinDist2 is the new target's distance				// flOldTargetDist2 is the old target's distance				// Don't switch unless the new target is closer by some percentage				if (flMinDist2 < (flOldTargetDist2 * 0.75f))				{					FoundTarget(pTargetCurrent, vecSentryOrigin);				}			}			return true;		}	}	return false;}

/*===============PlayerNoiseEach player can have two noise objects associated with it:a personal noise (jumping, pain, weapon firing), and a weapontarget noise (bullet wall impacts)Monsters that don't directly see the player can moveto a noise in hopes of seeing the player from there.===============*/void PlayerNoise(edict_t *who, vec3_t where, int type) {	edict_t		*noise;	edict_t		*blip = NULL;return;	if (deathmatch->value && !dmmonsters->value)		return;	if (who->flags & FL_NOTARGET)		return;	if (type == PNOISE_WEAPON) {		if (who->client->silencer_shots > 0) {			who->client->silencer_shots--;			return;		} else {			who->client->silencer_shots = 0;		}	}	if (!who->mynoise) {		noise = G_Spawn();		noise->classid = CI_P_NOISE;		noise->classname = "player noise";		VectorSet (noise->mins, -8, -8, -8);		VectorSet (noise->maxs, 8, 8, 8);		noise->owner = who;		noise->svflags = SVF_NOCLIENT;		who->mynoise = noise;		noise = G_Spawn();		noise->classid = CI_P_NOISE;		noise->classname = "player noise";		VectorSet (noise->mins, -8, -8, -8);		VectorSet (noise->maxs, 8, 8, 8);		noise->owner = who;		noise->svflags = SVF_NOCLIENT;		who->mynoise2 = noise;	}	// Zheele	while ((blip = findradius(blip, where, 750)) != NULL) {		if (!blip->inuse)			continue;		if (!blip->takedamage)			continue;		if (!(blip->svflags & SVF_MONSTER) || (blip->monsterinfo.aiflags & AI_GOOD_GUY))			continue;		if ((!blip->monsterinfo.aggressive) && (deathmatch->value) && (game.craze != 10) && (game.monsterhunt != 10))			continue;		if (blip->enemy)			continue;		if (((float) pow(who->radius_dmg, GIEX_MONSTER_PLAYERLEVEL_MULT_POW) * GIEX_MONSTER_PLAYERLEVEL_MULT) < ((float) blip->monsterinfo.skill * 0.75) && (game.monsterhunt != 10)) {			continue;		}		blip->enemy = who;		FoundTarget(blip);		if (!(blip->monsterinfo.aiflags & AI_SOUND_TARGET) && (blip->monsterinfo.sight))			blip->monsterinfo.sight (blip, blip->enemy);	}	if (type == PNOISE_SELF || type == PNOISE_WEAPON)	{		noise = who->mynoise;		level.sound_entity = noise;		level.sound_entity_framenum = level.framenum;	}	else // type == PNOISE_IMPACT	{		noise = who->mynoise2;		level.sound2_entity = noise;		level.sound2_entity_framenum = level.framenum;	}	VectorCopy (where, noise->s.origin);	VectorSubtract (where, noise->maxs, noise->absmin);	VectorAdd (where, noise->maxs, noise->absmax);	noise->teleport_time = level.time;	gi.linkentity (noise);}

voidmedic_cable_attack(edict_t *self){	vec3_t offset, start, end, f, r;	trace_t tr;	vec3_t dir, angles;	float distance;	if (!self)	{		return;	}	if (!self->enemy->inuse)	{		return;	}	AngleVectors(self->s.angles, f, r, NULL);	VectorCopy(medic_cable_offsets[self->s.frame - FRAME_attack42], offset);	G_ProjectSource(self->s.origin, offset, f, r, start);	/* check for max distance */	VectorSubtract(start, self->enemy->s.origin, dir);	distance = VectorLength(dir);	if (distance > 256)	{		return;	}	/* check for min/max pitch */	vectoangles(dir, angles);	if (angles[0] < -180)	{		angles[0] += 360;	}	if (fabs(angles[0]) > 45)	{		return;	}	tr = gi.trace(start, NULL, NULL, self->enemy->s.origin, self, MASK_SHOT);	if ((tr.fraction != 1.0) && (tr.ent != self->enemy))	{		return;	}	if (self->s.frame == FRAME_attack43)	{		gi.sound(self->enemy, CHAN_AUTO, sound_hook_hit, 1, ATTN_NORM, 0);		self->enemy->monsterinfo.aiflags |= AI_RESURRECTING;	}	else if (self->s.frame == FRAME_attack50)	{		self->enemy->spawnflags = 0;		self->enemy->monsterinfo.aiflags = 0;		self->enemy->target = NULL;		self->enemy->targetname = NULL;		self->enemy->combattarget = NULL;		self->enemy->deathtarget = NULL;		self->enemy->owner = self;		ED_CallSpawn(self->enemy);		self->enemy->owner = NULL;		if (self->enemy->think)		{			self->enemy->nextthink = level.time;			self->enemy->think(self->enemy);		}		self->enemy->monsterinfo.aiflags |= AI_RESURRECTING;		if (self->oldenemy && self->oldenemy->client)		{			self->enemy->enemy = self->oldenemy;			FoundTarget(self->enemy);		}	}	else	{		if (self->s.frame == FRAME_attack44)		{			gi.sound(self, CHAN_WEAPON, sound_hook_heal, 1, ATTN_NORM, 0);		}	}	/* adjust start for beam origin being in middle of a segment */	VectorMA(start, 8, f, start);	/* adjust end z for end spot since the monster is currently dead */	VectorCopy(self->enemy->s.origin, end);	end[2] = self->enemy->absmin[2] + self->enemy->size[2] / 2;	gi.WriteByte(svc_temp_entity);	gi.WriteByte(TE_MEDIC_CABLE_ATTACK);	gi.WriteShort(self - g_edicts);//.........这里部分代码省略.........

qboolean medic_checkattack (edict_t *self){	if (!(self->monsterinfo.aiflags & AI_MEDIC))	{		if( medic_FindDeadMonster(self) )			return false;	}	if (self->monsterinfo.aiflags & AI_MEDIC)	{		float	r;		vec3_t	forward, right, offset, start;		trace_t	tr;		// if we have 5 seconds or less before a timeout,		// look for a hint_path to the target		if ( (self->timestamp < level.time + 5) &&			 (self->monsterinfo.last_hint_time + 5 < level.time) )		{			// check for hint_paths.			self->monsterinfo.last_hint_time = level.time;			if (hintcheck_monsterlost(self))			{				if(developer->value)					gi.dprintf("medic at %s using hint_paths to find %s/n",					vtos(self->s.origin), self->enemy->classname);				self->timestamp = level.time + MEDIC_TRY_TIME;				return false;			}		}		// if we ran out of time, give up		if (self->timestamp < level.time)		{			//if(developer->value)			//	gi.dprintf("medic at %s timed out, abort heal/n",vtos(self->s.origin));			abortHeal (self, true);			self->timestamp = 0;			return false;		}				// if our target went away		if ((!self->enemy) || (!self->enemy->inuse)) {			abortHeal (self,false);			return false;		}		// if target is embedded in a solid		if (embedded(self->enemy))		{			abortHeal (self,false);			return false;		}		r = realrange(self,self->enemy);		if (r > MEDIC_MAX_HEAL_DISTANCE+10) {			self->monsterinfo.attack_state = AS_STRAIGHT;			//abortHeal(self,false);			return false;		} else if(r < MEDIC_MIN_DISTANCE) {			abortHeal(self,false);			return false;		}		// Lazarus 1.6.2.3: if point-to-point vector from cable to		// target is blocked by a solid		AngleVectors (self->s.angles, forward, right, NULL);		// Offset [8] has the largest displacement to the left... not a sure		// thing but this one should be the most severe test.		VectorCopy (medic_cable_offsets[8], offset);		G_ProjectSource (self->s.origin, offset, forward, right, start);		tr = gi.trace(start,NULL,NULL,self->enemy->s.origin,self,MASK_SHOT|MASK_WATER);		if (tr.fraction < 1.0 && tr.ent != self->enemy)			return false;		medic_attack(self);		return true;	}	// Lazarus: NEVER attack other monsters	if ((self->enemy) && (self->enemy->svflags & SVF_MONSTER))	{		self->enemy = self->oldenemy;		self->oldenemy = NULL;		if(self->enemy && self->enemy->inuse)		{			if(visible(self,self->enemy))				FoundTarget(self);			else				HuntTarget(self);		}		return false;	}	return M_CheckAttack (self);}

void M_ReactToDamage (edict_t *targ, edict_t *attacker, edict_t *inflictor){    // pmm    qboolean new_tesla;    if (!(attacker->client) && !(attacker->svflags & SVF_MONSTER))        return;    //=======    //ROGUE    // logic for tesla - if you are hit by a tesla, and can't see who you should be mad at (attacker)    // attack the tesla    // also, target the tesla if it's a "new" tesla    if ((inflictor) && (!strcmp(inflictor->classname, "tesla")))    {        new_tesla = MarkTeslaArea(targ, inflictor);        if (new_tesla)            TargetTesla (targ, inflictor);        return;    }    //ROGUE    //=======    if (attacker == targ || attacker == targ->enemy)        return;    // if we are a good guy monster and our attacker is a player    // or another good guy, do not get mad at them    if (targ->monsterinfo.aiflags & AI_GOOD_GUY)    {        if (attacker->client || (attacker->monsterinfo.aiflags & AI_GOOD_GUY))            return;    }    //PGM    // if we're currently mad at something a target_anger made us mad at, ignore    // damage    if (targ->enemy && targ->monsterinfo.aiflags & AI_TARGET_ANGER)    {        float	percentHealth;        // make sure whatever we were pissed at is still around.        if(targ->enemy->inuse)        {            percentHealth = (float)(targ->health) / (float)(targ->max_health);            if( targ->enemy->inuse && percentHealth > 0.33)                return;        }        // remove the target anger flag        targ->monsterinfo.aiflags &= ~AI_TARGET_ANGER;    }    //PGM    // PMM    // if we're healing someone, do like above and try to stay with them    if ((targ->enemy) && (targ->monsterinfo.aiflags & AI_MEDIC))    {        float	percentHealth;        percentHealth = (float)(targ->health) / (float)(targ->max_health);        // ignore it some of the time        if( targ->enemy->inuse && percentHealth > 0.25)            return;        // remove the medic flag        targ->monsterinfo.aiflags &= ~AI_MEDIC;        cleanupHealTarget (targ->enemy);    }    // PMM    // we now know that we are not both good guys    // if attacker is a client, get mad at them because he's good and we're not    if (attacker->client)    {        targ->monsterinfo.aiflags &= ~AI_SOUND_TARGET;        // this can only happen in coop (both new and old enemies are clients)        // only switch if can't see the current enemy        if (targ->enemy && targ->enemy->client)        {            if (visible(targ, targ->enemy))            {                targ->oldenemy = attacker;                return;            }            targ->oldenemy = targ->enemy;        }        targ->enemy = attacker;        if (!(targ->monsterinfo.aiflags & AI_DUCKED))            FoundTarget (targ);        return;    }    // it's the same base (walk/swim/fly) type and a different classname and it's not a tank    // (they spray too much), get mad at them    // PMM    // added medics to this    // FIXME -//.........这里部分代码省略.........

void thing_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf){	if(self->target_ent != other)		return;	if(other->health <= 0)	{		G_FreeEdict(self);		return;	}	self->touch = NULL;	if( self->target_ent->monsterinfo.aiflags & AI_SEEK_COVER )	{		edict_t	*monster;		// For monster/actor seeking cover after firing, 		// pause a random bit before resuming attack		self->touch_debounce_time = level.time + random()*6.;		monster = self->target_ent;		monster->monsterinfo.stand(monster);		monster->monsterinfo.pausetime = self->touch_debounce_time;		self->think = thing_think_pause;		self->think(self);		return;	}	if( self->target_ent->monsterinfo.aiflags & AI_EVADE_GRENADE )	{		edict_t	*grenade = other->next_grenade;		if(other->goalentity == self)			other->goalentity = NULL;		if(other->movetarget == self)			other->movetarget = NULL;		other->vehicle = NULL;		if(grenade)		{			// make sure this is still a grenade			if(grenade->inuse)			{				if(Q_strcasecmp(grenade->classname,"grenade") && Q_strcasecmp(grenade->classname,"hgrenade"))					other->next_grenade = grenade = NULL;			}			else				other->next_grenade = grenade = NULL;		}		if(grenade)		{			if(self->touch_debounce_time > level.time)			{				other->monsterinfo.pausetime = self->touch_debounce_time + 0.1;				other->monsterinfo.aiflags |= AI_STAND_GROUND;				other->monsterinfo.stand(other);			}			else				other->monsterinfo.pausetime = 0;			other->enemy = grenade->owner;			if (has_valid_enemy(other))			{				other->goalentity = other->enemy;				if (visible(other, other->enemy))					FoundTarget (other);				else					HuntTarget (other);			}			else			{				other->enemy = NULL;				other->monsterinfo.stand (other);			}			if(other->monsterinfo.pausetime > 0)			{				self->think = thing_grenade_boom;				self->nextthink = other->monsterinfo.pausetime;				return;			}			other->monsterinfo.aiflags &= ~(AI_CHASE_THING | AI_EVADE_GRENADE);		}		else if (has_valid_enemy(other))		{			other->monsterinfo.aiflags &= ~(AI_CHASE_THING | AI_EVADE_GRENADE);			other->goalentity = other->enemy;			if (visible(other, other->enemy))				FoundTarget (other);			else				HuntTarget (other);		}		else		{			other->enemy = NULL;			other->monsterinfo.pausetime = level.time + 100000000;			other->monsterinfo.aiflags &= ~(AI_CHASE_THING | AI_EVADE_GRENADE);			other->monsterinfo.stand (other);		}		G_FreeEdict(self);		return;	}	self->touch_debounce_time = 0;	thing_think(self);}

//.........这里部分代码省略.........		self->enemy->deathtarget = NULL;		self->enemy->monsterinfo.healer = self;		VectorCopy (self->enemy->maxs, maxs);		maxs[2] += 48;   // compensate for change when they die		tr = gi.trace (self->enemy->s.origin, self->enemy->mins, maxs, self->enemy->s.origin, self->enemy, MASK_MONSTERSOLID);		if (tr.startsolid || tr.allsolid)		{//			if ((g_showlogic) && (g_showlogic->value))//				gi.dprintf ("Spawn point obstructed, aborting heal!/n");			abortHeal (self, true, true, false);			return;		} 		else if (tr.ent != world)		{//			if ((g_showlogic) && (g_showlogic->value))//				gi.dprintf("heal in entity %s/n", tr.ent->classname);			abortHeal (self, true, true, false);			return;		}/*		else if (tr.ent == world)		{			if ((g_showlogic) && (g_showlogic->value))				gi.dprintf ("heal in world, aborting!/n");			abortHeal (self, 1);			return;		}*/		else		{			self->enemy->monsterinfo.aiflags |= AI_DO_NOT_COUNT;			ED_CallSpawn (self->enemy);			if (self->enemy->think)			{				self->enemy->nextthink = level.time;				self->enemy->think (self->enemy);			}	//		self->enemy->monsterinfo.aiflags |= AI_RESURRECTING;			self->enemy->monsterinfo.aiflags &= ~AI_RESURRECTING;			self->enemy->monsterinfo.aiflags |= AI_IGNORE_SHOTS|AI_DO_NOT_COUNT;			// turn off flies			self->enemy->s.effects &= ~EF_FLIES;			self->enemy->monsterinfo.healer = NULL;			if ((self->oldenemy) && (self->oldenemy->inuse) && (self->oldenemy->health > 0))			{//				if ((g_showlogic) && (g_showlogic->value))//					gi.dprintf ("setting heal target's enemy to %s/n", self->oldenemy->classname);				self->enemy->enemy = self->oldenemy;//				HuntTarget (self->enemy);				FoundTarget (self->enemy);			}			else			{//				if (g_showlogic && g_showlogic->value)//					gi.dprintf ("no valid enemy to set!/n");				self->enemy->enemy = NULL;				if (!FindTarget (self->enemy))				{					// no valid enemy, so stop acting					self->enemy->monsterinfo.pausetime = level.time + 100000000;					self->enemy->monsterinfo.stand (self->enemy);				}				self->enemy = NULL;				self->oldenemy = NULL;				if (!FindTarget (self))				{					// no valid enemy, so stop acting					self->monsterinfo.pausetime = level.time + 100000000;					self->monsterinfo.stand (self);					return;				}			}		}	}	else	{		if (self->s.frame == FRAME_attack44)			// PMM - medic commander sounds			if (self->mass == 400)				gi.sound (self, CHAN_WEAPON, sound_hook_heal, 1, ATTN_NORM, 0);			else				gi.sound (self, CHAN_WEAPON, commander_sound_hook_heal, 1, ATTN_NORM, 0);	}	// adjust start for beam origin being in middle of a segment	VectorMA (start, 8, f, start);	// adjust end z for end spot since the monster is currently dead	VectorCopy (self->enemy->s.origin, end);	end[2] = self->enemy->absmin[2] + self->enemy->size[2] / 2;	gi.WriteByte (svc_temp_entity);	gi.WriteByte (TE_MEDIC_CABLE_ATTACK);	gi.WriteShort (self - g_edicts);	gi.WritePosition (start);	gi.WritePosition (end);	gi.multicast (self->s.origin, MULTICAST_PVS);}

//.........这里部分代码省略.........		G_ProjectSource (self->s.origin, offset, f, r, startpoint);		// a little off the ground		startpoint[2] += 10;		ent = NULL;		if (FindSpawnPoint (startpoint, reinforcement_mins[summonStr-inc], reinforcement_maxs[summonStr-inc], spawnpoint, 32))		{			if (CheckSpawnPoint (spawnpoint, reinforcement_mins[summonStr-inc], reinforcement_maxs[summonStr-inc]))				ent = CreateGroundMonster (spawnpoint, self->s.angles,					reinforcement_mins[summonStr-inc], reinforcement_maxs[summonStr-inc],					reinforcements[summonStr-inc], 256);//			else if ((g_showlogic) && (g_showlogic->value))//				gi.dprintf ("CheckSpawnPoint failed volume check!/n");		}		else		{//			if ((g_showlogic) && (g_showlogic->value))//				gi.dprintf ("FindSpawnPoint failed to find a point!/n");		}		if (!ent)		{//			if ((g_showlogic) && (g_showlogic->value))//				gi.dprintf ("Spawn point obstructed for %s, aborting!/n", reinforcements[summonStr-inc]);			continue;		}//		gi.sound (self, CHAN_WEAPON, commander_sound_spawn, 1, ATTN_NORM, 0);		if (ent->think)		{			ent->nextthink = level.time;			ent->think (ent);		}		ent->monsterinfo.aiflags |= AI_IGNORE_SHOTS|AI_DO_NOT_COUNT|AI_SPAWNED_MEDIC_C;		ent->monsterinfo.commander = self;		self->monsterinfo.monster_slots--;//		if ((g_showlogic) && (g_showlogic->value))//			gi.dprintf ("medic_commander: %d slots remaining/n", self->monsterinfo.monster_slots);		if (self->monsterinfo.aiflags & AI_MEDIC)			designated_enemy = self->oldenemy;		else			designated_enemy = self->enemy;		if (coop && coop->value)		{			designated_enemy = PickCoopTarget(ent);			if (designated_enemy)			{				// try to avoid using my enemy				if (designated_enemy == self->enemy)				{					designated_enemy = PickCoopTarget(ent);					if (designated_enemy)					{//						if ((g_showlogic) && (g_showlogic->value))//						{//							gi.dprintf ("PickCoopTarget returned a %s - ", designated_enemy->classname);//							if (designated_enemy->client)//								gi.dprintf ("with name %s/n", designated_enemy->client->pers.netname);//							else//								gi.dprintf ("NOT A CLIENT/n");//						}					}					else					{//						if ((g_showlogic) && (g_showlogic->value))//							gi.dprintf ("pick coop failed, using my current enemy/n");						designated_enemy = self->enemy;					}				}			}			else			{//				if ((g_showlogic) && (g_showlogic->value))//					gi.dprintf ("pick coop failed, using my current enemy/n");				designated_enemy = self->enemy;			}		}		if ((designated_enemy) && (designated_enemy->inuse) && (designated_enemy->health > 0))		{			// fixme//			if ((g_showlogic) && (g_showlogic -> value))//				gi.dprintf  ("setting enemy to %s/n", designated_enemy->classname);			ent->enemy = designated_enemy;			FoundTarget (ent);		}		else		{			ent->enemy = NULL;			ent->monsterinfo.stand (ent);		}//		ent->s.event = EV_PLAYER_TELEPORT;	}}

//.........这里部分代码省略.........				return;			}			self->monsterinfo.medicTries++;			cleanupHeal (self, 1);			return;		}		abortHeal (self,false);		return;	}	if (self->s.frame == FRAME_attack43)	{		gi.sound (self->enemy, CHAN_AUTO, sound_hook_hit, 1, ATTN_NORM, 0);		self->enemy->monsterinfo.aiflags |= AI_RESURRECTING;		M_SetEffects(self->enemy);	}	else if (self->s.frame == FRAME_attack50)	{		self->enemy->spawnflags &= SF_MONSTER_NOGIB;		self->enemy->monsterinfo.aiflags = 0;		self->enemy->target = NULL;		self->enemy->targetname = NULL;		self->enemy->combattarget = NULL;		self->enemy->deathtarget = NULL;		self->enemy->owner = self;		// Lazarus: reset initially dead monsters to use the INVERSE of their		// initial health, and force gib_health to default value		if(self->enemy->max_health < 0)		{			self->enemy->max_health = -self->enemy->max_health;			self->enemy->gib_health = 0;		}		self->enemy->health = self->enemy->max_health;		self->enemy->takedamage = DAMAGE_AIM;		self->enemy->flags &= ~FL_NO_KNOCKBACK;		self->enemy->pain_debounce_time = 0;		self->enemy->damage_debounce_time = 0;		self->enemy->deadflag = DEAD_NO;		if(self->enemy->s.effects & EF_FLIES)			M_FliesOff(self->enemy);		ED_CallSpawn (self->enemy);		self->enemy->monsterinfo.healer = NULL;		self->enemy->owner = NULL;		// Knightmare- disable deadmonster_think		if (self->enemy->postthink)			self->enemy->postthink = NULL;		if (self->enemy->think)		{			self->enemy->nextthink = level.time;			self->enemy->think (self->enemy);		}		self->enemy->monsterinfo.aiflags &= ~AI_RESURRECTING;		M_SetEffects(self->enemy);		if (self->oldenemy && self->oldenemy->client)		{			self->enemy->enemy = self->oldenemy;			FoundTarget (self->enemy);		}		else		{			// Lazarus: this should make oblivious monsters 			// find player again			self->enemy->enemy = NULL;		}	}	else	{		if (self->s.frame == FRAME_attack44)			gi.sound (self, CHAN_WEAPON, sound_hook_heal, 1, ATTN_NORM, 0);	}	// adjust start for beam origin being in middle of a segment	// Lazarus: This isn't right... this causes cable start point to be well above muzzle	//          when target is closeby. f should be vector from muzzle to target, not	//          the forward viewing direction. PLUS... 8 isn't right... the model is	//          actually 32 units long, so use 16.. fixed below.//	VectorMA (start, 8, f, start);	//Knightmare- if enemy went away, like after returning from another level, return	if (!self->enemy)		return;	// adjust end z for end spot since the monster is currently dead	VectorCopy (self->enemy->s.origin, end);	end[2] = self->enemy->absmin[2] + self->enemy->size[2] / 2;	// Lazarus fix	VectorSubtract(end,start,f);	VectorNormalize(f);	VectorMA(start,16,f,start);	gi.WriteByte (svc_temp_entity);	gi.WriteByte (TE_MEDIC_CABLE_ATTACK);	gi.WriteShort (self - g_edicts);	gi.WritePosition (start);	gi.WritePosition (end);	gi.multicast (self->s.origin, MULTICAST_PVS);}

void thing_think (edict_t *self){	vec3_t	vec;	vec_t	dist;	edict_t	*monster;	monster = self->target_ent;	if(level.time <= self->touch_debounce_time)	{		if(monster && monster->inuse)		{			if(monster->movetarget == self)			{				if(monster->health > 0)				{					VectorSubtract(monster->s.origin,self->s.origin,vec);					vec[2] = 0;					dist = VectorLength(vec);					if(dist >= monster->size[0])					{						self->nextthink = level.time + FRAMETIME;						return;					}				}			}		}	}	if(!monster || !monster->inuse || (monster->health <= 0))	{		G_FreeEdict(self);		return;	}	if(monster->goalentity == self)		monster->goalentity = NULL;	if(monster->movetarget == self)		monster->movetarget = NULL;	if(monster->monsterinfo.aiflags & AI_FOLLOW_LEADER)	{		monster->monsterinfo.leader = NULL;		if(monster->monsterinfo.old_leader && monster->monsterinfo.old_leader->inuse)		{			monster->monsterinfo.pausetime = level.time + 2;			monster->monsterinfo.stand(monster);			VectorCopy(monster->monsterinfo.old_leader->s.origin,self->move_origin);			self->nextthink = level.time + 2;			self->think     = thing_restore_leader;			gi.linkentity(monster);			return;		}		else		{			monster->monsterinfo.aiflags &= ~AI_FOLLOW_LEADER;		}	}	if(monster->monsterinfo.aiflags & AI_CHICKEN)	{		monster->monsterinfo.stand(monster);		monster->monsterinfo.aiflags |= AI_STAND_GROUND;		monster->monsterinfo.pausetime = level.time + 100000;	}	monster->vehicle = NULL;	monster->monsterinfo.aiflags &= ~(AI_CHASE_THING | AI_SEEK_COVER | AI_EVADE_GRENADE);	G_FreeEdict(self);	if (has_valid_enemy(monster))	{		monster->monsterinfo.pausetime = 0;		monster->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND);		monster->goalentity = monster->enemy;		if (visible(monster, monster->enemy))		{			FoundTarget (monster);			return;		}		HuntTarget (monster);		return;	}	monster->enemy = NULL;	monster->monsterinfo.pausetime = level.time + 100000000;	monster->monsterinfo.stand (monster);}

voidCarrierSpawn(edict_t *self){	vec3_t f, r, offset, startpoint, spawnpoint;	edict_t *ent;	int mytime;	if (!self)	{		return;	}	VectorSet(offset, 105, 0, -58);	AngleVectors(self->s.angles, f, r, NULL);	G_ProjectSource(self->s.origin, offset, f, r, startpoint);	/* the +0.1 is because level.time is sometimes a little low */	mytime = (int)((level.time + 0.1 - self->timestamp) / 0.5);	if (FindSpawnPoint(startpoint, flyer_mins, flyer_maxs, spawnpoint, 32))	{		/* the second flier should be a kamikaze flyer */		if (mytime != 2)		{			ent = CreateMonster(spawnpoint, self->s.angles, "monster_flyer");		}		else		{			ent = CreateMonster(spawnpoint, self->s.angles, "monster_kamikaze");		}		if (!ent)		{			return;		}		gi.sound(self, CHAN_BODY, sound_spawn, 1, ATTN_NONE, 0);		self->monsterinfo.monster_slots--;		ent->nextthink = level.time;		ent->think(ent);		ent->monsterinfo.aiflags |= AI_SPAWNED_CARRIER | AI_DO_NOT_COUNT |									AI_IGNORE_SHOTS;		ent->monsterinfo.commander = self;		if ((self->enemy->inuse) && (self->enemy->health > 0))		{			ent->enemy = self->enemy;			FoundTarget(ent);			if (mytime == 1)			{				ent->monsterinfo.lefty = 0;				ent->monsterinfo.attack_state = AS_SLIDING;				ent->monsterinfo.currentmove = &flyer_move_attack3;			}			else if (mytime == 2)			{				ent->monsterinfo.lefty = 0;				ent->monsterinfo.attack_state = AS_STRAIGHT;				ent->monsterinfo.currentmove = &flyer_move_kamikaze;				ent->mass = 100;				ent->monsterinfo.aiflags |= AI_CHARGING;			}			else if (mytime == 3)			{				ent->monsterinfo.lefty = 1;				ent->monsterinfo.attack_state = AS_SLIDING;				ent->monsterinfo.currentmove = &flyer_move_attack3;			}		}	}}

voidM_ReactToDamage(edict_t *targ, edict_t *attacker){	if (!targ || !attacker)	{		return;	}		if (targ->health <= 0)	{		return;	}	if (!(attacker->client) && !(attacker->svflags & SVF_MONSTER))	{		return;	}	if ((attacker == targ) || (attacker == targ->enemy))	{		return;	}	/* if we are a good guy monster and our attacker is a	   player or another good guy, do not get mad at them */	if (targ->monsterinfo.aiflags & AI_GOOD_GUY)	{		if (attacker->client || (attacker->monsterinfo.aiflags & AI_GOOD_GUY))		{			return;		}	}	/* if attacker is a client, get mad at	   them because he's good and we're not */	if (attacker->client)	{		targ->monsterinfo.aiflags &= ~AI_SOUND_TARGET;		/* this can only happen in coop (both new and old		   enemies are clients) only switch if can't see the		   current enemy */		if (targ->enemy && targ->enemy->client)		{			if (visible(targ, targ->enemy))			{				targ->oldenemy = attacker;				return;			}			targ->oldenemy = targ->enemy;		}		targ->enemy = attacker;		if (!(targ->monsterinfo.aiflags & AI_DUCKED))		{			FoundTarget(targ);		}		return;	}	/* it's the same base (walk/swim/fly) type and	   a different classname and it's not a tank	   (they spray too much), get mad at them */	if (((targ->flags & (FL_FLY | FL_SWIM)) ==		 (attacker->flags & (FL_FLY | FL_SWIM))) &&		(strcmp(targ->classname, attacker->classname) != 0) &&		(strcmp(attacker->classname, "monster_tank") != 0) &&		(strcmp(attacker->classname, "monster_supertank") != 0) &&		(strcmp(attacker->classname, "monster_makron") != 0) &&		(strcmp(attacker->classname, "monster_jorg") != 0))	{		if (targ->enemy && targ->enemy->client)		{			targ->oldenemy = targ->enemy;		}		targ->enemy = attacker;		if (!(targ->monsterinfo.aiflags & AI_DUCKED))		{			FoundTarget(targ);		}	}	/* if they *meant* to shoot us, then shoot back */	else if (attacker->enemy == targ)	{		if (targ->enemy && targ->enemy->client)		{			targ->oldenemy = targ->enemy;		}		targ->enemy = attacker;		if (!(targ->monsterinfo.aiflags & AI_DUCKED))		{			FoundTarget(targ);		}//.........这里部分代码省略.........