djcev.com

//==============================================================================
// backpacks -- Player Backpacks
//==============================================================================

//======================================================================
// constants
//======================================================================

#ifdef SSQC
//----------------------------------------------------------------------
// backpack spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SPAWNFLAG_ITEM_BACKPACK_DEFAULT = 1, // default logic
        SPAWNFLAG_ITEM_BACKPACK_SHELLS = 2, // pack contains shells
        SPAWNFLAG_ITEM_BACKPACK_NAILS = 4, // pack contains nails
        SPAWNFLAG_ITEM_BACKPACK_ROCKETS = 8, // pack contains rockets
        SPAWNFLAG_ITEM_BACKPACK_CELLS = 16, // pack contains cells
        SPAWNFLAG_ITEM_BACKPACK_DROPPED = 32 // overlaps with SPAWNSILENT
        // SPAWNFLAG_ITEM_SPAWNSILENT = 32, // see base_item.qc -- CEV
        // SPAWNFLAG_ITEM_SPAWNED = 64, // see base_item.qc -- CEV
        // SPAWNFLAG_ITEM_SUSPENDED = 128, // see base_item.qc -- CEV
        // SPAWNFLAG_NOT_ON_EASY = 256, // next six see base_entities.qc -- CEV
        // SPAWNFLAG_NOT_ON_NORMAL = 512,
        // SPAWNFLAG_NOT_ON_HARD_OR_NIGHTMARE = 1024,
        // SPAWNFLAG_NOT_IN_DEATHMATCH = 2048,
        // SPAWNFLAG_NOT_IN_COOP = 4096,
        // SPAWNFLAG_NOT_IN_SP = 8192,
        // SPAWNFLAG_NOT_ON_SKILL2 = 32768, // see base_entities.qc -- CEV
        // SPAWNFLAG_NOT_ON_SKILL3 = 65536, // see base_entities.qc -- CEV
        // SPAWNFLAG_CENTERPRINTALL = 131072 // see base_entities.qc -- CEV
        // SPAWNFLAG_ITEM_RESPAWN = 2097152, // see base_item.qc -- CEV
        // SPAWNFLAG_ITEM_THROWN = 4194304, // see base_item.qc -- CEV
        // SPAWNFLAG_ITEM_DONTDROP = 8388608 // see base_item.qc -- CEV
} item_backpack_spawnflags;
#endif

//======================================================================
// forward declarations
//======================================================================

// item_backpack
#ifdef CSQC
void(float isnew) item_backpack_netreceive;
#endif
#ifdef SSQC
// ITEM_BACKPACK_MESSAGE(field, name)
void() item_backpack_think_groundcheck;
void() item_backpack_touch;
entity(entity src) item_backpack_drop;
entity(entity src, vector org, vector vel) spawn_item_backpack;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) item_backpack_init;
#endif
#ifdef SSQC
void() item_backpack;
#endif

//------------------------------------------------------------------------------

// Some of this text is from Drake -- dumptruck_ds

/*QUAKED item_backpack (0 .5 .8) (-16 -16 0) (16 16 72) SHELLS NAILS ROCKETS CELLS X SPAWN_SILENT TRIGGER_SPAWNED SUSPENDED_IN_AIR NOT_ON_EASY NOT_ON_NORMAL NOT_ON_HARD_OR_NIGHTMARE NOT_IN_DEATHMATCH NOT_IN_COOP NOT_IN_SINGLEPLAYER X NOT_ON_HARD_ONLY NOT_ON_NIGHTMARE_ONLY
{       model("progs/backpack.mdl");    }
By default, gives roughly half the ammo from the 4 standard pickups:

10 Shells
12 Nails
2 Rockets
3 Cells

Or you can use the spawnflags to mix and match types.
Override the spawnflags defaults by adding custom amounts to:

ammo_shells
ammo_nails
ammo_rockets
ammo_cells

Can trigger spawn and suspend in air, but not respawn. You can set a skin
index if you are using a custom model with skins.

The default pickup message is `You got a backpack.` But you can
set a custom message with the netname key. 'You got' will be the prefix
and the mapper chooses the rest of the message.

e.g. For 'You got a bunch of rockets!' the netname key would be
'a bunch of rockets!'
*/
//----------------------------------------------------------------------
// class item_backpack: base_item
// {
#ifdef CSQC
        //--------------------------------------------------------------
        void(float isnew) item_backpack_netreceive =
        {
                // creates a number of variables, including netflags -- CEV
                BASE_ITEM_NETRECEIVE (item_backpack_init)
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        #define ITEM_BACKPACK_MESSAGE(field, name) \
        { \
                if (self.field) \
                { \
                        if (acount) \
                                s = sprintf ("%s, %d " name, s, self.field); \
                        else \
                                s = sprintf ("%s %d " name, s, self.field); \
                        acount += 1; \
                } \
        }

        //--------------------------------------------------------------
        void() item_backpack_think_groundcheck =
        {
                if (self.flags & FL_ONGROUND)
                {
                        self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN;
                        self.think = sub_remove;
                        self.nextthink = time + 120;
                }
                else
                {
                        self.nextthink = time + 0.1;
                }
        };

        //--------------------------------------------------------------
        void() item_backpack_touch =
        {
                if (sub_checkvalidtouch(other) == FALSE)
                        return;

                // don't touch if other isn't holding a weapon -- CEV
                BASE_ENTITY_WEAPONLOOKUP (other)
                if (item_index < ITEM_SEQ_W_START||item_index > ITEM_SEQ_W_END)
                {
                        if (item_index != ITEM_SEQ_HANDS)
                                return;
                        if (!other.button6 && (!(other.flags & FL_THROW_HELD)))
                                return;
                }

                // add self.inventory1 (stored weapon) to other -- CEV
                if (self.inventory1)
                {
                        local float slot = 0;

                        // look up the default slot for this weapon -- CEV
                        switch (self.inventory1)
                        {
                                case ITEM_SEQ_AXE:
                                        slot = ITEM_WEAPON_AXE;
                                        break;
                                case ITEM_SEQ_SHOTGUN:
                                        slot = ITEM_WEAPON_SHOTGUN;
                                        break;
                                case ITEM_SEQ_SUPERSHOTGUN:
                                        slot = ITEM_WEAPON_SUPERSHOTGUN;
                                        break;
                                case ITEM_SEQ_NAILGUN:
                                        slot = ITEM_WEAPON_NAILGUN;
                                        break;
                                case ITEM_SEQ_SUPERNAILGUN:
                                        slot = ITEM_WEAPON_SUPERNAILGUN;
                                        break;
                                case ITEM_SEQ_GRENADELAUNCHER:
                                        slot = ITEM_WEAPON_GRENADELAUNCHER;
                                        break;
                                case ITEM_SEQ_ROCKETLAUNCHER:
                                        slot = ITEM_WEAPON_ROCKETLAUNCHER;
                                        break;
                                case ITEM_SEQ_LIGHTNINGGUN:
                                        slot = ITEM_WEAPON_LIGHTNINGGUN;
                                        break;
                        }

                        // now add the weapon if that slot is empty -- CEV
                        switch (slot)
                        {
                                case 1:
                                        if (other.inventory1 == ITEM_SEQ_HANDS)
                                                other.inventory1 =
                                                        self.inventory1;
                                        break;
                                case 2:
                                        if (other.inventory2 == ITEM_SEQ_HANDS)
                                                other.inventory2 =
                                                        self.inventory1;
                                        break;
                                case 3:
                                        if (other.inventory3 == ITEM_SEQ_HANDS)
                                                other.inventory3 =
                                                        self.inventory1;
                                        break;
                                case 4:
                                        if (other.inventory4 == ITEM_SEQ_HANDS)
                                                other.inventory4 =
                                                        self.inventory1;
                                        break;
                                case 5:
                                        if (other.inventory5 == ITEM_SEQ_HANDS)
                                                other.inventory5 =
                                                        self.inventory1;
                                        break;
                                case 6:
                                        if (other.inventory6 == ITEM_SEQ_HANDS)
                                                other.inventory6 =
                                                        self.inventory1;
                                        break;
                                case 7:
                                        if (other.inventory7 == ITEM_SEQ_HANDS)
                                                other.inventory7 =
                                                        self.inventory1;
                                        break;
                                case 8:
                                        if (other.inventory8 == ITEM_SEQ_HANDS)
                                                other.inventory8 =
                                                        self.inventory1;
                                        break;
                                default:
                                        dprint (sprintf("item_backpack_touch: "
                                                "unknown slot for item index "
                                                "%d!\n", self.inventory1));
                                        break;
                        }
                }

                // add ammo -- CEV
                other.ammo_shells += self.ammo_shells;
                other.ammo_nails += self.ammo_nails;
                other.ammo_rockets += self.ammo_rockets;
                other.ammo_cells += self.ammo_cells;

                // build the backpack message -- calls sprintf a lot -- CEV
                local string s = sprintf ("%s gets", other.netname);

                if (self.spawnflags & SPAWNFLAG_ITEM_BACKPACK_DROPPED)
                {
                        local float acount = 0;

                        // include self.netname if an item is stored in
                        // inventory slot 1 -- CEV
                        if (self.inventory1)
                        {
                                s = sprintf ("%s the %s", s, self.netname);
                                acount += 1;
                        }

                        // now do the ammo -- CEV
                        ITEM_BACKPACK_MESSAGE (ammo_shells, "shells")
                        ITEM_BACKPACK_MESSAGE (ammo_nails, "nails")
                        ITEM_BACKPACK_MESSAGE (ammo_rockets, "rockets")
                        ITEM_BACKPACK_MESSAGE (ammo_cells, "cells")

                        s = sprintf ("%s!\n", s);
                }
                else
                {
                        if (self.netname != "")
                                s = sprintf ("%s %s!\n", s, self.netname);
                        else
                                s = sprintf ("%s a backpack!\n", s);
                }

                // print the backpack message -- CEV
                sprint (other, s);

                // backpack touch sound
                sound (other, CHAN_ITEM, self.noise, VOL_HIGH, ATTN_NORM);

                // flash, bound ammo, & update CSQC clients -- CEV
                if (other.classtype == CT_PLAYER)
                {
                        stuffcmd (other, "bf\n");
                        base_entity_boundammo (other);
                        if (other.SendEntity)
                                other.SendFlags |= NETFLAG_PLAYER_AMMO |
                                        NETFLAG_PLAYER_WEAPON |
                                        NETFLAG_PLAYER_INVENTORY;
                }

                remove (self);
        };

        //--------------------------------------------------------------
        // DropBackpack
        //--------------------------------------------------------------
        entity(entity src) item_backpack_drop =
        {
                local entity pack = __NULL__;
                local vector vel;

                if (src.ammo_shells + src.ammo_nails + src.ammo_rockets +
                        src.ammo_cells <= 0)
                {
                        // nothing in it
                        dprint ("item_backpack_drop: empty pack!\n");
                        return pack;
                }

                vel_z = 300;
                vel_x = -100 + (random() * 200);
                vel_y = -100 + (random() * 200);

                pack = spawn_item_backpack (src, src.origin - '0 0 24', vel);

                return pack;
        };

        //--------------------------------------------------------------
        entity(entity src, vector org, vector vel) spawn_item_backpack =
        {
                local entity e = spawn ();
                e.owner = src;
                e.origin = org;
                e.velocity = vel;
                e.spawnflags = SPAWNFLAG_ITEM_BACKPACK_DROPPED,

                // copy ammo values to the new backpack entity -- CEV
                e.ammo_shells = src.ammo_shells;
                e.ammo_nails = src.ammo_nails;
                e.ammo_rockets = src.ammo_rockets;
                e.ammo_cells = src.ammo_cells;

                // if the source is a player & the player is holding a weapon
                // then add that weapon to the backpack's inventory -- CEV
                if (src.classtype == CT_PLAYER)
                {
                        // creates item_index -- CEV
                        BASE_ENTITY_WEAPONLOOKUP (src)
                        if (item_index >= ITEM_SEQ_W_START &&
                                item_index <= ITEM_SEQ_W_END)
                        {
                                e.inventory1 = item_index;
                        }
                }

                // now we're clear to init the backpack -- CEV
                item_backpack_init (e);
                return e;
        };
#endif

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        void(entity e) item_backpack_init =
        {
                e.classname = "item_backpack";
                e.classtype = CT_ITEM_BACKPACK;

                #ifdef SSQC
                e.touch = item_backpack_touch;
                e.flags = FL_ITEM;
                e.solid = SOLID_TRIGGER;
                e.movetype = MOVETYPE_TOSS;

                if !(e.spawnflags)
                {
                        objerror ("\bitem_backpack_init: NO SPAWNFLAG SET "
                                "ON item_backpack");
                        return;
                }

                if (e.spawnflags & SPAWNFLAG_ITEM_BACKPACK_DEFAULT)
                {
                        e.ammo_shells = 10;
                        e.ammo_nails = 12;
                        e.ammo_rockets = 2;
                        e.ammo_cells = 3;
                }

                if (e.spawnflags & SPAWNFLAG_ITEM_BACKPACK_SHELLS)
                        if (!e.ammo_shells)
                                e.ammo_shells = 10;

                if (e.spawnflags & SPAWNFLAG_ITEM_BACKPACK_NAILS)
                        if (!e.ammo_nails)
                                e.ammo_nails = 12;

                if (e.spawnflags & SPAWNFLAG_ITEM_BACKPACK_ROCKETS)
                        if (!e.ammo_rockets)
                                e.ammo_rockets = 2;

                if (e.spawnflags & SPAWNFLAG_ITEM_BACKPACK_CELLS)
                        if (!e.ammo_cells)
                                e.ammo_cells = 3;

                if (e.spawnflags & SPAWNFLAG_ITEM_BACKPACK_DROPPED)
                        e.weapon = ITEM_SEQ_BACKPACK;
                else
                        e.weapon = ITEM_SEQ_PD3BACKPACK;

                if (e.inventory1) {
                if (!e.netname || e.netname == "")
                {
                        if (e.inventory1 == ITEM_SEQ_AXE)
                                e.netname = "Axe";
                        else if (e.inventory1 == ITEM_SEQ_SHOTGUN)
                                e.netname = "Shotgun";
                        else if (e.inventory1 == ITEM_SEQ_SUPERSHOTGUN)
                                e.netname = "Double-barrelled Shotgun";
                        else if (e.inventory1 == ITEM_SEQ_NAILGUN)
                                e.netname = "Nailgun";
                        else if (e.inventory1 == ITEM_SEQ_SUPERNAILGUN)
                                e.netname = "Super Nailgun";
                        else if (e.inventory1 == ITEM_SEQ_GRENADELAUNCHER)
                                e.netname = "Grenade Launcher";
                        else if (e.inventory1 == ITEM_SEQ_ROCKETLAUNCHER)
                                e.netname = "Rocket Launcher";
                        else if (e.inventory1 == ITEM_SEQ_LIGHTNINGGUN)
                                e.netname = "Thunderbolt";
                        else
                                e.netname = "";
                } }
                #endif

                local item_info_t item = item_info[e.weapon];

                #ifdef SSQC
                precache_model (item.world_model);
                precache_sound (item.pickup_sound);
                setmodel (e, item.world_model);
                #endif

                #ifdef CSQC
                setmodelindex (e, e.modelindex);
                e.modelflags |= MF_ROTATE;
                #endif

                e.noise = item.pickup_sound;
                e.pos1 = '-16 -16 0';
                e.pos2 = '16 16 56';

                // StartItem

                #ifdef CSQC
                setsize (e, e.pos1, e.pos2);
                base_item_init (e);
                #endif

                #ifdef SSQC
                if (e.spawnflags & SPAWNFLAG_ITEM_BACKPACK_DROPPED)
                {
                        // don't delay, spawn immediately -- CEV
                        e.classgroup |= CG_ITEM;
                        setsize (e, e.pos1, e.pos2);

                        if (!(e.alpha))
                                e.alpha = ITEM_ALPHA_OPAQUE;

                        e.flags |= FL_FINDABLE_NONSOLID;
                        e.mdl = e.model;

                        e.tick = base_item_neteval;
                        e.classgroup |= CG_FRAMETICK;

                        e.SendEntity = base_entity_netsend;
                        e.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;

                        e.think = item_backpack_think_groundcheck;
                        e.nextthink = time + 0.1;
                }
                else
                {
                        setsize (e, e.pos1, e.pos2);
                        base_item_init (e);
                }
                #endif
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        void() item_backpack =
        {
                // remap spawnflags, inhibit spawn, remap fields -- CEV
                BASE_ITEM_PREINIT (__NULL__)

                item_backpack_init (self);
        };
// };
#endif