/* =======================================================================
 *
 * Player weapons.
 *
 * =======================================================================
 */

#include "../header/local.h"
#include "../monster/misc/player.h"

#define PLAYER_NOISE_SELF 0
#define PLAYER_NOISE_IMPACT 1

#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

#define TRAP_TIMER 5.0
#define TRAP_MINSPEED 300
#define TRAP_MAXSPEED 700

static qboolean is_quad;
static qboolean is_quadfire;
static byte is_silenced;

void weapon_grenade_fire(edict_t *ent, qboolean held);
void weapon_trap_fire(edict_t *ent, qboolean held);

void
P_ProjectSource(edict_t *ent, vec3_t distance,
		vec3_t forward, vec3_t right, vec3_t result)
{
	gclient_t *client = ent->client;
	float     *point  = ent->s.origin;
	vec3_t     _distance;

  	if (!client)
	{
		return;
	}

	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);

	// Berserker: fix - now the projectile hits exactly where the scope is pointing.
	if (aimfix->value)
	{
		vec3_t start, end;
		VectorSet(start, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2] + ent->viewheight);
		VectorMA(start, 8192, forward, end);

		trace_t	tr = gi.trace(start, NULL, NULL, end, ent, MASK_SHOT);
		if (tr.fraction < 1)
		{
			VectorSubtract(tr.endpos, result, forward);
			VectorNormalize(forward);
		}
	}
}

/*
 * Each player can have two noise objects associated with it:
 * a personal noise (jumping, pain, weapon firing), and a weapon
 * target noise (bullet wall impacts)
 *
 * Monsters that don't directly see the player can move
 * to a noise in hopes of seeing the player from there.
 */
static edict_t *
PlayerNoise_Spawn(edict_t *who, int type)
{
	edict_t *noise;

	if (!who)
	{
		return NULL;
	}

	noise = G_SpawnOptional();
	if (!noise)
	{
		return NULL;
	}

	noise->classname = "player_noise";
	noise->spawnflags = type;
	VectorSet (noise->mins, -8, -8, -8);
	VectorSet (noise->maxs, 8, 8, 8);
	noise->owner = who;
	noise->svflags = SVF_NOCLIENT;

	return noise;
}

static void
PlayerNoise_Verify(edict_t *who)
{
	edict_t *e;
	edict_t *n1;
	edict_t *n2;

	if (!who)
	{
		return;
	}

	n1 = who->mynoise;
	n2 = who->mynoise2;

	if (n1 && !n1->inuse)
	{
		n1 = NULL;
	}

	if (n2 && !n2->inuse)
	{
		n2 = NULL;
	}

	if (n1 && n2)
	{
		return;
	}

	for (e = g_edicts + 1 + game.maxclients; e < &g_edicts[globals.num_edicts]; e++)
	{
		if (!e->inuse || strcmp(e->classname, "player_noise") != 0)
		{
			continue;
		}

		if (e->owner && e->owner != who)
		{
			continue;
		}

		e->owner = who;

		if (!n2 && (e->spawnflags == PLAYER_NOISE_IMPACT || n1))
		{
			n2 = e;
		}
		else
		{
			n1 = e;
		}

		if (n1 && n2)
		{
			break;
		}
	}

	if (!n1)
	{
		n1 = PlayerNoise_Spawn(who, PLAYER_NOISE_SELF);
	}

	if (!n2)
	{
		n2 = PlayerNoise_Spawn(who, PLAYER_NOISE_IMPACT);
	}

	who->mynoise = n1;
	who->mynoise2 = n2;
}

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

	if (!who || !who->client)
	{
		return;
	}

	if (type == PNOISE_WEAPON)
	{
		if (who->client->silencer_shots)
		{
			who->client->silencer_shots--;
			return;
		}
	}

	if (deathmatch->value)
	{
		return;
	}

	if (who->flags & FL_NOTARGET)
	{
		return;
	}

	PlayerNoise_Verify(who);

	if ((type == PNOISE_SELF) || (type == PNOISE_WEAPON))
	{
		if (level.framenum <= (level.sound_entity_framenum + 3))
		{
			return;
		}

		if (!who->mynoise)
		{
			return;
		}

		noise = who->mynoise;
		level.sound_entity = noise;
		level.sound_entity_framenum = level.framenum;
	}
	else
	{
		if (level.framenum <= (level.sound2_entity_framenum + 3))
		{
			return;
		}

		if (!who->mynoise2)
		{
			return;
		}

		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->last_sound_time = level.time;
	gi.linkentity(noise);
}

qboolean
Pickup_Weapon(edict_t *ent, edict_t *other)
{
	int index;
	gitem_t *ammo;

	if (!ent || !other)
	{
		return false;
	}

	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)) &&
				(!coop_pickup_weapons->value || (ent->flags & FL_COOP_TAKEN)))
		{
			return false; /* 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);

		/* Don't get infinite ammo with trap */
		if (((int)dmflags->value & DF_INFINITE_AMMO) &&
			Q_stricmp(ent->item->pickup_name, "ammo_trap"))
		{
			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;
				ent->flags |= FL_COOP_TAKEN;
			}
		}
	}

	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 true;
}

/*
 * The old weapon has been dropped all the
 * way, so make the new one current
 */
void
ChangeWeapon(edict_t *ent)
{
	int i;

  	if (!ent)
	{
		return;
	}

	if (ent->client->grenade_time)
	{
		ent->client->grenade_time = level.time;
		ent->client->weapon_sound = 0;
		weapon_grenade_fire(ent, false);
		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;
	}
}

void
NoAmmoWeaponChange(edict_t *ent)
{
	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"))] > 1 &&
		ent->client->pers.inventory[ITEM_INDEX(FindItem("ionripper"))])
	{
		ent->client->newweapon = FindItem("ionripper");
		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");
}

/*
 * Called by ClientBeginServerFrame and ClientThink
 */
void
Think_Weapon(edict_t *ent)
{
  	if (!ent)
	{
		return;
	}

	/* 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);
		is_quadfire = (ent->client->quadfire_framenum > level.framenum);

		if (ent->client->silencer_shots)
		{
			is_silenced = MZ_SILENCED;
		}
		else
		{
			is_silenced = 0;
		}

		ent->client->pers.weapon->weaponthink(ent);
	}
}

/*
 * Make the weapon ready if there is ammo
 */
void
Use_Weapon(edict_t *ent, gitem_t *item)
{
	int ammo_index;
	gitem_t *ammo_item;

	if (!ent || !item)
	{
		return;
	}

	/* 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;
}

void
Use_Weapon2(edict_t *ent, gitem_t *item)
{
	int ammo_index;
	gitem_t *ammo_item;
	gitem_t *nextitem;
	int index;

	if (!ent || !item)
	{
		return;
	}

	if (strcmp(item->pickup_name, "HyperBlaster") == 0)
	{
		if (item == ent->client->pers.weapon)
		{
			item = FindItem("Ionripper");
			index = ITEM_INDEX(item);

			if (!ent->client->pers.inventory[index])
			{
				item = FindItem("HyperBlaster");
			}
		}
	}

	else if (strcmp(item->pickup_name, "Railgun") == 0)
	{
		ammo_item = FindItem(item->ammo);
		ammo_index = ITEM_INDEX(ammo_item);

		if (!ent->client->pers.inventory[ammo_index])
		{
			nextitem = FindItem("Phalanx");
			ammo_item = FindItem(nextitem->ammo);
			ammo_index = ITEM_INDEX(ammo_item);

			if (ent->client->pers.inventory[ammo_index])
			{
				item = FindItem("Phalanx");
				index = ITEM_INDEX(item);

				if (!ent->client->pers.inventory[index])
				{
					item = FindItem("Railgun");
				}
			}
		}
		else if (item == ent->client->pers.weapon)
		{
			item = FindItem("Phalanx");
			index = ITEM_INDEX(item);

			if (!ent->client->pers.inventory[index])
			{
				item = FindItem("Railgun");
			}
		}
	}

	/* see if we're already using it */
	if (item == ent->client->pers.weapon)
	{
		return;
	}

	if (item->ammo)
	{
		ammo_item = FindItem(item->ammo);
		ammo_index = ITEM_INDEX(ammo_item);

		if (!ent->client->pers.inventory[ammo_index] && !g_select_empty->value)
		{
			gi.cprintf(ent, PRINT_HIGH, "No %s for %s.\n",
					ammo_item->pickup_name, item->pickup_name);
			return;
		}
	}

	/* change to this weapon when down */
	ent->client->newweapon = item;
}

void
Drop_Weapon(edict_t *ent, gitem_t *item)
{
	int index;

	if (!ent || !item)
	{
		return;
	}

	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]--;
}

/*
 * A generic function to handle the basics of weapon thinking
 */
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))
{
	int n;

	if (!ent || !fire_frames || !fire)
	{
		return;
	}

	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;
		}
	}
}

void
weapon_grenade_fire(edict_t *ent, qboolean held)
{
	vec3_t offset;
	vec3_t forward, right;
	vec3_t start;
	int damage = 125;
	float timer;
	int speed;
	float radius;

  	if (!ent)
	{
		return;
	}

	radius = damage + 40;

	if (is_quad)
	{
		damage *= 4;

		gi.sound(ent, CHAN_ITEM, gi.soundindex(
				"items/damage3.wav"), 1, ATTN_NORM, 0);
	}

	VectorSet(offset, 8, 8, ent->viewheight - 8);
	AngleVectors(ent->client->v_angle, forward, right, NULL);
	P_ProjectSource(ent, 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;
	}
}

void
Weapon_Grenade(edict_t *ent)
{
  	if (!ent)
	{
		return;
	}

	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, true);
				ent->client->grenade_blew_up = true;
			}

			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 = false;
				}
				else
				{
					return;
				}
			}
		}

		if (ent->client->ps.gunframe == 12)
		{
			ent->client->weapon_sound = 0;
			weapon_grenade_fire(ent, false);
		}

		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;
		}
	}
}

/* GRENADE LAUNCHER */

void
weapon_grenadelauncher_fire(edict_t *ent)
{
	vec3_t offset;
	vec3_t forward, right;
	vec3_t start;
	int damage = 120;
	float radius;

  	if (!ent)
	{
		return;
	}

	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, 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]--;
	}
}

void
Weapon_GrenadeLauncher(edict_t *ent)
{
	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);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 5, 16, 59, 64, pause_frames,
				fire_frames, weapon_grenadelauncher_fire);
	}
}

/* ROCKET */

void
Weapon_RocketLauncher_Fire(edict_t *ent)
{
	vec3_t offset, start;
	vec3_t forward, right;
	int damage;
	float damage_radius;
	int radius_damage;

  	if (!ent)
	{
		return;
	}

	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, 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]--;
	}
}

void
Weapon_RocketLauncher(edict_t *ent)
{
	static int pause_frames[] = {25, 33, 42, 50, 0};
	static int fire_frames[] = {5, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 4, 12, 50, 54, pause_frames,
			fire_frames, Weapon_RocketLauncher_Fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 4, 12, 50, 54, pause_frames,
				fire_frames, Weapon_RocketLauncher_Fire);
	}
}

/* BLASTER / HYPERBLASTER */

void
Blaster_Fire(edict_t *ent, vec3_t g_offset, int damage,
		qboolean hyper, int effect)
{
	vec3_t forward, right;
	vec3_t start;
	vec3_t offset;

  	if (!ent)
	{
		return;
	}

	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, 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);
}

void
Weapon_Blaster_Fire(edict_t *ent)
{
	int damage;

  	if (!ent)
	{
		return;
	}

	if (deathmatch->value)
	{
		damage = 15;
	}
	else
	{
		damage = 10;
	}

	Blaster_Fire(ent, vec3_origin, damage, false, EF_BLASTER);
	ent->client->ps.gunframe++;
}

void
Weapon_Blaster(edict_t *ent)
{
	static int pause_frames[] = {19, 32, 0};
	static int fire_frames[] = {5, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 4, 8, 52, 55, pause_frames,
			fire_frames, Weapon_Blaster_Fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 4, 8, 52, 55, pause_frames,
				fire_frames, Weapon_Blaster_Fire);
	}
}

void
Weapon_HyperBlaster_Fire(edict_t *ent)
{
	float rotation;
	vec3_t offset;
	int effect;
	int damage;

  	if (!ent)
	{
		return;
	}

	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, true, 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;
	}
}

void
Weapon_HyperBlaster(edict_t *ent)
{
	static int pause_frames[] = {0};
	static int fire_frames[] = {6, 7, 8, 9, 10, 11, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 5, 20, 49, 53, pause_frames,
			fire_frames, Weapon_HyperBlaster_Fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 5, 20, 49, 53, pause_frames,
				fire_frames, Weapon_HyperBlaster_Fire);
	}
}

/* MACHINEGUN / CHAINGUN */

void
Machinegun_Fire(edict_t *ent)
{
	int i;
	vec3_t start;
	vec3_t forward, right;
	vec3_t angles;
	int damage = 8;
	int kick = 2;
	vec3_t offset;

  	if (!ent)
	{
		return;
	}

	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 || g_machinegun_norecoil->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, 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;
	}
}

void
Weapon_Machinegun(edict_t *ent)
{
	static int pause_frames[] = {23, 45, 0};
	static int fire_frames[] = {4, 5, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 3, 5, 45, 49, pause_frames,
			fire_frames, Machinegun_Fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 3, 5, 45, 49, pause_frames,
				fire_frames, Machinegun_Fire);
	}
}

void
Chaingun_Fire(edict_t *ent)
{
	int i;
	int shots;
	vec3_t start;
	vec3_t forward, right, up;
	float r, u;
	vec3_t offset;
	int damage;
	int kick = 2;

  	if (!ent)
	{
		return;
	}

	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, 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;
	}
}

void
Weapon_Chaingun(edict_t *ent)
{
	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};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 4, 31, 61, 64, pause_frames, fire_frames, Chaingun_Fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 4, 31, 61, 64, pause_frames,
				fire_frames, Chaingun_Fire);
	}
}

/* SHOTGUN / SUPERSHOTGUN */

void
weapon_shotgun_fire(edict_t *ent)
{
	vec3_t start;
	vec3_t forward, right;
	vec3_t offset;
	int damage = 4;
	int kick = 8;

  	if (!ent)
	{
		return;
	}

	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, offset, forward, right, start);

	if (is_quad)
	{
		damage *= 4;
		kick *= 4;
	}

	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]--;
	}
}

void
Weapon_Shotgun(edict_t *ent)
{
	static int pause_frames[] = {22, 28, 34, 0};
	static int fire_frames[] = {8, 9, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 7, 18, 36, 39, pause_frames,
			fire_frames, weapon_shotgun_fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 7, 18, 36, 39, pause_frames,
				fire_frames, weapon_shotgun_fire);
	}
}

void
weapon_supershotgun_fire(edict_t *ent)
{
	vec3_t start;
	vec3_t forward, right;
	vec3_t offset;
	vec3_t v;
	int damage = 6;
	int kick = 12;

  	if (!ent)
	{
		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, 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);
	
	if (aimfix->value)
	{	
		AngleVectors(v, 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, offset, forward, right, start);
	}	
	
	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);
	
	if (aimfix->value)
	{	
		AngleVectors(v, 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, offset, forward, right, start);
	}	
	
	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;
	}
}

void
Weapon_SuperShotgun(edict_t *ent)
{
	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);

  	if (!ent)
	{
		return;
	}

	if (is_quadfire)
	{
		Weapon_Generic(ent, 6, 17, 57, 61, pause_frames,
				fire_frames, weapon_supershotgun_fire);
	}
}

/* RAILGUN */

void
weapon_railgun_fire(edict_t *ent)
{
	vec3_t start;
	vec3_t forward, right;
	vec3_t offset;
	int damage;
	int kick;

  	if (!ent)
	{
		return;
	}

	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, 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]--;
	}
}

void
Weapon_Railgun(edict_t *ent)
{
	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);

  	if (!ent)
	{
		return;
	}

	if (is_quadfire)
	{
		Weapon_Generic(ent, 3, 18, 56, 61, pause_frames,
				fire_frames, weapon_railgun_fire);
	}
}

/* BFG10K */

void
weapon_bfg_fire(edict_t *ent)
{
	vec3_t offset, start;
	vec3_t forward, right;
	int damage;
	float damage_radius = 1000;

  	if (!ent)
	{
		return;
	}

	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, 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;
	}
}

void
Weapon_BFG(edict_t *ent)
{
	static int pause_frames[] = {39, 45, 50, 55, 0};
	static int fire_frames[] = {9, 17, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 8, 32, 55, 58, pause_frames,
			fire_frames, weapon_bfg_fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 8, 32, 55, 58, pause_frames,
				fire_frames, weapon_bfg_fire);
	}
}

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

/* RipperGun */

void
weapon_ionripper_fire(edict_t *ent)
{
	vec3_t start;
	vec3_t forward, right;
	vec3_t offset;
	vec3_t tempang;
	int damage;

  	if (!ent)
	{
		return;
	}

	if (deathmatch->value)
	{
		/* tone down for deathmatch */
		damage = 30;
	}
	else
	{
		damage = 50;
	}

	if (is_quad)
	{
		damage *= 4;
	}

	VectorCopy(ent->client->v_angle, tempang);
	tempang[YAW] += crandom();

	AngleVectors(tempang, forward, right, NULL);

	VectorScale(forward, -3, ent->client->kick_origin);
	ent->client->kick_angles[0] = -3;

	VectorSet(offset, 16, 7, ent->viewheight - 8);

	P_ProjectSource(ent, offset, forward, right, start);

	fire_ionripper(ent, start, forward, damage, 500, EF_IONRIPPER);

	/* send muzzle flash */
	gi.WriteByte(svc_muzzleflash);
	gi.WriteShort(ent - g_edicts);
	gi.WriteByte(MZ_IONRIPPER | 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] -=
			ent->client->pers.weapon->quantity;
	}

	if (ent->client->pers.inventory[ent->client->ammo_index] < 0)
	{
		ent->client->pers.inventory[ent->client->ammo_index] = 0;
	}
}

void
Weapon_Ionripper(edict_t *ent)
{
	static int pause_frames[] = {36, 0};
	static int fire_frames[] = {5, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 4, 6, 36, 39, pause_frames,
			fire_frames, weapon_ionripper_fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 4, 6, 36, 39, pause_frames,
				fire_frames, weapon_ionripper_fire);
	}
}

/*	Phalanx */

void
weapon_phalanx_fire(edict_t *ent)
{
	vec3_t start;
	vec3_t forward, right, up;
	vec3_t offset;
	vec3_t v;
	int damage;
	float damage_radius;
	int radius_damage;

  	if (!ent)
	{
		return;
	}

	damage = 70 + (int)(random() * 10.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] = -2;

	VectorSet(offset, 0, 8, ent->viewheight - 8);
	P_ProjectSource(ent, offset, forward, right, start);

	if (ent->client->ps.gunframe == 8)
	{
		v[PITCH] = ent->client->v_angle[PITCH];
		v[YAW] = ent->client->v_angle[YAW] - 1.5;
		v[ROLL] = ent->client->v_angle[ROLL];
		AngleVectors(v, forward, right, up);

		radius_damage = 30;
		damage_radius = 120;

		fire_plasma(ent, start, forward, damage, 725,
				damage_radius, radius_damage);

		if (!((int)dmflags->value & DF_INFINITE_AMMO))
		{
			ent->client->pers.inventory[ent->client->ammo_index]--;
		}
	}
	else
	{
		v[PITCH] = ent->client->v_angle[PITCH];
		v[YAW] = ent->client->v_angle[YAW] + 1.5;
		v[ROLL] = ent->client->v_angle[ROLL];
		AngleVectors(v, forward, right, up);
		fire_plasma(ent, start, forward, damage, 725,
				damage_radius, radius_damage);

		/* send muzzle flash */
		gi.WriteByte(svc_muzzleflash);
		gi.WriteShort(ent - g_edicts);
		gi.WriteByte(MZ_PHALANX | is_silenced);
		gi.multicast(ent->s.origin, MULTICAST_PVS);

		PlayerNoise(ent, start, PNOISE_WEAPON);
	}

	ent->client->ps.gunframe++;
}

void
Weapon_Phalanx(edict_t *ent)
{
	static int pause_frames[] = {29, 42, 55, 0};
	static int fire_frames[] = {7, 8, 0};

  	if (!ent)
	{
		return;
	}

	Weapon_Generic(ent, 5, 20, 58, 63, pause_frames,
			fire_frames, weapon_phalanx_fire);

	if (is_quadfire)
	{
		Weapon_Generic(ent, 5, 20, 58, 63, pause_frames,
				fire_frames, weapon_phalanx_fire);
	}
}

/* TRAP */

void
weapon_trap_fire(edict_t *ent, qboolean held)
{
	vec3_t offset;
	vec3_t forward, right;
	vec3_t start;
	int damage = 125;
	float timer;
	int speed;
	float radius;

  	if (!ent)
	{
		return;
	}

	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, offset, forward, right, start);

	timer = ent->client->grenade_time - level.time;
	speed = GRENADE_MINSPEED + (GRENADE_TIMER - timer) *
	   	((GRENADE_MAXSPEED - GRENADE_MINSPEED) / GRENADE_TIMER);
	fire_trap(ent, start, forward, damage, speed, timer, radius, held);

	ent->client->pers.inventory[ent->client->ammo_index]--;
	ent->client->grenade_time = level.time + 1.0;
}

void
Weapon_Trap(edict_t *ent)
{
  	if (!ent)
	{
		return;
	}

	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/trapcock.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/traploop.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_trap_fire(ent, true);
				ent->client->grenade_blew_up = true;
			}

			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 = false;
				}
				else
				{
					return;
				}
			}
		}

		if (ent->client->ps.gunframe == 12)
		{
			ent->client->weapon_sound = 0;
			weapon_trap_fire(ent, false);

			if (ent->client->pers.inventory[ent->client->ammo_index] == 0)
			{
				NoAmmoWeaponChange(ent);
			}
		}

		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;
		}
	}
}
