Verb:write

// 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), 
    PenCap,
    Typewriter, and 
    Eraser. Try 
    writing, 
    typing, 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/Advanced_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"] },
      });

      // 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.
      this.setIOV({
        write: {
          on_success: function () {
            WritingDemo.scorecard.completeEvent("write on paper");
          },
        },
        type: {
          // This is a 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" },
});


// 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

// createClass()
// Later in this file, we'll create several whiteboard markers.
// We already have a class, Marker, but we want a specific
// WhiteboardMarker class that will be the only class of
// Assets that are allowed to write on a Whiteboard.
//
// This is the bare minimum needed for a class definition.
// The only thing that sets it apart from Marker is the class
// name, but that's how instances of the class will be
// identified by verb methods trying to determine whether
// the classes can be used together.
//
// 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/Advanced_CustomClasses.html
// for more info.
WritingDemo.createClass(
  class WhiteboardMarker extends adventurejs.Marker {
    constructor(name, game_name) {
      super(name, game_name);
      this.class = "WhiteboardMarker";
    }
  }
);

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: {
    // Remember where we set up our custom WhiteboardMarker class?
    // setting whiteboard.dov.write.with_classes = ["WhiteboardMarker"]
    // establishes that only WhiteboardMarkers can write on Whiteboard.
    write: {
      with_classes: ["WhiteboardMarker"],
      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.appendTurn(`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: "Eraser",
  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.appendTurn(
      `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"],

  // 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 }. `,

  adjectives: "desk",
  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
  // appendTurn or overrideTurn.
  doUnnestThatFromThis: {
    Will: function () {
      WritingDemo.prependTurn(
        `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" },
}); //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.overrideTurn(
        `{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.overrideTurn(
        `{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: {
    // setting iov.write.with_classes = ["Chalk"]
    // establishes that assets of class Chalk are the
    // only assets allowed to write on Blackboard.
    // (This is the default setting for class Blackboard.
    // We're redefining it here just to make the point.)
    //
    // 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.appendTurn(
      `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: "Eraser",
  name: "felt eraser",
  place: { on: "blackboard ledge" },
  descriptions: { look: "It's a felt eraser. " },

  // Verb subscriptions
  // By setting iov.erase.with_classes to ["Blackboard"]
  // we're customizing this asset's erase verb subscription
  // to establish that the blackboard is the only
  // thing this eraser can erase.
  iov: { erase: { with_classes: ["Blackboard"] } },

  // 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.appendTurn(`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
  // appendTurn or prependTurn.
  doNestThatToThis: {
    Will: function () {
      WritingDemo.overrideTurn(`{We} fold {ourself} into the small bench. `);
    },
  },

  doUnnestThatFromThis: {
    Will: function () {
      WritingDemo.overrideTurn(`{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.
  tryClimb: () => {
    WritingDemo.print(`In Soviet Russia, shelves climb you! `);
    // return false ends the turn without further processing
    return false;
  },
}); // 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.appendTurn(`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.appendTurn(`{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! ** ]",
    },
  },
});