Verb:draw
Instance of: adventurejs.Verb
Defined in: adventure/dictionary/verbs/draw.js, line 6
Tutorials: Subscriptions VerbAnatomy VerbProcess ModifyVerbs ModifyVerbs
Description
> draw on sidewalk with chalk
You draw a tiny house with a rainbow over it.
Draw on a Tangible
Asset.
Requires that the drawing Asset has
asset.iov.draw.enabled
set to true and that the target has
asset.dov.draw.enabled
set to true.
Draw saves a record
of things drawn on an Asset to its
drawn_things
property, which can be appended to the Asset's description.
Demo
// WritingDemo.js
// ----------
/*global adventurejs WritingDemo*/
var WritingDemo = new adventurejs.Game("WritingDemo", "WritingDemoDisplay").set(
{
// title, version, and author are shown in the title bar
title: "Writing Demo",
version: "0.0.1",
author: "Ivan Cockrum",
description: "This is my great game! Thanks for playing!",
}
);
// Let's set some Game settings
WritingDemo.settings.set({
// apply_color_classes_to_written_strings: true,
// if any of these are true, adventurejs will log
// messages to the browser's console
// See the full list of available settings in
// /doc/adventure_Settings.js.html
log_keywords: {
verbaction: true,
verbreaction: true,
verbphase: true,
game: true,
parser: true,
verb: true,
},
// if any of these are true, adventurejs will print
// debug messages to the game display
debug_keywords: {
general: true,
// verbaction: true,
// verbreaction: true,
// verbphase: true,
},
// if this is true, the game won't infer objects
// until player has already used them
// good for preventing spoilers but can be annoying
objects_must_be_used_before_inferring: false,
// 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 be
// shown on first visit regardless of verbosity settings
print_verbose_room_descriptions_on_first_visit: true,
// 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
// when the parser infers an action, it may print
// the inference, such as "take pot (from stove)"
// for this game we want to turn these off
print_inferred: false,
});
WritingDemo.createAsset({
class: "Room",
name: "Writing Demo Foyer",
// setting definite_article to "the" sets it so the room
// name appears as "the Writing Demo Foyer" in lists
definite_article: "the",
descriptions: {
look: `Welcome to the Writing Demo, where you can try interacting with assets of several related classes including
WritingImplement
(Pen,
Pencil,
Chalk,
Marker),
WritingSurface
(Paper,
Blackboard,
Whiteboard),
Typewriter, and
Eraser. Try
writing on,
drawing on,
typing on, and
erasing things.
Visit the other rooms in this demo to find some
demonstrations. `,
brief: `Try verbs.
Read,
write,
type,
erase. `,
},
exits: {
north: "Classroom",
south: "Library",
east: "Office",
west: "Playroom",
},
}); // Writing Demo Foyer
WritingDemo.createAsset({
class: "Player",
name: "Will",
place: { in: "Writing Demo Foyer" },
is: { active: true },
pronouns: "second",
});
// createClass()
// We're going to create several pieces of paper for this game.
// AdventureJS has a Paper class, but we want to add some
// specific properties to every instance of Paper. First, we
// want to specify several subclasses of WritingImplements that
// can write on them - Pen, Pencil, Crayon - but not Chalk or
// Marker. Then, we want to specify a particular Eraser that
// can erase them - the rubber eraser but not the Whiteboard
// eraser or Blackboard eraser.
//
// This is a minimal class definition. It extends the
// Paper class by customizing its write and erase verb
// subscriptions.
//
// Creating custom classes is an advanced move, so if you decide
// to create some, be sure to RTFM and test them extensively.
// See https://adventurejs.com/doc/AdvancedScripting_CustomClasses.html
// for more info.
WritingDemo.createClass(
class CustomPaper extends adventurejs.Paper {
constructor(name, game_name) {
super(name, game_name);
this.class = "CustomPaper";
// Limit what classes can write on this class.
this.setIOV({
write: { with_classes: ["Crayon", "Pen", "Pencil"] },
});
// Limit what assets can erase this class.
this.setDOV({
erase: { with_assets: ["rubber eraser"] },
});
this.setIOV({
write: {
on_success: function () {
WritingDemo.scorecard.completeEvent("write on paper");
},
},
type: {
// We want to set a custom message when a player tries
// and fails to type on this class. Though it seems
// that "type on paper" would have paper be a direct
// object, type is tricky to parse because technically,
// the information being typed is the direct object,
// even if no information is specified. So, for type,
// the paper and the typewriter are both indirect
// objects.
// Here is one valid way to return a message, but...
// on_failure: `{We} might try putting it in a typewriter. `,
// ...we're going to be nitpicky about how we refer
// to the typewriter. If it's present we'll say
// "the typewriter" and if it's not we'll say
// "a typewriter". We'll use some embedded Javascript
// to test the typewriter's presence.
on_failure: () => {
return `{We} might try putting it in ${
WritingDemo.$("typewriter").$is("present") ? "the" : "a"
} typewriter. `;
},
},
});
}
}
);
// now we can create an instance of our new CustomPaper class
WritingDemo.createAsset({
class: "CustomPaper",
name: "pink paper",
indefinite_article: "a sheet of",
synonyms: ["sheet", "sheet of pink paper"],
description: "It's a sheet of pink paper. ",
place: { in: "Writing Demo Foyer" },
typed_strings: ["Find the two bonus points!"],
});
// Office.js
// ----------
/*global adventurejs A WritingDemo*/
WritingDemo.createAsset({
class: "Room",
name: "Office",
definite_article: "the",
descriptions: {
look: `This office is dominated by an oak mission style desk
with an old fashioned office chair. One wall is covered by a
whiteboard, with a narrow ledge for accessories. Try writing
on things with other things. See the example code
in Office.js for particulars. `,
brief: "Time to get to work. ",
},
exits: { west: "Writing Demo Foyer" },
}); // Office
WritingDemo.createAsset({
class: "Whiteboard",
name: "whiteboard",
place: { in: "Office" },
description: `It's a classic office whiteboard. `,
// Because the whiteboard is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { listed: false },
dov: {
// Though player can use an eraser to erase the whiteboard,
// setting whiteboard.dov.erase.with_nothing = true allows
// the player to erase the whiteboard without another asset,
// which we'll understand to mean that they're using their hand.
// (In fact this is the default setting for class Whiteboard,
// but we're redefining it here just to make this point.)
erase: {
with_nothing: true,
on_success: function () {
WritingDemo.scorecard.completeEvent("erase whiteboard");
},
},
},
iov: {
write: {
on_success: function () {
WritingDemo.scorecard.completeEvent("write on whiteboard");
},
},
},
// Should a player erase the whiteboard without an eraser,
// the verb action doEraseThis() will be called and we can
// treat it as if player is using their hand as an eraser.
doEraseThis: function () {
WritingDemo.appendOutput(`It leaves a smudge of ink on {our} hand. `);
},
}); //
// We don't have any special class for this whiteboard
// ledge so we'll just use the generic Thing class,
// and set whatever properties we might need.
WritingDemo.createAsset({
class: "Thing",
name: "whiteboard ledge",
description: `A narrow ledge that runs the length of the whiteboard, on which to store whiteboard accessories. `,
place: { in: "Office" },
// ensure that player can take things from and put things on the ledge
iov: { take: true, put: true },
// Because the ledge is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { listed: false },
// Thing has no aspects by default, so we'll do the bare
// minimum to define an "on" aspect. Now we can put things
// on it.
aspects: { on: true },
}); //
WritingDemo.createAsset({
class: "WhiteboardEraser",
name: "microfiber eraser",
place: { on: "whiteboard ledge" },
descriptions: { look: "It's a microfiber eraser. " },
// Verb subscriptions
// By setting iov.erase.with_classes to ["Whiteboard"]
// we're customizing this asset's erase verb subscription
// to establish that the whiteboard is the only
// thing this eraser can erase.
//
// This is similar to what we did with the WhiteboardMarker
// class, but we didn't bother to create a new class for
// WhiteboardErasers because there's only one of them,
// so we're just adjusting its individual properties.
// iov: { erase: { with_classes: ["Whiteboard"] } },
// Verb action hooks - doEraseThatWithThis()
// Verb action hooks allow authors
// to call custom code after specific actions.
//
// Verb action hooks can be formatted in different
// ways depending on the level of specificity needed.
//
// In this case, since the whiteboard is the only thing
// the eraser can erase, we know that the "That" in
// doEraseThatWithThis must be the whiteboard, and we can
// refer to it unambiguously in this verb action hook.
doEraseThatWithThis: function () {
WritingDemo.appendOutput(
`The eraser squeaks as it's dragged across the board. `
);
},
}); //
WritingDemo.createAsset({
class: "WhiteboardMarker",
name: "red marker",
adjectives: ["red", "dry erase", "red dry erase"],
place: { on: "whiteboard ledge" },
descriptions: { look: "It's a red dry erase marker. " },
appearance: { color: "red" },
}); // RedMarker
WritingDemo.createAsset({
class: "WhiteboardMarker",
name: "orange marker",
indefinite_article: "an",
adjectives: ["orange", "dry erase", "orange dry erase"],
place: { on: "whiteboard ledge" },
descriptions: { look: "It's a orange dry erase marker. " },
appearance: { color: "orange" },
}); // OrangeMarker
WritingDemo.createAsset({
class: "WhiteboardMarker",
name: "cyan marker",
adjectives: ["cyan", "dry erase", "cyan dry erase"],
place: { on: "whiteboard ledge" },
descriptions: { look: "It's a cyan dry erase marker. " },
appearance: { color: "cyan" },
}); // CyanMarker
WritingDemo.createAsset({
class: "Desk",
name: "desk",
place: { in: "Office" },
// describeDeskDrawers() is an example of a custom function.
// See the function description below for more information.
// Note how we've set description to be a function rather than
// a string, as we've done elsewhere. That is because we're
// using a Javascript ${template literal}, which is always
// evaluated immediately, and so if we set this as a string,
// it would be evaluated at runtime, before the game has built,
// and throw an error. By making it a function, it won't be
// evaluated until we call it.
description: () =>
`It's an oak mission style desk, with an old fashioned office
chair. It has three drawers stacked vertically.
${describeDeskDrawers()}`,
synonyms: [""],
adjectives: ["mission style", "mission", "style", "oak"],
// Just for fun, let's say the player can go under the desk.
aspects: {
under: {
list_contents_in_room: false,
list_contents_in_examine: true,
nest: {
posture: "kneel",
can: { enter: true, exit: true, kneel: true, stand: false },
},
},
},
// Because the desk is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { listed: false },
});
WritingDemo.createAsset({
class: "Drawer",
name: "top drawer",
synonyms: [
"top desk drawer",
"top drawer lock",
"top drawer lock plate",
"lock",
"lock plate",
],
adjectives: ["brass", "desk"],
// Here we're using an AdventureJS custom template
// to print whether the drawer is open or closed.
// Custom templates are like Javascript template literals,
// but a little different.
description: `The top drawer has a small brass lock plate. The drawer is { top drawer [is] open [or] closed }. `,
place: { attached: "desk" },
// We're setting this drawer closed and locked.
// We set listed to false so it doesn't
// get listed like a piece of inventory.
is: {
closed: true,
locked: true,
listed: false,
},
// Setting dov.unlock.with_assets["tiny brass key"]
// means that only the tiny brass key can unlock this.
dov: { unlock: { with_assets: ["tiny brass key"] } },
});
WritingDemo.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: "desk" },
is: {
closed: true,
listed: false,
},
});
WritingDemo.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: "desk" },
is: {
closed: true,
listed: false,
},
});
// Collections
// In our current example, the desk has three drawers. Though
// the parser understands plurals, if a player asked for
// "desk drawers", the parser's default behavior would be
// to prompt for disambiguation: "which drawer did you mean?"
//
// From a player's perspective, that's just tedious, because
// it's perfectly reasonable to expect "examine desk drawers"
// to return a description that includes all three. That's what
// Collections are for. Collections describe a group of assets,
// so that players can refer to multiple assets with one term.
//
// In this case, "desk drawers" is a Collection that represents
// all three desk drawers.
WritingDemo.createAsset({
class: "Collection",
name: "desk drawers",
place: { attached: "desk" },
collection: "top drawer, middle drawer, bottom drawer",
synonyms: ["drawers", "three drawers"],
is: {
listed: false,
},
// describeDeskDrawers() is an example of a custom function.
// See the function description below for more information.
// Note how we've set description to be a function rather than
// a string, as we've done elsewhere. That is because we're
// using a Javascript ${template literal}, which is always
// evaluated immediately, and so if we set this as a string,
// it would be evaluated at runtime, before the game has built,
// and throw an error. By making it a function, it won't be
// evaluated until we call it.
description: () =>
`The desk has three drawers stacked vertically: top, middle and bottom. ${describeDeskDrawers()}`,
});
// describeDeskDrawers()
// Here, we've made a custom function that describes the state
// of all three desk drawers. The reason we've done this
// is so that we can show it in two places without repeating
// code. We use this in the desk's description, and also in
// the desk drawers collection. This function exists in the
// global scope, aka the browser window, which means that
// you can call it from anywhere. (Technically, this is kind
// of sloppy, and you probably shouldn't do it in other
// environments, but it won't hurt anything in AdventureJS.)
// @returns string
function describeDeskDrawers() {
const open = [];
const closed = [];
let msg = "The top drawer has a small brass lockplate. ";
// get a list of all the open drawers
// and a list of all the closed drawers
WritingDemo.$("top drawer").is.closed ? closed.push("top") : open.push("top");
WritingDemo.$("middle drawer").is.closed
? closed.push("middle")
: open.push("middle");
WritingDemo.$("bottom drawer").is.closed
? closed.push("bottom")
: open.push("bottom");
// print a slightly different description based
// on however many drawers are open or closed
switch (open.length) {
case 0:
msg += `All three drawers are closed. `;
break;
case 1:
msg += `The ${closed[0]} and ${closed[1]} drawers are closed. The ${open[0]} drawer is open. `;
break;
case 2:
msg += `The ${open[0]} and ${open[1]} drawers are open. The ${closed[0]} drawer is closed. `;
break;
case 3:
msg += `All three drawers are open. `;
break;
}
return msg;
}
WritingDemo.createAsset({
class: "Chair",
name: "office chair",
indefinite_article: "an",
place: { in: "Office" },
// It's a swivel chair, so we're going to allow
// the verb turn to act on it.
dov: { turn: true },
description: `It's an old fashioned wooden office chair that rolls on swiveling castors. `,
// Because the chair is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { listed: false },
// Use as many adjectives and synonyms as you like.
// Adding more words makes it easier for you and your
// player. It reduces players' chances of getting stuck
// playing guess-the-word, and increases your chances
// of correctly parsing players' input.
synonyms: ["castor", "castors"],
adjectives: ["old", "fashioned", "old fashioned", "heavy", "wooden"],
// This is an example of a verb reaction hook. Any time
// Will (the player character of this game) gets out of
// the chair, this string will be prepended to the
// game's default output. It's also possible to
// appendOutput or overrideOutput.
doUnnestThatFromThis: {
Will: function () {
WritingDemo.prependOutput(
`The office chair creaks as {we} climb out of it. `
);
},
},
aspects: {
on: {
// Because we're not listing the chair, things placed on it
// won't be listed either. We're explicitly setting it so
// that they will be.
list_contents_in_room: true,
// By default, when the player is nested in one asset,
// they can't reach things in/on other assets.
// Setting aspects.on.nest.can.reach["student desk"] enables
// the player to reach the desk and items in/on it,
// such as the drawers and typewriter, while sitting
// in the office chair.
nest: { can: { reach: ["desk"] } },
},
},
});
WritingDemo.createAsset({
class: "Key",
name: "tiny brass key",
image: "brasskey",
description: "It's a tiny key, made of brass. ",
adjectives: ["tiny", "brass"],
place: { on: "desk" },
});
WritingDemo.createAsset({
class: "Pencil",
name: "mechanical pencil",
adjectives: "brass",
synonyms: ["design", "designs"],
place: { on: "desk" },
description:
"It's a mechanical pencil made out of pressed brass, with intricate designs stamped into it. ",
}); // BrassPencil
WritingDemo.createAsset({
class: "Eraser",
name: "rubber eraser",
place: { on: "desk" },
description: `It's an ordinary rubber eraser. `,
iov: {
erase: {
on_success: function () {
WritingDemo.scorecard.completeEvent("erase paper");
},
},
},
}); // BrassPencil
WritingDemo.createAsset({
class: "Pen",
name: "indigo pen",
indefinite_article: "an",
adjectives: "indigo",
place: { in: "top drawer" },
descriptions: { look: "It's a pen with indigo ink. " },
appearance: { color: "indigo" },
}); // IndigoPen
WritingDemo.createAsset({
class: "Pen",
name: "yellow pen",
adjectives: "yellow",
place: { in: "top drawer" },
descriptions: { look: "It's a pen with yellow ink. " },
appearance: { color: "yellow" },
}); // YellowPen
WritingDemo.createAsset({
class: "Pen",
name: "green pen",
adjectives: "green",
place: { in: "top drawer" },
descriptions: { look: "It's a pen with green ink. " },
appearance: { color: "green" },
iov: {
write: {
on_first_success: () => {
WritingDemo.scorecard.completeEvent("write with green pen");
},
},
},
}); //GreenPen
WritingDemo.createAsset({
class: "PenCap",
name: "pen cap",
place: { attached: "green pen" },
descriptions: { look: "It's a cap for a pen. " },
}); //
WritingDemo.createAsset({
class: "CustomPaper",
name: "white paper",
indefinite_article: "a sheet of",
synonyms: ["sheet", "sheet of white paper"],
adjectives: [""],
description: "It's a sheet of white paper. ",
place: { on: "desk" },
dov: { erase: { with_assets: ["rubber eraser"] } },
});
// Playroom.js
// ----------
/*global adventurejs A WritingDemo*/
WritingDemo.createAsset({
class: "Room",
name: "Playroom",
definite_article: "the",
descriptions: {
look: `Generations of children have lounged upon floor cushions scattered around a low activity table.
See the example code in Playroom.js for particulars. `,
brief: "Table. Cushions. Please take your seat. ",
},
exits: { east: "Writing Demo Foyer" },
}); // Playroom
WritingDemo.createAsset({
class: "Table",
name: "activity table",
place: { in: "Playroom" },
description: `It's a low table, perfect for arts and crafting. `,
adjectives: [""],
// The activity table is mentioned in the room description,
// so we don't need it listed in the room, but we do want
// the things on it to be listed in the room.
is: { listed: false },
// By default, Table class has an under aspect which is not
// revealed until player examines table, but in this case,
// we want player to see what's under the table as soon
// as they enter the room.
aspects: {
under: { know_contents_with_parent: true, list_contents_in_room: true },
},
});
WritingDemo.createAsset({
class: "Thing",
name: "cushions",
synonyms: ["cushion"],
adjectives: ["floor"],
place: { in: "Playroom" },
description: `A gang of comfortable floor cushions. `,
is: { listed: false },
// Because we're building on the basic Thing class, we have
// to define some basic setup stuff that might otherwise have
// been preset if we'd used a more specialized class.
// (The Furniture class would been suitable for these cushions.)
// Here, we need to set up an on aspect with a nest for the
// player to enter, and specify that the activity table is
// reachable while sitting in it.
aspects: {
on: {
nest: {
posture: "sit",
can: { enter: true, exit: true, sit: true, reach: ["activity table"] },
},
},
},
// Continuing with the basic setup...
// If player says "get up", which gets parsed as "stand up",
// while sitting on the cushions, we want to ensure they
// get off the cushions, as opposed to trying to stand up
// in place on the cushions, which is the default behavior
// for stand.
quirks: { stand_means_get_off: true },
// We want to print a custom message when the player sits here.
doNestThatToThis: {
Will: () => {
WritingDemo.scorecard.completeEvent("sit on cushions");
WritingDemo.overrideOutput(
`{We} settle down cross legged among the floor cushions, {our} knees pressed against the low activity table. `
);
},
},
// We want to print a custom message when the player leaves this.
doUnnestThatFromThis: {
Will: () => {
WritingDemo.overrideOutput(
`{We} climb up off the cushions, bumping the table along the way. `
);
},
},
}); // Cushions
WritingDemo.createAsset({
class: "Pencil",
name: "blue pencil",
adjectives: ["blue", "colored"],
place: { on: "activity table" },
description: "It's a blue colored pencil. ",
appearance: { color: "blue" },
}); // BluePencil
WritingDemo.createAsset({
class: "Pencil",
name: "pink pencil",
adjectives: ["pink", "colored"],
place: { on: "activity table" },
description: `It's an pink colored pencil. `,
appearance: { color: "pink" },
}); // PinkPencil
WritingDemo.createAsset({
class: "Pencil",
name: "teal pencil",
adjectives: ["teal", "colored"],
place: { on: "activity table" },
description: `It's a teal colored pencil. `,
appearance: { color: "teal" },
}); // TealPencil
WritingDemo.createAsset({
class: "CustomPaper",
name: "drawing paper",
indefinite_article: "a sheet of",
synonyms: ["sheet", "sheet of drawing paper"],
adjectives: [""],
description: "It's a sheet of drawing paper. ",
place: { on: "activity table" },
// It isn't necessary to include this next line because it is
// baked into the Paper class, but it's worth seeing how we
// determine which WritingImplements may write on which
// WritingSurfaces. Here, we're saying that Paper is
// subscribed to the verb write with these classes. If
// player tries to write on Paper with anything else, they'll
// get an error message.
// dov: { write: { with_classes: ["Crayon", "Pen", "Pencil"] } },
dov: { erase: { with_assets: ["rubber eraser"] } },
});
WritingDemo.createAsset({
class: "Crayon",
name: "purple crayon",
adjectives: [""],
place: { under: "activity table" },
description: `It's a purple crayon. `,
// Assigning a color to a WritingImplement is optional.
// If provided, the text that is written will be printed
// back with a CSS class with the name of that color, and
// a CSS class of the particular WritingImplement subclass.
// You can use this to make that text print in that color,
// or in a different font, etc.
//
// For example, strings written with this purple crayon
// will be printed like this and appear in purple:
// foo
//
// adventurejs.css has a few standard color classes defined.
// You're welcome to customize such classes as you like.
appearance: { color: "purple" },
}); //
// Classroom.js
// ----------
/*global adventurejs A WritingDemo*/
WritingDemo.createAsset({
class: "Room",
name: "Classroom",
definite_article: "the",
descriptions: {
look: `This classroom features an antique student desk with
an attached bench, facing a large blackboard
with a narrow ledge for accessories. Try writing
on things and erasing things. See the example code in
Classroom.js for particulars. `,
brief: "Blackboard. Desk. Bench. Please take your seat. ",
},
exits: { south: "Writing Demo Foyer" },
}); // Classroom
WritingDemo.createAsset({
class: "Blackboard",
name: "blackboard",
place: { in: "Classroom" },
description: `It's a classic schoolroom blackboard. `,
// Because the blackboard is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { listed: false },
dov: {
// Though player can use an eraser to erase the blackboard,
// setting dov.erase.with_nothing = true allows the player
// to erase the blackboard without another asset.
// (This is the default setting for class Blackboard.
// We're redefining it here just to make the point.)
erase: {
with_nothing: true,
on_success: function () {
WritingDemo.scorecard.completeEvent("erase blackboard");
},
},
},
iov: {
// The reason why write is defined under iov rather
// than dov is because when writing, the thing being
// written is always the direct object, while both
// the writing implement and the writing surface are
// indirect objects.
write: {
with_classes: ["Chalk"],
on_success: function () {
WritingDemo.scorecard.completeEvent("write on blackboard");
},
},
},
// Should a player erase the blackboard without an eraser,
// the verb action doEraseThis() will be called and we can
// treat it as if player is using their hand as an eraser.
doEraseThis: function () {
WritingDemo.appendOutput(
`It leaves a powdering of chalk dust on {our} hand. `
);
},
}); //
// We don't have any special class for this blackboard
// ledge so we'll just use the generic Thing class,
// and set whatever properties we might need.
WritingDemo.createAsset({
class: "Thing",
name: "blackboard ledge",
description: `A narrow ledge that runs the length of the blackboard, on which to store blackboard accessories. `,
place: { in: "Classroom" },
// ensure that player can take things from and put things on the ledge
iov: { take: true, put: true },
// Because the ledge is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { listed: false },
// Thing has no aspects by default, so we'll do the bare
// minimum to define an "on" aspect. Now we can put things
// on it. Though the ledge's listed is false,
// we can still have its contents listed in the room by
// setting the on aspect's list_contents_in_room to true.
aspects: { on: { list_contents_in_room: true } },
}); //
WritingDemo.createAsset({
class: "BlackboardEraser",
name: "felt eraser",
place: { on: "blackboard ledge" },
descriptions: { look: "It's a felt eraser. " },
// Verb action hooks - doEraseThatWithThis()
//
// Verb action hooks allow authors
// to call custom code after specific actions.
// Verb action hooks can be formatted in different
// ways depending on the level of specificity needed.
//
// In this case, since the whiteboard is the only thing
// the eraser can erase, we know that the "That" in
// doEraseThatWithThis must be the whiteboard, and we can
// refer to it unambiguously in this verb action hook.
doEraseThatWithThis: {
blackboard: function () {
WritingDemo.appendOutput(`A small cloud of chalk dust puffs out. `);
},
},
}); //
WritingDemo.createAsset({
class: "Chalk",
name: "stick of white chalk",
synonyms: "white chalk",
adjectives: "white",
place: { on: "blackboard ledge" },
descriptions: { look: "It's a stick of white chalk. " },
appearance: { color: "white" },
}); //
WritingDemo.createAsset({
class: "Chalk",
name: "stick of pink chalk",
synonyms: "pink chalk",
adjectives: "pink",
place: { on: "blackboard ledge" },
descriptions: { look: "It's a stick of pink chalk. " },
// Setting appearance.color is optional, but when it's set
// for WritingImplements, anything written with that tool
// will be printed to the game display with that color as
// a CSS class name. For example:
// whatever player wrote
appearance: { color: "pink" },
}); //
WritingDemo.createAsset({
class: "Chalk",
name: "stick of blue chalk",
synonyms: "blue chalk",
adjectives: "blue",
place: { on: "blackboard ledge" },
descriptions: { look: "It's a stick of blue chalk. " },
appearance: { color: "blue" },
}); //
WritingDemo.createAsset({
class: "Paper",
name: "blue paper",
synonyms: ["sheet", "sheet of blue paper"],
indefinite_article: "a sheet of",
adjectives: [""],
description: "It's a sheet of blue paper. ",
place: { in: "student desk" },
dov: { erase: { with_assets: ["rubber eraser"] } },
});
WritingDemo.createAsset({
class: "Desk",
name: "student desk",
place: { in: "Classroom" },
description: () =>
`It's an old-fashioned lift top school desk with an
attached bench. The desk top is {student desk [is] open [or] closed}. `,
synonyms: [""],
adjectives: [""],
dov: { open: true, close: true },
// Because the desk is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { closed: true, listed: false },
// If the desk's listed were true, the things sitting
// on it would be automatically listed. But since we've made
// the desk unlisted, we need to explicitly tell the game
// to list the things on the desk.
aspects: {
on: { list_contents_in_room: true },
in: { list_contents_in_room: true },
attached: {
// We've included the bench in the desk's description, so
// we don't want it listed as an inventory item when
// the desk is examined.
list_contents_in_examine: false,
// However, we do want the bench known/seen with the desk.
// The Desk class sets know_contents_with_parent and
// see_contents_with_parent to false, because the class
// definition assumes that anything attached to the desk
// is a drawer or something similar, where you might not
// want the player knowing about their contents until they
// open the drawer. We're going to override these properties
// to ensure that the player knows/sees the bench.
know_contents_with_parent: true,
see_contents_with_parent: true,
},
},
});
WritingDemo.createAsset({
class: "Chair",
name: "bench",
place: { attached: "student desk" },
synonyms: [""],
adjectives: ["uncomfortable", "wooden"],
description: `It's an uncomfortable looking wooden bench. `,
// Because the chair is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: {
listed: false,
// Because the bench is attached to the desk, it needs the
// is.deep_nest flag to allow player to nest to it.
// Technically it wasn't necessary to attach the bench to
// the desk - we could have just described it as being
// attached without actually attaching it. In this case it's
// just a matter of organizational preference.
deep_nest: true,
},
aspects: {
on: {
// Because we're not listing the chair, things placed on it
// won't be listed either. We're explicitly setting it so
// that they will be.
list_contents_in_room: true,
// By default, when the player is nested in one asset,
// they can't reach things in/on other assets.
// Setting aspects.on.nest.can.reach["student desk"] enables
// the player to reach the desk and items in/on it,
// such as the drawers and typewriter, while sitting
// in the office chair.
nest: { can: { reach: ["student desk"] } },
},
},
// doNestThatToThis()
// This is an example of a verb reaction hook. Any time
// Will (the player character of this game) gets into or
// out of the bench, the provided string will override the
// game's default output. It's also possible to
// appendOutput or prependOutput.
doNestThatToThis: {
Will: function () {
WritingDemo.overrideOutput(`{We} fold {ourself} into the small bench. `);
},
},
doUnnestThatFromThis: {
Will: function () {
WritingDemo.overrideOutput(
`{We} unfold {ourself} from the small bench. `
);
},
},
});
// Library.js
// ----------
/*global adventurejs A WritingDemo*/
WritingDemo.createAsset({
class: "Room",
name: "Library",
definite_article: "the",
descriptions: {
look: `Cramped shelves full of dusty books, but they're unimportant right now. A modest rolltop desk is permanently open to display an antique typewriter. Try typing. See the example code in Library.js for particulars. `,
brief: "Shelves. Books. Desk. Type! ",
},
exits: { north: "Writing Demo Foyer" },
}); // Library
WritingDemo.createAsset({
class: "Desk",
name: "rolltop desk",
adjectives: ["modest"],
place: { in: "Library" },
description: `It's a modest rolltop desk, locked in the open position. `,
// Because the desk is mentioned in the room description,
// we don't need it listed as a piece of inventory in the room.
// We can prevent it from being listed by setting
// is.listed to false.
is: { listed: false },
}); // RolltopDesk
WritingDemo.createAsset({
class: "Scenery",
name: "cramped shelves",
place: { in: "Library" },
description: `The cramped shelves are just a scenery object. You know. For verisimilitude. `,
// The shelves, being a scenery asset, aren't
// subscribed to verb climb and can't be climbed,
// but if a player should try to climb them, we
// want to offer a snappy response. We have a variety
// of verb hooks to work with. In this case,
// tryClimb() is the simplest option. We'll use
// overrideOutput to override the default response.
tryClimb: () => {
WritingDemo.overrideOutput(`In Soviet Russia, shelves climb you! `);
WritingDemo.scorecard.completeEvent("try to climb shelves");
},
}); // cramped shelves
WritingDemo.createAsset({
class: "Scenery",
name: "dusty books",
place: { in: "Library" },
description: `The dusty books are just another lousy scenery object. `,
// The books, like the shelves, are a scenery object
// that can't be interacted with, but we want to
// offer snappy responses to a few likely player actions.
tryRead: () => {
WritingDemo.print(`In Soviet Russia, books read you! `);
// return false ends the turn without further processing
return false;
},
tryTake: () => {
WritingDemo.print(`In Soviet Russia, books take you! `);
// return false ends the turn without further processing
return false;
},
}); // dusty books
WritingDemo.createAsset({
class: "CustomPaper",
name: "onionskin paper",
indefinite_article: "a sheet of",
synonyms: ["sheet", "sheet of onionskin paper"],
description: "It's a sheet of onionskin paper. ",
place: { on: "rolltop desk" },
});
WritingDemo.createAsset({
class: "Typewriter",
name: "typewriter",
adjectives: ["spindly", "old", "mechanical"],
place: { on: "rolltop desk" },
description: `It's a spindly old mechanical typewriter. `,
// By default, instances of Typewriter can be carried
// as inventory but we don't want this one to be moved
// so we're going to unset these verb subscriptions.
dov: {
take: false,
put: false,
get: false,
give: false,
move: false,
},
// Here, we want to check if there is a piece of paper
// in the typewriter when player types on it.
// There are several different ways to hook into verbs,
// ranging from broad to very granular, and taking into
// account whether the asset was the direct or indirect
// object of the verb. That gets a little tricky with
// the verb type, because player may input
// "type on typewriter", "type on paper",
// "type 'Hello, World!' on paper,"
// "type 'Hello, World!' on typewriter," etc.
// All of these will work, and the typewriter may be
// direct or indirect, depending on how the input was
// structured. So we're going to use a broad hook:
// doType is called any time the verb type is used on
// the typewriter, regardless of direct / indirect,
// and we're going to check if the typewriter has paper in it.
// See https://adventurejs.com/doc/Scripting_VerbHooks.html
// for more info on verb hooks.
doType: function () {
if (this.hasContents("in")) {
// Paper is the only class that can be put in Typewriter
// so if it's not empty, it's got a piece of paper in it
// and we can confidently refer to paper in our appended
// output.
WritingDemo.appendOutput(`Now try reading the paper. `);
WritingDemo.scorecard.completeEvent("type on paper");
} else {
// The typewriter is empty so let's append the default
// verb message to help inform the player.
WritingDemo.appendOutput(
`{We} might try putting a piece of paper in it. `
);
}
},
});
WritingDemo.createAsset({
class: "Thing",
name: "small placard",
place: { on: "rolltop desk" },
// See how this placard description uses custom HTML/CSS.
// We defined the CSS for this style inside the Styles.css
// file that loads with this game. You can load CSS
// via the html link tag, or embed it in a style tag
// in the HTML page that loads your game.
descriptions: {
look: `{We} see a neat typewritten note.
To use the typewriter,
insert a sheet of paper, use the verb type,
and put quotes around the string to be typed.
type "hello world"
`,
// We want to return the same description whether
// player looks at the placard or reads it, and we
// don't want to duplicate that code, so we set
// placard.descriptions.read to point to
// placard.descriptions.look
read: function () {
return this.descriptions.look;
},
// Sometimes we use ()=> arrow functions, but in this
// case, in order to get the right scope when we refer
// to this.descriptions, we need to use a standard function.
},
dov: { read: true },
});
// Scorecard.js
// ----------
/*global adventurejs WritingDemo*/
// Scoring
WritingDemo.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.
// See http://adventurejs.com/doc/Scripting_Scorecard.html
// for more info.
score_events: {
"write on whiteboard": 1,
"erase whiteboard": 1,
"write on blackboard": 1,
"erase blackboard": 1,
"type on paper": 1,
"write on paper": 1,
"erase paper": 1,
// You can also assign "bonus" points. These won't be
// counted in the total, allowing player to earn a
// score like 110/100.
"try to climb shelves": {
points: 1,
bonus: true,
// Customize the score message by setting message
// to a string or array or function.
message: "[ ** {We} got a bonus point! ** ]",
},
"write with green pen": {
points: 1,
bonus: true,
// Customize the score message by setting message
// to a string or array or function.
message: "[ ** {We} got a bonus point for getting the cap off! ** ]",
},
},
});
Source files
draw verb logic
Verb logic falls into a few recognizable patterns. Direction verbs tend to be simple and redirect to tryTravel()
. Manipulation verbs test whether one asset is allowed to interact with another asset. Locomotion verbs test the player's current ability to move in a specified way. Many verbs are similar, but no two verbs are identical. Each verb has its quirks. If you would like to learn more about general verb logic, we recommend you see the Verb Anatomy and Verb Process pages. Verb phases and verb actions / reactions offer various hooks to customize verb behavior. If you find that you want still more flexibility, you may want to investigate the patchVerb method, which lets you replace entire blocks of verb code. You can also write verbs from scratch if you're so inclined. See Modify Verbs for a complete list of verb modification methods.
The following sections provide information that is specific to the verb draw
, though they include many features which are common to most verbs.
- Verb Demo
- Sentence Structures help filter player input by defining what sentence structures
draw
can handle. - Verb Phrases describe the direct and indirect objects that
draw
can handle. - Verb Subscriptions enable
draw
to act on specific assets, and provide a collection of properties for customizing those interactions. - Verb Phases offer a broad method for authors to hook into default logic and override it with custom code.
- Verb Actions offer a surgical method for authors to hook into
draw
's default logic and inject custom code. - Verb Reactions are Verb Actions that occur as secondary effects of successfully applying
draw
. - Verb Params contain properties that are distinct to
draw
. Not all verbs have params. - Verb Methods lists the methods that
draw
inherits from the Verb class. - Verb Properties lists the properties that
draw
inherits from the Verb class.
draw sequencing
draw subscriptions
An asset must be subscribed to a verb for that verb to act upon that asset (with some exceptions). Though verbs are universal, each asset's verb subscriptions are distinct objects that can be used to customize how a given verb interacts with a given asset. To say it another way, a verb subscription is a collection of properties that defines how a verb should be applied to an asset; which allow authors to override a verb's default behaviors on a per-asset basis.
It's important to note that verb subscriptions need to be declared as direct or indirect, depending on whether the asset will be used as a direct object or indirect object. In the case of "unlock lock with key", the lock is the direct object and the key is the indirect object, and each asset needs to be subscribed to unlock in the appropriate way. (It's allowed, and a common pattern, to subscribe assets directly and indirectly to the same verb.)
Expand for example
MyGame.createAsset({
class: "Lock",
name: "lock",
dov: { unlock: true },
});
MyGame.createAsset({
class: "Key",
name: "key",
iov: { unlock: true },
});
As shown in the above example, dov: { unlock: true }
is the minimum that is required to subscribe an asset to a verb. However, verb subscriptions have many properties that can be used to customize how this verb is applied to this asset. (Setting any property eliminates the need to set verb: true
. ) Below is a list of verb subscription properties that authors may find useful.
automatically
allows for some verbs to be performed automatically if context calls for it; for example, when unlocking a door in order to pass through it. This takes precedence over global settings.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { automatically: true } }, });
automatically_after_use
if automatically is set true, this sets it so that a verb can only be applied automatically after a player has already used it manually. This is to prevent automatic use of tools from breaking puzzles. For example, imagine one door with many keys but only one that works; if choosing the right key is part of the puzzle, this option prevents players from simply saying "unlock door" and having the right key automatically selected for them.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { automatically_after_use: true } }, });
doBeforeTry
Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more aboutdraw
's verb phases.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { doBeforeTry: function (e) { console.log("draw.doBeforeTry"); }, } }, });
doAfterTry
Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more aboutdraw
's verb phases.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { doAfterTry: function (e) { console.log("draw.doAfterTry"); }, } }, });
doBeforeSuccess
Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more aboutdraw
's verb phases.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { doBeforeSuccess: function (e) { console.log("draw.doBeforeSuccess"); }, } }, });
doAfterSuccess
Verb phases provide methods to override default verb behaviors. See the verb phases section on this page to learn more aboutdraw
's verb phases.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { doAfterSuccess: function (e) { console.log("draw.doAfterSuccess"); }, } }, });
enabled
allows changing the state of an asset's responsiveness to a given verb. If set false, a subscribed asset will not respond to the verb. This is useful for temporarily disabling verbs for specific assets; for example, if you had a door that could not be unlocked until another action was completed. Authors can enable or disable an individual verb subscription viaasset.setDOV(verbname)
andasset.unsetDOV(verbname)
Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { enabled: true } }, });
on_success
is an optional parameter. It is set as a string by default, but authors may provide a string or array or function to be served by getStringOrArrayOrFunction(). The resulting string will be appended to the verb's default success message.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { on_success: "You draw the thing. " } }, });
on_first_success
is an optional parameter. It is set as a string by default, but may provide a string or array or function to be served by getStringOrArrayOrFunction(). The resulting string will be appended to the verb's default success message the first time it is applied to this asset.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { on_first_success: "You draw the thing the first time. " } }, });
on_failure
is an optional parameter. It is set as a string by default, but may provide a string or array or function to be served by getStringOrArrayOrFunction(). The resulting string will be appended to the verb's default failure message.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { on_failure: "You failed to draw the thing. " } }, });
on_first_failure
is an optional parameter. It is set as a string by default, but may provide a string or array or function to be served by getStringOrArrayOrFunction(). The resulting string will be appended to the verb's default failure message the first time it is applied to this asset.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { on_first_failure: "You failed to draw the thing the first time. " } }, });
once
if true, the verb can only be applied once to the asset. The verb subscription will be disabled after use.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { once: true } }, });
then_destroy
allows author to specify that this asset should be destroyed after using. If then_destroy is set, the asset will be destroyed after a single use regardless of how once is set. By default, then_destroy is set to a boolean. It may optionally be set to string or array or function subject to getStringOrArrayOrFunction(). If any of those types are found, they will be called and returned as results.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { then_destroy: true } }, });
with_anything
pertains only to indirect objects. If true, this asset can be used as an indirect object of this verb with any direct object.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", iov: { draw: { with_anything: true } }, });
with_assets
allows author to specify particular assets that can interact with this one using the given verb. For example "unlock door with key" where the specified key is the only asset that can unlock door. This works distinctly for direct and indirect verb subscriptions. So, for instance, in "unlock door with key", the door might have a direct object subscription, while the key has an indirect object description.Expand for example
MyGame.createAsset({ class: "Door", name: "gold door", dov: { unlock: { with_assets: [ "gold key" ] } }, }); MyGame.createAsset({ class: "Key", name: "gold key", iov: { unlock: { with_assets: [ "gold door" ] } }, });
with_classes
allows author to specify particular classes that can interact with this asset using the given verb. For example "unlock door with skeleton key" where any instance of the class SkeletonKey can unlock door. This works distinctly for direct and indirect verb subscriptions. So, for instance, in "unlock door with skeleton key", the door might have a direct object subscription, while the key has an indirect object description.Expand for example
MyGame.createAsset({ class: "Door", name: "red door", dov: { unlock: { with_classes: [ "SkeletonKey" ] } }, }); MyGame.createAsset({ class: "SkeletonKey", name: "skeleton key", iov: { unlock: { with_classes: [ "Door", "Chest" ] } }, });
with_nothing
pertains only to direct objects. If true, the specified verb can be applied to the direct object without the use of any indirect object.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { with_nothing: true } }, });
with_params
is used to contain a set of parameters that are specific to this particular verb. For example, plugIn includeswith_params.max_connections
for setting limits on how many other assets this asset can be plugged in to. See the with_params section on this page to learn more aboutdraw
's parameters.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { with_params: { // tool is a drawing implement tool: false, // target is a drawing surface target: false, } } }, });
with_prepositions
allows author to explicitly permit certain prepositions to be used with a verb on this object. For instance: "knock over umbrella stand" might fail with a message of "you can't knock over the umbrella stand"; settingumbrella_stand.dov.knock.with_prepositions = ["over"]
will allow the action to succeed.Expand for example
MyGame.createAsset({ class: "Thing", name: "universal widget", dov: { draw: { with_prepositions: [ "through", "over" ] } }, });
Notes
- To learn more about working with verb subscriptions, see Verb Subscriptions.
- These are most, but not all, of the properties of a verb subscription. For full reference, see the VerbSubscription class.
draw sentence structures
accepts_structures: [
"verb noun",
"verb preposition noun",
"verb noun preposition noun",
"verb preposition noun preposition noun",
"verb noun preposition noun preposition noun"
]
The parser uses multiple filtering methods to try to channel player input into useable tokens. Sentence structures are defined for each verb in order to narrow down the input that the verb can handle. For example, the verb "hit" might accept "verb noun" as in "hit troll", or "verb noun preposition noun" as in "hit troll with sword", whereas an intransitive verb like "jump" might accept "verb" as a complete sentence. Input that isn't accepted will return a warning to the player.
A note about adverbs: though the parser does handle some adverbs, such as "carefully examine tiara" and "turn left", it excludes them from consideration in sentence structures. Due to the slipperyness of the English language, an adverb can appear in multiple positions in a sentence while still describing the same verb, which presents enough possible word combinations to make sentence structures less useful as a filtering tool. Instead, the parser puts adverbs aside and handles them separately.
Notes
- It is possible for authors to modify a verb's structures through the use of patchVerb.
- To learn more about modifying verbs, see Modify Verbs.
draw phrases
phrase1:
{
accepts_noun: true,
requires_noun: true,
noun_must_be:
{
known: true,
present: true,
visible: true,
reachable: true,
},
accepts_preposition: true,
preposition_must_be: ["on", "with"],
},
phrase2:
{
accepts_noun: true,
requires_noun: true,
noun_must_be:
{
known: true,
present: true,
visible: true,
reachable: true,
prefer_carried_if_ambiguous: true,
},
accepts_preposition: true,
requires_preposition: true,
preposition_must_be: ["on", "with"],
},
phrase3:
{
accepts_noun: true,
requires_noun: true,
noun_must_be:
{
known: true,
present: true,
visible: true,
reachable: true,
prefer_carried_if_ambiguous: true,
},
accepts_preposition: true,
requires_preposition: true,
preposition_must_be: ["on", "with"],
},
The AdventureJS parser uses multiple filtering methods to try to interpret player input. A verb's phrases may consist of a noun and/or a preposition. Whether any noun is defined as a direct or indirect object is up to that verb's unique logic. Each verb defines a unique set of phrases depending on what its logic can handle. Verbs may handle zero, one, two, or three nouns. The nested noun_must_be object sets conditional qualifiers to help narrow down assets that the verb might act upon. Input that isn't accepted will return a warning to the player.
Notes
- It is possible for authors to modify a verb's phrases through the use of patchVerb.
- To see a list of properties that can be set for phrases, see the Phrase class.
- To see a list of properties that can be set for phrase.noun_must_be, see the NounMustBe class.
- To learn more about modifying verbs, see Modify Verbs.
draw phase hooks
Verb phase hooks let authors override verb subscriptions for specific assets when draw
is applied to them. This is a broad method for customizing verb/noun interactions on a per-asset basis. For example, an author might supply completely different logic for "throw feather" vs "throw baseball" vs "throw anvil".
When draw.do()
is called, it attempts to run a sequence of methods, or phases, as listed below. The four hooks have no default logic of their own but provide methods to inject custom code at any point in the life cycle of the verb action. See below for examples of how to use verb phases for draw
.
do
doBeforeTry hook
MyGame.createAsset({
class: "Thing",
name: "This Asset",
dov: {
draw: {
doBeforeTry: function( params )
{
let msg = `You're about to try to draw ${this.articlename}. `;
this.game.print(msg);
return;
},
},
},
});
doTry handles logic to determine if draw can be applied
doAfterTry hook
MyGame.createAsset({
class: "Thing",
name: "This Asset",
dov: {
draw: {
doAfterTry: function( params )
{
let msg = `You just tried to draw ${this.articlename}! `;
this.game.print(msg);
return;
},
},
},
});
doBeforeSuccess hook
MyGame.createAsset({
class: "Thing",
name: "This Asset",
dov: {
draw: {
doBeforeSuccess: function( params )
{
let msg = `You're about to succeed in performing draw on ${this.articlename}. `;
this.game.print(msg);
return;
},
},
},
});
doSuccess handles state changes and printing messages
doAfterSuccess hook
MyGame.createAsset({
class: "Thing",
name: "This Asset",
dov: {
draw: {
doAfterSuccess: function( params )
{
let msg = `You succeeded in performing draw on ${this.articlename}. `;
this.game.print(msg);
return;
},
},
},
});
Expand for example
Assets must have separate direct and indirect verb subscriptions. Consider this singing sword, which is directly subscribed to the verb "take". We want our game to print a custom message when the player tries to take the sword, and a different message when the player succeeds in taking it.
MyGame.createAsset({
class: "Sword",
name: "singing sword",
dov: {
take:
{
doAfterTry: function()
{
let msg = "The sword begins to vibrate as your hand curls around its haft. ";
MyGame.print( msg );
},
doAfterSuccess: function()
{
let msg = "The sword bursts into song in your hand. ";
MyGame.print( msg );
},
},
},
});
Now consider this stone, which is indirectly subscribed to "remove". We want to print messages when the sword is removed from it, so we'll hook into the stone's indirect object subscription. We could put this code on either object. A case like this comes down to author's choice.
MyGame.createAsset({
class: "Thing",
name: "stone",
iov: {
remove:
{
doBeforeTry: function()
{
let msg = "Will the stone judge you worthy enough to remove the sword? "
MyGame.print( msg );
},
doAfterSuccess: function()
{
let msg = "With the sword removed, the stone bursts into rubble! ";
MyGame.print( msg );
this.destroy();
},
},
},
});
Notes
- To learn more, see verb phase hooks.
- Verb phase hooks are similar to, but distinct from, verb action hooks and verb reaction hooks, which offer more surgical hooks.
draw action hooks
Every asset referred to in the turn's input is checked for verb action hooks. These hooks allow authors to inject custom code or print custom text during verb operations. There are two distinct approaches to defining verb actions, designed to accommodate different levels of scripting experience. Authors may use whichever approach they find most comfortable. For more details, see Action Hooks.
-
Simple approach: Define string properties such as
asset.do_draw
. If AdventureJS finds a string, it prints it instead of the default output for that turn. This option is best for authors who want to customize output without writing code. -
Advanced approach: Define method properties such as
asset.doDraw()
. If a method is found, it is called with a parameter object containing any relevant assets from the input (e.g.,asset.doDraw({asset1,asset2})
). The author may use or ignore these parameters. This approach offers complete control over the turn’s outcome: authors can add conditional logic, force success or failure, or revise the default output.
String properties
Expand any item to see code examples.
try_draw_this
Called on This
asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_this: "Found custom string at thing_one.try_draw_this", });
-
In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.
MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_this: { "Player Two": "Found custom string at thing_one.try_draw_this['Player Two']", }, });
do_draw_this
Called on This
asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_this: "Found custom string at thing_one.do_draw_this", });
-
In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.
MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_this: { "Player Two": "Found custom string at thing_one.do_draw_this['Player Two']", }, });
try_draw_preposition_this
Called on This
asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_with_this: "Found custom string at thing_one.try_draw_with_this", });
-
In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.
MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_with_this: { "Player Two": "Found custom string at thing_one.try_draw_with_this['Player Two']", }, });
do_draw_preposition_this
Called on This
asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_with_this: "Found custom string at thing_one.do_draw_with_this", });
-
In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.
MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_with_this: { "Player Two": "Found custom string at thing_one.do_draw_with_this['Player Two']", }, });
try_draw_this_preposition_that
Called on This
asset in a phrase such as "draw this with that", where This
is the direct object and That
is the indirect object.
try_draw_this_preposition_that
mirrors try_draw_that_preposition_this
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_this_with_that: "Found custom string at thing_one.try_draw_this_with_that", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response for
That
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_this_with_that: { "Thing Two": "Found custom string at thing_one.try_draw_this_with_that['Thing Two']", }, });
do_draw_this_preposition_that
Called on This
asset in a phrase such as "draw this with that", where This
is the direct object and That
is the indirect object.
do_draw_this_preposition_that
mirrors do_draw_that_preposition_this
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_this_with_that: "Found custom string at thing_one.do_draw_this_with_that", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response for
That
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_this_with_that: { "Thing Two": "Found custom string at thing_one.do_draw_this_with_that['Thing Two']", }, });
try_draw_that_preposition_this
Called on That
asset in a phrase such as "draw this with that", where That
is the indirect object and This
is the direct object.
try_draw_that_preposition_this
mirrors try_draw_this_preposition_that
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", try_draw_that_with_this: "Found custom string at thing_two.try_draw_that_with_this", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response for
This
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", try_draw_that_with_this: { "Thing One": "Found custom string at thing_two.try_draw_that_with_this['Thing One']", }, });
do_draw_that_preposition_this
Called on That
asset in a phrase such as "draw this with that", where That
is the indirect object and This
is the direct object.
do_draw_that_preposition_this
mirrors do_draw_this_preposition_that
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", do_draw_that_with_this: "Found custom string at thing_two.do_draw_that_with_this", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response for
This
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", do_draw_that_with_this: { "Thing One": "Found custom string at thing_two.do_draw_that_with_this['Thing One']", }, });
try_draw_preposition_this_preposition_that
Called on This
asset in a phrase such as "draw from this to that", where This
is the direct object and That
is the indirect object.
try_draw_preposition_this_preposition_that
mirrors try_draw_preposition_that_preposition_this
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
is moved to.MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_from_this_to_that: "Found custom string at thing_one.try_draw_from_this_to_that", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response when
This
is moved toThat
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_from_this_to_that: { "Thing Two": "Found custom string at thing_one.try_draw_from_this_to_that['Thing Two']", }, });
do_draw_preposition_this_preposition_that
Called on This
asset in a phrase such as "draw from this to that", where This
is the direct object and That
is the indirect object.
do_draw_preposition_this_preposition_that
mirrors dodraw_preposition_that_preposition_this
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
is moved to.MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_from_this_to_that: "Found custom string at thing_one.do_draw_from_this_to_that", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response when
This
is moved toThat
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_from_this_to_that: { "Thing Two": "Found custom string at thing_one.do_draw_from_this_to_that['Thing Two']", }, });
try_draw_preposition_that_preposition_this
Called on That
asset in a phrase such as "draw from this to that", where That
is the indirect object and This
is the direct object.
try_draw_preposition_that_preposition_this
mirrors try_draw_preposition_this_preposition_that
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", try_draw_from_that_to_this: "Found custom string at thing_two.try_draw_from_that_to_this", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response for
This
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", try_draw_from_that_to_this: { "Thing One": "Found custom string at thing_two.try_draw_from_that_to_this['Thing One']", }, });
do_draw_preposition_that_preposition_this
Called on That
asset in a phrase such as "draw from this to that", where That
is the indirect object and This
is the direct object.
do_draw_preposition_that_preposition_this
mirrors do_draw_preposition_this_preposition_that
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", do_draw_from_that_to_this: "Found custom string at thing_two.do_draw_from_that_to_this", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response for
This
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", do_draw_from_that_to_this: { "Thing One": "Found custom string at thing_two.do_draw_from_that_to_this['Thing One']", }, });
try_draw_this_preposition_that_preposition_other
Called on This
asset in a phrase such as "draw this from that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
try_draw_this_preposition_that_preposition_other
mirrors try_draw_preposition_that_this_preposition_other
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
is moved to.MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_this_to_that_with_other: "Found custom string at thing_one.try_draw_this_to_that_with_other", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response when
This
is moved toThat
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_this_to_that_with_other: { "Thing Two": "Found custom string at thing_one.try_draw_this_to_that_with_other['Thing Two']", }, });
-
This nested key / value approach can be extended to handle the
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing One", try_draw_this_to_that_with_other: { "Thing Two": { "Thing Three": "Found custom string at thing_one.try_draw_this_to_that_with_other['Thing Two']['Thing Three']" }, }, });
do_draw_this_preposition_that_preposition_other
Called on This
asset in a phrase such as "draw this from that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
do_draw_this_preposition_that_preposition_other
mirrors do_draw_preposition_that_this_preposition_other
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
is moved to.MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_this_to_that_with_other: "Found custom string at thing_one.do_draw_this_to_that_with_other", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response when
This
is moved toThat
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_this_to_that_with_other: { "Thing Two": "Found custom string at thing_one.do_draw_this_to_that_with_other['Thing Two']", }, });
-
This nested key / value approach can be extended to handle the
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing One", do_draw_this_to_that_with_other: { "Thing Two": { "Thing Three": "Found custom string at thing_one.do_draw_this_to_that_with_other['Thing Two']['Thing Three']" }, }, });
try_draw_that_preposition_this_preposition_other
Called on That
asset in a phrase such as "draw this to that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
try_draw_that_preposition_this_preposition_other
mirrors try_draw_this_preposition_that_preposition_other
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
is moved to.MyGame.createAsset({ class: "Thing", name: "Thing Two", try_drawto_that_this_with_other: "Found custom string at thing_two.try_drawto_that_this_with_other", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response when
This
is moved toThat
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", try_drawto_that_this_with_other: { "Thing One": "Found custom string at thing_two.try_drawto_that_this_with_other['Thing One']", }, });
-
This nested key / value approach can be extended to handle the
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", try_drawto_that_this_with_other: { "Thing One": { "Thing Three": "Found custom string at thing_two.try_drawto_that_this_with_other['Thing One']['Thing Three']" }, }, });
do_draw_that_preposition_this_preposition_other
Called on That
asset in a phrase such as "draw this to that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
do_draw_that_preposition_this_preposition_other
mirrors do_draw_this_preposition_that_preposition_other
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what
This
is moved to.MyGame.createAsset({ class: "Thing", name: "Thing Two", do_drawto_that_this_with_other: "Found custom string at thing_two.do_drawto_that_this_with_other", });
-
In this example, we use the name of an asset as a nested object key. This variation results in a singular response when
This
is moved toThat
particular asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", do_drawto_that_this_with_other: { "Thing One": "Found custom string at thing_two.do_drawto_that_this_with_other['Thing One']", }, });
-
This nested key / value approach can be extended to handle the
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", do_drawto_that_this_with_other: { "Thing One": { "Thing Three": "Found custom string at thing_two.do_drawto_that_this_with_other['Thing One']['Thing Three']" }, }, });
Method properties
Expand any item to see code examples. Methods are called with a parameter object in the form of action({asset1, asset2, params})
which authors may use or ignore.
tryDrawThis
Called on This
asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThis: function () { let msg = "Found custom method at thing_one.tryDrawThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThis: { "Player Two": function () { let msg = "Found custom method at thing_one.tryDrawThis['Player Two']()"; MyGame.print(msg); }, }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.
MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThis: function ({asset1}) { switch (asset1.name) { case "Player Two": let msg = "Found custom method at thing_one.tryDrawThis('Player Two')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
doDrawThis
Called on This
asset in a phrase such as "draw this".
Since no indirect object is given, we treat the player character as an indirect object.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThis: function () { let msg = "Found custom method at thing_one.doDrawThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThis: { "Player Two": function () { let msg = "Found custom method at thing_one.doDrawThis['Player Two']()"; MyGame.print(msg); }, }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.
MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThis: function ({asset1}) { switch (asset1.name) { case "Player Two": let msg = "Found custom method at thing_one.doDrawThis('Player Two')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
tryDrawPrepositionThis
Called on This
asset in a phrase such as "draw on this". Since no indirect object is given, we treat the player character as an indirect object. This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawWithThis: function () { let msg = "Found custom method at thing_one.tryDrawWithThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawPrepositionThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawWithThis: { "Player Two": function () { let msg = "Found custom method at thing_one.tryDrawWithThis['Player Two']()"; MyGame.print(msg); }, }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.
MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawWithThis: function ({asset1}) { switch (asset1.name) { case "Player Two": let msg = "Found custom method at thing_one.tryDrawWithThis('Player Two')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
doDrawPrepositionThis
Called on This
asset in a phrase such as "draw on this". Since no indirect object is given, we treat the player character as an indirect object. This example uses "with" as the preposition, but any preposition can set a unique response.
Note that sentence structures are commonly mutated during the doTry verb phase, so try
and do
may act on different sentence structures.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.
MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawWithThis: function () { let msg = "Found custom method at thing_one.doDrawWithThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawPrepositionThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawWithThis: { "Player Two": function () { let msg = "Found custom method at thing_one.doDrawWithThis['Player Two']()"; MyGame.print(msg); }, }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.
MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawWithThis: function ({asset1}) { switch (asset1.name) { case "Player Two": let msg = "Found custom method at thing_one.doDrawWithThis('Player Two')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
tryDrawThisPrepositionThat
Called on This
asset in a phrase such as "draw this with that", where This
is the direct object and That
is the indirect object.
tryDrawThisPrepositionThat
mirrors tryDrawThatPrepositionThis
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisWithThat: function () { let msg = "Found custom method at thing_one.tryDrawThisWithThat()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawThisPrepositionThat
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisWithThat: { "Thing Two": function (params) { let msg = "Found custom method at thing_one.tryDrawThisWithThat['Second Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisWithThat: function ({asset1}) { switch (asset1.name) { case "Thing Two": let msg = "Found custom method at thing_one.tryDrawThisWithThat('Second Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
doDrawThisPrepositionThat
Called on This
asset in a phrase such as "draw this with that", where This
is the direct object and That
is the indirect object.
doDrawThisPrepositionThat
mirrors doDrawThatPrepositionThis
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisWithThat: function () { let msg = "Found custom method at thing_one.doDrawThisWithThat()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawThisPrepositionThat
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisWithThat: { "Thing Two": function (params) { let msg = "Found custom method at thing_one.doDrawThisWithThat['Second Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisWithThat: function ({asset1}) { switch (asset1.name) { case "Thing Two": let msg = "Found custom method at thing_one.doDrawThisWithThat('Second Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
tryDrawThatPrepositionThis
Called on That
asset in a phrase such as "draw this with that", where That
is the indirect object and This
is the direct object.
tryDrawThatPrepositionThis
mirrors tryDrawThisPrepositionThat
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawThatWithThis: function () { let msg = "Found custom method at thing_two.tryDrawThatWithThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawThatPrepositionThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawThatWithThis: { "Thing One": function (params) { let msg = "Found custom method at thing_two.tryDrawThatWithThis['First Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawThatWithThis: function ({asset1}) { switch (asset1.name) { case "Thing One": let msg = "Found custom method at thing_two.tryDrawThatWithThis('First Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
doDrawThatPrepositionThis
Called on That
asset in a phrase such as "draw this with that", where That
is the indirect object and This
is the direct object.
doDrawThatPrepositionThis
mirrors doDrawThisPrepositionThat
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "with" as the preposition, but any preposition can set a unique response.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawThatWithThis: function () { let msg = "Found custom method at thing_two.doDrawThatWithThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawThatPrepositionThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawThatWithThis: { "Thing One": function (params) { let msg = "Found custom method at thing_two.doDrawThatWithThis['First Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawThatWithThis: function ({asset1}) { switch (asset1.name) { case "Thing One": let msg = "Found custom method at thing_two.doDrawThatWithThis('First Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
tryDrawPrepositionThisPrepositionThat
Called on This
asset in a phrase such as "draw from this to that", where This
is the direct object and That
is the indirect object.
tryDrawPrepositionThisPrepositionThat
mirrors tryDrawPrepositionThatPrepositionThis
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawFromThisToThat: function () { let msg = "Found custom method at thing_one.tryDrawFromThisToThat()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawPrepositionThisPrepositionThat
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawFromThisToThat: { "Thing Two": function (params) { let msg = "Found custom method at thing_one.tryDrawFromThisToThat['Second Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawFromThisToThat: function ({asset1}) { switch (asset1.name) { case "Thing Two": let msg = "Found custom method at thing_one.tryDrawFromThisToThat('Second Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
doDrawPrepositionThisPrepositionThat
Called on This
asset in a phrase such as "draw from this to that", where This
is the direct object and That
is the indirect object.
doDrawPrepositionThisPrepositionThat
mirrors doDrawPrepositionThatPrepositionThis
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawFromThisToThat: function () { let msg = "Found custom method at thing_one.doDrawFromThisToThat()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawPrepositionThisPrepositionThat
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawFromThisToThat: { "Thing Two": function (params) { let msg = "Found custom method at thing_one.doDrawFromThisToThat['Second Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawFromThisToThat: function ({asset1}) { switch (asset1.name) { case "Thing Two": let msg = "Found custom method at thing_one.doDrawFromThisToThat('Second Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
tryDrawPrepositionThatPrepositionThis
Called on That
asset in a phrase such as "draw from this to that", where This
is the direct object and That
is the indirect object.
tryDrawPrepositionThatPrepositionThis
mirrors tryDrawPrepositionThisPrepositionThat
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "from" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatFromThis: function () { let msg = "Found custom method at thing_two.tryDrawToThatFromThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawPrepositionThatPrepositionThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatFromThis: { "Thing One": function (params) { let msg = "Found custom method at thing_two.tryDrawToThatFromThis['First Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatFromThis: function ({asset1}) { switch (asset1.name) { case "Thing One": let msg = "Found custom method at thing_two.tryDrawToThatFromThis('First Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
doDrawPrepositionThatPrepositionThis
Called on That
asset in a phrase such as "draw from this to that", where This
is the direct object and That
is the indirect object.
doDrawPrepositionThatPrepositionThis
mirrors doDrawPrepositionThisPrepositionThat
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "from" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatFromThis: function () { let msg = "Found custom method at thing_two.doDrawToThatFromThis()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawPrepositionThatPrepositionThis
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatFromThis: { "Thing One": function (params) { let msg = "Found custom method at thing_two.doDrawToThatFromThis['First Thing']()"; MyGame.print(msg); } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatFromThis: function ({asset1}) { switch (asset1.name) { case "Thing One": let msg = "Found custom method at thing_two.doDrawToThatFromThis('First Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
tryDrawThisPrepositionThatPrepositionOther
Called on This
asset in a phrase such as "draw this to that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
tryDrawThisPrepositionThatPrepositionOther
mirrors tryDrawPrepositionThatThisPrepositionOther
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisToThatWithOther: function () { let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawThisPrepositionThatPrepositionOther
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.
This nested key / value approach can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisToThatWithOther: { "Thing Two": function (params) { let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther['Second Thing']()"; MyGame.print(msg); } }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisToThatWithOther: { "Thing Two": { "Thing Three": function (params) { let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther['Second Thing']['Third Thing']()"; MyGame.print(msg); } } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
This logic can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisToThatWithOther: function ({asset1}) { switch (asset1.name) { case "Thing Two": let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther('Second Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing One", tryDrawThisToThatWithOther: function ({asset1, asset2}) { switch (asset1.name) { case "Thing Two": if(asset2.name === "Thing Three"){ let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther('Second Thing', 'Third Thing')"; MyGame.print(msg); } else return; break; default: // do nothing and allow the default result break; } return; }, });
doDrawThisPrepositionThatPrepositionOther
Called on This
asset in a phrase such as "draw this to that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
doDrawThisPrepositionThatPrepositionOther
mirrors doDrawPrepositionThatThisPrepositionOther
. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
That
asset is.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisToThatWithOther: function () { let msg = "Found custom method at thing_one.doDrawThisToThatWithOther()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawThisPrepositionThatPrepositionOther
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.
This nested key / value approach can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisToThatWithOther: { "Thing Two": function (params) { let msg = "Found custom method at thing_one.doDrawThisToThatWithOther['Second Thing']()"; MyGame.print(msg); } }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisToThatWithOther: { "Thing Two": { "Thing Three": function (params) { let msg = "Found custom method at thing_one.doDrawThisToThatWithOther['Second Thing']['Third Thing']()"; MyGame.print(msg); } } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
This logic can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisToThatWithOther: function ({asset1}) { switch (asset1.name) { case "Thing Two": let msg = "Found custom method at thing_one.doDrawThisToThatWithOther('Second Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing One", doDrawThisToThatWithOther: function ({asset1, asset2}) { switch (asset1.name) { case "Thing Two": if(asset2.name === "Thing Three"){ let msg = "Found custom method at thing_one.doDrawThisToThatWithOther('Second Thing', 'Third Thing')"; MyGame.print(msg); } else return; break; default: // do nothing and allow the default result break; } return; }, });
tryDrawPrepositionThatThisPrepositionOther
Called on That
asset in a phrase such as "draw this to that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
tryDrawPrepositionThatThisPrepositionOther
mirrors tryDrawThisPrepositionThatPrepositionOther
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
This
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatThisWithOther: function () { let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
tryDrawPrepositionThatThisPrepositionOther
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.
This nested key / value approach can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatThisWithOther: { "Thing One": function (params) { let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther['First Thing']()"; MyGame.print(msg); } }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatThisWithOther: { "Thing One": { "Thing Three": function (params) { let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther['First Thing']['Third Thing']()"; MyGame.print(msg); } } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
This logic can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatThisWithOther: function ({asset1}) { switch (asset1.name) { case "Thing One": let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther('First Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", tryDrawToThatThisWithOther: function ({asset1, asset2}) { switch (asset1.name) { case "Thing One": if(asset2.name === "Thing Three"){ let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther('First Thing', 'Third Thing')"; MyGame.print(msg); } else return; break; default: // do nothing and allow the default result break; } return; }, });
doDrawPrepositionThatThisPrepositionOther
Called on That
asset in a phrase such as "draw this to that with other", where This
is the direct object, That
is the indirect object, and Other
is assumed to be a second indirect object (likely a tool).
doDrawPrepositionThatThisPrepositionOther
mirrors doDrawThisPrepositionThatPrepositionOther
. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.
This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.
-
In this example, we ignore the passed parameter. This variation results in the same response regardless of what
This
asset is.MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatThisWithOther: function () { let msg = "Found custom method at thing_two.doDrawToThatThisWithOther()"; MyGame.print(msg); }, });
-
To limit the method to act only on a certain asset, change the value of
doDrawPrepositionThatThisPrepositionOther
from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.
This nested key / value approach can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatThisWithOther: { "Thing One": function (params) { let msg = "Found custom method at thing_two.doDrawToThatThisWithOther['First Thing']()"; MyGame.print(msg); } }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatThisWithOther: { "Thing One": { "Thing Three": function (params) { let msg = "Found custom method at thing_two.doDrawToThatThisWithOther['First Thing']['Third Thing']()"; MyGame.print(msg); } } }, });
-
Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.
This logic can be extended to handle theMyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatThisWithOther: function ({asset1}) { switch (asset1.name) { case "Thing One": let msg = "Found custom method at thing_two.doDrawToThatThisWithOther('First Thing')"; MyGame.print(msg); break; default: // do nothing and allow the default result break; } return; }, });
Other
asset.MyGame.createAsset({ class: "Thing", name: "Thing Two", doDrawToThatThisWithOther: function ({asset1, asset2}) { switch (asset1.name) { case "Thing One": if(asset2.name === "Thing Three"){ let msg = "Found custom method at thing_two.doDrawToThatThisWithOther('First Thing', 'Third Thing')"; MyGame.print(msg); } else return; break; default: // do nothing and allow the default result break; } return; }, });
Notes
- Verb action hooks are specific to their particular verb.
- Which verb action hooks are called depends on the structure of the player's input. Hooks are checked for every asset in the input, including the player character. Which hooks are called depends on the sentence structure of the player's input:
-
Single-object input (e.g., "draw this"): The hook is called on
This
asset. Since no indirect object is specified, the player character is treated as an indirect object. -
Multiple-object input (e.g., "draw this with that"): The hook is called depending on the object’s role in the phrase.
do_draw_this_preposition_that
runs onThis
direct object, whiledo_draw_that_preposition_this
runs onThat
indirect object. These are equivalent, and you may place code on whichever asset makes sense to you. Any preposition can be used to define a unique response, for exampledraw with
vsdraw on
. -
Sentence structures are commonly mutated during the doTry verb phase, so
try
anddo
may act on different sentence structures. -
Verb actions are extremely granular and depend on specific combinations of assets and prepositions. Verb actions are called during a verb's doTry and doSuccess phases, which lets them override a verb's operations. Use them if you want to customize output for specific inputs, but beware of that granularity. Consider
doTake()
: it's called when a player takes an asset, so you might want to hook into that; but many other verbs may also move the asset into the player. If you want to catch any method that moves an asset into the player, you may find thedo_move_this_to_that
verb reaction more broadly applicable. - By default, string properties override a turn's output, but they can also be set to append or prepend the turn's default output. See verb action hooks for more information.
- Verb reaction hooks are functionally the same as action hooks. The only difference is that reaction hooks are not specific to any verb.
- Verb phase hooks are a different form of hook that allows authors to override entire verb phases.
draw reaction hooks
Every asset affected by the turn is checked for verb reaction hooks. These hooks allow authors to inject custom code or print custom text during verb operations. There are two distinct approaches to defining verb reactions, designed to accommodate different levels of scripting experience. Authors may use whichever approach they find most comfortable. See verb reaction hooks for details.
-
Simple approach: Define string properties (e.g.,
asset.do_move_this_to_that
). If AdventureJS finds a string, it prints it instead of the default output for that turn. This option is best for authors who want to customize output without writing code. -
Advanced approach: Define method properties (e.g.,
asset.doMoveThisToThat()
). If a method is found, it is called with a parameter object containing any relevant assets from the input (e.g.,asset.doMoveThisToThat({asset1})
). The author may use or ignore these parameters. This approach offers complete control over the turn’s outcome: authors can add conditional logic, force success or failure, or revise the default output.
String properties
Expand any item to see code examples. By default, string properties override a turn's output, but they can also be set to append or prepend output.
No verb reactions listed for draw
Method properties
Expand any item to see code examples. All methods are called with a parameter object in the form of asset.reaction({asset1, asset2, params})
which authors may use or ignore.
No verb reactions listed for draw
Notes
- See verb reaction hooks for more details.
- Reaction hooks aren't specific to any particular verb.
-
Verb reactions fire at the end of a turn after the verb's doSuccess phase. Many verbs may call the same reactions. For instance, any verb that moves an asset into the player calls
do_move_this_to_that
. This makes them more broadly applicable than verb actions and lets you customize the turn's output regardless of what verb is used. - Verb action hooks work the same way as reaction hooks, but are specific to their particular verb.
- Verb phase hooks are a different form of hook that allows authors to override entire verb phases.
draw params
Some verbs may have custom params. When an asset subscribes to such a verb, the verb's params are mirrored in the asset's verb subscription, where they are unique to that asset. To put it another way: while each verb may have a unique set of params, each asset may have its own customized version of those params.
with_params: {
// tool is a drawing implement
tool: false,
// target is a drawing surface
target: false,
},
For example, consider this setting of the verb plugIn:
MyGame.dictionary.verbs.plugIn.with_params.max_connections = 1
By default, assets that can be plugged in will take this setting and can only be plugged in to one other asset. Now imagine that an author wants to create a power cord that needs to be plugged in to both a computer and an outlet. The author can achieve that by customizing the cord's subscription to plugIn.
Expand for example
MyGame.createAsset({
class: "Cable",
name: "power cord",
dov: { plugIn: { with_assets: ['computer','outlet'], with_params: { max_connections: 2 }, }, },
})
MyGame.createAsset({
class: "Computer",
name: "PC",
iov: { plugIn: { with_assets: ['power cord'], }, },
})
MyGame.createAsset({
class: "ElectricalOutlet",
name: "outlet",
iov: { plugIn: { with_assets: ['power cord'], }, },
})
In this example, the power cord verb subscription's max_connections setting overrides the verb's max_connections setting, allowing the player to plug the power cord into two assets. The computer and the outlet don't have any custom value set for max_connections; they'll receive the default value, meaning they each can have only one asset plugged into them.
Notes
- It is possible for authors to modify a verb's params through the use of patchVerb.
- To learn more about modifying verbs, see Modify Verbs.
Private Constructor:
MyGame.createVerb({ "name": "draw", [...] });
draw is a predefined instance of Verb that gets constructed automatically at runtime. It is defined in the library as a generic object, and then passed to Dictionary#createVerb for construction, validation, and initialization. Because this is predefined, authors should not need to create new instances. For information on modifying predefined Verbs, see Modify Verbs.
- Index
- Methods
- Properties
Index
Methods:
- Inherited from Verb agree
- Inherited from Verb canBeIntransitive
- Inherited from Verb do
- Inherited from Verb doSuccess
- Inherited from Verb doTry
- Inherited from Verb enqueueCollection
- Inherited from Verb getState
- Inherited from Verb handleActions
- Inherited from Verb handleFailure
- Inherited from Verb handleSuccess
- Inherited from Verb hasState
- Inherited from Verb hasStructure
- Inherited from Verb hasVerbSubscriptionConnection
- Inherited from Verb initialize
- Inherited from Verb set
- Inherited from Verb setState
- Inherited from Verb setVerbConnection
- Inherited from Verb tryDestroyAfterUsing
- Inherited from Verb tryDestroyDirectObjectAfterUsing
- Inherited from Verb tryDestroyIndirectObjectAfterUsing
- Inherited from Verb tryPhaseHook
- Inherited from Verb tryToInferIndirectObject
- Inherited from Verb tryToPutThisInThatAspect
- Inherited from Verb unsetVerbConnection
- Inherited from Verb validate
Properties:
- accepts_adverbs
- accepts_direction
- accepts_number
- accepts_string
- accepts_structures
- adjectives
- allow_iov_on_iov
- article
- can_span
- default_direction
- dictionary
- direction_preposition
- doVerb
- doVerbFromThis
- doVerbThatFromThis
- doVerbThatWithThis
- doVerbThis
- doVerbThisFromThat
- doVerbThisWithThat
- doVerbWithThis
- enqueue_collections
- extends
- game
- gerund
- in_can_mean_on
- input_substitutions
- is_compass_direction
- is_direction
- is_relative_direction
- let_verb_handle_disambiguation
- let_verb_handle_remaining_input
- name
- Name
- override_verb_failure_msg
- override_verb_success_msg
- past_tense
- phrase1
- phrase2
- phrase3
- posture
- prettyname
- related
- requires_number
- requires_string
- state
- state_strings
- subject_must_be
- synonyms
- tryVerbFromThis
- tryVerbThatFromThis
- tryVerbThatWithThis
- tryVerbThis
- tryVerbThisFromThat
- tryVerbThisWithThat
- tryVerbWithThis
- type
- unstate
- verb_noun_prep
- verb_noun_prep_noun
- verb_noun_prep_noun_prep_noun
- verb_noun_prep_prep_noun
- verb_prep_noun
- verb_prep_noun_prep_noun
- verb_prep_noun_prep_noun_prep_noun
- verb_prep_prep_noun
- verb_prep_prep_prep_noun
Methods Collapse all |
agree
agree()
Defined in: adventure/dictionary/Verb.js, line 2998
Inherited from: adventurejs.Verb#agree
canBeIntransitive
canBeIntransitive()
Defined in: adventure/dictionary/Verb.js, line 2734
Inherited from: adventurejs.Verb#canBeIntransitive
do
do()
Defined in: adventure/dictionary/Verb.js, line 1077
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 doesn't have to use all of these methods. Some specialized Verbs including oops and undo override Verb.do entirely and don't use any submethods.
The other four submethods – Verb.doBeforeTry, Verb.doAfterTry, Verb.doBeforeSuccess, and Verb.doAfterSuccess – exist to provide optional hooks for authors to add custom interactions with individual Assets.
For more information about Verb Actions and Verb Phases, see Verb Actions and Verb Phases.
And so, the first thing Verb.do does is to verify that each method exists on the Verb instance. If the submethod exists, it is called. Each submethod sends a return to Verb.do.
If the Verb is acting on a collection, a false return means that the Asset currently being acted on has responded in a way that blocks further parsing, and brings this turn to a halt. A null return means that the Asset currently being acted on has concluded its own parsing, but not in such a way as to block further parsing, and Verb.do moves on to the next Asset.
doSuccess
doSuccess()
Defined in: adventure/dictionary/Verb.js, line 1804
Inherited from: adventurejs.Verb#doSuccess
doTry
doTry()
Defined in: adventure/dictionary/Verb.js, line 1416
Inherited from: adventurejs.Verb#doTry
enqueueCollection
enqueueCollection()
Defined in: adventure/dictionary/Verb.js, line 2397
Inherited from: adventurejs.Verb#enqueueCollection
getState
getState()
Defined in: adventure/dictionary/Verb.js, line 2752
Inherited from: adventurejs.Verb#getState
handleActions
handleActions()
Defined in: adventure/dictionary/Verb.js, line 1431
Inherited from: adventurejs.Verb#handleActions
handleFailure
handleFailure()
Defined in: adventure/dictionary/Verb.js, line 2441
Inherited from: adventurejs.Verb#handleFailure
handleSuccess
handleSuccess()
Defined in: adventure/dictionary/Verb.js, line 2540
Inherited from: adventurejs.Verb#handleSuccess
hasState
hasState()
Defined in: adventure/dictionary/Verb.js, line 2743
Inherited from: adventurejs.Verb#hasState
hasStructure
hasStructure() → {boolean}
Defined in: adventure/dictionary/Verb.js, line 2770
Inherited from: adventurejs.Verb#hasStructure
Returns:
boolean
hasVerbSubscriptionConnection
hasVerbSubscriptionConnection()
Defined in: adventure/dictionary/Verb.js, line 2901
Inherited from: adventurejs.Verb#hasVerbSubscriptionConnection
initialize
initialize()
Defined in: adventure/dictionary/Verb.js, line 2368
Inherited from: adventurejs.Verb#initialize
Todos: How does patchVerb handle initialization?
set
set(props) → {adventurejs.Verb}
Defined in: adventure/dictionary/Verb.js, line 2429
Inherited from: adventurejs.Verb#set
Parameters:
-
props
Object
A generic object containing properties to copy to the DisplayObject instance.
setState
setState()
Defined in: adventure/dictionary/Verb.js, line 2761
Inherited from: adventurejs.Verb#setState
setVerbConnection
setVerbConnection()
Defined in: adventure/dictionary/Verb.js, line 2780
Inherited from: adventurejs.Verb#setVerbConnection
computer.is.connected_by.plugIn.to_iov = ['socket']
socket.is.connected_by.plugIn.to_dov = ['computer']
tryDestroyAfterUsing
tryDestroyAfterUsing(object_of, asset) → {Object}
Defined in: adventure/asset/tryDestroyAfterUsing.js, line 6
Inherited from: adventurejs.Verb#tryDestroyAfterUsing
Parameters:
-
object_of
String -
asset
Object
Returns:
Object
tryDestroyDirectObjectAfterUsing
tryDestroyDirectObjectAfterUsing(asset) → {Boolean|string}
Defined in: adventure/asset/tryDestroyDirectObjectAfterUsing.js, line 6
Inherited from: adventurejs.Verb#tryDestroyDirectObjectAfterUsing
Parameters:
-
asset
Object
asset.dov[this.name].then_destroy
.
This is intended to provide a hook for authors
to easily destroy an object after a single use, such as a key
that only works once and then breaks or disappears.
Returns:
Boolean
|
string
tryDestroyIndirectObjectAfterUsing
tryDestroyIndirectObjectAfterUsing(asset) → {Boolean|string}
Defined in: adventure/asset/tryDestroyIndirectObjectAfterUsing.js, line 6
Inherited from: adventurejs.Verb#tryDestroyIndirectObjectAfterUsing
Parameters:
-
asset
Object
asset.iov[this.name].then_destroy
.
This is intended to provide a hook for authors
to easily destroy an object after a single use, such as a key
that only works once and then breaks or disappears.
Returns:
Boolean
|
string
tryPhaseHook
tryPhaseHook(phase) → {*}
Defined in: adventure/dictionary/Verb.js, line 1821
Inherited from: adventurejs.Verb#tryPhaseHook
Parameters:
-
phase
*
Returns:
*
tryToInferIndirectObject
tryToInferIndirectObject(options) → {Object}
Defined in: adventure/dictionary/Verb.js, line 1897
Inherited from: adventurejs.Verb#tryToInferIndirectObject
Parameters:
-
options
Object
An object of options.Properties
-
direct_object
Object -
handle_input
Boolean
If true, updates the global input object per standard specs used by most (but not all) of the verb instances that call this method. -
context
Object
The subject, usually player, could be an NPC. -
infer_first_use
Boolean
Optional param to set whether inference should work on first use.
-
Returns:
Object
tryToPutThisInThatAspect
tryToPutThisInThatAspect(direct_object, preposition, indirect_object) → {Object}
Defined in: adventure/dictionary/Verb.js, line 2114
Inherited from: adventurejs.Verb#tryToPutThisInThatAspect
Parameters:
-
direct_object
Object -
preposition
String -
indirect_object
Object
Returns:
Object
unsetVerbConnection
unsetVerbConnection()
Defined in: adventure/dictionary/Verb.js, line 2841
Inherited from: adventurejs.Verb#unsetVerbConnection
computer.is.connected_by.plugIn.to_iov = ['socket']
socket.is.connected_by.plugIn.to_dov = ['computer']
validate
validate()
Defined in: adventure/dictionary/Verb.js, line 2361
Inherited from: adventurejs.Verb#validate
Properties |
accepts_adverbs
accepts_adverbs :Array
Defined in: adventure/dictionary/Verb.js, line 432
Inherited from: adventurejs.Verb#accepts_adverbs
Default value: []
accepts_direction
accepts_direction :String
Defined in: adventure/dictionary/Phrase.js, line 26
Inherited from: adventurejs.Verb#accepts_direction
accepts_number
accepts_number :String
Defined in: adventure/dictionary/Phrase.js, line 40
Inherited from: adventurejs.Verb#accepts_number
accepts_string
accepts_string :String
Defined in: adventure/dictionary/Phrase.js, line 19
Inherited from: adventurejs.Verb#accepts_string
accepts_structures
accepts_structures :Array
Defined in: adventure/dictionary/Verb.js, line 426
Inherited from: adventurejs.Verb#accepts_structures
Default value: []
adjectives
adjectives :String
Defined in: adventure/dictionary/Verb.js, line 299
Overrides from: adventurejs.Verb#adjectives
allow_iov_on_iov
allow_iov_on_iov :Array
Defined in: adventure/dictionary/Verb.js, line 500
Inherited from: adventurejs.Verb#allow_iov_on_iov
Default value: false
allow_iov_on_iov
allows for some
additional checking when querying whether a verb is allowed
to operate on a particular pair of assets.
article
article :Boolean
Defined in: adventure/dictionary/Verb.js, line 388
Inherited from: adventurejs.Verb#article
Default value: false
can_span
can_span :String
Defined in: adventure/dictionary/Verb.js, line 236
Inherited from: adventurejs.Verb#can_span
default_direction
default_direction :String
Defined in: adventure/dictionary/Verb.js, line 163
Inherited from: adventurejs.Verb#default_direction
Default value: ""
dictionary
dictionary :Object
Defined in: adventure/dictionary/Verb.js, line 143
Inherited from: adventurejs.Verb#dictionary
Default value: {}
direction_preposition
direction_preposition :Boolean
Defined in: adventure/dictionary/Verb.js, line 400
Inherited from: adventurejs.Verb#direction_preposition
Default value: ""
doVerb
doVerb :Getter
Defined in: adventure/dictionary/Verb.js, line 596
Inherited from: adventurejs.Verb#doVerb
doVerbFromThis
doVerbFromThis :Getter
Defined in: adventure/dictionary/Verb.js, line 612
Inherited from: adventurejs.Verb#doVerbFromThis
doVerbThatFromThis
doVerbThatFromThis :Getter
Defined in: adventure/dictionary/Verb.js, line 652
Inherited from: adventurejs.Verb#doVerbThatFromThis
doVerbThatWithThis
doVerbThatWithThis :Getter
Defined in: adventure/dictionary/Verb.js, line 636
Inherited from: adventurejs.Verb#doVerbThatWithThis
doVerbThis
doVerbThis :Getter
Defined in: adventure/dictionary/Verb.js, line 604
Inherited from: adventurejs.Verb#doVerbThis
doVerbThisFromThat
doVerbThisFromThat :Getter
Defined in: adventure/dictionary/Verb.js, line 644
Inherited from: adventurejs.Verb#doVerbThisFromThat
doVerbThisWithThat
doVerbThisWithThat :Getter
Defined in: adventure/dictionary/Verb.js, line 628
Inherited from: adventurejs.Verb#doVerbThisWithThat
doVerbWithThis
doVerbWithThis :Getter
Defined in: adventure/dictionary/Verb.js, line 620
Inherited from: adventurejs.Verb#doVerbWithThis
enqueue_collections
enqueue_collections :Array
Defined in: adventure/dictionary/Verb.js, line 487
Inherited from: adventurejs.Verb#enqueue_collections
Default value: false
enqueue_collections
if true allows a verb to
unbundle the members of a collection in order to queue up
separate actions for each. For example, "gems" is a collection
that refers to three unique assets; "diamond", "emerald"
and "ruby". If take.enqueue_collections is true, "take gems"
will act individually on the diamond, the emerald and the ruby.
Only applies to direct object.
extends
extends :String
Defined in: adventure/dictionary/Verb.js, line 171
Inherited from: adventurejs.Verb#extends
Default value: ""
game
game :Object
Defined in: adventure/dictionary/Verb.js, line 136
Inherited from: adventurejs.Verb#game
Default value: {}
gerund
gerund :String
Defined in: adventure/dictionary/Verb.js, line 200
Inherited from: adventurejs.Verb#gerund
in_can_mean_on
in_can_mean_on :Boolean
Defined in: adventure/dictionary/Verb.js, line 355
Inherited from: adventurejs.Verb#in_can_mean_on
Default value: false
input_substitutions
input_substitutions :Object
Defined in: adventure/dictionary/Verb.js, line 438
Inherited from: adventurejs.Verb#input_substitutions
Default value: {}
is_compass_direction
is_compass_direction :Boolean
Defined in: adventure/dictionary/Verb.js, line 371
Inherited from: adventurejs.Verb#is_compass_direction
Default value: false
is_direction
is_direction :Boolean
Defined in: adventure/dictionary/Verb.js, line 364
Inherited from: adventurejs.Verb#is_direction
Default value: false
is_relative_direction
is_relative_direction :Boolean
Defined in: adventure/dictionary/Verb.js, line 379
Inherited from: adventurejs.Verb#is_relative_direction
Default value: false
let_verb_handle_disambiguation
let_verb_handle_disambiguation :Boolean
Defined in: adventure/dictionary/Verb.js, line 335
Inherited from: adventurejs.Verb#let_verb_handle_disambiguation
Default value: false
let_verb_handle_remaining_input
let_verb_handle_remaining_input :Boolean
Defined in: adventure/dictionary/Verb.js, line 344
Inherited from: adventurejs.Verb#let_verb_handle_remaining_input
Default value: false
name
name :String
Defined in: adventure/dictionary/Verb.js, line 179
Inherited from: adventurejs.Verb#name
Default value: ""
Name
Name :Getter
Defined in: adventure/dictionary/Verb.js, line 520
Inherited from: adventurejs.Verb#Name
Default value: []
override_verb_failure_msg
override_verb_failure_msg :String
Defined in: adventure/dictionary/Verb.js, line 450
Inherited from: adventurejs.Verb#override_verb_failure_msg
Default value: undefined
override_verb_success_msg
override_verb_success_msg :String
Defined in: adventure/dictionary/Verb.js, line 459
Inherited from: adventurejs.Verb#override_verb_success_msg
Default value: undefined
past_tense
past_tense :String
Defined in: adventure/dictionary/Verb.js, line 194
Inherited from: adventurejs.Verb#past_tense
phrase1
phrase1 :Object
Defined in: adventure/dictionary/Verb.js, line 408
Inherited from: adventurejs.Verb#phrase1
Default value: {}
phrase2
phrase2 :Object
Defined in: adventure/dictionary/Verb.js, line 414
Inherited from: adventurejs.Verb#phrase2
Default value: {}
phrase3
phrase3 :Object
Defined in: adventure/dictionary/Verb.js, line 420
Inherited from: adventurejs.Verb#phrase3
Default value: {}
posture
posture :String
Defined in: adventure/dictionary/Verb.js, line 206
Overrides from: adventurejs.Verb#posture
prettyname
prettyname :String
Defined in: adventure/dictionary/Verb.js, line 186
Inherited from: adventurejs.Verb#prettyname
related
requires_number
requires_number :String
Defined in: adventure/dictionary/Phrase.js, line 47
Inherited from: adventurejs.Verb#requires_number
requires_string
requires_string :String
Defined in: adventure/dictionary/Phrase.js, line 33
Inherited from: adventurejs.Verb#requires_string
state
state :String
Defined in: adventure/dictionary/Verb.js, line 247
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
state_strings :String
Defined in: adventure/dictionary/Verb.js, line 267
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.
subject_must_be
subject_must_be :Object
Defined in: adventure/dictionary/Verb.js, line 315
Inherited from: adventurejs.Verb#subject_must_be
Default value: {}
synonyms
synonyms :Getter/Setter
Defined in: adventure/dictionary/Verb.js, line 660
Inherited from: adventurejs.Verb#synonyms
Default value: []
tryVerbFromThis
tryVerbFromThis :Getter
Defined in: adventure/dictionary/Verb.js, line 556
Inherited from: adventurejs.Verb#tryVerbFromThis
tryVerbThatFromThis
tryVerbThatFromThis :Getter
Defined in: adventure/dictionary/Verb.js, line 588
Inherited from: adventurejs.Verb#tryVerbThatFromThis
tryVerbThatWithThis
tryVerbThatWithThis :Getter
Defined in: adventure/dictionary/Verb.js, line 572
Inherited from: adventurejs.Verb#tryVerbThatWithThis
tryVerbThis
tryVerbThis :Getter
Defined in: adventure/dictionary/Verb.js, line 540
Inherited from: adventurejs.Verb#tryVerbThis
tryVerbThisFromThat
tryVerbThisFromThat :Getter
Defined in: adventure/dictionary/Verb.js, line 580
Inherited from: adventurejs.Verb#tryVerbThisFromThat
tryVerbThisWithThat
tryVerbThisWithThat :Getter
Defined in: adventure/dictionary/Verb.js, line 564
Inherited from: adventurejs.Verb#tryVerbThisWithThat
tryVerbWithThis
tryVerbWithThis :Getter
Defined in: adventure/dictionary/Verb.js, line 548
Inherited from: adventurejs.Verb#tryVerbWithThis
type
type :String
Defined in: adventure/dictionary/Verb.js, line 151
Inherited from: adventurejs.Verb#type
Default value: ""
unstate
unstate :String
Defined in: adventure/dictionary/Verb.js, line 257
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
verb_noun_prep :Array
Defined in: adventure/dictionary/Verb.js, line 726
Inherited from: adventurejs.Verb#verb_noun_prep
Default value: []
verb_noun_prep_noun
verb_noun_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 890
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.
verb_noun_prep_noun_prep_noun
verb_noun_prep_noun_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 979
Inherited from: adventurejs.Verb#verb_noun_prep_noun_prep_noun
Default value: []
verb_noun_prep_prep_noun
verb_noun_prep_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 937
Inherited from: adventurejs.Verb#verb_noun_prep_prep_noun
Default value: []
verb_prep_noun
verb_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 767
Inherited from: adventurejs.Verb#verb_prep_noun
Default value: []
verb_prep_noun_prep_noun
verb_prep_noun_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 684
Inherited from: adventurejs.Verb#verb_prep_noun_prep_noun
Default value: []
verb_prep_noun_prep_noun_prep_noun
verb_prep_noun_prep_noun_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 1025
Inherited from: adventurejs.Verb#verb_prep_noun_prep_noun_prep_noun
Default value: []
verb_prep_prep_noun
verb_prep_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 808
Inherited from: adventurejs.Verb#verb_prep_prep_noun
Default value: []
verb_prep_prep_prep_noun
verb_prep_prep_prep_noun :Array
Defined in: adventure/dictionary/Verb.js, line 849
Inherited from: adventurejs.Verb#verb_prep_prep_prep_noun
Default value: []