Pre-release
AdventureJS Docs Downloads Bundler Devlog Score: 0 Moves: 0

Verb:empty

Instance of: AdventureJS.Dictionary.Verb

Defined in: Adventure/Dictionary/verbs/empty.js, line 5

Tutorials: Subscriptions HowAVerbIsBuilt HowAVerbWorks ModifyVerbs

Runtime node: game.dictionary.verbs.empty

Description

> empty satchel on desk
You empty the contents of the leather satchel on the desk.

Empty tries to empty the given direct object of its contents. Because Aspects can contain both Entities and Substances, emptying means that both the Entities and the Substances will fall out of the source Asset. If an Entity target is given, depending on its capacity, it may not be able to hold all of the contents of the source Asset. In this case, excess Entities and Substances will overflow onto the floor.

empty verb logic

Verb logic falls into a few recognizable patterns. Direction verbs tend to be simple and redirect to tryTravel(). Manipulation verbs test whether one asset is allowed to interact with another asset. Locomotion verbs test the player's current ability to move in a specified way. Many verbs are similar, but no two verbs are identical. Each verb has its quirks. If you would like to learn more about general verb logic, we recommend you see the Verb Anatomy and Verb Process pages. Verb phases and verb actions / reactions offer various hooks to customize verb behavior. If you find that you want still more flexibility, you may want to investigate the modifyVerb 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.

The following sections provide information that is specific to the verb empty, though they include many features which are common to most verbs.

  • Verb Subscriptions enable empty to act on specific assets, and provide a collection of properties for customizing those interactions.
  • Sentence Structures help filter player input by defining what sentence structures empty can handle.
  • Verb Phrases describe the direct and indirect objects that empty can handle.
  • Verb Phase Hooks offer a broad method for authors to hook into default logic and override it with custom code.
  • Verb Action Hooks offer a surgical method for authors to hook into empty's default logic and inject custom code.
  • Verb Reaction Hooks are like verb actions, but occur as secondary effects of successfully applying empty.
  • Verb Params contain properties that are distinct to empty. Not all verbs have params.
  • Verb Methods lists the methods that empty inherits from the Verb class.
  • Verb Properties lists the properties that empty inherits from the Verb class.

empty subscriptions

An asset must be subscribed to a verb for that verb to act upon that asset (with some exceptions). Though verbs are universal, each asset's verb subscriptions are distinct objects that can be used to customize how a given verb interacts with a given asset. To say it another way, a verb subscription is a collection of properties that defines how a verb should be applied to an asset; which allow authors to override a verb's default behaviors on a per-asset basis.

It's important to note that verb subscriptions need to be declared as direct or indirect, depending on whether the asset will be used as a direct object or indirect object. In the case of "unlock lock with key", the lock is the direct object and the key is the indirect object, and each asset needs to be subscribed to unlock in the appropriate way. (It's allowed, and a common pattern, to subscribe assets directly and indirectly to the same verb.)

Expand for example 
MyGame.createAsset({
  class: "Lock",
  name: "lock",
  dov: { unlock: true },
});
MyGame.createAsset({
  class: "Key",
  name: "key",
  iov: { unlock: true },
});

As shown in the above example, dov: { unlock: true } is the minimum that is required to subscribe an asset to a verb. However, verb subscriptions have many properties that can be used to customize how this verb is applied to this asset. (Setting any property eliminates the need to set verb: true. ) Below is a list of verb subscription properties that authors may find useful.

  • automatically {Boolean} Allows for some verbs to be performed automatically if context calls for it; for example, when unlocking a door in order to pass through it. An asset's verb subscription setting takes precedence over game settings.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { automatically: true } },
});
  • automatically_after_use {Boolean} This sets it so that a verb can only be applied automatically after a player has already used it manually. This is to prevent automatic use of tools from breaking puzzles. For example, imagine one door with many keys but only one that works; if choosing the right key is part of the puzzle, this option prevents players from simply saying "unlock door" and having the right key automatically selected for them. When setting automatically_after_use to true you don't also have to set automatically.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { automatically_after_use: true } },
});
  • enabled {Boolean} Verb subscriptions are enabled by default, but can be disabled manually. Temporarily disabling a verb subscription can be a useful method for controlling an asset. For example, you might disable open for a door that needs another action to be completed before it can be opened.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { enabled: true } },
});
    Individual verb subscriptions can be enabled / disabled via asset.setDOV(verbname) and asset.unsetDOV(verbname).
  • on_success {String|Array|Function} If this property returns a string, the string will be appended to the verb's default success message. Though a string is expected, this property is handled by getStringArrayFunction().
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { on_success: "You empty the universal widget. " } },
});
  • on_first_success {String|Array|Function} If this property returns a string, the string will be appended to the verb's default success message the first time it is applied to this asset. Though a string is expected, this property is handled by getStringArrayFunction().
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { on_first_success: "You empty the universal widget for the first time. " } },
});
  • on_failure {String|Array|Function} If this property returns a string, the string will be appended to the verb's default failure message. Though a string is expected, this property is handled by getStringArrayFunction().
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { on_failure: "You failed to empty the universal widget. " } },
});
  • on_first_failure {String|Array|Function} If this property returns a string, the string will be appended to the verb's default failure message the first time it is applied to this asset. Though a string is expected, this property is handled by getStringArrayFunction().
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { on_first_failure: "You failed to empty the universal widget this first time. " } },
});
  • once {Boolean} if true, the verb can only be applied once to the asset. The verb subscription will be disabled after use. No special message will be printed, but subsequent attempts to use the verb on this asset will explain why it can't be used again.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { once: true } },
});
  • then_destroy {Boolean} If this property is true, the asset will be destroyed after the verb is applied.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { then_destroy: true } },
});
  • on_destroy {String|Array|Function} If this property returns a string, the asset will be destroyed after the verb is applied, and the string will be appended to the verb's success message. Though a string is expected, this property is handled by getStringArrayFunction().
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { 
    empty: { 
      then_destroy: true, 
      on_destroy: "The widget is destroyed!" 
    } 
  },
});
  • with_anything {Boolean} Pertains only to indirect objects. If true, this asset can be used as an indirect object of this verb with any direct object.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  iov: { empty: { with_anything: true } },
});
  • with_assets {Boolean} Use to specify particular assets that can interact with this one using the given verb. For example "unlock door with key" where the specified key is the only asset that can unlock door. This works distinctly for direct and indirect verb subscriptions. So, for instance, in "unlock door with key", the door might have a direct object subscription, while the key has an indirect object description.
    Expand for example 
    MyGame.createAsset({
  class: "Door",
  name: "gold door",
  dov: { unlock: { with_assets: [ "gold key" ] } },
});
MyGame.createAsset({
  class: "Key",
  name: "gold key",
  iov: { unlock: { with_assets: [ "gold door" ] } },
});
  • with_classes {Array} Use to specify particular classes that can interact with this asset using the given verb. For example "unlock door with skeleton key" where any instance of the class SkeletonKey can unlock door. This works distinctly for direct and indirect verb subscriptions. So, for instance, in "unlock door with skeleton key", the door might have a direct object subscription, while the key has an indirect object description.
    Expand for example 
    MyGame.createAsset({
  class: "Door",
  name: "red door",
  dov: { unlock: { with_classes: [ "SkeletonKey" ] } },
});
MyGame.createAsset({
  class: "SkeletonKey",
  name: "skeleton key",
  iov: { unlock: { with_classes: [ "Door", "Chest" ] } },
});
  • with_nothing {Array} Pertains only to direct objects. If true, the specified verb can be applied to the direct object without the use of any indirect object.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { with_nothing: true } },
});
  • with_params {Object} Used to contain a set of parameters that are specific to this particular verb. For example, plugIn includes with_params.max_connections for setting limits on how many other assets this asset can be plugged into. See the with_params section on this page to learn more about empty's parameters.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { with_params: { empty_property: value } } },
});
  • with_prepositions {Array} Use to limit the prepositions that can be used with this asset. For instance: "knock over umbrella stand" might fail with a message of "you can't knock over the umbrella stand"; setting umbrella_stand.dov.knock.with_prepositions = ["over"] will allow the action to succeed.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { empty: { with_prepositions: [ "through", "over" ] } },
});
  • doBeforeTry {Function} Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more about empty's verb phases.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { 
    empty: { 
      doBeforeTry: function () {
        console.log("empty.doBeforeTry");
      },
    } 
  },
});
  • doAfterTry {Function} Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more about empty's verb phases.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { 
    empty: { 
      doAfterTry: function () {
        console.log("empty.doAfterTry");
      },
    } 
  },
});
  • doBeforeSuccess {Function} Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more about empty's verb phases.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { 
    empty: { 
      doBeforeSuccess: function () {
        console.log("empty.doBeforeSuccess");
      },
    } 
  },
});
  • doAfterSuccess {Function} Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more about empty's verb phases.
    Expand for example 
    MyGame.createAsset({
  class: "Entity",
  name: "universal widget",
  dov: { 
    empty: { 
      doAfterSuccess: function () {
        console.log("empty.doAfterSuccess");
      },
    } 
  },
});

Notes

  • To learn more about working with verb subscriptions, see Verb Subscriptions.
  • These are most, but not all, of the properties of a verb subscription. For full reference, see the VerbSubscription class.

empty sentence structures

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

The parser uses multiple filtering methods to try to channel player input into useable tokens. Sentence structures are defined for each verb in order to narrow down the input that the verb can handle. 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. Input that isn't accepted will return a warning to the player.

A note about adverbs: though the parser does handle some adverbs, such as "carefully examine tiara" and "turn left", it excludes them from consideration in sentence structures. Due to the slipperyness of the English language, an adverb can appear in multiple positions in a sentence while still describing the same verb, which presents enough possible word combinations to make sentence structures less useful as a filtering tool. Instead, the parser puts adverbs aside and handles them separately.

Notes

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

empty phrases

phrase1:
{
  accepts_noun:true,
  requires_noun: true,
  noun_must_be:
  {
    known: true,
    tangible: true,
    present_if_tangible: true,
    reachable_if_tangible: true,
  },
},
phrase2:
{
  accepts_noun:true,
  noun_must_be:
  {
    known: true,
    tangible: true,
    present_if_tangible: true,
    reachable_if_tangible: true,
  },
  accepts_preposition:true,
  requires_preposition: true,
},

The AdventureJS parser uses multiple filtering methods to try to interpret player input. A verb's phrases may consist of a noun and/or a preposition. Whether any noun is defined as a direct or indirect object is up to that verb's unique logic. Each verb defines a unique set of phrases depending on what its logic can handle. Verbs may handle zero, one, two, or three nouns. The nested noun_must_be object sets conditional qualifiers to help narrow down assets that the verb might act upon. Input that isn't accepted will return a warning to the player.

Notes

  • It is possible for authors to modify a verb's phrases through the use of modifyVerb.
  • 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.

empty phase hooks

Verb phase hooks let authors override verb subscriptions for specific assets when empty is applied to them. This is a broad method for customizing verb/noun interactions on a per-asset basis. For example, an author might supply completely different logic for "throw feather" vs "throw baseball" vs "throw anvil".

When empty.do() is called, it attempts to run a sequence of methods, or phases, as listed below. The four hooks have no default logic of their own but provide methods to inject custom code at any point in the life cycle of the verb action. See below for examples of how to use verb phases for empty.

do

    doBeforeTry hook

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

    doTry handles logic to determine if empty can be applied

    doAfterTry hook

     
    MyGame.createAsset({
  class: "Entity",
  name: "This Asset",
  dov: {
    empty: {
      doAfterTry: function( params )
      {
        let msg = `You just tried to empty ${this.article_name}! `;
        this.game.print(msg);
        return;
      },
    },
  },
});

    doBeforeSuccess hook

     
    MyGame.createAsset({
  class: "Entity",
  name: "This Asset",
  dov: {
    empty: {
      doBeforeSuccess: function( params )
      {
        let msg = `You're about to succeed in performing empty on ${this.article_name}. `;
        this.game.print(msg);
        return;
      },
    },
  },
});

    doSuccess handles state changes and printing messages

    doAfterSuccess hook

     
    MyGame.createAsset({
  class: "Entity",
  name: "This Asset",
  dov: {
    empty: {
      doAfterSuccess: function( params )
      {
        let msg = `You succeeded in performing empty on ${this.article_name}. `;
        this.game.print(msg);
        return;
      },
    },
  },
});
Expand for example

Assets must have separate direct and indirect verb subscriptions. Consider this singing sword, which is directly subscribed to the verb "take". We want our 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()
      {
        let msg = "The sword begins to vibrate as your hand curls around its haft. ";
        MyGame.print( msg );
      },
      doAfterSuccess: function()
      {
        let msg = "The sword bursts into song in your hand. ";
        MyGame.print( msg );
      },
    },
  },
});

Now consider this stone, which is indirectly subscribed to "remove". We want to print messages when the sword is removed from it, so we'll hook into the stone's indirect object subscription. We could put this code on either object. A case like this comes down to author's choice. 

MyGame.createAsset({
  class: "Entity",
  name: "stone",
  iov: {
    remove: 
    {
      doBeforeTry: function()
      {
        let msg = "Will the stone judge you worthy enough to remove the sword? "
        MyGame.print( msg );
      },
      doAfterSuccess: function()
      {
        let msg = "With the sword removed, the stone bursts into rubble! ";
        MyGame.print( msg );
        MyGame.destroyAsset(this);
      },      
    },
  },
});

Notes

empty action hooks

Every asset referred to in the turn's input is checked for verb action hooks. These hooks allow authors to inject custom code or print custom text during verb operations. There are two distinct approaches to defining verb actions, designed to accommodate different levels of scripting experience. Authors may use whichever approach they find most comfortable. For more details, see Action Hooks.

  1. Simple approach: Define string properties such as asset.do_empty. If AdventureJS finds a string, it prints it instead of the default output for that turn. This option is best for authors who want to customize output without writing code.
  2. Advanced approach: Define method properties such as asset.doEmpty(). If a method is found, it is called with a parameter object containing any relevant assets from the input (e.g., asset.doEmpty({asset1,asset2}) ). The author may use or ignore these parameters. This approach offers complete control over the turn’s outcome: authors can add conditional logic, force success or failure, or revise the default output.

Expand any item to see code examples. Methods are called with a parameter object in the form of action({asset1, asset2, params}) which authors may use or ignore.

tryEmptyThis

Called on This asset in a phrase such as "empty this". Since no indirect object is given, we treat the player character as an indirect object.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  tryEmptyThis: function () {
    let msg = "Found custom method at thing_one.tryEmptyThis()";
    MyGame.print(msg);
  },
});
  2. To limit the method to act only on a certain asset, change the value of tryEmptyThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  tryEmptyThis: {
    "Player Two": function () {
      let msg = "Found custom method at thing_one.tryEmptyThis['Player Two']()";
      MyGame.print(msg);
    },
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  tryEmptyThis: function ({asset1}) {
    switch (asset1.name) {
      case "Player Two":
        let msg = "Found custom method at thing_one.tryEmptyThis('Player Two')";
        MyGame.print(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
doEmptyThis

Called on This asset in a phrase such as "empty this". Since no indirect object is given, we treat the player character as an indirect object.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  doEmptyThis: function () {
    let msg = "Found custom method at thing_one.doEmptyThis()";
    MyGame.print(msg);
  },
});
  2. To limit the method to act only on a certain asset, change the value of doEmptyThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  doEmptyThis: {
    "Player Two": function () {
      let msg = "Found custom method at thing_one.doEmptyThis['Player Two']()";
      MyGame.print(msg);
    },
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  doEmptyThis: function ({asset1}) {
    switch (asset1.name) {
      case "Player Two":
        let msg = "Found custom method at thing_one.doEmptyThis('Player Two')";
        MyGame.print(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
tryEmptyThisPrepositionThat

Called on This asset in a phrase such as "empty this with that", where This is the direct object and That is the indirect object.

tryEmptyThisPrepositionThat mirrors tryEmptyThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  tryEmptyThisWithThat: function () {
    let msg = "Found custom method at thing_one.tryEmptyThisWithThat()";
    MyGame.print(msg);    
  },
});
  2. To limit the method to act only on a certain asset, change the value of tryEmptyThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  tryEmptyThisWithThat: { 
    "Thing Two": function (params) {
      let msg = "Found custom method at thing_one.tryEmptyThisWithThat['Second Thing']()";
      MyGame.print(msg);
    }
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  tryEmptyThisWithThat: function ({asset1}) {
    switch (asset1.name) {
      case "Thing Two":
        let msg = "Found custom method at thing_one.tryEmptyThisWithThat('Second Thing')";
        MyGame.print(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
doEmptyThisPrepositionThat

Called on This asset in a phrase such as "empty this with that", where This is the direct object and That is the indirect object.

doEmptyThisPrepositionThat mirrors doEmptyThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  doEmptyThisWithThat: function () {
    let msg = "Found custom method at thing_one.doEmptyThisWithThat()";
    MyGame.print(msg);    
  },
});
  2. To limit the method to act only on a certain asset, change the value of doEmptyThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  doEmptyThisWithThat: { 
    "Thing Two": function (params) {
      let msg = "Found custom method at thing_one.doEmptyThisWithThat['Second Thing']()";
      MyGame.print(msg);
    }
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing One",
  doEmptyThisWithThat: function ({asset1}) {
    switch (asset1.name) {
      case "Thing Two":
        let msg = "Found custom method at thing_one.doEmptyThisWithThat('Second Thing')";
        MyGame.print(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
tryEmptyThatPrepositionThis

Called on That asset in a phrase such as "empty this with that", where That is the indirect object and This is the direct object.

tryEmptyThatPrepositionThis mirrors tryEmptyThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing Two",
  tryEmptyThatWithThis: function () {
    let msg = "Found custom method at thing_two.tryEmptyThatWithThis()";
    MyGame.print(msg);    
  },
});
  2. To limit the method to act only on a certain asset, change the value of tryEmptyThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing Two",
  tryEmptyThatWithThis: { 
    "Thing One": function (params) {
      let msg = "Found custom method at thing_two.tryEmptyThatWithThis['First Thing']()";
      MyGame.print(msg);
    }
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing Two",
  tryEmptyThatWithThis: function ({asset1}) {
    switch (asset1.name) {
      case "Thing One":
        let msg = "Found custom method at thing_two.tryEmptyThatWithThis('First Thing')";
        MyGame.print(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
doEmptyThatPrepositionThis

Called on That asset in a phrase such as "empty this with that", where That is the indirect object and This is the direct object.

doEmptyThatPrepositionThis mirrors doEmptyThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing Two",
  doEmptyThatWithThis: function () {
    let msg = "Found custom method at thing_two.doEmptyThatWithThis()";
    MyGame.print(msg);    
  },
});
  2. To limit the method to act only on a certain asset, change the value of doEmptyThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing Two",
  doEmptyThatWithThis: { 
    "Thing One": function (params) {
      let msg = "Found custom method at thing_two.doEmptyThatWithThis['First Thing']()";
      MyGame.print(msg);
    }
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun. 
    MyGame.createAsset({
  class: "Entity",
  name: "Thing Two",
  doEmptyThatWithThis: function ({asset1}) {
    switch (asset1.name) {
      case "Thing One":
        let msg = "Found custom method at thing_two.doEmptyThatWithThis('First Thing')";
        MyGame.print(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});

Notes

  • Verb action hooks are specific to their particular verb.
  • Which verb action hooks are called depends on the structure of the player's input. Hooks are checked for every asset in the input, including the player character. Which hooks are called depends on the sentence structure of the player's input:
    1. Single-object input (e.g., "empty this"): The hook is called on This asset. Since no indirect object is specified, the player character is treated as an indirect object.
    2. Multiple-object input (e.g., "empty this with that"): The hook is called depending on the object’s role in the phrase. doThisPrepositionThat runs on This direct object, while doThatPrepositionThis runs on That indirect object. These are equivalent, and you may place code on whichever asset makes sense to you. Any preposition can be used to define a unique response, for example empty with vs empty on.
  • Sentence structures are commonly mutated during the doTry verb phase, so try and do may act on different sentence structures.
  • Verb actions are extremely granular and depend on specific combinations of assets and prepositions. Verb actions are called during a verb's doTry and doSuccess phases, which lets them override a verb's operations. Use them if you want to customize output for specific inputs, but beware of that granularity. Consider doTake(): it's called when a player takes an asset, so you might want to hook into that; but many other verbs may also move the asset into the player. If you want to catch any method that moves an asset into the player, you may find the doMoveThisToThat verb reaction more broadly applicable.
  • By default, string properties override a turn's output, but they can also be set to append or prepend the turn's default output. See verb action hooks for more information.
  • Verb reaction hooks are functionally the same as action hooks. The only difference is that reaction hooks are not specific to any verb.
  • Verb phase hooks are a different form of hook that allows authors to override entire verb phases.

empty reaction hooks

Every asset affected by the turn is checked for verb reaction hooks. These hooks allow authors to inject custom code or print custom text during verb operations. Verb reactions are subject to String Array Function, which means they can be set to any of those three types. Authors may use whichever they find most comfortable. See verb reaction hooks for details.

  1. String: If AdventureJS finds a string, it prints it instead of the default output for that turn. This option is best for authors who want to customize output without writing code.
  2. Array: If AdventureJS finds an array, it will print an item from the array, using randomization or not according to global settings.
  3. Functions: Set a function like asset.doMoveThisToThat(). If a function is found, it is called with a parameter object containing any relevant assets from the input (e.g., asset.doMoveThisToThat({asset1}) ). The author may use or ignore these parameters. This approach offers complete control over the turn’s outcome: authors can add conditional logic, force success or failure, or revise the default output.

Expand any item to see code examples. All methods are called with a parameter object in the form of asset.reaction({asset1, asset2, params}) which authors may use or ignore.

doMoveThisFromThat

Called on This Entity asset when it is removed from That Entity asset.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what This is removed from. 
    MyGame.createAsset({
  class: "Dagger",
  name: "Jeweled Dagger",
  doMoveThisFromThat: function () {
    let msg = "The jeweled dagger slides free. ";
    MyGame.overrideOutput(msg);
  },
});
  2. To limit the method to removing This from a certain That, you can change the value of doMoveThisFromThat from a method to an object, use That asset name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Dagger",
  name: "Jeweled Dagger",
  doMoveThisFromThat: {
    "Leather Scabbard": function () {
      let msg = "The jeweled dagger slides free from the leather scabbard. ";
      MyGame.overrideOutput(msg);
    },
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. 
    MyGame.createAsset({
  class: "Dagger",
  name: "Jeweled Dagger",
  doMoveThisFromThat: function ({asset1}) {
    switch (asset1.name) {
      case "Leather Scabbard":
        let msg = "The jeweled dagger slides smoothly from the leather scabbard. ";
        MyGame.overrideOutput(msg)
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
doMoveThatFromThis

Called on This Entity asset when That Entity asset is removed from it.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which That is removed from This. 
    MyGame.createAsset({
  class: "Chest",
  name: "Ornate Chest",
  doMoveThatFromThis: function () {
    let msg = "The chest snaps at you! ";
    MyGame.overrideOutput(msg);
  },
});
  2. To limit the method to act only when removing a certain That from This, you can change the value of doMoveThisFromThat from a method to an object, use That asset name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Chest",
  name: "Ornate Chest",
  doMoveThatFromThis: {
    "Leather Scabbard": function () {
      let msg = "The ornate chest snaps at you when you remove the leather scabbard from it. ";
      MyGame.overrideOutput(msg);
    },
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. 
    MyGame.createAsset({
  class: "Chest",
  name: "Ornate Chest",
  doMoveThatFromThis: function ({asset1}) {
    switch (asset1.name) {
      case "Leather Scabbard":
        let msg = "The ornate chest quivers at you when you remove the leather scabbard from it. ";
        MyGame.overrideOutput(msg)
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
doMoveThisToThat

Called on This Entity asset when it is moved to That Entity asset.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what This is moved to. 
    MyGame.createAsset({
  class: "Torch",
  name: "burning brand",
  doMoveThisToThat: function () {
    let msg = "The burning brand scorches its surroundings. ";
    MyGame.appendOutput(msg);
  },
});
  2. To limit the method to act only when moving This to a certain That, you can change the value of doMoveThisToThat from a method to an object, use That asset name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Torch",
  name: "burning brand",
  doMoveThisToThat: {
    "funeral pyre": function () {
      let msg = "The pyre bursts into flame! ";
      // add logic to change state of pyre
      MyGame.appendOutput(msg);
    },
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. 
    MyGame.createAsset({
  class: "Torch",
  name: "burning brand",
  doMoveThisToThat: function ({asset1}) {
    switch (asset1.name) {
      case "funeral pyre":
        let msg = "The pyre bursts into flame! ";
        // add logic to change state of pyre
        MyGame.appendOutput(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});
doMoveThatToThis

Called on an Entity asset when another asset is moved to it. Called on This Entity asset when That Entity asset is moved to it.

  1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which That is moved to This. 
    MyGame.createAsset({
  class: "Chest",
  name: "Ornate Chest",
  doMoveThatToThis: function () {
    let msg = "The chest snaps at you but accepts your offering. ";
    MyGame.overrideOutput(msg);
  },
});
  2. To limit the method to act only when moving a certain That to This, you can change the value of doMoveThatToThis from a method to an object, use That asset name as a key on the object, and set that key's value to a method instead. 
    MyGame.createAsset({
  class: "Chest",
  name: "Ornate Chest",
  doMoveThatToThis: {
    "Golden Idol": function () {
      let msg = "The ornate chest accepts the golden idol and belches loudly. ";
      MyGame.overrideOutput(msg);
    },
  },
});
  3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. 
    MyGame.createAsset({
  class: "Chest",
  name: "Ornate Chest",
  doMoveThatToThis: function ({asset1}) {
    switch (asset1.name) {
      case "Golden Idol":
        let msg = "The ornate chest accepts the golden idol and belches loudly. ";
        MyGame.overrideOutput(msg);
        break;
      default:
        // do nothing and allow the default result
        break;
    }
    return;
  },
});

Notes

  • See verb reaction hooks for more details.
  • Reaction hooks aren't specific to any particular verb.
  • Verb reactions fire at the end of a turn after the verb's doSuccess phase. Many verbs may call the same reactions. For instance, any verb that moves an asset into the player calls doMoveThisToThat. This makes them more broadly applicable than verb actions and lets you customize the turn's output regardless of what verb is used.
  • Verb action hooks work the same way as reaction hooks, but are specific to their particular verb.
  • Verb phase hooks are a different form of hook that allows authors to override entire verb phases.

empty params

Some verbs may have custom params. When an asset subscribes to such a verb, the verb's params are mirrored in the asset's verb subscription, where they are unique to that asset. To put it another way: while each verb may have a unique set of params, each asset may have its own customized version of those params. 

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. The author can achieve that by customizing the cord's subscription to plugIn.

Expand for example 
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'], }, },
})

In this example, the power cord verb subscription's max_connections setting overrides the verb's max_connections setting, allowing the player to plug the power cord into two assets. The computer and the outlet don't have any custom value set for max_connections; they'll receive the default value, meaning they each can have only one asset plugged into them.

Notes

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

Private Constructor:

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

empty 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. See Advanced Verbs: Modify Verbs for information on how to modify predefined verbs.

Inherited Overrides

Index

Methods:

Properties:

Methods Collapse all  |  Expand all

conjugate
conjugate()

Defined in: Adventure/Dictionary/Verb.js, line 3127

Inherited from: AdventureJS.Dictionary.Verb#conjugate

Return name of the verb taking into consideration third-person singular present tense for subjects using nonhuman / male / female pronouns (he/she/it) or proper name.
do
do()

Defined in: Adventure/Dictionary/Verb.js, line 1298

Inherited from: AdventureJS.Dictionary.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 and an optional debug statement 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 doesn't have to use all of these methods. Some specialized Verbs including 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
doSuccess()

Defined in: Adventure/Dictionary/Verb.js, line 2220

Inherited from: AdventureJS.Dictionary.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
doTry()

Defined in: Adventure/Dictionary/Verb.js, line 1766

Inherited from: AdventureJS.Dictionary.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
enqueueCollection()

Defined in: Adventure/Dictionary/Verb.js, line 2545

Inherited from: AdventureJS.Dictionary.Verb#enqueueCollection

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

Defined in: Adventure/Dictionary/Verb.js, line 698

Inherited from: AdventureJS.Dictionary.Verb#findQualifiedSynonym

Parameters:

  • value String
This is in support of saving verb synonyms as objects, in order to have distinct past tense and gerund for synonyms. This scheme is currently unfinished.
getState
getState()

Defined in: Adventure/Dictionary/Verb.js, line 2927

Inherited from: AdventureJS.Dictionary.Verb#getState

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

Defined in: Adventure/Dictionary/Verb.js, line 1797

Inherited from: AdventureJS.Dictionary.Verb#handleActions

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

Defined in: Adventure/Dictionary/Verb.js, line 2589

Inherited from: AdventureJS.Dictionary.Verb#handleFailure

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

Defined in: Adventure/Dictionary/Verb.js, line 2698

Inherited from: AdventureJS.Dictionary.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.
handleTryResults
handleTryResults()

Defined in: Adventure/Dictionary/Verb.js, line 1781

Inherited from: AdventureJS.Dictionary.Verb#handleTryResults

When handleActions calls a try action, if that action returns a string, we take it to mean that an author is returning a message when a user tries a specific action, which means we're going to print the string and return false to end processing for the turn.
hasState
hasState()

Defined in: Adventure/Dictionary/Verb.js, line 2918

Inherited from: AdventureJS.Dictionary.Verb#hasState

Does this verb have state or unstate?
hasStructure
hasStructure() → {boolean}

Defined in: Adventure/Dictionary/Verb.js, line 2945

Inherited from: AdventureJS.Dictionary.Verb#hasStructure

Test if this verb supports the given sentence structure.

Returns:

boolean
hasVerbSubscriptionConnection
hasVerbSubscriptionConnection()

Defined in: Adventure/Dictionary/Verb.js, line 3076

Inherited from: AdventureJS.Dictionary.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
initialize()

Defined in: Adventure/Dictionary/Verb.js, line 2516

Inherited from: AdventureJS.Dictionary.Verb#initialize

Todos: How does modifyVerb handle initialization?

If Verb is a direction, initialize adds it to game.dictionary.direction_lookup.
isIntransitive
isIntransitive()

Defined in: Adventure/Dictionary/Verb.js, line 2909

Inherited from: AdventureJS.Dictionary.Verb#isIntransitive

Verb can be intransitive if it doesn't require a noun.
set
set(props) → {Object}

Defined in: Adventure/Dictionary/Verb.js, line 2577

Inherited from: AdventureJS.Dictionary.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:

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

Defined in: Adventure/Dictionary/Verb.js, line 2936

Inherited from: AdventureJS.Dictionary.Verb#setState

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

Defined in: Adventure/Dictionary/Verb.js, line 2955

Inherited from: AdventureJS.Dictionary.Verb#setVerbConnection

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 like this:

computer.is.connected_by.plugIn.to_iov = ['socket']
socket.is.connected_by.plugIn.to_dov = ['computer']
tryDestroyAfterUsing
tryDestroyAfterUsing(object_of, asset) → {Object}

Defined in: Adventure/Asset/tryDestroyAfterUsing.js, line 6

Inherited from: AdventureJS.Dictionary.Verb#tryDestroyAfterUsing

Parameters:

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

Returns:

Object
tryDestroyDirectObjectAfterUsing
tryDestroyDirectObjectAfterUsing(asset) → {Boolean|string}

Defined in: Adventure/Asset/tryDestroyDirectObjectAfterUsing.js, line 6

Inherited from: AdventureJS.Dictionary.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
tryDestroyIndirectObjectAfterUsing(asset) → {Boolean|string}

Defined in: Adventure/Asset/tryDestroyIndirectObjectAfterUsing.js, line 6

Inherited from: AdventureJS.Dictionary.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
tryMoveThisToThat
tryMoveThisToThat(preposition, indirect_object) → {Object}

Defined in: Adventure/Assets/Tangibles/Entity/tryMoveThisToThat.js, line 5

Inherited from: AdventureJS.Dictionary.Verb#tryMoveThisToThat

Parameters:

  • preposition String
  • indirect_object Object
tryMoveThisToThat checks to see if one 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
tryMoveThisToThatOrParent
tryMoveThisToThatOrParent(target_aspect, target_asset) → {Object}

Defined in: Adventure/Assets/Tangibles/Entity/tryMoveThisToThatOrParent.js, line 5

Inherited from: AdventureJS.Dictionary.Verb#tryMoveThisToThatOrParent

Parameters:

  • target_aspect String
  • target_asset Object
tryMoveThisToThatOrParent checks to see if one asset can be placed within the specified aspect of another specified asset, and if it fails, tries to put the asset inside the other asset's room.

Returns:

Object
tryPhaseHook
tryPhaseHook(phase) → {*}

Defined in: Adventure/Dictionary/Verb.js, line 2237

Inherited from: AdventureJS.Dictionary.Verb#tryPhaseHook

Parameters:

  • phase *

Returns:

*
tryToInferIndirectObject
tryToInferIndirectObject(options) → {Object}

Defined in: Adventure/Dictionary/Verb.js, line 2325

Inherited from: AdventureJS.Dictionary.Verb#tryToInferIndirectObject

Parameters:

  • options Object
    An object of options.
    Properties
    • 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.
    • context Object
      The subject, usually player, could be an NPC.
    • allow_inference_on_first_use Boolean
      Optional param to set whether inference should work on first use.
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. The classic example is "unlock door" where the key must 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.allow_inference_on_first_use is false, tryToInferIndirectObject will fail regardless of other circumstances. The function only returns one indirect preposition: with. As in, "unlock door with key" or "feed pony with hay".

Returns:

Object
unsetVerbConnection
unsetVerbConnection()

Defined in: Adventure/Dictionary/Verb.js, line 3016

Inherited from: AdventureJS.Dictionary.Verb#unsetVerbConnection

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 like this:

computer.is.connected_by.plugIn.to_iov = ['socket']
socket.is.connected_by.plugIn.to_dov = ['computer']
validate
validate()

Defined in: Adventure/Dictionary/Verb.js, line 2509

Inherited from: AdventureJS.Dictionary.Verb#validate

Unused.

Properties  | 

accepts_adverbs
accepts_adverbs :Array

Defined in: Adventure/Dictionary/Verb.js, line 445

Inherited from: AdventureJS.Dictionary.Verb#accepts_adverbs

Default value: []

accepts_structures
accepts_structures :Array

Defined in: Adventure/Dictionary/Verb.js, line 439

Inherited from: AdventureJS.Dictionary.Verb#accepts_structures

Default value: []

adjectives
adjectives :String

Defined in: Adventure/Dictionary/Verb.js, line 312

Overrides from: AdventureJS.Dictionary.Verb#adjectives

Verb.adjective is for direction verbs so that, for example, 'south' can be described as 'southerly'.
allow_iov_on_iov
allow_iov_on_iov :Array

Defined in: Adventure/Dictionary/Verb.js, line 513

Inherited from: AdventureJS.Dictionary.Verb#allow_iov_on_iov

Default value: false

Most verbs use a pattern of dov operates on iov. Think, "unlock door with key". Some verbs use two objects that would appear to follow the same pattern until you consider an implied direct object. In "write on paper with pen" and "type on paper with typewriter", there is actually an implied direct object - the thing to be written or typed - which makes paper and pen/typewriter both indirect. If true, allow_iov_on_iov allows for some additional checking when querying whether a verb is allowed to operate on a particular pair of assets.
article
article :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 401

Inherited from: AdventureJS.Dictionary.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 direction_lookup for reference with directions.
can_span
can_span :String

Defined in: Adventure/Dictionary/Verb.js, line 249

Inherited from: AdventureJS.Dictionary.Verb#can_span

Locomotion verbs (ones that move the player) may result in player moving from object A to object B. When that occurs, output may vary depending on whether player would logically climb down off object A before climbing on object B, vs directly spanning the gap from object A to object B.
can_try
can_try :String

Defined in: Adventure/Dictionary/Verb.js, line 212

Inherited from: AdventureJS.Dictionary.Verb#can_try

Determines whether this verb supports player useing "try to verb" or "try verbing".
default_direction
default_direction :String

Defined in: Adventure/Dictionary/Verb.js, line 163

Inherited from: AdventureJS.Dictionary.Verb#default_direction

Default value: ""

Some locomotion verbs supplied without a preposition may use a default direction, for instance climb + up.
dictionary
dictionary :Object

Defined in: Adventure/Dictionary/Verb.js, line 143

Inherited from: AdventureJS.Dictionary.Verb#dictionary

Default value: {}

A shortcut to the main Game Dictionary.
direction_preposition
direction_preposition :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 413

Inherited from: AdventureJS.Dictionary.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
doVerb :Getter

Defined in: Adventure/Dictionary/Verb.js, line 609

Inherited from: AdventureJS.Dictionary.Verb#doVerb

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

Defined in: Adventure/Dictionary/Verb.js, line 625

Inherited from: AdventureJS.Dictionary.Verb#doVerbFromThis

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

Defined in: Adventure/Dictionary/Verb.js, line 665

Inherited from: AdventureJS.Dictionary.Verb#doVerbThatFromThis

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

Defined in: Adventure/Dictionary/Verb.js, line 649

Inherited from: AdventureJS.Dictionary.Verb#doVerbThatWithThis

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

Defined in: Adventure/Dictionary/Verb.js, line 617

Inherited from: AdventureJS.Dictionary.Verb#doVerbThis

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

Defined in: Adventure/Dictionary/Verb.js, line 657

Inherited from: AdventureJS.Dictionary.Verb#doVerbThisFromThat

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

Defined in: Adventure/Dictionary/Verb.js, line 641

Inherited from: AdventureJS.Dictionary.Verb#doVerbThisWithThat

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

Defined in: Adventure/Dictionary/Verb.js, line 633

Inherited from: AdventureJS.Dictionary.Verb#doVerbWithThis

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

Defined in: Adventure/Dictionary/Verb.js, line 500

Inherited from: AdventureJS.Dictionary.Verb#enqueue_collections

Default value: false

enqueue_collections if true allows a verb to unbundle the targets of a collection in order to queue up separate actions for each. For example, "gems" is a collection that targets 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
extends :String

Defined in: Adventure/Dictionary/Verb.js, line 171

Inherited from: AdventureJS.Dictionary.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
game :Object

Defined in: Adventure/Dictionary/Verb.js, line 136

Inherited from: AdventureJS.Dictionary.Verb#game

Default value: {}

A reference back to the main Game object.
gerund
gerund :String

Defined in: Adventure/Dictionary/Verb.js, line 206

Overrides from: AdventureJS.Dictionary.Verb#gerund

The gerund of the verb. May be used in output strings.
handle_disambiguation
handle_disambiguation :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 348

Inherited from: AdventureJS.Dictionary.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.
handle_unparsed_input
handle_unparsed_input :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 357

Inherited from: AdventureJS.Dictionary.Verb#handle_unparsed_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.
in_can_mean_on
in_can_mean_on :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 368

Inherited from: AdventureJS.Dictionary.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
input_substitutions :Object

Defined in: Adventure/Dictionary/Verb.js, line 451

Inherited from: AdventureJS.Dictionary.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
is_compass_direction :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 384

Inherited from: AdventureJS.Dictionary.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
is_direction :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 377

Inherited from: AdventureJS.Dictionary.Verb#is_direction

Default value: false

Set whether verb is a direction verb.
is_relative_direction
is_relative_direction :Boolean

Defined in: Adventure/Dictionary/Verb.js, line 392

Inherited from: AdventureJS.Dictionary.Verb#is_relative_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.
name
name :String

Defined in: Adventure/Dictionary/Verb.js, line 179

Inherited from: AdventureJS.Dictionary.Verb#name

Default value: ""

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

Defined in: Adventure/Dictionary/Verb.js, line 533

Inherited from: AdventureJS.Dictionary.Verb#Name

Default value: []

Return uppercase name of the verb.
override_failure_msg
override_failure_msg :String

Defined in: Adventure/Dictionary/Verb.js, line 463

Inherited from: AdventureJS.Dictionary.Verb#override_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_success_msg
override_success_msg :String

Defined in: Adventure/Dictionary/Verb.js, line 472

Inherited from: AdventureJS.Dictionary.Verb#override_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
past_tense :String

Defined in: Adventure/Dictionary/Verb.js, line 200

Inherited from: AdventureJS.Dictionary.Verb#past_tense

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

Defined in: Adventure/Dictionary/Verb.js, line 421

Inherited from: AdventureJS.Dictionary.Verb#phrase1

Default value: {}

phrase2
phrase2 :Object

Defined in: Adventure/Dictionary/Verb.js, line 427

Inherited from: AdventureJS.Dictionary.Verb#phrase2

Default value: {}

phrase3
phrase3 :Object

Defined in: Adventure/Dictionary/Verb.js, line 433

Inherited from: AdventureJS.Dictionary.Verb#phrase3

Default value: {}

posture
posture :String

Defined in: Adventure/Dictionary/Verb.js, line 219

Overrides from: AdventureJS.Dictionary.Verb#posture

Set a preferred posture that results when this verb acts on player. asset.aspect.aspect.nest.posture takes precedence unless this.override_aspect_posture = true.
prettyname
prettyname :String

Defined in: Adventure/Dictionary/Verb.js, line 186

Inherited from: AdventureJS.Dictionary.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
related :Array

Defined in: Adventure/Dictionary/Verb.js, line 484

Inherited from: AdventureJS.Dictionary.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.
state
state :String

Defined in: Adventure/Dictionary/Verb.js, line 260

Inherited from: AdventureJS.Dictionary.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
state_strings :String

Defined in: Adventure/Dictionary/Verb.js, line 280

Inherited from: AdventureJS.Dictionary.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.
subject_must_be
subject_must_be :Object

Defined in: Adventure/Dictionary/Verb.js, line 328

Inherited from: AdventureJS.Dictionary.Verb#subject_must_be

Default value: {}

subject_must_be sets conditions that the subject must meet in order for the Verb to act upon it. player: true is set by default. In order to allow player to instruct an NPC to perform a verb such as "Floyd, go east", that verb must be set player: false.
synonyms
synonyms :String

Defined in: Adventure/Dictionary/Verb.js, line 194

Overrides from: AdventureJS.Dictionary.Verb#synonyms

Any synonyms for the verb.
try_gerund
try_gerund :Array

Defined in: Adventure/Dictionary/Verb.js, line 876

Inherited from: AdventureJS.Dictionary.Verb#try_gerund

Default value: []

For "try gerund". When player input is parsed, they'll be converted to just verb, eg "try swimming" to "swim".
try_to_verb
try_to_verb :Array

Defined in: Adventure/Dictionary/Verb.js, line 919

Inherited from: AdventureJS.Dictionary.Verb#try_to_verb

Default value: []

For "try to verb". When player input is parsed, they'll be converted to just verb, eg "try to swim" to "swim".
tryVerbFromThis
tryVerbFromThis :Getter

Defined in: Adventure/Dictionary/Verb.js, line 569

Inherited from: AdventureJS.Dictionary.Verb#tryVerbFromThis

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

Defined in: Adventure/Dictionary/Verb.js, line 601

Inherited from: AdventureJS.Dictionary.Verb#tryVerbThatFromThis

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

Defined in: Adventure/Dictionary/Verb.js, line 585

Inherited from: AdventureJS.Dictionary.Verb#tryVerbThatWithThis

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

Defined in: Adventure/Dictionary/Verb.js, line 553

Inherited from: AdventureJS.Dictionary.Verb#tryVerbThis

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

Defined in: Adventure/Dictionary/Verb.js, line 593

Inherited from: AdventureJS.Dictionary.Verb#tryVerbThisFromThat

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

Defined in: Adventure/Dictionary/Verb.js, line 577

Inherited from: AdventureJS.Dictionary.Verb#tryVerbThisWithThat

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

Defined in: Adventure/Dictionary/Verb.js, line 561

Inherited from: AdventureJS.Dictionary.Verb#tryVerbWithThis

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

Defined in: Adventure/Dictionary/Verb.js, line 151

Inherited from: AdventureJS.Dictionary.Verb#type

Default value: ""

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

Defined in: Adventure/Dictionary/Verb.js, line 270

Inherited from: AdventureJS.Dictionary.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_gerund
verb_gerund :Array

Defined in: Adventure/Dictionary/Verb.js, line 742

Inherited from: AdventureJS.Dictionary.Verb#verb_gerund

Default value: []

For verb/gerund pairs such as "go swimming" or "go hiking". When player input is parsed, they'll be concatenated to "swim" or "hike".
verb_noun_prep
verb_noun_prep :Array

Defined in: Adventure/Dictionary/Verb.js, line 829

Inherited from: AdventureJS.Dictionary.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
verb_noun_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 1097

Inherited from: AdventureJS.Dictionary.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
verb_noun_prep_noun_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 1194

Inherited from: AdventureJS.Dictionary.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
verb_noun_prep_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 1148

Inherited from: AdventureJS.Dictionary.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
verb_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 962

Inherited from: AdventureJS.Dictionary.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
verb_prep_noun_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 784

Inherited from: AdventureJS.Dictionary.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
verb_prep_noun_prep_noun_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 1243

Inherited from: AdventureJS.Dictionary.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
verb_prep_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 1009

Inherited from: AdventureJS.Dictionary.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
verb_prep_prep_prep_noun :Array

Defined in: Adventure/Dictionary/Verb.js, line 1053

Inherited from: AdventureJS.Dictionary.Verb#verb_prep_prep_prep_noun

Default value: []

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