is possibly the first in-game scripting language
ever written. ZZT-oop was designed by Tim Sweeney as the scripting language used for his ground-breaking computer game ZZT
ZZT-oop is both object-oriented and multi threaded, it is a linear script of instructions prefixed with symbols that has a direct connection to an in-game "object" or scripted entity. Each object has a geographical position within the game, a single script, and a single point in this script that execution is currently at. Although wholly a game scripting language with little other use, it may be seen as a precursor to the far more advanced UnrealScript by the same author, and indeed possibly all game scripting languages.
Peculiarities and limitations
The ZZT-oop language is very limited in application to say the least. It was designed for simplicity rather than flexibility. Boolean flags are the only type of variables, making arithmetic impossible, forcing the programmer to be creative with algorithms, often relying on physical movement, possibly in invisible (but still physically present) objects rather than arithmetic calculations.
Although ZZT-oop is object oriented, objects are not instantiable due to their physical nature, meaning that one needs to duplicate much code to create complex systems.
ZZT-oop also lacks functions, and routines are likely to be interrupted &emdash; by rogue messages including ones sent by the object itself when it is shot or touched &emdash; and never completed. One can overcome this crudely using state flags or using the lock and unlock commands during important routines; however, this is likely to cause the object to miss out on signals.
ZZT-oop is wholly run-time interpreted with no pre-parsing. No lexical analysis is performed before running, nor is any byte code translation applied. This means that any errors are reported in a cryptic way during run-time, and this can make debugging consuming and frustrating.
However the language does have some advantages, its simplicity and intuitiveness for one, its lack of mathematical operators and integration within a fun game makes it very nonthreatening to budding programmers in primary school. The physical nature with a concrete geographic position makes objects far easier to visualise than abstract data types, and the parallel operating multi thread design is easy for one to think about in terms of a dynamic environment.
The syntax of the language is simple, there are 4 categories of instructions:
- Unprefixed instructions, cause the object to open up a message window and display text to the player
- Directions are prefixed with a / or a ?, they instruct an object to physically move north, south, east, west or idle for a cycle.
- Commands are prefixed with a # and they specify all interactions with the environment, whether it be shooting, setting a flag, sending a message or processing an if statement. There are hundreds of commands, but listing them is beyond the scope of this document.
- Messages are similar to a goto statement in primitive languages, the only difference is that they may optionally be sent to another object and cause that other object's own execution path to jump to that point in the script. The points that may be jumped to are prefixed with a : and are used to denote both what the name of the message is, and where it should jump when that message is received.
- Flags are global boolean variables used for conditionals that may only be set or cleared with commands, if the #if command is called the flag will be evaluated and if it is set to true, the message listed after will be sent, causing the script to jump to that point.
ZZT-oop provides a great stepping stone into programming especially for children, it has a huge amount of historical significance, it will provide one with many hours of fun, but very little else.