g_items.c File Reference

#include "g_local.h"

Go to the source code of this file.

Macros
#define	HEALTH_IGNORE_MAX   1
#define	HEALTH_TIMED   2

Functions
qboolean	Pickup_Weapon (edict_t *ent, edict_t *other)
void	Use_Weapon (edict_t *ent, gitem_t *inv)
void	Drop_Weapon (edict_t *ent, gitem_t *inv)
void	Weapon_Blaster (edict_t *ent)
void	Weapon_Shotgun (edict_t *ent)
void	Weapon_SuperShotgun (edict_t *ent)
void	Weapon_Machinegun (edict_t *ent)
void	Weapon_Chaingun (edict_t *ent)
void	Weapon_HyperBlaster (edict_t *ent)
void	Weapon_RocketLauncher (edict_t *ent)
void	Weapon_Grenade (edict_t *ent)
void	Weapon_GrenadeLauncher (edict_t *ent)
void	Weapon_Railgun (edict_t *ent)
void	Weapon_BFG (edict_t *ent)
void	Weapon_FlareGun (edict_t *ent)
void	Use_Quad (edict_t *ent, gitem_t *item)
gitem_t *	GetItemByIndex (int index)
gitem_t *	FindItemByClassname (char *classname)
gitem_t *	FindItem (char *pickup_name)
void	DoRespawn (edict_t *ent)
void	SetRespawn (edict_t *ent, float delay)
qboolean	Pickup_Powerup (edict_t *ent, edict_t *other)
void	Drop_General (edict_t *ent, gitem_t *item)
qboolean	Pickup_Adrenaline (edict_t *ent, edict_t *other)
qboolean	Pickup_AncientHead (edict_t *ent, edict_t *other)
qboolean	Pickup_Bandolier (edict_t *ent, edict_t *other)
qboolean	Pickup_Pack (edict_t *ent, edict_t *other)
void	Use_Breather (edict_t *ent, gitem_t *item)
void	Use_Envirosuit (edict_t *ent, gitem_t *item)
void	Use_Invulnerability (edict_t *ent, gitem_t *item)
void	Use_Silencer (edict_t *ent, gitem_t *item)
qboolean	Pickup_Key (edict_t *ent, edict_t *other)
qboolean	Add_Ammo (edict_t *ent, gitem_t *item, int count)
qboolean	Pickup_Ammo (edict_t *ent, edict_t *other)
void	Drop_Ammo (edict_t *ent, gitem_t *item)
void	MegaHealth_think (edict_t *self)
qboolean	Pickup_Health (edict_t *ent, edict_t *other)
int	ArmorIndex (edict_t *ent)
qboolean	Pickup_Armor (edict_t *ent, edict_t *other)
int	PowerArmorType (edict_t *ent)
void	Use_PowerArmor (edict_t *ent, gitem_t *item)
qboolean	Pickup_PowerArmor (edict_t *ent, edict_t *other)
void	Drop_PowerArmor (edict_t *ent, gitem_t *item)
void	Touch_Item (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
void	drop_temp_touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
void	drop_make_touchable (edict_t *ent)
edict_t *	Drop_Item (edict_t *ent, gitem_t *item)
void	Use_Item (edict_t *ent, edict_t *other, edict_t *activator)
void	droptofloor (edict_t *ent)
void	PrecacheItem (gitem_t *it)
void	SpawnItem (edict_t *ent, gitem_t *item)
void	SP_item_health (edict_t *self)
void	SP_item_health_small (edict_t *self)
void	SP_item_health_large (edict_t *self)
void	SP_item_health_mega (edict_t *self)
void	InitItems (void)
void	SetItemNames (void)

Variables
gitem_armor_t	jacketarmor_info = { 25, 50, .30, .00, ARMOR_JACKET}
gitem_armor_t	combatarmor_info = { 50, 100, .60, .30, ARMOR_COMBAT}
gitem_armor_t	bodyarmor_info = {100, 200, .80, .60, ARMOR_BODY}
static int	jacket_armor_index
static int	combat_armor_index
static int	body_armor_index
static int	power_screen_index
static int	power_shield_index
static int	quad_drop_timeout_hack
gitem_t	itemlist []

Macro Definition Documentation

HEALTH_IGNORE_MAX

#define HEALTH_IGNORE_MAX   1

Definition at line 48 of file g_items.c.

HEALTH_TIMED

#define HEALTH_TIMED   2

Definition at line 49 of file g_items.c.

Function Documentation

Add_Ammo()

qboolean Add_Ammo	(	edict_t *	ent,
		gitem_t *	item,
		int	count
	)

Definition at line 426 of file g_items.c.

{
    int         index;
    int         max;
 
    if (!ent->client)
        return qfalse;
 
    if (item->tag == AMMO_BULLETS)
        max = ent->client->pers.max_bullets;
    else if (item->tag == AMMO_SHELLS)
        max = ent->client->pers.max_shells;
    else if (item->tag == AMMO_ROCKETS)
        max = ent->client->pers.max_rockets;
    else if (item->tag == AMMO_GRENADES)
        max = ent->client->pers.max_grenades;
    else if (item->tag == AMMO_CELLS)
        max = ent->client->pers.max_cells;
    else if (item->tag == AMMO_SLUGS)
        max = ent->client->pers.max_slugs;
    else
        return qfalse;
 
    index = ITEM_INDEX(item);
 
    if (ent->client->pers.inventory[index] == max)
        return qfalse;
 
    ent->client->pers.inventory[index] += count;
 
    if (ent->client->pers.inventory[index] > max)
        ent->client->pers.inventory[index] = max;
 
    return qtrue;
}

Referenced by Cmd_Give_f(), Pickup_Ammo(), and Pickup_Weapon().

ArmorIndex()

int ArmorIndex

(

edict_t *

ent

)

Definition at line 563 of file g_items.c.

{
    if (!ent->client)
        return 0;
 
    if (ent->client->pers.inventory[jacket_armor_index] > 0)
        return jacket_armor_index;
 
    if (ent->client->pers.inventory[combat_armor_index] > 0)
        return combat_armor_index;
 
    if (ent->client->pers.inventory[body_armor_index] > 0)
        return body_armor_index;
 
    return 0;
}

Referenced by CheckArmor(), G_SetStats(), and Pickup_Armor().

DoRespawn()

void DoRespawn

(

edict_t *

ent

)

Definition at line 116 of file g_items.c.

{
    if (ent->team) {
        edict_t *master;
        int count;
        int choice;
 
        master = ent->teammaster;
 
        for (count = 0, ent = master; ent; ent = ent->chain, count++)
            ;
 
        choice = rand() % count;
 
        for (count = 0, ent = master; count < choice; ent = ent->chain, count++)
            ;
    }
 
    ent->svflags &= ~SVF_NOCLIENT;
    ent->solid = SOLID_TRIGGER;
    gi.linkentity(ent);
 
    // send an effect
    ent->s.event = EV_ITEM_RESPAWN;
}

Referenced by droptofloor(), and SetRespawn().

Drop_Ammo()

void Drop_Ammo	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 491 of file g_items.c.

{
    edict_t *dropped;
    int     index;
 
    index = ITEM_INDEX(item);
    dropped = Drop_Item(ent, item);
    if (ent->client->pers.inventory[index] >= item->quantity)
        dropped->count = item->quantity;
    else
        dropped->count = ent->client->pers.inventory[index];
 
    if (ent->client->pers.weapon &&
        ent->client->pers.weapon->tag == AMMO_GRENADES &&
        item->tag == AMMO_GRENADES &&
        ent->client->pers.inventory[index] - dropped->count <= 0) {
        gi.cprintf(ent, PRINT_HIGH, "Can't drop current weapon\n");
        G_FreeEdict(dropped);
        return;
    }
 
    ent->client->pers.inventory[index] -= dropped->count;
    ValidateSelectedItem(ent);
}

Drop_General()

void Drop_General	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 181 of file g_items.c.

{
    Drop_Item(ent, item);
    ent->client->pers.inventory[ITEM_INDEX(item)]--;
    ValidateSelectedItem(ent);
}

Referenced by Drop_PowerArmor().

Drop_Item()

edict_t* Drop_Item	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 798 of file g_items.c.

{
    edict_t *dropped;
    vec3_t  forward, right;
    vec3_t  offset;
 
    dropped = G_Spawn();
 
    dropped->classname = item->classname;
    dropped->item = item;
    dropped->spawnflags = DROPPED_ITEM;
    dropped->s.effects = item->world_model_flags;
    dropped->s.renderfx = RF_GLOW;
    VectorSet(dropped->mins, -15, -15, -15);
    VectorSet(dropped->maxs, 15, 15, 15);
    gi.setmodel(dropped, dropped->item->world_model);
    dropped->solid = SOLID_TRIGGER;
    dropped->movetype = MOVETYPE_TOSS;
    dropped->touch = drop_temp_touch;
    dropped->owner = ent;
 
    if (ent->client) {
        trace_t trace;
 
        AngleVectors(ent->client->v_angle, forward, right, NULL);
        VectorSet(offset, 24, 0, -16);
        G_ProjectSource(ent->s.origin, offset, forward, right, dropped->s.origin);
        trace = gi.trace(ent->s.origin, dropped->mins, dropped->maxs,
                         dropped->s.origin, ent, CONTENTS_SOLID);
        VectorCopy(trace.endpos, dropped->s.origin);
    } else {
        AngleVectors(ent->s.angles, forward, right, NULL);
        VectorCopy(ent->s.origin, dropped->s.origin);
    }
 
    VectorScale(forward, 100, dropped->velocity);
    dropped->velocity[2] = 300;
 
    dropped->think = drop_make_touchable;
    dropped->nextthink = level.time + 1;
 
    gi.linkentity(dropped);
 
    return dropped;
}

Referenced by Drop_Ammo(), Drop_General(), Drop_Weapon(), monster_death_use(), and TossClientWeapon().

drop_make_touchable()

void drop_make_touchable

(

edict_t *

ent

)

Definition at line 789 of file g_items.c.

{
    ent->touch = Touch_Item;
    if (deathmatch->value) {
        ent->nextthink = level.time + 29;
        ent->think = G_FreeEdict;
    }
}

Referenced by Drop_Item().

Drop_PowerArmor()

void Drop_PowerArmor	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 709 of file g_items.c.

{
    if ((ent->flags & FL_POWER_ARMOR) && (ent->client->pers.inventory[ITEM_INDEX(item)] == 1))
        Use_PowerArmor(ent, item);
    Drop_General(ent, item);
}

drop_temp_touch()

void drop_temp_touch	(	edict_t *	ent,
		edict_t *	other,
		cplane_t *	plane,
		csurface_t *	surf
	)

Definition at line 781 of file g_items.c.

{
    if (other == ent->owner)
        return;
 
    Touch_Item(ent, other, plane, surf);
}

Referenced by Drop_Item().

Drop_Weapon()

void Drop_Weapon	(	edict_t *	ent,
		gitem_t *	inv
	)

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

droptofloor()

void droptofloor

(

edict_t *

ent

)

Definition at line 867 of file g_items.c.

{
    trace_t     tr;
    vec3_t      dest;
    float       *v;
 
    v = tv(-15, -15, -15);
    VectorCopy(v, ent->mins);
    v = tv(15, 15, 15);
    VectorCopy(v, ent->maxs);
 
    if (ent->model)
        gi.setmodel(ent, ent->model);
    else
        gi.setmodel(ent, ent->item->world_model);
    ent->solid = SOLID_TRIGGER;
    ent->movetype = MOVETYPE_TOSS;
    ent->touch = Touch_Item;
 
    v = tv(0, 0, -128);
    VectorAdd(ent->s.origin, v, dest);
 
    tr = gi.trace(ent->s.origin, ent->mins, ent->maxs, dest, ent, MASK_SOLID);
    if (tr.startsolid) {
        gi.dprintf("droptofloor: %s startsolid at %s\n", ent->classname, vtos(ent->s.origin));
        G_FreeEdict(ent);
        return;
    }
 
    VectorCopy(tr.endpos, ent->s.origin);
 
    if (ent->team) {
        ent->flags &= ~FL_TEAMSLAVE;
        ent->chain = ent->teamchain;
        ent->teamchain = NULL;
 
        ent->svflags |= SVF_NOCLIENT;
        ent->solid = SOLID_NOT;
        if (ent == ent->teammaster) {
            ent->nextthink = level.time + FRAMETIME;
            ent->think = DoRespawn;
        }
    }
 
    if (ent->spawnflags & ITEM_NO_TOUCH) {
        ent->solid = SOLID_BBOX;
        ent->touch = NULL;
        ent->s.effects &= ~EF_ROTATE;
        ent->s.renderfx &= ~RF_GLOW;
    }
 
    if (ent->spawnflags & ITEM_TRIGGER_SPAWN) {
        ent->svflags |= SVF_NOCLIENT;
        ent->solid = SOLID_NOT;
        ent->use = Use_Item;
    }
 
    gi.linkentity(ent);
}

Referenced by SpawnItem().

FindItem()

gitem_t* FindItem

(

char *

pickup_name

)

Definition at line 98 of file g_items.c.

{
    int     i;
    gitem_t *it;
 
    it = itemlist;
    for (i = 0 ; i < game.num_items ; i++, it++) {
        if (!it->pickup_name)
            continue;
        if (!Q_stricmp(it->pickup_name, pickup_name))
            return it;
    }
 
    return NULL;
}

Referenced by ChangeWeapon(), CheckPowerArmor(), Cmd_Drop_f(), Cmd_Give_f(), Cmd_Use_f(), G_SetStats(), InitClientPersistant(), NoAmmoWeaponChange(), Pickup_Ammo(), Pickup_Bandolier(), Pickup_Pack(), Pickup_Weapon(), PrecacheItem(), SetItemNames(), SP_item_health(), SP_item_health_large(), SP_item_health_mega(), SP_item_health_small(), SP_worldspawn(), Use_PowerArmor(), and Use_Weapon().

FindItemByClassname()

gitem_t* FindItemByClassname

(

char *

classname

)

Definition at line 76 of file g_items.c.

{
    int     i;
    gitem_t *it;
 
    it = itemlist;
    for (i = 0 ; i < game.num_items ; i++, it++) {
        if (!it->classname)
            continue;
        if (!Q_stricmp(it->classname, classname))
            return it;
    }
 
    return NULL;
}

Referenced by monster_start(), SP_trigger_key(), SP_turret_driver(), and TossClientWeapon().

GetItemByIndex()

gitem_t* GetItemByIndex

(

int

index

)

Definition at line 61 of file g_items.c.

{
    if (index == 0 || index >= game.num_items)
        return NULL;
 
    return &itemlist[index];
}

Referenced by CheckArmor(), and G_SetStats().

InitItems()

void InitItems

(

void

)

Definition at line 2132 of file g_items.c.

{
    game.num_items = sizeof(itemlist) / sizeof(itemlist[0]) - 1;
}

Referenced by InitGame().

MegaHealth_think()

void MegaHealth_think

(

edict_t *

self

)

Definition at line 519 of file g_items.c.

{
    if (self->owner->health > self->owner->max_health) {
        self->nextthink = level.time + 1;
        self->owner->health -= 1;
        return;
    }
 
    if (!(self->spawnflags & DROPPED_ITEM) && (deathmatch->value))
        SetRespawn(self, 20);
    else
        G_FreeEdict(self);
}

Referenced by Pickup_Health().

Pickup_Adrenaline()

qboolean Pickup_Adrenaline	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 191 of file g_items.c.

{
    if (!deathmatch->value)
        other->max_health += 1;
 
    if (other->health < other->max_health)
        other->health = other->max_health;
 
    if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
        SetRespawn(ent, ent->item->quantity);
 
    return qtrue;
}

Referenced by SpawnItem().

Pickup_Ammo()

qboolean Pickup_Ammo	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 462 of file g_items.c.

{
    int         oldcount;
    int         count;
    qboolean    weapon;
 
    weapon = (ent->item->flags & IT_WEAPON);
    if ((weapon) && ((int)dmflags->value & DF_INFINITE_AMMO))
        count = 1000;
    else if (ent->count)
        count = ent->count;
    else
        count = ent->item->quantity;
 
    oldcount = other->client->pers.inventory[ITEM_INDEX(ent->item)];
 
    if (!Add_Ammo(other, ent->item, count))
        return qfalse;
 
    if (weapon && !oldcount) {
        if (other->client->pers.weapon != ent->item && (!deathmatch->value || other->client->pers.weapon == FindItem("blaster")))
            other->client->newweapon = ent->item;
    }
 
    if (!(ent->spawnflags & (DROPPED_ITEM | DROPPED_PLAYER_ITEM)) && (deathmatch->value))
        SetRespawn(ent, 30);
    return qtrue;
}

Pickup_AncientHead()

qboolean Pickup_AncientHead	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 205 of file g_items.c.

{
    other->max_health += 2;
 
    if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
        SetRespawn(ent, ent->item->quantity);
 
    return qtrue;
}

Referenced by SpawnItem().

Pickup_Armor()

qboolean Pickup_Armor	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 580 of file g_items.c.

{
    int             old_armor_index;
    gitem_armor_t   *oldinfo;
    gitem_armor_t   *newinfo;
    int             newcount;
    float           salvage;
    int             salvagecount;
 
    // get info on new armor
    newinfo = (gitem_armor_t *)ent->item->info;
 
    old_armor_index = ArmorIndex(other);
 
    // handle armor shards specially
    if (ent->item->tag == ARMOR_SHARD) {
        if (!old_armor_index)
            other->client->pers.inventory[jacket_armor_index] = 2;
        else
            other->client->pers.inventory[old_armor_index] += 2;
    }
 
    // if player has no armor, just use it
    else if (!old_armor_index) {
        other->client->pers.inventory[ITEM_INDEX(ent->item)] = newinfo->base_count;
    }
 
    // use the better armor
    else {
        // get info on old armor
        if (old_armor_index == jacket_armor_index)
            oldinfo = &jacketarmor_info;
        else if (old_armor_index == combat_armor_index)
            oldinfo = &combatarmor_info;
        else // (old_armor_index == body_armor_index)
            oldinfo = &bodyarmor_info;
 
        if (newinfo->normal_protection > oldinfo->normal_protection) {
            // calc new armor values
            salvage = oldinfo->normal_protection / newinfo->normal_protection;
            salvagecount = salvage * other->client->pers.inventory[old_armor_index];
            newcount = newinfo->base_count + salvagecount;
            if (newcount > newinfo->max_count)
                newcount = newinfo->max_count;
 
            // zero count of old armor so it goes away
            other->client->pers.inventory[old_armor_index] = 0;
 
            // change armor to new item with computed value
            other->client->pers.inventory[ITEM_INDEX(ent->item)] = newcount;
        } else {
            // calc new armor values
            salvage = newinfo->normal_protection / oldinfo->normal_protection;
            salvagecount = salvage * newinfo->base_count;
            newcount = other->client->pers.inventory[old_armor_index] + salvagecount;
            if (newcount > oldinfo->max_count)
                newcount = oldinfo->max_count;
 
            // if we're already maxed out then we don't need the new armor
            if (other->client->pers.inventory[old_armor_index] >= newcount)
                return qfalse;
 
            // update current armor value
            other->client->pers.inventory[old_armor_index] = newcount;
        }
    }
 
    if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
        SetRespawn(ent, 20);
 
    return qtrue;
}

Referenced by SpawnItem().

Pickup_Bandolier()

qboolean Pickup_Bandolier	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 215 of file g_items.c.

{
    gitem_t *item;
    int     index;
 
    if (other->client->pers.max_bullets < 250)
        other->client->pers.max_bullets = 250;
    if (other->client->pers.max_shells < 150)
        other->client->pers.max_shells = 150;
    if (other->client->pers.max_cells < 250)
        other->client->pers.max_cells = 250;
    if (other->client->pers.max_slugs < 75)
        other->client->pers.max_slugs = 75;
 
    item = FindItem("Bullets");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_bullets)
            other->client->pers.inventory[index] = other->client->pers.max_bullets;
    }
 
    item = FindItem("Shells");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_shells)
            other->client->pers.inventory[index] = other->client->pers.max_shells;
    }
 
    if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
        SetRespawn(ent, ent->item->quantity);
 
    return qtrue;
}

Pickup_Health()

qboolean Pickup_Health	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 533 of file g_items.c.

{
    if (!(ent->style & HEALTH_IGNORE_MAX))
        if (other->health >= other->max_health)
            return qfalse;
 
    other->health += ent->count;
 
    if (!(ent->style & HEALTH_IGNORE_MAX)) {
        if (other->health > other->max_health)
            other->health = other->max_health;
    }
 
    if (ent->style & HEALTH_TIMED) {
        ent->think = MegaHealth_think;
        ent->nextthink = level.time + 5;
        ent->owner = other;
        ent->flags |= FL_RESPAWN;
        ent->svflags |= SVF_NOCLIENT;
        ent->solid = SOLID_NOT;
    } else {
        if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
            SetRespawn(ent, 30);
    }
 
    return qtrue;
}

Referenced by SpawnItem(), and Touch_Item().

Pickup_Key()

qboolean Pickup_Key	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 405 of file g_items.c.

{
    if (coop->value) {
        if (strcmp(ent->classname, "key_power_cube") == 0) {
            if (other->client->pers.power_cubes & ((ent->spawnflags & 0x0000ff00) >> 8))
                return qfalse;
            other->client->pers.inventory[ITEM_INDEX(ent->item)]++;
            other->client->pers.power_cubes |= ((ent->spawnflags & 0x0000ff00) >> 8);
        } else {
            if (other->client->pers.inventory[ITEM_INDEX(ent->item)])
                return qfalse;
            other->client->pers.inventory[ITEM_INDEX(ent->item)] = 1;
        }
        return qtrue;
    }
    other->client->pers.inventory[ITEM_INDEX(ent->item)]++;
    return qtrue;
}

Pickup_Pack()

qboolean Pickup_Pack	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 251 of file g_items.c.

{
    gitem_t *item;
    int     index;
 
    if (other->client->pers.max_bullets < 300)
        other->client->pers.max_bullets = 300;
    if (other->client->pers.max_shells < 200)
        other->client->pers.max_shells = 200;
    if (other->client->pers.max_rockets < 100)
        other->client->pers.max_rockets = 100;
    if (other->client->pers.max_grenades < 100)
        other->client->pers.max_grenades = 100;
    if (other->client->pers.max_cells < 300)
        other->client->pers.max_cells = 300;
    if (other->client->pers.max_slugs < 100)
        other->client->pers.max_slugs = 100;
 
    item = FindItem("Bullets");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_bullets)
            other->client->pers.inventory[index] = other->client->pers.max_bullets;
    }
 
    item = FindItem("Shells");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_shells)
            other->client->pers.inventory[index] = other->client->pers.max_shells;
    }
 
    item = FindItem("Cells");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_cells)
            other->client->pers.inventory[index] = other->client->pers.max_cells;
    }
 
    item = FindItem("Grenades");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_grenades)
            other->client->pers.inventory[index] = other->client->pers.max_grenades;
    }
 
    item = FindItem("Rockets");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_rockets)
            other->client->pers.inventory[index] = other->client->pers.max_rockets;
    }
 
    item = FindItem("Slugs");
    if (item) {
        index = ITEM_INDEX(item);
        other->client->pers.inventory[index] += item->quantity;
        if (other->client->pers.inventory[index] > other->client->pers.max_slugs)
            other->client->pers.inventory[index] = other->client->pers.max_slugs;
    }
 
    if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
        SetRespawn(ent, ent->item->quantity);
 
    return qtrue;
}

Pickup_PowerArmor()

qboolean Pickup_PowerArmor	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 690 of file g_items.c.

{
    int     quantity;
 
    quantity = other->client->pers.inventory[ITEM_INDEX(ent->item)];
 
    other->client->pers.inventory[ITEM_INDEX(ent->item)]++;
 
    if (deathmatch->value) {
        if (!(ent->spawnflags & DROPPED_ITEM))
            SetRespawn(ent, ent->item->quantity);
        // auto-use for DM only if we didn't already have one
        if (!quantity)
            ent->item->use(other, ent->item);
    }
 
    return qtrue;
}

Referenced by SpawnItem().

Pickup_Powerup()

qboolean Pickup_Powerup	(	edict_t *	ent,
		edict_t *	other
	)

Definition at line 155 of file g_items.c.

{
    int     quantity;
 
    quantity = other->client->pers.inventory[ITEM_INDEX(ent->item)];
    if ((skill->value == 1 && quantity >= 2) || (skill->value >= 2 && quantity >= 1))
        return qfalse;
 
    if ((coop->value) && (ent->item->flags & IT_STAY_COOP) && (quantity > 0))
        return qfalse;
 
    other->client->pers.inventory[ITEM_INDEX(ent->item)]++;
 
    if (deathmatch->value) {
        if (!(ent->spawnflags & DROPPED_ITEM))
            SetRespawn(ent, ent->item->quantity);
        if (((int)dmflags->value & DF_INSTANT_ITEMS) || ((ent->item->use == Use_Quad) && (ent->spawnflags & DROPPED_PLAYER_ITEM))) {
            if ((ent->item->use == Use_Quad) && (ent->spawnflags & DROPPED_PLAYER_ITEM))
                quad_drop_timeout_hack = (ent->nextthink - level.time) / FRAMETIME;
            ent->item->use(other, ent->item);
        }
    }
 
    return qtrue;
}

Referenced by SpawnItem().

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

PowerArmorType()

int PowerArmorType

(

edict_t *

ent

)

Definition at line 655 of file g_items.c.

{
    if (!ent->client)
        return POWER_ARMOR_NONE;
 
    if (!(ent->flags & FL_POWER_ARMOR))
        return POWER_ARMOR_NONE;
 
    if (ent->client->pers.inventory[power_shield_index] > 0)
        return POWER_ARMOR_SHIELD;
 
    if (ent->client->pers.inventory[power_screen_index] > 0)
        return POWER_ARMOR_SCREEN;
 
    return POWER_ARMOR_NONE;
}

Referenced by CheckPowerArmor(), G_SetClientEffects(), and G_SetStats().

PrecacheItem()

void PrecacheItem

(

gitem_t *

it

)

Definition at line 937 of file g_items.c.

{
    char    *s, *start;
    char    data[MAX_QPATH];
    int     len;
    gitem_t *ammo;
 
    if (!it)
        return;
 
    if (it->pickup_sound)
        gi.soundindex(it->pickup_sound);
    if (it->world_model)
        gi.modelindex(it->world_model);
    if (it->view_model)
        gi.modelindex(it->view_model);
    if (it->icon)
        gi.imageindex(it->icon);
 
    // parse everything for its ammo
    if (it->ammo && it->ammo[0]) {
        ammo = FindItem(it->ammo);
        if (ammo != it)
            PrecacheItem(ammo);
    }
 
    // parse the space seperated precache string for other items
    s = it->precaches;
    if (!s || !s[0])
        return;
 
    while (*s) {
        start = s;
        while (*s && *s != ' ')
            s++;
 
        len = s - start;
        if (len >= MAX_QPATH || len < 5)
            gi.error("PrecacheItem: %s has bad precache string", it->classname);
        memcpy(data, start, len);
        data[len] = 0;
        if (*s)
            s++;
 
        // determine type based on extension
        if (!strcmp(data + len - 3, "md2"))
            gi.modelindex(data);
        else if (!strcmp(data + len - 3, "sp2"))
            gi.modelindex(data);
        else if (!strcmp(data + len - 3, "wav"))
            gi.soundindex(data);
        if (!strcmp(data + len - 3, "pcx"))
            gi.imageindex(data);
    }
}

Referenced by PrecacheItem(), SP_worldspawn(), and SpawnItem().

SetItemNames()

void SetItemNames

(

void

)

Definition at line 2146 of file g_items.c.

{
    int     i;
    gitem_t *it;
 
    for (i = 0 ; i < game.num_items ; i++) {
        it = &itemlist[i];
        gi.configstring(CS_ITEMS + i, it->pickup_name);
    }
 
    jacket_armor_index = ITEM_INDEX(FindItem("Jacket Armor"));
    combat_armor_index = ITEM_INDEX(FindItem("Combat Armor"));
    body_armor_index   = ITEM_INDEX(FindItem("Body Armor"));
    power_screen_index = ITEM_INDEX(FindItem("Power Screen"));
    power_shield_index = ITEM_INDEX(FindItem("Power Shield"));
}

Referenced by SP_worldspawn().

SetRespawn()

void SetRespawn	(	edict_t *	ent,
		float	delay
	)

Definition at line 142 of file g_items.c.

{
    ent->flags |= FL_RESPAWN;
    ent->svflags |= SVF_NOCLIENT;
    ent->solid = SOLID_NOT;
    ent->nextthink = level.time + delay;
    ent->think = DoRespawn;
    gi.linkentity(ent);
}

Referenced by MegaHealth_think(), Pickup_Adrenaline(), Pickup_Ammo(), Pickup_AncientHead(), Pickup_Armor(), Pickup_Bandolier(), Pickup_Health(), Pickup_Pack(), Pickup_PowerArmor(), Pickup_Powerup(), and Pickup_Weapon().

SP_item_health()

void SP_item_health

(

edict_t *

self

)

Definition at line 2071 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/healing/medium/tris.md2";
    self->count = 10;
    SpawnItem(self, FindItem("Health"));
    gi.soundindex("items/n_health.wav");
}

SP_item_health_large()

void SP_item_health_large

(

edict_t *

self

)

Definition at line 2102 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/healing/large/tris.md2";
    self->count = 25;
    SpawnItem(self, FindItem("Health"));
    gi.soundindex("items/l_health.wav");
}

SP_item_health_mega()

void SP_item_health_mega

(

edict_t *

self

)

Definition at line 2117 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/mega_h/tris.md2";
    self->count = 100;
    SpawnItem(self, FindItem("Health"));
    gi.soundindex("items/m_health.wav");
    self->style = HEALTH_IGNORE_MAX | HEALTH_TIMED;
}

SP_item_health_small()

void SP_item_health_small

(

edict_t *

self

)

Definition at line 2086 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/healing/stimpack/tris.md2";
    self->count = 2;
    SpawnItem(self, FindItem("Health"));
    self->style = HEALTH_IGNORE_MAX;
    gi.soundindex("items/s_health.wav");
}

SpawnItem()

void SpawnItem	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 1003 of file g_items.c.

{
    PrecacheItem(item);
 
    if (ent->spawnflags) {
        if (strcmp(ent->classname, "key_power_cube") != 0) {
            ent->spawnflags = 0;
            gi.dprintf("%s at %s has invalid spawnflags set\n", ent->classname, vtos(ent->s.origin));
        }
    }
 
    // some items will be prevented in deathmatch
    if (deathmatch->value) {
        if ((int)dmflags->value & DF_NO_ARMOR) {
            if (item->pickup == Pickup_Armor || item->pickup == Pickup_PowerArmor) {
                G_FreeEdict(ent);
                return;
            }
        }
        if ((int)dmflags->value & DF_NO_ITEMS) {
            if (item->pickup == Pickup_Powerup) {
                G_FreeEdict(ent);
                return;
            }
        }
        if ((int)dmflags->value & DF_NO_HEALTH) {
            if (item->pickup == Pickup_Health || item->pickup == Pickup_Adrenaline || item->pickup == Pickup_AncientHead) {
                G_FreeEdict(ent);
                return;
            }
        }
        if ((int)dmflags->value & DF_INFINITE_AMMO) {
            if ((item->flags == IT_AMMO) || (strcmp(ent->classname, "weapon_bfg") == 0)) {
                G_FreeEdict(ent);
                return;
            }
        }
    }
 
    if (coop->value && (strcmp(ent->classname, "key_power_cube") == 0)) {
        ent->spawnflags |= (1 << (8 + level.power_cubes));
        level.power_cubes++;
    }
 
    // don't let them drop items that stay in a coop game
    if ((coop->value) && (item->flags & IT_STAY_COOP)) {
        item->drop = NULL;
    }
 
    ent->item = item;
    ent->nextthink = level.time + 2 * FRAMETIME;    // items start after other solids
    ent->think = droptofloor;
    ent->s.effects = item->world_model_flags;
    ent->s.renderfx = RF_GLOW;
    if (ent->model)
        gi.modelindex(ent->model);
}

Referenced by Cmd_Give_f(), ED_CallSpawn(), SP_item_health(), SP_item_health_large(), SP_item_health_mega(), and SP_item_health_small().

Touch_Item()

void Touch_Item	(	edict_t *	ent,
		edict_t *	other,
		cplane_t *	plane,
		csurface_t *	surf
	)

Definition at line 723 of file g_items.c.

{
    qboolean    taken;
 
    if (!other->client)
        return;
    if (other->health < 1)
        return;     // dead people can't pickup
    if (!ent->item->pickup)
        return;     // not a grabbable item?
 
    taken = ent->item->pickup(ent, other);
 
    if (taken) {
        // flash the screen
        other->client->bonus_alpha = 0.25;
 
        // show icon and name on status bar
        other->client->ps.stats[STAT_PICKUP_ICON] = gi.imageindex(ent->item->icon);
        other->client->ps.stats[STAT_PICKUP_STRING] = CS_ITEMS + ITEM_INDEX(ent->item);
        other->client->pickup_msg_time = level.time + 3.0;
 
        // change selected item
        if (ent->item->use)
            other->client->pers.selected_item = other->client->ps.stats[STAT_SELECTED_ITEM] = ITEM_INDEX(ent->item);
 
        if (ent->item->pickup == Pickup_Health) {
            if (ent->count == 2)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/s_health.wav"), 1, ATTN_NORM, 0);
            else if (ent->count == 10)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/n_health.wav"), 1, ATTN_NORM, 0);
            else if (ent->count == 25)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/l_health.wav"), 1, ATTN_NORM, 0);
            else // (ent->count == 100)
                gi.sound(other, CHAN_ITEM, gi.soundindex("items/m_health.wav"), 1, ATTN_NORM, 0);
        } else if (ent->item->pickup_sound) {
            gi.sound(other, CHAN_ITEM, gi.soundindex(ent->item->pickup_sound), 1, ATTN_NORM, 0);
        }
    }
 
    if (!(ent->spawnflags & ITEM_TARGETS_USED)) {
        G_UseTargets(ent, other);
        ent->spawnflags |= ITEM_TARGETS_USED;
    }
 
    if (!taken)
        return;
 
    if (!((coop->value) && (ent->item->flags & IT_STAY_COOP)) || (ent->spawnflags & (DROPPED_ITEM | DROPPED_PLAYER_ITEM))) {
        if (ent->flags & FL_RESPAWN)
            ent->flags &= ~FL_RESPAWN;
        else
            G_FreeEdict(ent);
    }
}

Referenced by Cmd_Give_f(), drop_make_touchable(), drop_temp_touch(), droptofloor(), TossClientWeapon(), and Use_Item().

Use_Breather()

void Use_Breather	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 349 of file g_items.c.

{
    ent->client->pers.inventory[ITEM_INDEX(item)]--;
    ValidateSelectedItem(ent);
 
    if (ent->client->breather_framenum > level.framenum)
        ent->client->breather_framenum += 300;
    else
        ent->client->breather_framenum = level.framenum + 300;
 
//  gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage.wav"), 1, ATTN_NORM, 0);
}

Use_Envirosuit()

void Use_Envirosuit	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 364 of file g_items.c.

{
    ent->client->pers.inventory[ITEM_INDEX(item)]--;
    ValidateSelectedItem(ent);
 
    if (ent->client->enviro_framenum > level.framenum)
        ent->client->enviro_framenum += 300;
    else
        ent->client->enviro_framenum = level.framenum + 300;
 
//  gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage.wav"), 1, ATTN_NORM, 0);
}

Use_Invulnerability()

void Use_Invulnerability	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 379 of file g_items.c.

{
    ent->client->pers.inventory[ITEM_INDEX(item)]--;
    ValidateSelectedItem(ent);
 
    if (ent->client->invincible_framenum > level.framenum)
        ent->client->invincible_framenum += 300;
    else
        ent->client->invincible_framenum = level.framenum + 300;
 
    gi.sound(ent, CHAN_ITEM, gi.soundindex("items/protect.wav"), 1, ATTN_NORM, 0);
}

Use_Item()

void Use_Item	(	edict_t *	ent,
		edict_t *	other,
		edict_t *	activator
	)

Definition at line 844 of file g_items.c.

{
    ent->svflags &= ~SVF_NOCLIENT;
    ent->use = NULL;
 
    if (ent->spawnflags & ITEM_NO_TOUCH) {
        ent->solid = SOLID_BBOX;
        ent->touch = NULL;
    } else {
        ent->solid = SOLID_TRIGGER;
        ent->touch = Touch_Item;
    }
 
    gi.linkentity(ent);
}

Referenced by droptofloor().

Use_PowerArmor()

void Use_PowerArmor	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 672 of file g_items.c.

{
    int     index;
 
    if (ent->flags & FL_POWER_ARMOR) {
        ent->flags &= ~FL_POWER_ARMOR;
        gi.sound(ent, CHAN_AUTO, gi.soundindex("misc/power2.wav"), 1, ATTN_NORM, 0);
    } else {
        index = ITEM_INDEX(FindItem("cells"));
        if (!ent->client->pers.inventory[index]) {
            gi.cprintf(ent, PRINT_HIGH, "No cells for power armor.\n");
            return;
        }
        ent->flags |= FL_POWER_ARMOR;
        gi.sound(ent, CHAN_AUTO, gi.soundindex("misc/power1.wav"), 1, ATTN_NORM, 0);
    }
}

Referenced by Drop_PowerArmor().

Use_Quad()

void Use_Quad	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 325 of file g_items.c.

{
    int     timeout;
 
    ent->client->pers.inventory[ITEM_INDEX(item)]--;
    ValidateSelectedItem(ent);
 
    if (quad_drop_timeout_hack) {
        timeout = quad_drop_timeout_hack;
        quad_drop_timeout_hack = 0;
    } else {
        timeout = 300;
    }
 
    if (ent->client->quad_framenum > level.framenum)
        ent->client->quad_framenum += timeout;
    else
        ent->client->quad_framenum = level.framenum + timeout;
 
    gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage.wav"), 1, ATTN_NORM, 0);
}

Referenced by Pickup_Powerup().

Use_Silencer()

void Use_Silencer	(	edict_t *	ent,
		gitem_t *	item
	)

Definition at line 394 of file g_items.c.

{
    ent->client->pers.inventory[ITEM_INDEX(item)]--;
    ValidateSelectedItem(ent);
    ent->client->silencer_shots += 30;
 
//  gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage.wav"), 1, ATTN_NORM, 0);
}

Use_Weapon()

void Use_Weapon	(	edict_t *	ent,
		gitem_t *	inv
	)

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

Variable Documentation

body_armor_index

int body_armor_index

static

Definition at line 44 of file g_items.c.

Referenced by ArmorIndex(), and SetItemNames().

bodyarmor_info

gitem_armor_t bodyarmor_info = {100, 200, .80, .60, ARMOR_BODY}

Definition at line 40 of file g_items.c.

Referenced by Pickup_Armor().

combat_armor_index

int combat_armor_index

static

Definition at line 43 of file g_items.c.

Referenced by ArmorIndex(), Pickup_Armor(), and SetItemNames().

combatarmor_info

gitem_armor_t combatarmor_info = { 50, 100, .60, .30, ARMOR_COMBAT}

Definition at line 39 of file g_items.c.

Referenced by Pickup_Armor().

itemlist

gitem_t itemlist[]

Definition at line 1063 of file g_items.c.

Referenced by BeginIntermission(), Cmd_Give_f(), Cmd_InvDrop_f(), Cmd_InvUse_f(), Cmd_WeapLast_f(), Cmd_WeapNext_f(), Cmd_WeapPrev_f(), ED_CallSpawn(), FindItem(), FindItemByClassname(), G_SetStats(), GetItemByIndex(), InitItems(), player_die(), read_field(), SelectNextItem(), SelectPrevItem(), SetItemNames(), and write_field().

jacket_armor_index

int jacket_armor_index

static

Definition at line 42 of file g_items.c.

Referenced by ArmorIndex(), Pickup_Armor(), and SetItemNames().

jacketarmor_info

gitem_armor_t jacketarmor_info = { 25, 50, .30, .00, ARMOR_JACKET}

Definition at line 38 of file g_items.c.

Referenced by Pickup_Armor().

power_screen_index

int power_screen_index

static

Definition at line 45 of file g_items.c.

Referenced by PowerArmorType(), and SetItemNames().

power_shield_index

int power_shield_index

static

Definition at line 46 of file g_items.c.

Referenced by PowerArmorType(), and SetItemNames().

quad_drop_timeout_hack

int quad_drop_timeout_hack

static

Definition at line 52 of file g_items.c.

Referenced by Pickup_Powerup(), and Use_Quad().