Git Repos / fte_dogmode / qc / base_entities.qc
Last update to this file was on 2025-03-30 at 19:29.
Show base_entities.qc
//==============================================================================
// base_entities.qc -- top-level entities (entity, tempentity, mapentity)
//==============================================================================
//======================================================================
// constants
//======================================================================
#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// global spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
SPAWNFLAG_NOT_ON_EASY = 256, // this + next 3 are engine built-ins
SPAWNFLAG_NOT_ON_NORMAL = 512,
SPAWNFLAG_NOT_ON_HARD_OR_NIGHTMARE = 1024,
SPAWNFLAG_NOT_IN_DEATHMATCH = 2048,
SPAWNFLAG_NOT_IN_COOP = 4096, // Not in Coop
SPAWNFLAG_NOT_IN_SP = 8192, // Not in Single Player
SPAWNFLAG_NOT_IN_TEAMPLAY = 16384, // Not in Teamplay
SPAWNFLAG_NOT_ON_SKILL2 = 32768,// Not on Hard Only
SPAWNFLAG_NOT_ON_SKILL3 = 65536,// Not on Nightmare Only
SPAWNFLAG_CENTERPRINTALL = 131072 // print to all clients
} base_entity_spawnflags;
#endif
#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// common entity netflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
// first byte of netflags
NETFLAG_BASE_ENTITY_EXTRA1, // read an additional byte of netflags
NETFLAG_BASE_ENTITY_ORIGIN_X, // .origin has changed
NETFLAG_BASE_ENTITY_ORIGIN_Y,
NETFLAG_BASE_ENTITY_ORIGIN_Z,
NETFLAG_BASE_ENTITY_ANGLES_Y, // .angles_y has changed
NETFLAG_BASE_ENTITY_RESERVED1, // reserved
NETFLAG_BASE_ENTITY_FRAME, // .frame has changed
NETFLAG_BASE_ENTITY_SKIN, // .skin has changed
// second byte of netflags
NETFLAG_BASE_ENTITY_ANGLES_X, // .angles_x has changed
NETFLAG_BASE_ENTITY_ANGLES_Z, // .angles_z has changed
NETFLAG_BASE_ENTITY_MODEL, // model has changed
NETFLAG_BASE_ENTITY_SIZE, // .mins and/or .maxs have changed
NETFLAG_BASE_ENTITY_SOLID, // .solid and/or .movetype
NETFLAG_BASE_ENTITY_WEAPON, // .weapon has changed
NETFLAG_BASE_ENTITY_RESERVED2, // reserved
NETFLAG_BASE_ENTITY_ALPHA // .alpha has changed
} base_entity_netflags;
// this bit & higher require EXTRA1 to be set -- CEV
const float NETFLAG_BASE_ENTITY_HIGH1 = NETFLAG_BASE_ENTITY_ANGLES_X;
// OR together the angles bits for convenience -- CEV
const float NETFLAG_BASE_ENTITY_ANGLES = NETFLAG_BASE_ENTITY_ANGLES_X |
NETFLAG_BASE_ENTITY_ANGLES_Y | NETFLAG_BASE_ENTITY_ANGLES_Z;
// OR together the origin bits for convenience -- CEV
const float NETFLAG_BASE_ENTITY_ORIGIN = NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y | NETFLAG_BASE_ENTITY_ORIGIN_Z;
// all known netflag bits -- CEV
const float NETFLAG_BASE_ENTITY_FULLSEND = NETFLAG_BASE_ENTITY_EXTRA1 |
NETFLAG_BASE_ENTITY_ORIGIN_X | NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z | NETFLAG_BASE_ENTITY_ANGLES_Y |
NETFLAG_BASE_ENTITY_RESERVED1 | NETFLAG_BASE_ENTITY_FRAME |
NETFLAG_BASE_ENTITY_SKIN |
NETFLAG_BASE_ENTITY_ANGLES_X | NETFLAG_BASE_ENTITY_ANGLES_Z |
NETFLAG_BASE_ENTITY_MODEL | NETFLAG_BASE_ENTITY_SIZE |
NETFLAG_BASE_ENTITY_SOLID | NETFLAG_BASE_ENTITY_WEAPON |
NETFLAG_BASE_ENTITY_RESERVED2 | NETFLAG_BASE_ENTITY_ALPHA;
#endif
#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
typedef enum
{
STATE_ACTIVE = 0, // .estate field values
STATE_INACTIVE = 1,
STATE_INVISIBLE = 8
} base_entity_estates;
#endif
#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// identifies an entity as member of a linked list -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
QUE_TYPE_ACTOR, // moving actors (on the client)
QUE_TYPE_BODY, // the id1 bodyque
QUE_TYPE_CORPSE, // corpses
QUE_TYPE_DEBRIS // debris and gibs
} base_entity_queflags;
#endif
#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
typedef enumflags
{
DIMENSION_FLAG1,
DIMENSION_FLAG2,
DIMENSION_FLAG3,
DIMENSION_FLAG4,
DIMENSION_FLAG5,
DIMENSION_FLAG6,
DIMENSION_FLAG7,
DIMENSION_FLAG8
} base_entity_dimensionflags;
#endif
//======================================================================
// globals
//======================================================================
#ifdef CSQC
float servertime;
#endif
#ifdef SSQC
entity activator; // entity that activated trigger/brush
entity damage_attacker; // set by T_Damage
// Additional spawn parms, following the same parmN theme.
float parm17, parm18; /* parm19, parm20, parm21, parm22, parm23, parm24,
parm25, parm26, parm27, parm28, parm29, parm30, parm31, parm32; */
#endif
//----------------------------------------------------------------------
// linked lists -- CEV
//----------------------------------------------------------------------
#ifdef CSQC
entity actorque_head; // moving actors -- CEV
#endif
#ifdef SSQC
entity corpseque_head; // monster corpses -- CEV
entity debrisque_head; // debris from breakables -- CEV
float corpseque_count; // count of corpses queued -- CEV
float debrisque_count; // count of debris -- CEV
#endif
#if defined(CSQC) || defined(SSQC)
// Set by the engine before calls to spawn functions, and is most easily
// parsed with the tokenize builtin. This allows you to handle halflife's
// multiple-fields-with-the-same-name (or target-specific fields).
// comment from fteextensions.qc -- CEV
__unused var string __fullspawndata;
#endif
#if defined(CSQC) || defined(SSQC)
float trace_surfaceflagsf; // float form is deprecated
#endif
//======================================================================
// fields
//======================================================================
#if defined(CSQC) || defined(SSQC)
.float aflag; // trigger_filter, func_counter, item_
.float alpha; // translucency in supported engines
.float cnt; // misc flag
.float color; // Hipnotic
.float conlevel; // engine clobbers .waterlevel -- CEV
.float contype; // engine clobbers .watertype -- CEV
.float count; // for counting triggers
.float damage_mod; // dumptruck_ds
.float delay; // time from activation to firing
.float dimension_hit; // FTEQW
.float dimension_solid; //
.float distance;
.float dmg; // damage done by door when hit
.float height;
.float gravity; // from custdefs.qc by way of Hipnotic
.float is_waiting; // wait until activated before trigger?
.float inventory1; // inventory slots 1 through 8 -- CEV
.float inventory2; //
.float inventory3; //
.float inventory4; //
.float inventory5; //
.float inventory6; //
.float inventory7; //
.float inventory8; //
.float lefty; // used by monsters and func_bob
.float modelflags; // used to overwrite model flags -- CEV
.float queflag; // linked list flag -- CEV
.float scale; // resizes model. 1=normal, 2=double
.float speed;
.float speed2;
.float state; // plats / doors / buttons
.float style, style2;
.float t_length, t_width; // func_, monster face, player LG, etc
.float wait; // time from firing to restarting
.float waitmin; // sounds (removed: waitmax)
.float wantedgravity; // thanks Spike!
.float volume; // sounds
.float estate; // entity state
.float prevstate; // previous entity state
.void() olduse; // previous use function
.string mdl; // hold original model for switching
.string message2; // func_laser & trigger_heal
.string noise4; // noise & noise1-3 defined in entvars_t
// variables for enhanced triggering from Custents -- dumptruck_ds
// .string target // defined in entvars_t -- CEV
.string target2; // second target's name
.string target3; // third target's name
.string target4; // fourth target's name
// .string targetname // defined in entvars_t -- CEV
.string targetname2; // second name
.string targetname3; // third name
.string targetname4; // fourth name
.string killtarget; // first target to kill
.string killtarget2; // second target to kill
.string pain_target; // dumptruck_ds
.vector dest; // MG1
.vector dest2; // MG1
.vector mangle; // angle at start
.vector neworigin; // prediction, hipnotic rotation
.vector pos1; // used by func classes & to hold orig
.vector pos2; // mins & maxes -- CEV
.entity oldenemy; // mad at this ent before taking damage
.entity que_next; // linked lists -- CEV
.entity trigger_field; // TODO CEV: cutscene, door, shambler
#endif
#ifdef SSQC
.void() tick; // MG1 frametick system -- CEV
.void(entity src, float amount) th_pain;
.void(vector dir) destroy; // th_die
#endif
#ifdef SSQC
// Called by the engine whenever an entity needs to be (re)sent to a client's
// csprogs, either because SendFlags was set or because data was lost. Must
// write its data to the MSG_ENTITY buffer. Will be called at the engine's
// leasure.
.float(entity e, float changedflags) SendEntity;
// Indicates that something in the entity has been changed, and that it needs
// to be updated to all players that can see it. The engine will clear it at
// some point, with the cleared bits appearing in the 'changedflags' argument
// of the SendEntity method.
.float SendFlags;
#endif
#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity networking / prediction; based on Nuclide and CSQCTest -- CEV
//----------------------------------------------------------------------
.vector origin_net; // last origin sent/received
.vector origin_prev; // previous origin received
.vector angles_net; // last angles sent/received
.vector angles_prev; // previous angles received
.float frame_net; // last .frame sent/received
#ifdef CSQC
.vector velocity_net; // for player prediction -- CEV
.float origin_prev_stime;
.float origin_prev_time; // timestamp of previous origin receipt
.float origin_net_stime;
.float origin_net_time; // timestamp of most recent origin
.float angles_prev_stime;
.float angles_prev_time; // timestamp of previous angles receipt
.float angles_net_stime;
.float angles_net_time; // timestamp of most recent angles
.float flags_net; // last .flags received
.float pm_flags_net; // last .pm_flags received
.float pm_timer_net; // last .pm_timer received
#endif
#endif
//======================================================================
// forward declarations
//======================================================================
// base entity
#ifdef CSQC
// BASE_ENTITY_NETFLAGS2(fl) // read netflags2 built by macro below
// BASE_ENTITY_READALPHA(fl) // Read macros for often-used fields
// BASE_ENTITY_READANGLES(flP, flY, flR)
// BASE_ENTITY_READCLASSTYPE()
// BASE_ENTITY_READFRAME(fl)
// BASE_ENTITY_READMODEL(fl)
// BASE_ENTITY_READORIGIN(flX, flY, flZ)
// BASE_ENTITY_READSIZE(fl)
// BASE_ENTITY_READSKIN(fl)
// BASE_ENTITY_READSOLID(fl)
// BASE_ENTITY_READWEAPON(fl)
float(float isnew) base_entity_netreceive;
#endif
#ifdef SSQC
// BASE_ENTITY_NETFLAGS1(fl) // flag building macros
// BASE_ENTITY_NETFLAGS2(fl)
// BASE_ENTITY_NETFLAGS_EXTRA(fl1, fl2) // netflag hacks
// BASE_ENTITY_NETFLAGS_FRAMEHACK(fl)
// BASE_ENTITY_NETFLAGS_ANGLESHACK(flP, flY, flR)
// BASE_ENTITY_NETFLAGS_ORIGINHACK(flX, flY, flZ)
// BASE_ENTITY_WRITEALPHA(fl) // Write macros for often-used fields
// BASE_ENTITY_WRITEANGLES(flP, flY, flR)
// BASE_ENTITY_WRITECLASSTYPE()
// BASE_ENTITY_WRITEFRAME(fl)
// BASE_ENTITY_WRITEMODEL(fl)
// BASE_ENTITY_WRITEORIGIN(flX, flY, flZ)
// BASE_ENTITY_WRITESIZE(fl)
// BASE_ENTITY_WRITESKIN(fl)
// BASE_ENTITY_WRITESOLID(fl)
// BASE_ENTITY_WRITEWEAPON(fl)
float(entity to, float netflags) base_entity_netsend_null;
float(entity to, float netflags) base_entity_netsend;
#endif
#ifdef CSQC
float() base_entity_parsemapdata;
// BASE_ENTITY_LERP_ANGLES(ent, nvec, pvec, ctime, ntime, ptime)
// BASE_ENTITY_LERP_ORIGIN(ent, nvec, pvec, ctime, ntime, ptime)
#endif
#if defined(CSQC) || defined(SSQC)
// BASE_ENTITY_WEAPONLOOKUP(ent)
void(entity e) base_entity_aligntoground;
void(entity e, entity p, float maxspeed) base_entity_push;
void(entity e) base_entity_positioncontents;
void(entity e) base_entity_remove;
#endif
#ifdef SSQC
void() base_entity_movetype_push;
void(entity e) base_entity_boundammo;
#endif
#if defined(CSQC) || defined(SSQC)
entity(entity e, float fl) base_entity_que_add;
void(entity e, float fl) base_entity_que_rem;
#endif
#ifdef SSQC
float(entity src, entity dest) can_damage;
void(entity targ, entity inflictor, entity attacker, vector dir) killed;
void(entity inflictor, entity attacker, float damage, entity ignore)
t_radiusdamage2;
void(entity inflictor, entity attacker, float damage, float radius,
float mindamage, entity ignore) t_radiusdamage3;
void(entity attacker, float damage) t_beamdamage2;
void(entity targ, entity inflictor, entity attacker, float damage) t_damage2;
#endif
#if defined(CSQC) || defined(SSQC)
void() sub_null; // Subs
void(entity attacker, float damage) sub_nullpain;
void(vector dir) sub_nulldestroy;
void() sub_remove;
void() sub_remove_fade;
void(entity doas, void() f) sub_runvoidas;
float(entity doas, float() f) sub_runfloatas;
float(entity toucher) sub_checkvalidtouch;
#endif
#ifdef SSQC
void() sub_usetargets;
void(string matchstring, .string matchfield) sub_killtarget;
void(string matchstring, .string matchfield) sub_usetarget;
#endif
// base_tempentity
#if defined(CSQC) || defined(SSQC)
void(entity e) base_tempentity_init;
strip void() base_tempentity;
#endif
// temp_delayed_targets
#ifdef SSQC
void() temp_delayed_targets_think;
entity() spawn_temp_delayed_targets;
void(entity e) temp_delayed_targets_init;
strip void() temp_delayed_targets;
#endif
// base_mapentity
#if defined(CSQC) || defined(SSQC)
void(entity e) sub_setmovedir;
#endif
#ifdef SSQC
void() sub_useandforgettargets;
#endif
#ifdef SSQC
void(void(string key, string value) init_field_fn)
base_mapentity_init_spawndata;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) base_mapentity_init;
strip void() base_mapentity;
#endif
// noclass
#ifdef SSQC
void() noclass;
#endif
//------------------------------------------------------------------------------
//----------------------------------------------------------------------
// class base_entity: entity
// {
//==============================================================
// Generic entity networking -- Client
//==============================================================
#ifdef CSQC
//--------------------------------------------------------------
#define BASE_ENTITY_NETFLAGS2(fl) \
/* { */ \
if (netflags2 & (fl >> 8)) \
{ \
netflags |= fl; \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READALPHA(fl) \
/* { */ \
if (netflags & fl) \
{ \
self.alpha = ReadFloat (); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READCLASSTYPE() \
/* { */ \
self.classtype = ReadByte (); \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READANGLES(flP, flY, flR) \
/* { */ \
if (netflags & flP || netflags & flY || netflags & flR) \
{ \
if (isnew) \
{ \
if (netflags & flP) \
self.angles.x = ReadAngle (); \
if (netflags & flY) \
self.angles.y = ReadAngle (); \
if (netflags & flR) \
self.angles.z = ReadAngle (); \
self.angles_prev = self.angles; \
self.angles_net = self.angles; \
self.angles_prev_time = time; \
self.angles_net_time = self.angles_prev_time; \
self.angles_prev_stime = servertime; \
self.angles_net_stime = servertime; \
} \
else \
{ \
local vector newangles; \
if (netflags & flP) \
newangles.x = ReadAngle (); \
else \
newangles.x = self.angles_net.x; \
if (netflags & flY) \
newangles.y = ReadAngle (); \
else \
newangles.y = self.angles_net.y; \
if (netflags & flR) \
newangles.z = ReadAngle (); \
else \
newangles.z = self.angles_net.z; \
if (newangles != self.angles_net) \
{ \
self.angles_prev = self.angles_net; \
self.angles_prev_time = \
self.angles_net_time; \
self.angles_prev_stime = \
self.angles_net_stime; \
self.angles_net = newangles; \
self.angles_net_time = time; \
self.angles_net_stime = servertime; \
} \
} \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READFRAME(fl) \
/* { */ \
if (netflags & fl) \
{ \
self.frame_net = ReadByte (); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READMODEL(fl) \
/* { */ \
if (netflags & fl) \
{ \
self.modelindex = ReadShort (); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READORIGIN(flX, flY, flZ) \
/* { */ \
if (netflags & flX || netflags & flY || netflags & flZ) \
{ \
if (isnew) \
{ \
if (netflags & flX) \
self.origin.x = ReadCoord (); \
if (netflags & flY) \
self.origin.y = ReadCoord (); \
if (netflags & flZ) \
self.origin.z = ReadCoord (); \
self.origin_prev = self.origin; \
self.origin_net = self.origin; \
self.origin_prev_time = time; \
self.origin_net_time = self.origin_prev_time; \
self.origin_prev_stime = servertime; \
self.origin_net_stime = servertime; \
setorigin (self, self.origin); \
} \
else \
{ \
local vector neworigin; \
if (netflags & flX) \
neworigin.x = ReadCoord (); \
else \
neworigin.x = self.origin_net.x; \
if (netflags & flY) \
neworigin.y = ReadCoord (); \
else \
neworigin.y = self.origin_net.y; \
if (netflags & flZ) \
neworigin.z = ReadCoord (); \
else \
neworigin.z = self.origin_net.z; \
if (neworigin != self.origin_net) \
{ \
self.origin_prev = self.origin_net; \
self.origin_prev_time = \
self.origin_net_time; \
self.origin_prev_stime = \
self.origin_net_stime; \
self.origin_net = neworigin; \
self.origin_net_time = time; \
self.origin_net_stime = servertime; \
} \
} \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READSIZE(fl) \
/* { */ \
if (netflags & fl) \
{ \
self.mins.x = ReadCoord (); \
self.mins.y = ReadCoord (); \
self.mins.z = ReadCoord (); \
self.maxs.x = ReadCoord (); \
self.maxs.y = ReadCoord (); \
self.maxs.z = ReadCoord (); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READSKIN(fl) \
/* { */ \
if (netflags & fl) \
{ \
self.skin = ReadByte (); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READSOLID(fl) \
/* { */ \
if (netflags & fl) \
{ \
self.solid = ReadByte (); \
self.movetype = ReadByte (); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_READWEAPON(fl) \
/* { */ \
if (netflags & fl) \
{ \
self.weapon = ReadByte (); \
} \
/* } */
//--------------------------------------------------------------
float(float isnew) base_entity_netreceive =
{
local float netflags = ReadByte ();
if (netflags & NETFLAG_BASE_ENTITY_EXTRA1)
{
local float netflags2 = ReadByte ();
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_ANGLES_X)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_ANGLES_Z)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_MODEL)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_SIZE)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_SOLID)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_WEAPON)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_RESERVED2)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_ALPHA)
}
BASE_ENTITY_READORIGIN (NETFLAG_BASE_ENTITY_ORIGIN_X,
NETFLAG_BASE_ENTITY_ORIGIN_Y,
NETFLAG_BASE_ENTITY_ORIGIN_Z)
BASE_ENTITY_READANGLES (NETFLAG_BASE_ENTITY_ANGLES_X,
NETFLAG_BASE_ENTITY_ANGLES_Y,
NETFLAG_BASE_ENTITY_ANGLES_Z)
BASE_ENTITY_READFRAME (NETFLAG_BASE_ENTITY_FRAME)
BASE_ENTITY_READSKIN (NETFLAG_BASE_ENTITY_SKIN)
BASE_ENTITY_READMODEL (NETFLAG_BASE_ENTITY_MODEL)
BASE_ENTITY_READSIZE (NETFLAG_BASE_ENTITY_SIZE)
BASE_ENTITY_READSOLID (NETFLAG_BASE_ENTITY_SOLID)
BASE_ENTITY_READWEAPON (NETFLAG_BASE_ENTITY_WEAPON)
BASE_ENTITY_READALPHA (NETFLAG_BASE_ENTITY_ALPHA)
return netflags;
};
#endif
//==============================================================
// Generic entity networking -- Server
//==============================================================
#ifdef SSQC
//--------------------------------------------------------------
#define BASE_ENTITY_NETFLAGS1(fl) \
/* { */ \
if (netflags & fl) \
{ \
netflags1 |= fl; \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_NETFLAGS2(fl) \
/* { */ \
if (netflags & fl) \
{ \
netflags2 |= fl >> 8; \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_NETFLAGS_EXTRA(flH, flEXTRA) \
/* { */ \
if (netflags >= flH) \
{ \
if (!(netflags & flEXTRA)) \
netflags |= flEXTRA; \
} \
else \
{ \
if (netflags & flEXTRA) \
netflags &= ~flEXTRA; \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_NETFLAGS_FRAMEHACK(fl) \
/* { */ \
if (!(netflags & fl)) \
{ \
if (self.frame_net != self.frame) \
{ \
netflags |= fl; \
} \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_NETFLAGS_ANGLESHACK(flP, flY, flR) \
/* { */ \
if (netflags & flP) \
{ \
if (self.angles_net.x == self.angles.x) \
{ \
netflags &= ~flP; \
} \
} \
else \
{ \
if (self.angles_net.x != self.angles.x) \
{ \
netflags |= flP; \
} \
} \
if (netflags & flY) \
{ \
if (self.angles_net.y == self.angles.y) \
{ \
netflags &= ~flY; \
} \
} \
else \
{ \
if (self.angles_net.y != self.angles.y) \
{ \
netflags |= flY; \
} \
} \
if (netflags & flR) \
{ \
if (self.angles_net.z == self.angles.z) \
{ \
netflags &= ~flR; \
} \
} \
else \
{ \
if (self.angles_net.z != self.angles.z) \
{ \
netflags |= flR; \
} \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_NETFLAGS_ORIGINHACK(flX, flY, flZ) \
/* { */ \
if (netflags & flX) \
{ \
if (self.origin_net.x == self.origin.x) \
{ \
netflags &= ~flX; \
} \
} \
else \
{ \
if (self.origin_net.x != self.origin.x) \
{ \
netflags |= flX; \
} \
} \
if (netflags & flY) \
{ \
if (self.origin_net.y == self.origin.y) \
{ \
netflags &= ~flY; \
} \
} \
else \
{ \
if (self.origin_net.y != self.origin.y) \
{ \
netflags |= flY; \
} \
} \
if (netflags & flZ) \
{ \
if (self.origin_net.z == self.origin.z) \
{ \
netflags &= ~flZ; \
} \
} \
else \
{ \
if (self.origin_net.z != self.origin.z) \
{ \
netflags |= flZ; \
} \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITEALPHA(fl) \
/* { */ \
if (netflags & fl) \
{ \
WriteFloat (MSG_ENTITY, self.alpha); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITEANGLES(flP, flY, flR) \
/* { */ \
if (netflags & flP) \
{ \
WriteAngle (MSG_ENTITY, self.angles.x); \
self.angles_net.x = self.angles.x; \
} \
if (netflags & flY) \
{ \
WriteAngle (MSG_ENTITY, self.angles.y); \
self.angles_net.y = self.angles.y; \
} \
if (netflags & flR) \
{ \
WriteAngle (MSG_ENTITY, self.angles.z); \
self.angles_net.z = self.angles.z; \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITECLASSTYPE() \
/* { */ \
WriteByte (MSG_ENTITY, self.classtype); \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITEFRAME(fl) \
/* { */ \
if (netflags & fl) \
{ \
WriteByte (MSG_ENTITY, self.frame); \
self.frame_net = self.frame; \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITEMODEL(fl) \
/* { */ \
if (netflags & fl) \
{ \
WriteShort (MSG_ENTITY, self.modelindex); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITEORIGIN(flX, flY, flZ) \
/* { */ \
if (netflags & flX) \
{ \
WriteCoord (MSG_ENTITY, self.origin.x); \
self.origin_net.x = self.origin.x; \
} \
if (netflags & flY) \
{ \
WriteCoord (MSG_ENTITY, self.origin.y); \
self.origin_net.y = self.origin.y; \
} \
if (netflags & flZ) \
{ \
WriteCoord (MSG_ENTITY, self.origin.z); \
self.origin_net.z = self.origin.z; \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITESIZE(fl) \
/* { */ \
if (netflags & fl) \
{ \
WriteCoord (MSG_ENTITY, self.mins.x); \
WriteCoord (MSG_ENTITY, self.mins.y); \
WriteCoord (MSG_ENTITY, self.mins.z); \
WriteCoord (MSG_ENTITY, self.maxs.x); \
WriteCoord (MSG_ENTITY, self.maxs.y); \
WriteCoord (MSG_ENTITY, self.maxs.z); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITESKIN(fl) \
/* { */ \
if (netflags & fl) \
{ \
WriteByte (MSG_ENTITY, self.skin); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITESOLID(fl) \
/* { */ \
if (netflags & fl) \
{ \
WriteByte (MSG_ENTITY, self.solid); \
WriteByte (MSG_ENTITY, self.movetype); \
} \
/* } */
//--------------------------------------------------------------
#define BASE_ENTITY_WRITEWEAPON(fl) \
/* { */ \
if (netflags & fl) \
{ \
WriteByte (MSG_ENTITY, self.weapon); \
} \
/* } */
//--------------------------------------------------------------
float(entity to, float netflags) base_entity_netsend_null =
{
// this is to suppress the engine sending an entity -- CEV
return FALSE;
};
//--------------------------------------------------------------
float(entity to, float netflags) base_entity_netsend =
{
BASE_ENTITY_WRITECLASSTYPE ()
// restrict to known flags -- CEV
if (netflags > NETFLAG_BASE_ENTITY_FULLSEND)
netflags = NETFLAG_BASE_ENTITY_FULLSEND;
// split netflags into bytes -- CEV
local float netflags1 = 0;
local float netflags2 = 0;
// a couple of hacks for ORIGIN, ANGLES, and FRAME to ensure
// they're transmitted to the client if they've changed -- CEV
if (netflags != NETFLAG_BASE_ENTITY_FULLSEND)
{
// rewrite origin flags -- CEV
BASE_ENTITY_NETFLAGS_ORIGINHACK (
NETFLAG_BASE_ENTITY_ORIGIN_X,
NETFLAG_BASE_ENTITY_ORIGIN_Y,
NETFLAG_BASE_ENTITY_ORIGIN_Z)
// rewrite angles flags -- CEV
BASE_ENTITY_NETFLAGS_ANGLESHACK (
NETFLAG_BASE_ENTITY_ANGLES_X,
NETFLAG_BASE_ENTITY_ANGLES_Y,
NETFLAG_BASE_ENTITY_ANGLES_Z)
// rewrite frame flag -- CEV
BASE_ENTITY_NETFLAGS_FRAMEHACK (
NETFLAG_BASE_ENTITY_FRAME)
}
// make sure EXTRA1 is set if needed -- CEV
BASE_ENTITY_NETFLAGS_EXTRA (NETFLAG_BASE_ENTITY_HIGH1,
NETFLAG_BASE_ENTITY_EXTRA1)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_EXTRA1)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_ORIGIN_X)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_ORIGIN_Y)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_ORIGIN_Z)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_ANGLES_Y)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_RESERVED1)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_FRAME)
BASE_ENTITY_NETFLAGS1 (NETFLAG_BASE_ENTITY_SKIN)
// write first byte of netflags -- CEV
WriteByte (MSG_ENTITY, netflags1);
// build second netflags byte if needed -- CEV
if (netflags & NETFLAG_BASE_ENTITY_EXTRA1)
{
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_ANGLES_X)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_ANGLES_Z)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_MODEL)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_SIZE)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_SOLID)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_WEAPON)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_RESERVED2)
BASE_ENTITY_NETFLAGS2 (NETFLAG_BASE_ENTITY_ALPHA)
// write second byte -- CEV
WriteByte (MSG_ENTITY, netflags2);
}
// write entity data -- see base_entities.qc for macros -- CEV
BASE_ENTITY_WRITEORIGIN (NETFLAG_BASE_ENTITY_ORIGIN_X,
NETFLAG_BASE_ENTITY_ORIGIN_Y,
NETFLAG_BASE_ENTITY_ORIGIN_Z)
BASE_ENTITY_WRITEANGLES (NETFLAG_BASE_ENTITY_ANGLES_X,
NETFLAG_BASE_ENTITY_ANGLES_Y,
NETFLAG_BASE_ENTITY_ANGLES_Z)
BASE_ENTITY_WRITEFRAME (NETFLAG_BASE_ENTITY_FRAME)
BASE_ENTITY_WRITESKIN (NETFLAG_BASE_ENTITY_SKIN)
BASE_ENTITY_WRITEMODEL (NETFLAG_BASE_ENTITY_MODEL)
BASE_ENTITY_WRITESIZE (NETFLAG_BASE_ENTITY_SIZE)
BASE_ENTITY_WRITESOLID (NETFLAG_BASE_ENTITY_SOLID)
BASE_ENTITY_WRITEWEAPON (NETFLAG_BASE_ENTITY_WEAPON)
BASE_ENTITY_WRITEALPHA (NETFLAG_BASE_ENTITY_ALPHA)
return TRUE;
};
#endif
//==============================================================
// Misc Functions
//==============================================================
#ifdef CSQC
//--------------------------------------------------------------
// Called from CSQC_WorldLoaded to parse the map entity lump;
// here on the client-side we mostly care about entities that
// are solid or can affect movement -- CEV
//--------------------------------------------------------------
float() base_entity_parsemapdata =
{
local string field, value = "";
local entity e = spawn ();
local entity oself;
local void(entity e) initfunc = __NULL__;
while (1)
{
field = getentitytoken ();
if (field == __NULL__ || field == "")
break;
if (field == "}")
{
if (e.classname == __NULL__ ||
e.classname == "")
{
break;
}
if (e.classname == "worldspawn")
{
// manually copy a couple fields
world.fog_color = e.fog_color;
world.fog_density = e.fog_density;
// initialize world
oself = self;
self = world;
worldspawn ();
self = oself;
// don't need ent e anymore
remove (e);
return TRUE;
}
else if (initfunc)
{
initfunc (e);
return TRUE;
}
// past here we're ignoring the entity -- CEV
remove (e);
return TRUE;
}
value = getentitytoken ();
if (value == __NULL__ || value == "")
break;
// dprint (sprintf("CSQC_WorldLoaded: field %s, "
// "value %s\n", field, value));
switch (field)
{
case "classname":
e.classname = value;
break;
case "origin":
e.origin = stov (value);
break;
case "angles":
e.angles = stov (value);
break;
case "angle":
e.angles_x = 0;
e.angles_y = stof (value);
e.angles_z = 0;
break;
case "mangle":
e.mangle = stov (value);
break;
case "model":
e.model = value;
break;
case "fog_color":
e.fog_color = stov (value);
break;
case "fog_density":
e.fog_density = stof (value);
break;
case "target":
e.target = value;
break;
case "targetname":
e.targetname = value;
break;
}
}
// unhandled entity or something went wrong -- CEV
remove (e);
return FALSE;
};
//--------------------------------------------------------------
// angle interpolation macro -- suitable for predraw -- CEV
// args: entity, _net vector, _prev vector, time, _net_time, _prev_time
//--------------------------------------------------------------
#define BASE_ENTITY_LERP_ANGLES(ent, nvec, pvec, ctime, ntime, ptime) \
/* { */ \
if (ntime != ctime && (ntime - ptime)) \
{ \
local float af2 = (ctime - ntime) / (ntime - ptime); \
af2 = bound (0, af2, 1); \
local float ang; \
/* correctly wrap angles when interpolating. this is
* the same logic used in Ironwail 0.7.0; see
* Quake/cl_main.c line 547 -- CEV */ \
for (float angi = 0; angi < 3; angi++) \
{ \
ang = nvec[angi] - pvec[angi]; \
if (ang > 180) \
ang -= 360; \
else if (ang < -180) \
ang += 360; \
ent.angles[angi] = pvec[angi] + ang * af2; \
} \
}
/* } */
//--------------------------------------------------------------
// origin interpolation macro -- suitable for predraw -- CEV
// args: entity, _net vector, _prev vector, time, _net_time, _prev_time
//--------------------------------------------------------------
#define BASE_ENTITY_LERP_ORIGIN(ent, nvec, pvec, ctime, ntime, ptime) \
/* { */ \
local float of2 = ntime - ptime; \
if (ntime != ctime && (of2)) \
{ \
/* of2 (lerp fraction) code from Ironwail 0.7.0,
* file cl_main.c function CL_LerpPoint -- CEV */ \
if (of2 > 0.1) \
{ \
/* dropped packet, or start of demo
* (above comment from Ironwail) -- CEV */ \
/* this seems to smooth out some jerky motion,
* noticeable with monster_wizard -- CEV */ \
ptime = ntime - 0.1; \
of2 = 0.1; \
} \
of2 = (ctime - ntime) / of2; \
/* the engine (Ironwail at least) sometimes adjusts
* the client's time global while bounding the lerp
* fraction; let's not do that here in QC -- CEV */ \
of2 = bound (0, of2, 1); \
ent.origin = pvec + (nvec - pvec) * of2; \
/*
dprint (sprintf("BASE_ENTITY_LERP_ORIGIN: " \
"t - n %g, n - p %g, of2 %g\n", \
ctime - ntime, ntime - ptime, of2)); \
*/ \
setorigin (ent, ent.origin); \
} \
/* } */
#endif
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
#define BASE_ENTITY_WEAPONLOOKUP(ent) \
/* { */ \
local float item_index = 0; \
switch (ent.weapon) \
{ \
case 1: item_index = ent.inventory1; break; \
case 2: item_index = ent.inventory2; break; \
case 3: item_index = ent.inventory3; break; \
case 4: item_index = ent.inventory4; break; \
case 5: item_index = ent.inventory5; break; \
case 6: item_index = ent.inventory6; break; \
case 7: item_index = ent.inventory7; break; \
case 8: item_index = ent.inventory8; break; \
} \
/* } */
//--------------------------------------------------------------
// Align an entity to the ground plane. Code by Spike, found here:
// https://forums.insideqc.com/viewtopic.php?f=2&t=5585#p55093
//--------------------------------------------------------------
void(entity e) base_entity_aligntoground =
{
traceline (e.origin, e.origin - '0 0 128', TRUE, e);
if (trace_fraction == 1)
return;
local vector ang = e.angles;
ang_x *= -1;
makevectors (ang);
local vector coplanar = v_forward -
(v_forward * trace_plane_normal) * trace_plane_normal;
e.angles = vectoangles (coplanar, trace_plane_normal);
// e.angles = vectoangles (coplanar);
#ifdef SSQC
if (e.SendEntity)
{
if (e.classtype == CT_PLAYER)
e.SendFlags |= NETFLAG_PLAYER_ANGLES;
else
e.SendFlags |= NETFLAG_BASE_ENTITY_ANGLES;
}
#endif
};
//--------------------------------------------------------------
// Push entity e away from entity p at a rate based on p's
// velocity (no higher than maxspeed) -- CEV
//--------------------------------------------------------------
void(entity e, entity p, float maxspeed) base_entity_push =
{
local float espeed, newspeed, zspeed;
if (p.classtype == CT_PLAYER && p.speed)
newspeed = p.speed;
else
newspeed = vlen ([p.velocity_x, p.velocity_y, 0]);
zspeed = e.velocity_z;
// entities usually won't move if they're ONGROUND -- CEV
e.flags &= ~FL_ONGROUND;
// move away from the pushing entity; this is the same method
// t_damage uses to find damage knockback direction -- CEV
local vector dir;
dir = e.origin - (p.absmin + p.absmax) * 0.5;
dir = normalize (dir);
e.velocity += dir * newspeed;
// limit speed to argument maxspeed -- CEV
e.velocity_z = 0;
espeed = vlen (e.velocity);
if (espeed > maxspeed)
{
e.velocity = normalize (e.velocity);
e.velocity *= maxspeed;
}
if (e.movetype == MOVETYPE_BOUNCE)
// MOVETYPE_BOUNCE entities stop when impacting the
// ground if Z velocity is 60 or less. Let's not
// bounce around too much, so set a Z velocity a
// little above that threshhold. -- CEV
e.velocity_z = 70;
else
// restore Z speed as normal
e.velocity_z = zspeed;
};
//--------------------------------------------------------------
// Set waterlevel and watertype; based on checks from purecsqc's
// pmove.qc. Called by both monsters and players. -- CEV
//--------------------------------------------------------------
void(entity e) base_entity_positioncontents =
{
local vector v = e.origin;
#ifdef SSQC
local float oldtype = e.contype;
#endif
// check contents at e's feet + 1
v_z = e.origin_z + e.mins_z + 1;
e.contype = pointcontents (v);
if (e.contype < CONTENT_SOLID)
{
if (e.classtype == CT_PLAYER)
{
v_z = e.origin_z + (e.mins_z + e.maxs_z) * 0.5;
if (pointcontents(v) < CONTENT_SOLID)
{
v_z = e.origin_z + e.maxs_z;
if (pointcontents(v) < CONTENT_SOLID)
{
e.conlevel = WATERLEVEL_EYES;
}
else
{
e.conlevel = WATERLEVEL_WAIST;
}
}
else
{
e.conlevel = WATERLEVEL_FEET;
}
}
else if (e.classgroup & CG_MONSTER)
{
// only check contents past feet if the
// monster is in water
if (e.contype == CONTENT_WATER)
{
v_z = e.origin_z + e.maxs_z;
if (pointcontents(v) < CONTENT_SOLID)
{
e.conlevel = WATERLEVEL_EYES;
}
else
{
e.conlevel = WATERLEVEL_FEET;
}
}
else
{
e.conlevel = WATERLEVEL_FEET;
}
}
else
{
// all other entities only check to feet level
e.conlevel = WATERLEVEL_FEET;
}
}
else
{
e.conlevel = WATERLEVEL_NONE;
if (e.classgroup & CG_MONSTER)
e.air_finished = time + 12;
}
#ifdef SSQC
// do our content transition checks right here -- CEV
if (e.contype <= CONTENT_WATER && oldtype == CONTENT_EMPTY) {
if (e.classtype != CT_PLAYER) {
if (e.swim_time < time)
{
e.swim_time = time + 2;
sound (e, CHAN_AUTO, "misc/h2ohit1.wav", VOL_MID,
ATTN_NORM);
} } }
if (e.contype == CONTENT_EMPTY)
{
e.watertype = e.contype;
e.waterlevel = e.conlevel;
}
#endif
};
//--------------------------------------------------------------
// wrapper for remove() that safely pulls entities out of any
// queues they might be in before calling the real remove -- CEV
//--------------------------------------------------------------
void(entity e) base_entity_remove =
{
if (e)
{
if (e.queflag)
base_entity_que_rem (e, e.queflag);
if (e.classgroup & CG_FRAMETICK)
e.classgroup &= ~CG_FRAMETICK;
remove (e);
}
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
// .customphysics for MOVETYPE_PUSH entities that set SendFlags
// on the moving entity and any moved entities -- CEV
//--------------------------------------------------------------
void() base_entity_movetype_push =
{
local float mt = server_deltatime;
local float oldltime = self.ltime;
if (self.nextthink < self.ltime + mt)
mt = max (0, self.nextthink - self.ltime);
if (mt) {
if (self.velocity == '0 0 0' && self.avelocity == '0 0 0')
{
self.ltime += mt;
}
else
{
local vector oldmin = self.absmin;
local vector oldmax = self.absmax;
// pushing entities is hard; let the engine do it -- CEV
if (pushmove(self, self.velocity * mt,
self.avelocity * mt))
{
self.ltime += mt;
// flag any nearby ents to transmit origin to
// CSQC; findradius options from Xonotic -- CEV
local entity e = findradius(
(oldmin + oldmax) * 0.5,
vlen(oldmin - oldmax) * 0.5);
for (; e; e = e.chain)
{
switch (e.movetype)
{
case MOVETYPE_NONE:
case MOVETYPE_PUSH:
case MOVETYPE_NOCLIP:
continue;
}
if (e.origin == e.origin_net)
continue;
// defines so I don't run off the
// right side of my screen -- CEV
#define FL1 NETFLAG_BASE_ENTITY_ORIGIN
#define FL2 NETFLAG_PLAYER_ORIGIN
switch (e.SendEntity)
{
case base_entity_netsend:
e.SendFlags |= FL1;
break;
case player_netsend:
e.SendFlags |= FL2;
break;
default:
continue;
break;
}
#undef FL1
#undef FL2
#if 0
dprint (sprintf("base_entity_movetype_"
"push: %s found %s, time %g\n",
self.classname, e.classname,
time));
#endif
}
}
if (self.origin != self.origin_net)
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN;
} }
if (self.nextthink > oldltime)
{
if (self.nextthink <= self.ltime)
{
self.nextthink = 0;
if (self.think)
self.think ();
}
}
};
//--------------------------------------------------------------
void(entity e) base_entity_boundammo =
{
// these constants are defined in items/ammo.qc -- CEV
if (e.ammo_shells > AMMO_SHELLS_MAX)
e.ammo_shells = AMMO_SHELLS_MAX;
if (e.ammo_nails > AMMO_NAILS_MAX)
e.ammo_nails = AMMO_NAILS_MAX;
if (e.ammo_rockets > AMMO_ROCKETS_MAX)
e.ammo_rockets = AMMO_ROCKETS_MAX;
if (e.ammo_cells > AMMO_CELLS_MAX)
e.ammo_cells = AMMO_CELLS_MAX;
};
#endif
//==============================================================
// Linked List Handling
//==============================================================
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
#define BASE_ENTITY_QUE_DEBUG
//--------------------------------------------------------------
#define BASE_ENTITY_QUE_ADD_DEBUGPRINT() \
{ \
newcount = *que_count; \
dprint (sprintf("base_entity_que_add: " \
"added %s, type %g, new count %g\n", \
add.classname, fl, newcount)); \
}
//--------------------------------------------------------------
// base_entity_que_add
// arguments are: entity to add & type of list to add it to -- CEV
// returns an entity if one was removed from the queue -- CEV
//
// this is based on the linked list (actor list) management code
// in the Wrath Aeon Of Ruin multiplayer codebase by Reki -- CEV
//--------------------------------------------------------------
entity(entity add, float fl) base_entity_que_add =
{
local entity ret = __NULL__;
if (add.queflag)
{
// already in a queue -- CEV
if (add.queflag != fl)
dprint (sprintf("base_entity_que_add: %s "
"ent is a member of another list "
"(queflag %g, type %g)!\n",
add.classname, add.queflag, fl));
return ret;
}
add.queflag = fl;
local entity h = world;
local entity g;
local entity *que_head = __NULL__;
local float *que_count = __NULL__;
local float que_count_max = 0;
#ifdef BASE_ENTITY_QUE_DEBUG
local float newcount = 0;
#endif
switch (fl)
{
#ifdef CSQC
case QUE_TYPE_ACTOR:
que_head = &actorque_head;
break;
#endif
#ifdef SSQC
case QUE_TYPE_BODY:
que_head = &bodyque_head;
break;
case QUE_TYPE_CORPSE:
que_head = &corpseque_head;
que_count = &corpseque_count;
break;
case QUE_TYPE_DEBRIS:
que_head = &debrisque_head;
que_count = &debrisque_count;
que_count_max = DEBRISQUE_COUNT_MAX;
break;
#endif
default:
dprint (sprintf("base_entity_que_add: "
"unknown que type %g, class %s\n",
fl, add.classname));
return ret;
}
for (g = *que_head; g; h = g, g = g.que_next)
{
if (g == add)
// found a duplicate -- CEV
return ret;
}
if (h == world)
{
// we're the first, so we are the list -- CEV
*que_head = add;
// increment a count if we have one -- CEV
if (que_count)
{
*que_count = *que_count + 1;
#ifdef BASE_ENTITY_QUE_DEBUG
BASE_ENTITY_QUE_ADD_DEBUGPRINT ()
#endif
}
return ret;
}
// queue size limiter -- CEV
if (que_count)
{
if (que_count_max)
{
// store the queue head, then shift the head
// to its next, then return the stored entity
// -- CEV
if (*que_count >= que_count_max)
{
ret = *que_head;
*que_head = ret.que_next;
ret.que_next = world;
}
else
{
// increment global counter -- CEV
*que_count = *que_count + 1;
}
}
else
{
// increment global counter -- CEV
*que_count = *que_count + 1;
}
}
#ifdef BASE_ENTITY_QUE_DEBUG
if (que_count)
{
BASE_ENTITY_QUE_ADD_DEBUGPRINT ()
}
#endif
h.que_next = add;
return ret;
};
//--------------------------------------------------------------
#undef BASE_ENTITY_QUE_ADD_DEBUGPRINT
//--------------------------------------------------------------
#define BASE_ENTITY_QUE_REM_DEBUGPRINT() \
{ \
newcount = *que_count; \
dprint (sprintf("base_entity_que_rem: " \
"removed %s, type %g, new count %g\n", \
rem.classname, fl, newcount)); \
}
//--------------------------------------------------------------
void(entity rem, float fl) base_entity_que_rem =
{
if (!(rem.queflag))
// not a member of a list -- CEV
return;
rem.queflag = 0;
local entity *que_head = __NULL__;
local float *que_count = __NULL__;
#ifdef BASE_ENTITY_QUE_DEBUG
local float newcount = 0;
#endif
switch (fl)
{
#ifdef CSQC
case QUE_TYPE_ACTOR:
que_head = &actorque_head;
break;
#endif
#ifdef SSQC
case QUE_TYPE_BODY:
que_head = &bodyque_head;
break;
case QUE_TYPE_CORPSE:
que_head = &corpseque_head;
que_count = &corpseque_count;
break;
case QUE_TYPE_DEBRIS:
que_head = &debrisque_head;
que_count = &debrisque_count;
break;
#endif
default:
dprint (sprintf("base_entity_que_rem: "
"unknown que type %g, class %s\n",
fl, rem.classname));
return;
}
if (rem == *que_head)
{
local entity head1 = *que_head;
*que_head = head1.que_next;
// set the removed entity's que_next to 0 -- CEV
rem.que_next = world;
if (que_count)
{
*que_count = *que_count - 1;
#ifdef BASE_ENTITY_QUE_DEBUG
BASE_ENTITY_QUE_REM_DEBUGPRINT ()
#endif
}
return;
}
local entity h = world;
local entity g;
for (g = *que_head; g; h = g, g = g.que_next)
{
if (g != rem)
continue;
h.que_next = rem.que_next;
// set the removed entity's que_next to 0 -- CEV
rem.que_next = world;
if (que_count)
{
*que_count = *que_count - 1;
#ifdef BASE_ENTITY_QUE_DEBUG
BASE_ENTITY_QUE_REM_DEBUGPRINT ()
#endif
}
return;
}
};
//--------------------------------------------------------------
#undef BASE_ENTITY_QUE_REM_DEBUGPRINT
#endif
//==============================================================
// Damage Functions
//==============================================================
#ifdef SSQC
//--------------------------------------------------------------
// CanDamage
// Returns true if the source (inflictor) can directly damage
// the destination (target). Used for explosions and melee attacks.
//--------------------------------------------------------------
float(entity src, entity dest) can_damage =
{
if (dest.takedamage == DAMAGE_NO)
return FALSE;
// bmodels need special checking because their origin is 0,0,0
if (dest.movetype == MOVETYPE_PUSH)
{
traceline (src.origin,
0.5 * (dest.absmin + dest.absmax), TRUE, src);
if (trace_fraction == 1)
return TRUE;
if (trace_ent == dest)
return TRUE;
return FALSE;
}
traceline (src.origin, dest.origin, TRUE, src);
if (trace_fraction == 1)
return TRUE;
traceline (src.origin, dest.origin + '15 15 0', TRUE, src);
if (trace_fraction == 1)
return TRUE;
traceline (src.origin, dest.origin + '-15 -15 0', TRUE, src);
if (trace_fraction == 1)
return TRUE;
traceline (src.origin, dest.origin + '-15 15 0', TRUE, src);
if (trace_fraction == 1)
return TRUE;
traceline (src.origin, dest.origin + '15 -15 0', TRUE, src);
if (trace_fraction == 1)
return TRUE;
return FALSE;
};
//--------------------------------------------------------------
// Killed
//--------------------------------------------------------------
void(entity targ, entity inflictor, entity attacker, vector dir)
killed =
{
local entity stemp = self;
self = targ;
if (self.flags & FL_CLIENT && self.health < -99)
// don't let sbar look bad if a player
// also limits gib speed (velocity_for_damage) -- CEV
self.health = -99;
if (self.movetype == MOVETYPE_NONE ||
self.movetype == MOVETYPE_PUSH ||
self.movetype == MOVETYPE_FLYMISSILE ||
self.movetype == MOVETYPE_BOUNCE)
{
// doors, triggers, missiles, etc
// yoder add, 27/09/202 to let the SUB_UseTargets work
if (self.classtype == CT_MISC_EXPLOBOX ||
self.classtype == CT_MISC_EXPLOBOX2)
{
self.enemy = attacker;
}
if (self.th_die)
{
self.th_die ();
}
else if (self.destroy)
{
// rework for MOVETYPE_NONE, PUSH, etc -- CEV
dir = ((targ.absmin + targ.absmax) * 0.5) -
((inflictor.absmin + inflictor.absmax)
* 0.5);
self.destroy (normalize(dir));
}
self = stemp;
return;
}
self.enemy = attacker;
// bump the monster counter
if (self.flags & FL_MONSTER)
{
killed_monsters = killed_monsters + 1;
WriteByte (MSG_ALL, SVC_KILLEDMONSTER);
}
ClientObituary (self, inflictor, attacker);
self.takedamage = DAMAGE_NO;
self.touch = sub_null;
if (self.classgroup & CG_MONSTER)
base_monster_use_death ();
if (self.th_die)
self.th_die ();
else if (self.destroy)
self.destroy (dir);
self = stemp;
};
//--------------------------------------------------------------
// T_RadiusDamage
//--------------------------------------------------------------
void(entity inflictor, entity attacker, float damage, entity ignore)
t_radiusdamage2 =
{
local float points;
local entity head;
local vector org;
head = findradius (inflictor.origin, damage + 40);
while (head)
{
if (head == ignore || !head.takedamage)
{
head = head.chain;
continue;
}
org = head.origin + (head.mins + head.maxs) * 0.5;
points = 0.5 * vlen (inflictor.origin - org);
if (points < 0)
points = 0;
points = damage - points;
if (head == attacker)
points = points * 0.5;
if (points > 0)
{
if (can_damage(inflictor, head))
{
// shambler takes half damage from
// all explosions
if (head.classtype ==
CT_MONSTER_SHAMBLER)
{
t_damage2 (head, inflictor,
attacker, points * 0.5);
}
else
{
t_damage2 (head, inflictor,
attacker, points);
}
}
}
head = head.chain;
}
};
//--------------------------------------------------------------
void(entity inflictor, entity attacker, float damage, float radius,
float mindamage, entity ignore) t_radiusdamage3 =
{
local float points;
local entity head;
local vector org;
head = findradius (inflictor.origin, radius + 40);
while (head)
{
if (head == ignore || !head.takedamage)
{
head = head.chain;
continue;
}
org = head.origin + (head.mins + head.maxs) * 0.5;
points = max (0, 0.5 * vlen (inflictor.origin - org));
points = damage - points;
if (head == attacker)
points = points * 0.5;
if (mindamage > 0)
points = max (points, mindamage);
if (points > 0)
{
if (can_damage(inflictor, head))
{
// shambler takes half damage from
// all explosions
if (head.classtype ==
CT_MONSTER_SHAMBLER)
{
t_damage2 (head, inflictor,
attacker, points * 0.5);
}
else
{
t_damage2 (head, inflictor,
attacker, points);
}
}
}
head = head.chain;
}
};
//--------------------------------------------------------------
// T_BeamDamage
//--------------------------------------------------------------
void(entity attacker, float damage) t_beamdamage2 =
{
local float points;
local entity head;
head = findradius (attacker.origin, damage + 40);
while (head)
{
if (!head.takedamage)
{
head = head.chain;
continue;
}
points = 0.5 * vlen (attacker.origin - head.origin);
if (points < 0)
points = 0;
points = damage - points;
if (head == attacker)
points = points * 0.5;
if (points > 0)
{
if (can_damage(attacker, head))
{
if (head.classtype ==
CT_MONSTER_SHAMBLER)
{
t_damage2 (head, attacker,
attacker, points * 0.5);
}
else
{
t_damage2 (head, attacker,
attacker, points);
}
}
}
head = head.chain;
}
};
//--------------------------------------------------------------
// T_Damage
// The damage is coming from inflictor, but get mad at attacker
// This should be the only function that ever reduces health.
//--------------------------------------------------------------
void(entity targ, entity inflictor, entity attacker, float damage)
t_damage2 =
{
local entity stemp;
local vector dir = '0 0 0';
local float save;
local float take;
local float ignore_armor; // johnfitz
local string death_type; // johnfitz
// don't try to damage the world. Not healthy -- bmFbr
if (!targ)
return;
// make sure targ.deathtype doesn't keep stale info
// after this function is done -- johnfitz
death_type = targ.deathtype;
targ.deathtype = "";
// johnfitz
if (!targ.takedamage)
return;
// some func_breakables ignore monster damage -- johnfitz
// dded from Rubicon2 combat.qc -- dumptruck_ds
if (targ.classtype == CT_FUNC_BREAKABLE) {
if (targ.spawnflags & SPAWNFLAG_BASE_BREAKABLE_NO_MONSTERS) {
if (attacker.flags & FL_MONSTER)
{
return;
} } }
// johnfitz
// used by buttons and triggers to set activator for
// target firing
damage_attacker = attacker;
// check for quad damage powerup on the attacker
if (attacker.super_damage_finished > time)
{
dprint ("QUAD\n");
damage = damage * 4;
}
// damage mod for monsters -- dumptruck_ds
if (attacker.damage_mod)
damage = damage * attacker.damage_mod;
// TODO CEV this is a quick hack
if ((inflictor.classgroup & CG_PROJECTILE &&
inflictor.aflag & PROJECTILE_EXPLOSIVE) &&
(targ.classtype == CT_MONSTER_ZOMBIE ||
targ.classgroup & CG_CORPSE))
{
// let even weak explosions gib zombies and corpses
dprint ("t_damage2: damage boost for zombie gib\n");
damage = damage * 4;
}
// don't deplete armor if drowning/burning, or
// protected by biosuit/pentagram/godmode (note:
// in ID1 // pentagram/godmode doesn't actually
// protect your armor)
if (death_type == "burning" || death_type == "drowning" ||
targ.invincible_finished >= time ||
targ.flags & FL_GODMODE)
{
ignore_armor = TRUE;
}
else
{
ignore_armor = FALSE;
}
// johnfitz
// save damage based on the target's armor level
if (ignore_armor)
{
// some damage doesn't deplete armor -- johnfitz
save = 0;
}
else
{
save = ceil (targ.armortype * damage);
if (save >= targ.armorvalue)
{
save = targ.armorvalue;
// lost all armor
targ.armortype = 0;
targ.items = targ.items - (targ.items &
(IT_ARMOR1 | IT_ARMOR2 | IT_ARMOR3));
}
}
// 1998-08-12 Drowning doesn't hurt armor by Maddes/Athos start
// else
// {
// save = 0;
// }
// 1998-08-12 Drowning doesn't hurt armor by Maddes/Athos end
targ.armorvalue = targ.armorvalue - save;
take = ceil (damage - save);
// add to the damage total for clients, which will be
// sent as a single message at the end of the frame
// FIXME: remove after combining shotgun blasts?
if (targ.flags & FL_CLIENT)
{
targ.dmg_take = targ.dmg_take + take;
targ.dmg_save = targ.dmg_save + save;
targ.dmg_inflictor = inflictor;
}
// apply momentum change to players and monsters -- CEV
if (inflictor != world && targ.solid != SOLID_CORPSE && (
targ.movetype == MOVETYPE_WALK ||
targ.movetype == MOVETYPE_STEP ||
targ.movetype == MOVETYPE_FLY))
{
// figure momentum direction
dir = targ.origin -
(inflictor.absmin + inflictor.absmax) * 0.5;
// only a fraction of dir_z -- CEV
dir_z = dir_z * 0.5;
dir = normalize (dir);
if (targ.flags & FL_MONSTER &&
targ.flags & FL_ONGROUND &&
targ.movetype == MOVETYPE_STEP)
{
targ.flags &= ~FL_ONGROUND;
}
if (attacker.classtype == CT_PLAYER && attacker == targ)
// standard knockback for self-damage -- CEV
targ.velocity += dir * damage * 8;
else
// decreased knockback otherwise -- CEV
if (attacker.super_damage_finished > time)
// negate Quad
targ.velocity += dir * damage;
else
targ.velocity += dir * damage * 4;
/*
dprint (sprintf("t_damage2: inflictor %s adds "
"momentum in direction %v to target %s\n",
inflictor.classname, dir, targ.classname));
*/
}
// check for godmode or invincibility
if (targ.flags & FL_GODMODE)
return;
if (targ.invincible_finished >= time)
{
if (self.invincible_sound < time)
{
sound (targ, CHAN_ITEM, "items/protect3.wav",
VOL_HIGH, ATTN_NORM);
self.invincible_sound = time + 2;
}
return;
}
// team play damage avoidance
// 1998-07-29 Teamplay 1 fix by Maddes start
if ((teamplay == 1) && (targ.team > 0) &&
(targ.team == attacker.team) &&
(targ != attacker) &&
(attacker.classtype == CT_PLAYER) &&
// because squishing a teammate is still possible
(inflictor.classtype != CT_FUNC_DOOR))
{
return;
}
// 1998-07-29 Teamplay 1 fix by Maddes end
// do the damage
targ.health = targ.health - take;
// fire pain_target if appropriate
if ((targ.flags & FL_MONSTER) &&
targ.pain_target != "" &&
targ.health <= targ.pain_threshold)
{
sub_runvoidas (targ, sub_pain_use);
}
if (targ.health <= 0)
{
killed (targ, inflictor, attacker, dir);
return;
}
// react to the damage
stemp = self;
self = targ;
if ((self.flags & FL_MONSTER) && attacker != world)
{
// get mad unless of the same class (except soldiers)
if (self != attacker && attacker != self.enemy)
{
local float mode = 0;
// take highest mode so infighting
// happens consistently
if (self.infight_mode == -1 ||
self.infight_mode > mode)
{
mode = self.infight_mode;
}
if (mode != -1 && attacker.infight_mode > mode)
{
mode = attacker.infight_mode;
}
// soldiers of the same style will infight
// -- dumptruck_ds - thanks for c0burn and
// Shamblernaut for your help!
if (mode == -1)
{
if (attacker.classtype == CT_PLAYER)
{
if (self.enemy.classtype ==
CT_PLAYER)
self.oldenemy =
self.enemy;
self.enemy = attacker;
ai_foundtarget ();
}
}
else if ((self.classname != attacker.classname)
|| ((self.classtype == CT_MONSTER_GRUNT)
&& (self.style == attacker.style)) ||
// infight if different models
(mode > 0 &&
self.model != attacker.model) ||
// infight if different skin
(mode > 1 &&
self.skin != attacker.skin) ||
// always infight
(mode > 2))
{
if (self.enemy.classtype == CT_PLAYER)
self.oldenemy = self.enemy;
self.enemy = attacker;
ai_foundtarget ();
}
}
}
if (self.th_pain)
{
self.th_pain (attacker, take);
// nightmare mode monsters don't go into
// pain frames often
if (skill == 3)
self.pain_finished = time + 5;
}
self = stemp;
};
#endif
//==============================================================
// Subs
//==============================================================
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void() sub_null =
{
// no-op
};
//--------------------------------------------------------------
void(entity attacker, float damage) sub_nullpain =
{
// no-op
};
//--------------------------------------------------------------
void(vector dir) sub_nulldestroy =
{
// no-op
};
//--------------------------------------------------------------
void() sub_remove =
{
base_entity_remove (self);
};
//--------------------------------------------------------------
void() sub_remove_fade =
{
if (self.alpha <= 0)
{
base_entity_remove (self);
}
else
{
self.alpha -= 0.05;
self.think = sub_remove_fade;
self.nextthink = time + 0.1;
}
};
//--------------------------------------------------------------
// SUB_CallAsSelf
//--------------------------------------------------------------
void(entity doas, void() f) sub_runvoidas =
{
if (doas == world)
return;
local entity stemp = self;
local entity otemp = other;
other = self;
self = doas;
f ();
self = stemp;
other = otemp;
};
//--------------------------------------------------------------
// SUB_CallAsSelfFloat
//--------------------------------------------------------------
float(entity doas, float() f) sub_runfloatas =
{
if (doas == world)
return 0;
local entity stemp = self;
local float fl;
self = doas;
fl = f ();
self = stemp;
return fl;
};
//--------------------------------------------------------------
// was CheckValidTouch(); needed for both spawnable map entities
// and temporary entities -- CEV
//--------------------------------------------------------------
float(entity toucher) sub_checkvalidtouch =
{
if (toucher.classtype != CT_PLAYER)
return FALSE;
if (toucher.health <= 0)
return FALSE;
// from Copper -- dumptruck_ds
if (toucher.movetype == MOVETYPE_NOCLIP)
return FALSE;
if (self.estate != STATE_ACTIVE)
return FALSE;
return TRUE;
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
void() sub_usetargets =
{
if (self.estate != STATE_ACTIVE)
return;
if (self.delay)
{
// create a temp object to fire at a later time
spawn_temp_delayed_targets ();
return;
}
local entity t;
local string s = "";
// print the message
if (self.message != "" && !(self.flags & FL_NOCENTERPRINT))
{
if (self.spawnflags & SPAWNFLAG_CENTERPRINTALL)
{
t = findfloat (world, classtype, CT_PLAYER);
while (t)
{
centerprint (t, self.message);
if (!self.noise)
sound (t, CHAN_VOICE,
"misc/talk.wav",
VOL_HIGH, ATTN_NORM);
t = findfloat (t, classtype, CT_PLAYER);
}
}
else if (activator.classtype == CT_PLAYER)
{
centerprint (activator, self.message);
if (!self.noise)
sound (activator, CHAN_VOICE,
"misc/talk.wav",
VOL_HIGH, ATTN_NORM);
}
}
// killtargets
for (float g = 0; g < 2; g++)
{
if (g == 1)
s = self.killtarget2;
else if (g == 0)
s = self.killtarget;
if (s == __NULL__ || s == "")
continue;
for (float h = 0; h < 4; h++)
{
if (h == 3)
sub_killtarget (s, targetname4);
else if (h == 2)
sub_killtarget (s, targetname3);
else if (h == 1)
sub_killtarget (s, targetname2);
else
sub_killtarget (s, targetname);
}
s = "";
}
// regular targets
for (float i = 0; i < 4; i++)
{
if (i == 3)
s = self.target4;
else if (i == 2)
s = self.target3;
else if (i == 1)
s = self.target2;
else
s = self.target;
if (s == __NULL__ || s == "")
continue;
for (float j = 0; j < 4; j++)
{
if (j == 3)
sub_usetarget (s, targetname4);
else if (j == 2)
sub_usetarget (s, targetname3);
else if (j == 1)
sub_usetarget (s, targetname2);
else if (j == 0)
sub_usetarget (s, targetname);
}
s = "";
}
};
//--------------------------------------------------------------
void(string matchstring, .string matchfield) sub_killtarget =
{
local entity t = find (world, matchfield, matchstring);
while (t != world)
{
if (t.switchshadstyle)
lightstyle (t.switchshadstyle, "m");
if (t)
base_entity_remove (t);
t = find (t, matchfield, matchstring);
}
};
//--------------------------------------------------------------
void(string matchstring, .string matchfield) sub_usetarget =
{
if (matchstring == __NULL__ || matchstring == "")
return;
local entity stemp, otemp;
local entity atemp = activator;
local entity t = find (world, matchfield, matchstring);
while (t != world)
{
stemp = self;
otemp = other;
self = t;
other = stemp;
if (self.use != sub_null)
{
if (self.use)
{
self.use ();
}
}
self = stemp;
other = otemp;
activator = atemp;
t = find (t, matchfield, matchstring);
}
};
#endif
// };
#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// base_tempentity -- QC generated temporary entities
//----------------------------------------------------------------------
// class base_tempentity: base_entity
// {
//--------------------------------------------------------------
void(entity e) base_tempentity_init =
{
e.classgroup |= CG_TEMPENTITY;
};
//--------------------------------------------------------------
strip void() base_tempentity =
{
base_tempentity_init (self);
};
// };
#endif
#ifdef SSQC
//----------------------------------------------------------------------
// temp_delayed_targets -- to facilitate delayed SUB_UseTargets
//----------------------------------------------------------------------
// class temp_delayed_targets: base_tempentity
// {
//--------------------------------------------------------------
void() temp_delayed_targets_think =
{
activator = self.enemy;
sub_usetargets ();
remove (self);
};
//--------------------------------------------------------------
// 'self' in this context is the caller, not temp_delayed_targets
//--------------------------------------------------------------
entity() spawn_temp_delayed_targets =
{
// create a temp object to fire at a later time
local entity e = spawn ();
temp_delayed_targets_init (e);
e.enemy = activator;
e.message = self.message;
e.killtarget = self.killtarget;
e.killtarget2 = self.killtarget2;
e.target = self.target;
e.target2 = self.target2;
e.target3 = self.target3;
e.target4 = self.target4;
e.nextthink = time + self.delay;
return e;
};
//--------------------------------------------------------------
void(entity e) temp_delayed_targets_init =
{
base_tempentity_init (e);
e.classname = "DelayedUse";
e.classtype = CT_TEMP_DELAYEDUSE;
e.think = temp_delayed_targets_think;
};
//--------------------------------------------------------------
strip void() temp_delayed_targets =
{
temp_delayed_targets_init (self);
};
// };
#endif
//----------------------------------------------------------------------
// base_mapentity -- spawnable mapper-placeable entities
//----------------------------------------------------------------------
// class base_mapentity: base_entity
// {
//==============================================================
// Subs
//==============================================================
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) sub_setmovedir =
{
// QuakeEd only writes a single float for angles (bad idea),
// so up and down are just constant angles.
if (e.angles == '0 -1 0')
{
e.movedir = '0 0 1';
}
else if (e.angles == '0 -2 0')
{
e.movedir = '0 0 -1';
}
else
{
makevectors (e.angles);
e.movedir = v_forward;
}
e.angles = '0 0 0';
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
void() sub_useandforgettargets =
{
sub_usetargets ();
self.delay = 0;
self.killtarget = "";
self.killtarget2 = "";
self.message = "";
self.target = "";
self.target2 = "";
self.target3 = "";
self.target4 = "";
};
#endif
//==============================================================
// Initialization
//==============================================================
#ifdef SSQC
//--------------------------------------------------------------
// base_mapentity_init_spawndata
//
// loop over __fullspawndata running func for each key/value pair.
//
// __fullspawndata contains an entity's fields as set in the map
// file in a format suitable for reading with tokenize () -- CEV
//
// if running on the client you need a different offset in the
// for loop (i = 1 on server, i = 0 on client) -- CEV
//--------------------------------------------------------------
void(void(string key, string value) init_field_fn)
base_mapentity_init_spawndata =
{
if (init_field_fn != __NULL__) {
if (__fullspawndata != __NULL__ && __fullspawndata != "")
{
for (float i = 1; i < (tokenize(__fullspawndata) - 1);
i += 2)
{
init_field_fn (argv(i), argv(i + 1));
}
__fullspawndata = "";
} }
};
#endif
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) base_mapentity_init =
{
e.classgroup |= CG_MAPENTITY;
// TODO CEV placeholder
e.dimension_hit = DIMENSION_FLAG1;
e.dimension_solid = DIMENSION_FLAG1;
};
//--------------------------------------------------------------
strip void() base_mapentity =
{
base_mapentity_init (self);
};
#endif
// };
#ifdef SSQC
/*QUAKED noclass (0 0 0) (-8 -8 -8) (8 8 8)
prints a warning message when spawned
*/
//----------------------------------------------------------------------
void() noclass =
{
// new spawnflags for all entities -- iw
if (SUB_Inhibit())
return;
dprint (sprintf("noclass: spawned at %v\n", self.origin));
remove (self);
};
#endif
Return to the top of this page or return to the overview of this repo.
Log base_entities.qc
Return to the top of this page or return to the overview of this repo.