Verb: pick demo structures phrases params phases actions methods properties

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

var OpenGame = new adventurejs.Game("OpenGame", "OpenGameDisplay").set({
  // title, version, and author are shown in the title bar
  title: "Open Game",
  version: "0.0.1",
  author: "Ivan Cockrum",

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

OpenGame.settings.set({
  // if this is true, lists of exits will
  // show the names of rooms they lead to
  show_room_names_in_exit_descriptions: true,

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

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

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

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

  // 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
});

// Foyer

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

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

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

// Player

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

// Scoring

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

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

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

  // To attach a score event to your custom function, use
  // OpenGame.scorecard.completeEvent('open window');
  // You'll see these sprinkled throughout this demo code.

  // Adventurejs has built-in scoring functions,
  // but you may, if you like, write custom score handling.

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

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

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

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


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

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

// Sitting Room Out

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

// Sitting Room Out - Playground Window

OpenGame.createAsset({
  class: "Window",
  name: "inside window",
  synonyms: ["playground window", "playground"],
  place: { in: "Sitting Room" },
  direction: "out",
  descriptions: {
    // Note that this code block uses a combination of Javascript
    // native template literals and Adventurejs custom templates:
    // ${OpenGame} and $(inside window). The one with {squiggly}
    // brackets is Javascript. The one with (parentheses) is Adventurejs.

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

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

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

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

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

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

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

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

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

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

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

// Sitting Room North

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

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

// Sitting Room North Door - library Door

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

    // Note here how we're setting it so the library door can be
    // unlocked with the brass key.
    unlock: {
      with_assets: ["brass key"],
      with_nothing: false,
    },

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

// coffee table

OpenGame.createAsset({
  class: "Table",
  name: "coffee table",
  place: { in: "Sitting Room" },
  description:
    "It's a low, rectangular coffee table, apparently hand carved from oak. ",
  adjectives: "wood, wooden, carved, oak",
  aspects: {
    on: {
      player: { can: { enter: false } },
    },
  },
  dov: {
    go: {
      doBeforeTry: function (params) {
        // See how we're using a Verb Hook here. This is a way
        // to inject custom code into a verb when it is applied
        // to a particular asset. In this case by hooking into
        // go.doBeforeTry, we interrupt the verb before it can
        // run its default doTry conditional logic,
        // and print our own failure message. This basically means:
        // we don't care what the default logic has to say; you
        // just don't put your fat feet on the fine furniture.
        // See /doc/Scripting_VerbPhases.html for more info.
        OpenGame.print(
          "I mean, $(we) could, but it would just be rude. ",
          "concatenate_output"
        );
        return false;
      },
    },
    sit: {
      // Here, we're setting sit, stand and lie to use
      // the same code as go.doBeforeTry. This is one way
      // you could apply the same custom logic to multiple
      // verbs on an object. There are also other ways to
      // achieve similar results, such as unsubscribing
      // the asset from these verbs, or using verb actions.
      doBeforeTry: function () {
        return this.dov.go.doBeforeTry();
      },
    },
    stand: {
      doBeforeTry: function () {
        return this.dov.go.doBeforeTry();
      },
    },
    lie: {
      doBeforeTry: function () {
        return this.dov.go.doBeforeTry();
      },
    },
  },

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

  // Alternately, if you wanted the same verb effect hook to apply to
  // all assets, you could define it as a function itself rather
  // than creating nested objects. This is also valid.
  // In this case, since the doNestThatToThis function is on the
  // coffee table, it would prevent all characters from nesting.

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


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

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

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

// Sitting Room south Exit

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

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

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

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

// bureau desk

OpenGame.createAsset({
  class: "Desk",
  name: "bureau desk",
  adjectives: ["oak", "wood", "wooden", "substantial"],
  synonyms: [],
  place: { in: "Library" },
  descriptions: {
    // Note that this description is an ordinary string property. Elsewhere in this demo
    // we're using traditional functions or arrow functions because they include
    // Javascript template literals. This example only includes Adventurejs custom
    // templates, which do not get evaluated until output, and are safe to use in strings.
    // See /doc/Scripting_CustomTemplates.html for more info.
    look: `
      It's a substantial oak bureau desk with multiple drawers stacked vertically, 
      top, middle and bottom. The top drawer is $( top drawer is| open or| closed ), 
      the middle drawer is $( middle drawer is| open or| closed ), and the bottom 
      drawer is $( bottom drawer is| open or| closed ). `,
  },
  aspects: {
    on: {
      player: { can: { enter: false } },
    },
  },
});

// top drawer

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

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

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

    closed: true,
    locked: true,
    listed_in_parent: false,
  },
  dov: {
    // Adventurejs treats 'pick' and 'unlock' as distinct verbs.
    // If a player tries to use 'unlock' where 'pick' is defined,
    // the parser will try to redirect to 'pick'.

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

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

// middle drawer

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

// bottom drawer

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

// drawers collection

// Collections are a special class that allows players to refer
// to a group of objects and try to apply a verb to all of them,
// or get back a combined description.
// See doc/adventurejs.Collection.html for more info.
OpenGame.createAsset({
  class: "Collection",
  name: "desk drawers",
  place: { attached: "bureau desk" },
  collection: ["top drawer", "middle drawer", "bottom drawer"],
  synonyms: ["drawers", "three drawers"],
  is: {
    known: true,
    listed_in_parent: false,
  },
  descriptions: {
    look: function () {
      var openCount = [];
      var closedCount = [];
      var msg = "";

      msg += `The bureau has three drawers stacked vertically: 
      top, middle and bottom, each with a copper lock plate. 
      The top drawer's lock appears to be rather scratched up. 
      Currently, `;

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

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

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

      return msg;
    },
  },
});


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

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

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

// Playground in

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

// outside window

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

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

    through:
      "The wan light of the sitting room seems quite bright from out here. ",
    in: function () {
      return this.descriptions.in;
    },
  },
  is: {
    closed: true,
    locked: true,
  },
  dov: {
    lock: { with_nothing: true },
    unlock: { with_nothing: true },
  },

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


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

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

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

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

OpenGame.createAsset({
  class: "Key",
  name: "brass key",
  synonyms: ["glass bead"],
  article: "a",
  adjectives: ["burnished", "chonky"],
  place: { on: "coffee table" },
  description: `It's a burnished brass key with chonky teeth 
  and a small glass bead mounted in the head. `,
  iov: {
    unlock: {
      // Adventurejs offers many ways to override its default
      // actions and output. If
      // asset.dov.unlock.on_failure
      // is a string, it will be appended to the default unlock
      // failure message. In this case, we want to completely
      // override the output, so we call this.game.overrideOutput()
      // this.game is the same as OpenGame when called from a scoped function.
      // on_failure: function(){ this.game.overrideOutput(
      //   `Whoops! This brass key doesn't unlock that ${OpenGame.getInput().getAsset(1).name}. `
      // )},
      on_first_failure: function () {
        this.game.overrideOutput(
          `Whoops! Looks like $(we) can't unlock ${
            OpenGame.getInput().getAsset(1).articlename
          } with the brass key. `
        );
      },

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

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

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

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

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

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

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

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