Adventure.js Docs Downloads
Score: 0 Moves: 0

Verb: swing_on

Instance of: adventurejs.Verb

Defined in: adventure/dictionary/verbs/swing_on.js, line 11

How to: How to: VerbSubscriptions VerbAnatomy VerbProcess ModifyVerbs WriteVerbs

Runtime node: game.dictionary.verbs.swing_on 

> swing on rope
You swing on the rope.

Swing on has two distinct interpretations:

  • Player is nested on a Tangible Asset that swings, such as hanging from a vine
    ex: swing on vine
  • Player is holding a Tangible Asset that can be swung on (which needs to be tested)
    ex: "hold vine then swing on vine"
    • No special logic is provided on success. Authors wanting to make use of it may need to use a method such as verb hooks. See How to Use Verb Phase Hooks to learn more.

    swing_on sentence structures

    Adventurejs 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 How to Modify Verbs.

    swing_on phrases

    Adventurejs 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 How to Modify Verbs.

    swing_on params

    A verb may have custom params which will be mirrored in the properties of any asset that the verb can be applied to. 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",
  is: { direct_object_of_verb: { plugIn: { with_assets: ['computer','outlet'], with_params: { max_connections: 2 }, }, }, },
})
MyGame.createAsset({
  class: "Computer",
  name: "PC",
  is: { indirect_object_of_verb: { plugIn: { with_assets: ['power cord'], }, }, },
})
MyGame.createAsset({
  class: "ElectricalOutlet",
  name: "outlet",
  is: { indirect_object_of_verb: { 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 How to Modify Verbs.

    swing_on event hooks

    Verb Event Hooks provide a method for authors to hook custom code into particular actions (or reactions) of a verb. It works by looking for custom functions attached to the specific assets that the verb is being applied to, and calling whatever it finds. It's a fine grained way to control specific verb/noun interactions. Each verb has a unique set of event hooks. For instance, the verb lock has onTryLock and onTryLockThisWithThat and several other lock-specific hooks. There are also common event hooks that are called by multiple verbs. For example, consider onMoveThatToThis, which might be called during the doSuccess phase of verbs give, take, drop, throw, move, etc. In this example, imagine that an author would like the game to print a custom message whenever a certain object enters or leaves another object, by any method. 

    MyGame.createAsset({
  class: "NPC",
  name: "Elvis",
}),
MyGame.createAsset({
  class: "Room",
  name: "The Building",
  event_hooks: {
    onMoveThatToThis: 
    {
      "Elvis": function() 
      {
        MyGame.print("Elvis has entered The Building! ");
      }
    },
    onRemoveThatFromThis: 
    {
      "Elvis": function() 
      {
        MyGame.print("Elvis has left The Building! ");
      }
    },
  },
}),
    • To learn more, see How to Use Verb Event Hooks.
    • Some hooks are not tied to any specific verbs and though these are technically identical, we refer to them as verb effect hooks. See How to Use Verb Effect Hooks for a list of them.
    • Verb event Hooks are related to but distinct from verb phase hooks, which allow authors to broadly override entire phases of a verb.

    swing_on verb hooks

    do

    • doBeforeTry
    • doTry
    • doAfterTry
    • doBeforeSuccess
    • doSuccess
    • doAfterSuccess

    Every verb has a do function, and most (but not all) verbs go through six distinct phases. doTry handles all the conditional logic to determine whether this verb can be applied to that asset. doSuccess handles the output and state changes. The other four phases don't do anything by themselves; they exist to allow authors to inject custom code via the use of Verb Phase Hooks. This is a broad method for exercising control over verb/noun interactions. 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",
  verb_hooks: {
    take: 
    {
      doAfterTry: function( params )
      {
        MyGame.print( "The sword begins to vibrate as your hand 
        curls around its haft. ", "concatenate_output" );
      },
      doAfterSuccess: function( params )
      {
        MyGame.print( "The sword bursts into song in your hand. ", 
        "concatenate_output" );
      },
    },
  },
});
    • Verb Phase Hooks are related to but distinct from Verb Event Hooks, which are a more surgical option that allows authors to hook into specific events within doTry and doSuccess.
    • To learn more, see How to Use Verb Phase Hooks.

    Private Constructor:

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

    swing_on 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 How to Modify Verbs.

    Inherited Overrides
    IndexMethodsProperties

    Index

    Methods:

    Properties:

    Methods Collapse all  |  Expand all

    canBeIntransitive()

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

    Inherited from: adventurejs.Verb#canBeIntransitive

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

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

    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 Event Hooks and Verb Phase Hooks, see How to Use Verb Event Hooks and How to Use Verb Phase Hooks.

    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.
    doAfterSuccess()

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

    Inherited from: adventurejs.Verb#doAfterSuccess

    doAfterSuccess provides a hook for authors to add custom verb code to individual Assets. doAfterSuccess fires after doSuccess, which means that any custom code here follows the standard doSuccess code. For more information about Verb Phase Hooks, see the How to Use Verb Phase Hooks. For information about modifying Verbs, see How to Modify Verbs.
    doAfterTry()

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

    Inherited from: adventurejs.Verb#doAfterTry

    doAfterTry provides a hook for authors to add custom verb code to individual Assets. doAfterTry fires after doTry, which contains most of the specific logic for determining if this Verb is allowed to act on the specified Asset. Hooking into doAfterTry allows authors to inject custom logic that runs after the Asset has successfully passed through the standard doTry logic. This essentially lets you append custom conditional logic to doTry on an item-by-item basis without globally modifying doTry (which is also possible). If doAfterTry returns null or false, Verb.do will exit without executing the remaining methods. If Verb.do is parsing a collection of objects, returning null will continue to the next object and returning false will block all remaining objects. For more information about Verb Phase Hooks, see the How to Use Verb Phase Hooks. For information about modifying Verbs, see How to Modify Verbs.
    doBeforeSuccess()

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

    Inherited from: adventurejs.Verb#doBeforeSuccess

    doBeforeSuccess provides a hook for authors to add custom verb code to individual Assets. doBeforeSuccess fires after doTry and before doSuccess, which contains all code for applying this Verb to the specified Asset. Hooking into doBeforeSuccess allows authors to inject custom code that runs before the standard doSuccess code. This essentially lets you override doSuccess on an item-by-item basis without globally modifying doSuccess (which is also possible). If doBeforeSuccess returns null, it will prevent doSuccess from firing. For more information about Verb Phase Hooks, see the How to Use Verb Phase Hooks. For information about modifying Verbs, see How to Modify Verbs.
    doBeforeTry()

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

    Inherited from: adventurejs.Verb#doBeforeTry

    doBeforeTry provides a hook for authors to add custom verb code to individual Assets. doBeforeTry fires before doTry, which contains most of the specific logic for determining if this Verb is allowed to act on the specified Asset. Hooking into doBeforeTry allows authors to inject custom logic on an item-by-item basis that runs before any of the standard doTry logic. For more information about Verb Phase Hooks, see How to Use Verb Phase Hooks. For information about modifying Verbs, see How to Modify Verbs.
    doSuccess()

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

    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 How to Modify Verbs.
    doTry()

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

    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 How to Modify Verbs.
    enqueueCollection()

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

    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 2014

    Inherited from: adventurejs.Verb#getState

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

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

    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 1839

    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 with_success results and tryDestroy results.
    hasState()

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

    Inherited from: adventurejs.Verb#hasState

    Does this verb have state or unstate?
    hasVerbSubscriptionConnection()

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

    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 1673

    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 1747

    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.)
    setVerbSubscriptionConnection()

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

    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.is.direct_object_of_verb.plugIn.with_params.connections = ['socket']
    socket.is.indirect_object_of_verb.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.is.direct_object_of_verb.plugIn.with_assets = ['socket']
    connections: computer.is.direct_object_of_verb.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.is.direct_object_of_verb[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.is.indirect_object_of_verb[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
    tryPlaceAssetInAspectOfAsset(direct_object, preposition, indirect_object) → {Object}

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

    Inherited from: adventurejs.Verb#tryPlaceAssetInAspectOfAsset

    Parameters:

    • direct_object Object
    • preposition String
    • indirect_object Object
    tryPlaceAssetInAspectOfAsset 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
    tryToInferIndirectObject(direct_object) → {Object}

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

    Inherited from: adventurejs.Verb#tryToInferIndirectObject

    Parameters:

    • direct_object Object
    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
    unsetVerbSubscriptionConnection()

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

    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.is.direct_object_of_verb.plugIn.with_params.connections = ['socket']
    socket.is.indirect_object_of_verb.plugIn.with_params.connections = ['computer']
    validate()

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

    Inherited from: adventurejs.Verb#validate

    Unused.

    Properties Collapse all  |  Expand all

    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 231

    Inherited from: adventurejs.Verb#adjectives

    Verb.adjectives are for direction verbs so that, for example, 'south' can be associated with 'southern' and 'southernly'.
    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 309

    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"
    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 276

    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 326

    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 292

    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 285

    Inherited from: adventurejs.Verb#is_direction

    Default value: false

    Set whether verb is a direction verb.
    is_relative_direction :Boolean

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

    Inherited from: adventurejs.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.
    let_verb_handle_disambiguation :Boolean

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

    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 265

    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 152

    Inherited from: adventurejs.Verb#name

    Default value: ""

    String provided in Verb definition file (aka preverb). Compound verb names have underscores instead of spaces, such as ask_about and climb_down.
    Name :Getter

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

    Inherited from: adventurejs.Verb#Name

    Default value: []

    Return uppercase name of the verb.
    onDoFromThis :Getter

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

    Inherited from: adventurejs.Verb#onDoFromThis

    Returns "on[Verb]FromThis" for consistency with tryEventHook()
    onDoThatFromThis :Getter

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

    Inherited from: adventurejs.Verb#onDoThatFromThis

    Returns "on[Verb]ThatFromThis" for consistency with tryEventHook()
    onDoThatWithThis :Getter

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

    Inherited from: adventurejs.Verb#onDoThatWithThis

    Returns "on[Verb]ThatWithThis" for consistency with tryEventHook()
    onDoThis :Getter

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

    Inherited from: adventurejs.Verb#onDoThis

    Returns "on[Verb]This" for consistency with tryEventHook()
    onDoThisFromThat :Getter

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

    Inherited from: adventurejs.Verb#onDoThisFromThat

    Returns "on[Verb]ThisFromThat" for consistency with tryEventHook()
    onDoThisWithThat :Getter

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

    Inherited from: adventurejs.Verb#onDoThisWithThat

    Returns "on[Verb]ThisWithThat" for consistency with tryEventHook()
    onDoWithThis :Getter

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

    Inherited from: adventurejs.Verb#onDoWithThis

    Returns "on[Verb]WithThis" for consistency with tryEventHook()
    onTryFromThis :Getter

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

    Inherited from: adventurejs.Verb#onTryFromThis

    Returns "onTry[Verb]FromThis" for consistency with tryEventHook()
    onTryThatFromThis :Getter

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

    Inherited from: adventurejs.Verb#onTryThatFromThis

    Returns "onTry[Verb]ThatFromThis" for consistency with tryEventHook()
    onTryThatWithThis :Getter

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

    Inherited from: adventurejs.Verb#onTryThatWithThis

    Returns "onTry[Verb]ThatWithThis" for consistency with tryEventHook()
    onTryThis :Getter

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

    Inherited from: adventurejs.Verb#onTryThis

    Returns "onTry[Verb]This" for consistency with tryEventHook()
    onTryThisFromThat :Getter

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

    Inherited from: adventurejs.Verb#onTryThisFromThat

    Returns "onTry[Verb]ThisFromThat" for consistency with tryEventHook()
    onTryThisWithThat :Getter

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

    Inherited from: adventurejs.Verb#onTryThisWithThat

    Returns "onTry[Verb]ThisWithThat" for consistency with tryEventHook()
    onTryWithThis :Getter

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

    Inherited from: adventurejs.Verb#onTryWithThis

    Returns "onTry[Verb]WithThis" for consistency with tryEventHook()
    override_verb_failure_msg :String

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

    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 354

    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 171

    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 239

    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 162

    Inherited from: adventurejs.Verb#prettyname

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

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

    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 178

    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 198

    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 485

    Inherited from: adventurejs.Verb#synonyms

    Default value: []

    synonyms provide alternate words for verbs, such as "get" for "take".
    unstate :String

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

    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 567

    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 773

    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 883

    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 830

    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 620

    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 517

    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 936

    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 673

    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 723

    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"
    Documentation generated by JSDoc 3.6.11 on Mon Nov 20 2023 18:04:34 GMT-0800 (Pacific Standard Time)
    Found a problem or error in the docs? Report it to docs@adventurejs.com.