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

/*===============FireWeapon3===============*/void FireWeapon3( gentity_t *ent ){	if ( ent->client )	{		// set aiming directions		AngleVectors( ent->client->ps.viewangles, forward, right, up );		CalcMuzzlePoint( ent, forward, right, up, muzzle );	}	else	{		AngleVectors( ent->s.angles2, forward, right, up );		VectorCopy( ent->s.pos.trBase, muzzle );	}	// fire the specific weapon	switch ( ent->s.weapon )	{		case WP_ALEVEL3_UPG:			bounceBallFire( ent );			break;		case WP_ABUILD2:			slowBlobFire( ent );			break;		default:			break;	}}

/*===============areaZapFire===============*/void areaZapFire( gentity_t *ent ){  trace_t   tr;  vec3_t    end;  gentity_t *traceEnt;  vec3_t    mins, maxs;  VectorSet( mins, -LEVEL2_AREAZAP_WIDTH, -LEVEL2_AREAZAP_WIDTH, -LEVEL2_AREAZAP_WIDTH );  VectorSet( maxs, LEVEL2_AREAZAP_WIDTH, LEVEL2_AREAZAP_WIDTH, LEVEL2_AREAZAP_WIDTH );  // set aiming directions  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  VectorMA( muzzle, LEVEL2_AREAZAP_RANGE, forward, end );  trap_Trace( &tr, muzzle, mins, maxs, end, ent->s.number, MASK_SHOT );  if( tr.surfaceFlags & SURF_NOIMPACT )    return;  traceEnt = &g_entities[ tr.entityNum ];  if( ( ( traceEnt->client && traceEnt->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS ) ||      ( traceEnt->s.eType == ET_BUILDABLE &&        BG_FindTeamForBuildable( traceEnt->s.modelindex ) == BIT_HUMANS ) ) && traceEnt->health > 0 )  {    G_CreateNewZap( ent, traceEnt );  }}

/*===============CheckPounceAttack===============*/qboolean CheckPounceAttack( gentity_t *ent ){  trace_t tr;  gentity_t *traceEnt;  int damage, timeMax, pounceRange, pounceWidth, payload;  if( ent->client->pmext.pouncePayload <= 0 )    return qfalse;  // In case the goon lands on his target, he get's one shot after landing  payload = ent->client->pmext.pouncePayload;  if( !( ent->client->ps.pm_flags & PMF_CHARGE/* || ent->client->ps.weapon == WP_ALEVEL5 */) )    ent->client->pmext.pouncePayload = 0;  // Calculate muzzle point  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  // Trace from muzzle to see what we hit  if( ent->client->ps.weapon == WP_ALEVEL5)  {      pounceRange = LEVEL5_POUNCE_RANGE;      pounceWidth = LEVEL5_POUNCE_WIDTH;  }  else  {      pounceRange = ent->client->ps.weapon == WP_ALEVEL3 ? LEVEL3_POUNCE_RANGE : LEVEL3_POUNCE_UPG_RANGE;      pounceWidth = LEVEL3_POUNCE_WIDTH;  }  G_WideTrace( &tr, ent, pounceRange, pounceWidth, pounceWidth, &traceEnt );  if( traceEnt == NULL )    return qfalse;  // Send blood impact  if( traceEnt->takedamage )    WideBloodSpurt( ent, traceEnt, &tr, MOD_LEVEL3_POUNCE );  if( !traceEnt->takedamage )    return qfalse;      // Deal damage  if( ent->client->ps.weapon == WP_ALEVEL5)  {    timeMax = LEVEL5_POUNCE_TIME;    damage = payload * LEVEL5_POUNCE_DMG / timeMax;    ent->client->pmext.pouncePayload = 0;    G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage,	      DAMAGE_NO_LOCDAMAGE, MOD_LEVEL5_POUNCE );  }  else  {    timeMax = ent->client->ps.weapon == WP_ALEVEL3 ? LEVEL3_POUNCE_TIME : LEVEL3_POUNCE_TIME_UPG;    damage = payload * LEVEL3_POUNCE_DMG / timeMax;    ent->client->pmext.pouncePayload = 0;    G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage,	      DAMAGE_NO_LOCDAMAGE, MOD_LEVEL3_POUNCE );  }  return qtrue;}

/*===============G_MeleeFireCheck===============*/qboolean G_MeleeFireCheck( gentity_t *ent ) {	trace_t		tr;	vec3_t		end;	gentity_t	*tent;	gentity_t	*traceEnt;	// only living beeings can attack	if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) {		return qfalse;	}	// set aiming directions	AngleVectors ( ent->client->ps.viewangles, forward, right, up);	CalcMuzzlePoint ( ent, forward, right, up, muzzle );	VectorMA (muzzle, 32, forward, end);	// compensate for lag	G_CalcLagTimeAndShiftAllClients( ent );	trap_Trace (&tr, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT);    // move the clients back to their proper positions	if ( level.delagWeapons && ent->client && !(ent->r.svFlags & SVF_BOT) ) {		G_UnTimeShiftAllClients( ent );	}	if ( tr.surfaceFlags & SURF_NOIMPACT ) {		return qfalse;	}	traceEnt = &g_entities[ tr.entityNum ];	// send blood impact	if ( traceEnt->takedamage && traceEnt->client ) {		// compensate for lag effects		if ( level.delagWeapons && ent->client && !(ent->r.svFlags & SVF_BOT) ) {			VectorSubtract( traceEnt->client->saved.currentOrigin, traceEnt->r.currentOrigin, end );			VectorAdd( tr.endpos, end, tr.endpos );		}		// snap the endpos to integers, but nudged towards the line		SnapVectorTowards( tr.endpos, muzzle );		// create impact entity		tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_FLESH );		tent->s.eventParm = traceEnt->s.number;	}	if ( !traceEnt->takedamage) {		return qfalse;	}	G_Damage( traceEnt, ent, ent, forward, tr.endpos,		weLi[WP_SHOCKER].damage, 0, MOD_SHOCKER );	return qtrue;}

/*===============CheckGrabAttack===============*/void CheckGrabAttack( gentity_t *ent ){  trace_t   tr;  vec3_t    end, dir;  gentity_t *traceEnt;  // set aiming directions  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  VectorMA( muzzle, LEVEL1_GRAB_RANGE, forward, end );  trap_Trace( &tr, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT );  if( tr.surfaceFlags & SURF_NOIMPACT )    return;  traceEnt = &g_entities[ tr.entityNum ];  if( !traceEnt->takedamage )    return;  if( traceEnt->client )  {    if( traceEnt->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )      return;    if( traceEnt->client->ps.stats[ STAT_HEALTH ] <= 0 )      return;    if( !( traceEnt->client->ps.stats[ STAT_STATE ] & SS_GRABBED ) )    {      AngleVectors( traceEnt->client->ps.viewangles, dir, NULL, NULL );      traceEnt->client->ps.stats[ STAT_VIEWLOCK ] = DirToByte( dir );      //event for client side grab effect      G_AddPredictableEvent( ent, EV_LEV1_GRAB, 0 );    }    traceEnt->client->ps.stats[ STAT_STATE ] |= SS_GRABBED;    if( ent->client->ps.weapon == WP_ALEVEL1 )      traceEnt->client->grabExpiryTime = level.time + LEVEL1_GRAB_TIME;    else if( ent->client->ps.weapon == WP_ALEVEL1_UPG )      traceEnt->client->grabExpiryTime = level.time + LEVEL1_GRAB_U_TIME;  }  else if( traceEnt->s.eType == ET_BUILDABLE &&      traceEnt->s.modelindex == BA_H_MGTURRET )  {    if( !traceEnt->lev1Grabbed )      G_AddPredictableEvent( ent, EV_LEV1_GRAB, 0 );    traceEnt->lev1Grabbed = qtrue;    traceEnt->lev1GrabTime = level.time;  }}

/*===============CheckVenomAttack===============*/qboolean CheckVenomAttack( gentity_t *ent ){  trace_t   tr;  gentity_t *traceEnt;  int       damage = LEVEL0_BITE_DMG;  if( ent->client->ps.weaponTime )	return qfalse;  // Calculate muzzle point  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  G_WideTrace( &tr, ent, LEVEL0_BITE_RANGE, LEVEL0_BITE_WIDTH,               LEVEL0_BITE_WIDTH, &traceEnt );  if( traceEnt == NULL )    return qfalse;  if( !traceEnt->takedamage )    return qfalse;  if( traceEnt->health <= 0 )      return qfalse;  // only allow bites to work against buildings as they are constructing  if( traceEnt->s.eType == ET_BUILDABLE )  {    if( traceEnt->buildableTeam == TEAM_ALIENS )      return qfalse;    if ( !( traceEnt->s.modelindex == BA_H_MGTURRET || traceEnt->s.modelindex == BA_H_MGTURRET2 || traceEnt->s.modelindex == BA_H_TESLAGEN || !traceEnt->spawned ) )      damage = (int)(damage * g_DretchBuildingDamage.value);    else      damage = (int)(damage * g_DretchTurretDamage.value);    if (damage <= 0)      return qfalse;  }  if( traceEnt->client )  {    if( traceEnt->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )      return qfalse;    if( traceEnt->client->ps.stats[ STAT_HEALTH ] <= 0 )      return qfalse;  }  // send blood impact  WideBloodSpurt( ent, traceEnt, &tr, MOD_LEVEL0_BITE );  G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_LEVEL0_BITE );  ent->client->ps.weaponTime += LEVEL0_BITE_REPEAT;  return qtrue;}

/*===============CheckGauntletAttack===============*/qboolean CheckGauntletAttack( gentity_t *ent ) {	trace_t		tr;	vec3_t		end;	gentity_t	*tent;	gentity_t	*traceEnt;	int			damage;	// set aiming directions	AngleVectors (ent->client->ps.viewangles, forward, right, up);	CalcMuzzlePoint ( ent, forward, right, up, muzzle );	VectorMA (muzzle, 32, forward, end);	trap_Trace (&tr, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT);	if ( tr.surfaceFlags & SURF_NOIMPACT ) {		return qfalse;	}	if ( ent->client->noclip ) {		return qfalse;	}	traceEnt = &g_entities[ tr.entityNum ];	// send blood impact	if ( traceEnt->takedamage && traceEnt->client ) {		tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );		tent->s.otherEntityNum = traceEnt->s.number;		tent->s.eventParm = DirToByte( tr.plane.normal );		tent->s.weapon = ent->s.weapon;	}	if ( !traceEnt->takedamage) {		return qfalse;	}	if (ent->client->ps.powerups[PW_QUAD] ) {		G_AddEvent( ent, EV_POWERUP_QUAD, 0 );		s_quadFactor = g_quadfactor.value;	} else {		s_quadFactor = 1;	}#if 1	if( ent->client->persistantPowerup && ent->client->persistantPowerup->item && ent->client->persistantPowerup->item->giTag == PW_DOUBLER ) {		s_quadFactor *= 2;	}#endif	damage = 50 * s_quadFactor;	G_Damage( traceEnt, ent, ent, forward, tr.endpos,		damage, 0, MOD_GAUNTLET );	return qtrue;}

qboolCheckGauntletAttack(Gentity *ent){	Trace tr;	Vec3	end;	Gentity	*tent;	Gentity	*traceEnt;	int damage;	/* set aiming directions */	anglev3s (ent->client->ps.viewangles, forward, right, up);	CalcMuzzlePoint (ent, forward, right, up, muzzle);	saddv3 (muzzle, 32, forward, end);	trap_Trace (&tr, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT);	if(tr.surfaceFlags & SURF_NOIMPACT)		return qfalse;	if(ent->client->noclip)		return qfalse;	traceEnt = &g_entities[tr.entityNum];	/* send blood impact */	if(traceEnt->takedamage && traceEnt->client){		tent = G_TempEntity(tr.endpos, EV_MISSILE_HIT);		tent->s.otherEntityNum = traceEnt->s.number;		tent->s.eventParm = DirToByte(tr.plane.normal);		tent->s.weap[WSpri] = ent->s.weap[WSpri];		tent->s.weap[WSsec] = ent->s.weap[WSsec];		tent->s.weap[WShook] = ent->s.weap[WShook];	}	if(!traceEnt->takedamage)		return qfalse;	if(ent->client->ps.powerups[PW_QUAD]){		G_AddEvent(ent, EV_POWERUP_QUAD, 0);		s_quadFactor = g_quadfactor.value;	}else		s_quadFactor = 1;#ifdef MISSIONPACK	if(ent->client->persistantPowerup &&	   ent->client->persistantPowerup->item &&	   ent->client->persistantPowerup->item->tag == PW_DOUBLER)	then		s_quadFactor *= 2;#endif	damage = 50 * s_quadFactor;	G_Damage(traceEnt, ent, ent, forward, tr.endpos, damage, 0, MOD_GAUNTLET);	return qtrue;}

/*===============FireWeapon2===============*/void FireWeapon2( gentity_t *ent ){  if( ent->client )  {    // set aiming directions    AngleVectors( ent->client->ps.viewangles, forward, right, up );    CalcMuzzlePoint( ent, forward, right, up, muzzle );  }  else  {    AngleVectors( ent->s.angles2, forward, right, up );    VectorCopy( ent->s.pos.trBase, muzzle );  }  // fire the specific weapon  switch( ent->s.weapon )  {      case WP_MACHINEGUN:      bulletFire( ent, RIFLE_SPREAD2, RIFLE_DMG2, MOD_MACHINEGUN );      break;    case WP_ALEVEL2_UPG:      areaZapFire( ent );      break;    case WP_PAIN_SAW:      painSawFire2( ent );      break; 	      case WP_LUCIFER_CANNON:      LCChargeFire( ent, qtrue );      break;	      case WP_CHAINGUN:      bulletFire( ent, CHAINGUN_SPREAD2, CHAINGUN_DMG2, MOD_CHAINGUN );      break;    case WP_LAS_GUN:      lasGunFire2( ent );      break;	      case WP_PULSE_RIFLE:      prifleStasisFire( ent );      break;	      case WP_ABUILD:    case WP_HBUILD:      cancelBuildFire( ent );      break;	      default:      break;  }}

void Weapon_GrapplingHook_Fire (gentity_t *ent){//freeze	AngleVectors( ent->client->ps.viewangles, forward, right, up );	CalcMuzzlePoint( ent, forward, right, up, muzzle );//freeze	if (!ent->client->fireHeld && !ent->client->hook)		fire_grapple (ent, muzzle, forward);	ent->client->fireHeld = qtrue;}

void Weapon_GrapplingHook_Fire (gentity_t *ent){	/* LQ3A: Take the direction from the viewangles. */	AngleVectors(ent->client->ps.viewangles, forward, right, up);	CalcMuzzlePoint(ent, forward, right, up, muzzle);	if (!ent->client->fireHeld && !ent->client->hook)		fire_grapple (ent, muzzle, forward);	ent->client->fireHeld = qtrue;}

/*===============Offhand_Grapple_Fire===============*/void Offhand_Grapple_Fire(gentity_t *ent){    AngleVectors(ent->client->ps.viewangles, forward, right, up);    CalcMuzzlePoint(ent, forward, right, up, muzzle);    if (!ent->client->fireHeld && !ent->client->hook)        fire_grapple(ent, muzzle, forward);    ent->client->hookhasbeenfired = qtrue;    ent->client->fireHeld = qtrue;}

/*===============FireWeapon2===============*/void FireWeapon2( gentity_t *ent ){  if( ent->client )  {    // set aiming directions    AngleVectors( ent->client->ps.viewangles, forward, right, up );    CalcMuzzlePoint( ent, forward, right, up, muzzle );  }  else  {    AngleVectors( ent->s.angles2, forward, right, up );    VectorCopy( ent->s.pos.trBase, muzzle );  }  // fire the specific weapon  switch( ent->s.weapon )  {		/*case WP_ALEVEL1:			//Blaster_ball( ent, 0);			break;*/			    case WP_ALEVEL0:        explodedretch( ent );        break;    case WP_ALEVEL1_UPG:      poisonCloud( ent );      break;    case WP_ALEVEL2_UPG:      areaZapFire( ent );      break;    case WP_LUCIFER_CANNON:      LCChargeFire( ent, qtrue );      break;    case WP_ABUILD:    case WP_ABUILD2:    case WP_HBUILD:    case WP_HBUILD2:      cancelBuildFire( ent );      break;            case WP_BLASTER:          detonate( ent );          break;    default:      break;  }}

/*===============FireWeapon3===============*/void FireWeapon3( gentity_t *ent ){  if( ent->client )  {    // set aiming directions    AngleVectors( ent->client->ps.viewangles, forward, right, up );    CalcMuzzlePoint( ent, forward, right, up, muzzle );  }  else  {    AngleVectors( ent->s.angles2, forward, right, up );    VectorCopy( ent->s.pos.trBase, muzzle );  }  // fire the specific weapon  switch( ent->s.weapon )  {    case WP_ALEVEL3_UPG:      bounceBallFire( ent );      break;    case WP_ABUILD:      slowBlobFire( ent );      break;   case WP_ALEVEL2_UPG:      bounceBallFire_level2( ent );      break;  case WP_ALEVEL5:      Prickles( ent );      break;	      case WP_ALEVEL4:      // FireBreath_tyrant( ent );      break;    case WP_MASS_DRIVER:      if(g_humanStage.integer == S5 && BG_InventoryContainsUpgrade( UP_BATTPACK, ent->client->ps.stats ))      {	  massDriverFire2( ent );      }      break;    default:      break;  }}

void painSawFire( gentity_t *ent ){  trace_t   tr;  vec3_t    end;  gentity_t *tent;  gentity_t *traceEnt;  // set aiming directions  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  VectorMA( muzzle, PAINSAW_RANGE, forward, end );  G_UnlaggedOn( ent, muzzle, PAINSAW_RANGE );  trap_Trace( &tr, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT );  G_UnlaggedOff( );  if( tr.surfaceFlags & SURF_NOIMPACT )    return;  traceEnt = &g_entities[ tr.entityNum ];  // send blood impact  if( traceEnt->takedamage )  {    vec3_t  temp;    //hack to get the particle system to line up with the weapon    VectorCopy( tr.endpos, temp );    temp[ 2 ] -= 10.0f;    if( traceEnt->client )    {      tent = G_TempEntity( temp, EV_MISSILE_HIT );      tent->s.otherEntityNum = traceEnt->s.number;    }    else      tent = G_TempEntity( temp, EV_MISSILE_MISS );    tent->s.eventParm = DirToByte( tr.plane.normal );    tent->s.weapon = ent->s.weapon;    tent->s.generic1 = ent->s.generic1; //weaponMode  }  if( traceEnt->takedamage )    G_Damage( traceEnt, ent, ent, forward, tr.endpos, PAINSAW_DAMAGE, DAMAGE_NO_KNOCKBACK, MOD_PAINSAW );}

void Rune_Phase_Use(gentity_t *ent){	vec3_t oldmuzzle,muzzle,forward,right,up,end;	trace_t trace, trace2;	AngleVectors (ent->client->ps.viewangles, forward, right, up);	CalcMuzzlePoint ( ent, forward, right, up, muzzle );	if (ent->runetime<level.time)	{		VectorMA (muzzle, 250, forward, end);		trap_Trace (&trace, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT );		// we didn't hit anything, so exit		if ( trace.fraction == 1)			return;		SnapVectorTowards( trace.endpos, muzzle );        // prepare for firing through the wall        VectorCopy (muzzle, oldmuzzle);        VectorCopy (trace.endpos, muzzle);        VectorMA (muzzle, 96, forward, muzzle);                        if ( !( trap_PointContents( muzzle, -1 ) & CONTENTS_SOLID ))        {			// the point isn't inside a wall, so check to see if we are outside the bounds of the level			VectorCopy(muzzle,end);			end[2]=-10000;			trap_Trace (&trace2, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT );			// if we didn't hit anything after that big a trace, we are outside the level			if (trace2.fraction==1)				return;			TeleportPlayer(ent,muzzle,ent->client->ps.viewangles, qtrue, qtrue);			ent->runetime = level.time + RUNE_PHASE_RECHARGE;        }	}	else	{		//trap_SendServerCommand( ent->s.clientNum, va("print /"Phase is recharging/n/""));	}}

//---------------------------------------------------------static void WP_DropDetPack( gentity_t *self, vec3_t start, vec3_t dir ) //---------------------------------------------------------{	// Chucking a new one	AngleVectors( self->client->ps.viewangles, forwardVec, vrightVec, up );	CalcMuzzlePoint( self, forwardVec, vrightVec, up, muzzle, 0 );	VectorNormalize( forwardVec );	VectorMA( muzzle, -4, forwardVec, muzzle );	VectorCopy( muzzle, start );	WP_TraceSetStart( self, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall	gentity_t	*missile = CreateMissile( start, forwardVec, 300, 10000, self, qfalse );	missile->fxID = G_EffectIndex( "detpack/explosion" ); // if we set an explosion effect, explode death can use that instead	missile->classname = "detpack";	missile->s.weapon = WP_DET_PACK;	missile->s.pos.trType = TR_GRAVITY;	missile->s.eFlags |= EF_MISSILE_STICK;	missile->e_TouchFunc = touchF_charge_stick;		missile->damage = weaponData[WP_DET_PACK].damage;	missile->methodOfDeath = MOD_DETPACK;	missile->splashDamage = weaponData[WP_DET_PACK].splashDamage;	missile->splashRadius = weaponData[WP_DET_PACK].splashRadius;	missile->splashMethodOfDeath = MOD_DETPACK;// ?SPLASH;	missile->clipmask = (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_SHOTCLIP);//MASK_SHOT;	// we don't want it to ever bounce	missile->bounceCount = 0;	missile->s.radius = 30;	VectorSet( missile->s.modelScale, 1.0f, 1.0f, 1.0f );	gi.G2API_InitGhoul2Model( missile->ghoul2, weaponData[WP_DET_PACK].missileMdl, G_ModelIndex( weaponData[WP_DET_PACK].missileMdl ),		NULL_HANDLE, NULL_HANDLE, 0, 0);	AddSoundEvent( NULL, missile->currentOrigin, 128, AEL_MINOR, qtrue );	AddSightEvent( NULL, missile->currentOrigin, 128, AEL_SUSPICIOUS, 10 );}

/*===============FireWeapon3===============*/void FireWeapon3( gentity_t *ent ){  if( ent->client )  {    // set aiming directions    AngleVectors( ent->client->ps.viewangles, forward, right, up );    CalcMuzzlePoint( ent, forward, right, up, muzzle );  }  else  {    AngleVectors( ent->s.angles2, forward, right, up );    VectorCopy( ent->s.pos.trBase, muzzle );  }  // fire the specific weapon  switch( ent->s.weapon )  {    case WP_ALEVEL3_UPG:      bounceBallFire( ent );      break;    case WP_ABUILD2:      slowBlobFire( ent );      break;//    case WP_ALEVEL4://      lockBlobLauncherFire( ent ); //thats right bitch, i'll trap you!//N/B: Trap as in trap, not males dressing up as women.      break;/*    case WP_HBUILD2:      bulletFire( ent, 300, 1, MOD_TRIGGER_HURT );      bulletFire( ent, 300, 1, MOD_TRIGGER_HURT );      bulletFire( ent, 300, 1, MOD_TRIGGER_HURT );      break;	*/    default:      break;  }}

/*===============meleeAttack===============*/void meleeAttack( gentity_t *ent, float range, float width, int damage, meansOfDeath_t mod ){  trace_t   tr;  vec3_t    end;  gentity_t *tent;  gentity_t *traceEnt;  vec3_t    mins, maxs;  VectorSet( mins, -width, -width, -width );  VectorSet( maxs, width, width, width );  // set aiming directions  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  VectorMA( muzzle, range, forward, end );  G_UnlaggedOn( ent, muzzle, range );  trap_Trace( &tr, muzzle, mins, maxs, end, ent->s.number, MASK_SHOT );  G_UnlaggedOff( );  if( tr.surfaceFlags & SURF_NOIMPACT )    return;  traceEnt = &g_entities[ tr.entityNum ];  // send blood impact  if( traceEnt->takedamage && traceEnt->client )  {    tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );    tent->s.otherEntityNum = traceEnt->s.number;    tent->s.eventParm = DirToByte( tr.plane.normal );    tent->s.weapon = ent->s.weapon;    tent->s.generic1 = ent->s.generic1; //weaponMode  }  if( traceEnt->takedamage )    G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, mod );}

/*===============G_MedkitTargetLook for a possible healing target (a client) in the front.===============*/gentity_t *G_MedkitTarget( gentity_t *ent ){  trace_t   tr;  gentity_t *targetEnt = NULL;  if( g_humanMedkitRange.value <= 0 ||      g_humanMedkitWidth.value <= 0 )    return NULL;  // Calculate muzzle point  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  G_WideTrace( &tr, ent, g_humanMedkitRange.value,      g_humanMedkitWidth.value, g_humanMedkitWidth.value, &targetEnt );  if( ( targetEnt != NULL ) &&      ( targetEnt->client != NULL ) )    return targetEnt;  else    return NULL;}

/*================G_WideTraceTrace a bounding box against entities, but not the worldAlso check there is a line of sight between the start and end point================*/static void G_WideTrace( trace_t *tr, gentity_t *ent, float range, float width, gentity_t **target ){  vec3_t    mins, maxs;  vec3_t    end;  VectorSet( mins, -width, -width, -width );  VectorSet( maxs, width, width, width );  *target = NULL;  if( !ent->client )    return;  // Set aiming directions  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  VectorMA( muzzle, range, forward, end );  G_UnlaggedOn( ent, muzzle, range );  // Trace against entities  trap_Trace( tr, muzzle, mins, maxs, end, ent->s.number, CONTENTS_BODY );  if( tr->entityNum != ENTITYNUM_NONE )  {    *target = &g_entities[ tr->entityNum ];    // Set range to the trace length plus the width, so that the end of the    // LOS trace is close to the exterior of the target's bounding box    range = Distance( muzzle, tr->endpos ) + width;    VectorMA( muzzle, range, forward, end );    // Trace for line of sight against the world    trap_Trace( tr, muzzle, NULL, NULL, end, 0, CONTENTS_SOLID );    if( tr->fraction < 1.0f )      *target = NULL;  }  G_UnlaggedOff( );}

//.........这里部分代码省略.........		else if ( !ent->enemy )		{//an NPC with no enemy to auto-aim at			VectorCopy( ent->client->renderInfo.muzzleDir, wpFwd );		}		else		{//NPC, auto-aim at enemy			CalcEntitySpot( ent->enemy, SPOT_HEAD, enemy_org1 );			VectorSubtract (enemy_org1, muzzle1, delta1);			vectoangles ( delta1, angleToEnemy1 );			AngleVectors (angleToEnemy1, wpFwd, wpVright, wpUp);		}	}	else if ( ent->s.weapon == WP_BOT_LASER && ent->enemy )	{		vec3_t	delta1, enemy_org1, muzzle1;		vec3_t	angleToEnemy1;		CalcEntitySpot( ent->enemy, SPOT_HEAD, enemy_org1 );		CalcEntitySpot( ent, SPOT_WEAPON, muzzle1 );		VectorSubtract (enemy_org1, muzzle1, delta1);		vectoangles ( delta1, angleToEnemy1 );		AngleVectors (angleToEnemy1, wpFwd, wpVright, wpUp);	}	else	{		AngleVectors( ent->client->ps.viewangles, wpFwd, wpVright, wpUp );	}	ent->alt_fire = alt_fire;	CalcMuzzlePoint ( ent, wpFwd, wpVright, wpUp, wpMuzzle , 0);	// fire the specific weapon	switch( ent->s.weapon )	{	// Player weapons	//-----------------	case WP_SABER:		return;		break;	case WP_BRYAR_PISTOL:		WP_FireBryarPistol( ent, alt_fire );		break;	case WP_BLASTER:		WP_FireBlaster( ent, alt_fire );		break;	case WP_DISRUPTOR:		alert = 50; // if you want it to alert enemies, remove this		WP_FireDisruptor( ent, alt_fire );		break;	case WP_BOWCASTER:		WP_FireBowcaster( ent, alt_fire );		break;	case WP_REPEATER:		WP_FireRepeater( ent, alt_fire );		break;	case WP_DEMP2:

void Bullet_Fire (gentity_t *ent, float spread, int damage ) {	trace_t		tr;	vec3_t		end;#if 1	vec3_t		impactpoint, bouncedir;#endif	float		r, f, d;	float		u;	gentity_t	*tent;	gentity_t	*traceEnt;	int			i, passent;	vec3_t		forward, right, up;	AngleVectors (ent->client->ps.viewangles, forward, right, up);	CalcMuzzlePoint ( ent, forward, right, up, muzzle );	ent->client->accuracy_shots++;	f = ((float)(ent->client->accuracy_shots % SPIRAL_SIZE)) / SPIRAL_SIZE; // 0 >= f >= 1	d = (f+(1/SPIRAL_SIZE)) * 2.0 * M_PI;	damage *= s_quadFactor;	//Com_Printf("f: %f, d: %f/n, a: %i", f, d, ent->client->accuracy_shots);	u = sin(d) * (f * spread);	r = cos(d) * (f * spread);	//Com_Printf("end1 : [%f, %f, %f]/n", end[0], end[1], end[2]);	VectorMA (muzzle, 8192, forward, end);	//Com_Printf("end2 : [%f, %f, %f]/n", end[0], end[1], end[2]);	//Com_Printf("right : [%f, %f, %f]/n", right[0], right[1], right[2]);	VectorMA (end, r, right, end);	//Com_Printf("end3 : [%f, %f, %f]/n", end[0], end[1], end[2]);	//Com_Printf("up : [%f, %f, %f]/n", up[0], up[1], up[2]);	VectorMA (end, u, up, end);	//Com_Printf("end4 : [%f, %f, %f]/n", end[0], end[1], end[2]);	passent = ent->s.number;	for (i = 0; i < 10; i++) {		trap_Trace (&tr, muzzle, NULL, NULL, end, passent, MASK_SHOT);		if ( tr.surfaceFlags & SURF_NOIMPACT ) {			return;		}		traceEnt = &g_entities[ tr.entityNum ];		// snap the endpos to integers, but nudged towards the line		SnapVectorTowards( tr.endpos, muzzle );		// send bullet impact		if ( traceEnt->takedamage && traceEnt->client ) {			tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_FLESH );			tent->s.eventParm = traceEnt->s.number;			if( LogAccuracyHit( traceEnt, ent ) ) {				ent->client->accuracy_hits++;			}		} else {			tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_WALL );			tent->s.eventParm = DirToByte( tr.plane.normal );		}		tent->s.otherEntityNum = ent->s.number;		if ( traceEnt->takedamage) {#if 1			if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {				if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {					G_BounceProjectile( muzzle, impactpoint, bouncedir, end );					VectorCopy( impactpoint, muzzle );					// the player can hit him/herself with the bounced rail					passent = ENTITYNUM_NONE;				}				else {					VectorCopy( tr.endpos, muzzle );					passent = traceEnt->s.number;				}				continue;			}			else {#endif				G_Damage( traceEnt, ent, ent, forward, tr.endpos,					damage, 0, MOD_MACHINEGUN);#if 1			}#endif		}		break;	}}

//.........这里部分代码省略.........		{			VectorCopy ( ent->currentOrigin, point );			if ( ent->client ) 			{				point[2] += ent->client->ps.viewheight;			}		}		if ( spot == SPOT_CHEST && ent->client )		{			if ( ent->client->NPC_class != CLASS_ATST )			{//adjust up some				point[2] -= ent->maxs[2]*0.2f;			}		}		break;	case SPOT_HEAD_LEAN:		if ( ent->client && VectorLengthSquared( ent->client->renderInfo.eyePoint ) && (ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD) )		{//Actual tag_head eyespot!			//FIXME: Stasis aliens may have a problem here...			VectorCopy( ent->client->renderInfo.eyePoint, point );			if ( ent->client->NPC_class == CLASS_ATST )			{//adjust up some				point[2] += 28;//magic number :)			}			if ( ent->NPC )			{//always aim from the center of my bbox, so we don't wiggle when we lean forward or backwards				point[0] = ent->currentOrigin[0];				point[1] = ent->currentOrigin[1];			}			else if ( !ent->s.number )			{				SubtractLeanOfs( ent, point );			}			//NOTE: automatically takes leaning into account!		}		else		{			VectorCopy ( ent->currentOrigin, point );			if ( ent->client ) 			{				point[2] += ent->client->ps.viewheight;			}			//AddLeanOfs ( ent, point );		}		break;	//FIXME: implement...	//case SPOT_CHEST:		//Returns point 3/4 from tag_torso to tag_head?		//break;	case SPOT_LEGS:		VectorCopy ( ent->currentOrigin, point );		point[2] += (ent->mins[2] * 0.5);		break;	case SPOT_WEAPON:		if( ent->NPC && !VectorCompare( ent->NPC->shootAngles, vec3_origin ) && !VectorCompare( ent->NPC->shootAngles, ent->client->ps.viewangles ))		{			AngleVectors( ent->NPC->shootAngles, forward, right, up );		}		else		{			AngleVectors( ent->client->ps.viewangles, forward, right, up );		}		CalcMuzzlePoint( (gentity_t*)ent, forward, right, up, point, 0 );		//NOTE: automatically takes leaning into account!		break;	case SPOT_GROUND:		// if entity is on the ground, just use it's absmin		if ( ent->s.groundEntityNum != -1 ) 		{			VectorCopy( ent->currentOrigin, point );			point[2] = ent->absmin[2];			break;		}		// if it is reasonably close to the ground, give the point underneath of it		VectorCopy( ent->currentOrigin, start );		start[2] = ent->absmin[2];		VectorCopy( start, end );		end[2] -= 64;		gi.trace( &tr, start, ent->mins, ent->maxs, end, ent->s.number, MASK_PLAYERSOLID, G2_NOCOLLIDE, 0 );		if ( tr.fraction < 1.0 ) 		{			VectorCopy( tr.endpos, point);			break;		}		// otherwise just use the origin		VectorCopy( ent->currentOrigin, point );		break;	default:		VectorCopy ( ent->currentOrigin, point );		break;	}}

void NPC_BSSniper_Attack( void ){	//Don't do anything if we're hurt	if ( NPC->painDebounceTime > level.time )	{		NPC_UpdateAngles( qtrue, qtrue );		return;	}	//NPC_CheckEnemy( qtrue, qfalse );	//If we don't have an enemy, just idle	if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//	{		NPC->enemy = NULL;		NPC_BSSniper_Patrol();//FIXME: or patrol?		return;	}	if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )	{//going to run		NPC_UpdateAngles( qtrue, qtrue );		return;	}	if ( !NPC->enemy )	{//WTF?  somehow we lost our enemy?		NPC_BSSniper_Patrol();//FIXME: or patrol?		return;	}	enemyLOS = enemyCS = qfalse;	AImove = qtrue;	faceEnemy = qfalse;	shoot = qfalse;	enemyDist = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	if ( enemyDist < 16384 )//128 squared	{//too close, so switch to primary fire		if ( NPC->client->ps.weapon == WP_DISRUPTOR )		{//sniping... should be assumed			if ( NPCInfo->scriptFlags & SCF_ALT_FIRE )			{//use primary fire				trace_t	trace;				gi.trace ( &trace, NPC->enemy->currentOrigin, NPC->enemy->mins, NPC->enemy->maxs, NPC->currentOrigin, NPC->enemy->s.number, NPC->enemy->clipmask, G2_NOCOLLIDE, 0 );				if ( !trace.allsolid && !trace.startsolid && (trace.fraction == 1.0 || trace.entityNum == NPC->s.number ) )				{//he can get right to me					NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;					//reset fire-timing variables					NPC_ChangeWeapon( WP_DISRUPTOR );					NPC_UpdateAngles( qtrue, qtrue );					return;				}			}			//FIXME: switch back if he gets far away again?		}	}	else if ( enemyDist > 65536 )//256 squared	{		if ( NPC->client->ps.weapon == WP_DISRUPTOR )		{//sniping... should be assumed			if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )			{//use primary fire				NPCInfo->scriptFlags |= SCF_ALT_FIRE;				//reset fire-timing variables				NPC_ChangeWeapon( WP_DISRUPTOR );				NPC_UpdateAngles( qtrue, qtrue );				return;			}		}	}	Sniper_UpdateEnemyPos();	//can we see our target?	if ( NPC_ClearLOS( NPC->enemy ) )//|| (NPCInfo->stats.aim >= 5 && gi.inPVS( NPC->client->renderInfo.eyePoint, NPC->enemy->currentOrigin )) )	{		NPCInfo->enemyLastSeenTime = level.time;		VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );		enemyLOS = qtrue;		float maxShootDist = NPC_MaxDistSquaredForWeapon();		if ( enemyDist < maxShootDist )		{			vec3_t fwd, right, up, muzzle, end;			trace_t	tr;			AngleVectors( NPC->client->ps.viewangles, fwd, right, up );			CalcMuzzlePoint( NPC, fwd, right, up, muzzle, 0 );			VectorMA( muzzle, 8192, fwd, end );			gi.trace ( &tr, muzzle, NULL, NULL, end, NPC->s.number, MASK_SHOT, G2_RETURNONHIT, 0 );			int hit = tr.entityNum;			//can we shoot our target?			if ( Sniper_EvaluateShot( hit ) )			{				enemyCS = qtrue;			}		}	}	/*	else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )	{		NPCInfo->enemyLastSeenTime = level.time;		faceEnemy = qtrue;//.........这里部分代码省略.........

void Sniper_FaceEnemy( void ){	//FIXME: the ones behind kill holes are facing some arbitrary direction and not firing	//FIXME: If actually trying to hit enemy, don't fire unless enemy is at least in front of me?	//FIXME: need to give designers option to make them not miss first few shots	if ( NPC->enemy )	{		vec3_t	muzzle, target, angles, forward, right, up;		//Get the positions		AngleVectors( NPC->client->ps.viewangles, forward, right, up );		CalcMuzzlePoint( NPC, forward, right, up, muzzle, 0 );		//CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );		CalcEntitySpot( NPC->enemy, SPOT_ORIGIN, target );		if ( enemyDist > 65536 && NPCInfo->stats.aim < 5 )//is 256 squared, was 16384 (128*128)		{			if ( NPC->count < (5-NPCInfo->stats.aim) )			{//miss a few times first				if ( shoot && TIMER_Done( NPC, "attackDelay" ) && level.time >= NPCInfo->shotTime )				{//ready to fire again					qboolean	aimError = qfalse;					qboolean	hit = qtrue;					int			tryMissCount = 0;					trace_t		trace;					GetAnglesForDirection( muzzle, target, angles );					AngleVectors( angles, forward, right, up );					while ( hit && tryMissCount < 10 )					{						tryMissCount++;						if ( !Q_irand( 0, 1 ) )						{							aimError = qtrue;							if ( !Q_irand( 0, 1 ) )							{								VectorMA( target, NPC->enemy->maxs[2]*Q_flrand(1.5, 4), right, target );							}							else							{								VectorMA( target, NPC->enemy->mins[2]*Q_flrand(1.5, 4), right, target );							}						}						if ( !aimError || !Q_irand( 0, 1 ) )						{							if ( !Q_irand( 0, 1 ) )							{								VectorMA( target, NPC->enemy->maxs[2]*Q_flrand(1.5, 4), up, target );							}							else							{								VectorMA( target, NPC->enemy->mins[2]*Q_flrand(1.5, 4), up, target );							}						}						gi.trace( &trace, muzzle, vec3_origin, vec3_origin, target, NPC->s.number, MASK_SHOT, G2_NOCOLLIDE, 0 );						hit = Sniper_EvaluateShot( trace.entityNum );					}					NPC->count++;				}				else				{					if ( !enemyLOS )					{						NPC_UpdateAngles( qtrue, qtrue );						return;					}				}			}			else			{//based on distance, aim value, difficulty and enemy movement, miss				//FIXME: incorporate distance as a factor?				int missFactor = 8-(NPCInfo->stats.aim+g_spskill->integer) * 3;				if ( missFactor > ENEMY_POS_LAG_STEPS )				{					missFactor = ENEMY_POS_LAG_STEPS;				}				else if ( missFactor < 0 )				{//???					missFactor = 0 ;				}				VectorCopy( NPCInfo->enemyLaggedPos[missFactor], target );			}			GetAnglesForDirection( muzzle, target, angles );		}		else		{			target[2] += Q_flrand( 0, NPC->enemy->maxs[2] );			//CalcEntitySpot( NPC->enemy, SPOT_HEAD_LEAN, target );			GetAnglesForDirection( muzzle, target, angles );		}		NPCInfo->desiredYaw		= AngleNormalize360( angles[YAW] );		NPCInfo->desiredPitch	= AngleNormalize360( angles[PITCH] );	}	NPC_UpdateAngles( qtrue, qtrue );}

/*===============FireWeapon===============*/void FireWeapon( gentity_t *ent ){	if ( ent->client )	{		// set aiming directions		AngleVectors( ent->client->ps.viewangles, forward, right, up );		CalcMuzzlePoint( ent, forward, right, up, muzzle );	}	else	{		AngleVectors( ent->turretAim, forward, right, up );		VectorCopy( ent->s.pos.trBase, muzzle );	}	// fire the specific weapon	switch ( ent->s.weapon )	{		case WP_ALEVEL1:			meleeAttack( ent, LEVEL1_CLAW_RANGE, LEVEL1_CLAW_WIDTH, LEVEL1_CLAW_WIDTH,			             LEVEL1_CLAW_DMG, MOD_LEVEL1_CLAW );			break;		case WP_ALEVEL1_UPG:			meleeAttack( ent, LEVEL1_CLAW_U_RANGE, LEVEL1_CLAW_WIDTH, LEVEL1_CLAW_WIDTH,			             LEVEL1_CLAW_DMG, MOD_LEVEL1_CLAW );			break;		case WP_ALEVEL3:			meleeAttack( ent, LEVEL3_CLAW_RANGE, LEVEL3_CLAW_WIDTH, LEVEL3_CLAW_WIDTH,			             LEVEL3_CLAW_DMG, MOD_LEVEL3_CLAW );			break;		case WP_ALEVEL3_UPG:			meleeAttack( ent, LEVEL3_CLAW_UPG_RANGE, LEVEL3_CLAW_WIDTH,			             LEVEL3_CLAW_WIDTH, LEVEL3_CLAW_DMG, MOD_LEVEL3_CLAW );			break;		case WP_ALEVEL2:			meleeAttack( ent, LEVEL2_CLAW_RANGE, LEVEL2_CLAW_WIDTH, LEVEL2_CLAW_WIDTH,			             LEVEL2_CLAW_DMG, MOD_LEVEL2_CLAW );			break;		case WP_ALEVEL2_UPG:			meleeAttack( ent, LEVEL2_CLAW_U_RANGE, LEVEL2_CLAW_WIDTH, LEVEL2_CLAW_WIDTH,			             LEVEL2_CLAW_DMG, MOD_LEVEL2_CLAW );			break;		case WP_ALEVEL4:			meleeAttack( ent, LEVEL4_CLAW_RANGE, LEVEL4_CLAW_WIDTH,			             LEVEL4_CLAW_HEIGHT, LEVEL4_CLAW_DMG, MOD_LEVEL4_CLAW );			break;		case WP_BLASTER:			blasterFire( ent );			break;		case WP_MACHINEGUN:			bulletFire( ent, RIFLE_SPREAD, RIFLE_DMG, MOD_MACHINEGUN );			break;		case WP_SHOTGUN:			shotgunFire( ent );			break;		case WP_CHAINGUN:			bulletFire( ent, CHAINGUN_SPREAD, CHAINGUN_DMG, MOD_CHAINGUN );			break;		case WP_FLAMER:			flamerFire( ent );			break;		case WP_PULSE_RIFLE:			pulseRifleFire( ent );			break;		case WP_MASS_DRIVER:			massDriverFire( ent );			break;		case WP_LUCIFER_CANNON:			LCChargeFire( ent, qfalse );			break;		case WP_LAS_GUN:			lasGunFire( ent );			break;		case WP_PAIN_SAW:			painSawFire( ent );			break;		case WP_GRENADE:			throwGrenade( ent );			break;//.........这里部分代码省略.........

/*===============CheckGrabAttack===============*/void CheckGrabAttack( gentity_t *ent ){	trace_t   tr;	vec3_t    end, dir;	gentity_t *traceEnt;	// set aiming directions	AngleVectors( ent->client->ps.viewangles, forward, right, up );	CalcMuzzlePoint( ent, forward, right, up, muzzle );	if ( ent->client->ps.weapon == WP_ALEVEL1 )	{		VectorMA( muzzle, LEVEL1_GRAB_RANGE, forward, end );	}	else if ( ent->client->ps.weapon == WP_ALEVEL1_UPG )	{		VectorMA( muzzle, LEVEL1_GRAB_U_RANGE, forward, end );	}	trap_Trace( &tr, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT );	if ( tr.surfaceFlags & SURF_NOIMPACT )	{		return;	}	traceEnt = &g_entities[ tr.entityNum ];	if ( !traceEnt->takedamage )	{		return;	}	if ( traceEnt->client )	{		if ( traceEnt->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )		{			return;		}		if ( traceEnt->client->ps.stats[ STAT_HEALTH ] <= 0 )		{			return;		}		if ( !( traceEnt->client->ps.stats[ STAT_STATE ] & SS_GRABBED ) )		{			AngleVectors( traceEnt->client->ps.viewangles, dir, NULL, NULL );			traceEnt->client->ps.stats[ STAT_VIEWLOCK ] = DirToByte( dir );			//event for client side grab effect			G_AddPredictableEvent( ent, EV_LEV1_GRAB, 0 );		}		traceEnt->client->ps.stats[ STAT_STATE ] |= SS_GRABBED;		if ( ent->client->ps.weapon == WP_ALEVEL1 )		{			traceEnt->client->grabExpiryTime = level.time + LEVEL1_GRAB_TIME;			// Update the last combat time.			ent->client->lastCombatTime = level.time + LEVEL1_GRAB_TIME;			traceEnt->client->lastCombatTime = level.time + LEVEL1_GRAB_TIME;		}		else if ( ent->client->ps.weapon == WP_ALEVEL1_UPG )		{			traceEnt->client->grabExpiryTime = level.time + LEVEL1_GRAB_U_TIME;			// Update the last combat time.			ent->client->lastCombatTime = level.time + LEVEL1_GRAB_TIME;			traceEnt->client->lastCombatTime = level.time + LEVEL1_GRAB_TIME;		}	}}

/*===============CheckPounceAttack===============*/qboolean CheckPounceAttack( gentity_t *ent ){  trace_t   tr;  vec3_t    end;  gentity_t *tent;  gentity_t *traceEnt;  int       damage;  vec3_t    mins, maxs;  VectorSet( mins, -LEVEL3_POUNCE_WIDTH, -LEVEL3_POUNCE_WIDTH, -LEVEL3_POUNCE_WIDTH );  VectorSet( maxs, LEVEL3_POUNCE_WIDTH, LEVEL3_POUNCE_WIDTH, LEVEL3_POUNCE_WIDTH );  if( !ent->client->allowedToPounce )    return qfalse;  if( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )  {    ent->client->allowedToPounce = qfalse;    return qfalse;  }  if( ent->client->ps.weaponTime )    return qfalse;  // set aiming directions  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  VectorMA( muzzle, LEVEL3_POUNCE_RANGE, forward, end );  trap_Trace( &tr, ent->s.origin, mins, maxs, end, ent->s.number, MASK_SHOT );  //miss  if( tr.fraction >= 1.0 )    return qfalse;  if( tr.surfaceFlags & SURF_NOIMPACT )    return qfalse;  traceEnt = &g_entities[ tr.entityNum ];  // send blood impact  if( traceEnt->takedamage && traceEnt->client )  {    tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );    tent->s.otherEntityNum = traceEnt->s.number;    tent->s.eventParm = DirToByte( tr.plane.normal );    tent->s.weapon = ent->s.weapon;    tent->s.generic1 = ent->s.generic1; //weaponMode  }  if( !traceEnt->takedamage )    return qfalse;  damage = (int)( ( (float)ent->client->pouncePayload / (float)LEVEL3_POUNCE_SPEED ) * LEVEL3_POUNCE_DMG );  G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage,      DAMAGE_NO_KNOCKBACK|DAMAGE_NO_LOCDAMAGE, MOD_LEVEL3_POUNCE );  ent->client->ps.weaponTime += LEVEL3_POUNCE_TIME;  ent->client->allowedToPounce = qfalse;  return qtrue;}

/*===============CheckVenomAttack===============*/qboolean CheckVenomAttack( gentity_t *ent ){  trace_t   tr;  vec3_t    end;  gentity_t *tent;  gentity_t *traceEnt;  vec3_t    mins, maxs;  int       damage = LEVEL0_BITE_DMG;  VectorSet( mins, -LEVEL0_BITE_WIDTH, -LEVEL0_BITE_WIDTH, -LEVEL0_BITE_WIDTH );  VectorSet( maxs, LEVEL0_BITE_WIDTH, LEVEL0_BITE_WIDTH, LEVEL0_BITE_WIDTH );  // set aiming directions  AngleVectors( ent->client->ps.viewangles, forward, right, up );  CalcMuzzlePoint( ent, forward, right, up, muzzle );  VectorMA( muzzle, LEVEL0_BITE_RANGE, forward, end );  trap_Trace( &tr, muzzle, mins, maxs, end, ent->s.number, MASK_SHOT );  if( tr.surfaceFlags & SURF_NOIMPACT )    return qfalse;  traceEnt = &g_entities[ tr.entityNum ];  if( !traceEnt->takedamage )    return qfalse;  if( !traceEnt->client && !traceEnt->s.eType == ET_BUILDABLE )    return qfalse;  //allow bites to work against defensive buildables only  if( traceEnt->s.eType == ET_BUILDABLE )  {    if( traceEnt->s.modelindex != BA_H_MGTURRET &&        traceEnt->s.modelindex != BA_H_TESLAGEN )      return qfalse;    //hackery    damage *= 0.5f;  }  if( traceEnt->client )  {    if( traceEnt->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )      return qfalse;    if( traceEnt->client->ps.stats[ STAT_HEALTH ] <= 0 )      return qfalse;  }  // send blood impact  if( traceEnt->takedamage && traceEnt->client )  {    tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );    tent->s.otherEntityNum = traceEnt->s.number;    tent->s.eventParm = DirToByte( tr.plane.normal );    tent->s.weapon = ent->s.weapon;    tent->s.generic1 = ent->s.generic1; //weaponMode  }  G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_LEVEL0_BITE );  return qtrue;}