codemp/game/g_vehicleTurret.c File Reference

#include "g_headers.h"
#include "bg_vehicles.h"
#include "b_local.h"
#include "../ghoul2/G2.h"

Go to the source code of this file.

Functions
void	G_SetEnemy (gentity_t *self, gentity_t *enemy)
void	WP_CalcVehMuzzle (gentity_t *ent, int muzzleNum)
gentity_t *	WP_FireVehicleWeapon (gentity_t *ent, vec3_t start, vec3_t dir, vehWeaponInfo_t *vehWeapon, qboolean alt_fire, qboolean isTurretWeap)
void	G_VehMuzzleFireFX (gentity_t *ent, gentity_t *broadcaster, int muzzlesFired)
void	VEH_TurretCheckFire (Vehicle_t *pVeh, gentity_t *parent, turretStats_t *turretStats, vehWeaponInfo_t *vehWeapon, int turretNum, int curMuzzle)
void	VEH_TurretAnglesToEnemy (Vehicle_t *pVeh, int curMuzzle, float fSpeed, gentity_t *turretEnemy, qboolean bAILead, vec3_t desiredAngles)
qboolean	VEH_TurretAim (Vehicle_t *pVeh, gentity_t *parent, gentity_t *turretEnemy, turretStats_t *turretStats, vehWeaponInfo_t *vehWeapon, int turretNum, int curMuzzle, vec3_t desiredAngles)
void	VEH_TurretObeyPassengerControl (Vehicle_t *pVeh, gentity_t *parent, int turretNum)
void	VEH_TurretThink (Vehicle_t *pVeh, gentity_t *parent, int turretNum)

---

Function Documentation

void G_SetEnemy (  gentity_t *  self, gentity_t *  enemy )

void G_VehMuzzleFireFX (  gentity_t *  ent, gentity_t *  broadcaster, int  muzzlesFired )

Definition at line 3836 of file g_weapon.c. References gentity_s::client, EV_VEH_FIRE, G_AddEvent(), G_TempEntity(), gentity_t, gentity_s::m_pVehicle, entityState_s::number, playerState_s::origin, entityState_s::owner, gclient_s::ps, gentity_s::s, entityState_s::trickedentindex, and Vehicle_t. Referenced by FireVehicleWeapon(), and VEH_TurretCheckFire(). { Vehicle_t *pVeh = ent->m_pVehicle; gentity_t *b; if (!pVeh) { return; } if (!broadcaster) { //oh well. We will WASTE A TEMPENT. b = G_TempEntity( ent->client->ps.origin, EV_VEH_FIRE ); } else { //joy b = broadcaster; } //this guy owns it b->s.owner = ent->s.number; //this is the bitfield of all muzzles fired this time //NOTE: just need MAX_VEHICLE_MUZZLES bits for this... should be cool since it's currently 12 and we're sending it in 16 bits b->s.trickedentindex = muzzlesFired; if ( broadcaster ) { //add the event G_AddEvent( b, EV_VEH_FIRE, 0 ); } }

qboolean VEH_TurretAim (  Vehicle_t *  pVeh, gentity_t *  parent, gentity_t *  turretEnemy, turretStats_t *  turretStats, vehWeaponInfo_t *  vehWeapon, int  turretNum, int  curMuzzle, vec3_t  desiredAngles )

Definition at line 89 of file g_vehicleTurret.c. References AngleNormalize180(), AnglesSubtract(), turretStats_t::bAILead, vehWeaponInfo_t::fSpeed, turretStats_t::fTurnSpeed, gentity_t, Vehicle_s::m_iMuzzleTime, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_vMuzzleDir, Vehicle_s::m_vOrientation, NPC_SetBoneAngles(), PITCH, turretStats_t::pitchAxis, turretStats_t::pitchBone, turretStats_t::pitchClampDown, turretStats_t::pitchClampUp, qboolean, qfalse, qtrue, vehicleInfo_t::turret, vec3_t, vectoangles(), VectorClear, VEH_TurretAnglesToEnemy(), Vehicle_t, WP_CalcVehMuzzle(), YAW, turretStats_t::yawAxis, turretStats_t::yawBone, turretStats_t::yawClampLeft, and turretStats_t::yawClampRight. Referenced by VEH_TurretObeyPassengerControl(), and VEH_TurretThink(). { vec3_t curAngles, addAngles, newAngles, yawAngles, pitchAngles; float aimCorrect = qfalse; WP_CalcVehMuzzle( parent, curMuzzle ); //get the current absolute angles of the turret right now vectoangles( pVeh->m_vMuzzleDir[curMuzzle], curAngles ); //subtract out the vehicle's angles to get the relative alignment AnglesSubtract( curAngles, pVeh->m_vOrientation, curAngles ); if ( turretEnemy ) { aimCorrect = qtrue; // ...then we'll calculate what new aim adjustments we should attempt to make this frame // Aim at enemy VEH_TurretAnglesToEnemy( pVeh, curMuzzle, vehWeapon->fSpeed, turretEnemy, turretStats->bAILead, desiredAngles ); } //subtract out the vehicle's angles to get the relative desired alignment AnglesSubtract( desiredAngles, pVeh->m_vOrientation, desiredAngles ); //Now clamp the desired relative angles //clamp yaw desiredAngles[YAW] = AngleNormalize180( desiredAngles[YAW] ); if ( pVeh->m_pVehicleInfo->turret[turretNum].yawClampLeft && desiredAngles[YAW] > pVeh->m_pVehicleInfo->turret[turretNum].yawClampLeft ) { aimCorrect = qfalse; desiredAngles[YAW] = pVeh->m_pVehicleInfo->turret[turretNum].yawClampLeft; } if ( pVeh->m_pVehicleInfo->turret[turretNum].yawClampRight && desiredAngles[YAW] < pVeh->m_pVehicleInfo->turret[turretNum].yawClampRight ) { aimCorrect = qfalse; desiredAngles[YAW] = pVeh->m_pVehicleInfo->turret[turretNum].yawClampRight; } //clamp pitch desiredAngles[PITCH] = AngleNormalize180( desiredAngles[PITCH] ); if ( pVeh->m_pVehicleInfo->turret[turretNum].pitchClampDown && desiredAngles[PITCH] > pVeh->m_pVehicleInfo->turret[turretNum].pitchClampDown ) { aimCorrect = qfalse; desiredAngles[PITCH] = pVeh->m_pVehicleInfo->turret[turretNum].pitchClampDown; } if ( pVeh->m_pVehicleInfo->turret[turretNum].pitchClampUp && desiredAngles[PITCH] < pVeh->m_pVehicleInfo->turret[turretNum].pitchClampUp ) { aimCorrect = qfalse; desiredAngles[PITCH] = pVeh->m_pVehicleInfo->turret[turretNum].pitchClampUp; } //Now get the offset we want from our current relative angles AnglesSubtract( desiredAngles, curAngles, addAngles ); //Now cap the addAngles for our fTurnSpeed if ( addAngles[PITCH] > turretStats->fTurnSpeed ) { //aimCorrect = qfalse;//??? addAngles[PITCH] = turretStats->fTurnSpeed; } else if ( addAngles[PITCH] < -turretStats->fTurnSpeed ) { //aimCorrect = qfalse;//??? addAngles[PITCH] = -turretStats->fTurnSpeed; } if ( addAngles[YAW] > turretStats->fTurnSpeed ) { //aimCorrect = qfalse;//??? addAngles[YAW] = turretStats->fTurnSpeed; } else if ( addAngles[YAW] < -turretStats->fTurnSpeed ) { //aimCorrect = qfalse;//??? addAngles[YAW] = -turretStats->fTurnSpeed; } //Now add the additional angles back in to our current relative angles //FIXME: add some AI aim error randomness...? newAngles[PITCH] = AngleNormalize180( curAngles[PITCH]+addAngles[PITCH] ); newAngles[YAW] = AngleNormalize180( curAngles[YAW]+addAngles[YAW] ); //Now set the bone angles to the new angles //set yaw if ( turretStats->yawBone ) { VectorClear( yawAngles ); yawAngles[turretStats->yawAxis] = newAngles[YAW]; NPC_SetBoneAngles( parent, turretStats->yawBone, yawAngles ); } //set pitch if ( turretStats->pitchBone ) { VectorClear( pitchAngles ); pitchAngles[turretStats->pitchAxis] = newAngles[PITCH]; NPC_SetBoneAngles( parent, turretStats->pitchBone, pitchAngles ); } //force muzzle to recalc next check pVeh->m_iMuzzleTime[curMuzzle] = 0; return aimCorrect; }

void VEH_TurretAnglesToEnemy (  Vehicle_t *  pVeh, int  curMuzzle, float  fSpeed, gentity_t *  turretEnemy, qboolean  bAILead, vec3_t  desiredAngles )

Definition at line 61 of file g_vehicleTurret.c. References gentity_s::client, entityShared_t::currentOrigin, gentity_t, Vehicle_s::m_vMuzzlePos, entityState_s::pos, gclient_s::ps, gentity_s::r, gentity_s::s, trajectory_t::trDelta, vec3_t, vectoangles(), VectorCopy, VectorMA, VectorNormalize(), VectorSubtract, Vehicle_t, and playerState_s::velocity. Referenced by VEH_TurretAim(). { vec3_t enemyDir, org; VectorCopy( turretEnemy->r.currentOrigin, org ); if ( bAILead ) {//we want to lead them a bit vec3_t diff, velocity; float dist; VectorSubtract( org, pVeh->m_vMuzzlePos[curMuzzle], diff ); dist = VectorNormalize( diff ); if ( turretEnemy->client ) { VectorCopy( turretEnemy->client->ps.velocity, velocity ); } else { VectorCopy( turretEnemy->s.pos.trDelta, velocity ); } VectorMA( org, (dist/fSpeed), velocity, org ); } //FIXME: this isn't quite right, it's aiming from the muzzle, not the center of the turret... VectorSubtract( org, pVeh->m_vMuzzlePos[curMuzzle], enemyDir ); //Get the desired absolute, world angles to our target vectoangles( enemyDir, desiredAngles ); }

void VEH_TurretCheckFire (  Vehicle_t *  pVeh, gentity_t *  parent, turretStats_t *  turretStats, vehWeaponInfo_t *  vehWeapon, int  turretNum, int  curMuzzle )

Definition at line 12 of file g_vehicleTurret.c. References vehTurretStatus_t::ammo, G_VehMuzzleFireFX(), gentity_t, vehWeaponInfo_t::iAmmoPerShot, turretStats_t::iDelay, turretStats_t::iMuzzle, level, Vehicle_s::m_iMuzzleTag, Vehicle_s::m_iMuzzleWait, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_vMuzzleDir, Vehicle_s::m_vMuzzlePos, vehTurretStatus_t::nextMuzzle, qtrue, level_locals_t::time, vehicleInfo_t::turret, Vehicle_s::turretStatus, Vehicle_t, WP_CalcVehMuzzle(), and WP_FireVehicleWeapon(). Referenced by VEH_TurretObeyPassengerControl(), and VEH_TurretThink(). { // if it's time to fire and we have an enemy, then gun 'em down! pushDebounce time controls next fire time if ( pVeh->m_iMuzzleTag[curMuzzle] == -1 ) {//invalid muzzle? return; } if ( pVeh->m_iMuzzleWait[curMuzzle] >= level.time ) {//can't fire yet return; } if ( pVeh->turretStatus[turretNum].ammo < vehWeapon->iAmmoPerShot ) {//no ammo, can't fire return; } //if ( turretEnemy ) { //FIXME: check to see if I'm aiming generally where I want to int nextMuzzle = 0, muzzlesFired = (1<<curMuzzle); gentity_t *missile; WP_CalcVehMuzzle( parent, curMuzzle ); //FIXME: some variation in fire dir missile = WP_FireVehicleWeapon( parent, pVeh->m_vMuzzlePos[curMuzzle], pVeh->m_vMuzzleDir[curMuzzle], vehWeapon, (turretNum!=0), qtrue ); //play the weapon's muzzle effect if we have one G_VehMuzzleFireFX(parent, missile, muzzlesFired ); //take the ammo away pVeh->turretStatus[turretNum].ammo -= vehWeapon->iAmmoPerShot; //toggle to the next muzzle on this turret, if there is one nextMuzzle = ((curMuzzle+1)==pVeh->m_pVehicleInfo->turret[turretNum].iMuzzle[0])?pVeh->m_pVehicleInfo->turret[turretNum].iMuzzle[1]:pVeh->m_pVehicleInfo->turret[turretNum].iMuzzle[0]; if ( nextMuzzle ) {//a valid muzzle to toggle to pVeh->turretStatus[turretNum].nextMuzzle = nextMuzzle-1;//-1 because you type muzzles 1-10 in the .veh file } //add delay to the next muzzle so it doesn't fire right away on the next frame pVeh->m_iMuzzleWait[pVeh->turretStatus[turretNum].nextMuzzle] = level.time + turretStats->iDelay; } }

void VEH_TurretObeyPassengerControl (  Vehicle_t *  pVeh, gentity_t *  parent, int  turretNum )

Definition at line 304 of file g_vehicleTurret.c. References BUTTON_ALT_ATTACK, BUTTON_ATTACK, usercmd_s::buttons, gentity_s::client, clientPersistant_t::cmd, g_vehWeaponInfo, gentity_t, gentity_s::health, turretStats_t::iWeapon, Vehicle_s::m_ppPassengers, Vehicle_s::m_pVehicleInfo, vehTurretStatus_t::nextMuzzle, NULL, turretStats_t::passengerNum, gclient_s::pers, gclient_s::ps, vehicleInfo_t::turret, Vehicle_s::turretStatus, vec3_t, VectorCopy, VEH_TurretAim(), VEH_TurretCheckFire(), Vehicle_t, and playerState_s::viewangles. Referenced by VEH_TurretThink(). { turretStats_t *turretStats = &pVeh->m_pVehicleInfo->turret[turretNum]; gentity_t *passenger = (gentity_t *)pVeh->m_ppPassengers[turretStats->passengerNum-1]; if ( passenger && passenger->client && passenger->health > 0 ) {//a valid, living passenger client vehWeaponInfo_t *vehWeapon = &g_vehWeaponInfo[turretStats->iWeapon]; int curMuzzle = pVeh->turretStatus[turretNum].nextMuzzle; vec3_t aimAngles; VectorCopy( passenger->client->ps.viewangles, aimAngles ); VEH_TurretAim( pVeh, parent, NULL, turretStats, vehWeapon, turretNum, curMuzzle, aimAngles ); if ( (passenger->client->pers.cmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK)) ) {//he's pressing an attack button, so fire! VEH_TurretCheckFire( pVeh, parent, turretStats, vehWeapon, turretNum, curMuzzle ); } } }

void VEH_TurretThink (  Vehicle_t *  pVeh, gentity_t *  parent, int  turretNum )

Definition at line 324 of file g_vehicleTurret.c. References trace_t::allsolid, turretStats_t::bAI, gentity_s::client, entityShared_t::currentOrigin, gentity_s::enemy, enemyDist, vehTurretStatus_t::enemyEntNum, vehTurretStatus_t::enemyHoldTime, trace_t::entityNum, ENTITYNUM_NONE, ENTITYNUM_WORLD, turretStats_t::fAIRange, g_entities, g_vehWeaponInfo, gentity_t, gentity_s::health, turretStats_t::iAmmoMax, gentity_s::inuse, turretStats_t::iWeapon, level, Vehicle_s::m_iNumPassengers, Vehicle_s::m_pPilot, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_vMuzzlePos, MASK_SHOT, vehTurretStatus_t::nextMuzzle, NULL, entityState_s::number, entityShared_t::ownerNum, turretStats_t::passengerNum, qboolean, qfalse, qtrue, gentity_s::r, gentity_s::s, gclient_s::sess, clientSession_t::sessionTeam, trace_t::startsolid, TEAM_SPECTATOR, level_locals_t::time, trap_InPVS(), trap_Trace(), vehicleInfo_t::turret, Vehicle_s::turretStatus, vec3_t, VectorCopy, VectorSubtract, VEH_TurretAim(), VEH_TurretCheckFire(), VEH_TurretObeyPassengerControl(), Vehicle_t, and WP_CalcVehMuzzle(). { qboolean doAim = qfalse; float enemyDist, rangeSq; vec3_t enemyDir; turretStats_t *turretStats = &pVeh->m_pVehicleInfo->turret[turretNum]; vehWeaponInfo_t *vehWeapon = NULL; gentity_t *turretEnemy = NULL; int curMuzzle = 0;//? if ( !turretStats || !turretStats->iAmmoMax ) {//not a valid turret return; } if ( turretStats->passengerNum && pVeh->m_iNumPassengers >= turretStats->passengerNum ) {//the passenger that has control of this turret is on the ship VEH_TurretObeyPassengerControl( pVeh, parent, turretNum ); return; } else if ( !turretStats->bAI )//try AI {//this turret does not think on its own. return; } vehWeapon = &g_vehWeaponInfo[turretStats->iWeapon]; rangeSq = (turretStats->fAIRange*turretStats->fAIRange); curMuzzle = pVeh->turretStatus[turretNum].nextMuzzle; if ( pVeh->turretStatus[turretNum].enemyEntNum < ENTITYNUM_WORLD ) { turretEnemy = &g_entities[pVeh->turretStatus[turretNum].enemyEntNum]; if ( turretEnemy->health < 0 || !turretEnemy->inuse || turretEnemy == ((gentity_t*)pVeh->m_pPilot)//enemy became my pilot///? || turretEnemy == parent || turretEnemy->r.ownerNum == parent->s.number // a passenger? || ( turretEnemy->client && turretEnemy->client->sess.sessionTeam == TEAM_SPECTATOR ) ) {//don't keep going after spectators, pilot, self, dead people, etc. turretEnemy = NULL; pVeh->turretStatus[turretNum].enemyEntNum = ENTITYNUM_NONE; } } if ( pVeh->turretStatus[turretNum].enemyHoldTime < level.time ) { if ( VEH_TurretFindEnemies( pVeh, parent, turretStats, turretNum, curMuzzle ) ) { turretEnemy = &g_entities[pVeh->turretStatus[turretNum].enemyEntNum]; doAim = qtrue; } else if ( parent->enemy && parent->enemy->s.number < ENTITYNUM_WORLD ) { turretEnemy = parent->enemy; doAim = qtrue; } if ( turretEnemy ) {//found one if ( turretEnemy->client ) {//hold on to clients for a min of 3 seconds pVeh->turretStatus[turretNum].enemyHoldTime = level.time + 3000; } else {//hold less pVeh->turretStatus[turretNum].enemyHoldTime = level.time + 500; } } } if ( turretEnemy != NULL ) { if ( turretEnemy->health > 0 ) { // enemy is alive WP_CalcVehMuzzle( parent, curMuzzle ); VectorSubtract( turretEnemy->r.currentOrigin, pVeh->m_vMuzzlePos[curMuzzle], enemyDir ); enemyDist = VectorLengthSquared( enemyDir ); if ( enemyDist < rangeSq ) { // was in valid radius if ( trap_InPVS( pVeh->m_vMuzzlePos[curMuzzle], turretEnemy->r.currentOrigin ) ) { // Every now and again, check to see if we can even trace to the enemy trace_t tr; vec3_t start, end; VectorCopy( pVeh->m_vMuzzlePos[curMuzzle], start ); VectorCopy( turretEnemy->r.currentOrigin, end ); trap_Trace( &tr, start, NULL, NULL, end, parent->s.number, MASK_SHOT ); if ( tr.entityNum == turretEnemy->s.number || (!tr.allsolid && !tr.startsolid ) ) { doAim = qtrue; // Can see our enemy } } } } } if ( doAim ) { vec3_t aimAngles; if ( VEH_TurretAim( pVeh, parent, turretEnemy, turretStats, vehWeapon, turretNum, curMuzzle, aimAngles ) ) { VEH_TurretCheckFire( pVeh, parent, /*turretEnemy,*/ turretStats, vehWeapon, turretNum, curMuzzle ); } } }

void WP_CalcVehMuzzle (  gentity_t *  ent, int  muzzleNum )

Definition at line 3575 of file g_weapon.c. References gentity_s::client, gentity_t, gentity_s::ghoul2, level, Vehicle_s::m_iMuzzleTag, Vehicle_s::m_iMuzzleTime, gentity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_vMuzzleDir, Vehicle_s::m_vMuzzlePos, gentity_s::modelScale, NEGATIVE_Y, NULL, playerState_s::origin, ORIGIN, PITCH, gclient_s::ps, ROLL, level_locals_t::time, trap_G2API_GetBoltMatrix_NoRecNoRot(), vehicleInfo_t::type, vec3_t, VectorCopy, Vehicle_t, VH_ANIMAL, VH_SPEEDER, VH_WALKER, and playerState_s::viewangles. Referenced by FireVehicleWeapon(), VEH_TurretAim(), VEH_TurretCheckFire(), and VEH_TurretThink(). { Vehicle_t *pVeh = ent->m_pVehicle; mdxaBone_t boltMatrix; vec3_t vehAngles; assert(pVeh); if (pVeh->m_iMuzzleTime[muzzleNum] == level.time) { //already done for this frame, don't need to do it again return; } //Uh... how about we set this, hunh...? :) pVeh->m_iMuzzleTime[muzzleNum] = level.time; VectorCopy( ent->client->ps.viewangles, vehAngles ); if ( pVeh->m_pVehicleInfo && (pVeh->m_pVehicleInfo->type == VH_ANIMAL ||pVeh->m_pVehicleInfo->type == VH_WALKER ||pVeh->m_pVehicleInfo->type == VH_SPEEDER) ) { vehAngles[PITCH] = vehAngles[ROLL] = 0; } trap_G2API_GetBoltMatrix_NoRecNoRot(ent->ghoul2, 0, pVeh->m_iMuzzleTag[muzzleNum], &boltMatrix, vehAngles, ent->client->ps.origin, level.time, NULL, ent->modelScale); BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, pVeh->m_vMuzzlePos[muzzleNum]); BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, pVeh->m_vMuzzleDir[muzzleNum]); }

gentity_t* WP_FireVehicleWeapon (  gentity_t *  ent, vec3_t  start, vec3_t  dir, vehWeaponInfo_t *  vehWeapon, qboolean  alt_fire, qboolean  isTurretWeap )

Definition at line 3623 of file g_weapon.c. References gentity_s::angle, vehWeaponInfo_t::bExplodeOnExpire, vehWeaponInfo_t::bHasGravity, vehWeaponInfo_t::bIonWeapon, vehWeaponInfo_t::bIsProjectile, gentity_s::bounceCount, vehWeaponInfo_t::bSaberBlockable, CLASS_VEHICLE, gentity_s::classname, gentity_s::client, gentity_s::clipmask, entityShared_t::contents, CONTENTS_LIGHTSABER, CreateMissile(), gentity_s::damage, DAMAGE_DEATH_KNOCKBACK, gentity_s::dflags, gentity_s::die, EF_ALT_FIRING, EF_JETPACK_ACTIVE, EF_RADAROBJECT, entityState_s::eFlags, gentity_s::enemy, ENTITYNUM_NONE, vehWeaponInfo_t::fHeight, vehWeaponInfo_t::fHoming, vehWeaponInfo_t::fHomingFOV, vehWeaponInfo_t::fSpeed, vehWeaponInfo_t::fSplashRadius, vehWeaponInfo_t::fWidth, g_entities, G_ExplodeMissile(), G_FreeEntity(), G_SetOrigin(), g_vehWeaponInfo, entityState_s::genericenemyindex, gentity_s::genericValue1, gentity_s::genericValue2, gentity_t, gentity_s::health, vehWeaponInfo_t::iDamage, vehWeaponInfo_t::iHealth, vehWeaponInfo_t::iLifeTime, vehWeaponInfo_t::iLockOnTime, vehWeaponInfo_t::iSplashDamage, level, Vehicle_s::m_pPilot, gentity_s::m_pVehicle, MASK_SHOT, gentity_s::mass, MAX_GENTITIES, entityShared_t::maxs, gentity_s::methodOfDeath, entityShared_t::mins, MOD_VEHICLE, gentity_s::movedir, gentity_s::nextthink, entityState_s::NPC_class, NULL, entityState_s::number, OnSameTeam(), entityState_s::otherEntityNum, entityState_s::otherEntityNum2, entityState_s::owner, entityShared_t::ownerNum, entityState_s::pos, gclient_s::ps, qfalse, qtrue, gentity_s::r, gentity_s::radius, gentity_s::random, RocketDie(), playerState_s::rocketLastValidTime, playerState_s::rocketLockIndex, playerState_s::rocketLockTime, rocketThink(), gentity_s::s, bgEntity_s::s, gentity_s::spawnflags, gentity_s::speed, gentity_s::splashDamage, gentity_s::splashMethodOfDeath, gentity_s::splashRadius, gentity_s::takedamage, gentity_s::think, level_locals_t::time, gentity_s::touch, TR_GRAVITY, trajectory_t::trType, vec3_t, VectorCopy, VectorScale, VectorSet, VEH_HOMING_MISSILE_THINK_TIME, entityState_s::weapon, WP_BLASTER, WP_DEMP2, WP_ROCKET_LAUNCHER, WP_THERMAL, WP_TouchVehMissile(), WP_TURRET, and WP_VehWeapSetSolidToOwner(). Referenced by FireVehicleWeapon(), and VEH_TurretCheckFire(). { gentity_t *missile = NULL; //FIXME: add some randomness...? Inherent inaccuracy stat of weapon? Pilot skill? if ( !vehWeapon ) {//invalid vehicle weapon return NULL; } else if ( vehWeapon->bIsProjectile ) {//projectile entity vec3_t mins, maxs; VectorSet( maxs, vehWeapon->fWidth/2.0f,vehWeapon->fWidth/2.0f,vehWeapon->fHeight/2.0f ); VectorScale( maxs, -1, mins ); //make sure our start point isn't on the other side of a wall WP_TraceSetStart( ent, start, mins, maxs ); //FIXME: CUSTOM MODEL? //QUERY: alt_fire true or not? Does it matter? missile = CreateMissile( start, dir, vehWeapon->fSpeed, 10000, ent, qfalse ); missile->classname = "vehicle_proj"; missile->s.genericenemyindex = ent->s.number+MAX_GENTITIES; missile->damage = vehWeapon->iDamage; missile->splashDamage = vehWeapon->iSplashDamage; missile->splashRadius = vehWeapon->fSplashRadius; //FIXME: externalize some of these properties? missile->dflags = DAMAGE_DEATH_KNOCKBACK; missile->clipmask = MASK_SHOT; //Maybe by checking flags...? if ( vehWeapon->bSaberBlockable ) { missile->clipmask |= CONTENTS_LIGHTSABER; } /* if ( (vehWeapon->iFlags&VWF_KNOCKBACK) ) { missile->dflags &= ~DAMAGE_DEATH_KNOCKBACK; } if ( (vehWeapon->iFlags&VWF_RADAR) ) { missile->s.eFlags |= EF_RADAROBJECT; } */ // Make it easier to hit things VectorCopy( mins, missile->r.mins ); VectorCopy( maxs, missile->r.maxs ); //some slightly different stuff for things with bboxes if ( vehWeapon->fWidth || vehWeapon->fHeight ) {//we assume it's a rocket-like thing missile->s.weapon = WP_ROCKET_LAUNCHER;//does this really matter? missile->methodOfDeath = MOD_VEHICLE;//MOD_ROCKET; missile->splashMethodOfDeath = MOD_VEHICLE;//MOD_ROCKET;// ?SPLASH; // we don't want it to ever bounce missile->bounceCount = 0; missile->mass = 10; } else {//a blaster-laser-like thing missile->s.weapon = WP_BLASTER;//does this really matter? missile->methodOfDeath = MOD_VEHICLE; //count as a heavy weap missile->splashMethodOfDeath = MOD_VEHICLE;// ?SPLASH; // we don't want it to bounce forever missile->bounceCount = 8; } if ( vehWeapon->bHasGravity ) {//TESTME: is this all we need to do? missile->s.weapon = WP_THERMAL;//does this really matter? missile->s.pos.trType = TR_GRAVITY; } if ( vehWeapon->bIonWeapon ) {//so it disables ship shields and sends them out of control missile->s.weapon = WP_DEMP2; } if ( vehWeapon->iHealth ) {//the missile can take damage missile->health = vehWeapon->iHealth; missile->takedamage = qtrue; missile->r.contents = MASK_SHOT; missile->die = RocketDie; } //pilot should own this projectile on server if we have a pilot if (ent->m_pVehicle && ent->m_pVehicle->m_pPilot) {//owned by vehicle pilot missile->r.ownerNum = ent->m_pVehicle->m_pPilot->s.number; } else {//owned by vehicle? missile->r.ownerNum = ent->s.number; } //set veh as cgame side owner for purpose of fx overrides missile->s.owner = ent->s.number; if ( alt_fire ) {//use the second weapon's iShotFX missile->s.eFlags |= EF_ALT_FIRING; } if ( isTurretWeap ) {//look for the turret weapon info on cgame side, not vehicle weapon info missile->s.weapon = WP_TURRET; } if ( vehWeapon->iLifeTime ) {//expire after a time if ( vehWeapon->bExplodeOnExpire ) {//blow up when your lifetime is up missile->think = G_ExplodeMissile;//FIXME: custom func? } else {//just remove yourself missile->think = G_FreeEntity;//FIXME: custom func? } missile->nextthink = level.time + vehWeapon->iLifeTime; } missile->s.otherEntityNum2 = (vehWeapon-&g_vehWeaponInfo[0]); missile->s.eFlags |= EF_JETPACK_ACTIVE; //homing if ( vehWeapon->fHoming ) {//homing missile if ( ent->client && ent->client->ps.rocketLockIndex != ENTITYNUM_NONE ) { int dif = 0; float rTime; rTime = ent->client->ps.rocketLockTime; if (rTime == -1) { rTime = ent->client->ps.rocketLastValidTime; } if ( !vehWeapon->iLockOnTime ) {//no minimum lock-on time dif = 10;//guaranteed lock-on } else { float lockTimeInterval = vehWeapon->iLockOnTime/16.0f; dif = ( level.time - rTime ) / lockTimeInterval; } if (dif < 0) { dif = 0; } //It's 10 even though it locks client-side at 8, because we want them to have a sturdy lock first, and because there's a slight difference in time between server and client if ( dif >= 10 && rTime != -1 ) { missile->enemy = &g_entities[ent->client->ps.rocketLockIndex]; if (missile->enemy && missile->enemy->client && missile->enemy->health > 0 && !OnSameTeam(ent, missile->enemy)) { //if enemy became invalid, died, or is on the same team, then don't seek it missile->spawnflags |= 1;//just to let it know it should be faster... missile->speed = vehWeapon->fSpeed; missile->angle = vehWeapon->fHoming; missile->radius = vehWeapon->fHomingFOV; //crap, if we have a lifetime, need to store that somewhere else on ent and have rocketThink func check it every frame... if ( vehWeapon->iLifeTime ) {//expire after a time missile->genericValue1 = level.time + vehWeapon->iLifeTime; missile->genericValue2 = (int)(vehWeapon->bExplodeOnExpire); } //now go ahead and use the rocketThink func missile->think = rocketThink;//FIXME: custom func? missile->nextthink = level.time + VEH_HOMING_MISSILE_THINK_TIME; missile->s.eFlags |= EF_RADAROBJECT;//FIXME: externalize if ( missile->enemy->s.NPC_class == CLASS_VEHICLE ) {//let vehicle know we've locked on to them missile->s.otherEntityNum = missile->enemy->s.number; } } } VectorCopy( dir, missile->movedir ); missile->random = 1.0f;//FIXME: externalize? } } if ( !vehWeapon->fSpeed ) {//a mine or something? //only do damage when someone touches us missile->s.weapon = WP_THERMAL;//does this really matter? G_SetOrigin( missile, start ); missile->touch = WP_TouchVehMissile; missile->s.eFlags |= EF_RADAROBJECT;//FIXME: externalize //crap, if we have a lifetime, need to store that somewhere else on ent and have rocketThink func check it every frame... if ( vehWeapon->iLifeTime ) {//expire after a time missile->genericValue1 = vehWeapon->iLifeTime; missile->genericValue2 = (int)(vehWeapon->bExplodeOnExpire); } //now go ahead and use the setsolidtoowner func missile->think = WP_VehWeapSetSolidToOwner; missile->nextthink = level.time + 3000; } } else {//traceline //FIXME: implement } return missile; }