mirror of
https://github.com/sehugg/8bitworkshop.git
synced 2024-09-11 09:54:37 +00:00
334 lines
11 KiB
INI
334 lines
11 KiB
INI
! ------------------------------------------------------------------------------
|
|
! Inform for New Writers
|
|
!
|
|
! The House - Version 5
|
|
!
|
|
! Last Modified: David Cornelson - 22-Jan-1998
|
|
!
|
|
! This work is freely offered to the Public Domain. - DAC 12-12-2015
|
|
!
|
|
! ------------------------------------------------------------------------------
|
|
|
|
Constant Story "The House";
|
|
|
|
Constant Headline
|
|
"^Inform for New Writers^
|
|
The House - Version 5^
|
|
By New Writer (1998) - Last Compiled: 22-Jan-1998^";
|
|
|
|
Constant MAX_SCORE 100;
|
|
Serial "980122";
|
|
|
|
Release 2;
|
|
|
|
Include "Parser";
|
|
Include "VerbLib";
|
|
|
|
!-------------------------------------------------------------------------------
|
|
! Initialise
|
|
!
|
|
!-------------------------------------------------------------------------------
|
|
|
|
[ Initialise;
|
|
|
|
location = Sidewalk;
|
|
|
|
];
|
|
|
|
[ PrintRank;
|
|
print ", earning you the rank of ";
|
|
if (score >= 100) "the greatest.";
|
|
if (score >= 80) "above average.";
|
|
if (score >= 60) "average.";
|
|
if (score >= 40) "below average.";
|
|
if (score >= 20) "the barely living.";
|
|
"the living dead.";
|
|
];
|
|
|
|
! ----------------------------------------------------------------------------
|
|
! Locations
|
|
!
|
|
! In this section we will define our locations. These are "Objects" to Inform.
|
|
!
|
|
! ----------------------------------------------------------------------------
|
|
|
|
!
|
|
! VERSION 5 - Adding a container to your game, functions, verbs, and death.
|
|
!
|
|
! In many cases you will want an object to be able to contain other objects.
|
|
! This may be as simple as creating a 'backpack' that will contain your school
|
|
! papers, apple, and pencil sharpener. In a more complex definition, a container
|
|
! could be a chasm, a bottomless pit, refrigerator, or a television.
|
|
!
|
|
! We're going to create a simple container and a complex container.
|
|
!
|
|
! The simple container is probably very familiar to you. It's a mailbox amd it's
|
|
! right here in front of the house. It contains a letter that can be read as well.
|
|
!
|
|
|
|
Object Sidewalk "Sidewalk"
|
|
with description
|
|
"You are standing on the sidewalk in front of a house to the west.",
|
|
w_to Front_Porch,
|
|
has light;
|
|
|
|
!
|
|
! Add the mailbox with open and closed descriptions.
|
|
!
|
|
Object -> Mailbox "mailbox"
|
|
with name "mailbox" "box",
|
|
when_open "There is an open mailbox here.",
|
|
when_closed "There is a closed mailbox here.",
|
|
has static container openable;
|
|
|
|
!
|
|
! Add 'legible' attribute to distinguish something that can be 'read'.
|
|
! This is determined in the verb extension located in the grammar
|
|
! section at the end of this file.
|
|
!
|
|
Attribute legible;
|
|
|
|
!
|
|
! And here is the letter, which can be consulted, read, or torn up. If it's
|
|
! torn up, the letter is removed from the game, never to be seen again.
|
|
!
|
|
Object -> -> Letter "letter"
|
|
with name "letter" "paper",
|
|
description
|
|
"The letter is a simple page of notebook paper.",
|
|
before [; Consult,Read: "The letter contains a vague story about an evil couch,
|
|
but you can't make out anymore detail. Interesting
|
|
little tidbit though.";
|
|
Tear: remove Letter;
|
|
"You rip the letter into tiny pieces that blow away in the wind.";
|
|
]
|
|
has legible;
|
|
|
|
Object Front_Porch "Front Porch"
|
|
with description
|
|
"This is the front porch of the house. There are two doors
|
|
leading inside. The door on the left leads west and the
|
|
door on the right leads northwest.",
|
|
e_to Sidewalk,
|
|
w_to Left_Front_Door,
|
|
in_to Left_Front_Door,
|
|
nw_to Right_Front_Door,
|
|
has light;
|
|
|
|
Object -> Left_Front_Door "left front door"
|
|
with name "left" "front" "door",
|
|
description
|
|
"The left front door is made of brass.",
|
|
when_open "The left front door is open.",
|
|
when_closed "The left front door is closed.",
|
|
door_to Foyer,
|
|
door_dir w_to,
|
|
has static door openable;
|
|
|
|
Object Right_Front_Door "right front door"
|
|
with name "right" "front" "door",
|
|
description
|
|
"The right front door is made of wood.",
|
|
when_open "The right front door is open.",
|
|
when_closed "The right front door is closed.",
|
|
door_to [; if (location==Front_Porch) return Den; return Front_Porch; ],
|
|
door_dir [; if (location==Front_Porch) return nw_to; return se_to; ],
|
|
found_in Front_Porch Den,
|
|
with_key right_key,
|
|
has static door openable lockable locked;
|
|
|
|
Object Den "Den"
|
|
with description
|
|
"You are in the den of the house. The living room is west of hear
|
|
and the front porch is to the southeast.",
|
|
se_to Right_Front_Door,
|
|
out_to Right_Front_Door,
|
|
w_to Living_Room,
|
|
has light;
|
|
|
|
Object -> Rock "rock"
|
|
with name "rock",
|
|
description
|
|
"It's smooth and flat, perfect for skipping in a pond.",
|
|
before [; Insert,PutOn,ThrowAt:
|
|
if (second==Evil_Couch) rfalse; ! Allow the rock to be eaten by couch
|
|
if (second==Pond) {
|
|
print "The rock skips across the water several times and sinks.
|
|
Amazingly, after a few moments, the rock washes up at
|
|
your feet. Wow, what an undertow!^";
|
|
move Rock to Backyard;
|
|
rtrue;
|
|
!
|
|
! Replace rock so that player can try it again....
|
|
!
|
|
} else {
|
|
print "You can't throw the rock at ",(the) second, ".^";
|
|
rtrue;
|
|
}
|
|
];
|
|
|
|
Object Living_Room "Living Room"
|
|
with name "living" "room",
|
|
description
|
|
"This is the living room of the house. The den is to the east.",
|
|
e_to Den,
|
|
has light;
|
|
|
|
!
|
|
! And here is our evil couch. Anything put on or in the couch will be
|
|
! 'eaten', including you. In fact, by setting the 'deadflag' to 1,
|
|
! Inform is informed to 'end' the game because you have died.
|
|
!
|
|
! Notice we used the 'before' property and the 'Enter' and 'Receive'
|
|
! verbs to handle the action.
|
|
!
|
|
Object -> Evil_Couch "couch"
|
|
with name "couch" "sofa",
|
|
when_open "There is a filthy, worn down couch here.",
|
|
before [; Enter: deadflag=1;
|
|
"You are eaten by the couch.";
|
|
Receive: remove noun;
|
|
"The couch eats ", (the) noun, " and belches.";
|
|
],
|
|
has static container open enterable;
|
|
|
|
Object Foyer "Foyer"
|
|
with description
|
|
"You are standing in the foyer of the house. It seems as though
|
|
you can go up a staircase, northwest, or back out the front
|
|
door to the east.",
|
|
out_to Front_Porch,
|
|
e_to Front_Porch,
|
|
nw_to Hallway,
|
|
u_to Upper_Hallway,
|
|
has light;
|
|
|
|
Object Hallway "Hallway"
|
|
with description
|
|
"You are in the hallway on the first floor of the house. The
|
|
foyer is southeast and the kitchen is west of here.",
|
|
se_to Foyer,
|
|
w_to Kitchen,
|
|
has light;
|
|
|
|
Object Kitchen "Kitchen"
|
|
with description
|
|
"This is the kitchen of the house. A hallway can be seen to the
|
|
east and an open doorway to the west leads out to the backyard.",
|
|
e_to Hallway,
|
|
w_to Backyard,
|
|
out_to Backyard,
|
|
has light;
|
|
|
|
Object Backyard "Backyard"
|
|
with name "yard",
|
|
description
|
|
"This is the backyard behind the house. There is a pond here.",
|
|
e_to Kitchen,
|
|
in_to Kitchen,
|
|
has light;
|
|
|
|
Object -> Pond "pond"
|
|
with name "pond" "water",
|
|
description
|
|
"It's a small pond, but wide enough to skip rocks.",
|
|
has static concealed container open;
|
|
|
|
Object Upper_Hallway "Upper Hallway"
|
|
with description
|
|
"This is the second floor hallway. Rooms can be seen north and
|
|
south and a staircase leads down.",
|
|
n_to North_Bedroom,
|
|
s_to South_Bedroom,
|
|
d_to Foyer,
|
|
has light;
|
|
|
|
Object North_Bedroom "North Bedroom"
|
|
with description
|
|
"This is a bedroom on the north side of the house.",
|
|
s_to Upper_Hallway,
|
|
has light;
|
|
|
|
Object -> right_key "right key" with name "right" "key", article "the";
|
|
|
|
Object South_Bedroom "South Bedroom"
|
|
with description
|
|
"This is a bedroom on the south side of the house.",
|
|
n_to Upper_Hallway,
|
|
has light;
|
|
|
|
! ----------------------------------------------------------------------------
|
|
!
|
|
! Functions
|
|
!
|
|
! ----------------------------------------------------------------------------
|
|
|
|
!
|
|
! Added function ReadSub so that the property 'before' can use it. The default,
|
|
! if there is no 'before read', is to examine the object.
|
|
!
|
|
[ ReadSub; <<Examine noun>>; ];
|
|
|
|
[ TearSub; "You can't tear that"; ];
|
|
|
|
! ----------------------------------------------------------------------------
|
|
! Grammar
|
|
!
|
|
! The grammar section includes the file "Grammar" and will later include
|
|
! extensions to the standard grammar library.
|
|
!
|
|
! ----------------------------------------------------------------------------
|
|
|
|
Include "Grammar";
|
|
|
|
!
|
|
! We also have to extend the read grammar to call ReadSub
|
|
! by default.
|
|
!
|
|
! We're using the 'Extend' statment because the word "read" is already defined
|
|
! in the grammar file included above. This adds our usage.
|
|
!
|
|
! The 'first' tag is used to indicate to Inform that this usage of the word
|
|
! "read" should be the first one checked. Without 'first', the "read" word
|
|
! will not work the way we want it to because the default usage will get
|
|
! called and will not handle our code properly.
|
|
!
|
|
! 'legible' is the attribute we created and by placing it here, we're telling
|
|
! Inform that this attribute must be present in the object to call this usage
|
|
! of the word "read".
|
|
!
|
|
Extend "read" first * legible -> Read;
|
|
|
|
!
|
|
! We've also added the ability to 'tear' an object. Notice
|
|
! we had to specify 'noun' and then direct the default to
|
|
! TearSub.
|
|
!
|
|
! By the way, the 'Sub' is added on automatically by Inform.
|
|
!
|
|
! The word 'noun' tells Inform that the word "tear" must be followed by a
|
|
! noun, otherwise Inform will reply, "What do you want to tear?".
|
|
!
|
|
Verb "tear" * noun -> Tear;
|
|
!
|
|
! Q: I'm really confused! Inform uses the words "first", "second", and "noun".
|
|
! Can you explain the difference again?
|
|
!
|
|
! A: Sure.
|
|
!
|
|
! 'first' is a flag used in the grammar statement "Extend" so that the
|
|
! new usage is called before previously defined usages. Without this
|
|
! flag, an older usage might get called and your code may not work.
|
|
!
|
|
! 'second' is a variable that Inform sets if there is a second noun in
|
|
! the player's statement.
|
|
!
|
|
! 'noun' is a variable that Inform sets if there are any nouns in the
|
|
! player's statement. It gets set to the first noun found.
|
|
!
|
|
! > THROW ROCK AT POND
|
|
!
|
|
! ^ ^
|
|
! noun second
|
|
!
|