# newbie.t | documentation

    #charset "us-ascii"
    #include "advlite.h"

    /*
     *   ****************************************************************************
     *    newbie.t
     *    This module forms part of the adv3Lite library
     *    (c) 2012-13 Eric Eve
     */
    #include "advlite.h"

    /*
     *   Many of the ideas in this file are based on Emily Short's
     *   NewbieGrammar.h extension for Inform 6, itself based on observation of
     *   some of the non-standard things newcomers to IF tend to type. The idea
     *   is to get the parser to recognize these commands, at least to the
     *   extent of giving the player who issues them some help towards typing
     *   more useful commands rather than giving a standard (and probably
     *   unhelpful) parser error message
     *
     *   We also provide some helpful brief IF playing instructions for newbies,
     *   a sample transcript they can view to get the general idea, and a
     *   mechanism to check whether someone is entering an excessive number of
     *   invalid commands (so that we can then offer more help).
     */

    helpMessage: object
        printMsg {
            "<<if defined(Instructions)>>If you\'re new to interactive fiction, you
            can type <<aHref('INSTRUCTIONS', 'INSTRUCTIONS', 'Show full
                instructions')>> at the prompt for a full explanation of how to
            interact with the software and the story; for<<else>>For<<end>> a brief
            introduction to playing this type of game type <<aHref('INTRO', 'INTRO',
                'Show a brief introduction')>>, or <<aHref('SAMPLE', 'SAMPLE', 'Show
                    a short sample transcript')>> to show a short sample transcript.
            <<if gHintManager != nil>>If you\'re having trouble moving forward and
            need help solving a puzzle, type <<aHref('HINT', 'HINT', 'Show
                hints')>>.<<end>> ";

            if(defined(extraHintManager))
               extraHintManager.explainExtraHints();

            if(versionInfo.propDefined(&showAbout, PropDefDirectly))
               "For more information specific to this game, type <<aHref('ABOUT',
                   'ABOUT', 'Show information about this game')>>. ";
        }

        briefIntro()
        {
            "You play this kind of game by entering brief commands (try to use as
            few words as possible). Examples include:\b
            WEST\n
            X KEYS\n
            TAKE BOOK\n
            READ BOOK\n
            DROP BOOK\n
            PUT BOOK ON TABLE\n
            OPEN DOOR\b
            To move around use compass directions: NORTH, EAST, SOUTH etc. These may
            be abbreviated to N, E, S, W, NE, NW, SE, SW.
            You can also use IN, OUT, UP and DOWN.\b
            EXAMINE (= LOOK AT) can be abbreviated to X; X BOOK, EXAMINE BOOK and
            LOOK AT BOOK all mean the same thing.\b
            The command INVENTORY (or simply I) will give you a list of what you're
            carrying.\n
            Use LOOK or L to repeat the description of your current location.\n
            AGAIN or G repeats the previous command.\b
            For full instructions, use the <<aHref('INSTRUCTIONS', 'INSTRUCTIONS',
                                                  'Show full Instructions')>>
            command.\n
            To see a sample transcript, use the <<aHref('SAMPLE', 'SAMPLE', 'See
                sample transcript')>> command. ";
        }

        showSample()
        {
            "A typical game (not this particular one) might start something like
            this:\b";
            inputManager.pauseForMore();
            "<b>>x me</b>\n
            You\'re a handsome enough young lad.\b
            <b>>i</b>\n
            You're carrying a flashlight and a treasure map.\b
            <b>>x map</b>\n
            So far as you can tell, the map indicates that some treasure was hidden
            underground somewhere on Horatio Bumblespoon\'s property.\b
            <b>>l</b>\n
            <b>Bumblespoon's Back Yard</b>\n
            Suffering from years of neglect, this back yard has been thoroughly
            overgrown with a tangle of weeds and briars. A path leads north round
            the side of the house, and you can just make out a narrow staircase
            leading down into the darkness.\b
            <b>>x weeds</b>\n
            The weeds aren\'t important.\b
            <b>>down</b>\n
            <b>In the Dark</b>\n
            It is pitch dark in here.\b
            <b>>switch on flashlight</b>\n
            <b>Damp Cellar</b>\n
            Green mould covers the walls, and a pile of rusty junk clutters one
            corner. The only way out appears to be back up the stairs.\b
            <b>>x junk</b>\n
            It\'s mostly bits of broken gardening equipment, together with the
            remains of a metal bed-frame. But underneath it all you can just make
            out what looks like a large chest.\b
            <b>>x chest</b>\n
            It\'s a large wooden chest, reinforced with steel bands. It\'s closed.\b
            <b>>open chest</b>\n
            You can\'t really get at it with all that junk in the way.\b
            <b>>move junk</b>\n
            You manage to move quite a bit of the junk, clearing your access to
            the wooden chest beneath.\b
            <b>>open chest</b>\n
            (first trying to unlock the wooden chest)\n
            The wooden chest seems to be locked.\b
            <b>>unlock chest</b>\n
            What do you want to unlock it with?\b
            <b>>key</b>\n
            You see no key here.\b
            At this point the player knows he or she has to go in search of the key,
            and presumably that\'s how this game would continue.\b";
            inputManager.pauseForMore();
            "And now back to the game you\'re actually playing....\b";
            gPlayerChar.getOutermostRoom.lookAroundWithin();

        }
    ;

    /* Declare these two properties in case the hintsys module isn't present */
    property extraHintsExist;
    property explainExtraHints;

     /*
      *   The playerHelper is an object that starts a daemon at start of play.
      *   This daemon checks whether the player is making any progress at all,
      *   and also watches the ratio of commands the parser rejects to the
      *   number of turns. If this ratio becomes too high (as defined by the
      *   errorThreshold property) we offer the player a HELP command. If it
      *   becomes very low (as defined by the ceaseCheckingErrorLevel property)
      *   we cease checking (i.e. stop the daemon) on the grounds that the
      *   player doesn't appear to need the kind of help we want to offer. We
      *   first perform a check after firstCheckAfter turns to see if the player
      *   is making any progress, and then after each errorCheckInterval turns
      *   to see if the player is having difficulty entering valid commands.
      *
      *   The idea is to keep offering HELP to an inexperienced player who
      *   clearly needs it, even if the player declined to read any help text at
      *   the start of the game.
      */
    playerHelper: InitObject

        /*
         *   Set up the firstCheck() Fuse and note the player character's starting
         *   location.
         */
        execute()
        {
            new Fuse(self, &firstCheck, firstCheckAfter);

            startLocation = gPlayerChar.location;
        }

        /*
         *   The location the playerCharacter starts out in at the beginning of the
         *   game. It may be useful to know this in the firstCheckCriterion method.
         */
        startLocation = nil

        /*
         *   The number of turns that must elapse before we test the
         *   firstCheckCriterion to see if the player appears to be stuck.
         */
        firstCheckAfter = 10

        /*
         *   The message to display if the player seems to be stuck at the start of
         *   the game.
         */
        firstCheckMsg =  "<.p>You don't seem to be making much progress. If you
            feel you could use a little help, enter the
            command <<aHref('HELP', 'HELP', 'Requesting help')>>. "

        /*
         *   The number of turns between each check on whether the player is
         *   entering too many erroneous commands.
         */
        errorCheckInterval = 20

        /*
         *   The proportion of rejected commands to turns (i.e. accepted
         *   commands) that will trigger an offer of help. We express this
         *   number as a percentage.
         */
        errorThreshold = 50

        /*
         *   The proportion of rejected commands to turns, expressed as a
         *   percentage, below which we stop checking for errors. The default is 5
         *   (in other words if less than 5 per cent of the player's commands are
         *   being rejected, the player presumably knows what s/he's doing, so we
         *   don't need to keep checking)
         */
        ceaseCheckingErrorLevel = 5

        /*
         *   The criterion to apply to see whether the player is making any progress
         *   at the start of the game. This method should return true if the player
         *   seems to be stuck. By default we simply return nil as there's no way of
         *   knowing how to measure 'stuckness' for games in general, so specific
         *   games will need to override this method. A game involved exploration
         *   might set the condition to gLocation == startLocation (meaning the
         *   player character hasn't moved) for example.
         */
        firstCheckCriterion()
        {
            return nil;
        }

        /*
         *   Check whether the player appears to be making any progress at the start
         *   of the game. If not, display a message offering help and start the
         *   error checking daemon.
         */
        firstCheck()
        {
            /*
             *   If the player is still in the starting location (and so hasn't
             *   visited the endOfDriveway, which would trigger its doScript
             *   method) after 5 turns, s/he may be a novice who's getting stuck,
             *   so we'll offer help.
             */
            if(firstCheckCriterion())
            {
                /* Display a message offering help. */
                firstCheckMsg;
                /*
                 *   We've just offered help, so we'll wait another
                 *   errorCheckInterval turns before seeing whether to offer it
                 *   again.
                 */
                new Fuse(self, &startErrorDaemon, errorCheckInterval);
            }
            else
                startErrorDaemon();
        }

        startErrorDaemon() { errorDaemonID = new Daemon(self, &errorCheck, 1); }

        /* Watch for a high percentage of errors in user input */
        errorCheck()
        {
            local errorPercent = (100 * errorCount)/libGlobal.totalTurns;

            if(errorPercent > errorThreshold)
            {
                "<.p>Please type <<aHref('HELP', 'HELP', 'Requesting help')>> if you
                need help with this game.<.p>";
                /*
                 *   We don't want to keep showing this message every turn, so
                 *   we'll turn the daemon off for twenty turns.
                 */

                stopErrorDaemon();
                new Fuse(self, &startErrorDaemon, errorCheckInterval);

            }

            /*
             *   If there are very few input errors, we're probably not needed
             *   any more
             */
            if(errorPercent < ceaseCheckingErrorLevel)
                stopErrorDaemon();

        }

        /* Stop the error check daemon from running */
        stopErrorDaemon()
        {
            if(errorDaemonID != nil)
                errorDaemonID.removeEvent();

            errorDaemonID = nil;
        }

        /*
         *   The offerHelp() method asks whether the player has played this kind of
         *   game before and accepts a Y or N answer. if the answer is NO then it
         *   goes on to display a message suggesting sources of help.
         *
         *   This method can usefully be called at the end of the
         *   gameMain.showIntro() method, but it's up to game authors to incluse it
         *   there if they want it/
         */
        offerHelp()
        {
            "Have you played this kind of game before? (<b>y</b> or <b>n</b>) >";
            if(!yesOrNo())
            {
                "\b";
                helpMessage.printMsg();
            }
            "\b";
        }

        /*
         *   For internal use only: the ID of the currently running error check
         *   Daemon (if there is one)
         */
        errorDaemonID = nil

        /*
         *   For internal use only: the number of badly formed commands the player
         *   has entered.
         */
        errorCount = 0
    ;

    /*
     *   This game may be played by novice players. We'll try to keep track of
     *   how many not-understood commands they enter, in case it helps us decide
     *   whether they need help. The playerHelper object will use this
     *   information to decide whether to offer help.
     */

    modify NotUnderstoodError
        display()
        {
            inherited;
            playerHelper.errorCount++;
        }
    ;

    modify UnknownWordError
        display()
        {
            inherited;
            playerHelper.errorCount++;
        }
    ;

    modify EmptyNounError
        display()
        {
            inherited;
            playerHelper.errorCount++;
        }
    ;

    //-------------------------------------------------------------------------------
    /*
     *   More newbie-helpful bits and pieces, based on work by Emily Short for I6
     *
     *   The idea is to trap the kind of invalid input a newcomer to IF might
     *   type and respond with something a bit more helpful than a standard
     *   parser error message. In some cases we'll execute the command the
     *   player probably meant, and in others we'll just explain why the command
     *   failed.
     */

    /*  First, trap attempts to refer to body parts */

    bodyParts: MultiLoc, Unthing 'body; (my) (your) (his) (her) (this) (left)
        (right); head hand ear fist finger thumb arm leg foot eye face nose mouth
        tooth tongue lip knee elbow; it them'

        notHereMsg = 'Generally speaking, there is no need to refer to your
            body parts individually in interactive fiction.  WEAR SHOES ON FEET will
            not necessarily be implemented, for instance; WEAR SHOES is enough.  And
            unless you get some hint to the contrary, you probably cannot OPEN DOOR
            WITH FOOT or PUT THE SAPPHIRE RING IN MY MOUTH. '

        initialLocationClass = Room

    ;

    /* Trap the use of vague words like 'someone' or 'something' or 'anyone' */
    somethingPreParser: StringPreParser
        doParsing(str, which)
        {
            local ret = rexSearch(pat, str);
            if(ret != nil)
            {
                /* first check whether the word occurs in the dictionary */
                local lst = cmdDict.findWord(ret[3]);

                /* then see if it matches any objects in scope. */
                lst = lst.intersect(Q.scopeList(gPlayerChar));

                /* if not, display a helpful message */
                if(lst.length == 0)
                {
                    "It's usually better not to use vague words like
                    <q><<ret[3]>></q> in your commands, because the game won't be
                    able to guess what you mean. Be more specific and refer to the
                    objects in your vicinity. ";
                    playerHelper.errorCount++;
                    return nil;
                }
            }
            return str;
        }
        pat = static new RexPattern('<NoCase>(someone|something|anyone|anything)')

       isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    /*
     *   Trap commands like LOOK HERE or SEARCH THERE. We'll actually carry out
     *   a LOOK command, but we'll also tell the player just to use LOOK in
     *   future.
     */
    DefineIAction(LookHere)
        execAction(cmd)
        {
            gActor.getOutermostRoom.lookAroundWithin();
            playerHelper.errorCount++;
            "<.p>[For future reference, you don't need to refer to places in the
            game with words like <q><<cmd.verbProd.placeName>></q>; a simple LOOK
            command will suffice]<.p>";
        }
    ;

    VerbRule(LookHere)
        ('l' | 'look' | 'search') ('here'->placeName|'there'->placeName)
        : VerbProduction
        action = LookHere
        verbPhrase = 'look/looking'
    ;

    /*
     *   Trap the words KINDLY and PLEASE in a player's command, and explain that
     *   they shouldn't be used, giving examples of the kind of commands to use
     *   instead. (But don't do this in conversation, where these words might be
     *   part of valid conversational exchange)
     */
    pleasePreParser: StringPreParser
        doParsing(str, which)
        {
            if(rexMatch(pat, str) && gPlayerChar.currentInterlocutor == nil)
            {
                "That's very polite of you, but there's really no need to use words
                like <q>please</q> and <q>kindly</q>; you'll find the game
                will understand you far better if you stick to simple imperatives
                like GO NORTH, or X KEYS or PUT BOX ON TABLE. <.p>";
                playerHelper.errorCount++;
                return nil;
            }
            return str;
        }
        pat = static new RexPattern('<NoCase>%<(please|kindly)%>')
    ;

    /*
     *   Trap any command beginning with USE, telling the player to be more specific, unless the game
     *   code defines its own Use action.
     */
    usePreParser: StringPreParser
        doParsing (str, which)
        {
            if(str.toLower.startsWith('use ') && !(defined(Use) && Use.ofKind(Action)))
            {
                "<.p>I don't recognize the command USE, because it's a bit too
                vague; please be more specific about what you want to do.<.p>";
                playerHelper.errorCount++;
                return nil;
            }

            return str;
        }
    ;

    /*
     *   Trap commands like KEEP GOING NORTH or CONTINUE HEADING WEST. We'll
     *   carry out the directional movement command obviously intended, but
     *   advise the player on the standard form of such commands.
    // */
    KeepGoing: TravelAction
        execAction(cmd)
        {
            local action = Go.createInstance();
            cmd.dobj = cmd.verbProd.dirMatch.dir;

            action.execAction(cmd);
            "[In most Interactive Fiction, it is necessary as well as easier to
            phrase commands like this as simple directions: GO NORTH, NORTH (or
            just N), etc., rather than KEEP GOING NORTH, HEAD BACK NORTH,
            etc.]<.p>";
        }
    ;

    VerbRule(KeepGoing)
        ('keep' | 'continue') ('going'|'walking'|'running'|'heading') singleDir
        | 'head' ('back' | ) singleDir
        : VerbProduction
        action = KeepGoing
        verbPhrase = 'go/going (where)'
    ;

    /*
     *   Trap commands that start with a pronoun (e.g. I AM LOST or YOU ARE SILLY)
     *   and advise the player that they are likely to be unproductive, suggesting
     *   the format of commands that are more likely to work.
     *
     *   Note that we have to make exceptions that allow valid commands starting
     *   with I where I is an abbreviation for INVENTORY, such as I itself, I TALL
     *   and I WIDE. We also have to make exceptions when a conversation is in
     *   progress, since the command could be a valid SayTopic.
     */
    pronounUsePreParser: StringPreParser
        doParsing(str, which)
        {
            if(rexMatch(pat3, str) || gPlayerChar.currentInterlocutor != nil)
                return str;

            if(rexMatch(pat, str) || rexMatch(pat2, str))
            {
                "If the game is not understanding you, try issuing your commands in
                the imperative: e.g., THROW THE KNIFE, but not I WOULD REALLY LIKE
                TO THROW THE KNIFE.  Chatty sentences such as YOU ARE A VERY STUPID
                GAME will only prove themselves true.\b
                If you really feel that the game is looking for a word that is not
                a verb (as the solution to a riddle, eg.) try some variations, such
                as SAY FLOOBLE.\b
                If you need more help, try the <<aHref('HELP','HELP', 'Ask for
                    help')>> command.<.p>";
                playerHelper.errorCount++;
                return nil;
            }
            return str;
        }
        pat = static new RexPattern('<NoCase>^(you|he|she|it|they|we|its|theyre'
                                    + '|youre|hes|shes)<Space|squote>')

        pat2 = static new RexPattern('<NoCase>^(i|im|i<squote>m)<Space>+%w')

        pat3 = static new RexPattern('<NoCase>^i<Space>+(wide|tall)')
    ;

    /*
     *   Trap commands like WHERE CAN I GET HELP. Print a suitable Help message,
     *   and then explain the use of the HELP command.
     */
    DefineSystemAction(WhereHelp)
        execAction(cmd)
        {
            "[A simple HELP would do]<.p>";
            helpMessage.printMsg();
        }
    ;

    VerbRule(WhereHelp)
        'where' ('can' | 'do' | 'does' | 'should')
        ('i' | 'we' | 'one' | 'anyone'| 'someone')
        ('get' | 'find' | 'obtain')
        ('help' | 'assistance' | 'instructions')
        (literalDobj | )
        : VerbProduction
        action = WhereHelp
        verbPhrase = 'request/requesting help'
        priority = 80

        /*
         *   Don't match this grammar if the player char is in conversation, since
         *   in that case the player may be attempting a valid conversational
         *   command)
         */
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    DefineSystemAction(Help)
        execAction(cmd)   {   helpMessage.printMsg();   }
    ;

    /* Provide grammar to understand a fairly wide variety of requests for help */

    VerbRule(Help)
        ('help' | 'assist' | 'assistance' ) |
        'how' ('do' | 'can' | 'does' | 'will' | 'shall' | 'could' | 'should' | 'may'
               | 'must')
        ('i' | 'me' | 'he' | 'she' | 'it' | 'we' | 'you' | 'they' | 'person' | 'one'
         | 'someone' | 'anyone' | 'somebody' | 'anybody') literalDobj

        : VerbProduction
        action = Help
        verbPhrase = 'help/helping with the software'

        priority = 80

        /*
         *   Don't match this grammar if the player char is in conversation, since
         *   in that case the player may be attempting a valid conversational
         *   command)
         */
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    VerbRule(WhatNext)
        'what' ('next' | 'now') |
        'what' ('should' | 'can' | 'do' | 'does' | 'am' | 'is')
        ('i' | 'one' |'anyone' | 'someone')
        (('meant' 'to')|) ('do' | 'try') ('next' | 'now'|)
        : VerbProduction
        action = Help
        verbPhrase = 'help/helping with the software'

        priority = 80

        /*
         *   Don't match this grammar if the player char is in conversation, since
         *   in that case the player may be attempting a valid conversational
         *   command)
         */
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    /*
     *   Provide a command to display a brief introduction to playing IF (as an
     *   alternative to the full INSTRUCTIONS menu provided by the TADS 3 library)
     */
    DefineSystemAction(Intro)
        execAction(cmd) { helpMessage.briefIntro(); }
    ;

    VerbRule(Intro)
        ('show'|'view'|) ('brief'|) ('intro' | 'introduction')
        : VerbProduction
        action = Intro
        verbPhrase = 'show/showing brief introduction'
    ;

    /* Provide a command to show the player a sample transcript */
    DefineSystemAction(Sample)
        execAction(cmd) { helpMessage.showSample(); }
    ;

    VerbRule(Sample)
        ('show'|'view'|) 'sample' ('transcript' | )
        : VerbProduction
        action = Sample
        verbPhrase = 'show/showing sample transcript'
    ;

    /*
     *   Make WHAT IS X behave like EXAMINE X, but then explain the standard
     *   phrasing of an EXAMINE command.
     */

    VerbRule(WhatIsNoun)
        ('whats' | 'what' ('is'|'are')) multiDobj
        : VerbProduction
        action = Examine
        verbPhrase = 'examine/examining (what)'

        priority = 80

        /*
         *   Don't match this grammar if the player char is in conversation, since
         *   in that case the player may be attempting a valid conversational
         *   command)
         */
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    modify Examine
        execAction(cmd)
        {
            inherited(cmd);
            if(cmd.verbProd.grammarTag == 'WhatIsNoun')
            {
                local obj = cmd.dobj;
                "[You can do this in future by using <<aHref('X '+ obj.name.toUpper,
                    'X ' + obj.name.toUpper, 'Examine ' + obj.theName)>>, which is
                quicker and more standard.]\b";
                playerHelper.errorCount++;
            }
        }
    ;

    /*
     *   Trap variants on WHAT AM I CARRYING that should be turned into an INVENTORY
     *   command.
     */

    VerbRule(WhatAmICarrying)
        'what' ('am'|'are') ('i'|'we'|'you') ('carrying' | 'holding')
        | 'what' 'do' ('i'|'we'|'you') 'have'
        | 'what' 'have' ('i'|'we'|'you') 'got'
        : VerbProduction
        action = Inventory
        verbPhrase = 'take/taking inventory'
        priority = 80
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    modify Inventory
        execAction(cmd)
        {
            inherited(cmd);
            if(cmd.verbProd.grammarTag == 'WhatAmICarrying')
            {
                "[You can do this in future by using <<aHref('INVENTORY',
                    'INVENTORY', 'Take Inventory')>> or just
                <<aHref('I', 'I', 'Take Inventory')>>, which is
                quicker and more standard.]\b";
                playerHelper.errorCount++;
            }
        }
    ;

    /*
     *   Trap a variety of commands of the sort WHAT IS GAME ABOUT or WHATS THE
     *   POINT and respond by showing the game's ABOUT text.
     */
    VerbRule(WhatsThePoint)
        ('whats' | 'what' 'is') ('the'|) ('point' | 'idea' | 'goal' | 'purpose')
        (literalDobj | )
        : VerbProduction
        action = About
        verbPhrase = 'ask/asking about the point of the game'

        priority = 80

        /*
         *   Don't match this grammar if the player char is in conversation, since
         *   in that case the player may be attempting a valid conversational
         *   command)
         */
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    VerbRule(WhatThisGame)
        ('whats' | 'what' ('is'|'are')) ('the' | 'these' | 'this' |)
        ('game' | 'story' | 'program' | 'games' | ('interactive' 'fiction'))
            ('for' | 'about' | )
        : VerbProduction
        action = About
        verbPhrase = 'ask/asking what the game is about'

        priority = 80

        /*
         *   Don't match this grammar if the player char is in conversation, since
         *   in that case the player may be attempting a valid conversational
         *   command)
         */
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    /*
     *   Trap a variety of vague travel commands like GO SOMEWHERE or WALK
     *   AROUND or TURN RIGHT and explain how movement commands should be
     *   phrased. Then display a list of available exits from the current
     *   location.
     */
    DefineIAction(GoSomewhere)
        execAction(cmd)
        {
            "If you want to go somewhere, use one of the compass directions (NORTH,
            EAST, SW, W, S etc). ";

            playerHelper.errorCount++;

            if(defined(exitLister) &&
               exitLister.cannotGoShowExits(gActor, gActor.getOutermostRoom));
        }
        actionTime = 0
    ;

    VerbRule(GoSomewhere)
        (('go' | 'walk' |  'proceed' | 'run') ( | ('to' 'the') )
        ('left' | 'right' | 'on' | 'onwards' | 'onward' | 'forward' | 'forwards' |
         'around' | 'somewhere' | (('straight'| ) 'ahead'))) | ('turn'
             ('left'|'right'))
        : VerbProduction
        action = GoSomewhere
        verbPhrase = 'go/going somewhere'
    ;

    modify VagueTravel
        execAction(cmd)  {  delegated GoSomewhere(cmd);  }
    ;

    /*
     *   Trap commands like WHERE AM I or WHERE ARE WE or WHAT IS HERE. Perform
     *   a LOOK command but explain that LOOK is the phrasing to use.
     */
    DefineIAction(WhereAmI)
        execAction(cmd)
        {
            gActor.getOutermostRoom.lookAroundWithin();
            "<.p>[In future, just use the <<aHref('LOOK','LOOK', 'Look around')>>
            command]<.p>";
        }

    ;

    VerbRule(WhereAmI)
        'where' ('are' | 'am' | 'is') ('i' | 'we')
        : VerbProduction
        action = WhereAmI
        verbPhrase = 'look/looking'

        priority = 80
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    VerbRule(WhatsHere)
        'what' 'is' 'here'
        | 'whats' 'here'
        : VerbProduction
        action = WhereAmI
        verbPhrase = 'ask/asking what\'s here'

        priority = 80
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    /*
     *   Provide a response to WHO AM I. We provide a brief explanation and then
     *   perform an EXAMINE ME command to add any game-specific player character
     *   description.
     */
    DefineIAction(WhoAmI)
        execAction(cmd)
        {
            "[You're the main character of the game.  Of course, the game author
            may have given you a description.  You can see this description in the
            future by typing <<aHref('X ME','X ME','Examine me')>>], which is
            quicker and more standard.]\b";
            replaceAction(Examine, gPlayerChar);
            playerHelper.errorCount++;
        }
    ;

    VerbRule(WhoAmI)
        ('who'| 'what') ('am'|'is') ('i'|'me')
        : VerbProduction
        action = WhoAmI
        verbPhrase = 'ask/asking who I am'

        priority = 80
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    /*
     *   Trap commands like WHERE CAN I GO. Perform an EXITS command to list the
     *   exits, but then tell the player to use the wording EXITS in future.
     */
    DefineIAction(WhereGo)
        execAction(cmd)
        {
            nestedAction(Exits);
            "<.p>[In future, just use the EXITS command]<.p>";
        }
    ;

    VerbRule(WhereGo)
        'where' ('can' | 'do' | 'does' | 'should') ('i' | 'we' | 'one'| 'anyone')
        'go'
        : VerbProduction
        action = WhereGo
        verbPhrase = 'show/showing exits'

        priority = 80
        isActive = (gPlayerChar.currentInterlocutor == nil)
    ;

    /*
     *   The StringPreparser and the TopicAction which follows are designed to
     *   deal with command like LOOK FOR X, FIND Y or SEARCH FOR Z. The
     *   complication is that in the standard library these are all forms of
     *   LOOK UP X, which prompt the response "What do you want to look that up
     *   in?". This is likely to confuse new players.
     *
     *   The StringPreparser checks to see if there's a Consultable in the
     *   current location. If so, then we use the standard library handling, on
     *   the assumption that the player is trying to looking something up in it.
     *   If not we change the command to SEEK X in order to invoke the new
     *   SeekAction defined below.
     */

    seekPreParser: StringPreParser
        doParsing(str, which)
        {
            local doReplacement = true;

            if(defined(Consultable) && firstObj(Consultable))
            {
                doReplacement = nil;
            }

            if(doReplacement && rexMatch(pat, str))
               str = rexReplace(pat, str, 'seek', ReplaceOnce);

            return str;
        }
        pat = static new RexPattern('^<NoCase>(find|look for|search for|hunt for)')
    ;

    /*
     *   SeekAction is designed to handle of commands FIND X, LOOK FOR Y or
     *   SEARCH FOR Z, when they don't seem to be intended as attempts to look
     *   something up in a Consultable. We make it a TopicAction so that it will
     *   match whatever the player types, and so not give away any premature
     *   spoilery information by the nature of the parser's response.
     *
     *   The appropriate response then depends on the player character's state of
     *   knowledge. In the most general case the player is simply given
     *   instructions on how to go about looking for things. This hardly seems
     *   appropriate, however if the object requested is in plain sight, in
     *   which case we point this out to the player. As a courtesy to the
     *   player, we also remind him or her of where an object was last seen, if
     *   it has been seen.
     *
     *   One or two complications need to be dealt with. If the player finds
     *   something like FIND SMELL or FIND NOISE then we should describe it as
     *   having been smelt or heard elsewhere, not seen. We also want to make
     *   sure that the command never matches an Unthing in preference to a
     *   Thing, and that if an Unthing is matched it is not described as being
     *   present.
     */

    DefineTopicAction(Seek)
        execAction(cmd)
        {
            local obj = getBestMatch(cmd);
            gMessageParams(obj);
            if(obj && obj.ofKind(Unthing))
            {
                say(obj.notImportantMsg);
                return;
            }

            if(obj == gPlayerChar)
            {
                "If you've managed to lose your player character, things must be
                desperate! But don't worry, {I}{\'m} right {here}. ";
                return;
            }

            if(obj && obj.ofKind(Thing) && gActor.hasSeen(obj))
            {
                local loc = obj.location;
                if(loc == nil)
                {
                    if(obj.isIn(gActor.getOutermostRoom))
                        loc = gActor.getOutermostRoom;
                    else if(obj.ofKind(MultiLoc) && obj.locationList.length > 0)
                        loc = obj.locationList[1];
                }

                if(obj.isIn(gActor))
                    "{I} {am} carrying {him obj}. ";
                else if(gActor.canSee(obj) && loc != nil)
                {
                    "{The subj obj} {is} ";
                    if(loc == gActor.getOutermostRoom)
                        "right {here}. ";
                    else
                        "<<obj.isIn(gActor.getOutermostRoom) ? '' : 'nearby, '>>
                        <<locDesc(obj, loc)>>. ";
                }
                else
                    "{I} {|had} last <<senseDesc(obj)>> {the obj}
                    <<locDesc(obj, obj.lastSeenAt)>>. ";
            }
            else
                "If you want to find something you can\'t see, you'll have to hunt
                for it. If you think it may be in your current location, try
                examining things, searching things, opening things that open, or
                looking in, under and behind things. If what you\'re looking for
                could be elsewhere, you may have to go elsewhere to find it. ";

        }

        /*
         *   gTopic.getBestMatch() may not give the best results for our
         *   purposes. The following code is designed to prefer Things to
         *   Unthings, and then to prioritize what the player char can see over
         *   what s/he has seen, and both over what s/he only knows about. If
         *   none of these find a match, we then revert to gTopic.getBestMatch.
         */

        getBestMatch(cmd)
        {
            local lst = cmd.dobj.topicList;

            /*
             *   First see if our topic list includes anything the actor can see
             *   that's not an Unthing.
             */
            local obj = lst.valWhich({x: x.ofKind(Thing) && gActor.canSee(x)
                                     && !x.ofKind(Unthing)});
            if(obj != nil)
                return obj;

            /*
             *   Next see if there's anything in our topic list that the actor has
             *   previously seen.
             */
            obj = lst.valWhich({x: gActor.hasSeen(x) && !x.ofKind(Unthing)});
            if(obj != nil)
                return obj;

            /*
             *   Next see if there's anything in our topic list that the actor
             *   knows about.
             */
            obj = lst.valWhich({x: x.ofKind(Thing) && gActor.knowsAbout(x)});

            if(obj != nil)
                return obj;

            /*
             *   Finally, if all else fails, just return the ResolvedTopic's idea of
             *   a best match.
             */
            return cmd.dobj.getBestMatch();

        }

        locDesc(obj, loc)
        {
            if(obj.ofKind(Noise) || obj.ofKind(Odor))
                "coming from <<loc.theName>>";
            else
                "<<loc.objInName>>";
        }

        senseDesc(obj)
        {
            if(obj.ofKind(Noise))
                return 'heard';
            if(obj.ofKind(Odor))
                return 'smelt';
            return '{saw|seen}';
        }

    ;

    VerbRule(Seek)
        ('seek' | ('hunt' 'for')) topicDobj
        : VerbProduction
        action = Seek
        verbPhrase = 'seek/seeking (what)'
        missingQ = 'what do you want to seek'
    ;

Adv3Lite Library Reference Manual
Generated on 01/03/2024 from adv3Lite version 1.6.2