codemp/game/g_weapon.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// g_weapon.c 
// perform the server side effects of a weapon firing

#include "g_local.h"
#include "be_aas.h"
#include "bg_saga.h"
#include "../ghoul2/G2.h"
#include "q_shared.h"

static  float   s_quadFactor;
static  vec3_t  forward, vright, up;
static  vec3_t  muzzle;

// Bryar Pistol
//--------
#define BRYAR_PISTOL_VEL                        1600
#define BRYAR_PISTOL_DAMAGE                     10
#define BRYAR_CHARGE_UNIT                       200.0f  // bryar charging gives us one more unit every 200ms--if you change this, you'll have to do the same in bg_pmove
#define BRYAR_ALT_SIZE                          1.0f

// E11 Blaster
//---------
#define BLASTER_SPREAD                          1.6f//1.2f
#define BLASTER_VELOCITY                        2300
#define BLASTER_DAMAGE                          20

// Tenloss Disruptor
//----------
#define DISRUPTOR_MAIN_DAMAGE                   30 //40
#define DISRUPTOR_MAIN_DAMAGE_SIEGE             50
#define DISRUPTOR_NPC_MAIN_DAMAGE_CUT   0.25f

#define DISRUPTOR_ALT_DAMAGE                    100 //125
#define DISRUPTOR_NPC_ALT_DAMAGE_CUT    0.2f
#define DISRUPTOR_ALT_TRACES                    3               // can go through a max of 3 damageable(sp?) entities
#define DISRUPTOR_CHARGE_UNIT                   50.0f   // distruptor charging gives us one more unit every 50ms--if you change this, you'll have to do the same in bg_pmove

// Wookiee Bowcaster
//----------
#define BOWCASTER_DAMAGE                        50
#define BOWCASTER_VELOCITY                      1300
#define BOWCASTER_SPLASH_DAMAGE         0
#define BOWCASTER_SPLASH_RADIUS         0
#define BOWCASTER_SIZE                          2

#define BOWCASTER_ALT_SPREAD            5.0f
#define BOWCASTER_VEL_RANGE                     0.3f
#define BOWCASTER_CHARGE_UNIT           200.0f  // bowcaster charging gives us one more unit every 200ms--if you change this, you'll have to do the same in bg_pmove

// Heavy Repeater
//----------
#define REPEATER_SPREAD                         1.4f
#define REPEATER_DAMAGE                         14
#define REPEATER_VELOCITY                       1600

#define REPEATER_ALT_SIZE                               3       // half of bbox size
#define REPEATER_ALT_DAMAGE                             60
#define REPEATER_ALT_SPLASH_DAMAGE              60
#define REPEATER_ALT_SPLASH_RADIUS              128
#define REPEATER_ALT_SPLASH_RAD_SIEGE   80
#define REPEATER_ALT_VELOCITY                   1100

// DEMP2
//----------
#define DEMP2_DAMAGE                            35
#define DEMP2_VELOCITY                          1800
#define DEMP2_SIZE                                      2               // half of bbox size

#define DEMP2_ALT_DAMAGE                        8 //12          // does 12, 36, 84 at each of the 3 charge levels.
#define DEMP2_CHARGE_UNIT                       700.0f  // demp2 charging gives us one more unit every 700ms--if you change this, you'll have to do the same in bg_weapons
#define DEMP2_ALT_RANGE                         4096
#define DEMP2_ALT_SPLASHRADIUS          256

// Golan Arms Flechette
//---------
#define FLECHETTE_SHOTS                         5
#define FLECHETTE_SPREAD                        4.0f
#define FLECHETTE_DAMAGE                        12//15
#define FLECHETTE_VEL                           3500
#define FLECHETTE_SIZE                          1
#define FLECHETTE_MINE_RADIUS_CHECK     256
#define FLECHETTE_ALT_DAMAGE            60
#define FLECHETTE_ALT_SPLASH_DAM        60
#define FLECHETTE_ALT_SPLASH_RAD        128

// Personal Rocket Launcher
//---------
#define ROCKET_VELOCITY                         900
#define ROCKET_DAMAGE                           100
#define ROCKET_SPLASH_DAMAGE            100
#define ROCKET_SPLASH_RADIUS            160
#define ROCKET_SIZE                                     3
#define ROCKET_ALT_THINK_TIME           100

// Concussion Rifle
//---------
//primary
//man, this thing is too absurdly powerful. having to
//slash the values way down from sp.
#define CONC_VELOCITY                           3000
#define CONC_DAMAGE                                     75 //150
#define CONC_NPC_DAMAGE_EASY            40
#define CONC_NPC_DAMAGE_NORMAL          80
#define CONC_NPC_DAMAGE_HARD            100
#define CONC_SPLASH_DAMAGE                      40 //50
#define CONC_SPLASH_RADIUS                      200 //300
//alt
#define CONC_ALT_DAMAGE                         25 //100
#define CONC_ALT_NPC_DAMAGE_EASY        20
#define CONC_ALT_NPC_DAMAGE_MEDIUM      35
#define CONC_ALT_NPC_DAMAGE_HARD        50

// Stun Baton
//--------------
#define STUN_BATON_DAMAGE                       20
#define STUN_BATON_ALT_DAMAGE           20
#define STUN_BATON_RANGE                        8

// Melee
//--------------
#define MELEE_SWING1_DAMAGE                     10
#define MELEE_SWING2_DAMAGE                     12
#define MELEE_RANGE                                     8

// ATST Main Gun
//--------------
#define ATST_MAIN_VEL                           4000    // 
#define ATST_MAIN_DAMAGE                        25              // 
#define ATST_MAIN_SIZE                          3               // make it easier to hit things

// ATST Side Gun
//---------------
#define ATST_SIDE_MAIN_DAMAGE                           75
#define ATST_SIDE_MAIN_VELOCITY                         1300
#define ATST_SIDE_MAIN_NPC_DAMAGE_EASY          30
#define ATST_SIDE_MAIN_NPC_DAMAGE_NORMAL        40
#define ATST_SIDE_MAIN_NPC_DAMAGE_HARD          50
#define ATST_SIDE_MAIN_SIZE                                     4
#define ATST_SIDE_MAIN_SPLASH_DAMAGE            10      // yeah, pretty small, either zero out or make it worth having?
#define ATST_SIDE_MAIN_SPLASH_RADIUS            16      // yeah, pretty small, either zero out or make it worth having?

#define ATST_SIDE_ALT_VELOCITY                          1100
#define ATST_SIDE_ALT_NPC_VELOCITY                      600
#define ATST_SIDE_ALT_DAMAGE                            130

#define ATST_SIDE_ROCKET_NPC_DAMAGE_EASY        30
#define ATST_SIDE_ROCKET_NPC_DAMAGE_NORMAL      50
#define ATST_SIDE_ROCKET_NPC_DAMAGE_HARD        90

#define ATST_SIDE_ALT_SPLASH_DAMAGE                     130
#define ATST_SIDE_ALT_SPLASH_RADIUS                     200
#define ATST_SIDE_ALT_ROCKET_SIZE                       5
#define ATST_SIDE_ALT_ROCKET_SPLASH_SCALE       0.5f    // scales splash for NPC's

extern qboolean G_BoxInBounds( vec3_t point, vec3_t mins, vec3_t maxs, vec3_t boundsMins, vec3_t boundsMaxs );
extern qboolean G_HeavyMelee( gentity_t *attacker );
extern void Jedi_Decloak( gentity_t *self );

static void WP_FireEmplaced( gentity_t *ent, qboolean altFire );

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

void touch_NULL( gentity_t *ent, gentity_t *other, trace_t *trace )
{

}

void laserTrapExplode( gentity_t *self );
void RocketDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);

//We should really organize weapon data into tables or parse from the ext data so we have accurate info for this,
float WP_SpeedOfMissileForWeapon( int wp, qboolean alt_fire )
{
        return 500;
}

//-----------------------------------------------------------------------------
void W_TraceSetStart( gentity_t *ent, vec3_t start, vec3_t mins, vec3_t maxs )
//-----------------------------------------------------------------------------
{
        //make sure our start point isn't on the other side of a wall
        trace_t tr;
        vec3_t  entMins;
        vec3_t  entMaxs;
        vec3_t  eyePoint;

        VectorAdd( ent->r.currentOrigin, ent->r.mins, entMins );
        VectorAdd( ent->r.currentOrigin, ent->r.maxs, entMaxs );

        if ( G_BoxInBounds( start, mins, maxs, entMins, entMaxs ) )
        {
                return;
        }

        if ( !ent->client )
        {
                return;
        }

        VectorCopy( ent->s.pos.trBase, eyePoint);
        eyePoint[2] += ent->client->ps.viewheight;
                
        trap_Trace( &tr, eyePoint, mins, maxs, start, ent->s.number, MASK_SOLID|CONTENTS_SHOTCLIP );

        if ( tr.startsolid || tr.allsolid )
        {
                return;
        }

        if ( tr.fraction < 1.0f )
        {
                VectorCopy( tr.endpos, start );
        }
}


/*
----------------------------------------------
        PLAYER WEAPONS
----------------------------------------------
*/

/*
======================================================================

BRYAR PISTOL

======================================================================
*/

//----------------------------------------------
static void WP_FireBryarPistol( gentity_t *ent, qboolean altFire )
//---------------------------------------------------------
{
        int damage = BRYAR_PISTOL_DAMAGE;
        int count;

        gentity_t       *missile = CreateMissile( muzzle, forward, BRYAR_PISTOL_VEL, 10000, ent, altFire );

        missile->classname = "bryar_proj";
        missile->s.weapon = WP_BRYAR_PISTOL;

        if ( altFire )
        {
                float boxSize = 0;

                count = ( level.time - ent->client->ps.weaponChargeTime ) / BRYAR_CHARGE_UNIT;

                if ( count < 1 )
                {
                        count = 1;
                }
                else if ( count > 5 )
                {
                        count = 5;
                }

                if (count > 1)
                {
                        damage *= (count*1.7);
                }
                else
                {
                        damage *= (count*1.5);
                }

                missile->s.generic1 = count; // The missile will then render according to the charge level.

                boxSize = BRYAR_ALT_SIZE*(count*0.5);

                VectorSet( missile->r.maxs, boxSize, boxSize, boxSize );
                VectorSet( missile->r.mins, -boxSize, -boxSize, -boxSize );
        }

        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        if (altFire)
        {
                missile->methodOfDeath = MOD_BRYAR_PISTOL_ALT;
        }
        else
        {
                missile->methodOfDeath = MOD_BRYAR_PISTOL;
        }
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

        // we don't want it to bounce forever
        missile->bounceCount = 8;
}

/*
======================================================================

GENERIC

======================================================================
*/

//---------------------------------------------------------
void WP_FireTurretMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod, gentity_t *ignore )
//---------------------------------------------------------
{
        gentity_t *missile;

        missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );

        missile->classname = "generic_proj";
        missile->s.weapon = WP_TURRET;

        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = mod;
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

        if (ignore)
        {
                missile->passThroughNum = ignore->s.number+1;
        }

        // we don't want it to bounce forever
        missile->bounceCount = 8;
}

//Currently only the seeker drone uses this, but it might be useful for other things as well.

//---------------------------------------------------------
void WP_FireGenericBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod )
//---------------------------------------------------------
{
        gentity_t *missile;

        missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );

        missile->classname = "generic_proj";
        missile->s.weapon = WP_BRYAR_PISTOL;

        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = mod;
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

        // we don't want it to bounce forever
        missile->bounceCount = 8;
}

/*
======================================================================

BLASTER

======================================================================
*/

//---------------------------------------------------------
void WP_FireBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire )
//---------------------------------------------------------
{
        int velocity    = BLASTER_VELOCITY;
        int     damage          = BLASTER_DAMAGE;
        gentity_t *missile;

        if (ent->s.eType == ET_NPC)
        { //animent
                damage = 10;
        }

        missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );

        missile->classname = "blaster_proj";
        missile->s.weapon = WP_BLASTER;

        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = MOD_BLASTER;
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

        // we don't want it to bounce forever
        missile->bounceCount = 8;
}

//---------------------------------------------------------
void WP_FireTurboLaserMissile( gentity_t *ent, vec3_t start, vec3_t dir )
//---------------------------------------------------------
{
        int velocity    = ent->mass; //FIXME: externalize
        gentity_t *missile;

        missile = CreateMissile( start, dir, velocity, 10000, ent, qfalse );
        
        //use a custom shot effect
        missile->s.otherEntityNum2 = ent->genericValue14;
        //use a custom impact effect
        missile->s.emplacedOwner = ent->genericValue15;

        missile->classname = "turbo_proj";
        missile->s.weapon = WP_TURRET;

        missile->damage = ent->damage;          //FIXME: externalize
        missile->splashDamage = ent->splashDamage;      //FIXME: externalize
        missile->splashRadius = ent->splashRadius;      //FIXME: externalize
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = MOD_TURBLAST; //count as a heavy weap
        missile->splashMethodOfDeath = MOD_TURBLAST;// ?SPLASH;
        missile->clipmask = MASK_SHOT;

        // we don't want it to bounce forever
        missile->bounceCount = 8;

        //set veh as cgame side owner for purpose of fx overrides
        missile->s.owner = ent->s.number;

        //don't let them last forever
        missile->think = G_FreeEntity;
        missile->nextthink = level.time + 5000;//at 20000 speed, that should be more than enough
}

//---------------------------------------------------------
void WP_FireEmplacedMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, gentity_t *ignore )
//---------------------------------------------------------
{
        int velocity    = BLASTER_VELOCITY;
        int     damage          = BLASTER_DAMAGE;
        gentity_t *missile;

        missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );

        missile->classname = "emplaced_gun_proj";
        missile->s.weapon = WP_TURRET;//WP_EMPLACED_GUN;

        missile->activator = ignore;

        missile->damage = damage;
        missile->dflags = (DAMAGE_DEATH_KNOCKBACK|DAMAGE_HEAVY_WEAP_CLASS);
        missile->methodOfDeath = MOD_VEHICLE;
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

        if (ignore)
        {
                missile->passThroughNum = ignore->s.number+1;
        }

        // we don't want it to bounce forever
        missile->bounceCount = 8;
}

//---------------------------------------------------------
static void WP_FireBlaster( gentity_t *ent, qboolean altFire )
//---------------------------------------------------------
{
        vec3_t  dir, angs;

        vectoangles( forward, angs );

        if ( altFire )
        {
                // add some slop to the alt-fire direction
                angs[PITCH] += crandom() * BLASTER_SPREAD;
                angs[YAW]       += crandom() * BLASTER_SPREAD;
        }

        AngleVectors( angs, dir, NULL, NULL );

        // FIXME: if temp_org does not have clear trace to inside the bbox, don't shoot!
        WP_FireBlasterMissile( ent, muzzle, dir, altFire );
}



int G_GetHitLocation(gentity_t *target, vec3_t ppoint);

/*
======================================================================

DISRUPTOR

======================================================================
*/
//---------------------------------------------------------
static void WP_DisruptorMainFire( gentity_t *ent )
//---------------------------------------------------------
{
        int                     damage = DISRUPTOR_MAIN_DAMAGE;
        qboolean        render_impact = qtrue;
        vec3_t          start, end;
        trace_t         tr;
        gentity_t       *traceEnt, *tent;
        float           shotRange = 8192;
        int                     ignore, traces;

        if ( g_gametype.integer == GT_SIEGE )
        {
                damage = DISRUPTOR_MAIN_DAMAGE_SIEGE;
        }

        memset(&tr, 0, sizeof(tr)); //to shut the compiler up

        VectorCopy( ent->client->ps.origin, start );
        start[2] += ent->client->ps.viewheight;//By eyes

        VectorMA( start, shotRange, forward, end );

        ignore = ent->s.number;
        traces = 0;
        while ( traces < 10 )
        {//need to loop this in case we hit a Jedi who dodges the shot
                if (d_projectileGhoul2Collision.integer)
                {
                        trap_G2Trace( &tr, start, NULL, NULL, end, ignore, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
                }
                else
                {
                        trap_Trace( &tr, start, NULL, NULL, end, ignore, MASK_SHOT );
                }

                traceEnt = &g_entities[tr.entityNum];

                if (d_projectileGhoul2Collision.integer && traceEnt->inuse && traceEnt->client)
                { //g2 collision checks -rww
                        if (traceEnt->inuse && traceEnt->client && traceEnt->ghoul2)
                        { //since we used G2TRFLAG_GETSURFINDEX, tr.surfaceFlags will actually contain the index of the surface on the ghoul2 model we collided with.
                                traceEnt->client->g2LastSurfaceHit = tr.surfaceFlags;
                                traceEnt->client->g2LastSurfaceTime = level.time;
                        }

                        if (traceEnt->ghoul2)
                        {
                                tr.surfaceFlags = 0; //clear the surface flags after, since we actually care about them in here.
                        }
                }

                if (traceEnt && traceEnt->client && traceEnt->client->ps.duelInProgress &&
                        traceEnt->client->ps.duelIndex != ent->s.number)
                {
                        VectorCopy( tr.endpos, start );
                        ignore = tr.entityNum;
                        traces++;
                        continue;
                }

                if ( Jedi_DodgeEvasion( traceEnt, ent, &tr, G_GetHitLocation(traceEnt, tr.endpos) ) )
                {//act like we didn't even hit him
                        VectorCopy( tr.endpos, start );
                        ignore = tr.entityNum;
                        traces++;
                        continue;
                }
                else if (traceEnt && traceEnt->client && traceEnt->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= FORCE_LEVEL_3)
                {
                        if (WP_SaberCanBlock(traceEnt, tr.endpos, 0, MOD_DISRUPTOR, qtrue, 0))
                        { //broadcast and stop the shot because it was blocked
                                gentity_t *te = NULL;

                                tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_MAIN_SHOT );
                                VectorCopy( muzzle, tent->s.origin2 );
                                tent->s.eventParm = ent->s.number;

                                te = G_TempEntity( tr.endpos, EV_SABER_BLOCK );
                                VectorCopy(tr.endpos, te->s.origin);
                                VectorCopy(tr.plane.normal, te->s.angles);
                                if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
                                {
                                        te->s.angles[1] = 1;
                                }
                                te->s.eventParm = 0;
                                te->s.weapon = 0;//saberNum
                                te->s.legsAnim = 0;//bladeNum

                                return;
                        }
                }
                else if ( (traceEnt->flags&FL_SHIELDED) )
                {//stopped cold
                        return;
                }
                //a Jedi is not dodging this shot
                break;
        }

        if ( tr.surfaceFlags & SURF_NOIMPACT ) 
        {
                render_impact = qfalse;
        }

        // always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
        tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_MAIN_SHOT );
        VectorCopy( muzzle, tent->s.origin2 );
        tent->s.eventParm = ent->s.number;

        traceEnt = &g_entities[tr.entityNum];

        if ( render_impact )
        {
                if ( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage )
                {
                        if ( traceEnt->client && LogAccuracyHit( traceEnt, ent )) 
                        {
                                ent->client->accuracy_hits++;
                        } 

                        G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NORMAL, MOD_DISRUPTOR );
                        
                        tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_HIT );
                        tent->s.eventParm = DirToByte( tr.plane.normal );
                        if (traceEnt->client)
                        {
                                tent->s.weapon = 1;
                        }
                }
                else 
                {
                         // Hmmm, maybe don't make any marks on things that could break
                        tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_MISS );
                        tent->s.eventParm = DirToByte( tr.plane.normal );
                        tent->s.weapon = 1;
                }
        }
}


qboolean G_CanDisruptify(gentity_t *ent)
{
        if (!ent || !ent->inuse || !ent->client || ent->s.eType != ET_NPC ||
                ent->s.NPC_class != CLASS_VEHICLE || !ent->m_pVehicle)
        { //not vehicle
                return qtrue;
        }

        if (ent->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
        { //animal is only type that can be disintigeiteigerated
                return qtrue;
        }

        //don't do it to any other veh
        return qfalse;
}

//---------------------------------------------------------
void WP_DisruptorAltFire( gentity_t *ent )
//---------------------------------------------------------
{
        int                     damage = 0, skip;
        qboolean        render_impact = qtrue;
        vec3_t          start, end;
        vec3_t          muzzle2;
        trace_t         tr;
        gentity_t       *traceEnt, *tent;
        float           shotRange = 8192.0f;
        int                     i;
        int                     count, maxCount = 60;
        int                     traces = DISRUPTOR_ALT_TRACES;
        qboolean        fullCharge = qfalse;

        damage = DISRUPTOR_ALT_DAMAGE-30;

        VectorCopy( muzzle, muzzle2 ); // making a backup copy

        if (ent->client)
        {
                VectorCopy( ent->client->ps.origin, start );
                start[2] += ent->client->ps.viewheight;//By eyes

                count = ( level.time - ent->client->ps.weaponChargeTime ) / DISRUPTOR_CHARGE_UNIT;
                if ( g_gametype.integer == GT_SIEGE )
                {//maybe a full alt-charge should be a *bit* more dangerous in Siege mode?
                        //maxCount = ceil((200.0f-(float)damage)/2.0f);//cap at 200 damage total
                        maxCount = 200;//the previous line ALWAYS evaluated to 135 - was that on purpose?
                }
        }
        else
        {
                VectorCopy( ent->r.currentOrigin, start );
                start[2] += 24;

                count = ( 100 ) / DISRUPTOR_CHARGE_UNIT;
        }

        count *= 2;

        if ( count < 1 )
        {
                count = 1;
        }
        else if ( count >= maxCount )
        {
                count = maxCount;
                fullCharge = qtrue;
        }

        // more powerful charges go through more things
        if ( count < 10 )
        {
                traces = 1;
        }
        else if ( count < 20 )
        {
                traces = 2;
        }

        damage += count;
        
        skip = ent->s.number;

        for (i = 0; i < traces; i++ )
        {
                VectorMA( start, shotRange, forward, end );

                if (d_projectileGhoul2Collision.integer)
                {
                        trap_G2Trace( &tr, start, NULL, NULL, end, skip, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
                }
                else
                {
                        trap_Trace( &tr, start, NULL, NULL, end, skip, MASK_SHOT );
                }

                traceEnt = &g_entities[tr.entityNum];

                if (d_projectileGhoul2Collision.integer && traceEnt->inuse && traceEnt->client)
                { //g2 collision checks -rww
                        if (traceEnt->inuse && traceEnt->client && traceEnt->ghoul2)
                        { //since we used G2TRFLAG_GETSURFINDEX, tr.surfaceFlags will actually contain the index of the surface on the ghoul2 model we collided with.
                                traceEnt->client->g2LastSurfaceHit = tr.surfaceFlags;
                                traceEnt->client->g2LastSurfaceTime = level.time;
                        }

                        if (traceEnt->ghoul2)
                        {
                                tr.surfaceFlags = 0; //clear the surface flags after, since we actually care about them in here.
                        }
                }

                if ( tr.surfaceFlags & SURF_NOIMPACT ) 
                {
                        render_impact = qfalse;
                }

                if (traceEnt && traceEnt->client && traceEnt->client->ps.duelInProgress &&
                        traceEnt->client->ps.duelIndex != ent->s.number)
                {
                        skip = tr.entityNum;
                        VectorCopy(tr.endpos, start);
                        continue;
                }

                if (Jedi_DodgeEvasion(traceEnt, ent, &tr, G_GetHitLocation(traceEnt, tr.endpos)))
                {
                        skip = tr.entityNum;
                        VectorCopy(tr.endpos, start);
                        continue;
                }
                else if (traceEnt && traceEnt->client && traceEnt->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= FORCE_LEVEL_3)
                {
                        if (WP_SaberCanBlock(traceEnt, tr.endpos, 0, MOD_DISRUPTOR_SNIPER, qtrue, 0))
                        { //broadcast and stop the shot because it was blocked
                                gentity_t *te = NULL;

                                tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_SHOT );
                                VectorCopy( muzzle, tent->s.origin2 );
                                tent->s.shouldtarget = fullCharge;
                                tent->s.eventParm = ent->s.number;

                                te = G_TempEntity( tr.endpos, EV_SABER_BLOCK );
                                VectorCopy(tr.endpos, te->s.origin);
                                VectorCopy(tr.plane.normal, te->s.angles);
                                if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
                                {
                                        te->s.angles[1] = 1;
                                }
                                te->s.eventParm = 0;
                                te->s.weapon = 0;//saberNum
                                te->s.legsAnim = 0;//bladeNum

                                return;
                        }
                }

                // always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
                tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_SHOT );
                VectorCopy( muzzle, tent->s.origin2 );
                tent->s.shouldtarget = fullCharge;
                tent->s.eventParm = ent->s.number;

                // If the beam hits a skybox, etc. it would look foolish to add impact effects
                if ( render_impact ) 
                {
                        if ( traceEnt->takedamage && traceEnt->client )
                        {
                                tent->s.otherEntityNum = traceEnt->s.number;

                                // Create a simple impact type mark
                                tent = G_TempEntity(tr.endpos, EV_MISSILE_MISS);
                                tent->s.eventParm = DirToByte(tr.plane.normal);
                                tent->s.eFlags |= EF_ALT_FIRING;
        
                                if ( LogAccuracyHit( traceEnt, ent )) 
                                {
                                        if (ent->client)
                                        {
                                                ent->client->accuracy_hits++;
                                        }
                                }
                        } 
                        else 
                        {
                                 if ( traceEnt->r.svFlags & SVF_GLASS_BRUSH 
                                                || traceEnt->takedamage 
                                                || traceEnt->s.eType == ET_MOVER )
                                 {
                                        if ( traceEnt->takedamage )
                                        {
                                                G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, 
                                                                DAMAGE_NO_KNOCKBACK, MOD_DISRUPTOR_SNIPER );

                                                tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_HIT );
                                                tent->s.eventParm = DirToByte( tr.plane.normal );
                                        }
                                 }
                                 else
                                 {
                                         // Hmmm, maybe don't make any marks on things that could break
                                        tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_MISS );
                                        tent->s.eventParm = DirToByte( tr.plane.normal );
                                 }
                                break; // and don't try any more traces
                        }

                        if ( (traceEnt->flags&FL_SHIELDED) )
                        {//stops us cold
                                break;
                        }

                        if ( traceEnt->takedamage )
                        {
                                vec3_t preAng;
                                int preHealth = traceEnt->health;
                                int preLegs = 0;
                                int preTorso = 0;

                                if (traceEnt->client)
                                {
                                        preLegs = traceEnt->client->ps.legsAnim;
                                        preTorso = traceEnt->client->ps.torsoAnim;
                                        VectorCopy(traceEnt->client->ps.viewangles, preAng);
                                }

                                G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_DISRUPTOR_SNIPER );

                                if (traceEnt->client && preHealth > 0 && traceEnt->health <= 0 && fullCharge &&
                                        G_CanDisruptify(traceEnt))
                                { //was killed by a fully charged sniper shot, so disintegrate
                                        VectorCopy(preAng, traceEnt->client->ps.viewangles);

                                        traceEnt->client->ps.eFlags |= EF_DISINTEGRATION;
                                        VectorCopy(tr.endpos, traceEnt->client->ps.lastHitLoc);

                                        traceEnt->client->ps.legsAnim = preLegs;
                                        traceEnt->client->ps.torsoAnim = preTorso;

                                        traceEnt->r.contents = 0;

                                        VectorClear(traceEnt->client->ps.velocity);
                                }

                                tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_HIT );
                                tent->s.eventParm = DirToByte( tr.plane.normal );
                                if (traceEnt->client)
                                {
                                        tent->s.weapon = 1;
                                }
                        }
                }
                else // not rendering impact, must be a skybox or other similar thing?
                {
                        break; // don't try anymore traces
                }

                // Get ready for an attempt to trace through another person
                VectorCopy( tr.endpos, muzzle );
                VectorCopy( tr.endpos, start );
                skip = tr.entityNum;
        }
}


//---------------------------------------------------------
static void WP_FireDisruptor( gentity_t *ent, qboolean altFire )
//---------------------------------------------------------
{
        if (!ent || !ent->client || ent->client->ps.zoomMode != 1)
        { //do not ever let it do the alt fire when not zoomed
                altFire = qfalse;
        }

        if (ent && ent->s.eType == ET_NPC && !ent->client)
        { //special case for animents
                WP_DisruptorAltFire( ent );
                return;
        }

        if ( altFire )
        {
                WP_DisruptorAltFire( ent );
        }
        else
        {
                WP_DisruptorMainFire( ent );
        }
}


/*
======================================================================

BOWCASTER

======================================================================
*/

static void WP_BowcasterAltFire( gentity_t *ent )
{
        int     damage  = BOWCASTER_DAMAGE;

        gentity_t *missile = CreateMissile( muzzle, forward, BOWCASTER_VELOCITY, 10000, ent, qfalse);

        missile->classname = "bowcaster_proj";
        missile->s.weapon = WP_BOWCASTER;

        VectorSet( missile->r.maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
        VectorScale( missile->r.maxs, -1, missile->r.mins );

        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = MOD_BOWCASTER;
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

        missile->flags |= FL_BOUNCE;
        missile->bounceCount = 3;
}

//---------------------------------------------------------
static void WP_BowcasterMainFire( gentity_t *ent )
//---------------------------------------------------------
{
        int                     damage  = BOWCASTER_DAMAGE, count;
        float           vel;
        vec3_t          angs, dir;
        gentity_t       *missile;
        int i;

        if (!ent->client)
        {
                count = 1;
        }
        else
        {
                count = ( level.time - ent->client->ps.weaponChargeTime ) / BOWCASTER_CHARGE_UNIT;
        }

        if ( count < 1 )
        {
                count = 1;
        }
        else if ( count > 5 )
        {
                count = 5;
        }

        if ( !(count & 1 ))
        {
                // if we aren't odd, knock us down a level
                count--;
        }

        //scale the damage down based on how many are about to be fired
        if (count <= 1)
        {
                damage = 50;
        }
        else if (count == 2)
        {
                damage = 45;
        }
        else if (count == 3)
        {
                damage = 40;
        }
        else if (count == 4)
        {
                damage = 35;
        }
        else
        {
                damage = 30;
        }

        for (i = 0; i < count; i++ )
        {
                // create a range of different velocities
                vel = BOWCASTER_VELOCITY * ( crandom() * BOWCASTER_VEL_RANGE + 1.0f );

                vectoangles( forward, angs );

                // add some slop to the alt-fire direction
                angs[PITCH] += crandom() * BOWCASTER_ALT_SPREAD * 0.2f;
                angs[YAW]       += ((i+0.5f) * BOWCASTER_ALT_SPREAD - count * 0.5f * BOWCASTER_ALT_SPREAD );
                
                AngleVectors( angs, dir, NULL, NULL );

                missile = CreateMissile( muzzle, dir, vel, 10000, ent, qtrue );

                missile->classname = "bowcaster_alt_proj";
                missile->s.weapon = WP_BOWCASTER;

                VectorSet( missile->r.maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
                VectorScale( missile->r.maxs, -1, missile->r.mins );

                missile->damage = damage;
                missile->dflags = DAMAGE_DEATH_KNOCKBACK;
                missile->methodOfDeath = MOD_BOWCASTER;
                missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

                // we don't want it to bounce
                missile->bounceCount = 0;
        }
}

//---------------------------------------------------------
static void WP_FireBowcaster( gentity_t *ent, qboolean altFire )
//---------------------------------------------------------
{
        if ( altFire )
        {
                WP_BowcasterAltFire( ent );
        }
        else
        {
                WP_BowcasterMainFire( ent );
        }
}



/*
======================================================================

REPEATER

======================================================================
*/

//---------------------------------------------------------
static void WP_RepeaterMainFire( gentity_t *ent, vec3_t dir )
//---------------------------------------------------------
{
        int     damage  = REPEATER_DAMAGE;

        gentity_t *missile = CreateMissile( muzzle, dir, REPEATER_VELOCITY, 10000, ent, qfalse );

        missile->classname = "repeater_proj";
        missile->s.weapon = WP_REPEATER;

        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = MOD_REPEATER;
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;

        // we don't want it to bounce forever
        missile->bounceCount = 8;
}

//---------------------------------------------------------
static void WP_RepeaterAltFire( gentity_t *ent )
//---------------------------------------------------------
{
        int     damage  = REPEATER_ALT_DAMAGE;

        gentity_t *missile = CreateMissile( muzzle, forward, REPEATER_ALT_VELOCITY, 10000, ent, qtrue );

        missile->classname = "repeater_alt_proj";
        missile->s.weapon = WP_REPEATER;

        VectorSet( missile->r.maxs, REPEATER_ALT_SIZE, REPEATER_ALT_SIZE, REPEATER_ALT_SIZE );
        VectorScale( missile->r.maxs, -1, missile->r.mins );
        missile->s.pos.trType = TR_GRAVITY;
        missile->s.pos.trDelta[2] += 40.0f; //give a slight boost in the upward direction
        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = MOD_REPEATER_ALT;
        missile->splashMethodOfDeath = MOD_REPEATER_ALT_SPLASH;
        missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
        missile->splashDamage = REPEATER_ALT_SPLASH_DAMAGE;
        if ( g_gametype.integer == GT_SIEGE )   // we've been having problems with this being too hyper-potent because of it's radius
        {
                missile->splashRadius = REPEATER_ALT_SPLASH_RAD_SIEGE;
        }
        else
        {
                missile->splashRadius = REPEATER_ALT_SPLASH_RADIUS;
        }

        // we don't want it to bounce forever
        missile->bounceCount = 8;
}

//---------------------------------------------------------
static void WP_FireRepeater( gentity_t *ent, qboolean altFire )
//---------------------------------------------------------
{
        vec3_t  dir, angs;

        vectoangles( forward, angs );

        if ( altFire )
        {
                WP_RepeaterAltFire( ent );
        }
        else
        {
                // add some slop to the alt-fire direction
                angs[PITCH] += crandom() * REPEATER_SPREAD;
                angs[YAW]       += crandom() * REPEATER_SPREAD;

                AngleVectors( angs, dir, NULL, NULL );

                WP_RepeaterMainFire( ent, dir );
        }
}


/*
======================================================================

DEMP2

======================================================================
*/

static void WP_DEMP2_MainFire( gentity_t *ent )
{
        int     damage  = DEMP2_DAMAGE;

        gentity_t *missile = CreateMissile( muzzle, forward, DEMP2_VELOCITY, 10000, ent, qfalse);

        missile->classname = "demp2_proj";
        missile->s.weapon = WP_DEMP2;

        VectorSet( missile->r.maxs, DEMP2_SIZE, DEMP2_SIZE, DEMP2_SIZE );
        VectorScale( missile->r.maxs, -1, missile->r.mins );
        missile->damage = damage;
        missile->dflags = DAMAGE_DEATH_KNOCKBACK;
        missile->methodOfDeath = MOD_DEMP2;
        missile->clipmask = MASK_SHOT;

        // we don't want it to ever bounce
        missile->bounceCount = 0;
}

static gentity_t *ent_list[MAX_GENTITIES];

void DEMP2_AltRadiusDamage( gentity_t *ent )
{
        float           frac = ( level.time - ent->genericValue5 ) / 800.0f; // / 1600.0f; // synchronize with demp2 effect
        float           dist, radius, fact;
        gentity_t       *gent;
        int                     iEntityList[MAX_GENTITIES];
        gentity_t       *entityList[MAX_GENTITIES];
        gentity_t       *myOwner = NULL;
        int                     numListedEntities, i, e;
        vec3_t          mins, maxs;
        vec3_t          v, dir;

        if (ent->r.ownerNum >= 0 &&
                ent->r.ownerNum < /*MAX_CLIENTS ... let npc's/shooters use it*/MAX_GENTITIES)
        {
                myOwner = &g_entities[ent->r.ownerNum];
        }

        if (!myOwner || !myOwner->inuse || !myOwner->client)
        {
                ent->think = G_FreeEntity;
                ent->nextthink = level.time;
                return;
        }

        frac *= frac * frac; // yes, this is completely ridiculous...but it causes the shell to grow slowly then "explode" at the end
        
        radius = frac * 200.0f; // 200 is max radius...the model is aprox. 100 units tall...the fx draw code mults. this by 2.

        fact = ent->count*0.6;

        if (fact < 1)
        {
                fact = 1;
        }

        radius *= fact;

        for ( i = 0 ; i < 3 ; i++ ) 
        {
                mins[i] = ent->r.currentOrigin[i] - radius;
                maxs[i] = ent->r.currentOrigin[i] + radius;
        }

        numListedEntities = trap_EntitiesInBox( mins, maxs, iEntityList, MAX_GENTITIES );

        i = 0;
        while (i < numListedEntities)
        {
                entityList[i] = &g_entities[iEntityList[i]];
                i++;
        }

        for ( e = 0 ; e < numListedEntities ; e++ ) 
        {
                gent = entityList[ e ];

                if ( !gent || !gent->takedamage || !gent->r.contents )
                {
                        continue;
                }

                // find the distance from the edge of the bounding box
                for ( i = 0 ; i < 3 ; i++ ) 
                {
                        if ( ent->r.currentOrigin[i] < gent->r.absmin[i] ) 
                        {
                                v[i] = gent->r.absmin[i] - ent->r.currentOrigin[i];
                        } 
                        else if ( ent->r.currentOrigin[i] > gent->r.absmax[i] ) 
                        {
                                v[i] = ent->r.currentOrigin[i] - gent->r.absmax[i];
                        } 
                        else 
                        {
                                v[i] = 0;
                        }
                }

                // shape is an ellipsoid, so cut vertical distance in half`
                v[2] *= 0.5f;

                dist = VectorLength( v );

                if ( dist >= radius ) 
                {
                        // shockwave hasn't hit them yet
                        continue;
                }

                if (dist+(16*ent->