From 583066756567c4985f9f616b1f8a48936fef94e0 Mon Sep 17 00:00:00 2001 From: Glenn Hutchings Date: Fri, 22 Apr 2016 17:58:26 +0100 Subject: [PATCH] Use default role in glossary. --- appendices/g.rst | 341 +++++++++++++++++++++++------------------------ 1 file changed, 167 insertions(+), 174 deletions(-) diff --git a/appendices/g.rst b/appendices/g.rst index ff7a04d..a8d66c7 100644 --- a/appendices/g.rst +++ b/appendices/g.rst @@ -2,6 +2,8 @@ Appendix G -- Glossary ======================== +.. default-role:: term + .. only:: html .. image:: /images/picD.png @@ -19,60 +21,57 @@ phrases. .. glossary:: action - The generated effect of the player's input, usually by the - :term:`parser` but also occasionally by the designer's code. It - refers to a single task to be processed by Inform, such as DROP - KETTLE, and it's stored in four numbers: one each for the action - itself and the ``actor`` object who is to perform it (the player or - an :term:`NPC`), one for the ``noun`` -- or direct object, if - present -- and a fourth for the ``second`` noun -- if it exists, for - example the "POT" in THROW KETTLE AT POT. See also :term:`fake - action`. + The generated effect of the player's input, usually by the `parser` + but also occasionally by the designer's code. It refers to a single + task to be processed by Inform, such as DROP KETTLE, and it's stored + in four numbers: one each for the action itself and the ``actor`` + object who is to perform it (the player or an `NPC`), one for the + ``noun`` -- or direct object, if present -- and a fourth for the + ``second`` noun -- if it exists, for example the "POT" in THROW + KETTLE AT POT. See also `fake action`. alpha-testing - The testing which is carried out by the game's :term:`designer`, in - a futile attempt to ensure that it does everything that it should - and nothing that it shouldn't. See also :term:`beta-testing`. + The testing which is carried out by the game's `designer`, in a + futile attempt to ensure that it does everything that it should and + nothing that it shouldn't. See also `beta-testing`. argument - A parameter supplied in a call to a :term:`routine`, which is the - actual value for one of the routine's defined local variables. For + A parameter supplied in a call to a `routine`, which is the actual + value for one of the routine's defined local variables. For example, the argument is 8 in the call ``MyRoutine(8)``. The definition of the routine includes the variable that will hold the argument, in this case ``x``: ``[ MyRoutine x; ... ];`` ASCII file - See :term:`text file`. + See `text file`. assignment - A statement which sets or changes the value of a :term:`variable`. - There are three in Inform: ``=`` (set equal to), ``++`` (add one to - the current value), ``--`` (subtract one from the current value). + A statement which sets or changes the value of a `variable`. There + are three in Inform: ``=`` (set equal to), ``++`` (add one to the + current value), ``--`` (subtract one from the current value). attributes Named flags that can be defined for an object after the keyword - ``has`` . An attribute is either present (on) or not present - (off). The designer may test from any other part of the program - *if* an object *has* a certain attribute, *give* an attribute to an - object or take it away as need arises. For instance, the attribute + ``has`` . An attribute is either present (on) or not present (off). + The designer may test from any other part of the program *if* an + object *has* a certain attribute, *give* an attribute to an object + or take it away as need arises. For instance, the attribute ``container`` states that the object is capable of having other objects placed inside it. avatar - See :term:`player`. + See `player`. banner - Information about a game which is displayed at the start of play. beta-testing The testing which is carried out by a small band of trusted volunteers, prior to general public release, during which the gross - inadequacy of the designer's :term:`alpha-testing` effort becomes + inadequacy of the designer's `alpha-testing` effort becomes painfully apparent. binary file - A computer file containing binary data -- 0s and 1s -- which is created by a program and which only a program can understand. @@ -80,47 +79,46 @@ phrases. Used to highlight a term explained in this glossary. child - See :term:`object tree`. + See `object tree`. class - A special :term:`object` template from which other objects can - inherit :term:`properties` and/or :term:`attributes`. The template - must begin with the word ``Class`` and must have an internal - identifier. Objects that wish to inherit from a class usually - begin with the internal ID of the class in place of the word - ``Object`` , but may instead define a segment ``class`` followed by - the class's internal ID. The designer may test whether an object - belongs to -- is a member of -- a class. + A special `object` template from which other objects can inherit + `properties` and/or `attributes`. The template must begin with the + word ``Class`` and must have an internal identifier. Objects that + wish to inherit from a class usually begin with the internal ID of + the class in place of the word ``Object`` , but may instead define a + segment ``class`` followed by the class's internal ID. The designer + may test whether an object belongs to -- is a member of -- a class. code block - See :term:`statement block`. + See `statement block`. comment Text which starts with an exclamation mark ``!`` and which is - ignored by the compiler when it reads the :term:`source file`; - added to improve the file's layout or for explanatory notes. + ignored by the compiler when it reads the `source file`; added to + improve the file's layout or for explanatory notes. compile-time - The time when the :term:`compiler` is at work making the - :term:`story file`. See also :term:`run-time`. + The time when the `compiler` is at work making the `story file`. + See also `run-time`. compiler A program that reads the source code written by the designer and - turns it into a :term:`story file`, which can then be played by a - Z-machine :term:`interpreter`. + turns it into a `story file`, which can then be played by a + Z-machine `interpreter`. constant - A particular value which is defined at :term:`compile-time`, always - stays the same and cannot be changed while the game is being - played. Common examples include numbers, strings and the internal - IDs of objects, any of which can be either written out explicitly - or set as the value of a named ``Constant``. + A particular value which is defined at `compile-time`, always stays + the same and cannot be changed while the game is being played. + Common examples include numbers, strings and the internal IDs of + objects, any of which can be either written out explicitly or set as + the value of a named ``Constant``. Debug mode A option which causes to compiler to include extra code into the story file, thus making it easier for the designer to understand - what's happening while a game is being tested prior to release. - See also :term:`Strict mode`. + what's happening while a game is being tested prior to release. See + also `Strict mode`. designer A person who uses Inform to create a text adventure game: in other @@ -130,38 +128,35 @@ phrases. The collection of all input words "understood" by the game. dictionary word - A word written in single quotes '...' within the :term:`source - file`, usually (but not exclusively) as one of the values assigned - to an object's ``name`` property. All such words are stored in the - :term:`dictionary`, which is consulted by the :term:`parser` when - attempting to make sense of a player's command. Only the first - nine characters are significant (thus ``'cardiogram'`` and - ``'cardiograph'`` are treated as the same word). Use - ``'coins//p'`` to mark "``coins``" as plural, referring to all coin - objects which are present. Use ``'t//'`` to enter the - single-character word "t" into the dictionary (``'t'`` is a - constant representing a character value). + A word written in single quotes '...' within the `source file`, + usually (but not exclusively) as one of the values assigned to an + object's ``name`` property. All such words are stored in the + `dictionary`, which is consulted by the `parser` when attempting to + make sense of a player's command. Only the first nine characters + are significant (thus ``'cardiogram'`` and ``'cardiograph'`` are + treated as the same word). Use ``'coins//p'`` to mark "``coins``" + as plural, referring to all coin objects which are present. Use + ``'t//'`` to enter the single-character word "t" into the dictionary + (``'t'`` is a constant representing a character value). directive - A line of Inform code which asks the :term:`compiler` to do - something there and then, at :term:`compile-time`; typical examples - are to Include the contents of another file, or to set aside some - space within the story file where a variable value may be stored. - Not to be confused with a :term:`statement`, which asks the - compiler to compose an instruction which the interpreter will obey - at :term:`run-time`; typical examples are to display some text, or - to change the value held within a variable's storage space. + A line of Inform code which asks the `compiler` to do something + there and then, at `compile-time`; typical examples are to Include + the contents of another file, or to set aside some space within the + story file where a variable value may be stored. Not to be confused + with a `statement`, which asks the compiler to compose an + instruction which the interpreter will obey at `run-time`; typical + examples are to display some text, or to change the value held + within a variable's storage space. editor - A general-purpose program for creating and modifying :term:`text - file`\s. + A general-purpose program for creating and modifying `text file`\s. embedded routine A routine that is defined in the body of an object, as the value of - one of its :term:`properties`. Unlike a :term:`standalone - routine`, an embedded routine doesn't have a name of its own, and - returns ``false`` if execution reaches the terminating marker - ``]``. + one of its `properties`. Unlike a `standalone routine`, an embedded + routine doesn't have a name of its own, and returns ``false`` if + execution reaches the terminating marker ``]``. entry point One of a predefined list of optional routines which, if you provide @@ -176,31 +171,30 @@ phrases. of Receive (which can be intercepted by Y). false - A logical state which is the opposite of :term:`true`, represented - by the value 0. + A logical state which is the opposite of `true`, represented by the + value 0. flag A variable which can take only two possible values. function - See :term:`routine`. + See `routine`. global variable A variable not specific to any routine or object, which can be used by any routine in the game. inheritance - The process by which an :term:`object` belonging to a :term:`class` - acquires the properties and attributes of said class. Inheritance - happens automatically; the designer has just to create class - definitions, followed by objects having those classes. + The process by which an `object` belonging to a `class` acquires the + properties and attributes of said class. Inheritance happens + automatically; the designer has just to create class definitions, + followed by objects having those classes. interpreter - A program that reads the :term:`story file` of a game and enables - people to play it. Interpreters must be platform-specific (that - is, they will be different programs for each operating system), - thus allowing the story file to be universal and - platform-independent. + A program that reads the `story file` of a game and enables people + to play it. Interpreters must be platform-specific (that is, they + will be different programs for each operating system), thus allowing + the story file to be universal and platform-independent. italic type Used for emphasis, and as a placeholder to represent a value which @@ -208,11 +202,11 @@ phrases. library A group of text files, part of the Inform system, that includes the - :term:`parser`, definitions for the :term:`model world`, language - files, grammar definitions and a customised stock of default - answers and behaviour for the player's actions. The library will - make frequent calls to the game file to see if the designer wants - to override those defaults. + `parser`, definitions for the `model world`, language files, grammar + definitions and a customised stock of default answers and behaviour + for the player's actions. The library will make frequent calls to + the game file to see if the designer wants to override those + defaults. library files The actual files containing the source code of the library. There @@ -225,9 +219,9 @@ phrases. designer can call to perform some commonly useful task. local variable - A variable which is part of only one :term:`routine`; its value - remains unavailable to other routines in the game. The value of a - local variable is *not* preserved between calls to the routine. + A variable which is part of only one `routine`; its value remains + unavailable to other routines in the game. The value of a local + variable is *not* preserved between calls to the routine. model world The imaginary environment which the player character inhabits. @@ -242,140 +236,139 @@ phrases. random pedestrian. object - A group of :term:`routine`\s and variables bundled up together in a - coherent unit. Objects represent the items that make up the - :term:`model world` (a torch; a car; a beam of light; etc.), a fact - which organises the designer's code in sensible chunks, easy to - manage. Each object has two parts: the header, which comprises the - internal ID, the external name and its defined parent (all fields - are optional), and the body, which comprises the property variables - and attribute flags particular to that object, if any. + A group of `routine`\s and variables bundled up together in a + coherent unit. Objects represent the items that make up the `model + world` (a torch; a car; a beam of light; etc.), a fact which + organises the designer's code in sensible chunks, easy to manage. + Each object has two parts: the header, which comprises the internal + ID, the external name and its defined parent (all fields are + optional), and the body, which comprises the property variables and + attribute flags particular to that object, if any. object tree A hierarchy that defines objects' relationships in terms of - containment. Each :term:`object` is either contained within - another object -- its parent -- or is *not* contained; objects such - as rooms which are not within another object have the constant + containment. Each `object` is either contained within another + object -- its parent -- or is *not* contained; objects such as rooms + which are not within another object have the constant ``nothing`` (0) as a parent. An object contained within another is a child. For example, a shoe inside a box: the box is the shoe's parent and the shoe is a child of the box. Consider now this box being inside the wardrobe. The box is a child of the wardrobe, but - the shoe is still a child of the box, not the wardrobe. In a - normal game, the object tree will undergo many transformations as - the result of the player's activities. + the shoe is still a child of the box, not the wardrobe. In a normal + game, the object tree will undergo many transformations as the + result of the player's activities. parent - See :term:`object tree`. + See `object tree`. parser - Part of the :term:`library` which is responsible for analysing the + Part of the `library` which is responsible for analysing the player's input and trying to make sense of it, dividing it into separate words (verb, nouns) and trying to match them against the - words stored in the game's :term:`dictionary` and the actions - defined in the game's grammar. If the player's input makes sense, - the parser will trigger the resulting :term:`action`; if not, it - will complain that it didn't understand. + words stored in the game's `dictionary` and the actions defined in + the game's grammar. If the player's input makes sense, the parser + will trigger the resulting `action`; if not, it will complain that + it didn't understand. PC 1. a personal computer; - 2. the player character (see :term:`player`). + 2. the player character (see `player`). player 1. the final user of the game, normally a person full of radical opinions about your capabilities as a designer; - 2. a variable referring to the :term:`object` -- sometimes known as - an "avatar" -- which currently represents that user within the - :term:`model world`. + 2. a variable referring to the `object` -- sometimes known as an + "avatar" -- which currently represents that user within the + `model world`. print rule A customised rule to apply while in a ``print`` or ``print_ret`` statement, to control the manner in which an item of data is to be displayed. For example: ``print (The) noun, " is mine."`` is - telling the game to use a capitalised definite article for the - noun. The library defines a stock of print rules, and designers - may create some of their own. + telling the game to use a capitalised definite article for the noun. + The library defines a stock of print rules, and designers may create + some of their own. properties - Variables attached to a single :term:`object`, of which they are a - part. They are defined in the body of the object after the keyword + Variables attached to a single `object`, of which they are a part. + They are defined in the body of the object after the keyword ``with`` and have a name and a value. The latter (which defaults - to 0) can be a number, a string "...", a dictionary word '...' or - an embedded routine ``[;...]``; it can also be a list of those + to 0) can be a number, a string "...", a dictionary word '...' or an + embedded routine ``[;...]``; it can also be a list of those separated by spaces. The value of an object's property can be tested and changed from any part of the game. The fact that an object provides a property may be tested. RAIF - The ``rec.arts.int-fiction`` Usenet newsgroup for IF designers. + The :newsgroup:`rec.arts.int-fiction` Usenet newsgroup for IF + designers. RGIF - - The ``rec.games.int-fiction`` Usenet newsgroup for IF players. + The :newsgroup:`rec.games.int-fiction` Usenet newsgroup for IF + players. room - An :term:`object` which defines a geographical unit into which the - map of the :term:`model world` is divided. Rooms have no parent - object (or, more precisely, their parent object is ``nothing``) and - they represent the places where the player character is at any - given moment -- the player character can't be in more than one room - at a time. Note that the name "room" does not imply necessarily - "indoors". A clearing, a sandy beach, the top of a tree, even - floating in outer space -- these are all possible room objects. + An `object` which defines a geographical unit into which the map of + the `model world` is divided. Rooms have no parent object (or, more + precisely, their parent object is ``nothing``) and they represent + the places where the player character is at any given moment -- the + player character can't be in more than one room at a time. Note + that the name "room" does not imply necessarily "indoors". A + clearing, a sandy beach, the top of a tree, even floating in outer + space -- these are all possible room objects. routine In general terms, a routine is a computer program that makes some - specific calculation, following an ordered set of instructions; - this is the only unit of coherent and executable code understood by + specific calculation, following an ordered set of instructions; this + is the only unit of coherent and executable code understood by Inform. More practically, a routine is a collection of - :term:`statement`\s which are written between markers ``[...]``. - When a routine is "called", possibly with arguments -- specific - values for its defined variables, if they exist -- the interpreter - executes the statements in sequence. If the interpreter encounters - a ``return`` statement, or reaches the ``]`` at the end of the - routine, it immediately stops executing statements in the routine - and resumes execution at the statement which called that routine. - Every routine returns a value, which is either supplied by the - return statement or implied by the ] at the end of the routine. - See :term:`embedded routine` and :term:`standalone routine`. + `statement`\s which are written between markers ``[...]``. When a + routine is "called", possibly with arguments -- specific values for + its defined variables, if they exist -- the interpreter executes the + statements in sequence. If the interpreter encounters a ``return`` + statement, or reaches the ``]`` at the end of the routine, it + immediately stops executing statements in the routine and resumes + execution at the statement which called that routine. Every routine + returns a value, which is either supplied by the return statement or + implied by the ] at the end of the routine. See `embedded routine` + and `standalone routine`. run-time - The period of time when the :term:`interpreter` is running a - :term:`story file` (that is, someone is playing the game). See - also :term:`compile-time`. + The period of time when the `interpreter` is running a `story file` + (that is, someone is playing the game). See also `compile-time`. source file A text file containing your game defined using the Inform language. standalone routine - A routine which is not part of an object. Unlike an - :term:`embedded routine`, it must provide a name of its own, and it - returns ``true`` when execution reaches the terminating marker - ``]``. + A routine which is not part of an object. Unlike an `embedded + routine`, it must provide a name of its own, and it returns ``true`` + when execution reaches the terminating marker ``]``. statement - A single instruction to be executed at :term:`run-time`. See also - :term:`directive`. + A single instruction to be executed at `run-time`. See also + `directive`. statement block - A group of :term:`statement`\s bundled up together between braces + A group of `statement`\s bundled up together between braces ``{...}``, which are then treated as a single unit -- as if they were only one statement. They commonly appear in loops and conditions. story file - A binary file which is the output of the :term:`compiler` and can - be played through the use of an :term:`interpreter` (also known as - Z-code file or game file). The format of story files is standard - and platform-independent. + A binary file which is the output of the `compiler` and can be + played through the use of an `interpreter` (also known as Z-code + file or game file). The format of story files is standard and + platform-independent. Strict mode - An option which causes the :term:`compiler` to include extra code - into the story file, thus making it easier to detect certain design - mistakes while a game is being played. + An option which causes the `compiler` to include extra code into the + story file, thus making it easier to detect certain design mistakes + while a game is being played. string - A piece of text between double quotes "...", to be displayed for - the player's benefit at :term:`run-time`. + A piece of text between double quotes "...", to be displayed for the + player's benefit at `run-time`. switch 1. an optional keyword or symbol to operate special features of the @@ -388,21 +381,21 @@ phrases. read. true - A logical state which is the opposite of :term:`false`, represented - by any value other than zero (typically 1). + A logical state which is the opposite of `false`, represented by any + value other than zero (typically 1). variable - A named value which can change during :term:`run-time`. It must be + A named value which can change during `run-time`. It must be declared before use, either as a ``Global`` variable (available to any routine within the game), or as a local variable (part of one specific routine and usable by that routine alone). Variables have a name and a value; it's the value which is capable of change, not - the name. Object :term:`properties` behave as variables. + the name. Object `properties` behave as variables. Z-code file - See :term:`story file`. + See `story file`. Z-machine A virtual machine (an imaginary computer simulated by the - :term:`interpreter`) on which story files run. Z stands for - "Zork", the first ever Infocom title. + `interpreter`) on which story files run. Z stands for "Zork", the + first ever Infocom title. -- 2.31.1