p_weapon.c File Reference

#include "g_local.h"
#include "m_player.h"

Go to the source code of this file.

Macros
#define	FRAME_FIRE_FIRST   (FRAME_ACTIVATE_LAST + 1)
#define	FRAME_IDLE_FIRST   (FRAME_FIRE_LAST + 1)
#define	FRAME_DEACTIVATE_FIRST   (FRAME_IDLE_LAST + 1)
#define	GRENADE_TIMER   3.0
#define	GRENADE_MINSPEED   400
#define	GRENADE_MAXSPEED   800

Functions
void	weapon_grenade_fire (edict_t *ent, qboolean held)
static void	P_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
void	PlayerNoise (edict_t *who, vec3_t where, int type)
qboolean	Pickup_Weapon (edict_t *ent, edict_t *other)
void	ChangeWeapon (edict_t *ent)
void	NoAmmoWeaponChange (edict_t *ent)
void	Think_Weapon (edict_t *ent)
void	Use_Weapon (edict_t *ent, gitem_t *item)
void	Drop_Weapon (edict_t *ent, gitem_t *item)
void	Weapon_Generic (edict_t *ent, int FRAME_ACTIVATE_LAST, int FRAME_FIRE_LAST, int FRAME_IDLE_LAST, int FRAME_DEACTIVATE_LAST, int *pause_frames, int *fire_frames, void(*fire)(edict_t *ent))
void	Weapon_Grenade (edict_t *ent)
void	weapon_grenadelauncher_fire (edict_t *ent)
void	Weapon_GrenadeLauncher (edict_t *ent)
void	Weapon_RocketLauncher_Fire (edict_t *ent)
void	Weapon_RocketLauncher (edict_t *ent)
void	Blaster_Fire (edict_t *ent, vec3_t g_offset, int damage, qboolean hyper, int effect)
void	Weapon_Blaster_Fire (edict_t *ent)
void	Weapon_Blaster (edict_t *ent)
void	Weapon_HyperBlaster_Fire (edict_t *ent)
void	Weapon_HyperBlaster (edict_t *ent)
void	Machinegun_Fire (edict_t *ent)
void	Weapon_Machinegun (edict_t *ent)
void	Chaingun_Fire (edict_t *ent)
void	Weapon_Chaingun (edict_t *ent)
void	weapon_shotgun_fire (edict_t *ent)
void	Weapon_Shotgun (edict_t *ent)
void	weapon_supershotgun_fire (edict_t *ent)
void	Weapon_SuperShotgun (edict_t *ent)
void	weapon_railgun_fire (edict_t *ent)
void	Weapon_Railgun (edict_t *ent)
void	weapon_bfg_fire (edict_t *ent)
void	Weapon_BFG (edict_t *ent)
void	fire_flaregun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius)
void	weapon_flaregun_fire (edict_t *ent)
void	Weapon_FlareGun (edict_t *ent)

Variables
static qboolean	is_quad
static byte	is_silenced

Macro Definition Documentation

FRAME_DEACTIVATE_FIRST

#define FRAME_DEACTIVATE_FIRST   (FRAME_IDLE_LAST + 1)

Definition at line 350 of file p_weapon.c.

FRAME_FIRE_FIRST

#define FRAME_FIRE_FIRST   (FRAME_ACTIVATE_LAST + 1)

Definition at line 348 of file p_weapon.c.

FRAME_IDLE_FIRST

#define FRAME_IDLE_FIRST   (FRAME_FIRE_LAST + 1)

Definition at line 349 of file p_weapon.c.

GRENADE_MAXSPEED

#define GRENADE_MAXSPEED   800

Definition at line 483 of file p_weapon.c.

GRENADE_MINSPEED

#define GRENADE_MINSPEED   400

Definition at line 482 of file p_weapon.c.

GRENADE_TIMER

#define GRENADE_TIMER   3.0

Definition at line 481 of file p_weapon.c.

Function Documentation

Blaster_Fire()

void Blaster_Fire	(	edict_t *	ent,
		vec3_t	g_offset,
		int	damage,
		qboolean	hyper,
		int	effect
	)

Definition at line 731 of file p_weapon.c.

{
    vec3_t  forward, right;
    vec3_t  start;
    vec3_t  offset;
 
    if (is_quad)
        damage *= 4;
    AngleVectors(ent->client->v_angle, forward, right, NULL);
    VectorSet(offset, 24, 8, ent->viewheight - 8);
    VectorAdd(offset, g_offset, offset);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
    VectorScale(forward, -2, ent->client->kick_origin);
    ent->client->kick_angles[0] = -1;
 
    fire_blaster(ent, start, forward, damage, 1000, effect, hyper);
 
    // send muzzle flash
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    if (hyper)
        gi.WriteByte(MZ_HYPERBLASTER | is_silenced);
    else
        gi.WriteByte(MZ_BLASTER | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    PlayerNoise(ent, start, PNOISE_WEAPON);
}

Referenced by Weapon_Blaster_Fire(), and Weapon_HyperBlaster_Fire().

Chaingun_Fire()

void Chaingun_Fire

(

edict_t *

ent

)

Definition at line 942 of file p_weapon.c.

{
    int         i;
    int         shots;
    vec3_t      start;
    vec3_t      forward, right, up;
    float       r, u;
    vec3_t      offset;
    int         damage;
    int         kick = 2;
 
    if (deathmatch->value)
        damage = 6;
    else
        damage = 8;
 
    if (ent->client->ps.gunframe == 5)
        gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnu1a.wav"), 1, ATTN_IDLE, 0);
 
    if ((ent->client->ps.gunframe == 14) && !(ent->client->buttons & BUTTON_ATTACK)) {
        ent->client->ps.gunframe = 32;
        ent->client->weapon_sound = 0;
        return;
    } else if ((ent->client->ps.gunframe == 21) && (ent->client->buttons & BUTTON_ATTACK)
               && ent->client->pers.inventory[ent->client->ammo_index]) {
        ent->client->ps.gunframe = 15;
    } else {
        ent->client->ps.gunframe++;
    }
 
    if (ent->client->ps.gunframe == 22) {
        ent->client->weapon_sound = 0;
        gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnd1a.wav"), 1, ATTN_IDLE, 0);
    } else {
        ent->client->weapon_sound = gi.soundindex("weapons/chngnl1a.wav");
    }
 
    ent->client->anim_priority = ANIM_ATTACK;
    if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
        ent->s.frame = FRAME_crattak1 - (ent->client->ps.gunframe & 1);
        ent->client->anim_end = FRAME_crattak9;
    } else {
        ent->s.frame = FRAME_attack1 - (ent->client->ps.gunframe & 1);
        ent->client->anim_end = FRAME_attack8;
    }
 
    if (ent->client->ps.gunframe <= 9)
        shots = 1;
    else if (ent->client->ps.gunframe <= 14) {
        if (ent->client->buttons & BUTTON_ATTACK)
            shots = 2;
        else
            shots = 1;
    } else
        shots = 3;
 
    if (ent->client->pers.inventory[ent->client->ammo_index] < shots)
        shots = ent->client->pers.inventory[ent->client->ammo_index];
 
    if (!shots) {
        if (level.time >= ent->pain_debounce_time) {
            gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
            ent->pain_debounce_time = level.time + 1;
        }
        NoAmmoWeaponChange(ent);
        return;
    }
 
    if (is_quad) {
        damage *= 4;
        kick *= 4;
    }
 
    for (i = 0 ; i < 3 ; i++) {
        ent->client->kick_origin[i] = crandom() * 0.35;
        ent->client->kick_angles[i] = crandom() * 0.7;
    }
 
    for (i = 0 ; i < shots ; i++) {
        // get start / end positions
        AngleVectors(ent->client->v_angle, forward, right, up);
        r = 7 + crandom() * 4;
        u = crandom() * 4;
        VectorSet(offset, 0, r, u + ent->viewheight - 8);
        P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
        fire_bullet(ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_CHAINGUN);
    }
 
    // send muzzle flash
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte((MZ_CHAINGUN1 + shots - 1) | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index] -= shots;
}

Referenced by Weapon_Chaingun().

ChangeWeapon()

void ChangeWeapon

(

edict_t *

ent

)

Definition at line 162 of file p_weapon.c.

{
    int i;
 
    if (ent->client->grenade_time) {
        ent->client->grenade_time = level.time;
        ent->client->weapon_sound = 0;
        weapon_grenade_fire(ent, qfalse);
        ent->client->grenade_time = 0;
    }
 
    ent->client->pers.lastweapon = ent->client->pers.weapon;
    ent->client->pers.weapon = ent->client->newweapon;
    ent->client->newweapon = NULL;
    ent->client->machinegun_shots = 0;
 
    // set visible model
    if (ent->s.modelindex == 255) {
        if (ent->client->pers.weapon)
            i = ((ent->client->pers.weapon->weapmodel & 0xff) << 8);
        else
            i = 0;
        ent->s.skinnum = (ent - g_edicts - 1) | i;
    }
 
    if (ent->client->pers.weapon && ent->client->pers.weapon->ammo)
        ent->client->ammo_index = ITEM_INDEX(FindItem(ent->client->pers.weapon->ammo));
    else
        ent->client->ammo_index = 0;
 
    if (!ent->client->pers.weapon) {
        // dead
        ent->client->ps.gunindex = 0;
        return;
    }
 
    ent->client->weaponstate = WEAPON_ACTIVATING;
    ent->client->ps.gunframe = 0;
    ent->client->ps.gunindex = gi.modelindex(ent->client->pers.weapon->view_model);
 
    ent->client->anim_priority = ANIM_PAIN;
    if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
        ent->s.frame = FRAME_crpain1;
        ent->client->anim_end = FRAME_crpain4;
    } else {
        ent->s.frame = FRAME_pain301;
        ent->client->anim_end = FRAME_pain304;
 
    }
}

Referenced by PutClientInServer(), Think_Weapon(), Weapon_Generic(), and Weapon_Grenade().

Drop_Weapon()

void Drop_Weapon	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 322 of file p_weapon.c.

{
    int     index;
 
    if ((int)(dmflags->value) & DF_WEAPONS_STAY)
        return;
 
    index = ITEM_INDEX(item);
    // see if we're already using it
    if (((item == ent->client->pers.weapon) || (item == ent->client->newweapon)) && (ent->client->pers.inventory[index] == 1)) {
        gi.cprintf(ent, PRINT_HIGH, "Can't drop current weapon\n");
        return;
    }
 
    Drop_Item(ent, item);
    ent->client->pers.inventory[index]--;
}

fire_flaregun()

void fire_flaregun	(	edict_t *	self,
		vec3_t	start,
		vec3_t	aimdir,
		int	damage,
		int	speed,
		float	timer,
		float	damage_radius
	)

Definition at line 956 of file g_weapon.c.

{
    edict_t *flare;
    vec3_t dir;
    vec3_t forward, right, up;
 
    vectoangles(aimdir, dir);
    AngleVectors(dir, forward, right, up);
 
    flare = G_Spawn();
    VectorCopy(start, flare->s.origin);
    VectorScale(aimdir, speed, flare->velocity);
    VectorSet(flare->avelocity, 300, 300, 300);
    flare->movetype = MOVETYPE_BOUNCE;
    flare->clipmask = MASK_SHOT;
    flare->solid = SOLID_BBOX;
 
    const float size = 4;
    VectorSet(flare->mins, -size, -size, -size);
    VectorSet(flare->maxs, size, size, size);
 
    flare->s.modelindex = gi.modelindex("models/objects/flare/tris.md2");
    flare->owner = self;
    flare->touch = flare_touch;
    flare->nextthink = FRAMETIME;
    flare->think = flare_think;
    flare->radius_dmg = damage;
    flare->dmg_radius = damage_radius;
    flare->classname = "flare";
    flare->timestamp = level.time + 15.0; //live for 15 seconds 
    gi.linkentity(flare);
}

Referenced by weapon_flaregun_fire().

Machinegun_Fire()

void Machinegun_Fire

(

edict_t *

ent

)

Definition at line 857 of file p_weapon.c.

{
    int i;
    vec3_t      start;
    vec3_t      forward, right;
    vec3_t      angles;
    int         damage = 8;
    int         kick = 2;
    vec3_t      offset;
 
    if (!(ent->client->buttons & BUTTON_ATTACK)) {
        ent->client->machinegun_shots = 0;
        ent->client->ps.gunframe++;
        return;
    }
 
    if (ent->client->ps.gunframe == 5)
        ent->client->ps.gunframe = 4;
    else
        ent->client->ps.gunframe = 5;
 
    if (ent->client->pers.inventory[ent->client->ammo_index] < 1) {
        ent->client->ps.gunframe = 6;
        if (level.time >= ent->pain_debounce_time) {
            gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
            ent->pain_debounce_time = level.time + 1;
        }
        NoAmmoWeaponChange(ent);
        return;
    }
 
    if (is_quad) {
        damage *= 4;
        kick *= 4;
    }
 
    for (i = 1 ; i < 3 ; i++) {
        ent->client->kick_origin[i] = crandom() * 0.35;
        ent->client->kick_angles[i] = crandom() * 0.7;
    }
    ent->client->kick_origin[0] = crandom() * 0.35;
    ent->client->kick_angles[0] = ent->client->machinegun_shots * -1.5;
 
    // raise the gun as it is firing
    if (!deathmatch->value) {
        ent->client->machinegun_shots++;
        if (ent->client->machinegun_shots > 9)
            ent->client->machinegun_shots = 9;
    }
 
    // get start / end positions
    VectorAdd(ent->client->v_angle, ent->client->kick_angles, angles);
    AngleVectors(angles, forward, right, NULL);
    VectorSet(offset, 0, 8, ent->viewheight - 8);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
    fire_bullet(ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN);
 
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte(MZ_MACHINEGUN | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index]--;
 
    ent->client->anim_priority = ANIM_ATTACK;
    if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
        ent->s.frame = FRAME_crattak1 - (int)(random() + 0.25);
        ent->client->anim_end = FRAME_crattak9;
    } else {
        ent->s.frame = FRAME_attack1 - (int)(random() + 0.25);
        ent->client->anim_end = FRAME_attack8;
    }
}

Referenced by Weapon_Machinegun().

NoAmmoWeaponChange()

void NoAmmoWeaponChange

(

edict_t *

ent

)

Definition at line 218 of file p_weapon.c.

{
    if (ent->client->pers.inventory[ITEM_INDEX(FindItem("slugs"))]
        &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("railgun"))]) {
        ent->client->newweapon = FindItem("railgun");
        return;
    }
    if (ent->client->pers.inventory[ITEM_INDEX(FindItem("cells"))]
        &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("hyperblaster"))]) {
        ent->client->newweapon = FindItem("hyperblaster");
        return;
    }
    if (ent->client->pers.inventory[ITEM_INDEX(FindItem("bullets"))]
        &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("chaingun"))]) {
        ent->client->newweapon = FindItem("chaingun");
        return;
    }
    if (ent->client->pers.inventory[ITEM_INDEX(FindItem("bullets"))]
        &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("machinegun"))]) {
        ent->client->newweapon = FindItem("machinegun");
        return;
    }
    if (ent->client->pers.inventory[ITEM_INDEX(FindItem("shells"))] > 1
        &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("super shotgun"))]) {
        ent->client->newweapon = FindItem("super shotgun");
        return;
    }
    if (ent->client->pers.inventory[ITEM_INDEX(FindItem("shells"))]
        &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("shotgun"))]) {
        ent->client->newweapon = FindItem("shotgun");
        return;
    }
    ent->client->newweapon = FindItem("blaster");
}

Referenced by Chaingun_Fire(), Machinegun_Fire(), Weapon_Generic(), Weapon_Grenade(), and Weapon_HyperBlaster_Fire().

P_ProjectSource()

static void P_ProjectSource ( gclient_t *  client, vec3_t  point, vec3_t  distance, vec3_t  forward, vec3_t  right, vec3_t  result  )

static

Definition at line 31 of file p_weapon.c.

{
    vec3_t  _distance;
 
    VectorCopy(distance, _distance);
    if (client->pers.hand == LEFT_HANDED)
        _distance[1] *= -1;
    else if (client->pers.hand == CENTER_HANDED)
        _distance[1] = 0;
    G_ProjectSource(point, _distance, forward, right, result);
}

Referenced by Blaster_Fire(), Chaingun_Fire(), Machinegun_Fire(), weapon_bfg_fire(), weapon_flaregun_fire(), weapon_grenade_fire(), weapon_grenadelauncher_fire(), weapon_railgun_fire(), Weapon_RocketLauncher_Fire(), weapon_shotgun_fire(), and weapon_supershotgun_fire().

Pickup_Weapon()

qboolean Pickup_Weapon	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 110 of file p_weapon.c.

{
    int         index;
    gitem_t     *ammo;
 
    index = ITEM_INDEX(ent->item);
 
    if ((((int)(dmflags->value) & DF_WEAPONS_STAY) || coop->value)
        && other->client->pers.inventory[index]) {
        if (!(ent->spawnflags & (DROPPED_ITEM | DROPPED_PLAYER_ITEM)))
            return qfalse;   // leave the weapon for others to pickup
    }
 
    other->client->pers.inventory[index]++;
 
    if (!(ent->spawnflags & DROPPED_ITEM)) {
        // give them some ammo with it
        ammo = FindItem(ent->item->ammo);
        if ((int)dmflags->value & DF_INFINITE_AMMO)
            Add_Ammo(other, ammo, 1000);
        else
            Add_Ammo(other, ammo, ammo->quantity);
 
        if (!(ent->spawnflags & DROPPED_PLAYER_ITEM)) {
            if (deathmatch->value) {
                if ((int)(dmflags->value) & DF_WEAPONS_STAY)
                    ent->flags |= FL_RESPAWN;
                else
                    SetRespawn(ent, 30);
            }
            if (coop->value)
                ent->flags |= FL_RESPAWN;
        }
    }
 
    if (other->client->pers.weapon != ent->item &&
        (other->client->pers.inventory[index] == 1) &&
        (!deathmatch->value || other->client->pers.weapon == FindItem("blaster")))
        other->client->newweapon = ent->item;
 
    return qtrue;
}

PlayerNoise()

void PlayerNoise	(	edict_t *	who,
		vec3_t	where,
		int	type
	)

Definition at line 56 of file p_weapon.c.

{
    edict_t     *noise;
 
    if (type == PNOISE_WEAPON) {
        if (who->client->silencer_shots) {
            who->client->silencer_shots--;
            return;
        }
    }
 
    if (deathmatch->value)
        return;
 
    if (who->flags & FL_NOTARGET)
        return;
 
 
    if (!who->mynoise) {
        noise = G_Spawn();
        noise->classname = "player_noise";
        VectorSet(noise->mins, -8, -8, -8);
        VectorSet(noise->maxs, 8, 8, 8);
        noise->owner = who;
        noise->svflags = SVF_NOCLIENT;
        who->mynoise = noise;
 
        noise = G_Spawn();
        noise->classname = "player_noise";
        VectorSet(noise->mins, -8, -8, -8);
        VectorSet(noise->maxs, 8, 8, 8);
        noise->owner = who;
        noise->svflags = SVF_NOCLIENT;
        who->mynoise2 = noise;
    }
 
    if (type == PNOISE_SELF || type == PNOISE_WEAPON) {
        noise = who->mynoise;
        level.sound_entity = noise;
        level.sound_entity_framenum = level.framenum;
    } else { // type == PNOISE_IMPACT
        noise = who->mynoise2;
        level.sound2_entity = noise;
        level.sound2_entity_framenum = level.framenum;
    }
 
    VectorCopy(where, noise->s.origin);
    VectorSubtract(where, noise->maxs, noise->absmin);
    VectorAdd(where, noise->maxs, noise->absmax);
    noise->teleport_time = level.time;
    gi.linkentity(noise);
}

Referenced by bfg_touch(), Blaster_Fire(), blaster_touch(), Chaingun_Fire(), ClientThink(), fire_lead(), fire_rail(), Grenade_Explode(), Machinegun_Fire(), P_WorldEffects(), rocket_touch(), weapon_bfg_fire(), weapon_flaregun_fire(), weapon_grenadelauncher_fire(), weapon_railgun_fire(), Weapon_RocketLauncher_Fire(), weapon_shotgun_fire(), and weapon_supershotgun_fire().

Think_Weapon()

void Think_Weapon

(

edict_t *

ent

)

Definition at line 260 of file p_weapon.c.

{
    // if just died, put the weapon away
    if (ent->health < 1) {
        ent->client->newweapon = NULL;
        ChangeWeapon(ent);
    }
 
    // call active weapon think routine
    if (ent->client->pers.weapon && ent->client->pers.weapon->weaponthink) {
        is_quad = (ent->client->quad_framenum > level.framenum);
        if (ent->client->silencer_shots)
            is_silenced = MZ_SILENCED;
        else
            is_silenced = 0;
        ent->client->pers.weapon->weaponthink(ent);
    }
}

Referenced by ClientBeginServerFrame(), and ClientThink().

Use_Weapon()

void Use_Weapon	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 287 of file p_weapon.c.

{
    int         ammo_index;
    gitem_t     *ammo_item;
 
    // see if we're already using it
    if (item == ent->client->pers.weapon)
        return;
 
    if (item->ammo && !g_select_empty->value && !(item->flags & IT_AMMO)) {
        ammo_item = FindItem(item->ammo);
        ammo_index = ITEM_INDEX(ammo_item);
 
        if (!ent->client->pers.inventory[ammo_index]) {
            gi.cprintf(ent, PRINT_HIGH, "No %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
            return;
        }
 
        if (ent->client->pers.inventory[ammo_index] < item->quantity) {
            gi.cprintf(ent, PRINT_HIGH, "Not enough %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
            return;
        }
    }
 
    // change to this weapon when down
    ent->client->newweapon = item;
}

Weapon_BFG()

void Weapon_BFG

(

edict_t *

ent

)

Definition at line 1294 of file p_weapon.c.

{
    static int  pause_frames[]  = {39, 45, 50, 55, 0};
    static int  fire_frames[]   = {9, 17, 0};
 
    Weapon_Generic(ent, 8, 32, 55, 58, pause_frames, fire_frames, weapon_bfg_fire);
}

weapon_bfg_fire()

void weapon_bfg_fire

(

edict_t *

ent

)

Definition at line 1238 of file p_weapon.c.

{
    vec3_t  offset, start;
    vec3_t  forward, right;
    int     damage;
    float   damage_radius = 1000;
 
    if (deathmatch->value)
        damage = 200;
    else
        damage = 500;
 
    if (ent->client->ps.gunframe == 9) {
        // send muzzle flash
        gi.WriteByte(svc_muzzleflash);
        gi.WriteShort(ent - g_edicts);
        gi.WriteByte(MZ_BFG | is_silenced);
        gi.multicast(ent->s.origin, MULTICAST_PVS);
 
        ent->client->ps.gunframe++;
 
        PlayerNoise(ent, start, PNOISE_WEAPON);
        return;
    }
 
    // cells can go down during windup (from power armor hits), so
    // check again and abort firing if we don't have enough now
    if (ent->client->pers.inventory[ent->client->ammo_index] < 50) {
        ent->client->ps.gunframe++;
        return;
    }
 
    if (is_quad)
        damage *= 4;
 
    AngleVectors(ent->client->v_angle, forward, right, NULL);
 
    VectorScale(forward, -2, ent->client->kick_origin);
 
    // make a big pitch kick with an inverse fall
    ent->client->v_dmg_pitch = -40;
    ent->client->v_dmg_roll = crandom() * 8;
    ent->client->v_dmg_time = level.time + DAMAGE_TIME;
 
    VectorSet(offset, 8, 8, ent->viewheight - 8);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
    fire_bfg(ent, start, forward, damage, 400, damage_radius);
 
    ent->client->ps.gunframe++;
 
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index] -= 50;
}

Referenced by Weapon_BFG().

Weapon_Blaster()

void Weapon_Blaster

(

edict_t *

ent

)

Definition at line 774 of file p_weapon.c.

{
    static int  pause_frames[]  = {19, 32, 0};
    static int  fire_frames[]   = {5, 0};
 
    Weapon_Generic(ent, 4, 8, 52, 55, pause_frames, fire_frames, Weapon_Blaster_Fire);
}

Weapon_Blaster_Fire()

void Weapon_Blaster_Fire

(

edict_t *

ent

)

Definition at line 762 of file p_weapon.c.

{
    int     damage;
 
    if (deathmatch->value)
        damage = 15;
    else
        damage = 10;
    Blaster_Fire(ent, vec3_origin, damage, qfalse, EF_BLASTER);
    ent->client->ps.gunframe++;
}

Referenced by Weapon_Blaster().

Weapon_Chaingun()

void Weapon_Chaingun

(

edict_t *

ent

)

Definition at line 1044 of file p_weapon.c.

{
    static int  pause_frames[]  = {38, 43, 51, 61, 0};
    static int  fire_frames[]   = {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 0};
 
    Weapon_Generic(ent, 4, 31, 61, 64, pause_frames, fire_frames, Chaingun_Fire);
}

Weapon_FlareGun()

void Weapon_FlareGun

(

edict_t *

ent

)

Definition at line 1364 of file p_weapon.c.

{
    static int pause_frames[] = { 39, 45, 50, 53, 0 };
    static int fire_frames[] = { 9, 17, 0 };
    // Check the top of p_weapon.c for definition of Weapon_Generic 
    // 
    Weapon_Generic(ent, 8, 13, 49, 53,
        pause_frames,
        fire_frames,
        weapon_flaregun_fire);
}

weapon_flaregun_fire()

void weapon_flaregun_fire

(

edict_t *

ent

)

Definition at line 1319 of file p_weapon.c.

{
    vec3_t offset;
    vec3_t forward, right;
    vec3_t start;
 
    // Setup the parameters used in the call to fire_flaregun() 
     // 
    VectorSet(offset, 8, 8, ent->viewheight - 8);
    AngleVectors(ent->client->v_angle, forward, right, NULL);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
    VectorScale(forward, -2, ent->client->kick_origin);
    ent->client->kick_angles[0] = -1;
 
    // Make the flaregun actually shoot the flare 
     // 
    fire_flaregun(ent, start, forward, 0, 800, 25, 0);
 
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte(MZ_FLARE | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    // Bump the gunframe 
     // 
    ent->client->ps.gunframe++;
 
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    // Subtract one cell from our inventory 
     // 
    ent->client->pers.inventory[ent->client->ammo_index]--;
}

Referenced by Weapon_FlareGun().

Weapon_Generic()

void Weapon_Generic	(	edict_t *	ent,
		int	FRAME_ACTIVATE_LAST,
		int	FRAME_FIRE_LAST,
		int	FRAME_IDLE_LAST,
		int	FRAME_DEACTIVATE_LAST,
		int *	pause_frames,
		int *	fire_frames,
		void(*)(edict_t *ent)	fire
	)

Definition at line 352 of file p_weapon.c.

{
    int     n;
 
    if (ent->deadflag || ent->s.modelindex != 255) { // VWep animations screw up corpses
        return;
    }
 
    if (ent->client->weaponstate == WEAPON_DROPPING) {
        if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST) {
            ChangeWeapon(ent);
            return;
        } else if ((FRAME_DEACTIVATE_LAST - ent->client->ps.gunframe) == 4) {
            ent->client->anim_priority = ANIM_REVERSE;
            if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
                ent->s.frame = FRAME_crpain4 + 1;
                ent->client->anim_end = FRAME_crpain1;
            } else {
                ent->s.frame = FRAME_pain304 + 1;
                ent->client->anim_end = FRAME_pain301;
 
            }
        }
 
        ent->client->ps.gunframe++;
        return;
    }
 
    if (ent->client->weaponstate == WEAPON_ACTIVATING) {
        if (ent->client->ps.gunframe == FRAME_ACTIVATE_LAST) {
            ent->client->weaponstate = WEAPON_READY;
            ent->client->ps.gunframe = FRAME_IDLE_FIRST;
            return;
        }
 
        ent->client->ps.gunframe++;
        return;
    }
 
    if ((ent->client->newweapon) && (ent->client->weaponstate != WEAPON_FIRING)) {
        ent->client->weaponstate = WEAPON_DROPPING;
        ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
 
        if ((FRAME_DEACTIVATE_LAST - FRAME_DEACTIVATE_FIRST) < 4) {
            ent->client->anim_priority = ANIM_REVERSE;
            if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
                ent->s.frame = FRAME_crpain4 + 1;
                ent->client->anim_end = FRAME_crpain1;
            } else {
                ent->s.frame = FRAME_pain304 + 1;
                ent->client->anim_end = FRAME_pain301;
 
            }
        }
        return;
    }
 
    if (ent->client->weaponstate == WEAPON_READY) {
        if (((ent->client->latched_buttons | ent->client->buttons) & BUTTON_ATTACK)) {
            ent->client->latched_buttons &= ~BUTTON_ATTACK;
            if ((!ent->client->ammo_index) ||
                (ent->client->pers.inventory[ent->client->ammo_index] >= ent->client->pers.weapon->quantity)) {
                ent->client->ps.gunframe = FRAME_FIRE_FIRST;
                ent->client->weaponstate = WEAPON_FIRING;
 
                // start the animation
                ent->client->anim_priority = ANIM_ATTACK;
                if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
                    ent->s.frame = FRAME_crattak1 - 1;
                    ent->client->anim_end = FRAME_crattak9;
                } else {
                    ent->s.frame = FRAME_attack1 - 1;
                    ent->client->anim_end = FRAME_attack8;
                }
            } else {
                if (level.time >= ent->pain_debounce_time) {
                    gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                    ent->pain_debounce_time = level.time + 1;
                }
                NoAmmoWeaponChange(ent);
            }
        } else {
            if (ent->client->ps.gunframe == FRAME_IDLE_LAST) {
                ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                return;
            }
 
            if (pause_frames) {
                for (n = 0; pause_frames[n]; n++) {
                    if (ent->client->ps.gunframe == pause_frames[n]) {
                        if (rand() & 15)
                            return;
                    }
                }
            }
 
            ent->client->ps.gunframe++;
            return;
        }
    }
 
    if (ent->client->weaponstate == WEAPON_FIRING) {
        for (n = 0; fire_frames[n]; n++) {
            if (ent->client->ps.gunframe == fire_frames[n]) {
                if (ent->client->quad_framenum > level.framenum)
                    gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
 
                fire(ent);
                break;
            }
        }
 
        if (!fire_frames[n])
            ent->client->ps.gunframe++;
 
        if (ent->client->ps.gunframe == FRAME_IDLE_FIRST + 1)
            ent->client->weaponstate = WEAPON_READY;
    }
}

Referenced by Weapon_BFG(), Weapon_Blaster(), Weapon_Chaingun(), Weapon_FlareGun(), Weapon_GrenadeLauncher(), Weapon_HyperBlaster(), Weapon_Machinegun(), Weapon_Railgun(), Weapon_RocketLauncher(), Weapon_Shotgun(), and Weapon_SuperShotgun().

Weapon_Grenade()

void Weapon_Grenade

(

edict_t *

ent

)

Definition at line 530 of file p_weapon.c.

{
    if ((ent->client->newweapon) && (ent->client->weaponstate == WEAPON_READY)) {
        ChangeWeapon(ent);
        return;
    }
 
    if (ent->client->weaponstate == WEAPON_ACTIVATING) {
        ent->client->weaponstate = WEAPON_READY;
        ent->client->ps.gunframe = 16;
        return;
    }
 
    if (ent->client->weaponstate == WEAPON_READY) {
        if (((ent->client->latched_buttons | ent->client->buttons) & BUTTON_ATTACK)) {
            ent->client->latched_buttons &= ~BUTTON_ATTACK;
            if (ent->client->pers.inventory[ent->client->ammo_index]) {
                ent->client->ps.gunframe = 1;
                ent->client->weaponstate = WEAPON_FIRING;
                ent->client->grenade_time = 0;
            } else {
                if (level.time >= ent->pain_debounce_time) {
                    gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                    ent->pain_debounce_time = level.time + 1;
                }
                NoAmmoWeaponChange(ent);
            }
            return;
        }
 
        if ((ent->client->ps.gunframe == 29) || (ent->client->ps.gunframe == 34) || (ent->client->ps.gunframe == 39) || (ent->client->ps.gunframe == 48)) {
            if (rand() & 15)
                return;
        }
 
        if (++ent->client->ps.gunframe > 48)
            ent->client->ps.gunframe = 16;
        return;
    }
 
    if (ent->client->weaponstate == WEAPON_FIRING) {
        if (ent->client->ps.gunframe == 5)
            gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/hgrena1b.wav"), 1, ATTN_NORM, 0);
 
        if (ent->client->ps.gunframe == 11) {
            if (!ent->client->grenade_time) {
                ent->client->grenade_time = level.time + GRENADE_TIMER + 0.2;
                ent->client->weapon_sound = gi.soundindex("weapons/hgrenc1b.wav");
            }
 
            // they waited too long, detonate it in their hand
            if (!ent->client->grenade_blew_up && level.time >= ent->client->grenade_time) {
                ent->client->weapon_sound = 0;
                weapon_grenade_fire(ent, qtrue);
                ent->client->grenade_blew_up = qtrue;
            }
 
            if (ent->client->buttons & BUTTON_ATTACK)
                return;
 
            if (ent->client->grenade_blew_up) {
                if (level.time >= ent->client->grenade_time) {
                    ent->client->ps.gunframe = 15;
                    ent->client->grenade_blew_up = qfalse;
                } else {
                    return;
                }
            }
        }
 
        if (ent->client->ps.gunframe == 12) {
            ent->client->weapon_sound = 0;
            weapon_grenade_fire(ent, qfalse);
        }
 
        if ((ent->client->ps.gunframe == 15) && (level.time < ent->client->grenade_time))
            return;
 
        ent->client->ps.gunframe++;
 
        if (ent->client->ps.gunframe == 16) {
            ent->client->grenade_time = 0;
            ent->client->weaponstate = WEAPON_READY;
        }
    }
}

weapon_grenade_fire()

void weapon_grenade_fire	(	edict_t *	ent,
		qboolean	held
	)

Definition at line 485 of file p_weapon.c.

{
    vec3_t  offset;
    vec3_t  forward, right;
    vec3_t  start;
    int     damage = 125;
    float   timer;
    int     speed;
    float   radius;
 
    radius = damage + 40;
    if (is_quad)
        damage *= 4;
 
    VectorSet(offset, 8, 8, ent->viewheight - 8);
    AngleVectors(ent->client->v_angle, forward, right, NULL);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
    timer = ent->client->grenade_time - level.time;
    speed = GRENADE_MINSPEED + (GRENADE_TIMER - timer) * ((GRENADE_MAXSPEED - GRENADE_MINSPEED) / GRENADE_TIMER);
    fire_grenade2(ent, start, forward, damage, speed, timer, radius, held);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index]--;
 
    ent->client->grenade_time = level.time + 1.0;
 
    if (ent->deadflag || ent->s.modelindex != 255) { // VWep animations screw up corpses
        return;
    }
 
    if (ent->health <= 0)
        return;
 
    if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
        ent->client->anim_priority = ANIM_ATTACK;
        ent->s.frame = FRAME_crattak1 - 1;
        ent->client->anim_end = FRAME_crattak3;
    } else {
        ent->client->anim_priority = ANIM_REVERSE;
        ent->s.frame = FRAME_wave08;
        ent->client->anim_end = FRAME_wave01;
    }
}

Referenced by ChangeWeapon(), and Weapon_Grenade().

Weapon_GrenadeLauncher()

void Weapon_GrenadeLauncher

(

edict_t *

ent

)

Definition at line 659 of file p_weapon.c.

{
    static int  pause_frames[]  = {34, 51, 59, 0};
    static int  fire_frames[]   = {6, 0};
 
    Weapon_Generic(ent, 5, 16, 59, 64, pause_frames, fire_frames, weapon_grenadelauncher_fire);
}

weapon_grenadelauncher_fire()

void weapon_grenadelauncher_fire

(

edict_t *

ent

)

Definition at line 625 of file p_weapon.c.

{
    vec3_t  offset;
    vec3_t  forward, right;
    vec3_t  start;
    int     damage = 120;
    float   radius;
 
    radius = damage + 40;
    if (is_quad)
        damage *= 4;
 
    VectorSet(offset, 8, 8, ent->viewheight - 8);
    AngleVectors(ent->client->v_angle, forward, right, NULL);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
    VectorScale(forward, -2, ent->client->kick_origin);
    ent->client->kick_angles[0] = -1;
 
    fire_grenade(ent, start, forward, damage, 600, 2.5, radius);
 
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte(MZ_GRENADE | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    ent->client->ps.gunframe++;
 
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index]--;
}

Referenced by Weapon_GrenadeLauncher().

Weapon_HyperBlaster()

void Weapon_HyperBlaster

(

edict_t *

ent

)

Definition at line 841 of file p_weapon.c.

{
    static int  pause_frames[]  = {0};
    static int  fire_frames[]   = {6, 7, 8, 9, 10, 11, 0};
 
    Weapon_Generic(ent, 5, 20, 49, 53, pause_frames, fire_frames, Weapon_HyperBlaster_Fire);
}

Weapon_HyperBlaster_Fire()

void Weapon_HyperBlaster_Fire

(

edict_t *

ent

)

Definition at line 783 of file p_weapon.c.

{
    float   rotation;
    vec3_t  offset;
    int     effect;
    int     damage;
 
    ent->client->weapon_sound = gi.soundindex("weapons/hyprbl1a.wav");
 
    if (!(ent->client->buttons & BUTTON_ATTACK)) {
        ent->client->ps.gunframe++;
    } else {
        if (! ent->client->pers.inventory[ent->client->ammo_index]) {
            if (level.time >= ent->pain_debounce_time) {
                gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                ent->pain_debounce_time = level.time + 1;
            }
            NoAmmoWeaponChange(ent);
        } else {
            rotation = (ent->client->ps.gunframe - 5) * 2 * M_PI / 6;
            offset[0] = -4 * sin(rotation);
            offset[1] = 0;
            offset[2] = 4 * cos(rotation);
 
            if ((ent->client->ps.gunframe == 6) || (ent->client->ps.gunframe == 9))
                effect = EF_HYPERBLASTER;
            else
                effect = 0;
            if (deathmatch->value)
                damage = 15;
            else
                damage = 20;
            Blaster_Fire(ent, offset, damage, qtrue, effect);
            if (!((int)dmflags->value & DF_INFINITE_AMMO))
                ent->client->pers.inventory[ent->client->ammo_index]--;
 
            ent->client->anim_priority = ANIM_ATTACK;
            if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) {
                ent->s.frame = FRAME_crattak1 - 1;
                ent->client->anim_end = FRAME_crattak9;
            } else {
                ent->s.frame = FRAME_attack1 - 1;
                ent->client->anim_end = FRAME_attack8;
            }
        }
 
        ent->client->ps.gunframe++;
        if (ent->client->ps.gunframe == 12 && ent->client->pers.inventory[ent->client->ammo_index])
            ent->client->ps.gunframe = 6;
    }
 
    if (ent->client->ps.gunframe == 12) {
        gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/hyprbd1a.wav"), 1, ATTN_NORM, 0);
        ent->client->weapon_sound = 0;
    }
 
}

Referenced by Weapon_HyperBlaster().

Weapon_Machinegun()

void Weapon_Machinegun

(

edict_t *

ent

)

Definition at line 934 of file p_weapon.c.

{
    static int  pause_frames[]  = {23, 45, 0};
    static int  fire_frames[]   = {4, 5, 0};
 
    Weapon_Generic(ent, 3, 5, 45, 49, pause_frames, fire_frames, Machinegun_Fire);
}

Weapon_Railgun()

void Weapon_Railgun

(

edict_t *

ent

)

Definition at line 1221 of file p_weapon.c.

{
    static int  pause_frames[]  = {56, 0};
    static int  fire_frames[]   = {4, 0};
 
    Weapon_Generic(ent, 3, 18, 56, 61, pause_frames, fire_frames, weapon_railgun_fire);
}

weapon_railgun_fire()

void weapon_railgun_fire

(

edict_t *

ent

)

Definition at line 1176 of file p_weapon.c.

{
    vec3_t      start;
    vec3_t      forward, right;
    vec3_t      offset;
    int         damage;
    int         kick;
 
    if (deathmatch->value) {
        // normal damage is too extreme in dm
        damage = 100;
        kick = 200;
    } else {
        damage = 150;
        kick = 250;
    }
 
    if (is_quad) {
        damage *= 4;
        kick *= 4;
    }
 
    AngleVectors(ent->client->v_angle, forward, right, NULL);
 
    VectorScale(forward, -3, ent->client->kick_origin);
    ent->client->kick_angles[0] = -3;
 
    VectorSet(offset, 0, 7,  ent->viewheight - 8);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
    fire_rail(ent, start, forward, damage, kick);
 
    // send muzzle flash
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte(MZ_RAILGUN | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    ent->client->ps.gunframe++;
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index]--;
}

Referenced by Weapon_Railgun().

Weapon_RocketLauncher()

void Weapon_RocketLauncher

(

edict_t *

ent

)

Definition at line 714 of file p_weapon.c.

{
    static int  pause_frames[]  = {25, 33, 42, 50, 0};
    static int  fire_frames[]   = {5, 0};
 
    Weapon_Generic(ent, 4, 12, 50, 54, pause_frames, fire_frames, Weapon_RocketLauncher_Fire);
}

Weapon_RocketLauncher_Fire()

void Weapon_RocketLauncher_Fire

(

edict_t *

ent

)

Definition at line 675 of file p_weapon.c.

{
    vec3_t  offset, start;
    vec3_t  forward, right;
    int     damage;
    float   damage_radius;
    int     radius_damage;
 
    damage = 100 + (int)(random() * 20.0);
    radius_damage = 120;
    damage_radius = 120;
    if (is_quad) {
        damage *= 4;
        radius_damage *= 4;
    }
 
    AngleVectors(ent->client->v_angle, forward, right, NULL);
 
    VectorScale(forward, -2, ent->client->kick_origin);
    ent->client->kick_angles[0] = -1;
 
    VectorSet(offset, 8, 8, ent->viewheight - 8);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
    fire_rocket(ent, start, forward, damage, 650, damage_radius, radius_damage);
 
    // send muzzle flash
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte(MZ_ROCKET | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    ent->client->ps.gunframe++;
 
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index]--;
}

Referenced by Weapon_RocketLauncher().

Weapon_Shotgun()

void Weapon_Shotgun

(

edict_t *

ent

)

Definition at line 1105 of file p_weapon.c.

{
    static int  pause_frames[]  = {22, 28, 34, 0};
    static int  fire_frames[]   = {8, 9, 0};
 
    Weapon_Generic(ent, 7, 18, 36, 39, pause_frames, fire_frames, weapon_shotgun_fire);
}

weapon_shotgun_fire()

void weapon_shotgun_fire

(

edict_t *

ent

)

Definition at line 1061 of file p_weapon.c.

{
    vec3_t      start;
    vec3_t      forward, right;
    vec3_t      offset;
    int         damage = 4;
    int         kick = 8;
 
    if (ent->client->ps.gunframe == 9) {
        ent->client->ps.gunframe++;
        return;
    }
 
    AngleVectors(ent->client->v_angle, forward, right, NULL);
 
    VectorScale(forward, -2, ent->client->kick_origin);
    ent->client->kick_angles[0] = -2;
 
    VectorSet(offset, 0, 8,  ent->viewheight - 8);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
    if (is_quad) {
        damage *= 4;
        kick *= 4;
    }
 
    if (deathmatch->value)
        fire_shotgun(ent, start, forward, damage, kick, 500, 500, DEFAULT_DEATHMATCH_SHOTGUN_COUNT, MOD_SHOTGUN);
    else
        fire_shotgun(ent, start, forward, damage, kick, 500, 500, DEFAULT_SHOTGUN_COUNT, MOD_SHOTGUN);
 
    // send muzzle flash
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte(MZ_SHOTGUN | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    ent->client->ps.gunframe++;
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index]--;
}

Referenced by Weapon_Shotgun().

Weapon_SuperShotgun()

void Weapon_SuperShotgun

(

edict_t *

ent

)

Definition at line 1158 of file p_weapon.c.

{
    static int  pause_frames[]  = {29, 42, 57, 0};
    static int  fire_frames[]   = {7, 0};
 
    Weapon_Generic(ent, 6, 17, 57, 61, pause_frames, fire_frames, weapon_supershotgun_fire);
}

weapon_supershotgun_fire()

void weapon_supershotgun_fire

(

edict_t *

ent

)

Definition at line 1114 of file p_weapon.c.

{
    vec3_t      start;
    vec3_t      forward, right;
    vec3_t      offset;
    vec3_t      v;
    int         damage = 6;
    int         kick = 12;
 
    AngleVectors(ent->client->v_angle, forward, right, NULL);
 
    VectorScale(forward, -2, ent->client->kick_origin);
    ent->client->kick_angles[0] = -2;
 
    VectorSet(offset, 0, 8,  ent->viewheight - 8);
    P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);
 
    if (is_quad) {
        damage *= 4;
        kick *= 4;
    }
 
    v[PITCH] = ent->client->v_angle[PITCH];
    v[YAW]   = ent->client->v_angle[YAW] - 5;
    v[ROLL]  = ent->client->v_angle[ROLL];
    AngleVectors(v, forward, NULL, NULL);
    fire_shotgun(ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT / 2, MOD_SSHOTGUN);
    v[YAW]   = ent->client->v_angle[YAW] + 5;
    AngleVectors(v, forward, NULL, NULL);
    fire_shotgun(ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT / 2, MOD_SSHOTGUN);
 
    // send muzzle flash
    gi.WriteByte(svc_muzzleflash);
    gi.WriteShort(ent - g_edicts);
    gi.WriteByte(MZ_SSHOTGUN | is_silenced);
    gi.multicast(ent->s.origin, MULTICAST_PVS);
 
    ent->client->ps.gunframe++;
    PlayerNoise(ent, start, PNOISE_WEAPON);
 
    if (!((int)dmflags->value & DF_INFINITE_AMMO))
        ent->client->pers.inventory[ent->client->ammo_index] -= 2;
}

Referenced by Weapon_SuperShotgun().

Variable Documentation

is_quad

qboolean is_quad

static

Definition at line 24 of file p_weapon.c.

Referenced by Blaster_Fire(), Chaingun_Fire(), Machinegun_Fire(), Think_Weapon(), weapon_bfg_fire(), weapon_grenade_fire(), weapon_grenadelauncher_fire(), weapon_railgun_fire(), Weapon_RocketLauncher_Fire(), weapon_shotgun_fire(), and weapon_supershotgun_fire().

is_silenced

byte is_silenced

static

Definition at line 25 of file p_weapon.c.

Referenced by Blaster_Fire(), Chaingun_Fire(), Machinegun_Fire(), Think_Weapon(), weapon_bfg_fire(), weapon_flaregun_fire(), weapon_grenadelauncher_fire(), weapon_railgun_fire(), Weapon_RocketLauncher_Fire(), weapon_shotgun_fire(), and weapon_supershotgun_fire().