Standard Rules by Graham Nelson

Documentation for Version 3/120430 of the Standard Rules by Graham Nelson   Unlike other extensions, the Standard Rules are compulsorily included with every project. They define the phrases, kinds and relations which are basic to Inform, and which are described throughout the documentation.

  Section SR3/4 - Locale descriptions - Unindexed   Table of Locale Priorities

with blank rows for each thing.   To describe locale for (O - object):   carry out the printing the locale description activity with O.   To set the/-- locale priority of (O - an object) to (N - a number):   if O is a thing:      if N <= 0, now O is mentioned;      if there is a notable-object of O in the Table of Locale Priorities:         choose row with a notable-object of O in the Table of Locale Priorities;         if N <= 0, blank out the whole row;         otherwise now the locale description priority entry is N;      otherwise:         if N is greater than 0:            choose a blank row in the Table of Locale Priorities;            now the notable-object entry is O;            now the locale description priority entry is N;   Printing the locale description of something (documented at act_pld) is an activity. [30]   The locale paragraph count is a number that varies.   Before printing the locale description (this is the initialise locale description rule):   now the locale paragraph count is 0;   repeat through the Table of Locale Priorities:      blank out the whole row.   Before printing the locale description (this is the find notable locale objects rule):   let the domain be the parameter-object;   carry out the choosing notable locale objects activity with the domain;   continue the activity.   For printing the locale description (this is the interesting locale paragraphs rule):   let the domain be the parameter-object;   sort the Table of Locale Priorities in locale description priority order;   repeat through the Table of Locale Priorities:      carry out the printing a locale paragraph about activity with the notable-object entry;   continue the activity.   For printing the locale description (this is the you-can-also-see rule):   let the domain be the parameter-object;   let the mentionable count be 0;   repeat with item running through things:      now the item is not marked for listing;   repeat through the Table of Locale Priorities:      if the locale description priority entry is greater than 0,         now the notable-object entry is marked for listing;      increase the mentionable count by 1;   if the mentionable count is greater than 0:      repeat with item running through things:         if the item is mentioned:            now the item is not marked for listing;      begin the listing nondescript items activity with the domain;      if the number of marked for listing things is 0:         abandon the listing nondescript items activity with the domain;      otherwise:         if handling the listing nondescript items activity with the domain:            if the domain is the location:               say "[We] " (A);            otherwise if the domain is a supporter or the domain is an animal:               say "On [the domain] [we] " (B);            otherwise:               say "In [the domain] [we] " (C);            if the locale paragraph count is greater than 0:               say "[regarding the player][can] also see " (D);            otherwise:               say "[regarding the player][can] see " (E);            let the common holder be nothing;            let contents form of list be true;            repeat with list item running through marked for listing things:               if the holder of the list item is not the common holder:                  if the common holder is nothing,                     now the common holder is the holder of the list item;                  otherwise now contents form of list is false;               if the list item is mentioned, now the list item is not marked for listing;            filter list recursion to unmentioned things;            if contents form of list is true and the common holder is not nothing,               list the contents of the common holder, as a sentence, including contents,                  giving brief inventory information, tersely, not listing                  concealed items, listing marked items only;            otherwise say "[a list of marked for listing things including contents]";            if the domain is the location, say " here" (F);            say ".[paragraph break]";            unfilter list recursion;         end the listing nondescript items activity with the domain;   continue the activity.   Choosing notable locale objects of something (documented at act_cnlo) is an activity. [31]   For choosing notable locale objects (this is the standard notable locale objects rule):   let the domain be the parameter-object;   let the held item be the first thing held by the domain;   while the held item is a thing:      set the locale priority of the held item to 5;      now the held item is the next thing held after the held item;   continue the activity.   Printing a locale paragraph about something (documented at act_plp) is an activity. [32]   For printing a locale paragraph about a thing (called the item)   (this is the don't mention player's supporter in room descriptions rule):   if the item encloses the player, set the locale priority of the item to 0;   continue the activity.   For printing a locale paragraph about a thing (called the item)   (this is the don't mention scenery in room descriptions rule):   if the item is scenery, set the locale priority of the item to 0;   continue the activity.   For printing a locale paragraph about a thing (called the item)   (this is the don't mention undescribed items in room descriptions rule):   if the item is undescribed:      set the locale priority of the item to 0;   continue the activity.   For printing a locale paragraph about a thing (called the item)   (this is the set pronouns from items in room descriptions rule):   if the item is not mentioned, set pronouns from the item;   continue the activity.   For printing a locale paragraph about a thing (called the item)   (this is the offer items to writing a paragraph about rule):   if the item is not mentioned:      if a paragraph break is pending, say "[conditional paragraph break]";      carry out the writing a paragraph about activity with the item;      if a paragraph break is pending:         increase the locale paragraph count by 1;         now the item is mentioned;         say "[conditional paragraph break]";   continue the activity.   For printing a locale paragraph about a thing (called the item)   (this is the use initial appearance in room descriptions rule):   if the item is not mentioned:      if the item provides the property initial appearance and the         item is not handled and the initial appearance of the item is         not "":         increase the locale paragraph count by 1;         say "[initial appearance of the item]";         say "[paragraph break]";         if a locale-supportable thing is on the item:            repeat with possibility running through things on the item:               now the possibility is marked for listing;               if the possibility is mentioned:                  now the possibility is not marked for listing;            say "On [the item] " (A);            list the contents of the item, as a sentence, including contents,               giving brief inventory information, tersely, not listing               concealed items, prefacing with is/are, listing marked items only;            say ".[paragraph break]";         now the item is mentioned;   continue the activity.   For printing a locale paragraph about a supporter (called the tabletop)   (this is the initial appearance on supporters rule):   repeat with item running through not handled things on the tabletop which      provide the property initial appearance:      if the item is not a person and the initial appearance of the item is not ""         and the item is not undescribed:         now the item is mentioned;         say initial appearance of the item;         say paragraph break;   continue the activity.   Definition: a thing (called the item) is locale-supportable if the item is not scenery and the item is not mentioned and the item is not undescribed.   For printing a locale paragraph about a thing (called the item)   (this is the describe what's on scenery supporters in room descriptions rule):   if the item is scenery and the item does not enclose the player:      if a locale-supportable thing is on the item:         set pronouns from the item;         repeat with possibility running through things on the item:            now the possibility is marked for listing;            if the possibility is mentioned:               now the possibility is not marked for listing;         increase the locale paragraph count by 1;         say "On [the item] " (A);         list the contents of the item, as a sentence, including contents,            giving brief inventory information, tersely, not listing            concealed items, prefacing with is/are, listing marked items only;         say ".[paragraph break]";   continue the activity.   For printing a locale paragraph about a thing (called the item)   (this is the describe what's on mentioned supporters in room descriptions rule):   if the item is mentioned and the item is not undescribed and the item is      not scenery and the item does not enclose the player:      if a locale-supportable thing is on the item:         set pronouns from the item;         repeat with possibility running through things on the item:            now the possibility is marked for listing;            if the possibility is mentioned:               now the possibility is not marked for listing;         increase the locale paragraph count by 1;         say "On [the item] " (A);         list the contents of the item, as a sentence, including contents,            giving brief inventory information, tersely, not listing            concealed items, prefacing with is/are, listing marked items only;         say ".[paragraph break]";   continue the activity.   Issuing the response text of something -- documented at act_resp -- is an activity on responses. [33]   The standard issuing the response text rule is listed last in for issuing the response text.   The standard issuing the response text rule translates into I6 as "STANDARD_RESPONSE_ISSUING_R".     Part SR4 - Actions   Section SR4/1 - Verbs needed for adaptive text   To achieve is a verb. To appreciate is a verb. To arrive is a verb. To care is a verb. To close is a verb. To die is a verb. To discover is a verb. To drop is a verb. To eat is a verb. To feel is a verb. To find is a verb. To get is a verb. To give is a verb. To go is a verb. To happen is a verb. To hear is a verb. To jump is a verb. To lack is a verb. To lead is a verb. To like is a verb. To listen is a verb. To lock is a verb. To look is a verb. To need is a verb. To open is a verb. To pass is a verb. To pick is a verb. To provoke is a verb. To pull is a verb. To push is a verb. To put is a verb. To rub is a verb. To say is a verb. To search is a verb. To see is a verb. To seem is a verb. To set is a verb. To smell is a verb. To sniff is a verb. To squeeze is a verb. To switch is a verb. To take is a verb. To talk is a verb. To taste is a verb. To touch is a verb. To turn is a verb. To wait is a verb. To wave is a verb. To win is a verb.   Section SR4/2 - Standard actions concerning the actor's possessions   Taking inventory is an action applying to nothing. The taking inventory action translates into I6 as "Inv".   The specification of the taking inventory action is "Taking an inventory of one's immediate possessions: the things being carried, either directly or in any containers being carried. When the player performs this action, either the inventory listing, or else a special message if nothing is being carried or worn, is printed during the carry out rules: nothing happens at the report stage. The opposite happens for other people performing the action: nothing happens during carry out, but a report such as 'Mr X looks through his possessions.' is produced (provided Mr X is visible)."   Carry out taking inventory (this is the print empty inventory rule):   if the first thing held by the player is nothing,      say "[We] [are] carrying nothing." (A) instead.   Carry out taking inventory (this is the print standard inventory rule):   say "[We] [are] carrying:[line break]" (A);   list the contents of the player, with newlines, indented, including contents,      giving inventory information, with extra indentation.   Report an actor taking inventory (this is the report other people taking   inventory rule):   if the actor is not the player and the action is not silent:      say "[The actor] [look] through [their] possessions." (A);   Taking is an action applying to one thing. The taking action translates into I6 as "Take".   The specification of the taking action is "The taking action is the only way an action in the Standard Rules can cause something to be carried by an actor. It is very simple in operation (the entire carry out stage consists only of 'now the actor carries the noun') but many checks must be performed before it can be allowed to happen."   Check an actor taking (this is the can't take yourself rule):   if the actor is the noun:      if the actor is the player, say "[We] [are] always self-possessed." (A);      stop the action.   Check an actor taking (this is the can't take other people rule):   if the noun is a person:      if the actor is the player, say "I don't suppose [the noun] [would care] for that." (A);      stop the action.   Check an actor taking (this is the can't take component parts rule):   if the noun is part of something (called the whole):      if the actor is the player:         say "[regarding the noun][Those] [seem] to be a part of [the whole]." (A);      stop the action.   Check an actor taking (this is the can't take people's possessions rule):   let the local ceiling be the common ancestor of the actor with the noun;   let the owner be the not-counting-parts holder of the noun;   while the owner is not nothing and the owner is not the local ceiling:      if the owner is a person:         if the actor is the player:            say "[regarding the noun][Those] [seem] to belong to [the owner]." (A);         stop the action;      let the owner be the not-counting-parts holder of the owner;   Check an actor taking (this is the can't take items out of play rule):   let H be the noun;   while H is not nothing and H is not a room:      let H be the not-counting-parts holder of H;   if H is nothing:      if the actor is the player:         say "[regarding the noun][Those] [aren't] available." (A);      stop the action.   Check an actor taking (this is the can't take what you're inside rule):   let the local ceiling be the common ancestor of the actor with the noun;   if the local ceiling is the noun:      if the actor is the player:         say "[We] [would have] to get            [if noun is a supporter]off[otherwise]out of[end if] [the noun] first." (A);      stop the action.   Check an actor taking (this is the can't take what's already taken rule):   if the actor is carrying the noun or the actor is wearing the noun:      if the actor is the player:         say "[We] already [have] [regarding the noun][those]." (A);      stop the action.   Check an actor taking (this is the can't take scenery rule):   if the noun is scenery:      if the actor is the player:         say "[regarding the noun][They're] hardly portable." (A);      stop the action.   Check an actor taking (this is the can only take things rule):   if the noun is not a thing:      if the actor is the player:         say "[We] [cannot] carry [the noun]." (A);      stop the action.   Check an actor taking (this is the can't take what's fixed in place rule):   if the noun is fixed in place:      if the actor is the player:         say "[regarding the noun][They're] fixed in place." (A);      stop the action.   Check an actor taking (this is the use player's holdall to avoid exceeding   carrying capacity rule):   if the number of things carried by the actor is at least the      carrying capacity of the actor:      if the actor is holding a player's holdall (called the current working sack):         let the transferred item be nothing;         repeat with the possible item running through things carried by            the actor:            if the possible item is not lit and the possible item is not               the current working sack, let the transferred item be the possible item;         if the transferred item is not nothing:            if the actor is the player:               say "(putting [the transferred item] into [the current working sack]                  to make room)[command clarification break]" (A);            silently try the actor trying inserting the transferred item               into the current working sack;            if the transferred item is not in the current working sack:               stop the action.   Check an actor taking (this is the can't exceed carrying capacity rule):   if the number of things carried by the actor is at least the      carrying capacity of the actor:      if the actor is the player:         say "[We]['re] carrying too many things already." (A);      stop the action.   Carry out an actor taking (this is the standard taking rule):   now the actor carries the noun;   if the actor is the player, now the noun is handled.   Report an actor taking (this is the standard report taking rule):   if the action is not silent:      if the actor is the player:         say "Taken." (A);      otherwise:         say "[The actor] [pick] up [the noun]." (B).   Removing it from is an action applying to two things. The removing it from action translates into I6 as "Remove".   The specification of the removing it from action is "Removing is not really an action in its own right. Whereas there are many ways to put something down (on the floor, on top of something, inside something else, giving it to somebody else, and so on), Inform has only one way to take something: the taking action. Removing exists only to provide some nicely worded replies to impossible requests, and in all sensible cases is converted into taking. Because of this, it's usually a bad idea to write rules about removing: if you write a rule such as 'Instead of removing the key, ...' then it won't apply if the player simply types TAKE KEY instead. The safe way to do this is to write a rule about taking, which covers all possibilities."   Check an actor removing something from (this is the can't remove what's not inside rule):   if the holder of the noun is not the second noun:      if the actor is the player:         say "But [regarding the noun][they] [aren't] there now." (A);      stop the action.   Check an actor removing something from (this is the can't remove from people rule):   let the owner be the holder of the noun;   if the owner is a person:      if the owner is the actor, convert to the taking off action on the noun;      if the actor is the player:         say "[regarding the noun][Those] [seem] to belong to [the owner]." (A);      stop the action.   Check an actor removing something from (this is the convert remove to take rule):   convert to the taking action on the noun.   The can't take component parts rule is listed before the can't remove what's not inside rule in the check removing it from rules.   Dropping is an action applying to one thing. The dropping action translates into I6 as "Drop".   The specification of the dropping action is "Dropping is one of five actions by which an actor can get rid of something carried: the others are inserting (into a container), putting (onto a supporter), giving (to someone else) and eating. Dropping means dropping onto the actor's current floor, which is usually the floor of a room - but might be the inside of a box if the actor is also inside that box, and so on.   The can't drop clothes being worn rule silently tries the taking off action on any clothing being dropped: unlisting this rule removes both this behaviour and also the requirement that clothes cannot simply be dropped."   Check an actor dropping (this is the can't drop yourself rule):   if the noun is the actor:      if the actor is the player:         say "[We] [lack] the dexterity." (A);      stop the action.   Check an actor dropping something which is part of the actor (this is the   can't drop body parts rule):   if the actor is the player:      say "[We] [can't drop] part of [ourselves]." (A);   stop the action.   Check an actor dropping (this is the can't drop what's already dropped rule):   if the noun is in the holder of the actor:      if the actor is the player:         say "[The noun] [are] already here." (A);      stop the action.   Check an actor dropping (this is the can't drop what's not held rule):   if the actor is carrying the noun, continue the action;   if the actor is wearing the noun, continue the action;   if the actor is the player:      say "[We] [haven't] got [regarding the noun][those]." (A);   stop the action.   Check an actor dropping (this is the can't drop clothes being worn rule):   if the actor is wearing the noun:      if the actor is the player:         say "(first taking [the noun] off)[command clarification break]" (A);      silently try the actor trying taking off the noun;      if the actor is wearing the noun, stop the action;   Check an actor dropping (this is the can't drop if this exceeds carrying   capacity rule):   let the receptacle be the holder of the actor;   if the receptacle is a room, continue the action; [room floors have infinite capacity]   if the receptacle provides the property carrying capacity:      if the receptacle is a supporter:         if the number of things on the receptacle is at least the carrying            capacity of the receptacle:            if the actor is the player:               now the prior named object is nothing;               say "[There] [are] no more room on [the receptacle]." (A);            stop the action;      otherwise if the receptacle is a container:         if the number of things in the receptacle is at least the carrying            capacity of the receptacle:            if the actor is the player:               now the prior named object is nothing;               say "[There] [are] no more room in [the receptacle]." (B);            stop the action;   Carry out an actor dropping (this is the standard dropping rule):   now the noun is in the holder of the actor.   Report an actor dropping (this is the standard report dropping rule):   if the action is not silent:       if the actor is the player:         say "Dropped." (A);      otherwise:         say "[The actor] [put] down [the noun]." (B);   Putting it on is an action applying to two things. The putting it on action translates into I6 as "PutOn".   The specification of the putting it on action is "By this action, an actor puts something he is holding on top of a supporter: for instance, putting an apple on a table."   Check an actor putting something on (this is the convert put to drop where possible rule):   if the second noun is down or the actor is on the second noun,      convert to the dropping action on the noun.   Check an actor putting something on (this is the can't put what's not held rule):   if the actor is carrying the noun, continue the action;   if the actor is wearing the noun, continue the action;   carry out the implicitly taking activity with the noun;   if the actor is carrying the noun, continue the action;   stop the action.   Check an actor putting something on (this is the can't put something on itself rule):   let the noun-CPC be the component parts core of the noun;   let the second-CPC be the component parts core of the second noun;   let the transfer ceiling be the common ancestor of the noun-CPC with the second-CPC;   if the transfer ceiling is the noun-CPC:      if the actor is the player:         say "[We] [can't put] something on top of itself." (A);      stop the action.   Check an actor putting something on (this is the can't put onto what's not a supporter rule):   if the second noun is not a supporter:      if the actor is the player:         say "Putting things on [the second noun] [would achieve] nothing." (A);      stop the action.   Check an actor putting something on (this is the can't put clothes being worn rule):   if the actor is wearing the noun:      if the actor is the player:         say "(first taking [regarding the noun][them] off)[command clarification break]" (A);      silently try the actor trying taking off the noun;      if the actor is wearing the noun, stop the action.   Check an actor putting something on (this is the can't put if this exceeds   carrying capacity rule):   if the second noun provides the property carrying capacity:      if the number of things on the second noun is at least the carrying capacity         of the second noun:         if the actor is the player:            say "[There] [are] no more room on [the second noun]." (A);         stop the action.   Carry out an actor putting something on (this is the standard putting rule):   now the noun is on the second noun.   Report an actor putting something on (this is the concise report putting rule):   if the action is not silent:      if the actor is the player and the I6 parser is running multiple actions:         say "Done." (A);         stop the action;   continue the action.   Report an actor putting something on (this is the standard report putting rule):   if the action is not silent:      say "[The actor] [put] [the noun] on [the second noun]." (A).   Inserting it into is an action applying to two things. The inserting it into action translates into I6 as "Insert".   The specification of the inserting it into action is "By this action, an actor puts something he is holding into a container: for instance, putting a coin into a collection box."   Check an actor inserting something into (this is the convert insert to drop where   possible rule):   if the second noun is down or the actor is in the second noun,      convert to the dropping action on the noun.   Check an actor inserting something into (this is the can't insert what's not held rule):   if the actor is carrying the noun, continue the action;   if the actor is wearing the noun, continue the action;   carry out the implicitly taking activity with the noun;   if the actor is carrying the noun, continue the action;   stop the action.   Check an actor inserting something into (this is the can't insert something into itself rule):   let the noun-CPC be the component parts core of the noun;   let the second-CPC be the component parts core of the second noun;   let the transfer ceiling be the common ancestor of the noun-CPC with the second-CPC;   if the transfer ceiling is the noun-CPC:      if the actor is the player:         say "[We] [can't put] something inside itself." (A);      stop the action.   Check an actor inserting something into (this is the can't insert into closed containers rule):   if the second noun is a closed container:      if the actor is the player:         say "[The second noun] [are] closed." (A);      stop the action.   Check an actor inserting something into (this is the can't insert into what's not a   container rule):   if the second noun is not a container:      if the actor is the player:         say "[regarding the second noun][Those] [can't contain] things." (A);      stop the action.   Check an actor inserting something into (this is the can't insert clothes being worn rule):   if the actor is wearing the noun:      if the actor is the player:         say "(first taking [regarding the noun][them] off)[command clarification break]" (A);      silently try the actor trying taking off the noun;      if the actor is wearing the noun, stop the action;   Check an actor inserting something into (this is the can't insert if this exceeds   carrying capacity rule):   if the second noun provides the property carrying capacity:      if the number of things in the second noun is at least the carrying capacity      of the second noun:         if the actor is the player:            now the prior named object is nothing;            say "[There] [are] no more room in [the second noun]." (A);         stop the action.   Carry out an actor inserting something into (this is the standard inserting rule):   now the noun is in the second noun.   Report an actor inserting something into (this is the concise report inserting rule):   if the action is not silent:      if the actor is the player and the I6 parser is running multiple actions:         say "Done." (A);         stop the action;   continue the action.   Report an actor inserting something into (this is the standard report inserting rule):   if the action is not silent:      say "[The actor] [put] [the noun] into [the second noun]." (A).   Eating is an action applying to one thing. The eating action translates into I6 as "Eat".   The specification of the eating action is "Eating is the only one of the built-in actions which can, in effect, destroy something: the carry out rule removes what's being eaten from play, and nothing in the Standard Rules can then get at it again.   Note that, uncontroversially, one can only eat things with the 'edible' either/or property. Until 2011, the action also required that the foodstuff had to be carried by the eater, which meant that a player standing next to a bush with berries who typed EAT BERRIES would force a '(first taking the berries)' action. This is no longer true. Taking is now only forced if the foodstuff is portable."   Check an actor eating (this is the can't eat unless edible rule):   if the noun is not a thing or the noun is not edible:      if the actor is the player:         say "[regarding the noun][They're] plainly inedible." (A);      stop the action.   Check an actor eating (this is the can't eat clothing without removing it first rule):   if the actor is wearing the noun:      if the actor is the player:         say "(first taking [the noun] off)[command clarification break]" (A);      try the actor trying taking off the noun;      if the actor is wearing the noun, stop the action.   Check an actor eating (this is the can't eat other people's food rule):   if the noun is enclosed by a person (called the owner) who is not the actor:      if the actor is the player:         say "[The owner] [might not appreciate] that." (A);      stop the action.   Check an actor eating (this is the can't eat portable food without carrying it rule):   if the noun is portable and the actor is not carrying the noun:      carry out the implicitly taking activity with the noun;      if the actor is not carrying the noun, stop the action.   Carry out an actor eating (this is the standard eating rule):   now the noun is nowhere.   Report an actor eating (this is the standard report eating rule):   if the action is not silent:      if the actor is the player:         say "[We] [eat] [the noun]. Not bad." (A);      otherwise:         say "[The actor] [eat] [the noun]." (B).   Section SR4/3 - Standard actions which move the actor   Going is an action applying to one visible thing. The going action translates into I6 as "Go".   The specification of the going action is "This is the action which allows people to move from one room to another, using whatever map connections and doors are to hand. The Standard Rules are written so that the noun can be either a direction or a door in the location of the actor: while the player's commands only lead to going actions with directions as nouns, going actions can also happen as a result of entering actions, and then the noun can indeed be a door."   The going action has a room called the room gone from (matched as "from"). The going action has an object called the room gone to (matched as "to"). The going action has an object called the door gone through (matched as "through"). The going action has an object called the vehicle gone by (matched as "by"). The going action has an object called the thing gone with (matched as "with").   Rule for setting action variables for going (this is the standard set going variables rule):   now the thing gone with is the item-pushed-between-rooms;   now the room gone from is the location of the actor;   if the actor is in an enterable vehicle (called the carriage),      now the vehicle gone by is the carriage;   let the target be nothing;   if the noun is a direction:      let direction D be the noun;      let the target be the room-or-door direction D from the room gone from;   otherwise:      if the noun is a door, let the target be the noun;   if the target is a door:      now the door gone through is the target;      now the target is the other side of the target from the room gone from;   now the room gone to is the target.   Check an actor going when the actor is on a supporter (called the chaise)   (this is the stand up before going rule):   if the actor is the player:      say "(first getting off [the chaise])[command clarification break]" (A);   silently try the actor exiting.   Check an actor going (this is the can't travel in what's not a vehicle rule):   let nonvehicle be the holder of the actor;   if nonvehicle is the room gone from, continue the action;   if nonvehicle is the vehicle gone by, continue the action;   if the actor is the player:      if nonvehicle is a supporter:         say "[We] [would have] to get off [the nonvehicle] first." (A);      otherwise:          say "[We] [would have] to get out of [the nonvehicle] first." (B);   stop the action.   Check an actor going (this is the can't go through undescribed doors rule):   if the door gone through is not nothing and the door gone through is undescribed:      if the actor is the player:         say "[We] [can't go] that way." (A);      stop the action.   Check an actor going (this is the can't go through closed doors rule):   if the door gone through is not nothing and the door gone through is closed:      if the actor is the player:         say "(first opening [the door gone through])[command clarification break]" (A);      silently try the actor opening the door gone through;      if the door gone through is open, continue the action;      stop the action.   Check an actor going (this is the determine map connection rule):   let the target be nothing;   if the noun is a direction:      let direction D be the noun;      let the target be the room-or-door direction D from the room gone from;   otherwise:      if the noun is a door, let the target be the noun;   if the target is a door:      now the target is the other side of the target from the room gone from;   now the room gone to is the target.   Check an actor going (this is the can't go that way rule):   if the room gone to is nothing:      if the door gone through is nothing:         if the actor is the player:            say "[We] [can't go] that way." (A);         stop the action;      if the actor is the player:         say "[We] [can't], since [the door gone through] [lead] nowhere." (B);      stop the action.   Carry out an actor going (this is the move player and vehicle rule):   if the vehicle gone by is nothing,      surreptitiously move the actor to the room gone to during going;   otherwise      surreptitiously move the vehicle gone by to the room gone to during going;   if the location is not the location of the player:      now the location is the location of the player.   Carry out an actor going (this is the move floating objects rule):   if the actor is the player or the player is within the vehicle gone by      or the player is within the thing gone with:      update backdrop positions.   Carry out an actor going (this is the check light in new location rule):   if the actor is the player or the player is within the vehicle gone by      or the player is within the thing gone with:      surreptitiously reckon darkness.   Report an actor going (this is the describe room gone into rule):   if the player is the actor:      if the action is not silent:         produce a room description with going spacing conventions;   otherwise:      if the noun is a direction:         if the location is the room gone from or the player is within the            vehicle gone by or the player is within the thing gone with:            if the room gone from is the room gone to:               continue the action;            otherwise:               if the noun is up:                  say "[The actor] [go] up" (A);               otherwise if the noun is down:                  say "[The actor] [go] down" (B);               otherwise:                  say "[The actor] [go] [noun]" (C);         otherwise:            let the back way be the opposite of the noun;            if the location is the room gone to:               let the room back the other way be the room back way from the                  location;               let the room normally this way be the room noun from the                  room gone from;               if the room back the other way is the room gone from or                  the room back the other way is the room normally this way:                  if the back way is up:                     say "[The actor] [arrive] from above" (D);                  otherwise if the back way is down:                     say "[The actor] [arrive] from below" (E);                  otherwise:                     say "[The actor] [arrive] from [the back way]" (F);               otherwise:                  say "[The actor] [arrive]" (G);            otherwise:               if the back way is up:                  say "[The actor] [arrive] at [the room gone to] from above" (H);               otherwise if the back way is down:                  say "[The actor] [arrive] at [the room gone to] from below" (I);               otherwise:                  say "[The actor] [arrive] at [the room gone to] from [the back way]" (J);      otherwise if the location is the room gone from:         say "[The actor] [go] through [the noun]" (K);      otherwise:         say "[The actor] [arrive] from [the noun]" (L);      if the vehicle gone by is not nothing:         say " ";         if the vehicle gone by is a supporter:            say "on [the vehicle gone by]" (M);         otherwise:            say "in [the vehicle gone by]" (N);      if the thing gone with is not nothing:         if the player is within the thing gone with:            say ", pushing [the thing gone with] in front, and [us] along too" (O);         otherwise if the player is within the vehicle gone by:            say ", pushing [the thing gone with] in front" (P);         otherwise if the location is the room gone from:            say ", pushing [the thing gone with] away" (Q);         otherwise:            say ", pushing [the thing gone with] in" (R);      if the player is within the vehicle gone by and the player is not         within the thing gone with:         say ", taking [us] along" (S);         say ".";         try looking;         continue the action;      say ".";   Entering is an action applying to one thing. The entering action translates into I6 as "Enter".   The specification of the entering action is "Whereas the going action allows people to move from one location to another in the model world, the entering action is for movement inside a location: for instance, climbing into a cage or sitting on a couch. (Entering is not allowed to change location, so any attempt to enter a door is converted into a going action.) What makes entering trickier than it looks is that the player may try to enter an object which is itself inside, or part of, something else, which might in turn be... and so on. To preserve realism, the implicitly pass through other barriers rule automatically generates entering and exiting actions needed to pass between anything which might be in the way: for instance, in a room with two open cages, an actor in cage A who tries entering cage B first has to perform an exiting action."   Rule for supplying a missing noun while entering (this is the find what to enter rule):   if something enterable (called the box) is in the location,      now the noun is the box;   otherwise continue the activity.   The find what to enter rule is listed last in the for supplying a missing noun rulebook.   Check an actor entering (this is the convert enter door into go rule):   if the noun is a door, convert to the going action on the noun.   Check an actor entering (this is the convert enter compass direction into go rule):   if the noun is a direction, convert to the going action on the noun.   Check an actor entering (this is the can't enter what's already entered rule):   if the actor is the noun, make no decision;   let the local ceiling be the common ancestor of the actor with the noun;   if the local ceiling is the noun:      if the player is the actor:         if the noun is a supporter:            say "But [we]['re] already on [the noun]." (A);         otherwise:            say "But [we]['re] already in [the noun]." (B);      stop the action.   Check an actor entering (this is the can't enter what's not enterable rule):   if the noun is not enterable:      if the player is the actor:         if the player's command includes "stand":            say "[regarding the noun][They're] not something [we] [can] stand on." (A);         otherwise if the player's command includes "sit":            say "[regarding the noun][They're] not something [we] [can] sit down on." (B);         otherwise if the player's command includes "lie":            say "[regarding the noun][They're] not something [we] [can] lie down on." (C);         otherwise:            say "[regarding the noun][They're] not something [we] [can] enter." (D);      stop the action.   Check an actor entering (this is the can't enter closed containers rule):   if the noun is a closed container:      if the player is the actor:         say "[We] [can't get] into the closed [noun]." (A);      stop the action.   Check an actor entering (this is the can't enter if this exceeds carrying   capacity rule):   if the noun provides the property carrying capacity:      if the noun is a supporter:         if the number of things on the noun is at least the carrying            capacity of the noun:            if the actor is the player:               now the prior named object is nothing;               say "[There] [are] no more room on [the noun]." (A);            stop the action;      otherwise if the noun is a container:         if the number of things in the noun is at least the carrying            capacity of the noun:            if the actor is the player:               now the prior named object is nothing;               say "[There] [are] no more room in [the noun]." (B);            stop the action;   Check an actor entering (this is the can't enter something carried rule):   let the local ceiling be the common ancestor of the actor with the noun;   if the local ceiling is the actor:      if the player is the actor:         say "[We] [can] only get into something free-standing." (A);      stop the action.   Check an actor entering (this is the implicitly pass through other barriers rule):   if the holder of the actor is the holder of the noun, continue the action;   let the local ceiling be the common ancestor of the actor with the noun;   while the holder of the actor is not the local ceiling:      let the current home be the holder of the actor;      if the player is the actor:         if the current home is a supporter or the current home is an animal:            say "(getting off [the current home])[command clarification break]" (A);         otherwise:            say "(getting out of [the current home])[command clarification break]" (B);      silently try the actor trying exiting;      if the holder of the actor is the current home, stop the action;   if the holder of the actor is the noun, stop the action;   if the holder of the actor is the holder of the noun, continue the action;   let the target be the holder of the noun;   if the noun is part of the target, let the target be the holder of the target;   while the target is a thing:      if the holder of the target is the local ceiling:         if the player is the actor:            if the target is a supporter:               say "(getting onto [the target])[command clarification break]" (C);            otherwise if the target is a container:               say "(getting into [the target])[command clarification break]" (D);            otherwise:               say "(entering [the target])[command clarification break]" (E);         silently try the actor trying entering the target;         if the holder of the actor is not the target, stop the action;         convert to the entering action on the noun;         continue the action;      let the target be the holder of the target;   Carry out an actor entering (this is the standard entering rule):   surreptitiously move the actor to the noun.   Report an actor entering (this is the standard report entering rule):   if the actor is the player:      if the action is not silent:         if the noun is a supporter:            say "[We] [get] onto [the noun]." (A);         otherwise:            say "[We] [get] into [the noun]." (B);   otherwise if the noun is a container:      say "[The actor] [get] into [the noun]." (C);   otherwise:      say "[The actor] [get] onto [the noun]." (D);   continue the action.   Report an actor entering (this is the describe contents entered into rule):   if the actor is the player, describe locale for the noun.   Exiting is an action applying to nothing. The exiting action translates into I6 as "Exit". The exiting action has an object called the container exited from (matched as "from").   The specification of the exiting action is "Whereas the going action allows people to move from one location to another in the model world, and the entering action is for movement deeper inside the objects in a location, the exiting action is for movement back out towards the main floor area. Climbing out of a cupboard, for instance, is an exiting action. Exiting when already in the main floor area of a room with a map connection to the outside is converted to a going action. Finally, note that whereas entering works for either containers or supporters, exiting is purely for getting oneself out of containers: if the actor is on top of a supporter instead, an exiting action is converted to the getting off action."   Setting action variables for exiting:   now the container exited from is the holder of the actor.   Check an actor exiting (this is the convert exit into go out rule):   let the local room be the location of the actor;   if the container exited from is the local room:      if the room-or-door outside from the local room is not nothing,         convert to the going action on the outside;   Check an actor exiting (this is the can't exit when not inside anything rule):   let the local room be the location of the actor;   if the container exited from is the local room:      if the player is the actor:         say "But [we] [aren't] in anything at the [if story tense is present            tense]moment[otherwise]time[end if]." (A);      stop the action.   Check an actor exiting (this is the can't exit closed containers rule):   if the actor is in a closed container (called the cage):      if the player is the actor:         say "You can't get out of the closed [cage]." (A);      stop the action.   Check an actor exiting (this is the convert exit into get off rule):   if the actor is on a supporter (called the platform),      convert to the getting off action on the platform.   Carry out an actor exiting (this is the standard exiting rule):   let the former exterior be the not-counting-parts holder of the container exited from;   surreptitiously move the actor to the former exterior.   Report an actor exiting (this is the standard report exiting rule):   if the action is not silent:      if the actor is the player:         if the container exited from is a supporter:            say "[We] [get] off [the container exited from]." (A);         otherwise:             say "[We] [get] out of [the container exited from]." (B);      otherwise:          say "[The actor] [get] out of [the container exited from]." (C);   continue the action.   Report an actor exiting (this is the describe room emerged into rule):   if the actor is the player:      surreptitiously reckon darkness;      produce a room description with going spacing conventions.   Getting off is an action applying to one thing. The getting off action translates into I6 as "GetOff".   The specification of the getting off action is "The getting off action is for actors who are currently on top of a supporter: perhaps standing on a platform, but maybe only sitting on a chair or even lying down in bed. Unlike the similar exiting action, getting off takes a noun: the platform, chair, bed or what have you."   Check an actor getting off (this is the can't get off things rule):   if the actor is on the noun, continue the action;   if the actor is carried by the noun, continue the action;   if the actor is the player:      say "But [we] [aren't] on [the noun] at the [if story tense is present         tense]moment[otherwise]time[end if]." (A);   stop the action.   Carry out an actor getting off (this is the standard getting off rule):   let the former exterior be the not-counting-parts holder of the noun;   surreptitiously move the actor to the former exterior.   Report an actor getting off (this is the standard report getting off rule):   if the action is not silent:      say "[The actor] [get] off [the noun]." (A);   continue the action.   Report an actor getting off (this is the describe room stood up into rule):   if the actor is the player,      produce a room description with going spacing conventions.   Section SR4/4 - Standard actions concerning the actor's vision   Looking is an action applying to nothing. The looking action translates into I6 as "Look".   The specification of the looking action is "The looking action describes the player's current room and any visible items, but is made more complicated by the problem of visibility. Inform calculates this by dividing the room into visibility levels. For an actor on the floor of a room, there is only one such level: the room itself. But an actor sitting on a chair inside a packing case which is itself on a gantry would have four visibility levels: chair, case, gantry, room. The looking rules use a special phrase, 'the visibility-holder of X', to go up from one level to the next: thus the visibility-holder of the case is the gantry.   The 'visibility level count' is the number of levels which the player can actually see, and the 'visibility ceiling' is the uppermost visible level. For a player standing on the floor of a lighted room, this will be a count of 1 with the ceiling set to the room. But a player sitting on a chair in a closed opaque packing case would have visibility level count 2, and visibility ceiling equal to the case. Moreover, light has to be available in order to see anything at all: if the player is in darkness, the level count is 0 and the ceiling is nothing.   Finally, note that several actions other than looking also produce room descriptions in some cases. The most familiar is going, but exiting a container or getting off a supporter will also generate a room description. (The phrase used by the relevant rules is 'produce a room description with going spacing conventions' and carry out or report rules for newly written actions are welcome to use this too if they would like to. The spacing conventions affect paragraph division, and note that the main description paragraph may be omitted for a place not newly visited, depending on the VERBOSE settings.) Room descriptions like this are produced by running the check, carry out and report rules for looking, but are not subject to before, instead or after rules: so they do not count as a new action. The looking variable 'room-describing action' holds the action name of the reason a room description is currently being made: if the player typed LOOK, this will indeed be set to the looking action, but if we're describing a room just reached by GO EAST, say, it will be set to the going action. This can be used to customise carry out looking rules so that different forms of description are used on going to a room as compared with looking around while already there."   The looking action has an action name called the room-describing action. The looking action has a truth state called abbreviated form allowed. The looking action has a number called the visibility level count. The looking action has an object called the visibility ceiling.   Setting action variables for looking (this is the determine visibility ceiling   rule):   if the actor is the player, calculate visibility ceiling at low level;   now the visibility level count is the visibility ceiling count calculated;   now the visibility ceiling is the visibility ceiling calculated;   now the room-describing action is the looking action.   Carry out looking (this is the declare everything unmentioned rule):   repeat with item running through things:      now the item is not mentioned.   Carry out looking (this is the room description heading rule):   say bold type;   if the visibility level count is 0:      begin the printing the name of a dark room activity;      if handling the printing the name of a dark room activity:         say "Darkness" (A);      end the printing the name of a dark room activity;   otherwise if the visibility ceiling is the location:      say "[visibility ceiling]";   otherwise:      say "[The visibility ceiling]";   say roman type;   let intermediate level be the visibility-holder of the actor;   repeat with intermediate level count running from 2 to the visibility level count:      if the intermediate level is a supporter or the intermediate level is an animal:         say " (on [the intermediate level])" (B);      otherwise:         say " (in [the intermediate level])" (C);      let the intermediate level be the visibility-holder of the intermediate level;   say line break;   say run paragraph on with special look spacing.   Carry out looking (this is the room description body text rule):   if the visibility level count is 0:      if set to abbreviated room descriptions, continue the action;      if set to sometimes abbreviated room descriptions and         abbreviated form allowed is true and         darkness witnessed is true,         continue the action;      begin the printing the description of a dark room activity;      if handling the printing the description of a dark room activity:         now the prior named object is nothing;         say "[It] [are] pitch dark, and [we] [can't see] a thing." (A);      end the printing the description of a dark room activity;   otherwise if the visibility ceiling is the location:      if set to abbreviated room descriptions, continue the action;      if set to sometimes abbreviated room descriptions and abbreviated form         allowed is true and the location is visited, continue the action;      print the location's description;   Carry out looking (this is the room description paragraphs about objects rule):   if the visibility level count is greater than 0:      let the intermediate position be the actor;      let the IP count be the visibility level count;      while the IP count is greater than 0:         now the intermediate position is marked for listing;         let the intermediate position be the visibility-holder of the            intermediate position;         decrease the IP count by 1;      let the top-down IP count be the visibility level count;      while the top-down IP count is greater than 0:         let the intermediate position be the actor;         let the IP count be 0;         while the IP count is less than the top-down IP count:            let the intermediate position be the visibility-holder of the               intermediate position;            increase the IP count by 1;         describe locale for the intermediate position;         decrease the top-down IP count by 1;   continue the action;   Carry out looking (this is the check new arrival rule):   if in darkness:      now the darkness witnessed is true;   otherwise:      if the location is a room, now the location is visited;   Report an actor looking (this is the other people looking rule):   if the actor is not the player:      say "[The actor] [look] around." (A).   Examining is an action applying to one visible thing and requiring light. The examining action translates into I6 as "Examine".   The specification of the examining action is "The act of looking closely at something. Note that the noun could be either a direction or a thing, which is why the Standard Rules include the 'examine directions rule' to deal with directions: it simply says 'You see nothing unexpected in that direction.' and stops the action. (If you would like to handle directions differently, list another rule instead of this one in the carry out examining rules.)   Some things have no description property, or rather, have only a blank text as one. It's possible that something interesting may be said anyway (see the rules for directions, containers, supporters and devices), but if not, we give up with a bland response. This is done by the examine undescribed things rule."   The examining action has a truth state called examine text printed.   Carry out examining (this is the standard examining rule):   if the noun provides the property description and the description of the noun is not "":      say "[description of the noun][line break]";      now examine text printed is true.   Carry out examining (this is the examine directions rule):   if the noun is a direction:      say "[We] [see] nothing unexpected in that direction." (A);      now examine text printed is true.   Carry out examining (this is the examine containers rule):   if the noun is a container:      if the noun is open or the noun is transparent:         if something described which is not scenery is in the noun and something which            is not the player is in the noun:            say "In [the noun] " (A);            list the contents of the noun, as a sentence, tersely, not listing               concealed items, prefacing with is/are;            say ".";            now examine text printed is true;         otherwise if examine text printed is false:            if the player is in the noun:               make no decision;            say "[The noun] [are] empty." (B);            now examine text printed is true;   Carry out examining (this is the examine supporters rule):   if the noun is a supporter:      if something described which is not scenery is on the noun and something which is         not the player is on the noun:         say "On [the noun] " (A);         list the contents of the noun, as a sentence, tersely, not listing            concealed items, prefacing with is/are, including contents,            giving brief inventory information;         say ".";         now examine text printed is true.   Carry out examining (this is the examine devices rule):   if the noun is a device:      say "[The noun] [are] [if story tense is present tense]currently [end if]switched         [if the noun is switched on]on[otherwise]off[end if]." (A);      now examine text printed is true.   Carry out examining (this is the examine undescribed things rule):   if examine text printed is false:      say "[We] [see] nothing special about [the noun]." (A).   Report an actor examining (this is the report other people examining rule):   if the actor is not the player:      say "[The actor] [look] closely at [the noun]." (A).   Looking under is an action applying to one visible thing and requiring light. The looking under action translates into I6 as "LookUnder".   The specification of the looking under action is "The standard Inform world model does not have a concept of things being under other things, so this action is only minimally provided by the Standard Rules, but it exists here for traditional reasons (and because, after all, LOOK UNDER TABLE is the sort of command which ought to be recognised even if it does nothing useful). The action ordinarily either tells the player he finds nothing of interest, or reports that somebody else has looked under something.   The usual way to make this action do something useful is to write a rule like 'Instead of looking under the cabinet for the first time: now the player has the silver key; say ...' and so on."   Carry out an actor looking under (this is the standard looking under rule):   if the player is the actor:      say "[We] [find] nothing of interest." (A);   stop the action.   Report an actor looking under (this is the report other people looking under rule):   if the action is not silent:      if the actor is not the player:         say "[The actor] [look] under [the noun]." (A).   Searching is an action applying to one thing and requiring light. The searching action translates into I6 as "Search".   The specification of the searching action is "Searching looks at the contents of an open or transparent container, or at the items on top of a supporter. These are often mentioned in room descriptions already, and then the action is unnecessary, but that wouldn't be true for something like a kitchen cupboard which is scenery - mentioned in passing in a room description, but not made a fuss of. Searching such a cupboard would then, by listing its contents, give the player more information than the ordinary room description shows.   The usual check rules restrict searching to containers and supporters: so the Standard Rules do not allow the searching of people, for instance. But it is easy to add instead rules ('Instead of searching Dr Watson: ...') or even a new carry out rule ('Check searching someone (called the suspect): ...') to extend the way searching normally works."   Check an actor searching (this is the can't search unless container or supporter rule):   if the noun is not a container and the noun is not a supporter:      if the player is the actor:         say "[We] [find] nothing of interest." (A);      stop the action.   Check an actor searching (this is the can't search closed opaque containers rule):   if the noun is a closed opaque container:      if the player is the actor:         say "[We] [can't see] inside, since [the noun] [are] closed." (A);      stop the action.   Report searching a container (this is the standard search containers rule):   if the noun contains a described thing which is not scenery:      say "In [the noun] " (A);      list the contents of the noun, as a sentence, tersely, not listing         concealed items, prefacing with is/are;      say ".";   otherwise:      say "[The noun] [are] empty." (B).   Report searching a supporter (this is the standard search supporters rule):   if the noun supports a described thing which is not scenery:      say "On [the noun] " (A);      list the contents of the noun, as a sentence, tersely, not listing         concealed items, prefacing with is/are;      say ".";   otherwise:      now the prior named object is nothing;      say "[There] [are] nothing on [the noun]." (B).   Report an actor searching (this is the report other people searching rule):   if the actor is not the player:      say "[The actor] [search] [the noun]." (A).   Consulting it about is an action applying to one thing and one topic. The consulting it about action translates into I6 as "Consult".   The specification of the consulting it about action is "Consulting is a very flexible and potentially powerful action, but only because it leaves almost all of the work to the author to deal with directly. The idea is for it to respond to commands such as LOOK UP HENRY FITZROY IN HISTORY BOOK, where the topic would be the snippet of command HENRY FITZROY and the thing would be the book.   The Standard Rules simply parry such requests by saying that the player finds nothing of interest. All interesting responses must be provided by the author, using rules like 'Instead of consulting the history book about...'"   Report an actor consulting something about (this is the block consulting rule):   if the actor is the player:      say "[We] [discover] nothing of interest in [the noun]." (A);   otherwise:      say "[The actor] [look] at [the noun]." (B);   Section SR4/5 - Standard actions which change the state of things   Locking it with is an action applying to one thing and one carried thing. The locking it with action translates into I6 as "Lock".   The specification of the locking it with action is "Locking is the act of using an object such as a key to ensure that something such as a door or container cannot be opened unless first unlocked. (Only closed things can be locked.)   Locking can be performed on any kind of thing which provides the either/or properties lockable, locked, openable and open. The 'can't lock without a lock rule' tests to see if the noun both provides the lockable property, and if it is in fact lockable: it is then assumed that the other properties can safely be checked. In the Standard Rules, the container and door kinds both satisfy these requirements.   We can create a new kind on which opening, closing, locking and unlocking will work thus: 'A briefcase is a kind of thing. A briefcase can be openable. A briefcase can be open. A briefcase can be lockable. A briefcase can be locked. A briefcase is usually openable, lockable, open and unlocked.'   Inform checks whether the key fits using the 'can't lock without the correct key rule'. To satisfy this, the actor must be directly holding the second noun, and it must be the current value of the 'matching key' property for the noun. (This property is seldom referred to directly because it is automatically set by assertions like 'The silver key unlocks the wicket gate.')   The Standard Rules provide locking and unlocking actions at a fairly basic level: they can be much enhanced using the extension Locksmith by Emily Short, which is included with all distributions of Inform."   Check an actor locking something with (this is the can't lock without a lock rule):   if the noun provides the property lockable and the noun is lockable:      continue the action;   if the actor is the player:      say "[regarding the noun][Those] [don't] seem to be something [we] [can] lock." (A);   stop the action.   Check an actor locking something with (this is the can't lock what's already   locked rule):   if the noun is locked:      if the actor is the player:         say "[regarding the noun][They're] locked at the [if story tense is present            tense]moment[otherwise]time[end if]." (A);      stop the action.   Check an actor locking something with (this is the can't lock what's open rule):   if the noun is open:      if the actor is the player:         say "First [we] [would have] to close [the noun]." (A);      stop the action.   Check an actor locking something with (this is the can't lock without the correct key rule):   if the holder of the second noun is not the actor or      the noun does not provide the property matching key or      the matching key of the noun is not the second noun:      if the actor is the player:         say "[regarding the second noun][Those] [don't] seem to fit the lock." (A);      stop the action.   Carry out an actor locking something with (this is the standard locking rule):   now the noun is locked.   Report an actor locking something with (this is the standard report locking rule):   if the actor is the player:      if the action is not silent:         say "[We] [lock] [the noun]." (A);   otherwise:      if the actor is visible:         say "[The actor] [lock] [the noun]." (B);   Unlocking it with is an action applying to one thing and one carried thing. The unlocking it with action translates into I6 as "Unlock".   The specification of the unlocking it with action is "Unlocking undoes the effect of locking, and renders the noun openable again provided that the actor is carrying the right key (which must be the second noun).   Unlocking can be performed on any kind of thing which provides the either/or properties lockable, locked, openable and open. The 'can't unlock without a lock rule' tests to see if the noun both provides the lockable property, and if it is in fact lockable: it is then assumed that the other properties can safely be checked. In the Standard Rules, the container and door kinds both satisfy these requirements.   We can create a new kind on which opening, closing, locking and unlocking will work thus: 'A briefcase is a kind of thing. A briefcase can be openable. A briefcase can be open. A briefcase can be lockable. A briefcase can be locked. A briefcase is usually openable, lockable, open and unlocked.'   Inform checks whether the key fits using the 'can't unlock without the correct key rule'. To satisfy this, the actor must be directly holding the second noun, and it must be the current value of the 'matching key' property for the noun. (This property is seldom referred to directly because it is automatically set by assertions like 'The silver key unlocks the wicket gate.')   The Standard Rules provide locking and unlocking actions at a fairly basic level: they can be much enhanced using the extension Locksmith by Emily Short, which is included with all distributions of Inform."   Check an actor unlocking something with (this is the can't unlock without a lock rule):   if the noun provides the property lockable and the noun is lockable:      continue the action;   if the actor is the player:      say "[regarding the noun][Those] [don't] seem to be something [we] [can] unlock." (A);   stop the action.   Check an actor unlocking something with (this is the can't unlock what's already unlocked rule):   if the noun is not locked:      if the actor is the player:         say "[regarding the noun][They're] unlocked at the [if story tense is present            tense]moment[otherwise]time[end if]." (A);      stop the action.   Check an actor unlocking something with (this is the can't unlock without the correct key rule):   if the holder of the second noun is not the actor or      the noun does not provide the property matching key or      the matching key of the noun is not the second noun:      if the actor is the player:         say "[regarding the second noun][Those] [don't] seem to fit the lock." (A);      stop the action.   Carry out an actor unlocking something with (this is the standard unlocking rule):   now the noun is not locked.   Report an actor unlocking something with (this is the standard report unlocking rule):   if the actor is the player:      if the action is not silent:         say "[We] [unlock] [the noun]." (A);   otherwise:      if the actor is visible:         say "[The actor] [unlock] [the noun]." (B);   Switching on is an action applying to one thing. The switching on action translates into I6 as "SwitchOn".   The specification of the switching on action is "The switching on and switching off actions are for the simplest kind of machinery operation: they are for objects representing machines (or more likely parts of machines), which are considered to be either off or on at any given time.   The actions are intended to be used where the noun is a device, but in fact they could work just as well with any kind which can be 'switched on' or 'switched off'."   Check an actor switching on (this is the can't switch on unless switchable rule):   if the noun provides the property switched on, continue the action;   if the actor is the player:      say "[regarding the noun][They] [aren't] something [we] [can] switch." (A);   stop the action.   Check an actor switching on (this is the can't switch on what's already on rule):   if the noun is switched on:      if the actor is the player:         say "[regarding the noun][They're] already on." (A);      stop the action.   Carry out an actor switching on (this is the standard switching on rule):   now the noun is switched on.   Report an actor switching on (this is the standard report switching on rule):   if the action is not silent:      say "[The actor] [switch] [the noun] on." (A).   Switching off is an action applying to one thing. The switching off action translates into I6 as "SwitchOff".   The specification of the switching off action is "The switching off and switching on actions are for the simplest kind of machinery operation: they are for objects representing machines (or more likely parts of machines), which are considered to be either off or on at any given time.   The actions are intended to be used where the noun is a device, but in fact they could work just as well with any kind which can be 'switched on' or 'switched off'."   Check an actor switching off (this is the can't switch off unless switchable rule):   if the noun provides the property switched on, continue the action;   if the actor is the player:      say "[regarding the noun][They] [aren't] something [we] [can] switch." (A);   stop the action.   Check an actor switching off (this is the can't switch off what's already off rule):   if the noun is switched off:      if the actor is the player:         say "[regarding the noun][They're] already off." (A);      stop the action.   Carry out an actor switching off (this is the standard switching off rule):   now the noun is switched off.   Report an actor switching off (this is the standard report switching off rule):   if the action is not silent:      say "[The actor] [switch] [the noun] off." (A).   Opening is an action applying to one thing. The opening action translates into I6 as "Open".   The specification of the opening action is "Opening makes something no longer a physical barrier. The action can be performed on any kind of thing which provides the either/or properties openable and open. The 'can't open unless openable rule' tests to see if the noun both can be and actually is openable. (It is assumed that anything which can be openable can also be open.) In the Standard Rules, the container and door kinds both satisfy these requirements.   In the event that the thing to be opened is also lockable, we are forbidden to open it when it is locked. Both containers and doors can be lockable, but the opening and closing actions would also work fine with kinds which cannot be.   We can create a new kind on which opening and closing will work thus: 'A case file is a kind of thing. A case file can be openable. A case file can be open. A case file is usually openable and closed.'   The meaning of open and closed is different for different kinds of thing. When a container is closed, that means people outside cannot reach in, and vice versa; when a door is closed, people cannot use the 'going' action to pass through it. If we were to create a new kind such as 'case file', we would also need to write rules to make the open and closed properties interesting for this kind."   Check an actor opening (this is the can't open unless openable rule):   if the noun provides the property openable and the noun is openable:      continue the action;   if the actor is the player:      say "[regarding the noun][They] [aren't] something [we] [can] open." (A);   stop the action.   Check an actor opening (this is the can't open what's locked rule):   if the noun provides the property lockable and the noun is locked:      if the actor is the player:         say "[regarding the noun][They] [seem] to be locked." (A);      stop the action.   Check an actor opening (this is the can't open what's already open rule):   if the noun is open:      if the actor is the player:         say "[regarding the noun][They're] already open." (A);      stop the action.   Carry out an actor opening (this is the standard opening rule):   now the noun is open.   Report an actor opening (this is the reveal any newly visible interior rule):   if the actor is the player and      the noun is an opaque container and      the first thing held by the noun is not nothing and      the noun does not enclose the actor:      if the action is not silent:         if the actor is the player:            say "[We] [open] [the noun], revealing " (A);            list the contents of the noun, as a sentence, tersely, not listing               concealed items;            say ".";      stop the action.   Report an actor opening (this is the standard report opening rule):   if the actor is the player:      if the action is not silent:         say "[We] [open] [the noun]." (A);   otherwise if the player can see the actor:      say "[The actor] [open] [the noun]." (B);   otherwise:      say "[The noun] [open]." (C);   Closing is an action applying to one thing. The closing action translates into I6 as "Close".   The specification of the closing action is "Closing makes something into a physical barrier. The action can be performed on any kind of thing which provides the either/or properties openable and open. The 'can't close unless openable rule' tests to see if the noun both can be and actually is openable. (It is assumed that anything which can be openable can also be open, and hence can also be closed.) In the Standard Rules, the container and door kinds both satisfy these requirements.   We can create a new kind on which opening and closing will work thus: 'A case file is a kind of thing. A case file can be openable. A case file can be open. A case file is usually openable and closed.'   The meaning of open and closed is different for different kinds of thing. When a container is closed, that means people outside cannot reach in, and vice versa; when a door is closed, people cannot use the 'going' action to pass through it. If we were to create a new kind such as 'case file', we would also need to write rules to make the open and closed properties interesting for this kind."   Check an actor closing (this is the can't close unless openable rule):   if the noun provides the property openable and the noun is openable:      continue the action;   if the actor is the player:      say "[regarding the noun][They] [aren't] something [we] [can] close." (A);   stop the action.   Check an actor closing (this is the can't close what's already closed rule):   if the noun is closed:      if the actor is the player:         say "[regarding the noun][They're] already closed." (A);      stop the action.   Carry out an actor closing (this is the standard closing rule):   now the noun is closed.   Report an actor closing (this is the standard report closing rule):   if the actor is the player:      if the action is not silent:         say "[We] [close] [the noun]." (A);   otherwise if the player can see the actor:      say "[The actor] [close] [the noun]." (B);   otherwise:      say "[The noun] [close]." (C);   Wearing is an action applying to one carried thing. The wearing action translates into I6 as "Wear".   The specification of the wearing action is "The Standard Rules give Inform only a simple model of clothing. A thing can be worn only if it has the either/or property of being 'wearable'. (Typing a sentence like 'Mr Jones wears the Homburg hat.' automatically implies that the hat is wearable, which is why we only seldom need to use the word 'wearable' directly.) There is no checking of how much or how little any actor is wearing, or how incongruous this may appear: nor any distinction between under or over-clothes.   To put on an article of clothing, the actor must be directly carrying it, as enforced by the 'can't wear what's not held rule'."   Check an actor wearing (this is the can't wear what's not clothing rule):   if the noun is not a thing or the noun is not wearable:      if the actor is the player:         say "[We] [can't wear] [regarding the noun][those]!" (A);      stop the action.   Check an actor wearing (this is the can't wear what's not held rule):   if the holder of the noun is not the actor:      if the actor is the player:         say "[We] [aren't] holding [regarding the noun][those]!" (A);      stop the action.   Check an actor wearing (this is the can't wear what's already worn rule):   if the actor is wearing the noun:      if the actor is the player:         say "[We]['re] already wearing [regarding the noun][those]!" (A);      stop the action.   Carry out an actor wearing (this is the standard wearing rule):   now the actor wears the noun.   Report an actor wearing (this is the standard report wearing rule):   if the actor is the player:      if the action is not silent:         say "[We] [put] on [the noun]." (A);   otherwise:      say "[The actor] [put] on [the noun]." (B).   Taking off is an action applying to one thing. The taking off action translates into I6 as "Disrobe".   Does the player mean taking off something worn: it is very likely.   The specification of the taking off action is "The Standard Rules give Inform only a simple model of clothing. A thing can be worn only if it has the either/or property of being 'wearable'. (Typing a sentence like 'Mr Jones wears the Homburg hat.' automatically implies that the hat is wearable, which is why we only seldom need to use the word 'wearable' directly.) There is no checking of how much or how little any actor is wearing, or how incongruous this may appear: nor any distinction between under or over-clothes.   When an article of clothing is taken off, it becomes a thing directly carried by its former wearer, rather than being (say) dropped onto the floor."   Check an actor taking off (this is the can't take off what's not worn rule):   if the actor is not wearing the noun:      if the actor is the player:         say "[We] [aren't] wearing [the noun]." (A);      stop the action.   Check an actor taking off (this is the can't exceed carrying capacity when taking off rule):   if the number of things carried by the actor is at least the carrying capacity of the actor:      if the actor is the player:         say "[We]['re] carrying too many things already." (A);      stop the action.   Carry out an actor taking off (this is the standard taking off rule):   now the actor carries the noun.   Report an actor taking off (this is the standard report taking off rule):   if the actor is the player:      if the action is not silent:         say "[We] [take] off [the noun]." (A);   otherwise:      say "[The actor] [take] off [the noun]." (B).   Section SR4/6 - Standard actions concerning other people   Giving it to is an action applying to one carried thing and one thing. The giving it to action translates into I6 as "Give".   The specification of the giving it to action is "This action is indexed by Inform under 'Actions concerning other people', but it could just as easily have gone under 'Actions concerning the actor's possessions' because - like dropping, putting it on or inserting it into - this is an action which gets rid of something being carried.   The Standard Rules implement this action fully - if it reaches the carry out and report rulebooks, then the item is indeed transferred to the recipient, and this is properly reported. But giving something to somebody is not like putting something on a shelf: the recipient has to agree. The final check rule, the 'block giving rule', assumes that the recipient does not consent - so the gift fails to happen. The way to make the giving action use its abilities fully is to replace the block giving rule with a rule which makes a more sophisticated decision about who will accept what from whom, and only blocks some attempts, letting others run on into the carry out and report rules."   Check an actor giving something to (this is the can't give what you haven't got rule):   if the actor is not the holder of the noun:      if the actor is the player:         say "[We] [aren't] holding [the noun]." (A);      stop the action.   Check an actor giving something to (this is the can't give to yourself rule):   if the actor is the second noun:      if the actor is the player:         say "[We] [can't give] [the noun] to [ourselves]." (A);      stop the action.   Check an actor giving something to (this is the can't give to a non-person rule):   if the second noun is not a person:      if the actor is the player:         say "[The second noun] [aren't] able to receive things." (A);      stop the action.   Check an actor giving something to (this is the can't give clothes being worn rule):   if the actor is wearing the noun:      say "(first taking [the noun] off)[command clarification break]" (A);      silently try the actor trying taking off the noun;      if the actor is wearing the noun, stop the action;   Check an actor giving something to (this is the block giving rule):   if the actor is the player:      say "[The second noun] [don't] seem interested." (A);   stop the action.   Check an actor giving something to (this is the can't exceed carrying capacity   when giving rule):   if the number of things carried by the second noun is at least the carrying      capacity of the second noun:      if the actor is the player:         say "[The second noun] [are] carrying too many things already." (A);      stop the action.   Carry out an actor giving something to (this is the standard giving rule):   move the noun to the second noun.   Report an actor giving something to (this is the standard report giving rule):   if the actor is the player:      say "[We] [give] [the noun] to [the second noun]." (A);   otherwise if the second noun is the player:      say "[The actor] [give] [the noun] to [us]." (B);   otherwise:      say "[The actor] [give] [the noun] to [the second noun]." (C).   Showing it to is an action applying to one carried thing and one visible thing. The showing it to action translates into I6 as "Show".   The specification of the showing it to action is "Anyone can show anyone else something which they are carrying, but not some nearby piece of scenery, say - so this action is suitable for showing the emerald locket to Katarina, but not showing the Orange River Rock Room to Mr Douglas.   The Standard Rules implement this action in only a minimal way, checking that it makes sense but then blocking all such attempts with a message such as 'Katarina is not interested.' - this is the task of the 'block showing rule'. As a result, there are no carry out or report rules. To make it into a systematic and interesting action, we would need to unlist the block showing rule and then to write carry out and report rules: but usually for IF purposes we only need to make a handful of special cases of showing work properly, and for those we can simply write Instead rules to handle them."   Check an actor showing something to (this is the can't show what you haven't   got rule):   if the actor is not the holder of the noun:      if the actor is the player:         say "[We] [aren't] holding [the noun]." (A);      stop the action.   Check an actor showing something to (this is the convert show to yourself to   examine rule):   if the actor is the second noun:      convert to the examining action on the noun.   Check an actor showing something to (this is the block showing rule):   if the actor is the player:      say "[The second noun] [are] unimpressed." (A);   stop the action.   Waking is an action applying to one thing. The waking action translates into I6 as "WakeOther".   The specification of the waking action is "This is the act of jostling a sleeping person to wake him or her up, and it finds its way into the Standard Rules only for historical reasons. Inform does not by default provide any model for people being asleep or awake, so this action does not do anything in the standard implementation: instead, it is always stopped by the block waking rule."   Check an actor waking (this is the block waking rule):   if the actor is the player:      now the prior named object is nothing;      say "That [seem] unnecessary." (A);   stop the action.   Throwing it at is an action applying to one carried thing and one visible thing. The throwing it at action translates into I6 as "ThrowAt".   The specification of the throwing it at action is "Throwing something at someone or something is difficult for Inform to model. So many considerations apply: just because the actor can see the target, does it follow that the target can accurately hit it? What if the projectile is heavy, like an anvil, or something not easily aimable, like a feather? What if there is a barrier in the way, like a cage with bars spaced so that only items of a certain size get through? And then: what should happen as a result? Will the projectile break, or do damage, or fall to the floor, or into a container or onto a supporter? And so on.   Because it seems hopeless to try to model this in any general way, Inform instead provides the action for the user to attach specific rules to. The check rules in the Standard Rules simply require that the projectile is not an item of clothing still worn (this will be relevant for women attending a Tom Jones concert) but then, in either the 'futile to throw things at inanimate objects rule' or the 'block throwing at rule', will refuse to carry out the action with a bland message.   To make throwing do something, then, we must either write Instead rules for special circumstances, or else unlist these check rules and write suitable carry out and report rules to pick up the thread."   Check an actor throwing something at (this is the implicitly remove thrown clothing rule):   if the actor is wearing the noun:      say "(first taking [the noun] off)[command clarification break]" (A);      silently try the actor trying taking off the noun;      if the actor is wearing the noun, stop the action;   Check an actor throwing something at (this is the futile to throw things at inanimate   objects rule):   if the second noun is not a person:      if the actor is the player:         say "Futile." (A);      stop the action.   Check an actor throwing something at (this is the block throwing at rule):   if the actor is the player:      say "[We] [lack] the nerve when it [if story tense is the past         tense]came[otherwise]comes[end if] to the crucial moment." (A);   stop the action.   Attacking is an action applying to one thing. The attacking action translates into I6 as "Attack".   The specification of the attacking action is "Violence is seldom the answer, and attempts to attack another person are normally blocked as being unrealistic or not seriously meant. (I might find a shop assistant annoying, but IF is not Grand Theft Auto, and responding by killing him is not really one of my options.) So the Standard Rules simply block attempts to fight people, but the action exists for rules to make exceptions."   Check an actor attacking (this is the block attacking rule):   if the actor is the player:      now the prior named object is nothing;      say "Violence [aren't] the answer to this one." (A);   stop the action.   Kissing is an action applying to one thing. The kissing action translates into I6 as "Kiss".   The specification of the kissing action is "Possibly because Inform was originally written by an Englishman, attempts at kissing another person are normally blocked as being unrealistic or not seriously meant. So the Standard Rules simply block attempts to kiss people, but the action exists for rules to make exceptions."   Check an actor kissing (this is the kissing yourself rule):   if the noun is the actor:      if the actor is the player:         say "[We] [don't] get much from that." (A);      stop the action.   Check an actor kissing (this is the block kissing rule):   if the actor is the player:      say "[The noun] [might not] like that." (A);   stop the action.   Answering it that is an action applying to one thing and one topic. The answering it that action translates into I6 as "Answer".   The specification of the answering it that action is "The Standard Rules do not include any systematic way to handle conversation: instead, Inform is set up so that it is as easy as we can make it to write specific rules handling speech in particular games, and so that if no such rules are written then all attempts to communicate are gracefully if not very interestingly rejected.   The topic here can be any double-quoted text, which can itself contain tokens in square brackets: see the documentation on Understanding.   Answering is an action existing so that the player can say something free-form to somebody else. A convention of IF is that a command such as DAPHNE, TAKE MASK is a request to Daphne to perform an action: if the persuasion rules in force mean that she consents, the action 'Daphne taking the mask' does indeed then result. But if the player types DAPHNE, 12375 or DAPHNE, GREAT HEAVENS - or anything else not making sense as a command - the action 'answering Daphne that ...' will be generated.   The name of the action arises because it is also caused by typing, say, ANSWER 12375 when Daphne (say) has asked a question."   Report an actor answering something that (this is the block answering rule):   if the actor is the player:      now the prior named object is nothing;      say "[There] [are] no reply." (A);   stop the action.   Telling it about is an action applying to one thing and one topic. The telling it about action translates into I6 as "Tell".   The specification of the telling it about action is "The Standard Rules do not include any systematic way to handle conversation: instead, Inform is set up so that it is as easy as we can make it to write specific rules handling speech in particular games, and so that if no such rules are written then all attempts to communicate are gracefully if not very interestingly rejected.   The topic here can be any double-quoted text, which can itself contain tokens in square brackets: see the documentation on Understanding.   Telling is an action existing only to catch commands like TELL ALEX ABOUT GUITAR. Customarily in IF, such a command is shorthand which the player accepts as a conventional form: it means 'tell Alex what I now know about the guitar' and would make sense if the player had himself recently discovered something significant about the guitar which might interest Alex."   Check an actor telling something about (this is the telling yourself rule):   if the actor is the noun:      if the actor is the player:         say "[We] [talk] to [ourselves] a while." (A);      stop the action.   Report an actor telling something about (this is the block telling rule):   if the actor is the player:      now the prior named object is nothing;      say "This [provoke] no reaction." (A);   stop the action.   Asking it about is an action applying to one thing and one topic. The asking it about action translates into I6 as "Ask".   The specification of the asking it about action is "The Standard Rules do not include any systematic way to handle conversation: instead, Inform is set up so that it is as easy as we can make it to write specific rules handling speech in particular games, and so that if no such rules are written then all attempts to communicate are gracefully if not very interestingly rejected.   The topic here can be any double-quoted text, which can itself contain tokens in square brackets: see the documentation on Understanding.   Asking is an action existing only to catch commands like ASK STEPHEN ABOUT PENELOPE. Customarily in IF, such a command is shorthand which the player accepts as a conventional form: it means 'engage Mary in conversation and try to find out what she might know about'. It's understood as a convention of the genre that Mary should not be expected to respond in cases where there is no reason to suppose that she has anything relevant to pass on - ASK JANE ABOUT RICE PUDDING, for instance, need not conjure up a recipe even if Jane is a 19th-century servant and therefore almost certainly knows one."   Report an actor asking something about (this is the block asking rule):   if the actor is the player:      now the prior named object is nothing;      say "[There] [are] no reply." (A);   stop the action.   Asking it for is an action applying to two things. The asking it for action translates into I6 as "AskFor".   The specification of the asking it for action is "The Standard Rules do not include any systematic way to handle conversation, but this is action is not quite conversation: it doesn't involve any spoken text as such. It exists to catch commands like ASK SALLY FOR THE EGG WHISK, where the whisk is something which Sally has and the player can see.   Slightly oddly, but for historical reasons, an actor asking himself for something is treated to an inventory listing instead. All other cases are converted to the giving action: that is, ASK SALLY FOR THE EGG WHISK is treated as if it were SALLY, GIVE ME THE EGG WHISK - an action for Sally to perform and which then follows rules for giving.   To ask for information or something intangible, see the asking it about action."   Check an actor asking something for (this is the asking yourself for something rule):   if the actor is the noun and the actor is the player:      try taking inventory instead.   Check an actor asking something for (this is the translate asking for to giving rule):   convert to request of the noun to perform giving it to action with the second noun and the actor.   Section SR4/7 - Standard actions which are checked but then do nothing unless rules intervene   Waiting is an action applying to nothing. The waiting action translates into I6 as "Wait".   The specification of the waiting action is "The inaction action: where would we be without waiting? Waiting does not cause time to pass by - that happens anyway - but represents a positive choice by the actor not to fill that time. It is an action so that rules can be attached to it: for instance, we could imagine that a player who consciously decides to sit and wait might notice something which a busy player does not, and we could write a rule accordingly.   Note the absence of check or carry out rules - anyone can wait, at any time, and it makes nothing happen."   Report an actor waiting (this is the standard report waiting rule):   if the actor is the player:      if the action is not silent:         now the prior named object is nothing;         say "Time [pass]." (A);   otherwise:      say "[The actor] [wait]." (B).   Touching is an action applying to one thing. The touching action translates into I6 as "Touch".   The specification of the touching action is "Touching is just that, touching something without applying pressure: a touch-sensitive screen or a living creature might react, but a standard push-button or lever will probably not.   In the Standard Rules there are no check touching rules, since touchability is already a requirement of the noun for the action anyway, and no carry out rules because nothing in the standard Inform world model reacts to a mere touch - though report rules do mean that attempts to touch other people provoke a special reply."   Report an actor touching (this is the report touching yourself rule):   if the noun is the actor:      if the actor is the player:         if the action is not silent:            say "[We] [achieve] nothing by this." (A);      otherwise:         say "[The actor] [touch] [themselves]." (B);      stop the action;   continue the action.   Report an actor touching (this is the report touching other people rule):   if the noun is a person:      if the actor is the player:         if the action is not silent:            say "[The noun] [might not like] that." (A);      otherwise if the noun is the player:         say "[The actor] [touch] [us]." (B);      otherwise:         say "[The actor] [touch] [the noun]." (C);      stop the action;   continue the action.   Report an actor touching (this is the report touching things rule):   if the actor is the player:      if the action is not silent:         say "[We] [feel] nothing unexpected." (A);   otherwise:      say "[The actor] [touch] [the noun]." (B).   Waving is an action applying to one thing. The waving action translates into I6 as "Wave".   The specification of the waving action is "Waving in this sense is like waving a sceptre: the item to be waved must be directly held (or worn) by the actor.   In the Standard Rules there are no carry out rules for this action because nothing in the standard Inform world model which reacts to it. The action is provided for authors to hang more interesting behaviour onto for special cases: say, waving a particular rusty iron rod with a star on the end."   Check an actor waving (this is the can't wave what's not held rule):   if the actor is not the holder of the noun:      if the actor is the player:         say "But [we] [aren't] holding [regarding the noun][those]." (A);      stop the action.   Report an actor waving (this is the report waving things rule):   if the actor is the player:      if the action is not silent:         say "[We] [wave] [the noun]." (A);   otherwise:      say "[The actor] [wave] [the noun]." (B).   Pulling is an action applying to one thing. The Pulling action translates into I6 as "Pull".   The specification of the pulling action is "Pulling is the act of pulling something not grossly larger than the actor by an amount which would not substantially move it.   In the Standard Rules there are no carry out rules for this action because nothing in the standard Inform world model which reacts to it. The action is provided for authors to hang more interesting behaviour onto for special cases: say, pulling a lever. ('The big red lever is a fixed in place device. Instead of pulling the big red lever, try switching on the lever. Instead of pushing the big red lever, try switching off the lever.')"   Check an actor pulling (this is the can't pull what's fixed in place rule):   if the noun is fixed in place:      if the actor is the player:         say "[regarding the noun][They] [are] fixed in place." (A);      stop the action.   Check an actor pulling (this is the can't pull scenery rule):   if the noun is scenery:      if the actor is the player:         say "[We] [are] unable to." (A);      stop the action.   Check an actor pulling (this is the can't pull people rule):   if the noun is a person:      if the actor is the player:         say "[The noun] [might not like] that." (A);      stop the action.   Report an actor pulling (this is the report pulling rule):   if the actor is the player:      if the action is not silent:         now the prior named object is nothing;         say "Nothing obvious [happen]." (A);   otherwise:      say "[The actor] [pull] [the noun]." (B).   Pushing is an action applying to one thing. The Pushing action translates into I6 as "Push".   The specification of the pushing action is "Pushing is the act of pushing something not grossly larger than the actor by an amount which would not substantially move it. (See also the pushing it to action, which involves a longer-distance push between rooms.)   In the Standard Rules there are no carry out rules for this action because nothing in the standard Inform world model which reacts to it. The action is provided for authors to hang more interesting behaviour onto for special cases: say, pulling a lever. ('The big red lever is a fixed in place device. Instead of pulling the big red lever, try switching on the lever. Instead of pushing the big red lever, try switching off the lever.')"   Check an actor pushing something (this is the can't push what's fixed in place rule):   if the noun is fixed in place:      if the actor is the player:         say "[regarding the noun][They] [are] fixed in place." (A);      stop the action.   Check an actor pushing something (this is the can't push scenery rule):   if the noun is scenery:      if the actor is the player:         say "[We] [are] unable to." (A);      stop the action.   Check an actor pushing something (this is the can't push people rule):   if the noun is a person:      if the actor is the player:         say "[The noun] [might not like] that." (A);      stop the action.   Report an actor pushing something (this is the report pushing rule):   if the actor is the player:      if the action is not silent:         now the prior named object is nothing;         say "Nothing obvious [happen]." (A);   otherwise:      say "[The actor] [push] [the noun]." (B).   Turning is an action applying to one thing. The Turning action translates into I6 as "Turn".   The specification of the turning action is "Turning is the act of rotating something - say, a dial.   In the Standard Rules there are no carry out rules for this action because nothing in the standard Inform world model which reacts to it. The action is provided for authors to hang more interesting behaviour onto for special cases: say, turning a capstan."   Check an actor turning (this is the can't turn what's fixed in place rule):   if the noun is fixed in place:      if the actor is the player:         say "[regarding the noun][They] [are] fixed in place." (A);      stop the action.   Check an actor turning (this is the can't turn scenery rule):   if the noun is scenery:      if the actor is the player:         say "[We] [are] unable to." (A);      stop the action.   Check an actor turning (this is the can't turn people rule):   if the noun is a person:      if the actor is the player:         say "[The noun] [might not like] that." (A);      stop the action.   Report an actor turning (this is the report turning rule):   if the actor is the player:      if the action is not silent:         now the prior named object is nothing;         say "Nothing obvious [happen]." (A);   otherwise:      say "[The actor] [turn] [the noun]." (B).   Pushing it to is an action applying to one thing and one visible thing. The Pushing it to action translates into I6 as "PushDir".   The specification of the pushing it to action is "This action covers pushing a large object, not being carried, so that the actor pushes it from one room to another: for instance, pushing a bale of hay to the east.   This is rapidly converted into a special form of the going action. If the noun object has the either/or property 'pushable between rooms', then the action is converted to going by the 'standard pushing in directions rule'. If that going action succeeds, then the original pushing it to action stops; it's only if that fails that we run on into the 'block pushing in directions rule', which then puts an end to the matter."   Check an actor pushing something to (this is the can't push unpushable things rule):   if the noun is not pushable between rooms:      if the actor is the player:         say "[The noun] [cannot] be pushed from place to place." (A);      stop the action.   Check an actor pushing something to (this is the can't push to non-directions rule):   if the second noun is not a direction:      if the actor is the player:         say "[regarding the noun][They] [aren't] a direction." (A);      stop the action.   Check an actor pushing something to (this is the can't push vertically rule):   if the second noun is up or the second noun is down:      if the actor is the player:         say "[The noun] [cannot] be pushed up or down." (A);      stop the action.   Check an actor pushing something to (this is the can't push from within rule):   if the noun encloses the actor:      if the actor is the player:         say "[The noun] [cannot] be pushed from here." (A);      stop the action.   Check an actor pushing something to (this is the standard pushing in directions rule):   convert to special going-with-push action.   Check an actor pushing something to (this is the block pushing in directions rule):   if the actor is the player:      say "[The noun] [cannot] be pushed from place to place." (A);   stop the action.   Squeezing is an action applying to one thing. The Squeezing action translates into I6 as "Squeeze".   The specification of the squeezing action is "Squeezing is an action which can conveniently vary from squeezing something hand-held, like a washing-up liquid bottle, right up to squeezing a pillar in a bear hug.   In the Standard Rules there are no carry out rules for this action because nothing in the standard Inform world model which reacts to it. The action is provided for authors to hang more interesting behaviour onto for special cases. A mildly fruity message is produced to players who attempt to squeeze people, which is blocked by a check squeezing rule."   Check an actor squeezing (this is the innuendo about squeezing people rule):   if the noun is a person:      if the actor is the player:         say "[The noun] [might not like] that." (A);      stop the action.   Report an actor squeezing (this is the report squeezing rule):   if the actor is the player:      if the action is not silent:         say "[We] [achieve] nothing by this." (A);   otherwise:      say "[The actor] [squeeze] [the noun]." (B).   Section SR4/8 - Standard actions which always do nothing unless rules intervene   Saying yes is an action applying to nothing. The Saying yes action translates into I6 as "Yes".   The specification of the saying yes action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor saying yes (this is the block saying yes rule):   if the actor is the player:      say "That was a rhetorical question." (A);   stop the action.   Saying no is an action applying to nothing. The Saying no action translates into I6 as "No".   The specification of the saying no action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor saying no (this is the block saying no rule):   if the actor is the player:      say "That was a rhetorical question." (A);   stop the action.   Burning is an action applying to one thing. The Burning action translates into I6 as "Burn".   The specification of the burning action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor burning (this is the block burning rule):   if the actor is the player:      say "This dangerous act [would achieve] little." (A);   stop the action.   Waking up is an action applying to nothing. The Waking up action translates into I6 as "Wake".   The specification of the waking up action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor waking up (this is the block waking up rule):   if the actor is the player:      now the prior named object is nothing;      say "The dreadful truth [are], this [are not] a dream." (A);   stop the action.   Thinking is an action applying to nothing. The Thinking action translates into I6 as "Think".   The specification of the thinking action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor thinking (this is the block thinking rule):   if the actor is the player:      say "What a good idea." (A);   stop the action.   Smelling is an action applying to nothing or one thing. The Smelling action translates into I6 as "Smell".   The specification of the smelling action is "The Standard Rules define this action in only a minimal way, replying only that the player smells nothing unexpected."   Report an actor smelling (this is the report smelling rule):   if the actor is the player:      if the action is not silent:         say "[We] [smell] nothing unexpected." (A);   otherwise:      say "[The actor] [sniff]." (B).   Listening to is an action applying to nothing or one thing and abbreviable. The Listening to action translates into I6 as "Listen".   The specification of the listening to action is "The Standard Rules define this action in only a minimal way, replying only that the player hears nothing unexpected."   Report an actor listening to (this is the report listening rule):   if the actor is the player:      if the action is not silent:         say "[We] [hear] nothing unexpected." (A);   otherwise:      say "[The actor] [listen]." (B).   Tasting is an action applying to one thing. The Tasting action translates into I6 as "Taste".   The specification of the tasting action is "The Standard Rules define this action in only a minimal way, replying only that the player tastes nothing unexpected."   Report an actor tasting (this is the report tasting rule):   if the actor is the player:      if the action is not silent:         say "[We] [taste] nothing unexpected." (A);   otherwise:      say "[The actor] [taste] [the noun]." (B).   Cutting is an action applying to one thing. The Cutting action translates into I6 as "Cut".   The specification of the cutting action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor cutting (this is the block cutting rule):   if the actor is the player:      say "Cutting [regarding the noun][them] up [would achieve] little." (A);   stop the action.   Jumping is an action applying to nothing. The Jumping action translates into I6 as "Jump".   The specification of the jumping action is "The Standard Rules define this action in only a minimal way, simply reporting a little jump on the spot."   Report an actor jumping (this is the report jumping rule):   if the actor is the player:      if the action is not silent:         say "[We] [jump] on the spot." (A);   otherwise:      say "[The actor] [jump] on the spot." (B).   Tying it to is an action applying to two things. The Tying it to action translates into I6 as "Tie".   The specification of the tying it to action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor tying something to (this is the block tying rule):   if the actor is the player:      say "[We] [would achieve] nothing by this." (A);   stop the action.   Drinking is an action applying to one thing. The Drinking action translates into I6 as "Drink".   The specification of the drinking action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor drinking (this is the block drinking rule):   if the actor is the player:      now the prior named object is nothing;      say "[There's] nothing suitable to drink here." (A);   stop the action.   Saying sorry is an action applying to nothing. The Saying sorry action translates into I6 as "Sorry".   The specification of the saying sorry action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor saying sorry (this is the block saying sorry rule):   if the actor is the player:      say "Oh, don't [if American dialect option is         active]apologize[otherwise]apologise[end if]." (A);   stop the action.   Swinging is an action applying to one thing. The Swinging action translates into I6 as "Swing".   The specification of the swinging action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor swinging (this is the block swinging rule):   if the actor is the player:      now the prior named object is nothing;      say "[There's] nothing sensible to swing here." (A);   stop the action.   Rubbing is an action applying to one thing. The Rubbing action translates into I6 as "Rub".   The specification of the rubbing action is "The Standard Rules define this action in only a minimal way, simply reporting that it has happened."   Check an actor rubbing (this is the can't rub another person rule):   if the noun is a person who is not the actor:      if the actor is the player:         say "[The noun] [might not like] that." (A);      stop the action.   Report an actor rubbing (this is the report rubbing rule):   if the actor is the player:      if the action is not silent:         say "[We] [rub] [the noun]." (A);   otherwise:      say "[The actor] [rub] [the noun]." (B).   Setting it to is an action applying to one thing and one topic. The Setting it to action translates into I6 as "SetTo".   The specification of the setting it to action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor setting something to (this is the block setting it to rule):   if the actor is the player:      say "No, [we] [can't set] [regarding the noun][those] to anything." (A);   stop the action.   Waving hands is an action applying to nothing. The Waving hands action translates into I6 as "WaveHands".   The specification of the waving hands action is "The Standard Rules define this action in only a minimal way, simply reporting a little wave of the hands."   Report an actor waving hands (this is the report waving hands rule):   if the actor is the player:      if the action is not silent:         say "[We] [wave]." (A);   otherwise:      say "[The actor] [wave]." (B).   Buying is an action applying to one thing. The Buying action translates into I6 as "Buy".   The specification of the buying action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor buying (this is the block buying rule):   if the actor is the player:      now the prior named object is nothing;      say "Nothing [are] on sale." (A);   stop the action.   Climbing is an action applying to one thing. The Climbing action translates into I6 as "Climb".   The specification of the climbing action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor climbing (this is the block climbing rule):   if the actor is the player:      say "Little [are] to be achieved by that." (A);   stop the action.   Sleeping is an action applying to nothing. The Sleeping action translates into I6 as "Sleep".   The specification of the sleeping action is "The Standard Rules define this action in only a minimal way, blocking it with a check rule which stops it in all cases. It exists so that before or instead rules can be written to make it do interesting things in special cases. (Or to reconstruct the action as something more substantial, unlist the block rule and supply carry out and report rules, together perhaps with some further check rules.)"   Check an actor sleeping (this is the block sleeping rule):   if the actor is the player:      say "[We] [aren't] feeling especially drowsy." (A);   stop the action.   Section SR4/9 - Standard actions which happen out of world   Quitting the game is an action out of world and applying to nothing. The quitting the game action translates into I6 as "Quit".   The quit the game rule is listed in the carry out quitting the game rulebook. The quit the game rule translates into I6 as "QUIT_THE_GAME_R" with   "Are you sure you want to quit? " (A).   Saving the game is an action out of world and applying to nothing. The saving the game action translates into I6 as "Save".   The save the game rule is listed in the carry out saving the game rulebook. The save the game rule translates into I6 as "SAVE_THE_GAME_R" with   "Save failed." (A),   "Ok." (B).   Restoring the game is an action out of world and applying to nothing. The restoring the game action translates into I6 as "Restore".   The restore the game rule is listed in the carry out restoring the game rulebook. The restore the game rule translates into I6 as "RESTORE_THE_GAME_R" with   "Restore failed." (A),   "Ok." (B).   Restarting the game is an action out of world and applying to nothing. The restarting the game action translates into I6 as "Restart".   The restart the game rule is listed in the carry out restarting the game rulebook. The restart the game rule translates into I6 as "RESTART_THE_GAME_R" with   "Are you sure you want to restart? " (A),   "Failed." (B).   Verifying the story file is an action out of world and applying to nothing. The verifying the story file action translates into I6 as "Verify".   The verify the story file rule is listed in the carry out verifying the story file rulebook. The verify the story file rule translates into I6 as "VERIFY_THE_STORY_FILE_R" with   "The game file has verified as intact." (A),   "The game file did not verify as intact, and may be corrupt." (B).   Switching the story transcript on is an action out of world and applying to nothing. The switching the story transcript on action translates into I6 as "ScriptOn".   The switch the story transcript on rule is listed in the carry out switching the story   transcript on rulebook. The switch the story transcript on rule translates into I6 as "SWITCH_TRANSCRIPT_ON_R" with    "Transcripting is already on." (A),    "Start of a transcript of" (B),    "Attempt to begin transcript failed." (C).   Switching the story transcript off is an action out of world and applying to nothing. The switching the story transcript off action translates into I6 as "ScriptOff".   The switch the story transcript off rule is listed in the carry out switching the story   transcript off rulebook. The switch the story transcript off rule translates into I6 as "SWITCH_TRANSCRIPT_OFF_R" with    "Transcripting is already off." (A),    "[line break]End of transcript." (B),    "Attempt to end transcript failed." (C).     Requesting the story file version is an action out of world and applying to nothing. The requesting the story file version action translates into I6 as "Version".   The announce the story file version rule is listed in the carry out requesting the story   file version rulebook. The announce the story file version rule translates into I6 as "ANNOUNCE_STORY_FILE_VERSION_R".   Requesting the score is an action out of world and applying to nothing. The requesting the score action translates into I6 as "Score".   The announce the score rule is listed in the carry out requesting the score rulebook. The announce the score rule translates into I6 as "ANNOUNCE_SCORE_R" with   "[if the story has ended]In that game you scored[otherwise]You have so far scored[end if]   [score] out of a possible [maximum score], in [turn count] turn[s]" (A),    ", earning you the rank of " (B),   "[There] [are] no score in this story." (C),   "[bracket]Your score has just gone up by [number understood in words]      point[s].[close bracket]" (D),   "[bracket]Your score has just gone down by [number understood in words]      point[s].[close bracket]" (E).   Preferring abbreviated room descriptions is an action out of world and applying to nothing. The preferring abbreviated room descriptions action translates into I6 as "LMode3".   The prefer abbreviated room descriptions rule is listed in the carry out preferring   abbreviated room descriptions rulebook. The prefer abbreviated room descriptions rule translates into I6 as "PREFER_ABBREVIATED_R".   The standard report preferring abbreviated room descriptions rule is listed in the   report preferring abbreviated room descriptions rulebook. The standard report preferring abbreviated room descriptions rule translates into   I6 as "REP_PREFER_ABBREVIATED_R" with   " is now in its 'superbrief' mode, which always gives short descriptions   of locations (even if you haven't been there before)." (A).   Preferring unabbreviated room descriptions is an action out of world and applying to nothing. The preferring unabbreviated room descriptions action translates into I6 as "LMode2".   The prefer unabbreviated room descriptions rule is listed in the carry out preferring   unabbreviated room descriptions rulebook. The prefer unabbreviated room descriptions rule translates into I6 as "PREFER_UNABBREVIATED_R".   The standard report preferring unabbreviated room descriptions rule is listed in the   report preferring unabbreviated room descriptions rulebook. The standard report preferring unabbreviated room descriptions rule translates into   I6 as "REP_PREFER_UNABBREVIATED_R" with   " is now in its 'verbose' mode, which always gives long descriptions of   locations (even if you've been there before)." (A).   Preferring sometimes abbreviated room descriptions is an action out of world and   applying to nothing. The preferring sometimes abbreviated room descriptions action translates into I6 as "LMode1".   The prefer sometimes abbreviated room descriptions rule is listed in the carry out   preferring sometimes abbreviated room descriptions rulebook. The prefer sometimes abbreviated room descriptions rule translates into I6 as   "PREFER_SOMETIMES_ABBREVIATED_R".   The standard report preferring sometimes abbreviated room descriptions rule is listed   in the report preferring sometimes abbreviated room descriptions rulebook. The standard report preferring sometimes abbreviated room descriptions rule translates   into I6 as "REP_PREFER_SOMETIMES_ABBR_R" with   " is now in its 'brief' printing mode, which gives long descriptions    of places never before visited and short descriptions otherwise." (A).   Switching score notification on is an action out of world and applying to nothing. The switching score notification on action translates into I6 as "NotifyOn".   The switch score notification on rule is listed in the carry out switching score   notification on rulebook. The switch score notification on rule translates into I6 as "SWITCH_SCORE_NOTIFY_ON_R".   The standard report switching score notification on rule is listed in the report   switching score notification on rulebook. The standard report switching score notification on rule translates into   I6 as "REP_SWITCH_NOTIFY_ON_R" with "Score notification on." (A).   Switching score notification off is an action out of world and applying to nothing. The switching score notification off action translates into I6 as "NotifyOff".   The switch score notification off rule is listed in the carry out switching score   notification off rulebook. The switch score notification off rule translates into I6 as "SWITCH_SCORE_NOTIFY_OFF_R".   The standard report switching score notification off rule is listed in the report   switching score notification off rulebook. The standard report switching score notification off rule translates into   I6 as "REP_SWITCH_NOTIFY_OFF_R" with "Score notification off." (A).   Requesting the pronoun meanings is an action out of world and applying to nothing. The requesting the pronoun meanings action translates into I6 as "Pronouns".   The announce the pronoun meanings rule is listed in the carry out requesting the   pronoun meanings rulebook. The announce the pronoun meanings rule translates into I6 as "ANNOUNCE_PRONOUN_MEANINGS_R" with   "At the moment, " (A),   "means " (B),   "is unset" (C),   "no pronouns are known to the game." (D).   The understand token a time period translates into I6 as "RELATIVE_TIME_TOKEN".   Section SR4/10 - Grammar   Understand "take [things]" as taking. Understand "take off [something]" as taking off. Understand "take [something] off" as taking off. Understand "take [things inside] from [something]" as removing it from. Understand "take [things inside] off [something]" as removing it from. Understand "take inventory" as taking inventory. Understand the commands "carry" and "hold" as "take".   Understand "get in/on" as entering. Understand "get out/off/down/up" as exiting. Understand "get [things]" as taking. Understand "get in/into/on/onto [something]" as entering. Understand "get off/down [something]" as getting off. Understand "get [things inside] from [something]" as removing it from.   Understand "pick up [things]" or "pick [things] up" as taking.   Understand "stand" or "stand up" as exiting. Understand "stand on [something]" as entering.   Understand "remove [something preferably held]" as taking off. Understand "remove [things inside] from [something]" as removing it from.   Understand "shed [something preferably held]" as taking off. Understand the commands "doff" and "disrobe" as "shed".   Understand "wear [something preferably held]" as wearing. Understand the command "don" as "wear".   Understand "put [other things] in/inside/into [something]" as inserting it into. Understand "put [other things] on/onto [something]" as putting it on. Understand "put on [something preferably held]" as wearing. Understand "put [something preferably held] on" as wearing. Understand "put down [things preferably held]" or "put [things preferably held] down" as dropping.   Understand "insert [other things] in/into [something]" as inserting it into.   Understand "drop [things preferably held]" as dropping. Understand "drop [other things] in/into/down [something]" as inserting it into. Understand "drop [other things] on/onto [something]" as putting it on. Understand "drop [something preferably held] at/against [something]" as throwing it at. Understand the commands "throw" and "discard" as "drop".   Understand "give [something preferably held] to [someone]" as giving it to. Understand "give [someone] [something preferably held]" as giving it to (with nouns reversed). Understand the commands "pay" and "offer" and "feed" as "give".   Understand "show [someone] [something preferably held]" as showing it to (with nouns reversed). Understand "show [something preferably held] to [someone]" as showing it to. Understand the commands "present" and "display" as "show".   Understand "go" as going. Understand "go [direction]" as going. Understand "go [something]" as entering. Understand "go into/in/inside/through [something]" as entering. Understand the commands "walk" and "run" as "go".   Understand "inventory" as taking inventory. Understand the commands "i" and "inv" as "inventory".   Understand "look" as looking. Understand "look at [something]" as examining. Understand "look [something]" as examining. Understand "look inside/in/into/through [something]" as searching. Understand "look under [something]" as looking under. Understand "look up [text] in [something]" as consulting it about (with nouns reversed). Understand the command "l" as "look".   Understand "consult [something] on/about [text]" as consulting it about.   Understand "open [something]" as opening. Understand "open [something] with [something preferably held]" as unlocking it with. Understand the commands "unwrap", "uncover" as "open".   Understand "close [something]" as closing. Understand "close up [something]" as closing. Understand "close off [something]" as switching off. Understand the commands "shut" and "cover" as "close".   Understand "enter" as entering. Understand "enter [something]" as entering. Understand the command "cross" as "enter".   Understand "sit on top of [something]" as entering. Understand "sit on/in/inside [something]" as entering.   Understand "exit" as exiting. Understand the commands "leave" and "out" as "exit".   Understand "examine [something]" as examining. Understand the commands "x", "watch", "describe" and "check" as "examine".   Understand "read [something]" as examining. Understand "read about [text] in [something]" as consulting it about (with nouns reversed). Understand "read [text] in [something]" as consulting it about (with nouns reversed).   Understand "yes" as saying yes. Understand the command "y" as "yes".   Understand "no" as saying no.   Understand "sorry" as saying sorry.   Understand "search [something]" as searching.   Understand "wave" as waving hands.   Understand "wave [something]" as waving.   Understand "set [something] to [text]" as setting it to. Understand the command "adjust" as "set".   Understand "pull [something]" as pulling. Understand the command "drag" as "pull".   Understand "push [something]" as pushing. Understand "push [something] [direction]" or "push [something] to [direction]" as pushing it to. Understand the commands "move", "shift", "clear" and "press" as "push".   Understand "turn [something]" as turning. Understand "turn [something] on" or "turn on [something]" as switching on. Understand "turn [something] off" or "turn off [something]" as switching off. Understand the commands "rotate", "twist", "unscrew" and "screw" as "turn".   Understand "switch [something switched on]" as switching off. Understand "switch [something]" or "switch on [something]" or "switch [something] on" as   switching on. Understand "switch [something] off" or "switch off [something]" as switching off.   Understand "lock [something] with [something preferably held]" as locking it with.   Understand "unlock [something] with [something preferably held]" as unlocking it with.   Understand "attack [something]" as attacking. Understand the commands "break", "smash", "hit", "fight", "torture", "wreck", "crack", "destroy",   "murder", "kill", "punch" and "thump" as "attack".   Understand "wait" as waiting. Understand the command "z" as "wait".   Understand "answer [text] to [someone]" as answering it that (with nouns reversed). Understand the commands "say", "shout" and "speak" as "answer".   Understand "tell [someone] about [text]" as telling it about.   Understand "ask [someone] about [text]" as asking it about. Understand "ask [someone] for [something]" as asking it for.   Understand "eat [something preferably held]" as eating.   Understand "sleep" as sleeping. Understand the command "nap" as "sleep".   Understand "climb [something]" or "climb up/over [something]" as climbing. Understand the command "scale" as "climb".   Understand "buy [something]" as buying. Understand the command "purchase" as "buy".   Understand "squeeze [something]" as squeezing. Understand the command "squash" as "squeeze".   Understand "swing [something]" or "swing on [something]" as swinging.   Understand "wake" or "wake up" as waking up. Understand "wake [someone]" or "wake [someone] up" or "wake up [someone]" as waking. Understand the commands "awake" and "awaken" as "wake".   Understand "kiss [someone]" as kissing. Understand the commands "embrace" and "hug" as "kiss".   Understand "think" as thinking.   Understand "smell" as smelling. Understand "smell [something]" as smelling. Understand the command "sniff" as "smell".   Understand "listen" as listening to. Understand "hear [something]" as listening to. Understand "listen to [something]" as listening to.   Understand "taste [something]" as tasting.   Understand "touch [something]" as touching. Understand the command "feel" as "touch".   Understand "rub [something]" as rubbing. Understand the commands "shine", "polish", "sweep", "clean", "dust", "wipe" and "scrub" as "rub".   Understand "tie [something] to [something]" as tying it to. Understand the commands "attach" and "fasten" as "tie".   Understand "burn [something]" as burning. Understand the command "light" as "burn".   Understand "drink [something]" as drinking. Understand the commands "swallow" and "sip" as "drink".   Understand "cut [something]" as cutting. Understand the commands "slice", "prune" and "chop" as "cut".   Understand "jump" as jumping. Understand the commands "skip" and "hop" as "jump".   Understand "score" as requesting the score. Understand "quit" or "q" as quitting the game. Understand "save" as saving the game. Understand "restart" as restarting the game. Understand "restore" as restoring the game. Understand "verify" as verifying the story file. Understand "version" as requesting the story file version. Understand "script" or "script on" or "transcript" or "transcript on" as switching the story   transcript on. Understand "script off" or "transcript off" as switching the story transcript off. Understand "superbrief" or "short" as preferring abbreviated room descriptions. Understand "verbose" or "long" as preferring unabbreviated room descriptions. Understand "brief" or "normal" as preferring sometimes abbreviated room descriptions. Understand "nouns" or "pronouns" as requesting the pronoun meanings. Understand "notify" or "notify on" as switching score notification on. Understand "notify off" as switching score notification off.     Part SR5 - Phrasebook   Section SR5/1/1 - Saying - Values   To say (val - sayable value of kind K)   (documented at ph_say):   (- {-say:val:K} -).   To say (something - number) in words   (documented at phs_numwords):   (- print (number) say__n=({something}); -). To say (something - time) in words   (documented at phs_timewords):   (- print (PrintTimeOfDayEnglish) {something}; -). To say s   (documented at phs_s):   (- STextSubstitution(); -).   Section SR5/1/2 - Saying - Names with articles   To say a (something - object)   (documented at phs_a):   (- print (a) {something}; -). To say an (something - object)   (documented at phs_a):   (- print (a) {something}; -). To say A (something - object)   (documented at phs_A):   (- CIndefArt({something}); -). To say An (something - object)   (documented at phs_A):   (- CIndefArt({something}); -). To say the (something - object)   (documented at phs_the):   (- print (the) {something}; -). To say The (something - object)   (documented at phs_The):   (- print (The) {something}; -).   Section SR5/1/3 - Saying - Say if and otherwise   To say if (c - condition)   (documented at phs_if): (- {-erase}   if (~~({c})) jump {-label:Say};      -). To say unless (c - condition)   (documented at phs_unless): (- {-erase}   if ({c}) jump {-label:Say};      -). To say otherwise/else if (c - condition)   (documented at phs_elseif): (- {-erase}   jump {-label:SayX}; .{-label:Say}{-counter-up:Say}; if (~~({c})) jump {-label:Say};      -). To say otherwise/else unless (c - condition)   (documented at phs_elseunless): (- {-erase}   jump {-label:SayX}; .{-label:Say}{-counter-up:Say}; if ({c}) jump {-label:Say};      -). To say otherwise   (documented at phs_otherwise): (- {-erase}   jump {-label:SayX}; .{-label:Say}{-counter-up:Say};      -). To say else   (documented at phs_otherwise): (- {-erase}   jump {-label:SayX}; .{-label:Say}{-counter-up:Say};      -). To say end if   (documented at phs_endif): (- {-erase}   .{-label:Say}{-counter-up:Say}; .{-label:SayX}{-counter-up:SayX};      -). To say end unless   (documented at phs_endunless): (- {-erase}   .{-label:Say}{-counter-up:Say}; .{-label:SayX}{-counter-up:SayX};      -).   Section SR5/1/4 - Saying - Say one of   To say one of -- beginning say_one_of (documented at phs_oneof): (-   {-counter-makes-array:say_one_of}   {-counter-makes-array:say_one_flag}   if (I7_ST_say_one_flag-->{-counter:say_one_flag} == false) {      I7_ST_say_one_of-->{-counter:say_one_of} = {-final-segment-marker}(I7_ST_say_one_of-->{-counter:say_one_of}, {-segment-count});       I7_ST_say_one_flag-->{-counter:say_one_flag} = true;   }   if (say__comp == false) I7_ST_say_one_flag-->{-counter:say_one_flag}{-counter-up:say_one_flag} = false;   switch ((I7_ST_say_one_of-->{-counter:say_one_of}{-counter-up:say_one_of})%({-segment-count}+1)-1) {-open-brace}      0: -). To say or -- continuing say_one_of (documented at phs_or):   (- @nop; {-segment-count}: -). To say at random -- ending say_one_of with marker I7_SOO_RAN (documented at phs_random):   (- {-close-brace} -). To say purely at random -- ending say_one_of with marker I7_SOO_PAR (documented at phs_purelyrandom):   (- {-close-brace} -). To say then at random -- ending say_one_of with marker I7_SOO_TRAN (documented at phs_thenrandom):   (- {-close-brace} -). To say then purely at random -- ending say_one_of with marker I7_SOO_TPAR (documented at phs_thenpurelyrandom):   (- {-close-brace} -). To say sticky random -- ending say_one_of with marker I7_SOO_STI (documented at phs_sticky):   (- {-close-brace} -). To say as decreasingly likely outcomes -- ending say_one_of with marker I7_SOO_TAP (documented at phs_decreasing):   (- {-close-brace} -). To say in random order -- ending say_one_of with marker I7_SOO_SHU (documented at phs_order):   (- {-close-brace} -). To say cycling -- ending say_one_of with marker I7_SOO_CYC (documented at phs_cycling):   (- {-close-brace} -). To say stopping -- ending say_one_of with marker I7_SOO_STOP (documented at phs_stopping):   (- {-close-brace} -).   To say first time -- beginning say_first_time (documented at phs_firsttime):   (- {-counter-makes-array:say_first_time}   if ((say__comp == false) && ((I7_ST_say_first_time-->{-counter:say_first_time}{-counter-up:say_first_time})++ == 0)) {-open-brace}      -). To say only -- ending say_first_time (documented at phs_firsttime):   (- {-close-brace} -).   Section SR5/1/5 - Saying - Paragraph control   To say line break -- running on   (documented at phs_linebreak):   (- new_line; -). To say no line break -- running on   (documented at phs_nolinebreak): do nothing. To say conditional paragraph break -- running on   (documented at phs_condparabreak):   (- DivideParagraphPoint(); -). To say command clarification break -- running on   (documented at phs_clarifbreak):   (- CommandClarificationBreak(); -). To say paragraph break -- running on   (documented at phs_parabreak):   (- DivideParagraphPoint(); new_line; -). To say run paragraph on -- running on   (documented at phs_runparaon):   (- RunParagraphOn(); -). To say run paragraph on with special look spacing -- running on   (documented at phs_runparaonsls):   (- SpecialLookSpacingBreak(); -). To decide if a paragraph break is pending   (documented at ph_breakpending):   (- (say__p) -).   Section SR5/1/6 - Saying - Special characters   To say bracket -- running on   (documented at phs_bracket):   (- print "["; -). To say close bracket -- running on   (documented at phs_closebracket):   (- print "]"; -). To say apostrophe/' -- running on   (documented at phs_apostrophe):   (- print "'"; -). To say quotation mark -- running on   (documented at phs_quotemark):   (- print "~"; -).   Section SR5/1/7 - Saying - Fonts and visual effects   To say bold type -- running on   (documented at phs_bold):   (- style bold; -). To say italic type -- running on   (documented at phs_italic):   (- style underline; -). To say roman type -- running on   (documented at phs_roman):   (- style roman; -). To say fixed letter spacing -- running on   (documented at phs_fixedspacing):   (- font off; -). To say variable letter spacing -- running on   (documented at phs_varspacing):   (- font on; -). To display the boxed quotation (Q - text)   (documented at ph_boxed):   (- DisplayBoxedQuotation({-box-quotation-text:Q}); -).   Section SR5/1/8 - Saying - Some built-in texts   To say the/-- banner text   (documented at phs_banner):   (- Banner(); -). To say the/-- list of extension credits   (documented at phs_extcredits):   (- ShowExtensionVersions(); -). To say the/-- complete list of extension credits   (documented at phs_compextcredits):   (- ShowFullExtensionVersions(); -). To say the/-- player's surroundings   (documented at phs_surroundings):   (- SL_Location(true); -).   Section SR5/1/9 - Saying - Saying lists of things   To list the contents of (O - an object),   with newlines,   indented,   giving inventory information,   as a sentence,   including contents,   including all contents,   tersely,   giving brief inventory information,   using the definite article,   listing marked items only,   prefacing with is/are,   not listing concealed items,   suppressing all articles,   with extra indentation,   and/or capitalized   (documented at ph_listcontents):   (- WriteListFrom(child({O}), {phrase options}); -).   To say a list of (OS - description of objects)   (documented at phs_alistof): (-       objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      WriteListOfMarkedObjects(ENGLISH_BIT);   -). To say A list of (OS - description of objects)   (documented at phs_Alistof):   (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      TEXT_TY_Say_Capitalised((+ "[list-writer list of marked objects]" +));   -).   To say list of (OS - description of objects)   (documented at phs_listof): (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      WriteListOfMarkedObjects(ENGLISH_BIT+NOARTICLE_BIT);   -). To say the list of (OS - description of objects)   (documented at phs_thelistof): (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      WriteListOfMarkedObjects(ENGLISH_BIT+DEFART_BIT);   -). To say The list of (OS - description of objects)   (documented at phs_Thelistof):   (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      TEXT_TY_Say_Capitalised((+ "[list-writer articled list of marked objects]" +));   -). To say is-are a list of (OS - description of objects)   (documented at phs_isalistof): (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      WriteListOfMarkedObjects(ENGLISH_BIT+ISARE_BIT);   -). To say is-are list of (OS - description of objects)   (documented at phs_islistof): (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      WriteListOfMarkedObjects(ENGLISH_BIT+ISARE_BIT+NOARTICLE_BIT);   -). To say is-are the list of (OS - description of objects)   (documented at phs_isthelistof): (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      WriteListOfMarkedObjects(ENGLISH_BIT+DEFART_BIT+ISARE_BIT);   -). To say a list of (OS - description of objects) including contents   (documented at phs_alistofconts): (-      objectloop({-my:1} ofclass Object)         if ({-matches-description:1:OS})            give {-my:1} workflag2;         else            give {-my:1} ~workflag2;      WriteListOfMarkedObjects(ENGLISH_BIT+RECURSE_BIT+PARTINV_BIT+         TERSE_BIT+CONCEAL_BIT);   -).   Section SR5/1/10 - Saying - Group in and omit from lists   To group (OS - description of objects) together   (documented at ph_group): (-      objectloop({-my:1} provides list_together)         if ({-matches-description:1:OS})            BlkValueCopy({-my:1}.list_together, {-list-together:unarticled});   -). To group (OS - description of objects) together giving articles   (documented at ph_groupart): (-      objectloop({-my:1} provides list_together)         if ({-matches-description:1:OS})            BlkValueCopy({-my:1}.list_together, {-list-together:articled});   -). To group (OS - description of objects) together as (T - text)   (documented at ph_grouptext): (-      {-my:2} = BlkValueCreate(TEXT_TY);      {-my:2} = TEXT_TY_SubstitutedForm({-my:2}, {-by-reference:T});      objectloop({-my:1} provides list_together)         if ({-matches-description:1:OS})            BlkValueCopy({-my:1}.list_together, {-my:2});      BlkValueFree({-my:2});   -). To omit contents in listing   (documented at ph_omit):   (- c_style = c_style &~ (RECURSE_BIT+FULLINV_BIT+PARTINV_BIT); -).   Section SR5/1/11 - Saying - Lists of values   To say (L - a list of values) in brace notation   (documented at phs_listbraced):   (- LIST_OF_TY_Say({-by-reference:L}, 1); -). To say (L - a list of objects) with definite articles   (documented at phs_listdef):   (- LIST_OF_TY_Say({-by-reference:L}, 2); -). To say (L - a list of objects) with indefinite articles   (documented at phs_listindef):   (- LIST_OF_TY_Say({-by-reference:L}, 3); -).   Section SR5/1/12 - Saying - Filtering contents - Unindexed   To filter list recursion to (D - description of objects):   (- list_filter_routine = {D}; -). To unfilter list recursion:   (- list_filter_routine = 0; -).   Section SR5/1/13 - Saying - Responses   To say text of (R - response)   (documented at phs_response):   carry out the issuing the response text activity with R.   Section SR5/2/1 - Values - Making conditions true   To now (cn - condition)   (documented at ph_now):   (- {cn} -).   Section SR5/2/2 - Values - Giving values temporary names   To let (t - nonexisting variable) be (u - value)   (assignment operation)   (documented at ph_let): (-      {-unprotect:t}      {-copy:t:u}   -). To let (t - nonexisting variable) be (u - name of kind of value)   (assignment operation)   (documented at ph_letdefault): (-      {-unprotect:t}      {-initialise:t}   -). To let (t - nonexisting variable) be (u - description of relations of values   of kind K to values of kind L)   (assignment operation)   (documented at ph_letrelation): (-      {-unprotect:t}      {-initialise:t}      {-now-matches-description:t:u};   -). To let (t - nonexisting variable) be given by (Q - equation name)   (documented at ph_letequation): (-      {-unprotect:t}      {-primitive-definition:solve-equation};   -).   To let (t - existing variable) be (u - value)   (assignment operation)   (documented at ph_let): (-       {-copy:t:u}   -). To let (t - existing variable) be given by (Q - equation name)   (documented at ph_letequation): (-      {-primitive-definition:solve-equation};   -).   To increase (S - storage) by (w - value)   (assignment operation)   (documented at ph_increase): (-      {-copy:S:+w};   -). To decrease (S - storage) by (w - value)   (assignment operation)   (documented at ph_decrease): (-      {-copy:S:-w};   -). To increment (S - storage)   (documented at ph_increment): (-      {-copy:S:+};   -). To decrement (S - storage)   (documented at ph_decrement): (-      {-copy:S:-};   -).   Section SR5/2/4 - Values - Arithmetic   To decide which arithmetic value is (X - arithmetic value) + (Y - arithmetic value)   (arithmetic operation 0)   (documented at ph_plus):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) plus (Y - arithmetic value)   (arithmetic operation 0)   (documented at ph_plus):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) - (Y - arithmetic value)   (arithmetic operation 1)   (documented at ph_minus):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) minus (Y - arithmetic value)   (arithmetic operation 1)   (documented at ph_minus):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) * (Y - arithmetic value)   (arithmetic operation 2)   (documented at ph_times):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) times (Y - arithmetic value)   (arithmetic operation 2)   (documented at ph_times):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) multiplied by (Y - arithmetic value)   (arithmetic operation 2)   (documented at ph_times):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) / (Y - arithmetic value)   (arithmetic operation 3)   (documented at ph_divide):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) divided by (Y - arithmetic value)   (arithmetic operation 3)   (documented at ph_divide):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is remainder after dividing (X - arithmetic value)   by (Y - arithmetic value)   (arithmetic operation 4)   (documented at ph_remainder):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is (X - arithmetic value) to the nearest (Y - arithmetic value)   (arithmetic operation 5)   (documented at ph_nearest):   (- ({-arithmetic-operation:X:Y}) -). To decide which arithmetic value is the square root of (X - arithmetic value)   (arithmetic operation 6)   (documented at ph_squareroot):   (- ({-arithmetic-operation:X}) -). To decide which arithmetic value is the cube root of (X - arithmetic value)   (arithmetic operation 8)   (documented at ph_cuberoot):   (- ({-arithmetic-operation:X}) -). To decide which arithmetic value is total (p - arithmetic value valued property)   of (S - description of values)   (arithmetic operation 12)   (documented at ph_total):   (- {-primitive-definition:total-of} -).   Section SR5/2/4a - Values - Real Arithmetic (for Glulx only)   To say (R - a real number) to (N - number) decimal places   (documented at phs_realplaces):   (- Float({R}, {N}); -). To say (R - a real number) in decimal notation   (documented at phs_decimal):   (- FloatDec({R}); -). To say (R - a real number) to (N - number) decimal places in decimal notation   (documented at phs_decimalplaces):   (- FloatDec({R}, {N}); -). To say (R - a real number) in scientific notation   (documented at phs_scientific):   (- FloatExp({R}); -). To say (R - a real number) to (N - number) decimal places in scientific notation   (documented at phs_scientificplaces):   (- FloatExp({R}, {N}); -).   To decide which real number is the reciprocal of (R - a real number)   (documented at ph_reciprocal):   (- REAL_NUMBER_TY_Reciprocal({R}) -). To decide which real number is the absolute value of (R - a real number)   (documented at ph_absolutevalue)   (this is the abs function):   (- REAL_NUMBER_TY_Abs({R}) -). To decide which real number is the real square root of (R - a real number)   (arithmetic operation 7)   (documented at ph_realsquareroot)   (this is the root function inverse to rsqr):   (- REAL_NUMBER_TY_Root({R}) -). To decide which real number is the real square of (R - a real number)   (this is the rsqr function inverse to root):   let x be given by x = R^2 where x is a real number;   decide on x. To decide which real number is the ceiling of (R - a real number)   (documented at ph_ceiling)   (this is the ceiling function):   (- REAL_NUMBER_TY_Ceiling({R}) -). To decide which real number is the floor of (R - a real number)   (documented at ph_floor)   (this is the floor function):   (- REAL_NUMBER_TY_Floor({R}) -). To decide which number is (R - a real number) to the nearest whole number   (documented at ph_nearestwholenumber)   (this is the int function):   (- REAL_NUMBER_TY_to_NUMBER_TY({R}) -).   To decide which real number is the natural/-- logarithm of (R - a real number)   (documented at ph_logarithm)   (this is the log function inverse to exp):   (- REAL_NUMBER_TY_Log({R}) -). To decide which real number is the logarithm to base (N - a number) of (R - a real number)   (documented at ph_logarithmto):   (- REAL_NUMBER_TY_BLog({R}, {N}) -). To decide which real number is the exponential of (R - a real number)   (documented at ph_exp)   (this is the exp function inverse to log):   (- REAL_NUMBER_TY_Exp({R}) -). To decide which real number is (R - a real number) to the power (P - a real number)   (documented at ph_power):   (- REAL_NUMBER_TY_Pow({R}, {P}) -).   Section SR5/2/4a - Values - Trigonometry (for Glulx only)   To decide which real number is (R - a real number) degrees   (documented at ph_degrees):   (- REAL_NUMBER_TY_Times({R}, $+0.0174532925) -).   To decide which real number is the sine of (R - a real number)   (documented at ph_sine)   (this is the sin function inverse to arcsin):   (- REAL_NUMBER_TY_Sin({R}) -). To decide which real number is the cosine of (R - a real number)   (documented at ph_cosine)   (this is the cos function inverse to arccos):   (- REAL_NUMBER_TY_Cos({R}) -). To decide which real number is the tangent of (R - a real number)   (documented at ph_tangent)   (this is the tan function inverse to arctan):   (- REAL_NUMBER_TY_Tan({R}) -). To decide which real number is the arcsine of (R - a real number)   (documented at ph_arcsine)   (this is the arcsin function inverse to sin):   (- REAL_NUMBER_TY_Arcsin({R}) -). To decide which real number is the arccosine of (R - a real number)   (documented at ph_arccosine)   (this is the arccos function inverse to cos):   (- REAL_NUMBER_TY_Arccos({R}) -). To decide which real number is the arctangent of (R - a real number)   (documented at ph_arctangent)   (this is the arctan function inverse to tan):   (- REAL_NUMBER_TY_Arctan({R}) -).   Section SR5/2/4a - Values - Hyperbolic functions (for Glulx only)   To decide which real number is the hyperbolic sine of (R - a real number)   (documented at ph_hyperbolicsine)   (this is the sinh function inverse to arcsinh):   (- REAL_NUMBER_TY_Sinh({R}) -). To decide which real number is the hyperbolic cosine of (R - a real number)   (documented at ph_hyperboliccosine)   (this is the cosh function inverse to arccosh):   (- REAL_NUMBER_TY_Cosh({R}) -). To decide which real number is the hyperbolic tangent of (R - a real number)   (documented at ph_hyperbolictangent)   (this is the tanh function inverse to arctanh):   (- REAL_NUMBER_TY_Tanh({R}) -). To decide which real number is the hyperbolic arcsine of (R - a real number)   (documented at ph_hyperbolicarcsine)   (this is the arcsinh function inverse to sinh):   let x be given by x = log(R + root(R^2 + 1)) where x is a real number;   decide on x. To decide which real number is the hyperbolic arccosine of (R - a real number)   (documented at ph_hyperbolicarccosine)   (this is the arccosh function inverse to cosh):   let x be given by x = log(R + root(R^2 - 1)) where x is a real number;   decide on x. To decide which real number is the hyperbolic arctangent of (R - a real number)   (documented at ph_hyperbolicarctangent)   (this is the arctanh function inverse to tanh):   let x be given by x = 0.5*(log(1+R) - log(1-R)) where x is a real number;   decide on x.   Section SR5/2/5 - Values - Enumerations   To decide which number is number of (S - description of values)   (documented at ph_numberof):   (- {-primitive-definition:number-of} -). To decide which K is (name of kind of enumerated value K) after (X - K)   (documented at ph_enumafter):   (- A_{-printing-routine:K}({X}) -). To decide which K is (name of kind of enumerated value K) before (X - K)   (documented at ph_enumbefore):   (- B_{-printing-routine:K}({X}) -). To decide which K is the first value of (name of kind of enumerated value K)   (documented at ph_enumfirst):   decide on the default value of K. To decide which K is the last value of (name of kind of enumerated value K)   (documented at ph_enumlast):   decide on K before the default value of K.   Section SR5/2/6 - Values - Truth states   To decide what truth state is whether or not (C - condition)   (documented at ph_whether):   (- ({C}) -).   Section SR5/2/7 - Values - Randomness   To decide which K is a/-- random (S - description of values of kind K)   (documented at ph_randomdesc):   (- {-primitive-definition:random-of} -). To decide which K is a random (name of kind of arithmetic value K) between (first value - K) and (second value - K)   (documented at ph_randombetween):   (- R_{-printing-routine:K}({first value}, {second value}) -). To decide which K is a random (name of kind of arithmetic value K) from (first value - K) to (second value - K)   (documented at ph_randombetween):   (- R_{-printing-routine:K}({first value}, {second value}) -). To decide which K is a random (name of kind of enumerated value K) between (first value - K) and (second value - K)   (documented at ph_randombetween):   (- R_{-printing-routine:K}({first value}, {second value}) -). To decide which K is a random (name of kind of enumerated value K) from (first value - K) to (second value - K)   (documented at ph_randombetween):   (- R_{-printing-routine:K}({first value}, {second value}) -). To decide whether a random chance of (N - number) in (M - number) succeeds   (documented at ph_randomchance):   (- (GenerateRandomNumber(1, {M}) <= {N}) -). To seed the random-number generator with (N - number)   (documented at ph_seed):   (- VM_Seed_RNG({N}); -).   Section SR5/2/8 - Values - Tables   To choose a/the/-- row (N - number) in/from (T - table name)   (documented at ph_chooserow):   (- {-my:ct_0} = {T}; {-my:ct_1} = {N}; -). To choose a/the/-- row with (TC - K valued table column) of (w - value of kind K)   in/from (T - table name)   (documented at ph_chooserowwith):   (- {-my:ct_0} = {T}; {-my:ct_1} = TableRowCorr(ct_0, {TC}, {w}); -). To choose a/the/-- blank row in/from (T - table name)   (documented at ph_chooseblankrow):   (- {-my:ct_0} = {T}; {-my:ct_1} = TableBlankRow(ct_0); -). To choose a/the/-- random row in/from (T - table name)   (documented at ph_chooserandomrow):   (- {-my:ct_0} = {T}; {-my:ct_1} = TableRandomRow(ct_0); -). To decide which number is number of rows in/from (T - table name)   (documented at ph_numrows):   (- TableRows({T}) -). To decide which number is number of blank rows in/from (T - table name)   (documented at ph_numblank):   (- TableBlankRows({T}) -). To decide which number is number of filled rows in/from (T - table name)   (documented at ph_numfilled):   (- TableFilledRows({T}) -). To decide if there is (TR - table-reference)   (documented at ph_thereis):   (- (Exists{-by-reference:TR}) -). To decide if there is no (TR - table-reference)   (documented at ph_thereisno):   (- (Exists{-by-reference:TR} == false) -). To blank out (tr - table-reference)   (documented at ph_blankout):   (- {-by-reference:tr}{-backspace},4); -). To blank out the whole row   (documented at ph_blankoutrow):   (- TableBlankOutRow({-my:ct_0}, {-my:ct_1}); -). To blank out the whole (TC - table column) in/from (T - table name)   (documented at ph_blankoutcol):   (- TableBlankOutColumn({T}, {TC}); -). To blank out the whole of (T - table name)   (documented at ph_blankouttable):   (- TableBlankOutAll({T}); -). To showme the contents of (T - table name)   (documented at ph_showmetable):   (- TableDebug({T}); -). To say the/-- current table row   (documented at phs_currenttablerow):   (- TableRowDebug({-my:ct_0}, {-my:ct_1}); -). To say row (N - number) in/from (T - table name)   (documented at phs_tablerow):   (- TableRowDebug({T}, {N}); -). To say (TC - table column) in/from (T - table name)   (documented at phs_tablecolumn):   (- TableColumnDebug({T}, {TC}); -).   Section SR5/2/9 - Values - Sorting tables   To sort (T - table name) in/into random order   (documented at ph_sortrandom):   (- TableShuffle({T}); -). To sort (T - table name) in/into (TC - table column) order   (documented at ph_sortcolumn):   (- TableSort({T}, {TC}, 1); -). To sort (T - table name) in/into reverse (TC - table column) order   (documented at ph_sortcolumnreverse):   (- TableSort({T}, {TC}, -1); -).   Section SR5/2/10 - Values - Breaking down text   To decide what number is the number of characters in (T - text)   (documented at ph_numchars):   (- TEXT_TY_BlobAccess({-by-reference:T}, CHR_BLOB) -). To decide what number is the number of words in (T - text)   (documented at ph_numwords):   (- TEXT_TY_BlobAccess({-by-reference:T}, WORD_BLOB) -). To decide what number is the number of punctuated words in (T - text)   (documented at ph_numpwords):   (- TEXT_TY_BlobAccess({-by-reference:T}, PWORD_BLOB) -). To decide what number is the number of unpunctuated words in (T - text)   (documented at ph_numupwords):   (- TEXT_TY_BlobAccess({-by-reference:T}, UWORD_BLOB) -). To decide what number is the number of lines in (T - text)   (documented at ph_numlines):   (- TEXT_TY_BlobAccess({-by-reference:T}, LINE_BLOB) -). To decide what number is the number of paragraphs in (T - text)   (documented at ph_numparas):   (- TEXT_TY_BlobAccess({-by-reference:T}, PARA_BLOB) -).   To decide what text is character number (N - a number) in (T - text)   (documented at ph_charnum):   (- TEXT_TY_GetBlob({-new:text}, {-by-reference:T}, {N}, CHR_BLOB) -). To decide what text is word number (N - a number) in (T - text)   (documented at ph_wordnum):   (- TEXT_TY_GetBlob({-new:text}, {-by-reference:T}, {N}, WORD_BLOB) -). To decide what text is punctuated word number (N - a number) in (T - text)   (documented at ph_pwordnum):   (- TEXT_TY_GetBlob({-new:text}, {-by-reference:T}, {N}, PWORD_BLOB) -). To decide what text is unpunctuated word number (N - a number) in (T - text)   (documented at ph_upwordnum):   (- TEXT_TY_GetBlob({-new:text}, {-by-reference:T}, {N}, UWORD_BLOB) -). To decide what text is line number (N - a number) in (T - text)   (documented at ph_linenum):   (- TEXT_TY_GetBlob({-new:text}, {-by-reference:T}, {N}, LINE_BLOB) -). To decide what text is paragraph number (N - a number) in (T - text)   (documented at ph_paranum):   (- TEXT_TY_GetBlob({-new:text}, {-by-reference:T}, {N}, PARA_BLOB) -).   To decide what text is the substituted form of (T - text)   (documented at ph_subform):   (- TEXT_TY_SubstitutedForm({-new:text}, {-by-reference:T}) -).   Section SR5/2/11 - Values - Matching text   To decide if (T - text) exactly matches the text (find - text),   case insensitively   (documented at ph_exactlymatches):   (- TEXT_TY_Replace_RE(CHR_BLOB,{-by-reference:T},{-by-reference:find},0,{phrase options},1) -). To decide if (T - text) matches the text (find - text),   case insensitively   (documented at ph_matches):   (- TEXT_TY_Replace_RE(CHR_BLOB,{-by-reference:T},{-by-reference:find},0,{phrase options}) -). To decide what number is number of times (T - text) matches the text   (find - text), case insensitively   (documented at ph_nummatches):   (- TEXT_TY_Replace_RE(CHR_BLOB,{-by-reference:T},{-by-reference:find},1,{phrase options}) -).   To decide if (T - text) exactly matches the regular expression (find - text),   case insensitively   (documented at ph_exactlymatchesre):   (- TEXT_TY_Replace_RE(REGEXP_BLOB,{-by-reference:T},{-by-reference:find},0,{phrase options},1) -). To decide if (T - text) matches the regular expression (find - text),   case insensitively   (documented at ph_matchesre):   (- TEXT_TY_Replace_RE(REGEXP_BLOB,{-by-reference:T},{-by-reference:find},0,{phrase options}) -). To decide what text is text matching regular expression   (documented at ph_matchtext):   (- TEXT_TY_RE_GetMatchVar(0) -). To decide what text is text matching subexpression (N - a number)   (documented at ph_subexpressiontext):   (- TEXT_TY_RE_GetMatchVar({N}) -). To decide what number is number of times (T - text) matches the regular expression   (find - text),case insensitively   (documented at ph_nummatchesre):   (- TEXT_TY_Replace_RE(REGEXP_BLOB,{-by-reference:T},{-by-reference:find},1,{phrase options}) -).   Section SR5/2/12 - Values - Replacing text   To replace the text (find - text) in (T - text) with (replace - text),   case insensitively   (documented at ph_replace):   (- TEXT_TY_Replace_RE(CHR_BLOB, {-lvalue-by-reference:T}, {-by-reference:find},      {-by-reference:replace}, {phrase options}); -). To replace the regular expression (find - text) in (T - text) with   (replace - text), case insensitively   (documented at ph_replacere):   (- TEXT_TY_Replace_RE(REGEXP_BLOB, {-lvalue-by-reference:T}, {-by-reference:find},      {-by-reference:replace}, {phrase options}); -). To replace the word (find - text) in (T - text) with   (replace - text)   (documented at ph_replacewordin):   (- TEXT_TY_ReplaceText(WORD_BLOB, {-lvalue-by-reference:T}, {-by-reference:find}, {-by-reference:replace}); -). To replace the punctuated word (find - text) in (T - text)   with (replace - text)   (documented at ph_replacepwordin):   (- TEXT_TY_ReplaceText(PWORD_BLOB, {-lvalue-by-reference:T}, {-by-reference:find}, {-by-reference:replace}); -).   To replace character number (N - a number) in (T - text)   with (replace - text)   (documented at ph_replacechar):   (- TEXT_TY_ReplaceBlob(CHR_BLOB, {-lvalue-by-reference:T}, {N}, {-by-reference:replace}); -). To replace word number (N - a number) in (T - text)   with (replace - text)   (documented at ph_replaceword):   (- TEXT_TY_ReplaceBlob(WORD_BLOB, {-lvalue-by-reference:T}, {N}, {-by-reference:replace}); -). To replace punctuated word number (N - a number) in (T - text)   with (replace - text)   (documented at ph_replacepword):   (- TEXT_TY_ReplaceBlob(PWORD_BLOB, {-lvalue-by-reference:T}, {N}, {-by-reference:replace}); -). To replace unpunctuated word number (N - a number) in (T - text)   with (replace - text)   (documented at ph_replaceupword):   (- TEXT_TY_ReplaceBlob(UWORD_BLOB, {-lvalue-by-reference:T}, {N}, {-by-reference:replace}); -). To replace line number (N - a number) in (T - text) with (replace - text)   (documented at ph_replaceline):   (- TEXT_TY_ReplaceBlob(LINE_BLOB, {-lvalue-by-reference:T}, {N}, {-by-reference:replace}); -). To replace paragraph number (N - a number) in (T - text) with (replace - text)   (documented at ph_replacepara):   (- TEXT_TY_ReplaceBlob(PARA_BLOB, {-lvalue-by-reference:T}, {N}, {-by-reference:replace}); -).   Section SR5/2/13 - Values - Casing of text   To decide what text is (T - text) in lower case   (documented at ph_lowercase):   (- TEXT_TY_CharactersToCase({-new:text}, {-by-reference:T}, 0) -). To decide what text is (T - text) in upper case   (documented at ph_uppercase):   (- TEXT_TY_CharactersToCase({-new:text}, {-by-reference:T}, 1) -). To decide what text is (T - text) in title case   (documented at ph_titlecase):   (- TEXT_TY_CharactersToCase({-new:text}, {-by-reference:T}, 2) -). To decide what text is (T - text) in sentence case   (documented at ph_sentencecase):   (- TEXT_TY_CharactersToCase({-new:text}, {-by-reference:T}, 3) -). To decide if (T - text) is in lower case   (documented at ph_inlower):   (- TEXT_TY_CharactersOfCase({-by-reference:T}, 0) -). To decide if (T - text) is in upper case   (documented at ph_inupper):   (- TEXT_TY_CharactersOfCase({-by-reference:T}, 1) -).   Section SR5/2/14 - Values - Adaptive text   To say infinitive of (V - a verb)   (documented at phs_infinitive):   (- {V}(1); -). To say past participle of (V - a verb)   (documented at phs_pastpart):   (- {V}(2); -). To say present participle of (V - a verb)   (documented at phs_prespart):   (- {V}(3); -).   To say adapt (V - verb)   (documented at phs_adapt):   (- {V}(CV_POS, PNToVP(), story_tense); -). To say adapt (V - verb) in (T - grammatical tense)   (documented at phs_adaptt):   (- {V}(CV_POS, PNToVP(), {T}); -). To say adapt (V - verb) from (P - narrative viewpoint)   (documented at phs_adaptv):   (- {V}(CV_POS, {P}, story_tense); -). To say adapt (V - verb) in (T - grammatical tense) from (P - narrative viewpoint)   (documented at phs_adaptvt):   (- {V}(CV_POS, {P}, {T}); -). To say negate (V - verb)   (documented at phs_negate):   (- {V}(CV_NEG, PNToVP(), story_tense); -). To say negate (V - verb) in (T - grammatical tense)   (documented at phs_negatet):   (- {V}(CV_NEG, PNToVP(), {T}); -). To say negate (V - verb) from (P - narrative viewpoint)   (documented at phs_negatev):   (- {V}(CV_NEG, {P}, story_tense); -). To say negate (V - verb) in (T - grammatical tense) from (P - narrative viewpoint)   (documented at phs_negatevt):   (- {V}(CV_NEG, {P}, {T}); -).   To decide which relation of objects is meaning of (V - a verb): (- {V}(CV_MEANING) -).   To say here   (documented at phs_here):   say "[if story tense is present tense]here[otherwise]there". To say now   (documented at phs_now):   say "[if story tense is present tense]now[otherwise]then".   Section SR5/2/15 - Values - Lists   To add (new entry - K) to (L - list of values of kind K), if absent   (documented at ph_addtolist):   (- LIST_OF_TY_InsertItem({-lvalue-by-reference:L}, {new entry}, 0, 0, {phrase options}); -).   To add (new entry - K) at entry (E - number) in (L - list of values of kind K), if absent   (documented at ph_addatentry):   (- LIST_OF_TY_InsertItem({-lvalue-by-reference:L}, {new entry}, 1, {E}, {phrase options}); -).   To add (LX - list of Ks) to (L - list of values of kind K), if absent   (documented at ph_addlisttolist):   (- LIST_OF_TY_AppendList({-lvalue-by-reference:L}, {-by-reference:LX}, 0, 0, {phrase options}); -).   To add (LX - list of Ks) at entry (E - number) in (L - list of values of kind K)   (documented at ph_addlistatentry):   (- LIST_OF_TY_AppendList({-lvalue-by-reference:L}, {-by-reference:LX}, 1, {E}, 0); -).   To remove (existing entry - K) from (L - list of values of kind K), if present   (documented at ph_remfromlist):   (- LIST_OF_TY_RemoveValue({-lvalue-by-reference:L}, {existing entry}, {phrase options}); -).   To remove (N - list of Ks) from (L - list of values of kind K), if present   (documented at ph_remlistfromlist):   (- LIST_OF_TY_Remove_List({-lvalue-by-reference:L}, {-by-reference:N}, {phrase options}); -).   To remove entry (N - number) from (L - list of values), if present   (documented at ph_rementry):   (- LIST_OF_TY_RemoveItemRange({-lvalue-by-reference:L}, {N}, {N}, {phrase options}); -).   To remove entries (N - number) to (N2 - number) from (L - list of values), if present   (documented at ph_rementries):   (- LIST_OF_TY_RemoveItemRange({-lvalue-by-reference:L}, {N}, {N2}, {phrase options}); -).   To decide if (N - K) is listed in (L - list of values of kind K)   (documented at ph_islistedin):   (- (LIST_OF_TY_FindItem({-by-reference:L}, {N})) -).   To decide if (N - K) is not listed in (L - list of values of kind K)   (documented at ph_isnotlistedin):   (- (LIST_OF_TY_FindItem({-by-reference:L}, {N}) == false) -).   To decide what list of Ks is the list of (D - description of values of kind K)   (documented at ph_listofdesc):   (- {-new-list-of:list of K} -). To decide what list of objects is the multiple object list   (documented at ph_multipleobjectlist):   (- LIST_OF_TY_Mol({-new:list of objects}) -). To alter the multiple object list to (L - list of objects)   (documented at ph_altermultipleobjectlist):   (- LIST_OF_TY_Set_Mol({-by-reference:L}); -).   Section SR5/2/16 - Values - Length of lists   To decide what number is the number of entries in/of (L - a list of values)   (documented at ph_numberentries):   (- LIST_OF_TY_GetLength({-by-reference:L}) -). To truncate (L - a list of values) to (N - a number) entries/entry   (documented at ph_truncate):   (- LIST_OF_TY_SetLength({-lvalue-by-reference:L}, {N}, -1, 1); -). To truncate (L - a list of values) to the first (N - a number) entries/entry   (documented at ph_truncatefirst):   (- LIST_OF_TY_SetLength({-lvalue-by-reference:L}, {N}, -1, 1); -). To truncate (L - a list of values) to the last (N - a number) entries/entry   (documented at ph_truncatelast):   (- LIST_OF_TY_SetLength({-lvalue-by-reference:L}, {N}, -1, -1); -). To extend (L - a list of values) to (N - a number) entries/entry   (documented at ph_extend):   (- LIST_OF_TY_SetLength({-lvalue-by-reference:L}, {N}, 1); -). To change (L - a list of values) to have (N - a number) entries/entry   (documented at ph_changelength):   (- LIST_OF_TY_SetLength({-lvalue-by-reference:L}, {N}, 0); -).   Section SR5/2/17 - Values - Reversing and rotating lists   To reverse (L - a list of values)   (documented at ph_reverselist):   (- LIST_OF_TY_Reverse({-lvalue-by-reference:L}); -). To rotate (L - a list of values)   (documented at ph_rotatelist):   (- LIST_OF_TY_Rotate({-lvalue-by-reference:L}, 0); -). To rotate (L - a list of values) backwards   (documented at ph_rotatelistback):   (- LIST_OF_TY_Rotate({-lvalue-by-reference:L}, 1); -).   Section SR5/2/18 - Values - Sorting lists   To sort (L - a list of values)   (documented at ph_sortlist):   (- LIST_OF_TY_Sort({-lvalue-by-reference:L}, 1); -). To sort (L - a list of values) in/into reverse order   (documented at ph_sortlistreverse):   (- LIST_OF_TY_Sort({-lvalue-by-reference:L}, -1); -). To sort (L - a list of values) in/into random order   (documented at ph_sortlistrandom):   (- LIST_OF_TY_Sort({-lvalue-by-reference:L}, 2); -). To sort (L - a list of objects) in/into (P - property) order   (documented at ph_sortlistproperty):   (- LIST_OF_TY_Sort({-lvalue-by-reference:L}, 1, {P}, {-property-holds-block-value:P}); -). To sort (L - a list of objects) in/into reverse (P - property) order   (documented at ph_sortlistpropertyreverse):   (- LIST_OF_TY_Sort({-lvalue-by-reference:L}, -1, {P}, {-property-holds-block-value:P}); -).   Section SR5/2/19 - Values - Relations   To show relation (R - relation)   (documented at ph_showrelation):   (- {-show-me:R}; RelationTest({-by-reference:R}, RELS_SHOW); -).   To decide which object is next step via (R - relation of objects)   from (O1 - object) to (O2 - object)   (documented at ph_nextstep):   (- RelationRouteTo({-by-reference:R},{O1},{O2},false) -). To decide which number is number of steps via (R - relation of objects)   from (O1 - object) to (O2 - object)   (documented at ph_numbersteps):   (- RelationRouteTo({-by-reference:R},{O1},{O2},true) -).   To decide which list of Ks is list of (name of kind of value K)   that/which/whom (R - relation of Ks to values of kind L) relates   (documented at ph_leftdomain):   (- RelationTest({-by-reference:R}, RELS_LIST, {-new:list of K}, RLIST_ALL_X) -).   To decide which list of Ls is list of (name of kind of value L)   to which/whom (R - relation of values of kind K to Ls) relates   (documented at ph_rightdomain):   (- RelationTest({-by-reference:R}, RELS_LIST, {-new:list of L}, RLIST_ALL_Y) -). [1]   To decide which list of Ls is list of (name of kind of value L)   that/which/whom (R - relation of values of kind K to Ls) relates to   (documented at ph_rightdomain):   (- RelationTest({-by-reference:R}, RELS_LIST, {-new:list of L}, RLIST_ALL_Y) -). [2]   To decide which list of Ks is list of (name of kind of value K) that/which/who   relate to (Y - L) by (R - relation of Ks to values of kind L)   (documented at ph_leftlookuplist):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ALL_X, {Y}, {-new:list of K}) -).   To decide which list of Ls is list of (name of kind of value L) to which/whom (X - K)   relates by (R - relation of values of kind K to Ls)   (documented at ph_rightlookuplist):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ALL_Y, {X}, {-new:list of L}) -). [1]   To decide which list of Ls is list of (name of kind of value L)   that/which/whom (X - K) relates to by (R - relation of values of kind K to Ls)   (documented at ph_rightlookuplist):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ALL_Y, {X}, {-new:list of L}) -). [2]   To decide whether (name of kind of value K) relates to (Y - L) by   (R - relation of Ks to values of kind L)   (documented at ph_ifright):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ANY, {Y}, RLANY_CAN_GET_X) -).   To decide whether (X - K) relates to (name of kind of value L) by   (R - relation of values of kind K to Ls)   (documented at ph_ifleft):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ANY, {X}, RLANY_CAN_GET_Y) -).   To decide which K is (name of kind of value K) that/which/who relates to   (Y - L) by (R - relation of Ks to values of kind L)   (documented at ph_leftlookup):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ANY, {Y}, RLANY_GET_X) -).   To decide which L is (name of kind of value L) to which/whom (X - K)   relates by (R - relation of values of kind K to Ls)   (documented at ph_rightlookup):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ANY, {X}, RLANY_GET_Y) -). [1]   To decide which L is (name of kind of value L) that/which/whom (X - K)   relates to by (R - relation of values of kind K to Ls)   (documented at ph_rightlookup):   (- RelationTest({-by-reference:R}, RELS_LOOKUP_ANY, {X}, RLANY_GET_Y) -). [2]   Section SR5/2/20 - Values - Functional programming   To decide whether (val - K) matches (desc - description of values of kind K)   (documented at ph_valuematch):   (- {-primitive-definition:description-application} -).   To decide what K is (function - phrase nothing -> value of kind K) applied   (documented at ph_applied0):   (- {-primitive-definition:function-application} -).   To decide what L is (function - phrase value of kind K -> value of kind L)   applied to (input - K)   (documented at ph_applied1):   (- {-primitive-definition:function-application} -).   To decide what M is (function - phrase (value of kind K, value of kind L) -> value of kind M)   applied to (input - K) and (second input - L)   (documented at ph_applied2):   (- {-primitive-definition:function-application} -).   To decide what N is (function - phrase (value of kind K, value of kind L, value of kind M) -> value of kind N)   applied to (input - K) and (second input - L) and (third input - M)   (documented at ph_applied3):   (- {-primitive-definition:function-application} -).   To apply (function - phrase nothing -> nothing)   (documented at ph_apply0):   (- {-primitive-definition:function-application}; -).   To apply (function - phrase value of kind K -> nothing)   to (input - K)   (documented at ph_apply1):   (- {-primitive-definition:function-application}; -).   To apply (function - phrase (value of kind K, value of kind L) -> nothing)   to (input - K) and (second input - L)   (documented at ph_apply2):   (- {-primitive-definition:function-application}; -).   To apply (function - phrase (value of kind K, value of kind L, value of kind M) -> nothing)   to (input - K) and (second input - L) and (third input - M)   (documented at ph_apply3):   (- {-primitive-definition:function-application}; -).   To decide what list of L is (function - phrase K -> value of kind L) applied to (original list - list of values of kind K)   (documented at ph_appliedlist):   let the result be a list of Ls;   repeat with item running through the original list:      let the mapped item be the function applied to the item;      add the mapped item to the result;   decide on the result.   To decide what K is the (function - phrase (K, K) -> K) reduction of (original list - list of values of kind K)   (documented at ph_reduction):   let the total be a K;   let the count be 0;   repeat with item running through the original list:      increase the count by 1;      if the count is 1, now the total is the item;      otherwise now the total is the function applied to the total and the item;   decide on the total.   To decide what list of K is the filter to (criterion - description of Ks) of   (full list - list of values of kind K)   (documented at ph_filter):   let the filtered list be a list of K;   repeat with item running through the full list:      if the item matches the criterion:         add the item to the filtered list;   decide on the filtered list.   To showme (V - value)   (documented at ph_showme):   (- {-show-me:V} -).   To decide what K is the default value of (V - name of kind of value of kind K)   (documented at ph_defaultvalue):   (- {-new:K} -).   Section SR5/2/21 - Values - Files (for Glulx external files language element only)   To read (filename - external file) into (T - table name)   (documented at ph_readtable):   (- FileIO_GetTable({filename}, {T}); -). To write (filename - external file) from (T - table name)   (documented at ph_writetable):   (- FileIO_PutTable({filename}, {T}); -). To decide if (filename - external file) exists   (documented at ph_fileexists):   (- (FileIO_Exists({filename}, false)) -). To decide if ready to read (filename - external file)   (documented at ph_fileready):   (- (FileIO_Ready({filename}, false)) -). To mark (filename - external file) as ready to read   (documented at ph_markfileready):   (- FileIO_MarkReady({filename}, true); -). To mark (filename - external file) as not ready to read   (documented at ph_markfilenotready):   (- FileIO_MarkReady({filename}, false); -). To write (T - text) to (FN - external file)   (documented at ph_writetext):   (- FileIO_PutContents({FN}, {T}, false); -). To append (T - text) to (FN - external file)   (documented at ph_appendtext):   (- FileIO_PutContents({FN}, {T}, true); -). To say text of (FN - external file)   (documented at ph_saytext):   (- FileIO_PrintContents({FN}); say__p = 1; -).   Section SR5/2/22 - Values - Figures (for figures language element only)   To display (F - figure name), one time only   (documented at ph_displayfigure):   (- DisplayFigure(ResourceIDsOfFigures-->{F}, {phrase options}); -). To decide which number is the Glulx resource ID of (F - figure name)   (documented at ph_figureid):   (- ResourceIDsOfFigures-->{F} -).   Section SR5/2/23 - Values - Sound effects (for sounds language element only)   To play (SFX - sound name), one time only   (documented at ph_playsf):   (- PlaySound(ResourceIDsOfSounds-->{SFX}, {phrase options}); -). To decide which number is the Glulx resource ID of (SFX - sound name)   (documented at ph_soundid):   (- ResourceIDsOfSounds-->{SFX} -).   Section SR5/3/1 - Control phrases - If and unless   To if (c - condition) begin -- end conditional   (documented at ph_if):   (- if {c} -). To unless (c - condition) begin -- end conditional   (documented at ph_unless):   (- if (~~{c}) -).   To if (V - value) is begin -- end conditional   (documented at ph_switch):   (- {-primitive-definition:switch} -).   Section SR5/3/2 - Control phrases - While   To while (c - condition) begin -- end loop   (documented at ph_while):   (- while {c} -).   Section SR5/3/3 - Control phrases - Repeat   To repeat with (loopvar - nonexisting K variable)   running from (v - arithmetic value of kind K) to (w - K) begin -- end loop   (documented at ph_repeat):      (- for ({loopvar}={v}: {loopvar}<={w}: {loopvar}++) -). To repeat with (loopvar - nonexisting K variable)   running from (v - enumerated value of kind K) to (w - K) begin -- end loop   (documented at ph_repeat):      (- for ({loopvar}={v}: {loopvar}<={w}: {loopvar}++) -). To repeat with (loopvar - nonexisting K variable)   running through (OS - description of values of kind K) begin -- end loop   (documented at ph_runthrough):      (- {-primitive-definition:repeat-through} -). To repeat with (loopvar - nonexisting object variable)   running through (L - list of values) begin -- end loop   (documented at ph_repeatlist):      (- {-primitive-definition:repeat-through-list} -).   To repeat through (T - table name) begin -- end loop   (documented at ph_repeattable): (-      @push {-my:ct_0}; @push {-my:ct_1};      for ({-my:1}={T}, {-my:2}=1, ct_0={-my:1}, ct_1={-my:2}:         {-my:2}<=TableRows({-my:1}):         {-my:2}++, ct_0={-my:1}, ct_1={-my:2})         if (TableRowIsBlank(ct_0, ct_1)==false)            {-block}      @pull {-my:ct_1}; @pull {-my:ct_0};   -). To repeat through (T - table name) in reverse order begin -- end loop   (documented at ph_repeattablereverse): (-      @push {-my:ct_0}; @push {-my:ct_1};      for ({-my:1}={T}, {-my:2}=TableRows({-my:1}), ct_0={-my:1}, ct_1={-my:2}:         {-my:2}>=1:         {-my:2}--, ct_0={-my:1}, ct_1={-my:2})         if (TableRowIsBlank(ct_0, ct_1)==false)            {-block}      @pull {-my:ct_1}; @pull {-my:ct_0};   -). To repeat through (T - table name) in (TC - table column) order begin -- end loop   (documented at ph_repeattablecol): (-      @push {-my:ct_0}; @push {-my:ct_1};      for ({-my:1}={T}, {-my:2}=TableNextRow({-my:1}, {TC}, 0, 1), ct_0={-my:1}, ct_1={-my:2}:         {-my:2}~=0:         {-my:2}=TableNextRow({-my:1}, {TC}, {-my:2}, 1), ct_0={-my:1}, ct_1={-my:2})            {-block}      @pull {-my:ct_1}; @pull {-my:ct_0};   -). To repeat through (T - table name) in reverse (TC - table column) order begin -- end loop   (documented at ph_repeattablecolreverse): (-      @push {-my:ct_0}; @push {-my:ct_1};      for ({-my:1}={T}, {-my:2}=TableNextRow({-my:1}, {TC}, 0, -1), ct_0={-my:1}, ct_1={-my:2}:         {-my:2}~=0:         {-my:2}=TableNextRow({-my:1}, {TC}, {-my:2}, -1), ct_0={-my:1}, ct_1={-my:2})            {-block}      @pull {-my:ct_1}; @pull {-my:ct_0};   -).   Section SR5/3/6 - Control phrases - Changing the flow of loops   To break -- in loop   (documented at ph_break):   (- {-primitive-definition:break} -). To next -- in loop   (documented at ph_next):   (- continue; -).   Section SR5/3/7 - Control phrases - Deciding outcomes   To yes   (documented at ph_yes):   (- rtrue; -) - in to decide if only. To decide yes   (documented at ph_yes):   (- rtrue; -) - in to decide if only. To no   (documented at ph_no):   (- rfalse; -) - in to decide if only. To decide no   (documented at ph_no):   (- rfalse; -) - in to decide if only.   To decide on (something - value)   (documented at ph_decideon):   (- return {-return-value:something}; -).   Section SR5/3/8 - Control phrases - Stop or go   To do nothing (documented at ph_nothing):   (- ; -). To stop (documented at ph_stop):   (- rtrue; -) - in to only.   Section SR5/4/1 - Actions, activities and rules - Trying actions   To try (S - action)   (documented at ph_try):   (- {-try-action:S} -). To silently try (S - action)   (documented at ph_trysilently):   (- {-try-action-silently:S} -). To try silently (S - action)   (documented at ph_trysilently):   (- {-try-action-silently:S} -). To decide whether the action is not silent:   (- (keep_silent == false) -).   Section SR5/4/2 - Actions, activities and rules - Action requirements   To decide whether the action requires a touchable noun   (documented at ph_requirestouch):   (- (NeedToTouchNoun()) -). To decide whether the action requires a touchable second noun   (documented at ph_requirestouch2):   (- (NeedToTouchSecondNoun()) -). To decide whether the action requires a carried noun   (documented at ph_requirescarried):   (- (NeedToCarryNoun()) -). To decide whether the action requires a carried second noun   (documented at ph_requirescarried2):   (- (NeedToCarrySecondNoun()) -). To decide whether the action requires light   (documented at ph_requireslight):   (- (NeedLightForAction()) -).   Section SR5/4/3 - Actions, activities and rules - Stop or continue   To stop the action   (documented at ph_stopaction):   (- rtrue; -) - in to only. To continue the action   (documented at ph_continueaction):   (- rfalse; -) - in to only.   Section SR5/4/4 - Actions, activities and rules - Actions as values   To decide what action is the current action   (documented at ph_currentaction):   (- STORED_ACTION_TY_Current({-new:action}) -). To decide what action is the action of (A - action)   (documented at ph_actionof):   (- {A} -). To decide if (act - a action) involves (X - an object)   (documented at ph_involves):   (- (STORED_ACTION_TY_Involves({-by-reference:act}, {X})) -). To decide what action name is the action name part of (act - a action)   (documented at ph_actionpart):   (- (STORED_ACTION_TY_Part({-by-reference:act}, STORA_ACTION_F)) -). To decide what object is the noun part of (act - a action)   (documented at ph_nounpart):   (- (STORED_ACTION_TY_Part({-by-reference:act}, STORA_NOUN_F)) -). To decide what object is the second noun part of (act - a action)   (documented at ph_secondpart):   (- (STORED_ACTION_TY_Part({-by-reference:act}, STORA_SECOND_F)) -). To decide what object is the actor part of (act - a action)   (documented at ph_actorpart):   (- (STORED_ACTION_TY_Part({-by-reference:act}, STORA_ACTOR_F)) -).   Section SR5/4/5 - Actions, activities and rules - Carrying out activities   To carry out the (A - activity on nothing) activity   (documented at ph_carryout):   (- CarryOutActivity({A}); -). To carry out the (A - activity on value of kind K) activity with (val - K)   (documented at ph_carryoutwith):   (- CarryOutActivity({A}, {val}); -).   To continue the activity   (documented at ph_continueactivity):   (- rfalse; -) - in to only.   Section SR5/4/6 - Actions, activities and rules - Advanced activities   To begin the (A - activity on nothing) activity   (documented at ph_beginactivity):   (- BeginActivity({A}); -). To begin the (A - activity on value of kind K) activity with (val - K)   (documented at ph_beginactivitywith):   (- BeginActivity({A}, {val}); -). To decide whether handling (A - activity) activity   (documented at ph_handlingactivity):   (- (~~(ForActivity({A}))) -). To decide whether handling (A - activity on value of kind K) activity with (val - K)   (documented at ph_handlingactivitywith):   (- (~~(ForActivity({A}, {val}))) -). To end the (A - activity on nothing) activity   (documented at ph_endactivity):   (- EndActivity({A}); -). To end the (A - activity on value of kind K) activity with (val - K)   (documented at ph_endactivitywith):   (- EndActivity({A}, {val}); -). To abandon the (A - activity on nothing) activity   (documented at ph_abandonactivity):   (- AbandonActivity({A}); -). To abandon the (A - activity on value of kind K) activity with (val - K)   (documented at ph_abandonactivitywith):   (- AbandonActivity({A}, {val}); -).   Section SR5/4/7 - Actions, activities and rules - Following rules   To follow (RL - a rule)   (documented at ph_follow):   (- FollowRulebook({RL}); -). To follow (RL - value of kind K based rule producing a value) for (V - K)   (documented at ph_followfor):   (- FollowRulebook({RL}, {V}, true); -). To follow (RL - a nothing based rule)   (documented at ph_follow):   (- FollowRulebook({RL}); -). To decide what K is the (name of kind K) produced by (RL - rule producing a value of kind K)   (documented at ph_producedby):   (- ResultOfRule({RL}, 0, true, {-strong-kind:K}) -). To decide what L is the (name of kind L) produced by (RL - value of kind K based rule   producing a value of kind L) for (V - K)   (documented at ph_producedbyfor):   (- ResultOfRule({RL}, {V}, true, {-strong-kind:L}) -). To decide what K is the (name of kind K) produced by (RL - nothing based rule producing a value of kind K)   (documented at ph_producedby):   (- ResultOfRule({RL}, 0, true, {-strong-kind:K}) -). To abide by (RL - a rule)   (documented at ph_abide):   (- if (FollowRulebook({RL})) rtrue; -) - in to only. To abide by (RL - value of kind K based rule producing a value) for (V - K)   (documented at ph_abidefor):   (- if (FollowRulebook({RL}, {V}, true)) rtrue; -) - in to only. To abide by (RL - a nothing based rule)   (documented at ph_abide):   (- if (FollowRulebook({RL})) rtrue; -) - in to only. To anonymously abide by (RL - a rule)   (documented at ph_abideanon):   (- if (temporary_value = FollowRulebook({RL})) {      if (RulebookSucceeded()) ActRulebookSucceeds(temporary_value);      else ActRulebookFails(temporary_value);      return 2;   } -) - in to only. To anonymously abide by (RL - value of kind K based rule producing a value) for (V - K)   (documented at ph_abideanon):   (- if (temporary_value = FollowRulebook({RL}, {V}, true)) {      if (RulebookSucceeded()) ActRulebookSucceeds(temporary_value);      else ActRulebookFails(temporary_value);      return 2;   } -) - in to only. To anonymously abide by (RL - a nothing based rule)   (documented at ph_abideanon):   (- if (temporary_value = FollowRulebook({RL})) {      if (RulebookSucceeded()) ActRulebookSucceeds(temporary_value);      else ActRulebookFails(temporary_value);      return 2;   } -) - in to only.   Section SR5/4/8 - Actions, activities and rules - Success and failure   To make no decision   (documented at ph_nodecision): (- rfalse; -) - in to only. To rule succeeds   (documented at ph_succeeds):   (- RulebookSucceeds(); rtrue; -) - in to only. To rule fails   (documented at ph_fails):   (- RulebookFails(); rtrue; -) - in to only. To rule succeeds with result (val - a value)   (documented at ph_succeedswith):   (- RulebookSucceeds({-weak-kind:rule-return-kind},{-return-value-from-rule:val}); rtrue; -) - in to only. To decide if rule succeeded   (documented at ph_succeeded):   (- (RulebookSucceeded()) -). To decide if rule failed   (documented at ph_failed):   (- (RulebookFailed()) -). To decide which rulebook outcome is the outcome of the rulebook   (documented at ph_rulebookoutcome):   (- (ResultOfRule()) -).   Section SR5/5/1 - Model world - Ending the story   To end the story   (documented at ph_end):   (- deadflag=3; story_complete=false; -). To end the story finally   (documented at ph_endfinally):   (- deadflag=3; story_complete=true; -). To end the story saying (finale - text)   (documented at ph_endsaying):   (- deadflag={-by-reference:finale}; story_complete=false; -). To end the story finally saying (finale - text)   (documented at ph_endfinallysaying):   (- deadflag={-by-reference:finale}; story_complete=true; -). To decide whether the story has ended   (documented at ph_ended):   (- (deadflag~=0) -). To decide whether the story has ended finally   (documented at ph_finallyended):   (- (story_complete) -). To decide whether the story has not ended   (documented at ph_notended):   (- (deadflag==0) -). To decide whether the story has not ended finally   (documented at ph_notfinallyended):   (- (story_complete==false) -). To resume the story   (documented at ph_resume):   (- resurrect_please = true; -).   Section SR5/5/2 - Model world - Times of day   To decide which number is the minutes part of (t - time)   (documented at ph_minspart):   (- ({t}%ONE_HOUR) -). To decide which number is the hours part of (t - time)   (documented at ph_hourspart):   (- ({t}/ONE_HOUR) -).   To decide if (t - time) is before (t2 - time)   (documented at ph_timebefore):   (- ((({t}+20*ONE_HOUR)%(TWENTY_FOUR_HOURS))<(({t2}+20*ONE_HOUR)%(TWENTY_FOUR_HOURS))) -). To decide if (t - time) is after (t2 - time)   (documented at ph_timeafter):   (- ((({t}+20*ONE_HOUR)%(TWENTY_FOUR_HOURS))>(({t2}+20*ONE_HOUR)%(TWENTY_FOUR_HOURS))) -). To decide which time is (t - time) before (t2 - time)   (documented at ph_shiftbefore):   (- (({t2}-{t}+TWENTY_FOUR_HOURS)%(TWENTY_FOUR_HOURS)) -). To decide which time is (t - time) after (t2 - time)   (documented at ph_shiftafter):   (- (({t2}+{t}+TWENTY_FOUR_HOURS)%(TWENTY_FOUR_HOURS)) -).   Section SR5/5/3 - Model world - Durations   To decide which time is (n - number) minutes   (documented at ph_durationmins):   (- (({n})%(TWENTY_FOUR_HOURS)) -). To decide which time is (n - number) hours   (documented at ph_durationhours):   (- (({n}*ONE_HOUR)%(TWENTY_FOUR_HOURS)) -).   Section SR5/5/4 - Model world - Timed events   To (R - rule) in (t - number) turn/turns from now   (documented at ph_turnsfromnow):   (- SetTimedEvent({-mark-event-used:R}, {t}+1, 0); -). To (R - rule) at (t - time)   (documented at ph_attime):   (- SetTimedEvent({-mark-event-used:R}, {t}, 1); -). To (R - rule) in (t - time) from now   (documented at ph_timefromnow):   (- SetTimedEvent({-mark-event-used:R}, (the_time+{t})%(TWENTY_FOUR_HOURS), 1); -).   Section SR5/5/5 - Model world - Scenes   To decide if (sc - scene) has happened   (documented at ph_hashappened):   (- (scene_endings-->({sc}-1)) -). To decide if (sc - scene) has not happened   (documented at ph_hasnothappened):   (- (scene_endings-->({sc}-1) == 0) -). To decide if (sc - scene) has ended   (documented at ph_hasended):   (- (scene_endings-->({sc}-1) > 1) -). To decide if (sc - scene) has not ended   (documented at ph_hasnotended):   (- (scene_endings-->({sc}-1) <= 1) -).   Section SR5/5/6 - Model world - Timing of scenes   To decide which time is the time since (sc - scene) began   (documented at ph_scenetimesincebegan):   (- (SceneUtility({sc}, 1)) -). To decide which time is the time when (sc - scene) began   (documented at ph_scenetimewhenbegan):   (- (SceneUtility({sc}, 2)) -). To decide which time is the time since (sc - scene) ended   (documented at ph_scenetimesinceended):   (- (SceneUtility({sc}, 3)) -). To decide which time is the time when (sc - scene) ended   (documented at ph_scenetimewhenended):   (- (SceneUtility({sc}, 4)) -).   Section SR5/5/7 - Model world - Player's identity and location   To decide whether in darkness   (documented at ph_indarkness):   (- (location==thedark) -).   Section SR5/5/8 - Model world - Moving and removing things   To move (something - object) to (something else - object),   without printing a room description   or printing an abbreviated room description   (documented at ph_move):   (- MoveObject({something}, {something else}, {phrase options}, false); -). To remove (something - object) from play   (deprecated)   (documented at ph_remove):   (- RemoveFromPlay({something}); -). To move (O - object) backdrop to all (D - description of objects)   (documented at ph_movebackdrop):   (- MoveBackdrop({O}, {D}); -). To update backdrop positions   (documented at ph_updatebackdrop):   (- MoveFloatingObjects(); -).   Section SR5/5/9 - Model world - The map   To decide which room is location of (O - object)   (documented at ph_locationof):   (- LocationOf({O}) -). To decide which room is room (D - direction) from/of (R1 - room)   (documented at ph_roomdirof):   (- MapConnection({R1},{D}) -). To decide which door is door (D - direction) from/of (R1 - room)   (documented at ph_doordirof):   (- DoorFrom({R1},{D}) -). To decide which object is the other side of (D - door) from (R1 - room)   (documented at ph_othersideof):   (- OtherSideOfDoor({D},{R1}) -). To decide which object is the direction of (D - door) from (R1 - room)   (documented at ph_directionofdoor):   (- DirectionDoorLeadsIn({D},{R1}) -). To decide which object is room-or-door (D - direction) from/of (R1 - room)   (documented at ph_roomordoor):   (- RoomOrDoorFrom({R1},{D}) -). To change (D - direction) exit of (R1 - room) to (R2 - room)   (documented at ph_changeexit):   (- AssertMapConnection({R1},{D},{R2}); -). To change (D - direction) exit of (R1 - room) to nothing/nowhere   (documented at ph_changenoexit):   (- AssertMapConnection({R1},{D},nothing); -). To decide which room is the front side of (D - object)   (documented at ph_frontside):   (- FrontSideOfDoor({D}) -). To decide which room is the back side of (D - object)   (documented at ph_backside):   (- BackSideOfDoor({D}) -).   Section SR5/5/10 - Model world - Route-finding   To decide which object is best route from (R1 - object) to (R2 - object),   using doors or using even locked doors   (documented at ph_bestroute):   (- MapRouteTo({R1},{R2},0,{phrase options}) -). To decide which number is number of moves from (R1 - object) to (R2 - object),   using doors or using even locked doors   (documented at ph_bestroutelength):   (- MapRouteTo({R1},{R2},0,{phrase options},true) -). To decide which object is best route from (R1 - object) to (R2 - object) through   (RS - description of objects),   using doors or using even locked doors   (documented at ph_bestroutethrough):   (- MapRouteTo({R1},{R2},{RS},{phrase options}) -). To decide which number is number of moves from (R1 - object) to (R2 - object) through   (RS - description of objects),   using doors or using even locked doors   (documented at ph_bestroutethroughlength):   (- MapRouteTo({R1},{R2},{RS},{phrase options},true) -).   Section SR5/5/11 - Model world - The object tree   To decide which object is holder of (something - object)   (documented at ph_holder):   (- (HolderOf({something})) -). To decide which object is next thing held after (something - object)   (documented at ph_nextheld):   (- (sibling({something})) -). To decide which object is first thing held by (something - object)   (documented at ph_firstheld):   (- (child({something})) -).   Section SR5/6/1 - Understanding - Asking yes/no questions   To decide whether player consents   (documented at ph_consents):      (- YesOrNo() -).   Section SR5/6/2 - Understanding - The player's command   To decide if (S - a snippet) matches (T - a topic)   (documented at ph_snippetmatches):   (- (SnippetMatches({S}, {T})) -). To decide if (S - a snippet) does not match (T - a topic)   (documented at ph_snippetdoesnotmatch):   (- (SnippetMatches({S}, {T}) == false) -). To decide if (S - a snippet) includes (T - a topic)   (documented at ph_snippetincludes):   (- (matched_text=SnippetIncludes({T},{S})) -). To decide if (S - a snippet) does not include (T - a topic)   (documented at ph_snippetdoesnotinclude):   (- (SnippetIncludes({T},{S})==0) -).   Section SR5/6/3 - Understanding - Changing the player's command   To change the text of the player's command to (T - text)   (documented at ph_changecommand):   (- SetPlayersCommand({-by-reference:T}); -). To replace (S - a snippet) with (T - text)   (documented at ph_replacesnippet):   (- SpliceSnippet({S}, {-by-reference:T}); -). To cut (S - a snippet)   (documented at ph_cutsnippet):   (- SpliceSnippet({S}, 0); -). To reject the player's command   (documented at ph_rejectcommand):   (- RulebookFails(); rtrue; -) - in to only.   Section SR5/6/4 - Understanding - Scope and pronouns   To place (O - an object) in scope, but not its contents   (documented at ph_placeinscope):   (- PlaceInScope({O}, {phrase options}); -). To place the/-- contents of (O - an object) in scope   (documented at ph_placecontentsinscope):   (- ScopeWithin({O}); -). To set pronouns from (O - an object)   (documented at ph_setpronouns):   (- PronounNotice({O}); -).   Section SR5/8/1 - Message support - Issuance - Unindexed   To issue score notification message:   (- NotifyTheScore(); -). To say pronoun dictionary word:   (- print (address) pronoun_word; -). To say recap of command:   (- PrintCommand(); -). The pronoun reference object is an object that varies. The pronoun reference object variable translates into I6 as "pronoun_obj".   To say pronoun i6 dictionary word:   (- print (address) pronoun_word; -).   To say parser command so far:   (- PrintCommand(); -).   Section SR5/9/1 - Miscellaneous other phrases - Unindexed   To decide which object is the component parts core of (X - an object):   (- CoreOf({X}) -). To decide which object is the common ancestor of (O - an object) with   (P - an object):    (- (CommonAncestor({O}, {P})) -). To decide which object is the not-counting-parts holder of (O - an object):    (- (CoreOfParentOfCoreOf({O})) -). To decide which object is the visibility-holder of (O - object):   (- VisibilityParent({O}) -). To calculate visibility ceiling at low level:   (- FindVisibilityLevels(); -). To decide which object is the touchability ceiling of (O - object):   (- TouchabilityCeiling({O}) -).   To decide which number is the visibility ceiling count calculated:   (- visibility_levels -). To decide which object is the visibility ceiling calculated:   (- visibility_ceiling -).   To produce a room description with going spacing conventions:   (- LookAfterGoing(); -).   To print the location's description:   (- PrintOrRun(location, description); -).   To decide if expanding text for comparison purposes:   (- say__comp -).   To decide whether the I6 parser is running multiple actions:   (- (multiflag==1) -).   To decide if set to sometimes abbreviated room descriptions:   (- (lookmode == 1) -). To decide if set to unabbreviated room descriptions:   (- (lookmode == 2) -). To decide if set to abbreviated room descriptions:   (- (lookmode == 3) -).   To convert to (AN - an action name) on (O - an object):   (- return GVS_Convert({AN},{O},0); -) - in to only. To convert to request of (X - object) to perform (AN - action name) with   (Y - object) and (Z - object):   (- return ConvertToRequest({X}, {AN}, {Y}, {Z}); -). To convert to special going-with-push action:   (- return ConvertToGoingWithPush(); -).   To surreptitiously move (something - object) to (something else - object):   (- move {something} to {something else}; -). To surreptitiously move (something - object) to (something else - object) during going:   (- MoveDuringGoing({something}, {something else}); -). To surreptitiously reckon darkness:   (- SilentlyConsiderLight(); -).   To say list-writer list of marked objects: (-       WriteListOfMarkedObjects(ENGLISH_BIT);   -). To say list-writer articled list of marked objects: (-       WriteListOfMarkedObjects(ENGLISH_BIT+DEFART_BIT+CFIRSTART_BIT);   -).   To ***:   (- {-primitive-definition:verbose-checking} -). To *** (T - text):   (- {-primitive-definition:verbose-checking} -).   The Standard Rules end here.