Adventure.js Docs Downloads
Score: 0 Moves: 0

Verb: lock

Instance of: adventurejs.Verb

Defined in: adventure/dictionary/verbs/lock.js, line 9

How to: How to: VerbSubscriptions VerbAnatomy VerbProcess ModifyVerbs WriteVerbs

Runtime node: game.dictionary.verbs.lock 

> lock handcuff with key
You lock the pair of handcuffs with the little silver key, 
effectively shackling yourself to the campus railing. It's 
a mark of your privilege that you think this will stop the 
bulldozers, which roll right over you on their way to 
demolish the University Hall. You have died. But such a 
noble death! One day the University bards will write ballads 
about your heroic failure.

Lock a Tangible Asset. Requires that the lock has asset.is.direct_object_of_verb.lock.enabled set to true and its is.locked property set to false. If the lock requires a key, verb will soft prompt for one.

lock demo + example code 


// OpenGame.js
// --------------------------------------------------
/*global adventurejs A OpenGame*/ 

var OpenGame = new adventurejs.Game( "OpenGame", "OpenGameDisplay" )
.set({

  // title, version, and author are shown in the title bar
  title: "Open Game",
  version: "0.0.1",
  author: "Ivan Cockrum",

  description: "This is my great game! Thanks for playing!",

  // set this to set a default response to
  // player input that is not understood
  if_parser_has_no_response_print_this: "I have no response to your input. ",

  // set this to provide a default
  // response to blank input
  if_input_is_empty_print_this: "I didn't see any input. ",

  // alternately, game can be set to print 
  // the current room description with 
  // if_input_is_empty_print_room_description: true

});

OpenGame.settings.set({

  // if this is true, lists of exits will
  // show the names of rooms they lead to
  show_room_names_in_exit_descriptions: true,

  // if this is true, lists of exits will
  // only include room names known to player
  show_room_names_in_exit_descriptions_only_when_room_is_known: false,

  // if this is true, lists of exits will only
  // show room names for exits player has used
  show_room_names_in_exit_descriptions_only_after_exit_has_been_used: false,

  // if this is true, verbose room descriptions
  // will only be shown on first visit
  print_verbose_room_descriptions_on_first_visit: true,

  // if this is true, adventurejs will print
  // debug messages to the game display
  print_debug_messages: true,

});  

// Foyer

OpenGame.createAsset({
  class: "Room",
  name: "Open Foyer",

  descriptions: {
    look: `Welcome to the Open Demo, where you can try opening and closing things, and locking and unlocking and picking locks, with the verbs open, close, lock, unlock, pick. Visit the other rooms in this demo to find some demonstrations. `,
    brief: `Try verbs. Open, close, lock, unlock, pick. `,
  },

  exits: {
    // This is a shortcut for creating an Exit. It's useful 
    // for exits that don't have any special properties or 
    // an Aperture, which is an Exit's physical presence.
    east: "Sitting Room",
  },

}); // Open Foyer

// Player

OpenGame.createAsset({
  class: "Player",
  name: "Tim Hunter",
  place: { in: "Open Foyer" },
  is: { active: true, },
});

// Scoring

OpenGame.scorecard.set({
  
  // This is how you set score events for your game. 
  // You can add as few or as many as you like, 
  // and set points to whatever number you like.
  // The names are up to you, so set them however you like.
  score_events: {
    "open window": 1,
    "take ann": 1,
    "open library door": 1,
    "open top drawer": 1,
    "open chest": 1,
    "take andy": 1,

    // Let's say you want the game to start with 
    // some points already set. You can do that like this.
    "preset points": { points: 5, complete: true, recorded: true },

    // You can set negative points too. These unset points cancel 
    // out the preset points above.
    "unset points": { points: -5, complete: true, recorded: true },
  },

  // To attach a score event to your custom function, use
  // OpenGame.scorecard.completeEvent('open window');
  // You'll see these sprinkled throughout this demo code.
  
  // Adventurejs has built-in scoring functions, 
  // but you may, if you like, write custom score handling.

  // this returns a string
  // score_message: `$(Our) score went up! `,

  // this returns a custom function
  // score_message: function(){ 
  //   return `Dude, you totally just got ${this.diff} points!`
  // },

  // Or maybe you just want to tweak the score display. 
  // By default score appears in 0/0 format, but let's 
  // say you'd like it to say "Score: 0 out of 0".
  // score_format: function()
  // {
  //   return `Score: ${this.score} out of ${this.total}`;
  // }

  // score_message and score_format have access to some vars:
  // - this.score (old score)
  // - this.newscore (new score)
  // - this.diff (difference between old/new )
  // - this.total (total of points available)

})



// SittingRoom.js
// --------------------------------------------------
/*global adventurejs A OpenGame*/ 

OpenGame.createAsset({
  class: "Room",
  article: "the",
  name: "Sitting Room",
  descriptions: { 
    look: "The sitting room has many things on which to sit. None of them are objects though, because this is not a sitting demo. I suppose we should have called it an opening room. Shut up about it already! Instead, try opening and closing things: the playground window, the library door, the chest. Oh, did I mention that there's a window and a door? ",
    brief: "Don't sit. Window. Door. ",
  },
  exits: {
    west: "Open Foyer",
  },
});

// Sitting Room Out

OpenGame.createAsset({
  class: "Exit",
  direction: "out",
  place: { in:  "Sitting Room" },
  destination: "Playground",
  descriptions: {
    for_exits_list: `out the window to the 
    Playground`,
    travel: `$(We) climb clumsily out the window and tumble 
    to the playground, where you land on your bottom on a 
    soft tuft of grass. `,
  },
  aperture: "inside window",
});

// Sitting Room Out - Playground Window

OpenGame.createAsset({
  class: "Window",
  name: "inside window",
  synonyms: [ "playground window", "playground" ],
  place: { in:  "Sitting Room" },
  direction: "out",
  descriptions: {

    // Note that this code block uses a combination of Javascript 
    // native template literals and Adventurejs custom templates: 
    // ${OpenGame} and $(inside window). The one with {squiggly} 
    // brackets is Javascript. The one with (parentheses) is Adventurejs.

    // These can be used in combination, with one important caveat. 
    // For many properties, Adventurejs can accept a string or array 
    // or function. Adventurejs custom templates are only evaluated
    // immediately before being output. But, Javascript template 
    // literals used in a string are evaluated when the property 
    // containing the string is created. So in order to use template
    // literals, it's important to wrap the string in a function 
    // that will only be evaluated when called by Adventurejs.

    look: ()=>`
      Through the window, $(we) can see a child's playground. 
      Currently the window is 
      $(inside window is locked or unlocked) and 
      $(inside window is open or closed).
      ${!OpenGame.$('inside window')._didDo('unlock')?
        `The window locks and unlocks by way of a simple  
        sash latch that doesn't require any key. `:""} 
      ${OpenGame.$('inside window').$is('locked')?
        "Try opening the window without first unlocking it. ":""} 
      ${!OpenGame.$('inside window').$is('closed')?
        `$(We) might just climb through it. `:""}
      `,

    // This commented block below is an alternate version.
    // It may appear like it should work the same way, 
    // but because it has a template literal in a string property, 
    // it would throw an error when the game is launched.

    // look: `The window is 
    // $(inside window is open or closed) and 
    // $(inside window is locked or unlocked). 
    // It locks by way of a simple sash latch that doesn't require any key. 
    // ${OpenGame.$('inside window').$is('locked')?
    //   'Try entering "unlock window then open it".':''} 
    //   Beyond the window, $(we) can see a child's playground. `,


    // Here, we've set a description to use if a player
    // inputs "look through window".
    through: "You can see a small child's playground through the window. ",

    // And here, we're redirecting "look out window" 
    // to "look through window" so we can capture both 
    // possibilities without duplicating the code.
    out: function(){ return this.descriptions.through; },
  },

  is: { 
    closed: true, 
    locked: true,
    direct_object_of_verb: { 

      // window.is.direct_object_of_verb.unlock.with_nothing 
      // allows the window to be unlocked without use of a key.
      unlock: { 
        with_nothing: true, 
        with_success_first_time: function(){
          if( !this.is.closed )
          {
            // In some circumstances, when a user inputs 'open thing',  
            // the verb open may redirect to 'unlock thing'. If that 
            // happened here, we want to account for it by returning
            // our custom open.with_success_first_time function.
            return this.is.direct_object_of_verb.open.with_success_first_time();
          }
          else 
          {
            return "$(We) should easily be able to open it now. ";
          }
        }
      },

      // lock and unlock params have to be set independently. 
      // This is so that you could, for instance, set it so that
      // once the player unlocks it, it can't be locked again.
      lock: { with_nothing: true, }, 

      open: { 
        // with_success_first_time calls this function and 
        // appends this string to the native verb output,
        // only the first time the player opens the window.
        with_success_first_time: function(){
          OpenGame.scorecard.completeEvent('open window');
          return "Now that it's open $(we) just might climb out of it. ";
        },

        // with_failure_first_time only prints a message
        with_failure_first_time: `But it's just a simple sash 
        latch that doesn't need any key to unlock it. `,

      },
    },
  },

  // This inside window is linked to the outside window.
  // Apertures, aka doors and windows, only exist in one room.
  // For a door to be in two rooms, we actually need two doors: 
  // one side in one room, the other side in the other room.
  // We handle each side as a unique asset. In order to keep them 
  // in sync we use the linked_asset property, so that if one is 
  // set as open, so is the other one. 
  linked_asset: "outside window",
});

// Sitting Room North

OpenGame.createAsset({
  class: "Exit",
  direction: "north",
  place: { in:  "Sitting Room" },
  destination: "Library",
  descriptions: {
    //look: "It looks frosty that way. ",

    // for_exits_list is a special description for exits,
    // that lets authors customize how individual exits
    // are described when the player is presented with a 
    // list of exits.
    for_exits_list: "through the door north to the Library",
  },
  aperture: "library door",
});

// Sitting Room North Door - library Door

OpenGame.createAsset({
  class: "Door",
  name: "library door",
  place: { in:  "Sitting Room" },
  is: { 
    closed: true, 
    locked: true, 
    direct_object_of_verb: { 
      //close: true, // already set for all instances of Door class
      open: { 
        with_success_first_time: function(){
          OpenGame.scorecard.completeEvent('open library door');
          return "Now you can enter the Library.  ";
        },
      },

      // Note here how we're setting it so the library door can be 
      // unlocked with the brass key.
      unlock: { 
        with_assets: ['brass key'], 
        with_nothing: false, 
      }, 
      
      // We set the assets for each verb, lock and unlock, explicitly
      // because it's common that an author might want a player to 
      // unlock a door and then never have to interact with it again.
      // So if we want the key to also lock the door, we have to say so.
      lock: { 
        with_assets: ['brass key'], 
        with_nothing: false, 
      }, 
    }, 
  },
  linked_asset: "sitting room door",
  direction: "north",
  descriptions: {
    look: "A lovely Victorian nine panel oak door with frosted glass and a scuffed brass lock plate. ",
    through: function()
    {
      // Here we're setting a description for "look through door"
      // that returns a different value depending on whether the 
      // door is open or closed. 
      // "through" is what we call an Aspect, along with behind, 
      // in, on, under, and many other prepositions. Any Aspect 
      // can have a unique description set this way.
      if( !OpenGame.$( "library door" ).$is("closed") ) 
      {
        return "Through the open door you can see shelves stuffed with books and books and books. ";
      } 
      else 
      {
        return "The glass panes in the door's upper half are quite heavily frosted, and don't reveal anything beyond. ";
      }
    },
  },
});

// coffee table

OpenGame.createAsset({
  class: "Table",
  name: "coffee table",
  place: { in: "Sitting Room" },
  description: "It's a low, rectangular coffee table, apparently hand carved from oak. ",
  adjectives: "wood, wooden, carved, oak",
  can_put:{
    on: {
      can_hold_player: false,
    },
  },

  verb_hooks: {
    go:
    {
      doBeforeTry: function(params)
      {
        // See how we're using a Verb Hook here. This is a way 
        // to inject custom code into a verb when it is applied 
        // to a particular asset. In this case by hooking into 
        // go.doBeforeTry, we interrupt the verb before it can 
        // run its default doTry conditional logic, 
        // and print our own failure message. This basically means:
        // we don't care what the default logic has to say; you 
        // just don't put your fat feet on the fine furniture.
        // See /doc/tutorial_UseVerbPhaseHooks.html for more info.
        OpenGame.print( "I mean, $(we) could, but it would just be rude. ", "concatenate_output" );
        return false;
      },
    },
    sit:
    {
      // Here, we're setting sit, stand and lie to use 
      // the same code as go.doBeforeTry. This is one way 
      // you could apply the same custom logic to multiple 
      // verbs on an object. There are also other ways to 
      // achieve similar results, such as unsubscribing 
      // the asset from these verbs, or using event_hooks.
      doBeforeTry: function(){return this.verb_hooks.go.doBeforeTry();},
    },
    stand:
    {
      doBeforeTry: function(){return this.verb_hooks.go.doBeforeTry();},
    },
    lie:
    {
      doBeforeTry: function(){return this.verb_hooks.go.doBeforeTry();},
    }
  },

  event_hooks:
  {
    // Here's an example of an event hook. 
    // This will be superceded by the verb_hooks up above; to see 
    // it in action you'll have to comment out the verb_hooks block.
    // event_hooks are called when a particular action occurs,
    // such as moving the player onto an asset, regardless of what 
    // verb caused it; go, or climb, or jump, or sit, or lie.
    // Every verb that results in moving the player into a thing
    // tries to call thing.event_hooks.onNestThatToThis(player).
    // onNestThatToThis is a very broad event hook that will catch 
    // a lot of circumstances. Other event hooks may be broad or narrow.
    // See /doc/tutorial_UseVerbEventHooks.html for more info.
    onNestThatToThis: { 
      // Nesting only applies to characters.
      // Tim Hunter is the name of our player character in this game.
      'Tim Hunter' : function()
      {
        this.game.print("Whoa there, podner! Let's keep those fat feet off the fine furniture. ");
        return false;
      },
    },

    // Alternately, if you wanted the same event hook to apply to 
    // all assets, you could define it as a function itself rather
    // than creating nested objects. This is also valid.

    // onNestThatToThis: function()
    // {
    //   this.game.print("Whoa there, podner! Let's keep those fat feet off the fine furniture. ");
    //   return false;
    // },

  }
});


// Library.js
// --------------------------------------------------
/*global adventurejs A OpenGame*/ 

OpenGame.createAsset({
  class: "Room",
  name: "Library",
  descriptions: { 

    look: `The library is stuffed with books near 
    to the point of inducing claustrophia. But also cozy? 
    It's hard to say precisely. $(We) scan the 
    overflowing shelves. Sadly, none of the books are objects. 
    Instead, take a look at the bureau and its drawers. `, 

    brief: "Books. Desk. Door south. ",
  },
}); // Library

// Sitting Room south Exit

OpenGame.createAsset({
  class: "Exit",
  direction: "south",
  place: { in:  "Library" },
  destination: "Sitting Room",
  descriptions: {
    //look: "A heavy Victorian nine panel oak door with frosted panes. ",
    for_exits_list: "south to the Sitting Room",
  },
  aperture: "sitting room door",
});

// Sitting Room south door
// Exits have no physical properties. In order to apply 
// physical properties to an exit, it needs an Aperture. 
// Apertures can be manipulated like other tangible assets.

OpenGame.createAsset({
  class: "Door",
  name: "sitting room door",
  place: { in: "Library" },
  direction: "south",
  descriptions: {
    look: "It's a Victorian 9 panel oak door. ",
    open: "The sitting room door is open. ",
    closed: "The sitting room door is closed. ",

    // Assets can have a number of descriptions to use in 
    // different contexts. Descriptions can be strings or 
    // arrays or functions. This example shows a function
    // that uses native Javascript logic to return a string.
    // See /doc/tutorial-Subscription.html for more info.
    through: function()
    {
      // This is one way to refer to objects in custom code:
      // GameName.$( "asset name" ).is("property")
      // See /doc/tutorial_UseCustomCode.html for more info.
      if( !OpenGame.$( "sitting room door" ).$is("closed") ) 
      {
        return "Through the open door $(we) can see the Sitting Room. ";
      } 
      else 
      {
        return "$(We) can't see anything through the door's frosted panes. ";
      }
    },
  },
  linked_asset: "library door",
  is: { 
    closed: true, 
    locked: true,
    direct_object_of_verb: { 
      open: true, 
      close: true,
      unlock: { with_assets: ['brass key'] }, 
      lock: { with_assets: ['brass key'] }, 
    }, 
  },
});

// bureau desk

OpenGame.createAsset({
  class: "Desk",
  name: "bureau desk",
  adjectives: [ "oak", "wood", "wooden", "substantial" ],
  synonyms: [],
  place: { in: "Library" },
  descriptions: {

    // Note that this description is an ordinary string property. Elsewhere in this demo 
    // we're using traditional functions or arrow functions because they include 
    // Javascript template literals. This example only includes Adventurejs custom  
    // templates, which do not get evaluated until output, and are safe to use in strings. 
    // See /doc/tutorial_UseCustomTemplates.html for more info.
    look: `
      It's a substantial oak bureau desk with multiple drawers stacked vertically, 
      top, middle and bottom. The top drawer is $( top drawer is open or closed ), 
      the middle drawer is $( middle drawer is open or closed ), and the bottom 
      drawer is $( bottom drawer is open or closed ). `,
  },
  can_put:{
    on: { 
      can_hold_player: false,
    },
  },
});

// top drawer

OpenGame.createAsset({
  class: "Drawer",
  name: "top drawer",
  adjectives: [ "desk", "scratched" ],
  synonyms: [ "lock", "lock plate", "scratches" ],

  // Note how we're using top_drawer.description here whereas we've used
  // desk.descriptions.look above. All assets can have multiple 
  // descriptions. Setting asset.description is a shortcut to setting 
  // asset.descriptions.look, for when an asset only needs one description.
  description: `The top drawer's copper lock plate 
    seems to be particularly scratched up. 
    Currently the drawer is $( top drawer is open or closed ). `,

  place: { attached: "bureau desk" },
  is: { 
    
    // Note how we're setting known:true here. 
    // By default, players can't interact with 
    // assets until they're known.
    // Also by default, attached assets don't 
    // become known until a player examines 
    // the asset they're attached to.
    known: true,

    closed: true,
    locked: true,
    listed_in_parent: false,
    direct_object_of_verb: { 

      // Adventurejs treats 'pick' and 'unlock' as distinct verbs.
      // If a player tries to use 'unlock' where 'pick' is defined, 
      // the parser will try to redirect to 'pick'.

      pick: { with_assets: ['copper hairpin'] }, 
      // Pick and unlock are distinct verbs, to allow authors to 
      // create precise situations. But, making them distinct can
      // lead to finicky situations that are unpleasant for players.
      // It's a fine line. We could either set it so that both verbs
      // work the same way:
      // unlock: { with_assets: ['copper hairpin'] }, 
      // Or we give the player a hint, if we don't want unlock to work.
      unlock: { with_failure: `$(We) might be able to pick it with something. ` },

      open: { 
        with_failure_first_time: "Bet you didn't see that coming, huh? ", 
        with_success_first_time: function(){
          OpenGame.scorecard.completeEvent('open top drawer');
          //return "  ";
        },
      },
    },
  },
});

// middle drawer

OpenGame.createAsset({
  class: "Drawer",
  name: "middle drawer",
  synonyms: "middle desk drawer",
  description: "The middle drawer is $( middle drawer is open or closed ). ",
  adjectives: "desk",
  place: { attached: "bureau desk" },
  is: { 
    known: true,
    closed: true,
    listed_in_parent: false 
  },
});

// bottom drawer

OpenGame.createAsset({
  class: "Drawer",
  name: "bottom drawer",
  synonyms: "bottom desk drawer",
  description: "The bottom drawer is $( bottom drawer is open or closed ). ",
  adjectives: "desk",
  place: { attached: "bureau desk" },
  is: { 
    known: true,
    closed: true,
    listed_in_parent: false 
  },
});

// drawers collection

// Collections are a special class that allows players to refer 
// to a group of objects and try to apply a verb to all of them, 
// or get back a combined description.
// See doc/adventurejs.Collection.html for more info.
OpenGame.createAsset({
  class: "Collection",
  name: "desk drawers",
  place: { attached: "bureau desk" },
  collection: [ "top drawer", "middle drawer", "bottom drawer" ],
  synonyms: [ "drawers", "three drawers" ],
  is: { 
    known: true,
    listed_in_parent: false 
  },
  descriptions: {
    look: function()
    {
      var openCount = [];
      var closedCount = [];
      var msg = '';
      
      msg += `The bureau has three drawers stacked vertically: 
      top, middle and bottom, each with a copper lock plate. 
      The top drawer's lock appears to be rather scratched up. 
      Currently, `;

      // Note how we're using 'this' here. Under normal circumstances 
      // nested properties don't have access to their top level object.
      // Adventurejs uses asset.descriptions.look.call(asset) 
      // to ensure that asset descriptions can refer to their asset. 
      // Any property that relies on getStringOrArrayOrFunction() 
      // will have 'this' scoped to its parent asset.
      // See /doc/tutorial-StringOrArrayOrFunction.html for more info.
      for( var i in this.collection )
      {
        // this.collection contains asset names. 
        // We want to get references to the asset objects.
        // One way to do this is with GameName.$("my asset")
        // See /doc/tutorial_UseCustomCode.html for more info.
        let drawer = OpenGame.$(this.collection[i]);

        // Once we have an asset reference, asset.$is(property) 
        // is a safe way to try to get asset properties.
        drawer.$is('closed') ? 
          closedCount.push( drawer.name ) : 
          openCount.push( drawer.name );
      }

      if( 0 === openCount.length ) 
      {
        msg += "all three drawers are closed.";
      } 
      else if( 0 === closedCount.length ) 
      {
        msg += "all three drawers are open.";
      } 
      else if ( 2 == openCount.length ) 
      {
        msg += `the ${openCount[0]} and ${openCount[1]} 
        are open, while the ${closedCount[0]} is closed. `;
      } 
      else if ( 2 == closedCount.length ) 
      {
        msg += `the ${closedCount[0]} and ${closedCount[1]} 
        are open, while the ${openCount[0]} is open. `;
      }

      return msg;
    },
  },
});


// Playground.js
// --------------------------------------------------
/*global adventurejs A OpenGame*/ 

OpenGame.createAsset({
  class: "Room",
  article: "the",
  name: "Playground",
  descriptions: { 

    look: `Fireflies speckle the dusk with softly pulsing 
    motes of light. $(We've) come to a modest child's playground 
    around back of the house. The playground has many things with 
    which to play, but none of them are objects, and we're not 
    going to get into it, ok? A window leads back into the house. `,

    brief: `Play here. Go window. `,
  },
  room_scenery: {
    fireflies: { 
      enabled: true, 
      description: "Fireflies pulse gently here and there, lending a charming quality to the darkening playground. " 
    },
    grass: { 
      enabled: true, 
      description: "Occasional tufts of glossy medium height grass dot the yard. " 
    },
  },
});

// Playground in

OpenGame.createAsset({
  class: "Exit",
  direction: "in",
  place: { in:  "Playground" },
  destination: "Sitting Room",
  descriptions: {
    for_exits_list: `in to the Sitting Room`,
    travel: `$(We) grab hold of the window sill, scrabble awkwardly up 
    the siding, and heft $(ourself) over the sill and in through the window, 
    where $(we) tumble into the sitting room. `,
  },
  aperture: "outside window",
});

// outside window

OpenGame.createAsset({
  class: "Window",
  name: "outside window",
  place: { in:  "Playground" },
  direction: "in",
  descriptions: {

    // See how this example uses a traditional function.
    // Traditional functions are able to be scoped to their
    // top level assets which means you can use 'this' with them.
    // By contrast if you look at the code for the inside 
    // window description, you'll see that it uses an arrow 
    // function. Arrow functions are permitted, but because
    // they can't be scoped to their parent asset, they 
    // can't use 'this'. 
    look: function(){
      return `
      Though the sitting room seemed dimly lit, as it is 
      now dusk outside, the light through the window seems 
      quite bright from out here.
      The window is $(inside window is open or closed).
      ${!this.is.closed?
        "$(We) should be able to climb back inside. ":
        "$(We'll) need to open the window if $(we) hope to get back through it. "}
      `;
    },

    // We could instead have used a traditional function here, 
    // and those do receive scope, which would have let us use 
    // 'this' to refer to the window.

    through: "The wan light of the sitting room seems quite bright from out here. ",
    in: function(){ return this.descriptions.in; },

  },
  is: { 
    closed: true, 
    locked: true,
    direct_object_of_verb: { 
      lock: { with_nothing: true, }, 
      unlock: { with_nothing: true, }, 
    },
  },

  // Apertures, aka doors and windows etc, may exist in two places
  // one side in one room, and another side in another room.
  // We handle each side as a unique asset. In order to keep them 
  // in sync, meaning open/closed and locked/unlocked, we use the 
  // linked_asset property. This outside window asset is linked to 
  // its other side, a corresponding inside window asset.
  linked_asset: "inside window",
});



// Objects.js
// --------------------------------------------------
/*global adventurejs A OpenGame*/ 

OpenGame.createAsset({
  class: "Chest",
  name: "small antique chest",
  indefinite_article: "an",
  place: { on: "coffee table" },

  descriptions:{
    look: function(){
      let msg = `It's a small antique Victorian chest, 
      lacquered in a glossy prussian blue and bound with 
      ornate blue steel straps that are pitted with age. 
      Its lid is 
      $(small antique chest is locked or unlocked) and 
      $(small antique chest is open or closed). `;    
      if(this.game.$('small antique chest').$is('open'))
      {
        msg += `The chest is lined with a rich egg yolk 
          yellow brocade that presents a startling contrast 
          to its dark exterior. `;
      }
      return msg;
    },
  },
  adjectives: ["victorian","prussian","blue","steel","glossy","old",],
  synonyms: ["straps",],
  is:
  {
    locked: true,
    closed: true,
    direct_object_of_verb: { 
      open: {
        with_nothing: true,
        with_failure_first_time: `$(We) didn't think it was going to be that easy, did $(we)? `,
        with_success_first_time: function(){
          OpenGame.scorecard.completeEvent('open chest');
          //return "  ";
        },
      },
      unlock: { 
        with_assets: ['blue steel key'],
      },
      lock: { 
        with_assets: ['blue steel key'], 
      },
    },
  },
});

OpenGame.createAsset({
  class: "Paper",
  name: "goldenrod sheet",
  description: `It's a sheet of goldenrod colored paper with 
    a child's drawing on it. The drawing appears to feature  
    a girl with fire engine red hair. The name "Copper" is 
    scrawled above her in big childlike letters. `,
  place: { in: "top drawer" },
});

OpenGame.createAsset({
  class: "Key",
  name: "brass key",
  synonyms: ["glass bead"],
  article: "a",
  adjectives: ["burnished","chonky"],
  place: { on: "coffee table" },
  description: `It's a burnished brass key with chonky teeth 
  and a small glass bead mounted in the head. `,
  is: { 
    indirect_object_of_verb: {
      unlock: { 

        // Adventurejs offers many ways to override its default 
        // actions and output. If 
        // asset.is.direct_object_of_verb.unlock.with_failure 
        // is a string, it will be appended to the default unlock 
        // failure message. In this case, we want to completely 
        // override the output, so we call this.game.overrideOutput()
        // this.game is the same as OpenGame when called from a scoped function.
        // with_failure: function(){ this.game.overrideOutput(
        //   `Whoops! This brass key doesn't unlock that ${OpenGame.getInput().getAsset(1).name}. `
        // )},
        with_failure_first_time: function(){ this.game.overrideOutput(
          `Whoops! Looks like $(we) can't unlock ${OpenGame.getInput().getAsset(1).articlename} with the brass key. `
        )},

        with_success: `Now you can open the door. `,
        then_destroy: `Oh no! The brass key broke! `,

        // There's something missing here. We haven't set this key to
        // unlock: { with_assets: ['sitting room door'] }, 
        // to indicate that this key can open that lock. 
        // That's because we've already set that lock to
        // unlock: { with_assets: ['brass key'] }
        // When assets are linked through verb subscriptions,
        // you only have to set one or the other. Two-way connections 
        // will be completed during game initialization.

      },
    },
    direct_object_of_verb: {
      take: { with_success_first_time: "Now to find something to unlock with it. " },
    },
  },
}); // brass Key

OpenGame.createAsset({
  class: "Key",
  name: "blue steel key",
  synonyms: [ "blue key","steel key"],
  adjectives: ["victorian"],
  is: { 
    indirect_object_of_verb: { 
      unlock: { with_assets: ['small antique chest'], }, 
    }, 
  },
  description: "It's an ornate Victorian key made of blue steel. ",
  // article: "a",
  place: { in: "top drawer" },
});

// OpenGame.createAsset({
//   class: "Key",
//   name: "tiny brass key",
//   description: "It's a tiny key, made of brass. ",
//   article: "a",
//   adjectives: ["tiny", "brass"],
//   // place: { in: "Sitting Room" },
//   is: { indirect_object_of_verb: { 'unlock': {then_destroy: { with_result: "foo" }, } }, },
// });

// OpenGame.createAsset({
//   class: "Key",
//   name: "giant brass key",
//   description: "It's a giant novelty key that looks like it's made of brass. ",
//   article: "a",
//   adjectives: "giant, brass",
//   // place: { in: "Sitting Room" },
// });


OpenGame.createAsset({
  class: "Doll",
  name: "Raggedy Ann doll",
  place: { in: "Playground"},
  descriptions:{
    look: function(){
      return `It's a threadworn Raggedy Ann doll, either well 
      loved or abandoned, it's hard to tell which. 
      ${ OpenGame.$("copper hairpin").$is('attached',this)?
        "A patch of her red hair is gathered into a loose pigtail by a hairpin. ":
        "Her messy red hair is by turns tangled and patchy. " } `},
  },
  can_put:{
    attached:{
      list_in_room: false,
      list_in_examine: false,
    },
  },
  is:{
    direct_object_of_verb:{
      attach: {
        with_nothing: true,
      },
      take: { 
        with_success_first_time: function(){
          OpenGame.scorecard.completeEvent('take ann');
          //return " ";
        },
      },
    },
  },
});

OpenGame.createAsset({
  class: "Doll",
  name: "Raggedy Andy doll",
  place: { in: "small antique chest"},
  descriptions:{
    look: function(){
      return `It's a well-loved Raggedy Andy doll in a patched 
      sailor suit. His red hair is partially covered by a cap 
      that appears to be sewn on. " } `},
  },
  is: {
    direct_object_of_verb: {
      take: { 
        with_success_first_time: function(){
          OpenGame.scorecard.completeEvent('take andy');
          //return " ";
        },
      },
    },
  },
});

OpenGame.createAsset({
  class: "Lockpick",
  name: "copper hairpin",
  synonyms: ["pin","beads","tines","head"],
  adjectives: ["hammered"],
  article: "the",
  is: { 
    direct_object_of_verb:{
      attach: {
        with_nothing: true,
      },
      take: {
        with_success_first_time: "Good catch. It looks like it might be used to pick a lock. ",
        with_success: "$(We) twirl it between $(our) nimble fingers. ",
      },
    },
    indirect_object_of_verb: { 
      pick: { 
        with_assets: ["top drawer"], 
        then_destroy: "The hairpin snaps into pieces! $(We'll) have to find Raggedy Ann a new one. ",
        with_failure: "And just as well, as the copper is quite soft and probably won't serve long. "
      },
    }, 
  },
  descriptions: {
    throw: "It skitters across the floor. ",
    look: `The hammered copper hairpin has two tines and  
    a butterfly shaped head with tiny beads affixed to it, in  
    a vaguely art nouveau style. It's actually quite nice. `,
  },
  place: { attached: "raggedy ann doll" },
  event_hooks: {}
});

lock sentence structures

accepts_structures: [
  'verb noun', // ie 'lock door'
  'verb noun preposition noun', // ie 'lock door with key'
],

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.

lock phrases

phrase1:
{
  accepts_noun: true,
  requires_noun: true,
  noun_must_be:
  {
    known: true,
    tangible: true,
    present: true,
    visible: true, 
    reachable: true,
  },
},
phrase2:
{
  accepts_noun: true,
  noun_must_be:
  {
    in_inventory: true,
    known: true,
  },
  accepts_preposition: true,
  requires_preposition: true,
  preposition_must_be: ["with"],
},

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.

lock params

with_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.

lock event hooks

onTryLockThis
onTryLockThisWithThat
onTryLockThatWithThis
onLockThis
onLockThisWithThat
onLockThatWithThis

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.

lock 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": "lock", [...] });

lock 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:14 GMT-0800 (Pacific Standard Time)
Found a problem or error in the docs? Report it to docs@adventurejs.com.