Verb:type

// WritingDemo.js
// ----------
/*global AdventureJS WritingDemo*/

var WritingDemo = new AdventureJS.Game("WritingDemo", "WritingDemoContainer");

// Let's set some Game settings
WritingDemo.settings.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!",

  // 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: {
    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: {
    general: true,
    // verbaction: true,
    // verbreaction: true,
    // verbphase: true,
  },

  // if this is false, the game won't infer objects
  // until player has already used them
  // good for preventing spoilers but can be annoying
  allow_inference_on_first_use: true,

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

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

  // if this is true, lists of exits will only
  // show room names for exits player has used
  print_exits_room_names_if_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,

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

    // set this to provide a default
    // response to blank input
    empty_input: "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 
    <a href="/doc/AdventureJS.Assets.WritingImplement.html">WritingImplement</a> 
    (<a href="/doc/AdventureJS.Assets.Pen.html">Pen</a>, 
    <a href="/doc/AdventureJS.Assets.Pencil.html">Pencil</a>, 
    <a href="/doc/AdventureJS.Assets.Chalk.html">Chalk</a>, 
    <a href="/doc/AdventureJS.Assets.Marker.html">Marker</a>), 
    <a href="/doc/AdventureJS.Assets.WritingSurface.html">WritingSurface</a> 
    (<a href="/doc/AdventureJS.Assets.Paper.html">Paper</a>, 
    <a href="/doc/AdventureJS.Assets.Blackboard.html">Blackboard</a>, 
    <a href="/doc/AdventureJS.Assets.Whiteboard.html">Whiteboard</a>), 
    <a href="/doc/AdventureJS.Assets.Typewriter.html">Typewriter</a>, and 
    <a href="/doc/AdventureJS.Assets.Eraser.html">Eraser</a>. Try 
    <a href="/doc/write.html">writing</a> on, 
    <a href="/doc/write.html">drawing</a> on, 
    <a href="/doc/type.html">typing</a> on, and 
    <a href="/doc/erase.html">erasing</a> things. 
    Visit the other rooms in this demo to find some 
    demonstrations. `,
    brief: `Try verbs. 
    <a href="/doc/read.html">Read</a>, 
    <a href="/doc/write.html">write</a>, 
    <a href="/doc/type.html">type</a>, 
    <a href="/doc/erase.html">erase</a>. `,
  },

  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",
  extend: "Paper",

  // Limit what assets can erase this class.
  dov: {
    erase: { with_assets: ["rubber eraser"] },
  },

  // Limit what classes can write on this class.
  iov: {
    write: {
      with_classes: ["Crayon", "Pen", "Pencil"],
      on_success: function () {
        WritingDemo.scorecard.awardPoint("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: function () {
        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 articles are handled automatically,
  // but they can be set manually
  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 <a href="/examples/WritingDemo/Office.js">Office.js</a> 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.awardPoint("erase whiteboard");
      },
    },
  },
  iov: {
    write: {
      on_success: function () {
        WritingDemo.scorecard.awardPoint("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: "Entity",
  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",
  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: function () {
    return `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.
  // Placeholders 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" },
  targets: "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: function () {
    return `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",
  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.awardPoint("erase paper");
      },
    },
  },
}); // BrassPencil

WritingDemo.createAsset({
  class: "Pen",
  name: "indigo pen",
  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: function () {
        WritingDemo.scorecard.awardPoint("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 articles are handled automatically,
  // but they can be set manually
  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 <a href="/examples/WritingDemo/Playroom.js">Playroom.js</a> 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: "Entity",
  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: function () {
      WritingDemo.scorecard.awardPoint("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: function () {
      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 articles are handled automatically,
  // but they can be set manually
  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:
  // <span class="string purple crayon">foo</span>
  //
  // 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 
    <a href="/examples/WritingDemo/Classroom.js">Classroom.js</a> 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.awardPoint("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.awardPoint("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: "Entity",
  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:
  // <span class="pink">whatever player wrote</span>
  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 articles are handled automatically,
  // but they can be set manually
  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: function () {
    return `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 <a href="/examples/WritingDemo/Library.js">Library.js</a> 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: function () {
    WritingDemo.overrideOutput(`In Soviet Russia, shelves climb you! `);
    WritingDemo.scorecard.awardPoint("try to climb shelves");
  },
  // dov: { climb: true },
}); // 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: function () {
    WritingDemo.print(`In Soviet Russia, books read you! `);
    // return false ends the turn without further processing
    return false;
  },
  tryTake: function () {
    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 articles are handled automatically,
  // but they can be set manually
  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.awardPoint("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: "Entity",
  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. 
  <span class="placard">To use the typewriter, <br/>
  insert a sheet of paper, use the verb type, <br/>
  and put quotes around the string to be typed. <br/><br/>
  type "hello world"
  </span> `,

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

  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/GoalsScoresHints_Scorecards.html
  // for more info.

  overview: "",
  noscore: "",

  points: {
    "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": {
      value: 1,
      bonus: true,
      // Customize the score message by setting message
      // to a string or array or function.
      award_text: "[ ** {We} got a bonus point! ** ]",
      complete_text: "{We} tried to climb the library shelves. ",

      awarded: false,
    },

    "write with green pen": {
      value: 1,
      bonus: true,
      // Customize the score message by setting message
      // to a string or array or function.
      award_text: "[ ** {We} got a bonus point for getting the cap off! ** ]",

      awarded: false,
    },
  },
});