Verb: unlock
Instance of: adventurejs.Verb
Defined in: adventure/dictionary/verbs/unlock.js, line 9
How to: How to: VerbSubscriptions VerbAnatomy VerbProcess ModifyVerbs WriteVerbs
> unlock heart with love
You unlock the heart stone with the loving key. The
chamber's dim lighting immediately brightens into a pulsating
glow. The sense of forboding that had descended upon you lifts
too. You feel yourself buoyed with positive emotion. In fact...
whoa... you look down to find your feet rising from the ground.
Unlock a Tangible Asset. Requires that the lock has asset.is.direct_object_of_verb.unlock.enabled set to true and its is.locked property set to true. If the lock requires a key, verb will soft prompt for one.
unlock 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: {}
});
unlock sentence structures
accepts_structures: [
'verb noun', // ie 'unlock chest'
'verb noun preposition noun', // ie 'unlock chest with brass 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.
unlock 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.
unlock 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.
unlock event hooks
onTryUnlockThis onTryUnlockThisWithThat onTryUnlockThatWithThis onUnlockThis onUnlockThisWithThat onUnlockThatWithThis
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.
unlock 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": "unlock", [...] });
unlock 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.
Index
Methods:
- Inherited from Verb canBeIntransitive
- Inherited from Verb do
- Inherited from Verb doAfterSuccess
- Inherited from Verb doAfterTry
- Inherited from Verb doBeforeSuccess
- Inherited from Verb doBeforeTry
- Inherited from Verb doSuccess
- Inherited from Verb doTry
- Inherited from Verb enqueueCollection
- Inherited from Verb getState
- Inherited from Verb handleFailure
- Inherited from Verb handleSuccess
- Inherited from Verb hasState
- Inherited from Verb hasVerbSubscriptionConnection
- Inherited from Verb initialize
- Inherited from Verb set
- Inherited from Verb setVerbSubscriptionConnection
- Inherited from Verb tryDestroyAfterUsing
- Inherited from Verb tryDestroyDirectObjectAfterUsing
- Inherited from Verb tryDestroyIndirectObjectAfterUsing
- Inherited from Verb tryPlaceAssetInAspectOfAsset
- Inherited from Verb tryToInferIndirectObject
- Inherited from Verb unsetVerbSubscriptionConnection
- Inherited from Verb validate
Properties:
- Inherited from Verb accepts_direction
- Inherited from Verb accepts_number
- Inherited from Verb accepts_string
- Inherited from Verb adjectives
- Inherited from Verb dictionary
- Inherited from Verb direction_preposition
- Inherited from Verb game
- Inherited from Verb in_can_mean_on
- Inherited from Verb input_substitutions
- Inherited from Verb is_compass_direction
- Inherited from Verb is_direction
- Inherited from Verb is_relative_direction
- Inherited from Verb let_verb_handle_disambiguation
- Inherited from Verb let_verb_handle_remaining_input
- Inherited from Verb name
- Inherited from Verb Name
- Inherited from Verb onDoFromThis
- Inherited from Verb onDoThatFromThis
- Inherited from Verb onDoThatWithThis
- Inherited from Verb onDoThis
- Inherited from Verb onDoThisFromThat
- Inherited from Verb onDoThisWithThat
- Inherited from Verb onDoWithThis
- Inherited from Verb onTryFromThis
- Inherited from Verb onTryThatFromThis
- Inherited from Verb onTryThatWithThis
- Inherited from Verb onTryThis
- Inherited from Verb onTryThisFromThat
- Inherited from Verb onTryThisWithThat
- Inherited from Verb onTryWithThis
- Inherited from Verb override_verb_failure_msg
- Inherited from Verb override_verb_success_msg
- Inherited from Verb past_tense
- Inherited from Verb player_must_be
- Inherited from Verb prettyname
- Inherited from Verb related
- Inherited from Verb requires_number
- Inherited from Verb requires_string
- Inherited from Verb state
- Inherited from Verb state_strings
- Inherited from Verb synonyms
- Inherited from Verb unstate
- Inherited from Verb verb_noun_prep
- Inherited from Verb verb_noun_prep_noun
- Inherited from Verb verb_noun_prep_noun_prep_noun
- Inherited from Verb verb_noun_prep_prep_noun
- Inherited from Verb verb_prep_noun
- Inherited from Verb verb_prep_noun_prep_noun
- Inherited from Verb verb_prep_noun_prep_noun_prep_noun
- Inherited from Verb verb_prep_prep_noun
- Inherited from Verb verb_prep_prep_prep_noun
Methods Collapse all |
Defined in: adventure/dictionary/Verb.js, line 1993
Inherited from: adventurejs.Verb#canBeIntransitive
Defined in: adventure/dictionary/Verb.js, line 1022
Inherited from: adventurejs.Verb#do
do ->
- doBeforeTry (hook for authors)
- doTry
- doAfterTry (hook for authors)
- doBeforeSuccess (hook for authors)
- doSuccess
- doAfterSuccess (hook for authors)
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.
Defined in: adventure/dictionary/Verb.js, line 1369
Inherited from: adventurejs.Verb#doAfterSuccess
Defined in: adventure/dictionary/Verb.js, line 1253
Inherited from: adventurejs.Verb#doAfterTry
Defined in: adventure/dictionary/Verb.js, line 1304
Inherited from: adventurejs.Verb#doBeforeSuccess
Defined in: adventure/dictionary/Verb.js, line 1188
Inherited from: adventurejs.Verb#doBeforeTry
Defined in: adventure/dictionary/Verb.js, line 1351
Inherited from: adventurejs.Verb#doSuccess
Defined in: adventure/dictionary/Verb.js, line 1236
Inherited from: adventurejs.Verb#doTry
Defined in: adventure/dictionary/Verb.js, line 1716
Inherited from: adventurejs.Verb#enqueueCollection
Defined in: adventure/dictionary/Verb.js, line 2014
Inherited from: adventurejs.Verb#getState
Defined in: adventure/dictionary/Verb.js, line 1760
Inherited from: adventurejs.Verb#handleFailure
Defined in: adventure/dictionary/Verb.js, line 1839
Inherited from: adventurejs.Verb#handleSuccess
Defined in: adventure/dictionary/Verb.js, line 2004
Inherited from: adventurejs.Verb#hasState
Defined in: adventure/dictionary/Verb.js, line 2115
Inherited from: adventurejs.Verb#hasVerbSubscriptionConnection
Defined in: adventure/dictionary/Verb.js, line 1673
Inherited from: adventurejs.Verb#initialize
Todos: How does patchVerb handle initialization?
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.
Defined in: adventure/dictionary/Verb.js, line 2024
Inherited from: adventurejs.Verb#setVerbSubscriptionConnection
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']
Defined in: adventure/asset/tryDestroyAfterUsing.js, line 7
Inherited from: adventurejs.Verb#tryDestroyAfterUsing
Parameters:
-
object_of
String -
asset
Object
Returns:
Object
Defined in: adventure/asset/tryDestroyDirectObjectAfterUsing.js, line 7
Inherited from: adventurejs.Verb#tryDestroyDirectObjectAfterUsing
Parameters:
-
asset
Object
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
Defined in: adventure/asset/tryDestroyIndirectObjectAfterUsing.js, line 7
Inherited from: adventurejs.Verb#tryDestroyIndirectObjectAfterUsing
Parameters:
-
asset
Object
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
Defined in: adventure/dictionary/Verb.js, line 1465
Inherited from: adventurejs.Verb#tryPlaceAssetInAspectOfAsset
Parameters:
-
direct_object
Object -
preposition
String -
indirect_object
Object
Returns:
Object
Defined in: adventure/dictionary/Verb.js, line 1411
Inherited from: adventurejs.Verb#tryToInferIndirectObject
Parameters:
-
direct_object
Object
Returns:
Object
Defined in: adventure/dictionary/Verb.js, line 2077
Inherited from: adventurejs.Verb#unsetVerbSubscriptionConnection
computer.is.direct_object_of_verb.plugIn.with_params.connections = ['socket']
socket.is.indirect_object_of_verb.plugIn.with_params.connections = ['computer']
Defined in: adventure/dictionary/Verb.js, line 1662
Inherited from: adventurejs.Verb#validate
Properties Collapse all |
Defined in: adventure/dictionary/Phrase.js, line 27
Inherited from: adventurejs.Verb#accepts_direction
Defined in: adventure/dictionary/Phrase.js, line 41
Inherited from: adventurejs.Verb#accepts_number
Defined in: adventure/dictionary/Phrase.js, line 20
Inherited from: adventurejs.Verb#accepts_string
Defined in: adventure/dictionary/Verb.js, line 231
Inherited from: adventurejs.Verb#adjectives
Defined in: adventure/dictionary/Verb.js, line 144
Inherited from: adventurejs.Verb#dictionary
Default value: {}
Defined in: adventure/dictionary/Verb.js, line 309
Inherited from: adventurejs.Verb#direction_preposition
Default value: ""
Defined in: adventure/dictionary/Verb.js, line 137
Inherited from: adventurejs.Verb#game
Default value: {}
Defined in: adventure/dictionary/Verb.js, line 276
Inherited from: adventurejs.Verb#in_can_mean_on
Default value: false
Defined in: adventure/dictionary/Verb.js, line 326
Inherited from: adventurejs.Verb#input_substitutions
Default value: {}
Defined in: adventure/dictionary/Verb.js, line 292
Inherited from: adventurejs.Verb#is_compass_direction
Default value: false
Defined in: adventure/dictionary/Verb.js, line 285
Inherited from: adventurejs.Verb#is_direction
Default value: false
Defined in: adventure/dictionary/Verb.js, line 300
Inherited from: adventurejs.Verb#is_relative_direction
Default value: false
Defined in: adventure/dictionary/Verb.js, line 256
Inherited from: adventurejs.Verb#let_verb_handle_disambiguation
Default value: false
Defined in: adventure/dictionary/Verb.js, line 265
Inherited from: adventurejs.Verb#let_verb_handle_remaining_input
Default value: false
Defined in: adventure/dictionary/Verb.js, line 152
Inherited from: adventurejs.Verb#name
Default value: ""
Defined in: adventure/dictionary/Verb.js, line 376
Inherited from: adventurejs.Verb#Name
Default value: []
Defined in: adventure/dictionary/Verb.js, line 442
Inherited from: adventurejs.Verb#onDoFromThis
Defined in: adventure/dictionary/Verb.js, line 477
Inherited from: adventurejs.Verb#onDoThatFromThis
Defined in: adventure/dictionary/Verb.js, line 463
Inherited from: adventurejs.Verb#onDoThatWithThis
Defined in: adventure/dictionary/Verb.js, line 435
Inherited from: adventurejs.Verb#onDoThis
Defined in: adventure/dictionary/Verb.js, line 470
Inherited from: adventurejs.Verb#onDoThisFromThat
Defined in: adventure/dictionary/Verb.js, line 456
Inherited from: adventurejs.Verb#onDoThisWithThat
Defined in: adventure/dictionary/Verb.js, line 449
Inherited from: adventurejs.Verb#onDoWithThis
Defined in: adventure/dictionary/Verb.js, line 398
Inherited from: adventurejs.Verb#onTryFromThis
Defined in: adventure/dictionary/Verb.js, line 426
Inherited from: adventurejs.Verb#onTryThatFromThis
Defined in: adventure/dictionary/Verb.js, line 412
Inherited from: adventurejs.Verb#onTryThatWithThis
Defined in: adventure/dictionary/Verb.js, line 384
Inherited from: adventurejs.Verb#onTryThis
Defined in: adventure/dictionary/Verb.js, line 419
Inherited from: adventurejs.Verb#onTryThisFromThat
Defined in: adventure/dictionary/Verb.js, line 405
Inherited from: adventurejs.Verb#onTryThisWithThat
Defined in: adventure/dictionary/Verb.js, line 391
Inherited from: adventurejs.Verb#onTryWithThis
Defined in: adventure/dictionary/Verb.js, line 345
Inherited from: adventurejs.Verb#override_verb_failure_msg
Default value: undefined
Defined in: adventure/dictionary/Verb.js, line 354
Inherited from: adventurejs.Verb#override_verb_success_msg
Default value: undefined
Defined in: adventure/dictionary/Verb.js, line 171
Inherited from: adventurejs.Verb#past_tense
Defined in: adventure/dictionary/Verb.js, line 239
Inherited from: adventurejs.Verb#player_must_be
Default value: {}
Defined in: adventure/dictionary/Verb.js, line 162
Inherited from: adventurejs.Verb#prettyname
Defined in: adventure/dictionary/Phrase.js, line 48
Inherited from: adventurejs.Verb#requires_number
Defined in: adventure/dictionary/Phrase.js, line 34
Inherited from: adventurejs.Verb#requires_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".
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.
Defined in: adventure/dictionary/Verb.js, line 485
Inherited from: adventurejs.Verb#synonyms
Default value: []
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".
Defined in: adventure/dictionary/Verb.js, line 567
Inherited from: adventurejs.Verb#verb_noun_prep
Default value: []
Defined in: adventure/dictionary/Verb.js, line 773
Inherited from: adventurejs.Verb#verb_noun_prep_noun
Default value: []
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.
Defined in: adventure/dictionary/Verb.js, line 883
Inherited from: adventurejs.Verb#verb_noun_prep_noun_prep_noun
Default value: []
Defined in: adventure/dictionary/Verb.js, line 830
Inherited from: adventurejs.Verb#verb_noun_prep_prep_noun
Default value: []
Defined in: adventure/dictionary/Verb.js, line 620
Inherited from: adventurejs.Verb#verb_prep_noun
Default value: []
Defined in: adventure/dictionary/Verb.js, line 517
Inherited from: adventurejs.Verb#verb_prep_noun_prep_noun
Default value: []
Defined in: adventure/dictionary/Verb.js, line 936
Inherited from: adventurejs.Verb#verb_prep_noun_prep_noun_prep_noun
Default value: []
Defined in: adventure/dictionary/Verb.js, line 673
Inherited from: adventurejs.Verb#verb_prep_prep_noun
Default value: []
Defined in: adventure/dictionary/Verb.js, line 723
Inherited from: adventurejs.Verb#verb_prep_prep_prep_noun
Default value: []