Git Repos / fte_dogmode / qc / items / gore.qc
Last update to this file was on 2025-03-30 at 19:29.
Show gore.qc
//==============================================================================
// items/gore.qc -- corpses, gibs, heads. the meaty bits. -- 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
//----------------------------------------------------------------------
// base_item_gib spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
SPAWNFLAG_ITEM_GIB_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_gib_spawnflags;
#endif
#ifdef SSQC
const float DEBRISQUE_COUNT_MAX = 50; // max number of gibs at one time
const float GIB1_DAMAGE = 5; // small gib damage when thrown
const float GIB2_DAMAGE = 15; // large gib damage when thrown
const float GIB3_DAMAGE = 10; // med. (slice-like) gib damage
// TODO CEV
const string GIB_SOUND_FIRE = "items/damage.wav";
#endif
#if defined(CSQC) || defined(SSQC)
// gib & head sizes; values from progs_dump 3 -- CEV
const vector GIB1_MINS = '-3.57 -8.06 -3.34';
const vector GIB1_MAXS = '3.69 8.31 30';
const vector GIB2_MINS = '-12.68 -14.83 -6.19';
const vector GIB2_MAXS = '13.53 14.57 30';
const vector GIB3_MINS = '-18.95 -15.92 -3.13';
const vector GIB3_MAXS = '13.17 15.66 30';
const vector DEMON1_HEAD_MINS = '-13.64 -16.77 -0.11';
const vector DEMON1_HEAD_MAXS = '17.44 16.22 30';
const vector DOG_HEAD_MINS = '-9.66 -11.89 -0.2';
const vector DOG_HEAD_MAXS = '6.57 7.96 13.29';
const vector ENFORCER_HEAD_MINS = '-10.63 -10.23 -0.05';
const vector ENFORCER_HEAD_MAXS = '9.27 8.25 30';
const vector HELL_KNIGHT_HEAD_MINS = '-7.9 -12.97 -0.63';
const vector HELL_KNIGHT_HEAD_MAXS = '10.55 8.87 21.06';
const vector KNIGHT_HEAD_MINS = '-8.17 -7.47 -0.13';
const vector KNIGHT_HEAD_MAXS = '8.36 6.5 30';
const vector OGRE_HEAD_MINS = '-12.35 -15.7 -0.17';
const vector OGRE_HEAD_MAXS = '10.67 13.88 30';
const vector PLAYER_HEAD_MINS = '-9.67 -12.38 -2.1';
const vector PLAYER_HEAD_MAXS = '11.49 50.7 30';
const vector SHALRATH_HEAD_MINS = '-19.85 -19.09 -1.44';
const vector SHALRATH_HEAD_MAXS = '13.72 16.8 30';
const vector SHAMBLER_HEAD_MINS = '-15.15 -20.638 -0.45';
const vector SHAMBLER_HEAD_MAXS = '21.44 21.76 30';
const vector ARMY_HEAD_MINS = '-9.67 -8.27 -0.28';
const vector ARMY_HEAD_MAXS = '4.05 4.8 13.41';
const vector WIZARD_HEAD_MINS = '-10.41 -8.66 -0.54';
const vector WIZARD_HEAD_MAXS = '6.52 10.82 30';
const vector ZOMBIE_HEAD_MINS = '-16 -16 0'; // not exact size -- CEV
const vector ZOMBIE_HEAD_MAXS = '16 16 56';
#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 dmg) velocity_for_damage;
#endif
// base_item_gib
#ifdef CSQC
void(float isnew, void(entity) initfn) base_item_gib_netreceive;
#endif
#ifdef SSQC
// BASE_ITEM_GIB_THROW(spawnfunc)
void(entity grabber, entity gib) base_item_gib_grab;
void(entity attacker, float item_index) base_item_gib_fire;
void() base_item_gib_touch;
entity(entity src, vector org, vector vel, float fl, void(entity) initfn)
spawn_base_item_gib;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) base_item_gib_init;
#endif
#ifdef SSQC
strip void() base_item_gib;
#endif
// item_gib1
#if defined(CSQC) || defined(SSQC)
void(entity e) item_gib1_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_gib1;
void() item_gib1;
#endif
// item_gib2
#if defined(CSQC) || defined(SSQC)
void(entity e) item_gib2_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_gib2;
void() item_gib2;
#endif
// item_gib3
#if defined(CSQC) || defined(SSQC)
void(entity e) item_gib3_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_gib3;
void() item_gib3;
#endif
// item_head_demon
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_demon_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_demon;
void() item_head_demon;
#endif
// item_head_dog
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_dog_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_dog;
void() item_head_dog;
#endif
// item_head_enforcer
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_enforcer_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_enforcer;
void() item_head_enforcer;
#endif
// item_head_hell_knight
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_hell_knight_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_hell_knight;
void() item_head_hell_knight;
#endif
// item_head_knight
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_knight_init
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_knight;
void() item_head_knight;
#endif
// item_head_ogre
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_ogre_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_ogre;
void() item_head_ogre;
#endif
// item_head_player
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_player_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_player;
void() item_head_player;
#endif
// item_head_shalrath
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_shalrath_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_shalrath;
void() item_head_shalrath;
#endif
// item_head_shambler
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_shambler_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_shambler;
void() item_head_shambler;
#endif
// item_head_army
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_army_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_army;
void() item_head_army;
#endif
// item_head_wizard
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_wizard_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_wizard;
void() item_head_wizard;
#endif
// item_head_zombie
#if defined(CSQC) || defined(SSQC)
void(entity e) item_head_zombie_init;
#endif
#ifdef SSQC
entity(entity src, vector org, vector vel, float fl) spawn_item_head_zombie;
void() item_head_zombie;
#endif
#ifdef SSQC
//----------------------------------------------------------------------
// original progs_dump 3 / DeadStuff entities -- CEV
//----------------------------------------------------------------------
void() gib_misc_1 = { item_gib1 (); };
void() gib_misc_2 = { item_gib2 (); };
void() gib_misc_3 = { item_gib3 (); };
void() gib_head_demon = { item_head_demon (); };
void() gib_head_dog = { item_head_dog (); };
void() gib_head_enforcer = { item_head_enforcer (); };
void() gib_head_hell_knight = { item_head_hell_knight (); };
void() gib_head_knight = { item_head_knight (); };
void() gib_head_ogre = { item_head_ogre (); };
void() gib_head_player = { item_head_player (); };
void() gib_head_shalrath = { item_head_shalrath (); };
void() gib_head_shambler = { item_head_shambler (); };
void() gib_head_army = { item_head_army (); };
void() gib_head_wizard = { item_head_wizard (); };
void() gib_head_zombie = { item_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.direct_damage = 0;
e.velocity_z += 250 + 50 * random ();
e.nextthink = time + 1;
return e;
};
//----------------------------------------------------------------------
vector(vector dir, float dmg) 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, dmg * dmg / 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, dmg * dmg / 22, 800);
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 > 500)
v *= 500 / vspeed;
v_z = min (500, v_z);
#if 0
dprint (sprintf("velocity_for_damage: damage is %g, startdir is %v, "
"v is %v\n", dmg, startdir, v));
#endif
return v;
};
#endif
//----------------------------------------------------------------------
// base_item_gib
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// class base_item_gib: base_item
// {
#ifdef CSQC
//--------------------------------------------------------------
void(float isnew, void(entity) initfn) base_item_gib_netreceive =
{
// creates a number of variables, including netflags -- CEV
BASE_ITEM_NETRECEIVE (initfn)
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
// was self.origin + '0 0 24' -- CEV
//--------------------------------------------------------------
#define BASE_ITEM_GIB_THROW(d, h, func) \
{ \
spawn_base_item_gib (self, self.origin, \
velocity_for_damage(d, h), \
SPAWNFLAG_ITEM_THROWN, func); \
}
//--------------------------------------------------------------
void(entity grabber, entity gib) base_item_gib_grab =
{
BASE_ITEM_INVENTORY_ADD (gib, grabber)
// don't re-grab / immediately throw the item -- CEV
if (grabber.button6)
grabber.flags |= FL_THROW_HELD;
// let the player know -- CEV
sprint (grabber, sprintf("%s grabbed a %s\n",
grabber.netname, gib.netname));
// let CSQC know -- CEV
if (grabber.classtype == CT_PLAYER && grabber.SendEntity)
grabber.SendFlags |= NETFLAG_PLAYER_WEAPON;
// remove the gib from the queue before firing targets -- CEV
base_entity_que_rem (gib, QUE_TYPE_DEBRIS);
// fire all targets / killtargets (unlikely to be used) -- CEV
local entity stemp = self;
local entity otemp = grabber;
other = grabber;
self = gib;
activator = grabber;
sub_usetargets ();
self = stemp;
other = otemp;
// gibs won't respawn so we're clear to remove here -- CEV
if (gib)
{
gib.model = __NULL__;
setmodel (gib, gib.model);
gib.solid = SOLID_NOT;
gib.touch = sub_null;
gib.think = sub_remove;
gib.nextthink = time + 0.2;
gib.SendFlags |= NETFLAG_BASE_ENTITY_MODEL |
NETFLAG_BASE_ENTITY_SOLID;
}
};
//--------------------------------------------------------------
// player has pressed +attack while holding a gib -- CEV
//--------------------------------------------------------------
void(entity attacker, float item_index) base_item_gib_fire =
{
// play a sound then delay next attack -- CEV
sound (attacker, CHAN_ITEM, GIB_SOUND_FIRE, VOL_MHI, ATTN_NORM);
attacker.attack_finished = time + 0.5;
};
//--------------------------------------------------------------
// 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
//
// gib_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_gib_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_push (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 gibs to move into the floor -- CEV
self.avelocity_y = 100 * crandom ();
};
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl,
void(entity) initfn) spawn_base_item_gib =
{
local entity e = spawn ();
e.owner = src;
e.spawnflags = fl;
e.origin = org;
e.velocity = vel;
initfn (e);
// thrown from a gibbed enemy -- CEV
if (fl & SPAWNFLAG_ITEM_THROWN) {
if (src.health < 0)
{
// special handling for heads -- CEV
if (e.weapon >= ITEM_SEQ_HEAD_START &&
e.weapon <= ITEM_SEQ_HEAD_END)
{
// -24 due to offset from BASE_ITEM_GIB_THROW
// then an addition -24 -- CEV
/*
if (!(src.classgroup & CG_CORPSE))
e.origin_z -= 48;
*/
if (!e.avelocity)
e.avelocity = crandom() * '0 600 0';
}
else
{
e.avelocity_x = random() * 600;
e.avelocity_y = random() * 600;
e.avelocity_z = random() * 600;
}
} }
// register this entity in the gib queue -- CEV
local entity rem = base_entity_que_add (e, QUE_TYPE_DEBRIS);
if (rem)
{
// a gib 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)
//--------------------------------------------------------------
// gibs don't call base_item_init, they get special treatment -- CEV
//--------------------------------------------------------------
void(entity e) base_item_gib_init =
{
#ifdef SSQC
if (e.flags & FL_CLIENT)
dprint (sprintf("base_item_gib_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;
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);
// TODO CEV
precache_sound ("items/damage.wav");
#endif
#ifdef CSQC
setmodelindex (e, e.modelindex);
#endif
e.noise = item.pickup_sound;
// guarantee size -- CEV
if (!e.pos1 && !e.pos2)
{
e.pos1 = '0 0 0';
e.pos2 = '32 32 56';
}
if (!(e.flags & FL_CLIENT))
// let's not change the player name lol -- CEV
e.netname = item.name;
#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.destroy)
e.destroy = sub_nulldestroy;
// make sure we won't take damage -- CEV
e.takedamage = DAMAGE_NO;
// so we can be picked up -- CEV
e.flags |= FL_FINDABLE_NONSOLID;
if (e.spawnflags & SPAWNFLAG_ITEM_THROWN)
if (e.flags & FL_CLIENT)
e.flags &= ~FL_ONGROUND;
if (e.spawnflags & SPAWNFLAG_ITEM_GIB_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;
e.think = base_item_think_throwgroundcheck;
e.nextthink = time + 0.1;
}
else
{
e.solid = SOLID_TRIGGER;
}
}
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_gib_touch;
}
// TODO CEV
e.angles.y = e.owner.angles.y + item.view_angles_offset.y;
// send this entity to CSQC -- CEV
e.classgroup |= CG_FRAMETICK;
e.SendEntity = base_entity_netsend;
e.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;
e.tick = base_item_neteval;
#endif
// now set bounding box if we're solid -- CEV
if (e.solid)
setsize (e, e.pos1, e.pos2);
else
setsize (e, '0 0 0', '0 0 0');
setorigin (e, e.origin);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
strip void() base_item_gib =
{
base_item_gib_init (self);
};
#endif
// };
//----------------------------------------------------------------------
// individual gibs
//----------------------------------------------------------------------
/*QUAKED item_gib1 (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 item_gib1: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_gib1_init =
{
e.classname = "item_gib1";
e.classtype = CT_ITEM_GIB1;
#ifdef SSQC
e.weapon = ITEM_SEQ_GIB1;
e.dmg = GIB1_DAMAGE;
e.frame = 0;
#endif
e.pos1 = GIB1_MINS;
e.pos2 = GIB1_MAXS;
// this will set e.solid
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl) spawn_item_gib1 =
{
return spawn_base_item_gib (src, org, vel, fl, item_gib1_init);
};
//--------------------------------------------------------------
void() item_gib1 =
{
// remap spawnflags, inhibit spawn, remap fields -- CEV
BASE_ITEM_PREINIT (__NULL__)
item_gib1_init (self);
};
#endif
// };
/*QUAKED item_gib2 (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 item_gib2: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_gib2_init =
{
e.classname = "item_gib2";
e.classtype = CT_ITEM_GIB2;
#ifdef SSQC
e.weapon = ITEM_SEQ_GIB2;
e.dmg = GIB2_DAMAGE;
e.frame = 0;
#endif
e.pos1 = GIB2_MINS;
e.pos2 = GIB2_MAXS;
// this will set e.solid
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl) spawn_item_gib2 =
{
return spawn_base_item_gib (src, org, vel, fl, item_gib2_init);
};
//--------------------------------------------------------------
void() item_gib2 =
{
// remap spawnflags, inhibit spawn, remap fields -- CEV
BASE_ITEM_PREINIT (__NULL__)
item_gib2_init (self);
};
#endif
// };
/*QUAKED item_gib3 (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 item_gib3: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_gib3_init =
{
e.classname = "item_gib3";
e.classtype = CT_ITEM_GIB3;
#ifdef SSQC
e.weapon = ITEM_SEQ_GIB3;
e.dmg = GIB3_DAMAGE;
e.frame = 0;
#endif
e.pos1 = GIB3_MINS;
e.pos2 = GIB3_MAXS;
// this will set e.solid
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl) spawn_item_gib3 =
{
return spawn_base_item_gib (src, org, vel, fl, item_gib3_init);
};
//--------------------------------------------------------------
void() item_gib3 =
{
// remap spawnflags, inhibit spawn, remap fields -- CEV
BASE_ITEM_PREINIT (__NULL__)
item_gib3_init (self);
};
#endif
// };
//----------------------------------------------------------------------
// heads
//----------------------------------------------------------------------
/*QUAKED item_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 item_head_demon: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_demon_init =
{
e.classname = "item_head_demon";
e.classtype = CT_ITEM_HEAD_DEMON;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_DEMON;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = DEMON1_HEAD_MINS;
e.pos2 = DEMON1_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_demon =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_demon_init);
};
//--------------------------------------------------------------
void() item_head_demon =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_demon_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_dog: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_dog_init =
{
e.classname = "item_head_dog";
e.classtype = CT_ITEM_HEAD_DOG;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_DOG;
// was 1 -- dumptruck_ds
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = DOG_HEAD_MINS;
e.pos2 = DOG_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_dog =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_dog_init);
};
//--------------------------------------------------------------
void() item_head_dog =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_dog_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_enforcer: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_enforcer_init =
{
e.classname = "item_head_enforcer";
e.classtype = CT_ITEM_HEAD_ENFORCER;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_ENFORCER;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = ENFORCER_HEAD_MINS;
e.pos2 = ENFORCER_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_enforcer =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_enforcer_init);
};
//--------------------------------------------------------------
void() item_head_enforcer =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_enforcer_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_hell_knight: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_hell_knight_init =
{
e.classname = "item_head_hellknight";
e.classtype = CT_ITEM_HEAD_HELLKNIGHT;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_HELLKNIGHT;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = HELL_KNIGHT_HEAD_MINS;
e.pos2 = HELL_KNIGHT_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_hell_knight =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_hell_knight_init);
};
//--------------------------------------------------------------
void() item_head_hell_knight =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_hell_knight_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_knight: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_knight_init =
{
e.classname = "item_head_knight";
e.classtype = CT_ITEM_HEAD_KNIGHT;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_KNIGHT;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = KNIGHT_HEAD_MINS;
e.pos2 = KNIGHT_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_knight =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_knight_init);
};
//--------------------------------------------------------------
void() item_head_knight =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_knight_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_ogre: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_ogre_init =
{
e.classname = "item_head_ogre";
e.classtype = CT_ITEM_HEAD_OGRE;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_OGRE;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = OGRE_HEAD_MINS;
e.pos2 = OGRE_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_ogre =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_ogre_init);
};
//--------------------------------------------------------------
void() item_head_ogre =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_ogre_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_player: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_player_init =
{
// don't reset class if passed a client entity -- CEV
if (!(e.flags & FL_CLIENT))
{
e.classname = "item_head_player";
e.classtype = CT_ITEM_HEAD_PLAYER;
}
#ifdef SSQC
// TODO CEV let's hope this behaves
e.weapon = ITEM_SEQ_HEAD_PLAYER;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = PLAYER_HEAD_MINS;
e.pos2 = PLAYER_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
#ifdef SSQC
if (e.SendEntity)
{
e.SendFlags |= NETFLAG_PLAYER_MODEL |
NETFLAG_PLAYER_SOLID | NETFLAG_PLAYER_SIZE;
}
#endif
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_player =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_player_init);
};
//--------------------------------------------------------------
void() item_head_player =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_player_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_shalrath: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_shalrath_init =
{
e.classname = "item_head_shalrath";
e.classtype = CT_ITEM_HEAD_SHALRATH;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_SHALRATH;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = SHALRATH_HEAD_MINS;
e.pos2 = SHALRATH_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_shalrath =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_shalrath_init);
};
//--------------------------------------------------------------
void() item_head_shalrath =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_shalrath_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_shambler: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_shambler_init =
{
e.classname = "item_head_shambler";
e.classtype = CT_ITEM_HEAD_SHAMBLER;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_SHAMBLER;
// was 1, caused an error -- dumptruck_ds
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = SHAMBLER_HEAD_MINS;
e.pos2 = SHAMBLER_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_shambler =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_shambler_init);
};
//--------------------------------------------------------------
void() item_head_shambler =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_shambler_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_army: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_army_init =
{
e.classname = "item_head_army";
e.classtype = CT_ITEM_HEAD_ARMY;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_ARMY;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = ARMY_HEAD_MINS;
e.pos2 = ARMY_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_army =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_army_init);
};
//--------------------------------------------------------------
void() item_head_army =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_army_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_wizard: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_wizard_init =
{
e.classname = "item_head_wizard";
e.classtype = CT_ITEM_HEAD_WIZARD;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_WIZARD;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = WIZARD_HEAD_MINS;
e.pos2 = WIZARD_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_wizard =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_wizard_init);
};
//--------------------------------------------------------------
void() item_head_wizard =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_wizard_init (self);
};
#endif
// };
/*QUAKED item_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 item_head_zombie: base_item_gib
// {
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) item_head_zombie_init =
{
e.classname = "item_head_zombie";
e.classtype = CT_ITEM_HEAD_ZOMBIE;
#ifdef SSQC
e.weapon = ITEM_SEQ_HEAD_ZOMBIE;
e.frame = 0;
e.view_ofs = '0 0 8';
#endif
e.pos1 = ZOMBIE_HEAD_MINS;
e.pos2 = ZOMBIE_HEAD_MAXS;
// gib_init interprets spawnflags and will set .solid -- CEV
base_item_gib_init (e);
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
entity(entity src, vector org, vector vel, float fl)
spawn_item_head_zombie =
{
return spawn_base_item_gib (src, org, vel, fl,
item_head_zombie_init);
};
//--------------------------------------------------------------
void() item_head_zombie =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
item_head_zombie_init (self);
};
#endif
// };
Return to the top of this page or return to the overview of this repo.
Log gore.qc
| Date | Commit Message | Author | + | - |
|---|---|---|---|---|
| 2025-03-30 | Big commit. Entity networking, etc. | cev | +1453 |
Return to the top of this page or return to the overview of this repo.