QuakeC

QuakeC is a very simplified dialect of the well-known C programming language, as used by Quake. Nexuiz uses the FTEQCC dialect of QuakeC, so only this one will be described (as well as some common extensions among Quake engines).

Quake only knows four elementary data types: the basic types float, vector, string, and the object type entity. Also, there is a very special type of types, fields, and of course functions. FTEQCC also adds arrays, although these are slow and a bit buggy. Note that there are no pointers!

This is the basic numeric type in QuakeC. It represents the standard 32bit floating point type as known from C. It has 23 bits of mantissa, 8 bits of exponent, and one sign bit. The numeric range goes from about 1.175e-38 to about 3.403e+38, and the number of significant decimal digits is about six.

As float has 23 bits of mantissa, it can also be used to safely represent integers in the range from -16777216 to 16777216. 16777217 is the first integer float can not represent.

Common functions for float are especially ceil, floor (working just like in C, rounding up/down to the next integer), and random, which yields a random number r with 0 <= r < 1.

This type is basically three floats together. By declaring a vector v, you also create three floats v_x, v_y and v_z (note the underscore) that contain the components of the vector.

Vectors can be used with the usual mathematical operators in the usual way used in mathematics. For example, vector + vector simply returns the sum of the vectors, and vector * float scales the vector by the given factor. Note however that dividing a vector by a float is NOT supported, one has to use vector * (1 / float) instead. Multiplying two vectors yields their dot product of type float.

Common functions to be used on vectors are vlen (vector length), normalize (vector divided by its length, i.e. a unit vector).

Vector literals are written like '1 0 0'.

COMPILER BUG: always use vector = vector * float instead of vector *= float, as the latter creates incorrect code.

A string in QuakeC is an immutable reference to a null-terminated character string stored in the engine. It is not possible to change a character in a string, but there are various functions to create new strings:

ftos and vtos convert floats and vectors to strings. Their inverses are, of course, stof and stov, which parse a string into a float or a vector.

strcat concatenates 2 to 8 strings together, as in strcat(“a”, “b”, “c”) == “abc”

strstrofs(haystack, needle, offset) searches for an occurence of one string in another, as in strstrofs(“haystack”, “ac”, 0) == 5. The offset defines from which starting position to search, and the return value is -1 if no match is found.

substring(string, startpos, length) returns part of a string.

Note that there are different kinds of strings, regarding memory management:

• Temporary strings are strings returned by built-in string handling functions such as substring, strcat. They last only for the duration of the function call from the engine. That means it is safe to return a temporary string in a function you wrote, but not to store them in global variables or objects as their storage will be overwritten soon.
• Allocated strings are strings that are explicitly allocated. They are returned by strzone and persist until they are freed (using strunzone). Note that strzone does not change the string given as a parameter, but returns the newly allocated string and keeps the passed temporary string the same way! That means:
  • To allocate a string, do for example myglobal = strzone(strcat(“hello ”, “world”));
  • To free the string when it is no longer needed, do: strunzone(myglobal);
• Engine owned strings, such as netname. These should be treated just like temporary strings: if you want to keep them in your own variables, strzone them.
• Constant strings. A string literal like “foo” gets permanent storage assigned by the compiler. There is no need to strzone such strings.
• The null string. A global uninitialized string variable has the special property that is is usually treated like the constant, empty, string ”” (so using it does not constitute an error), but it is the only string that evaluates to FALSE in an if expression (but not in the ! operator - in boolean context, the string ”” counts as FALSE too). As this is a useful property, Nexuiz code declares such a string variable of the name string_null. That means that the following patterns are commonly used for allocating strings:
  • Assigning to a global string variable: if(myglobal) strunzone(myglobal); myglobal = strzone(...);
  • Freeing the global string variable: if(myglobal) strunzone(myglobal); myglobal = string_null;
  • Checking if a global string value has been set: if(myglobal) { value has been set; } else { string has not yet been set; }

The main object type in QuakeC is entity, a reference to an engine internal object. An entity can be imagined as a huge struct, containing many fields. This is the only object type in the language. However, fields can be added to the entity type by the following syntax:

.float myfield;

and then all objects e get a field that can be accessed like in e.myfield.

The special entity world also doubles as the null reference. It can not be written to other than in the spawnfunc_worldspawn function that is run when the map is loaded, and is the only entity value that counts as false in an if expression. Thus, functions that return entities tend to return world to indicate failure (e.g. find returns world to indicate no more entity can be found).

If a field has not been set, it gets the usual zero value of the type when the object is created (i.e. 0 for float, string_null for string, '0 0 0' for vector, and world for entity).

A reference to such a field can be stored too, in a field variable. It is declared and used like

.float myfield;
// ...
// and in some function:
var .float myfieldvar;
myfieldvar = myfield;
e.myfieldvar = 42;

Field variables can be used as function parameters too - in that case you leave the var keyword out, as it is not needed for disambiguation.

Functions work just like in C:

float sum3(float a, float b, float c)
{
  return a + b + c;
}

However, the syntax to declare function pointers is simplified:

typedef float(float, float, float) op3func_t;
float(float a, float b, float c) f;
op3func_t g;
f = sum3;
g = f;
print(ftos(g(1, 2, 3)), "\n"); // prints 6

In original QuakeC by Id Software, this simplified function pointer syntax also was the only way to define functions (you may still encounter this in Nexuiz code in a few places):

float(float a, float b) sum2 = {
  return a + b;
}

A special kind of functions are built-in functions (defined by the engine). These are imported using so-called built-in numbers, with a syntax like

string strcat(string a, string b, ...) = #115;

In Nexuiz, the built-in functions from Quake are defined in builtins.qh, and the built-in functions from various extensions supported by the DarkPlaces engine are defined in extensions.qh. Information about them can be found, among other sources, on http://quakery.quakedev.com/qwiki/index.php/List_of_builtin_functions

As the QuakeC virtual machine provides no pointers or similar ways to handle arrays, array support is added by FTEQCC and very limited. Arrays can only be global, must have a fixed size (not dynamically allocated), and are a bit buggy and slow. Almost as great as in FORTRAN, except they can't be multidimensional either!

You declare arrays like in C:

#define MAX_ASSASSINS 16
entity assassins[MAX_ASSASSINS];
#define BTREE_MAX_CHILDREN 5
.entity btree_child[BTREE_MAX_CHILDREN];
#define MAX_FLOATFIELDS 3
var .float myfloatfields[MAX_FLOATFIELDS];

The former is a global array of entities and can be used the usual way:

assassins[self.assassin_index] = self;

The middle one is a global array of (allocated and constant) entity fields and not a field of array type (which does not exist), so its usage looks a bit strange:

for(i = 0; i < BTREE_MAX_CHILDREN; ++i)
  self.(btree_child[i]) = world;

Note that this works:

var .entity indexfield;
indexfield = btree_child[i];
self.indexfield = world;

The latter one is a global array of (assignable) entity field variables, and looks very similar:

myfloatfields[3] = health;
self.(myfloatfields[3]) = 0;
// equivalent to self.health = 0;

Do not use arrays when you do not need to - using both arrays and function calls in the same expression can get messed up (COMPILER BUG), and arrays are slowly emulated using functions ArrayGet*myfloatfields and ArraySet*myfloatfields the compiler generates that internally do a binary search for the array index.

This section deals with language constructs in FTEQCC that are not similar to anything in other languages.

There is a second way to do a negated if:

if not(expression)
  ...

It compiles to slightly more efficient code than

if(!expression)
  ...

and has the notable difference that

if not("")
  ...

will not execute (as ”” counts as true in an if expression), but

if(!"")
  ...

will execute (as both ”” and string_null is false when boolean operators are used on it)..

Some patterns in code that are often encountered in Nexuiz are listed here, in no particular order.

The usual way to handle classes in Quake is using fields, function pointers and the special property classname.

But first, let's look at how the engine creates entities when the map is loaded.

Assume you have the following declarations in your code:

entity self;
.string classname;
.vector origin;
.float height;

and the engine encounters the entity

{
"classname" "func_bobbing"
"height" "128"
"origin" "0 32 -64"
}

then it will, during loading the map, behave as if the following QuakeC code was executed:

self = spawn();
self.classname = "func_bobbing";
self.height = 128;
self.origin = '0 32 -64';
spawnfunc_func_bobbing();

We learn from this:

• The special global entity variable self is used when “methods” of an object are called, like - in this case - the “constructor” or spawn function spawnfunc_func_bobbing.
• Before calling the spawn function, the engine sets the mapper specified fields to the values. String values can be treated by the QC code as if they are constant strings, that means there is no need to strzone them.
• Spawn functions always have the spawnfunc_ name prefix and take no arguments.
• The string field classname always contains the name of the entity class when it was created by the engine.
• As the engine uses this pattern when loading maps and this can't be changed, it makes very much sense to follow this pattern for all entities, even for internal use. Especially making sure classname is set to a sensible value is very helpful.

Methods are represented as fields of function type:

.void() think;

and are assigned to the function to be called in the spawn function, like:

void func_bobbing_think()
{
  // lots of stuff
}

void spawnfunc_func_bobbing()
{
  // ... even more stuff ...
  self.think = func_bobbing_think;
}

To call a method of the same object, you would use

self.think();

but to call a method of another object, you first have to set self to that other object, but you typically need to restore self to its previous value when done:

entity oldself;
// ...
oldself = self;
self.think();
self = oldself;

...

One common way to loop through entities is the find loop. It works by calling a built-in function like

entity find(entity start, .string field, string match) = #18;

repeatedly. This function is defined as follows:

• if start is world, the first entity e with e.field == match is returned
• otherwise, the entity e after start in the entity order with e.field == match is returned
• if no such entity exists, world is returned

It can be used to enumerate all entities of a given type, for example “info_player_deathmatch”:

entity e;
for(e = world; (e = find(e, classname, "info_player_deathmatch")); )
  print("Spawn point found at ", vtos(e.origin), "\n");

There are many other functions that can be used in find loops, for example findfloat, findflags, findentity.

Note that the function findradius is misnamed and is not used as part of a find loop, but instead sets up a linked list of the entities found.

An alternate way to loop through a set of entities is a linked list. I assume you are already familiar with the concept, so I'll skip information about how to manage them.

It is however noteworthy that some built-in functions create such linked lists using the entity field chain as list pointer. Some of these functions are the aforementioned findradius, and findchain, findchainfloat, findchainflags and findchainentity.

A loop like the following could be used with these:

entity e;
for(e = findchain(classname, "info_player_deathmatch"); e; e = e.chain)
  print("Spawn point found at ", vtos(e.origin), "\n");

The main advantage of linked lists however is that you can keep them in memory by using other fields than chain for storing their pointers. That way you can avoid having to search all entities over and over again (which is what find does internally) when you commonly need to work with the same type of entities.

Error handling is virtually not existent in Quake C code. There is no way to throw and handle exceptions.

However, built-in functions like fopen return -1 on error.

To report an error condition, the following means are open to you:

• Use the print function to spam it to the console. Hopefully someone will read that something went wrong. After that, possibly use remove to delete the entity that caused the error (but make sure there are no leftover references to it!).
• Use the error function to abort the program code and report a fatal error with a backtrace showing how it came to it.
• Use the objerror function to abort spawning an entity (i.e. removing it again). This also prints an error message, and the entity that caused the error will not exist in game. Do not forget to return from the spawn function directly after calling objerror!

With default compile options (i.e. if the option -flo is not passed to the compiler), boolean expressions are evaluated fully. This means that in

if(!flag && SomeComplexFunction(self))
  ...

SomeCompexFunction is always evaluated, even if flag is true. To avoid this, one can use:

if(!flag)
if(SomeComplexFunction(self))
  ...

Do not count on the modifying and reading operators like += or ++ to always work. Using them in simple cases like

a += 42;
for(i = 0; i < n; ++i)
  ...

is generally safe, but complex constructs like

self.enemy.frags += self.value--;

are doomed. Instead, split up such expressions into simpler steps:

self.enemy.frags = self.enemy.frags + self.value;
self.value -= 1;

The compiler warning RETURN VALUE ALREADY IN USE is a clear indicator that an expression was too complex for it to deal with it correctly. If you encounter the warning, do make sure you change the code to no longer cause it, as the generated code will be incorrect then.

Also, do not use the += like operators on vectors, as they are known to create incorrect code and only operate on the x component of the vector.

Mixing function calls with array dereferencing, or doing more than one array dereferencing in the same expression, is known to create incorrect code. Avoid constructs like

print(ftos(floatarray[i]), " --> ", stringarray[i], anotherstringarray[i], "\n");

as the array dereferencings and the ftos return value are likely to overwrite each other. Instead, simplify it:

float f;
string s, s2;
// ...
f = floatarray[i];
s = stringarray[i];
s2 = anotherstringarray[i];
print(ftos(f), " --> ", s, s2, "\n");

The pitch angle is inverted between these two functions. You have to negate the pitch (i.e. the x component of the vector representing the euler angles) to make it fit the other function.