djcev.com

//==============================================================================
// base_item.qc -- top-level item pickups
//==============================================================================

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

#ifdef SSQC
//----------------------------------------------------------------------
// base item spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SPAWNFLAG_ITEM_SPAWNSILENT = 32,// item won't make sound when spawning
        SPAWNFLAG_ITEM_SPAWNED = 64,
        SPAWNFLAG_ITEM_SUSPENDED = 128,
        // SPAWNFLAG_NOT_ON_EASY = 256, // 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,// respawn
        SPAWNFLAG_ITEM_THROWN = 4194304, // item was thrown
        SPAWNFLAG_ITEM_DONTDROP = 8388608 // last flag! don't drop to the ground
} base_item_spawnflags;
#endif

#ifdef SSQC
const float ITEM_ALPHA_WAITSPAWN = 0.00001; // alpha values (respawn feedback)
const float ITEM_ALPHA_NEARSPAWN = 0.2;
const float ITEM_ALPHA_OPAQUE = 1.0;

const string ITEM_SOUND_SPAWN = "cev/items/respawn.ogg";
#endif

//======================================================================
// fields
//======================================================================

#ifdef SSQC
.vector particles_offset;
#endif

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

// base_item
#ifdef CSQC
// BASE_ITEM_NETRECEIVE(initfn)
float() base_item_predraw;
#endif
#ifdef SSQC
void() base_item_neteval;
#endif
#ifdef SSQC
// BASE_ITEM_INVENTORY_ADD(from, to)
// BASE_ITEM_INVENTORY_REMOVE(holder)
// BASE_ITEM_PICKUPMESSAGE(p, i, chan)
// BASE_ITEM_CHECKREMOVE(bic_item, sp_wait, dm_wait)
// BASE_ITEM_THROW_ROTATION(ent, item)
void(entity actor) base_item_drop_stuff;
float() base_item_touch_projectile;
float(entity item, float delay_sp, float delay_dm) base_item_check_respawn;
void() base_item_think_respawn;
void() base_item_think_nearspawn;
void() base_item_think_rhull;
void() base_item_think_throwgroundcheck;
void() base_item_think_place;
void() base_item_use_delayspawn;
// BASE_ITEM_PREINIT(func)
void(string key, string value) base_item_init_field;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) base_item_init;
#endif
#ifdef SSQC
strip void() base_item;
#endif

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

//----------------------------------------------------------------------
// class base_item: base_mapentity
// {
        //==============================================================
        // Generic item networking -- CEV
        //==============================================================

#ifdef CSQC
        //--------------------------------------------------------------
        #define BASE_ITEM_NETRECEIVE(initfn) \
        /* { */ \
                local float netflags = base_entity_netreceive (isnew); \
                if (NETFLAG_BASE_ENTITY_FRAME) \
                { \
                        self.frame = self.frame_net; \
                } \
                if (isnew && !(self.predraw)) \
                { \
                        initfn (self); \
                } \
                else \
                { \
                        if (netflags & NETFLAG_BASE_ENTITY_MODEL) \
                        { \
                                setmodelindex (self, self.modelindex); \
                        } \
                        if (netflags & NETFLAG_BASE_ENTITY_SOLID) \
                        { \
                                if (self.solid) \
                                { \
                                        if (self.pos1 || self.pos2) \
                                                setsize (self, self.pos1, \
                                                        self.pos2); \
                                        else \
                                                setsize (self, self.mins, \
                                                        self.maxs); \
                                } \
                                else \
                                { \
                                        setsize (self, '0 0 0', '0 0 0'); \
                                } \
                        } \
                } \
        /* } */

        //--------------------------------------------------------------
        float() base_item_predraw =
        {
                // skip invisible entities -- CEV
                if (!self.modelindex)
                        return PREDRAW_NEXT;

                if (self.modelflags & MF_ROTATE)
                {
                        // this item is flagged to automatically rotate -- CEV
                        // rotation formula from Nuclide -- CEV
                        self.angles.y += frametime * 120.0f;
                        // wrap angles -- CEV
                        if (self.angles.y > 180)
                                self.angles.y -= 360;
                        else if (self.angles.y < -180)
                                self.angles.y += 360;
                }
                else
                {
                        // interpolate angles -- see base_entities.qc -- CEV
                        BASE_ENTITY_LERP_ANGLES (self,
                                self.angles_net, self.angles_prev, time,
                                self.angles_net_time, self.angles_prev_time)
                }

                // interpolate origin -- see base_entities.qc -- CEV
                BASE_ENTITY_LERP_ORIGIN (self,
                        self.origin_net, self.origin_prev, time,
                        self.origin_net_time, self.origin_prev_time)

                // draw this entity -- CEV
                addentity (self);

                setorigin (self, self.origin_net);

                // go to next without auto-drawing this entity -- CEV
                return PREDRAW_NEXT;
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        void() base_item_neteval =
        {
                if (!(self.SendFlags & NETFLAG_BASE_ENTITY_ORIGIN))
                {
                        if (self.origin != self.origin_net)
                        {
                                // client needs updated origin -- CEV
                                self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN;
                        }
                }

                if (!(self.SendFlags & NETFLAG_BASE_ENTITY_ANGLES))
                {
                        if (self.angles != self.angles_net)
                        {
                                // client needs updated angles -- CEV
                                self.SendFlags |= NETFLAG_BASE_ENTITY_ANGLES;
                        }
                }
        };
#endif

        //==============================================================
        // Macros
        //==============================================================

#ifdef SSQC
        //--------------------------------------------------------------
        #define BASE_ITEM_INVENTORY_ADD(from, to) \
        /* { */ \
                switch (to.weapon) \
                { \
                        case 1: to.inventory1 = from.weapon; break; \
                        case 2: to.inventory2 = from.weapon; break; \
                        case 3: to.inventory3 = from.weapon; break; \
                        case 4: to.inventory4 = from.weapon; break; \
                        case 5: to.inventory5 = from.weapon; break; \
                        case 6: to.inventory6 = from.weapon; break; \
                        case 7: to.inventory7 = from.weapon; break; \
                        case 8: to.inventory8 = from.weapon; break; \
                } \
        /* } */

        //--------------------------------------------------------------
        #define BASE_ITEM_INVENTORY_REMOVE(holder) \
        /* { */ \
                switch (holder.weapon) \
                { \
                        case 1: holder.inventory1 = ITEM_SEQ_HANDS; break; \
                        case 2: holder.inventory2 = ITEM_SEQ_HANDS; break; \
                        case 3: holder.inventory3 = ITEM_SEQ_HANDS; break; \
                        case 4: holder.inventory4 = ITEM_SEQ_HANDS; break; \
                        case 5: holder.inventory5 = ITEM_SEQ_HANDS; break; \
                        case 6: holder.inventory6 = ITEM_SEQ_HANDS; break; \
                        case 7: holder.inventory7 = ITEM_SEQ_HANDS; break; \
                        case 8: holder.inventory8 = ITEM_SEQ_HANDS; break; \
                } \
        /* } */

        //--------------------------------------------------------------
        #define BASE_ITEM_PICKUPMESSAGE(p, i, chan) \
        /* { */ \
                /* item touch message */ \
                sprint (p, sprintf("%s got the %s!\n", p.netname, i.name)); \
                /* item touch sound */ \
                sound (p, chan, i.pickup_sound, i.pickup_vol, ATTN_NORM); \
                /* item touch screenflash */ \
                stuffcmd (p, "bf\n"); \
        /* } */

        //--------------------------------------------------------------
        // check if we need to respawn the item; remove if not -- CEV
        //--------------------------------------------------------------
        #define BASE_ITEM_CHECKREMOVE(bic_item, sp_wait, dm_wait) \
        /* { */ \
                /* make sure the item exists before proceeding -- CEV */ \
                if (bic_item) \
                { \
                        bic_item.model = __NULL__; \
                        bic_item.solid = SOLID_NOT; \
                        setmodel (bic_item, bic_item.model); \
                        bic_item.SendFlags |= NETFLAG_BASE_ENTITY_MODEL | \
                                NETFLAG_BASE_ENTITY_SOLID; \
                        /* Supa, SP respawning items support */ \
                        if (bic_item.spawnflags & SPAWNFLAG_ITEM_THROWN) \
                        { \
                                /* remove thrown items after pickup -- CEV */ \
                                bic_item.touch = sub_null; \
                                bic_item.think = sub_remove; \
                                bic_item.nextthink = time + 0.2; \
                        } \
                        else if (base_item_check_respawn(bic_item, \
                                sp_wait, dm_wait)) \
                        { \
                                /* clear to remove this item -- CEV */ \
                                bic_item.touch = sub_null; \
                                bic_item.think = sub_remove; \
                                bic_item.nextthink = time + 0.2; \
                        } \
                } \
        /* } */

        //--------------------------------------------------------------
        // set up rotation for thrown items -- CEV
        //--------------------------------------------------------------
        #define BASE_ITEM_THROW_ROTATION(ent, item) \
        /* { */ \
                if (ent.spawnflags & SPAWNFLAG_ITEM_THROWN && ent.owner) \
                { \
                        local float ay; \
                        /* TODO CEV simplify this */ \
                        ay = ent.owner.angles.y + item.view_angles_offset.y; \
                        ay = ay - 360.0f * rint(ay / 360.0f); \
                        ay = ay - 180.0f * rint(ay / 180.0f); \
                        ay = ay - 90.0f * rint(ay / 90.0f); \
                        ent.angles.y = ay; \
                        if (ent.angles.y > 0) \
                                ent.avelocity_y = -60; \
                        else \
                                ent.avelocity_y = 60; \
                } \
        /* } */

        //==============================================================
        // Static Helper Functions
        //==============================================================

        //--------------------------------------------------------------
        // DropStuff -- dumptruck_ds
        // set drops_item on a monster to a number:
        //
        // 1 = Silver Key
        // 2 = Gold Key
        // 3 = Health Vial
        // 4 = Armor Shard
        // 5 = Health Vial & Armor Shard
        // 6 = random combination of 3 Vials and/or Shards
        //
        // TODO CEV this should probably be outside of base_item
        //--------------------------------------------------------------
        void(entity actor) base_item_drop_stuff =
        {
                switch (actor.drop_item)
                {
                        case 0:
                                // drop nothing
                                break;
                        case 1:
                                item_key1_drop (actor);
                                break;
                        case 2:
                                item_key2_drop (actor);
                                break;
                        case 3:
                                item_health_vial_drop (actor);
                                break;
                        case 4:
                                item_armor_shard_drop (actor);
                                break;
                        case 5:
                                item_health_vial_drop (actor);
                                item_armor_shard_drop (actor);
                                break;
                        case 6:
                                local float rand_drop = rint(random() * 3);
                                if (rand_drop == 1)
                                {
                                        item_armor_shard_drop (actor);
                                        item_health_vial_drop (actor);
                                        item_health_vial_drop (actor);
                                }
                                else if (rand_drop == 2)
                                {
                                        item_armor_shard_drop (actor);
                                        item_armor_shard_drop (actor);
                                        item_health_vial_drop (actor);
                                }
                                else if (rand_drop == 0)
                                {
                                        item_armor_shard_drop (actor);
                                        item_armor_shard_drop (actor);
                                        item_armor_shard_drop (actor);
                                }
                                else
                                {
                                        item_health_vial_drop (actor);
                                        item_health_vial_drop (actor);
                                        item_health_vial_drop (actor);
                                }
                                break;
                        default:
                                dprint (sprintf("base_item_drop_stuff: "
                                        "unhandled drop_item %g\n",
                                        actor.drop_item));
                }
        };

        //--------------------------------------------------------------
        float() base_item_touch_projectile =
        {
                if (self.spawnflags & SPAWNFLAG_ITEM_THROWN) {
                if (!(self.flags & FL_ONGROUND)) {
                if (self.solid == SOLID_SLIDEBOX)
                {
                        // this is a thrown item that's currently SOLID_SLIDEBOX
                        // (and so probably airborne). do some typical
                        // projectile checks -- CEV
                        local float pc = pointcontents (self.origin);
                        if (pc == CONTENT_SKY)
                        {
                                dprint (sprintf("base_item_touch_projectile: "
                                        "%s in the sky!\n",
                                        self.classname));
                                base_entity_remove (self);
                                return TRUE;
                        }
                        else if (pc == CONTENT_SOLID)
                        {
                                dprint (sprintf("base_item_touch_projectile: "
                                        "%s within a solid!\n",
                                        self.classname));
                                base_entity_remove (self);
                                return TRUE;
                        }

                        if (other.solid == SOLID_BSP)
                        {
                                dprint (sprintf("base_item_touch_projectile: "
                                        "hit %s, vel %v!\n",
                                        other.classname, self.velocity));

                                if (other.classtype == CT_WORLD) {
                                if (self.velocity_z < 0)
                                {
                                        base_entity_aligntoground (self);
                                } }

                                if (self.flags & FL_ONGROUND)
                                        self.velocity = '0 0 0';
                                else
                                        self.velocity = [
                                                self.velocity_x * 0.5,
                                                self.velocity_y * 0.5,
                                                self.velocity_z];
                        }

                        if (other != self.owner) {
                        if (!(self.flags & FL_ONGROUND)) {
                        if (other.takedamage) {
                        if (time >= self.attack_finished) {
                        if (self.dmg)
                        {
                                // we're airbone for sure and hit something
                                // that takes damage. do the thing. -- CEV
                                self.attack_finished = time + 0.5;
                                spawn_touchblood (self.dmg);
                                t_damage2 (other, self, self.owner, self.dmg);
                        } } } } }

                        // skip all other checks if we're still solid
                        // at this point -- CEV
                        return TRUE;
                } } }
                return FALSE;
        };

        //==============================================================
        // Subs
        //==============================================================

        //--------------------------------------------------------------
        // CheckItemRespawn -- was in items.qc
        //--------------------------------------------------------------
        float(entity item, float delay_sp, float delay_dm)
                base_item_check_respawn =
        {
                // DM rules first
                if (deathmatch == 1)
                {
                        if (delay_dm > 5.0)
                        {
                                item.alpha = ITEM_ALPHA_WAITSPAWN;
                                item.SendFlags |= NETFLAG_BASE_ENTITY_ALPHA;
                                item.think = base_item_think_nearspawn;
                                item.nextthink = time + delay_dm - 5.0;
                        }
                        else
                        {
                                item.alpha = ITEM_ALPHA_NEARSPAWN;
                                item.SendFlags |= NETFLAG_BASE_ENTITY_ALPHA;
                                item.nextthink = time + delay_dm;
                        }

                        item.nextthink = time + delay_dm;
                        setmodel (item, item.mdl);
                        return FALSE;
                }

                if (deathmatch)
                {
                        dprint (sprintf("base_item_check_respawn: unhandled "
                                "deathmatch state %f\n", deathmatch));
                        return TRUE;
                }

                // Supa, SP respawning items support
                // respawn item if flagged, otherwise abort
                if (!(item.spawnflags & SPAWNFLAG_ITEM_RESPAWN) ||
                        item.wait == -1)
                {
                        return TRUE;
                }

                // inc before check to account for zero indexing
                item.cnt = item.cnt + 1;

                // limited respawns
                if (item.count && item.count < item.cnt)
                        return TRUE;

                // okay, we're clear to set up a respawn
                if (item.wait)
                {
                        // custom respawn delay
                        if (item.wait > 5.0)
                        {
                                item.alpha = ITEM_ALPHA_WAITSPAWN;
                                item.SendFlags |= NETFLAG_BASE_ENTITY_ALPHA;
                                item.think = base_item_think_nearspawn;
                                item.nextthink = time + item.wait - 5.0;
                        }
                        else
                        {
                                item.alpha = ITEM_ALPHA_NEARSPAWN;
                                item.SendFlags |= NETFLAG_BASE_ENTITY_ALPHA;
                                item.nextthink = time + item.wait;
                        }
                }
                else
                {
                        if (delay_sp > 5.0)
                        {
                                item.alpha = ITEM_ALPHA_WAITSPAWN;
                                item.SendFlags |= NETFLAG_BASE_ENTITY_ALPHA;
                                item.think = base_item_think_nearspawn;
                                item.nextthink = time + delay_sp - 5.0;
                        }
                        else
                        {
                                item.alpha = ITEM_ALPHA_NEARSPAWN;
                                item.SendFlags |= NETFLAG_BASE_ENTITY_ALPHA;
                                item.nextthink = time + delay_sp;
                        }
                }

                setmodel (item, item.mdl);
                return FALSE;
        };

        //==============================================================
        // Interfacing
        //==============================================================

        //--------------------------------------------------------------
        // SUB_Regen -- was in items.qc
        //--------------------------------------------------------------
        void() base_item_think_respawn =
        {
                // restore original model
                self.model = self.mdl;
                self.alpha = ITEM_ALPHA_OPAQUE;
                setmodel (self, self.model);

                // allow it to be touched again
                self.solid = SOLID_TRIGGER;
                self.flags |= FL_FINDABLE_NONSOLID;

                // guarantee size -- CEV
                if (self.pos1 || self.pos2)
                        setsize (self, self.pos1, self.pos2);

                // relink -- CEV
                setorigin (self, self.origin);

                // new respawning effects -- CEV
                sound (self, CHAN_VOICE, ITEM_SOUND_SPAWN, VOL_HIGH, ATTN_NORM);

                // make sure the client knows -- CEV
                self.SendFlags |= NETFLAG_BASE_ENTITY_MODEL |
                        NETFLAG_BASE_ENTITY_SOLID | NETFLAG_BASE_ENTITY_ALPHA;
        };

        //--------------------------------------------------------------
        void() base_item_think_nearspawn =
        {
                // bump alpha when 5s remain -- CEV
                self.alpha = ITEM_ALPHA_NEARSPAWN;
                self.SendFlags |= NETFLAG_BASE_ENTITY_ALPHA;
                self.think = base_item_think_respawn;
                self.nextthink = time + 5.0;
        };

        //--------------------------------------------------------------
        // RefreshHull -- Supa, restore old hull and lock movement
        //--------------------------------------------------------------
        void() base_item_think_rhull =
        {
                dprint ("base_item_think_rhull: fix for bboxes\n");

                // dumptruck_ds -- fix for bounding boxes
                if (self.pos1 || self.pos2)
                        setsize (self, self.pos1, self.pos2);
                else
                        setsize (self, '0 0 0', '32 32 56');

                self.movetype = MOVETYPE_NONE;
                self.velocity = '0 0 0';
                self.SendFlags |= NETFLAG_BASE_ENTITY_SOLID;
        };

        //--------------------------------------------------------------
        void() base_item_think_throwgroundcheck =
        {
                if (self.flags & FL_ONGROUND)
                {
                        // yaw to 0 (so the bbox will fit the item) -- CEV
                        if (!(self.classgroup & CG_CORPSE))
                                if (self.angles_y)
                                        self.angles_y = 0;

                        // return to original size -- CEV
                        if (self.pos1 || self.pos2)
                                setsize (self, self.pos1, self.pos2);

                        // remove from frametick que if needed -- CEV
                        if (self.classgroup & CG_FRAMETICK)
                                self.classgroup &= ~CG_FRAMETICK;

                        // stop moving, thinking, & return to non-solid -- CEV
                        self.velocity = '0 0 0';
                        self.avelocity = '0 0 0';
                        self.solid = SOLID_TRIGGER;
                        self.think = sub_null;
                        self.SendFlags |= NETFLAG_BASE_ENTITY_SOLID |
                                NETFLAG_BASE_ENTITY_ANGLES;
                }
                else
                {
                        /*
                        dprint (sprintf("base_item_think_throwgroundcheck: "
                                "angles %v\n", self.angles));
                        */

                        // manage rotation towards center -- CEV
                        if (self.angles_y)
                        {
                                if (self.avelocity_y > 0)
                                {
                                        if (self.angles_y > 0)
                                        {
                                                self.angles_y = 0;
                                                self.avelocity_y = 0;
                                        }
                                }
                                else
                                {
                                        if (self.angles_y < 0)
                                        {
                                                self.angles_y = 0;
                                                self.avelocity_y = 0;
                                        }
                                }
                        }

                        self.nextthink = time + 0.1;
                        self.SendFlags |= NETFLAG_BASE_ENTITY_ANGLES;
                }
        };

        //--------------------------------------------------------------
        // PlaceItem -- plants the object on the floor
        //--------------------------------------------------------------
        void() base_item_think_place =
        {
                // we want to be visible -- CEV
                if (!(self.alpha))
                        self.alpha = ITEM_ALPHA_OPAQUE;

                // so findradius can find it -- CEV
                self.flags |= FL_FINDABLE_NONSOLID;

                // make extra wide
                self.flags |= FL_ITEM;

                // so it can be restored on respawn
                self.mdl = self.model;

                if (!(self.spawnflags & SPAWNFLAG_ITEM_THROWN))
                {
                        self.velocity = '0 0 0';
                        self.think = base_item_think_respawn;
                }

                // guarantee size -- CEV
                if (!self.pos1 && !self.pos2)
                {
                        self.pos1 = '0 0 0';
                        self.pos2 = '32 32 56';
                }

                if (self.spawnflags & SPAWNFLAG_ITEM_THROWN)
                {
                        self.solid = SOLID_SLIDEBOX;
                        self.movetype = MOVETYPE_TOSS;
                        setsize (self, self.pos1, self.pos2);
                        setorigin (self, self.origin);

                        // add to frametick queue -- CEV
                        self.tick = base_item_neteval;
                        self.classgroup |= CG_FRAMETICK;

                        // check for ground once per 0.1 -- CEV
                        self.think = base_item_think_throwgroundcheck;
                        self.nextthink = time + 0.1;
                }
                else if (self.spawnflags & SPAWNFLAG_ITEM_SUSPENDED)
                {
                        // ijed Don't drop spawnflag
                        dprint (sprintf("base_item_think_place: spawned "
                                "suspended item %s at %v\n",
                                self.classname, self.origin));
                        setsize (self, self.pos1, self.pos2);
                        self.solid = SOLID_TRIGGER;
                        self.movetype = MOVETYPE_FLY;
                }
                else
                {
                        setsize (self, self.pos1, self.pos2);

                        // The following hack for item_health was inherited
                        // from the RMQ code, and was here when the
                        // func_mapjamx maps were created. It would have been
                        // nice to remove this code entirely, because progs_dump
                        // doesn't need it, and it breaks item_health's
                        // collision with entities that have MOVETYPE_PUSH.
                        // However, removing this code would cause some of the
                        // item_health entities in some of the func_mapjamx
                        // maps to "fall out of the level", because they're
                        // accidentally touching solid surfaces. So, to
                        // maintain backwards-compatibility, this code has
                        // been left in, but will only be run if one of the
                        // func_mapjamx maps is being played.  -- iw
                        if (known_release == KNOWN_RELEASE_FUNC_MAPJAMX)
                        {
                                if (self.classtype == CT_ITEM_HEALTH)
                                {
                                        // Supa, CTF
                                        // hacking around hull issues..
                                        // void hull for now
                                        setsize (self, '0 0 0',  '0 0 0');
                                        self.think = base_item_think_rhull;
                                        self.nextthink = time + 0.2;
                                }
                        }

                        self.solid = SOLID_TRIGGER;
                        self.movetype = MOVETYPE_TOSS;

                        if (!(self.spawnflags & SPAWNFLAG_ITEM_DONTDROP))
                        {
                                setorigin (self, self.origin + '0 0 6');

                                if (!droptofloor())
                                {
                                        dprint (sprintf("base_item_think_place"
                                                ": bonus item %s fell out of "
                                                "level at %v\n",
                                                self.classname, self.origin));
                                        // TODO CEV
                                        // base_entity_remove (self);
                                        return;
                                }

                                // TODO CEV
                                // base_entity_aligntoground (self);
                        }

                        self.tick = base_item_neteval;
                        // self.classgroup |= CG_FRAMETICK;
                }

                if (self.spawnflags & SPAWNFLAG_ITEM_SPAWNED)
                {
                        // SPAWNED, gb
                        self.pos1 = self.mins;
                        self.pos2 = self.maxs;

                        self.model = "";
                        self.solid = SOLID_NOT;
                        self.flags &= ~FL_FINDABLE_NONSOLID;

                        if (self.spawnflags & SPAWNFLAG_ITEM_DONTDROP)
                                self.movetype = MOVETYPE_NONE;

                        self.use = base_item_use_delayspawn;
                }

                self.SendEntity = base_entity_netsend;
                self.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;
        };

        //--------------------------------------------------------------
        // DelaySpawnItem -- this is from rmq-items.qc
        // Makes a SPAWNED item ready for pickup on a trigger event
        // - modified a bit -- dumptruck_ds
        //--------------------------------------------------------------
        void() base_item_use_delayspawn =
        {
                self.solid = SOLID_TRIGGER;
                self.flags |= FL_FINDABLE_NONSOLID;
                setmodel (self, self.mdl);
                setsize (self, self.pos1, self.pos2);

                if (!(self.spawnflags & SPAWNFLAG_ITEM_SPAWNSILENT))
                        // SILENT, gb
                        spawn_tfog (self.origin + self.particles_offset);

                if (self.spawnflags & SPAWNFLAG_ITEM_SUSPENDED)
                        self.movetype = MOVETYPE_FLY;
                else
                        self.movetype = MOVETYPE_TOSS;

                self.use = sub_null;
        };

        //==============================================================
        // Constructor & Spawn Functions
        //==============================================================

        //--------------------------------------------------------------
        // pre-initialization macro. remap spawnflags for known releases,
        // check spawnflags to inhibit spawn, then loop over spawndata
        // if necessary -- CEV
        //--------------------------------------------------------------
        #define BASE_ITEM_PREINIT(func) \
        /* { */ \
                if (known_release == KNOWN_RELEASE_QUAKE3 || \
                        known_release == KNOWN_RELEASE_CPMA || \
                        known_release == KNOWN_RELEASE_QUAKELIVE) \
                { \
                        /* remap flags for Q3 -- CEV */ \
                        compat_quake3_item_spawnflags (); \
                } \
                else if (known_release == KNOWN_RELEASE_COPPER) \
                { \
                        /* remap flags for Copper -- CEV */ \
                        compat_copper_item_spawnflags (); \
                } \
                /* call func (if it's valid) to remap fields -- CEV */ \
                /* run before inhibit in case it alters spawnflags -- CEV */ \
                base_mapentity_init_spawndata (func); \
                /* new spawnflags for all entities -- iw */ \
                if (SUB_Inhibit()) \
                        return; \
        /* } */

        //--------------------------------------------------------------
        void(string key, string value) base_item_init_field =
        {
                if (known_release == KNOWN_RELEASE_QUAKE3 ||
                        known_release == KNOWN_RELEASE_CPMA ||
                        known_release == KNOWN_RELEASE_QUAKELIVE)
                {
                        compat_quake3_entity_init_field (key, value);
                }

                switch (key)
                {
                        // remap Quoth (and pd3) item respawning fields to
                        // count, wait, and a spawnflag -- CEV
                        case "respawncount":
                                // count limits number of respawns -- CEV
                                if (!self.count)
                                        self.count = stof (value);
                                break;
                        case "respawndelay":
                                // wait is respawn delay -- CEV
                                if (!self.wait)
                                        self.wait = stof (value);
                                break;
                        case "ritem":
                                // set SPAWNFLAG_ITEM_RESPAWN -- CEV
                                local float ritem = stof (value);
                                if (ritem)
                                        self.spawnflags |=
                                                SPAWNFLAG_ITEM_RESPAWN;
                                break;
                }
        };
#endif

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        void(entity e) base_item_init =
        {
                base_mapentity_init (e);
                e.classgroup |= CG_ITEM;

                #ifdef CSQC
                setsize (e, e.pos1, e.pos2);
                setorigin (e, e.origin);
                // let the server run physics (toss) for items -- CEV
                e.movetype = MOVETYPE_NONE;
                e.drawmask = DRAWMASK_NORMAL;
                e.predraw = base_item_predraw;
                #endif

                #ifdef SSQC
                //------------------------------------------------------
                // StartItem -- Sets the clipping size and plants the
                // object on the floor
                //------------------------------------------------------
                if (e.spawnflags & SPAWNFLAG_ITEM_THROWN)
                {
                        // call immediately for thrown items -- CEV
                        sub_runvoidas (e, base_item_think_place);
                }
                else
                {
                        e.think = base_item_think_place;
                        // items start after other solids
                        // was 0.2 -- dumptruck_ds
                        e.nextthink = time + 0.3;
                }
                #endif
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        strip void() base_item =
        {
                base_item_init (self);
        };
#endif
// };