! ---------------------------------------------------------------------------- ! Toyshop 961111 One of the standard Inform 6 example games ! ! This is not a real game. The main example game for Inform is "Advent", ! a port of Colossal Cave. Since that's something of an antique, and most ! of the objects in it are rather simple, this is a collection of more ! exotic features and peculiar objects. Note that "Advent" has plenty of ! interesting doors, a good lantern and bottled oil and water, so those ! won't be part of the Toyshop. ! ! Needs Inform 6 with library 6/1 or later to compile. ! ! To win, simply find 6 interesting things to do and leave by the main exit! ! ! Object Is an example of... ! ! >SA satchel Container into which the game silently puts things ! >HE helium balloon Something moving under the control of a daemon ! >CA little red car Vehicle, and pushable from place to place ! >PF padded floor Scenery present in several rooms at once ! >GR hand grenade Timed events: a grenade and its pin ! >MA matchbook Simple fire and matches; changing inventory styles ! >WC white candles A stock of objects identical to each other ! >GL white gloves Two independent objects which can behave as a pair ! >CO green cone Easy before and after rules ! >HW high window Starting and stopping daemons ! >BC bolted cupboard A typical locked container (with key) ! >GB glass box Container light can get through ! >SB steel box Container light can't get through ! >BL building blocks A complicated class definition; piles of objects ! >CH Christopher Someone you can talk to, and persuade to do things ! >OF Office Rules about moving in a particular direction ! >TB toothed bag A container with ideas about what it will allow ! >SL spirit level Something to put on top of things ! >BB blackboard A blackboard to write messages on ! ! (The code is marked with >SA and so on for easy access with a text editor) ! ---------------------------------------------------------------------------- Constant DEBUG; Constant Story "TOYSHOP"; Constant Headline "^An Interactive Demonstration^ Copyright (c) 1994 by Graham Nelson. All rights given away.^"; Release 4; Serial "961111"; ! This sets the serial date to the date of this source ! file, not to the date of compilation. ! Now we serve notice to Inform that we do not wish to use the standard ! routine for the Burn action, and will instead be defining our own: Replace BurnSub; ! Next include the first of the three standard library files: Include "Parser"; ! ---------------------------------------------------------------------------- ! >SA Ungenerously, the player can only carry at most 4 things, but there's ! a satchel to carry other things around in... ! ---------------------------------------------------------------------------- Constant MAX_CARRIED = 4; Constant SACK_OBJECT = satchel; Object satchel "satchel" with description "Big and with a smile painted on it.", name "satchel", article "your", when_closed "Your satchel lies on the floor.", when_open "Your satchel lies open on the floor.", has container open openable; ! We're going to use the most elaborate scoring system the ! library provides (even though we're going to make the six tasks all ! score only 1 point each), so we define all this... Constant TASKS_PROVIDED; Constant NUMBER_TASKS = 6; Array task_scores -> 1 1 1 1 1 1; Constant MAX_SCORE = 6; ! And include the library of standard verbs and actions. Include "VerbLib"; ! ---------------------------------------------------------------------------- ! Off we go into the Toyshop... ! ---------------------------------------------------------------------------- Class Toyroom has light; Toyroom Toyshop "Toyshop" with description "The centre of a long east-west hall. Shelves are lined with toys, painted clowns face you from the walls and the floor is lightly padded with colourful mats. A doorway leads north, with a red warning triangle above it.", name "clowns" "painted" "shelves" "triangle", e_to East_End, w_to West_End, n_to Danger_Zone; Object -> chair "high chair" with name "chair" "high" has supporter enterable; ! ---------------------------------------------------------------------------- ! >HE The balloon is completely self-contained as a piece of code, except ! that it does not set itself going (though even this could have been ! arranged): it is set going in the Initialise() routine. ! ! Notice that the "after" for Drop takes away the "moved" attribute. ! This is one way to ensure that the "initial" message will always be ! the one displayed. (Alternatively, we could have given it a "describe" ! property.) ! ---------------------------------------------------------------------------- Object -> balloon "helium balloon" with description "Blue, with a yellow smile.", name "helium" "balloon" "blue" "string", initial "A balloon nestles on the ceiling, its long string hanging.", before [; Attack: remove self; StopDaemon(self); "Easily, you burst the balloon. Pop!^^ Shame it was irreplaceable, really."; ], after [; Take: "You take the balloon by its string. It's buoyant!"; Drop: give balloon ~moved; "The balloon rises gracefully to the ceiling."; ], daemon [ from_room to_room; if (random(3)~=1) rfalse; from_room=parent(self); if (from_room==East_End or West_End) to_room=Toyshop; if (from_room==Toyshop) { if (random(2)==1) to_room=East_End; else to_room=West_End; } if (to_room==0) rfalse; move self to to_room; if (location==from_room) "^A breeze blows the balloon away to the ", (name) to_room, "."; if (location==to_room) "^A breeze blows the balloon in from the ", (name) from_room, "."; ]; ! ---------------------------------------------------------------------------- ! >CA There are two exceptions to the ordinary before/after rules, for ! vehicles and things which can be pushed from place to place: this car ! demonstrates both at once. ! ! The "before" for PushDir (push in a named direction) must call ! AllowPushDir and then return true to signify that the push is legal. ! ! The "before" for Go must return true to signify that travelling in ! the object is legal. (Note that it must also be enterable.) ! ---------------------------------------------------------------------------- Object -> car "little red car" with name "little" "red" "car" "kar1", description "Large enough to sit inside. Among the controls is a prominent on/off switch. The numberplate is KAR 1.", when_on "The red car sits here, its engine still running.", when_off "A little red car is parked here.", before [; PushDir: AllowPushDir(); rtrue; Go: if (car has on) { Achieved(1); "Brmm! Brmm!"; } print "(The ignition is off at the moment.)^"; ], after [; PushDir: "The car rolls very slowly as you push it."; ], has switchable enterable static container open; Object -> -> "small note" with name "small" "note", description " !!!! FROBOZZ MAGIC CAR COMPANY !!!!^ ^Hello, Driver!^ ^Instructions for use:^ ^Switch on the ignition and off you go!^ ^Warranty:^ ^This car is guaranteed against all defects for a period of 76 milliseconds from date of purchase or until used, whichever comes first.^ ^Good Luck!"; ! ---------------------------------------------------------------------------- ! >PF An example of an object spread across several (three) rooms: ! ---------------------------------------------------------------------------- Object padded_floor "padded floor" with name "padded" "floor" "mats" "padding", description "To protect little children and adventurers.", before [; Take: "It is protected from little children and adventurers."; ], found_in East_End Toyshop West_End has scenery; ! ---------------------------------------------------------------------------- Toyroom Danger_Zone "Danger Zone" with description "This is the Danger Zone, which you should know better than to go into. A single door leads back south.", s_to Toyshop; ! ---------------------------------------------------------------------------- ! >GR A classic example of a timer (or, as some people call them and ! appropriately so in this case, a fuse). To demonstrate stopping ! a timer before the alarm (and for fun), there is also a pin: ! ---------------------------------------------------------------------------- Object -> grenade "nasty-looking hand grenade" with name "hand" "grenade" "nasty" "nasty-looking", initial "A nasty-looking hand grenade (there is no other kind) rolls about irresponsibly on the floor.", description "Not recommended for children under 90.", before [; Pull: if (self has general) "Too late for that."; StartTimer(self, 5); give self general; move the_pin to player; "You pull the pin out, an irrevocable act."; ], time_left 0, time_out [; deadflag=1; "^An immense explosion suddenly demolishes the toyshop!^^ Will you never learn?"; ], has transparent; Object -> -> the_pin "pin" with name "pin", description "The pin is designed to be easy to pull.", before [; Take, Pull: if (self in grenade) <>; Insert: if (self notin grenade && second==grenade) { StopTimer(grenade); move self to grenade; give grenade ~general; "Amazing! You got the pin back into the grenade!"; } ]; ! ---------------------------------------------------------------------------- ! >MA This is a matchbook of five matches, which is quite simple in that you ! can only actually have one match at a time: otherwise, it's quite ! a full implementation. Note that the inventory lines for the match ! and the matchbook are coded here. Note also that the "match" object ! returns to the book even when the book is empty, so that the parser ! will still understand requests for matches - which the "before" rule, ! which automatically removes matches when needed, can then turn down. ! ! The matchbook has a daemon whose job is to tidy up lost matches. One ! might expect this rule to be coded with an "after" routine, to trap ! the player dropping matches. But suppose there were a magpie in the ! game, and it flew down and stole the match but left the matchbook! ! As it happens there isn't, but this is better form. ! ---------------------------------------------------------------------------- Object -> matchbook "matchbook" with name "matchbook" "book" "matches", number 5, before [; Burn: if (match has light) { remove match; remove matchbook; "What a waste of matches!"; } ], invent [; if (inventory_stage==2) { switch(self.number) { 0: print " (empty)"; 1: print " (1 match left)"; default: print " (", self.number, " matches left)"; } } ], description [; print "The cover advertisement reads ~Curses - Adventure of a Lunchtime~. The book "; switch(self.number) { 0: "is empty."; 1: "has a single match left."; default: print_ret "contains ", self.number, " matches."; } ], daemon [; if (match notin matchbook && match notin player) { move match to matchbook; if (match has light) { give match ~light; StopTimer(match); } StopDaemon(self); } ], has transparent; Object -> -> match "match" with parse_name [ i j; if (self has light) j='burning'; else j='unlit'; while (NextWord()=='match' or j) i++; return i; ], article "an", before [ i; if (self in matchbook) { i=matchbook.number; if (i==0) "There are no matches left in the book."; i--; matchbook.number=i; move self to player; StartDaemon(matchbook); print "(taking a match from the book, which "; if (i==0) print "is now empty)^"; if (i==1) print "has one more left)^"; if (i>1) print "has ", i, " left)^"; self.article = "an"; } Take, Remove: if (self in player) "Done."; Burn: if (self has light) "The match is already alight."; if (matchbook notin player) "You need the matchbook to strike the match."; give self light; StartTimer(self, 2+random(3)); self.article = "a"; "You strike the match."; ], short_name [; if (self has light) print "burning match"; else print "unlit match"; rtrue; ], time_left, time_out [; move self to matchbook; give self ~light; "^You drop the match as the flame reaches your finger."; ]; ! ---------------------------------------------------------------------------- ! >WC A box of eight candles. ! ! This is a simple way to code up duplicate objects. For one thing, ! > take candles ! does not quite behave as we would hope: it'll only pick up one candle ! (though "> take four candles" will work). See the "Block" class ! below for a way to make good. ! ! If we had needed a much greater number of candles, we could have used ! object creation and destruction during play. See the "Ticket" class ! from the "Balances" example game. ! ---------------------------------------------------------------------------- Class Candle with name "wax" "candle" "candles", short_name "wax candle", plural "wax candles", description "It looks just like all the other candles.", before [; Burn: "Disappointingly, the wick refuses to burn."; ]; Object -> "grey tin box" with name "tin" "box" "grey", description "A grey tin box of ~Major's Candles~.", has container openable; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Candle -> ->; Toyroom East_End "East End" with name "dolls" "nurses", description "The eastern end of the toyshop is pink, and dolls and nurses line the shelves right up to the high window. A dark doorway leads to a northern side chamber.", w_to Toyshop, n_to DarkRoom; ! ---------------------------------------------------------------------------- ! >GL The following example, suggested to the author by Richard Tucker, ! demonstrates an apparently tricky case of objects with associated ! sub-objects. The pair of white gloves behaves just like any other item ! of clothing - but the player can also use the left and right gloves ! independently, can take away or wear only one and so on. When they ! come back together (even in a cupboard, say, or on a mantelpiece) ! they are called a pair again. ! ! We can do this with only three objects, one daemon and one rule. ! ! When the gloves are together, and the player refers to an individual ! glove, the before rule splits up the pair and starts the daemon. ! Once active, the daemon tries every turn to re-join them into a pair. ! (If it succeeds, it turns itself off.) ! ! Note that the "pair of gloves" object has the "general" attribute exactly ! when the gloves are apart. Otherwise the pair-object contains both ! glove objects, and has "transparent" so that the parser knows the player ! can see and refer to them. ! ---------------------------------------------------------------------------- Object -> gloves "white gloves" with article "a pair of", name "white" "gloves" "pair" "of", daemon [; if (parent(right_glove) ~= parent(left_glove)) return; if ((left_glove has worn && right_glove hasnt worn) || (left_glove hasnt worn && right_glove has worn)) return; if (left_glove has worn) give gloves worn; else give gloves ~worn; move gloves to parent(right_glove); give gloves ~general; move right_glove to gloves; move left_glove to gloves; give right_glove ~worn; give left_glove ~worn; StopDaemon(self); ], has clothing transparent; Class Glove with article "the", name "white" "glove", before [; if (self notin gloves) rfalse; move left_glove to parent(gloves); move right_glove to parent(gloves); if (gloves has worn) { give left_glove worn; give right_glove worn; } give gloves general; remove gloves; StartDaemon(gloves); ], has clothing; Glove -> -> left_glove "left glove" with description "White silk, monogrammed with a scarlet R.", name "left"; Glove -> -> right_glove "right glove" with description "White silk, monogrammed with a scarlet T.", name "right"; ! ---------------------------------------------------------------------------- ! ...and that's all: the "gloves" code is self-contained. ! ! Exercise for the reader: hide a (sharp) jewel inside the left glove. ! (Alter the glove class to make them containers open only when not worn. ! Add two "after" rules to warn the player if there's something sharp ! to the touch, one for putting on the pair of gloves, one for putting on ! an individual glove.) ! ---------------------------------------------------------------------------- ! ---------------------------------------------------------------------------- ! >CO A traditional Inform example object: ! ---------------------------------------------------------------------------- Object -> cone "green cone" with name "green" "cone" "emerald" "marzipan", describe [; if (cone has moved) "^A misshapen cone of green marzipan sits here."; "^Nearby is an emerald green cone, one foot high."; ], description "The cone seems to be made of emerald-coloured marzipan.", before [; Eat: if (random(100) <= 30) { deadflag = 1; "Unfortunately, you seem to be allergic to almonds."; } "You nibble at a corner of the cone."; ], after [; Take: "Taken. (Your hands are smeared with marzipan.)"; Drop: cone.description = "The cone is a vague green mess."; "The cone drops to the floor and sags a little."; ], has edible; ! ---------------------------------------------------------------------------- ! >HW It's the draught from this slightly-concealed window which propels the ! balloon: ! ---------------------------------------------------------------------------- Object -> "high window" with name "high" "window", description [; print "A narrow, high window "; if (self has open) "through which a draught blows."; "which is closed."; ], after [; Open: StartDaemon(balloon); Close: Achieved(2); StopDaemon(balloon); ], has scenery openable open; ! ---------------------------------------------------------------------------- ! >BC A typical locked container, containing a rather pathetic prize... ! ---------------------------------------------------------------------------- Object -> "bolted cupboard" with name "bolted" "cupboard", describe [; if (self hasnt open) "^A shut cupboard is bolted to one wall."; "^Bolted up on one wall is an open cupboard."; ], with_key key has locked container openable lockable static; Object -> -> "boiled sweet" with name "boiled" "sweet", after [; Eat: Achieved(0); "It takes an irritatingly long time to eat."; ], has edible; ! ---------------------------------------------------------------------------- ! >GB This is really to demonstrate "transparent". Shutting up the glowing ! >SB ball in the glass box does not make the room go dark: shutting it up ! in the steel box does. Also, you can examine things in the glass box ! even when the glass box is shut. ! (Note also that the Dark Room is explicitly told not to have "light", ! which it would otherwise inherit from the "Toyroom" class.) ! ---------------------------------------------------------------------------- Toyroom DarkRoom "Dark Room" with description "A featureless storage room, hardly worth illumination.", cant_go "The only exit is back south.", s_to East_End has ~light; Object -> "glass box with a lid" with name "glass" "box" "with" "lid" has container transparent openable open; Object -> "steel box with a lid" with name "steel" "box" "with" "lid" has container openable open; Toyroom West_End "West End" with name "soldiers" "model" "aircraft" "planes", description "The western end of the toyshop is blue, and soldiers and model aircraft line the shelves. A small office lies to the south.", e_to Toyshop, s_to Office; ! ---------------------------------------------------------------------------- ! >BL The class Block provides for stackable building blocks. ! ! Note that with the "describe" routine missing, the game would still ! correctly describe stacks of blocks: just a little less elegantly. ! ---------------------------------------------------------------------------- Class Block with description "Just a child's building block, four inches on a side.", ! The parse_name routine below ensures that "take blocks" ! works correctly: parse_name [ i j; for (::) { j=NextWord(); if (j=='block' or 'cube' or 'building' or (self.name)) i++; else { if (j=='blocks' or 'cubes') { parser_action=##PluralFound; i++; } else return i; } } ], describe [ c d e; d = child(self); while (d~=0 && d ofclass Block) { c++; e=d; d=child(d); } if (c==0) rfalse; print "^There is a pile of building blocks here, "; while (c>=0) { print (address) e.name; ! Sneaky: print the "name" out if (c>0) print " on "; ! using its dictionary address c--; e=parent(e); } "."; ], before [ c; PutOn: if (second ofclass Block) { if (child(second)~=0 && child(second) ofclass Block) "There's no room on the top of one cube for two more, side by side."; } else print "(They're really intended to be piled on top of each other.)^"; c=second; while (c ofclass Block) c=parent(c); if (c~=location or mantelpiece) "Too unsteady a base."; ], after [ c stack; PutOn: stack=noun; while (parent(stack) ofclass Block) { stack=parent(stack); c++; } if (c<2) { if (Chris has general) rtrue; rfalse; } if (c==2) "The pile of three cubes is unsteady, but viable."; if (Chris has general) { Achieved(3); "^Expertly he keeps the pile of four cubes stable."; } stack=noun; while (parent(stack) ofclass Block) { c=stack; stack=parent(stack); move c to location; } "The pile of four cubes wobbles, wobbles, steadies... and suddenly collapses!"; Take: stack=child(noun); if (stack==0) rfalse; while (stack~=0) { c=stack; stack=child(stack); move c to location; } "Your pile of cubes is collapsed as a result."; ], has supporter; Block -> "green cube" with name "green"; Block -> "red cube" with name "red"; Block -> "yellow cube" with name "yellow"; Block -> "blue cube" with name "blue"; ! ---------------------------------------------------------------------------- ! >CH A guest appearance by my cousin Christopher, aged six (*), who plays ! with one thing at a time (easily forgetting which). Being "transparent" ! (no reflection on him!) means the parser allows the player to examine ! whatever he's playing with... but not to take it from him. ! (* In 1993, when this game was first written.) ! ---------------------------------------------------------------------------- Object -> Chris "Christopher" with name "child" "boy" "chris" "christopher", describe [; print "^A boy called Christopher sits here"; if (child(Chris) ~= nothing) print ", playing with ", (a) child(Chris); "."; ], life [ x; Ask: switch(second) { 'juggling', 'fluorescent', 'ball': "~That's mine!~"; 'helium', 'balloon': "Christopher yawns."; 'cube', 'cubes': "~Bet I can make a higher tower than you.~"; 'toys', 'toyshop': "~Isn't it fabulous here?~"; default: "~Dunno.~"; } Answer: switch(noun) { 'hello', 'hallo', 'hi': "~Hello,~ says Christopher cheerfully."; default: "Christopher seems preoccupied."; } Attack: remove self; "Christopher makes a run for it, effortlessly slipping past you!"; Kiss: "~That's soppy, that is.~"; Give: if (noun==balloon) "He's too bored by the balloon."; x=child(Chris); if (x~=0) { move x to location; print "He forgets about ", (the) x, " and "; } else print "He "; print "eagerly grabs ", (the) noun; move noun to Chris; "."; ], orders [; Drop: if (noun in Chris) "~Won't! It's mine!~"; Take: "Christopher can't be bothered."; Give: if (second==player) "~Get your own!~"; Go: "~But I like it here!~"; PutOn: if (noun notin Chris) "He is mightily confused."; if (~~(noun ofclass Block && second ofclass Block)) "He can't see the point of this."; print "Christopher leans over with great concentration and does so.^"; move noun to player; give self general; ; give self ~general; rtrue; ], each_turn [; if (random(3)~=1) rtrue; print "^Christopher "; switch(random(4)) { 1: "yawns."; 2: "frowns."; 3: "stretches."; 4: "hums tonelessly."; } ], has animate proper transparent; Object "fluorescent juggling ball" Chris with initial "On the floor is a fluorescent juggling ball!", name "fluorescent" "juggling" "ball", description "It glows with soft light." has light; ! ---------------------------------------------------------------------------- ! >OF A simple movement rule. ! ---------------------------------------------------------------------------- Toyroom Office "Office" with description "A small, grey office, with a broad stone mantelpiece. In the east wall is a doorway marked ~Exit~, and the Toyshop, of course, lies north.", cant_go "The Toyshop floor lies north.", n_to West_End, e_to [; if (score~=MAX_SCORE) "A gong sounds. ~You cannot leave the Toyshop until you have done six interesting things!~"; deadflag=2; "A gong sounds. ~Congratulations! You may now leave the Toyshop and begin writing your own Inform game!~"; ]; ! ---------------------------------------------------------------------------- ! >TB A somewhat acquisitive container... but it can be taught to behave. ! ---------------------------------------------------------------------------- Object -> "toothed bag" with name "toothed" "bag", initial "In one corner is a curious, toothed bag.", description "A capacious bag with a toothed mouth.", before [; LetGo: "The bag defiantly bites itself shut on your hand until you desist."; ], after [; Receive: if (noun==cone) { self.before=0; self.after=0; "The bag wriggles interminably as it tries to eat the enormous mass of marzipan. That'll teach it."; } "The bag wriggles hideously as it swallows ", (the) noun, "."; ], has container open; ! ---------------------------------------------------------------------------- ! >SL Which can be put on the mantelpiece: the first time this is done, the ! game randomly decides which end is higher, and sticks to this decision. ! ---------------------------------------------------------------------------- Object -> -> spirit_level "spirit level" with name "spirit" "level" "wood" "flask", number 0, description "A length of wood containing a flask of viscous green liquid, in which a bubble is trapped.", before [; Examine: if (spirit_level in mantelpiece) { print "The bubble is at the "; if (self.number==1) "northeast end."; "southeast end."; } ], after [; PutOn: if (second~=mantelpiece) rfalse; if (spirit_level hasnt general) self.number=random(2); give spirit_level general; Achieved(4); print "You put the spirit level on the mantelpiece, and the bubble slowly drifts towards the "; if (self.number==1) "northeast."; "southwest."; ]; Object -> mantelpiece "mantelpiece" with name "mantel" "mantle" "piece" "mantelpiece" has scenery supporter; Object -> -> key "iron key" with name "iron" "key", article "an"; ! ---------------------------------------------------------------------------- ! >BB A blackboard which can be written on or wiped clear. ! ---------------------------------------------------------------------------- Object -> -> chalk "stick of chalk" with name "stick" "of" "chalk"; Array boardtext string 64; Object -> blackboard "blackboard" with name "board" "blackboard" "black", describe [; <>; ], before [ i f; Examine: for (i=1:i<=boardtext->0:i++) if (boardtext->i~=' ' or 0) f=1; if (f==0) { print "^The office blackboard is wiped clean.^"; if (self hasnt general) { give self general; "^[To write on it, try > write ~message...~]"; } rtrue; } print "^The office blackboard bears the message:^ "; for (i=1:i<=boardtext->0:i++) { f=boardtext->i; if (f~=0) print (char) f; } new_line; rtrue; Rub: for (i=1:i<=boardtext->0:i++) boardtext->i = ' '; "You wipe the blackboard clean."; ], has static; Global from_char; Global to_char; [ QuotedText i j f; i = WordAddress(wn++); i=i-buffer; if (buffer->i=='"') { for (j=i+1:j<=(buffer->1)+1:j++) if (buffer->j=='"') f=j; if (f==0) return -1; from_char = i+1; to_char=f-1; if (from_char>to_char) return -1; while (buffer+f > WordAddress(wn)) wn++; wn++; return 1; } return -1; ]; [ WriteSub i j; if (chalk notin player) "You're holding nothing to write with."; if (blackboard notin location) "The blackboard is elsewhere."; for (i=from_char,j=1:i<=to_char && j0:i++,j++) boardtext->j = buffer->i; for (:j0:j++) boardtext->j=0; Achieved(5); <>; ]; ! ---------------------------------------------------------------------------- ! End of object definitions. ! ---------------------------------------------------------------------------- ! ! Routines and Entry Points ! ! (Fuller examples of which can be found in the "Advent" example game.) ! ! Initialise() just sets up the initial state of the game. ! We are required to set "location" to the start location of the ! player; the rest is optional. ! ! StartDaemon(balloon) starts the process which blows the balloon back ! and forth. ! ---------------------------------------------------------------------------- [ Initialise; location=chair; move satchel to player; print "^^^^^~What's so special about Inform,~ is the last thing you remember saying to the mad alchemist. Big mistake...^^"; StartDaemon(balloon); ]; ! ---------------------------------------------------------------------------- ! Print names of tasks out (when the library asks us to). Note that they ! are numbered from 0 to NUMBER_TASKS-1. ! ---------------------------------------------------------------------------- [ PrintTaskName achievement; switch(achievement) { 0: "eating a sweet"; 1: "driving the car"; 2: "shutting out the draught"; 3: "building a tower of four"; 4: "seeing which way the mantelpiece leans"; 5: "writing on the blackboard"; } ]; [ PrintRank; print ", earning you the rank of "; if (score >= 6) "Toyshop manager."; if (score >= 5) "management trainee."; if (score >= 4) "undergraduate."; if (score >= 3) "schoolchild."; if (score >= 2) "nursery-school child."; if (score >= 1) "toddler."; "newborn baby."; ]; ! ---------------------------------------------------------------------------- ! Now (as promised earlier) we provide the replacement for BurnSub, ! specially adapted to the rules of the Toyshop: ! ---------------------------------------------------------------------------- [ BurnSub; if (match hasnt light) "You have no source of flame."; if (noun has animate) <>; if (noun==padded_floor) { deadflag=1; "A gong sounds, but before a sepulchral voice finishes clearing its throat, the whole padded floor goes up in an inferno."; } "A gong sounds, and a sepulchral, rather disappointed voice says: ~It is forbidden to play with fire in the Toyshop.~"; ]; ! ---------------------------------------------------------------------------- ! And we provide one new action, "Burst", which in fact just passes over to ! "Attack", plus one for writing on the board: ! ---------------------------------------------------------------------------- [ BurstSub; <>; ]; Include "Grammar"; Verb "burst" "pop" "prick" "stab" "pierce" * noun -> Burst; Verb "write" * QuotedText -> Write; ! ----------------------------------------------------------------------------