Use pagestyle for standard page headings.

[ibg.git] / appendices / g.rst

diff --git a/appendices/g.rst b/appendices/g.rst
index ff7a04ded3174a70e53c9acf490ce5a4c9bf71af..a8d66c75d629bbbe6363fdba71385b7fcc6c3ea7 100644 (file)
--- a/appendices/g.rst
+++ b/appendices/g.rst
@@ -2,6 +2,8 @@
  Appendix G -- Glossary
 ========================
 
  Appendix G -- Glossary
 ========================
 

+.. default-role:: term
+

 .. only:: html
 
    .. image:: /images/picD.png
 .. only:: html
 
    .. image:: /images/picD.png


@@ -19,60 +21,57 @@ phrases.
 .. glossary::
 
    action
 .. 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
 
    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
 
    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
        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
 
    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
 
    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
        ``container`` states that the object is capable of having other
        objects placed inside it.
 
    avatar

-       See :term:`player`.
+       See `player`.

 
    banner
 
    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
        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
        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.
 
        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
        Used to highlight a term explained in this glossary.
 
    child

-       See :term:`object tree`.
+       See `object tree`.

 
    class
 
    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
 
    code block

-       See :term:`statement block`.
+       See `statement block`.

 
    comment
        Text which starts with an exclamation mark ``!`` and which is
 
    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
 
    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
 
    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
 
    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
 
    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
 
    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
        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
 
    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
 
    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
 
    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
 
    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
        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
 
    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
 
    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
 
    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
 
    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
 
    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
 
    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
        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.
 
    model world
        The imaginary environment which the player character inhabits.


@@ -242,140 +236,139 @@ phrases.
        random pedestrian.
 
    object
        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
 
    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
        ``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
 
    parent

-       See :term:`object tree`.
+       See `object tree`.

 
    parser
 
    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
        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;
 
    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;
 
    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
 
    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
 
    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
        ``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
        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
 
    RGIF

-
-       The ``rec.games.int-fiction`` Usenet newsgroup for IF players.
+       The :newsgroup:`rec.games.int-fiction` Usenet newsgroup for IF
+       players.

 
    room
 
    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
 
    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
        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
 
    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
 
    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
 
    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
 
    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
        ``{...}``, 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
 
    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
 
    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
 
    switch
        1. an optional keyword or symbol to operate special features of the


@@ -388,21 +381,21 @@ phrases.
        read.
 
    true
        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
 
    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
        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
 
    Z-code file

-       See :term:`story file`.
+       See `story file`.

 
    Z-machine
        A virtual machine (an imaginary computer simulated by the
 
    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.