#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_I18N /* Specifies that the engine uses $MODULE.dat.$LANG.po files that translates the dotranslate_* globals on load - these are usually created via the _("foo") qcc intrinsic. */
#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_SINCOSSQRTPOW
#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_STRFTIME
#define DP_QC_STRING_CASE_FUNCTIONS
#define DP_QC_STRINGBUFFERS
#define DP_QC_STRINGCOLORFUNCTIONS
#define DP_QC_STRREPLACE
#define DP_QC_TOKENIZEBYSEPARATOR
#define DP_QC_TRACEBOX
#define DP_QC_TRACETOSS
#define DP_QC_TRACE_MOVETYPE_HITMODEL
#define DP_QC_TRACE_MOVETYPE_WORLDONLY
#define DP_QC_TRACE_MOVETYPES
#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_CUSTOMIZEENTITYFORCLIENT /* Deprecated feature for compat with DP. Can be slow, incompatible with splitscreen, usually malfunctions with mvds. */
#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_HALFLIFE_MODELS
#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_RENDERTARGETS /* VF_RT_DESTCOLOUR exists and can be used to redirect any rendering to a texture instead of the screen. */
#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/foo.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_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_INTCONV /* Provides string<>int conversions, including hex representations. */
#define FTE_QC_MATCHCLIENTNAME
#define FTE_QC_MULTICAST /* QuakeWorld's multicast builtin works along with MSG_MULTICAST, but also with unicast support. */
#define FTE_QC_PAUSED
#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_QC_STUFFCMDFLAGS /* Variation on regular stuffcmd that gives control over how spectators/mvds should be treated. */
#define FTE_QC_TRACETRIGGER
#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 FTE_INFOBLOBS /* Removes the length limits on user/server/local info strings, and allows embedded nulls and other otherwise-reserved characters. This can be used to network avatar images and the like, or other binary data. */
#define FTE_VRINPUTS /* input_weapon, input_left_*, input_right_*, input_head_* work, both in csqc (as inputs with suitable plugin/hardware support) and ssqc (available in PlayerPreThink). */
#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 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. */
#ifdef _ACCESSORS
accessorstrbuf:float;
accessorsearchhandle:float;
accessorhashtable:float;
accessorinfostring:string;
accessorfilestream:float;
accessorfilestream:float;
#else
#define strbuf float
#define searchhandle float
#define hashtable float
#define infostring string
#define filestream float
#endif
entityself;/* The magic me */
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. */
floatcltime;/* A local timer that ticks relative to local time regardless of latency, packetloss, or pause. */
floatframetime;/* The time since the last physics/render/input frame. */
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. */
.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. */
.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. */
.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. */
.floatpmove_flags;
.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. */
.floatrenderflags;
.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. */
.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. */
.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;
.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. */
floattrace_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. */
.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. */
.inthitcontentsmaski;/* Traces performed for this entity will impact against surfaces that match this contents mask (CONTENTBITS_* constants). */
__deprecated("Does not support mod-specific contents.").floatdphitcontentsmask;/* Some crappy field that inefficiently requires translating to the native contents flags. Ditch the 'dp', do it properly. */
.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. */
.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. */
.floatdrawflags;/* Various flags that affect lighting values and scaling. Typically set to 96 in quake for proper compatibility with DP_QC_SCALE. */
.floatabslight;/* Allows overriding light levels. Use drawflags to state that this field should actually be used. */
.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. */
.floatpflags;/* Realtime lighting flags */
.floatframe3;/* Some people just don't understand how to use framegroups... */
.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(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(stringcmd)CSQC_ConsoleCommand;/* Called if the user uses any console command registed via registercommand. */
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
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. */
__usedvarfloatphysics_mode=2;/* 0: original csqc - physics are not run
1:DP-compat.Thinksoccur,butnottruemovetypes.
2:movetypesoccurjustastheydoinssqc.*/
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. */
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. */
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_BODY=0x02000000i;/* Content bit that indicates collisions against SOLID_BBOX/SOLID_SLIDEBOX entities. */
constintCONTENTBIT_CORPSE=0x04000000i;/* Content bit that indicates collisions against SOLID_CORPSE entities. */
constintCONTENTBIT_Q2LADDER=0x20000000i;/* Content bit specific to q2bsp (conflicts with q3bsp contents so use with caution). */
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. */
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;
constfloatSOUNDFLAG_ABSVOLUME=16;/* The sample's volume is not scaled by the volume cvar. Use with caution */
constfloatSOUNDFLAG_FORCELOOP=2;/* The sound will restart once it reaches the end of the sample. */
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. */
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. */
conststringINFOKEY_P_PING="ping";/* The player's ping time, in milliseconds. */
conststringINFOKEY_P_NAME="name";/* The player's name. */
conststringINFOKEY_P_SPECTATOR="*spectator";/* Whether the player is a spectator or not. */
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). */
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:
constfloatMOVE_WORLDONLY=3;/* The trace will ignore everything but the worldmodel. This is useful for to prevent the q3bsp pvs+culling issues that come with spectator modes leaving the world . */
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. */
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. */
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. */
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. */
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. */
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_NOCLAMP=4;/* Texture coords for the pic will not be clamped nor padded nor atlased. */
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_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;
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_MINDIST=23;/* The distance of the near clip plane from the view position. Should generally not be <=0, as this would introduce NANs. */
constfloatVF_MAXDIST=24;/* The distance of the far clip plane from the view position. If 0, will be considered infinite. */
constfloatVF_CL_VIEWANGLES=33;
constfloatVF_CL_VIEWANGLES_X=34;
constfloatVF_CL_VIEWANGLES_Y=35;
constfloatVF_CL_VIEWANGLES_Z=36;
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. */
#define VF_LPLAYER VF_ACTIVESEAT
constfloatVF_ACTIVESEAT=202;/* The 'seat' number, used when running splitscreen. */
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). */
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. */
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. */
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). */
constfloatVF_PROJECTIONOFFSET=224;/* vec2 horizontal+vertical offset for the projection matrix, for weird off-centre rendering. */
constfloatDRAWFLAG_NORMAL=0;/* Args for drawpic/drawfill/beginpolygon. Not to be confused with the hexen2-compatibility feature. */
constfloatDRAWFLAG_ADD=1;/* Forces additive blending, overriding any shader settings. */
constfloatDRAWFLAG_MODULATE=2;/* Forces alpha blending, overriding any shader settings. */
constfloatDRAWFLAG_2D=4;/* For use with beginpolygon. The polygon will be drawn to the 2d screen, instead of being added to the 3d scene. */
constfloatDRAWFLAG_TWOSIDED=1024;/* For use with beginpolygon. The polygon will be two-sided without any backface culling. */
constfloatDRAWFLAG_LINES=2048;/* For use with beginpolygon. The surface verticies should be interpreted as a line loop, instead of a triangle fan. */
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. */
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. */
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=5;/* A semi-colon delimited list of gamedirs that the mod's content can be loaded through. */
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. */
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. */
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. */
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(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
float(floatmodidx,floatframenum,__inoutfloatbasetime,floattargettime,__outintcode,__outstringdata)getnextmodelevent=#0:getnextmodelevent;/* Part of FTE_GFX_MODELEVENTS
float(floatmodidx,floatframenum,inteventidx,__outfloattimestamp,__outintcode,__outstringdata)getmodeleventidx=#0:getmodeleventidx;/* 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(entityent,floatbonenum,vectororg,optionalvectorangorfwd,optionalvectorright,optionalvectorup)skel_set_bone_world=#283;/* Part of FTE_QC_RAGDOLL_WIP
void(stringimagename,intwidth,intheight,void*pixeldata,optionalintdatasize,optionalintformat)r_uploadimage=#0:r_uploadimage;/* Part of FTE_CSQC_RAWIMAGES
entity(entityfrom,optionalentityto)copyentity=#400;/* Part of DP_QC_COPYENTITY
Copiesallfieldsfromoneentitytoanother.*/
entity(.stringfield,stringmatch,optional.entitychainfield)findchain=#402;/* Part of DP_QC_FINDCHAIN*/
entity(.floatfld,floatmatch,optional.entitychainfield)findchainfloat=#403;/* Part of DP_QC_FINDCHAINFLOAT*/
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*/
void(vectormincorner,vectormaxcorner,vectorvel,floathowmany,floatcolor)te_particlerain=#409;/* Part of DP_TE_PARTICLERAIN*/
void(vectormincorner,vectormaxcorner,vectorvel,floathowmany,floatcolor)te_particlesnow=#410;/* Part of DP_TE_PARTICLESNOW*/
void(vectororg,vectorvel,floathowmany)te_spark=#411;/* Part of DP_TE_SPARK*/
void(vectororg)te_gunshotquad=#412;/* Part of _DP_TE_QUADEFFECTS1*/
void(vectororg)te_spikequad=#413;/* Part of _DP_TE_QUADEFFECTS1*/
void(vectororg)te_superspikequad=#414;/* Part of _DP_TE_QUADEFFECTS1*/
void(vectororg)te_explosionquad=#415;/* Part of _DP_TE_QUADEFFECTS1*/
void(vectororg)te_smallflash=#416;/* Part of DP_TE_SMALLFLASH*/
void(vectororg,floatradius,floatlifetime,vectorcolor)te_customflash=#417;/* Part of DP_TE_CUSTOMFLASH*/
void(vectororg,optionalfloatcount)te_gunshot=#418;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_spike=#419;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_superspike=#420;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_explosion=#421;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_tarexplosion=#422;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_wizspike=#423;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_knightspike=#424;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_lavasplash=#425;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg)te_teleport=#426;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(vectororg,floatcolor,floatcolorlength)te_explosion2=#427;/* Part of DP_TE_STANDARDEFFECTBUILTINS*/
void(entityown,vectorstart,vectorend)te_lightning1=#428;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(entityown,vectorstart,vectorend)te_lightning2=#429;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(entityown,vectorstart,vectorend)te_lightning3=#430;/* Part of DP_TE_STANDARDEFFECTBUILTINS, FTE_TE_STANDARDEFFECTBUILTINS*/
void(entityown,vectorstart,vectorend)te_beam=#431;/* Part of DP_TE_STANDARDEFFECTBUILTINS*/
void(vectordir)vectorvectors=#432;/* Part of DP_QC_VECTORVECTORS*/
void(vectororg)te_plasmaburn=#433;/* Part of _DP_TE_PLASMABURN*/
float(entitye,floats)getsurfacenumpoints=#434;/* Part of DP_QC_GETSURFACE*/
vector(entitye,floats,floatn)getsurfacepoint=#435;/* Part of DP_QC_GETSURFACE*/
vector(entitye,floats)getsurfacenormal=#436;/* Part of DP_QC_GETSURFACE*/
string(entitye,floats)getsurfacetexture=#437;/* Part of DP_QC_GETSURFACE*/
float(entitye,vectorp)getsurfacenearpoint=#438;/* Part of DP_QC_GETSURFACE*/
vector(entitye,floats,vectorp)getsurfaceclippedpoint=#439;/* Part of DP_QC_GETSURFACE*/
float(strings)tokenize=#441;/* Part of KRIMZON_SV_PARSECLIENTCOMMAND*/
string(floatn)argv=#442;/* Part of KRIMZON_SV_PARSECLIENTCOMMAND*/
void(entitye,entitytagentity,stringtagname)setattachment=#443;/* Part of DP_GFX_QUAKE3MODELTAGS*/
searchhandle(stringpattern,enumflags:float{SB_CASEINSENSITIVE=1<<0,SB_FULLPACKAGEPATH=1<<1,SB_ALLOWDUPES=1<<2,SB_FORCESEARCH=1<<3,SB_MULTISEARCH=1<<4}flags,floatquiet,optionalstringfilterpackage)search_begin=#444;/* Part of DP_QC_FS_SEARCH, DP_QC_FS_SEARCH_PACKFILE
