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

/*==================UI_SwingAngles==================*/static void UI_SwingAngles( float destination, float swingTolerance, float clampTolerance,                            float speed, float *angle, qbool *swinging ) {    float	swing;    float	move;    float	scale;    if ( !*swinging ) {        // see if a swing should be started        swing = AngleSubtract( *angle, destination );        if ( swing > swingTolerance || swing < -swingTolerance ) {            *swinging = qtrue;        }    }    if ( !*swinging ) {        return;    }    // modify the speed depending on the delta    // so it doesn't seem so linear    swing = AngleSubtract( destination, *angle );    scale = fabs( swing );    if ( scale < swingTolerance * 0.5 ) {        scale = 0.5;    } else if ( scale < swingTolerance ) {        scale = 1.0;    } else {        scale = 2.0;    }    // swing towards the destination angle    if ( swing >= 0 ) {        move = uiInfo.uiDC.frameTime * scale * speed;        if ( move >= swing ) {            move = swing;            *swinging = qfalse;        }        *angle = AngleMod( *angle + move );    } else if ( swing < 0 ) {        move = uiInfo.uiDC.frameTime * scale * -speed;        if ( move <= swing ) {            move = swing;            *swinging = qfalse;        }        *angle = AngleMod( *angle + move );    }    // clamp to no more than tolerance    swing = AngleSubtract( destination, *angle );    if ( swing > clampTolerance ) {        *angle = AngleMod( destination - (clampTolerance - 1) );    } else if ( swing < -clampTolerance ) {        *angle = AngleMod( destination + (clampTolerance - 1) );    }}

void WalkerYawAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS){	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);	if (parentPS && parentPS->speed)	{		float s = parentPS->speed;		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*1.5f; //magic number hackery		if (s < 0.0f)		{			s = -s;		}		angDif *= s/pVeh->m_pVehicleInfo->speedMax;		if (angDif > maxDif)		{			angDif = maxDif;		}		else if (angDif < -maxDif)		{			angDif = -maxDif;		}		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));	}}

void ProcessOrientCommands( Vehicle_t *pVeh ){	/********************************************************************************/	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/	/********************************************************************************/	playerState_t *riderPS;	playerState_t *parentPS;	float angDif;	if (pVeh->m_pPilot)	{		riderPS = pVeh->m_pPilot->playerState;	}	else	{		riderPS = pVeh->m_pParentEntity->playerState;	}	parentPS = pVeh->m_pParentEntity->playerState;	//pVeh->m_vOrientation[YAW] = 0.0f;//riderPS->viewangles[YAW];	angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);	if (parentPS && parentPS->speed)	{		float s = parentPS->speed;		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*4.0f; //magic number hackery		if (s < 0.0f)		{			s = -s;		}		angDif *= s/pVeh->m_pVehicleInfo->speedMax;		if (angDif > maxDif)		{			angDif = maxDif;		}		else if (angDif < -maxDif)		{			angDif = -maxDif;		}		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));		if (parentPS->electrifyTime > pm->cmd.serverTime)		{ //do some crazy stuff			pVeh->m_vOrientation[YAW] += (sin(pm->cmd.serverTime/1000.0f)*3.0f)*pVeh->m_fTimeModifier;		}	}	/********************************************************************************/	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/	/********************************************************************************/}

void WalkerYawAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS){	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);	//ROP VEHICLE_IMP START	if (!pVeh->bTransAnimFlag && parentPS && 		(parentPS->speed || pVeh->m_pVehicleInfo->turnWhenStopped))	{		float s = parentPS->speed;		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*1.5f; //magic number hackery		pVeh->eTurningOnSpot = VEHICLE_NOT_TURNING;		if(s == 0.0f)		{			//If were stationary, then simulate walking speed			s = pVeh->m_pVehicleInfo->speedMax * 0.275f;		}		if (s < 0.0f)		{			s = -s;		}		angDif *= s/pVeh->m_pVehicleInfo->speedMax;		if (angDif > maxDif)		{			angDif = maxDif;		}		else if (angDif < -maxDif)		{			angDif = -maxDif;		}		if(parentPS->speed == 0.0f)		{			if(angDif > (maxDif * 0.25))			{				//We are turning right				pVeh->eTurningOnSpot = VEHICLE_TURNING_RIGHT;			}			else if(angDif < -(maxDif * 0.25))			{				//We are turning left				pVeh->eTurningOnSpot = VEHICLE_TURNING_LEFT;			}		}		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));	}	//ROP VEHICLE_IMP END}

/*=================BG_EmplacedViewShared code for emplaced angle gun constriction=================*/int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint){	float dif = AngleSubtract(baseAngles[YAW], angles[YAW]);	if (dif > constraint ||		dif < -constraint)	{		float amt;		if (dif > constraint)		{			amt = (dif-constraint);			dif = constraint;		}		else if (dif < -constraint)		{			amt = (dif+constraint);			dif = -constraint;		}		else		{			amt = 0.0f;		}		*newYaw = AngleSubtract(angles[YAW], -dif);		if (amt > 1.0f || amt < -1.0f)		{ //significant, force the view			return 2;		}		else		{ //just a little out of range			return 1;		}	}	return 0;}

/*=================CG_DrawCompassIcon=================*/void CG_DrawCompassIcon(float x, float y, float w, float h, vec3_t origin, vec3_t dest, qhandle_t shader){	float  angle, pi2 = M_PI * 2;	vec3_t v1, angles;	float  len;	VectorCopy(dest, v1);	VectorSubtract(origin, v1, v1);	len = VectorLength(v1);	VectorNormalize(v1);	vectoangles(v1, angles);	if (v1[0] == 0 && v1[1] == 0 && v1[2] == 0)	{		return;	}	angles[YAW] = AngleSubtract(cg.predictedPlayerState.viewangles[YAW], angles[YAW]);	angle = ((angles[YAW] + 180.f) / 360.f - (0.50 / 2.f)) * pi2;	w /= 2;	h /= 2;	x += w;	y += h;	{		w = sqrt((w * w) + (h * h)) / 3.f * 2.f * 0.9f;	}	x = x + (cos(angle) * w);	y = y + (sin(angle) * w);	len = 1 - MIN(1.f, len / 2000.f);	CG_DrawPic(x - (14 * len + 4) / 2, y - (14 * len + 4) / 2, 14 * len + 8, 14 * len + 8, shader);}

void ProcessOrientCommands( Vehicle_t *pVeh ){	/********************************************************************************/	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/	/********************************************************************************/	playerState_t *riderPS;	playerState_t *parentPS;#ifdef _JK2MP	float angDif;	if (pVeh->m_pPilot)	{		riderPS = pVeh->m_pPilot->playerState;	}	else	{		riderPS = pVeh->m_pParentEntity->playerState;	}	parentPS = pVeh->m_pParentEntity->playerState;	//pVeh->m_vOrientation[YAW] = 0.0f;//riderPS->viewangles[YAW];	angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);	if (parentPS && parentPS->speed)	{		float s = parentPS->speed;		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*4.0f; //magic number hackery		if (s < 0.0f)		{			s = -s;		}		angDif *= s/pVeh->m_pVehicleInfo->speedMax;		if (angDif > maxDif)		{			angDif = maxDif;		}		else if (angDif < -maxDif)		{			angDif = -maxDif;		}		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));		if (parentPS->electrifyTime > pm->cmd.serverTime)		{ //do some crazy stuff			pVeh->m_vOrientation[YAW] += (sin(pm->cmd.serverTime/1000.0f)*3.0f)*pVeh->m_fTimeModifier;		}	}#else 	gentity_t *rider = pVeh->m_pParentEntity->owner;	if ( !rider || !rider->client )	{		riderPS = &pVeh->m_pParentEntity->client->ps;	}	else	{		riderPS = &rider->client->ps;	}	parentPS = &pVeh->m_pParentEntity->client->ps;	if (pVeh->m_ulFlags & VEH_FLYING)	{		pVeh->m_vOrientation[YAW] += pVeh->m_vAngularVelocity;	}	else if (		(pVeh->m_ulFlags & VEH_SLIDEBREAKING) ||	// No Angles Control While Out Of Control 		(pVeh->m_ulFlags & VEH_OUTOFCONTROL) 		// No Angles Control While Out Of Control 		)	{		// Any ability to change orientation?	}	else if (		(pVeh->m_ulFlags & VEH_STRAFERAM)			// No Angles Control While Strafe Ramming		)	{		if (parentPS->hackingTime>0)		{			parentPS->hackingTime--;			pVeh->m_vOrientation[ROLL] += (parentPS->hackingTime<( STRAFERAM_DURATION/2))?(-STRAFERAM_ANGLE):( STRAFERAM_ANGLE);		}		else if (pVeh->hackingTime<0)		{			parentPS->hackingTime++;			pVeh->m_vOrientation[ROLL] += (parentPS->hackingTime>(-STRAFERAM_DURATION/2))?( STRAFERAM_ANGLE):(-STRAFERAM_ANGLE);		}	}	else	{		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];	}#endif	/********************************************************************************/	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/	/********************************************************************************/}

void CL_FinishMove( usercmd_t *cmd ) {	int		i;	// copy the state that the cgame is currently sending	cmd->weapon = cl.cgameUserCmdValue;	cmd->forcesel = cl.cgameForceSelection;	cmd->invensel = cl.cgameInvenSelection;	if (cl.gcmdSendValue)	{		cmd->generic_cmd = cl.gcmdValue;		//cl.gcmdSendValue = qfalse;		cl.gcmdSentValue = qtrue;	}	else	{		cmd->generic_cmd = 0;	}	// send the current server time so the amount of movement	// can be determined without allowing cheating	cmd->serverTime = cl.serverTime;		if (cl.cgameViewAngleForceTime > cl.serverTime)	{		cl.cgameViewAngleForce[YAW] -= SHORT2ANGLE(cl.snap.ps.delta_angles[YAW]);		cl.viewangles[YAW] = cl.cgameViewAngleForce[YAW];		cl.cgameViewAngleForceTime = 0;	}	if ( cl_crazyShipControls )	{		float pitchSubtract, pitchDelta, yawDelta;		yawDelta = AngleSubtract(cl.viewangles[YAW],cl_lastViewAngles[YAW]);		//yawDelta *= (4.0f*pVeh->m_fTimeModifier);		cl_sendAngles[ROLL] -= yawDelta;		float nRoll = fabs(cl_sendAngles[ROLL]);		pitchDelta = AngleSubtract(cl.viewangles[PITCH],cl_lastViewAngles[PITCH]);		//pitchDelta *= (2.0f*pVeh->m_fTimeModifier);		pitchSubtract = pitchDelta * (nRoll/90.0f);		cl_sendAngles[PITCH] += pitchDelta-pitchSubtract;		//yaw-roll calc should be different		if (nRoll > 90.0f)		{			nRoll -= 180.0f;		}		if (nRoll < 0.0f)		{			nRoll = -nRoll;		}		pitchSubtract = pitchDelta * (nRoll/90.0f);		if ( cl_sendAngles[ROLL] > 0.0f )		{			cl_sendAngles[YAW] += pitchSubtract;		}		else		{			cl_sendAngles[YAW] -= pitchSubtract;		}				cl_sendAngles[PITCH] = AngleNormalize180( cl_sendAngles[PITCH] );		cl_sendAngles[YAW] = AngleNormalize360( cl_sendAngles[YAW] );		cl_sendAngles[ROLL] = AngleNormalize180( cl_sendAngles[ROLL] );		for (i=0 ; i<3 ; i++) {			cmd->angles[i] = ANGLE2SHORT(cl_sendAngles[i]);		}	}	else	{		for (i=0 ; i<3 ; i++) {			cmd->angles[i] = ANGLE2SHORT(cl.viewangles[i]);		}		//in case we switch to the cl_crazyShipControls		VectorCopy( cl.viewangles, cl_sendAngles );	}	//always needed in for the cl_crazyShipControls	VectorCopy( cl.viewangles, cl_lastViewAngles );}

//.........这里部分代码省略.........		{			//FIXME get this limit from the NPCs stats?			// don't let the player look up or down more than 90 degrees			if ( temp > pitchClampMax ) 			{				ps->delta_angles[i] = (pitchClampMax - cmd->angles[i]) & 0xffff;	//& clamp to short				temp = pitchClampMax;			} 			else if ( temp < pitchClampMin ) 			{				ps->delta_angles[i] = (pitchClampMin - cmd->angles[i]) & 0xffff;	//& clamp to short				temp = pitchClampMin;			}		}		if ( i == ROLL && ps->vehicleModel != 0 ) 		{			if ( temp > pitchClampMax ) 			{				ps->delta_angles[i] = (pitchClampMax - cmd->angles[i]) & 0xffff;				temp = pitchClampMax;			} 			else if ( temp < pitchClampMin ) 			{				ps->delta_angles[i] = (pitchClampMin - cmd->angles[i]) & 0xffff;				temp = pitchClampMin;			}		}		//FIXME: Are we losing precision here?  Is this why it jitters?		ps->viewangles[i] = SHORT2ANGLE(temp);		if ( i == YAW && lockedYaw) 		{			// don't let the player look left or right more than the clamp, if any			if ( AngleSubtract(ps->viewangles[i], gent->client->renderInfo.lockYaw) > yawMax ) 			{				ps->viewangles[i] = yawMax;			} 			else if ( AngleSubtract(ps->viewangles[i], gent->client->renderInfo.lockYaw) < yawMin ) 			{				ps->viewangles[i] = yawMin;			}		}	}	if ( (!cg.renderingThirdPerson||cg.zoomMode) && (cmd->buttons & BUTTON_USE) && cmd->rightmove != 0 && !cmd->forwardmove && cmd->upmove <= 0 )	{//Only lean if holding use button, strafing and not moving forward or back and not jumping		if ( gent )		{			int leanofs = 0;			vec3_t	viewangles;			if ( cmd->rightmove > 0 )			{				/*				if( pm->ps->legsAnim != LEGS_LEAN_RIGHT1)				{					PM_SetAnim(pm, SETANIM_LEGS, LEGS_LEAN_RIGHT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);				}				pm->ps->legsAnimTimer = 500;//Force it to hold the anim for at least half a sec				*/				if ( ps->leanofs <= 28 )				{					leanofs = ps->leanofs + 4;				}				else

//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!//If you really need to violate this rule for SP, then use ifdefs.//By BG-compatible, I mean no use of game-specific data - ONLY use//stuff available in the MP bgEntity (in SP, the bgEntity is #defined//as a gentity, but the MP-compatible access restrictions are based//on the bgEntity structure in the MP codebase) -rww// ProcessOrientCommands the Vehicle.static void ProcessOrientCommands( Vehicle_t *pVeh ){	/********************************************************************************/	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/	/********************************************************************************/	bgEntity_t *parent = pVeh->m_pParentEntity;	playerState_t *parentPS, *riderPS;	bgEntity_t *rider = NULL;	if (parent->s.owner != ENTITYNUM_NONE)	{		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];	}	if ( !rider )	{		rider = parent;	}	parentPS = parent->playerState;	if (rider)	{		float angDif;		riderPS = rider->playerState;		angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);		if (parentPS && parentPS->speed)		{			float s = parentPS->speed;			float maxDif = pVeh->m_pVehicleInfo->turningSpeed*4.0f; //magic number hackery			if (s < 0.0f)			{				s = -s;			}			angDif *= s/pVeh->m_pVehicleInfo->speedMax;			if (angDif > maxDif)			{				angDif = maxDif;			}			else if (angDif < -maxDif)			{				angDif = -maxDif;			}			pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));		}	}/*	speed = VectorLength( parentPS->velocity );	// If the player is the rider...	if ( rider->s.number < MAX_CLIENTS )	{//FIXME: use the vehicle's turning stat in this calc		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];	}	else	{		float turnSpeed = pVeh->m_pVehicleInfo->turningSpeed;		if ( !pVeh->m_pVehicleInfo->turnWhenStopped			&& !parentPS->speed )//FIXME: or !pVeh->m_ucmd.forwardmove?		{//can't turn when not moving			//FIXME: or ramp up to max turnSpeed?			turnSpeed = 0.0f;		}		if (rider->s.eType == ET_NPC)		{//help NPCs out some			turnSpeed *= 2.0f;			if (parentPS->speed > 200.0f)			{				turnSpeed += turnSpeed * parentPS->speed/200.0f*0.05f;			}		}		turnSpeed *= pVeh->m_fTimeModifier;		//default control scheme: strafing turns, mouselook aims		if ( pVeh->m_ucmd.rightmove < 0 )		{			pVeh->m_vOrientation[YAW] += turnSpeed;		}		else if ( pVeh->m_ucmd.rightmove > 0 )		{			pVeh->m_vOrientation[YAW] -= turnSpeed;		}		if ( pVeh->m_pVehicleInfo->malfunctionArmorLevel && pVeh->m_iArmor <= pVeh->m_pVehicleInfo->malfunctionArmorLevel )		{//damaged badly		}	}*/	/********************************************************************************/	/*	END	Here is where make sure the vehicle is properly oriented.	END			*///.........这里部分代码省略.........

//-----------------------------------------------------static void turret_aim( gentity_t *self )//-----------------------------------------------------{	vec3_t	enemyDir, org, org2;	vec3_t	desiredAngles, setAngle;	float	diffYaw = 0.0f, diffPitch = 0.0f, turnSpeed;	const float pitchCap = 40.0f;	gentity_t *top = &g_entities[self->r.ownerNum];	if ( !top )	{		return;	}	// move our gun base yaw to where we should be at this time....	BG_EvaluateTrajectory( &top->s.apos, level.time, top->r.currentAngles );	top->r.currentAngles[YAW] = AngleNormalize180( top->r.currentAngles[YAW] );	top->r.currentAngles[PITCH] = AngleNormalize180( top->r.currentAngles[PITCH] );	turnSpeed = top->speed;	if ( self->painDebounceTime > level.time )	{		desiredAngles[YAW] = top->r.currentAngles[YAW]+flrand(-45,45);		desiredAngles[PITCH] = top->r.currentAngles[PITCH]+flrand(-10,10);		if (desiredAngles[PITCH] < -pitchCap)		{			desiredAngles[PITCH] = -pitchCap;		}		else if (desiredAngles[PITCH] > pitchCap)		{			desiredAngles[PITCH] = pitchCap;		}		diffYaw = AngleSubtract( desiredAngles[YAW], top->r.currentAngles[YAW] );		diffPitch = AngleSubtract( desiredAngles[PITCH], top->r.currentAngles[PITCH] );		turnSpeed = flrand( -5, 5 );	}	else if ( self->enemy )	{		// ...then we'll calculate what new aim adjustments we should attempt to make this frame		// Aim at enemy		VectorCopy( self->enemy->r.currentOrigin, org );		org[2]+=self->enemy->r.maxs[2]*0.5f;		if (self->enemy->s.eType == ET_NPC &&			self->enemy->s.NPC_class == CLASS_VEHICLE &&			self->enemy->m_pVehicle &&			self->enemy->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)		{ //hack!			org[2] += 32.0f;		}		/*		mdxaBone_t	boltMatrix;		// Getting the "eye" here		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 					self->torsoBolt,					&boltMatrix, self->r.currentAngles, self->s.origin, (cg.time?cg.time:level.time),					NULL, self->s.modelScale );		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );		*/		VectorCopy( top->r.currentOrigin, org2 );		VectorSubtract( org, org2, enemyDir );		vectoangles( enemyDir, desiredAngles );		desiredAngles[PITCH] = AngleNormalize180(desiredAngles[PITCH]);		if (desiredAngles[PITCH] < -pitchCap)		{			desiredAngles[PITCH] = -pitchCap;		}		else if (desiredAngles[PITCH] > pitchCap)		{			desiredAngles[PITCH] = pitchCap;		}		diffYaw = AngleSubtract( desiredAngles[YAW], top->r.currentAngles[YAW] );		diffPitch = AngleSubtract( desiredAngles[PITCH], top->r.currentAngles[PITCH] );	}	else	{//FIXME: Pan back and forth in original facing		// no enemy, so make us slowly sweep back and forth as if searching for a new one		desiredAngles[YAW] = sin( level.time * 0.0001f + top->count );		desiredAngles[YAW] *=  60.0f;		desiredAngles[YAW] += self->s.angles[YAW];		desiredAngles[YAW] = AngleNormalize180( desiredAngles[YAW] );		diffYaw = AngleSubtract( desiredAngles[YAW], top->r.currentAngles[YAW] );		diffPitch = AngleSubtract( 0, top->r.currentAngles[PITCH] );		turnSpeed = 1.0f;	}	if ( diffYaw )	{		// cap max speed....		if ( fabs(diffYaw) > turnSpeed )		{			diffYaw = ( diffYaw >= 0 ? turnSpeed : -turnSpeed );		}	}//.........这里部分代码省略.........

//-----------------------------------------------------static void turretG2_aim( gentity_t *self )//-----------------------------------------------------{    vec3_t	enemyDir, org, org2;    vec3_t	desiredAngles, setAngle;    float	diffYaw = 0.0f, diffPitch = 0.0f;    float	maxYawSpeed = (self->spawnflags&SPF_TURRETG2_TURBO)?30.0f:14.0f;    float	maxPitchSpeed = (self->spawnflags&SPF_TURRETG2_TURBO)?15.0f:3.0f;    // move our gun base yaw to where we should be at this time....    BG_EvaluateTrajectory( &self->s.apos, level.time, self->r.currentAngles );    self->r.currentAngles[YAW] = AngleNormalize360( self->r.currentAngles[YAW] );    self->speed = AngleNormalize360( self->speed );    if ( self->enemy )    {        mdxaBone_t	boltMatrix;        // ...then we'll calculate what new aim adjustments we should attempt to make this frame        // Aim at enemy        if ( self->enemy->client )        {            VectorCopy( self->enemy->client->renderInfo.eyePoint, org );        }        else        {            VectorCopy( self->enemy->r.currentOrigin, org );        }        if ( self->spawnflags & 2 )        {            org[2] -= 15;        }        else        {            org[2] -= 5;        }        if ( (self->spawnflags&SPF_TURRETG2_LEAD_ENEMY) )        {   //we want to lead them a bit            vec3_t diff, velocity;            float dist;            VectorSubtract( org, self->s.origin, diff );            dist = VectorNormalize( diff );            if ( self->enemy->client )            {                VectorCopy( self->enemy->client->ps.velocity, velocity );            }            else            {                VectorCopy( self->enemy->s.pos.trDelta, velocity );            }            VectorMA( org, (dist/self->mass), velocity, org );        }        // Getting the "eye" here        trap_G2API_GetBoltMatrix( self->ghoul2,                                  0,                                  (self->alt_fire?self->genericValue12:self->genericValue11),                                  &boltMatrix,                                  self->r.currentAngles,                                  self->s.origin,                                  level.time,                                  NULL,                                  self->modelScale );        BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org2 );        VectorSubtract( org, org2, enemyDir );        vectoangles( enemyDir, desiredAngles );        diffYaw = AngleSubtract( self->r.currentAngles[YAW], desiredAngles[YAW] );        diffPitch = AngleSubtract( self->speed, desiredAngles[PITCH] );    }    else    {        // no enemy, so make us slowly sweep back and forth as if searching for a new one//		diffYaw = sin( level.time * 0.0001f + self->count ) * 5.0f;	// don't do this for now since it can make it go into walls.    }    if ( diffYaw )    {        // cap max speed....        if ( fabs(diffYaw) > maxYawSpeed )        {            diffYaw = ( diffYaw >= 0 ? maxYawSpeed : -maxYawSpeed );        }        // ...then set up our desired yaw        VectorSet( setAngle, 0.0f, diffYaw, 0.0f );        VectorCopy( self->r.currentAngles, self->s.apos.trBase );        VectorScale( setAngle,- 5, self->s.apos.trDelta );        self->s.apos.trTime = level.time;        self->s.apos.trType = TR_LINEAR;    }    if ( diffPitch )    {        if ( fabs(diffPitch) > maxPitchSpeed )        {//.........这里部分代码省略.........

void AnglesSubtract( vector3 *v1, vector3 *v2, vector3 *v3 ) {	v3->x = AngleSubtract( v1->x, v2->x );	v3->y = AngleSubtract( v1->y, v2->y );	v3->z = AngleSubtract( v1->z, v2->z );}

void Reached_Tramcar( gentity_t *ent ) {	gentity_t       *next;	float speed;	vec3_t move;	float length;	// copy the apropriate values	next = ent->nextTrain;	if ( !next || !next->nextTrain ) {		return;     // just stop	}	// Rafael	if ( next->wait == -1 && next->count ) {		// G_Printf ("stoped wait = -1 count %i/n",next->count);		return;	}	if ( !Q_stricmp( ent->classname, "props_me109" ) ) {		vec3_t vec, angles;		float diff;		if ( next->spawnflags & 8 ) { // laps			next->count--;			if ( !next->count ) {				next->count = next->count2;				GetNextTrack( ent );				Think_SetupAirplaneWaypoints( ent );				next = ent->nextTrain;				G_Printf( "changed track to %s/n", next->targetname );			} else {				G_Printf( "%s lap %i/n", next->targetname, next->count );			}		} else if ( ( next->spawnflags & 1 ) && !( next->count ) && ent->health > 0 )         { // SCRIPT flag			GetNextTrack( ent );			Think_SetupAirplaneWaypoints( ent );		} else if ( ( next->spawnflags & 2 ) && ( ent->spawnflags & 8 ) && ent->health <= 0 && ent->takedamage )         { // death path			ent->takedamage = qfalse;			GetNextTrack( ent );			Think_SetupAirplaneWaypoints( ent );		} else if ( ( next->spawnflags & 4 ) )       { // explode the plane			ExplodePlaneSndFx( ent );			ent->s.modelindex = crash_part;			// spawn the wing at the player effect			ent->nextTrain = NULL;			G_UseTargets( next, NULL );			return;		}		VectorSubtract( ent->nextTrain->nextTrain->s.origin, ent->r.currentOrigin, vec );		vectoangles( vec, angles );		diff = AngleSubtract( ent->r.currentAngles [YAW], angles[YAW] );		// diff = AngleSubtract (ent->TargetAngles [YAW], angles[YAW]);		ent->rotate[1] = 1;		ent->angle = -diff;		//if (angles[YAW] == 0)		//	ent->s.apos.trDuration = ent->s.pos.trDuration;		//else		//	ent->s.apos.trDuration = 1000;		{			VectorCopy( next->s.origin, ent->pos1 );			VectorCopy( next->nextTrain->s.origin, ent->pos2 );			// if the path_corner has a speed, use that			if ( next->speed ) {				speed = next->speed;			} else {				// otherwise use the train's speed				speed = ent->speed;			}			if ( speed < 1 ) {				speed = 1;			}			// calculate duration			VectorSubtract( ent->pos2, ent->pos1, move );			length = VectorLength( move );			ent->s.apos.trDuration = length * 1000 / speed;//testing// ent->gDuration = ent->s.apos.trDuration;			ent->gDurationBack = ent->gDuration = ent->s.apos.trDuration;// ent->gDeltaBack = ent->gDelta =		}//.........这里部分代码省略.........

void AnglesSubtract(vec3_t v1, vec3_t v2, vec3_t v3) {	v3[0] = AngleSubtract(v1[0], v2[0]);	v3[1] = AngleSubtract(v1[1], v2[1]);	v3[2] = AngleSubtract(v1[2], v2[2]);}

/*=================CG_DrawNewCompass=================*/static void CG_DrawNewCompass(rectDef_t location){	float        basex = location.x, basey = location.y - 16, basew = location.w, baseh = location.h;	snapshot_t   *snap;	float        angle;	int          i;	static float lastangle  = 0;	static float anglespeed = 0;	float        diff;	if (cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport)	{		snap = cg.nextSnap;	}	else	{		snap = cg.snap;	}	if (snap->ps.pm_flags & PMF_LIMBO /*|| snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR*/#if FEATURE_MULTIVIEW	    || cg.mvTotalClients > 0#endif	    )	{		CG_DrawExpandedAutoMap();		return;	}	diff = basew * 0.25f;	if (cgs.autoMapExpanded)	{		if (cg.time - cgs.autoMapExpandTime < 100.f)		{			CG_CompasMoveLocation(&basex, &basey, qtrue);		}		else		{			CG_DrawExpandedAutoMap();			return;		}	}	else	{		if (cg.time - cgs.autoMapExpandTime <= 150.f)		{			CG_DrawExpandedAutoMap();			return;		}		else if ((cg.time - cgs.autoMapExpandTime > 150.f) && (cg.time - cgs.autoMapExpandTime < 250.f))		{			CG_CompasMoveLocation(&basex, &basey, qfalse);		}	}	if (snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR)	{		return;	}	CG_DrawAutoMap(basex + (diff / 2), basey + (diff / 2), basew - diff, baseh - diff);	CG_DrawPic(basex + 4, basey + 4, basew - 8, baseh - 8, cgs.media.compassShader);	angle       = (cg.predictedPlayerState.viewangles[YAW] + 180.f) / 360.f - (0.125f);	diff        = AngleSubtract(angle * 360, lastangle * 360) / 360.f;	anglespeed /= 1.08f;	anglespeed += diff * 0.01f;	if (Q_fabs(anglespeed) < 0.00001f)	{		anglespeed = 0;	}	lastangle += anglespeed;	CG_DrawRotatedPic(basex + 4, basey + 4, basew - 8, baseh - 8, cgs.media.compass2Shader, lastangle);	//if( !(cgs.ccFilter & CC_FILTER_REQUESTS) ) {	// draw voice chats	{		centity_t *cent;		for (i = 0; i < MAX_CLIENTS; i++)		{			cent = &cg_entities[i];			if (cg.predictedPlayerState.clientNum == i || !cgs.clientinfo[i].infoValid || cg.predictedPlayerState.persistant[PERS_TEAM] != cgs.clientinfo[i].team)			{				continue;			}			// also draw revive icons if cent is dead and player is a medic			if (cent->voiceChatSpriteTime < cg.time)			{				continue;			}//.........这里部分代码省略.........