sample.hug

!\---------------------------------------------------------------------------

        THE VAULT OF HUGO
        Hugo v2.5 Tutorial Game

        by Kent Tessman (c) 1995-1999

---------------------------------------------------------------------------\!

#version 2.5

#set DEBUG                              ! include HugoFix library and grammar
#set VERBSTUBS                          ! include verb stub routines

#set USE_VEHICLES                       ! from OBJLIB.H
#set USE_PLURAL_OBJECTS                 !
#set USE_ATTACHABLES                    !

#set NO_AUX_MATH                        ! don't need advanced math routines

#switches -ls                           ! print statistics to SAMPLE.LST
#ifset DEBUG
#switches -d
#endif


! The following limit setting reserves 512 extra bytes of dictionary space
! so that the play can name the unnamed object.  A maximum 512 bytes are
! required because the game needs to write the name, adjective, and misc
! properties of the object.

$MAXDICTEXTEND = 512


!----------------------------------------------------------------------------
! NEW GRAMMAR:

verb "kick", "punt", "boot"
        *                                               DoVague
        * object                                        DoPunt

verb "board"
        * (minecar)                                     DoEnter

verb "roll", "drive", "steer", "ride"
        *                                               DoVague
        * object                                        DoMoveinVehicle
        * "to" object                                   DoMoveinVehicle

! In the grammar definitions below, STRING refers to any section of the
! player's input enclosed in quotation marks.

verb "write", "scribble", "scrawl", "print"
        *                                               DoVague
        * "on" object                                   DoWriteOn
        * "on" object "with" held                       DoWriteOn
        * string                                        DoWrite
        * string "on" object                            DoWrite
        * string "on" object "with" held                DoWrite
        * string "with" held                            DoWrite

verb "name", "call", "christen"
        *                                               DoVague
        * (unnamedobject)                               DoNameWhat
        * (unnamedobject) string                        DoName

verb "stick"
        *                                               DoVague
        * (dart)                                        DoAttachObject
        * (dart) "in"/"on" (dartboard)                  DoAttachObject


#include "verblib.g"                    ! normal verb grammar

!----------------------------------------------------------------------------

#ifset PRECOMPILED_LIBRARY
#link "hugolib.hlb"
#else
#include "hugolib.h"                    ! standard library routines
#endif

! Normally, the library's PrintScore routine uses a MAX_SCORE/score
! formula to determine a ranking (if rankings are provided); the following
! global is used in the replaced PrintScore routine to ensure that rank is
! set by the game, not approximated by the library.

global rank

routine init
{
        MAX_SCORE = 50
        ranking[0] = "Amateur Adventurer"
        ranking[1] = "Competent Door-Unlocker"
        ranking[2] = "Bomb-Meddling Adventurer"
        ranking[3] = "Master Magic Wand Finder"
        ranking[4] = "The Genuine Article Sample Game Solver"
        MAX_RANK = 4

        counter = -1                    ! 1 turn before turn 0

        STATUSTYPE = 1                  ! score/turns
        TEXTCOLOR = DEF_FOREGROUND
        BGCOLOR = DEF_BACKGROUND
        SL_TEXTCOLOR = DEF_SL_FOREGROUND
        SL_BGCOLOR = DEF_SL_BACKGROUND

        prompt = ">"
        color TEXTCOLOR, BGCOLOR

        DEFAULT_FONT = PROP_ON
        Font(DEFAULT_FONT)

        cls
        "You brace yourself, check your flashlight, and, with \
        source code in hand, prepare to enter...\n"

        Font(BOLD_ON)
        "THE VAULT OF HUGO"
        Font(BOLD_OFF)
        "An Interactive Example"
        print BANNER

        player = you
        location = outsidevault
        old_location = location

        move player to location         ! initialize player location
        FindLight(location)             ! whether the player can see
        DescribePlace(location)         ! the appropriate description
        location is visited
        CalculateHolding(player)        ! total size of player contents

        Acquire(player, flashlight)     ! give the player the flashlight
        flashlight is known

        Activate(key_daemon)            ! set up initial daemons

        InitPluralObjects
}

#ifset PRECOMPILED_LIBRARY
replace main
{
#else
routine main
{
#endif
        counter = counter + 1
        PrintStatusLine
        run location.each_turn
        runevents
        RunScripts
        if speaking not in location     ! in case the character being spoken
                speaking = 0            ! to leaves
}

player_character you "you"
{}


! flashlight
!
! The flashlight is an example of a light source.  The rules for
! the FindLight routine in HUGOLIB.H check to see if any light sources
! are available (starting with the room itself, then working through
! the visible contents) before deciding if the player is able to see
! in any given location.

object flashlight "flashlight"
{
        in you
        nouns "flashlight", "light", "torch", "lamp"
        adjective "flash"
        article "your"
        short_desc
        {
                CArt(self)
                " is here, ";
                if self is switchedon
                        "glowing brightly."
                else
                        "turned off."
        }
        long_desc
        {
                "It's one of those disposable kinds.  Built-in battery.  \
                $3.99 at the corner store.  That sort of thing.  At the
                moment, it is ";
                if self is switchedon
                        "on."
                else
                        "off."
        }
        before
        {
                ! The before property routine attempts to match the verb
                ! routine based on a given specifier.  In the case below,
                ! if the verbroutine global is set to DoBurn (technically
                ! &DoBurn, the address of the DoBurn routine) and the
                ! object global is set to the flashlight object, the
                ! following routine is run before (in place of) the DoBurn
                ! routine.

                object DoBurn
                        {Perform(&DoSwitchOn, self)}
        }
        after
        {
                ! The two routines below are similar to the before routine
                ! above, except that they are run after the verb routine.

                object DoSwitchOn
                {
                        "A beam of serviceable light appears from your
                        flashlight."
                        self is light
                        FindLight(location)
                        if location is not visited
                                {DescribePlace(location)
                                location is visited}
                }
                object DoSwitchOff
                {
                        "Your flashlight goes dark.  ";
                        self is not light
                        if FindLight(location)
                                print newline
                        else
                                "And so does everything else."
                }
        }
        is switchable
}

!----------------------------------------------------------------------------
! OUTSIDE THE VAULT
!----------------------------------------------------------------------------
room outsidevault "outside a vault"
{
        long_desc
                {"Kind of that 1930s, Bela Lugosi, graveyardy motif at
                work here.  It's a pretty creepy place.  Directly in
                front of you is the giant door to an even more giant
                vault.  Above the door hangs a rusty sign."}
        e_to {return vaultdoor.door_to}
        in_to {return vaultdoor.door_to}
        cant_go
                {"Vines, thorns, and bent, twisted trees bar travel in any
                direction away from the vault."}
        before
        {
                location DoDig
                {
                        if object ~= bump
                                "You can't dig in that."
                        else
                                Perform(&DoSearch, bump)
                }
        }
}


! key_daemon
!
! This basic daemon is simply a trigger that checks every turn to see
! if 10 turns have passed.  If so, it prints a brief section of prose
! before deactivating itself.  (It is also deactivated if the player
! pre-emptively searches the bump in the ground.)

daemon key_daemon
{}

event key_daemon
{
        if counter = 10
        {
                "\nAll this shuffling around outside the door has uncovered
                a little bump in the ground."

                event_flag = true
                Deactivate(key_daemon)
        }
}

scenery bump "little bump"
{
        in outsidevault
        nouns "bump", "ground"
        adjective "little"
        article "a"
        long_desc
        {
                if key is not moved
                        {"It looks like there might be something there."
                        bump is moved}
                else
                        {"You've already got the key.  What more do
                        you want?"}
        }
        before
        {
                ! More than one verb routine may be given as a potential
                ! match to a specifier in a before or after routine, as in:

                object DoSearch, DoDig
                {
                        if key is moved
                                "You already did.  There's nothing else
                                to find."
                        else
                        {
                                bump is moved
                                "You find a rusty iron key!\n(Taken.)"
                                Acquire(player, key)
                                score = score + 10
                                Deactivate(key_daemon)
                        }
                }
        }
}

object key "rusty iron key"
{
        noun "key"
        adjectives "rusty", "iron"
        article "a"
        size 20
        long_desc
                {"A skeleton key.  Rusty.  Iron.  And heavy, too.  A perfect
                match for the vault door, no?"}
        before
        {
                xobject DoUnlock
                {
                        if object = oakdoor
                                "The rusty key doesn't work on this door."
                        else
                                return false    ! library continues as usual
                }
        }
}

scenery sign "rusty sign"
{
        in outsidevault
        noun "sign"
        article "a"
        adjective "rusty"
        long_desc {"\"Here lies Hugo.\""}
        is readable
}


! vaultdoor
!
! Notice that the found_in property specifies the rooms on either side
! of the door; OBJLIB.H does the rest.  The vault door's special attribute
! is set once the player scores points for opening it.

door vaultdoor "vault door"
{
        nouns "door", "doorway"
        adjective "vault", "giant"
        article "the"
        between outsidevault, insidevault
        key_object key
        after
        {
                object DoUnlock
                {
                        if self is not special
                        {
                                self is special
                                score = score + 10
                                rank = 1
                        }
                        return false    ! library continues as usual
                }
        }
        is not open, lockable, locked
}

scenery vault "vault"
{
        in outsidevault
        noun "vault"
        article "the"
        long_desc {"Big, imposing, and complete with rusty sign."}
        door_to                         ! so a player can "go vault"
                {return vaultdoor.door_to}
        before
        {
                object DoEnter
                {
                        object = vaultdoor      ! change object before letting
                        return false            ! library continue normally
                }
        }
}

!----------------------------------------------------------------------------
! INSIDE THE VAULT
!----------------------------------------------------------------------------
room insidevault "inside the vault"
{
        long_desc
        {
                "Standing in the middle of this dimly lit chamber, you
                realize that just maybe you should've splurged on a
                more expensive flashlight.  You also realize that there
                are four ways you can go:  a marble archway to the north,
                a muddy cave opening to the east, ";
                if oakdoor is not blown_open
                        "an oak door set in a brick frame";
                else
                        "an empty brick frame where the oak door used to be";
                " to the southeast, and west back outside where you came
                from."
        }
        w_to {return vaultdoor.door_to}
        out_to {return vaultdoor.door_to}
        se_to {return oakdoor.door_to}
        n_to objectroom
        e_to characterroom
        in_to {"You'll have to be a little more specific about which way
                you want to go."}
        is not light
        after
        {
                location DoGo

                        ! changes the way the vault is refered to from
                        ! "a vault" to "the vault"--a stylistic thing

                {
                        outsidevault.name = "outside the vault"
                        return false
                }
        }
        vehicle_path minecar    ! i.e. the mine car can travel here
}


! minecar
!
! This is an excellent example of a basic vehicle from OBJLIB.H.  The
! vehicle_verbs property must mirror the valid words provided in the
! verb grammar at the start of this file.  The vehicle_move property is
! checked before the vehicle is allowed to move.  (This is where, for
! example, a car object would be checked to make sure that the ignition
! is turned on, or the tires aren't flat, etc.)  Any room in which travel
! in the mine car is permitted must have minecar in its vehicle_path
! property.

vehicle minecar "mine car"
{
        in insidevault
        nouns "car", "cart"
        adjectives "mine", "my", "old"  ! because:  synonym "mine" for "my"
                                        ! in HUGOLIB.H
        article "a"
        vehicle_verbs "roll", "drive", "steer", "ride"
        vehicle_move
        {
                ! Here, the mine car will not roll until the big rock is
                ! removed from under it.  Note that the rock is not actually
                ! under the car, but looking under the car moves it from
                ! the nothing object to the room object.

                if bigrock in nothing
                        {"Something seems to be stopping the mine car
                        from rolling."
                        return false}
        }
        initial_desc
                {"An old mine car sits abandoned to one side."}
        long_desc
                {"It was probably used to haul rocks during the
                excavation of the original Hugo.  You could probably
                get in it."}
        contains_desc
                {"The old mine car is loaded with";}
        before
        {
                object DoClimb
                        {Perform(&DoEnter, self)}
                object DoLookUnder
                {
                        ! The big rock initially begins the game in nothing;
                        ! looking under the mine car moves it inside the
                        ! vault.

                        if bigrock not in nothing
                                "You don't find anything else."
                        else
                        {
                                "You find a big rock lodged between the
                                wheels, which you manage to wrestle out of
                                the way."
                                move bigrock to insidevault
                        }
                }
        }
        after
        {
                object DoEnter
                {
                        pencil is known
                        return false
                }
        }
        capacity 100
        holding 0
        reach minecar                   ! can't reach things outside the car
        is container, open, static

        ! Because the mine car has the quiet attribute set, its contents
        ! (i.e. the pencil) are not immediately obvious--they are not
        ! listed by WhatsIn until the player specifically looks inside.

        is quiet

        ! Also, it is mobile and therefore may be pulled by the rope.

        is mobile
        attach_immobile                 ! returns false if the car is mobile
        {
                if bigrock in nothing
                        "Something seems to be stopping the mine car
                        from rolling."
                else:  return false
        }
}

object bigrock "big rock"
{
        nouns "rock", "stone"
        adjectives "big", "large", "huge"
        article "a"
        after
        {
                object DoGet
                        {"Oof.  It's a struggle, but you manage to
                        pick it up."}
        }
        size 50
}

!----------------------------------------------------------------------------
! THE OBJECT ROOM
!----------------------------------------------------------------------------
room objectroom "Object Room"
{
        article "the"
        prep "in"
        s_to insidevault
        out_to insidevault
        long_desc
        {
                "This room contains a collection of objects with different
                properties, attributes, and associated routines in order
                to give some idea of basic object design.  In addition to
                the various furnishings, you notice a dartboard hanging on
                one wall."
        }
        vehicle_path minecar
        is not light
}

! chair
!
! Try sitting in it.

object chair "wooden chair"
{
        in objectroom
        noun "chair"
        adjective "wooden"
        article "a"
        reach cardtable         ! i.e. only the chair and the card table
                                ! may be reached from the chair
        is enterable, static
}


! cardtable
!
! Try sitting on it.  (You can't--it's not enterable.)  But it can hold
! things on its surface.

object cardtable "card table"
{
        in objectroom
        nouns "table", "cardtable"
        adjective "card"
        article "a"
        capacity 50
        holding 0
        is platform, static
}


! deckofcards and playingcard
!
! A rather unimpressive example of how to extract a single object from
! a group of similar objects.  Pick a card, any card.

object deckofcards "playing cards"
{
        in cardtable
        noun "cards"
        adjective "deck", "playing"
        article "some"
        initial_desc
                {"A deck of playing cards has been placed appropriately
                on the table."}
        size 10
        is plural
}

object card "playing card"
{
        found_in deckofcards
        noun "card" , "diamonds"
        adjective "playing", "nine"
        article "a"
        size 5
        long_desc {"It's the nine of diamonds."}
        after
        {
                object DoGet
                {
                        if object.found_in ~= false
                        {
                                object.found_in = false
                                "You deal the nine of diamonds."
                                object.name = "nine of diamonds"
                                object.article = "the"
                        }
                        else
                                return false
                }
        }
}


! goldcoins
!
! A simple demonstration of identical_class from OBJLIB.H.  The coins can
! be referred to individually, by number (i.e. "two coins"), or as a
! group ("the coins").

identical_class goldcoins "shiny gold coins"
{
        article "some"
        nouns "coins"
        adjectives "shiny", "gold"
        single_noun "coin"
        long_desc
                "Shiny and gold:  both admirable qualities in a coin."
        plural_of coin1, coin2, coin3
}

object coin1 "shiny gold coin"
{
        in cardtable
        article "a"
        noun "coin"
        adjectives "shiny", "gold"
        identical_to goldcoins
}

coin1 coin2 "shiny gold coin"           ! copy coin1 to coin2
{
        in cardtable
}

coin1 coin3 "shiny gold coin"
{
        in cardtable
}


! mittens
!
! Try wearing them.  Try writing when you're wearing them.

object mittens "pair of mittens"
{
        in transparentbox
        nouns "mitten", "mittens"
        adjective "pair"
        article "a"
        size 10
        initial_desc
                {"A pair of mittens is inside the transparent box."}
        is clothing
}


! box
!
! The basic box class is used by transparentbox and opaquebox.  The boxes
! plural_class (from OBJLIB.H) exists only to allow the boxes to be referred
! to as a group.

plural_class boxes "boxes"
{
        article "some"
        noun "boxes"
        single_noun "box"
        plural_of transparentbox, opaquebox
}

class box "box"
{
        noun "box"
        article "a"
        size 20
        capacity 20
        holding 0
        long_desc
        {
                if self is open
                        "It's open."
                else
                        "It's closed."
        }
        after
        {
                ! This after routine replaces the normal library "Taken."
                ! response whenever a box object is the parent of the
                ! taken object.

                parent(object) DoGet
                {
                        print "You take "; The(object); " out of "; \
                        The(self); "."
                }
        }
        plural_is boxes
        is openable, not open, container
}


! transparentbox
!
! Try getting something out of it when it's closed, even if you can see
! the contents.  Then try putting the flashlight in here and closing it.

box transparentbox "transparent box"
{
        in objectroom
        adjective "transparent", "clear"
        is transparent
}


! opaquebox
!
! Now try putting the flashlight in here and closing it.  The library does
! all the work of checking to see if the DoClose verb routine hides the
! light source in the room.

box opaquebox "opaque box"
{
        in objectroom
        adjective "opaque"
        article "an"
}

box largedrum "large drum"
! the special attribute is set once it has been opened
{
        in objectroom
        nouns "drum", "can", "barrel"
        adjectives "large", "big", "larger"
        short_desc
        {
                "A large drum--not the musical kind--is here.  ";
                if warningnote is hidden
                {
                        "Attached to it is a warning note."
                        warningnote is known
                        warningnote is already_listed
                }
                print newline
        }
        long_desc
                {"It's one of those big barrels used for storing and shipping
                oil, chemicals, and other hazardous materials.  Hint."}
        before
        {
                object DoGet
                        {"It's much too heavy to take."}
        }
        after
        {
                object DoOpen
                {
                        ! if drum hasn't been opened the first time
                        if self is not special
                        {
                                "Ignoring all warnings to the contrary, you
                                open the drum.  Inside is another, smaller
                                drum, as well as a second warning note."
                                self is special
                                smalldrum is known
                                warningnote.name = "first warning note"
                        }
                        else
                                return false
                }
        }
}

plural_class notes "notes"
{
        nouns "notes", "paper"
        adjectives "warning", "pieces"
        single_noun "note"
        plural_of warningnote, secondnote
}

object warningnote "warning note"
{
        in objectroom
        nouns "note", "paper"
        adjectives "warning", "first", "piece"
        article "a"
        long_desc
                {"\"Do not open this drum.  Whatever you do, don't open
                this drum.  Do not.  Open.  This drum.\""}
        before
        {
                object DoGet
                        {self is not hidden
                        return false}
        }
        plural_is notes
        is readable, hidden
}

box smalldrum "smaller drum"
! the special attribute is set once the bomb has been found
{
        in largedrum
        nouns "drum", "can", "barrel"
        adjectives "small", "smaller", "little"
        long_desc
        {
                "It's a smaller version of the first drum";
                if secondnote is hidden
                {
                        " (with a second warning note attached, of course)";
                        secondnote is known
                        secondnote is already_listed
                }
                print "."
        }
        before
        {
                object DoGet
                        {"Small is a relative term here.  It's still too
                        big to pick up."}
        }
        after
        {
                object DoOpen
                {
                        if self is not special   ! if bomb hasn't been found
                        {
                                "You find a bomb.  What luck."
                                self is special
                                bomb is known
                                Activate(bomb_fuse, 10)
                                score = score + 10
                                rank = 2
                        }
                        else
                                return false
                }
        }
}

object secondnote "second warning note"
{
        in largedrum
        nouns "note", "paper"
        adjectives "warning", "second", "piece"
        article "a"
        long_desc
                {"\"You listen well.  But this time we mean it.  Don't open
                this drum.\""}
        before
        {
                object DoGet
                {
                        self is not hidden
                        return false
                }
        }
        plural_is notes
        is readable, hidden
}

object bomb "bomb"
{
        in smalldrum
        nouns "bomb"
        article "a"
        long_desc
                {"Just your typical, garden-variety bomb."}
}


! bomb_fuse
!
! This fuse begins running as soon as the player opens the small drum.
! It prints a message only when it is within earshot or view of the player,
! but keeps ticking regardless.

fuse bomb_fuse
{}

event bomb_fuse
{
        if bomb in player                       ! player is holding it
                {"\nThe bomb you're holding is ticking."
                event_flag = true}
        elseif FindObject(bomb, location)       ! bomb is visible in the room
                {"\nThe bomb is ticking."
                event_flag = true}
        elseif Contains(location, bomb)         ! bomb is otherwise in room
                {"\nYou hear a ticking noise."
                event_flag = true}

        if not self.tick                        ! when self.timer = 0
        {
                if Contains(location, bomb)     ! if in player's location
                {
                        "\nKABOOM!\n\n\
                        (Right next to the bomb was not, as they say, such
                        a great place to be as it went off.  You're dead now.)"

                        endflag = 2     ! when endflag is non-false, it
                                        ! immediately triggers the end of the
                                        ! game
                }
                else
                {
                        "\nYou hear a muffled kaboom."
                        event_flag = true
                        if bomb in insidevault
                        {
                                oakdoor is blown_open
                                oakdoor is not openable
                                oakdoor is not hidden
                                score = score + 10

                                ! The following activates the dwarf's
                                ! script with eleven steps; the DwarfDropBall
                                ! ensures that she drops whatever she was
                                ! holding before going anywhere.

                                setscript[script(dwarf,11)] = \
                                        &CharMove, s_obj,
                                        &CharMove, w_obj,
                                        &CharWait, nothing,
                                        &CharShakeHead, oakdoor,
                                        &CharWait, nothing,
                                        &CharMove, n_obj,
                                        &CharWait, nothing,
                                        &CharShakeHead, largedrum,
                                        &CharMove, s_obj,
                                        &CharMove, e_obj,
                                        &CharMove, n_obj
                                DwarfDropBall
                        }
                        remove bomb
                        Deactivate(bomb_fuse)
                }
        }
}


attribute written alias special         ! for the pad only
array writing[65]                       ! up to 64 characters of writing

! pad
!
! Try:  write "something" on paper.

object pad "pad of paper"
{
        in cardtable
        article "a"
        nouns "paper"
        adjective "pad", "regular", "writing"
        long_desc
        {
                "It's a regular pad of writing paper.  ";
                if self is written
                {
                        "Written on it is:  \"";
                        print StringPrint(writing); "\"."
                }
                else:  "It's blank."
                print newline
        }
        is readable
}

object pencil "pencil"
{
        in minecar
        article "a"
        noun "pencil"
        adjective "wooden"
        long_desc
                "Not just a wooden pencil, but a magical wooden pencil,
                which one might use, perhaps, to name a hitherto unnamed
                object."
        size 5
}


! unnamedobject
!
! The unnamed object can be given a name by the player--i.e. have a word
! written on it by which the object may be referred to--in order to
! demonstrate the DICT command.

object unnamedobject "unnamed object"
! the special attribute is set once the player has given it a name
{
        in objectroom
        article "an"
        noun "object"
        adjective "unnamed", "non-descript", "nondescript"
        misc 0                          ! will eventually contain the non-
                                        ! case-altered version of the name
        initial_desc
                "Lying in the corner of the room is a non-descript,
                unnamed object."
        short_desc
                print "The "; self.name; " is here."
        long_desc
        {
                "Nothing special about it.  You can't even tell what it
                might be for.";
                if self is special
                        {"  Written on the side of it is:  \"";
                        print object.misc; "\".";}
                print newline
        }
        is openable, clothing, switchable
}

scenery dartboard "old dartboard"
{
        in objectroom
        article "a"
        noun "dartboard", "board"
        adjective "old", "dart"
        short_desc
                "Hanging on one wall is an old dartboard."
        is static
}


! dart
!
! The dart can be attached to the dartboard either by sticking it in or
! throwing it.  Since the attach_take property is true, the dart is released
! when attached and taken when detached.

attachable dart "green dart"
{
        in objectroom
        article "a"
        noun "dart"
        adjective "green"
        size 5
        attach_verb "stick", "throw"
        detach_verb "get"
        attach_prep "in"
        attached_desc "sticking out of"
        attach_take true
        attach_drop true
        attached_to dartboard           ! space for one attachment
        attachable_to dartboard
        before
        {
                object DoThrowAt
                {
                        if xobject is living
                                "Trying to start something, are we?"
                        else
                                Perform(&DoAttachObject, object, xobject)
                }
        }
}


! rope
!
! The rope is another attachable--but unlike the dart, because attach_take
! is not set to true, it may still be carried after being attached to another
! object.  Since the minecar has the mobile attribute set, it may be pulled
! around; the chair and cardtable, however, may not.

attachable rope "heavy rope"
{
        in objectroom
        article "a"
        nouns "rope", "twine"
        adjective "heavy", "thick"
        attach_verbs "tie", "attach"
        detach_verbs "untie", "detach"
        attached_to chair, 0            ! space for two attachments
        attachable_to chair, cardtable, minecar
}


!----------------------------------------------------------------------------
! THE CHARACTER ROOM AND THE BALL ROOM
!----------------------------------------------------------------------------
room characterroom "Character Room"
{
        noun "room"
        adjective "character"
        article "the"
        prep "in"
        w_to insidevault
        out_to insidevault
        n_to ballroom
        in_to ballroom
        long_desc
                {"The Character Room provides a couple of good examples of
                character scripts and events.  Exits are north and west."}
        vehicle_path minecar
}


! guard
!
! Ask him about things in the game.  Try:
!
!       ask guard about the minecar
!       guard, tell me about the minecar
!       guard, what about the minecar?
!
! Or, once you've begun talking to him, simply:
!
!       tell me about...
!       what about...

character guard "burly guard"
{
        in characterroom
        noun "guard"
        adjective "burly"
        article "a"
        long_desc
                {"He's wearing a button that reads:  \"Just ask me.\""}
        before
        {
                ! The guard is the object, since the question is asked as:
                ! "ask <object> about <xobject>".

                object DoAsk
                {
                        select xobject
                        case minecar
                                "\"You bring that in here, and you're asking
                                for trouble.\""
                        case ballroom
                                "\"Don't let me catch you taking none of them
                                there balls out of the Ball Room.\""
                        case bomb
                                "\"I don't know what kind of loopy nut
                                would want to be carting a bomb in here.\""
                        case dwarf
                                {"\"She's a short little one.  Kinda strange,
                                I have to say.  Spends all her time in there
                                just a-kickin' away.  I think she's mad
                                'cause she lost her magic wand.\""
                                wand is known}
                        case wand
                                "\"Wish I had one.\""
                        case oakdoor
                                "\"I have no idea how to get that thing
                                open.  The only way would be to blast it,
                                if you had something to blast it with...\""
                        case you
                                "The guard doesn't think too much of you."
                        case guard
                                "I wouldn't pry if I were you."
                        case else
                                return false
                }
        }
}


! This object-linked event is checked only when the guard is in the player's
! location.

event guard
{
        if minecar in location
        {
                "\nThe guard lifts his big boot up to the mine car and gives
                you a firm shove back out the door.  \"Not in that thing,
                you don't, pal!\""
                if player in minecar
                {
                        move minecar to insidevault
                        location = insidevault
                        PrintStatusLine
                }
                else
                {MovePlayer(insidevault)
                MoveAllAttachables(player, characterroom, insidevault, true)
                }
        }
        if Contains(player, bomb)
        {
                "\nThe guard grabs you and throws you back out the door.  \
                \"Get out of here with that bomb, pal!\"  An unsubtle
                approach, yes, but one that works."
                MovePlayer(insidevault)
        }
        if Contains(player, soccerball) or Contains(player, basketball)
        {
                "\nThe guard grabs you and throws you back out the door.  \
                \"Read the sign, pal!  They call it the Ball Room for a
                reason.  Keep 'em in there!\""
                MovePlayer(ballroom)
        }
}

room ballroom "Ball Room"
{
        noun "room", "ballroom"
        adjective "ball"
        article "the"
        prep "in"
        s_to characterroom
        out_to characterroom
}


! This event runs whenever the player is in the ballroom.

event ballroom                          ! the dwarf plays with the balls
{
        local a

        if dwarf in ballroom
        {
                a = random(6)           ! 1 to 6
                select a
                        case 1
                                DwarfGetBall(soccerball)
                        case 2
                                DwarfGetBall(basketball)
                        case 3, 4
                                DwarfDropBall
                        case else
                        {
                                if child(dwarf)
                                {
                                        "\nThe dwarf winds up and gives the ";
                                        print child(dwarf).name;
                                        " a kick.  It ricochets off the wall
                                        and bounces back to her."
                                        event_flag = true
                                }
                        }
        }
}

routine DwarfDropBall
{
        if child(dwarf)
        {
                "\nThe dwarf drops the ";
                print child(dwarf).name; "."
                move child(dwarf) to ballroom
                event_flag = true
        }
}

routine DwarfGetBall(obj)
{
        if obj in ballroom
        {
                DwarfDropBall
                move obj to dwarf
                "\nThe dwarf picks up the ";
                print obj.name; "."
                event_flag = true
        }
        else                            ! player must have ball obj
        {
                if obj = basketball     ! so try to choose the other ball
                        obj = soccerball
                else
                        obj = basketball

                if obj not in ballroom  ! player must have both balls
                        "\nThe dwarf looks at you impatiently and more than
                        a little accusingly, waiting for you to give her
                        back her balls."
        }
}

plural_class balls "balls"
{
        article "some"
        noun "balls"
        single_noun "ball"
        plural_of soccerball, basketball
}

object soccerball "checkered soccer ball"
{
        type balls                      ! for identification as a ball
        in ballroom
        nouns "ball", "soccerball"
        adjective "soccer", "checkered"
        article "a"
        before
        {
                object DoGet
                {
                        if self in dwarf        ! if she's holding it
                                {"The dwarf shakes a fist at you and
                                mutters, \"Get your own, kid.\""}
                        else
                                return false
                }
        }
        plural_is balls
}

soccerball basketball "orange basketball"       ! copy the other ball object
{
        in ballroom
        nouns "ball", "basketball"
        adjective "basket", "orange"
        article "an"
}

female_character dwarf "little dwarf"
{
        in ballroom
        noun "dwarf"
        adjective "little"
        article "a"
        order_response          ! i.e. "dwarf, (do something)", such as
        {                       ! "dwarf, kick ball"

                if verbroutine = &DoPunt
                {
                        if object.type ~= balls
                                {"The dwarf looks at you like you're nuts."
                                return true}
                        if object in player
                                {"(first giving the ball to her)"
                                if child(dwarf)
                                        move child(dwarf) to location
                                move object to dwarf}

                        if object not in dwarf
                                {"The dwarf shrugs.  \"I would, but I don't
                                have ";
                                print The(object); ".\""}
                        else
                                {"The dwarf winds up and gives the ";
                                print object.name;
                                " a kick.  It ricochets off the wall and
                                bounces back to her."}
                }
                else
                        return false
        }
        after
        {
                object DoAsk
                {
                        if xobject = wand
                                "\"I'd like to have it back.\""
                        else
                                return false
                }
                object DoTell
                {
                        if xobject = wand
                                "\"I'd like to have it back.\""
                        else
                                return false
                }

                ! In this case, the dwarf is the xobject, since the command
                ! is given as:  "show <object> to <xobject>".

                xobject DoShow
                {
                        if object = wand
                                "\"Give that to me!\""
                        else
                                return false
                }
                xobject DoGive
                {
                        if object = wand
                        {
                                "\"Thank you!  I've been looking for
                                that.\"  The dwarf takes the wand and bonks
                                you a little roughly on the head with it,
                                transporting you back to your nice, warm bed."
                                rank = 4
                                score = score + 10
                                endflag = 1
                        }
                        else
                                return false
                }
        }
}

routine CharShakeHead
{
        local char, obj
        if char in location
                print CThe(char); " shakes her head at "; The(obj); "."
}

!----------------------------------------------------------------------------
! BRICK ROOM
!----------------------------------------------------------------------------

! Special attribute for the oak door:
attribute blown_open alias special

object oakdoor "oak door"       ! a little more complicated door object
{
        in insidevault
        noun "door", "doorway"
        adjective "oak"
        article "an"
        short_desc
                {"Lying on the floor is the oak door."}
        door_to
        {
                if self is not blown_open
                        "The oak door is locked up tight as a drum."
                else
                        return brickroom
        }
        vehicle_path minecar

        ! Setting key_object to a non-zero value means the door is not
        ! openable without a key.  In this case, the ! key is
        ! technically object 1, which doesn't exist in the game.  So
        ! for all intents and purposes, the player can never unlock
        ! this door.  (It has to be blown open.)

        key_object 1

        is static, openable, not open, lockable, locked

        ! Since the door is hidden at the outset, its short_desc is
        ! not printed (until the door is blown open).

        is hidden
}

room brickroom "Brick Room"
{
        noun "room"
        adjective "brick"
        article "the"
        prep "in"
        long_desc
                {"This room is finished entirely in brick masonry.  Good,
                solid workmanship.  You can head back out to the northwest."}
        nw_to insidevault
        out_to insidevault
}

object trophy "shining golden trophy"
{
        in brickroom
        nouns "award", "trophy", "inscription"
        adjectives "shining", "golden"
        article "a"
        initial_desc
                {"A shining golden trophy--an award for your efforts--is
                here.  It bears an inscription."}
        long_desc
                {"Congratulations for solving this sample game's one and
                only major puzzle.  (Although it really wasn't that hard,
                was it?  And you probably don't deserve such a nice shining
                golden trophy.)"}
        after
        {
                object DoGet
                {
                        if parent(letter) = nothing
                                {"As you pick up the trophy, a magic wand
                                falls to the ground, and a small piece of
                                paper flutters down after it."
                                move wand to brickroom
                                move letter to brickroom
                                rank = 3}

                        else
                                return false
                }
        }
        is readable
}

object letter "handwritten letter"
{
        nouns "paper", "letter"
        adjective "handwritten", "piece"
        article "a"
        long_desc
                {"It's a letter from the author of this sample game.  Goes
                something like this:\n\n\"Give this to the dwarf to solve
                the game.\"  Nothing fancy, but I'm sure it was late
                when he was writing this."}
        is readable
}

object wand "magic wand"
{
        noun "wand"
        adjective "magic", "twinkling"
        article "a"
        short_desc {"A magic wand is twinkling on the floor here."}
        long_desc
                {"\"The official magic wand of social democrats
                everywhere.\""}
        before
        {
                object DoWave
                {
                        "You wave the magic wand, a cloud of orange mist
                        appears, and...\n\n...Aw, forget it.  I'm just
                        kidding.  What makes you think you know what to
                        do with a magic wand, anyway?"
                }
        }
}

!----------------------------------------------------------------------------
! NEW VERB ROUTINES
!----------------------------------------------------------------------------

routine DoPunt
{
        if object is living
                "Oh, good.  Real good.  Pick a fight, now.  That's really
                going to get you places."
        elseif object.type ~= balls
                "You won't get very far trying to kick that around."
        else
        {
                "You wind up and give ";
                The(object)
                " a good boot.  ";
                if dwarf in ballroom
                        "The dwarf nods approvingly."
                else
                        print newline
                move object to ballroom
                player.holding = player.holding - object.size
        }
        return true
}

routine DoWriteOn       ! response to an improperly phrased command
{
        if xobject and xobject ~= pencil
                {"You can't write with ";
                print The(xobject); "!"}
        elseif object ~= pad and object ~= unnamedobject
                {"There's not much point in defacing ";
                print The(object); "."}
        else
                "You'll have to be a little more specific about exactly
                what you'd like to write.  Try:  'write \"something\".'"
}

routine DoWrite
{
        local len

        if not xobject
        {
                if pencil not in player
                        {"You're not holding anything to write with."
                        return false}
                else
                        xobject = pencil
        }
        if not object
        {
                if FindObject(pad, location) ~= 1
                        {"Nothing to write on."
                        return false}
                else
                        object = pad
        }

        if xobject ~= pencil or (object ~= pad and object ~= unnamedobject)
                {DoWriteOn
                return}
        elseif mittens is worn
                "Good luck writing with those mittens on."
        elseif object = unnamedobject
                return Perform(&DoName, unnamedobject)
        else
        {
                if pad is written
                        {"You scratch out \"";
                        print StringPrint(writing); "\" and ";}
                else:  "You ";

                ! Read the engine parse$ into the writing[] array, to a
                ! maximum of 64 characters

                len = string(writing, parse$, 64)

                print word[1]; " \""; StringPrint(writing); "\"";
                " on the pad."
                pad is written
        }
        return true
}


! Notice that the DoName routine only allows the player to create one new
! entry in order to avoid overrunning MAXDICTEXTEND.

array name_array[50]

routine DoName
{
        if object is special
                {"You already named it ";
                The(object)
                "--don't go changing your mind now."}
        elseif pencil not in player
                "Would help if you were holding something to write that
                on the object, so you'll remember it."
        else
        {
                local i, len

                len = string(name_array, parse$, 49)    ! maximum 49 char.
                for (i=0; i<len; i=i+1)
                {
                        ! Because the parser cannot recognize multiple
                        ! words...
                        if name_array[i] = ' '          ! a space
                                {"Better keep it to one word."
                                return}

                        ! ...or non-alphanumeric characters (a table of
                        ! ASCII values will show why these are the
                        ! boundaries)

                        if name_array[i] < '0' or name_array[i] > 'z' or
                        (  name_array[i] > '9' and name_array[i] < 'A') or
                        (  name_array[i] > 'Z' and name_array[i] < 'a'):
                                {"Better to keep the fancy punctuation
                                out of it."
                                return}
                }

                "You write \"";
                StringPrint(name_array)
                "\" on the object."

                ! The misc property contains the non-case-corrected version
                ! of the name.

                object.misc = dict(name_array, 49)

                ! The name is converted to '"<string>" object':

                ! initial quote first...
                name_array[0] = '\"'

                ! then read parse$ into name_array (after the first quote)...
                len = string(name_array+1, parse$, 49)

                ! and append the last part to name_array...
                string(name_array+len+1, "\" object")

                ! ...before turning name_array into a dictionary entry
                object.name = dict(name_array, 49)

                ! Since the adjective will be referred to by the parser,
                ! it must be lowercase--name_array must also be reloaded
                ! with parse$ since it has been modified above.

                len = string(name_array, parse$, 49)
                for (i=0; i<len; i=i+1) ! the actual case-conversion loop
                {
                        if name_array[i] >= 'A' and name_array[i] <= 'Z'
                                name_array[i] = name_array[i] + ('a'-'A')
                }

                ! then write the word as a dictionary entry
                object.adjective #1 = dict(name_array, 49)

                object.article = "the"  ! i.e. 'the "<string>" object'
                object is special
                object is moved
        }
}

routine DoNameWhat
{
        "Try:  name object \"(something)\"."
}

!----------------------------------------------------------------------------
! REPLACE LIBRARY ROUTINES:
!----------------------------------------------------------------------------

global already_warned

replace DarkWarning
{
        if not already_warned           ! player is only warned once...
        {
                "It's pitch black in here.  Stumbling around in the dark
                isn't such a hot idea:  you're liable to be eaten by a grue."
                already_warned = true
        }
        else                            ! ...and gets three safe moves before
        {                               ! becoming a snack for a grue
                already_warned = already_warned + 1
                if already_warned > 4
                        {"You stumble around in the dark...and are eaten
                        by a grue!  Bad move.  Should've used a light."
                        endflag = 2}
                else
                        "You stumble around in the dark."
        }
}

! Below is the new PrintScore routine.  Note that it differs from the
! library routine in that it uses the new global rank to print the ranking.

replace PrintScore(end_of_game)
{
        "You ";
        if not end_of_game
                "have ";
        "scored a total of ";
        print number score; " out of "; number max_score;
        print ", giving you the rank of "; ranking[rank]; "."
}