codemp/game/g_missile.c File Reference

#include "g_local.h"
#include "w_saber.h"
#include "q_shared.h"
#include "../namespace_begin.h"
#include "../namespace_end.h"

Go to the source code of this file.

Defines
#define	MISSILE_PRESTEP_TIME   50
Functions
void	laserTrapStick (gentity_t *ent, vec3_t endpos, vec3_t normal)
void	Jedi_Decloak (gentity_t *self)
qboolean	FighterIsLanded (Vehicle_t *pVeh, playerState_t *parentPS)
float	RandFloat (float min, float max)
void	G_ReflectMissile (gentity_t *ent, gentity_t *missile, vec3_t forward)
void	G_DeflectMissile (gentity_t *ent, gentity_t *missile, vec3_t forward)
void	G_BounceMissile (gentity_t *ent, trace_t *trace)
void	G_ExplodeMissile (gentity_t *ent)
void	G_RunStuckMissile (gentity_t *ent)
void	G_BounceProjectile (vec3_t start, vec3_t impact, vec3_t dir, vec3_t endout)
gentity_t *	CreateMissile (vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire)
void	G_MissileBounceEffect (gentity_t *ent, vec3_t org, vec3_t dir)
void	WP_SaberBlockNonRandom (gentity_t *self, vec3_t hitloc, qboolean missileBlock)
void	G_MissileImpact (gentity_t *ent, trace_t *trace)
void	G_RunMissile (gentity_t *ent)

---

Define Documentation

#define MISSILE_PRESTEP_TIME   50

Definition at line 7 of file g_missile.c.

---

Function Documentation

gentity_t* CreateMissile (  vec3_t  org, vec3_t  dir, float  vel, int  life, gentity_t *  owner, qboolean  altFire )

Definition at line 291 of file g_missile.c. References entityShared_t::currentOrigin, EF_ALT_FIRING, entityState_s::eFlags, ET_MISSILE, entityState_s::eType, G_FreeEntity(), G_Spawn(), gentity_t, level, gentity_s::nextthink, NULL, entityState_s::number, entityShared_t::ownerNum, gentity_s::parent, entityState_s::pos, gentity_s::r, gentity_s::s, SVF_USE_CURRENT_ORIGIN, entityShared_t::svFlags, gentity_s::target_ent, gentity_s::think, level_locals_t::time, TR_LINEAR, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, vec3_t, VectorCopy, and VectorScale. Referenced by EWebFire(), ImperialProbe_FireBlaster(), Mark1_FireBlaster(), Mark1_FireRocket(), Mark1Dead_FireBlaster(), Mark1Dead_FireRocket(), Mark2_FireBlaster(), Remote_Fire(), Seeker_Fire(), Sentry_Fire(), WP_FireBlasterMissile(), WP_FireEmplacedMissile(), WP_FireGenericBlasterMissile(), WP_FireTurboLaserMissile(), WP_FireTurretMissile(), and WP_FireVehicleWeapon(). { gentity_t *missile; missile = G_Spawn(); missile->nextthink = level.time + life; missile->think = G_FreeEntity; missile->s.eType = ET_MISSILE; missile->r.svFlags = SVF_USE_CURRENT_ORIGIN; missile->parent = owner; missile->r.ownerNum = owner->s.number; if (altFire) { missile->s.eFlags |= EF_ALT_FIRING; } missile->s.pos.trType = TR_LINEAR; missile->s.pos.trTime = level.time;// - MISSILE_PRESTEP_TIME; // NOTENOTE This is a Quake 3 addition over JK2 missile->target_ent = NULL; SnapVector(org); VectorCopy( org, missile->s.pos.trBase ); VectorScale( dir, vel, missile->s.pos.trDelta ); VectorCopy( org, missile->r.currentOrigin); SnapVector(missile->s.pos.trDelta); return missile; }

qboolean FighterIsLanded (  Vehicle_t *  pVeh, playerState_t *  parentPS )

Definition at line 297 of file FighterNPC.c. References FighterOverValidLandingSurface(), playerState_t, qboolean, qfalse, qtrue, playerState_s::speed, and Vehicle_t. Referenced by G_MissileImpact(), and PM_VehicleImpact(). { if ( FighterOverValidLandingSurface( pVeh ) && !parentPS->speed )//stopped { return qtrue; } return qfalse; }

void G_BounceMissile (  gentity_t *  ent, trace_t *  trace )

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

void G_BounceProjectile (  vec3_t  start, vec3_t  impact, vec3_t  dir, vec3_t  endout )

Definition at line 277 of file g_missile.c. References DotProduct, vec3_t, VectorMA, VectorNormalize(), and VectorSubtract. { vec3_t v, newv; float dot; VectorSubtract( impact, start, v ); dot = DotProduct( v, dir ); VectorMA( v, -2*dot, dir, newv ); VectorNormalize(newv); VectorMA(impact, 8192, newv, endout); }

void G_DeflectMissile (  gentity_t *  ent, gentity_t *  missile, vec3_t  forward )

Definition at line 91 of file g_missile.c. References AngleVectors(), gentity_s::client, entityShared_t::currentOrigin, DotProduct, G2_MODEL_PART, gentity_t, level, gentity_s::nextthink, entityState_s::number, entityShared_t::ownerNum, entityState_s::pos, gclient_s::ps, gentity_s::r, RandFloat(), gentity_s::s, gentity_s::think, level_locals_t::time, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, vec3_t, VectorCopy, VectorNormalize(), VectorScale, playerState_s::viewangles, entityState_s::weapon, WP_ROCKET_LAUNCHER, and WP_SABER. Referenced by G_MissileImpact(). { vec3_t bounce_dir; int i; float speed; int isowner = 0; vec3_t missile_dir; if (missile->r.ownerNum == ent->s.number) { //the original owner is bouncing the missile, so don't try to bounce it back at him isowner = 1; } //save the original speed speed = VectorNormalize( missile->s.pos.trDelta ); if (ent->client) { //VectorSubtract( ent->r.currentOrigin, missile->r.currentOrigin, missile_dir ); AngleVectors(ent->client->ps.viewangles, missile_dir, 0, 0); VectorCopy(missile_dir, bounce_dir); //VectorCopy( missile->s.pos.trDelta, bounce_dir ); VectorScale( bounce_dir, DotProduct( forward, missile_dir ), bounce_dir ); VectorNormalize( bounce_dir ); } else { VectorCopy(forward, bounce_dir); VectorNormalize(bounce_dir); } for ( i = 0; i < 3; i++ ) { bounce_dir[i] += RandFloat( -1.0f, 1.0f ); } VectorNormalize( bounce_dir ); VectorScale( bounce_dir, speed, missile->s.pos.trDelta ); missile->s.pos.trTime = level.time; // move a bit on the very first frame VectorCopy( missile->r.currentOrigin, missile->s.pos.trBase ); if ( missile->s.weapon != WP_SABER && missile->s.weapon != G2_MODEL_PART ) {//you are mine, now! missile->r.ownerNum = ent->s.number; } if ( missile->s.weapon == WP_ROCKET_LAUNCHER ) {//stop homing missile->think = 0; missile->nextthink = 0; } }

void G_ExplodeMissile (  gentity_t *  ent  )

Definition at line 215 of file g_missile.c. References gentity_s::activator, BG_EvaluateTrajectory(), entityShared_t::currentOrigin, DirToByte(), ET_GENERAL, entityState_s::eType, EV_MISSILE_MISS, gentity_s::freeAfterEvent, G_AddEvent(), g_entities, G_RadiusDamage(), G_SetOrigin(), gentity_t, level, entityState_s::number, gentity_s::parent, entityState_s::pos, qfalse, qtrue, gentity_s::r, gentity_s::s, gentity_s::splashDamage, gentity_s::splashMethodOfDeath, gentity_s::splashRadius, gentity_s::takedamage, level_locals_t::time, trap_LinkEntity(), and vec3_t. Referenced by RocketDie(). { vec3_t dir; vec3_t origin; BG_EvaluateTrajectory( &ent->s.pos, level.time, origin ); SnapVector( origin ); G_SetOrigin( ent, origin ); // we don't have a valid direction, so just point straight up dir[0] = dir[1] = 0; dir[2] = 1; ent->s.eType = ET_GENERAL; G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( dir ) ); ent->freeAfterEvent = qtrue; ent->takedamage = qfalse; // splash damage if ( ent->splashDamage ) { if( G_RadiusDamage( ent->r.currentOrigin, ent->parent, ent->splashDamage, ent->splashRadius, ent, ent, ent->splashMethodOfDeath ) ) { if (ent->parent) { g_entities[ent->parent->s.number].client->accuracy_hits++; } else if (ent->activator) { g_entities[ent->activator->s.number].client->accuracy_hits++; } } } trap_LinkEntity( ent ); }

void G_MissileBounceEffect (  gentity_t *  ent, vec3_t  org, vec3_t  dir )

Definition at line 324 of file g_missile.c. References entityState_s::angles, entityShared_t::currentOrigin, EV_SABER_BLOCK, entityState_s::eventParm, G_EffectIndex(), G_PlayEffectID(), G_TempEntity(), gentity_t, entityState_s::legsAnim, entityState_s::origin, gentity_s::r, gentity_s::s, vec3_t, VectorCopy, entityState_s::weapon, WP_BLASTER, WP_BOWCASTER, and WP_BRYAR_PISTOL. Referenced by G_MissileImpact(). { //FIXME: have an EV_BOUNCE_MISSILE event that checks the s.weapon and does the appropriate effect switch( ent->s.weapon ) { case WP_BOWCASTER: G_PlayEffectID( G_EffectIndex("bowcaster/deflect"), ent->r.currentOrigin, dir ); break; case WP_BLASTER: case WP_BRYAR_PISTOL: G_PlayEffectID( G_EffectIndex("blaster/deflect"), ent->r.currentOrigin, dir ); break; default: { gentity_t *te = G_TempEntity( org, EV_SABER_BLOCK ); VectorCopy(org, te->s.origin); VectorCopy(dir, te->s.angles); te->s.eventParm = 0; te->s.weapon = 0;//saberNum te->s.legsAnim = 0;//bladeNum } break; } }

void G_MissileImpact (  gentity_t *  ent, trace_t *  trace )

Definition at line 355 of file g_missile.c. References entityState_s::angles, AngleVectors(), BG_EvaluateTrajectoryDelta(), gentity_s::bounceCount, CLASS_ATST, CLASS_GONK, CLASS_INTERROGATOR, CLASS_MARK1, CLASS_MARK2, CLASS_MOUSE, CLASS_PROBE, CLASS_R2D2, CLASS_R5D2, CLASS_REMOTE, CLASS_SEEKER, CLASS_SENTRY, class_t, CLASS_VEHICLE, gentity_s::classname, gentity_s::client, gclient_s::cloakToggleTime, clientPersistant_t::cmd, entityShared_t::contents, CONTENTS_LIGHTSABER, entityShared_t::currentAngles, entityShared_t::currentOrigin, gentity_s::damage, DAMAGE_HALF_ABSORB, DAMAGE_HEAVY_WEAP_CLASS, gentity_s::dflags, DirToByte(), playerState_s::duelIndex, playerState_s::duelInProgress, EF_ALT_FIRING, EF_MISSILE_STICK, entityState_s::eFlags, playerState_s::electrifyTime, trace_t::endpos, trace_t::entityNum, ET_GENERAL, entityState_s::eType, EV_GRENADE_BOUNCE, EV_MISSILE_HIT, EV_MISSILE_MISS, EV_MISSILE_MISS_METAL, EV_MISSILE_STICK, EV_SABER_BLOCK, entityState_s::eventParm, playerState_s::fd, FighterIsLanded(), FL_BOUNCE, FL_BOUNCE_HALF, FL_BOUNCE_SHRAPNEL, FL_DMG_BY_HEAVY_WEAP_ONLY, FL_SHIELDED, gentity_s::flags, FORCE_LEVEL_1, FORCE_LEVEL_2, FORCE_LEVEL_3, forcedata_s::forcePowerLevel, usercmd_s::forwardmove, FP_SABER_DEFENSE, gentity_s::freeAfterEvent, G2_MODEL_PART, G_AddEvent(), G_BounceMissile(), G_Damage(), G_DeflectMissile(), g_entities, G_MissileBounceEffect(), G_RadiusDamage(), G_ReflectMissile(), G_SetOrigin(), G_TempEntity(), gentity_t, Jedi_Decloak(), laserTrapStick(), entityState_s::legsAnim, level, LogAccuracyHit(), gentity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, gentity_s::methodOfDeath, MOD_CONC, MOD_CONC_ALT, MOD_DEMP2_ALT, MOD_DET_PACK_SPLASH, MOD_FLECHETTE_ALT_SPLASH, MOD_REPEATER_ALT, MOD_ROCKET, MOD_ROCKET_HOMING, MOD_SABER, MOD_THERMAL, MOD_THERMAL_SPLASH, MOD_TIMED_MINE_SPLASH, MOD_TRIP_MINE_SPLASH, MOD_TURBLAST, MOD_VEHICLE, gentity_s::neverFree, cplane_s::normal, gclient_s::NPC_class, NULL, entityState_s::number, entityState_s::origin, entityState_s::otherEntityNum, entityShared_t::ownerNum, gentity_s::parent, gclient_s::pers, trace_t::plane, entityState_s::pos, playerState_s::powerups, gclient_s::ps, PW_CLOAKED, Q3_INFINITE, Q_irand(), Q_stricmp(), qboolean, qfalse, qtrue, gentity_s::r, gentity_s::s, playerState_s::saberBlockTime, playerState_s::saberEventFlags, SEF_DEFLECTED, SnapVectorTowards(), gentity_s::spawnflags, gentity_s::splashDamage, gentity_s::splashMethodOfDeath, gentity_s::splashRadius, SURF_FORCEFIELD, SURF_METALSTEPS, trace_t::surfaceFlags, gentity_s::takedamage, gentity_s::think, level_locals_t::time, trap_LinkEntity(), trajectory_t::trBase, vehicleInfo_t::type, vec3_t, VectorCopy, playerState_s::velocity, VH_FIGHTER, VH_SPEEDER, playerState_s::viewangles, entityState_s::weapon, playerState_s::weaponTime, WP_BOWCASTER, WP_DEMP2, WP_DET_PACK, WP_EMPLACED_GUN, WP_FLECHETTE, WP_ROCKET_LAUNCHER, WP_SABER, WP_SaberBlockNonRandom(), WP_SaberCanBlock(), WP_THERMAL, and WP_TRIP_MINE. Referenced by G_RunMissile(), and WP_TouchVehMissile(). { gentity_t *other; qboolean hitClient = qfalse; qboolean isKnockedSaber = qfalse; other = &g_entities[trace->entityNum]; // check for bounce if ( !other->takedamage && (ent->bounceCount > 0 || ent->bounceCount == -5) && ( ent->flags & ( FL_BOUNCE | FL_BOUNCE_HALF ) ) ) { G_BounceMissile( ent, trace ); G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 ); return; } else if (ent->neverFree && ent->s.weapon == WP_SABER && (ent->flags & FL_BOUNCE_HALF)) { //this is a knocked-away saber if (ent->bounceCount > 0 || ent->bounceCount == -5) { G_BounceMissile( ent, trace ); G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 ); return; } isKnockedSaber = qtrue; } // I would glom onto the FL_BOUNCE code section above, but don't feel like risking breaking something else if ( (!other->takedamage && (ent->bounceCount > 0 || ent->bounceCount == -5) && ( ent->flags&(FL_BOUNCE_SHRAPNEL) ) ) || ((trace->surfaceFlags&SURF_FORCEFIELD)&&!ent->splashDamage&&!ent->splashRadius&&(ent->bounceCount > 0 || ent->bounceCount == -5)) ) { G_BounceMissile( ent, trace ); if ( ent->bounceCount < 1 ) { ent->flags &= ~FL_BOUNCE_SHRAPNEL; } return; } /* if ( !other->takedamage && ent->s.weapon == WP_THERMAL && !ent->alt_fire ) {//rolling thermal det - FIXME: make this an eFlag like bounce & stick!!! //G_BounceRollMissile( ent, trace ); if ( ent->owner && ent->owner->s.number == 0 ) { G_MissileAddAlerts( ent ); } //gi.linkentity( ent ); return; } */ if ((other->r.contents & CONTENTS_LIGHTSABER) && !isKnockedSaber) { //hit this person's saber, so.. gentity_t *otherOwner = &g_entities[other->r.ownerNum]; if (otherOwner->takedamage && otherOwner->client && otherOwner->client->ps.duelInProgress && otherOwner->client->ps.duelIndex != ent->r.ownerNum) { goto killProj; } } else if (!isKnockedSaber) { if (other->takedamage && other->client && other->client->ps.duelInProgress && other->client->ps.duelIndex != ent->r.ownerNum) { goto killProj; } } if (other->flags & FL_DMG_BY_HEAVY_WEAP_ONLY) { if (ent->methodOfDeath != MOD_REPEATER_ALT && ent->methodOfDeath != MOD_ROCKET && ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH && ent->methodOfDeath != MOD_ROCKET_HOMING && ent->methodOfDeath != MOD_THERMAL && ent->methodOfDeath != MOD_THERMAL_SPLASH && ent->methodOfDeath != MOD_TRIP_MINE_SPLASH && ent->methodOfDeath != MOD_TIMED_MINE_SPLASH && ent->methodOfDeath != MOD_DET_PACK_SPLASH && ent->methodOfDeath != MOD_VEHICLE && ent->methodOfDeath != MOD_CONC && ent->methodOfDeath != MOD_CONC_ALT && ent->methodOfDeath != MOD_SABER && ent->methodOfDeath != MOD_TURBLAST) { vec3_t fwd; if (trace) { VectorCopy(trace->plane.normal, fwd); } else { //oh well AngleVectors(other->r.currentAngles, fwd, NULL, NULL); } G_DeflectMissile(other, ent, fwd); G_MissileBounceEffect(ent, ent->r.currentOrigin, fwd); return; } } if ((other->flags & FL_SHIELDED) && ent->s.weapon != WP_ROCKET_LAUNCHER && ent->s.weapon != WP_THERMAL && ent->s.weapon != WP_TRIP_MINE && ent->s.weapon != WP_DET_PACK && ent->s.weapon != WP_DEMP2 && ent->s.weapon != WP_EMPLACED_GUN && ent->methodOfDeath != MOD_REPEATER_ALT && ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH && ent->methodOfDeath != MOD_TURBLAST && ent->methodOfDeath != MOD_VEHICLE && ent->methodOfDeath != MOD_CONC && ent->methodOfDeath != MOD_CONC_ALT && !(ent->dflags&DAMAGE_HEAVY_WEAP_CLASS) ) { vec3_t fwd; if (other->client) { AngleVectors(other->client->ps.viewangles, fwd, NULL, NULL); } else { AngleVectors(other->r.currentAngles, fwd, NULL, NULL); } G_DeflectMissile(other, ent, fwd); G_MissileBounceEffect(ent, ent->r.currentOrigin, fwd); return; } if (other->takedamage && other->client && ent->s.weapon != WP_ROCKET_LAUNCHER && ent->s.weapon != WP_THERMAL && ent->s.weapon != WP_TRIP_MINE && ent->s.weapon != WP_DET_PACK && ent->s.weapon != WP_DEMP2 && ent->methodOfDeath != MOD_REPEATER_ALT && ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH && ent->methodOfDeath != MOD_CONC && ent->methodOfDeath != MOD_CONC_ALT && other->client->ps.saberBlockTime < level.time && !isKnockedSaber && WP_SaberCanBlock(other, ent->r.currentOrigin, 0, 0, qtrue, 0)) { //only block one projectile per 200ms (to prevent giant swarms of projectiles being blocked) vec3_t fwd; gentity_t *te; int otherDefLevel = other->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE]; te = G_TempEntity( ent->r.currentOrigin, EV_SABER_BLOCK ); VectorCopy(ent->r.currentOrigin, te->s.origin); VectorCopy(trace->plane.normal, te->s.angles); te->s.eventParm = 0; te->s.weapon = 0;//saberNum te->s.legsAnim = 0;//bladeNum /*if (other->client->ps.velocity[2] > 0 || other->client->pers.cmd.forwardmove || other->client->pers.cmd.rightmove) */ if (other->client->ps.velocity[2] > 0 || other->client->pers.cmd.forwardmove < 0) //now we only do it if jumping or running backward. Should be able to full-on charge. { otherDefLevel -= 1; if (otherDefLevel < 0) { otherDefLevel = 0; } } AngleVectors(other->client->ps.viewangles, fwd, NULL, NULL); if (otherDefLevel == FORCE_LEVEL_1) { //if def is only level 1, instead of deflecting the shot it should just die here } else if (otherDefLevel == FORCE_LEVEL_2) { G_DeflectMissile(other, ent, fwd); } else { G_ReflectMissile(other, ent, fwd); } other->client->ps.saberBlockTime = level.time + (350 - (otherDefLevel*100)); //200; //For jedi AI other->client->ps.saberEventFlags |= SEF_DEFLECTED; if (otherDefLevel == FORCE_LEVEL_3) { other->client->ps.saberBlockTime = 0; //^_^ } if (otherDefLevel == FORCE_LEVEL_1) { goto killProj; } return; } else if ((other->r.contents & CONTENTS_LIGHTSABER) && !isKnockedSaber) { //hit this person's saber, so.. gentity_t *otherOwner = &g_entities[other->r.ownerNum]; if (otherOwner->takedamage && otherOwner->client && ent->s.weapon != WP_ROCKET_LAUNCHER && ent->s.weapon != WP_THERMAL && ent->s.weapon != WP_TRIP_MINE && ent->s.weapon != WP_DET_PACK && ent->s.weapon != WP_DEMP2 && ent->methodOfDeath != MOD_REPEATER_ALT && ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH && ent->methodOfDeath != MOD_CONC && ent->methodOfDeath != MOD_CONC_ALT /*&& otherOwner->client->ps.saberBlockTime < level.time*/) { //for now still deflect even if saberBlockTime >= level.time because it hit the actual saber vec3_t fwd; gentity_t *te; int otherDefLevel = otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE]; //in this case, deflect it even if we can't actually block it because it hit our saber //WP_SaberCanBlock(otherOwner, ent->r.currentOrigin, 0, 0, qtrue, 0); if (otherOwner->client && otherOwner->client->ps.weaponTime <= 0) { WP_SaberBlockNonRandom(otherOwner, ent->r.currentOrigin, qtrue); } te = G_TempEntity( ent->r.currentOrigin, EV_SABER_BLOCK ); VectorCopy(ent->r.currentOrigin, te->s.origin); VectorCopy(trace->plane.normal, te->s.angles); te->s.eventParm = 0; te->s.weapon = 0;//saberNum te->s.legsAnim = 0;//bladeNum /*if (otherOwner->client->ps.velocity[2] > 0 || otherOwner->client->pers.cmd.forwardmove || otherOwner->client->pers.cmd.rightmove)*/ if (otherOwner->client->ps.velocity[2] > 0 || otherOwner->client->pers.cmd.forwardmove < 0) //now we only do it if jumping or running backward. Should be able to full-on charge. { otherDefLevel -= 1; if (otherDefLevel < 0) { otherDefLevel = 0; } } AngleVectors(otherOwner->client->ps.viewangles, fwd, NULL, NULL); if (otherDefLevel == FORCE_LEVEL_1) { //if def is only level 1, instead of deflecting the shot it should just die here } else if (otherDefLevel == FORCE_LEVEL_2) { G_DeflectMissile(otherOwner, ent, fwd); } else { G_ReflectMissile(otherOwner, ent, fwd); } otherOwner->client->ps.saberBlockTime = level.time + (350 - (otherDefLevel*100));//200; //For jedi AI otherOwner->client->ps.saberEventFlags |= SEF_DEFLECTED; if (otherDefLevel == FORCE_LEVEL_3) { otherOwner->client->ps.saberBlockTime = 0; //^_^ } if (otherDefLevel == FORCE_LEVEL_1) { goto killProj; } return; } } // check for sticking if ( !other->takedamage && ( ent->s.eFlags & EF_MISSILE_STICK ) ) { laserTrapStick( ent, trace->endpos, trace->plane.normal ); G_AddEvent( ent, EV_MISSILE_STICK, 0 ); return; } // impact damage if (other->takedamage && !isKnockedSaber) { // FIXME: wrong damage direction? if ( ent->damage ) { vec3_t velocity; qboolean didDmg = qfalse; if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) { g_entities[ent->r.ownerNum].client->accuracy_hits++; hitClient = qtrue; } BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity ); if ( VectorLength( velocity ) == 0 ) { velocity[2] = 1; // stepped on a grenade } if (ent->s.weapon == WP_BOWCASTER || ent->s.weapon == WP_FLECHETTE || ent->s.weapon == WP_ROCKET_LAUNCHER) { if (ent->s.weapon == WP_FLECHETTE && (ent->s.eFlags & EF_ALT_FIRING)) { ent->think(ent); } else { G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity, /*ent->s.origin*/ent->r.currentOrigin, ent->damage, DAMAGE_HALF_ABSORB, ent->methodOfDeath); didDmg = qtrue; } } else { G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity, /*ent->s.origin*/ent->r.currentOrigin, ent->damage, 0, ent->methodOfDeath); didDmg = qtrue; } if (didDmg && other && other->client) { //What I'm wondering is why this isn't in the NPC pain funcs. But this is what SP does, so whatever. class_t npc_class = other->client->NPC_class; // If we are a robot and we aren't currently doing the full body electricity... if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE || npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 || npc_class == CLASS_REMOTE || npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 || //npc_class == CLASS_PROTOCOL ||//no protocol, looks odd npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY ) { // special droid only behaviors if ( other->client->ps.electrifyTime < level.time + 100 ) { // ... do the effect for a split second for some more feedback other->client->ps.electrifyTime = level.time + 450; } //FIXME: throw some sparks off droids,too } } } if ( ent->s.weapon == WP_DEMP2 ) {//a hit with demp2 decloaks people, disables ships if ( other && other->client && other->client->NPC_class == CLASS_VEHICLE ) {//hit a vehicle if ( other->m_pVehicle //valid vehicle ent && other->m_pVehicle->m_pVehicleInfo//valid stats && (other->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER//always affect speeders ||(other->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER && ent->classname && Q_stricmp("vehicle_proj", ent->classname ) == 0) )//only vehicle ion weapons affect a fighter in this manner && !FighterIsLanded( other->m_pVehicle , &other->client->ps )//not landed && !(other->spawnflags&2) )//and not suspended {//vehicles hit by "ion cannons" lose control if ( other->client->ps.electrifyTime > level.time ) {//add onto it //FIXME: extern the length of the "out of control" time? other->client->ps.electrifyTime += Q_irand(200,500); if ( other->client->ps.electrifyTime > level.time + 4000 ) {//cap it other->client->ps.electrifyTime = level.time + 4000; } } else {//start it //FIXME: extern the length of the "out of control" time? other->client->ps.electrifyTime = level.time + Q_irand(200,500); } } } else if ( other && other->client && other->client->ps.powerups[PW_CLOAKED] ) { Jedi_Decloak( other ); if ( ent->methodOfDeath == MOD_DEMP2_ALT ) {//direct hit with alt disables cloak forever //permanently disable the saboteur's cloak other->client->cloakToggleTime = Q3_INFINITE; } else {//temp disable other->client->cloakToggleTime = level.time + Q_irand( 3000, 10000 ); } } } } killProj: // is it cheaper in bandwidth to just remove this ent and create a new // one, rather than changing the missile into the explosion? if ( other->takedamage && other->client && !isKnockedSaber ) { G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) ); ent->s.otherEntityNum = other->s.number; } else if( trace->surfaceFlags & SURF_METALSTEPS ) { G_AddEvent( ent, EV_MISSILE_MISS_METAL, DirToByte( trace->plane.normal ) ); } else if (ent->s.weapon != G2_MODEL_PART && !isKnockedSaber) { G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) ); } if (!isKnockedSaber) { ent->freeAfterEvent = qtrue; // change over to a normal entity right at the point of impact ent->s.eType = ET_GENERAL; } SnapVectorTowards( trace->endpos, ent->s.pos.trBase ); // save net bandwidth G_SetOrigin( ent, trace->endpos ); ent->takedamage = qfalse; // splash damage (doesn't apply to person directly hit) if ( ent->splashDamage ) { if( G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius, other, ent, ent->splashMethodOfDeath ) ) { if( !hitClient && g_entities[ent->r.ownerNum].client ) { g_entities[ent->r.ownerNum].client->accuracy_hits++; } } } if (ent->s.weapon == G2_MODEL_PART) { ent->freeAfterEvent = qfalse; //it will free itself } trap_LinkEntity( ent ); }

void G_ReflectMissile (  gentity_t *  ent, gentity_t *  missile, vec3_t  forward )

Definition at line 24 of file g_missile.c. References entityShared_t::currentOrigin, DotProduct, G2_MODEL_PART, g_entities, gentity_t, level, gentity_s::nextthink, entityState_s::number, entityShared_t::ownerNum, entityState_s::pos, gentity_s::r, RandFloat(), gentity_s::s, gentity_s::think, level_locals_t::time, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, vec3_t, VectorCopy, VectorNormalize(), VectorScale, VectorSubtract, entityState_s::weapon, WP_ROCKET_LAUNCHER, and WP_SABER. Referenced by ForceThrow(), and G_MissileImpact(). { vec3_t bounce_dir; int i; float speed; gentity_t *owner = ent; int isowner = 0; if ( ent->r.ownerNum ) { owner = &g_entities[ent->r.ownerNum]; } if (missile->r.ownerNum == ent->s.number) { //the original owner is bouncing the missile, so don't try to bounce it back at him isowner = 1; } //save the original speed speed = VectorNormalize( missile->s.pos.trDelta ); //if ( ent && owner && owner->NPC && owner->enemy && Q_stricmp( "Tavion", owner->NPC_type ) == 0 && Q_irand( 0, 3 ) ) if ( &g_entities[missile->r.ownerNum] && missile->s.weapon != WP_SABER && missile->s.weapon != G2_MODEL_PART && !isowner ) {//bounce back at them if you can VectorSubtract( g_entities[missile->r.ownerNum].r.currentOrigin, missile->r.currentOrigin, bounce_dir ); VectorNormalize( bounce_dir ); } else if (isowner) { //in this case, actually push the missile away from me, and since we're giving boost to our own missile by pushing it, up the velocity vec3_t missile_dir; speed *= 1.5; VectorSubtract( missile->r.currentOrigin, ent->r.currentOrigin, missile_dir ); VectorCopy( missile->s.pos.trDelta, bounce_dir ); VectorScale( bounce_dir, DotProduct( forward, missile_dir ), bounce_dir ); VectorNormalize( bounce_dir ); } else { vec3_t missile_dir; VectorSubtract( ent->r.currentOrigin, missile->r.currentOrigin, missile_dir ); VectorCopy( missile->s.pos.trDelta, bounce_dir ); VectorScale( bounce_dir, DotProduct( forward, missile_dir ), bounce_dir ); VectorNormalize( bounce_dir ); } for ( i = 0; i < 3; i++ ) { bounce_dir[i] += RandFloat( -0.2f, 0.2f ); } VectorNormalize( bounce_dir ); VectorScale( bounce_dir, speed, missile->s.pos.trDelta ); missile->s.pos.trTime = level.time; // move a bit on the very first frame VectorCopy( missile->r.currentOrigin, missile->s.pos.trBase ); if ( missile->s.weapon != WP_SABER && missile->s.weapon != G2_MODEL_PART ) {//you are mine, now! missile->r.ownerNum = ent->s.number; } if ( missile->s.weapon == WP_ROCKET_LAUNCHER ) {//stop homing missile->think = 0; missile->nextthink = 0; } }

void G_RunMissile (  gentity_t *  ent  )

Definition at line 798 of file g_missile.c. References trace_t::allsolid, entityState_s::apos, BG_EvaluateTrajectory(), gentity_s::bounceCount, gentity_s::client, gentity_s::clipmask, entityShared_t::currentOrigin, d_projectileGhoul2Collision, EF_JETPACK_ACTIVE, EF_MISSILE_STICK, entityState_s::eFlags, trace_t::endpos, trace_t::entityNum, ENTITYNUM_NONE, ENTITYNUM_WORLD, ET_MISSILE, ET_NPC, entityState_s::eType, EV_GHOUL2_MARK, FL_BOUNCE_HALF, gentity_s::flags, trace_t::fraction, G2_MODEL_PART, gclient_s::g2LastSurfaceHit, gclient_s::g2LastSurfaceTime, G2TRFLAG_DOGHOULTRACE, G2TRFLAG_GETSURFINDEX, G2TRFLAG_HITCORPSES, G2TRFLAG_THICK, G_AddEvent(), g_entities, G_FreeEntity(), g_g2TraceLod, G_MissileImpact(), G_RunStuckMissile(), G_RunThink(), gentity_t, gentity_s::ghoul2, entityState_s::groundEntityNum, gclient_s::hook, vmCvar_t::integer, gentity_s::inuse, gentity_s::isSaberEntity, level, MAX_CLIENTS, entityShared_t::maxs, entityShared_t::mins, gentity_s::neverFree, NULL, entityState_s::number, entityState_s::origin, entityState_s::origin2, entityState_s::otherEntityNum, entityShared_t::ownerNum, gentity_s::parent, gentity_s::passThroughNum, PITCH, entityState_s::pos, qboolean, qfalse, qtrue, gentity_s::r, ROLL, gentity_s::s, trace_t::startsolid, SURF_NOIMPACT, trace_t::surfaceFlags, SVF_OWNERNOTSHARED, entityShared_t::svFlags, gentity_s::target_ent, level_locals_t::time, TR_GRAVITY, TR_LINEAR, TR_STATIONARY, trap_G2Trace(), trap_LinkEntity(), trap_Trace(), trajectory_t::trBase, trajectory_t::trDelta, entityState_s::trickedentindex, trajectory_t::trTime, trajectory_t::trType, vec3_t, VectorClear, VectorCopy, entityState_s::weapon, WP_NONE, WP_NUM_WEAPONS, and WP_SABER. Referenced by G_RunFrame(). { vec3_t origin, groundSpot; trace_t tr; int passent; qboolean isKnockedSaber = qfalse; if (ent->neverFree && ent->s.weapon == WP_SABER && (ent->flags & FL_BOUNCE_HALF)) { isKnockedSaber = qtrue; ent->s.pos.trType = TR_GRAVITY; } // get current position BG_EvaluateTrajectory( &ent->s.pos, level.time, origin ); // if this missile bounced off an invulnerability sphere if ( ent->target_ent ) { passent = ent->target_ent->s.number; } else { // ignore interactions with the missile owner if ( (ent->r.svFlags&SVF_OWNERNOTSHARED) && (ent->s.eFlags&EF_JETPACK_ACTIVE) ) {//A vehicle missile that should be solid to its owner //I don't care about hitting my owner passent = ent->s.number; } else { passent = ent->r.ownerNum; } } // trace a line from the previous position to the current position if (d_projectileGhoul2Collision.integer) { trap_G2Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, passent, ent->clipmask, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer ); if (tr.fraction != 1.0 && tr.entityNum < ENTITYNUM_WORLD) { gentity_t *g2Hit = &g_entities[tr.entityNum]; if (g2Hit->inuse && g2Hit->client && g2Hit->ghoul2) { //since we used G2TRFLAG_GETSURFINDEX, tr.surfaceFlags will actually contain the index of the surface on the ghoul2 model we collided with. g2Hit->client->g2LastSurfaceHit = tr.surfaceFlags; g2Hit->client->g2LastSurfaceTime = level.time; } if (g2Hit->ghoul2) { tr.surfaceFlags = 0; //clear the surface flags after, since we actually care about them in here. } } } else { trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, passent, ent->clipmask ); } if ( tr.startsolid || tr.allsolid ) { // make sure the tr.entityNum is set to the entity we're stuck in trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, passent, ent->clipmask ); tr.fraction = 0; } else { VectorCopy( tr.endpos, ent->r.currentOrigin ); } if (ent->passThroughNum && tr.entityNum == (ent->passThroughNum-1)) { VectorCopy( origin, ent->r.currentOrigin ); trap_LinkEntity( ent ); goto passthrough; } trap_LinkEntity( ent ); if (ent->s.weapon == G2_MODEL_PART && !ent->bounceCount) { vec3_t lowerOrg; trace_t trG; VectorCopy(ent->r.currentOrigin, lowerOrg); lowerOrg[2] -= 1; trap_Trace( &trG, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, lowerOrg, passent, ent->clipmask ); VectorCopy(trG.endpos, groundSpot); if (!trG.startsolid && !trG.allsolid && trG.entityNum == ENTITYNUM_WORLD) { ent->s.groundEntityNum = trG.entityNum; } else { ent->s.groundEntityNum = ENTITYNUM_NONE; } } if ( tr.fraction != 1) { // never explode or bounce on sky if ( tr.surfaceFlags & SURF_NOIMPACT ) { // If grapple, reset owner if (ent->parent && ent->parent->client && ent->parent->client->hook == ent) { ent->parent->client->hook = NULL; } if ((ent->s.weapon == WP_SABER && ent->isSaberEntity) || isKnockedSaber) { G_RunThink( ent ); return; } else if (ent->s.weapon != G2_MODEL_PART) { G_FreeEntity( ent ); return; } } #if 0 //will get stomped with missile impact event... if (ent->s.weapon > WP_NONE && ent->s.weapon < WP_NUM_WEAPONS && (tr.entityNum < MAX_CLIENTS || g_entities[tr.entityNum].s.eType == ET_NPC)) { //player or NPC, try making a mark on him /* gentity_t *evEnt = G_TempEntity(ent->r.currentOrigin, EV_GHOUL2_MARK); evEnt->s.owner = tr.entityNum; //the entity the mark should be placed on evEnt->s.weapon = ent->s.weapon; //the weapon used (to determine mark type) VectorCopy(ent->r.currentOrigin, evEnt->s.origin); //the point of impact //origin2 gets the predicted trajectory-based position. BG_EvaluateTrajectory( &ent->s.pos, level.time, evEnt->s.origin2 ); //If they are the same, there will be problems. if (VectorCompare(evEnt->s.origin, evEnt->s.origin2)) { evEnt->s.origin2[2] += 2; //whatever, at least it won't mess up. } */ //ok, let's try adding it to the missile ent instead (tempents bad!) G_AddEvent(ent, EV_GHOUL2_MARK, 0); //copy current pos to s.origin, and current projected traj to origin2 VectorCopy(ent->r.currentOrigin, ent->s.origin); BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->s.origin2 ); //the index for whoever we are hitting ent->s.otherEntityNum = tr.entityNum; if (VectorCompare(ent->s.origin, ent->s.origin2)) { ent->s.origin2[2] += 2.0f; //whatever, at least it won't mess up. } } #else if (ent->s.weapon > WP_NONE && ent->s.weapon < WP_NUM_WEAPONS && (tr.entityNum < MAX_CLIENTS || g_entities[tr.entityNum].s.eType == ET_NPC)) { //player or NPC, try making a mark on him //copy current pos to s.origin, and current projected traj to origin2 VectorCopy(ent->r.currentOrigin, ent->s.origin); BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->s.origin2 ); if (VectorCompare(ent->s.origin, ent->s.origin2)) { ent->s.origin2[2] += 2.0f; //whatever, at least it won't mess up. } } #endif G_MissileImpact( ent, &tr ); if (tr.entityNum == ent->s.otherEntityNum) { //if the impact event other and the trace ent match then it's ok to do the g2 mark ent->s.trickedentindex = 1; } if ( ent->s.eType != ET_MISSILE && ent->s.weapon != G2_MODEL_PART ) { return; // exploded } } passthrough: if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) ) {//stuck missiles should check some special stuff G_RunStuckMissile( ent ); return; } if (ent->s.weapon == G2_MODEL_PART) { if (ent->s.groundEntityNum == ENTITYNUM_WORLD) { ent->s.pos.trType = TR_LINEAR; VectorClear(ent->s.pos.trDelta); ent->s.pos.trTime = level.time; VectorCopy(groundSpot, ent->s.pos.trBase); VectorCopy(groundSpot, ent->r.currentOrigin); if (ent->s.apos.trType != TR_STATIONARY) { ent->s.apos.trType = TR_STATIONARY; ent->s.apos.trTime = level.time; ent->s.apos.trBase[ROLL] = 0; ent->s.apos.trBase[PITCH] = 0; } } } // check think function after bouncing G_RunThink( ent ); }

void G_RunStuckMissile (  gentity_t *  ent  )

Definition at line 252 of file g_missile.c. References entityState_s::apos, ENTITYNUM_WORLD, G_Damage(), g_entities, G_RunThink(), gentity_t, entityState_s::groundEntityNum, MOD_CRUSH, NULL, entityState_s::pos, gentity_s::s, gentity_s::takedamage, TR_STATIONARY, trajectory_t::trDelta, trajectory_t::trType, and vec3_origin. Referenced by G_RunMissile(). { if ( ent->takedamage ) { if ( ent->s.groundEntityNum >= 0 && ent->s.groundEntityNum < ENTITYNUM_WORLD ) { gentity_t *other = &g_entities[ent->s.groundEntityNum]; if ( (!VectorCompare( vec3_origin, other->s.pos.trDelta ) && other->s.pos.trType != TR_STATIONARY) || (!VectorCompare( vec3_origin, other->s.apos.trDelta ) && other->s.apos.trType != TR_STATIONARY) ) {//thing I stuck to is moving or rotating now, kill me G_Damage( ent, other, other, NULL, NULL, 99999, 0, MOD_CRUSH ); return; } } } // check think function G_RunThink( ent ); }

void Jedi_Decloak (  gentity_t *  self  )

Definition at line 818 of file NPC_AI_Jedi.c. { if ( self ) { self->flags &= ~FL_NOTARGET; if ( self->client ) { if ( self->client->ps.powerups[PW_CLOAKED] ) {//Uncloak self->client->ps.powerups[PW_CLOAKED] = 0; G_Sound( self, CHAN_ITEM, G_SoundIndex("sound/chars/shadowtrooper/decloak.wav") ); } } } }

void laserTrapStick (  gentity_t *  ent, vec3_t  endpos, vec3_t  normal )

Definition at line 2400 of file g_weapon.c. References entityState_s::angles, entityState_s::apos, entityState_s::bolt2, CHAN_WEAPON, gentity_s::count, entityShared_t::currentAngles, gentity_s::die, EF_FIRING, entityState_s::eFlags, G_SetOrigin(), G_Sound(), G_SoundIndex(), gentity_s::genericValue15, gentity_t, gentity_s::health, laserTrapDelayedExplode(), laserTrapThink(), level, LT_ACTIVATION_DELAY, LT_ALT_TIME, LT_SIZE, entityShared_t::maxs, entityShared_t::mins, gentity_s::movedir, gentity_s::nextthink, entityState_s::pos, gentity_s::pos1, proxMineThink(), qtrue, gentity_s::r, gentity_s::s, SVF_OWNERNOTSHARED, entityShared_t::svFlags, gentity_s::takedamage, gentity_s::think, entityState_s::time, level_locals_t::time, gentity_s::touch, touch_NULL(), touchLaserTrap(), TR_STATIONARY, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, vec3_t, vectoangles(), VectorClear, VectorCopy, and VectorSet. { G_SetOrigin( ent, endpos ); VectorCopy( normal, ent->pos1 ); VectorClear( ent->s.apos.trDelta ); // This will orient the object to face in the direction of the normal VectorCopy( normal, ent->s.pos.trDelta ); //VectorScale( normal, -1, ent->s.pos.trDelta ); ent->s.pos.trTime = level.time; //This does nothing, cg_missile makes assumptions about direction of travel controlling angles vectoangles( normal, ent->s.apos.trBase ); VectorClear( ent->s.apos.trDelta ); ent->s.apos.trType = TR_STATIONARY; VectorCopy( ent->s.apos.trBase, ent->s.angles ); VectorCopy( ent->s.angles, ent->r.currentAngles ); G_Sound( ent, CHAN_WEAPON, G_SoundIndex( "sound/weapons/laser_trap/stick.wav" ) ); if ( ent->count ) {//a tripwire //add draw line flag VectorCopy( normal, ent->movedir ); ent->think = laserTrapThink; ent->nextthink = level.time + LT_ACTIVATION_DELAY;//delay the activation ent->touch = touch_NULL; //make it shootable ent->takedamage = qtrue; ent->health = 5; ent->die = laserTrapDelayedExplode; //shove the box through the wall VectorSet( ent->r.mins, -LT_SIZE*2, -LT_SIZE*2, -LT_SIZE*2 ); VectorSet( ent->r.maxs, LT_SIZE*2, LT_SIZE*2, LT_SIZE*2 ); //so that the owner can blow it up with projectiles ent->r.svFlags |= SVF_OWNERNOTSHARED; } else { ent->touch = touchLaserTrap; ent->think = proxMineThink;//laserTrapExplode; ent->genericValue15 = level.time + 30000; //auto-explode after 30 seconds. ent->nextthink = level.time + LT_ALT_TIME; // How long 'til she blows //make it shootable ent->takedamage = qtrue; ent->health = 5; ent->die = laserTrapDelayedExplode; //shove the box through the wall VectorSet( ent->r.mins, -LT_SIZE*2, -LT_SIZE*2, -LT_SIZE*2 ); VectorSet( ent->r.maxs, LT_SIZE*2, LT_SIZE*2, LT_SIZE*2 ); //so that the owner can blow it up with projectiles ent->r.svFlags |= SVF_OWNERNOTSHARED; if ( !(ent->s.eFlags&EF_FIRING) ) {//arm me G_Sound( ent, CHAN_WEAPON, G_SoundIndex( "sound/weapons/laser_trap/warning.wav" ) ); ent->s.eFlags |= EF_FIRING; ent->s.time = -1; ent->s.bolt2 = 1; } } }

float RandFloat (  float  min, float  max )

Definition at line 39 of file w_saber.c. References min, and rand(). Referenced by G_DeflectMissile(), G_ReflectMissile(), and WP_SaberBlock(). { return ((rand() * (max - min)) / 32768.0F) + min; }

void WP_SaberBlockNonRandom (  gentity_t *  self, vec3_t  hitloc, qboolean  missileBlock )

Definition at line 9122 of file w_saber.c. References AngleVectors(), BLOCKED_LOWER_LEFT, BLOCKED_LOWER_RIGHT, BLOCKED_TOP, BLOCKED_UPPER_LEFT, BLOCKED_UPPER_RIGHT, gentity_s::client, DotProduct, gentity_t, NULL, playerState_s::origin, gclient_s::ps, playerState_s::saberBlocked, vec3_t, VectorCopy, VectorNormalize(), VectorSubtract, playerState_s::viewangles, playerState_s::viewheight, and WP_MissileBlockForBlock(). { vec3_t diff, fwdangles={0,0,0}, right; vec3_t clEye; float rightdot; float zdiff; VectorCopy(self->client->ps.origin, clEye); clEye[2] += self->client->ps.viewheight; VectorSubtract( hitloc, clEye, diff ); diff[2] = 0; VectorNormalize( diff ); fwdangles[1] = self->client->ps.viewangles[1]; // Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine. AngleVectors( fwdangles, NULL, right, NULL ); rightdot = DotProduct(right, diff); zdiff = hitloc[2] - clEye[2]; if ( zdiff > 0 ) { if ( rightdot > 0.3 ) { self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT; } else if ( rightdot < -0.3 ) { self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT; } else { self->client->ps.saberBlocked = BLOCKED_TOP; } } else if ( zdiff > -20 )//20 ) { if ( zdiff < -10 )//30 ) {//hmm, pretty low, but not low enough to use the low block, so we need to duck } if ( rightdot > 0.1 ) { self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT; } else if ( rightdot < -0.1 ) { self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT; } else { self->client->ps.saberBlocked = BLOCKED_TOP; } } else { if ( rightdot >= 0 ) { self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT; } else { self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT; } } if ( missileBlock ) { self->client->ps.saberBlocked = WP_MissileBlockForBlock( self->client->ps.saberBlocked ); } }