djcev.com

//==============================================================================
// Global Program Constants
//==============================================================================

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

#if defined(CSQC) || defined(SSQC)
// inspired by Copper
const string version = "\n\"Dog\" mode for FTE\nversion 0.1b";

const float FALSE = 0;
const float TRUE = 1;
const float NEGATIVE = -1;
const float M_PI = 3.14159265358979323846; // matches value in gcc v2 math.h
const float M_DEG2RAD = 0.01745329251994329576;
const float M_RAD2DEG = 57.29577951308232087679;

const vector VEC_ORIGIN = '0 0 0';      // origin & null vector value
const vector VEC_HULL_MIN = '-16 -16 -24';
const vector VEC_HULL_MAX = '16 16 32'; // Quake standard HULL1
const vector VEC_HULL_SIZE = '32 32 56';
const vector VEC_HULL2_MIN = '-32 -32 -24';
const vector VEC_HULL2_MAX = '32 32 64';// Quake standard HULL2
const vector VEC_HULL2_SIZE = '64 64 88';
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// input button mapping -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        INPUT_BUTTON0,                  // attack 1
        // INPUT_BUTTON1,               // not supported by the network protocol
        INPUT_BUTTON2,                  // jump
        INPUT_BUTTON3,                  //
        INPUT_BUTTON4,                  //
        INPUT_BUTTON5,                  //
        INPUT_BUTTON6,                  // grab
        INPUT_BUTTON7,                  // walk
        INPUT_BUTTON8                   // crouch
} input_button_flags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity .flags
//----------------------------------------------------------------------
typedef enumflags
{
        FL_FLY = 1,                     // standard id1 .flags
        FL_SWIM = 2,
        FL_CLIENT = 8,                  // set for all client edicts
        FL_INWATER = 16,                // for enter/leave water splash
        FL_MONSTER = 32,
        FL_GODMODE = 64,                // player cheat
        FL_NOTARGET = 128,              // player cheat
        FL_ITEM = 256,                  // extra wide size for bonus items
        FL_ONGROUND = 512,              // standing on something
        FL_PARTIALGROUND = 1024,        // not all corners are valid
        FL_WATERJUMP = 2048,            // player jumping out of water
        FL_JUMPRELEASED = 4096,         // for jump debouncing
        FL_NOSELECT = 8192,             // ignored by entity selector
        FL_FINDABLE_NONSOLID = 16384,   // entity discoverable w/findradius
        FL_UNUSED1 = 32768,             // unused flag -- CEV
        FL_LAGGEDMOVE = 65536,          // FTE SSQC: enables anti-lag
        FL_NOCENTERPRINT,               // don't centerprint when targets used
        FL_MUZZLEFLASH,                 // EF_MUZZLEFLASH replacement -- CEV
        FL_DIMLIGHT,                    // EF_DIMLIGHT replacement -- CEV
        FL_UNUSED2,                     // unused flags -- CEV
        FL_UNUSED3,
        FL_UNUSED4,
        FL_THROW_HELD                   // holding grab (23rd flag) -- CEV
} entity_flags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity .modelflags
//----------------------------------------------------------------------
typedef enumflags
{
        MF_ROCKET = 1,
        MF_GRENADE = 2,
        MF_GIB = 4,                     // Regular blood trail
        MF_ROTATE = 8,
        MF_TRACER = 16,                 // AKA: green scrag trail
        MF_ZOMGIB = 32,                 // Dark blood trail
        MF_TRACER2 = 64,                // AKA: hellknight projectile trail
        MF_TRACER3 = 128                // AKA: purple vore trail
} entity_modelflags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity movetypes
//----------------------------------------------------------------------
typedef enum
{
        MOVETYPE_NONE,                  // NONE never moves
        // MOVETYPE_ANGLENOCLIP = 1,
        // MOVETYPE_ANGLECLIP = 2,
        MOVETYPE_WALK = 3,              // players only
        MOVETYPE_STEP,                  // discrete, not real time unless fall
        MOVETYPE_FLY,
        MOVETYPE_TOSS,                  // gravity
        MOVETYPE_PUSH,                  // no clip to world, push and crush
        MOVETYPE_NOCLIP,
        MOVETYPE_FLYMISSILE,            // fly with extra size against monsters
        MOVETYPE_BOUNCE,                // standard bounce
        MOVETYPE_BOUNCEMISSILE          // bounce with extra size
} entity_movetypes;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity .solid types
//----------------------------------------------------------------------
typedef enum
{
        SOLID_NOT = 0,                  // no interaction (nonsolid)
        SOLID_TRIGGER = 1,              // touch on edge, but not blocking
        SOLID_BBOX = 2,                 // touch on edge, block
        SOLID_SLIDEBOX = 3,             // touch on edge, but not an onground
        SOLID_BSP = 4,                  // bsp clip, touch on edge, block
        SOLID_CORPSE = 5                // Nonsolid to SLIDEBOX or other CORPSE
} entity_solidtypes;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity .items flags
//----------------------------------------------------------------------
typedef enumflags
{
        IT_RUNE1,                       // .items flag values
        IT_RUNE2,                       // note that weapons are not included
        IT_RUNE3,                       // RUNE1-RUNE4 are id1 standard sigils
        IT_RUNE4,
        IT_RUNE5,                       // RUNE5-RUNE6 are mg1 additional sigils
        IT_RUNE6,
        // IT_UNUSED = 64,              // two unused flags
        // IT_UNUSED = 128,
        // IT_SHELLS = 256,             // id1 standard ammo flags (unused)
        // IT_NAILS = 512,
        // IT_ROCKETS = 1024,
        // IT_CELLS = 2048,
        // IT_UNUSED = 4096,            // another unused flag
        IT_ARMOR1 = 8192,               // id1 armors
        IT_ARMOR2 = 16384,
        IT_ARMOR3 = 32768,
        IT_SUPERHEALTH = 65536,         // megahealth
        IT_KEY1 = 131072,               // id1 keys
        IT_KEY2 = 262144,
        IT_INVISIBILITY = 524288,       // id1 ring
        IT_INVULNERABILITY = 1048576,   // id1 pent
        IT_SUIT = 2097152,              // id1 environment suit
        IT_QUAD = 4194304               // id1 quad damage; 22nd flag
} entity_item_flags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity .effects flags
//----------------------------------------------------------------------
typedef enumflags
{
        EF_BRIGHTFIELD = 1,
        EF_MUZZLEFLASH = 2,
        EF_BRIGHTLIGHT = 4,
        EF_DIMLIGHT = 8
} entity_effects_flags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// entity_point_contenttypes -- values returned by pointcontents ()
//----------------------------------------------------------------------
typedef enum
{
        CONTENT_EMPTY = -1,             // in the open
        CONTENT_SOLID = -2,             // in a solid
        CONTENT_WATER = -3,             // point in water
        CONTENT_SLIME = -4,             // in slime
        CONTENT_LAVA = -5,              // lava
        CONTENT_SKY = -6                // in sky - oh no!
} entity_pointcontent_types;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// entity .deadflag values
//----------------------------------------------------------------------
typedef enum
{
        DEAD_NO = 0,
        DEAD_DYING = 1,
        DEAD_DEAD = 2,
        DEAD_RESPAWNABLE = 3
} entity_deadflag_types;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// entity .takedamage values
//----------------------------------------------------------------------
typedef enum
{
        DAMAGE_NO = 0,
        DAMAGE_YES = 1,
        DAMAGE_AIM = 2
} entity_takedamage_types;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// surface types (used for footstep sounds); see world_surface_type -- CEV
//----------------------------------------------------------------------
typedef enum
{
        SURFACE_UNKNOWN,
        SURFACE_DIRT,
        SURFACE_GRASS,
        SURFACE_METAL,
        SURFACE_STONE,                  // the default type (in most cases)
        SURFACE_WOOD,
        SURFACE_WATER,
        SURFACE_WADING
} world_surface_types;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// q3surfaceflags - valid for trace_surfaceflagsf -- CEV
// the following definitions are copied from dpextensions.qc -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        Q3SURFACEFLAG_NODAMAGE = 1,
        Q3SURFACEFLAG_SLICK = 2,        // low friction surface
        Q3SURFACEFLAG_SKY = 4,          // sky surface (also NOIMPACT & NOMARKS)
        Q3SURFACEFLAG_LADDER = 8,       // climbable surface
        Q3SURFACEFLAG_NOIMPACT = 16,    // projectiles should remove themselves
        Q3SURFACEFLAG_NOMARKS = 32,     // projectiles should not leave marks
        Q3SURFACEFLAG_FLESH = 64,       // projectiles should do a fleshy effect
        Q3SURFACEFLAG_NODRAW = 128,     // compiler hint (not important to qc)
        // Q3SURFACEFLAG_HINT = 256,    // compiler hint (not important to qc)
        // Q3SURFACEFLAG_SKIP = 512,    // compiler hint (not important to qc)
        // Q3SURFACEFLAG_NOLIGHTMAP = 1024, // compiler hint (not important)
        // Q3SURFACEFLAG_POINTLIGHT = 2048, // compiler hint (not important)
        Q3SURFACEFLAG_METALSTEPS = 4096,// surface should make metal step sounds
        Q3SURFACEFLAG_NOSTEPS = 8192,   // surface should not make step sounds
        Q3SURFACEFLAG_NONSOLID = 16384  // compiler hint (not important to qc)
} world_q3surfaceflags;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// sound channels
//----------------------------------------------------------------------
typedef enum
{
        CHAN_AUTO = 0,                  // 0 never overrides
        CHAN_WEAPON = 1,                // dedicated weapon sounds
        CHAN_VOICE,                     // player/monster voice
        CHAN_ITEM,                      // misc item sounds
        CHAN_ITEM_AMMO,                 // ammo sounds
        CHAN_ITEM_ARMOR,                // armor sounds
        CHAN_ITEM_HEALTH,               // health sounds
        CHAN_ITEM_POWERUP,              // powerup sounds
        CHAN_ITEM_WEAPON,               // weapon sounds
        CHAN_ITEM_WEAPON_ROCKETS,       // rocket launcher sounds
        CHAN_BODY,                      //
        CHAN_FEET,                      // dedicated channel for steps -- CEV
        CHAN_SLIDE                      // dedicated channel for sliding -- CEV
} sound_channels;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// sound attenuation values
//----------------------------------------------------------------------
typedef enum
{
        ATTN_NONE = 0,                  // sound attenuation; no attenuation
        ATTN_NORM = 1,                  // standard attenuation
        ATTN_IDLE = 2,                  // extra attenuation
        ATTN_FEET = 2,
        ATTN_STATIC = 3                 // even more attn. (good for torches)
} sound_attenuation_types;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// sound volume presets -- CEV
//----------------------------------------------------------------------
const float VOL_MAX = 1.0;              // sound volume: maximum
const float VOL_HIGH = 0.9;             // sound volume: high
const float VOL_MHI = 0.7;              // sound volume: medium-high
const float VOL_MID = 0.5;              // sound volume: middle
const float VOL_LOW = 0.25;             // low volume; ambient sounds
const float VOL_MIN = 0.1;              // minimal volume
const float VOL_SILENT = 0.0;           // silent
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// soundflags (some of these are only valid on client or server) -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SOUNDFLAG_RELIABLE = 1,         // SSQC: sent reliably, no PHS
        SOUNDFLAG_FORCELOOP = 2,        // CSQC & SSQC: sound will restart
        // The different audio channels are played at the same volume
        // regardless of which way the player is facing, without needing
        // to use 0 attenuation.
        SOUNDFLAG_NOSPACIALISE = 4,     // CSQC
        SOUNDFLAG_ABSVOLUME = 16,       // CSQC: vol isn't scaled by vol cvar
        SOUNDFLAG_NOREVERB = 32,        // CSQC & SSQC: disable reverb
        SOUNDFLAG_FOLLOW = 64,          // CSQC & SSQC: update to follow emitter
        SOUNDFLAG_UNICAST = 256,        // SSQC: heard only by msg_entity ent
        SOUNDFLAG_SENDVELOCITY = 512    // SSQC: vel will be sent (for doppler)
} sound_flags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// traceline / tracebox flags
//----------------------------------------------------------------------
typedef enum
{
        MOVE_NORMAL = 0,                // traceline / tracebox flags; 
        MOVE_NOMONSTERS = 1,            // ignore all non-solid_bsp entities
        MOVE_MISSILE = 2,               // bbox of +/- 15 against FL_MONSTER
        MOVE_WORLDONLY = 3,             // 
        MOVE_HITMODEL = 4,              // impact mesh instead of bbox
        MOVE_TRIGGERS = 16,             // impact only triggers
        MOVE_EVERYTHING = 32,           // solids & triggers & non-solid ents
        MOVE_LAGGED = 64                // antilag based on player's latency
} trace_moveflags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// rtlight flags
//----------------------------------------------------------------------
typedef enumflags
{
        PFLAGS_NOSHADOW = 1,            // rtlights will not cast shadows
        PFLAGS_CORONA = 2               // enable coronas on associated rtlights
} rtlight_flags;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// common protocol bytes
//----------------------------------------------------------------------
typedef enum
{
        SVC_UPDATESTAT = 3,             // required by Hipnotic code
        SVC_SETVIEWPORT = 5,            // Camera Hip. Drake devkit dumptruck_ds
        SVC_SETVIEWANGLES = 10,         // Camera Hip. Drake devkit dumptruck_ds
        SVC_TEMPENTITY = 23,
        SVC_KILLEDMONSTER = 27,
        SVC_FOUNDSECRET = 28,
        SVC_INTERMISSION = 30,
        SVC_FINALE = 31,
        SVC_CDTRACK = 32,
        SVC_SELLSCREEN = 33,
        SVC_CUTSCENE = 34,              // Hipnotic Drake devkit -- dumptruck_ds
        SVC_CGAMEPACKET = 83            // FTE CSQC_Parse_Event -- CEV
} game_protocolbytes;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// temporary entity protocol bytes
//----------------------------------------------------------------------
typedef enum
{
        TE_SPIKE = 0,
        TE_SUPERSPIKE = 1,
        TE_GUNSHOT = 2,
        TE_EXPLOSION = 3,
        TE_TAREXPLOSION = 4,
        TE_LIGHTNING1 = 5,
        TE_LIGHTNING2 = 6,
        TE_WIZSPIKE = 7,
        TE_KNIGHTSPIKE = 8,
        TE_LIGHTNING3 = 9,
        TE_LAVASPLASH = 10,
        TE_TELEPORT = 11,
        TE_EXPLOSION2 = 12              // from doe -- dumptruck_ds
} game_tempentity_protocolbytes;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// stat types; valid for getstatf(...), some server messages
//----------------------------------------------------------------------
typedef enum
{
        STAT_HEALTH = 0,                // player's health
        STAT_WEAPONMODELI = 2,          // modelindex of current viewmodel
        STAT_AMMO = 3,                  // player.currentammo
        STAT_ARMOR = 4,
        STAT_WEAPONFRAME = 5,
        STAT_SHELLS = 6,
        STAT_NAILS = 7,
        STAT_ROCKETS = 8,
        STAT_CELLS = 9,
        STAT_ACTIVEWEAPON = 10,         // player.weapon
        STAT_TOTALSECRETS = 11,
        STAT_TOTALMONSTERS = 12,        // required by Hipnotic code
        STAT_FOUNDSECRETS = 13,
        STAT_KILLEDMONSTERS = 14,
        STAT_ITEMS = 15,                // self.items | (self.items2<<23)
        STAT_VIEWHEIGHT = 16,           // player.view_ofs_z
        STAT_VIEW2 = 20,                // num of ents in server's .view2 field
        STAT_VIEWZOOM = 21,             // scales fov and sens. See DP_VIEWZOOM
        STAT_IDEALPITCH = 25,
        STAT_PUNCHANGLE_X = 26,
        STAT_PUNCHANGLE_Y = 27,
        STAT_PUNCHANGLE_Z = 28
} game_stats;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// server message destinations
//----------------------------------------------------------------------
typedef enum
{
        MSG_BROADCAST = 0,              // unreliable to all
        MSG_ONE = 1,                    // reliable to one (msg_entity)
        MSG_ALL = 2,                    // reliable to all
        MSG_INIT = 3,                   // write to the init string
        // The byte(s) will be written into the multicast buffer for more
        // selective sending. Messages sent this way will never be split
        // across packets, and using this for csqc-only messages will not
        // break protocol translation.
        MSG_MULTICAST = 4,
        MSG_ENTITY = 5                  // used only in 'SendEntity' functions
} game_server_messagedest;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// server message multicast sets. valid for argument 2 of multicast -- CEV
//----------------------------------------------------------------------
typedef enum
{
        MULTICAST_ALL = 0,              // unreliable to all players
        MULTICAST_PHS = 1,              // unreliable to players that can hear
        MULTICAST_PVS = 2,              // unreliable to players that can see
        MULTICAST_ALL_R = 3,            // reliable to all players
        MULTICAST_PHS_R = 4,            // reliable to players that can hear
        MULTICAST_PVS_R = 5,            // reliable to players that can see
        MULTICAST_ONE = 6,              // unreliable to msg_entity global
        MULTICAST_ONE_R = 7             // reliable to msg_entity global
} game_server_multicastsets;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// valid for MSG_MULTICAST SVC_CGAMEPACKET, see CSQC_Parse_Event -- CEV
//----------------------------------------------------------------------
typedef enum
{
        EVENT_INTERMISSION,             // intermission changed on the server
        EVENT_CSHIFT_FADE,              // csf_fade
        EVENT_CSHIFT_SET,               // csf_set
        EVENT_LIGHTNING2                // TE_LIGHTNING2
} game_multicast_events;
#endif

#ifdef CSQC
//----------------------------------------------------------------------
// game client properties - valid for getproperty, setproperty -- CEV
//----------------------------------------------------------------------
typedef enum
{
        VF_MIN = 1,                     // top-left of the 3d viewport
        VF_SIZE = 4,                    // width+height of the 3d viewport
        VF_ORIGIN = 11,                 // origin of the view (not the player)
        VF_ORIGIN_X = 12,
        VF_ORIGIN_Y = 13,
        VF_ORIGIN_Z = 14,
        VF_ANGLES = 15,                 // angles the view will be drawn at
        VF_ANGLES_X = 16,
        VF_ANGLES_Y = 17,
        VF_ANGLES_Z = 18,
        VF_DRAWWORLD = 19,              // boolean; draw world?
        VF_DRAWENGINESBAR = 20,         // boolean; draw engine statusbar?
        VF_DRAWCROSSHAIR = 21,          // boolean; draw engine crosshair?
        VF_CL_VIEWANGLES = 33,
        VF_CL_VIEWANGLES_X = 34,
        VF_CL_VIEWANGLES_Y = 35,
        VF_CL_VIEWANGLES_Z = 36,
        // VF_VIEWENTITY -- Changes the RF_EXTERNALMODEL flag on entities to
        // match the new selection, and removes entities flaged with
        // RF_VIEWENTITY. Requires cunning use of .entnum and typically
        // requires calling addentities(MASK_VIEWMODEL) too.
        VF_VIEWENTITY = 206
} game_client_properties;
#endif

#ifdef CSQC
//----------------------------------------------------------------------
// drawmask flags; these constants are only used in CSQC_UpdateView -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        DRAWMASK_NONE = 0,
        DRAWMASK_ENGINE = 1,
        DRAWMASK_VIEWMODEL = 2,
        DRAWMASK_NORMAL = 4
} game_client_drawflags;
#endif

#ifdef CSQC
//----------------------------------------------------------------------
// return values from the predraw function -- CEV
//----------------------------------------------------------------------
typedef enum
{
        // Returning this will cause the engine to automatically invoke
        // addentity(self) for you.
        PREDRAW_AUTOADD = 0,
        // Returning this will simply move on to the next entity without
        // the autoadd behaviour, so can be used for particle/invisible/special
        // entites, or entities that were explicitly drawn with addentity.
        PREDRAW_NEXT = 1
} game_client_predrawflags;
#endif

#ifdef CSQC
//----------------------------------------------------------------------
// clientside entity renderflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        RF_VIEWMODEL = 1,               // the entity is a view model
        RF_EXTERNALMODEL = 2,           // visible in mirrors but not otherwise
        // Hacks the depth values such that the entity uses depth values as
        // if it were closer to the screen. This is useful when combined with
        // viewmodels to avoid weapons poking in to walls.
        RF_DEPTHHACK,
        RF_ADDITIVE,                    // additive blend instead of normal
        // The entity will be oriented according to the current
        // v_forward+v_right+v_up vector values instead of the entity's
        // .angles field.
        RF_USEAXIS,
        RF_NOSHADOW                     // entity will not cast shadows
} game_client_renderflags;
#endif

#ifdef CSQC
//----------------------------------------------------------------------
// fieldnum arguments valid for getentity -- CEV
//----------------------------------------------------------------------
typedef enum
{
        GE_MAXENTS = -1,                // max num of valid entities
        GE_ACTIVE = 0,                  // is this entity known to the client?
        GE_ORIGIN = 1,                  // interpolated .origin
        GE_FORWARD = 2,                 // interpolated forward vector
        GE_RIGHT = 3,                   // entity's right vector
        GE_UP = 4,                      // entity's up vector
        GE_SCALE = 5,                   // .scale
        GE_ORIGINANDVECTORS = 6,        // interpolated .origin + v_forward etc
        GE_ALPHA = 7,                   // entity .alpha
        GE_COLORMOD = 8,                // colormod vector
        GE_PANTSCOLOR = 9,              // entity's lower color (from .colormap)
        GE_SHIRTCOLOR = 10,             // entity's upper color (from .colormap)
        GE_SKIN = 11,                   // entity's .skin index
        GE_MINS = 12,                   // entity's .min vector
        GE_MAXS = 13,                   // entity's .max vector
        GE_ABSMIN = 14,                 // entity's .absmin vector
        GE_ABSMAX = 15,                 // entity's .absmax vector
        GE_MODELINDEX = 200,            // guess entity's .modelindex float
        GE_MODELINDEX2 = 201,           // guess entity's .vw_index float
        GE_EFFECTS = 202,               // guess entity's .effects float
        GE_FRAME = 203,                 // guess entity's .frame float
        GE_ANGLES = 204,                // guess entity's .angles vector
        GE_FATNESS = 205,               // guess entity's .fatness float
        GE_DRAWFLAGS = 206,             // guess entity's .drawflags float
        GE_ABSLIGHT = 207,              // guess entity's .abslight float
        GE_GLOWMOD = 208,               // guess entity's .glowmod vector
        GE_GLOWSIZE = 209,              // guess entity's .glowside float
        GE_GLOWCOLOUR = 210,            // guess entity's .glowcolor float
        GE_RTSTYLE = 211,               // guess entity's .style float
        GE_RTPFLAGS = 212,              // guess entity's .pflags float
        GE_RTCOLOUR = 213,              // guess entity's .color vector
        GE_RTRADIUS = 214,              // guess entity's .light_lev float
        GE_TAGENTITY = 215,             // guess entity's .tag_entity float
        GE_TAGINDEX = 216,              // guess entity's .tag_index float
        GE_GRAVITYDIR = 217,            // guess entity's .gravitydir vector
        GE_TRAILEFFECTNUM = 218         // guess entity's .traileffectnum float
} game_client_entityfieldnums;
#endif

#ifdef CSQC
//----------------------------------------------------------------------
// arguments for serverkey, serverkeyfloat, etc. -- CEV
//----------------------------------------------------------------------
// The address of the server we connected to
const string SERVERKEY_IP = "ip";
// The hostname that was last passed to the connect command
const string SERVERKEY_SERVERNAME = "servername";
// The current connection state. Will be set to one of:
//      disconnected (menu-only mode),
//      active (gamestate received and loaded),
//      connecting (connecting, downloading, or precaching content)
const string SERVERKEY_CONSTATE = "constate";
// Set to the hostname of the server that we are attempting to
// connect or transfer to.
const string SERVERKEY_TRANSFERRING = "transferring";
// loadstage, loading image name, current step, max steps
// Stages are: 1=connecting, 2=serverside, 3=clientside
// Key will be empty if we are not loading.
const string SERVERKEY_LOADSTATE = "loadstate";
// 1 if the server claimed to be paused. 0 otherwise
const string SERVERKEY_PAUSESTATE = "pausestate";
// The progress of any current downloads. Empty string if no download is
//      active, otherwise a tokenizable string containing this info:
//      files-remaining, total-size, unknown-sizes-flag, file-localname,
//      file-remotename, file-percent, file-rate, file-received-bytes,
//      file-total-bytes
// If the current file info is omitted, then we are waiting for a
// download to start.
const string SERVERKEY_DLSTATE = "dlstate";
// The protocol we are connected to the server with.
const string SERVERKEY_PROTOCOL = "protocol";
// The number of player/spectator slots allocated on the server.
const string SERVERKEY_MAXPLAYERS = "maxplayers";
#endif