/*
 * Copyright (C) 1997-2001 Id Software, Inc.
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59
 * Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */
/* g_weapon.c */

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


static qboolean	is_quad;
static byte	is_silenced;


void		weapon_grenade_fire(edict_t * ent, qboolean held);


void
P_ProjectSource(gclient_t * client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
{
	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);
}


/*
 * =============== PlayerNoise
 *
 * 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. ===============
 */
void
PlayerNoise(edict_t * who, vec3_t where, int type)
{
	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);
}


qboolean
Pickup_Weapon(edict_t * ent, edict_t * other)
{
	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 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);
		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 true;
}


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

	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;

	}
}

/*
 * ================= NoAmmoWeaponChange =================
 */
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"))]
	    && 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");
}

/*
 * ================= Think_Weapon
 *
 * Called by ClientBeginServerFrame and ClientThink =================
 */
void
Think_Weapon(edict_t * ent)
{
	/* 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);
	}
}


/*
 * ================ Use_Weapon
 *
 * Make the weapon ready if there is ammo ================
 */
void
Use_Weapon(edict_t * ent, gitem_t * item)
{
	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]) {
#ifdef WITH_ACEBOT
			safe_cprintf
#else
			gi.cprintf
#endif
			    (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) {
#ifdef WITH_ACEBOT
			safe_cprintf
#else
			gi.cprintf
#endif
			    (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;
}



/*
 * ================ Drop_Weapon ================
 */
void
Drop_Weapon(edict_t * ent, gitem_t * item)
{
	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)) {
#ifdef WITH_ACEBOT
		safe_cprintf
#else
		gi.cprintf
#endif
		    (ent, PRINT_HIGH, "Can't drop current weapon\n");
		return;
	}
	Drop_Item(ent, item);
	ent->client->pers.inventory[index]--;
}


/*
 * ================ Weapon_Generic
 *
 * A generic function to handle the basics of weapon thinking ================
 */
#define FRAME_FIRE_FIRST		(FRAME_ACTIVATE_LAST + 1)
#define FRAME_IDLE_FIRST		(FRAME_FIRE_LAST + 1)
#define FRAME_DEACTIVATE_FIRST	(FRAME_IDLE_LAST + 1)

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


/*
 * ======================================================================
 *
 * GRENADE
 *
 * ======================================================================
 */

#define GRENADE_TIMER		3.0
#define GRENADE_MINSPEED	400
#define GRENADE_MAXSPEED	800

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;

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

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

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

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

/*
 * ======================================================================
 *
 * ROCKET
 *
 * ======================================================================
 */

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

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


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


void
Weapon_Blaster_Fire(edict_t * ent)
{
	int		damage;

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

	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;

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

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

#ifdef GAME_MOD
void
Extr_Shell_Touch(edict_t * self, edict_t * other, cplane_t * plane, csurface_t * surf)
{
	gi.sound(self, CHAN_VOICE, gi.soundindex("misc/brass_shell.wav"), 1, ATTN_NORM, 0);
	self->solid = SOLID_NOT;
}

void
Extr_Shell(edict_t * self, char *modelname, vec3_t start, vec3_t aimdir, int speed, vec3_t velocity, char *kierunek)
{
	edict_t        *Extr_Shell;
	vec3_t		dir;
	vec3_t		forward, right, up;

	if (deathmatch->value || coop->value) {
		if (!eject_bullets_dm_coop->value)
			return;
	}
	vectoangles(aimdir, dir);
	AngleVectors(dir, forward, right, up);

	Extr_Shell = G_Spawn();

	VectorCopy(start, Extr_Shell->s.origin);
	VectorCopy(aimdir, Extr_Shell->movedir);
	VectorCopy(velocity, Extr_Shell->velocity);
	vectoangles(aimdir, Extr_Shell->s.angles);
	VectorMA(Extr_Shell->velocity, 120 + random() * 20, up, Extr_Shell->velocity);

	if (!stricmp(kierunek, "right"))
		VectorMA(Extr_Shell->velocity, -80 - random() * 20, right, Extr_Shell->velocity);
	else
		VectorMA(Extr_Shell->velocity, 80 + random() * 20, right, Extr_Shell->velocity);

	Extr_Shell->avelocity[0] = random() * 600;
	Extr_Shell->avelocity[1] = random() * 600;
	Extr_Shell->avelocity[2] = random() * 600;
	gi.setmodel(Extr_Shell, modelname);

	Extr_Shell->movetype = MOVETYPE_BOUNCE;
	Extr_Shell->clipmask = MASK_SHOT;
	Extr_Shell->solid = SOLID_BBOX;
	Extr_Shell->owner = self;

	VectorSet(Extr_Shell->mins, -1.5, -0.6, -0.55);
	VectorSet(Extr_Shell->maxs, 1.5, 0.6, 0.55);

	Extr_Shell->nextthink = level.time + 25 + random() * 1;
	Extr_Shell->think = G_FreeEdict;
	Extr_Shell->touch = Extr_Shell_Touch;
	Extr_Shell->classname = "Extr_Shell";
	gi.linkentity(Extr_Shell);


}

#endif

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

#ifdef GAME_MOD
	vec3_t		start_shell, forward_shell, left_shell, offset_shell;

#endif
	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;
	}
#ifdef GAME_MOD
	if (eject_bullets->value) {
		VectorSet(offset_shell, 12, 8.7, ent->viewheight - 3.2);
		AngleVectors(ent->client->v_angle, forward_shell, left_shell, NULL);
		P_ProjectSource(ent->client, ent->s.origin, offset_shell, forward_shell, left_shell, start_shell);
		VectorScale(forward_shell, -2, ent->client->kick_origin);
		Extr_Shell(ent, "models/shells/m_shell.md2", start_shell, forward_shell, 2, ent->velocity, "leftt");
	}
#endif
	/* 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;
	}
}

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

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;

#ifdef GAME_MOD
	vec3_t		start_shell, forward_shell, left_shell, offset_shell;

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

#ifdef GAME_MOD
	if (eject_bullets->value) {
		VectorSet(offset_shell, 12, 8.7, ent->viewheight - 3.2);
		AngleVectors(ent->client->v_angle, forward_shell, left_shell, NULL);
		P_ProjectSource(ent->client, ent->s.origin, offset_shell, forward_shell, left_shell, start_shell);
		VectorScale(forward_shell, 2, ent->client->kick_origin);
		Extr_Shell(ent, "models/shells/m_shell.md2", start_shell, forward_shell, 2, ent->velocity, "left");
	}
#endif
	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;
}


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

	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;

#ifdef GAME_MOD
	vec3_t		start_shell, forward_shell, left_shell, offset_shell;

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

#ifdef GAME_MOD
	if (eject_bullets->value) {
		VectorSet(offset_shell, 12, 8.7, ent->viewheight - 3.2);
		AngleVectors(ent->client->v_angle, forward_shell, left_shell, NULL);
		P_ProjectSource(ent->client, ent->s.origin, offset_shell, forward_shell, left_shell, start_shell);
		VectorScale(forward_shell, -2, ent->client->kick_origin);
		Extr_Shell(ent, "models/shells/s_shell.md2", start_shell, forward_shell, 2, ent->velocity, "right");
	}
#endif
	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]--;
}

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


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;

#ifdef GAME_MOD
	vec3_t		start_shell, forward_shell, left_shell, offset_shell;

#endif
	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;
	}
#ifdef GAME_MOD
	if (eject_bullets->value) {
		VectorSet(offset_shell, 12, 8.7, ent->viewheight - 3.2);
		AngleVectors(ent->client->v_angle, forward_shell, left_shell, NULL);
		P_ProjectSource(ent->client, ent->s.origin, offset_shell, forward_shell, left_shell, start_shell);
		VectorScale(forward_shell, -2, ent->client->kick_origin);
		Extr_Shell(ent, "models/shells/s_shell.md2", start_shell, forward_shell, 2, ent->velocity, "right");


		VectorSet(offset_shell, 15, 10.9, ent->viewheight - 5.4);
		AngleVectors(ent->client->v_angle, forward_shell, left_shell, NULL);
		P_ProjectSource(ent->client, ent->s.origin, offset_shell, forward_shell, left_shell, start_shell);
		VectorScale(forward_shell, 0, ent->client->kick_origin);
		Extr_Shell(ent, "models/shells/s_shell.md2", start_shell, forward_shell, 4, ent->velocity, "right");
	}
#endif
	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;
}

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



/*
 * ======================================================================
 *
 * RAILGUN
 *
 * ======================================================================
 */

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


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


/*
 * ======================================================================
 *
 * BFG10K
 *
 * ======================================================================
 */

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

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


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