Click the link to download the current page: Download
| Function Name | Description | Where | Example | Type | Engine |
|---|---|---|---|---|---|
| spawn | Creates a new entity. | Server | entity e = spawn(); | entity | WinQuake, DarkPlaces, FTE |
| remove | Removes (deletes) an entity from the world. | Server | remove(self); | entity | WinQuake, DarkPlaces, FTE |
| copyentity | Copies all data in the entity to another entity.. | Server | copyentity(from, to); | entity | DarkPlaces, FTE |
| setorigin | Sets an entity's position. | Server | setorigin(self, '0 0 0'); | entity | WinQuake, DarkPlaces, FTE |
| setmodel | Assigns a model to an entity. | Server | setmodel(self, "progs/player.mdl"); | file | WinQuake, DarkPlaces, FTE |
| setsize | Sets the bounding box size of an entity. | Server | setsize(self, mins, maxs); | entity | WinQuake, DarkPlaces, FTE |
| setcolor | Sets the color on a client and updates internal color information accordingly (equivalent to stuffing a "color" command but immediate). | Server | selfcolor('1 0 0'); | visual | WinQuake, DarkPlaces, FTE |
| setattachment | Attachs e to a tag on tagentity (note: use "" to attach to entity origin/angles instead of a tag). | Server | setattachment(child, parent); | entity | DarkPlaces, FTE |
| movetogoal | Moves entity toward goal entity. | Server | movetogoal(self, dist); | ai | WinQuake, DarkPlaces, FTE |
| changepitch | Changes entity's pitch toward goal. | Server | changepitch(); | ai | DarkPlaces, FTE |
| ChangeYaw | Change the horizontal orientation of self. Turns towards self.ideal_yaw at self.yaw_speed, and sets the global variable current_yaw. | Server | ChangeYaw(); | ai | WinQuake, DarkPlaces, FTE |
| walkmove | Moves self in the given direction. Returns FALSE if could not move (used to detect blocked monsters). | Server | walkmove(self.angles_y, speed); | ai | WinQuake, DarkPlaces, FTE |
| droptofloor | Drops self to the floor, if the floor is less than -256 coordinates below. Returns TRUE if landed on floor. | Server | droptofloor(); | physics | WinQuake, DarkPlaces, FTE |
| checkbottom | Rturns TRUE if on the ground. Used only for jumping monsters that need to jump randomly not to get hung up. | Server | checkbottom(self); | physics | DarkPlaces, FTE |
| clienttype | Returns type of connected client. | Server | clienttype(self); | network | WinQuake, DarkPlaces, FTE |
| dropclient | Disconnects client from server. | Server | dropclient(self); | network | WinQuake, DarkPlaces, FTE |
| spawnclient | Like spawn, but for client slots (also calls relevant connect/spawn functions), returns world if no clients available. | Server | spawnclient(); | network | WinQuake, DarkPlaces, FTE |
| checkclient | Returns client (or object that has a client enemy) that would be a valid target. If there are more than one valid options, they are cycled each frame. If (self.origin + self.viewofs) is not in the PVS of the target, 0 (FALSE) is returned. | Server | checkclient(); | ai | WinQuake, DarkPlaces, FTE |
| aim | Returns a vector along which the entity e can shoot. Usually, e is a player, and the vector returned is calculated by auto aiming to the closest enemy entity. | Server | aim(e, missilespeed); | ai | WinQuake, DarkPlaces, FTE |
| entityfieldname | Returns the name as a string, eg. "origin" or "classname" or whatever. | Server | entityfieldname(ent, fieldIndex); | entity | DarkPlaces, FTE |
| entityfieldtype | Returns a value that the constants represent, but the field may be of another type in more exotic progs.dat formats or compilers.. | Server | entityfieldtype(ent, fieldIndex); | entity | DarkPlaces, FTE |
| putentityfieldstring | Puts the data returned by getentityfieldstring back into the entity. | Server | putentityfieldstring(ent, fieldName, "value"); | entity | DarkPlaces, FTE |
| getentityfieldstring | Returns data as would be written to a savegame, eg... "0.05" (float), "0 0 1" (vector), or "Hello World!" (string). Function names can also be returned. | Server | getentityfieldstring(ent, fieldName); | entity | DarkPlaces, FTE |
| wasfreed | Returns whether an entity slot is currently free (removed). | Server | wasfreed(ent); | debug | DarkPlaces, FTE |
| edict_num | Returns the entity corresponding to a given number, this works even for freed entities, but you should call wasfreed(ent) to see if is currently active. | Server | edict_num(entnum); | entity | DarkPlaces, FTE |
| num_for_edict | Returns the number of an entity. | Server | num_for_edict(num); | entity | DarkPlaces, FTE |
| getextresponse | Gets a response from engine extension. | Server | getextresponse("key"); | engine | DarkPlaces, FTE |
| makestatic | Make an entity static to the world, by sending a broadcast message to the network. The entity is then removed from the list of dynamic entities in the world, and it cannot be deleted (until the level ends). | Server | makestatic(ent); | entity | WinQuake, DarkPlaces, FTE |
| nextent | Returns entity that is just after e in the entity list. Useful to browse the list of entities, because it skips the undefined ones. | Server | nextent(e); | entity | DarkPlaces, FTE |
| crash | Intentionally crashes (debug). | Menu | crash(); | debug | DarkPlaces, FTE |
| stackdump | Prints current stack trace. | Menu | stackdump(); | debug | DarkPlaces, FTE |
| clientstate | Returns the state of a client. | Menu | clientstate(self); | network | DarkPlaces, FTE |
| clientcount | Returns number of connected clients. | Menu | clientcount(); | network | DarkPlaces, FTE |
| traceline | Performs a line trace (raycast). | Server | traceline(start, end, FALSE, self); | physics | WinQuake, DarkPlaces, FTE |
| tracebox | Similar to traceline but much more useful, traces a box of the size specified (technical note: in quake1 and halflife bsp maps the mins and maxs will be rounded up to one of the hull sizes, quake3 bsp does not have this problem, this is the case with normal moving entities as well). | Server | tracebox(start, end, mins, maxs, self); | physics | DarkPlaces, FTE |
| tracetoss | Simulates movement of the entity as if it is MOVETYPE_TOSS and starting with it's current state (location, velocity, etc). | Server, Client | TraceToss(self, goal); | physics | DarkPlaces, FTE |
| pointcontents | Returns the contents of the area situated at position pos. Used to know if an area is in water, in slime or in lava. Makes use of the BSP tree, and is supposed to be very fast. | Server | pointcontents(self.origin); | physics | WinQuake, DarkPlaces, FTE |
| checkpvs | Returns true if viewee can be seen from viewpos according to PVS data. | Server | checkpvs(vec_viewpos, viewe_ent); | physics | DarkPlaces, FTE |
| movetypesteplandevent | This field function, when provided, is triggered on a MOVETYPE_STEP entity when it experiences "land event". | Server | movetypesteplandevent(self); | physics | DarkPlaces, FTE |
| contentstransition | Handles transition between content types. | Server | contentstransition(ent); | physics | DarkPlaces, FTE |
| sin | Sine of angle in degrees. | Server | sin(90); | math | DarkPlaces, FTE |
| cos | Cosine of angle in degrees. | Server | cos(0); | math | DarkPlaces, FTE |
| sqrt | Square root of a number. | Server | sqrt(4); | math | DarkPlaces, FTE |
| fabs | Returns absolute value of val (like the equivalent function in C). | Server | fabs(-1.5); | math | DarkPlaces, FTE |
| floor | Returns val, rounded up to the integer below (like the equivalent function in C). | Server | floor(1.8); | math | DarkPlaces, FTE |
| ceil | Returns val, rounded up to the integer above (like the equivalent function in C). | Server | ceil(1.2); | math | DarkPlaces, FTE |
| rint | Rounds to nearest int. | Server | rint(1.6); | math | DarkPlaces, FTE |
| pow | Raises to power. | Server | pow(2, 3); | math | DarkPlaces, FTE |
| min | Returns the lowest of all the supplied numbers. | Server | min(1, 2, ...); | math | DarkPlaces, FTE |
| max | Returns the highest of all the supplied numbers. | Server | max(1, 2, ...); | math | DarkPlaces, FTE |
| log | Natural logarithm. | Server | log(10); | math | DarkPlaces, FTE |
| mod | Modulus operation. | Server | mod(10, 3); | math | DarkPlaces, FTE |
| bound | Clamps the value to the range and returns it. | Server | bound(min, val, max); | math | DarkPlaces, FTE |
| random | Returns random float (0-1). | Server | random(); | math | WinQuake, DarkPlaces, FTE |
| randomvec | Returns a vector of length < 1, much quicker version of this QC. | Server | randomvec(); | math | DarkPlaces, FTE |
| bitshift | Multiplies number by a power of 2 corresponding to quantity (0 = *1, 1 = *2, 2 = *4, 3 = *8, -1 = /2, -2 = /4x, etc), and rounds down (due to integer math) like other bit operations do (& and | and the like). | Server | bitshift(1, 2); | math | DarkPlaces, FTE |
| normalize | Returns a vector of length 1. | Server | normalize(v); | math | DarkPlaces, FTE |
| vlen | Returns vector length. | Server | vlen(v); | math | DarkPlaces, FTE |
| vectoyaw | Returns an angle in degrees. Vector to yaw: calculates the yaw angle (bearing) corresponding to a given 3D direction. | Server | vectoyaw(v); | math | DarkPlaces, FTE |
| vectoangles | Vector to angles: calculates the pitch angle (aiming) and yaw angle (bearing) corresponding to a given 3D direction. | Server | vectoangles(v); | math | DarkPlaces, FTE |
| vectoangles2 | Variant of vectoangles that takes an up vector to calculate roll angle (also uses this to calculate yaw correctly if the forward is straight up or straight down). | Server | vectoangles2(forward, up); | math | DarkPlaces, FTE |
| vectorvectors | Creates v_forward, v_right, and v_up vectors given a forward vector, similar to makevectors except it takes a forward direction vector instead of angles. | Server | vectorvectors(dir); | math | DarkPlaces, FTE |
| makevectors | Calculates v_forward/v_right/v_up from angles. | Server | makevectors(self.angles); | math | DarkPlaces, FTE |
| setorigin | Sets an entity's position. | Server | setorigin(self, pos); | math | DarkPlaces, FTE |
| crc16 | Some hash function to build hash tables with. This has to be be the CRC-16-CCITT that is also required for the QuakeWorld download protocol. | Server | crc16(caseinsensitive, str, ...); | hash | DarkPlaces, FTE |
| asin | Returns angle in radians for a given sin() value, the result is in the range -PI*0.5 to PI*0.5 | Server | asin(0.5); | math | DarkPlaces, FTE |
| acos | Returns angle in radians for a given cos() value, the result is in the range 0 to PI. | Server | acos(0.5); | math | DarkPlaces, FTE |
| atan | Returns angle in radians for a given tan() value, the result is in the range -PI*0.5 to PI*0.5. | Server | atan(1); | math | DarkPlaces, FTE |
| atan2 | Returns angle in radians for a given cos() and sin() value pair, the result is in the range -PI to PI (this is identical to vectoyaw except it returns radians rather than degrees). | Server | atan2(y, x); | math | DarkPlaces, FTE |
| tan | Returns tangent value (which is simply sin(a)/cos(a)) for the given angle in radians, the result is in the range -infinity to +infinity | Server | tan(45); | math | DarkPlaces, FTE |
| digest_hex | Returns a given hex digest of given data. | Server | digest_hex("MD4", "data", ...); | hash | DarkPlaces, FTE |
| strlen | Returns length of string. | Server | strlen("text"); | string | DarkPlaces, FTE |
| strcat | Concatenates strings. | Server | strcat("a", "b"); | string | DarkPlaces, FTE |
| substring | Returns a section of a string as a tempstring - see FTE_STRINGS for enhanced version. | Server | substring("abc", 1, 1); | string | DarkPlaces, FTE |
| sprintf | Formats string with values. | Server | sprintf("x = %d", 5); | string | DarkPlaces, FTE |
| strlennocol | String length without color codes. | Server | strlennocol("^1Red"); | string | DarkPlaces, FTE |
| strdecolorize | Removes color codes from string. | Server | strdecolorize("^1Red"); | string | DarkPlaces, FTE |
| strtolower | Converts string to lowercase. | Server | strtolower("ABC"); | string | DarkPlaces, FTE |
| strtoupper | Converts string to uppercase. | Server | strtoupper("abc"); | string | DarkPlaces, FTE |
| strstrofs | Finds offset of substring. | Server | strstrofs("abc", "b", 0); | string | DarkPlaces, FTE |
| str2chr | Gets character from string. | Server | str2chr("abc", 0); | string | DarkPlaces, FTE |
| chr2str | Converts character code to string. | Server | chr2str(65); | string | DarkPlaces, FTE |
| strconv | Converts value to string. | Server | strconv(123); | string | DarkPlaces, FTE |
| strpad | Pads a string to desired length. | Server | strpad("x", 4, "0", 0); | string | DarkPlaces, FTE |
| strreplace | Replaces substrings. | Server | strreplace("abc", "b", "x"); | string | DarkPlaces, FTE |
| strireplace | Case-insensitive replace. | Server | strireplace("abc", "B", "x"); | string | DarkPlaces, FTE |
| strcmp | Compares two strings. | Server | strcmp("a", "b"); | string | DarkPlaces, FTE |
| strncmp | Compares up to N characters. | Server | strncmp("abc", "abd", 2); | string | DarkPlaces, FTE |
| strcasecmp | Case-insensitive string compare. | Server | strcasecmp("abc", "ABC"); | string | DarkPlaces, FTE |
| strncasecmp | Case-insensitive compare up to N characters. | Server | strncasecmp("abc", "ABC", 3); | string | DarkPlaces, FTE |
| strftime | Formats timestamp. | Server | strftime(time, "%Y-%m-%d"); | string | DarkPlaces, FTE |
| strzone | Duplicates string to memory zone. | Server | strzone("text"); | string | DarkPlaces, FTE |
| strunzone | Frees zoned string. | Server | strunzone(str); | string | DarkPlaces, FTE |
| chr | Returns ASCII code of character. | Server | chr("A"); | string | DarkPlaces, FTE |
| buf_create | Creates a new buffer. | Server | buf_create(); | string | DarkPlaces, FTE |
| buf_del | Deletes a buffer. | Server | buf_del(buf); | string | DarkPlaces, FTE |
| buf_getsize | Returns buffer size. | Server | buf_getsize(buf); | string | DarkPlaces, FTE |
| buf_copy | Copies one buffer to another. | Server | buf_copy(src, dest); | string | DarkPlaces, FTE |
| buf_sort | Sorts buffer content. | Server | buf_sort(buf, sortpower, backward); | string | DarkPlaces, FTE |
| buf_implode | Joins buffer elements into string. | Server | buf_implode(buf, ","); | string | DarkPlaces, FTE |
| bufstr_get | Gets string from buffer. | Server | bufstr_get(buf, index); | string | DarkPlaces, FTE |
| bufstr_set | Sets buffer string at index. | Server | bufstr_set(buf, index, "val"); | string | DarkPlaces, FTE |
| bufstr_add | Adds string to buffer. | Server | bufstr_add(buf, "val", order); | string | DarkPlaces, FTE |
| bufstr_free | Frees buffer string memory. | Server | bufstr_free(buf, string_index); | string | DarkPlaces, FTE |
| buf_cvarlist | Functions to list cvars and store their names into a stringbuffer cvars that start with pattern but not with antipattern will be stored into the buffer. | Server | buf_cvarlist(buf, pattern, antipattern); | string | DarkPlaces, FTE |
| buf_loadfile | Append each line of file as new buffer string, return 1 if succesful. | Server | buf_loadfile("file.txt", buf); | file | DarkPlaces, FTE |
| buf_writefile | Writes buffer strings as lines, returns 1 if succesful | Server | buf_writefile(file_handle, buf_handle, startpos, numstrings); | file | DarkPlaces, FTE |
| bufstr_find | Returns string index. | Server | bufstr_find(buf, "needle", matchrule, startpos, step); | string | DarkPlaces, FTE |
| matchpattern | Pattern match test. | Server | matchpattern("text", "t*", matchrule); | string | DarkPlaces, FTE |
| matchpatternofs | Pattern match at offset. | Server | matchpatternofs("text", "t*", matchrule, 1); | string | DarkPlaces, FTE |
| stuffcmd | Send a command to a given player, as if it had been typed on the player's console. | Server | stuffcmd(self, "cmd"); | cvar | DarkPlaces, FTE |
| localcmd | Execute a command on the server, as if it had been typed on the server's console. | Server | localcmd("sv_gravity 800\n"); | cvar | DarkPlaces, FTE |
| centerprint | Sends center print to client. | Server | centerprint(self, "Hello"); | DarkPlaces, FTE | |
| bprint | Broadcast a message to all players on the current server. | Server | bprint("Hello all"); | DarkPlaces, FTE | |
| sprint | Single client print. | Server | sprint(self, "Hi"); | DarkPlaces, FTE | |
| dprint | Debug print. | Server | dprint("Debug info"); | debug | DarkPlaces, FTE |
| eprint | Print details about a given entity (for debug purposes). | Server | eprint(self); | debug | DarkPlaces, FTE |
| Generic print. | Server | print("message"); | DarkPlaces, FTE | ||
| registercommand | Registers new command. | Server | registercommand("mycmd"); | cvar | DarkPlaces, FTE |
| registercvar | Adds a new console cvar to the server console (in singleplayer this is the player's console), the cvar exists until the mod is unloaded or the game quits. | Server | registercvar("sv_test", "1"); | cvar | DarkPlaces, FTE |
| cvar | Gets cvar value. | Server | cvar("sv_gravity"); | cvar | DarkPlaces, FTE |
| cvar_set | Sets cvar value. | Server | cvar_set("sv_gravity", "800"); | cvar | DarkPlaces, FTE |
| cvar_defstring | Returns the default value of a cvar, as a tempstring. | Server | cvar_defstring("name"); | cvar | DarkPlaces, FTE |
| cvar_description | Returns the description of a cvar. | Server | cvar_description("name"); | cvar | DarkPlaces, FTE |
| cvar_string | Returns the value of a cvar, as a tempstring. | Server | cvar_string("name"); | cvar | DarkPlaces, FTE |
| cvar_type | Gets cvar type (exists, saved, private, engine, hasdescription, readonly). | Server | cvar_type("name"); | cvar | DarkPlaces, FTE |
| str_cvar | Gets string value of a cvar. | Server | str_cvar("sv_gravity"); | cvar | DarkPlaces, FTE |
| tokenizebyseparator | This function returns tokens separated by any of the supplied separator strings. | Server | tokenizebyseparator("a,b", ","); | string | DarkPlaces, FTE |
| tokenize_console | This function returns tokens separated just like the console does. | Server | tokenize_console(str); | cvar | DarkPlaces, FTE |
| argv_start_index | Returns the index of the first character of each token in the original string. | Server | argv_start_index(i); | cvar | DarkPlaces, FTE |
| argv_end_index | Returns the index of the last character of each token in the original string. | Server | argv_end_index(i); | cvar | DarkPlaces, FTE |
| addstat | Sets stat index for client. | Server | addstat(1, value); | engine | DarkPlaces, FTE |
| setpause | Pauses the game. | Server | setpause(TRUE); | cvar | DarkPlaces, FTE |
| coverage | Returns code coverage percent. | Server | coverage(); | debug | DarkPlaces, FTE |
| clientcommand | Sends command to client. | Server | clientcommand(self, "say hi"); | cvar | DarkPlaces, FTE |
| tokenize | Splits string into tokens. | Server | tokenize("one two"); | string | DarkPlaces, FTE |
| argv | Gets argument from tokenized input. | Server | argv(0); | cvar | DarkPlaces, FTE |
| cmd | Gets the input command name. | Server | cmd(); | cvar | DarkPlaces, FTE |
| fopen | Opens a file inside quake/gamedir/data/ (mode is FILE_READ, FILE_APPEND, or FILE_WRITE), returns fhandle >= 0 if successful, or fhandle < 0 if unable to open file for any reason. | Server | fopen("data.txt", "r"); | file | DarkPlaces, FTE |
| fclose | Closes an open file handle. | Server | fclose(f); | file | DarkPlaces, FTE |
| fgets | Reads a line of text from the file and returns as a tempstring. | Server | fgets(f); | file | DarkPlaces, FTE |
| fputs | Writes a string to file. | Server | fputs(f, "text"); | file | DarkPlaces, FTE |
| fcopy | Copies one file to another. | Server | fcopy("a.txt", "b.txt"); | file | Wrath DarkPlaces, FTE |
| frename | Renames a file. | Server | frename("old.txt", "new.txt"); | file | Wrath DarkPlaces, FTE |
| fremove | Deletes a file. | Server | fremove("file.txt"); | file | Wrath DarkPlaces, FTE |
| fexists | Checks if a file exists. | Server | fexists("data.txt"); | file | Wrath DarkPlaces, FTE |
| rmtree | Deletes directory and contents. | Server | rmtree("folder"); | file | Wrath DarkPlaces, FTE |
| loadfromdata | Loads entity from string. | Server | loadfromdata(ent, data); | entity | DarkPlaces, FTE |
| loadfromfile | Loads entity from file. | Server | loadfromfile(ent, "state.dat"); | entity | DarkPlaces, FTE |
| writetofile | Writes entity to file. | Server | writetofile(ent, "state.dat"); | entity | DarkPlaces, FTE |
| sound | Plays sound on an entity. | Server | sound(self, CHAN_BODY, "weapons/shot.wav", 1, ATTN_NORM); | sound | DarkPlaces, FTE |
| precache_sound | Preloads a sound file. | Server | precache_sound("misc/hit.wav"); | sound | DarkPlaces, FTE |
| precache_sound2 | Same as precache_sound, but only for registered Quake. | Server | precache_sound2("sound.wav", 1); | sound | DarkPlaces, FTE |
| ambientsound | An ambient sound is emitted, from the given position. | Server | ambientsound(self.origin, "ambience/drip1.wav", 0.5, ATTN_STATIC); | sound | DarkPlaces, FTE |
| sound7 | Advanced sound function. | Server | sound7(self, CHAN_AUTO, "sound.wav", 1, ATTN_NORM, 0, 0); | sound | DarkPlaces, FTE |
| getsoundtime | Get currently sound playing position on entity channel, -1 if not playing or error. | Server | getsoundtime("sound.wav"); | sound | DarkPlaces, FTE |
| soundlength | Returns length of sound sample in seconds, -1 on error (sound not precached, sound system not initialized, etc). | Server | soundlength("sound.wav"); | sound | DarkPlaces, FTE |
| pointsound | Plays sound at position. | Server, Client | pointsound("sound.wav", '0 0 0'); | sound | DarkPlaces, FTE |
| localsound | Plays sound locally. | Menu | localsound("misc/menu.wav"); | sound | DarkPlaces, FTE |
| pointparticles | Spawns particles at point. | Server | pointparticles(effectnum, origin); | particle | DarkPlaces, FTE |
| trailparticles | Spawns trail particles. | Server, Client | trailparticles(entity, effectnum, start, end); | particle | DarkPlaces, FTE |
| particle | Creates basic particle effect. | Server | particle(origin, velocity, color, alpha, scale); | particle | DarkPlaces, FTE |
| particleeffectnum | Gets numeric ID of particle effect. | Server | particleeffectnum("effectname"); | particle | DarkPlaces, FTE |
| effect | Triggers particle effect. | Server | effect(num, origin); | effect | DarkPlaces, FTE |
| te_blood | Blood spray effect. | Server | te_blood(origin, velocity, howmany); | effect | DarkPlaces, FTE |
| te_bloodshower | Creates an exploding shower of blood, for making gibbings more convincing. | Server | te_bloodshower(vec_min, vec_max, speed, howmany); | effect | DarkPlaces, FTE |
| te_customflash | Creates a customized light flash. | Server | te_customflash(origin, radius, lifetime, color); | effect | DarkPlaces, FTE |
| te_explosionrgb | Colored explosion effect. | Server | te_explosionrgb(origin, rgb); | effect | DarkPlaces, FTE |
| te_flamejet | Creates a single puff of flame particles. | Server | te_flamejet(origin, velocity, howmany); | effect | DarkPlaces, FTE |
| te_particlecube | Creates a cloud of particles, useful for forcefields but quite customizable. | Server | te_particlecube(v_min, v_max, vel, howmany, color, gravityflag, randomveljitter); | effect | DarkPlaces, FTE |
| te_particlerain | Rain particle effect. | Server | te_particlerain(mins, maxs, vel, howmany, color); | effect | DarkPlaces, FTE |
| te_particlesnow | Snow particle effect. | Server | te_particlesnow(mins, maxs, vel, howmany, color); | effect | DarkPlaces, FTE |
| te_plasmaburn | Plasma burn effect. | Server | te_plasmaburn(origin); | effect | DarkPlaces, FTE |
| te_gunshotquad | Quad gunshot effect. | Server | te_gunshotquad(origin); | effect | DarkPlaces, FTE |
| te_spikequad | Quad spike impact effect. | Server | te_spikequad(origin); | effect | DarkPlaces, FTE |
| te_superspikequad | Quad superspike effect. | Server | te_superspikequad(origin); | effect | DarkPlaces, FTE |
| te_explosionquad | Quad explosion effect. | Server | te_explosionquad(origin); | effect | DarkPlaces, FTE |
| te_smallflash | Small flash effect. | Server | te_smallflash(origin); | effect | DarkPlaces, FTE |
| te_spark | Spark effect. | Server | te_spark(origin, velocity, howmany); | effect | DarkPlaces, FTE |
| te_gunshot | Gunshot effect. | Server | te_gunshot(origin); | effect | DarkPlaces, FTE |
| te_spike | Spike impact effect. | Server | te_spike(origin); | effect | DarkPlaces, FTE |
| te_superspike | Superspike impact effect. | Server | te_superspike(origin); | effect | DarkPlaces, FTE |
| te_explosion | Standard explosion effect. | Server | te_explosion(origin); | effect | DarkPlaces, FTE |
| te_tarexplosion | TAR explosion effect. | Server | te_tarexplosion(origin); | effect | DarkPlaces, FTE |
| te_wizspike | Wizard spike effect. | Server | te_wizspike(origin); | effect | DarkPlaces, FTE |
| te_knightspike | Knight spike effect. | Server | te_knightspike(origin); | effect | DarkPlaces, FTE |
| te_lavasplash | Lava splash effect. | Server | te_lavasplash(origin); | effect | DarkPlaces, FTE |
| te_teleport | Teleport flash effect. | Server | te_teleport(origin); | effect | DarkPlaces, FTE |
| te_explosion2 | Alternate explosion effect. | Server | te_explosion2(origin, color, colorlength); | effect | DarkPlaces, FTE |
| te_lightning1 | Lightning bolt type 1. | Server | te_lightning1(owner_ent, start, end); | effect | DarkPlaces, FTE |
| te_lightning2 | Lightning bolt type 2. | Server | te_lightning2(owner_ent, start, end); | effect | DarkPlaces, FTE |
| te_lightning3 | Lightning bolt type 3. | Server | te_lightning3(owner_ent, start, end); | effect | DarkPlaces, FTE |
| te_beam | Draws a beam effect. | Server | te_beam(owner_ent, start, end); | effect | DarkPlaces, FTE |
| skel_create | Create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex, as the skeleton uses the hierarchy from the model. | Server | skel_create(modlindex); | skeleton | DarkPlaces, FTE |
| skel_build | Blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure. | Server | skel_build(skel, ent, modlindex, retainfrac, firstbone, lastbone); | skeleton | DarkPlaces, FTE |
| skel_get_numbones | Returns how many bones exist in the created skeleton, 0 if skeleton does not exist. | Server | skel_get_numbones(skel); | skeleton | DarkPlaces, FTE |
| skel_get_bonename | Returns name of bone (as a tempstring), "" if invalid bonenum (< 1 for example) or skeleton does not exist. | Server | skel_get_bonename(skel, index); | skeleton | DarkPlaces, FTE |
| skel_get_boneparent | Returns parent num for supplied bonenum, 0 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this). | Server | skel_get_boneparent(skel, bonenum); | skeleton | DarkPlaces, FTE |
| skel_find_bone | Get number of bone with specified name, 0 on failure, bonenum (1-based) on success, same as using gettagindex but takes modelindex instead of entity. | Server | skel_find_bone(skel, "Bone"); | skeleton | DarkPlaces, FTE |
| skel_get_bonerel | Get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone). | Server | skel_get_bonerel(skel, bonenum); | skeleton | DarkPlaces, FTE |
| skel_get_boneabs | Get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity). | Server | skel_get_boneabs(skel, bonenum); | skeleton | DarkPlaces, FTE |
| skel_set_bone | Set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone). | Server | skel_set_bone(skel, bonenum, org); | skeleton | DarkPlaces, FTE |
| skel_mul_bone | Transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone). | Server | skel_mul_bone(skel, bonenum, org); | skeleton | DarkPlaces, FTE |
| skel_mul_bones | Transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones). | Server | skel_mul_bones(skel, startbone, endbone, org); | skeleton | DarkPlaces, FTE |
| skel_copybones | Copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse | Server | skel_copybones(skeldst, skelsrc, startbone, endbone); | skeleton | DarkPlaces, FTE |
| skel_delete | Deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work). | Server | skel_delete(skel); | skeleton | DarkPlaces, FTE |
| frameforname | Finds number of a specified frame in the animation, returns -1 if no match found. | Server | frameforname(modlindex, "idle"); | skeleton | DarkPlaces, FTE |
| frameduration | Returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0. | Server | frameduration(modlindex, framenum); | skeleton | DarkPlaces, FTE |
| WriteByte | Writes a byte to the message buffer. | Server | WriteByte(client, 255); | network | DarkPlaces, FTE |
| WriteChar | Writes a character to the message buffer. | Server | WriteChar(client, 'A'); | network | DarkPlaces, FTE |
| WriteShort | Writes a short integer to the buffer. | Server | WriteShort(client, 300); | network | DarkPlaces, FTE |
| WriteLong | Writes a long integer to the buffer. | Server | WriteLong(client, 65536); | network | DarkPlaces, FTE |
| WriteCoord | Writes a coordinate (float) to the buffer. | Server | WriteCoord(client, self.origin_x); | network | DarkPlaces, FTE |
| WriteAngle | This function writes a single byte, that represents 256 * (angle / 380). | Server | WriteAngle(client, self.angles_y); | network | DarkPlaces, FTE |
| WriteString | Writes a null-terminated string. | Server | WriteString(client, "hello\n"); | network | DarkPlaces, FTE |
| WriteUnterminatedString | Writes a string without null-termination. | Server | WriteUnterminatedString(client, "hi"); | network | DarkPlaces, FTE |
| WriteEntity | This function writes an entity reference, taking two bytes. | Server | WriteEntity(client, self); | network | DarkPlaces, FTE |
| WriteFloat | Writes a float value. | Server | WriteFloat(client, 1.23); | network | DarkPlaces, FTE |
| WritePicture | Writes an image to a client. | Server | WritePicture(client, "img.tga", size); | file | DarkPlaces, FTE |
| SendEntity | Sends entity state over network. | Server | SendEntity(self); | network | DarkPlaces, FTE |
| etos | Prints "entity 1" or similar into a string. (this was a Q2 builtin). | Server | etos(self); | conversion | DarkPlaces, FTE |
| stof | Get numerical value from a string. | Server | stof("1.5"); | conversion | DarkPlaces, FTE |
| etof | Entity to float (edict index). | Menu | etof(self); | conversion | DarkPlaces, FTE |
| ftoe | Float to entity (edict). | Menu | ftoe(1); | conversion | DarkPlaces, FTE |
| stov | String to vector. | Server | stov("1 2 3"); | conversion | DarkPlaces, FTE |
| ftos | Float to string. | Server | ftos(3.14); | conversion | DarkPlaces, FTE |
| vtos | Vector to string. | Server | vtos('1 2 3'); | conversion | DarkPlaces, FTE |
| sprintf | Formats string. | Server | sprintf("x = %d", 5); | string | DarkPlaces, FTE |
| error | Triggers a fatal error. | Server | error("Something went wrong"); | debug | DarkPlaces, FTE |
| objerror | Aborts current object with error. | Server | objerror("Invalid use"); | debug | DarkPlaces, FTE |
| coredump | Triggers a coredump for debugging. | Server | coredump(); | debug | DarkPlaces, FTE |
| traceon | Enables function tracing. | Server | traceon(); | debug | DarkPlaces, FTE |
| traceoff | Disables function tracing. | Server | traceoff(); | debug | DarkPlaces, FTE |
| changelevel | Changes to another level. | Server | changelevel("start"); | engine | DarkPlaces, FTE |
| precache_model | Preloads a model. | Server | precache_model("progs/weapon.mdl"); | file | DarkPlaces, FTE |
| precache_model2 | Preloads model only for purchased Quake. | Server | precache_model2("model.mdl", 1); | file | DarkPlaces, FTE |
| precache_file | Preloads a file. | Server | precache_file("maps/test.bsp"); | file | DarkPlaces, FTE |
| precache_file2 | Preloads file for purchased Quake. | Server | precache_file2("file.txt", 1); | file | DarkPlaces, FTE |
| infoadd | Sets or adds a key/value pair to an infostring - note: forbidden characters are \ and " | Server | infoadd("key1\nval1\n", "key2", "val2"); | string | DarkPlaces, FTE |
| infoget | Gets a key/value pair in an infostring, returns value or null if not found. | Server | infoget("key\nvalue", "key"); | string | DarkPlaces, FTE |
| callfunction | Calls a function by pointer. | Server, Client, Menu | callfunction(func); | engine | DarkPlaces, FTE |
| isfunction | Checks if value is a function pointer. | Server | isfunction(function_name); | engine | DarkPlaces, FTE |
| parseentitydata | Parses entity data. | Server | parseentitydata(entity, "worldspawn { }"); | entity | DarkPlaces, FTE |
| gettime | Gets the current time. | Server, Client, Menu | gettime(); | engine | DarkPlaces, FTE |
| gettagindex | Gets model tag index. | Server | gettagindex(model, "tag"); | model | DarkPlaces, FTE |
| gettaginfo | Gets model tag transform. | Server | gettaginfo(entity, tag); | model | DarkPlaces, FTE |
| whichpack | For files in a pak/pk3, returns the pack's file name in FRIK_FILE name space. | Server | whichpack("maps/start.bsp"); | file | DarkPlaces, FTE |
| checkextension | Checks for engine extension. | Server, Client, Menu | checkextension("DP_SV_SETCOLOR"); | engine | DarkPlaces, FTE |
| setspawnparms | set parm1... to the values at level start for coop respawn. Restore the original spawn parameters of a client entity. Doesn't work if client is not a player. | Server | setspawnparms(client); | entity | WinQuake, DarkPlaces, FTE |
| search_packfile_begin | Extension to search_begin (DP_QC_FS_SEARCH), performs a filename search with the specified pattern (for example "maps/*.bsp") and stores the results in a search slot (minimum of 128 supported by any engine with this extension), the other functions take this returned search slot number, be sure to search_free when done (they are also freed on progs reload). | Server | search_packfile_begin("id1/pak0.pak", "*.mdl"); | file | DarkPlaces, FTE |
| search_begin | Performs a filename search with the specified pattern (for example "maps/*.bsp") and stores the results in a search slot (minimum of 128 supported by any engine with this extension), the other functions take this returned search slot number, be sure to search_free when done (they are also freed on progs reload). | Server | search_begin("maps/*.bsp"); | file | DarkPlaces, FTE |
| search_end | Frees a search slot (also done at progs reload). | Server | search_end(); | file | DarkPlaces, FTE |
| search_getsize | Returns how many filenames were found. | Server | search_getsize(); | file | DarkPlaces, FTE |
| search_getfilename | Returns a filename from the search. | Server | search_getfilename(); | file | DarkPlaces, FTE |
| find | Where: start = beginning of list to search (world, for the beginning of list); field = entity field that must be examined (ex: targetname); match = value that must be matched (ex: other.target). Returns the entity found, or world if no entity was found. Searches the server entity list beginning at start, looking for an entity that has entity.field = match | Server | find(start, field, value); | entity | DarkPlaces, FTE |
| findradius | Where: origin = origin of sphere; radius = radius of sphere. Returns a chain of entities that have their origins within a spherical area. The entity returned is e, and the next in the chain is e.chain, until e == FALSE. Typical usage: find and harm the victims of an explosion. | Server | findradius(origin, radius); | entity | DarkPlaces, FTE |
| findchain | Similar to find() but returns a chain of entities like findradius. | Server | findchain(field, match); | entity | DarkPlaces, FTE |
| findradius_tofield | Similar to findchain() etc, but stores the chain into .tofield instead of .chain. | Server | findradius_tofield(origin, radius, field); | entity | DarkPlaces, FTE |
| findchain_tofield | Similar to findchain() etc, but stores the chain into .tofield instead of .chain. | Server | findchain_tofield(field, value); | entity | DarkPlaces, FTE |
| findchainflags_tofield | Similar to findchain() etc, but stores the chain into .tofield instead of .chain. | Server | findchainflags_tofield(field, flags); | entity | DarkPlaces, FTE |
| findchainfloat_tofield | Similar to findchain() etc, but stores the chain into .tofield instead of .chain. | Server | findchainfloat_tofield(field, value); | entity | DarkPlaces, FTE |
| findchainflags | Similar to findflags() but returns a chain of entities like findradius. | Server | findchainflags(flags); | entity | DarkPlaces, FTE |
| findchainentity | Similar to findentity()/findfloat() but returns a chain of entities like findradius. | Server | findchainentity(type); | entity | DarkPlaces, FTE |
| findchainfloat | Similar to findentity()/findfloat() but returns a chain of entities like findradius. | Server | findchainfloat(field, value); | entity | DarkPlaces, FTE |
| findflags | Finds an entity with the specified flag set in the field, similar to find(). | Server | findflags(flags); | entity | DarkPlaces, FTE |
| findentity | Finds an entity, similar to find(), but for entity and float fields. | Server | findentity(index); | entity | DarkPlaces, FTE |
| findfloat | Finds an float field value, similar to find(), but for entity and float fields. | Server | findfloat(field, value); | entity | DarkPlaces, FTE |
| findchainstring | Finds entities by string field match. | Menu | findchainstring(field, "value"); | entity | DarkPlaces, FTE |
| uri_escape | Escapes URI components. | Server | uri_escape("hello world"); | string | DarkPlaces, FTE |
| uri_unescape | Unescapes URI components. | Server | uri_unescape("hello%20world"); | string | DarkPlaces, FTE |
| uri_get | Performs HTTP GET request. | Server | uri_get("http://example.com", id); | network | DarkPlaces, FTE |
| uri_post | Performs HTTP POST request. | Server | uri_post("http://example.com", id, "application/json", "data=1"); | network | DarkPlaces, FTE |
| uri_postbuf | POST request with buffer. | Server | uri_postbuf("http://example.com", id, "application/json", delim, buf); | network | DarkPlaces, FTE |
| URI_Get_Callback | Mandatory callback for all http requests | Server | void(float id, float status, string data) URI_Get_Callback; | network | DarkPlaces, FTE |
| getsurfacepoint | Gets a point on a surface by index. | Server | getsurfacepoint(entity, surfIndex, pointIndex); | surface | DarkPlaces, FTE |
| getsurfacenumpoints | Returns number of points on a surface. | Server | getsurfacenumpoints(entity, surfIndex); | surface | DarkPlaces, FTE |
| getsurfacetexture | Gets texture name of a surface. | Server | getsurfacetexture(entity, surfIndex); | surface | DarkPlaces, FTE |
| getsurfacenormal | Gets normal vector of a surface. | Server | getsurfacenormal(entity, surfIndex); | surface | DarkPlaces, FTE |
| getsurfaceclippedpoint | Gets clipped point on surface. | Server | getsurfaceclippedpoint(entity, surfIndex, point); | surface | DarkPlaces, FTE |
| getsurfacetriangle | Gets triangle data from a surface. | Server | getsurfacetriangle(entity, surfIndex, triIndex); | surface | DarkPlaces, FTE |
| getsurfacenumtriangles | Returns number of triangles on surface. | Server | getsurfacenumtriangles(entity, surfIndex); | surface | DarkPlaces, FTE |
| getsurfacepointattribute | Gets attribute (e.g. texcoord) of a surface point. | Server | getsurfacepointattribute(entity, surfIndex, pointIndex, "texcoord"); | surface | DarkPlaces, FTE |
| getsurfacenearpoint | Finds nearest point on surface to given position. | Server | getsurfacenearpoint(entity, position); | surface | DarkPlaces, FTE |
| getlight | Returns the color of lighting at the requested location. | Server | getlight(position); | engine | DarkPlaces, FTE |
| getlight2 | Same as getlight, but you may specify what type of lights you want. | Server | getlight2(position, LP_RTWORLD); | engine | DarkPlaces, FTE |
| getentity | Allows to query parms from render entities, especially useful with attaching CSQC ents to server entities networked and interpolated by engine (monsters, players), number of entity is it's SVQC number you can send it via tempentity/CSQC entity message. | Server | getentity(index); | entity | DarkPlaces, FTE |
| getentityvec | Gets vector field of entity by index. | Server | getentityvec(index, "origin"); | entity | DarkPlaces, FTE |
| clearscene | CSQC builtin to clear the scene of all entities / reset our view properties. | Client | clearscene(); | render | DarkPlaces, FTE |
| addentities | Adds entities with these rendermask field var's to our view. | Client | addentities(MASK_NORMAL | MASK_ENGINE | MASK_ENGINEVIEWMODELS); | render | DarkPlaces, FTE |
| addentity | Adds a single entity to the scene. | Client | addentity(entity); | render | DarkPlaces, FTE |
| setproperty | Sets a render property on entity. | Client | setproperty(VF_DRAWWORLD, 1); | render | DarkPlaces, FTE |
| getproperty | Gets a scalar render property. | Client | getproperty(VF_DRAWWORLD); | render | DarkPlaces, FTE |
| getpropertyvec | Gets a vector render property. | Client | getpropertyvec(MASK_ENGINEVIEWMODELS); | render | DarkPlaces, FTE |
| renderscene | Renders the composed client scene. | Client | renderscene(); | render | DarkPlaces, FTE |
| adddynamiclight | Adds a dynamic light. | Client | adddynamiclight(pos, radius, color); | render | DarkPlaces, FTE |
| adddynamiclight2 | Adds a dynamic light with more parameters. | Client | adddynamiclight2(pos, radius, color, style, cubemap, pflags); | render | DarkPlaces, FTE |
| R_BeginPolygon | Starts a polygon definition. | Client | R_BeginPolygon("texture.tga", DRAWFLAG_NORMAL); | render | DarkPlaces, FTE |
| R_PolygonVertex | Adds a vertex to the polygon. | Client | R_PolygonVertex(pos, texcoord, color, alpha); | render | DarkPlaces, FTE |
| R_EndPolygon | Finishes polygon definition. | Client | R_EndPolygon(); | render | DarkPlaces, FTE |
| cs_unproject | Converts screen to world coordinates (S2W). | Client | cs_unproject(x, y); | render | DarkPlaces, FTE |
| cs_project | Converts world to screen coordinates (W2S). | Client | cs_project(pos); | render | DarkPlaces, FTE |
| drawline | Draws a 2D line on screen. | Client | drawline(width, pos1, pos2, color, alpha, flag); | draw | DarkPlaces, FTE |
| iscachedpic | Checks if image is loaded in memory. | Client | iscachedpic("pic.tga"); | draw | DarkPlaces, FTE |
| precache_pic | Preloads an image for drawing. | Client | precache_pic("image.tga"); | draw | DarkPlaces, FTE |
| precache_cubemap | Preloads a cubemap texture. | Client | precache_cubemap("cubemaps/237nx.tga"); | draw | DarkPlaces, FTE |
| draw_getimagesize | Gets dimensions of an image. | Client | draw_getimagesize("pic.tga"); | draw | DarkPlaces, FTE |
| freepic | Frees cached image. | Client | freepic("pic.tga"); | draw | DarkPlaces, FTE |
| drawcharacter | Draws a single character. | Client | drawcharacter(pos, char, scale, color, alpha, flag); | draw | DarkPlaces, FTE |
| drawstring | Draws a string on screen. | Client | drawstring(pos, "text", scale, color, alpha, flag); | draw | DarkPlaces, FTE |
| drawpic | Draws an image. | Client | drawpic(pos, "image.tga", size, color, alpha, flag); | draw | DarkPlaces, FTE |
| drawfill | Draws a filled box. | Client | drawfill(pos1, size, color, alpha, flag); | draw | DarkPlaces, FTE |
| drawsetcliparea | Sets a screen clip area. | Client | drawsetcliparea(x, y, w, h); | draw | DarkPlaces, FTE |
| drawresetcliparea | Clears clip area restriction. | Client | drawresetcliparea(); | draw | DarkPlaces, FTE |
| drawcolorcodedstring | Draws colored string with ^ codes. | Client | drawcolorcodedstring(pos, "^1Red", scale, alpha, flag); | draw | DarkPlaces, FTE |
| drawcolorcodedstring2 | Draws colored string with clipping. | Client | drawcolorcodedstring2(pos, "^2Green", scale, color, alpha, flag); | draw | DarkPlaces, FTE |
| drawsubpic | Draws a portion of an image. | Client | drawsubpic(pos, size, "pic.tga", srcPos, srcSize, color, alpha, flag); | draw | DarkPlaces, FTE |
| getstatf | Gets float from a stat. | Client | getstatf(stat_number); | stats | DarkPlaces, FTE |
| getstati | Gets integer from a stat. | Client | getstati(stat_number); | stats | DarkPlaces, FTE |
| getstats | Gets string from a stat. | Client | getstats(stat_number); | stats | DarkPlaces, FTE |
| setmodelindex | Sets model index. | Client | setmodelindex(entity, index); | model | DarkPlaces, FTE |
| modelnameforindex | Gets model name by index. | Client | modelnameforindex(1); | model | DarkPlaces, FTE |
| numentityfields | Gets number of fields on entity. | Client | numentityfields(entity); | entity | DarkPlaces, FTE |
| keynumtostring | Gets key name from key code. | Client | keynumtostring(13); | input | DarkPlaces, FTE |
| stringtokeynum | Gets key code from key name. | Client | stringtokeynum("ENTER"); | input | DarkPlaces, FTE |
| getkeybind | Gets binding for key. | Client | getkeybind("F1"); | input | DarkPlaces, FTE |
| setcursormode | Sets mouse cursor mode. | Client | setcursormode(1); | input | DarkPlaces, FTE |
| getmousepos | Gets mouse position. | Client | getmousepos(); | input | DarkPlaces, FTE |
| getinputstate | Gets key/button input state. | Client | getinputstate("MOUSE1"); | input | DarkPlaces, FTE |
| setsensitivityscale | Scales mouse sensitivity. | Client | setsensitivityscale(0.5); | input | DarkPlaces, FTE |
| runstandardplayerphysics | Executes standard movement logic. | Client | runstandardplayerphysics(); | physics | DarkPlaces, FTE |
| getplayerkeyvalue | Gets a player config key. | Client | getplayerkeyvalue(self, "name"); | network | DarkPlaces, FTE |
| isdemo | Returns true if demo is playing. | Client | isdemo(); | engine | DarkPlaces, FTE |
| isserver | Returns true if client is also server. | Client | isserver(); | engine | DarkPlaces, FTE |
| SetListener | Sets the audio listener entity. | Client | SetListener(self); | sound | DarkPlaces, FTE |
| serverkey | Gets server-specific info string. | Client | serverkey("version"); | network | DarkPlaces, FTE |
| entitybyindex | Returns entity by index. | Client | entitybyindex(0); | entity | DarkPlaces, FTE |
| getkeybind_bindmap | Gets bind from specific bindmap. | Client | getkeybind_bindmap("F1", 0); | input | DarkPlaces, FTE |
| setkeybind_bindmap | Binds key in specific bindmap. | Client | setkeybind_bindmap("F1", "+show", 0); | input | DarkPlaces, FTE |
| getbindmaps | Gets active bindmaps. | Client | getbindmaps(); | input | DarkPlaces, FTE |
| setbindmaps | Sets active bindmaps. | Client | setbindmaps(bm); | input | DarkPlaces, FTE |
| findkeysforcommand | Finds keys bound to a command. | Client | findkeysforcommand("toggleconsole", 0); | input | DarkPlaces, FTE |
| V_CalcRefdef | Use this on the player entity after performing prediction. | Client | V_CalcRefdef(); | render | DarkPlaces, FTE |
| setkeydest | Sets input destination. | Client | setkeydest("menu"); | input | DarkPlaces, FTE |
| getkeydest | Gets current key destination. | Client | getkeydest(); | input | DarkPlaces, FTE |
| setmousetarget | Sets mouse target entity. | Client | setmousetarget(self); | input | DarkPlaces, FTE |
| getmousetarget | Gets current mouse target. | Client | getmousetarget(); | input | DarkPlaces, FTE |
| getresolution | Gets screen resolution. | Client | getresolution(); | engine | DarkPlaces, FTE |
| gethostcachevalue | Gets host list value. | Client | gethostcachevalue(0, "name"); | network | DarkPlaces, FTE |
| gethostcachestring | Gets full host cache as string. | Client | gethostcachestring(); | network | DarkPlaces, FTE |
| netaddress_resolve | Resolves hostname to IP. | Client | netaddress_resolve("example.com"); | network | DarkPlaces, FTE |
| ReadByte | Reads byte from network message. | Client | ReadByte(); | network | DarkPlaces, FTE |
| ReadChar | Reads char from network message. | Client | ReadChar(); | network | DarkPlaces, FTE |
| ReadShort | Reads short from network message. | Client | ReadShort(); | network | DarkPlaces, FTE |
| ReadLong | Reads long from network message. | Client | ReadLong(); | network | DarkPlaces, FTE |
| ReadCoord | Reads float coordinate. | Client | ReadCoord(); | network | DarkPlaces, FTE |
| ReadAngle | Reads float angle. | Client | ReadAngle(); | network | DarkPlaces, FTE |
| ReadString | Reads null-terminated string. | Client | ReadString(); | network | DarkPlaces, FTE |
| ReadFloat | Reads float value. | Client | ReadFloat(); | network | DarkPlaces, FTE |
| ReadPicture | Reads image data from message. | Client | ReadPicture(); | network | DarkPlaces, FTE |
| findfont | Finds font by fontname and return it's index. | Menu | findfont("conchars"); | ui | DarkPlaces, FTE |
| loadfont | Loads a font into memory. | Menu | loadfont("fontname", fontmaps, sizes, sltot, fix_scale, fix_voffset); | ui | DarkPlaces, FTE |
| stringwidth | Get a width of string with given font and char size. | Menu | stringwidth("text"); | ui | DarkPlaces, FTE |
| stringwidth_menu | Same as stringwidth, but in menu.dat it has different builtin #. | Menu | stringwidth_menu("text", fonthandle); | ui | DarkPlaces, FTE |
| crypto_getkeyfp | Retrieves the cached host key's CA fingerprint of a server given by IP address. | Menu | crypto_getkeyfp("key"); | crypto | DarkPlaces, FTE |
| crypto_getidfp | Retrieves the cached host key fingerprint of a server given by IP address. | Menu | crypto_getidfp("id"); | crypto | DarkPlaces, FTE |
| crypto_getidstatus | Retrieves the cached host key's key status. See below for CRYPTO_IDSTATUS_ defines. | Menu | crypto_getidstatus("id"); | crypto | DarkPlaces, FTE |
| crypto_getencryptlevel | 0 if never encrypting, 1 supported, 2 requested, 3 required, appended by list of allowed methods in order of preference ("AES128"), preceded by a space each. | Menu | crypto_getencryptlevel(); | crypto | DarkPlaces, FTE |
| crypto_getmykeyfp | Retrieves the CA key fingerprint of a given CA slot, or "" if slot is unused but more to come, or string_null if end of list. | Menu | crypto_getmykeyfp(); | crypto | DarkPlaces, FTE |
| crypto_getmyidfp | Retrieves the ID fingerprint of a given CA slot, or "" if slot is unused but more to come, or string_null if end of list. | Menu | crypto_getmyidfp(); | crypto | DarkPlaces, FTE |
| crypto_getmyidstatus | Retrieves the ID's status of a given CA slot, or 0 if slot is unused but more to come, or -1 if end of list. | Menu | crypto_getmyidstatus(); | crypto | DarkPlaces, FTE |
| crypto_uri_postbuf | Encrypts and posts a URI buffer using crypto. Use -1 as buffer handle to justs end delim as postdata | Menu | crypto_uri_postbuf(uri, data); | crypto | DarkPlaces, FTE |
| gecko_create | Creates a Gecko web control. | Menu | gecko_create("id", "about:blank"); | ui | DarkPlaces, FTE |
| gecko_destroy | Destroys a Gecko control. | Menu | gecko_destroy("id"); | ui | DarkPlaces, FTE |
| gecko_navigate | Navigates to a URL. | Menu | gecko_navigate("id", "http://example.com"); | ui | DarkPlaces, FTE |
| gecko_keyevent | Sends key input to Gecko. | Menu | gecko_keyevent("id", keynum, isdown); | ui | DarkPlaces, FTE |
| gecko_mousemove | Moves cursor within Gecko. | Menu | gecko_mousemove("id", x, y); | ui | DarkPlaces, FTE |
| gecko_resize | Resizes a Gecko window. | Menu | gecko_resize("id", width, height); | ui | DarkPlaces, FTE |
| gecko_get_texture_extent | Gets dimensions of Gecko texture. | Menu | gecko_get_texture_extent("id"); | ui | DarkPlaces, FTE |
| validstring | Checks if string is valid. | Menu | validstring("hello"); | string | DarkPlaces, FTE |
| altstr_count | Returns count of entries in altstr. | Menu | altstr_count("listname"); | string | DarkPlaces, FTE |
| altstr_prepare | Initializes altstr table. | Menu | altstr_prepare("listname", size); | string | DarkPlaces, FTE |
| altstr_get | Gets string from altstr index. | Menu | altstr_get("listname", index); | string | DarkPlaces, FTE |
| altstr_set | Sets string in altstr index. | Menu | altstr_set("listname", index, "value"); | string | DarkPlaces, FTE |
| altstr_ins | Inserts string into altstr at index. | Menu | altstr_ins("listname", index, "value"); | string | DarkPlaces, FTE |
| resethostcachemasks | Clears all filters/masks on the server browser host cache. | Menu | resethostcachemasks(); | serverbrowser | DarkPlaces, FTE |
| sethostcachemaskstring | Sets a string-based filter on the host cache. | Menu | sethostcachemaskstring("map", "dm6"); | serverbrowser | DarkPlaces, FTE |
| sethostcachemasknumber | Sets a numeric filter on the host cache. | Menu | sethostcachemasknumber("ping", 100); | serverbrowser | DarkPlaces, FTE |
| resorthostcache | Resorts the host cache list using active filters and sorting mode. | Menu | resorthostcache(); | serverbrowser | DarkPlaces, FTE |
| sethostcachesort | Sets the sort key for the host cache list. | Menu | sethostcachesort("ping"); | serverbrowser | DarkPlaces, FTE |
| refreshhostcache | Requests a refresh of the server browser host list. | Menu | refreshhostcache(); | serverbrowser | DarkPlaces, FTE |
| gethostcachenumber | Returns the number of servers in the cache. | Menu | gethostcachenumber(); | serverbrowser | DarkPlaces, FTE |
| gethostcacheindexforkey | Gets the index of the server that has a given key/value. | Menu | gethostcacheindexforkey("name", "My Server"); | serverbrowser | DarkPlaces, FTE |
| addwantedhostcachekey | Adds a custom key to track in the server list. | Menu | addwantedhostcachekey("mod"); | serverbrowser | DarkPlaces, FTE |
| netaddress_resolve | Resolves a hostname to an IP address. | Menu | netaddress_resolve("example.com"); | network | DarkPlaces, FTE |
| getgamedirinfo | Retrieves metadata about the current game/mod directory. | Menu | getgamedirinfo(); | engine | DarkPlaces, FTE |