#define FTE_PEXT_SETVIEW /* NQ's svc_setview works correctly even in quakeworld */
#define DP_ENT_SCALE
#define FTE_PEXT_LIGHTSTYLECOL
#define DP_ENT_ALPHA
#define FTE_PEXT_VIEW2
#define FTE_PEXT_ACURATETIMINGS
#define FTE_PEXT_SOUNDDBL
#define FTE_PEXT_FATNESS
#define DP_HALFLIFE_MAP
#define FTE_PEXT_TE_BULLET
#define FTE_PEXT_HULLSIZE
#define FTE_PEXT_MODELDBL
#define FTE_PEXT_ENTITYDBL
#define FTE_PEXT_ENTITYDBL2
#define FTE_PEXT_FLOATCOORDS
#define FTE_PEXT_VWEAP
#define FTE_PEXT_Q2BSP
#define FTE_PEXT_Q3BSP
#define DP_ENT_COLORMOD
#define FTE_HEXEN2
#define FTE_PEXT_SPAWNSTATIC
#define FTE_PEXT_CUSTOMTENTS
#define FTE_PEXT_256PACKETENTITIES
#define TEI_SHOWLMP2
#define DP_GFX_QUAKE3MODELTAGS
#define FTE_PK3DOWNLOADS
#define PEXT_CHUNKEDDOWNLOADS
#define EXT_CSQC_SHARED
#define PEXT_DPFLAGS
#define EXT_CSQC
#define BX_COLOREDTEXT
#define DP_CON_SET /* The 'set' console command exists, and can be used to create/set cvars. */
#define DP_CON_SETA /* The 'seta' console command exists, like the 'set' command, but also marks the cvar for archiving, allowing it to be written into the user's config. Use this command in your default.cfg file. */
#define DP_ENT_TRAILEFFECTNUM /* self.traileffectnum=particleeffectnum("myeffectname"); can be used to attach a particle trail to the given server entity. This is equivelent to calling trailparticles each frame. */
#define DP_MONSTERWALK /* MOVETYPE_WALK is valid on non-player entities. Note that only players receive acceleration etc in line with none/bounce/fly/noclip movetypes on the player, thus you will have to provide your own accelerations (incluing gravity) yourself. */
#define DP_QC_MULTIPLETEMPSTRINGS /* Superseded by DP_QC_UNLIMITEDTEMPSTRINGS. Functions that return a temporary string will not overwrite/destroy previous temporary strings until at least 16 strings are returned (or control returns to the engine). */
#define DP_QC_RANDOMVEC
#define DP_QC_RENDER_SCENE /* clearscene+addentity+setviewprop+renderscene+setmodel are available to menuqc. WARNING: DP advertises this extension without actually supporting it, FTE does actually support it. */
#define DP_QC_SPRINTF /* Provides the sprintf builtin, which allows for rich formatting along the lines of C's function with the same name. Not to be confused with QC's sprint builtin. */
#define DP_QC_UNLIMITEDTEMPSTRINGS /* Supersedes DP_QC_MULTIPLETEMPSTRINGS, superseded by FTE_QC_PERSISTENTTEMPSTRINGS. Specifies that all temp strings will be valid at least until the QCVM returns. */
#define DP_SV_CLIENTCOLORS /* Provided only for compatibility with DP. */
#define DP_SV_CLIENTNAME /* Provided only for compatibility with DP. */
#define DP_SV_DRAWONLYTOCLIENT
#define DP_SV_DROPCLIENT /* Equivelent to quakeworld's stuffcmd(self,"disconnect\n"); hack */
#define DP_SV_EFFECT
#define DP_SV_EXTERIORMODELFORCLIENT
#define DP_SV_NODRAWTOCLIENT
#define DP_SV_PLAYERPHYSICS /* Allows reworking parts of NQ player physics. USE AT OWN RISK - this necessitates NQ physics and is thus guarenteed to break prediction. */
#define DP_SV_POINTSOUND
#define DP_SV_PRECACHEANYTIME /* Specifies that the various precache builtins can be called at any time. WARNING: precaches are sent reliably while sound events, modelindexes, and particle events are not. This can mean sounds and particles might not work the first time around, or models may take a while to appear (after the reliables are received and the model is loaded from disk). Always attempt to precache a little in advance in order to reduce these issues (preferably at the start of the map...) */
#define FTE_CALLTIMEOFDAY /* Replication of mvdsv functionality (call calltimeofday to cause 'timeofday' to be called, with arguments that can be saved off to a global). Generally strftime is simpler to use. */
#define FTE_CSQC_ALTCONSOLES /* The engine tracks multiple consoles. These may or may not be directly visible to the user. */
#define FTE_CSQC_BASEFRAME /* Specifies that .basebone, .baseframe2, .baselerpfrac, baseframe1time, etc exist in csqc. These fields affect all bones in the entity's model with a lower index than the .basebone field, allowing you to give separate control to the legs of a skeletal model, without affecting the torso animations. */
#define FTE_CSQC_SERVERBROWSER /* Provides builtins to query the engine's serverbrowser servers list from ssqc. Note that these builtins are always available in menuqc. */
#define FTE_CSQC_SKELETONOBJECTS /* Provides container objects for skeletal bone data, which can be modified on a per bone basis if needed. This allows you to dynamically generate animations (or just blend them with greater customisation) instead of being limited to a single animation or two. */
#define FTE_CSQC_RAWIMAGES /* Provides raw rgba image access to csqc. With this, the csprogs can read textures into qc-accessible memory, modify it, and then upload it to the renderer. */
#define FTE_CSQC_REVERB /* Specifies that the mod can create custom reverb effects. Whether they will actually be used or not depends upon the sound driver. */
#define FTE_CSQC_WINDOWCAPTION /* Provides csqc with the ability to change the window caption as displayed when running windowed or in the task bar when switched out. */
#define FTE_ENT_SKIN_CONTENTS /* self.skin = CONTENTS_WATER; makes a brush entity into water. use -16 for a ladder. */
#define FTE_ENT_UNIQUESPAWNID
#define FTE_EXTENDEDTEXTCODES
#define FTE_FORCESHADER /* Allows csqc to override shaders on models with an explicitly named replacement. Also allows you to define shaders with a fallback if it does not exist on disk. */
#define FTE_FORCEINFOKEY /* Provides an easy way to change a user's userinfo from the server. */
#define FTE_GFX_QUAKE3SHADERS /* specifies that the engine has full support for vanilla quake3 shaders */
#define FTE_GFX_REMAPSHADER /* With the raw power of stuffcmds, the r_remapshader console command is exposed! This mystical command can be used to remap any shader to another. Remapped shaders that specify $diffuse etc in some form will inherit the textures implied by the surface. */
#define FTE_MULTIPROGS /* Multiple progs.dat files can be loaded inside the same qcvm. Insert new ones with addprogs inside the 'init' function, and use externvalue+externset to rewrite globals (and hook functions) to link them together. Note that the result is generally not very clean unless you carefully design for it beforehand. */
#define FTE_MULTITHREADED /* Faux multithreading, allowing multiple contexts to run in sequence. */
#define FTE_MVD_PLAYERSTATS /* In csqc, getplayerstat can be used to query any player's stats when playing back MVDs. isdemo will return 2 in this case. */
#define FTE_PART_SCRIPT /* Specifies that the r_particledesc cvar can be used to select a list of particle effects to load from particles/*.cfg, the format of which is documented elsewhere. */
#define FTE_PART_NAMESPACES /* Specifies that the engine can use foo.bar to load effect foo from particle description bar. When used via ssqc, this should cause the client to download whatever effects as needed. */
#define FTE_PART_NAMESPACE_EFFECTINFO /* Specifies that effectinfo.bar can load effects from effectinfo.txt for DP compatibility. */
#define FTE_QC_BASEFRAME /* Specifies that .basebone and .baseframe exist in ssqc. These fields affect all bones in the entity's model with a lower index than the .basebone field, allowing you to give separate control to the legs of a skeletal model, without affecting the torso animations, from ssqc. */
#define FTE_QC_FILE_BINARY /* Extends FRIK_FILE with binary read+write, as well as allowing seeking. Requires pointers. */
#define FTE_QC_CHANGELEVEL_HUB /* Adds an extra argument to changelevel which is carried over to the next map in the 'spawnspot' global. Maps will be saved+reloaded until the extra argument is omitted again, purging all saved maps. Saved games will contain a copy of each preserved map. parm1-parm64 globals can be used, giving more space to transfer more player data. */
#define FTE_QC_CHECKCOMMAND /* Provides a way to test if a console command exists, and whether its a command/alias/cvar. Does not say anything about the expected meanings of any arguments or values. */
#define FTE_QC_CUSTOMSKINS /* The engine supports the use of q3 skins, as well as the use of such skin 'files' to specify rich top+bottom colours, qw skins, geomsets, or texture composition even on non-players.. */
#define FTE_QC_DIGEST_SHA1
#define FTE_QC_DIGEST_SHA224
#define FTE_QC_DIGEST_SHA384
#define FTE_QC_DIGEST_SHA512
#define FTE_QC_FS_SEARCH_SIZEMTIME
#define FTE_QC_HARDWARECURSORS /* setcursormode exists in both csqc+menuqc, and accepts additional arguments to specify a cursor image to use when this module has focus. If the image exceeds hardware limits (or hardware cursors are unsupported), it will be emulated using regular draws - this at least still avoids conflicting cursors as only one will ever be used, even if console+menu+csqc are all overlayed. */
#define FTE_QC_INFOKEY /* QuakeWorld's infokey builtin works, and reports at least name+topcolor+bottomcolor+ping(in ms)+ip(unmasked, but not always ipv4)+team(aka bottomcolor in nq). Does not require actual localinfo/serverinfo/userinfo, but they're _highly_ recommended to any engines with csqc */
#define FTE_QC_PERSISTENTTEMPSTRINGS /* Supersedes DP_QC_MULTIPLETEMPSTRINGS. Temp strings are garbage collected automatically, and do not expire while they're still in use. This makes strzone redundant. */
#define FTE_QC_RAGDOLL_WIP
#define FTE_QC_SENDPACKET /* Allows the use of out-of-band udp packets to/from other hosts. Includes the SV_ParseConnectionlessPacket event. */
#define FTE_QUAKE2_CLIENT /* This engine is able to act as a quake2 client */
#define FTE_QUAKE2_SERVER /* This engine is able to act as a quake2 server */
#define FTE_QUAKE3_CLIENT /* This engine is able to act as a quake3 client */
#define FTE_QUAKE3_SERVER /* This engine is able to act as a quake3 server */
#define FTE_SOLID_LADDER /* Allows a simple trigger to remove effects of gravity (solid 20). obsolete. will prolly be removed at some point as it is not networked properly. Use FTE_ENT_SKIN_CONTENTS */
#define FTE_SPLITSCREEN /* Client supports splitscreen, controlled via cl_splitscreen. Servers require allow_splitscreen 1 if splitscreen is to be used over the internet. Mods that use csqc will need to be aware for this to work properly. per-client networking may be problematic. */
#define FTE_SQL /* Provides sql* builtins which can be used for sql database access */
#define FTE_SQL_SQLITE /* SQL functionality is able to utilise sqlite databases */
#define FTE_STRINGS /* Extra builtins (and additional behaviour) to make string manipulation easier */
#define FTE_SV_POINTPARTICLES /* Specifies that particleeffectnum, pointparticles, and trailparticles exist in ssqc as well as csqc. particleeffectnum acts as a precache, allowing ssqc values to be networked up with csqc for use. Use in combination with FTE_PART_SCRIPT+FTE_PART_NAMESPACES to use custom effects. This extension is functionally identical to the DP version, but avoids any misplaced assumptions about the format of the client's particle descriptions. */
#define FTE_SV_REENTER
#define FTE_TE_STANDARDEFFECTBUILTINS /* Provides builtins to replace writebytes, with a QW compatible twist. */
#define FTE_TERRAIN_MAP /* This engine supports .hmp files, as well as terrain embedded within bsp files. */
#define FTE_RAW_MAP /* This engine supports directly loading .map files, as well as realtime editing of the various brushes. */
#define KRIMZON_SV_PARSECLIENTCOMMAND /* SSQC's SV_ParseClientCommand function is able to handle client 'cmd' commands. The tokenizing parts also work in csqc. */
#define NEH_CMD_PLAY2
#define NEH_RESTOREGAME
#define QSG_CVARSTRING
#define QW_ENGINE
#define QWE_MVD_RECORD /* You can use the easyrecord command to record MVD demos serverside. */
#define TEI_MD3_MODEL
#define TENEBRAE_GFX_DLIGHTS /* Allows ssqc to attach rtlights to entities with various special properties. */
#define ZQ_MOVETYPE_FLY /* MOVETYPE_FLY works on players. */
#define ZQ_MOVETYPE_NOCLIP /* MOVETYPE_NOCLIP works on players. */
#define ZQ_MOVETYPE_NONE /* MOVETYPE_NONE works on players. */
#define ZQ_VWEP
#define ZQ_QC_STRINGS /* The strings-only subset of FRIK_FILE is supported. */
entityother;/* Valid in touch functions, this is the entity that we touched. */
entityworld;/* The null entity. Hurrah. Readonly after map spawn time. */
floattime;/* The current game time. Stops when paused. */
#endif
#ifdef CSQC
floatcltime;/* A local timer that ticks relative to local time regardless of latency, packetloss, or pause. */
#endif
#if defined(CSQC) || defined(SSQC)
floatframetime;/* The time since the last physics/render/input frame. */
#endif
#ifdef CSQC
floatplayer_localentnum;/* This is entity number the player is seeing from/spectating, or the player themself, can change mid-map. */
floatplayer_localnum;/* The 0-based player index, valid for getplayerkeyvalue calls. */
floatmaxclients;/* Maximum number of player slots on the server. */
floatclientcommandframe;/* This is the input-frame sequence. frames < clientcommandframe have been sent to the server. frame==clientcommandframe is still being generated and can still change. */
floatservercommandframe;/* This is the input-frame that was last acknowledged by the server. Input frames greater than this should be applied to the player's entity. */
#endif
#if defined(QWSSQC)
entitynewmis;/* A named entity that should be run soon, to reduce the effects of latency. */
#endif
#ifdef SSQC
floatforce_retouch;/* If positive, causes all entities to check for triggers. */
floatparm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11,parm12,parm13,parm14,parm15,parm16;/* Player specific mod-defined values that are transferred from one map to the next. These are set by the qc inside calls to SetNewParms and SetChangeParms, and can then be read on a per-player basis after a call to the setspawnparms builtin. They are not otherwise valid. */
void()main;/* This function is never called, and is effectively dead code. */
void()StartFrame;/* Called at the start of each new physics frame. Player entities may think out of sequence so try not to depend upon explicit ordering too much. */
void()PlayerPreThink;/* With Prediction(QW compat/FTE default): Called before the player's input commands are processed.
void()ClientConnect;/* Called after the connecting client has finished loading and is ready to receive active entities. Note that this is NOT the first place that a client might be referred to. To determine if the client has csqc active (and kick anyone that doesn't), you can use if(infokeyf(self,INFOKEY_P_CSQCACTIVE)) {sprint(self, "CSQC is required for this server\n");dropclient(self);} */
void()PutClientInServer;/* Enginewise, this is only ever called immediately after ClientConnect and is thus a little redundant. Modwise, this is also called for respawning a player etc. */
void()ClientDisconnect;/* Called once a client disconnects or times out. Not guarenteed to be called on map changes. */
void()SetNewParms;/* Called without context when a new client initially connects (before ClientConnect is even called). This function is expected to only set the parm* globals so that they can be decoded properly later. You should not rely on 'self' being set. */
void()SetChangeParms;/* Called for each client on map changes. Should copy various entity fields to the parm* globals. */
.floatmodelindex;/* This is the model precache index for the model that was set on the entity, instead of having to look up the model according to the .model field. Use setmodel to change it. */
.vectorabsmin;/* Set by the engine when the entity is relinked (by setorigin, setsize, or setmodel). This is in world coordinates. */
.vectorabsmax;/* Set by the engine when the entity is relinked (by setorigin, setsize, or setmodel). This is in world coordinates. */
#endif
#ifdef SSQC
.floatltime;/* On MOVETYPE_PUSH entities, this is used as an alternative to the 'time' global, and .nextthink is synced to this instead of time. This allows time to effectively freeze if the entity is blocked, ensuring the think happens when the entity reaches the target point instead of randomly. */
#endif
#ifdef CSQC
.floatentnum;/* The entity number as its known on the server. */
.floatdrawmask;/* Acts as a filter in the addentities call. */
.float()predraw;/* Called by addentities after the filter and before the entity is actually drawn. Do your interpolation and animation in here. Should return one of the PREDRAW_* constants. */
#endif
#if defined(QWSSQC)
.floatlastruntime;/* This field used to be used to avoid running an entity multiple times in a single frame due to quakeworld's out-of-order thinks. It is no longer used by FTE due to precision issues, but may still be updated for compatibility reasons. */
#endif
#if defined(CSQC) || defined(SSQC)
.floatmovetype;/* Describes how the entity moves. One of the MOVETYPE_ constants. */
.floatsolid;/* Describes whether the entity is solid or not, and any special properties infered by that. Must be one of the SOLID_ constants */
.vectororigin;/* The current location of the entity in world space. Inline bsp entities (ie: ones placed by a mapper) will typically have a value of '0 0 0' in their neutral pose, as the geometry is offset from that. It is the reference point of the entity rather than the center of its geometry, for non-bsp models, this is often not a significant distinction. */
.vectoroldorigin;/* This is often used on players to reset the player back to where they were last frame if they somehow got stuck inside something due to fpu precision. Never change a player's oldorigin field to inside a solid, because that might cause them to become pemanently stuck. */
.vectorvelocity;/* The direction and speed that the entity is moving in world space. */
.vectorangles;/* The eular angles the entity is facing in, in pitch, yaw, roll order. Due to a legacy bug, mdl/iqm/etc formats use +x=UP, bsp/spr/etc formats use +x=DOWN. */
.vectoravelocity;/* The amount the entity's angles change by per second. Note that this is direct eular angles, and thus the angular change is non-linear and often just looks buggy if you're changing more than one angle at a time. */
.stringclassname;/* Identifies the class/type of the entity. Useful for debugging, also used for loading, but its value is not otherwise significant to the engine, this leaves the mod free to set it to whatever it wants and randomly test strings for values in whatever inefficient way it chooses fit. */
#endif
#ifdef CSQC
.floatrenderflags;
#endif
#if defined(CSQC) || defined(SSQC)
.stringmodel;/* The model name that was set via setmodel, in theory. Often, this is cleared to null to prevent the engine from being seen by clients while not changing modelindex. This behaviour allows inline models to remain solid yet be invisible. */
.floatframe;/* The current frame the entity is meant to be displayed in. In CSQC, note the lerpfrac and frame2 fields as well. if it specifies a framegroup, the framegroup will autoanimate in ssqc, but not in csqc. */
#endif
#ifdef CSQC
.floatframe1time;/* The absolute time into the animation/framegroup specified by .frame. */
.floatframe2;/* The alternative frame. Visible only when lerpfrac is set to 1. */
.floatframe2time;/* The absolute time into the animation/framegroup specified by .frame2. */
.floatlerpfrac;/* If 0, use frame1 only. If 1, use frame2 only. Mix them together for values between. */
#endif
#if defined(CSQC) || defined(SSQC)
.floatskin;/* The skin index to use. on a bsp entity, setting this to 1 will switch to the 'activated' texture instead. A negative value will be understood as a replacement contents value, so setting it to CONTENTS_WATER will make a movable pool of water. */
.floateffects;/* Lots of random flags that change random effects. See EF_* constants. */
.vectormins;/* The minimum extent of the model (ie: the bottom-left coordinate relative to the entity's origin). Change via setsize. May also be changed by setmodel. */
.vectormaxs;/* like mins, but in the other direction. */
.vectorsize;/* maxs-mins. Updated when the entity is relinked (by setorigin, setsize, setmodel) */
.void()touch;
#endif
#ifdef SSQC
.void()use;
#endif
#if defined(CSQC) || defined(SSQC)
.void()think;
.void()blocked;
.floatnextthink;/* The time at which the entity is next scheduled to fire its think event. For MOVETYPE_PUSH entities, this is relative to that entity's ltime field, for all other entities it is relative to the time gloal. */
.floatfixangle;/* Forces the clientside view angles to change to the value of .angles (has some lag). If set to 1/TRUE, the server will guess whether to send a delta or an explicit angle. If 2, will always send a delta (due to lag between transmission and acknowledgement, this cannot be spammed reliably). If 3, will always send an explicit angle. */
inttrace_networkentity;/* Repots which ssqc entnum was hit when a csqc traceline impacts an ssqc-based brush entity. */
vectorpmove_org;/* Reports the origin of the engineside player (after prediction). Does not work when the player is a csqc-owned entity. */
vectorpmove_vel;/* Reports the velocity of the engineside player (after prediction). Does not work when the player is a csqc-owned entity. */
floatpmove_onground;/* Reports the onground state of the engineside player (after prediction). Does not work when the player is a csqc-owned entity. */
.floatlastruntime;/* This field used to be used to avoid running an entity multiple times in a single frame due to quakeworld's out-of-order thinks. It is no longer used by FTE due to precision issues, but may still be updated for compatibility reasons. */
.floathull;/* Overrides the hull used by the entity for walkmove/movetogoal and not traceline/tracebox. */
.entitymovechain;/* This is a linked list of entities which will be moved whenever this entity moves, logically they are attached to this entity. */
.void()chainmoved;/* Called when the entity is moved as a result of being part of another entity's .movechain */
.void(floatold,floatnew)contentstransition;/* This function is called when the entity moves between water and air. If specified, default splash sounds will be disabled allowing you to provide your own. */
.floatdimension_solid;/* This is the bitmask of dimensions which the entity is solid within. This is not networked, instead csqc traces impacting ssqc entities assumes the ssqc entity to have a dimension_solid of 1. */
.floatdimension_hit;/* This is the bitmask of dimensions which the entity will be blocked by. If other.dimension_solid & self.dimension_hit, our traces will impact and not proceed. If its false, the traces will NOT impact, allowing self to pass straight through. */
.floatscale;/* Multiplier that resizes the entity. 1 is normal sized, 2 is double sized. scale 0 is remapped to 1. In SSQC, this is limited to 1/16th precision, with a maximum just shy of 16. */
.floatfatness;/* How many QuakeUnits to push the entity's verticies along their normals by. */
.floatalpha;/* The transparency of the entity. 1 means opaque, 0.0001 means virtually invisible. 0 is remapped to 1, for compatibility. */
.floatmodelflags;/* Used to override the flags set in the entity's model. Should be set according to the MF_ constants. Use effects|=EF_NOMODELFLAGS to ignore the model's flags completely. The traileffectnum field is more versatile. */
#endif
#ifdef SSQC
.floatframe1time;/* This controls the time into the framegroup/animation named by .frame, you should increment this value according to frametime or to distance moved, depending on the sort of animation you're attempting. You may wish to avoid incrementing this while lerpfrac is still changing, to avoid wasting parts of the animation. */
#endif
#if defined(CSQC) || defined(SSQC)
.floatbasebone;/* The base* frame animations are equivelent to their non-base versions, except that they only affect bone numbers below the 'basebone' value. This means that the base* animation can affect the legs of a skeletal model independantly of the normal animation fields affecting the torso area. For more complex animation than this, use skeletal objects. */
.floatbaseframe;/* See basebone */
.void()customphysics;/* Called once each physics frame, overriding the entity's .movetype field and associated logic. You'll probably want to use tracebox to move it through the world. Be sure to call .think as appropriate. */
.entitytag_entity;/* Specifies which entity this entity's origin+angles is 'attached' to. */
.floattag_index;/* Specifies the tag or bone on the parent entity that we're attached to. If this is -1 then the entity is instead a q3-like camera portal, with the tag_entity saying the entity to display for. If tag_entity is world then this is a q3-like portal surface marker with a separate camera (with a tag_entity referring to the portal surface). */
.vectorgravitydir;/* Specifies the direction in which gravity acts. Must be normalised. '0 0 0' also means down. Use '0 0 1' if you want the player to be able to run on ceilings. */
.vector(vectororg,vectorang)camera_transform;/* A callback that provides portal transform information for portal surfaces attached to this entity. Also used to open up pvs in ssqc. */
.vectorcolor;/* This affects the colour of realtime lights that were enabled via the pflags field. */
.floatlight_lev;/* This is the radius of an entity's light. This is not normally used by the engine, but is used for realtime lights (ones that are enabled with the pflags field). */
.floatstyle;/* Used by the light util to decide how an entity's light should animate. On an entity with pflags set, this also affects realtime lights. */
.vectormovement;/* These are the directions that the player is currently trying to move in (ie: which +forward/+moveright/+moveup etc buttons they have held), expressed relative to that player's angles. Order is forward, right, up. */
__deprecated("Cannot be recorded in MVDs, nor work properly with splitscreen. Use CSQC instead.").entitynodrawtoclient;/* This entity will not be sent to the player named by this field. They will be invisible and not emit dlights/particles. Does not work in MVD-recorded game. */
__deprecated("Cannot be recorded in MVDs, nor work properly with splitscreen. Use CSQC instead.").entitydrawonlytoclient;/* This entity will be sent *only* to the player named by this field. To other players they will be invisible and not emit dlights/particles. Does not work in MVD-recorded game. */
__deprecated("Redundant. Cannot be recorded in MVDs, nor work properly with splitscreen. Use CSQC instead.").entityviewmodelforclient;/* This entity will be sent only to the player named by this field, and this entity will be attached to the player's view as an additional weapon model. */
__deprecated("Cannot be recorded in MVDs, nor work properly with splitscreen. Use CSQC instead.").entityexteriormodeltoclient;/* This entity will be invisible to the player named by this field, except in mirrors or mirror-like surfaces, where it will be visible as normal. It may still cast shadows as normal, and generate lights+particles, depending on client settings. Does not affect how other players see the entity. */
.floatemiteffectnum;/* This should be set to the result of particleeffectnum, in order to continually spawn particles in the direction that this entity faces. */
__deprecated("Does not work with MVDs nor splitscreen.").floatdimension_see;/* This is the dimension mask (bitfield) that the client is allowed to see. Entities and events not in this dimension mask will be invisible. */
__deprecated("Does not work with MVDs nor splitscreen.").floatdimension_seen;/* This is the dimension mask (bitfield) that the client is visible within. Clients that cannot see this dimension mask will not see this entity. */
__deprecated("Does not work with MVDs nor splitscreen.").floatdimension_ghost;/* If this entity is visible only within these dimensions, it will become transparent, as if a ghost. */
__deprecated("Does not work with MVDs nor splitscreen.").floatdimension_ghost_alpha;/* If this entity is subject to dimension_ghost, this is the scaler for its alpha value. If 0, 0.5 will be used instead. */
.float(entityplayerent,floatchangedflags)SendEntity;/* 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. */
.floatSendFlags;/* 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. */
.floatlight_level;/* Used by hexen2 to indicate the light level where the player is standing. */
.floatpvsflags;/* Reconfigures when the entity is visible to clients */
.floatuniquespawnid;/* Incremented by 1 whenever the entity is respawned. Persists across remove calls, for when the two-second grace period is insufficient. */
DEP_CSQC.float()customizeentityforclient;/* Called just before an entity is sent to a client (non-csqc protocol). This gives you a chance to tailor 'self' according to what 'other' should see. */
.floatframe3time;/* .frame3 equivelent of frame1time. */
.floatlerpfrac3;/* Weight of .frame3 - .frame's weight is automatically calculated as 1-(lerpfrac+lerpfrac3+lerpfrac4), as a result these fields should NEVER add to above 1. */
void()SpectatorConnect;/* Called when a spectator joins the game. */
void()SpectatorDisconnect;/* Called when a spectator disconnects from the game. */
void()SpectatorThink;/* Called each frame for each spectator. */
void(stringcmd)SV_ParseClientCommand;/* Provides QC with a way to intercept 'cmd foo' commands from the client. Very handy. Self will be set to the sending client, while the 'cmd' argument can be tokenize()d and each element retrieved via argv(argno). Unrecognised cmds MUST be passed on to the clientcommand builtin. */
void(stringdest,stringfrom,stringcmd,stringinfo)SV_ParseClusterEvent;/* Part of cluster mode. Handles cross-node events that were sent via clusterevent, on behalf of the named client. */
float(stringsender,stringbody)SV_ParseConnectionlessPacket;/* Provides QC with a way to communicate between servers, or with client server browsers. Sender is the sender's ip. Body is the body of the message. You'll need to add your own password/etc support as required. Self is not valid. */
void(floatpauseduration)SV_PausedTic;/* For each frame that the server is paused, this function will be called to give the gamecode a chance to unpause the server again. the pauseduration argument says how long the server has been paused for (the time global is frozen and will not increment while paused). Self is not valid. */
float(floatnewstatus)SV_ShouldPause;/* Called to give the qc a change to block pause/unpause requests. Return false for the pause request to be ignored. newstatus is 1 if the user is trying to pause the game. For the duration of the call, self will be set to the player who tried to pause, or to world if it was triggered by a server-side event. */
void()SV_RunClientCommand;/* Called each time a player movement packet was received from a client. Self is set to the player entity which should be updated, while the input_* globals specify the various properties stored within the input packet. The contents of this function should be somewaht identical to the equivelent function in CSQC, or prediction misses will occur. If you're feeling lazy, you can simply call 'runstandardplayerphysics' after modifying the inputs. */
void()SV_AddDebugPolygons;/* Called each video frame. This is the only place where ssqc is allowed to call the R_BeginPolygon/R_PolygonVertex/R_EndPolygon builtins. This is exclusively for debugging, and will break in anything but single player as it will not be called if the engine is not running both a client and a server. */
DEP_CSQCvoid()SV_PlayerPhysics;/* Compatibility method to tweak player input that does not reliably work with prediction (prediction WILL break). Mods that care about prediction should use SV_RunClientCommand instead. If pr_no_playerphysics is set to 1, this function will never be called, which will either fix prediction or completely break player movement depending on whether the feature was even useful. */
void()EndFrame;/* Called after non-player entities have been run at the end of the physics frame. Player physics is performed out of order and can/will still occur between EndFrame and BeginFrame. */
string(stringaddr,stringuinfo,stringfeatures)SV_CheckRejectConnection;/* Called to give the mod a chance to ignore connection requests based upon client protocol support or other properties. Use infoget to read the uinfo and features arguments. */
#endif
#ifdef CSQC
void(floatapilevel,stringenginename,floatengineversion)CSQC_Init;/* Called at startup. enginename and engineversion are arbitary hints and can take any form. enginename should be consistant between revisions, but this cannot truely be relied upon. */
void()CSQC_WorldLoaded;/* Called after the server's model+sound precaches have been executed. Gives a chance for the qc to read the entity lump from the bsp (via getentitytoken). */
void()CSQC_Shutdown;/* Specifies that the csqc is going down. Save your persistant settings here. */
void(floatvwidth,floatvheight,floatnotmenu)CSQC_UpdateView;/* Called every single video frame. The CSQC is responsible for rendering the entire screen. */
void(floatvwidth,floatvheight,floatnotmenu)CSQC_UpdateViewLoading;/* Alternative to CSQC_UpdateView, called when the engine thinks there should be a loading screen. If present, will inhibit the engine's normal loading screen, deferring to qc to draw it. */
void(vectorviewsize,floatscoresshown)CSQC_DrawHud;/* Part of simple csqc, called after drawing the 3d view whenever CSQC_UpdateView is not defined. */
void(vectorviewsize,floatscoresshown)CSQC_DrawScores;/* Part of simple csqc, called after CSQC_DrawHud whenever CSQC_UpdateView is not defined, and when there are no menus/console active. */
void(stringmsg)CSQC_Parse_StuffCmd;/* Gives the CSQC a chance to intercept stuffcmds. Use the tokenize builtin to parse the message. Unrecognised commands would normally be localcmded, but its probably better to drop unrecognised stuffcmds completely. */
float(stringmsg)CSQC_Parse_CenterPrint;/* Gives the CSQC a chance to intercept centerprints. Return true if you wish the engine to otherwise ignore the centerprint. */
float(floatsave,floattake,vectorinflictororg)CSQC_Parse_Damage;/* Called as a result of player.dmg_save or player.dmg_take being set on the server.
void(stringprintmsg,floatprintlvl)CSQC_Parse_Print;/* Gives the CSQC a chance to intercept sprint/bprint builtin calls. CSQC should filter by the client's current msg setting and then pass the message on to the print command, or handle them itself. */
void()CSQC_Parse_Event;/* Called when the client receives an SVC_CGAMEPACKET. The csqc should read the data or call the error builtin if it does not recognise the message. */
float(floatevtype,floatscanx,floatchary,floatdevid)CSQC_InputEvent;/* Called whenever a key is pressed, the mouse is moved, etc. evtype will be one of the IE_* constants. The other arguments vary depending on the evtype. Key presses are not guarenteed to have both scan and unichar values set at the same time. */
__usedvoid()CSQC_Input_Frame;/* Called just before each time clientcommandframe is updated. You can edit the input_* globals in order to apply your own player inputs within csqc, which may allow you a convienient way to pass certain info to ssqc. */
void(stringrendererdescription)CSQC_RendererRestarted;/* Called by the engine after the video was restarted. This serves to notify the CSQC that any render targets that it may have cached were purged, and will need to be regenerated. */
float(stringtext,stringinfo)CSQC_ConsoleLink;/* Called if the user clicks a ^[text\infokey\infovalue^] link. Use infoget to read/check each supported key. Return true if you wish the engine to not attempt to handle the link itself.
void(floatentnum)CSQC_Ent_Spawn;/* Clumsily defined function for compat with DP. Should call spawn, set that ent's entnum field, and return the entity inside the 'self' global which will then be used for fllowing Ent_Updates. MUST NOT PARSE ANY NETWORK DATA (which makes it kinda useless). */
void(floatisnew)CSQC_Ent_Update;/* Parses the data sent by ssqc's various SendEntity functions (must use the exact same reads as the ssqc used writes - to debug this rule more easily, you may wish to use sv_csqcdebug). 'self' provides context between frames, and self.entnum should normally report which ssqc entity . Be aware that interpolation will need to happen separately. */
string(stringuri,stringmethod,stringpostdata,__instringrequestheaders,__inoutstringresponseheaders)Cef_GeneratePage;/* Provides an entrypoint to generate pages for the CEF plugin from within QC. Headers are
string(stringuri,stringmethod,stringpostdata,__instringrequestheaders,__inoutstringresponseheaders)HTTP_GeneratePage;/* Provides an entrypoint to generate pages for pages requested over http (sv_port_tcp+net_enable_http). Headers are
void(floatprevprogs)init;/* Part of FTE_MULTIPROGS. Called as soon as a progs is loaded, called at a time when entities are not valid. This is the only time when it is safe to call addprogs without field assignment. As it is also called as part of addprogs, this also gives you a chance to hook functions in modules that are already loaded (via externget+externget). */
void()initents;/* Part of FTE_MULTIPROGS. Called after fields have been finalized. This is the first point at which it is safe to call spawn(), and is called before any entity fields have been parsed. You can use this entrypoint to send notifications to other modules. */
#endif
#ifdef MENU
void()m_init;
void()m_shutdown;
void(vectorscreensize)m_draw;/* Provides the menuqc with a chance to draw. Will be called even if the menu does not have focus, so be sure to avoid that. COMPAT: screensize is not provided in DP. */
void(vectorscreensize,floatopaque)m_drawloading;/* Additional drawing function to draw loading screens. If opaque is set, then this function must ensure that the entire screen is overdrawn (even if just by a black drawfill). */
void(stringrendererdescription)Menu_RendererRestarted;/* Called by the engine after the video was restarted. This serves to notify the MenuQC that any render targets that it may have cached were purged, and will need to be regenerated. */
floatparm17,parm18,parm19,parm20,parm21,parm22,parm23,parm24,parm25,parm26,parm27,parm28,parm29,parm30,parm31,parm32;/* Additional spawn parms, following the same parmN theme. */
varfloatdimension_send;/* Used by multicast functionality. Multicasts (and related builtins that multicast internally) will only be sent to players where (player.dimension_see & dimension_send) is non-zero. */
//var float dimension_default = 255;
/* Default dimension bitmask */
#endif
#if defined(CSQC) || defined(SSQC)
__usedvarfloatphysics_mode=2;/* 0: original csqc - physics are not run
1:DP-compat.Thinksoccur,butnottruemovetypes.
2:movetypesoccurjustastheydoinssqc.*/
#endif
#ifdef CSQC
floatgamespeed;/* Set by the engine, this is the value of the sv_gamespeed cvar */
floatnumclientseats;/* This is the number of splitscreen clients currently running on this client. */
#endif
#if defined(CSQC) || defined(MENU)
varvectordrawfontscale='110';/* Specifies a scaler for all text rendering. There are other ways to implement this. */
floatdrawfont;/* Allows you to choose exactly which font is to be used to draw text. Fonts can be registered/allocated with the loadfont builtin. */
constfloatMOVETYPE_6DOF=30;/* A glorified MOVETYPE_FLY. Players using this movetype will get some flightsim-like physics, with fully independant rotations (order-dependant transforms). */
constfloatMOVETYPE_WALLWALK=31;/* Players using this movetype will be able to orient themselves to walls, and then run up them. */
constfloatMOVETYPE_PHYSICS=32;/* Enable the use of ODE physics upon this entity. */
constfloatSOLID_NOT=0;
constfloatSOLID_TRIGGER=1;
constfloatSOLID_BBOX=2;
constfloatSOLID_SLIDEBOX=3;
constfloatSOLID_BSP=4;/* Does not collide against other SOLID_BSP entities. Normally paired with MOVETYPE_PUSH. */
constfloatSOLID_CORPSE=5;/* Non-solid to SOLID_SLIDEBOX or other SOLID_CORPSE entities. For hitscan weapons to hit corpses, change the player's .hitcontentsmaski value to include CONTENTBIT_CORPSE, perform the traceline, then revert the player's .solid value. */
__deprecated("Obsoleted by .skin=CONTENTS_LADDER")constfloatSOLID_LADDER=20;/* Obsolete and may be removed at some point. Use skin=CONTENT_LADDER and solid_bsp or solid_trigger instead. */
constfloatGE_MAXENTS=-1;/* Valid for getentity, ignores the entity argument. Returns the maximum number of entities which may be valid, to avoid having to poll 65k when only 100 are used. */
constfloatGE_ACTIVE=0;/* Valid for getentity. Returns whether this entity is known to the client or not. */
constfloatGE_ORIGIN=1;/* Valid for getentity. Returns the interpolated .origin. */
constfloatGE_FORWARD=2;/* Valid for getentity. Returns the interpolated forward vector. */
constfloatGE_RIGHT=3;/* Valid for getentity. Returns the entity's right vector. */
constfloatGE_UP=4;/* Valid for getentity. Returns the entity's up vector. */
constfloatGE_SCALE=5;/* Valid for getentity. Returns the entity .scale. */
constfloatGE_ORIGINANDVECTORS=6;/* Valid for getentity. Returns interpolated .origin, but also sets v_forward, v_right, and v_up accordingly. Use vectoangles(v_forward,v_up) to determine the angles. */
constfloatGE_ALPHA=7;/* Valid for getentity. Returns the entity alpha. */
constfloatGE_COLORMOD=8;/* Valid for getentity. Returns the colormod vector. */
constfloatGE_PANTSCOLOR=9;/* Valid for getentity. Returns the entity's lower color (from .colormap), as a palette range value. */
constfloatGE_SHIRTCOLOR=10;/* Valid for getentity. Returns the entity's lower color (from .colormap), as a palette range value. */
constfloatGE_SKIN=11;/* Valid for getentity. Returns the entity's .skin index. */
constfloatGE_MINS=12;/* Valid for getentity. Guesses the entity's .min vector. */
constfloatGE_MAXS=13;/* Valid for getentity. Guesses the entity's .max vector. */
constfloatGE_ABSMIN=14;/* Valid for getentity. Guesses the entity's .absmin vector. */
constfloatGE_ABSMAX=15;/* Valid for getentity. Guesses the entity's .absmax vector. */
constfloatGE_MODELINDEX=200;/* Valid for getentity. Guesses the entity's .modelindex float. */
constfloatGE_MODELINDEX2=201;/* Valid for getentity. Guesses the entity's .vw_index float. */
constfloatGE_EFFECTS=202;/* Valid for getentity. Guesses the entity's .effects float. */
constfloatGE_FRAME=203;/* Valid for getentity. Guesses the entity's .frame float. */
constfloatGE_ANGLES=204;/* Valid for getentity. Guesses the entity's .angles vector. */
constfloatGE_FATNESS=205;/* Valid for getentity. Guesses the entity's .fatness float. */
constfloatGE_DRAWFLAGS=206;/* Valid for getentity. Guesses the entity's .drawflags float. */
constfloatGE_ABSLIGHT=207;/* Valid for getentity. Guesses the entity's .abslight float. */
constfloatGE_GLOWMOD=208;/* Valid for getentity. Guesses the entity's .glowmod vector. */
constfloatGE_GLOWSIZE=209;/* Valid for getentity. Guesses the entity's .glowsize float. */
constfloatGE_GLOWCOLOUR=210;/* Valid for getentity. Guesses the entity's .glowcolor float. */
constfloatGE_RTSTYLE=211;/* Valid for getentity. Guesses the entity's .style float. */
constfloatGE_RTPFLAGS=212;/* Valid for getentity. Guesses the entity's .pflags float. */
constfloatGE_RTCOLOUR=213;/* Valid for getentity. Guesses the entity's .color vector. */
constfloatGE_RTRADIUS=214;/* Valid for getentity. Guesses the entity's .light_lev float. */
constfloatGE_TAGENTITY=215;/* Valid for getentity. Guesses the entity's .tag_entity float. */
constfloatGE_TAGINDEX=216;/* Valid for getentity. Guesses the entity's .tag_index float. */
constfloatGE_GRAVITYDIR=217;/* Valid for getentity. Guesses the entity's .gravitydir vector. */
constfloatGE_TRAILEFFECTNUM=218;/* Valid for getentity. Guesses the entity's .traileffectnum float. */
#endif
#ifdef SSQC
constfloatDAMAGE_NO=0;
constfloatDAMAGE_YES=1;
constfloatDAMAGE_AIM=2;
#endif
#if defined(CSQC) || defined(SSQC)
constfloatCONTENT_EMPTY=-1;
constfloatCONTENT_SOLID=-2;
constfloatCONTENT_WATER=-3;
constfloatCONTENT_SLIME=-4;
constfloatCONTENT_LAVA=-5;
constfloatCONTENT_SKY=-6;
constfloatCONTENT_LADDER=-16;/* If this value is assigned to a solid_bsp's .skin field, the entity will become a ladder volume. */
constintCONTENTBIT_SKY=0x80000000i;/* Content bit somewhat specific to q1bsp (aliases to NODROP in q3bsp), but you should probably check surfaceflags&SURF_SKY as well for q2+q3bsp too. */
constintCONTENTBITS_POINTSOLID=CONTENTBIT_SOLID|0x00000002i|CONTENTBIT_BODY;/* Bits that traceline would normally consider solid */
constintCONTENTBITS_BOXSOLID=CONTENTBIT_SOLID|0x00000002i|CONTENTBIT_BODY|CONTENTBIT_PLAYERCLIP;/* Bits that tracebox would normally consider solid */
constfloatCHAN_AUTO=0;/* The automatic channel, play as many sounds on this channel as you want, and they'll all play, however the other channels will replace each other. */
constfloatCHAN_WEAPON=1;
constfloatCHAN_VOICE=2;
constfloatCHAN_ITEM=3;
constfloatCHAN_BODY=4;
#endif
#if defined(QWSSQC)
constfloatCHANF_RELIABLE=8;/* Only valid if the flags argument is not specified. The sound will be sent reliably, which is important if it is intended to replace looping sounds on doors etc. */
#endif
#ifdef SSQC
constfloatSOUNDFLAG_RELIABLE=1;/* The sound will be sent reliably, and without regard to phs. */
#endif
#ifdef CSQC
constfloatSOUNDFLAG_ABSVOLUME=16;/* The sample's volume is not scaled by the volume cvar. Use with caution */
#endif
#if defined(CSQC) || defined(SSQC)
constfloatSOUNDFLAG_FORCELOOP=2;/* The sound will restart once it reaches the end of the sample. */
#endif
#ifdef CSQC
constfloatSOUNDFLAG_NOSPACIALISE=4;/* The different audio channels are played at the same volume regardless of which way the player is facing, without needing to use 0 attenuation. */
#endif
#if defined(CSQC) || defined(SSQC)
constfloatSOUNDFLAG_NOREVERB=32;/* Disables the use of underwater/reverb effects on this sound effect. */
constfloatSOUNDFLAG_FOLLOW=64;/* The sound's origin will updated to follow the emitting entity. */
constfloatSOUNDFLAG_UNICAST=256;/* The sound will be sent only by the player specified by msg_entity. Spectators and related splitscreen players will also hear the sound. */
constfloatSOUNDFLAG_SENDVELOCITY=512;/* The entity's current velocity will be sent to the client, only useful if doppler is enabled. */
#endif
#if defined(CSQC) || defined(SSQC)
constfloatATTN_NONE=0;/* Sounds with this attenuation can be heard throughout the map */
constfloatATTN_NORM=1;/* Standard attenuation */
constfloatATTN_IDLE=2;/* Extra attenuation so that sounds don't travel too far. */
constfloatATTN_STATIC=3;/* Even more attenuation to avoid torches drowing out everything else throughout the map. */
#endif
#ifdef SSQC
constfloatSVC_CGAMEPACKET=83;/* Direct ssqc->csqc message. Must only be multicast. The data triggers a CSQC_Parse_Event call in the csqc for the csqc to read the contents. The server *may* insert length information for clients connected via proxies which are not able to cope with custom csqc payloads. This should only ever be used in conjunction with the MSG_MULTICAST destination. */
constfloatMSG_BROADCAST=0;/* The byte(s) will be unreliably sent to all players. MSG_ constants are valid arguments to the Write* builtin family. */
constfloatMSG_ONE=1;/* The byte(s) will be reliably sent to the player specified in the msg_entity global. WARNING: in quakeworld servers without network preparsing enabled, this can result in illegible server messages (due to individual reliable messages being split between multiple backbuffers/packets). NQ has larger reliable buffers which avoids this issue, but still kicks the client. */
constfloatMSG_ALL=2;/* The byte(s) will be reliably sent to all players. */
__deprecated("Use MSG_MULTICAST+multicast(MULTICAST_*)")constfloatMSG_BROADCAST;/* The byte(s) will be unreliably sent to all players. MSG_ constants are valid arguments to the Write* builtin family. */
__deprecated("Use MSG_MULTICAST+multicast(MULTICAST_ONE_R)")constfloatMSG_ONE=1;/* The byte(s) will be reliably sent to the player specified in the msg_entity global. WARNING: in quakeworld servers without network preparsing enabled, this can result in illegible server messages (due to individual reliable messages being split between multiple backbuffers/packets). NQ has larger reliable buffers which avoids this issue, but still kicks the client. */
__deprecated("Use MSG_MULTICAST+multicast(MULTICAST_ALL)")constfloatMSG_ALL=2;/* The byte(s) will be reliably sent to all players. */
constfloatMSG_INIT=3;/* The byte(s) will be written into the signon buffer. Clients will see these messages when they connect later. This buffer is only flushed on map changes, so spamming it _WILL_ result in overflows. */
constfloatMSG_MULTICAST=4;/* 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. */
constfloatMSG_ENTITY=5;/* The byte(s) will be written into the entity buffer. This is a special value used only inside 'SendEntity' functions. */
constfloatMULTICAST_ALL=0;/* The multicast message is unreliably sent to all players. MULTICAST_ constants are valid arguments for the multicast builtin, which ignores the specified origin when given this constant. */
constfloatMULTICAST_PHS=1;/* The multicast message is unreliably sent to only players that can potentially hear the specified origin. Its quite loose. */
constfloatMULTICAST_PVS=2;/* The multicast message is unreliably sent to only players that can potentially see the specified origin. */
constfloatMULTICAST_ONE=6;/* The multicast message is unreliably sent to the player (AND ALL TRACKING SPECTATORS) specified in the msg_entity global. The specified origin is ignored. */
constfloatMULTICAST_ONE_NOSPECS=9;/* The multicast message is unreliably sent to the player specified in the msg_entity global. The specified origin is ignored. */
constfloatMULTICAST_ALL_R=3;/* The multicast message is reliably sent to all players. The specified origin is ignored. */
constfloatMULTICAST_PHS_R=4;/* The multicast message is reliably sent to only players that can potentially hear the specified origin. Players might still not receive it if they are out of range. */
constfloatMULTICAST_PVS_R=5;/* The multicast message is reliably sent to only players that can potentially see the specified origin. Players might still not receive it if they cannot see the event. */
constfloatMULTICAST_ONE_R=7;/* The multicast message is reliably sent to the player (AND ALL TRACKING SPECTATORS) specified in the msg_entity global. The specified origin is ignored */
constfloatMULTICAST_ONE_R_NOSPECS=10;/* The multicast message is reliably sent to the player specified in the msg_entity global. The specified origin is ignored */
constfloatPVSF_IGNOREPVS=3;/* Ignores pvs. This entity is visible whereever you are on the map. Updates will be sent regardless of pvs or phs */
constfloatPVSF_NOREMOVE=128;/* Once visible to a client, this entity will remain visible. This can be useful for csqc and corpses. While this flag is set, no CSQC_Remove events will be sent for the entity, but this does NOT mean that it will still receive further updates while outside of the pvs. */
conststringINFOKEY_P_IP="ip";/* The apparent ip address of the client. This may be a proxy's ip address. */
conststringINFOKEY_P_REALIP="realip";/* If sv_getrealip is set, this gives the ip as determine using that algorithm. */
conststringINFOKEY_P_CSQCACTIVE="csqcactive";/* Client has csqc enabled. CSQC ents etc will be sent to this player. */
conststringINFOKEY_P_SVPING="svping";
conststringINFOKEY_P_GUID="guid";/* Some hash string which should be reasonably unique to this player's quake installation. */
conststringINFOKEY_P_CHALLENGE="challenge";
conststringINFOKEY_P_USERID="*userid";
conststringINFOKEY_P_DOWNLOADPCT="download";/* The client's download percentage for the current file. Additional files are not known. */
conststringINFOKEY_P_TRUSTLEVEL="trustlevel";
conststringINFOKEY_P_PROTOCOL="protocol";/* The network protocol the client is using to connect to the server. */
conststringINFOKEY_P_VIP="*VIP";/* 1 if the player has the VIP 'penalty'. */
conststringINFOKEY_P_ISMUTED="*ismuted";/* 1 if the player has the 'mute' penalty and is not allowed to use the say/say_team commands. */
conststringINFOKEY_P_ISDEAF="*isdeaf";/* 1 if the player has the 'deaf' penalty and cannot see other people's say/say_team commands. */
conststringINFOKEY_P_ISCRIPPLED="*ismuted";/* 1 if the player has the cripple penalty, and their movement values are ignored (.movement is locked to 0). */
conststringINFOKEY_P_ISCUFFED="*ismuted";/* 1 if the player has the cuff penalty, and is unable to attack or use impulses(.button0 and .impulse fields are locked to 0). */
conststringINFOKEY_P_ISLAGGED="*ismuted";/* 1 if the player has the fakelag penalty and has an extra 200ms of lag. */
#endif
#if defined(CSQC) || defined(SSQC)
conststringINFOKEY_P_PING="ping";/* The player's ping time, in milliseconds. */
conststringINFOKEY_P_NAME="name";/* The player's name. */
conststringINFOKEY_P_TOPCOLOR="topcolor";/* The player's upper/shirt colour (palette index). */
conststringINFOKEY_P_BOTTOMCOLOR="bottomcolor";/* The player's lower/pants/trouser colour (palette index). */
#endif
#ifdef CSQC
conststringINFOKEY_P_TOPCOLOR_RGB="topcolor_rgb";/* The player's upper/shirt colour as an rgb value in a format usable with stov. */
conststringINFOKEY_P_BOTTOMCOLOR_RGB="bottomcolor_rgb";/* The player's lower/pants/trouser colour as an rgb value in a format usable with stov. */
conststringINFOKEY_P_MUTED="ignored";/* 0: we can see the result of the player's say/say_team commands. 1: we see no say/say_team messages from this player. Use the ignore command to toggle this value. */
conststringINFOKEY_P_VOIP_MUTED="vignored";/* 0: we can hear this player when they speak (assuming voip is generally enabled). 1: we ignore everything this player says. Use cl_voip_mute to change the values. */
conststringINFOKEY_P_ENTERTIME="entertime";/* Reads the timestamp at which the player entered the game, in terms of csqc's time global. */
conststringINFOKEY_P_FRAGS="frags";/* Reads a player's frag count. */
conststringINFOKEY_P_PACKETLOSS="pl";/* Reads a player's packetloss, as a percentage. */
conststringINFOKEY_P_VOIPSPEAKING="voipspeaking";/* Boolean value that says whether the given player is currently sending voice information. */
conststringINFOKEY_P_VOIPLOUDNESS="voiploudness";/* Only valid for the local player. Gives a value between 0 and 1 to indicate to the user how loud their mic is. */
conststringSERVERKEY_IP="ip";/* The address of the server we connected to. */
conststringSERVERKEY_SERVERNAME="servername";/* The hostname that was last passed to the connect command. */
conststringSERVERKEY_CONSTATE="constate";/* 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, aka: loading screen). */
conststringSERVERKEY_TRANSFERRING="transferring";/* Set to the hostname of the server that we are attempting to connect or transfer to. */
conststringSERVERKEY_LOADSTATE="loadstate";/* loadstage, loading image name, current step, max steps
Stagesare:1=connecting,2=serverside,3=clientside
Keywillbeemptyifwearenotloading.*/
conststringSERVERKEY_PAUSESTATE="pausestate";/* 1 if the server claimed to be paused. 0 otherwise */
conststringSERVERKEY_DLSTATE="dlstate";/* The progress of any current downloads. Empty string if no download is active, otherwise a tokenizable string containing this info:
constfloatFL_FINDABLE_NONSOLID=16384;/* Allows this entity to be found with findradius */
#endif
#ifdef SSQC
constfloatFL_LAGGEDMOVE=65536;/* Enables anti-lag on rockets etc. */
#endif
#if defined(CSQC) || defined(SSQC)
constfloatMOVE_NORMAL=0;
constfloatMOVE_NOMONSTERS=1;/* The trace will ignore all non-solid_bsp entities. */
constfloatMOVE_MISSILE=2;/* The trace will use a bbox size of +/- 15 against entities with FL_MONSTER set. */
constfloatMOVE_HITMODEL=4;/* Traces will impact the actual mesh of the model instead of merely their bounding box. Should generally only be used for tracelines. Note that this flag is unreliable as an object can animate through projectiles. The bounding box MUST be set to completely encompass the entity or those extra areas will be non-solid (leaving a hole for things to go through). */
constfloatMOVE_TRIGGERS=16;/* This trace type will impact only triggers. It will ignore non-solid entities. */
constfloatMOVE_EVERYTHING=32;/* This type of trace will hit solids and triggers alike. Even non-solid entities. */
#endif
#ifdef SSQC
constfloatMOVE_LAGGED=64;/* Will use antilag based upon the player's latency. Traces will be performed against old positions for entities instead of their current origin. */
#endif
#if defined(CSQC) || defined(SSQC)
constfloatMOVE_ENTCHAIN=128;/* Returns a list of entities impacted via the trace_ent.chain field */
constfloatMOVE_OTHERONLY=256;/* Traces that use this trace type will collide against *only* the entity specified via the 'other' global, and will ignore all owner/solid_not/dimension etc rules, they will still adhere to contents and bsp/bbox rules though. */
#endif
constfloatRESTYPE_MODEL=0;/* RESTYPE_* constants are used as arguments with the resourcestatus builtin. */
constfloatRESTYPE_PIC=3;/* precache_pic. Status results are an amalgomation of the textures used by the named shader. */
constfloatRESTYPE_SKIN=4;/* setcustomskin */
constfloatRESTYPE_TEXTURE=5;/* Individual textures within shaders. These are not directly usable, but may be named as part of a skin file, or a shader. */
#endif
constfloatRESSTATE_NOTKNOWN=0;/* RESSTATE_* constants are return values from the resourcestatus builtin. The engine doesn't know about the resource if it is in this state. This means you will need to precache it. Attempting to use it anyway may result in warnings, errors, or silently succeed, depending on engine version and resource type. */
constfloatRESSTATE_NOTLOADED=1;/* The resource was precached, but has been flushed and there has not been an attempt to reload it. If you use the resource normally, chances are it'll be loaded but at the cost of a stall. */
constfloatRESSTATE_LOADING=2;/* Resources in this this state are queued for loading, and will be loaded at the engine's convienience. If you attempt to query the resource now, the engine will stall until the result is available. sounds in this state may be delayed, while models/pics/shaders may be invisible. */
constfloatRESSTATE_FAILED=3;/* Resources in this state are unusable/could not be loaded. You will get placeholders or dummy results. Queries will not stall the engine. The engine may display placeholder content. */
constfloatRESSTATE_LOADED=4;/* Resources in this state are finally usable, everything will work okay. Hurrah. Queries will not stall the engine. */
constfloatPFLAGS_NOSHADOW=1;/* Associated RT lights attached will not cast shadows, making them significantly faster to draw. */
constfloatPFLAGS_CORONA=2;/* Enables support of coronas on the associated rtlights. */
#endif
#ifdef SSQC
constfloatPFLAGS_FULLDYNAMIC=128;/* When set in self.pflags, enables fully-customised dynamic lights. Custom rtlight information is not otherwise used. */
#endif
constfloatEV_STRING=1;
constfloatEV_FLOAT=2;
constfloatEV_VECTOR=3;
constfloatEV_ENTITY=4;
constfloatEV_FIELD=5;
constfloatEV_FUNCTION=6;
constfloatEV_POINTER=7;
constfloatEV_INTEGER=8;
constfloatEV_VARIANT=9;
hashtablegamestate;/* Special hash table index for hash_add and hash_get. Entries in this table will persist over map changes (and doesn't need to be created/deleted). */
constfloatHASH_REPLACE=256;/* Used with hash_add. Attempts to remove the old value instead of adding two values for a single key. */
constfloatHASH_ADD=512;/* Used with hash_add. The new entry will be inserted in addition to the existing entry. */
#ifdef CSQC
constfloatSTAT_HEALTH=0;/* Player's health. */
constfloatSTAT_WEAPONMODELI=2;/* This is the modelindex of the current viewmodel (renamed from the original name 'STAT_WEAPON' due to confusions). */
constfloatSTAT_ITEMS=15;/* self.items | (self.items2<<23). In order to decode this stat properly, you need to use getstatbits(STAT_ITEMS,0,23) to read self.items, and getstatbits(STAT_ITEMS,23,11) to read self.items2 or getstatbits(STAT_ITEMS,28,4) to read the visible part of serverflags, whichever is applicable. */
constfloatPRECACHE_PIC_FROMWAD=1;/* Attempt to load it from the legacy gfx.wad file (usually its better to just use a gfx/ prefix instead). */
constfloatPRECACHE_PIC_DOWNLOAD=256;/* If no image could be loaded then attempt to download one from the server. This flag can cause the function to block until completion. (Slow!) */
constfloatPRECACHE_PIC_TEST=512;/* The precache will block until the image is fully loaded, returning a null string on failure. (Slow!) */
constfloatVF_MIN=1;/* The top-left of the 3d viewport in screenspace. The VF_ values are used via the setviewprop/getviewprop builtins. */
constfloatVF_MIN_X=2;
constfloatVF_MIN_Y=3;
constfloatVF_SIZE=4;/* The width+height of the 3d viewport in screenspace. */
constfloatVF_SIZE_X=5;
constfloatVF_SIZE_Y=6;
constfloatVF_VIEWPORT=7;/* vector+vector. Two argument shortcut for VF_MIN and VF_SIZE */
constfloatVF_FOV=8;/* sets both fovx and fovy. consider using afov instead. */
constfloatVF_FOVX=9;/* horizontal field of view. does not consider aspect at all. */
constfloatVF_FOVY=10;/* vertical field of view. does not consider aspect at all. */
constfloatVF_ORIGIN=11;/* The origin of the view. Not of the player. */
constfloatVF_ORIGIN_X=12;
constfloatVF_ORIGIN_Y=13;
constfloatVF_ORIGIN_Z=14;
constfloatVF_ANGLES=15;/* The angles the view will be drawn at. Not the angle the client reports to the server. */
constfloatVF_ANGLES_X=16;
constfloatVF_ANGLES_Y=17;
constfloatVF_ANGLES_Z=18;
#endif
#ifdef CSQC
constfloatVF_DRAWWORLD=19;/* boolean. If set to 1, the engine will draw the world and static/persistant rtlights. If 0, the world will be skipped and everything will be fullbright. */
constfloatVF_DRAWENGINESBAR=20;/* boolean. If set to 1, the sbar will be drawn, and viewsize will be honoured automatically. */
constfloatVF_DRAWCROSSHAIR=21;/* boolean. If set to 1, the engine will draw its default crosshair. */
constfloatVF_PERSPECTIVE=200;/* 1: regular rendering. Fov specifies the angle. 0: isometric-style. Fov specifies the number of Quake Units each side of the viewport, and mindist restrictions are removed, pvs culling should be disabled. */
constfloatVF_ACTIVESEAT=202;/* The 'seat' number, used when running splitscreen. */
#endif
#if defined(CSQC) || defined(MENU)
constfloatVF_AFOV=203;/* Aproximate fov. Matches the 'fov' cvar. The engine handles the aspect ratio for you. */
constfloatVF_SCREENVSIZE=204;/* Provides a reliable way to retrieve the current virtual screen size (even if the screen is automatically scaled to retain aspect). */
constfloatVF_SCREENPSIZE=205;/* Provides a reliable way to retrieve the current physical screen size (cvars need vid_restart for them to take effect). */
#endif
#ifdef CSQC
constfloatVF_VIEWENTITY=206;/* 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. */
#endif
#if defined(CSQC) || defined(MENU)
constfloatVF_RT_DESTCOLOUR=212;/* The texture name to write colour info into, this includes both 3d and 2d drawing.
constfloatVF_RT_DEPTH=210;/* The texture name to use as a depth buffer. Also used for shaders that specify $sourcedepth. 1-based. Additional arguments are: format (IMGFMT_D*), sizexy. */
constfloatVF_RT_RIPPLE=211;/* The texture name to use as a ripplemap (target for shaders with 'sort ripple'). Also used for shaders that specify $ripplemap. 1-based. Additional arguments are: format, sizexy. */
constfloatVF_ENVMAP=220;/* The cubemap name to use as a fallback for $reflectcube, if a shader was unable to load one. Note that this doesn't automatically change shader permutations or anything. */
constfloatVF_USERDATA=221;/* Pointer (and byte size) to an array of vec4s. This data is then globally visible to all glsl via the w_user uniform. */
#endif
#ifdef CSQC
constfloatVF_SKYROOM_CAMERA=222;/* Controls the camera position of the skyroom (which will be drawn underneath transparent sky surfaces). This should move slightly with the real camera, but not so much that the skycamera enters walls. Requires a skyshader with a blend mode on the first pass (or no passes). */
#endif
#if defined(CSQC) || defined(MENU)
constfloatVF_PROJECTIONOFFSET=224;/* vec2 horizontal+vertical offset for the projection matrix, for weird off-centre rendering. */
constfloatRF_VIEWMODEL=1;/* Specifies that the entity is a view model, and that its origin is relative to the current view position. These entities are also subject to viewweapon bob. */
constfloatRF_EXTERNALMODEL=2;/* Specifies that this entity should be displayed in mirrors (and may still cast shadows), but will not otherwise be visible. */
#endif
#if defined(CSQC) || defined(MENU)
constfloatRF_DEPTHHACK=4;/* 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. */
constfloatRF_ADDITIVE=8;/* Shaders from this entity will temporarily be hacked to use an additive blend mode instead of their normal blend mode. */
#endif
#ifdef CSQC
constfloatRF_USEAXIS=16;/* The entity will be oriented according to the current v_forward+v_right+v_up vector values instead of the entity's .angles field. */
constfloatRF_NOSHADOW=32;/* This entity will not cast shadows. Often useful on view models. */
constfloatRF_FRAMETIMESARESTARTTIMES=64;/* Specifies that the frame1time, frame2time field are timestamps (denoting the start of the animation) rather than time into the animation. */
constfloatIE_KEYDOWN=0;/* Specifies that a key was pressed. Second argument is the scan code. Third argument is the unicode (printable) char value. Fourth argument denotes which keyboard(or mouse, if its a mouse 'scan' key) the event came from. Note that some systems may completely separate scan codes and unicode values, with a 0 value for the unspecified argument. */
constfloatIE_KEYUP=1;/* Specifies that a key was released. Arguments are the same as IE_KEYDOWN. On some systems, this may be fired instantly after IE_KEYDOWN was fired. */
constfloatIE_MOUSEDELTA=2;/* Specifies that a mouse was moved (touch screens and tablets typically give IE_MOUSEABS events instead, use in_windowed_mouse 0 to test code to cope with either). Second argument is the X displacement, third argument is the Y displacement. Fourth argument is which mouse or touch event triggered the event. */
constfloatIE_MOUSEABS=3;/* Specifies that a mouse cursor or touch event was moved to a specific location relative to the virtual screen space. Second argument is the new X position, third argument is the new Y position. Fourth argument is which mouse or touch event triggered the event. */
constfloatIE_ACCELEROMETER=4;
constfloatIE_FOCUS=5;/* Specifies that input focus was given. parama says mouse focus, paramb says keyboard focus. If either are -1, then it is unchanged. */
constfloatIE_JOYAXIS=6;/* Specifies that what value a joystick/controller axis currently specifies. x=axis, y=value. Will be called multiple times, once for each axis of each active controller. */
constfloatGGDI_GAMEDIR=0;/* Used with getgamedirinfo to query the mod's public gamedir. There is often other info that cannot be expressed with just a gamedir name, resulting in dupes or other weirdness. */
constfloatGGDI_DESCRIPTION=1;/* The human-readable title of the mod. Empty when no data is known (ie: the gamedir just contains some maps). */
constfloatGGDI_OVERRIDES=2;/* A list of settings overrides. */
constfloatGGDI_LOADCOMMAND=3;/* The console command needed to actually load the mod. */
constfloatGGDI_ICON=4;/* The mod's Icon path, ready for drawpic. */
constfloatGGDI_GAMEDIRLIST=4;/* A semi-colon delimited list of gamedirs that the mod's content can be loaded through. */
constfloatCLIENTTYPE_DISCONNECTED=0;/* Return value from clienttype() builtin. This entity is a player slot that is currently empty. */
constfloatCLIENTTYPE_REAL=1;/* This is a real player, and not a bot. */
constfloatCLIENTTYPE_BOT=2;/* This player slot does not correlate to a real player, any messages sent to this client will be ignored. */
constfloatCLIENTTYPE_NOTACLIENT=3;/* This entity is not even a player slot. This is typically an error condition. */
#endif
constfloatFILE_READ=0;/* The file may be read via fgets to read a single line at a time. */
constfloatFILE_APPEND=1;/* Like FILE_WRITE, but writing starts at the end of the file. */
constfloatFILE_WRITE=2;/* fputs will be used to write to the file. */
#if defined(CSQC) || defined(SSQC)
constfloatFILE_READNL=4;/* Like FILE_READ, except newlines are not special. fgets reads the entire file into a tempstring. */
constfloatFILE_MMAP_READ=5;/* The file will be loaded into memory. fgets returns a pointer to the first byte (and will always return the same value for this file). Cast this to your datatype. */
constfloatFILE_MMAP_RW=6;/* Like FILE_MMAP_READ, except any changes to the data will be written back to disk once the file is closed. */
#endif
#ifdef CSQC
constfloatMASK_ENGINE=1;/* Valid as an argument for addentities. If specified, all non-csqc entities will be added to the scene. */
constfloatMASK_VIEWMODEL=2;/* Valid as an argument for addentities. If specified, the regular engine viewmodel will be added to the scene. */
constfloatPREDRAW_AUTOADD=0;/* Valid as a return value from the predraw function. Returning this will cause the engine to automatically invoke addentity(self) for you. */
constfloatPREDRAW_NEXT=1;/* Valid as a return value from the predraw function. 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. */
filestream(stringfilename,floatmode)fopen=#48;/* Part of FRIK_FILE*/
void(filestreamfhandle)fclose=#49;/* Part of FRIK_FILE*/
string(filestreamfhandle)fgets=#50;/* Part of FRIK_FILE*/
void(filestreamfhandle,strings)fputs=#51;/* Part of FRIK_FILE*/
float(string)strlen=#52;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
string(string,optionalstring,optionalstring,optionalstring,optionalstring,optionalstring,optionalstring,optionalstring)strcat=#53;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
string(strings,floatstart,floatlength)substring=#54;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
vector(string)stov=#55;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
searchhandle(stringpattern,enumflags:float{SB_CASEINSENSITIVE=1<<0,SB_FULLPACKAGEPATH=1<<1,SB_ALLOWDUPES=1<<2,SB_FORCESEARCH=1<<3}flags,floatquiet,optionalstringpackage)search_begin=#74;/* Part of DP_QC_FS_SEARCH, DP_QC_FS_SEARCH_PACKFILE*/
void(searchhandlehandle)search_end=#75;/* Part of DP_QC_FS_SEARCH, DP_QC_FS_SEARCH_PACKFILE*/
float(searchhandlehandle)search_getsize=#76;/* Part of DP_QC_FS_SEARCH, DP_QC_FS_SEARCH_PACKFILE*/
string(searchhandlehandle,floatnum)search_getfilename=#77;/* Part of DP_QC_FS_SEARCH, DP_QC_FS_SEARCH_PACKFILE*/
void(filestreamfhandle,strings,optionalstrings2,optionalstrings3,optionalstrings4,optionalstrings5,optionalstrings6,optionalstrings7)fputs=#113;/* Part of FRIK_FILE
float(strings)strlen=#114;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
string(strings1,optionalstrings2,optionalstrings3,optionalstrings4,optionalstrings5,optionalstrings6,optionalstrings7,optionalstrings8)strcat=#115;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
string(strings,floatstart,floatlength)substring=#116;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
vector(strings)stov=#117;/* Part of FRIK_FILE, FTE_STRINGS, ZQ_QC_STRINGS*/
float(optionalstringhost,optionalstringuser,optionalstringpass,optionalstringdefaultdb,optionalstringdriver)sqlconnect=#250;/* Part of FTE_SQL*/
void(floatserveridx)sqldisconnect=#251;/* Part of FTE_SQL*/
float(floatserveridx,void(floatserveridx,floatqueryidx,floatrows,floatcolumns,floateof,floatfirstrow)callback,floatquerytype,stringquery)sqlopenquery=#252;/* Part of FTE_SQL*/
void(floatserveridx,floatqueryidx)sqlclosequery=#253;/* Part of FTE_SQL*/
string(floatserveridx,floatqueryidx,floatrow,floatcolumn)sqlreadfield=#254;/* Part of FTE_SQL*/
string(floatserveridx,optionalfloatqueryidx)sqlerror=#255;/* Part of FTE_SQL*/
string(floatserveridx,stringdata)sqlescape=#256;/* Part of FTE_SQL*/
string(floatserveridx)sqlversion=#257;/* Part of FTE_SQL*/
float(floatserveridx,floatqueryidx,floatrow,floatcolumn)sqlreadfloat=#258;/* Part of FTE_SQL*/
float(floatskel,entityent,floatmodelindex,floatretainfrac,floatfirstbone,floatlastbone,optionalfloataddfrac)skel_build=#264;/* Part of FTE_CSQC_SKELETONOBJECTS
void(floatskel,floatstartbone,floatendbone,vectororg,optionalvectorfwd,optionalvectorright,optionalvectorup)skel_premul_bones=#273;/* Part of FTE_CSQC_SKELETONOBJECTS
void(floatmodidx,floatframenum,__inoutfloatbasetime,floattargettime,void(floattimestamp,intcode,stringdata)callback)processmodelevents=#0:processmodelevents;/* Part of FTE_GFX_MODELEVENTS
int(floatmodelid,vector*planes,float*dists,intnumplanes,int*out_brushes,int*out_faces,intmaxresults)brush_findinvolume=#0:brush_findinvolume;/* Part of FTE_RAW_MAP
void(stringimagename,intwidth,intheight,void*pixeldata,optionalintdatasize,optionalintformat)r_uploadimage=#0:r_uploadimage;/* Part of FTE_CSQC_RAWIMAGES
void(vectororg,stringmodelname,floatstartframe,floatendframe,floatframerate)effect=#404;/* Part of DP_SV_EFFECT
Spawnsaself-animatingsprite*/
void(vectororg,vectordir,floatcount)te_blood=#405;/* Part of DP_TE_BLOOD*/
void(vectormincorner,vectormaxcorner,floatexplosionspeed,floathowmany)te_bloodshower=#406;/* Part of _DP_TE_BLOODSHOWER*/
void(vectororg,vectorcolor)te_explosionrgb=#407;/* Part of DP_TE_EXPLOSIONRGB*/
void(vectormincorner,vectormaxcorner,vectorvel,floathowmany,floatcolor,floatgravityflag,floatrandomveljitter)te_particlecube=#408;/* Part of DP_TE_PARTICLECUBE*/
searchhandle(stringpattern,enumflags:float{SB_CASEINSENSITIVE=1<<0,SB_FULLPACKAGEPATH=1<<1,SB_ALLOWDUPES=1<<2,SB_FORCESEARCH=1<<3}flags,floatquiet,optionalstringfilterpackage)search_begin=#444;/* Part of DP_QC_FS_SEARCH, DP_QC_FS_SEARCH_PACKFILE
