943 lines
36 KiB
INI
943 lines
36 KiB
INI
! ----------------------------------------------------------------------------
|
|
! 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) <<Pull 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;
|
|
<PutOn noun second>;
|
|
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
|
|
[; <<Examine self>>; ],
|
|
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 && j<boardtext->0:i++,j++)
|
|
boardtext->j = buffer->i;
|
|
for (:j<boardtext->0:j++) boardtext->j=0;
|
|
Achieved(5);
|
|
<<Examine blackboard>>;
|
|
];
|
|
|
|
! ----------------------------------------------------------------------------
|
|
! 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) <<Attack noun>>;
|
|
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; <<Attack noun>>; ];
|
|
|
|
Include "Grammar";
|
|
|
|
Verb "burst" "pop" "prick" "stab" "pierce"
|
|
* noun -> Burst;
|
|
|
|
Verb "write" * QuotedText -> Write;
|
|
|
|
! ----------------------------------------------------------------------------
|