Pre-release
Adventure.js Docs Downloads
Score: 0 Moves: 0

Verb: run structures phrases params phases actions methods properties

Instance of: adventurejs.Verb

Defined in: adventure/dictionary/verbs/run.js, line 7

More info: VerbSubscriptions VerbAnatomy VerbProcess ModifyVerbs WriteVerbs

Runtime node: game.dictionary.verbs.run 

> run under cat
You run under the old half-blind cat. It sniffs the air and
mews with confusion. You're safe for a moment, but there's
no time to waste. You wrack your brain for ways to reverse
the witch's spell with your little mousey paws.
Run extends core verb go. It checks whether "run" is contextually available before forwarding to "go" for further handling.

run sentence structures

accepts_structures: [
  "verb",
  "verb noun",
  "verb preposition",
  "verb preposition noun",
  "verb noun preposition noun"
]

The Adventurejs parser uses multiple filtering methods to try to interpret player input. Sentence structures are defined for each verb in order to narrow down the sentence structures that a verb can accept. For example, the verb "hit" might accept "verb noun" as in "hit troll", or "verb noun preposition noun" as in "hit troll with sword", whereas an intransitive verb like "jump" might accept "verb" as a complete sentence. This helps to filter player input. Input that isn't accepted will return a warning to the player.

  • It is possible for authors to modify a verb's structures through the use of patchVerb.
  • To learn more about modifying verbs, see Modify Verbs.

run phrases

phrase1:
{
  accepts_noun:true,
  noun_must_be:
  {
    known: true,
    tangible: true,
    present: true,
    visible: true,
    reachable: true,
  },
  accepts_preposition: true,
},
phrase2:
{
  accepts_noun:true,
  noun_must_be:
  {
    known: true,
    tangible: true,
    present: true,
    visible: true,
    reachable: true,
  },
  accepts_preposition: true,
},

The Adventurejs parser uses multiple filtering methods to try to interpret player input. Phrases are defined for each verb in order to narrow down the words that a verb can accept. This applies to preposition/noun pairs: from zero in the case of intransitive verbs, up to three in the case of verbs that can handle input such as "pour water from jug into basin". The nested noun_must_be object sets conditional qualifiers for nouns, that helps narrow down game objects that the verb might act upon. Input that isn't accepted will return a warning to the player.

  • It is possible for authors to modify a verb's phrases through the use of patchVerb.
  • To see a list of properties that can be set for phrases, see the Phrase class.
  • To see a list of properties that can be set for phrase.noun_must_be, see the NounMustBe class.
  • To learn more about modifying verbs, see Modify Verbs.

run params

Some verbs have custom params which are mirrored in the properties of any asset subscribed to the verb. 

with_params: {},

For example, consider this setting of the verb plugIn:

MyGame.dictionary.verbs.plugIn.with_params.max_connections = 1

By default, assets that can be plugged in will take this setting and can only be plugged in to one other asset. Now imagine that an author wants to create a power cord that needs to be plugged in to both a computer and an outlet. 

MyGame.createAsset({
  class: "Cable",
  name: "power cord",
  dov: { plugIn: { with_assets: ['computer','outlet'], with_params: { max_connections: 2 }, }, },
})
MyGame.createAsset({
  class: "Computer",
  name: "PC",
  iov: { plugIn: { with_assets: ['power cord'], }, },
})
MyGame.createAsset({
  class: "ElectricalOutlet",
  name: "outlet",
  iov: { plugIn: { with_assets: ['power cord'], }, },
})

The power cord's max_connections setting overrides the verb's max_attachment setting, allowing the player to plug the power cord into two assets, while the computer and the outlet can still have only one asset plugged into them.

  • It is possible for authors to modify a verb's params through the use of patchVerb.
  • To learn more about modifying verbs, see Modify Verbs.

run verb phases

Verb Phases allow an author to override how a verb is applied to any given asset. This is a broad method for exercising control over verb/noun interactions that allows for custom per-asset verb logic. For example, an author might supply completely different logic for "throw feather" vs "throw baseball" vs "throw anvil". This works by overriding portions of asset verb subscriptions. When a verb is applied to an asset, its do() method is called. For most (but not all) verbs, do() acts as a sequencer that moves the verb through six distinct phases.

  • doTry handles all the conditional logic to determine whether a verb can be applied to an asset.
  • doSuccess handles output and state changes.
  • doBeforeTry, doAfterTry, doBeforeSuccess and doAfterSuccess don't do anything by themselves, but provide opportunities for authors to inject custom code at various stages of a verb action.

do

    doBeforeTry 
    MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  dov: {
    run: {
      doBeforeTry: function( params )
      {
        let msg = `You're about to try to run ${this.Name}. `;
        this.game.print(msg);
        return;
      },
    },
  },
});

    doTry

    doAfterTry 
    MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  dov: {
    run: {
      doAfterTry: function( params )
      {
        let msg = `You just tried to run ${this.Name}! `;
        this.game.print(msg);
        return;
      },
    },
  },
});
    doBeforeSuccess 
    MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  dov: {
    run: {
      doBeforeSuccess: function( params )
      {
        let msg = `You're about to try to succeed in performing run on ${this.Name}. `;
        this.game.print(msg);
        return;
      },
    },
  },
});

    doSuccess

    doAfterSuccess 
    MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  dov: {
    run: {
      doAfterSuccess: function( params )
      {
        let msg = `You're moving on from your success performing run on ${this.Name}. `;
        this.game.print(msg);
        return;
      },
    },
  },
});

For example, consider the verb "take" as applied to this singing sword. Imagine that an author wants the game to print a custom message when the player tries to take the sword, and a different message when the player succeeds in taking it. 

MyGame.createAsset({
  class: "Sword",
  name: "singing sword",
  dov: {
    take: 
    {
      doAfterTry: function( params )
      {
        let msg = "The sword begins to vibrate as your hand curls around its haft. ";
        MyGame.print( msg );
      },
      doAfterSuccess: function( params )
      {
        let msg = "The sword bursts into song in your hand. ";
        MyGame.print( msg );
      },
    },
  },
});

Please note that verb subscriptions are set distinctly for direct objects and indirect objects. All of the prior examples show verb phases applied to direct object verb subscriptions. Verb phases can also be applied to indirect object subscriptions. For example, perhaps our swinging sword had to be removed from a stone. We might want to hook into the stone's indirect object verb subscription for "remove". 

MyGame.createAsset({
  class: "Thing",
  name: "stone",
  iov: {
    remove: 
    {
      doBeforeTry: function( params )
      {
        let msg = "Will the stone judge you worthy enough to remove the sword? "
        MyGame.print( msg );
      },
      doAfterSuccess: function( params )
      {
        let msg = "With the sword removed, the stone bursts into rubble! ";
        MyGame.print( msg );
        this.destroy();
      },      
    },
  },
});
  • To learn more, see Verb Phases.
  • Verb Phases are related to but distinct from Verb Actions, which offers a more surgical method to hook into the doTry and doSuccess phases, on a per object basis.

run verb actions

Verb actions provide hooks for injecting custom code into very specific verb actions (or reactions). It works by looking for custom functions attached to the assets that the verb is being applied to, and calling any function that it finds. It's a fine-grained way to tailor specific verb/noun interactions. Each verb has a unique set of actions. For instance, the verb lock has onTryLock and onTryLockThisWithThat and several other lock-specific hooks, whereas the verb climb has onTryClimb and onTryClimbFromThisToThat, etc.

Expand any item to see a code example.

tryRun

If a verb is called without a direct object, the verb.handleActions method looks for a verb action on the player.

MyGame.createAsset({
  class: "Player",
  name: "My Hero",
  tryRun: function (params) {
    let msg = 'Called verb action my_hero.tryRun()';
    this.game.print(msg);
    return;
  },
});

doRun

If a verb is called without a direct object, the verb.handleActions method looks for a verb action on the player. (Although, during the doTry phase, it's common for sentence structures to mutate so that they have changed by the time they reach the doSuccess phase.)

MyGame.createAsset({
  class: "Player",
  name: "My Hero",
  doRun: function (params) {
    let msg = 'Called verb action my_hero.doRun()';
    this.game.print(msg);
    return;
  },
});

tryRunThis

If a verb is called with a direct object, the verb.handleActions method looks at the direct object for a verb action.

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  tryRunThis: function (params) {
    let msg = 'Called verb action this_asset.tryRunThis()';
    this.game.print(msg);
    return;
  },
});

Verb actions can have nested functions. If tryRunThis is found to be an object rather than a function, the verb.handleActions method checks the object for a nested verb action that treats the player as an indirect object. This can be used in this way:

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  tryRunThis: { 
    "My Hero": function (params) {
      let msg = 'Called verb action this_asset.tryRunThis["My Hero"]()';
      this.game.print(msg);
      return;
    }
  },
});

doRunThis

If a verb is called with a direct object, the verb.handleActions method looks at the direct object for a verb action. (Although, during the doTry phase, it's common for sentence structures to mutate so that they have changed by the time they reach the doSuccess phase.)

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  doRunThis: function (params) {
    let msg = 'Called verb action this_asset.doRunThis()';
    this.game.print(msg);
    return;
  },
});

Verb actions can have nested functions. If doRunThis is found to be an object rather than a function, the verb.handleActions method checks the object for a nested verb action that treats the player as an indirect object. This can be used in this way:

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  doRunThis: { 
    "My Hero": function (params) {
      let msg = 'Called verb action this_asset.doRunThis["My Hero"]()';
      this.game.print(msg);
      return;
    }
  },
});

tryRun[Preposition]

If a verb is called without a direct object, the verb.handleActions method looks for a verb action on the player.

MyGame.createAsset({
  class: "Player",
  name: "My Hero",
  tryRunThrough: function (params) {
    let msg = 'Called verb action my_hero.tryRunThrough()';
    this.game.print(msg);
    return;
  },
});

doRun[Preposition]

If a verb is called without a direct object, the verb.handleActions method looks for a verb action on the player. (Although, during the doTry phase, it's common for sentence structures to mutate so that they have changed by the time they reach the doSuccess phase.)

MyGame.createAsset({
  class: "Player",
  name: "My Hero",
  doRunThrough: function (params) {
    let msg = 'Called verb action my_hero.doRunThrough()';
    this.game.print(msg);
    return;
  },
});

tryRun[Preposition]This

If a verb is called with a direct object, the verb.handleActions method looks at the direct object for a verb action. This example uses "through" as the preposition, but any preposition can be used. You can even set up unique function calls per preposition.

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  tryRunThroughThis: function (params) {
    let msg = 'Called verb action this_asset.tryRunThroughThis()';
    this.game.print(msg);
    return;
  },
});

Verb actions can have nested functions. If tryRun[Preposition]This is found to be an object rather than a function, the verb.handleActions method checks the object for a nested verb action that treats the player as an indirect object. This can be used in this way:

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  tryRunThroughThis: { 
    "My Hero": function (params) {
      let msg = 'Called verb action this_asset.tryRunThroughThis["My Hero"]()';
      this.game.print(msg);
      return;
    }
  },
});

doRun[Preposition]This

If a verb is called with a direct object, the verb.handleActions method looks at the direct object for a verb action. This example uses "through" as the preposition, but any preposition can be used. You can even set up unique function calls per preposition.

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  doRunThroughThis: function (params) {
    let msg = 'Called verb action this_asset.doRunThroughThis()';
    this.game.print(msg);
    return;
  },
});

Verb actions can have nested functions. If doRun[Preposition]This is found to be an object rather than a function, the verb.handleActions method checks the object for a nested verb action that treats the player as an indirect object. This can be used in this way:

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  doRunThroughThis: { 
    "My Hero": function (params) {
      let msg = 'Called verb action this_asset.doRunThroughThis["My Hero"]()';
      this.game.print(msg);
      return;
    }
  },
});

tryRunThis[Preposition]That

If a verb is called with a direct object + preposition + indirect object, the verb.handleActions method looks at the direct object + preposition for a verb action.

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  tryRunThisThroughThat: function (params) {
    let msg = 'Called verb action this_asset.tryRunThisThroughThat()';
    this.game.print(msg);
    return;
  },
});

Verb actions can have nested functions. If tryRunThisThroughThat is found to be an object rather than a function, the verb.handleActions method checks the object for a nested verb action for the indirect object. This can be used in this way:

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  tryRunThisThroughThat: { 
    "That Asset": function (params) {
      let msg = 'Called verb action this_asset.tryRunThisThroughThat["That Asset"]()';
      this.game.print(msg);
      return;
    }
  },
});

doRunThis[Preposition]That

If a verb is called with a direct object + preposition, the verb.handleActions method looks at the direct object + preposition for a verb action. This example uses "through" as the preposition, but any preposition can be used. You can even set up unique function calls per preposition.

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  doRunThisThroughThat: function (params) {
    let msg = 'Called verb action this_asset.doRunThroughThis()';
    this.game.print(msg);
    return;
  },
});

Verb actions can have nested functions. If tryRunThisThroughThat is found to be an object rather than a function, the verb.handleActions method checks the object for a nested verb action for the indirect object. This can be used in this way:

MyGame.createAsset({
  class: "Thing",
  name: "This Asset",
  doRunThisThroughThat: { 
    "That Asset": function (params) {
      let msg = 'Called verb action this_asset.doRunThisThroughThat["That Asset"]()';
      this.game.print(msg);
      return;
    }
  },
});

Each of the items above can be expanded to show a specific example, but here is a generic example. 

MyGame.createAsset({
  class: "Player",
  name: "Elvis",  
});
MyGame.createAsset({
  class: "Weapon",
  name: "pistol",
});
MyGame.createAsset({
  class: "Electronics",
  name: "television",
  doShootThisWithThat:{
    "pistol": function {
      let msg = "You fire the pistol at the television, which explodes with a screech of static and sparks. ";
      this.game.print(msg);
    },
  },
});
  • To learn more, see Verb Actions.
  • Some hooks are not tied to any specific verbs and though these are technically identical, we refer to them as verb reactions. See Verb Reactions for a list of them.
  • Verb actions are related to but distinct from verb phases, which allow authors to broadly override entire phases of a verb.

run verb reactions

None available for run

Verb reactions provide a hook for authors to inject custom code into specific interactions between assets. They are identical to verb actions but for one thing: while verb actions are called during a verb's doTry or doSuccess phases, verb reactions are called as a secondary effect, or result, of doSuccess. For example, take lantern results in moving the lantern to the player from its original parent. Drop lantern results in moving the lantern from the player to the room. In both cases, the lantern leaves one place and enters another, so both verbs result in calling these four verb reactions:

lantern.doRemoveThisFromThat(player),
player.doRemoveThatFromThis(lantern),
lantern.doMoveThisToThat(room), and
room.doMoveThatToThis(lantern).

OMG you may exclaim. Why four reactions? Technically, two reactions are occurring – the lantern leaves the player and enters the room – but because we want to give authors maximum flexibility to organize code however makes sense to them, we check both assets for code relative to the other.

In this example, imagine that an author would like the game to print a custom message whenever a certain asset enters or leaves another asset, by any method. 

MyGame.createAsset({
  class: "NPC",
  name: "Elvis",
}),
MyGame.createAsset({
  class: "Room",
  name: "The Building",
  doMoveThatToThis: 
  {
    "Elvis": function() 
    {
      MyGame.print("Elvis has entered The Building! ");
    }
  },
  doRemoveThatFromThis: 
  {
    "Elvis": function() 
    {
      MyGame.print("Elvis has left The Building! ");
    }
  },
}),
  • To learn more, see Verb Reactions.
  • Hooks that are tied directly to verbs are called verb actions. See Verb Actions for more information.
  • Verb reactions are related to but distinct from verb phases, which allow authors to broadly override entire phases of a verb.

run verb logic

Verb logic falls into a few recognizable patterns. Direction verbs tend to be simple. Manipulation verbs do a lot of testing to see whether one asset is allowed to interact with another asset. Many verbs are similar, but no two verbs are identical. Each verb has its quirks. If you would like to learn more about verb logic, we recommend you see the Verb Anatomy and Verb Process pages. If you find that you want more than you can get from verb phases and verb actions / reactions / you may want to investigate the patchVerb method, which lets you replace entire blocks of verb code. You can also write verbs from scratch if you're so inclined. See Modify Verbs for a complete list of verb modification methods.

Private Constructor:

MyGame.createVerb({ "name": "run", [...] });

run is a predefined instance of Verb that gets constructed automatically at runtime. It is defined in the library as a generic object, and then passed to Dictionary#createVerb for construction, validation, and initialization. Because this is predefined, authors should not need to create new instances. For information on modifying predefined Verbs, see Modify Verbs.

Inherited Overrides

Index

Methods:

Properties:

Methods Collapse all  |  Expand all

canBeIntransitive()

Defined in: adventure/dictionary/Verb.js, line 1905

Inherited from: adventurejs.Verb#canBeIntransitive

Verb can be intransitive if it doesn't require a noun.
do()

Defined in: adventure/dictionary/Verb.js, line 968

Inherited from: adventurejs.Verb#do

Verb.do is a coordinating method that sequences six other submethods in a series. In the case of Verb instances that can act on a collection of Assets in a single turn, Verb.do only fires once, but it loops through the Asset collection and calls each submethod for every Asset in the collection. The sequence is:

do -> The two key submethods are Verb.doTry and Verb.doSuccess. For most Verb instances, these two methods contain the bulk of the logic particular to this Verb. Verb.doTry determines whether a Verb can act on an Asset, and if it can't, prints an error message to Display. Verb.doSuccess applies the Verb to the Asset: updates the game state, assembles dynamic output, and prints the results to Display.

A Verb instance isn't required to use all of these methods. Some Verbs may bypass Verb.doTry because no special conditions are required to apply the Verb. Some specialized Verbs such as oops and undo override Verb.do entirely and don't use any submethods.

The other four submethods – Verb.doBeforeTry, Verb.doAfterTry, Verb.doBeforeSuccess, and Verb.doAfterSuccess – exist to provide optional hooks for authors to add custom interactions with individual Assets. For more information about Verb Actions and Verb Phases, see Verb Actions and Verb Phases.

And so, the first thing Verb.do does is to verify that each method exists on the Verb instance. If the submethod exists, it is called. Each submethod sends a return to Verb.do.

If the Verb is acting on a collection, a false return means that the Asset currently being acted on has responded in a way that blocks further parsing, and brings this turn to a halt. A null return means that the Asset currently being acted on has concluded its own parsing, but not in such a way as to block further parsing, and Verb.do moves on to the next Asset.
doSuccess()

Defined in: adventure/dictionary/Verb.js, line 1233

Inherited from: adventurejs.Verb#doSuccess

doSuccess typically contains all the code needed to apply this Verb to the specified Asset once it has successfully passed through all of our conditional logic. doBeforeSuccess and doAfterSuccess are provided so that authors can apply custom success code on an item-by-item basis, but it is also possible to globally modify doSuccess. For information about modifying verbs, see Modify Verbs.
doTry()

Defined in: adventure/dictionary/Verb.js, line 1138

Inherited from: adventurejs.Verb#doTry

doTry typically contains all the specific logic needed to determine if this Verb can act on the specified Asset. (We already applied some general logic supplied by NounMustBe before arriving here.) For information about modifying verbs, see Modify Verbs.
enqueueCollection()

Defined in: adventure/dictionary/Verb.js, line 1582

Inherited from: adventurejs.Verb#enqueueCollection

enqueueCollection takes a collection of Assets and enqueues them to game.parser for sequential handling.
getState()

Defined in: adventure/dictionary/Verb.js, line 1923

Inherited from: adventurejs.Verb#getState

Get this verb's state or unstate.
handleActions()

Defined in: adventure/dictionary/Verb.js, line 1153

Inherited from: adventurejs.Verb#handleActions

handleActions attempts to call any verb actions that match the current assets and sentence structure.
handleFailure()

Defined in: adventure/dictionary/Verb.js, line 1620

Inherited from: adventurejs.Verb#handleFailure

handleFailure prints either a given fail message or a generic fail msg if one is specified.
handleSuccess()

Defined in: adventure/dictionary/Verb.js, line 1718

Inherited from: adventurejs.Verb#handleSuccess

handleSuccess prints the provided success message or a generic one that has been defined by author. It also checks direct and indirect objects for custom verb subscription on_success results and tryDestroy results.
hasState()

Defined in: adventure/dictionary/Verb.js, line 1914

Inherited from: adventurejs.Verb#hasState

Does this verb have state or unstate?
hasVerbSubscriptionConnection()

Defined in: adventure/dictionary/Verb.js, line 2064

Inherited from: adventurejs.Verb#hasVerbSubscriptionConnection

Test whether two assets are connected by this verb, for example a rope tied to a tree, or a computer plugged into a socket.
initialize()

Defined in: adventure/dictionary/Verb.js, line 1547

Inherited from: adventurejs.Verb#initialize

Todos: How does patchVerb handle initialization?

If Verb is a direction, initialize adds it to game.dictionary.directionLookup.
set(props) → {adventurejs.Verb}

Defined in: adventure/dictionary/Verb.js, line 1608

Inherited from: adventurejs.Verb#set

Parameters:

  • props Object
    A generic object containing properties to copy to the DisplayObject instance.
Provides a chainable shortcut method for setting a number of properties on the instance.

Returns:

adventurejs.Verb Returns the instance the method is called on (useful for chaining calls.)
setState()

Defined in: adventure/dictionary/Verb.js, line 1932

Inherited from: adventurejs.Verb#setState

Apply this verb's state or unstate to an asset.
setVerbSubscriptionConnection()

Defined in: adventure/dictionary/Verb.js, line 1941

Inherited from: adventurejs.Verb#setVerbSubscriptionConnection

Connect two assets that share a connection when acted upon by this verb. For example, in the case of 'plug computer into socket', each asset has the other asset's ID saved to its verb subscription like this:

computer.dov.plugIn.with_params.connections = ['socket']
socket.iov.plugIn.with_params.connections = ['computer']

This is one of two verb subscription properties that are related and very similar, and it's important to understand the distinction between them. ...with_assets defines which assets CAN BE connected. ...with_params.connections stores which assets ARE connected.

with_assets: computer.dov.plugIn.with_assets = ['socket']
connections: computer.dov.plugIn.with_params.connections = ['socket']
tryDestroyAfterUsing(object_of, asset) → {Object}

Defined in: adventure/asset/tryDestroyAfterUsing.js, line 7

Inherited from: adventurejs.Verb#tryDestroyAfterUsing

Parameters:

  • object_of String
  • asset Object
tryDestroyAfterUsing is the underlying function for tryDestroyDirectObjectAfterUsing and tryDestroyIndirectObjectAfterUsing.

Returns:

Object
tryDestroyDirectObjectAfterUsing(asset) → {Boolean|string}

Defined in: adventure/asset/tryDestroyDirectObjectAfterUsing.js, line 7

Inherited from: adventurejs.Verb#tryDestroyDirectObjectAfterUsing

Parameters:

  • asset Object
tryDestroyDirectObjectAfterUsing checks to see if the specified asset can only be used directly once with this verb by checking for asset.dov[this.name].then_destroy. This is intended to provide a hook for authors to easily destroy an object after a single use, such as a key that only works once and then breaks or disappears.

Returns:

Boolean | string
tryDestroyIndirectObjectAfterUsing(asset) → {Boolean|string}

Defined in: adventure/asset/tryDestroyIndirectObjectAfterUsing.js, line 7

Inherited from: adventurejs.Verb#tryDestroyIndirectObjectAfterUsing

Parameters:

  • asset Object
tryDestroyIndirectObjectAfterUsing checks to see if the specified asset can only be used indirectly once with this verb by checking for asset.iov[this.name].then_destroy. This is intended to provide a hook for authors to easily destroy an object after a single use, such as a key that only works once and then breaks or disappears.

Returns:

Boolean | string
tryToInferIndirectObject(direct_object, handle_input) → {Object}

Defined in: adventure/dictionary/Verb.js, line 1292

Inherited from: adventurejs.Verb#tryToInferIndirectObject

Parameters:

  • direct_object Object
  • handle_input Boolean
    If true, updates the global input object per standard specs used by most (but not all) of the verb instances that call this method.
tryToInferIndirectObject is called by some verbs when they receive a direct object with no indirect object, to test whether an indirect object can be inferred. In order to be inferred, indirect object must be in player inventory. If player hasn't already interacted with direct object and game.settings.infer_indirect_objects_only_after_interaction is true, tryToInferIndirectObject will fail regardless of other circumstances.

Returns:

Object
tryToPutThisInThatAspect(direct_object, preposition, indirect_object) → {Object}

Defined in: adventure/dictionary/Verb.js, line 1369

Inherited from: adventurejs.Verb#tryToPutThisInThatAspect

Parameters:

  • direct_object Object
  • preposition String
  • indirect_object Object
tryToPutThisInThatAspect checks to see if a asset can be placed within the specified aspect of another specified asset. For example, "put sword in stone" and "push stone into depression" would both be tested with this function.

Returns:

Object
unsetVerbSubscriptionConnection()

Defined in: adventure/dictionary/Verb.js, line 2009

Inherited from: adventurejs.Verb#unsetVerbSubscriptionConnection

Disconnect two assets that share a connection when acted upon by this verb. For example, in the case of 'plug computer into socket', each asset has the other asset's ID saved to its verb subscription like this:

computer.dov.plugIn.with_params.connections = ['socket']
socket.iov.plugIn.with_params.connections = ['computer']
validate()

Defined in: adventure/dictionary/Verb.js, line 1540

Inherited from: adventurejs.Verb#validate

Unused.

Properties  | 

accepts_direction :String

Defined in: adventure/dictionary/Phrase.js, line 27

Inherited from: adventurejs.Verb#accepts_direction

Currently unused.
accepts_number :String

Defined in: adventure/dictionary/Phrase.js, line 41

Inherited from: adventurejs.Verb#accepts_number

Currently unused.
accepts_string :String

Defined in: adventure/dictionary/Phrase.js, line 20

Inherited from: adventurejs.Verb#accepts_string

Currently unused.
adjectives :String

Defined in: adventure/dictionary/Verb.js, line 251

Inherited from: adventurejs.Verb#adjectives

Verb.adjectives are for direction verbs so that, for example, 'south' can be associated with 'southern' and 'southernly'.
article :Boolean

Defined in: adventure/dictionary/Verb.js, line 328

Inherited from: adventurejs.Verb#article

Default value: false

Set whether a direction can be referred to with an article, as in "there is a door to the north" vs "there is a door to starboard". This is a bit of mixed purpose because this property doesn't apply to the verb, but is stored in directionLookup for reference with directions.
dictionary :Object

Defined in: adventure/dictionary/Verb.js, line 144

Inherited from: adventurejs.Verb#dictionary

Default value: {}

A shortcut to the main Game Dictionary.
direction_preposition :Boolean

Defined in: adventure/dictionary/Verb.js, line 340

Inherited from: adventurejs.Verb#direction_preposition

Default value: ""

When player travels, this string may be prepended before the verb name, such as "you walk to the north"
doVerb :Getter

Defined in: adventure/dictionary/Verb.js, line 487

Inherited from: adventurejs.Verb#doVerb

Returns "do[Verb]This" for consistency with callAction()
doVerbFromThis :Getter

Defined in: adventure/dictionary/Verb.js, line 503

Inherited from: adventurejs.Verb#doVerbFromThis

Returns "do[Verb]FromThis" for consistency with callAction()
doVerbThatFromThis :Getter

Defined in: adventure/dictionary/Verb.js, line 543

Inherited from: adventurejs.Verb#doVerbThatFromThis

Returns "do[Verb]ThatFromThis" for consistency with callAction()
doVerbThatWithThis :Getter

Defined in: adventure/dictionary/Verb.js, line 527

Inherited from: adventurejs.Verb#doVerbThatWithThis

Returns "do[Verb]ThatWithThis" for consistency with callAction()
doVerbThis :Getter

Defined in: adventure/dictionary/Verb.js, line 495

Inherited from: adventurejs.Verb#doVerbThis

Returns "do[Verb]This" for consistency with callAction()
doVerbThisFromThat :Getter

Defined in: adventure/dictionary/Verb.js, line 535

Inherited from: adventurejs.Verb#doVerbThisFromThat

Returns "do[Verb]ThisFromThat" for consistency with callAction()
doVerbThisWithThat :Getter

Defined in: adventure/dictionary/Verb.js, line 519

Inherited from: adventurejs.Verb#doVerbThisWithThat

Returns "do[Verb]ThisWithThat" for consistency with callAction()
doVerbWithThis :Getter

Defined in: adventure/dictionary/Verb.js, line 511

Inherited from: adventurejs.Verb#doVerbWithThis

Returns "do[Verb]WithThis" for consistency with callAction()
enqueue_collections :Array

Defined in: adventure/dictionary/Verb.js, line 406

Inherited from: adventurejs.Verb#enqueue_collections

Default value: false

enqueue_collections if true allows a verb to unbundle the members of a collection in order to queue up separate actions for each. For example, "gems" is a collection that refers to three unique assets; "diamond", "emerald" and "ruby". If take.enqueue_collections is true, "take gems" will act individually on the diamond, the emerald and the ruby. Only applies to direct object.
extends :String

Defined in: adventure/dictionary/Verb.js, line 165

Inherited from: adventurejs.Verb#extends

Default value: ""

Extension verbs may perform some contextual logic before forwarding to another verb for the bulk of logic, such as "crawl" -> "go".
game :Object

Defined in: adventure/dictionary/Verb.js, line 137

Inherited from: adventurejs.Verb#game

Default value: {}

A reference back to the main Game object.
in_can_mean_on :Boolean

Defined in: adventure/dictionary/Verb.js, line 295

Inherited from: adventurejs.Verb#in_can_mean_on

Default value: false

Some types of objects can accept 'in' for 'on' interchangeably, such as 'sit in chair' / 'sit on chair', or 'lie in bed' / 'lie on bed'.
input_substitutions :Object

Defined in: adventure/dictionary/Verb.js, line 357

Inherited from: adventurejs.Verb#input_substitutions

Default value: {}

To simplify identifying verbs in input, specifically with regards to adverbs & prepositions, we can provide a list of synonyms for the verb. The parser will look for these synonyms in the input and replace them with the verb name. Then, the verb can handle the adverb/preposition as it sees fit.
is_compass_direction :Boolean

Defined in: adventure/dictionary/Verb.js, line 311

Inherited from: adventurejs.Verb#is_compass_direction

Default value: false

Set whether direction verb is a compass direction, meaning, it can be found on a compass rose.
is_direction :Boolean

Defined in: adventure/dictionary/Verb.js, line 304

Inherited from: adventurejs.Verb#is_direction

Default value: false

Set whether verb is a direction verb.
is_spatial_direction :Boolean

Defined in: adventure/dictionary/Verb.js, line 319

Inherited from: adventurejs.Verb#is_spatial_direction

Default value: false

Set whether direction verb is a relative direction such as those used on ships: port, starboard, etc. Also applies to left, right, forward, back, etc.
let_verb_handle_disambiguation :Boolean

Defined in: adventure/dictionary/Verb.js, line 275

Inherited from: adventurejs.Verb#let_verb_handle_disambiguation

Default value: false

Setting this to true allows you to write your own disambiguation script. Warning: going off road! Recommended for experienced Javascript users.
let_verb_handle_remaining_input :Boolean

Defined in: adventure/dictionary/Verb.js, line 284

Inherited from: adventurejs.Verb#let_verb_handle_remaining_input

Default value: false

When input is parsed, parse the verb and then pass the remainder of the input to the verb as a string, for the verb to act on. Chief example is: "oops xxx" where we don't want to parse xxx, we just want to let oops use it as a substitute for last turn's unknown input.
name :String

Defined in: adventure/dictionary/Verb.js, line 174

Inherited from: adventurejs.Verb#name

Default value: ""

String provided in Verb definition file (aka preverb).
Name :Getter

Defined in: adventure/dictionary/Verb.js, line 422

Inherited from: adventurejs.Verb#Name

Default value: []

Return uppercase name of the verb.
override_verb_failure_msg :String

Defined in: adventure/dictionary/Verb.js, line 369

Inherited from: adventurejs.Verb#override_verb_failure_msg

Default value: undefined

Provides a simple method for an author to override all failure messages for a verb with one generic string.
override_verb_success_msg :String

Defined in: adventure/dictionary/Verb.js, line 378

Inherited from: adventurejs.Verb#override_verb_success_msg

Default value: undefined

Provides a simple method for an author to override success messages for a verb with one generic string.
past_tense :String

Defined in: adventure/dictionary/Verb.js, line 191

Inherited from: adventurejs.Verb#past_tense

The past tense of the verb. May be used in output strings.
player_must_be :Object

Defined in: adventure/dictionary/Verb.js, line 259

Inherited from: adventurejs.Verb#player_must_be

Default value: {}

player_must_be sets conditions that the Player Character must meet in order for the Verb to act.
prettyname :String

Defined in: adventure/dictionary/Verb.js, line 182

Inherited from: adventurejs.Verb#prettyname

String provided in verb definition file. The prettyname is used for printing, and can include spaces, ie ask prints as "ask about".
related :Array

Defined in: adventure/dictionary/Verb.js, line 390

Inherited from: adventurejs.Verb#related

related is an array of related verbs, intended for use with tryToInferIndirectObject. Depending on a game's settings, some verbs may be applied automatically, but only when a user has already applied the verb themselves. For example, an author might not want a door to be opened automatically because the player should bring intention to the action of opening it, in order to appreciate the consequences. tryToInferIndirectObject considers whether a verb has previously been applied to an asset. In some cases, the verb's opposing verb may also be considered. For example, whether the player unlocked a door, or picked it, or locked it themselves, we consider them to have interacted with it.
requires_number :String

Defined in: adventure/dictionary/Phrase.js, line 48

Inherited from: adventurejs.Verb#requires_number

Currently unused.
requires_string :String

Defined in: adventure/dictionary/Phrase.js, line 34

Inherited from: adventurejs.Verb#requires_string

Currently unused.
state :String

Defined in: adventure/dictionary/Verb.js, line 198

Inherited from: adventurejs.Verb#state

state is an optional property for verbs that apply state to assets, such as close and lock. For example, "close door" will set door.is.closed to true. When used, state will contain the state to be set true on an asset. In the case of close, its state would be "closed".
state_strings :String

Defined in: adventure/dictionary/Verb.js, line 218

Inherited from: adventurejs.Verb#state_strings

state_strings is an optional property for verbs that is used to provide string substitutions for authors using the string substitution form of $(sink drain is| plugged or| unplugged). Because "unplugged" isn't a proper verb state, we'll use this as a reverse lookup to test whether the asset, sink_drain in this case, is subscribed to the relevant verb and has the specified state. state_strings only apply to direct objects.
synonyms :Getter/Setter

Defined in: adventure/dictionary/Verb.js, line 551

Inherited from: adventurejs.Verb#synonyms

Default value: []

synonyms provide alternate words for verbs, such as "get" for "take".
tryVerbFromThis :Getter

Defined in: adventure/dictionary/Verb.js, line 447

Inherited from: adventurejs.Verb#tryVerbFromThis

Returns "try[Verb]FromThis" for consistency with callAction()
tryVerbThatFromThis :Getter

Defined in: adventure/dictionary/Verb.js, line 479

Inherited from: adventurejs.Verb#tryVerbThatFromThis

Returns "try[Verb]ThatFromThis" for consistency with callAction()
tryVerbThatWithThis :Getter

Defined in: adventure/dictionary/Verb.js, line 463

Inherited from: adventurejs.Verb#tryVerbThatWithThis

Returns "try[Verb]ThatWithThis" for consistency with callAction()
tryVerbThis :Getter

Defined in: adventure/dictionary/Verb.js, line 431

Inherited from: adventurejs.Verb#tryVerbThis

Returns "try[Verb]This" for consistency with callAction()
tryVerbThisFromThat :Getter

Defined in: adventure/dictionary/Verb.js, line 471

Inherited from: adventurejs.Verb#tryVerbThisFromThat

Returns "try[Verb]ThisFromThat" for consistency with callAction()
tryVerbThisWithThat :Getter

Defined in: adventure/dictionary/Verb.js, line 455

Inherited from: adventurejs.Verb#tryVerbThisWithThat

Returns "try[Verb]ThisWithThat" for consistency with callAction()
tryVerbWithThis :Getter

Defined in: adventure/dictionary/Verb.js, line 439

Inherited from: adventurejs.Verb#tryVerbWithThis

Returns "try[Verb]WithThis" for consistency with callAction()
type :String

Defined in: adventure/dictionary/Verb.js, line 152

Inherited from: adventurejs.Verb#type

Default value: ""

May be used to help narrow verb selections in ambiguous situations.
unstate :String

Defined in: adventure/dictionary/Verb.js, line 208

Inherited from: adventurejs.Verb#unstate

unstate is an optional property for verbs that unset state from assets, such as open and unlock. For example, "open door" will set door.is.closed to false. When used, unstate will contain the state to be set false on an asset. In the case of open, its unstate would be "closed".
verb_noun_prep :Array

Defined in: adventure/dictionary/Verb.js, line 617

Inherited from: adventurejs.Verb#verb_noun_prep

Default value: []

For verb/noun pairs with a trailing preposition, or more likely a direction, such as "push bed north". When player input is parsed, they'll be concatenated, eg to "pushnorth bed".
verb_noun_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 781

Inherited from: adventurejs.Verb#verb_noun_prep_noun

Default value: []

For verb/preposition pairs separated by another word, usually a noun, such as "lock door with key" or "take sword from stone". When player input is parsed, they'll be concatenated, eg to "lockwith door key" or "takefrom sword stone".

Though verb_prep_noun and verb_noun_prep_noun look similar, the reason they are separate fields is because we have to use different regex patterns to find each type in user input.
verb_noun_prep_noun_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 870

Inherited from: adventurejs.Verb#verb_noun_prep_noun_prep_noun

Default value: []

For a verb phrase with three nouns and two prepositions. For example, in the phrase "tie boat to pier with rope", we're looking for "tie" and "to" and "with", and we would parse the phrase as "tietowith boat pier rope"
verb_noun_prep_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 828

Inherited from: adventurejs.Verb#verb_noun_prep_prep_noun

Default value: []

For a verb phrase with two nouns and two prepositions. For example, in the phrase "take skateboard from under bed", we're looking for "take" and "from" and "under", and we would parse the phrase as "takefromunder skateboard bed"
verb_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 658

Inherited from: adventurejs.Verb#verb_prep_noun

Default value: []

For verb/preposition pairs separated by a space, such as "go to" or "look at". When player input is parsed, they'll be concatenated, eg "go to" to "goTo".
verb_prep_noun_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 575

Inherited from: adventurejs.Verb#verb_prep_noun_prep_noun

Default value: []

For phrases like "jump from branch to vine" or "look at sun with glasses", where we have a verb + preposition followed by a noun and then another preposition
verb_prep_noun_prep_noun_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 916

Inherited from: adventurejs.Verb#verb_prep_noun_prep_noun_prep_noun

Default value: []

For a verb phrase with three nouns and three prepositions. For example, in the phrase "swing from branch to tree on vine", we're looking for "swing from with on".
verb_prep_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 699

Inherited from: adventurejs.Verb#verb_prep_prep_noun

Default value: []

For compound preps separated by spaces, verb/prep/prep, such as "get out of"
verb_prep_prep_prep_noun :Array

Defined in: adventure/dictionary/Verb.js, line 740

Inherited from: adventurejs.Verb#verb_prep_prep_prep_noun

Default value: []

For three part compound preps, verb/prep/prep/prep, such as "get out from behind"