PAW: The Professional Adventure Writer (1986, ZX Spectrum / Gilsoft International)

Author(s): Tim Gilberts, Graeme Yeandle, and Phil Wade (Gilsoft International)

Sources: Wikipedia: Professional Adventure Writer · IFWiki: PAW · Stefan Vogt: The Gilsoft Adventure Systems · ngPAWS / DAAD documentation (PAW-lineage condition/action model) · Internet Archive: P.A.W. (zx_P.A.W._Professional_Adventure_Writer_1986_Gilsoft_International)

Category: inspiration, Batch 10 (gameplay-mechanics mining). A shipped, mass-adopted authoring system that let non-programmers build complete text adventures from a small kit of tables, flags, objects, a vocabulary database, and a parser: the direct historical precedent for a cart grammar plus an SDK. Serves: IF Creation Kit / propaganda (assigned by Josh; see cart map)

What it is

PAW is Gilsoft’s adventure-creation package for the ZX Spectrum, and later the Amstrad CPC and PCW. It was the successor to The Quill (1983, Graeme Yeandle), which had already let people write machine-code text adventures with no programming knowledge. PAW folded in the functionality of Quill’s companion tools (The Illustrator for graphics, released 1984, and The Press) and added a much stronger parser and a full condition/action programming model. Thousands of published and homebrew Spectrum adventures were built with it. Where Adventure and Zork are landmark games, PAW is a landmark authoring engine: it packaged the whole IF machine into an editor an ordinary user could drive.

Mechanics

PAW is a database editor over a fixed table-driven runtime. An author fills in the tables; the runtime executes them. The pieces:

• Process tables. Game logic lives in numbered process tables. The two main ones, Process 1 and Process 2, are entered every turn; the author can define up to 254 tables in total and call one from another the way subroutines are called. Each table is a list of entries.
• Condition/action entries (“condacts”). Every table entry is keyed to a verb-noun pair and carries a list of conditions followed by a list of actions. The entry’s conditions are tested in order; if any fails, the entry is abandoned and the parser moves to the next entry; if all pass, the actions run. Conditions test location, object presence, and flag values (analogues in the descendant DAAD system include AT, PRESENT, CARRIED, ZERO, EQ, GT). Actions move the player, create/destroy/place objects, set flags, print messages, call another process, or end the turn (GET, DROP, CREATE, DESTROY, LET, MESSAGE, PROCESS, DONE).
• Flags. 256 general-purpose flags hold the mutable world state, some reserved by the system (for example the flag that always holds the player’s current location) and the rest free for the author to define.
• Objects. Each object carries a location, a weight, wearable/container status, and a set of binary attributes, so the runtime can reason about what is carried, worn, present, or elsewhere.
• Locations and connections. Numbered locations each hold descriptions and a connections table that lists which movement words lead where.
• A vocabulary database and a strong parser. Up to 1,500 words per game, each tagged as verb, noun, adjective, adverb, preposition, or pronoun, with synonyms sharing one word value. The parser reads complex input up to 125 characters, extracts a canonical sentence of the shape (adverb) verb (adjective noun) (preposition) (adjective noun), carries the previous verb forward when one is omitted (so GET SWORD AND SHIELD works), and resolves pronouns like IT against the last noun.
• PSI (pseudo-intelligence) characters. A non-player character is authored as a set of process-table entries that run each turn, giving the character autonomous, rule-driven behavior every turn. Contemporary reviews called this out as a headline PAW capability over The Quill.
• Graphics and packaging. A built-in graphics editor draws location pictures with line-and-fill primitives, plus text compression to fit more world into memory and multiple redefinable character sets. The package shipped with two manuals: a 66-page introductory guide and a 72-page technical guide.

Mineable patterns

• A whole authoring system from a handful of primitives. Tables + flags + objects + locations + a vocabulary + a parser is enough to express a large space of games. The kit is small; the reachable content is large.
• Behavior as condition/action entries keyed to input. “When the player types this and these conditions hold, run these actions” is a compact, inspectable rule format that scales from one-liners to full characters.
• Process tables as callable subroutines. Turn logic decomposes into named tables that call each other, which keeps a large world’s rules modular across named tables.
• A flag bank as the entire mutable world state. A fixed, bounded set of numbered flags holds everything that changes, so save/restore and reasoning about state stay simple and deterministic.
• NPCs authored as recurring rule sets (PSI). A character is a bundle of per-turn condition/action entries, so a character’s “intelligence” lives in author-written data.
• A layered parser with a canonical sentence form. Normalize messy typed input into a fixed (adverb) verb (adj noun) (prep) (adj noun) shape, with synonyms, verb carry-over, and pronoun resolution, so the game logic only ever sees clean tokens.

KN-86 resonance

Keep this at the concept level. The fit is with the authoring model, and this stops short of designing a specific cart.

• PAW is the closest 1980s analogue to KN-86’s cart-authoring stack: a fixed runtime plus an author-facing kit (the SDK, the .kn86 format, the cart grammar) from which complete content is assembled. It is a good reference when explaining why the KN-86 authoring surface is a small set of composable primitives.
• PAW’s condition/action condacts and process tables rhyme with cart behavior tables and event handlers: declare “when input and state, do actions,” and let the runtime dispatch. KN-86 expresses this in KEC Lisp handlers where PAW used a restricted table language, but the shape (“content as inspectable rules keyed to input and state”) is the same.
• The 256-flag bank as the complete mutable world state echoes KN-86’s bias toward bounded, human-readable save state and a deterministic state model.
• PSI (characters as recurring rule sets) is a concept-level precedent for authoring autonomous actors as data, which touches the CIPHER voice and mission/behavior tables without prescribing how any of them work.
• PAW’s layered parser and canonical sentence form is a reference for a keyboard-first typed-command surface (the TERM key / REPL context) that stays forgiving about phrasing while handing clean tokens to cart logic.

Sources & verification

Consulted: Wikipedia: Professional Adventure Writer (developers, Quill lineage, platforms, 1,500-word vocabulary, 256 flags, 125-character sentences, the parser’s word classes, the graphics editor and character sets); IFWiki: PAW and Stefan Vogt’s Gilsoft Adventure Systems (the Quill → Illustrator → PAW history and the “fused The Quill and its companion programs” framing); the ngPAWS / DAAD documentation, used to describe the shared PAW-lineage condition/action process-table model concretely (DAAD is the direct descendant of PAW and documents the same condacts, flags, objects, locations, and Logical Sentence parser); Internet Archive item zx_P.A.W._Professional_Adventure_Writer_1986_Gilsoft_International; and the Your Sinclair review summarized on Everygamegoing (its “PSI’s All Round” section confirms PSI as a headline feature).

Confidence: high on the overall architecture (process tables, condacts, flags, objects, locations, vocabulary, parser, graphics) and on the Quill/Illustrator lineage and the two manuals (66-page introductory, 72-page technical). Medium on precise counts as they applied to the 1986 Spectrum release specifically: the “up to 254 process tables” figure and the exact condition/action token names are drawn partly from the descendant DAAD documentation, which extended the model (DAAD numbers process tables 0–255); PAW’s own numbers may differ by one or two at the edges. The PSI definition (“a character whose per-turn activities are gathered into a process table”) is well attested but paraphrased from secondary sources and is not a direct quote from the PAW technical manual. Wikipedia’s infobox and body disagree on 1986 vs 1987 for the release year; 1986 is the commonly cited first-release year and is used here.