mirror of
https://github.com/sehugg/8bitworkshop.git
synced 2024-11-23 06:32:11 +00:00
423 lines
15 KiB
INI
423 lines
15 KiB
INI
! ------------------------------------------------------------------------------
|
|
! Inform for New Writers
|
|
!
|
|
! The House - Version 4
|
|
!
|
|
! Last Modified: David Cornelson - 22-Jan-1998
|
|
!
|
|
! This work is freely offered to the Public Domain. - DAC 12-12-2015
|
|
!
|
|
! ------------------------------------------------------------------------------
|
|
|
|
Constant DEBUG;
|
|
|
|
Constant Story "The House";
|
|
|
|
Constant Headline
|
|
"^Inform for New Writers^
|
|
The House - Version 4^
|
|
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.
|
|
!
|
|
! ----------------------------------------------------------------------------
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
!
|
|
! VERSION 4 - Cause and Effect. Things happen based on what a player does.
|
|
!
|
|
! In this version of The House, we're going to add an object, the rock, and
|
|
! a place where the rock is useful. Unlike version 3 where Inform provides
|
|
! a special 'door' object, we must provide our own logic to 'handle' the rock.
|
|
!
|
|
! To do this, we're going to use what are called 'code blocks'. A code block is a
|
|
! group of statements that combine to handle one particular piece of logic
|
|
!
|
|
! Code blocks contain a decision and/or a loop. A decision is handled by one of two
|
|
! Inform statements, the 'if' statement and the 'switch' statement. We'll talk about
|
|
! the 'switch' statement and 'loops' in later versions of The House.
|
|
!
|
|
! DECISION STATEMENTS
|
|
!
|
|
! THE 'if' STATEMENT
|
|
!
|
|
! The 'if' statement contains a comparison of variables, numbers, and/or text that
|
|
! provides a true or false result. Based on either result (true or false) another
|
|
! code block is written to handle the decision.
|
|
!
|
|
! For example:
|
|
!
|
|
! if (1==1) {
|
|
! print "True";
|
|
! } else {
|
|
! print "False";
|
|
! }
|
|
!
|
|
! In the above example, the word "True" will be printed because the comparison of
|
|
! 1 to 1 is a true statement, 1 certainly does equal 1. If we changed the comparison
|
|
! to:
|
|
!
|
|
! if (1==2) {
|
|
! print "True";
|
|
! } else {
|
|
! print "False";
|
|
! }
|
|
!
|
|
! ...then "False" would be printed because 1 does not equal 2.
|
|
!
|
|
! Here are some more examples of valid 'if' statements...
|
|
!
|
|
! eggs=2;
|
|
! if (eggs<2) {
|
|
! print "You don't have enough eggs!";
|
|
! } else {
|
|
! print "You have enough eggs!";
|
|
! }
|
|
!
|
|
! The above 'if' statement asks if the variable 'eggs' is less than two. If the value
|
|
! is less than two, print "You don't have enough eggs!", otherwise Inform will print
|
|
! "You have two eggs, just enough!" (which is the case since we set the variable 'eggs'
|
|
! to 2 before the 'if' statement).
|
|
!
|
|
! eggs=2;
|
|
! bacon=4;
|
|
! if (eggs<2) {
|
|
! print "You don't have enough eggs!";
|
|
! if (bacon<4) {
|
|
! print "You don't have enough bacon either!";
|
|
! } else {
|
|
! print "You have four strips of bacon though!";
|
|
! }
|
|
! } else {
|
|
! print "You enough eggs!";
|
|
! if (bacon<4) {
|
|
! print "You don't have enough bacon though!";
|
|
! } else {
|
|
! print "You have four strips of bacon too!";
|
|
! }
|
|
! }
|
|
!
|
|
! In the above example, things get more complicated. I'll rewrite it in english so
|
|
! that you can understand what is happening. Many programmers start out writing
|
|
! things in english and they call it 'pseudocode'.
|
|
!
|
|
! set eggs to 2
|
|
! set bacon to 4
|
|
!
|
|
! if there are less than two eggs then
|
|
! print "You don't have enough eggs!"
|
|
! if there are less than four bacon then
|
|
! print "You don't have enough bacon either!"
|
|
! else
|
|
! print "You have four strips of bacon though!"
|
|
! end if
|
|
! else
|
|
! print "You enough eggs!"
|
|
! if there are less than four bacon then
|
|
! print "You don't have enough bacon though!"
|
|
! else
|
|
! print "You have four strips of bacon too!"
|
|
! end if
|
|
! end if
|
|
!
|
|
! Questions: Q: Why is there a double equal sign in the 'if' statement?
|
|
!
|
|
! A: Inform will set variables with one equals sign "=" and compare them
|
|
! when you put two equals signs "==" together. This is important to
|
|
! remember and can cause a lot of 'bugs' in your code. Another exanple
|
|
! explaining this is:
|
|
!
|
|
! if (eggs=2) print "There are two eggs.";
|
|
!
|
|
! This statement will ALWAYS BE TRUE because eggs is being SET to 2, NOT
|
|
! compared.
|
|
!
|
|
! Q: What are the squiggly brackets, '{' and '}', for?
|
|
!
|
|
! A: They signify the beginning and end of an 'if' statement code block.
|
|
! You need them to group more than one statement together. The left
|
|
! squiggly bracket begin the code block and the right squiggly bracket
|
|
! ends the code block.
|
|
!
|
|
! NOTE: You only need the brackets if you have more than one statement
|
|
! in the resulting code block. Another example might be:
|
|
!
|
|
! if (eggs==2) {
|
|
! print "There are a pair of eggs.";
|
|
! bacon=4;
|
|
! }
|
|
! else
|
|
! print "There are ", eggs, " eggs.";
|
|
!
|
|
! In the above example, squiggly brackets were only needed for
|
|
! the 'true' code block because we have two statements where
|
|
! there is only one statement for the 'false' code block.
|
|
!
|
|
! Q: What are the symbols for 'if' statement comparisons?
|
|
!
|
|
! A: They are as follows: ~= not equal
|
|
! == equal
|
|
! < less than
|
|
! <= less than or equal
|
|
! > greater than
|
|
! >= greater than or equal
|
|
! && and
|
|
! || or
|
|
!
|
|
! The '&&' and '||' symbols are used to combine comparisons. For example:
|
|
!
|
|
! if (eggs==2 && bacon==4) print "You have two eggs and four bacon!";
|
|
!
|
|
! if (eggs==2 || bacon==4) print "You have either 2 eggs or 4 bacon!";
|
|
!
|
|
|
|
!
|
|
! Okay, now let's apply our knowledge of the 'if' statement and write an embedded function
|
|
! that will handle our rock.
|
|
!
|
|
! We've placed the rock in the den, but we're going to put the action in the backyard
|
|
! which is a location we're adding in this version of The House. Skip down by the kitchen for
|
|
! more...
|
|
!
|
|
|
|
|
|
Object Den "Den"
|
|
with description
|
|
"You are in the den of the house.",
|
|
se_to Right_Front_Door,
|
|
out_to Right_Front_Door,
|
|
has light;
|
|
|
|
!
|
|
! This is our rock object.
|
|
!
|
|
! We've added the property 'before' with the arguments 'PutOn','Insert', and
|
|
! 'ThrowAt:'. When the rock is thrown at or in anything, this function is executed.
|
|
!
|
|
! In this case, the object being thrown, rock or keys, is the value of the Inform
|
|
! variable 'noun'. If noun equals the object 'Rock', then the true code block is
|
|
! executed, otherwise the false code block is executed.
|
|
!
|
|
! Q: Why is the statement 'rtrue' placed at the end of both code blocks?
|
|
!
|
|
! A: Normally, the Inform parser handles the action of an object being thrown at
|
|
! something else. This is the default processing. If you throw the 'right key'
|
|
! around The House or at the pond, you'll see the 'default' Inform processing.
|
|
!
|
|
! Since we wanted special processing for the rock, we handled the actions on
|
|
! our own through our code. But at the end of handling the thrown rock, we have
|
|
! to let the Inform parser know that we took care of everything and not to do
|
|
! anything.
|
|
!
|
|
! If we return true, Inform understands and leaves everything alone.
|
|
! If we return false, Inform will execute the default processing.
|
|
!
|
|
! By the way, rtrue and rfalse are shortcuts to the statements:
|
|
!
|
|
! return true;
|
|
! return false;
|
|
!
|
|
!
|
|
! Q: Why is the variable 'second' being compared to the object name 'Pond'?
|
|
!
|
|
! A: The variable 'second' is an Inform variable set to the second noun of
|
|
! of a players statement. For example:
|
|
!
|
|
! > THROW ROCK AT POND
|
|
!
|
|
! In this statement, 'rock' is the first noun and Inform determines the object
|
|
! value for 'rock' and sets the variable 'noun' to that value. For the noun
|
|
! 'pond', Inform determines the object value and sets this in the variable
|
|
! 'second'.
|
|
!
|
|
! Q: Why is '(the)' before 'second' in the print statement below?
|
|
!
|
|
! A: This is to force Inform to print the article 'the' before the word. In any
|
|
! object, you can define the article property with a value, such as "the",
|
|
! "your", "an", or "some", so that Inform understands how to refer to the
|
|
! object in sentences.
|
|
!
|
|
|
|
Object -> Rock "rock"
|
|
with name "rock",
|
|
description
|
|
"It's smooth and flat, perfect for skipping in a pond.",
|
|
before [; Insert,PutOn,ThrowAt:
|
|
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 throw the rock at ",(the) second, " and bounces
|
|
back into your stomach. Ouch! That hurt.^";
|
|
rtrue;
|
|
}
|
|
];
|
|
|
|
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;
|
|
|
|
!
|
|
! We've added out_to and w_to for a connection to the backyard as well as
|
|
! changing the description to help the player know what's going on.
|
|
!
|
|
|
|
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;
|
|
|
|
!
|
|
! This is our new location. Notice we added the name "yard" in case the player
|
|
! abbreviates their commands.
|
|
!
|
|
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;
|
|
|
|
!
|
|
! This is where we plan to use the rock....
|
|
!
|
|
|
|
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;
|
|
|
|
!
|
|
! Added the article "the"...
|
|
!
|
|
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;
|
|
|
|
! ----------------------------------------------------------------------------
|
|
! Grammar
|
|
!
|
|
! The grammar section includes the file "Grammar" and will later include
|
|
! extensions to the standard grammar library.
|
|
!
|
|
! ----------------------------------------------------------------------------
|
|
|
|
Include "Grammar";
|
|
|