/*

 *   Sample game using the TADS 3 library.

 *   

 *   This is an extremely contrived game, and is not intended to be the

 *   least bit interesting to a player but rather serves as a test of

 *   various library features during library development.  

 */

#include "adv3.h"

#include "tok.h"

#include "en_us.h"

/*

 *   This is how we'd change a library grammar definition for a verb, if

 *   we wanted to replace library grammar with our own.  This doesn't

 *   change the rest of the VerbRule definition; it merely changes the

 *   grammar.  If we wanted to change the rest of the VerbRule, we'd use

 *   'replace' rather than 'modify'.  Note that 'replace' and' modify'

 *   both replace the grammar rule itself, though; they differ in how they

 *   handle the *rest* of the properties of the VerbRule object.

 *   

 *   To delete a library verb rule grammar, modify the rule and use an

 *   unmatchable token as the replacement grammar rule (' ' will work,

 *   since the standard tokenizer won't return a space character as a

 *   token).  

 */

//modify VerbRule(Examine)

//    ('ex' | 'lkat') DobjList :

//;

/* ------------------------------------------------------------------------ */

/*

 *   Game credits and version information

 */

versionInfo: GameID

    IFID = 'fa555579-c107-f533-d2a8-d2c93ca87ea0'

    name = 'TADS 3 Library Sampler'

    version = '1.0'

    byline = 'by M.J.Roberts'

    htmlByline =

        'by <a href="mailto:mjr_@hotmail.com">M.&nbsp;J.&nbsp;Roberts</a>'

    authorEmail = 'M.J. Roberts <mjr_@hotmail.com>'

    desc = 'A random sample and test of features of

               the tads 3 library.'

    htmlDesc = 'A random sample and test of features of the

                <b><font size=-1>TADS</font> 3 library</b>.'

    /* add some special text of our own for the credits */

    showCredit()

    {

        "<b><<name>></b>\n

        <<htmlByline>>\b

        Thanks to everyone who has participated in the TADS 3 library

        design process for contributing so many great ideas.

        \b

        <center>

        * * *

        \n

        </center>

        \b";

    }

    /* show "about" information */

    showAbout()

    {

        "This is just a boring sample game to test features of

        the library under construction.  Everything in this game

        is contrived to exercise a particular set of library

        features, and we make no attempt to make a coherent

        game out of this hodge-podge of tests.  A more interesting

        demonstration game will have to wait until the library

        is further along. ";

    }

;

/* ------------------------------------------------------------------------ */

/*

 *   Set up a barrier object so that we can conveniently prevent the

 *   tricycle from going past certain points.  This is just a generic

 *   vehicle barrier, but we customize the failure message.  

 */

tricycleBarrier: VehicleBarrier

    construct(msg) { msg_ = msg; }

    explainTravelBarrier(traveler)

    {

        if (traveler == tricycle)

            reportFailure(msg_);

        else

            inherited(traveler);

    }

    msg_ = '{You/he}\'d best stay indoors with the tricycle; it would

            probably break if you rode it outside. '

; 

/* set up a barrier against pushing the television out of the house */

tvBarrier: PushTravelBarrier

    construct(msg) { msg_ = msg; }

    canPushedObjectPass(obj) { return obj != television; }

    explainTravelBarrier(traveler) { reportFailure(msg_); }

    msg_ = 'The television\'s casters are too small to

            allow the TV to go beyond this point. '

;

/* ------------------------------------------------------------------------ */

/*

 *   Trivial class for rooms in the house.  We use this mostly for

 *   identification of house rooms.  

 */

class HouseRoom: Room

;

class DarkHouseRoom: DarkRoom, HouseRoom

;

/* ------------------------------------------------------------------------ */

/*

 *   Basic Coin class 

 */

class Coin: Thing

    vocabWords = 'coin*coins'

    listWith = [coinGroup]

    /* 

     *   The base name for the coin as it appears in groups.  We leave off

     *   the word "coin" because the coin group prefix uses it.  

     */

    coinGroupBaseName = ''

    /* use the coinCollective for selected actions on coins */

    collectiveGroups = [coinCollective]

    /* 

     *   coin group name and counted name - we synthesize these from the

     *   group base name 

     */

    coinGroupName = ('one ' + coinGroupBaseName)

    countedCoinGroupName(cnt)

        { return spellIntBelow(cnt, 100) + ' ' + coinGroupBaseName; }

;

/*

 *   copper coins 

 */

class CopperCoin: Coin 'copper -' 'copper coin' @livingRoom

    isEquivalent = true

    coinValue = 1

    coinGroupBaseName = 'copper'

;

/* 

 *   silver coins 

 */

class SilverCoin: Coin 'silver -' 'silver coin' @livingRoom

    isEquivalent = true

    coinValue = 5

    coinGroupBaseName = 'silver'

;

/*

 *   gold coins 

 */

class GoldCoin: Coin 'gold -' 'gold coin' @livingRoom

    isEquivalent = true

    coinValue = 10

    coinGroupBaseName = 'gold'

    /* flag: I've awarded points for being taken by the player character */

    takeAwarded = nil

    /* award points when the item is first taken */

    afterAction()

    {

        /* inherit the default handling */

        inherited();

        /* 

         *   if I'm now being held directly or indirectly, and I haven't

         *   awarded my points for being taken before, award points now 

         */

        if (!takeAwarded && isIn(libGlobal.playerChar))

        {

            /* award my points */

            goldCoinAchievement.awardPoints();

            /* only award this achievement once per coin */

            takeAwarded = true;

        }

    }

;

/*

 *   Coin group - this is a listing group we use to group coins in room

 *   contents lists, object contents lists, and inventory lists.  

 */

coinGroup: ListGroupParen

    showGroupCountName(lst)

    {

        "<<spellIntBelowExt(lst.length(), 100, 0,

           DigitFormatGroupSep)>> coins";

    }

    /* 

     *   Just for the heck of it, order coins in a group in descending

     *   order of monetary value.  Since we want descending order, return

     *   the negative of the value comparison.  

     */

    compareGroupItems(a, b) { return b.coinValue - a.coinValue; }

    /*

     *   Customize the display of the individual coins listed in a coin

     *   group, so that we leave off the word "coin" from the name.  This

     *   will make our group list look like so:

     *   

     *   five coins (two gold, two silver, one copper) 

     */

    showGroupItem(lister, obj, options, pov, info)

        { say(obj.coinGroupName); }

    showGroupItemCounted(lister, lst, options, pov, infoTab)

        { say(lst[1].countedCoinGroupName(lst.length())); }

;

/*

 *   Coin Collective - this is a collective group object that we use to

 *   perform certain actions on coins collectively, rather than iteratively

 *   on the individuals.  This is an "itemizing" collective group, because

 *   we want "examine coins" to show a message listing the individual

 *   coins.  

 */

coinCollective: ItemizingCollectiveGroup '*coins' 'coins'

;

/* ------------------------------------------------------------------------ */

/*

 *   Balloons 

 */

class Balloon: Thing 'inflated uninflated popped balloon'

    /* balloons are by default equivalent to one another */

    isEquivalent = true

    /* list balloons in one place as a group */

    listWith = [balloonGroup]

    /* our state index - this is an index into our allStates list */

    state = nil

    /* get our current state - translates our index to a state */

    getState = (allStates[state])

    /* our list of all of our possible states */

    allStates = [balloonStateInflated,

                 balloonStateUninflated,

                 balloonStatePopped]

;

class RedBalloon: Balloon 'red -' 'red balloon';

class BlueBalloon: Balloon 'blue -' 'blue balloon';

class GreenBalloon: Balloon 'green -' 'green balloon';

/* use a simple unadorned grouper to keep all the balloons together */

balloonGroup: ListGroupSorted;

/* balloon state objects */

balloonStateInflated: ThingState 'inflated' +1

    stateTokens = ['inflated']

;

balloonStateUninflated: ThingState 'uninflated' +2

    stateTokens = ['uninflated']

;

balloonStatePopped: ThingState 'popped' +3

    stateTokens = ['popped']

;

sun: MultiFaceted

    initialLocationClass = OutdoorRoom

    instanceObject: Distant { 'sun' 'sun'

        "It's the yellow star around which the Earth orbits. "

    }

;

/* ------------------------------------------------------------------------ */

/*

 *   Living Room 

 */

redBook: Thing 'red book*books' 'red book' @livingRoom;

blueBook: Thing 'blue test book/booklet*books booklets'

    'blue test booklet' @livingRoom;

bigRedBall: Thing 'big large red ball*balls' 'large red ball' @livingRoom;

smallRedBall: Thing 'small little red ball*balls' 'small red ball' @livingRoom;

greenBall: Thing 'green ball*balls' 'green ball' @livingRoom;

box: Container 'brown cardboard box' 'brown box' @livingRoom;

poBox: Thing 'p. o. p.o. po post office # box' 'PO Box' @livingRoom;

eightball: Thing '8 ball/8-ball*balls' '8-ball' @livingRoom;

greenJar: OpenableContainer 'green glass jar*jars' 'green jar' @livingRoom

    "It's made of transparent green glass. "

    material = glass

    initiallyOpen = nil

;

clearJar: OpenableContainer 'clear glass jar*jars' 'clear jar' @livingRoom

    "It's made of clear glass. "

    material = glass

    initiallyOpen = true

    isEquivalent = true

;

CopperCoin location=greenJar;

CopperCoin location=greenJar;

SilverCoin;

SilverCoin;

SilverCoin;

GoldCoin;

GoldCoin;

GoldCoin;

GoldCoin;

GoldCoin;

/* achievement for obtaining a gold coin */

goldCoinAchievement: Achievement

    "obtaining <<spellInt(scoreCount)>> gold coin<<

      scoreCount > 1 ? 's' : ''>>"

    /* 

     *   we're worth two points, and we can be awarded up to five times

     *   (one time per gold coin), for a total of ten points 

     */

    points = 2

    maxPoints = 10

;

ironKey: Key 'iron key*keys' 'iron key' @livingRoom

    "It's an ordinary iron key. "

;

brassKey: Key 'brass key*keys' 'brass key' @livingRoom

    "It's an ordinary brass key. "

;

rustyKey: Key 'rusty key*keys' 'rusty key' @livingRoom

    "It's an ordinary rusty key. "

;

/*

 *   Note that we don't have to define any vocabulary for the player

 *   character, since the library automatically defines the appropriate

 *   pronouns for any actor being used as the player character.  The

 *   pronoun selection is automatic and dynamic, so if we change to

 *   another player character later, the pronouns will all switch

 *   automatically at the same time.  

 */

me: Person

    location = livingRoom

    bulkCapacity = 5 // to force lots of bag-of-holding shuffling, for testing

//  referralPerson = firstPerson

    /* 

     *   When we issue a series of commands to another actor, we can wait

     *   until the entire series finishes before we take another turn.

     *   Set this flag to true to wait, or nil to allow us to take turns

     *   while the other actor carries out our orders. 

     */

    issueCommandsSynchronously = true

;

+ duffel: BagOfHolding, Openable, Container 'duffel bag' 'duffel bag'

    "It's a really capacious bag. "

;

+ keyring: Keyring 'key ring/keyring' 'keyring'

;

bob: Person 'bob' 'Bob' @livingRoom

    isProperName = true

    isHim = true

    /* obey any command from any other character */

    obeyCommand(issuer, action) { return true; }

    /* 

     *   We want to be able to follow other actors if requested, so keep

     *   track of departure data.  NPC's don't track departure information

     *   by default, because most NPC's never need it, and tracking it

     *   consumes a little extra time and memory.  

     */

    wantsFollowInfo(obj) { return true; }

;

/*

 *   Respond to any ASK ABOUT topic with a generic message incorporating

 *   the tokens from the topic.  

 */

+ DefaultAskTopic

    "<q>Ah, yes, <<gTopic.getTopicText()>>, very interesting...</q> "

;

+ GiveTopic

    matchTopic(fromActor, obj)

    {

        /* we match any coin */

        return obj.ofKind(Coin) ? matchScore : nil;

    }

    handleTopic(fromActor, obj)

    {

        /* accept the coin into my actor's inventory */

        obj.moveInto(getActor());

        /* add our special report */

        gTranscript.addReport(new AcceptCoinReport(obj));

        /* register for collective handling at the end of the command */

        gAction.callAfterActionMain(self);

    }

    afterActionMain()

    {

        /*

         *   adjust the transcript by summarizing consecutive coin

         *   acceptance reports 

         */

        gTranscript.summarizeAction(

            {x: x.ofKind(AcceptCoinReport)},

            {vec: '\^' + getActor().theName + ' accepts the '

                  + spellInt(vec.length()) + ' coins. ' });

    }

;

+ AskForTopic [ironKey, brassKey, rustyKey]

    handleTopic(fromActor, topic)

    {

        "<q>So, you want a key, do you? Let's see... ";

        SimpleLister.showSimpleList(topic.inScopeList + topic.likelyList);

        "...</q>";

    }

;

class AcceptCoinReport: MainCommandReport

    construct(obj)

    {

        /* remember the coin we accepted */

        coinObj = obj;

        /* inherit the default handling */

        gMessageParams(obj);

        inherited('Bob accepts {the obj/him}. ');

    }

    /* my coin object */

    coinObj = nil

;

bill: Person 'bill' 'Bill' @livingRoom

    isProperName = true

    isHim = true

    obeyCommand(issuer, action) { return true; }

    wantsFollowInfo(obj) { return true; }

    /* 

     *   Make Bill go after Bob.  This normally wouldn't be important,

     *   since the relative order of actor turns is usually arbitrary, but

     *   we want our test scripts to be stable so we establish a fixed

     *   order.  We accomplish the order adjustment simply by giving Bill a

     *   slightly higher schedule order than the default.  

     */

    calcScheduleOrder()

    {

        inherited();

        scheduleOrder += 1;

    }

;

livingRoom: HouseRoom

    roomName = 'Living Room'

    destName = 'the living room'

    desc = "It's a nice, big room.  A potted plant is the only attempt

            at decoration.  Passages lead north, east, and west.

            To the south, the front door of the house

            leads outside. "

    north = diningRoom

    east = den

    south = frontDoor

    out asExit(south)

    west = platformRoom

;

+ tricycle: Vehicle, BasicChair 'tricycle/trike' 'tricycle'

    "It's a child's three-wheeled bike. "

    gaveInstructions = nil

    allowedPostures = [sitting]

    /*

     *   Customize the travel arrival/departure messages for certain types

     *   of connectors.  The default message is of the form "The tricycle

     *   (carrying whoever) arrives from the east."  This isn't great for

     *   the tricycle, which only carries one rider, and which only goes

     *   when the rider makes it go; a better message would be "Bob rides

     *   the tricycle in from the east," which better captures that the

     *   rider is the one making the tricycle go somewhere.  

     */

    sayArrivingDir(dir, conn)

    {

        local actor = getTravelerActors()[1];

        "<<actor.name>> ride<<actor.verbEndingS>> in from the

        <<dir.name>> on a tricycle. ";

    }

    sayArrivingThroughPassage(conn)

    {

        local actor = getTravelerActors()[1];

        "<<actor.name>> ride<<actor.verbEndingS>> in through

        <<conn.theName>> on a tricycle. ";

    }

    sayDepartingDir(dir, conn)

    {

        local actor = getTravelerActors()[1];

        "<<actor.name>> ride<<actor.verbEndingS>> the tricycle off

        to the <<dir.name>>. ";

    }

    sayDepartingThroughPassage(conn)

    {

        local actor = getTravelerActors()[1];

        "<<actor.name>> ride<<actor.verbEndingS>> off

        through <<conn.theName>> on the tricycle. ";

    }

    dobjFor(Ride) asDobjFor(SitOn)

    dobjFor(SitOn)

    {

        check()

        {

            /* don't allow riding the tricycle except in the house */

            if (!gActor.location.getOutermostRoom().ofKind(HouseRoom))

            {

                reportFailure('{You/he} shouldn\'t ride {the dobj/him}

                    except in the house; {it dobj/he} might break. ');

                exit;

            }

        }

        action()

        {

            /* inherit the default handling */

            inherited();

            /* if we haven't given instructions previously, do so now */

            if (!gaveInstructions)

            {

                mainReport('Okay, {you\'re} now on the tricycle.  {You/he}

                    can probably manage to ride around on it if

                    {it/he} tr{ies}; just say the direction you\'d like '

                    + (gActor.isPlayerChar ? '' : '{it/him}') + ' to go. ');

                gaveInstructions = true;

            }

        }

    }

    dobjFor(Eat) { verify() { } action() { "{You/he} eat{s} {your} tricycle. "; } }

;

+ frontDoor: Door 'front door' 'front door'

    "It leads outside to the south. "

    travelBarrier = [tricycleBarrier, tvBarrier]

;

+ Decoration

    'potted plant small green clay plant/tree/pot/leaf/leaves/dirt/soil'

    'potted plant'

    "It's a tree with small green leaves, about six feet tall and

    growing in a clay pot filled with soil. "

;

+ television: TravelPushable

    'old huge boxy model/unit/television/tv' 'television'

    "It's an old, huge, boxy model, certainly black-and-white.  The

    bulbous picture tube shows no sign of life.  Two dials control

    the channel selection (it looks like it's currently <<curChannel>>),

    but the channel setting hardly matters when the set doesn't work

    in the first place.  It seems to be on small casters, which is

    a good thing given how big it is and how heavy it looks. "

    specialDesc = "An old television, a huge, boxy, massive-looking thing,

                   sits on the floor. "

    specialNominalRoomPartLocation = defaultFloor

    curChannel()

    {

        if (upperDial.curSetting == 'UHF')

            return lowerDial.curSetting;

        else

            return upperDial.curSetting;

    }

;

++ Decoration 'casters' 'casters'

    "Small wheels, intended to make it easier to move the unit's

    huge bulk around the house. "

;

++ Decoration 'bulbous picture tube/screen' 'picture tube'

    "It shows no pictures. ";

++ upperDial: NumberedDial, Component

    'upper tv television channel dial*dials' 'upper dial'

    "This is the VHF selector dial; it can be set to a channel from 2

    through 13, or to the additional stop marked \"UHF\". It's

    currently set to <<curSetting>>. "

   minSetting = 2

   maxSetting = 13

   curSetting = 8

   isValidSetting(val)

   {

       /* allow the special 'uhf' setting in addition to the numbers */

       if (val.toLower() == 'uhf')

           return true;

       /* inherit the default handling to check the numbered settings */

       return inherited(val);

   }

   makeSetting(val)

   {

       /* if the setting is 'uhf', change it to all caps */

       if (val.toLower() == 'uhf')

           val = 'UHF';

       /* inherit default handling with the (possibly) adjusted value */

       inherited(val);

   }

;

++ lowerDial: NumberedDial, Component

    'lower tv television channel dial*dials' 'lower dial'

    "This is the UHF selector dial; it can be set to a channel from

    14 through 82.  It's currently set to <<curSetting>>.  You probably

    have to turn the upper dial to \"UHF\" for this dial's setting

    to have any effect. "

    minSetting = 14

    maxSetting = 82

    curSetting = 44

;

+ Consultable 'phone book' 'phone book'

    "You can probably look up people you know in here. "

;

++ ConsultTopic @bob "Bob's number is (415)555-1212. ";

++ ConsultTopic @bill "Bill's number is (650)555-1212. ";

++ ConsultTopic @salesman "Ron's number is (510)555-1212. ";

++ ConsultTopic @insCompany

    "<q>Actuarial Life Insurance Company!  Call for best rates!

    (800)555-1212!</q> "

;

++ DefaultConsultTopic "You can't find any such listing. ";

/* ------------------------------------------------------------------------ */

/*

 *   Platform room 

 */

platformRoom: HouseRoom 'Platform Room' 'the platform room'

    "This room is obviously highly contrived.  Filling one end of the

    room is a platform, almost like a theater stage, raised a couple of

    feet above the floor.  At opposite ends of the 

    platform are two smaller platforms, one red and one blue; 

    atop each smaller platform is a chair of the same color as its platform.

    In the center of the main platform is a raised dais, upon which

    <<stool.isDirectlyIn(dais) ? "are a wooden stool and" : "is">> a

    leather armchair.

    <.p>The only exit is east. "

    east = livingRoom

    down = (whiteBox.isOpen ? whiteBox.down : nil)

;

+ Fixture, Platform

    'main theater theatre platform/stage*platforms' 'main platform'

;

++whiteBox: Openable, Booth 'large white cardboard box' 'white box'

    useInitSpecialDesc()

    {

        /* show our initial description only when the actor isn't in me */

        return inherited() && !gActor.isIn(self);

    }

    initSpecialDesc = "On the main platform is a large white box,

        about waist high and quite roomy. "

    /* don't mention our contents if we're using our initial description */

    contentsListed = (!useSpecialDesc())

    interiorDesc = "The box is roomy, but not enough that you can

                    stand up in it when it's closed. "

    down = whiteBoxTrapDoor

    /* make it paper, so we can hear through the box */

    material = paper

    /* 

     *   we can't stand up in the box when it's closed, so make the

     *   default posture sitting 

     */

    defaultPosture = (isOpen ? standing : sitting)

    /* we can't close the box when someone's standing in it */

    makeOpen(stat)

    {

        /* if we're closing the box, check to make sure we're allowed to */

        if (!stat)

        {

            /* 

             *   We're trying to close the box; if anyone's standing in

             *   the box, don't allow it. 

             */

            foreach (local cur in allContents())

            {

                /* if this is a standing actor, disallow closure */

                if (cur.isActor && cur.posture == standing)

                {

                    /* 

                     *   we can't close - issue a failure report and

                     *   terminate the command 

                     */

                    reportFailure('{You/he} cannot close the box while

                        anyone is standing in it. ');

                    exit;

                }

            }

        }

        /* no problems - inherit default handling */

        inherited(stat);

    }

    /* 

     *   if they try to stand within a nested room within us, mention that

     *   they can only sit 

     */

    roomBeforeAction()

    {

        /* 

         *   If we're closed, and the action is 'stand', and they're

         *   something nested within me, mention after the fact that

         *   there's no room to stand up.  We need to mention this, but we

         *   do not need to enforce the constraint here because the nested

         *   room will set our default sitting posture when moving an

         *   actor from an interior location.  

         */

        if (!isOpen

            && gActionIs(Stand)

            && gActor.isIn(self)

            && !gActor.isDirectlyIn(self))

            reportAfter('There isn\'t room to stand up in here, so

                {you/he} sit{s} in the box. ');

    }

    /* enforce the low headroom when the box is closed */

    makeStandingUp()

    {

        if (isOpen)

        {

            /* we're open, so proceed as normal */

            inherited();

        }

        else

        {

            /* the box is closed, so they can't stand up */

            reportFailure('There\'s not enough room to stand up in

                the box while it\'s closed. ');

        }

    }

;

+++ whiteBoxTrapDoor: Fixture, Door -> tunnelTrapDoor

    'small trap door' 'trap door'

    "It's set into the floor of the box; it looks just large enough

    for you to fit through. "

    /* 

     *   list me *after* the room's contents, since the box is sometimes

     *   listed with the room's contents 

     */

    specialDescBeforeContents = nil

    initSpecialDesc = "A small trap door is set into the floor of the box. "

    /* don't require standing up before entering the trap door */

    actorTravelPreCond(actor) { return []; }

    enteredBefore = nil

    dobjFor(TravelVia)

    {

        action()

        {

            /* mention the ladder below */

            if (enteredBefore)

                "You find the ladder below and climb down. ";

            else

            {

                "You tentatively lower yourself through the door, and

                manage to find what feels like a ladder below, so you

                carefully climb down. ";

                enteredBefore = true;

            }

            /* inherit the default handling */

            inherited();

        }

    }

;

+++ Switch 'small black plastic beeper pager box/beeper/pager/switch' 'beeper'

    "It's a small black plastic box with a single red light

    (which is currently <<isOn ? 'lit' : 'off'>>) and a

    switch (currently <<isOn ? 'on' : 'off'>>). "

    /* 

     *   if they know about us, they'll recognize our beeping, so they'll

     *   want to be able to refer to the beeper itself; thus, give the

     *   beeper a sound presence once it's been seen 

     */

    soundPresence = (isOn && seen)

    isOn = true

    makeOn(val)

    {

        /* inherit the default handling */

        inherited(val);

        /* add/remove our beeping sound, as appropriate */

        beeperNoise.moveInto(val ? self : nil);

    }

;

++++ Component 'tiny small red beeper light' 'beeper light'

    "It's a tiny red light, currently <<location.isOn ? 'lit' : 'off'>>. "

;

++++ beeperNoise: Noise

    'piercing high-pitched high pitched beeping sound/noise/beep'

    'beeping sound'

    sourceDesc = "The beeper is making a piercing, high-pitched beeping

                  noise. "

    descWithSource = "The beeper is beeping, which is what they do. "

    descWithoutSource = "It's a piercing, high-pitched beeping noise. "

    hereWithSource = "The beeper is making a piercing beeping noise. "

    hereWithoutSource = "You can hear a high-pitched beeping noise. "

    displaySchedule = [2, 4]

;

++ Fixture, Platform 'small smaller red platform*platforms' 'red platform'

;

class PlatformChair: Chair

    dobjFor(SitOn)

    {

        verify()

        {

            /* inherit default */

            inherited();

            /* 

             *   if they're directly in my location, and my location is a

             *   nested room of some kind, boost likelihood that this is