#charset "us-ascii"
#include "tads.h"
#include "tok.h"
#include "adv3.h"
#include "en_us.h"
#include <vector.h>
#include <dict.h>
#include <gramprod.h>
#include <strcomp.h>

//---------------------------------------------------------------
// MSG_SMART.T
// by Greg Boettcher
// Version 1.02
// Released 23 June 2006
//
// Copyright information:
//    This file contains a large number of TADS 3 messages. The
// content of these messages was written by Michael J. Roberts,
// and is copyright (c) 2000, 2005 Michael J. Roberts, and 
// may be used under the same terms as the rest of TADS 3.
//    What is original in this file is a number of modifications
// to make the TADS 3 messages use "smart" or "curly" quotes.
// These modifications are by me, Greg Boettcher, and are
// in the public domain. You may use my modifications for any 
// purpose. You need not credit me unless you feel like it.
// 
// My email address:
// <gregXatXgregboettcherXdotXcom>
//---------------------------------------------------------------

/*
The sole purpose of this extension is to make it so the TADS 3 
library messages always use "smart" or "curly" quotes for all 
single quotes and double quotes and apostrophes. I think I 
have successfully done this. If I've missed anything, feel 
free to let me know.

Stephen Granade's cquotes.t already serves a similar purpose 
as this extension. It works as an output filter, and attempts
to turn *ALL* straight quotes into "curly" quotes -- not just 
the ones in the library messages, but also the ones in your 
own programming code. The reason why I created this file is 
because I thought, rightly or wrongly, that an output filter 
would never get convert quotes correctly all of the time. 
As a point of reference, I know from personal experience that 
Microsoft Word correctly converts quotes to "smart" quotes 
only *most* of the time, not always. This extension should
do it correctly always -- for the library messages, that is.
It won't do anything for your own programming code.

Also note that this file will become obsolete soon, for more 
reasons than one. 

First of all, the next version of TADS 3 (the one that comes 
after 3.0.9) will include these "smart-quote" modifications 
as part of the standard language files msg_neu.t and en_us.t. 
So after the next release of TADS 3, this extension will serve 
no purpose. (With Mike Roberts' permission, I changed msg_neu.t 
and en_us.t to make them this way. Thanks, Mike!) 

Secondly, I only made this file after I detected certain bugs
in my extension msg_custom.t. That file was designed so that
you could turn smart quotes on or off at will, as well as
adjust 5 other factors pertaining to standard messages.
Unfortunately, on June 17, 2006, I discovered a bug in 
msg_custom.t that may take a long time to completely fix. 
I intend to fix it, but in the meantime I am releasing 
msg_smart.t to take care of the smart quote concern.
As soon as I get around to completely fixing msg_custom.t, 
this file will become obsolete.

Another note: As of this version, msg_smart.t modifies only 
msg_neu.t and en_us.t, not instruct.t.

As I understand, there is no need to avoid using "smart" or 
"curly" quotes on account of the fact that some interpreters 
cannot display them as such. As I understand, TADS 3 
interpreters that cannot display "smart" quotes generally 
do a good job at rendering them as regular "straight" quotes, 
and not producing unwanted output such as "<q>" or "&rsquo;".
*/

// ----------------------------------
// MSG_NEU.T MODIFICATIONS
// ----------------------------------

modify libMessages //: MessageHelper
    dimReadDesc(obj)
    {
        gMessageParams(obj);
        "There{&rsquo;s| was} not enough light to read {that obj/him}. ";
    }
    firstScoreChange(delta)
    {
        "<.commandsep><.notification><<
            basicScoreChange(delta)>><./notification>
        \n<.notification>If you&rsquo;d prefer not to be notified about
        score changes in the future, type <<
        aHref('notify off', 'NOTIFY OFF', 'Turn off score notifications')
        >>.<./notification> ";
    }
    firstFootnote()
    {
        "<.commandsep><.notification>A number in [square brackets] like
        the one above refers to a footnote, which you can read by typing
        FOOTNOTE followed by the number:
        <<aHref('footnote 1', 'FOOTNOTE 1', 'Show footnote [1]')>>,
        for example.  Footnotes usually contain added background information
        that might be interesting but isn&rsquo;t essential to the story.
        If you&rsquo;d prefer not to see footnotes at all,
        you can control their appearance by typing
        <<aHref('footnotes', 'FOOTNOTES',
                'Control footnote appearance')>>.<./notification> ";
    }
    showFootnoteStatus(stat)
    {
        "The current setting is FOOTNOTES ";
        switch(stat)
        {
        case FootnotesOff:
            "OFF, which hides all footnote references.
            Type <<aHref('footnotes medium', 'FOOTNOTES MEDIUM',
                         'Set footnotes to Medium')>> to
            show references to footnotes except those you&rsquo;ve
            already seen, or <<aHref('footnotes full', 'FOOTNOTES FULL',
                                     'Set footnotes to Full')>>
            to show all footnote references. ";
            break;

        case FootnotesMedium:
            "MEDIUM, which shows references to unread footnotes, but
            hides references to those you&rsquo;ve already read.  Type
            <<aHref('footnotes off', 'FOOTNOTES OFF',
                    'Turn off footnotes')>> to hide
            footnote references entirely, or <<aHref(
                'footnotes full', 'FOOTNOTES FULL',
                'Set footnotes to Full')>> to show every reference, even to
            notes you&rsquo;ve already read. ";
            break;

        case FootnotesFull:
            "FULL, which shows every footnote reference, even to
            notes you&rsquo;ve already read.  Type <<aHref('footnotes medium',
            'FOOTNOTES MEDIUM', 'Set footnotes to Medium')>> to show
            only references to notes you
            haven&rsquo;t yet read, or <<aHref('footnotes off', 
                'FOOTNOTES OFF', 'Turn off footnotes')>>
            to hide footnote references entirely. ";
            break;
        }
    }
    invalidCommandToken(ch)
    {
        "<.parser>The story doesn&rsquo;t know how to use the character
        &lsquo;<<ch>>&rsquo; in a command.<./parser> ";
    }
    oopsOutOfContext = "<.parser>You can only use OOPS to correct
        a misspelling immediately after the story points out a word
        it doesn&rsquo;t know.<./parser> "
    noCommandForAgain()
    {
        "<.parser>There&rsquo;s nothing to repeat.<./parser> ";
    }
    pausePrompt()
    {
        "<.parser>The story is now paused.  Please press
        the space bar when you are ready to resume the story, or
        press the &lsquo;S&rsquo; key to save the current 
        position.<./parser><.p>";
    }
    invalidFinishOption(resp)
    {
        "\bThat isn&rsquo;t one of the options. ";
    }
    exitsOnOffOkay(stat, look)
    {
        if (stat && look)
            "<.parser>The list of exits will now be shown in both
            the status line and in each room description.<./parser> ";
        else if (!stat && !look)
            "<.parser>The list of exits will no longer be shown in
            either the status line or room description.<./parser> ";
        else
            "<.parser>The list of exits <<stat ? 'will' : 'will not'>> be
            shown in the status line, and <<look ? 'will' : 'won&rsquo;t'>> be
            included in room descriptions.<./parser> ";
    }
    sorryHintsDisabled = '<.parser>Sorry, but hints have been disabled
                          for this session, as you requested.  If 
                          you&rsquo;ve changed your mind, you&rsquo;ll 
                          have to save your current position, exit the 
                          TADS interpreter, and start a new interpreter 
                          session.<./parser> '

    hintsNotPresent = '<.parser>Sorry, this story doesn&rsquo;t
                       have any built-in hints.<./parser> '
    showHintWarning =
       "<.notification>Warning: Some people don&rsquo;t like built-in 
       hints, since the temptation to ask for help prematurely can become
       overwhelming when hints are so close at hand.  If you&rsquo;re 
       worried that your willpower won&rsquo;t hold up, you can disable 
       hints for the rest of this session by typing <<aHref('hints off', 
       'HINTS OFF')>>.  If you still want to see the hints now, type
       <<aHref('hint', 'HINT')>>.<./notification> "
    commandNotPresent = "<.parser>That command isn&rsquo;t needed
                         in this story.<./parser> "
    scoreNotPresent = "<.parser>This story doesn&rsquo;t use
                       scoring.<./parser> "
    defaultsFileNotSupported = "<.parser>Sorry, but the version of the
        TADS interpreter you&rsquo;re using doesn&rsquo;t support saving 
        or restoring defaults.  You must install a more recent version
        in order to use this feature.<./parser> "
    roomDarkDesc = "It{&rsquo;s| was} pitch black. "
    notOnboardShip = "That direction {is|was}n&rsquo;t meaningful {|t}here. "
;

modify playerMessages //: libMessages
    commandNotUnderstood(actor)
    {
        "<.parser>The story doesn&rsquo;t understand that command.<./parser> ";
    }
    specialTopicInactive(actor)
    {
        "<.parser>That command can&rsquo;t be used right now.<./parser> ";
    }
    noMatchForPronoun(actor, typ, pronounWord)
    {
        "<.parser>The word <q><<pronounWord>></q> doesn&rsquo;t refer to
        anything right now.<./parser> ";
    }
    reflexiveNotAllowed(actor, typ, pronounWord)
    {
        "<.parser>The story doesn&rsquo;t understand how to use the word
        <q><<pronounWord>></q> like that.<./parser> ";
    }
    wrongReflexive(actor, typ, pronounWord)
    {
        "<.parser>The story doesn&rsquo;t understand what the
        word <q><<pronounWord>></q> refers to.<./parser> ";
    }
    insufficientQuantity(actor, txt, matchList, requiredNum)
    {
        "<.parser>\^<<actor.nameDoes>>n&rsquo;t see that many
        <<txt>> <<tSel('here', 'there')>>.<./parser> ";
    }
    uniqueObjectRequired(actor, txt, matchList)
    {
        "<.parser>You can&rsquo;t use multiple objects there.<./parser> ";
    }
    singleObjectRequired(actor, txt)
    {
        "<.parser>Multiple objects aren&rsquo;t allowed with that
        command.<./parser> ";
    }
    ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
    {
        "<.parser>The story doesn&rsquo;t know which
        <<originalText>> you mean.<./parser> ";
    }
    wordIsUnknown(actor, txt)
    {
        "<.parser>The story doesn&rsquo;t understand that
        command.<./parser> ";
    }
;

modify npcMessages //: playerMessages
    noMatchForAll(actor)
    {
        "<.parser>\^<<actor.nameDoes>>n&rsquo;t see anything
        suitable.<./parser> ";
    }
    insufficientQuantity(actor, txt, matchList, requiredNum)
    {
        "<.parser>\^<<actor.nameDoes>>n&rsquo;t see that many
         <<txt>>.<./parser> ";
    }
    ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
    {
        "<.parser>\^<<actor.nameDoes>>n&rsquo;t know which
        <<originalText>> you mean<<tSel('', 't')>>.<./parser> ";
    }
;

modify npcMessagesDirect //: npcMessages
    noMatchCannotSee(actor, txt)
    {
        "\^<<actor.nameVerb('look')>> around. <q>I don&rsquo;t
        see any <<txt>>.</q> ";
    }
    noMatchNotAware(actor, txt)
    {
        "<q>I&rsquo;m not aware of any <<txt>>,</q> <<actor.nameSays>>. ";
    }
    noMatchForAll(actor)
    {
        "\^<<actor.nameSays>>, <q>I don&rsquo;t see anything suitable.</q> ";
    }
    zeroQuantity(actor, txt)
    {
        "\^<<actor.nameSays>>,
        <q>I can&rsquo;t do that to zero of something.</q> ";
    }
    insufficientQuantity(actor, txt, matchList, requiredNum)
    {
        "\^<<actor.nameSays>>,
        <q>I don&rsquo;t see that many <<txt>> here.</q> ";
    }
    uniqueObjectRequired(actor, txt, matchList)
    {
        "\^<<actor.nameSays>>,
        <q>I can&rsquo;t use multiple objects like that.</q> ";
    }
    singleObjectRequired(actor, txt)
    {
        "\^<<actor.nameSays>>,
        <q>I can&rsquo;t use multiple objects like that.</q> ";
    }
    disambigOrdinalOutOfRange(actor, ordinalWord, originalText)
    {
        /* leave the quote open for the re-prompt */
        "\^<<actor.nameSays>>,
        <q>There weren&rsquo;t that many choices. ";
    }
    ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
    {
        "\^<<actor.nameSays>>,
        <q>I don&rsquo;t know which <<originalText>> you mean.</q> ";
    }
    missingObject(actor, action, which)
    {
        "\^<<actor.nameSays>>,
        <q>I don&rsquo;t know <<action.whatObj(which)>>
        you want me to <<action.getQuestionInf(which)>>.</q> ";
    }
    askUnknownWord(actor, txt)
    {
        "\^<<actor.nameSays>>,
        <q>I don&rsquo;t know the word <q><<txt>></q>.</q> ";
    }
    wordIsUnknown(actor, txt)
    {
        "\^<<actor.nameSays>>,
        <q>You used a word I don&rsquo;t know.</q> ";
    }
;

modify npcDeferredMessagesDirect //: npcDeferredMessages
    commandNotUnderstood(actor)
    {
        "\^<<actor.nameSays>>,
        <q>I didn&rsquo;t understand what you meant.</q> ";
    }
    noMatchCannotSee(actor, txt)
    {
        "\^<<actor.nameSays>>, <q>I didn&rsquo;t see any <<txt>>.</q> ";
    }
    noMatchNotAware(actor, txt)
    {
        "\^<<actor.nameSays>>, <q>I&rsquo;m not aware of any <<txt>>.</q> ";
    }
    noMatchForAll(actor)
    {
        "\^<<actor.nameSays>>, <q>I didn&rsquo;t see anything suitable.</q> ";
    }
    noMatchForAllBut(actor)
    {
        "\^<<actor.nameSays>>,
        <q>I didn&rsquo;t see what you meant.</q> ";
    }
    zeroQuantity(actor, txt)
    {
        "\^<<actor.nameSays>>,
        <q>I didn&rsquo;t understand what you meant.</q> ";
    }
    insufficientQuantity(actor, txt, matchList, requiredNum)
    {
        "\^<<actor.nameSays>>,
        <q>I didn&rsquo;t see enough <<txt>>.</q> ";
    }
    uniqueObjectRequired(actor, txt, matchList)
    {
        "\^<<actor.nameSays>>,
        <q>I didn&rsquo;t understand what you meant.</q> ";
    }
    singleObjectRequired(actor, txt)
    {
        "\^<<actor.nameSays>>,
        <q>I didn&rsquo;t understand what you meant.</q> ";
    }
    ambiguousNounPhrase(actor, originalText, matchList, fullMatchList)
    {
        "\^<<actor.nameSays>>,
        <q>I couldn&rsquo;t tell which <<originalText>> you meant.</q> ";
    }
    askMissingObject(actor, action, which)
    {
        reportQuestion('\^' + actor.nameSays
                       + ', <q>I didn&rsquo;t know '
                       + action.whatObj(which) + ' you wanted me to '
                       + action.getQuestionInf(which) + '.</q> ');
    }
    wordIsUnknown(actor, txt)
    {
        "\^<<actor.nameSays>>,
        <q>You used a word I don&rsquo;t know.</q> ";
    }
;

modify playerActionMessages //: MessageHelper
    tooDarkMsg = 'It{&rsquo;s| was} too dark to do that. '
    decorationNotImportantMsg(obj)
    {
        gMessageParams(obj);
        return '{The obj/he} {is}n&rsquo;t important. ';
    }
    unthingNotHereMsg(obj)
    {
        gMessageParams(obj);
        return '{You/he} {does}n&rsquo;t see {that obj/him} {|t}here. ';
    }
    nothingInsideMsg =
        'There{&rsquo;s| was} nothing unusual in {the dobj/him}. '
    notWearableMsg =
        '{That dobj/he} {is}n&rsquo;t something {you/he} {can} wear. '
    notDoffableMsg =
        '{That dobj/he} {is}n&rsquo;t something {you/he} {can} remove. '
    cannotMovePushableMsg = 'It wouldn&rsquo;t {|have} accomplish{|ed} anything
        to move {the dobj/him} around aimlessly, but {it actor/he}
        might {be|have been} able to push {it dobj/him} in a specific
        direction. '
    cannotTakePersonMsg =
        '{The dobj/he} probably wouldn&rsquo;t {|have} like{|d} that. '
    cannotMovePersonMsg =
        '{The dobj/he} probably wouldn&rsquo;t {|have} like{|d} that. '
    cannotPutPersonMsg =
        '{The dobj/he} probably wouldn&rsquo;t {|have} like{|d} that. '
    cannotTastePersonMsg =
        '{The dobj/he} probably wouldn&rsquo;t {|have} like{|d} that. '
    surfaceTooFullMsg(obj, cont)
    {
        gMessageParams(obj, cont);
        return 'There{&rsquo;s| was} no room for {the obj/him} on '
               + '{the cont/him}. ';
    }
    undersideTooFullMsg(obj, cont)
    {
        gMessageParams(obj, cont);
        return 'There{&rsquo;s| was} no room for {the obj/him} under '
               + '{the cont/him}. ';
    }
    rearTooFullMsg(obj, cont)
    {
        gMessageParams(obj, cont);
        return 'There{&rsquo;s |was} no room for {the obj/him} behind '
               + '{the cont/him}. ';
    }
    notASurfaceMsg = 'There{&rsquo;s| was} no good surface on {the iobj/him}. '
    objNotForKeyringMsg = '{The dobj/he} {does}n&rsquo;t fit on {the iobj/him}. '
    keyNotDetachableMsg = '{The dobj/he} {is}n&rsquo;t attached to anything. '
    takeFromNotInMsg = '{The dobj/he} {is}n&rsquo;t in {that iobj/him}. '
    takeFromNotOnMsg = '{The dobj/he} {is}n&rsquo;t on {that iobj/him}. '
    takeFromNotUnderMsg = '{The dobj/he} {is}n&rsquo;t under {that iobj/him}. '
    takeFromNotBehindMsg = '{The dobj/he} {is}n&rsquo;t behind {that iobj/him}. '
    takeFromNotInActorMsg = '{The iobj/he} {does}n&rsquo;t have {that dobj/him}. '
    whereToGoMsg = 'You&rsquo;ll have to say which way to go. '
    cannotGoThatWayInDarkMsg = 'It{&rsquo;s| was} too dark; {you/he} {can\'t} see
                             where {you\'re} going. '
    cannotGoBackMsg = '{You/he} {does}n&rsquo;t know how to return from {|t}here. '
    nestedRoomTooHighToExitMsg(obj)
    {
        return 'It{&rsquo;s| was} too long a drop to do that from {|t}here. ';
    }
    cannotJumpOffHereMsg = 'There{&rsquo;s| was} nowhere to jump from {|t}here. '
    cannotTalkToSelf = 'Talking to {yourself/himself}
        {won&rsquo;t|wouldn&rsquo;t} accomplish anything. '
    cannotAskSelfMsg = 'Talking to {yourself/himself}
        {won&rsquo;t|wouldn&rsquo;t} accomplish anything. '
    cannotAskSelfForMsg = 'Talking to {yourself/himself}
        {won&rsquo;t|wouldn&rsquo;t} accomplish anything. '
    cannotTellSelfMsg = 'Talking to {yourself/himself}
        {won&rsquo;t|wouldn&rsquo;t} accomplish anything. '
    cannotGiveToSelfMsg = 'Giving {the dobj/him} to {yourself/himself}
        {won&rsquo;t|wouldn&rsquo;t} accomplish anything. '
    cannotShowToSelfMsg = 'Showing {the dobj/him} to {yourself/himself}
        {won&rsquo;t|wouldn&rsquo;t} accomplish anything. '
    matchNotLitMsg = '{The dobj/he} {is}n&rsquo;t lit. '
    cannotTurnOnMsg =
        '{That dobj/he} {is}n&rsquo;t something {you/he} {can} turn on. '
    cannotTurnOffMsg =
        '{That dobj/he} {is}n&rsquo;t something {you/he} {can} turn off. '
    cannotDetachPermanentMsg =
        'There{&rsquo;s| was} no obvious way to detach {that dobj/him}. '
    notAttachedToMsg = '{The dobj/he} {is}n&rsquo;t attached to {that iobj/him}. '
    cannotLockWithMsg =
        '{The iobj/he} {does}n&rsquo;t look suitable for locking that. '
    cannotUnlockWithMsg =
        '{The iobj/he} {does}n&rsquo;t look suitable for unlocking that. '
    unknownHowToLockMsg =
        'It{&rsquo;s| was} not clear how to lock {the dobj/him}. '
    unknownHowToUnlockMsg =
        'It{&rsquo;s| was} not clear how to unlock {the dobj/him}. '
    keyDoesNotFitLockMsg = '{The iobj/he} {does}n&rsquo;t fit the lock. '
    cannotCleanMsg =
        '{You/he} wouldn&rsquo;t {|have} know{|n} how to clean {that dobj/him}. '
    cannotSleepMsg = '{You/he} {does}n&rsquo;t need to sleep right now. '
    cannotSitOnMsg =
        '{That dobj/he} {is}n&rsquo;t something {you/he} {can} sit on. '
    cannotLieOnMsg =
        '{That dobj/he} {is}n&rsquo;t something {you/he} {can} lie on. '
    noRoomToStandMsg =
        'There{&rsquo;s| was} no room for {you/him} to stand {on dobj}. '
    noRoomToSitMsg =
        'There{&rsquo;s| was} no room for {you/him} to sit {on dobj}. '
    noRoomToLieMsg =
        'There{&rsquo;s| was} no room for {you/him} to lie {on dobj}. '
    willNotCatchMsg(catcher)
    {
        return '\^' + catcher.nameDoes
            + 'n&rsquo;t look like ' + catcher.itNom + ' want'
            + catcher.verbEndingSEd + ' to catch anything. ';
    }
    cannotKissActorMsg
        = '{The dobj/he} probably wouldn&rsquo;t {|have} like{|d} that. '
;

modify npcActionMessages //: playerActionMessages
    whereToGoMsg =
        'You&rsquo;ll have to say which way {you/he} should {|have} go{|ne}. '
    objNotForKeyringMsg = '{You/he} {cannot} do that because
                        {that dobj/he} {does}n&rsquo;t fit on {the iobj/him}. '
    takeFromNotInMsg = '{You/he} {cannot} do that because
        {the dobj/he} {is}n&rsquo;t in {that iobj/him}. '
    takeFromNotOnMsg = '{You/he} {cannot} do that because
        {the dobj/he} {is}n&rsquo;t on {that iobj/him}. '
    takeFromNotUnderMsg = '{You/he} {cannot} do that because
        {the dobj/he} {is}n&rsquo;t under {that iobj/him}. '
    takeFromNotBehindMsg = '{You/he} {cannot} do that because
        {the dobj/he} {is}n&rsquo;t behind {that iobj/him}. '
    cannotJumpOffHereMsg = 'There{&rsquo;s| was} nowhere for {you/him} to jump. '
    shouldNotBreakMsg = '{You/he} {does}n&rsquo;t want to break {that dobj/him}. '
    keyDoesNotFitLockMsg = '{You/he} tr{ies/ied} {the iobj/he}, but
                         {it iobj/he} {does}n&rsquo;t fit the lock. '
    okayFollowModeMsg = '<q>Okay, I will follow {the dobj/him}.</q> '
;

// ----------------------------------
// EN_US.T MODIFICATIONS
// ----------------------------------

modify Thing
    thatIsContraction
    {
        return thatNom + tSel(isPlural ? ' are' : '&rsquo;s', ' ' + verbToBe);
    }
    itIsContraction
    {
        return itNom + tSel(isPlural ? '&rsquo;re' : '&rsquo;s', ' ' + verbToBe);
    }
    theNamePossAdj
    {
        return theName + (isPlural && theName.endsWith('s') ? '&rsquo;' : '&rsquo;s');
    }
    pluralNameFrom(str)
    {
        local len;
        local lastChar;
        local lastPair;
        if (isPlural)
            return str;
        len = str.length();
        if (len == 0)
            return '';
        if (len == 1)
        {
            if (rexMatch(patSingleApostropheS, str) != nil)
                return str + '\'s';
            else
                return str + 's';
        }
        lastChar = str.substr(len, 1);
        lastPair = (len == 1 ? lastChar : str.substr(len - 1, 2));
        if (rexMatch(patUpperOrDigit, lastChar) != nil)
            return str + 's';
        if (lastChar == '.')
            return str + '&rsquo;s';
        if (rexMatch(patVowelY, lastPair) != nil)
            return str.substr(1, len - 1) + 'ies';
        if ('sxzh'.find(lastChar) != nil)
            return str + 'es';
        return str + 's';
    }
    nameIsnt { return nameIs + 'n&rsquo;t'; }
    verbCant = (tSel('can&rsquo;t', 'couldn&rsquo;t'))
    verbWont = (tSel('won&rsquo;t', 'wouldn&rsquo;t'))
;

modify Actor
    thatIsContraction
    {
        return thatNom + tSel(['&rsquo;m', '&rsquo;re', '&rsquo;s',
            '&rsquo;re', '&rsquo;re', ' are'][conjugationSelector], ' ' + verbToBe);
    }
    itIsContraction
    {
        return itNom + tSel(
            '&rsquo;' + ['m', 're', 's', 're', 're', 're'][conjugationSelector],
            ' ' + verbToBe);
    }
    nameIsnt
    {
        return conjugationSelector == 1 && !gameMain.usePastTense
            ? 'I&rsquo;m not' : inherited;
    }
;