Modules
Angles as FTE's server reads them: {pitch, yaw, roll} in degrees, pitch above zero
looking down.
The animation of the entities a program sends itself, carried to each watching player
as GoldSrc's engine carries entity_state_t's sequence, frame, animtime and
framerate for every entity it sends (delta.lst).
A builtin's arguments and result: argument i (from 0) sits in the program's
parameter slots at 4 + 3 * i, and the result goes to slot 1.
A program's autocvar_<name> globals kept equal to console variable <name>, and a
server's info keys kept equal to its :serverinfo and :userinfo variables, as FTE
keeps them (PR_AutoCvar, Cvar_SetCore).
The engine functions a QuakeC program calls by number, as FTE runs them for a server
program: vectors and angles, entities and models, traces, sounds, monster movement,
searches, console variables, messages and level changes. Where FTE's rule depends on
the kind of program, a QuakeWorld program is one whose crc is 54730.
The aim builtin as FTE runs it (PF_aim): the direction a shot from entity should
take, from its origin raised by its view_ofs height, given v_forward.
The print builtins as FTE runs them: bprint (23) to every player, sprint (24) to
one, and centerprint (73) in the middle of one player's screen, their text joined
from every argument after the leading ones. A QuakeWorld program (crc 54730) gives
bprint and sprint a print level before the text; otherwise the level is 2
(PRINT_HIGH). Prints reach a player's reliable messages (QuakeServer.Outbox) and,
as {:print, :notify | :center, text}, the server's events. A sprint or
centerprint to an entity that is not a player prints that it was tried.
Numbers as FTE's ftos and vtos write them for a QuakeC program.
The message-writing builtins (WriteByte to WriteEntity, numbers 52 to 59, and
FTE's WriteFloat, WriteInt and WriteUnterminatedString), which append bytes to a
message in FTE's encodings.
FTE's player cheat commands, for the host's player (entity 1), allowed as FTE's
SV_MayCheat allows them: with sv_cheats set, or always on a single-player server.
The console: the commands a program queues with localcmd, the lines of the
configuration files they exec, and commands typed or sent to it, run against the
host's QuakeServer.Cvars table as FTE's console runs them.
FTE's key bindings (keys.c): the console's bind, in_bind, bindlevel, unbind
and unbindall, and the lookups the client and menu programs make, kept in the
host's QuakeServer.Cvars table (QuakeServer.Cvars.binding/3) so every holder of it
shares them.
The console's exec and cfg_save, as FTE's Cmd_Exec_f and Cmd_WriteConfig_f
run them, with FTE's main config fte.cfg.
The console's commands about console variables, run on the host's
QuakeServer.Cvars table as FTE's cmd.c and cvar.c run them.
FTE's contents as bits (bspfile.h), and the translation from the codes Quake and
Half-Life maps store (Q1BSP_TranslateContents, and the contents a brush entity's
negative skin forces on all of its brushes).
FTE's console variables: one table every process of a game reads and writes, the server, its client program and its menu alike, as FTE's single process has one set.
One console variable as QuakeServer.Cvars.fetch/2 reads it.
The console variables FTE's engine registers that a game here reads: the server's physics and rules, the client's screen, sound and player settings, and every engine variable FreeHL's programs and configs name. Each has FTE's default (for the server's physics, the default this server plays by), flags, second name and description.
Entities of a running level: making and freeing them, and their fields by name.
The entity references in a file the program carries from one level to the next,
translated by Half-Life's level transition rule (GoldSrc's engine and the HLSDK's
CSaveRestoreBuffer: a saved reference is an index into the save's entity table,
restored as the entity that table entry was restored into, and as null when the entry
was not carried into the level). The rule is Half-Life's (GoldSrc and the HLSDK), not
FreeHL's under FTE, where a number read back is the entity of that number in the new
level whatever it now is.
What the server tells the client happened: particles and printed messages, added to
the server's events. Sounds are QuakeServer.Sounds.
The builtins of an FTE server program: Quake's (QuakeServer.Builtins) and FTE's
extensions to them, by number and, for builtins a program binds by name, by name.
FTE's string buffer builtins beyond making, reading and writing single strings
(QuakeServer.Extensions.Store)
FTE's abort (211), which stops every QuakeC function running
(QuakeC.Exec.abort/1), and checkcommand (294), which says what a console name is,
in the order the console looks: 1 a command (the console's own,
QuakeServer.Console.command?/1, or one the program registered), 2 an alias, 3 a
console variable, 0 nothing.
FTE's effect and sound builtins: named particle effects by number, effects at a point
and along a trail, the te_ temporary effects, sounds at a point and with pitch, and
sound numbers. Each becomes an event for the client (QuakeServer.Server.emit/2)
FTE's builtins that recode text and bytes
FTE's builtins that write entities as text and read them back, as its PR_SaveEnt
and PR_RestoreEnt, and that list or protect entities
FTE's file builtins beyond opening, reading and writing (QuakeServer.Extensions.Store)
QuakeC's sprintf: C's conversions over the builtin's arguments.
FTE's JSON builtins: json_parse lays the parsed tree out in the program's memory and
returns its root node's address (null when the text is not JSON); the others read a
node: json_get_value_type (0 string, 1 number, 2 object, 3 array, 4 true, 5 false,
6 null), json_get_name, json_get_integer, json_get_float, json_get_string,
json_get_length, json_get_child_at_index and json_find_object_child (null when
absent). json_free gives the tree's memory back. A null node reads as JSON null.
js_run_script returns null, as FTE does outside its web build.
FTE's changelevel(map, optional startspot): the first change asked for in a frame
is kept, in the server's changelevel and, given a second argument, the landmark in
changelevel_startspot; later ones are ignored.
FTE's light builtins: getlight (the world's light at a point, 0 to 255 a channel,
as Cauldron3D.Bsp.Light.at/4 finds it), lightstyle with an optional colour,
getlightstyle (the pattern, and the colour through its second argument) and
getlightstylergb (the colour scaled by the pattern's brightness now, m being 1.03).
FTE's arithmetic builtins: trigonometry, powers, logarithms, modulo, clamping, bit
shifts, angle and vector helpers, and turning the v_forward, v_right, v_up axes.
FTE's builtins over a program's memory as bytes: createbuffer (a zeroed block one
byte longer than asked, or null for a size below 1), memrealloc (a new block holding
the old one's bytes, the old one given back; a size of 0 is taken as 1, one below 0 or
above 16 MiB fails with null), memcmp (bytes compared as unsigned, the sign of the
first difference) and memstrsize (a string's length in bytes).
FTE's model builtins: model numbers by name and names by number; a studio model's sequences ("frames") by name and action, their length and their events; skeleton objects; tags (a studio model's bones, then its attachments, numbered from 1) and where a tag lies on an entity in the world; and the surfaces of a brush model, with their corners' position, texture axes, normal, texture and lightmap places and light.
FTE's movement builtins: the engine's player movement (runstandardplayerphysics),
area portals (openportal) and the rigid-body physics calls.
FTE's message builtins beyond Quake's: writing floats and integers, and multicast,
which sends the message built with MSG_MULTICAST (QuakeServer.Multicast.send/4)
and starts a new one.
FTE's server polygon builtins, for drawing in the world from the server program:
R_BeginPolygon(texture, flags, is2d), R_PolygonVertex(origin, texcoords, rgb, alpha) and R_EndPolygon(). Each finished polygon becomes the event
{:polygon, %{texture:, flags:, flat?:, vertices: [{origin, texcoords, rgb, alpha}]}}
(QuakeServer.Server.emit/2), and the next starts on the same texture.
FTE's route_calculate (sv_move.c): a path over the level's waypoints from where an
entity stands to a destination, handed to the program's callback at the start of the
next frame (run/1) as a list of nodes in allocated memory.
FTE's builtins about the engine around the program: console variables (cvar,
cvar_string, cvar_set, cvar_setf, registercvar, cvar_defstring,
cvar_type, cvar_description, buf_cvarlist, cvars_haveunsaved, as FTE's
pr_bgcmd.c runs them on the host's QuakeServer.Cvars table), server and player info
keys, which extensions and functions exist, calling functions by name, the time,
printing, console commands, registered stats, and the kinds of client.
FTE's builtins that keep things: hash tables, allocated memory, files, file searches and string buffers.
FTE's string builtins: length, joining, cutting, searching, comparing, case, number
conversion, sprintf, and the tokenizers whose tokens argv reads back.
FTE's entity builtins: finding by float, flags and string into chains, entity numbers, copying, freeing at once, box traces and tossed traces, potentially-visible checks, touching triggers, turning in pitch, attachments, and reading and writing fields by their place in the program's field list.
FTE's network builtins
FTE's key numbers (keynum_t), key names and modifiers, and the QuakeC key codes the
client and menu programs use for them, as FTE's keys.c and pr_clcmd.c number,
name and translate them.
Text with FTE's markup reduced to the characters it shows, as FTE's
COM_ParseFunString followed by COM_DeFunString with flags ignored: colour and
style codes are dropped and a link's hidden part with them.
The bytes a QuakeC program writes with WriteByte and the rest, read back into
events for the client.
The models a level has asked for, by index, as the server needs them: their box, and for brush models the hulls things collide with.
FTE's multicast (SV_MulticastProtExt): the message a program built with
MSG_MULTICAST goes to the players to names, each choosing as the player is when it
is sent, into the player's reliable messages or datagram (QuakeServer.Outbox).
FTE's delivery of the entities a program sends itself (SendEntity) to the client
programs of the players watching (sv_ents.c).
What the server holds for each player until the player's next packet, as FTE keeps it
for a client: the reliable messages (MSG_ONE, reliable multicasts, prints), the
datagram (unreliable multicasts), and the last centerprint, which goes out with the
next packet after the reliable messages queued before it.
One physics frame of a level, as FTE's server runs it (sv_phys.c): the program's
StartFrame, then every entity by its move type (WPhys_RunEntity), then EndFrame,
and the clock moved on by the frame.
A player's command run by a program that defines SV_RunClientCommand, as FTE runs
one when it arrives (SV_RunFullQCMovement, then SV_PostRunCmd): the input_
globals are set from the command; unless the server is fixing the player's view
(fixangle), v_angle and movement are too; the button fields and impulse are set;
the velocity is bounded; while alive, the body turns to the view (a third of the pitch)
and rolls with sideways speed; then PlayerPreThink, the player's think and
SV_RunClientCommand run, and PlayerPostThink and the missile it spawned (newmis)
after. When the program turned the view itself, the new view angles are kept for the
client in the server's ext.setangle. The player is from then on left out of the
physics frames (QuakeServer.Physics.independent?/2).
FTE's solid-body movement (sv_phys.c): sliding along what a box hits
(WPhys_FlyMove), moving a box at once (WPhys_PushEntity), the touches two entities
run when they meet (WPhys_Impact), and the velocity clip a surface gives
(ClipVelocity).
FTE's straight push: a pusher moved by move takes along what stands on it and what
its new place overlaps, by setting each one's origin and testing the spot. One that
will not fit is nudged an eighth of a unit further, then left where it was if that is
free; a box with no width, one not solid or a box trigger (flattened), or anything in
a liquid pusher's way never blocks. Anything else blocks: the pusher and everything
moved go back, and the pusher's blocked runs. Nothing is touched by the push itself.
FTE's turning push: a pusher moved by move and turned by turn takes along what
stands on it and what its new place overlaps. Each one is moved by move, turned by
turn and swung round the pusher's origin by it, then its spot is tested. One that
will not fit is put back if that is free, else pushed by move through the world,
else nudged an eighth of a unit each way. A box with no width, anything in a liquid
pusher's way, or one not solid or a box trigger (flattened) never blocks; anything else
blocks: everything goes back, the pusher's blocked runs. Once all have moved, each
touches the triggers it is in.
What FTE's two pushes share (QuakeServer.Physics.Push and
QuakeServer.Physics.PushTurn): which entities a pusher's move reaches, the pusher's
blocked call, and putting moved entities back.
Doors, lifts and trains, as FTE runs them (WPhys_Physics_Pusher): brush models that
move on their own clock (ltime) by their velocity and turn by their avelocity,
through QuakeServer.Physics.Push (moving only) or QuakeServer.Physics.PushTurn
(turning). Each frame a pusher moves for the frame, or only until its nextthink when
that comes first; the clock advances only when the push went through. When the clock
has reached nextthink the think runs, with the program's time the frame's start. A
pusher its think moved or turned is put back and pushed that far, taking along what it
carries.
FTE's walking movement (sv_phys.c), for walking entities other than players that move
themselves: gravity (WPhys_AddGravity), the water check (WPhys_CheckWater), getting
out of the world when stuck (WPhys_CheckStuck), and the walk itself with stepping up
and down stairs (WPhys_WalkMove), slowed against walls it faces (WPhys_WallFriction).
The player's command applied before physics for a program that does not run its
players' commands itself, as FTE's NetQuake player physics (SV_ClientThink) does: view
angles and buttons copied in, the body turned to the view and rolled by strafing,
punch angles decayed, and the velocity accelerated on the ground (with friction,
stronger at ledges), in the air, or in water.
FTE's QuakeWorld player movement (PM_PlayerMove): one command of a player's input
moving a box through the world and the entities near it.
One command: angles as signed 16-bit numbers (360 degrees is 65536), the
forward, side and up moves, the buttons bits (2 is jump) and its length
msec in milliseconds.
The movement settings. entgravity scales gravity for the player; edge_box
tests for ledges with the player's box instead of a line; coordtype is :float,
or :fixed_13_3 for positions snapped to eighths before testing where the player
fits, unless noround.
Something the player can collide with or stand in: entity number entity at
origin, either a brush model (model, as QuakeServer.Models.get/2 gives it,
turned by angles) or, with model nil, a box of mins..maxs.
The server's sound list and particle effect list as FTE gives them to a player's
client: the first time a player is sent them, the whole sound list as
svcfte_soundlistshort and each effect as svcfte_precache, as FTE's signon does;
after that every sound or effect added since, as svcfte_precache, as FTE sends a
precache made while the level runs. All go into the player's reliable messages
(QuakeServer.Outbox).
The fixed numbers QuakeC programs share with FTE's server: move types, solid kinds, entity flags, contents, effects, spawn flags and message types.
A client program's sendevent arriving at the server, as FTE handles one (its
qcrequest): the program's function CSEv_<name>_<types> runs with self the player
and the values in its parameters, types being one letter a value — f float, v
vector, i integer, s string, e entity. Without values the function is
CSEv_<name>_ when the name holds an underscore and CSEv_<name> otherwise. A name
the program has no function for prints that the request is not supported.
A level running in a process of its own, on its own clock, as FTE's listen server runs
one for its own client (SV_Frame, SV_Physics): the host clock follows real time,
and physics frames catch up to it whenever it is at least the cvar sv_mintic ahead,
each frame as long as it is ahead up to sv_maxtic; after sv_limittics frames of
sv_maxtic the rest is dropped. A player's command runs as it arrives
(QuakeServer.Server.client_command/3), covering its msec milliseconds when given,
else its timelength in whole milliseconds, up to 250. A command's sequence (the
client's number for it) is the one the server acknowledges in every packet after it
runs, as FTE's server sends a client's last_sequence (PEXT2_PREDINFO): 0 when the
program does not run its players' commands itself, telling the client it cannot
predict.
A running level of a QuakeC game: the program and its entities, the map, the models and sounds it has asked for, and what happened this frame for a client to show.
The messages FTE sends a client after the level's model and sound lists and before the
client begins (SV_SendClientPrespawnInfo, SVQW_Spawn_f): the static entities
(makestatic), oldest first, then the static sounds (ambientsound), then each player
slot's info keys.
A sound started on the server, as FTE starts one (SVQ1_StartSound, SV_StartSound):
it goes to the players as a sound message (QuakeServer.Multicast) and to the server's
events as {:sound, %{entity:, channel:, name:, volume:, attenuation:, origin:, pitch:}}.
Where a server finds its game: the compiled QuakeC program, the maps and the model
files. A game names a module with these callbacks as QuakeServer.Server.start/2's
:source.
A map's entities brought to life: the first is the world itself, every later one a
fresh entity; each has its keys written into its fields and then its spawn function
run with it as self.
Monster movement as FTE's sv_move.c has it, with gravity along -z: a step that
climbs stairs and slopes and refuses ledges, flying and swimming that rise or sink
toward the enemy, turning toward ideal_yaw, and the choice of a new direction toward
a goal when the way ahead is blocked.
Numbers read from text as C's strtod, strtol and atof read them, the readings
FTE's stof builtin and its entity-key parser (ED_ParseEpair) use.
What a map's visibility lets a viewer potentially see, as FTE's server works it out for
Quake and Half-Life maps (q1bsp.c): the leaves an entity's box touches, recorded when
it is linked, and the leaves seen from every leaf within 8 units of a viewer's eye (the
fat PVS), and the leaves that may hear a point (its PHS).
Where a level's entities are, and what moving boxes run into, as FTE's world.c has it.
The grid linked entities are filed in: 128 by 128 cells across the world model's ground, each at least 128 units wide, and one list for entities too large for it.
A move against a studio model's hitboxes, posed as FTE's server poses it
(HLMDL_Trace): a hitbox struck gives the trace its group as surface_id, its bone
(from 1) as bone_id, its number (from 1) as brush_id and its face (from 1, 0 when
the move started inside it) as brush_face.
Boxes moved through a brush model's collision hulls, stopped by the contents a mask of
QuakeServer.Contents bits names.
What a move through the world ran into, with every field FTE's trace_t gives a
program.