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

/** G_SpawnQueue_AddClient*/void G_SpawnQueue_AddClient( edict_t *ent ){	g_teamspawnqueue_t *queue;	int i;	if( !ent || !ent->r.client )		return;	if( ENTNUM( ent ) <= 0 || ENTNUM( ent ) > gs.maxclients )		return;	if( ent->r.client->team < TEAM_SPECTATOR|| ent->r.client->team >= GS_MAX_TEAMS )		return;	queue = &g_spawnQueues[ent->r.client->team];	for( i = queue->start; i < queue->head; i++ )	{		if( queue->list[i % MAX_CLIENTS] == ENTNUM( ent ) )			return;	}	G_SpawnQueue_RemoveClient( ent );	queue->list[queue->head % MAX_CLIENTS] = ENTNUM( ent );	queue->head++;	if( queue->spectate_team )		G_ChasePlayer( ent, NULL, true, 0 );}

/** G_ClearSnap* We just run G_SnapFrame, the server just sent the snap to the clients,* it's now time to clean up snap specific data to start the next snap from clean.*/void G_ClearSnap( void ){	edict_t	*ent;	game.realtime = trap_Milliseconds(); // level.time etc. might not be real time	// clear gametype's clock override	gs.gameState.longstats[GAMELONG_CLOCKOVERRIDE] = 0;	// clear all events in the snap	for( ent = &game.edicts[0]; ENTNUM( ent ) < game.numentities; ent++ )	{		if( ISEVENTENTITY( &ent->s ) )  // events do not persist after a snapshot		{			G_FreeEdict( ent );			continue;		}		// events only last for a single message		ent->s.events[0] = ent->s.events[1] = 0;		ent->s.eventParms[0] = ent->s.eventParms[1] = 0;		ent->numEvents = 0;		ent->eventPriority[0] = ent->eventPriority[1] = false;		ent->s.teleported = qfalse; // remove teleported bit.		// remove effect bits that are (most likely) added from gametypes		ent->s.effects = ( ent->s.effects & (EF_TAKEDAMAGE|EF_CARRIER|EF_FLAG_TRAIL|EF_ROTATE_AND_BOB|EF_STRONG_WEAPON|EF_GHOST) );	}	// recover some info, let players respawn and finally clear the snap structures	for( ent = &game.edicts[0]; ENTNUM( ent ) < game.numentities; ent++ )	{		if( !GS_MatchPaused() )		{			// copy origin to old origin ( this old_origin is for snaps )			if( !( ent->r.svflags & SVF_TRANSMITORIGIN2 ) )				VectorCopy( ent->s.origin, ent->s.old_origin );			G_CheckClientRespawnClick( ent );		}		if( GS_MatchPaused() )			ent->s.sound = entity_sound_backup[ENTNUM( ent )];		// clear the snap temp info		memset( &ent->snap, 0, sizeof( ent->snap ) );		if( ent->r.client && trap_GetClientState( PLAYERNUM( ent ) ) >= CS_SPAWNED )		{			memset( &ent->r.client->resp.snap, 0, sizeof( ent->r.client->resp.snap ) );			// set race stats to invisible			RS_clearHUDStats( ent->r.client ); // racesow - clear with our function		}	}	g_snapStarted = false;}

/** G_Client_DeadView*/static void G_Client_DeadView( edict_t *ent ){	edict_t	*body;	gclient_t *client;	trace_t	trace;	client = ent->r.client;	// find the body	for( body = game.edicts + gs.maxclients; ENTNUM( body ) < gs.maxclients + BODY_QUEUE_SIZE + 1; body++ )	{		if( !body->r.inuse || body->r.svflags & SVF_NOCLIENT )			continue;		if( body->activator == ent )  // this is our body			break;	}	if( body->activator != ent )	{                          // ran all the list and didn't find our body		return;	}	// move us to body position	VectorCopy( body->s.origin, ent->s.origin );	VectorCopy( body->s.origin, ent->s.old_origin );	ent->s.teleported = qtrue;	client->ps.viewangles[ROLL] = 0;	client->ps.viewangles[PITCH] = 0;	// see if our killer is still in view	if( body->enemy && ( body->enemy != ent ) )	{		G_Trace( &trace, ent->s.origin, vec3_origin, vec3_origin, body->enemy->s.origin, body, MASK_OPAQUE );		if( trace.fraction != 1.0f )		{			body->enemy = NULL;		}		else		{			client->ps.viewangles[YAW] = LookAtKillerYAW( ent, NULL, body->enemy );		}	}	else	{    // nobody killed us, so just circle around the body ?	}	G_ProjectThirdPersonView( ent->s.origin, client->ps.viewangles, body );	VectorCopy( client->ps.viewangles, ent->s.angles );	VectorCopy( ent->s.origin, client->ps.pmove.origin );	VectorClear( client->ps.pmove.velocity );	GS_SnapPosition( client->ps.pmove.origin, ent->r.mins, ent->r.maxs, ENTNUM( ent ), 0 );}

static unsigned int G_FindPointedPlayer( edict_t *self ) {	trace_t trace;	int i, j, bestNum = 0;	vec3_t boxpoints[8];	float value, dist, value_best = 0.90f;   // if nothing better is found, print nothing	edict_t *other;	vec3_t vieworg, dir, viewforward;	if( G_IsDead( self ) ) {		return 0;	}	// we can't handle the thirdperson modifications in server side :/	VectorSet( vieworg, self->r.client->ps.pmove.origin[0], self->r.client->ps.pmove.origin[1], self->r.client->ps.pmove.origin[2] + self->r.client->ps.viewheight );	AngleVectors( self->r.client->ps.viewangles, viewforward, NULL, NULL );	for( i = 0; i < gs.maxclients; i++ ) {		other = PLAYERENT( i );		if( !other->r.inuse ) {			continue;		}		if( !other->r.client ) {			continue;		}		if( other == self ) {			continue;		}		if( !other->r.solid || ( other->r.svflags & SVF_NOCLIENT ) ) {			continue;		}		VectorSubtract( other->s.origin, self->s.origin, dir );		dist = VectorNormalize2( dir, dir );		if( dist > 1000 ) {			continue;		}		value = DotProduct( dir, viewforward );		if( value > value_best ) {			BuildBoxPoints( boxpoints, other->s.origin, tv( 4, 4, 4 ), tv( 4, 4, 4 ) );			for( j = 0; j < 8; j++ ) {				G_Trace( &trace, vieworg, vec3_origin, vec3_origin, boxpoints[j], self, MASK_SHOT | MASK_OPAQUE );				if( trace.ent && trace.ent == ENTNUM( other ) ) {					value_best = value;					bestNum = ENTNUM( other );				}			}		}	}	return bestNum;}

static int G_Teams_CompareMembers( const void *a, const void *b ){	edict_t *edict_a = game.edicts + *(int *)a;	edict_t *edict_b = game.edicts + *(int *)b;	int score_a = edict_a->r.client->level.stats.score;	int score_b = edict_b->r.client->level.stats.score;	int result = ( level.gametype.inverseScore ? -1 : 1 ) * ( score_b - score_a );	if (!result)		result = Q_stricmp( edict_a->r.client->netname, edict_b->r.client->netname );	if (!result)		result = ENTNUM( edict_a ) - ENTNUM( edict_b );	return result;}

void G_ScoreboardMessage_AddChasers( int entnum, int entnum_self ){	char entry[MAX_TOKEN_CHARS];	int i;	edict_t *e;	size_t len;	len = strlen( scoreboardString );	if( !len )		return;	// add personal spectators	Q_strncpyz( entry, "&y ", sizeof( entry ) );	ADD_SCOREBOARD_ENTRY( scoreboardString, len, entry );	for( i = 0; i < teamlist[TEAM_SPECTATOR].numplayers; i++ )	{		e = game.edicts + teamlist[TEAM_SPECTATOR].playerIndices[i];		if( ENTNUM( e ) == entnum_self )			continue;		if( e->r.client->connecting || trap_GetClientState( PLAYERNUM( e ) ) < CS_SPAWNED )			continue;		if( !e->r.client->resp.chase.active || e->r.client->resp.chase.target != entnum )			continue;		Q_snprintfz( entry, sizeof( entry ), "%i ", PLAYERNUM( e ) );		ADD_SCOREBOARD_ENTRY( scoreboardString, len, entry );	}}

//Sunflower spiral with Fibonacci numbers static void G_Fire_SunflowerPattern( edict_t *self, vec3_t start, vec3_t dir, int *seed, int count, 	int hspread, int vspread, int range, float damage, int kick, int stun, int dflags, int mod, int timeDelta ){	int i;	float r;	float u;	float fi;	trace_t trace;	for( i = 0; i < count; i++ )	{		fi = i * 2.4; //magic value creating Fibonacci numbers		r = cos( (float)*seed + fi ) * hspread * sqrt(fi);		u = sin( (float)*seed + fi ) * vspread * sqrt(fi); 		GS_TraceBullet( &trace, start, dir, r, u, range, ENTNUM( self ), timeDelta );		if( trace.ent != -1 )		{			if( game.edicts[trace.ent].takedamage )			{				G_Damage( &game.edicts[trace.ent], self, self, dir, dir, trace.endpos, damage, kick, stun, dflags, mod );			}			else			{				if( !( trace.surfFlags & SURF_NOIMPACT ) )				{				}			}		}	}}

void G_PlayerAward( edict_t *ent, const char *awardMsg ){	edict_t *other;	char cmd[MAX_STRING_CHARS];	gameaward_t *ga;	int i, size;	score_stats_t *stats;	if( !awardMsg || !awardMsg[0] || !ent->r.client )		return;	Q_snprintfz( cmd, sizeof( cmd ), "aw /"%s/"", awardMsg );	trap_GameCmd( ent, cmd );	if( dedicated->integer )		G_Printf( "%s", COM_RemoveColorTokens( va( "%s receives a '%s' award./n", ent->r.client->netname, awardMsg ) ) );	ent->r.client->level.stats.awards++;	teamlist[ent->s.team].stats.awards++;	G_Gametype_ScoreEvent( ent->r.client, "award", awardMsg );	stats = &ent->r.client->level.stats;	if( !stats->awardAllocator )		stats->awardAllocator = LinearAllocator( sizeof( gameaward_t ), 0, _G_LevelMalloc, _G_LevelFree );	// ch : this doesnt work for race right?	if( GS_MatchState() == MATCH_STATE_PLAYTIME || GS_MatchState() == MATCH_STATE_POSTMATCH )	{		// ch : we store this locally to send to MM		// first check if we already have this one on the clients list		size = LA_Size( stats->awardAllocator );		ga = NULL;		for( i = 0; i < size; i++ )		{			ga = ( gameaward_t * )LA_Pointer( stats->awardAllocator, i );			if( !strncmp( ga->name, awardMsg, sizeof(ga->name)-1 ) )				break;		}		if( i >= size )		{			ga = ( gameaward_t * )LA_Alloc( stats->awardAllocator );			memset( ga, 0, sizeof(*ga) );			ga->name = G_RegisterLevelString( awardMsg );		}		if( ga )			ga->count++;	}	// add it to every player who's chasing this player	for( other = game.edicts + 1; PLAYERNUM( other ) < gs.maxclients; other++ )	{		if( !other->r.client || !other->r.inuse || !other->r.client->resp.chase.active )			continue;		if( other->r.client->resp.chase.target == ENTNUM( ent ) )			trap_GameCmd( other, cmd );	}}

/** GClip_FindBoxInRadius* Returns entities that have their boxes within a spherical area*/edict_t *GClip_FindBoxInRadius4D( edict_t *from, vec3_t org, float rad, int timeDelta ){	int i, j;	c4clipedict_t *check;	vec3_t mins, maxs;	int fromNum;	if( !from ) from = world;	fromNum = ENTNUM( from ) + 1;	for( i = fromNum; i < game.numentities; i++ )	{		if( !game.edicts[i].r.inuse )			continue;		check = GClip_GetClipEdictForDeltaTime( i, timeDelta );		if( !check->r.inuse )			continue;		if( check->r.solid == SOLID_NOT )			continue;		// make absolute mins and maxs		for( j = 0; j < 3; j++ )		{			mins[j] = check->s.origin[j] + check->r.mins[j];			maxs[j] = check->s.origin[j] + check->r.maxs[j];		}		if( !BoundsAndSphereIntersect( mins, maxs, org, rad ) )			continue;		return &game.edicts[i]; // return realtime entity	}	return NULL;}

/** AI_InitEntitiesData*/void AI_InitEntitiesData( void ){	int newlinks, newjumplinks;	edict_t *ent;	if( !nav.num_nodes )	{		if( g_numbots->integer ) trap_Cvar_Set( "g_numbots", "0" );		return;	}	// create nodes for navigable map entities ( must happen after finding teams )	for( ent = game.edicts + 1 + gs.maxclients; ENTNUM( ent ) < game.numentities; ent++ )		AI_AddNavigableEntity( ent );	// add all clients to goalEntities so they can be tracked as enemies	for( ent = game.edicts + 1; PLAYERNUM( ent ) < gs.maxclients; ent++ )		AI_AddGoalEntity( ent );	// link all newly added nodes	newlinks = AI_LinkServerNodes( nav.serverNodesStart );	newjumplinks = AI_LinkCloseNodes_JumpPass( nav.serverNodesStart );	if( developer->integer )	{		G_Printf( "       : added nodes:%i./n", nav.num_nodes - nav.serverNodesStart );		G_Printf( "       : total nodes:%i./n", nav.num_nodes );		G_Printf( "       : added links:%i./n", newlinks );		G_Printf( "       : added jump links:%i./n", newjumplinks );	}	G_Printf( "       : AI Navigation Initialized./n" );	nav.loaded = qtrue;}

/** W_Touch_Plasma*/static void W_Touch_Plasma( edict_t *ent, edict_t *other, cplane_t *plane, int surfFlags ){	int hitType;	vec3_t dir;	if( surfFlags & SURF_NOIMPACT )	{		G_FreeEdict( ent );		return;	}	hitType = G_Projectile_HitStyle( ent, other );	if( hitType == PROJECTILE_TOUCH_NOT )		return;	if( other->takedamage )	{		VectorNormalize2( ent->velocity, dir );		if( hitType == PROJECTILE_TOUCH_DIRECTSPLASH ) // use hybrid direction from splash and projectile		{			G_SplashFrac4D( ENTNUM( other ), ent->s.origin, ent->projectileInfo.radius, dir, NULL, NULL, ent->timeDelta );		}		else		{			VectorNormalize2( ent->velocity, dir );		}		G_Damage( other, ent, ent->r.owner, dir, ent->velocity, ent->s.origin, ent->projectileInfo.maxDamage, ent->projectileInfo.maxKnockback, ent->projectileInfo.stun, DAMAGE_KNOCKBACK_SOFT, ent->style );	}	W_Plasma_Explosion( ent, other, plane, surfFlags );}

/** G_RunEntities* treat each object in turn* even the world and clients get a chance to think*/static void G_RunEntities( void ){	edict_t	*ent;	for( ent = &game.edicts[0]; ENTNUM( ent ) < game.numentities; ent++ )	{		if( !ent->r.inuse )			continue;		if( ISEVENTENTITY( &ent->s ) )			continue; // events do not think		level.current_entity = ent;		// backup oldstate ( for world frame ).		ent->olds = ent->s;		// if the ground entity moved, make sure we are still on it		if( !ent->r.client )		{			if( ( ent->groundentity ) && ( ent->groundentity->linkcount != ent->groundentity_linkcount ) )				G_CheckGround( ent );		}		G_RunEntity( ent );		if( ent->takedamage )			ent->s.effects |= EF_TAKEDAMAGE;		else			ent->s.effects &= ~EF_TAKEDAMAGE;	}}

void G_Fire_SpiralPattern( edict_t *self, vec3_t start, vec3_t dir, int *seed, int count, int spread, int range, float damage, int kick, int stun, int dflags, int mod, int timeDelta ){	int i;	float r;	float u;	trace_t trace;	for( i = 0; i < count; i++ )	{		r = cos( *seed + i ) * spread * i;		u = sin( *seed + i ) * spread * i;		GS_TraceBullet( &trace, start, dir, r, u, range, ENTNUM( self ), timeDelta );		if( trace.ent != -1 )		{			if( game.edicts[trace.ent].takedamage )			{				G_Damage( &game.edicts[trace.ent], self, self, dir, dir, trace.endpos, damage, kick, stun, dflags, mod );			}			else			{				if( !( trace.surfFlags & SURF_NOIMPACT ) )				{				}			}		}	}}

/** W_Touch_Rocket*/static void W_Touch_Rocket( edict_t *ent, edict_t *other, cplane_t *plane, int surfFlags ) {	int mod_splash;	vec3_t dir;	int hitType;	if( surfFlags & SURF_NOIMPACT ) {		G_FreeEdict( ent );		return;	}	hitType = G_Projectile_HitStyle( ent, other );	if( hitType == PROJECTILE_TOUCH_NOT ) {		return;	}	if( other->takedamage ) {		int directHitDamage = ent->projectileInfo.maxDamage;		VectorNormalize2( ent->velocity, dir );		if( hitType == PROJECTILE_TOUCH_DIRECTSPLASH ) { // use hybrid direction from splash and projectile			G_SplashFrac4D( ENTNUM( other ), ent->s.origin, ent->projectileInfo.radius, dir, NULL, NULL, ent->timeDelta );		} else {			VectorNormalize2( ent->velocity, dir );			if( hitType == PROJECTILE_TOUCH_DIRECTAIRHIT ) {				directHitDamage += DIRECTAIRTHIT_DAMAGE_BONUS;			} else if( hitType == PROJECTILE_TOUCH_DIRECTHIT ) {				directHitDamage += DIRECTHIT_DAMAGE_BONUS;			}		}		G_Damage( other, ent, ent->r.owner, dir, ent->velocity, ent->s.origin, directHitDamage, ent->projectileInfo.maxKnockback, ent->projectileInfo.stun, 0, ent->style );	}	if( ent->s.effects & EF_STRONG_WEAPON ) {		mod_splash = MOD_ROCKET_SPLASH_S;	} else {		mod_splash = MOD_ROCKET_SPLASH_W;	}	G_RadiusDamage( ent, ent->r.owner, plane, other, mod_splash );	// spawn the explosion	if( !( surfFlags & SURF_NOIMPACT ) ) {		edict_t *event;		vec3_t explosion_origin;		VectorMA( ent->s.origin, -0.02, ent->velocity, explosion_origin );		event = G_SpawnEvent( EV_ROCKET_EXPLOSION, DirToByte( plane ? plane->normal : NULL ), explosion_origin );		event->s.firemode = ( ent->s.effects & EF_STRONG_WEAPON ) ? FIRE_MODE_STRONG : FIRE_MODE_WEAK;		event->s.weapon = ( ( ent->projectileInfo.radius * 1 / 8 ) > 255 ) ? 255 : ( ent->projectileInfo.radius * 1 / 8 );	}	// free the rocket at next frame	G_FreeEdict( ent );}

/** W_Fire_Lasergun*/edict_t	*W_Fire_Lasergun( edict_t *self, vec3_t start, vec3_t angles, float damage, int knockback, int stun, int range, int mod, int timeDelta ){	edict_t	*laser;	qboolean newLaser;	trace_t	tr;	vec3_t dir;	if( GS_Instagib() )		damage = 9999;	laser = _FindOrSpawnLaser( self, ET_LASERBEAM, &newLaser );	if( newLaser )	{		// the quad start sound is added from the server		if( self->r.client && self->r.client->ps.inventory[POWERUP_QUAD] > 0 )			G_Sound( self, CHAN_AUTO, trap_SoundIndex( S_QUAD_FIRE ), ATTN_NORM );	}	laser_damage = damage;	laser_knockback = knockback;	laser_stun = stun;	laser_attackerNum = ENTNUM( self );	laser_mod = mod;	laser_missed = qtrue;	GS_TraceLaserBeam( &tr, start, angles, range, ENTNUM( self ), timeDelta, _LaserImpact );	laser->r.svflags |= SVF_FORCEOWNER;	VectorCopy( start, laser->s.origin );	AngleVectors( angles, dir, NULL, NULL );	VectorMA( laser->s.origin, range, dir, laser->s.origin2 );	laser->think = G_Laser_Think;	laser->nextThink = level.time + 100;	if( laser_missed && self->r.client )		G_AwardPlayerMissedLasergun( self, mod );	// calculate laser's mins and maxs for linkEntity	G_SetBoundsForSpanEntity( laser, 8 );	GClip_LinkEntity( laser );	return laser;}

/** G_Teams_InvitePlayer*/static void G_Teams_InvitePlayer( int team, edict_t *ent ){	int i;	if( team < TEAM_PLAYERS || team >= GS_MAX_TEAMS )		return;	if( !ent->r.inuse || !ent->r.client )		return;	for( i = 0; teamlist[team].invited[i] && i < MAX_CLIENTS; i++ )	{		if( teamlist[team].invited[i] == ENTNUM( ent ) )			return;	}	teamlist[team].invited[i] = ENTNUM( ent );}

/** W_Fire_Bullet*/void W_Fire_Bullet( edict_t *self, vec3_t start, vec3_t angles, int seed, int range, int spread, float damage, int knockback, int stun, int mod, int timeDelta ){	vec3_t dir;	edict_t *event;	float r, u;	double alpha, s;	trace_t trace;	int dmgflags = DAMAGE_STUN_CLAMP|DAMAGE_KNOCKBACK_SOFT;	if( GS_Instagib() )		damage = 9999;	AngleVectors( angles, dir, NULL, NULL );	// send the event	event = G_SpawnEvent( EV_FIRE_BULLET, seed, start );	event->s.ownerNum = ENTNUM( self );	event->r.svflags = SVF_TRANSMITORIGIN2;	VectorScale( dir, 4096, event->s.origin2 ); // DirToByte is too inaccurate	event->s.weapon = WEAP_MACHINEGUN;	if( mod == MOD_MACHINEGUN_S )		event->s.weapon |= EV_INVERSE;	// circle shape	alpha = M_PI * Q_crandom( &seed ); // [-PI ..+PI]	s = fabs( Q_crandom( &seed ) ); // [0..1]	r = s * cos( alpha ) * spread;	u = s * sin( alpha ) * spread;	GS_TraceBullet( &trace, start, dir, r, u, range, ENTNUM( self ), timeDelta );	if( trace.ent != -1 )	{		if( game.edicts[trace.ent].takedamage )		{			G_Damage( &game.edicts[trace.ent], self, self, dir, dir, trace.endpos, damage, knockback, stun, dmgflags, mod );		}		else		{			if( !( trace.surfFlags & SURF_NOIMPACT ) )			{			}		}	}}

nav_ents_t *AI_GetGoalentForEnt( edict_t *target ){	int entnum;	if( !target )		return NULL;	entnum = ENTNUM( target );	return nav.entsGoals[entnum];}

/** W_Fire_LinearProjectile - Spawn a generic linear projectile without a model, touch func, sound nor mod*/static edict_t *W_Fire_LinearProjectile( edict_t *self, vec3_t start, vec3_t angles, int speed,										float damage, int minKnockback, int maxKnockback, int stun, int minDamage, int radius, int timeout, int timeDelta ){	edict_t	*projectile;	vec3_t dir;	projectile = G_Spawn();	VectorCopy( start, projectile->s.origin );	VectorCopy( start, projectile->s.old_origin );	VectorCopy( start, projectile->olds.origin );	VectorCopy( angles, projectile->s.angles );	AngleVectors( angles, dir, NULL, NULL );	VectorScale( dir, speed, projectile->velocity );	GS_SnapVelocity( projectile->velocity );	projectile->movetype = MOVETYPE_LINEARPROJECTILE;	projectile->s.linearProjectile = qtrue;	projectile->r.solid = SOLID_YES;	projectile->r.clipmask = ( !GS_RaceGametype() ) ? MASK_SHOT : MASK_SOLID;	projectile->r.svflags = SVF_PROJECTILE;	// enable me when drawing exception is added to cgame	projectile->r.svflags |= SVF_TRANSMITORIGIN2;	VectorClear( projectile->r.mins );	VectorClear( projectile->r.maxs );	projectile->s.modelindex = 0;	projectile->r.owner = self;	projectile->s.ownerNum = ENTNUM( self );	projectile->touch = W_Touch_Projectile; //generic one. Should be replaced after calling this func	projectile->nextThink = level.time + timeout;	projectile->think = G_FreeEdict;	projectile->classname = NULL; // should be replaced after calling this func.	projectile->style = 0;	projectile->s.sound = 0;	projectile->timeStamp = level.time;	projectile->s.linearProjectileTimeStamp = game.serverTime;	projectile->timeDelta = timeDelta;	projectile->projectileInfo.minDamage = min( minDamage, damage );	projectile->projectileInfo.maxDamage = damage;	projectile->projectileInfo.minKnockback = min( minKnockback, maxKnockback );	projectile->projectileInfo.maxKnockback = maxKnockback;	projectile->projectileInfo.stun = stun;	projectile->projectileInfo.radius = radius;	GClip_LinkEntity( projectile );	// update some data required for the transmission	VectorCopy( projectile->velocity, projectile->s.linearProjectileVelocity );	projectile->s.team = self->s.team;	projectile->s.modelindex2 = ( abs( timeDelta ) > 255 ) ? 255 : (unsigned int)abs( timeDelta );	return projectile;}

/** G_Match_RemoveAllProjectiles*/void G_Match_RemoveAllProjectiles( void ){	edict_t *ent;	for( ent = game.edicts + gs.maxclients; ENTNUM( ent ) < game.numentities; ent++ )	{		if( ent->r.inuse && !ent->r.client && ent->r.svflags & SVF_PROJECTILE && ent->r.solid != SOLID_NOT )		{			G_FreeEdict( ent );		}	}}

/** G_RunFrame* Advances the world*/void G_RunFrame( unsigned int msec, unsigned int serverTime ){	G_CheckCvars();	game.localTime = time( NULL );	game.serverTime = serverTime;	G_UpdateFrameTime( msec );	if( !g_snapStarted )		G_StartFrameSnap();	G_CallVotes_Think();	// "freeze" match clock	if( GS_MatchWaiting() || GS_MatchPaused() )	{		gs.gameState.longstats[GAMELONG_MATCHSTART] += msec;	}	if( GS_MatchPaused() )	{		edict_t *ent;		// "freeze" linear projectiles		for( ent = game.edicts + gs.maxclients; ENTNUM( ent ) < game.numentities; ent++ )		{			if( ent->s.linearProjectile )				ent->s.linearProjectileTimeStamp += msec;		}		G_RunClients();		G_RunGametype();		G_LevelGarbageCollect();		return;	}	level.framenum++;	level.time += msec;	level.think_client_entity = G_GetNextThinkClient( level.think_client_entity );	G_SpawnQueue_Think();	// run the world	G_asCallMapPreThink();	G_RunClients();	G_RunEntities();	G_RunGametype();	G_asCallMapPostThink();	GClip_BackUpCollisionFrame();	G_LevelGarbageCollect();}

/** W_Touch_Grenade*/static void W_Touch_Grenade( edict_t *ent, edict_t *other, cplane_t *plane, int surfFlags ){	int hitType;	vec3_t dir;	if( surfFlags & SURF_NOIMPACT )	{		G_FreeEdict( ent );		return;	}	hitType = G_Projectile_HitStyle( ent, other );	if( hitType == PROJECTILE_TOUCH_NOT )		return;	// don't explode on doors and plats that take damage	if( !other->takedamage || ISBRUSHMODEL( other->s.modelindex ) )	{		G_AddEvent( ent, EV_GRENADE_BOUNCE, ( ent->s.effects & EF_STRONG_WEAPON ) ? FIRE_MODE_STRONG : FIRE_MODE_WEAK, true );		return;	}	if( other->takedamage )	{		int directHitDamage = ent->projectileInfo.maxDamage;		VectorNormalize2( ent->velocity, dir );		if( hitType == PROJECTILE_TOUCH_DIRECTSPLASH ) // use hybrid direction from splash and projectile		{			G_SplashFrac4D( ENTNUM( other ), ent->s.origin, ent->projectileInfo.radius, dir, NULL, NULL, ent->timeDelta );		}		else		{			VectorNormalize2( ent->velocity, dir );			// no direct hit bonuses for grenades			/*			if( hitType == PROJECTILE_TOUCH_DIRECTAIRHIT )				directHitDamage += DIRECTAIRTHIT_DAMAGE_BONUS;			else if( hitType == PROJECTILE_TOUCH_DIRECTHIT )				directHitDamage += DIRECTHIT_DAMAGE_BONUS;			*/		}		G_Damage( other, ent, ent->r.owner, dir, ent->velocity, ent->s.origin, directHitDamage, ent->projectileInfo.maxKnockback, ent->projectileInfo.stun, 0, ent->style );	}	ent->enemy = other;	W_Grenade_ExplodeDir( ent, plane ? plane->normal : NULL );}

static edict_t *G_ClosestFlagBase( edict_t *ent ){	int i;	edict_t *t, *best;	float dist, best_dist;	static qboolean firstTime = qtrue;	static unsigned int lastLevelSpawnCount;	static edict_t *flagBases[GS_MAX_TEAMS];	// store pointers to flag bases if called for the first time in this level spawn	if( firstTime || lastLevelSpawnCount != game.levelSpawnCount )	{		for( t = game.edicts + 1 + gs.maxclients; ENTNUM( t ) < game.numentities; t++ )		{			if( t->s.type != ET_FLAG_BASE )				continue;			flagBases[t->s.team] = t;		}		// ok, remember last time we were called		firstTime = qfalse;		lastLevelSpawnCount = game.levelSpawnCount;	}	best = NULL;	best_dist = 9999999;	// find the closest flag base starting from TEAM_ALPHA	for( i = TEAM_ALPHA; i < GS_MAX_TEAMS; i++ )	{		t = flagBases[i];		if( !t )			continue;		// if equally distant from two bases, consider this item neutral		dist = Distance( ent->s.origin, t->s.origin );		if( best && fabs( dist - best_dist ) < 10 )		{			best = NULL;			break;		}		if( dist < best_dist )		{			best_dist = dist;			best = t;		}	}	return best;}

/** W_Fire_Bullet*/void W_Fire_Bullet( edict_t *self, vec3_t start, vec3_t fv, vec3_t rv, vec3_t uv, int seed, int range, 	int hspread, int vspread, float damage, int knockback, int stun, int mod, int timeDelta ) {	edict_t *event;	float r, u;	double alpha, s;	trace_t trace;	int dmgflags = DAMAGE_STUN_CLAMP | DAMAGE_KNOCKBACK_SOFT;	if( GS_Instagib() ) {		damage = 9999;	}	// send the event	event = G_SpawnEvent( EV_FIRE_BULLET, seed, start );	event->s.ownerNum = ENTNUM( self );	VectorCopy( fv, event->s.origin2 );	VectorCopy( rv, event->s.origin3 );	event->s.weapon = WEAP_MACHINEGUN;	event->s.firemode = ( mod == MOD_MACHINEGUN_S ) ? FIRE_MODE_STRONG : FIRE_MODE_WEAK;	// circle shape	alpha = M_PI * Q_crandom( &seed ); // [-PI ..+PI]	s = fabs( Q_crandom( &seed ) ); // [0..1]	r = s * cos( alpha ) * hspread;	u = s * sin( alpha ) * vspread;	GS_TraceBullet( &trace, start, fv, rv, uv, r, u, range, ENTNUM( self ), timeDelta );	if( trace.ent != -1 ) {		if( game.edicts[trace.ent].takedamage ) {			G_Damage( &game.edicts[trace.ent], self, self, fv, fv, trace.endpos, damage, knockback, stun, dmgflags, mod );		} else {			if( !( trace.surfFlags & SURF_NOIMPACT ) ) {			}		}	}}

/** W_Touch_GunbladeBlast*/static void W_Touch_GunbladeBlast( edict_t *ent, edict_t *other, cplane_t *plane, int surfFlags ){	vec3_t dir;	int hitType;	if( surfFlags & SURF_NOIMPACT )	{		G_FreeEdict( ent );		return;	}	hitType = G_Projectile_HitStyle( ent, other );	if( hitType == PROJECTILE_TOUCH_NOT )		return;	if( other->takedamage )	{		VectorNormalize2( ent->velocity, dir );		if( hitType == PROJECTILE_TOUCH_DIRECTSPLASH ) // use hybrid direction from splash and projectile		{			G_SplashFrac4D( ENTNUM( other ), ent->s.origin, ent->projectileInfo.radius, dir, NULL, NULL, ent->timeDelta );		}		else		{			VectorNormalize2( ent->velocity, dir );		}		G_Damage( other, ent, ent->r.owner, dir, ent->velocity, ent->s.origin, ent->projectileInfo.maxDamage, ent->projectileInfo.maxKnockback, ent->projectileInfo.stun, 0, ent->style );	}	G_RadiusDamage( ent, ent->r.owner, plane, other, MOD_GUNBLADE_S );	// add explosion event	if( ( !other->takedamage || ISBRUSHMODEL( other->s.modelindex ) ) )	{		edict_t *event;		event = G_SpawnEvent( EV_GUNBLADEBLAST_IMPACT, DirToByte( plane ? plane->normal : NULL ), ent->s.origin );		event->s.weapon = ( ( ent->projectileInfo.radius * 1/8 ) > 127 ) ? 127 : ( ent->projectileInfo.radius * 1/8 );		event->s.skinnum = ( ( ent->projectileInfo.maxKnockback * 1/8 ) > 255 ) ? 255 : ( ent->projectileInfo.maxKnockback * 1/8 );	}	// free at next frame	G_FreeEdict( ent );}

/** G_Trace* * Moves the given mins/maxs volume through the world from start to end.* * Passedict and edicts owned by passedict are explicitly not checked.* ------------------------------------------------------------------* mins and maxs are relative* if the entire move stays in a solid volume, trace.allsolid will be set,* trace.startsolid will be set, and trace.fraction will be 0* if the starting point is in a solid, it will be allowed to move out* to an open area* passedict is explicitly excluded from clipping checks (normally NULL)*/static void GClip_Trace( trace_t *tr, vec3_t start, vec3_t mins, vec3_t maxs, 	vec3_t end, edict_t *passedict, int contentmask, int timeDelta ){	moveclip_t clip;	if( !tr )		return;	if( !mins )		mins = vec3_origin;	if( !maxs )		maxs = vec3_origin;	if( passedict == world )	{		memset( tr, 0, sizeof( trace_t ) );		tr->fraction = 1;		tr->ent = -1;	}	else	{		// clip to world		trap_CM_TransformedBoxTrace( tr, start, end, mins, maxs, NULL, contentmask, NULL, NULL );		tr->ent = tr->fraction < 1.0 ? world->s.number : -1;		if( tr->fraction == 0 )			return; // blocked by the world	}	memset( &clip, 0, sizeof( moveclip_t ) );	clip.trace = tr;	clip.contentmask = contentmask;	clip.start = start;	clip.end = end;	clip.mins = mins;	clip.maxs = maxs;	clip.passent = passedict ? ENTNUM( passedict ) : -1;	VectorCopy( mins, clip.mins2 );	VectorCopy( maxs, clip.maxs2 );	// create the bounding box of the entire move	GClip_TraceBounds( start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs );	// clip to other solid entities	GClip_ClipMoveToEntities( &clip, timeDelta );}

/** TVM_ClientEndSnapFrame* * Called for each player at the end of the server frame* and right after spawning*/void TVM_ClientEndSnapFrame( edict_t *ent ){	edict_t *spec;	tvm_relay_t *relay = ent->relay;	assert( ent && ent->local && ent->r.client && !ent->r.client->chase.active );	if( relay->playernum < 0 )		spec = NULL;	else		spec = relay->edicts + relay->playernum + 1;	if( relay->frame.valid && !relay->frame.multipov )	{		assert( spec );		ent->r.client->ps = spec->r.client->ps;		ent->r.client->ps.pmove.pm_type = PM_CHASECAM;		ent->r.client->ps.pmove.pm_flags |= PMF_NO_PREDICTION;		ent->r.client->ps.POVnum = PLAYERNUM( spec ) + 1;		ent->s = spec->s;		ent->s.number = ENTNUM( ent );		return;	}	if( spec && spec->r.inuse && spec->r.client )	{		memcpy( ent->r.client->ps.stats, spec->r.client->ps.stats, sizeof( ent->r.client->ps.stats ) );		memcpy( ent->r.client->ps.inventory, spec->r.client->ps.inventory, sizeof( ent->r.client->ps.inventory ) );	}	else	{		memset( ent->r.client->ps.stats, 0, sizeof( ent->r.client->ps.stats ) );		memset( ent->r.client->ps.inventory, 0, sizeof( ent->r.client->ps.inventory ) );	}	ent->r.client->ps.viewheight = ent->viewheight;	if( relay->playernum < 0 )		ent->r.client->ps.POVnum = 255; // FIXME	else		ent->r.client->ps.POVnum = relay->playernum + 1;	if( TVM_ClientIsZoom( ent ) )		ent->r.client->ps.fov = ent->r.client->pers.zoomfov;	else		ent->r.client->ps.fov = ent->r.client->pers.fov;}

/** G_SpawnQueue_RemoveClient - Check all queues for this client and remove it*/void G_SpawnQueue_RemoveClient( edict_t *ent ){	g_teamspawnqueue_t *queue;	int i, team;	if( !ent->r.client )		return;	for( team = TEAM_SPECTATOR; team < GS_MAX_TEAMS; team++ )	{		queue = &g_spawnQueues[team];		for( i = queue->start; i < queue->head; i++ )		{			if( queue->list[i % MAX_CLIENTS] == ENTNUM( ent ) )				queue->list[i % MAX_CLIENTS] = -1;		}	}}

/** G_Teams_PlayerIsInvited*/static bool G_Teams_PlayerIsInvited( int team, edict_t *ent ){	int i;	if( team < TEAM_PLAYERS || team >= GS_MAX_TEAMS )		return false;	if( !ent->r.inuse || !ent->r.client )		return false;	for( i = 0; teamlist[team].invited[i] && i < MAX_CLIENTS; i++ )	{		if( teamlist[team].invited[i] == ENTNUM( ent ) )			return true;	}	return false;}

/** W_Fire_Electrobolt_Weak*/edict_t *W_Fire_Electrobolt_Weak( edict_t *self, vec3_t start, vec3_t angles, float speed, float damage, int minKnockback, int maxKnockback, int stun, int timeout, int mod, int timeDelta ){	edict_t	*bolt;	if( GS_Instagib() )		damage = 9999;	// projectile, weak mode	bolt = W_Fire_LinearProjectile( self, start, angles, speed, damage, minKnockback, maxKnockback, stun, 0, 0, timeout, timeDelta );	bolt->s.modelindex = trap_ModelIndex( PATH_ELECTROBOLT_WEAK_MODEL );	bolt->s.type = ET_ELECTRO_WEAK; //add particle trail and light	bolt->s.ownerNum = ENTNUM( self );	bolt->touch = W_Touch_Bolt;	bolt->classname = "bolt";	bolt->style = mod;	bolt->s.effects &= ~EF_STRONG_WEAPON;	return bolt;}