djcev.com

//==============================================================================
// items/throwables.qc -- breakable debris, gibs, heads, misc. throwables -- CEV
//==============================================================================

//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
// Scenic Dead Monster Patch stuff here from DeadStuff mod -- dumptruck_ds
//
// deadstuff version 1.0 - tony collen - manero@canweb.net -
//      EfNet IRC #QuakeEd or #Trinity
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

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

#ifdef SSQC
const float DEBRISQUE_COUNT_MAX = 50;   // max number of gibs at one time
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// base_item_throwable spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SPAWNFLAG_ITEM_THROWABLE_SOLID = 1 // spawnflags: solid
        // 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, // 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
} base_item_throwable_spawnflags;
#endif

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

#ifdef SSQC
void(vector org, vector vel, float damage) spawn_blood;
void(float damage) spawn_touchblood;
void(vector org, vector vel) spawn_chunk;
entity(vector org, vector vel) spawn_meatspray;
vector(vector dir, float damage) velocity_for_damage;
#endif

// base_item_throwable
#ifdef CSQC
void(float isnew) base_item_throwable_netreceive;
#endif
#ifdef SSQC
// BASE_ITEM_THROWABLE(idx, d, h)
void(entity attacker, float item_index) base_item_throwable_fire;
void(entity grabber, entity d) base_item_throwable_grab;
void() base_item_throwable_think;
void() base_item_throwable_touch;
entity(float idx, vector o, vector v, float fl) spawn_base_item_throwable;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) base_item_throwable_init;
#endif
#ifdef SSQC
strip void() base_item_throwable;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// original progs_dump 3 / DeadStuff entity spawn functions -- CEV
//----------------------------------------------------------------------
void() gib_misc_1;
void() gib_misc_2;
void() gib_misc_3;
void() gib_head_demon;
void() gib_head_dog;
void() gib_head_enforcer;
void() gib_head_hell_knight;
void() gib_head_knight;
void() gib_head_ogre;
void() gib_head_player;
void() gib_head_shalrath;
void() gib_head_shambler;
void() gib_head_army;
void() gib_head_wizard;
void() gib_head_zombie;
#endif

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

//----------------------------------------------------------------------
//  misc. functions
//----------------------------------------------------------------------

#ifdef SSQC
//----------------------------------------------------------------------
// SpawnBlood
//----------------------------------------------------------------------
void(vector org, vector vel, float damage) spawn_blood =
{
        particle (org, vel * 0.1, 73, damage * 2);
};

//----------------------------------------------------------------------
// spawn_touchblood
//----------------------------------------------------------------------
void(float damage) spawn_touchblood =
{
        // wall_velocity
        local vector vel;

        vel = normalize (self.velocity);
        vel = normalize (vel + v_up * (random() - 0.5) +
                v_right * (random() - 0.5));
        // TODO CEV when was the last time a trace was called?
        vel = vel + 2 * trace_plane_normal;
        vel = (vel * 200) * 0.2;

        spawn_blood (self.origin + vel * 0.01, vel, damage);
};

//----------------------------------------------------------------------
// SpawnChunk
//----------------------------------------------------------------------
void(vector org, vector vel) spawn_chunk =
{
        particle (org, vel * 0.02, 0, 10);
};

//----------------------------------------------------------------------
// SpawnMeatSpray
//----------------------------------------------------------------------
entity(vector org, vector vel) spawn_meatspray =
{
        // reusing the "zombiechunk" projectile -- CEV
        local entity e = spawn_projectile_zombiechunk (self, org, vel);
        // override some defaults, notably solid and force damage to 0 -- CEV
        e.solid = SOLID_NOT;
        e.dmg = 0;
        e.velocity_z += 250 + 50 * random ();
        e.nextthink = time + 1;
        return e;
};

//----------------------------------------------------------------------
vector(vector dir, float damage) velocity_for_damage =
{
        // uncomment if needed for the debug print below -- CEV
        // local vector startdir = dir;

        // next three lines original id1 behavior -- CEV
        local vector v;
        v_x = 100 * crandom ();
        v_y = 100 * crandom ();
        v_z = 200 + 100 * random ();
        // damage response scaling from Alkaline, presumably by bmFbr -- CEV
        v *= max (1, min(10, damage * damage / 5000));

        if (dir != '0 0 0')
        {
                // directional gib behavior from Alkaline (which appears to
                // be by bmFbr according to the commit log, see Alkaline
                // commit 083f87c18a2d2be645ba197c1f23fc6533afca81).
                // dir is set by killed () and is already normalized -- CEV
                dir *= bound (10, damage * damage / 22, 600);
                dir_x *= 2.5;
                dir_y *= 2.5;
                dir_z *= 0.7;
                v += dir;
        }

        // velocity limiting code again from Alkaline and written by bmFbr.
        // I'm leaning on Alkaline here and above because the implementation
        // I came up with was way worse. -- CEV
        local float vspeed = vlen (v);
        if (vspeed > 450)
                v *= 450 / vspeed;
        v_z = min (450, v_z);

        #if 0
        dprint (sprintf("velocity_for_damage: damage is %g, startdir is %v, "
                "v is %v\n", damage, startdir, v));
        #endif

        return v;
};
#endif

//----------------------------------------------------------------------
//  base_item_throwable
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// class base_item_throwable: base_item
// {
#ifdef CSQC
        //--------------------------------------------------------------
        void(float isnew) base_item_throwable_netreceive =
        {
                // creates a number of variables, including netflags -- CEV
                BASE_ITEM_NETRECEIVE (base_item_throwable_init)
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        // was self.origin + '0 0 24' -- CEV
        //--------------------------------------------------------------
        #define BASE_ITEM_THROWABLE(idx, d, h) \
        { \
                spawn_base_item_throwable (idx, self.origin, \
                        velocity_for_damage(d, h), \
                        SPAWNFLAG_ITEM_THROWN); \
        }

        //--------------------------------------------------------------
        // player has pressed +attack while holding -- CEV
        //--------------------------------------------------------------
        void(entity attacker, float item_index) base_item_throwable_fire =
        {
                // TODO CEV
                makevectors (self.v_angle);
                player_throw_item (v_forward * 400.0f + v_up * 45.0f);
        };

        //--------------------------------------------------------------
        void(entity grabber, entity d) base_item_throwable_grab =
        {
                BASE_ITEM_INVENTORY_ADD (d, grabber)

                // don't re-grab / immediately throw the item -- CEV
                if (grabber.button4)
                        grabber.flags |= FL_THROW_HELD;

                // let the player know -- CEV
                sprint (grabber, sprintf("%s grabbed a %s\n",
                        grabber.netname, d.netname));

                // let CSQC know -- CEV
                if (grabber.classtype == CT_PLAYER && grabber.SendEntity)
                        grabber.SendFlags |= NETFLAG_PLAYER_WEAPON;

                // remove the ent from the queue before firing targets -- CEV
                base_entity_que_rem (d, QUE_TYPE_DEBRIS);

                // fire all targets / killtargets (unlikely to be used) -- CEV
                local entity stemp = self;
                local entity otemp = grabber;
                other = grabber;
                self = d;
                activator = grabber;
                sub_usetargets ();
                self = stemp;
                other = otemp;

                // throwables won't respawn so we're clear to remove here -- CEV
                if (d)
                {
                        d.model = __NULL__;
                        setmodel (d, d.model);
                        d.solid = SOLID_NOT;
                        d.touch = sub_null;
                        d.think = sub_remove;
                        d.nextthink = time + 0.2;

                        d.SendFlags |= NETFLAG_BASE_ENTITY_MODEL |
                                NETFLAG_BASE_ENTITY_SOLID;
                }
        };

        //--------------------------------------------------------------
        // cut-down/altered version of base_item_think_throwgroundcheck -- CEV
        //--------------------------------------------------------------
        void() base_item_throwable_think =
        {
                if (self.flags & FL_ONGROUND)
                {
                        if (self.classgroup & CG_FRAMETICK)
                                self.classgroup &= ~CG_FRAMETICK;

                        if (self.owner)
                                self.owner = world;

                        if (self.solid != SOLID_TRIGGER)
                        {
                                self.solid = SOLID_TRIGGER;
                                self.SendFlags |= NETFLAG_BASE_ENTITY_SOLID;
                        }

                        self.velocity = '0 0 0';
                }
                else
                {
                        if (!(self.classgroup & CG_FRAMETICK))
                                self.classgroup |= CG_FRAMETICK;
                }

                self.think = base_item_throwable_think;
                self.nextthink = time + 0.1;
        };

        //--------------------------------------------------------------
        // Inspired by Ivana Gibson's kickable gibs [1] and similar
        // functions found in other mods (Scarlet, etc) -- CEV
        // [1]: https://www.insideqc.com/qctut/lesson-52.shtml
        //
        // throwable_touch runs much more often than other item touch
        // funcs (mainly due to touching world); concessions have been
        // made // so it doesn't eat too much time -- CEV
        //--------------------------------------------------------------
        void() base_item_throwable_touch =
        {
                setorigin (self, self.origin);

                self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN |
                        NETFLAG_BASE_ENTITY_ANGLES;

                // only run if touched by a player or monster -- CEV
                if (other.classtype != CT_PLAYER)
                        if (!(other.classgroup & CG_MONSTER))
                                return;

                // check touch_projectile & return early if in motion -- CEV
                if (self.velocity)
                {
                        // thrown item check -- CEV
                        base_item_touch_projectile ();
                        return;
                }

                // only run if other is moving fast enough to disturb
                // stationary objects -- CEV
                if (other.classtype == CT_PLAYER)
                        if (other.speed < 200)
                                return;

                // push self horizontally according to other's direction and
                // speed, maximum of 160ups -- CEV
                base_entity_displace (self, other, PM_MAXSPEED * 0.5);

                if (self.avelocity.y == 0)
                        // a little spin, as a treat. Rotating in the other
                        // axes seem to cause ents to move into the floor -- CEV
                        self.avelocity_y = 100 * crandom ();
        };

        //--------------------------------------------------------------
        entity(float idx, vector o, vector v, float fl)
                spawn_base_item_throwable =
        {
                local entity e = spawn ();
                e.owner = self;
                e.spawnflags = fl;
                e.origin = o;
                e.velocity = v;
                e.weapon = idx;

                // initialize the ent -- CEV
                base_item_throwable_init (e);

                if (fl & SPAWNFLAG_ITEM_THROWN)
                {
                        if (self.health <= 0)
                        {
                                // thrown from a gibbed enemy -- CEV
                                if (idx >= ITEM_SEQ_HEAD_START &&
                                        idx <= ITEM_SEQ_HEAD_END)
                                {
                                        // special handling for heads -- CEV
                                        if (!e.avelocity)
                                                e.avelocity.y = crandom() * 600;
                                }
                                else
                                {
                                        e.avelocity.x = random() * 600;
                                        e.avelocity.y = random() * 600;
                                        e.avelocity.z = random() * 600;
                                }
                        }
                }

                // register this entity in the throwable queue -- CEV
                local entity rem = base_entity_que_add (e, QUE_TYPE_DEBRIS);
                if (rem)
                {
                        // a piece of throwable was removed from the queue;
                        // schedule it for removal for real -- CEV
                        rem.alpha = 1.0;
                        rem.think = sub_remove_fade;
                        rem.nextthink = time + 2 + random() * 10;
                }

                return e;
        };
#endif

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        // throwables don't call base_item_init, do all that work here -- CEV
        //--------------------------------------------------------------
        void(entity e) base_item_throwable_init =
        {
                local item_info_t iit = item_info[e.weapon];

                #ifdef SSQC
                // don't reset class if passed a client entity -- CEV
                if (!(e.flags & FL_CLIENT))
                {
                        e.classname = iit.classname;
                        e.classtype = iit.classtype;
                }

                if (!e.dmg)
                        e.dmg = iit.dmg;
                #endif

                e.frame = iit.world_frame;
                e.skin = iit.world_skin;
                e.view_ofs = '0 0 8';

                #ifdef SSQC
                if (e.flags & FL_CLIENT)
                        dprint (sprintf("base_item_throwable_init: found "
                                "FL_CLIENT, classtype %s\n", e.classname));

                if (!(e.flags & FL_CLIENT))
                        if (!(e.spawnflags & SPAWNFLAG_ITEM_THROWN))
                                base_mapentity_init (e);
                #endif

                #ifdef CSQC
                base_mapentity_init (e);
                #endif

                // both a (part of a) corpse and an item -- CEV
                e.classgroup |= CG_CORPSE | CG_ITEM;

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

                #ifdef CSQC
                setmodelindex (e, e.modelindex);
                #endif

                if (!(e.flags & FL_CLIENT))
                        // let's not change the player name lol -- CEV
                        e.netname = iit.name;

                // so we can be picked up -- CEV
                e.flags |= FL_FINDABLE_NONSOLID;

                // so we are pushed & teleported -- CEV
                e.stateflags |= STATE_PUSHABLE | STATE_TELEPORTABLE;

                #ifdef CSQC
                e.drawmask = DRAWMASK_NORMAL;
                e.predraw = base_item_predraw;
                #endif

                #ifdef SSQC
                // in case we're converting an existing entity -- CEV
                // clear potential leftover flags -- CEV
                if (e.flags & FL_MONSTER)
                        e.flags &= ~FL_MONSTER;

                if (e.flags & FL_FLY)
                        e.flags &= ~FL_FLY;

                if (e.flags & FL_SWIM)
                        e.flags &= ~FL_SWIM;

                // make sure destroy func is inactive -- CEV
                if (e.th_destroy)
                        e.th_destroy = sub_nulldestroy;

                // make sure we won't take damage -- CEV
                e.takedamage = DAMAGE_NO;

                if (e.spawnflags & SPAWNFLAG_ITEM_THROWN)
                        if (e.flags & FL_CLIENT)
                                e.flags &= ~FL_ONGROUND;

                if (e.spawnflags & SPAWNFLAG_ITEM_THROWABLE_SOLID)
                {
                        // explicitly flagged as solid -- CEV
                        e.solid = SOLID_BBOX;
                }
                else if (e.spawnflags & SPAWNFLAG_ITEM_THROWN)
                {
                        // thrown (as-in ThrowGib) -- CEV
                        if (e.owner && e.owner.classtype == CT_PLAYER)
                                e.solid = SOLID_SLIDEBOX;
                        else
                                e.solid = SOLID_TRIGGER;

                        e.think = base_item_throwable_think;
                        e.nextthink = time + 0.1;
                }
                else
                {
                        // otherwise spawn nonsolid -- CEV
                        e.solid = SOLID_NOT;
                }

                if (self.spawnflags & SPAWNFLAG_ITEM_SUSPENDED)
                {
                        // suspended so FLY and no touch displacement -- CEV
                        e.movetype = MOVETYPE_FLY;
                        e.touch = sub_null;
                }
                else
                {
                        // otherwise bounce & displacement (KickGib) -- CEV
                        e.movetype = MOVETYPE_BOUNCE;
                        e.touch = base_item_throwable_touch;
                }

                // TODO CEV
                e.angles.y = e.owner.angles.y + iit.view_angles_offset.y;

                // send this entity to CSQC -- CEV
                if (!e.SendEntity)
                {
                        e.classgroup |= CG_FRAMETICK;
                        e.contentstransition = base_item_contentstransition;
                        e.watertype = e.owner.watertype;

                        e.SendEntity = base_entity_netsend;
                        e.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;
                        e.tick = base_item_neteval;
                }
                else if (e.classtype == CT_PLAYER)
                {
                        e.SendFlags |= NETFLAG_PLAYER_MODEL |
                                NETFLAG_PLAYER_SOLID | NETFLAG_PLAYER_SIZE;
                }
                #endif

                // now set bounding box if we're solid -- CEV
                if (e.solid)
                        setsize (e, iit.world_mins, iit.world_maxs);
                else
                        setsize (e, '0 0 0', '0 0 0');

                setorigin (e, e.origin);
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        strip void() base_item_throwable =
        {
                base_item_throwable_init (self);
        };
#endif
// };

//----------------------------------------------------------------------
// original progs_dump 3 / DeadStuff entity spawn functions -- CEV
//----------------------------------------------------------------------

#ifdef SSQC

//----------------------------------------------------------------------
#define ITEM_GIB(igs) \
/* { */ \
        BASE_ITEM_PREINIT (__NULL__) \
        self.weapon = igs; \
        base_item_throwable_init (self); \
/* } */

/*QUAKED gib_misc_1 (0 0.5 0.8) (-8 -8 -8) (8 8 8) SOLID X X X X X X X 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/gib1.mdl");
}*/
//----------------------------------------------------------------------
// class gib_misc_1: base_item_throwable
// {
        void() gib_misc_1 = { ITEM_GIB (ITEM_SEQ_GIB1) };
// };

/*QUAKED gib_misc_2 (0 0.5 0.8) (-8 -8 -8) (8 8 8) SOLID X X X X X X X 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/gib2.mdl");
}*/
//----------------------------------------------------------------------
// class gib_misc_2: base_item_throwable
// {
        void() gib_misc_2 = { ITEM_GIB (ITEM_SEQ_GIB2) };
// };

/*QUAKED gib_misc_3 (0 0.5 0.8) (-8 -8 -8) (8 8 8) SOLID X X X X X X X 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/gib3.mdl");
}*/
//----------------------------------------------------------------------
// class gib_misc_3: base_item_throwable
// {
        void() gib_misc_3 = { ITEM_GIB (ITEM_SEQ_GIB3) };
// };

/*QUAKED gib_head_demon (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_demon.mdl");
}
*/
//----------------------------------------------------------------------
// class gib_head_demon: base_item_throwable
// {
        void() gib_head_demon = { ITEM_GIB (ITEM_SEQ_HEAD_DEMON) };
// };

/*QUAKED gib_head_dog (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_dog.mdl");
}
*/
//----------------------------------------------------------------------
// class gib_head_dog: base_item_throwable
// {
        void() gib_head_dog = { ITEM_GIB (ITEM_SEQ_HEAD_DOG) };
// };

/*QUAKED gib_head_enforcer (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_mega.mdl");
}
*/
//----------------------------------------------------------------------
// class gib_head_enforcer: base_item_throwable
// {
        void() gib_head_enforcer = { ITEM_GIB (ITEM_SEQ_HEAD_ENFORCER) };
// };

/*QUAKED gib_head_hell_knight (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_hellkn.mdl");
}*/
//----------------------------------------------------------------------
// class gib_head_hell_knight: base_item_throwable
// {
        void() gib_head_hell_knight = { ITEM_GIB (ITEM_SEQ_HEAD_HELLKNIGHT) };
// };

/*QUAKED gib_head_knight (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_knight.mdl");
}*/
//----------------------------------------------------------------------
// class gib_head_knight: base_item_throwable
// {
        void() gib_head_knight = { ITEM_GIB (ITEM_SEQ_HEAD_KNIGHT) };
// };

/*QUAKED gib_head_ogre (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_ogre.mdl");
}*/
//----------------------------------------------------------------------
// class gib_head_ogre: base_item_throwable
// {
        void() gib_head_ogre = { ITEM_GIB (ITEM_SEQ_HEAD_OGRE) };
// };

/*QUAKED gib_head_player (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_player.mdl");
}*/
//----------------------------------------------------------------------
// class gib_head_player: base_item_throwable
// {
        void() gib_head_player = { ITEM_GIB (ITEM_SEQ_HEAD_PLAYER) };
// };

/*QUAKED gib_head_shalrath (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_shal.mdl");
}*/
//----------------------------------------------------------------------
// class gib_head_shalrath: base_item_throwable
// {
        void() gib_head_shalrath = { ITEM_GIB (ITEM_SEQ_HEAD_SHALRATH) };
// };

/*QUAKED gib_head_shambler (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_shams.mdl");
}*/
//----------------------------------------------------------------------
// class gib_head_shambler: base_item_throwable
// {
        void() gib_head_shambler = { ITEM_GIB (ITEM_SEQ_HEAD_SHAMBLER) };
// };

/*QUAKED gib_head_army (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_guard.mdl");
}
*/
//----------------------------------------------------------------------
// class gib_head_army: base_item_throwable
// {
        void() gib_head_army = { ITEM_GIB (ITEM_SEQ_HEAD_ARMY) };
// };

/*QUAKED gib_head_wizard (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_wizard.mdl");
}*/
//----------------------------------------------------------------------
// class gib_head_wizard: base_item_throwable
// {
        void() gib_head_wizard = { ITEM_GIB (ITEM_SEQ_HEAD_WIZARD) };
// };

/*QUAKED gib_head_zombie (0 0.5 0.8) (-16 -16 0) (16 16 56) SOLID X X X X X X X 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/h_zombie.mdl");
}
*/
//----------------------------------------------------------------------
// class gib_head_zombie: base_item_throwable
// {
        void() gib_head_zombie = { ITEM_GIB (ITEM_SEQ_HEAD_ZOMBIE) };
// };

#undef ITEM_GIB
#endif