g_weapon.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//
// g_weapon.c 
// perform the server side effects of a weapon firing

#include "g_local.h"

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

#define NUM_NAILSHOTS 15

/*
================
G_BounceProjectile
================
*/
void G_BounceProjectile( vec3_t start, vec3_t impact, vec3_t dir, vec3_t endout ) {
    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);
}


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

GAUNTLET

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

void Weapon_Gauntlet( gentity_t *ent ) {

}

/*
===============
CheckGauntletAttack
===============
*/
qboolean CheckGauntletAttack( gentity_t *ent ) {
    trace_t     tr;
    vec3_t      end;
    gentity_t   *tent;
    gentity_t   *traceEnt;
    int         damage;

    // set aiming directions
    AngleVectors (ent->client->ps.viewangles, forward, right, up);

    CalcMuzzlePoint ( ent, forward, right, up, muzzle );

    VectorMA (muzzle, 32, forward, end);

    trap_Trace (&tr, muzzle, NULL, NULL, end, ent->s.number, MASK_SHOT);
    if ( tr.surfaceFlags & SURF_NOIMPACT ) {
        return qfalse;
    }

    traceEnt = &g_entities[ tr.entityNum ];

    // send blood impact
    if ( traceEnt->takedamage && traceEnt->client ) {
        tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );
        tent->s.otherEntityNum = traceEnt->s.number;
        tent->s.eventParm = DirToByte( tr.plane.normal );
        tent->s.weapon = ent->s.weapon;
    }

    if ( !traceEnt->takedamage) {
        return qfalse;
    }

    if (ent->client->ps.powerups[PW_QUAD] ) {
        G_AddEvent( ent, EV_POWERUP_QUAD, 0 );
        s_quadFactor = g_quadfactor.value;
    } else {
        s_quadFactor = 1;
    }
#ifdef MISSIONPACK
    if( ent->client->persistantPowerup && ent->client->persistantPowerup->item && ent->client->persistantPowerup->item->giTag == PW_DOUBLER ) {
        s_quadFactor *= 2;
    }
#endif

    damage = 50 * s_quadFactor;
    G_Damage( traceEnt, ent, ent, forward, tr.endpos,
        damage, 0, MOD_GAUNTLET );

    return qtrue;
}


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

MACHINEGUN

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

/*
======================
SnapVectorTowards

Round a vector to integers for more efficient network
transmission, but make sure that it rounds towards a given point
rather than blindly truncating.  This prevents it from truncating 
into a wall.
======================
*/
void SnapVectorTowards( vec3_t v, vec3_t to ) {
    int     i;

    for ( i = 0 ; i < 3 ; i++ ) {
        if ( to[i] <= v[i] ) {
            v[i] = (int)v[i];
        } else {
            v[i] = (int)v[i] + 1;
        }
    }
}

#ifdef MISSIONPACK
#define CHAINGUN_SPREAD     600
#endif
#define MACHINEGUN_SPREAD   200
#define MACHINEGUN_DAMAGE   7
#define MACHINEGUN_TEAM_DAMAGE  5       // wimpier MG in teamplay

void Bullet_Fire (gentity_t *ent, float spread, int damage ) {
    trace_t     tr;
    vec3_t      end;
#ifdef MISSIONPACK
    vec3_t      impactpoint, bouncedir;
#endif
    float       r;
    float       u;
    gentity_t   *tent;
    gentity_t   *traceEnt;
    int         i, passent;

    damage *= s_quadFactor;

    r = random() * M_PI * 2.0f;
    u = sin(r) * crandom() * spread * 16;
    r = cos(r) * crandom() * spread * 16;
    VectorMA (muzzle, 8192*16, forward, end);
    VectorMA (end, r, right, end);
    VectorMA (end, u, up, end);

    passent = ent->s.number;
    for (i = 0; i < 10; i++) {

        trap_Trace (&tr, muzzle, NULL, NULL, end, passent, MASK_SHOT);
        if ( tr.surfaceFlags & SURF_NOIMPACT ) {
            return;
        }

        traceEnt = &g_entities[ tr.entityNum ];

        // snap the endpos to integers, but nudged towards the line
        SnapVectorTowards( tr.endpos, muzzle );

        // send bullet impact
        if ( traceEnt->takedamage && traceEnt->client ) {
            tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_FLESH );
            tent->s.eventParm = traceEnt->s.number;
            if( LogAccuracyHit( traceEnt, ent ) ) {
                ent->client->accuracy_hits++;
            }
        } else {
            tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_WALL );
            tent->s.eventParm = DirToByte( tr.plane.normal );
        }
        tent->s.otherEntityNum = ent->s.number;

        if ( traceEnt->takedamage) {
#ifdef MISSIONPACK
            if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
                if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
                    G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
                    VectorCopy( impactpoint, muzzle );
                    // the player can hit him/herself with the bounced rail
                    passent = ENTITYNUM_NONE;
                }
                else {
                    VectorCopy( tr.endpos, muzzle );
                    passent = traceEnt->s.number;
                }
                continue;
            }
            else {
#endif
                G_Damage( traceEnt, ent, ent, forward, tr.endpos,
                    damage, 0, MOD_MACHINEGUN);
#ifdef MISSIONPACK
            }
#endif
        }
        break;
    }
}


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

BFG

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

void BFG_Fire ( gentity_t *ent ) {
    gentity_t   *m;

    m = fire_bfg (ent, muzzle, forward);
    m->damage *= s_quadFactor;
    m->splashDamage *= s_quadFactor;

//  VectorAdd( m->s.pos.trDelta, ent->client->ps.velocity, m->s.pos.trDelta );  // "real" physics
}


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

SHOTGUN

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

// DEFAULT_SHOTGUN_SPREAD and DEFAULT_SHOTGUN_COUNT are in bg_public.h, because
// client predicts same spreads
#define DEFAULT_SHOTGUN_DAMAGE  10

qboolean ShotgunPellet( vec3_t start, vec3_t end, gentity_t *ent ) {
    trace_t     tr;
    int         damage, i, passent;
    gentity_t   *traceEnt;
#ifdef MISSIONPACK
    vec3_t      impactpoint, bouncedir;
#endif
    vec3_t      tr_start, tr_end;

    passent = ent->s.number;
    VectorCopy( start, tr_start );
    VectorCopy( end, tr_end );
    for (i = 0; i < 10; i++) {
        trap_Trace (&tr, tr_start, NULL, NULL, tr_end, passent, MASK_SHOT);
        traceEnt = &g_entities[ tr.entityNum ];

        // send bullet impact
        if (  tr.surfaceFlags & SURF_NOIMPACT ) {
            return qfalse;
        }

        if ( traceEnt->takedamage) {
            damage = DEFAULT_SHOTGUN_DAMAGE * s_quadFactor;
#ifdef MISSIONPACK
            if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
                if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
                    G_BounceProjectile( tr_start, impactpoint, bouncedir, tr_end );
                    VectorCopy( impactpoint, tr_start );
                    // the player can hit him/herself with the bounced rail
                    passent = ENTITYNUM_NONE;
                }
                else {
                    VectorCopy( tr.endpos, tr_start );
                    passent = traceEnt->s.number;
                }
                continue;
            }
            else {
                G_Damage( traceEnt, ent, ent, forward, tr.endpos,
                    damage, 0, MOD_SHOTGUN);
                if( LogAccuracyHit( traceEnt, ent ) ) {
                    return qtrue;
                }
            }
#else
            G_Damage( traceEnt, ent, ent, forward, tr.endpos,   damage, 0, MOD_SHOTGUN);
                if( LogAccuracyHit( traceEnt, ent ) ) {
                    return qtrue;
                }
#endif
        }
        return qfalse;
    }
    return qfalse;
}

// this should match CG_ShotgunPattern
void ShotgunPattern( vec3_t origin, vec3_t origin2, int seed, gentity_t *ent ) {
    int         i;
    float       r, u;
    vec3_t      end;
    vec3_t      forward, right, up;
    int         oldScore;
    qboolean    hitClient = qfalse;

    // derive the right and up vectors from the forward vector, because
    // the client won't have any other information
    VectorNormalize2( origin2, forward );
    PerpendicularVector( right, forward );
    CrossProduct( forward, right, up );

    oldScore = ent->client->ps.persistant[PERS_SCORE];

    // generate the "random" spread pattern
    for ( i = 0 ; i < DEFAULT_SHOTGUN_COUNT ; i++ ) {
        r = Q_crandom( &seed ) * DEFAULT_SHOTGUN_SPREAD * 16;
        u = Q_crandom( &seed ) * DEFAULT_SHOTGUN_SPREAD * 16;
        VectorMA( origin, 8192 * 16, forward, end);
        VectorMA (end, r, right, end);
        VectorMA (end, u, up, end);
        if( ShotgunPellet( origin, end, ent ) && !hitClient ) {
            hitClient = qtrue;
            ent->client->accuracy_hits++;
        }
    }
}


void weapon_supershotgun_fire (gentity_t *ent) {
    gentity_t       *tent;

    // send shotgun blast
    tent = G_TempEntity( muzzle, EV_SHOTGUN );
    VectorScale( forward, 4096, tent->s.origin2 );
    SnapVector( tent->s.origin2 );
    tent->s.eventParm = rand() & 255;       // seed for spread pattern
    tent->s.otherEntityNum = ent->s.number;

    ShotgunPattern( tent->s.pos.trBase, tent->s.origin2, tent->s.eventParm, ent );
}


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

GRENADE LAUNCHER

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

void weapon_grenadelauncher_fire (gentity_t *ent) {
    gentity_t   *m;

    // extra vertical velocity
    forward[2] += 0.2f;
    VectorNormalize( forward );

    m = fire_grenade (ent, muzzle, forward);
    m->damage *= s_quadFactor;
    m->splashDamage *= s_quadFactor;

//  VectorAdd( m->s.pos.trDelta, ent->client->ps.velocity, m->s.pos.trDelta );  // "real" physics
}

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

ROCKET

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

void Weapon_RocketLauncher_Fire (gentity_t *ent) {
    gentity_t   *m;

    m = fire_rocket (ent, muzzle, forward);
    m->damage *= s_quadFactor;
    m->splashDamage *= s_quadFactor;

//  VectorAdd( m->s.pos.trDelta, ent->client->ps.velocity, m->s.pos.trDelta );  // "real" physics
}


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

PLASMA GUN

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

void Weapon_Plasmagun_Fire (gentity_t *ent) {
    gentity_t   *m;

    m = fire_plasma (ent, muzzle, forward);
    m->damage *= s_quadFactor;
    m->splashDamage *= s_quadFactor;

//  VectorAdd( m->s.pos.trDelta, ent->client->ps.velocity, m->s.pos.trDelta );  // "real" physics
}

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

RAILGUN

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


/*
=================
weapon_railgun_fire
=================
*/
#define MAX_RAIL_HITS   4
void weapon_railgun_fire (gentity_t *ent) {
    vec3_t      end;
#ifdef MISSIONPACK
    vec3_t impactpoint, bouncedir;
#endif
    trace_t     trace;
    gentity_t   *tent;
    gentity_t   *traceEnt;
    int         damage;
    int         i;
    int         hits;
    int         unlinked;
    int         passent;
    gentity_t   *unlinkedEntities[MAX_RAIL_HITS];

    damage = 100 * s_quadFactor;

    VectorMA (muzzle, 8192, forward, end);

    // trace only against the solids, so the railgun will go through people
    unlinked = 0;
    hits = 0;
    passent = ent->s.number;
    do {
        trap_Trace (&trace, muzzle, NULL, NULL, end, passent, MASK_SHOT );
        if ( trace.entityNum >= ENTITYNUM_MAX_NORMAL ) {
            break;
        }
        traceEnt = &g_entities[ trace.entityNum ];
        if ( traceEnt->takedamage ) {
#ifdef MISSIONPACK
            if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
                if ( G_InvulnerabilityEffect( traceEnt, forward, trace.endpos, impactpoint, bouncedir ) ) {
                    G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
                    // snap the endpos to integers to save net bandwidth, but nudged towards the line
                    SnapVectorTowards( trace.endpos, muzzle );
                    // send railgun beam effect
                    tent = G_TempEntity( trace.endpos, EV_RAILTRAIL );
                    // set player number for custom colors on the railtrail
                    tent->s.clientNum = ent->s.clientNum;
                    VectorCopy( muzzle, tent->s.origin2 );
                    // move origin a bit to come closer to the drawn gun muzzle
                    VectorMA( tent->s.origin2, 4, right, tent->s.origin2 );
                    VectorMA( tent->s.origin2, -1, up, tent->s.origin2 );
                    tent->s.eventParm = 255;    // don't make the explosion at the end
                    //
                    VectorCopy( impactpoint, muzzle );
                    // the player can hit him/herself with the bounced rail
                    passent = ENTITYNUM_NONE;
                }
            }
            else {
                if( LogAccuracyHit( traceEnt, ent ) ) {
                    hits++;
                }
                G_Damage (traceEnt, ent, ent, forward, trace.endpos, damage, 0, MOD_RAILGUN);
            }
#else
                if( LogAccuracyHit( traceEnt, ent ) ) {
                    hits++;
                }
                G_Damage (traceEnt, ent, ent, forward, trace.endpos, damage, 0, MOD_RAILGUN);
#endif
        }
        if ( trace.contents & CONTENTS_SOLID ) {
            break;      // we hit something solid enough to stop the beam
        }
        // unlink this entity, so the next trace will go past it
        trap_UnlinkEntity( traceEnt );
        unlinkedEntities[unlinked] = traceEnt;
        unlinked++;
    } while ( unlinked < MAX_RAIL_HITS );

    // link back in any entities we unlinked
    for ( i = 0 ; i < unlinked ; i++ ) {
        trap_LinkEntity( unlinkedEntities[i] );
    }

    // the final trace endpos will be the terminal point of the rail trail

    // snap the endpos to integers to save net bandwidth, but nudged towards the line
    SnapVectorTowards( trace.endpos, muzzle );

    // send railgun beam effect
    tent = G_TempEntity( trace.endpos, EV_RAILTRAIL );

    // set player number for custom colors on the railtrail
    tent->s.clientNum = ent->s.clientNum;

    VectorCopy( muzzle, tent->s.origin2 );
    // move origin a bit to come closer to the drawn gun muzzle
    VectorMA( tent->s.origin2, 4, right, tent->s.origin2 );
    VectorMA( tent->s.origin2, -1, up, tent->s.origin2 );

    // no explosion at end if SURF_NOIMPACT, but still make the trail
    if ( trace.surfaceFlags & SURF_NOIMPACT ) {
        tent->s.eventParm = 255;    // don't make the explosion at the end
    } else {
        tent->s.eventParm = DirToByte( trace.plane.normal );
    }
    tent->s.clientNum = ent->s.clientNum;

    // give the shooter a reward sound if they have made two railgun hits in a row
    if ( hits == 0 ) {
        // complete miss
        ent->client->accurateCount = 0;
    } else {
        // check for "impressive" reward sound
        ent->client->accurateCount += hits;
        if ( ent->client->accurateCount >= 2 ) {
            ent->client->accurateCount -= 2;
            ent->client->ps.persistant[PERS_IMPRESSIVE_COUNT]++;
            // add the sprite over the player's head
            ent->client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
            ent->client->ps.eFlags |= EF_AWARD_IMPRESSIVE;
            ent->client->rewardTime = level.time + REWARD_SPRITE_TIME;
        }
        ent->client->accuracy_hits++;
    }

}


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

GRAPPLING HOOK

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

void Weapon_GrapplingHook_Fire (gentity_t *ent)
{
    if (!ent->client->fireHeld && !ent->client->hook)
        fire_grapple (ent, muzzle, forward);

    ent->client->fireHeld = qtrue;
}

void Weapon_HookFree (gentity_t *ent)
{
    ent->parent->client->hook = NULL;
    ent->parent->client->ps.pm_flags &= ~PMF_GRAPPLE_PULL;
    G_FreeEntity( ent );
}

void Weapon_HookThink (gentity_t *ent)
{
    if (ent->enemy) {
        vec3_t v, oldorigin;

        VectorCopy(ent->r.currentOrigin, oldorigin);
        v[0] = ent->enemy->r.currentOrigin[0] + (ent->enemy->r.mins[0] + ent->enemy->r.maxs[0]) * 0.5;
        v[1] = ent->enemy->r.currentOrigin[1] + (ent->enemy->r.mins[1] + ent->enemy->r.maxs[1]) * 0.5;
        v[2] = ent->enemy->r.currentOrigin[2] + (ent->enemy->r.mins[2] + ent->enemy->r.maxs[2]) * 0.5;
        SnapVectorTowards( v, oldorigin );  // save net bandwidth

        G_SetOrigin( ent, v );
    }

    VectorCopy( ent->r.currentOrigin, ent->parent->client->ps.grapplePoint);
}

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

LIGHTNING GUN

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

void Weapon_LightningFire( gentity_t *ent ) {
    trace_t     tr;
    vec3_t      end;
#ifdef MISSIONPACK
    vec3_t impactpoint, bouncedir;
#endif
    gentity_t   *traceEnt, *tent;
    int         damage, i, passent;

    damage = 8 * s_quadFactor;

    passent = ent->s.number;
    for (i = 0; i < 10; i++) {
        VectorMA( muzzle, LIGHTNING_RANGE, forward, end );

        trap_Trace( &tr, muzzle, NULL, NULL, end, passent, MASK_SHOT );

#ifdef MISSIONPACK
        // if not the first trace (the lightning bounced of an invulnerability sphere)
        if (i) {
            // add bounced off lightning bolt temp entity
            // the first lightning bolt is a cgame only visual
            //
            tent = G_TempEntity( muzzle, EV_LIGHTNINGBOLT );
            VectorCopy( tr.endpos, end );
            SnapVector( end );
            VectorCopy( end, tent->s.origin2 );
        }
#endif
        if ( tr.entityNum == ENTITYNUM_NONE ) {
            return;
        }

        traceEnt = &g_entities[ tr.entityNum ];

        if ( traceEnt->takedamage) {
#ifdef MISSIONPACK
            if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
                if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
                    G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
                    VectorCopy( impactpoint, muzzle );
                    VectorSubtract( end, impactpoint, forward );
                    VectorNormalize(forward);
                    // the player can hit him/herself with the bounced lightning
                    passent = ENTITYNUM_NONE;
                }
                else {
                    VectorCopy( tr.endpos, muzzle );
                    passent = traceEnt->s.number;
                }
                continue;
            }
            else {
                G_Damage( traceEnt, ent, ent, forward, tr.endpos,
                    damage, 0, MOD_LIGHTNING);
            }
#else
                G_Damage( traceEnt, ent, ent, forward, tr.endpos,
                    damage, 0, MOD_LIGHTNING);
#endif
        }

        if ( traceEnt->takedamage && traceEnt->client ) {
            tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );
            tent->s.otherEntityNum = traceEnt->s.number;
            tent->s.eventParm = DirToByte( tr.plane.normal );
            tent->s.weapon = ent->s.weapon;
            if( LogAccuracyHit( traceEnt, ent ) ) {
                ent->client->accuracy_hits++;
            }
        } else if ( !( tr.surfaceFlags & SURF_NOIMPACT ) ) {
            tent = G_TempEntity( tr.endpos, EV_MISSILE_MISS );
            tent->s.eventParm = DirToByte( tr.plane.normal );
        }

        break;
    }
}

#ifdef MISSIONPACK
/*
======================================================================

NAILGUN

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

void Weapon_Nailgun_Fire (gentity_t *ent) {
    gentity_t   *m;
    int         count;

    for( count = 0; count < NUM_NAILSHOTS; count++ ) {
        m = fire_nail (ent, muzzle, forward, right, up );
        m->damage *= s_quadFactor;
        m->splashDamage *= s_quadFactor;
    }

//  VectorAdd( m->s.pos.trDelta, ent->client->ps.velocity, m->s.pos.trDelta );  // "real" physics
}


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

PROXIMITY MINE LAUNCHER

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

void weapon_proxlauncher_fire (gentity_t *ent) {
    gentity_t   *m;

    // extra vertical velocity
    forward[2] += 0.2f;
    VectorNormalize( forward );

    m = fire_prox (ent, muzzle, forward);
    m->damage *= s_quadFactor;
    m->splashDamage *= s_quadFactor;

//  VectorAdd( m->s.pos.trDelta, ent->client->ps.velocity, m->s.pos.trDelta );  // "real" physics
}

#endif

//======================================================================


/*
===============
LogAccuracyHit
===============
*/
qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker ) {
    if( !target->takedamage ) {
        return qfalse;
    }

    if ( target == attacker ) {
        return qfalse;
    }

    if( !target->client ) {
        return qfalse;
    }

    if( !attacker->client ) {
        return qfalse;
    }

    if( target->client->ps.stats[STAT_HEALTH] <= 0 ) {
        return qfalse;
    }

    if ( OnSameTeam( target, attacker ) ) {
        return qfalse;
    }

    return qtrue;
}


/*
===============
CalcMuzzlePoint

set muzzle location relative to pivoting eye
===============
*/
void CalcMuzzlePoint ( gentity_t *ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint ) {
    VectorCopy( ent->s.pos.trBase, muzzlePoint );
    muzzlePoint[2] += ent->client->ps.viewheight;
    VectorMA( muzzlePoint, 14, forward, muzzlePoint );
    // snap to integer coordinates for more efficient network bandwidth usage
    SnapVector( muzzlePoint );
}

/*
===============
CalcMuzzlePointOrigin

set muzzle location relative to pivoting eye
===============
*/
void CalcMuzzlePointOrigin ( gentity_t *ent, vec3_t origin, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint ) {
    VectorCopy( ent->s.pos.trBase, muzzlePoint );
    muzzlePoint[2] += ent->client->ps.viewheight;
    VectorMA( muzzlePoint, 14, forward, muzzlePoint );
    // snap to integer coordinates for more efficient network bandwidth usage
    SnapVector( muzzlePoint );
}



/*
===============
FireWeapon
===============
*/
void FireWeapon( gentity_t *ent ) {
    if (ent->client->ps.powerups[PW_QUAD] ) {
        s_quadFactor = g_quadfactor.value;
    } else {
        s_quadFactor = 1;
    }
#ifdef MISSIONPACK
    if( ent->client->persistantPowerup && ent->client->persistantPowerup->item && ent->client->persistantPowerup->item->giTag == PW_DOUBLER ) {
        s_quadFactor *= 2;
    }
#endif

    // track shots taken for accuracy tracking.  Grapple is not a weapon and gauntet is just not tracked
    if( ent->s.weapon != WP_GRAPPLING_HOOK && ent->s.weapon != WP_GAUNTLET ) {
#ifdef MISSIONPACK
        if( ent->s.weapon == WP_NAILGUN ) {
            ent->client->accuracy_shots += NUM_NAILSHOTS;
        } else {
            ent->client->accuracy_shots++;
        }
#else
        ent->client->accuracy_shots++;
#endif
    }

    // set aiming directions
    AngleVectors (ent->client->ps.viewangles, forward, right, up);

    CalcMuzzlePointOrigin ( ent, ent->client->oldOrigin, forward, right, up, muzzle );

    // fire the specific weapon
    switch( ent->s.weapon ) {
    case WP_GAUNTLET:
        Weapon_Gauntlet( ent );
        break;
    case WP_LIGHTNING:
        Weapon_LightningFire( ent );
        break;
    case WP_SHOTGUN:
        weapon_supershotgun_fire( ent );
        break;
    case WP_MACHINEGUN:
        if ( g_gametype.integer != GT_TEAM ) {
            Bullet_Fire( ent, MACHINEGUN_SPREAD, MACHINEGUN_DAMAGE );
        } else {
            Bullet_Fire( ent, MACHINEGUN_SPREAD, MACHINEGUN_TEAM_DAMAGE );
        }
        break;
    case WP_GRENADE_LAUNCHER:
        weapon_grenadelauncher_fire( ent );
        break;
    case WP_ROCKET_LAUNCHER:
        Weapon_RocketLauncher_Fire( ent );
        break;
    case WP_PLASMAGUN:
        Weapon_Plasmagun_Fire( ent );
        break;
    case WP_RAILGUN:
        weapon_railgun_fire( ent );
        break;
    case WP_BFG:
        BFG_Fire( ent );
        break;
    case WP_GRAPPLING_HOOK:
        Weapon_GrapplingHook_Fire( ent );
        break;
#ifdef MISSIONPACK
    case WP_NAILGUN:
        Weapon_Nailgun_Fire( ent );
        break;
    case WP_PROX_LAUNCHER:
        weapon_proxlauncher_fire( ent );
        break;
    case WP_CHAINGUN:
        Bullet_Fire( ent, CHAINGUN_SPREAD, MACHINEGUN_DAMAGE );
        break;
#endif
    default:
// FIXME        G_Error( "Bad ent->s.weapon" );
        break;
    }
}


#ifdef MISSIONPACK

/*
===============
KamikazeRadiusDamage
===============
*/
static void KamikazeRadiusDamage( vec3_t origin, gentity_t *attacker, float damage, float radius ) {
    float       dist;
    gentity_t   *ent;
    int         entityList[MAX_GENTITIES];
    int         numListedEntities;
    vec3_t      mins, maxs;
    vec3_t      v;
    vec3_t      dir;
    int         i, e;

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

    for ( i = 0 ; i < 3 ; i++ ) {
        mins[i] = origin[i] - radius;
        maxs[i] = origin[i] + radius;
    }

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

    for ( e = 0 ; e < numListedEntities ; e++ ) {
        ent = &g_entities[entityList[ e ]];

        if (!ent->takedamage) {
            continue;
        }

        // dont hit things we have already hit
        if( ent->kamikazeTime > level.time ) {
            continue;
        }

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

        dist = VectorLength( v );
        if ( dist >= radius ) {
            continue;
        }

//      if( CanDamage (ent, origin) ) {
            VectorSubtract (ent->r.currentOrigin, origin, dir);
            // push the center of mass higher than the origin so players
            // get knocked into the air more
            dir[2] += 24;
            G_Damage( ent, NULL, attacker, dir, origin, damage, DAMAGE_RADIUS|DAMAGE_NO_TEAM_PROTECTION, MOD_KAMIKAZE );
            ent->kamikazeTime = level.time + 3000;
//      }
    }
}

/*
===============
KamikazeShockWave
===============
*/
static void KamikazeShockWave( vec3_t origin, gentity_t *attacker, float damage, float push, float radius ) {
    float       dist;
    gentity_t   *ent;
    int         entityList[MAX_GENTITIES];
    int         numListedEntities;
    vec3_t      mins, maxs;
    vec3_t      v;
    vec3_t      dir;
    int         i, e;

    if ( radius < 1 )
        radius = 1;

    for ( i = 0 ; i < 3 ; i++ ) {
        mins[i] = origin[i] - radius;
        maxs[i] = origin[i] + radius;
    }

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

    for ( e = 0 ; e < numListedEntities ; e++ ) {
        ent = &g_entities[entityList[ e ]];

        // dont hit things we have already hit
        if( ent->kamikazeShockTime > level.time ) {
            continue;
        }

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

        dist = VectorLength( v );
        if ( dist >= radius ) {
            continue;
        }

//      if( CanDamage (ent, origin) ) {
            VectorSubtract (ent->r.currentOrigin, origin, dir);
            dir[2] += 24;
            G_Damage( ent, NULL, attacker, dir, origin, damage, DAMAGE_RADIUS|DAMAGE_NO_TEAM_PROTECTION, MOD_KAMIKAZE );
            //
            dir[2] = 0;
            VectorNormalize(dir);
            if ( ent->client ) {
                ent->client->ps.velocity[0] = dir[0] * push;
                ent->client->ps.velocity[1] = dir[1] * push;
                ent->client->ps.velocity[2] = 100;
            }
            ent->kamikazeShockTime = level.time + 3000;
//      }
    }
}

/*
===============
KamikazeDamage
===============
*/
static void KamikazeDamage( gentity_t *self ) {
    int i;
    float t;
    gentity_t *ent;
    vec3_t newangles;

    self->count += 100;

    if (self->count >= KAMI_SHOCKWAVE_STARTTIME) {
        // shockwave push back
        t = self->count - KAMI_SHOCKWAVE_STARTTIME;
        KamikazeShockWave(self->s.pos.trBase, self->activator, 25, 400, (int) (float) t * KAMI_SHOCKWAVE_MAXRADIUS / (KAMI_SHOCKWAVE_ENDTIME - KAMI_SHOCKWAVE_STARTTIME) );
    }
    //
    if (self->count >= KAMI_EXPLODE_STARTTIME) {
        // do our damage
        t = self->count - KAMI_EXPLODE_STARTTIME;
        KamikazeRadiusDamage( self->s.pos.trBase, self->activator, 400, (int) (float) t * KAMI_BOOMSPHERE_MAXRADIUS / (KAMI_IMPLODE_STARTTIME - KAMI_EXPLODE_STARTTIME) );
    }

    // either cycle or kill self
    if( self->count >= KAMI_SHOCKWAVE_ENDTIME ) {
        G_FreeEntity( self );
        return;
    }
    self->nextthink = level.time + 100;

    // add earth quake effect
    newangles[0] = crandom() * 2;
    newangles[1] = crandom() * 2;
    newangles[2] = 0;
    for (i = 0; i < MAX_CLIENTS; i++)
    {
        ent = &g_entities[i];
        if (!ent->inuse)
            continue;
        if (!ent->client)
            continue;

        if (ent->client->ps.groundEntityNum != ENTITYNUM_NONE) {
            ent->client->ps.velocity[0] += crandom() * 120;
            ent->client->ps.velocity[1] += crandom() * 120;
            ent->client->ps.velocity[2] = 30 + random() * 25;
        }

        ent->client->ps.delta_angles[0] += ANGLE2SHORT(newangles[0] - self->movedir[0]);
        ent->client->ps.delta_angles[1] += ANGLE2SHORT(newangles[1] - self->movedir[1]);
        ent->client->ps.delta_angles[2] += ANGLE2SHORT(newangles[2] - self->movedir[2]);
    }
    VectorCopy(newangles, self->movedir);
}

/*
===============
G_StartKamikaze
===============
*/
void G_StartKamikaze( gentity_t *ent ) {
    gentity_t   *explosion;
    gentity_t   *te;
    vec3_t      snapped;

    // start up the explosion logic
    explosion = G_Spawn();

    explosion->s.eType = ET_EVENTS + EV_KAMIKAZE;
    explosion->eventTime = level.time;

    if ( ent->client ) {
        VectorCopy( ent->s.pos.trBase, snapped );
    }
    else {
        VectorCopy( ent->activator->s.pos.trBase, snapped );
    }
    SnapVector( snapped );      // save network bandwidth
    G_SetOrigin( explosion, snapped );

    explosion->classname = "kamikaze";
    explosion->s.pos.trType = TR_STATIONARY;

    explosion->kamikazeTime = level.time;

    explosion->think = KamikazeDamage;
    explosion->nextthink = level.time + 100;
    explosion->count = 0;
    VectorClear(explosion->movedir);

    trap_LinkEntity( explosion );

    if (ent->client) {
        //
        explosion->activator = ent;
        //
        ent->s.eFlags &= ~EF_KAMIKAZE;
        // nuke the guy that used it
        G_Damage( ent, ent, ent, NULL, NULL, 100000, DAMAGE_NO_PROTECTION, MOD_KAMIKAZE );
    }
    else {
        if ( !strcmp(ent->activator->classname, "bodyque") ) {
            explosion->activator = &g_entities[ent->activator->r.ownerNum];
        }
        else {
            explosion->activator = ent->activator;
        }
    }

    // play global sound at all clients
    te = G_TempEntity(snapped, EV_GLOBAL_TEAM_SOUND );
    te->r.svFlags |= SVF_BROADCAST;
    te->s.eventParm = GTS_KAMIKAZE;
}
#endif

---