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

/*================CG_ReflectVelocity================*/void CG_ReflectVelocity( localEntity_t *le, trace_t *trace ) {	vec3_t	velocity;	float	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = cg.time - cg.frametime + cg.frametime * trace->fraction;	BG_EvaluateTrajectoryDelta( &le->pos, hitTime, velocity );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2*dot, trace->plane.normal, le->pos.trDelta );	VectorScale( le->pos.trDelta, le->bounceFactor, le->pos.trDelta );	VectorCopy( trace->endpos, le->pos.trBase );	le->pos.trTime = cg.time;	// check for stop, making sure that even on low FPS systems it doesn't bobble	if ( trace->allsolid || 		( trace->plane.normal[2] > 0 && 		( le->pos.trDelta[2] < 40 || le->pos.trDelta[2] < -cg.frametime * le->pos.trDelta[2] ) ) ) {		le->pos.trType = TR_STATIONARY;	} else {	}}

/*================CG_ReflectVelocity================*/void CG_ReflectVelocity( localEntity_t *le, trace_t *trace ) {	bvec3_t	velocity;	bfixed	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = cg.time - cg.frametime + FIXED_TO_INT(MAKE_GFIXED(cg.frametime) * trace->fraction);	BG_EvaluateTrajectoryDelta( &le->pos, hitTime, velocity );	dot = FIXED_VEC3DOT( velocity, trace->plane.normal );	FIXED_VEC3MA_R( velocity, -BFIXED(2,0)*dot, trace->plane.normal, le->pos.trDelta );	FIXED_VEC3SCALE( le->pos.trDelta, le->bounceFactor, le->pos.trDelta );	VectorCopy( trace->endpos, le->pos.trBase );	le->pos.trTime = cg.time;	// check for stop, making sure that even on low FPS systems it doesn't bobble	if ( trace->allsolid || 		( trace->plane.normal[2] > AFIXED_0 && 		( le->pos.trDelta[2] < BFIXED(40,0) || le->pos.trDelta[2] < -MAKE_BFIXED(cg.frametime) * le->pos.trDelta[2] ) ) ) {		le->pos.trType = TR_STATIONARY;	} else {	}}

/*================G_PredictBounceMissile================*/void G_PredictBounceMissile( gentity_t *ent, trajectory_t *pos, trace_t *trace, int time ) {	vec3_t velocity, origin;	float dot;	int hitTime;	BG_EvaluateTrajectory( pos, time, origin );	// reflect the velocity on the trace plane	hitTime = time;	BG_EvaluateTrajectoryDelta( pos, hitTime, velocity );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2 * dot, trace->plane.normal, pos->trDelta );	if ( ent->s.eFlags & EF_BOUNCE_HALF ) {		if ( ent->s.eFlags & EF_BOUNCE ) {     // both flags marked, do a third type of bounce			VectorScale( pos->trDelta, 0.35, pos->trDelta );		} else {			VectorScale( pos->trDelta, 0.65, pos->trDelta );		}		// check for stop		if ( trace->plane.normal[2] > 0.2 && VectorLength( pos->trDelta ) < 40 ) {			VectorCopy( trace->endpos, pos->trBase );			return;		}	}	VectorAdd( origin, trace->plane.normal, pos->trBase );	pos->trTime = time;}

/*================G_BounceMissile================*/void G_BounceMissile( gentity_t *ent, trace_t *trace ){  vec3_t  velocity;  float dot;  int   hitTime;  // reflect the velocity on the trace plane  hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;  BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );  dot = DotProduct( velocity, trace->plane.normal );  VectorMA( velocity, -2 * dot, trace->plane.normal, ent->s.pos.trDelta );  if( ent->s.eFlags & EF_BOUNCE_HALF )  {    VectorScale( ent->s.pos.trDelta, 0.65, ent->s.pos.trDelta );    // check for stop    if( trace->plane.normal[ 2 ] > 0.2 && VectorLength( ent->s.pos.trDelta ) < 40 )    {      G_SetOrigin( ent, trace->endpos );      return;    }  }  VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin );  VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );  ent->s.pos.trTime = level.time;}

/*================G_BounceMissile================*/void G_BounceMissile( gentity_t *ent, trace_t *trace ) {	vec3_t	velocity;	float	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );	if ( ent->s.eFlags & EF_BOUNCE_HALF ) {#ifndef SMOKINGUNS		VectorScale( ent->s.pos.trDelta, 0.65, ent->s.pos.trDelta );#else		VectorScale( ent->s.pos.trDelta, 0.17, ent->s.pos.trDelta );#endif		// check for stop		if ( trace->plane.normal[2] > 0.2 && VectorLength( ent->s.pos.trDelta ) < 40 ) {			G_SetOrigin( ent, trace->endpos );#ifdef SMOKINGUNS			if(!Q_stricmp(ent->classname, "grenadeno")){				ent->classname = "grenadeend";				VectorCopy(trace->endpos, ent->s.origin2);			}#endif			return;		}	}	VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin);	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );	ent->s.pos.trTime = level.time;}

/*================G_BounceMissile================*/void G_BounceMissile( gentity_t *ent, trace_t *trace ){    vec3_t  velocity;    float dot;    int   hitTime;    float cor = 1.;    if( !strcmp( ent->classname, "bounceball" ) )        cor = .8;    // reflect the velocity on the trace plane    hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;    BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );    dot = DotProduct( velocity, trace->plane.normal );    VectorMA( velocity, -(1+cor) * dot, trace->plane.normal, ent->s.pos.trDelta );    if( ent->s.eFlags & EF_BOUNCE_HALF )    {        if(!strcmp(ent->classname,"grenade") && g_proximityMines.integer) {            VectorScale( ent->s.pos.trDelta, 0.00, ent->s.pos.trDelta );        } else {            VectorScale( ent->s.pos.trDelta, 0.65, ent->s.pos.trDelta );        }        // check for stop        if( trace->plane.normal[ 2 ] > 0.2 && VectorLength( ent->s.pos.trDelta ) < 40 )        {            G_SetOrigin( ent, trace->endpos );            return;        }    }    VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin );    VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );    ent->s.pos.trTime = level.time;}

void G_BounceMissile_Q3( gentity_t *ent, trace_t *trace ) {	vector3	velocity;	float	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = level.previousTime + (int)(( level.time - level.previousTime ) * trace->fraction);	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, &velocity );	dot = DotProduct( &velocity, &trace->plane.normal );	VectorMA( &velocity, -2*dot, &trace->plane.normal, &ent->s.pos.trDelta );	if ( ent->flags & FL_BOUNCE_HALF ) {		VectorScale( &ent->s.pos.trDelta, 0.65f, &ent->s.pos.trDelta );		// check for stop		if ( trace->plane.normal.z > 0.2f && VectorLength( &ent->s.pos.trDelta ) < 40 ) {			G_SetOrigin( ent, &trace->endpos );			ent->s.time = level.time / 4;			return;		}	}	VectorAdd( &ent->r.currentOrigin, &trace->plane.normal, &ent->r.currentOrigin);	VectorCopy( &ent->r.currentOrigin, &ent->s.pos.trBase );	ent->s.pos.trTime = level.time;}

/*================G_BounceItem================*/void G_BounceItem( gentity_t *ent, trace_t *trace ) {	vec3_t	velocity;	float	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );	// cut the velocity to keep from bouncing forever	VectorScale( ent->s.pos.trDelta, ent->physicsBounce, ent->s.pos.trDelta );	// check for stop	if ( trace->plane.normal[2] > 0 && ent->s.pos.trDelta[2] < 40 ) {		trace->endpos[2] += 1.0;	// make sure it is off ground		SnapVector( trace->endpos );		G_SetOrigin( ent, trace->endpos );		ent->s.groundEntityNum = trace->entityNum;		return;	}	VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin);	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );	ent->s.pos.trTime = level.time;}

/*================G_BounceMissile================*/void G_BounceMissile( gentity_t *ent, trace_t *trace ) {    vec3_t	velocity;    float	dot;    int		hitTime;    // reflect the velocity on the trace plane    hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;    BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );    dot = DotProduct( velocity, trace->plane.normal );    VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );    if ( ent->flags & FL_BOUNCE_SHRAPNEL )    {        VectorScale( ent->s.pos.trDelta, 0.25f, ent->s.pos.trDelta );        ent->s.pos.trType = TR_GRAVITY;        // check for stop        if ( trace->plane.normal[2] > 0.7 && ent->s.pos.trDelta[2] < 40 ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7        {            G_SetOrigin( ent, trace->endpos );            ent->nextthink = level.time + 100;            return;        }    }    else if ( ent->flags & FL_BOUNCE_HALF )    {        VectorScale( ent->s.pos.trDelta, 0.65f, ent->s.pos.trDelta );        // check for stop        if ( trace->plane.normal[2] > 0.2 && VectorLength( ent->s.pos.trDelta ) < 40 )        {            G_SetOrigin( ent, trace->endpos );            return;        }    }    if (ent->s.weapon == WP_THERMAL)    {   //slight hack for hit sound        G_Sound(ent, CHAN_BODY, G_SoundIndex(va("sound/weapons/thermal/bounce%i.wav", Q_irand(1, 2))));    }    else if (ent->s.weapon == WP_SABER)    {        G_Sound(ent, CHAN_BODY, G_SoundIndex(va("sound/weapons/saber/bounce%i.wav", Q_irand(1, 3))));    }    else if (ent->s.weapon == G2_MODEL_PART)    {        //Limb bounce sound?    }    VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin);    VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );    ent->s.pos.trTime = level.time;    if (ent->bounceCount != -5)    {        ent->bounceCount--;    }}

/*================G_BounceMissile================*/void G_BounceMissile( gentity_t *ent, trace_t *trace ) {	vec3_t velocity;	float dot;	int hitTime;// Arnout: removed this for MP as well (was already gone from SP)/*		// Ridah, if we are a grenade, and we have hit an AI that is waiting to catch us, give them a grenade, and delete ourselves	if ((ent->splashMethodOfDeath == MOD_GRENADE_SPLASH) && (g_entities[trace->entityNum].flags & FL_AI_GRENADE_KICK) &&		(trace->endpos[2] > g_entities[trace->entityNum].r.currentOrigin[2])) {		g_entities[trace->entityNum].grenadeExplodeTime = ent->nextthink;		g_entities[trace->entityNum].flags &= ~FL_AI_GRENADE_KICK;		Add_Ammo( &g_entities[trace->entityNum], WP_GRENADE_LAUNCHER, 1, qfalse );	//----(SA)	modified		G_FreeEntity( ent );		return;	}*/	// reflect the velocity on the trace plane	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2 * dot, trace->plane.normal, ent->s.pos.trDelta );	// RF, record this for mover pushing	if ( trace->plane.normal[2] > 0.2 /*&& VectorLength( ent->s.pos.trDelta ) < 40*/ ) {		ent->s.groundEntityNum = trace->entityNum;	}	if ( ent->s.eFlags & EF_BOUNCE_HALF ) {		if ( ent->s.eFlags & EF_BOUNCE ) {     // both flags marked, do a third type of bounce			VectorScale( ent->s.pos.trDelta, 0.35, ent->s.pos.trDelta );		} else {			VectorScale( ent->s.pos.trDelta, 0.65, ent->s.pos.trDelta );		}		// check for stop		if ( trace->plane.normal[2] > 0.2 && VectorLength( ent->s.pos.trDelta ) < 40 ) {//----(SA)	make the world the owner of the dynamite, so the player can shoot it after it stops moving			if ( ent->s.weapon == WP_DYNAMITE || ent->s.weapon == WP_DYNAMITE2 ) {				ent->r.ownerNum = ENTITYNUM_WORLD;			}//----(SA)	end			G_SetOrigin( ent, trace->endpos );			return;		}	}	SnapVector( ent->s.pos.trDelta );	VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin );	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );	SnapVector( ent->s.pos.trBase );	ent->s.pos.trTime = level.time;}

/*================G_Bounce================*/static void G_Bounce( gentity_t *ent, trace_t *trace ){	vec3_t   velocity;	float    dot;	int      hitTime;	float    minNormal;	qboolean invert = qfalse;	// reflect the velocity on the trace plane	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2 * dot, trace->plane.normal, ent->s.pos.trDelta );	if ( ent->s.eType == ET_BUILDABLE )	{		minNormal = BG_Buildable( ent->s.modelindex )->minNormal;		invert = BG_Buildable( ent->s.modelindex )->invertNormal;	}	else	{		minNormal = 0.707f;	}	// cut the velocity to keep from bouncing forever	if ( ( trace->plane.normal[ 2 ] >= minNormal ||	       ( invert && trace->plane.normal[ 2 ] <= -minNormal ) ) &&	     trace->entityNum == ENTITYNUM_WORLD )	{		VectorScale( ent->s.pos.trDelta, ent->physicsBounce, ent->s.pos.trDelta );	}	else	{		VectorScale( ent->s.pos.trDelta, 0.3f, ent->s.pos.trDelta );	}	if ( VectorLength( ent->s.pos.trDelta ) < 10 )	{		VectorMA( trace->endpos, 0.5f, trace->plane.normal, trace->endpos );  // make sure it is off ground		G_SetOrigin( ent, trace->endpos );		ent->s.groundEntityNum = trace->entityNum;		VectorCopy( trace->plane.normal, ent->s.origin2 );		VectorSet( ent->s.pos.trDelta, 0.0f, 0.0f, 0.0f );		return;	}	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );	VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin );	ent->s.pos.trTime = level.time;}

/*================CG_ReflectVelocity================*/void CG_ReflectVelocity( localEntity_t *le, trace_t *trace ) {	vec3_t	velocity;	float	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = cg.time - cg.frametime + cg.frametime * trace->fraction;	BG_EvaluateTrajectoryDelta( &le->pos, hitTime, velocity );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2*dot, trace->plane.normal, le->pos.trDelta );	VectorScale( le->pos.trDelta, le->bounceFactor, le->pos.trDelta );	VectorCopy( trace->endpos, le->pos.trBase );	le->pos.trTime = cg.time;	// check for stop, making sure that even on low FPS systems it doesn't bobble	if (le->leMarkType == LEMT_BLOOD && trace->startsolid)		{			//centity_t *cent;			//cent = &cg_entities[trace->entityNum];			//if (cent && cent->currentState.apos.trType != TR_STATIONARY)			//	le->pos.trType = TR_STATIONARY;		}	else if ( trace->allsolid || 		( trace->plane.normal[2] > 0 && 		( le->pos.trDelta[2] < 40 || le->pos.trDelta[2] < -cg.frametime * le->pos.trDelta[2] ) ) ) {//----(SA)	if it's a fragment and it's not resting on the world...//			if(le->leType == LE_DEBRIS && trace->entityNum < (MAX_ENTITIES - 1))			if(le->leType == LE_FRAGMENT && trace->entityNum < (MAX_ENTITIES - 1))			{				le->pos.trType = TR_GRAVITY_PAUSED;			}			else			{				le->pos.trType = TR_STATIONARY;			}	}	else {	}}

void G_BounceMissile_JA( gentity_t *ent, trace_t *trace ) {	vector3	velocity;	float	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = level.previousTime + (int)(( level.time - level.previousTime ) * trace->fraction);	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, &velocity );	dot = DotProduct( &velocity, &trace->plane.normal );	VectorMA( &velocity, -2*dot, &trace->plane.normal, &ent->s.pos.trDelta );	if ( ent->flags & FL_BOUNCE_SHRAPNEL ) 	{		VectorScale( &ent->s.pos.trDelta, 0.25f, &ent->s.pos.trDelta );		ent->s.pos.trType = TR_GRAVITY;		// check for stop		if ( trace->plane.normal.z > 0.7f && ent->s.pos.trDelta.z < 40 ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7f		{			G_SetOrigin( ent, &trace->endpos );			ent->nextthink = level.time + 100;			return;		}	}	else if ( ent->flags & FL_BOUNCE_HALF ) 	{		VectorScale( &ent->s.pos.trDelta, 0.65f, &ent->s.pos.trDelta );		// check for stop		if ( trace->plane.normal.z > 0.2f && VectorLength( &ent->s.pos.trDelta ) < 40 ) 		{			G_SetOrigin( ent, &trace->endpos );			return;		}	}	VectorAdd( &ent->r.currentOrigin, &trace->plane.normal, &ent->r.currentOrigin);	VectorCopy( &ent->r.currentOrigin, &ent->s.pos.trBase );	ent->s.pos.trTime = level.time;	if (ent->bounceCount != -5)		ent->bounceCount--;}

/*================CG_ReflectVelocity================*/void CG_ReflectVelocity(localEntity_t * le, trace_t * trace){	vec3_t          velocity;	float           dot;	int             hitTime;	// reflect the velocity on the trace plane	hitTime = cg.time - cg.frametime + cg.frametime * trace->fraction;	BG_EvaluateTrajectoryDelta(&le->pos, hitTime, velocity);	dot = DotProduct(velocity, trace->plane.normal);	VectorMA(velocity, -2 * dot, trace->plane.normal, le->pos.trDelta);	VectorScale(le->pos.trDelta, le->bounceFactor, le->pos.trDelta);	VectorCopy(trace->endpos, le->pos.trBase);	le->pos.trTime = cg.time;	// check for stop, making sure that even on low FPS systems it doesn't bobble	if(trace->allsolid ||	   (trace->plane.normal[2] > 0 && (le->pos.trDelta[2] < 40 || le->pos.trDelta[2] < -cg.frametime * le->pos.trDelta[2])))	{		le->pos.trType = TR_STATIONARY;	}	else	{		if(le->leFlags & LEF_TUMBLE)		{			// collided with a surface so calculate the new rotation axis			CrossProduct(trace->plane.normal, velocity, le->rotAxis);			le->angVel = VectorNormalize(le->rotAxis) / le->radius;			// save current orientation as a rotation from model's base orientation			QuatMultiply0(le->quatRot, le->quatOrient);			// reset the orientation			QuatClear(le->quatOrient);		}	}}

/*================G_BounceItem================*/void G_BounceItem( gentity_t *ent, trace_t *trace ) {	vec3_t	velocity;	float	dot;	int		hitTime;	// reflect the velocity on the trace plane	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity, qfalse, ent->s.effect2Time );	dot = DotProduct( velocity, trace->plane.normal );	VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );	// cut the velocity to keep from bouncing forever	VectorScale( ent->s.pos.trDelta, ent->physicsBounce, ent->s.pos.trDelta );	// check for stop	if ( trace->plane.normal[2] > 0 && ent->s.pos.trDelta[2] < 40 ) {		if (g_flushItems.integer) {			vectoangles( trace->plane.normal, ent->s.angles );			ent->s.angles[0] += 90;			if (ent->s.angles[0] > 0.0 && ent->s.angles[0] < 50.0) {				// avoid freaky medpacks				G_SetAngle( ent, ent->s.angles);				trace->endpos[2] -= (tan(DEG2RAD(ent->s.angles[0])) * ITEM_RADIUS);			} else {				trace->endpos[2] += 1.0;   // make sure it is off ground			}		} else {			trace->endpos[2] += 1.0;   // make sure it is off ground		}		SnapVector( trace->endpos );		G_SetOrigin( ent, trace->endpos );		ent->s.groundEntityNum = trace->entityNum;		return;	}	VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin);	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );	ent->s.pos.trTime = level.time;}

/*================CG_AddFragment================*/void CG_AddFragment( localEntity_t *le ) {	vec3_t	newOrigin;	trace_t	trace;	if ( le->pos.trType == TR_STATIONARY ) {		// sink into the ground if near the removal time		int		t;		float	oldZ;				t = le->endTime - cg.time;		if ( t < SINK_TIME ) {			// we must use an explicit lighting origin, otherwise the			// lighting would be lost as soon as the origin went			// into the ground			VectorCopy( le->refEntity.origin, le->refEntity.lightingOrigin );			le->refEntity.renderfx |= RF_LIGHTING_ORIGIN;			oldZ = le->refEntity.origin[2];			le->refEntity.origin[2] -= 16 * ( 1.0 - (float)t / SINK_TIME );			trap_R_AddRefEntityToScene( &le->refEntity );			le->refEntity.origin[2] = oldZ;		} else {			trap_R_AddRefEntityToScene( &le->refEntity );		}		return;	}	// calculate new position	BG_EvaluateTrajectory( &le->pos, cg.time, newOrigin );	// trace a line from previous position to new position	CG_Trace( &trace, le->refEntity.origin, NULL, NULL, newOrigin, -1, CONTENTS_SOLID );	if ( trace.fraction == 1.0 ) {		qboolean	inWater;		vec3_t		newDelta;		// still in free fall		VectorCopy( newOrigin, le->refEntity.origin );		// check for water		inWater = CG_PointContents( newOrigin, -1 ) & CONTENTS_WATER;		if ( inWater && le->pos.trType == TR_GRAVITY ) {			BG_EvaluateTrajectoryDelta( &le->pos, cg.time, newDelta );			le->pos.trType = TR_WATER_GRAVITY;			VectorCopy( newOrigin, le->pos.trBase );			VectorCopy( newDelta, le->pos.trDelta );			le->pos.trTime = cg.time;		}		if ( !inWater && le->pos.trType == TR_WATER_GRAVITY ) {			BG_EvaluateTrajectoryDelta( &le->pos, cg.time, newDelta );			le->pos.trType = TR_GRAVITY;			VectorCopy( newOrigin, le->pos.trBase );			VectorCopy( newDelta, le->pos.trDelta );			le->pos.trTime = cg.time;		}		if ( le->leFlags & LEF_TUMBLE ) {			vec3_t angles;			BG_EvaluateTrajectory( &le->angles, cg.time, angles );			AnglesToAxis( angles, le->refEntity.axis );		}		trap_R_AddRefEntityToScene( &le->refEntity );		// add a fire trail		// CG_FireTrail( le );		return;	}	// if it is in a nodrop zone, remove it	// this keeps gibs from waiting at the bottom of pits of death	// and floating levels	if ( trap_CM_PointContents( trace.endpos, 0 ) & CONTENTS_NODROP ) {		CG_FreeLocalEntity( le );		return;	}	// stop rotation	le->angles.trType = TR_STATIONARY;	// leave a mark	CG_FragmentBounceMark( le, &trace );	// reflect the velocity on the trace plane	CG_ReflectVelocity( le, &trace );	trap_R_AddRefEntityToScene( &le->refEntity );}

void G_MissileImpact( gentity_t *ent, trace_t *trace ) {#elsevoid G_MissileImpact( gentity_t *ent, trace_t *trace, int shaderNum ) {#endif	gentity_t		*other;	qboolean		hitClient = qfalse;#ifndef SMOKINGUNS#ifdef MISSIONPACK	vec3_t			forward, impactpoint, bouncedir;	int				eFlags;#endif#else	qboolean		hitKnife  = qfalse;	vec3_t			bottledirs[ALC_COUNT];#endif	other = &g_entities[trace->entityNum];#ifndef SMOKINGUNS	// check for bounce	if ( !other->takedamage &&		( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {		G_BounceMissile( ent, trace );		G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );		return;	}#ifdef MISSIONPACK	if ( other->takedamage ) {		if ( ent->s.weapon != WP_PROX_LAUNCHER ) {			if ( other->client && other->client->invulnerabilityTime > level.time ) {				//				VectorCopy( ent->s.pos.trDelta, forward );				VectorNormalize( forward );				if (G_InvulnerabilityEffect( other, forward, ent->s.pos.trBase, impactpoint, bouncedir )) {					VectorCopy( bouncedir, trace->plane.normal );					eFlags = ent->s.eFlags & EF_BOUNCE_HALF;					ent->s.eFlags &= ~EF_BOUNCE_HALF;					G_BounceMissile( ent, trace );					ent->s.eFlags |= eFlags;				}				ent->target_ent = other;				return;			}		}	}#endif	// impact damage	if (other->takedamage) {#else	if(other->takedamage)		hitKnife = qtrue;	// check for bounce	if ( ( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {		G_BounceMissile( ent, trace );		return;	}	if (other->takedamage && ent->s.weapon != WP_DYNAMITE) {#endif		// FIXME: wrong damage direction?		if ( ent->damage ) {			vec3_t	velocity;			if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {				g_entities[ent->r.ownerNum].client->accuracy_hits++;				hitClient = qtrue;			}			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );			if ( VectorLength( velocity ) == 0 ) {				velocity[2] = 1;	// stepped on a grenade			}#ifndef SMOKINGUNS			G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,				ent->s.origin, ent->damage,				0, ent->methodOfDeath);#else			// you can't make dynamite exploding by using a knife			if(!(ent->s.weapon == WP_KNIFE && other->s.weapon == WP_DYNAMITE &&				other->s.eType == ET_ITEM)){				// prepare breakable, if not already initialized				if(!(other->flags & FL_BREAKABLE_INIT))					G_BreakablePrepare(other, shaderNum);				G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,					ent->s.origin, ent->damage,					0, ent->methodOfDeath);			}#endif		}	}#ifndef SMOKINGUNS	if( ent->s.weapon == WP_PROX_LAUNCHER ) {		if( ent->s.pos.trType != TR_GRAVITY ) {			return;		}//.........这里部分代码省略.........

static void MissileImpact( gentity_t *ent, trace_t *trace ){	int       dirAsByte, impactFlags;	const missileAttributes_t *ma = BG_Missile( ent->s.modelindex );	gentity_t *hitEnt   = &g_entities[ trace->entityNum ];	gentity_t *attacker = &g_entities[ ent->r.ownerNum ];	// Returns whether damage and hit effects should be done and played.	std::function<int(gentity_t*, trace_t*, gentity_t*)> impactFunc;	// Check for bounce.	if ( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) &&	     !HasComponents<HealthComponent>(*hitEnt->entity) )	{		BounceMissile( ent, trace );		if ( !( ent->s.eFlags & EF_NO_BOUNCE_SOUND ) )		{			G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );		}		return;	}	// Call missile specific impact functions.	switch( ent->s.modelindex )	{		case MIS_GRENADE:      impactFunc = ImpactGrenade;     break;		case MIS_FIREBOMB:     impactFunc = ImpactGrenade;     break;		case MIS_FLAMER:       impactFunc = ImpactFlamer;      break;		case MIS_FIREBOMB_SUB: impactFunc = ImpactFirebombSub; break;		case MIS_LOCKBLOB:     impactFunc = ImpactLockblock;   break;		case MIS_SLOWBLOB:     impactFunc = ImpactSlowblob;    break;		case MIS_HIVE:         impactFunc = ImpactHive;        break;		default:               impactFunc = DefaultImpactFunc; break;	}	impactFlags = impactFunc( ent, trace, hitEnt );	// Deal impact damage.	if ( !( impactFlags & MIF_NO_DAMAGE ) )	{		if ( ent->damage && G_Alive( hitEnt ) )		{			vec3_t dir;			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, dir );			if ( VectorNormalize( dir ) == 0 )			{				dir[ 2 ] = 1; // stepped on a grenade			}			int dflags = 0;			if ( !ma->doLocationalDamage ) dflags |= DAMAGE_NO_LOCDAMAGE;			if ( ma->doKnockback )         dflags |= DAMAGE_KNOCKBACK;			hitEnt->entity->Damage(ent->damage * MissileTimeDmgMod(ent), attacker,			                       Vec3::Load(trace->endpos), Vec3::Load(dir), dflags,			                       (meansOfDeath_t)ent->methodOfDeath);		}		// splash damage (doesn't apply to person directly hit)		if ( ent->splashDamage )		{			G_RadiusDamage( trace->endpos, ent->parent,			                ent->splashDamage * MissileTimeSplashDmgMod( ent ),			                ent->splashRadius, hitEnt, ( ma->doKnockback ? DAMAGE_KNOCKBACK : 0 ),			                ent->splashMethodOfDeath );		}	}	// Play hit effects and remove the missile.	if ( !( impactFlags & MIF_NO_EFFECT ) )	{		// Use either the trajectory direction or the surface normal for the hit event.		if ( ma->impactFlightDirection )		{			vec3_t trajDir;			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, trajDir );			VectorNormalize( trajDir );			dirAsByte = DirToByte( trajDir );		}		else		{			dirAsByte = DirToByte( trace->plane.normal );		}		// Add hit event.		if ( HasComponents<HealthComponent>(*hitEnt->entity) )		{			G_AddEvent( ent, EV_MISSILE_HIT_ENTITY, dirAsByte );			ent->s.otherEntityNum = hitEnt->s.number;		}		else if ( trace->surfaceFlags & SURF_METAL )		{			G_AddEvent( ent, EV_MISSILE_HIT_METAL, dirAsByte );		}		else//.........这里部分代码省略.........

//.........这里部分代码省略.........            //For jedi AI            otherOwner->client->ps.saberEventFlags |= SEF_DEFLECTED;            if (otherDefLevel == FORCE_LEVEL_3)            {                otherOwner->client->ps.saberBlockTime = 0; //^_^            }            if (otherDefLevel == FORCE_LEVEL_1)            {                goto killProj;            }            return;        }    }    // check for sticking    if ( !other->takedamage && ( ent->s.eFlags & EF_MISSILE_STICK ) )    {        laserTrapStick( ent, trace->endpos, trace->plane.normal );        G_AddEvent( ent, EV_MISSILE_STICK, 0 );        return;    }//JAPRO - Serverside - Flag punting - Start    if (g_allowFlagThrow.integer && !other->takedamage && other->s.eType == ET_ITEM)    {        vec3_t velocity;        if (ent->s.weapon == WP_REPEATER && (ent->s.eFlags & EF_ALT_FIRING))        {            other->s.pos.trType = TR_GRAVITY;            other->s.pos.trTime = level.time;            BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );            VectorScale( velocity, 0.7f, other->s.pos.trDelta );            VectorCopy( other->r.currentOrigin, other->s.pos.trBase );        }        else if (ent->s.weapon == WP_ROCKET_LAUNCHER && (ent->s.eFlags & EF_ALT_FIRING))        {            other->s.pos.trType = TR_GRAVITY;            other->s.pos.trTime = level.time;            BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );            VectorScale( velocity, 2.5f, other->s.pos.trDelta );            VectorCopy( other->r.currentOrigin, other->s.pos.trBase );        }        else if (ent->s.weapon == WP_ROCKET_LAUNCHER)        {            other->s.pos.trType = TR_GRAVITY;            other->s.pos.trTime = level.time;            BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );            VectorScale( velocity, 0.9f, other->s.pos.trDelta );            VectorCopy( other->r.currentOrigin, other->s.pos.trBase );        }        else if (ent->s.weapon == WP_THERMAL)        {            other->s.pos.trType = TR_GRAVITY;            other->s.pos.trTime = level.time;            BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );            VectorScale( velocity, 0.9f, other->s.pos.trDelta ); //tweak?            VectorCopy( other->r.currentOrigin, other->s.pos.trBase );        }    }//JAPRO - Serverside - Flag punting - End    // impact damage    if (other->takedamage && !isKnockedSaber) {

/*================G_MissileImpact	impactDamage is how much damage the impact will do to func_explosives================*/void G_MissileImpact( gentity_t *ent, trace_t *trace, int impactDamage ) {	gentity_t       *other;	qboolean hitClient = qfalse;	vec3_t velocity;	int etype;	other = &g_entities[trace->entityNum];	// handle func_explosives	if ( other->classname && Q_stricmp( other->classname, "func_explosive" ) == 0 ) {		// the damage is sufficient to "break" the ent (health == 0 is non-breakable)		if ( other->health && impactDamage >= other->health ) {			// check for other->takedamage needs to be inside the health check since it is			// likely that, if successfully destroyed by the missile, in the next runmissile()			// update takedamage would be set to '0' and the func_explosive would not be			// removed yet, causing a bounce.			if ( other->takedamage ) {				BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );				G_Damage( other, ent, &g_entities[ent->r.ownerNum], velocity, ent->s.origin, impactDamage, 0, ent->methodOfDeath );			}			// its possible of the func_explosive not to die from this and it			// should reflect the missile or explode it not vanish into oblivion			if ( other->health <= 0 ) {				return;			}		}	}	// check for bounce	if ( !other->takedamage &&		 ( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {		G_BounceMissile( ent, trace );		// JPW NERVE -- spotter White Phosphorous rounds shouldn't bounce noise		if ( !Q_stricmp( ent->classname,"WP" ) ) {			return;		}		// jpw		if ( !Q_stricmp( ent->classname, "flamebarrel" ) ) {			G_AddEvent( ent, EV_FLAMEBARREL_BOUNCE, 0 );		} else {			G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );		}		return;	}	if ( other->takedamage && ent->s.density == 1 ) {		G_ExplodeMissilePoisonGas( ent );		return;	}	// impact damage	if ( other->takedamage ) {		if ( ent->damage ) {			if ( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {				if ( g_entities[ent->r.ownerNum].client ) {					g_entities[ent->r.ownerNum].client->ps.persistant[PERS_ACCURACY_HITS]++;				}				hitClient = qtrue;			}			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );			if ( VectorLength( velocity ) == 0 ) {				velocity[2] = 1;    // stepped on a grenade			}			G_Damage( other, ent, &g_entities[ent->r.ownerNum], velocity,					  ent->s.origin, ent->damage,					  0, ent->methodOfDeath );		} else    // if no damage value, then this is a splash damage grenade only		{			G_BounceMissile( ent, trace );			return;		}	}	// is it cheaper in bandwidth to just remove this ent and create a new	// one, rather than changing the missile into the explosion?	if ( other->takedamage && other->client ) {		G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );		ent->s.otherEntityNum = other->s.number;	} else {		// Ridah, try projecting it in the direction it came from, for better decals		vec3_t dir;		BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, dir );		BG_GetMarkDir( dir, trace->plane.normal, dir );		G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( dir ) );	}	ent->freeAfterEvent = qtrue;	// change over to a normal entity right at the point of impact	etype = ent->s.eType;	ent->s.eType = ET_GENERAL;//.........这里部分代码省略.........

//.........这里部分代码省略.........        return;    }    else if( !strcmp( ent->classname, "lockblob" ) )    {        if( other->client && other->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )        {            other->client->ps.stats[ STAT_STATE ] |= SS_BLOBLOCKED;            other->client->lastLockTime = level.time;            AngleVectors( other->client->ps.viewangles, dir, NULL, NULL );            other->client->ps.stats[ STAT_VIEWLOCK ] = DirToByte( dir );        }    }    else if( !strcmp( ent->classname, "slowblob" ) )    {        if( other->client && other->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )        {            other->client->ps.stats[ STAT_STATE ] |= SS_SLOWLOCKED;            other->client->lastSlowTime = level.time;            AngleVectors( other->client->ps.viewangles, dir, NULL, NULL );            other->client->ps.stats[ STAT_VIEWLOCK ] = DirToByte( dir );        }    }    else if( !strcmp( ent->classname, "hive" ) )    {        if( other->s.eType == ET_BUILDABLE && other->s.modelindex == BA_A_HIVE )        {            if( !ent->parent )                G_Printf( S_COLOR_YELLOW "WARNING: hive entity has no parent in G_MissileImpact/n" );            else                ent->parent->active = qfalse;            G_FreeEntity( ent );            return;        }        else        {            //prevent collision with the client when returning            ent->r.ownerNum = other->s.number;            ent->think = AHive_ReturnToHive;            ent->nextthink = level.time + FRAMETIME;            //only damage humans            if( other->client && other->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )                returnAfterDamage = qtrue;            else                return;        }    }    // impact damage    if( other->takedamage )    {        // FIXME: wrong damage direction?        if( ent->damage )        {            vec3_t  velocity;            BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );            if( VectorLength( velocity ) == 0 )                velocity[ 2 ] = 1;  // stepped on a grenade            G_Damage( other, ent, attacker, velocity, ent->s.origin, ent->damage,                      0, ent->methodOfDeath );        }    }    if( returnAfterDamage )        return;    // is it cheaper in bandwidth to just remove this ent and create a new    // one, rather than changing the missile into the explosion?    if( other->takedamage && other->client )    {        G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );        ent->s.otherEntityNum = other->s.number;    }    else if( trace->surfaceFlags & SURF_METALSTEPS )        G_AddEvent( ent, EV_MISSILE_MISS_METAL, DirToByte( trace->plane.normal ) );    else        G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );    ent->freeAfterEvent = qtrue;    // change over to a normal entity right at the point of impact    ent->s.eType = ET_GENERAL;    SnapVectorTowards( trace->endpos, ent->s.pos.trBase );  // save net bandwidth    G_SetOrigin( ent, trace->endpos );    // splash damage (doesn't apply to person directly hit)    if( ent->splashDamage )        G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius,                        other, ent->splashMethodOfDeath );    trap_LinkEntity( ent );}

/*================G_MissileImpact================*/void G_MissileImpact( gentity_t *ent, trace_t *trace ) {	gentity_t		*other;	qboolean		hitClient = qfalse;#ifdef MISSIONPACK	vec3_t			forward, impactpoint, bouncedir;	int				eFlags;#endif	other = &g_entities[trace->entityNum];	// check for bounce	if ( !other->takedamage &&		( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {		G_BounceMissile( ent, trace );		G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );		return;	}#ifdef MISSIONPACK	if ( other->takedamage ) {		if ( ent->s.weapon != WP_PROX_LAUNCHER ) {			if ( other->client && other->client->invulnerabilityTime > level.time ) {				//				VectorCopy( ent->s.pos.trDelta, forward );				VectorNormalize( forward );				if (G_InvulnerabilityEffect( other, forward, ent->s.pos.trBase, impactpoint, bouncedir )) {					VectorCopy( bouncedir, trace->plane.normal );					eFlags = ent->s.eFlags & EF_BOUNCE_HALF;					ent->s.eFlags &= ~EF_BOUNCE_HALF;					G_BounceMissile( ent, trace );					ent->s.eFlags |= eFlags;				}				ent->target_ent = other;				return;			}		}	}#endif	// impact damage	if (other->takedamage) {		// FIXME: wrong damage direction?		if ( ent->damage ) {			vec3_t	velocity;			if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {				g_entities[ent->r.ownerNum].client->accuracy_hits++;				hitClient = qtrue;			}			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );			if ( VectorLength( velocity ) == 0 ) {				velocity[2] = 1;	// stepped on a grenade			}			G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,				ent->s.origin, ent->damage, 				0, ent->methodOfDeath);		}	}#ifdef MISSIONPACK	if( ent->s.weapon == WP_PROX_LAUNCHER ) {		if( ent->s.pos.trType != TR_GRAVITY ) {			return;		}		// if it's a player, stick it on to them (flag them and remove this entity)		if( other->s.eType == ET_PLAYER && other->health > 0 ) {			ProximityMine_Player( ent, other );			return;		}		SnapVectorTowards( trace->endpos, ent->s.pos.trBase );		G_SetOrigin( ent, trace->endpos );		ent->s.pos.trType = TR_STATIONARY;		VectorClear( ent->s.pos.trDelta );		G_AddEvent( ent, EV_PROXIMITY_MINE_STICK, trace->surfaceFlags );		ent->think = ProximityMine_Activate;		ent->nextthink = level.time + 2000;		vectoangles( trace->plane.normal, ent->s.angles );		ent->s.angles[0] += 90;		// link the prox mine to the other entity		ent->enemy = other;		ent->die = ProximityMine_Die;		VectorCopy(trace->plane.normal, ent->movedir);		VectorSet(ent->r.mins, -4, -4, -4);		VectorSet(ent->r.maxs, 4, 4, 4);		trap_LinkEntity(ent);		return;	}#endif	if (!strcmp(ent->classname, "hook")) {//.........这里部分代码省略.........

//.........这里部分代码省略.........		if (other->client)		{			AngleVectors(other->client->ps.viewangles, fwd, NULL, NULL);		}		else		{			AngleVectors(other->r.currentAngles, fwd, NULL, NULL);		}		VectorScale(ent->s.pos.trDelta, 0.2, ent->s.pos.trDelta);		G_Damage(other, ent, ent->parent, fwd, ent->s.origin, ent->genericValue9, 0, MOD_THERMAL);		G_DeflectMissile(other, ent, fwd);		//G_MissileBounceEffect(ent, ent->r.currentOrigin, fwd);		return;	}	// check for sticking	if ( !other->takedamage && ( ent->s.eFlags & EF_MISSILE_STICK ) ) 	{		laserTrapStick( ent, trace->endpos, trace->plane.normal );		G_AddEvent( ent, EV_MISSILE_STICK, 0 );		return;	}	// impact damage	if (other->takedamage && !isKnockedSaber) {		// FIXME: wrong damage direction?		weaponData_t *weapon = GetWeaponData (ent->s.weapon, ent->s.weaponVariation);		weaponFireModeStats_t *fireMode = &weapon->firemodes[ent->s.firingMode];				if ( ent->damage || fireMode->damageTypeHandle || fireMode->secondaryDmgHandle ) {			vec3_t	velocity;			hitClient = qtrue;			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );			if ( VectorLength( velocity ) == 0 ) {				velocity[2] = 1;	// stepped on a grenade			}            if ( fireMode->damageTypeHandle )            {                JKG_DoDamage (fireMode->damageTypeHandle, other, ent, &g_entities[ent->r.ownerNum], velocity, ent->r.currentOrigin, 0, ent->methodOfDeath);            }            else if ( ent->damage )            {                G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity, ent->r.currentOrigin, ent->damage, 0, ent->methodOfDeath);            }                        if ( fireMode->secondaryDmgHandle )            {                JKG_DoDamage (fireMode->secondaryDmgHandle, other, ent, &g_entities[ent->r.ownerNum], velocity, ent->r.currentOrigin, 0, ent->methodOfDeath);            }			if (other->client)			{ //What I'm wondering is why this isn't in the NPC pain funcs. But this is what SP does, so whatever.				class_t	npc_class = other->client->NPC_class;				// If we are a robot and we aren't currently doing the full body electricity...				if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||					   npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 || npc_class == CLASS_REMOTE ||					   npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 || //npc_class == CLASS_PROTOCOL ||//no protocol, looks odd					   npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )				{					// special droid only behaviors					if ( other->client->ps.electrifyTime < level.time + 100 )					{						// ... do the effect for a split second for some more feedback

//.........这里部分代码省略.........	if ( weapon->missileDlight ) {		trap_R_AddLightToScene( re->origin, weapon->missileDlight, 			weapon->missileDlightColor[0], weapon->missileDlightColor[1], weapon->missileDlightColor[2] );	}	// flicker between two skins	re->skinNum = cg.clientFrame & 1;	// convert direction of travel into axis	if ( VectorNormalize2( le->pos.trDelta, re->axis[0] ) == 0 ) {		re->axis[0][2] = 1;	}	// spin as it moves	if ( le->pos.trType != TR_STATIONARY ) {		if ( le->pos.trType == TR_GRAVITY ) {			RotateAroundDirection( re->axis, cg.time / 4 );		} else if ( le->pos.trType == TR_WATER_GRAVITY ) {			RotateAroundDirection( re->axis, cg.time / 8 );		} else {			RotateAroundDirection( re->axis, cg.time );		}	} else {		RotateAroundDirection( re->axis, 0 );	}	// trace a line from previous position to new position	CG_Trace( &trace, re->oldorigin, NULL, NULL, re->origin, le->owner, MASK_SHOT );	VectorCopy( re->origin, re->oldorigin );	// draw BIG grenades	if ( weLi[le->ti.weapon].category == CT_EXPLOSIVE ) {		AxisScale( re->axis, GRENADE_SCALE, re->axis );	}	if ( trace.fraction != 1.0 ) {		// hit the sky or something like that		if ( trace.surfaceFlags & SURF_NOIMPACT ) {			le->leFlags |= LEF_FINISHED;			le->endTime = cg.time + 500;			return;		}		// impact		other = &cg_entities[trace.entityNum];		if ( le->bounceFactor > 0 && ( le->bounceFactor == BOUNCE_FACTOR_HALF || other->currentState.eType != ET_PLAYER ) ) {			// reflect the velocity on the trace plane			CG_ReflectVelocity( le, &trace );			if ( cg.predictedImpacts < MAX_PREDICTED_IMPACTS ) {				cg.predictedImpacts++;				cg.predictedImpactsDecTime = cg.time;			}			// do bounce sound			if ( rand() & 1 ) {				trap_S_StartSound( le->pos.trBase, 0, CHAN_AUTO, cgs.media.hgrenb1aSound );			} else {				trap_S_StartSound( le->pos.trBase, 0, CHAN_AUTO, cgs.media.hgrenb2aSound );			}		} else {			// explode missile			if ( cg.predictedImpacts < MAX_PREDICTED_IMPACTS ) {				cg.predictedImpacts++;				cg.predictedImpactsDecTime = cg.time;			}			if ( other->currentState.eType == ET_PLAYER ) {				CG_MissileHitPlayer( le->ti.weapon, 0, trace.endpos, trace.plane.normal, trace.entityNum );			} else if ( !(trace.surfaceFlags & SURF_NOIMPACT) ) {				CG_MissileHitWall( le->ti.weapon, 0, trace.endpos, trace.plane.normal, 					(trace.surfaceFlags & SURF_METALSTEPS) ? IMPACTSOUND_METAL : IMPACTSOUND_DEFAULT );			}			// store the entity for deleting the server entity			le->leFlags |= LEF_FINISHED;			le->endTime = cg.time + 500;			return;		}	}	// check for medium change	if ( trap_CM_PointContents( re->origin, 0 ) & CONTENTS_WATER ) inWater = qtrue;	else inWater = qfalse;	if (  ( !inWater && le->pos.trType == TR_WATER_GRAVITY )		|| ( inWater && le->pos.trType == TR_GRAVITY ) ) {		// setup new tr		vec3_t	newDelta;		BG_EvaluateTrajectoryDelta( &le->pos, cg.time, newDelta );		VectorCopy( re->origin, le->pos.trBase );		VectorCopy( newDelta, le->pos.trDelta );		le->pos.trTime = cg.time;		if ( inWater ) le->pos.trType = TR_WATER_GRAVITY;		else le->pos.trType = TR_GRAVITY;	}		// add to refresh list	trap_R_AddRefEntityToScene( re );}

//.........这里部分代码省略.........			//For jedi AI			otherOwner->client->ps.saberEventFlags |= SEF_DEFLECTED;			if ( otherDefLevel == FORCE_LEVEL_3 ) {				otherOwner->client->ps.saberBlockTime = 0; //^_^			}			if ( otherDefLevel == FORCE_LEVEL_1 ) {				goto killProj;			}			return;		}	}	// check for sticking	if ( !other->takedamage && (ent->s.eFlags & EF_MISSILE_STICK) ) {		laserTrapStick( ent, &trace->endpos, &trace->plane.normal );		G_AddEvent( ent, EV_MISSILE_STICK, 0 );		return;	}	// impact damage	if ( other->takedamage && !isKnockedSaber ) {		// FIXME: wrong damage direction?		if ( ent->damage ) {			vector3	velocity;			qboolean didDmg = qfalse;			if ( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {				g_entities[ent->r.ownerNum].client->accuracy_hits++;				hitClient = qtrue;			}			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, &velocity );			if ( VectorLength( &velocity ) == 0 ) {				velocity.z = 1;	// stepped on a grenade			}			if ( ent->s.weapon == WP_BOWCASTER || ent->s.weapon == WP_FLECHETTE ||				ent->s.weapon == WP_ROCKET_LAUNCHER ) {				if ( ent->s.weapon == WP_FLECHETTE && (ent->s.eFlags & EF_ALT_FIRING) ) {					ent->think( ent );					JPLua::Entity_CallFunction( ent, JPLua::JPLUA_ENTITY_THINK );				}				else {					G_Damage( other, ent, &g_entities[ent->r.ownerNum], &velocity,						/*ent->s.origin*/&ent->r.currentOrigin, ent->damage,						DAMAGE_HALF_ABSORB, ent->methodOfDeath );					didDmg = qtrue;				}			}			else {				G_Damage( other, ent, &g_entities[ent->r.ownerNum], &velocity,					/*ent->s.origin*/&ent->r.currentOrigin, ent->damage,					0, ent->methodOfDeath );				didDmg = qtrue;			}			//Raz: air shots			if ( (other->client && other->client->ps.groundEntityNum == ENTITYNUM_NONE) &&				(ent->methodOfDeath == MOD_CONC ||				ent->methodOfDeath == MOD_REPEATER_ALT ||				ent->methodOfDeath == MOD_ROCKET ||				ent->methodOfDeath == MOD_ROCKET_HOMING ||				ent->methodOfDeath == MOD_THERMAL) ) {				g_entities[ent->r.ownerNum].client->ps.persistant[PERS_IMPRESSIVE_COUNT]++;

/*================G_MissileImpact================*/void G_MissileImpact( gentity_t *ent, trace_t *trace ) {	gentity_t		*other;	qboolean		hitPlayer = qfalse;#if defined MISSIONPACK && !defined TURTLEARENA // POWERS	vec3_t			forward, impactpoint, bouncedir;	int				eFlags;#endif#ifdef TA_WEAPSYS	qboolean damagedOther = qfalse;#endif	other = &g_entities[trace->entityNum];#if defined MISSIONPACK && !defined TURTLEARENA // POWERS	if ( other->takedamage ) {#ifdef TA_WEAPSYS		if ( !bg_projectileinfo[ent->s.weapon].stickOnImpact )#else		if ( ent->s.weapon != WP_PROX_LAUNCHER )#endif		{			if ( other->player && other->player->invulnerabilityTime > level.time ) {				//				VectorCopy( ent->s.pos.trDelta, forward );				VectorNormalize( forward );				if (G_InvulnerabilityEffect( other, forward, ent->s.pos.trBase, impactpoint, bouncedir )) {					VectorCopy( bouncedir, trace->plane.normal );					eFlags = ent->s.eFlags & EF_BOUNCE_HALF;					ent->s.eFlags &= ~EF_BOUNCE_HALF;					G_BounceMissile( ent, trace );					ent->s.eFlags |= eFlags;				}				ent->target_ent = other;				return;			}		}	}#endif	// impact damage	if (other->takedamage#ifdef TA_WEAPSYS // stickOnImpact only damages once		&& !(ent->count & 2)#endif		)	{		// FIXME: wrong damage direction?		if ( ent->damage ) {			vec3_t	velocity;			if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {				g_entities[ent->r.ownerNum].player->accuracy_hits++;				hitPlayer = qtrue;			}			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );			if ( VectorLength( velocity ) == 0 ) {#ifdef IOQ3ZTM				VectorCopy(trace->plane.normal, velocity);#else				velocity[2] = 1;	// stepped on a grenade#endif			}#ifdef TA_WEAPSYS			damagedOther = G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,				ent->s.origin, ent->damage,				0, ent->methodOfDeath);#else			G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,				ent->s.origin, ent->damage, 				0, ent->methodOfDeath);#endif		}	}	// check for bounce	if (#ifdef TA_WEAPSYS		!damagedOther &&#else		!other->takedamage &&#endif		( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {		G_BounceMissile( ent, trace );#ifdef TA_WEAPSYS // Bounce missiles		// Die on Nth bounce		if (ent->s.modelindex2 > 0)		{			ent->s.modelindex2--;			if (ent->s.modelindex2 == 0)			{				// Kill missile				G_ExplodeMissile( ent );				return;			}		}		G_AddEvent( ent, EV_PROJECTILE_BOUNCE, DirToByte( trace->plane.normal ) );		ent->s.time2 = trace->surfaceFlags; // surface//.........这里部分代码省略.........

void G_MissileImpact( gentity_t *ent, trace_t *trace ) {	gentity_t		*other;	qboolean		hitClient = qfalse;	other = &g_entities[trace->entityNum];	// check for bounce	if ( !other->takedamage &&		(ent->bounceCount > 0 || ent->bounceCount == -5) &&		( ent->flags & ( FL_BOUNCE | FL_BOUNCE_HALF ) ) ) {		G_BounceMissile( ent, trace );	//	G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );		return;	}	if ( other->s.eType == ET_MISSILE && ent->s.weapon == WP_QUANTIZER && other->s.weapon == WP_MORTAR )	{//Quantizer can deflect mortar shots :3		G_DeflectMissile( ent, other, &ent->s.pos.trDelta );		other->r.ownerNum = ent->r.ownerNum;		G_FreeEntity( ent );		return;	}	// impact damage	if (other->takedamage) {		// FIXME: wrong damage direction?		if ( ent->damage ) {			vector3	velocity;			if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {				g_entities[ent->r.ownerNum].client->accuracy_hits++;				hitClient = qtrue;			}			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, &velocity );			if ( VectorLength( &velocity ) == 0 ) {				velocity.z = 1;	// stepped on a grenade			}			//Raz: The inflictor is the missile, for direct hits from quantizer/RLauncher/etc			G_Damage( other, ent, &g_entities[ent->r.ownerNum], ent, NULL/*velocity*/, &ent->s.origin, ent->damage, 0, ent->methodOfDeath );		}	}	// is it cheaper in bandwidth to just remove this ent and create a new	// one, rather than changing the missile into the explosion?	if ( other->takedamage && other->client ) {		G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( &trace->plane.normal ) );		ent->s.otherEntityNum = other->s.number;	} else if( trace->surfaceFlags & SURF_METALSTEPS ) {		G_AddEvent( ent, EV_MISSILE_MISS_METAL, DirToByte( &trace->plane.normal ) );	} else {		G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( &trace->plane.normal ) );	}	ent->freeAfterEvent = qtrue;	// change over to a normal entity right at the point of impact	ent->s.eType = ET_GENERAL;	VectorSnapTowards( &trace->endpos, &ent->s.pos.trBase );	// save net bandwidth	G_SetOrigin( ent, &trace->endpos );	// splash damage (doesn't apply to person directly hit)#if 0	if ( ent->splashDamage ) {		if( G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius, 			other, ent->splashMethodOfDeath ) ) {			if( !hitClient ) {				g_entities[ent->r.ownerNum].client->accuracy_hits++;			}		}	}#else	//QtZ	if ( (ent->splashDamage || ent->splashRadius)		&& G_RadiusDamage( &trace->endpos, ent->parent, (float)ent->splashDamage, (float)ent->splashRadius, other, ent, ent->splashMethodOfDeath )		&& !hitClient && g_entities[ent->r.ownerNum].client )		g_entities[ent->r.ownerNum].client->accuracy_hits++;#endif	trap->SV_LinkEntity( (sharedEntity_t *)ent );}

//.........这里部分代码省略.........			if (otherDefLevel == FORCE_LEVEL_3)			{				otherOwner->client->ps.saberBlockTime = 0; //^_^			}			if (otherDefLevel == FORCE_LEVEL_1)			{				goto killProj;			}			return;		}	}	// check for sticking	if ( !other->takedamage && ( ent->s.eFlags & EF_MISSILE_STICK ) ) 	{		laserTrapStick( ent, trace->endpos, trace->plane.normal );		G_AddEvent( ent, EV_MISSILE_STICK, 0 );		return;	}	// impact damage	if (other->takedamage && !isKnockedSaber) {		// FIXME: wrong damage direction?		if ( ent->damage ) {			vec3_t	velocity;			qboolean didDmg = qfalse;			if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) &&				!ent->isReflected) {				g_entities[ent->r.ownerNum].client->accuracy_hits++;				hitClient = qtrue;			}			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );			if ( VectorLength( velocity ) == 0 ) {				velocity[2] = 1;	// stepped on a grenade			}			if ((ent->s.weapon == WP_BOWCASTER || ent->s.weapon == WP_FLECHETTE ||				ent->s.weapon == WP_ROCKET_LAUNCHER))			{				if (ent->s.weapon == WP_FLECHETTE && (ent->s.eFlags & EF_ALT_FIRING)) 				{					/* fix: there are rare situations where flechette did					explode by timeout AND by impact in the very same frame, then here					ent->think was set to G_FreeEntity, so the folowing think 					did invalidate this entity, BUT it would be reused later in this 					function for explosion event. This, then, would set ent->freeAfterEvent					to qtrue, so event later, when reusing this entity by using G_InitEntity(),					it would have this freeAfterEvent set AND this would in case of dropped					item erase it from game immeadiately. THIS for example caused					very rare flag dissappearing bug.	 */					if (ent->think == WP_flechette_alt_blow)						ent->think(ent);				}				else				{					G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,						/*ent->s.origin*/ent->r.currentOrigin, ent->damage, 						DAMAGE_HALF_ABSORB, ent->methodOfDeath);					didDmg = qtrue;				}			}			else			{				G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,

/*==================CG_AddMoveScale==================*/static void CG_AddMoveScale( localEntity_t *le ) {	refEntity_t	*re;	vec3_t		delta;	float		len;	re = &le->refEntity;	if ( !( le->leFlags & (LEF_DONT_SCALE | LEF_ALT_SCALE) ) ) {		re->radius = le->radius * ( cg.time - le->startTime ) * le->lifeRate + 8;	}	if ( le->leFlags & LEF_ALT_SCALE ) {		if ( re->hModel ) {			if ( (le->leFlags & LEF_AXIS_ALIGNED) && le->radius ) {				// it has a variing scale				AxisClear( re->axis );				AxisScale( re->axis, re->radius + le->radius * (cg.time - le->startTime) / (le->endTime - le->startTime), re->axis );			}			if ( !(le->leFlags & LEF_AXIS_ALIGNED) ) {				// model looks in flight direction				vec3_t	delta, angles;								BG_EvaluateTrajectoryDelta( &le->pos, cg.time, delta );				vectoangles( delta, angles );				AnglesToAxis( angles, re->axis );				if ( re->radius || le->radius ) AxisScale( re->axis, re->radius + le->radius * (cg.time - le->startTime) / (le->endTime - le->startTime), re->axis );			}		} else {			// sprites scale like this			re->radius += le->radius * cg.frametime / (le->endTime - le->startTime);		}	}	BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );	// check for collisions	if ( le->leFlags & LEF_COLLISIONS ) {		// do a trace sometimes		if ( le->ti.trailTime++ > 5 ) {			trace_t		trace;			le->ti.trailTime = 0;			CG_Trace( &trace, re->oldorigin, NULL, NULL, re->origin, le->owner, MASK_SHOT );			VectorCopy( re->origin, re->oldorigin );			// hit something			if ( trace.fraction < 1.0 ) {				entityState_t	*s1;				int		life;				// do impact effect				s1 = &cg_entities[le->owner].currentState;				life = s1->groundEntityNum;				if ( !( trace.surfaceFlags & SURF_NOIMPACT ) ) {					if ( s1->generic1 & PF_IMPACT_MODEL ) {						CG_MakeExplosion( trace.endpos, trace.plane.normal, 								   cgs.gameModels[s1->modelindex2],	cgs.gameShaders[s1->otherEntityNum2],								   life, qfalse, qfalse );					} else if ( s1->modelindex2 ) {						CG_MakeExplosion( trace.endpos, trace.plane.normal, 								   cgs.media.dishFlashModel, cgs.gameShaders[s1->modelindex2],								   life, qtrue, qtrue );					}				}				CG_FreeLocalEntity( le );				return;			}		}	}	// if the view would be "inside" the sprite, kill the sprite	// so it doesn't add too much overdraw	VectorSubtract( re->origin, cg.refdef.vieworg, delta );	len = VectorLength( delta );	if ( len < le->radius ) {		CG_FreeLocalEntity( le );		return;	}	trap_R_AddRefEntityToScene( re );}