From f497b78e27c0ad66269db1a4acd7a3ae649b8e79 Mon Sep 17 00:00:00 2001
From: Alexander Yakovlev <keloero@oreolek.ru>
Date: Wed, 20 Jan 2016 23:48:30 +0700
Subject: [PATCH] Salet conversion WIP

---
 Gulpfile.coffee      |  131 ++++
 Gulpfile.js          |  184 -----
 LICENSE.txt          |    4 +-
 game/begin.coffee    |   98 +--
 game/end.coffee      |   18 +-
 game/story.coffee    |  119 ++--
 html/index.html      |   41 +-
 lib/cycle.coffee     |   19 +
 lib/dialogue.coffee  |   34 +
 lib/interface.coffee |   16 +
 lib/localize.coffee  |   60 ++
 lib/markdown.coffee  |   36 +
 lib/obj.coffee       |   50 ++
 lib/oneOf.coffee     |  170 +++++
 lib/random.js        |  207 ++++++
 lib/room.coffee      |  277 ++++++++
 lib/undum.js         | 1617 ++++++++++++++++++++++++++++++++++++++++++
 package.json         |   13 +-
 sass/main.scss       |   27 +-
 19 files changed, 2729 insertions(+), 392 deletions(-)
 create mode 100644 Gulpfile.coffee
 delete mode 100644 Gulpfile.js
 create mode 100644 lib/cycle.coffee
 create mode 100644 lib/dialogue.coffee
 create mode 100644 lib/interface.coffee
 create mode 100644 lib/localize.coffee
 create mode 100644 lib/markdown.coffee
 create mode 100644 lib/obj.coffee
 create mode 100644 lib/oneOf.coffee
 create mode 100644 lib/random.js
 create mode 100644 lib/room.coffee
 create mode 100644 lib/undum.js

diff --git a/Gulpfile.coffee b/Gulpfile.coffee
new file mode 100644
index 0000000..19807d9
--- /dev/null
+++ b/Gulpfile.coffee
@@ -0,0 +1,131 @@
+watchify    = require('watchify')
+browserify  = require('browserify')
+browserSync = require('browser-sync')
+gulp        = require('gulp')
+source      = require('vinyl-source-stream')
+gutil       = require('gulp-util')
+coffeify    = require('coffeeify')
+coffee      = require("gulp-coffee")
+sass        = require('gulp-sass')
+uglify      = require('gulp-uglify')
+buffer      = require('vinyl-buffer')
+zip         = require('gulp-zip')
+_           = require('lodash')
+concat      = require('gulp-concat')
+
+reload = browserSync.reload
+
+html = (target) ->
+  return () ->
+    return gulp.src(['html/index.html','html/en.html'])
+          .pipe(gulp.dest(target));
+
+img = (target) ->
+  return () ->
+    return gulp.src(['img/*.png', 'img/*.jpeg', 'img/*.jpg'])
+          .pipe(gulp.dest(target));
+
+audio = (target) ->
+  return () ->
+    return gulp.src(['audio/*.mp3'])
+          .pipe(gulp.dest(target));
+
+gulp.task('html', html('./build'))
+gulp.task('img', img('./build/img'))
+gulp.task('audio', audio('./build/audio'))
+
+gulp.task('sass', () ->
+  gulp.src('sass/main.scss')
+    .pipe(sass({outputStyle: 'compressed'}).on('error', sass.logError))
+    .pipe(gulp.dest('./build/css'));
+)
+
+sources = [
+  './game/begin.coffee',
+  './game/story.coffee',
+  './game/end.coffee',
+]
+
+opts = _.assign({}, watchify.args, {
+  entries: ["./build/game/main.coffee"]
+  debug: true
+  transform: [coffeify]
+});
+bundler = watchify(browserify(opts))
+
+bundle = () ->
+  return bundler.bundle()
+    .on('error', gutil.log.bind(gutil, 'Browserify Error'))
+    .pipe(source('bundle.js'))
+    .pipe(gulp.dest('./build/game'))
+
+gulp.task('concatCoffee', () ->
+  return gulp.src(sources)
+    .pipe(concat('./main.coffee'))
+    .pipe(gulp.dest('./build/game'))
+)
+
+gulp.task('coffee', ['concatCoffee'], bundle)
+
+bundler.on('update', bundle);
+bundler.on('log', gutil.log);
+
+gulp.task('build', ['html', 'img', 'sass', 'coffee', 'audio'])
+
+gulp.task('serve', ['build'], () ->
+  browserSync({
+    server: {
+      baseDir: 'build'
+    }
+  })
+
+  sassListener = () ->
+    reload('./build/css/main.css')
+
+  gulp.watch(['./html/*.html'], ['html'])
+  gulp.watch(['./sass/*.scss'], ['sass'])
+  gulp.watch(['./img/*.png', './img/*.jpeg', './img/*.jpg'], ['img'])
+  gulp.watch(['./lib/*.coffee', './lib/*.js', './game/*.coffee'], ['coffee'])
+
+  gulp.watch(['./build/css/main.css'], sassListener)
+  gulp.watch(
+    ['./build/game/bundle.js', './build/img/*', './build/index.html'],
+    browserSync.reload)
+)
+
+gulp.task('html-dist', html('./dist'));
+gulp.task('img-dist', img('./dist/img'));
+gulp.task('audio-dist', audio('./dist/audio'));
+gulp.task('legal-dist', () ->
+  return gulp.src(['LICENSE.txt'])
+         .pipe(gulp.dest("./dist"));
+);
+
+gulp.task('sass-dist', () ->
+  return gulp.src('./sass/main.scss')
+        .pipe(sass({outputStyle: 'compressed'}))
+        .pipe(gulp.dest('./dist/css'));
+);
+
+distBundler = browserify({
+  debug: false,
+  entries: ['./build/game/main.coffee'],
+  transform: ['coffeeify']
+});
+
+gulp.task('coffee-dist', ['concatCoffee'], () ->
+  return distBundler.bundle()
+        .pipe(source('bundle.js'))
+        .pipe(buffer())
+        .pipe(uglify())
+        .on('error', gutil.log)
+        .pipe(gulp.dest('./dist/game'));
+);
+
+gulp.task('dist', ['html-dist', 'img-dist', 'sass-dist', 'coffee-dist', 'audio-dist', 'legal-dist']);
+
+gulp.task('zip', ['dist'], () ->
+  return gulp.src('dist/**')
+    .pipe(zip('dist.zip'))
+    .pipe(gulp.dest('.'));
+);
diff --git a/Gulpfile.js b/Gulpfile.js
deleted file mode 100644
index 0415f22..0000000
--- a/Gulpfile.js
+++ /dev/null
@@ -1,184 +0,0 @@
-'use strict';
-
-/* Imports */
-var watchify    = require('watchify'),
-    browserify  = require('browserify'),
-    browserSync = require('browser-sync'),
-    gulp        = require('gulp'),
-    source      = require('vinyl-source-stream'),
-    gutil       = require('gulp-util'),
-    coffeify    = require('coffeeify'),
-    sass        = require('gulp-sass'),
-    minifyCSS   = require('gulp-minify-css'),
-    uglify      = require('gulp-uglify'),
-    buffer      = require('vinyl-buffer'),
-    zip         = require('gulp-zip'),
-    _           = require('lodash'),
-    concat      = require('gulp-concat');
-
-var reload = browserSync.reload;
-
-/* Tasks */
-
-/* Trivial file copies */
-
-function html (target) {
-  return function () {
-    return gulp.src(['html/index.html','html/en.html'])
-          .pipe(gulp.dest(target));
-    };
-}
-
-function img (target) {
-  return function () {
-    return gulp.src(['img/*.png', 'img/*.jpeg', 'img/*.jpg'])
-          .pipe(gulp.dest(target));
-    };
-}
-
-function audio (target) {
-  return function () {
-    return gulp.src(['audio/*.mp3'])
-          .pipe(gulp.dest(target));
-    };
-}
-
-gulp.task('html', html('./build'));
-gulp.task('img', img('./build/img'));
-gulp.task('audio', audio('./build/audio'));
-
-/* Less */
-
-gulp.task('sass', function () {
-  gulp.src('sass/main.scss')
-    .pipe(sass().on('error', sass.logError))
-    .pipe(gulp.dest('./build/css'));
-});
-
-/* Bundle libraries */
-
-var undumBundler = browserify({debug: true});
-undumBundler.require('undum-commonjs');
-
-gulp.task('buildUndum', function () {
-  return undumBundler.bundle().pipe(source('undum.js')).pipe(gulp.dest('./build/game'));
-});
-
-/* Generate JavaScript with browser sync. */
-
-var sources = [
-  './game/begin.coffee',
-  './game/story.coffee',
-  './game/end.coffee',
-]
-
-var opts = _.assign({}, watchify.args, {
-  entries: ["./build/game/main.coffee"],
-  debug: true,
-  transform: [coffeify]
-});
-var bundler = watchify(browserify(opts));
-bundler.external('undum-commonjs');
-
-function bundle () {
-  return bundler.bundle()
-    .on('error', gutil.log.bind(gutil, 'Browserify Error'))
-    .pipe(source('bundle.js'))
-    .pipe(gulp.dest('./build/game'));
-};
-
-gulp.task('concatCoffee', function() {
-  return gulp.src(sources)
-    .pipe(concat('./main.coffee'))
-    .pipe(gulp.dest('./build/game'));
-});
-
-// `gulp coffee` will generate bundle
-gulp.task('coffee', ['buildUndum', 'concatCoffee'], bundle);
-
-bundler.on('update', bundle); // Re-bundle on dep updates
-bundler.on('log', gutil.log); // Output build logs to terminal
-
-/* Make a development build */
-
-gulp.task('build', ['html', 'img', 'sass', 'coffee', 'audio'], function () {
-
-});
-
-/* Start a development server */
-
-gulp.task('serve', ['build'], function () {
-  browserSync({
-    server: {
-      baseDir: 'build'
-    }
-  });
-
-  var sassListener = function () {
-    reload('./build/css/main.css');
-  }
-
-  gulp.watch(['./html/*.html'], ['html']);
-  gulp.watch(['./sass/*.scss'], ['sass']);
-  gulp.watch(['./img/*.png', './img/*.jpeg', './img/*.jpg'], ['img']);
-  gulp.watch(['./game/*.coffee'], ['coffee']);
-
-  gulp.watch(['./build/css/main.css'], sassListener);
-  gulp.watch(
-    ['./build/game/bundle.js', './build/img/*', './build/index.html'],
-    browserSync.reload);
-});
-
-/* Distribution tasks */
-
-var undumDistBundler = browserify();
-undumDistBundler.require('undum-commonjs');
-
-gulp.task('undum-dist', function () {
-  return undumDistBundler.bundle().pipe(source('undum.js'))
-    .pipe(buffer())
-    .pipe(uglify())
-    .pipe(gulp.dest('./dist/game'));
-});
-
-gulp.task('html-dist', html('./dist'));
-gulp.task('img-dist', img('./dist/img'));
-gulp.task('audio-dist', audio('./dist/audio'));
-gulp.task('legal-dist', function () {
-  return gulp.src(['LICENSE.txt'])
-         .pipe(gulp.dest("./dist"));
-});
-
-gulp.task('sass-dist', function () {
-  return gulp.src('./sass/main.scss')
-        .pipe(sass({outputStyle: 'compressed'}))
-        .pipe(gulp.dest('./dist/css'));
-});
-
-var distBundler = browserify({
-  debug: false,
-  entries: ['./build/game/main.coffee'],
-  transform: ['coffeeify']
-});
-
-distBundler.external('undum-commonjs');
-
-gulp.task('coffee-dist', ['undum-dist', 'concatCoffee'], function () {
-  return distBundler.bundle()
-        .pipe(source('bundle.js'))
-        .pipe(buffer())
-        .pipe(uglify())
-        .on('error', gutil.log)
-        .pipe(gulp.dest('./dist/game'));
-});
-
-gulp.task('dist', ['html-dist', 'img-dist', 'sass-dist', 'coffee-dist', 'audio-dist', 'legal-dist'],
-  function () {
-    return;
-});
-
-gulp.task('zip', ['dist'], function () {
-  return gulp.src('dist/**')
-    .pipe(zip('dist.zip'))
-    .pipe(gulp.dest('.'));
-});
diff --git a/LICENSE.txt b/LICENSE.txt
index 7c5f2d2..828576b 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,4 +1,6 @@
-Copyright (c) 2015-2016 Alexander Yakovlev, https://oreolek.ru/
+Copyright (c) 2016 Alexander Yakovlev, https://oreolek.ru/
+Raconteur is copyright (c) 2015 Bruno Dias, released under the similar license terms.
+Undum is copyright (c) 2009-2015 Ian Millington, released under the similar license terms.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/game/begin.coffee b/game/begin.coffee
index b91df35..df15015 100644
--- a/game/begin.coffee
+++ b/game/begin.coffee
@@ -2,54 +2,32 @@
 # This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
 # To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/4.0
 
-situation = require('raconteur')
-undum = require('undum-commonjs')
-oneOf = require('raconteur/lib/oneOf.js')
-qualities = require('raconteur/lib/qualities.js')
-$ = require("jquery")
-
-Array.prototype.oneOf = () ->
-  oneOf.apply(null, this)
-
-md = require('markdown-it')
-markdown = new md({
-  typographer: true,
-  html: true
-})
-
-shortid = require('shortid')
-# you have to alter linkRe in Undum core to use that.
-# Undum doesn't allow using uppercase letters in situation names by default.
+markdown = require('../../lib/markdown.coffee')
+room = require("../../lib/room.coffee")
+obj = require('../../lib/obj.coffee')
+dialogue = require('../../lib/dialogue.coffee')
+oneOf = require('../../lib/oneOf.coffee')
+require('../../lib/interface.coffee')
+undum = require('../../lib/undum.js')
 
 undum.game.id = "6a9909a4-586a-4089-bd18-26da684d1c8d"
-undum.game.version = "1.0"
+undum.game.version = "2.0"
+
+way_to = (content, ref) ->
+  return "<a href='#{ref}' class='way'>#{content}</a>"
+textlink = (content, ref) ->
+  return "<a href='./_writer_#{ref}' class='once'>#{content}</a>"
+actlink = (content, ref) ->
+  return "<a href='./#{ref}' class='once'>#{content}</a>"
+textcycle = (content, ref) ->
+  return "<a href='./_replacer_#{ref}' class='cycle' id='#{ref}'>#{content}</a>"# usage: writemd( system, "Text to write")
 
-a = require('raconteur/lib/elements.js').a
-way_to = (content, ref) -> a(content).class('way').ref(ref)
-textlink = (content, ref) -> a(content).once().writer(ref)
-actlink = (content, ref) -> a(content).once().action(ref)
-textcycle = (content, ref) -> a(content).replacer(ref).class("cycle").id(ref).toString()
-# usage: writemd( system, "Text to write")
 writemd = (system, text) ->
-  if typeof text is Function
-    text = text()
-  text = markdown.render(text)
+  text = markdown(text)
   system.write(text)
 
-preparemd = (text, mark) ->
-  if typeof text is Function
-    text = text()
-  text = markdown.render(text)
-  if mark?
-    text = """
-      <div class="#{mark}">
-        #{text}
-      </div>
-    """
-  return text
-
-money = (character, system, amount) ->
-  system.setQuality("money", character.qualities.money + amount)
+money = (character, amount) ->
+  character.sandbox.money = character.sandbox.money + amount
 
 code_can_input = (character) ->
   return character.sandbox.code.length < 8
@@ -108,40 +86,12 @@ code_check = (character, system) ->
 
     character.sandbox.code = ""
 
-update_ways = (ways) ->
-  content = ""
-  for way in ways
-    if undum.game.situations[way]?
-      content += way_to(undum.game.situations[way].title, way)
-  $("#ways").html(content)
-
-situation "start",
-  content: """
-    Peter had so much trouble sleeping he had to drown his pills in at least an hour of thoughts.
-
-    A violent ringing of the bell awakened him.
-    He rose from the bed, grumbling:
-    “Crazy neighbors and their guests. It must be three o'clock!”
-
-    The visitor entered the hallway.
-    It was him ringing the bell, but he was not going to meet Peter.
-    In fact, he wasn't looking for meeting anybody here.
-
-    Fourth floor, apartment 406.
-    There, he tried two keys.
-    The second of them fitted the lock.
-
-    Burglary is a curious line of employment.
-    Befittedly, Ronald Chernoff was very curious about a black phone behind the door of apartment 406 in a wooden box on a small table no farther than two meters from the bed.
-    A gift, a prototype, a valuable treasure left by Anastasia Kozlowa when she fled the country.
-    Of course, one had to be reasonably au fait with her *Instagram* to notice that.
-
+room "start",
+  dsc: """
     Peter opened his door to find an empty silent corridor.
     He went to the neighbor's door and met a closed door.
     Ronald was working inside, quietly walking around the apartment.
-    He began the inspection from [the living room.](living-room)
-
-    <hr>
+    He began the inspection from #{way_to('the living room.', 'living-room')}
   """
 
 is_visited = (situation) ->
@@ -153,7 +103,7 @@ is_visited = (situation) ->
 # N-th level examine function
 level = (text, mark) ->
   $("#content .#{mark}").fadeOut()
-  return preparemd(text, mark)
+  return markdown(text, mark)
 
 lvl1 = (text) ->
   $("#content .lvl2").fadeOut()
diff --git a/game/end.coffee b/game/end.coffee
index 71e69dc..b30cd97 100644
--- a/game/end.coffee
+++ b/game/end.coffee
@@ -1,24 +1,8 @@
-qualities
-  general:
-    money: qualities.integer('Money'),
-
 undum.game.init = (character, system) ->
-  $("#ways").on("click", "a", (event) ->
-    event.preventDefault()
-    undum.processClick($(this).attr("href"))
-  )
   _paq.push(['setCustomDimension', 1, false])
-  # If you use only once() links you can use this "hack":
-  document.onmousedown = (e) ->
-  	e.target.click()
-  # It makes every click slightly faster because the game responds after the user presses the mouse button,
-  # not after he presses and releases it.
-  #
-  # Another thing to bear in mind: this game is not a typical Undum game.
-  # It deliberately repeats the situations, so you can repeat "once" links once you re-enter the situation.
-  # So this game has no need in repeatable links at all and this hack is useful.
 
   character.sandbox.view_smash = 1
+  character.sandbox.money = 0
   character.sandbox.code = ""
   character.sandbox.knows_the_code = 0
   character.sandbox.box_opened = 0
diff --git a/game/story.coffee b/game/story.coffee
index 0c7bbb1..b0b4f58 100644
--- a/game/story.coffee
+++ b/game/story.coffee
@@ -1,44 +1,40 @@
-situation "living-room",
+room "living-room",
   title: "Living room"
-  before: () ->
-    if not $(".ways h2").is(':visible')
-      $(".ways h2").fadeIn()
-    update_ways(this.ways)
-    audio = document.getElementById("bgsound")
-    audio.currentTime=0
-    audio.volume = 0.5
-    audio.play()
+  enter: (character, system, from) ->
+    if (from == "start")
+      audio = document.getElementById("bgsound")
+      audio.currentTime=0
+      audio.volume = 0.5
+      audio.play()
   ways: ["bedroom", "kitchen", "balcony"]
-  content: """
-    Ronald is standing in a dark room with a big #{textlink("window.", "window")}
-
-    #{textlink("The walls", "walls")} are covered with a dingy rose wallpaper.
-
+  dsc: """
     #{textlink("A book stand", "bookcase")} is hanging above #{textlink("a television set.", "tv")}
-
-    Oh, and #{actlink("the door Ronald came into", "door")} the apartment is there, too.
   """
-  actions:
-    door: (character, system) ->
-      if character.sandbox.box_opened == 0
-        writemd(system, lvl1("Ronald has a job here. It's still on."))
-      else
-        system.doLink("exitdoor")
-  writers:
-    walls: (character, system) ->
-      lvl1("""
+  objects:
+    window: obj "window",
+      act: """
+        The moon is full today.
+        It illuminates the apartment, makes the things stand out in some weird angles.
+      """
+      dsc: "Ronald is standing in a dark room with a big {{window}}"
+    walls: obj "walls",
+      dsc: "{{The walls}} are covered with a dingy rose wallpaper."
+      act: """
         There are colorful photographs on the walls.
         A wooden house in a forest.
         A village on a mountaintop.
         A family sitting around a fire.
         A sunset burning in a vast ocean.
         A black monolith standing on sand dunes.
-      """)
-    window: (character, system) ->
-      lvl1("""
-        The moon is full today.
-        It illuminates the apartment, makes the things stand out in some weird angles.
-      """)
+      """
+    door: obj "door",
+      dsc: "Oh, and {{the door Ronald came into}} the apartment is there, too."
+      act: (character, system) ->
+        if character.sandbox.box_opened == 0
+          writemd(system, lvl1("Ronald has a job here. It's still on."))
+        else
+          system.doLink("exitdoor")
+  writers:
     bookcase: (character, system) ->
       lvl1("""
         Either Anastasia has a very conflicting taste in books, or she has no taste at all. Let's see...
@@ -88,7 +84,7 @@ situation "living-room",
           No need to read it, not a bit.
         """)
       else
-        money(character, system, 20000)
+        money(character, 20000)
         lvl2("""
           Nietsche's four-part novel about The Man, The Superman and everything in-between.
           It's surprisingly worn down.
@@ -117,12 +113,10 @@ situation "living-room",
         An expensive 40-something inch TV standing on a stylish black stand. The room looks kinda small for that monster.
       """)
 
-situation "bedroom",
-  before: () ->
-    update_ways(this.ways)
+room "bedroom",
   title: "Bedroom"
   ways: ["living-room", "kitchen", "bathroom"]
-  content: (character, system) ->
+  dsc: (character, system) ->
     return """
       The bedroom is spacious; its walls are lavender green, almost white in the moonlight.
 
@@ -188,7 +182,7 @@ situation "bedroom",
         """)
       else
         character.sandbox.seen_coat = 1
-        money(character, system, 4000)
+        money(character, 4000)
         return lvl2("""
           A warm coat.. hey, what's this?
           One of the pockets is loaded with cash!
@@ -264,7 +258,7 @@ situation "bedroom",
         """)
     money: (character, system) ->
       character.sandbox.seen_safe = 1
-      money(character, system, 50000)
+      money(character, 50000)
       lvl4("""
         It's a big cash.
         Odd that she didn't take this when she left.
@@ -278,12 +272,10 @@ situation "bedroom",
         The sketch is signed: *"L. Y. - 2017"*
       """)
 
-situation "kitchen",
-  before: () ->
-    update_ways(this.ways)
+room "kitchen",
   title: "Kitchen"
   ways: ["living-room", "bedroom"]
-  content: """
+  dsc: """
     The white, perfectly clean kitchen could be called spartan: #{textlink("a fridge,", "fridge")} a microwave and #{textlink("a big table", "table")} where one can eat whatever she "cooked" that way.
   """
   writers:
@@ -318,22 +310,19 @@ situation "kitchen",
           He's sure it's recent (`24.03.2018`) and it's about something-something QUANTUM AUDIO.. armement?
         """)
 
-situation "bathroom",
+room "bathroom",
   before: (character,system) ->
     writemd(system,"Ronald doesn't want to search the bathroom. It's too private a room to enter.")
     index = undum.game.situations["bedroom"].ways.indexOf("bathroom")
     undum.game.situations["bedroom"].ways.splice(index, 1)
-    update_ways(undum.game.situations["bedroom"].ways)
     return false
   title: "Bathroom"
   ways: ["bedroom"]
 
-situation "balcony",
-  before: () ->
-    update_ways(this.ways)
+room "balcony",
   title: "Balcony"
   ways: ["living-room"]
-  content: """
+  dsc: """
     A small glazed-in empty balcony.
     It's an amazing night.
     The whole town is lit by moonlight, standing perfectly still.
@@ -359,12 +348,10 @@ situation "balcony",
         &nbsp;&nbsp;&nbsp; *L. Y.*
       """)
 
-situation "box",
-  before: () ->
-    update_ways(this.ways)
+room "box",
   ways: ["bedroom"]
   choices: "#box"
-  content: (character, system) ->
+  dsc: (character, system) ->
     return """
       It's a red wood, very expensive.
       And this box is locked with a digital code key.
@@ -379,8 +366,7 @@ situation "box",
       }
     """
 
-# no need to call update_ways, it's the same location
-situation "smash",
+room "smash",
   canView: (character) ->
     character.sandbox.view_smash == 1
   optionText: "Smash the box"
@@ -388,10 +374,10 @@ situation "smash",
     character.sandbox.view_smash = 0
   choices: "#box"
   tags: ["box"]
-  content: "Ronald still needs the phone in this box. A very high-tech fragile phone. Smashing isn't an option."
+  dsc: "Ronald still needs the phone in this box. A very high-tech fragile phone. Smashing isn't an option."
 
 safe_button = (number) ->
-  situation "put#{number}",
+  room "put#{number}",
     choices: "#box"
     tags: ["box"]
     optionText: "Enter #{number}"
@@ -401,7 +387,7 @@ safe_button = (number) ->
       code_can_input(character)
     after: (character, system) ->
       code_check(character, system)
-    content: (character) -> """
+    dsc: (character) -> """
       Ronald presses button #{number}. The display is #{code_print(character)} now.
     """
 
@@ -410,22 +396,20 @@ safe_button(2)
 safe_button(7)
 safe_button(0)
 
-situation "reset",
+room "reset",
   choices: "#box"
   tags: ["box"]
   optionText: "Reset the display"
   before: (character) ->
     code_reset(character)
-  content: """
+  dsc: """
     Ronald presses Backspace until the display is empty.
   """
 
-situation "exitdoor",
-  before: () ->
-    update_ways(this.ways)
+room "exitdoor",
   ways: ["living-room"]
   choices: "#door"
-  content: """
+  dsc: """
     Ronald is ready to go.
     Maybe he's satisfied with his explorations or just wants to finish this.
     But then a new problem arrives.
@@ -433,15 +417,14 @@ situation "exitdoor",
     Someone's shadow is under the doorframe.
   """
 
-situation "finale",
+room "finale",
   before: () ->
     _paq.push(['setCustomDimension', 1, true])
     $("#tools_wrapper").hide()
-    update_ways(this.ways)
   optionText: "Use the Phone"
   tags: ["door"]
   ways: []
-  content: (character, system) -> """
+  dsc: (character, system) -> """
     "LOADING... 100%"
 
     Ronald opens the door and presses his finger to the phone screen.
@@ -460,8 +443,8 @@ situation "finale",
 
     “Well, that was a good night.”
 
-    #{if character.qualities.money > 0
-      "The pocket is heavy with #{character.qualities.money} rubles and the phone."
+    #{if character.sandbox.money > 0
+      "The pocket is heavy with #{character.sandbox.money} rubles and the phone."
     else
       "The phone is heavy in the pocket."
     }
diff --git a/html/index.html b/html/index.html
index 36e4343..ac6a84f 100644
--- a/html/index.html
+++ b/html/index.html
@@ -16,24 +16,37 @@
             <noscript>
               <p class="noscript_message">This game requires Javascript.</p>
             </noscript>
-            <p class="click_message">click to begin</p>
           </div>
         </div>
       </div>
       <div id="content_wrapper" class="row">
-        <div id="content">
+        <div id="intro" class="content">
+          <section>
+            <p>Peter had so much trouble sleeping he had to drown his pills in at least an hour of thoughts.</p>
+
+            <p>A violent ringing of the bell awakened him.
+            He rose from the bed, grumbling:
+            “Crazy neighbors and their guests. It must be three o'clock!”</p>
+
+            <p>The visitor entered the hallway.
+            It was him ringing the bell, but he was not going to meet Peter.
+            In fact, he wasn't looking for meeting anybody here.</p>
+
+            <p>Fourth floor, apartment 406.
+            There, he tried two keys.
+            The second of them fitted the lock.</p>
+
+            <p>Burglary is a curious line of employment.
+            Befittedly, Ronald Chernoff was very curious about a black phone behind the door of apartment 406 in a wooden box on a small table no farther than two meters from the bed.
+            A gift, a prototype, a valuable treasure left by Anastasia Kozlowa when she fled the country.
+            Of course, one had to be reasonably au fait with her <em>Instagram</em> to notice that.</p>
+            <noscript>You need to turn on Javascript to play this game.</noscript>
+          </section>
         </div>
+        <div id="content" class="content"></div>
         <a name="end_of_content"></a>
       </div>
       <div id="tools_wrapper" class="row">
-        <div id="character_panel" class="tools">
-          <div id="character">
-            <div id="character_text">
-              <div id="character_text_content"></div>
-            </div>
-            <!-- <div id="qualities"></div> -->
-          </div>
-        </div>
         <div class='ways'>
           <h2>Other rooms</h2>
           <div id="ways"></div>
@@ -46,9 +59,8 @@
       <div class="row">
         <div id="legal">
           <div id="footleft">
-            <p>The game was written by <b><a href="http://en.oreolek.ru/" target="_blank">Oreolek.</a></b></p>
+            <p>The game was written by <a href="http://en.oreolek.ru/" target="_blank">Oreolek</a> using <a href="http://git.oreolek.ru/oreolek/salet" target="_blank">Salet.</a></p>
             <p>Approximate play time: five minutes.</p>
-            <p>Written using <a href="http://undum.com" target="_blank">Undum</a> and <a href="http://sequitur.github.io/raconteur/" target="_blank">Raconteur</a>.</p>
             <p>Betatesting credit: <a href="https://verityvirtue.wordpress.com/">Verity Virtue</a></p>
           </div>
           <div id="footright">
@@ -75,7 +87,10 @@
 
     <div id="content_library"></div>
     <audio id="bgsound" preload="auto"><source src="audio/bgr.mp3" type='audio/mpeg; codecs="mp3"'></audio>
-    <script type="text/javascript" src="game/undum.js"></script>
+    <!-- CDN JS Libraries -->
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/marked/0.3.5/marked.min.js"></script>
+    <script type="text/javascript" src="//code.jquery.com/jquery-2.2.0.min.js"></script>
+    <!-- Game code -->
     <script type="text/javascript" src="game/bundle.js"></script>
     <!-- Piwik -->
     <script type="text/javascript">
diff --git a/lib/cycle.coffee b/lib/cycle.coffee
new file mode 100644
index 0000000..6d3f94f
--- /dev/null
+++ b/lib/cycle.coffee
@@ -0,0 +1,19 @@
+# Cycling interface.
+# Rooms: cycle through this.cycle_gallery
+# Objects: cycle through this.cycle_gallery
+
+cyclelink = (content) ->
+  return "<a href='./_replacer_cyclewriter' class='cycle' id='cyclewriter'>#{content}</a>"
+
+cycle = (responses, name, character) ->
+  if typeof responses == "function"
+    responses = responses()
+  character.sandbox.cycle_index ?= [] # initialize with empty array
+  character.sandbox.cycle_index[name] ?= 0 # initialize with 0
+  response = responses[character.sandbox.cycle_index[name]]
+  character.sandbox.cycle_index[name]++
+  if character.sandbox.cycle_index[name] == responses.length
+    character.sandbox.cycle_index[name] = 0
+  return cyclelink(response)
+
+module.exports = cycle
diff --git a/lib/dialogue.coffee b/lib/dialogue.coffee
new file mode 100644
index 0000000..bce17b7
--- /dev/null
+++ b/lib/dialogue.coffee
@@ -0,0 +1,34 @@
+room = require("./room.coffee")
+
+randomid = () ->
+  alphabet = "abcdefghijklmnopqrstuvwxyz0123456789" # see the dreaded linkRe expression in Undum
+  rndstr = []
+  for i in [1..10]
+    rndstr.push alphabet.charAt(Math.floor(Math.random() * alphabet.length))
+  return rndstr.join('').toString()
+
+###
+A dialogue shortcut.
+Usage:
+
+    dialogue "Point out a thing in her purse (mildly)", "start", "mild", """
+        Point out a thing in her purse (mildly)
+      """, "character.sandbox.mild = true"
+###
+dialogue = (title, startTag, endTag, text, effect) ->
+  retval = room(randomid(), {
+    optionText: title
+    dsc: text
+    clear: false # backlog is useful in dialogues
+    choices: "#"+endTag
+  })
+  if typeof(startTag) == "string"
+    retval.tags = [startTag]
+  else if typeof(startTag) == "object"
+    retval.tags = startTag
+  if effect?
+    retval.before = (character, system) ->
+      eval(effect)
+  return retval
+
+module.exports = dialogue
diff --git a/lib/interface.coffee b/lib/interface.coffee
new file mode 100644
index 0000000..db3a2de
--- /dev/null
+++ b/lib/interface.coffee
@@ -0,0 +1,16 @@
+###
+Salet interface configuration.
+###
+undum = require('./undum.js')
+$(document).ready(() ->
+  $("#ways").on("click", "a", (event) ->
+    event.preventDefault()
+    undum.processClick($(this).attr("href"))
+  )
+  $("#inventory").on("click", "a", (event) ->
+    event.preventDefault()
+  )
+  $("#load").on("click", "a", (event) ->
+    window.location.reload()
+  )
+)
diff --git a/lib/localize.coffee b/lib/localize.coffee
new file mode 100644
index 0000000..be3694d
--- /dev/null
+++ b/lib/localize.coffee
@@ -0,0 +1,60 @@
+# Internationalization support
+
+languages = {}
+
+# Default Messages
+
+en = {
+  terrible: "terrible",
+  poor: "poor",
+  mediocre: "mediocre",
+  fair: "fair",
+  good: "good",
+  great: "great",
+  superb: "superb",
+  yes: "yes",
+  no: "no",
+  choice: "Choice {number}",
+  no_group_definition: "Couldn't find a group definition for {id}.",
+  link_not_valid: "The link '{link}' doesn't appear to be valid.",
+  link_no_action: "A link with a situation of '.', must have an action.",
+  unknown_situation: "You can't move to an unknown situation: {id}.",
+  existing_situation: "You can't override situation {id} in HTML.",
+  erase_message: "This will permanently delete this character and immediately return you to the start of the game. Are you sure?",
+  no_current_situation: "I can't display, because we don't have a current situation.",
+  no_local_storage: "No local storage available.",
+  random_seed_error: "You must provide a valid random seed.",
+  random_error: "Initialize the Random with a non-empty seed before use.",
+  dice_string_error: "Couldn't interpret your dice string: '{string}'."
+}
+
+# Set this data as both the default fallback language, and the english preferred language.
+languages[""] = en
+languages["en"] = en
+
+languageCodes = Object.keys(languages)
+
+localize = (languageCode, message) ->
+  for thisCode in languageCodes
+    localized = languages[languageCode][message]
+    if localized
+      return localized
+  return message
+
+# API
+String.prototype.l = (args) ->
+  # Get lang attribute from html tag.
+  lang = document.getElementsByTagName("html")[0].getAttribute("lang") || ""
+
+  # Find the localized form.
+  localized = localize(lang, this)
+
+  # Merge in any replacement content.
+  if args
+    for name in args
+      localized = localized.replace(
+        new RegExp("\\{"+name+"\\}"), args[name]
+      )
+  return localized
+
+module.exports = languages;
diff --git a/lib/markdown.coffee b/lib/markdown.coffee
new file mode 100644
index 0000000..8cfdea8
--- /dev/null
+++ b/lib/markdown.coffee
@@ -0,0 +1,36 @@
+###
+Indent normalization. Removes tabs AND spaces from every line beginning.
+Implies that you don't mix up your tabs and spaces.
+Copyright 2015 Bruno Dias
+###
+normaliseTabs = (text) ->
+  unless text?
+    return ""
+  lines = text.split('\n');
+  indents = lines
+    .filter((l) => l != '')
+    .map((l) => l.match(/^\s+/))
+    .map((m) ->
+      if (m == null)
+        return ''
+      return m[0]
+    )
+  smallestIndent = indents.reduce((max, curr) ->
+    if (curr.length < max.length)
+      return curr
+    return max
+  )
+  return lines.map((l) ->
+    return l.replace(new RegExp('^' + smallestIndent), '')
+  ).join('\n')
+
+markdown = (text) ->
+  unless text?
+    return ""
+  if typeof text is Function
+    text = text()
+  return marked(normaliseTabs(text), {
+    smartypants: true
+  })
+
+module.exports = markdown
diff --git a/lib/obj.coffee b/lib/obj.coffee
new file mode 100644
index 0000000..f8ba818
--- /dev/null
+++ b/lib/obj.coffee
@@ -0,0 +1,50 @@
+markdown = require('./markdown.coffee')
+undum = require('./undum.js')
+objlink = (content, ref) ->
+  return "<a href='./_act_#{ref}' class='once'>#{content}</a>"
+
+Array::remove = (e) -> @[t..t] = [] if (t = @indexOf(e)) > -1
+
+parsedsc = (text, name) ->
+  window.objname = name
+  text = text.replace /\{\{(.+)\}\}/g, (str, p1) ->
+    name = window.objname
+    window.objname = undefined
+    return objlink(p1, name)
+  return text
+
+# An object class.
+# An object cannot be in several locations at once, you must clone the variable.
+class SaletObj
+  constructor: (spec) ->
+    unless spec.name?
+      console.error("Trying to create an object with no name")
+      return null
+    for key, value of spec
+      this[key] = value
+  level: 0
+  look: (character, system, f) =>
+    if @dsc
+      text = markdown(@dsc.fcall(this, character, system, f)) 
+      text = "<span class='look lvl#{@level}'>" + text + "</span>"
+      # replace braces {{}} with link to _act_
+      return parsedsc(text, @name)
+  takeable: false
+  take: (character, system) => "You take the #{@name}." # taking to inventory
+  act: (character, system) => "You don't find anything extraordinary about the #{@name}." # object action
+  dsc: (character, system) => "You see a {{#{@name}}} here." # object description
+  inv: (character, system) => "It's a {{#{@name}.}}" # inventory description
+  location: ""
+  put: (location) =>
+    @level = 0 # this is scenery
+    if undum.game.situations[location]?
+      undum.game.situations[location].take(this)
+      @location = location
+  delete: () =>
+    undum.game.situations[@location].objects.remove(this)
+
+obj = (name, spec) ->
+  spec ?= {}
+  spec.name = name
+  return new SaletObj(spec)
+module.exports = obj
diff --git a/lib/oneOf.coffee b/lib/oneOf.coffee
new file mode 100644
index 0000000..051e129
--- /dev/null
+++ b/lib/oneOf.coffee
@@ -0,0 +1,170 @@
+###
+oneOf.js
+
+Copyright (c) 2015 Bruno Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+###
+
+###
+  Undularity Tools
+
+  Those functions are not a core part of Undularity, but provide some
+  general functionality that relates to adaptive text generation.
+
+  This is provided partly as a helper to less technical users, and as
+  a convenience for authors.
+###
+
+# Monkey patching
+
+###
+  Shuffles an array. It can use Undum's random number generator implementation,
+  so it expects a System.rnd object to be passed into it. If one isn't
+  supplied, it will use Math.Random instead.
+
+  This is an implementation of the Fischer-Yates (Knuth) shuffle.
+
+  Returns the shuffled array.
+###
+
+Array.prototype.shuffle = (system) ->
+  rng = if system then system.rnd.random else Math.random
+  # slice() clones the array. Object members are copied by reference, beware.
+  newArr = this.slice()
+  m = newArr.length
+
+  while (m)
+    i = Math.floor(rng() * m--)
+    t = newArr[m]
+    newArr[m] = newArr[i]
+    newArr[i] = t
+
+  return newArr
+
+###
+  oneOf()
+
+  Takes an array and returns an object with several methods. Each method
+  returns an iterator which iterates over the array in a specific way:
+
+    inOrder()
+      Returns the array items in order.
+
+    cycling()
+      Returns the array items in order, cycling back to the first item when
+      it runs out.
+
+    stopping()
+      Returns the array items in order, then repeats the last item when it
+      runs out.
+
+    randomly()
+      Returns the array items at random. Takes a system object, for consistent
+      randomness. Will never return the same item twice in a row.
+
+    trulyAtRandom()
+      Returns the array items purely at random. Takes a system object, for
+      consistent randomness.
+
+    inRandomOrder()
+      Returns the array items in a random order. Takes a system object, for
+      consistent randomness.
+###
+
+###
+  Takes a function and gives it a toString() property that calls itself and
+  returns its value, allowing for ambiguous use of the closure object
+  as a text snippet.
+
+  Returns the modified function.
+###
+stringish = (callback) ->
+  callback.toString = () ->
+    return '' + this.call()
+  return callback
+
+oneOf = (ary...) ->
+  if ary.length == 0
+    throw new Error(
+      "tried to create a oneOf iterator with a 0-length array");
+
+  return {
+    inOrder: () ->
+      i = 0
+      return stringish(() ->
+        if i >= ary.length
+          return null
+        return ary[i++]
+      )
+
+    cycling: () ->
+      i = 0
+      return stringish(() ->
+        if (i >= ary.length)
+          i = 0
+        return ary[i++]
+      )
+
+    stopping: () ->
+      i = 0
+      return stringish(() ->
+        if (i >= ary.length)
+          i = ary.length - 1
+        return ary[i++]
+      )
+
+    randomly: (system) ->
+      rng = if system then system.rnd.random else Math.random
+      last = null
+
+      if (ary.length<2)
+        throw new Error("attempted to make randomly() iterator with a 1-length array")
+      return stringish( () ->
+        i = null
+        offset = null
+        if not last?
+          i = Math.floor(rng() * ary.length)
+        else
+          ###
+            Let offset be a random number between 1 and the length of the
+            array, minus one. We jump offset items ahead on the array,
+            wrapping around to the beginning. This gives us a random item
+            other than the one we just chose.
+          ###
+
+          offset = Math.floor(rng() * (ary.length -1) + 1);
+          i = (last + offset) % ary.length;
+
+        last = i
+        return ary[i]
+      )
+
+    trulyAtRandom: (system) ->
+      rng = if system then system.rnd.random else Math.random
+      return stringish(() ->
+        return ary[Math.floor(rng() * ary.length)];
+      )
+
+    inRandomOrder: (system) ->
+      shuffled = ary.shuffle(system)
+      i = 0
+      return stringish(() ->
+        if (i >= ary.length)
+          i = 0
+        return shuffled[i++]
+      )
+  }
+
+Array.prototype.oneOf = () ->
+  oneOf.apply(null, this)
+
+module.exports = oneOf;
diff --git a/lib/random.js b/lib/random.js
new file mode 100644
index 0000000..48b00a7
--- /dev/null
+++ b/lib/random.js
@@ -0,0 +1,207 @@
+// Random Number generation based on seedrandom.js code by David Bau.
+// Copyright 2010 David Bau, all rights reserved.
+//
+// Redistribution and use in source and binary forms, with or
+// without modification, are permitted provided that the following
+// conditions are met:
+//
+//   1. Redistributions of source code must retain the above
+//      copyright notice, this list of conditions and the
+//      following disclaimer.
+//
+//   2. Redistributions in binary form must reproduce the above
+//      copyright notice, this list of conditions and the
+//      following disclaimer in the documentation and/or other
+//      materials provided with the distribution.
+//
+//   3. Neither the name of this module nor the names of its
+//      contributors may be used to endorse or promote products
+//      derived from this software without specific prior written
+//      permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+// CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+var width = 256;
+var chunks = 6;
+var significanceExponent = 52;
+var startdenom = Math.pow(width, chunks);
+var significance = Math.pow(2, significanceExponent);
+var overflow = significance * 2;
+
+var Random = (function () {
+    var Random = function(seed) {
+        this.random = null;
+        if (!seed) throw {
+            name: "RandomSeedError",
+            message: "random_seed_error".l()
+        };
+        var key = [];
+        mixkey(seed, key);
+        var arc4 = new ARC4(key);
+        this.random = function() {
+            var n = arc4.g(chunks);
+            var d = startdenom;
+            var x = 0;
+            while (n < significance) {
+                n = (n + x) * width;
+                d *= width;
+                x = arc4.g(1);
+            }
+            while (n >= overflow) {
+                n /= 2;
+                d /= 2;
+                x >>>= 1;
+            }
+            return (n + x) / d;
+        };
+    };
+    // Helper type.
+    var ARC4 = function(key) {
+        var t, u, me = this, keylen = key.length;
+        var i = 0, j = me.i = me.j = me.m = 0;
+        me.S = [];
+        me.c = [];
+        if (!keylen) { key = [keylen++]; }
+        while (i < width) { me.S[i] = i++; }
+        for (i = 0; i < width; i++) {
+            t = me.S[i];
+            j = lowbits(j + t + key[i % keylen]);
+            u = me.S[j];
+            me.S[i] = u;
+            me.S[j] = t;
+        }
+        me.g = function getnext(count) {
+            var s = me.S;
+            var i = lowbits(me.i + 1); var t = s[i];
+            var j = lowbits(me.j + t); var u = s[j];
+            s[i] = u;
+            s[j] = t;
+            var r = s[lowbits(t + u)];
+            while (--count) {
+                i = lowbits(i + 1); t = s[i];
+                j = lowbits(j + t); u = s[j];
+                s[i] = u;
+                s[j] = t;
+                r = r * width + s[lowbits(t + u)];
+            }
+            me.i = i;
+            me.j = j;
+            return r;
+        };
+        me.g(width);
+    };
+    // Helper functions.
+    var mixkey = function(seed, key) {
+        seed += '';
+        var smear = 0;
+        for (var j = 0; j < seed.length; j++) {
+            var lb = lowbits(j);
+            smear ^= key[lb];
+            key[lb] = lowbits(smear*19 + seed.charCodeAt(j));
+        }
+        seed = '';
+        for (j in key) {
+            seed += String.fromCharCode(key[j]);
+        }
+        return seed;
+    };
+    var lowbits = function(n) {
+        return n & (width - 1);
+    };
+
+    return Random;
+})();
+
+/* Returns a random floating point number between zero and
+* one. NB: The prototype implementation below just throws an
+* error, it will be overridden in each Random object when the
+* seed has been correctly configured. */
+Random.prototype.random = function() {
+throw {
+    name:"RandomError",
+    message: "random_error".l()
+};
+};
+/* Returns an integer between the given min and max values,
+* inclusive. */
+Random.prototype.randomInt = function(min, max) {
+return min + Math.floor((max-min+1)*this.random());
+};
+/* Returns the result of rolling n dice with dx sides, and adding
+* plus. */
+Random.prototype.dice = function(n, dx, plus) {
+var result = 0;
+for (var i = 0; i < n; i++) {
+    result += this.randomInt(1, dx);
+}
+if (plus) result += plus;
+return result;
+};
+/* Returns the result of rolling n averaging dice (i.e. 6 sided dice
+* with sides 2,3,3,4,4,5). And adding plus. */
+Random.prototype.aveDice = (function() {
+var mapping = [2,3,3,4,4,5];
+return function(n, plus) {
+    var result = 0;
+    for (var i = 0; i < n; i++) {
+        result += mapping[this.randomInt(0, 5)];
+    }
+    if (plus) result += plus;
+    return result;
+};
+})();
+/* Returns a dice-roll result from the given string dice
+* specification. The specification should be of the form xdy+z,
+* where the x component and z component are optional. This rolls
+* x dice of with y sides, and adds z to the result, the z
+* component can also be negative: xdy-z. The y component can be
+* either a number of sides, or can be the special values 'F', for
+* a fudge die (with 3 sides, +,0,-), '%' for a 100 sided die, or
+* 'A' for an averaging die (with sides 2,3,3,4,4,5).
+*/
+
+Random.prototype.diceString = (function () {
+var diceRe = /^([1-9][0-9]*)?d([%FA]|[1-9][0-9]*)([-+][1-9][0-9]*)?$/;
+return function(def) {
+    var match = def.match(diceRe);
+    if (!match) {
+        throw new Error(
+            "dice_string_error".l({string:def})
+        );
+    }
+
+    var num = match[1]?parseInt(match[1], 10):1;
+    var sides;
+    var bonus = match[3]?parseInt(match[3], 10):0;
+
+    switch (match[2]) {
+    case 'A':
+        return this.aveDice(num, bonus);
+    case 'F':
+        sides = 3;
+        bonus -= num*2;
+        break;
+    case '%':
+        sides = 100;
+        break;
+    default:
+        sides = parseInt(match[2], 10);
+        break;
+    }
+    return this.dice(num, sides, bonus);
+};
+})();
+
+module.exports = Random;
diff --git a/lib/room.coffee b/lib/room.coffee
new file mode 100644
index 0000000..b3af465
--- /dev/null
+++ b/lib/room.coffee
@@ -0,0 +1,277 @@
+# I confess that this world model heavily borrows from INSTEAD engine. - A.Y.
+
+undum = require('./undum.js')
+obj = require('./obj.coffee')
+markdown = require('./markdown.coffee')
+cycle = require('./cycle.coffee')
+
+way_to = (content, ref) ->
+  return "<a href='#{ref}' class='way' id='waylink-#{ref}'>#{content}</a>"
+
+# jQuery was confused by this point where's the context so I did it vanilla-way
+print = (content) ->
+  if content == ""
+    return
+  if typeof content == "function"
+    content = content()
+  block = document.getElementById("current-situation")
+  if block
+    block.innerHTML = block.innerHTML + markdown(content)
+  else
+    console.error("No current situation found.")
+
+Array::remove = (e) -> @[t..t] = [] if (t = @indexOf(e)) > -1
+
+addClass = (element, className) ->
+  if (element.classList)
+    element.classList.add(className)
+  else
+    element.className += ' ' + className
+
+cls = (system) ->
+  system.clearContent()
+  system.clearContent("#intro")
+
+update_ways = (ways, name) ->
+  content = ""
+  distances = []
+  if ways
+    document.querySelector(".ways h2").style.display = "block"
+    for way in ways
+      if undum.game.situations[way]?
+        title = undum.game.situations[way].title.fcall(this, name)
+        content += way_to(title, way)
+        distances.push({
+          key: way
+          distance: undum.game.situations[way].distance
+        })
+  else
+    document.querySelector(".ways h2").style.display = "none"
+  document.getElementById("ways").innerHTML = content
+  min = Infinity
+  min_key = []
+  for node in distances
+    if node.distance < min
+      min = node.distance
+      min_key = [node.key]
+    if node.distance == min
+      min_key.push(node.key)
+  if min < Infinity
+    for node in min_key
+      addClass(document.getElementById("waylink-#{node}"), "destination")
+
+picture_tag = (picture) ->
+  extension = picture.substr((~-picture.lastIndexOf(".") >>> 0) + 2)
+  if (extension == "webm")
+    return """
+<video src="#{picture}" controls>
+  Your browser does not support the video tag for some reason.
+  You won't be able to view this video in this browser.
+</video>
+    """
+  return "<img class='img-responsive' src='#{picture}' alt='Room illustration'>"
+
+class SaletRoom extends undum.Situation
+  constructor: (spec) ->
+    undum.Situation.call(this, spec)
+    for index, value of spec
+      this[index] = value
+    return this
+  visited: 0
+  title: "Room"
+  objects: {}
+  
+  # room illustration image, VN-style. Can be a GIF or WEBM. Can be a function.
+  pic: false
+
+  dsc: false # room description
+  extendSection: false
+  distance: Infinity # distance to the destination
+  clear: true # clear the screen on entering the room?
+
+  ###
+    I call SaletRoom.exit every time the player exits to another room.
+    Unlike @after this gets called after the section is closed.
+    It's a styling difference.
+  ###
+  exit: (character, system, to) =>
+    return true
+
+  ###
+    I call SaletRoom.enter every time the player enters this room but before the section is opened.
+    Unlike @before this gets called before the current section is opened.
+    It's a styling difference.
+
+    The upstream Undum version does not allow you to redefine @enter function easily but allows custom @exit one.
+    It was renamed as @entering to achieve API consistency.
+  ###
+  enter: (character, system, from) =>
+    return true
+
+  ###
+    Salet's Undum version calls Situation.entering every time a situation is entered, and
+    passes it three arguments; The character object, the system object,
+    and a string referencing the previous situation, or null if there is
+    none (ie, for the starting situation).
+
+    My version of `enter` splits the location description from the effects.
+    Also if f == this.name (we're in the same location) the `before` and `after` callbacks are ignored.
+  ###
+  entering: (character, system, f) =>
+    if @clear and f?
+      cls(system)
+
+    if f != @name and f?
+      @visited++
+      if undum.game.situations[f].exit?
+        undum.game.situations[f].exit(character, system, @name)
+
+    if @enter
+      @enter character, system, f
+
+    current_situation = ""
+    if not @extendSection
+      classes = if @classes then ' ' + @classes.join(' ') else ''
+      situation = document.getElementById('current-situation')
+      if situation?
+        situation.removeAttribute('id')
+      # Javascript DOM manipulation functions like jQuery's append() or document.createElement
+      # don't work like a typical printLn - they create *DOM nodes*.
+      # You can't leave an unclosed tag just like that. So we have to buffer the output.
+      current_situation = "<section id='current-situation' data-situation='#{@name}' class='situation-#{@name}#{classes}'>"
+
+    if f != @name and @before?
+      current_situation += markdown(@before.fcall(this, character, system, f))
+
+    current_situation += @look character, system, f
+
+    if f != @name and @after?
+      current_situation += markdown(@after.fcall(this, character, system, f))
+
+    if not @extendSection
+      current_situation += "</section>"
+
+    system.write(current_situation)
+
+    if @choices
+      system.writeChoices(system.getSituationIdChoices(@choices, @minChoices, @maxChoices))
+
+  ###
+    An internal function to get the room's description and the descriptions of
+    every object in this room.
+  ###
+  look: (character, system, f) =>
+    update_ways(@ways, @name)
+    retval = ""
+
+    if @pic
+      retval += '<div class="pic">'+picture_tag(@pic.fcall(this, character, system, f))+'</div>'
+
+    # Print the room description
+    if @dsc
+      retval += markdown(@dsc.fcall(this, character, system, f))
+
+    for name, thing of @objects
+      retval += thing.look()
+
+    return retval
+
+  ###
+    Puts an object in this room.
+  ###
+  take: (thing) =>
+    @objects[thing.name] = thing
+    # BUG: for some really weird reason if the call is made in init function or
+    # during the initialization, this ALSO puts the thing in the start room.
+    undum.game.situations["start"].objects = {}
+
+  drop: (name) =>
+    delete @objects[name]
+
+  ###
+    Object action. A function or a string which comes when you click on the object link.
+    You could interpret this as an EXAMINE verb or USE one, it's your call.
+  ###
+  act: (character, system, action) =>
+    if (link = action.match(/^_(act|cycle)_(.+)$/)) #object action
+      for name, thing of @objects
+        if name == link[2]
+          if link[1] == "act"
+            # If it's takeable, the player can take this object.
+            # If not, we check the "act" function.
+            if thing.takeable
+              character.sandbox.inventory.push thing
+              @drop name
+              cls(system)
+              @entering.fcall(this, character, system, @name)
+              return print(thing.take.fcall(thing, character, system))
+            if thing.act
+              return print(thing.act.fcall(thing, character, system))
+          elseif link[1] == "cycle"
+            # TODO object cyclewriter
+      # the loop is done but no return came - match not found
+      console.error("Could not find #{link[1]} in current room.")
+
+    # we're done with objects, now check the regular actions
+    actionClass = action.match(/^_(\w+)_(.+)$/)
+    that = this
+
+    responses = {
+      writer: (ref) ->
+        content = that.writers[ref].fcall(that, character, system, action)
+        output = markdown(content)
+        system.writeInto(output, '#current-situation')
+      replacer: (ref) ->
+        content = that.writers[ref].fcall(that, character, system, action)
+        output = "<span>"+content+"</span>" # <p> tags are usually bad for replacers
+        system.replaceWith(output, '#'+ref)
+      inserter: (ref) ->
+        content = that.writers[ref].fcall(that, character, system, action)
+        output = markdown(content)
+        system.writeInto(output, '#'+ref)
+    }
+
+    if (actionClass)
+      # Matched a special action class
+      [responder, ref] = [actionClass[1], actionClass[2]]
+
+      if(!@writers.hasOwnProperty(actionClass[2]))
+        throw new Error("Tried to call undefined writer: #{action}");
+      responses[responder](ref);
+    else if (@actions.hasOwnProperty(action))
+      @actions[action].call(this, character, system, action);
+    else
+      throw new Error("Tried to call undefined action: #{action}");
+
+  # Marks every room in the game with distance to this room
+  destination: () =>
+    @distance = 0
+
+    candidates = [this]
+    while candidates.length > 0
+      current_room = candidates.shift()
+      if current_room.ways
+        for node in current_room.ways
+          if node.distance == Infinity
+            node.distance = current_room.distance + 1
+            candidates.push(node)
+
+  register: () =>
+    if not @name?
+      console.error("Situation has no name")
+      return this
+    undum.game.situations[@name] = this
+    return this
+
+  writers:
+    cyclewriter: (character) ->
+      cycle(this.cycle, this.name, character)
+
+room = (name, spec) ->
+  spec ?= {}
+  spec.name = name
+  retval = new SaletRoom(spec)
+  retval.register()
+  return retval
+
+module.exports = room
diff --git a/lib/undum.js b/lib/undum.js
new file mode 100644
index 0000000..8bb20d4
--- /dev/null
+++ b/lib/undum.js
@@ -0,0 +1,1617 @@
+// ---------------------------------------------------------------------------
+// UNDUM game library. Games and other modules using it should require it:
+//  var undum = require('undum');
+//
+// Version: 3.2.0-oreolek
+// ---------------------------------------------------------------------------
+
+var Random = require('./random.js');
+var languages = require('./localize.coffee');
+
+// ---------------------------------------------------------------------------
+// Infrastructure implementations
+
+/* Crockford's inherit function */
+/* (Exported globally) */
+
+Function.prototype.inherits = function(Parent) {
+    var d = {}, p = (this.prototype = new Parent());
+    this.prototype.uber = function(name) {
+        if (!(name in d)) d[name] = 0;
+        var f, r, t = d[name], v = Parent.prototype;
+        if (t) {
+            while (t) {
+                v = v.constructor.prototype;
+                t -= 1;
+            }
+            f = v[name];
+        } else {
+            f = p[name];
+            if (f == this[name]) {
+                f = v[name];
+            }
+        }
+        d[name] += 1;
+        r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
+        d[name] -= 1;
+        return r;
+    };
+    return this;
+};
+
+// Feature detection
+
+var hasLocalStorage = function() {
+    var hasStorage = false;
+    try {
+        hasStorage = ('localStorage' in window) &&
+            window.localStorage !== null &&
+            window.localStorage !== undefined;
+    }
+    catch (err) {
+        // Firefox with the "Always Ask" cookie accept setting
+        // will throw an error when attempting to access localStorage
+        hasStorage = false;
+    }
+    return hasStorage;
+};
+
+// Assertion
+
+var AssertionError = function(message) {
+    this.message = message;
+    this.name = AssertionError;
+};
+AssertionError.inherits(Error);
+
+var assert = function(expression, message) {
+    if (!expression) {
+        throw new AssertionError(message);
+    }
+};
+
+// -----------------------------------------------------------------------
+// Types for Author Use
+// -----------------------------------------------------------------------
+
+/* The game is split into situations, which respond to user
+ * choices. Situation is the base type. It has three methods:
+ * enter, act and exit, which you implement to perform any
+ * processing and output any content. The default implementations
+ * do nothing.
+ *
+ * You can either create your own type of Situation, and add
+ * enter, act and/or exit functions to the prototype (see
+ * SimpleSituation in this file for an example of that), or you
+ * can give those functions in the opts parameter. The opts
+ * parameter is an object. So you could write:
+ *
+ *    var situation = Situation({
+ *        entering: function(character, system, from) {
+ *            ... your implementation ...
+ *        }
+ *    });
+ *
+ * If you pass in enter, act and/or exit through these options,
+ * then they should have the same function signature as the full
+ * function definitions, below.
+ *
+ * Note that SimpleSituation, a derived type of Situation, calls
+ * passed in enter, act and exit functions AS WELL AS their normal
+ * action. This is most often what you want: the normal behavior
+ * plus a little extra custom behavior. If you want to override
+ * the behavior of a SimpleSituation, you'll have to create a
+ * derived type and set the enter, act and/or exit function on
+ * their prototypes. In most cases, however, if you want to do
+ * something completely different, it is better to derive your
+ * type from this type: Situation, rather than one of its
+ * children.
+ *
+ * In addition to enter, exit and act, the following options
+ * related to implicit situation selection are available:
+ *
+ * optionText: a string or a function(character, system,
+ *     situation) which should return the label to put in an
+ *     option block where a link to this situation can be
+ *     chosen. The situation passed in is the situation where the
+ *     option block is being displayed.
+ *
+ * canView: a function(character, system, situation) which should
+ *     return true if this situation should be visible in an
+ *     option block in the given situation.
+ *
+ * canChoose: a function(character, system, situation) which should
+ *     return true if this situation should appear clickable in an
+ *     option block. Returning false allows you to present the
+ *     option but prevent it being selected. You may want to
+ *     indicate to the player that they need to collect some
+ *     important object before the option is available, for
+ *     example.
+ *
+ * tags: a list of tags for this situation, which can be used for
+ *     implicit situation selection. The tags can also be given as
+ *     space, tab or comma separated tags in a string. Note that,
+ *     when calling `getSituationIdChoices`, tags are prefixed with
+ *     a hash, but that should not be the case here. Just use the
+ *     plain tag name.
+ *
+ * priority: a numeric priority value (default = 1). When
+ *     selecting situations implicitly, higher priority situations
+ *     are considered first.
+ *
+ * frequency: a numeric relative frequency (default = 1), so 100
+ *     would be 100 times more frequent. When there are more
+ *     options that can be displayed, situations will be selected
+ *     randomly based on their frequency.
+ *
+ * displayOrder: a numeric ordering value (default = 1). When
+ *     situations are selected implicitly, the results are ordered
+ *     by increasing displayOrder.
+ */
+
+var Situation = function(opts) {
+    if (opts) {
+        if (opts.entering) this._entering = opts.entering;
+        if (opts.act) this._act = opts.act;
+
+        // Options related to this situation being automatically
+        // selected and displayed in a list of options.
+        this._optionText = opts.optionText;
+        this._canView = opts.canView || true;
+        this._canChoose = opts.canChoose || true;
+        this._priority = (opts.priority !== undefined) ? opts.priority : 1;
+        this._frequency =
+            (opts.frequency !== undefined) ? opts.frequency : 1;
+        this._displayOrder =
+            (opts.displayOrder !== undefined) ? opts.displayOrder : 1;
+
+        // Tag are not stored with an underscore, because they are
+        // accessed directy. They should not be context sensitive
+        // (use the canView function to do context sensitive
+        // manipulation).
+        if (opts.tags !== undefined) {
+            if ($.isArray(opts.tags)) {
+                this.tags = opts.tags;
+            } else {
+                this.tags = opts.tags.split(/[ \t,]+/);
+            }
+        } else {
+            this.tags = [];
+        }
+    } else {
+        this._canView = true;
+        this._canChoose = true;
+        this._priority = 1;
+        this._frequency = 1;
+        this._displayOrder = 1;
+        this.tags = [];
+    }
+};
+
+/* A function that takes action when we enter a situation. The
+ * last parameter indicates the situation we have just left: it
+ * may be null if this is the starting situation. Unlike the
+ * exit() method, this method cannot prevent the transition
+ * happening: its return value is ignored. */
+Situation.prototype.entering = function(character, system, from) {
+    if (this._entering) this._entering(character, system, from);
+};
+/* A function that takes action when we carry out some action in a
+ * situation that isn't intended to lead to a new situation. */
+Situation.prototype.act = function(character, system, action) {
+    if (this._act) this._act(character, system, action);
+};
+/* Determines whether this situation should be contained within a
+ * list of options generated automatically by the given
+ * situation. */
+Situation.prototype.canView = function(character, system, situation) {
+    if ($.isFunction(this._canView)) {
+        return this._canView(character, system, situation);
+    } else {
+        return this._canView;
+    }
+};
+/* Determines whether this situation should be clickable within a
+ * list of options generated automatically by the given situation. */
+Situation.prototype.canChoose = function(character, system, situation) {
+    if ($.isFunction(this._canChoose)) {
+        return this._canChoose(character, system, situation);
+    } else {
+        return this._canChoose;
+    }
+};
+/* Returns the text that should be used to display this situation
+ * in an automatically generated list of choices. */
+Situation.prototype.optionText = function(character, system, situation) {
+    if ($.isFunction(this._optionText)) {
+        return this._optionText(character, system, situation);
+    } else {
+        return this._optionText;
+    }
+};
+/* Returns the priority, frequency and displayOrder for this situation,
+ * when being selected using `system.getSituationIdChoices`. */
+Situation.prototype.choiceData = function(character, system, situation) {
+    return {
+        priority: this._priority,
+        frequency: this._frequency,
+        displayOrder: this._displayOrder
+    };
+};
+
+/* Instances of this class define the qualities that characters
+ * may possess. The title should be a string, and can contain
+ * HTML. Options are passed in in the opts parameter. The
+ * following options are available.
+ *
+ * priority - A string used to sort qualities within their
+ *     groups. When the system displays a list of qualities they
+ *     will be sorted by this string. If you don't give a
+ *     priority, then the title will be used, so you'll get
+ *     alphabetic order. Normally you either don't give a
+ *     priority, or else use a priority string containing 0-padded
+ *     numbers (e.g. "00001").
+ *
+ * group - The Id of a group in which to display this
+ *     parameter. The corresponding group must be defined in
+ *     your `undum.game.qualityGroups` property.
+ *
+ * extraClasses - These classes will be attached to the <div> tag
+ *     that surrounds the quality when it is displayed. A common
+ *     use for this is to add icons representing the quality. In
+ *     your CSS define a class for each icon, then pass those
+ *     classes into the appropriate quality definitions.
+ *
+ * One key purpose of QualityDefinition is to format the quality
+ * value for display. Quality values are always stored as numeric
+ * values, but may be displayed in words or symbols. A number of
+ * sub-types of QualityDefinition are given that format their
+ * values in different ways.
+ */
+var QualityDefinition = function(title, opts) {
+    var myOpts = $.extend({
+        priority: title,
+        group: null,
+        extraClasses: null
+    }, opts);
+    this.title = title;
+    this.priority = myOpts.priority;
+    this.group = myOpts.group;
+    this.extraClasses = myOpts.extraClasses;
+};
+/* Formats the value (which is always numeric) into the value to
+ * be displayed. The result should be HTML (but no tags are
+ * needed). If null is returned, then the quality definition will
+ * not be displayed, so if you want an empty value return an empty
+ * string. */
+QualityDefinition.prototype.format = function(character, value) {
+    return value.toString();
+};
+
+/* A quality that is always displayed as the nearest integer of
+ * the current value, rounded down. Options (in the opts
+ * parameter) are the same as for QualityDefinition. */
+var IntegerQuality = function(title, opts) {
+    QualityDefinition.call(this, title, opts);
+};
+IntegerQuality.inherits(QualityDefinition);
+IntegerQuality.prototype.format = function(character, value) {
+    return Math.floor(value).toString();
+};
+
+/* A quality that displays as an IntegerQuality, unless it is
+ * zero, when it is omitted. Options (in the opts * parameter) are
+ * the same as for QualityDefinition. */
+var NonZeroIntegerQuality = function(title, opts) {
+    IntegerQuality.call(this, title, opts);
+};
+NonZeroIntegerQuality.inherits(IntegerQuality);
+NonZeroIntegerQuality.prototype.format = function(character, value) {
+    if (value === 0) {
+        return null;
+    } else {
+        return IntegerQuality.prototype.format.call(
+            this, character, value
+        );
+    }
+};
+
+/* A quality that displays its full numeric value, including
+ * decimal component. This is actually a trivial wrapper around
+ * the QualityDefinition class, which formats in the same
+ * way. Options (in the opts parameter) are the same as for
+ * QualityDefinition. */
+var NumericQuality = function(title, opts) {
+    QualityDefinition.call(this, title, opts);
+};
+NumericQuality.inherits(QualityDefinition);
+
+/* A quality that displays its values as one of a set of
+ * words. The quality value is first rounded down to the nearest
+ * integer, then this value is used to select a word to
+ * display. The offset parameter (optionally passed in as part of
+ * the opts object) controls what number maps to what word.
+ *
+ * The following options (in the opts parameter) are available:
+ *
+ * offset - With offset=0 (the default), the quantity value of 0
+ *     will map to the first word, and so on. If offset is
+ *     non-zero then the value given will correspond to the first
+ *     word in the list. So if offset=4, then the first word in
+ *     the list will be used for value=4.
+ *
+ * useBonuses - If this is true (the default), then values outside
+ *     the range of words will be construced from the word and a
+ *     numeric bonus. So with offset=0 and five words, the last of
+ *     which is 'amazing', a score of six would give 'amazing+1'.
+ *     if this is false, then the bonus would be omitted, so
+ *     anything beyond 'amazing' is still 'amazing'.
+ *
+ * Other options are the same as for QualityDefinition.
+ */
+var WordScaleQuality = function(title, values, opts) {
+    var myOpts = $.extend({
+        offset: null,
+        useBonuses: true
+    }, opts);
+    QualityDefinition.call(this, title, opts);
+    this.values = values;
+    this.offset = myOpts.offset;
+    this.useBonuses = myOpts.useBonuses;
+};
+WordScaleQuality.inherits(QualityDefinition);
+WordScaleQuality.prototype.format = function(character, value) {
+    var val = Math.floor(value - this.offset);
+    var mod = "";
+    if (val < 0) {
+        mod = val.toString();
+        val = 0;
+    } else if (val >= this.values.length) {
+        mod = "+" + (val - this.values.length + 1).toString();
+        val = this.values.length - 1;
+    }
+    if (!this.useBonuses) mod = "";
+    if (this.values[val] === null) return null;
+    return this.values[val] + mod; // Type coercion
+};
+
+/* A specialization of WordScaleQuality that uses the FUDGE RPG's
+ * adjective scale (from 'terrible' at -3 to 'superb' at +3). The
+ * options are as for WordScaleQuality. In particular you can use
+ * the offset option to control where the scale starts. So you
+ * could model a quality that everyone starts off as 'terrible'
+ * (such as Nuclear Physics) with an offset of 0, while another that
+ * is more common (such as Health) could have an offset of -5 so
+ * everyone starts with 'great'.
+ */
+var FudgeAdjectivesQuality = function(title, opts) {
+    WordScaleQuality.call(this, title, [
+        "terrible".l(), "poor".l(), "mediocre".l(),
+        "fair".l(), "good".l(), "great".l(), "superb".l()
+    ], opts);
+    if (!('offset' in opts)) this.offset = -3;
+};
+FudgeAdjectivesQuality.inherits(WordScaleQuality);
+
+/* An boolean quality that removes itself from the quality list if
+ * it has a zero value. If it has a non-zero value, its value
+ * field is usually left empty, but you can specify your own
+ * string to display as the `onDisplay` parameter of the opts
+ * object. Other options (in the opts parameter) are the same as
+ * for QualityDefinition. */
+var OnOffQuality = function(title, opts) {
+    var myOpts = $.extend({
+        onDisplay: ""
+    }, opts);
+    QualityDefinition.call(this, title, opts);
+    this.onDisplay = myOpts.onDisplay;
+};
+OnOffQuality.inherits(QualityDefinition);
+OnOffQuality.prototype.format = function(character, value) {
+    if (value) return this.onDisplay;
+    else return null;
+};
+
+/* A boolean quality that has different output text for zero or
+ * non-zero quality values. Unlike OnOffQuality, this definition
+ * doesn't remove itself from the list when it is 0. The options
+ * are as for QualityDefinition, with the addition of options
+ * 'yesDisplay' and 'noDisplay', which contain the HTML fragments
+ * used to display true and false values. If not given, these
+ * default to 'yes' and 'no'.
+ */
+var YesNoQuality = function(title, opts) {
+    var myOpts = $.extend({
+        yesDisplay: "yes".l(),
+        noDisplay: "no".l()
+    }, opts);
+    QualityDefinition.call(this, title, opts);
+    this.yesDisplay = myOpts.yesDisplay;
+    this.noDisplay = myOpts.noDisplay;
+};
+YesNoQuality.inherits(QualityDefinition);
+YesNoQuality.prototype.format = function(character, value) {
+    if (value) return this.yesDisplay;
+    else return this.noDisplay;
+};
+
+/* Defines a group of qualities that should be displayed together,
+ * under the given optional title. These should be defined in the
+ * `undum.game.qualityGroups` parameter. */
+var QualityGroup = function(title, opts) {
+    var myOpts = $.extend({
+        priority: title,
+        extraClasses: null
+    }, opts);
+    this.title = title;
+    this.priority = myOpts.priority;
+    this.extraClasses = myOpts.extraClasses;
+};
+
+
+// -----------------------------------------------------------------------
+// Types Passed to Situations
+// -----------------------------------------------------------------------
+
+/* A system object is passed into the enter, act and exit
+ * functions of each situation. It is used to interact with the
+ * UI.
+ */
+var System = function() {
+    this.rnd = null;
+    this.time = 0;
+};
+
+/* Removes all content from the page, clearing the main content area.
+ *
+ * If an elementSelector is given, then only that selector will be
+ * cleared. Note that all content from the cleared element is removed,
+ * but the element itself remains, ready to be filled again using
+ * System.write.
+ */
+System.prototype.clearContent = function(elementSelector) {
+    var $element;
+    if (elementSelector) $element = $(elementSelector);
+    if (!$element) $element = $("#content");
+    $element.empty();
+};
+
+/* Outputs regular content to the page. The content supplied must
+ * be valid "Display Content".
+ *
+ * "Display Content" is any HTML string that begins with a HTML
+ * start tag, ends with either an end or a closed tag, and is a
+ * valid and self-contained snippet of HTML. Note that the string
+ * doesn't have to consist of only one HTML tag. You could have
+ * several paragraphs, for example, as long as the content starts
+ * with the <p> of the first paragraph, and ends with the </p> of
+ * the last. So "<p>Foo</p><img src='bar'>" is valid, but "foo<img
+ * src='bar'>" is not.
+ *
+ * The content goes to the end of the page, unless you supply the
+ * optional selector argument. If you do, the content appears
+ * after the element that matches that selector.
+ */
+System.prototype.write = function(content, elementSelector) {
+    doWrite(content, elementSelector, 'append', 'after');
+};
+
+/* Outputs the given content in a heading on the page. The content
+ * supplied must be valid "Display Content".
+ *
+ * The content goes to the end of the page, unless you supply the
+ * optional selector argument. If you do, the content appears
+ * after the element that matches that selector.
+ */
+System.prototype.writeHeading = function(headingContent, elementSelector) {
+    var heading = $("<h1>").html(headingContent);
+    doWrite(heading, elementSelector, 'append', 'after');
+};
+
+/* Outputs regular content to the page. The content supplied must
+ * be valid "Display Content".
+ *
+ * The content goes to the beginning of the page, unless you
+ * supply the optional selector argument. If you do, the content
+ * appears after the element that matches that selector.
+ */
+System.prototype.writeBefore = function(content, elementSelector) {
+    doWrite(content, elementSelector, 'prepend', 'before');
+};
+
+/* Outputs regular content to the page. The content supplied must
+ * be valid "Display Content".
+ *
+ * When a selector is not specified, this behaves identically to
+ * System.prototype.write. If you supply a selector, the content
+ * appears as a child node at the end of the content of the
+ * element that matches that selector.
+ */
+
+System.prototype.writeInto = function(content, elementSelector) {
+    doWrite(content, elementSelector, 'append', 'append');
+};
+
+/* Replaces content with the content supplied, which must be valid
+ * "Display Content".
+ *
+ * When a selector is not specified, this replaces the entire
+ * content of the page. Otherwise, it replaces the element matched
+ * with the selector. This replaces the entire element, including
+ * the matched tags, so ideally the content supplied should fit
+ * in its place in the DOM with the same kind of display element.
+ */
+
+System.prototype.replaceWith = function(content, elementSelector) {
+    doWrite(content, elementSelector, 'replaceWith', 'replaceWith');
+};
+
+/* Carries out the given situation change or action, as if it were
+ * in a link that has been clicked. This allows you to do
+ * procedural transitions. You might have an action that builds up
+ * the character's strength, and depletes their magic. When the
+ * magic is all gone, you can force a situation change by calling
+ * this method. */
+System.prototype.doLink = function(code) {
+    processLink(code);
+};
+
+/* Turns any links that target the given href into plain
+ * text. This can be used to remove action options when an action
+ * is no longer available. It is used automatically when you give
+ * a link the 'once' class. */
+System.prototype.clearLinks = function(code) {
+    $("a[href='" + code + "']").each(function(index, element) {
+        var a = $(element);
+        a.replaceWith($("<span>").addClass("ex_link").html(a.html()));
+    });
+};
+
+/* Given a list of situation ids, this outputs a standard option
+ * block with the situation choices in the given order.
+ *
+ * The contents of each choice will be a link to the situation,
+ * the text of the link will be given by the situation's
+ * outputText property. Note that the canChoose function is
+ * called, and if it returns false, then the text will appear, but
+ * the link will not be clickable.
+ *
+ * Although canChoose is honored, canView and displayOrder are
+ * not. If you need to honor these, you should either do so
+ * manually, ot else use the `getSituationIdChoices` method to
+ * return an ordered list of valid viewable situation ids.
+ */
+System.prototype.writeChoices = function(listOfIds, elementSelector) {
+    if (listOfIds.length === 0) return;
+
+    var currentSituation = getCurrentSituation();
+    var $options = $("<ul>").addClass("options");
+    for (var i = 0; i < listOfIds.length; ++i) {
+        var situationId = listOfIds[i];
+        var situation = game.situations[situationId];
+        assert(situation, "unknown_situation".l({id:situationId}));
+        if (situation === currentSituation) {
+            continue;
+        }
+
+        var optionText = situation.optionText.fcall(this, character, this,
+                                              currentSituation);
+        if (!optionText) optionText = "choice".l({number:i+1});
+        var $option = $("<li>");
+        var $a;
+        if (situation.canChoose(character, this, currentSituation)) {
+            $a = $("<a>").attr({href: situationId});
+        } else {
+            $a = $("<span>");
+        }
+        $a.html(optionText);
+        $option.html($a);
+        $options.append($option);
+    }
+    doWrite($options, elementSelector, 'append', 'after');
+};
+
+/*
+ * fcall() (by analogy with fmap) is added to the prototypes of both String and
+ * Function. When called on a Function, it's an
+ * alias for Function#call(); when called on a String, it only returns the
+ * string itself, discarding any input.
+ */
+Function.prototype.fcall = Function.prototype.call;
+String.prototype.fcall = function() { return this; }
+
+/* Returns a list of situation ids to choose from, given a set of
+ * specifications.
+ *
+ * This function is a complex and powerful way of compiling
+ * implicit situation choices. You give it a list of situation ids
+ * and situation tags (if a single id or tag is needed just that
+ * string can be given, it doesn't need to be wrapped in a
+ * list). Tags should be prefixed with a hash # to differentiate
+ * them from situation ids. The function then considers all
+ * matching situations in descending priority order, calling their
+ * canView functions and filtering out any that should not be
+ * shown, given the current state. Without additional parameters
+ * the function returns a list of the situation ids at the highest
+ * level of priority that has any valid results. So, for example,
+ * if a tag #places matches three situations, one with priority 2,
+ * and two with priority 3, and all of them can be viewed in the
+ * current context, then only the two with priority 3 will be
+ * returned. This allows you to have high-priority situations that
+ * trump any lower situations when they are valid, such as
+ * situations that force the player to go to one destination if
+ * the player is out of money, for example.
+ *
+ * If a minChoices value is given, then the function will attempt
+ * to return at least that many results. If not enough results are
+ * available at the highest priority, then lower priorities will
+ * be considered in turn, until enough situations are found. In
+ * the example above, if we had a minChoices of three, then all
+ * three situations would be returned, even though they have
+ * different priorities. If you need to return all valid
+ * situations, regardless of their priorities, set minChoices to a
+ * large number, such as `Number.MAX_VALUE`, and leave maxChoices
+ * undefined.
+ *
+ * If a maxChoices value is given, then the function will not
+ * return any more than the given number of results. If there are
+ * more than this number of results possible, then the highest
+ * priority resuls will be guaranteed to be returned, but the
+ * lowest priority group will have to fight it out for the
+ * remaining places. In this case, a random sample is chosen,
+ * taking into account the frequency of each situation. So a
+ * situation with a frequency of 100 will be chosen 100 times more
+ * often than a situation with a frequency of 1, if there is one
+ * space available. Often these frequencies have to be taken as a
+ * guideline, and the actual probabilities will only be
+ * approximate. Consider three situations with frequencies of 1,
+ * 1, 100, competing for two spaces. The 100-frequency situation
+ * will be chosen almost every time, but for the other space, one
+ * of the 1-frequency situations must be chosen. So the actual
+ * probabilities will be roughly 50%, 50%, 100%. When selecting
+ * more than one result, frequencies can only be a guide.
+ *
+ * Before this function returns its result, it sorts the
+ * situations in increasing order of their displayOrder values.
+ */
+System.prototype.getSituationIdChoices = function(listOfOrOneIdsOrTags,
+                                                  minChoices, maxChoices)
+{
+    var datum;
+    var i;
+
+    // First check if we have a single string for the id or tag.
+    if ($.type(listOfOrOneIdsOrTags) == 'string') {
+        listOfOrOneIdsOrTags = [listOfOrOneIdsOrTags];
+    }
+
+    // First we build a list of all candidate ids.
+    var allIds = {};
+    for (i = 0; i < listOfOrOneIdsOrTags.length; ++i) {
+        var tagOrId = listOfOrOneIdsOrTags[i];
+        if (tagOrId.substr(0, 1) == '#') {
+            var ids = getSituationIdsWithTag(tagOrId.substr(1));
+            for (var j = 0; j < ids.length; ++j) {
+                allIds[ids[j]] = true;
+            }
+        } else {
+            allIds[tagOrId] = true;
+        }
+    }
+
+    // Filter out anything that can't be viewed right now.
+    var currentSituation = getCurrentSituation();
+    var viewableSituationData = [];
+    for (var situationId in allIds) {
+        var situation = game.situations[situationId];
+        assert(situation, "unknown_situation".l({id:situationId}));
+
+        if (situation.canView(character, system, currentSituation)) {
+            // While we're here, get the selection data.
+            var viewableSituationDatum =
+                situation.choiceData(character, system, currentSituation);
+            viewableSituationDatum.id = situationId;
+            viewableSituationData.push(viewableSituationDatum);
+        }
+    }
+
+    // Then we sort in descending priority order.
+    viewableSituationData.sort(function(a, b) {
+        return b.priority - a.priority;
+    });
+
+    var committed = [];
+    var candidatesAtLastPriority = [];
+    var lastPriority;
+    // In descending priority order.
+    for (i = 0; i < viewableSituationData.length; ++i) {
+        datum = viewableSituationData[i];
+        if (datum.priority != lastPriority) {
+            if (lastPriority !== undefined) {
+                // We've dropped a priority group, see if we have enough
+                // situations so far, and stop if we do.
+                if (minChoices === undefined || i >= minChoices) break;
+            }
+            // Continue to acccumulate more options.
+            committed.push.apply(committed, candidatesAtLastPriority);
+            candidatesAtLastPriority = [];
+            lastPriority = datum.priority;
+        }
+        candidatesAtLastPriority.push(datum);
+    }
+
+    // So the values in committed we're committed to, because without
+    // them we wouldn't hit our minimum. But those in
+    // candidatesAtLastPriority might take us over our maximum, so
+    // figure out how many we should choose.
+    var totalChoices = committed.length + candidatesAtLastPriority.length;
+    if (maxChoices === undefined || maxChoices >= totalChoices) {
+        // We can use all the choices.
+        committed.push.apply(committed, candidatesAtLastPriority);
+    } else if (maxChoices >= committed.length) {
+        // We can only use the commited ones.
+        // NO-OP
+    } else {
+        // We have to sample the candidates, using their relative frequency.
+        var candidatesToInclude = maxChoices - committed.length;
+        for (i = 0; i < candidatesAtLastPriority.length; ++i) {
+            datum = candidatesAtLastPriority[i];
+            datum._frequencyValue = this.rnd.random() / datum.frequency;
+        }
+        candidatesToInclude.sort(function(a, b) {
+            return a._frequencyValue - b._frequencyValue;
+        });
+        var chosen = candidatesToInclude.slice(0, candidatesToInclude);
+        committed.push.apply(committed, chosen);
+    }
+
+    // Now sort in ascending display order.
+    committed.sort(function(a, b) {
+        return a.displayOrder - b.displayOrder;
+    });
+
+    // And return as a list of ids only.
+    var result = [];
+    for (i = 0; i < committed.length; ++i) {
+        result.push(committed[i].id);
+    }
+    return result;
+};
+
+/* Call this to change the character text: the text in the right
+ * toolbar before the qualities list. This text is designed to be
+ * a short description of the current state of your character. The
+ * content you give should be "Display Content" (see
+ * `System.prototype.write` for the definition).
+ */
+System.prototype.setCharacterText = function(content) {
+    var block = $("#character_text_content");
+    var oldContent = block.html();
+    var newContent = augmentLinks(content);
+    if (interactive && block.is(':visible')) {
+        block.fadeOut(250, function() {
+            block.html(newContent);
+            block.fadeIn(750);
+        });
+        showHighlight($("#character_text"));
+    } else {
+        block.html(newContent);
+    }
+};
+
+/* Call this to change the value of a character quality. Don't
+ * directly change quality values, because that will not update
+ * the UI. (You can change any data in the character's sandbox
+ * directly, however, since that isn't displayed). */
+System.prototype.setQuality = function(quality, newValue) {
+    var oldValue = character.qualities[quality];
+    character.qualities[quality] = newValue;
+    if (!interactive) return;
+
+    // Work out how to display the values.
+    var newDisplay;
+    var qualityDefinition = game.qualities[quality];
+    if (qualityDefinition) {
+        newDisplay = qualityDefinition.format(character, newValue);
+    } else {
+        // We shouldn't display qualities that have no definition.
+        return;
+    }
+
+    // Add the data block, if we need it.
+    var qualityBlock = $("#q_"+quality);
+    if (qualityBlock.length <= 0) {
+        if (newDisplay === null) return;
+        qualityBlock = addQualityBlock(quality).hide().fadeIn(500);
+    } else {
+        // Do nothing if there's nothing to do.
+        if (oldValue == newValue) return;
+
+        // Change the value.
+        if (newDisplay === null) {
+            // Remove the block, and possibly the whole group, if
+            // it is the last quality in the group.
+            var toRemove = null;
+            var groupBlock = qualityBlock.parents('.quality_group');
+            if (groupBlock.find('.quality').length <= 1) {
+                toRemove = groupBlock;
+            } else {
+                toRemove = qualityBlock;
+            }
+
+            toRemove.fadeOut(1000, function() {
+                toRemove.remove();
+            });
+        } else {
+            var valBlock = qualityBlock.find("[data-attr='value']");
+            valBlock.fadeOut(250, function() {
+                valBlock.html(newDisplay);
+                valBlock.fadeIn(750);
+            });
+        }
+    }
+    showHighlight(qualityBlock);
+};
+
+/* The character that is passed into each situation is of this
+ * form.
+ *
+ * The `qualities` data member maps the Ids of each quality to its
+ * current value. When implementing enter, act or exit functions,
+ * you should consider this to be read-only. Make all
+ * modifications through `System.prototype.setQuality`.
+ * In your `init` function, you can set these values directly.
+ *
+ * The `sandbox` data member is designed to allow your code to
+ * track any data it needs to. The only proviso is that the data
+ * structure should be serializable into JSON (this means it must
+ * only consist of primitive types [objects, arrays, numbers,
+ * booleans, strings], and it must not contain circular series of
+ * references). The data in the sandbox is not displayed in the
+ * UI, although you are free to use it to create suitable output
+ * for the player..
+ */
+var Character = function() {
+    this.qualities = {};
+    this.sandbox = {
+        inventory: []
+    };
+};
+
+/* The data structure holding the content for the game. By default
+ * this holds nothing. It is this data structure that is populated
+ * in the `.game.js` file. Each element in the structure is
+ * commented, below.
+ *
+ * This should be static data that never changes through the
+ * course of the game. It is never saved, so anything that might
+ * change should be stored in the character.
+ */
+var game = {
+
+    // Situations
+
+    /* An object mapping from the unique id of each situation, to
+     * the situation object itself. This is the heart of the game
+     * specification. */
+    situations: {},
+
+    /* The unique id of the situation to enter at the start of a
+     * new game. */
+    start: "start",
+
+    // Quality display definitions
+
+    /* An object mapping the unique id of each quality to its
+     * QualityDefinition. You don't need definitions for every
+     * quality, but only qualities in this mapping will be
+     * displayed in the character box of the UI. */
+    qualities: {},
+
+    /* Qualities can have an optional group Id. This maps those
+     * Ids to the group definitions that says how to format its
+     * qualities.
+     */
+    qualityGroups: {},
+
+
+    // Hooks
+
+    /* This function is called at the start of the game. It is
+     * normally overridden to provide initial character creation
+     * (setting initial quality values, setting the
+     * character-text. This is optional, however, as set-up
+     * processing could also be done by the first situation's
+     * enter function. If this function is given it should have
+     * the signature function(character, system).
+     */
+    init: null,
+
+    /* This function is called before entering any new
+     * situation. It is called before the corresponding situation
+     * has its `enter` method called. It can be used to implement
+     * timed triggers, but is totally optional. If this function
+     * is given it should have the signature:
+     *
+     * function(character, system, oldSituationId, newSituationId);
+     */
+    entering: null,
+
+    /* Hook for when the situation has already been carried out
+     * and printed. The signature is:
+     *
+     * function(character, system, oldSituationId, newSituationId);
+     */
+    afterEnter: null,
+
+    /* This function is called before carrying out any action in
+     * any situation. It is called before the corresponding
+     * situation has its `act` method called. If this optional
+     * function is given it should have the signature:
+     *
+     * function(character, system, situationId, actionId);
+     *
+     * If the function returns true, then it is indicating that it
+     * has consumed the action, and the action will not be passed
+     * on to the situation. Note that this is the only one of
+     * these global handlers that can consume the event.
+     */
+    beforeAction: null,
+
+    /* This function is called after carrying out any action in
+     * any situation. It is called after the corresponding
+     * situation has its `act` method called. If this optional
+     * function is given it should have the signature:
+     *
+     * function(character, system, situationId, actionId);
+     */
+    afterAction: null,
+
+    /* This function is called after leaving any situation. It is
+     * called after the corresponding situation has its `exit`
+     * method called. If this optional function is given it should
+     * have the signature:
+     *
+     * function(character, system, oldSituationId, newSituationId);
+     */
+    exit: null
+};
+
+// =======================================================================
+
+// Code below doesn't form part of the public API for UNDUM, so
+// you shouldn't find you need to use it.
+
+// -----------------------------------------------------------------------
+// Internal Data
+// -----------------------------------------------------------------------
+
+/* The global system object. */
+var system = new System();
+
+/* This is the data on the player's progress that gets saved. */
+var progress = {
+    // A random seed string, used internally to make random
+    // sequences predictable.
+    seed: null,
+    // Keeps track of the links clicked, and when.
+    sequence: [],
+    // The time when the progress was saved.
+    saveTime: null
+};
+
+/* The Id of the current situation the player is in. */
+var current = null;
+
+/* This is the current character. It should be reconstructable
+ * from the above progress data. */
+var character = null;
+
+/* Tracks whether we're in interactive mode or batch mode. */
+var interactive = true;
+
+/* The system time when the game was initialized. */
+var startTime;
+
+/* The stack of links, resulting from the last action, still be to
+ * resolved. */
+var linkStack = null;
+
+// -----------------------------------------------------------------------
+// Utility Functions
+// -----------------------------------------------------------------------
+
+var getCurrentSituation = function() {
+    if (current) {
+        return game.situations[current];
+    } else {
+        return null;
+    }
+};
+
+var parse = function(str) {
+    if (str === undefined) {
+        return str;
+    } else {
+        return parseFloat(str);
+    }
+};
+
+var parseList = function(str, canBeUndefined) {
+    if (str === undefined) {
+        if (canBeUndefined) {
+            return undefined;
+        } else {
+            return [];
+        }
+    } else {
+        return str.split(/[ ,\t]+/);
+    }
+};
+
+var parseFn = function(str) {
+    if (str === undefined) {
+        return str;
+    } else {
+        var fstr = "(function(character, system, situation) {\n" +
+            str + "\n})";
+        var fn = eval(fstr);
+        return fn;
+    }
+};
+
+/* Outputs regular content to the page. Used by write and
+ * writeBefore, the last two arguments control what jQuery methods
+ * are used to add the content.
+ */
+var doWrite = function(content, selector, addMethod, appendMethod) {
+    var output = augmentLinks(content).addClass('new');
+    var element;
+    if (selector) {
+        element = $(selector);
+    }
+    if (!element) {
+        $('#content')[addMethod](output);
+    }
+    else {
+        element[appendMethod](output);
+    }
+};
+
+/* Gets the unique id used to identify saved games. */
+var getSaveId = function() {
+    return 'undum_'+game.id+"_"+game.version;
+};
+
+/* Adds the quality blocks to the character tools. */
+var showQualities = function() {
+    $("#qualities").empty();
+    for (var qualityId in character.qualities) {
+        addQualityBlock(qualityId);
+    }
+};
+
+/* Fades in and out a highlight on the given element. */
+var showHighlight = function(domElement) {
+    var highlight = domElement.find(".highlight");
+    if (highlight.length <= 0) {
+        highlight = $('<div>').addClass('highlight');
+        domElement.append(highlight);
+    }
+    highlight.fadeIn(250);
+    setTimeout(function() {
+        highlight.fadeOut(1000);
+    }, 2000);
+};
+
+/* Finds the correct location and inserts a particular DOM element
+ * fits into an existing list of DOM elements. This is done by
+ * priority order, so all elements (existing and new) must have
+ * their data-priority attribute set. */
+var insertAtCorrectPosition = function(parent, newItem) {
+    var newPriority = newItem.attr('data-priority');
+    var children = parent.children();
+    for (var i = 0; i < children.length; i++) {
+        var child = children.eq(i);
+        if (newPriority < child.attr('data-priority')) {
+            child.before(newItem);
+            return;
+        }
+    }
+    parent.append(newItem);
+};
+
+/* Adds a new group to the correct location in the quality list. */
+var addGroupBlock = function(groupId) {
+    var groupDefinition = game.qualityGroups[groupId];
+
+    // Build the group div with appropriate heading.
+    var groupBlock = $("#ui_library #quality_group").clone();
+    groupBlock.attr("id", "g_"+groupId);
+    groupBlock.attr("data-priority", groupDefinition.priority);
+
+    var titleElement = groupBlock.find("[data-attr='title']");
+    if (groupDefinition.title) {
+        titleElement.html(groupDefinition.title);
+    } else {
+        titleElement.remove();
+    }
+
+    if (groupDefinition.extraClasses) {
+        for (var i = 0; i < groupDefinition.extraClasses.length; i++) {
+            groupBlock.addClass(groupDefinition.extraClasses[i]);
+        }
+    }
+
+    // Add the block to the correct place.
+    var qualities = $("#qualities");
+    insertAtCorrectPosition(qualities, groupBlock);
+    return groupBlock;
+};
+
+/* Adds a new quality to the correct location in the quality list. */
+var addQualityBlock = function(qualityId) {
+    // Make sure we want to display this quality.
+    var qualityDefinition = game.qualities[qualityId];
+    if (!qualityDefinition) {
+      throw new Error("Can't display a quality that hasn't been defined: "+
+                      qualityId);
+    }
+
+    // Work out how the value should be displayed.
+    var name = qualityDefinition.title;
+    var val = qualityDefinition.format(
+        character, character.qualities[qualityId]
+    );
+    if (val === null) return null;
+
+    // Create the quality output.
+    var qualityBlock = $("#ui_library #quality").clone();
+    qualityBlock.attr("id", "q_"+qualityId);
+    qualityBlock.attr("data-priority", qualityDefinition.priority);
+    qualityBlock.find("[data-attr='name']").html(name);
+    qualityBlock.find("[data-attr='value']").html(val);
+    if (qualityDefinition.extraClasses) {
+        for (var i = 0; i < qualityDefinition.extraClasses.length; i++) {
+            qualityBlock.addClass(qualityDefinition.extraClasses[i]);
+        }
+    }
+
+    // Find or create the group block.
+    var groupBlock;
+    var groupId = qualityDefinition.group;
+    if (groupId) {
+        var group = game.qualityGroups[groupId];
+        assert(group, "no_group_definition".l({id: groupId}));
+        groupBlock = $("#g_"+groupId);
+        if (groupBlock.length <= 0) {
+            groupBlock = addGroupBlock(groupId);
+        }
+    }
+
+    // Position it correctly.
+    var groupQualityList = groupBlock.find(".qualities_in_group");
+    insertAtCorrectPosition(groupQualityList, qualityBlock);
+    return qualityBlock;
+};
+
+/* We use a CSS class, .new, to track which elements have just been added
+ * to the story roll. That allows authors to define special styling for
+ * newly-added elements (such as a fade-in effect), but we also use it to
+ * intelligently figure out where to place the scroll point at the top
+ * of each one. */
+
+/* Clears .new from every object with that class, in preparation for adding
+ * new ones. */
+var startOutputTransaction = function() {
+    $('.new').removeClass('new');
+};
+
+/* Scrolls the top of the screen to the specified point */
+var scrollTopTo = function (value) {
+  $('html,body').animate({scrollTop: value}, 500);
+};
+
+/* Scrolls the bottom of the screen to the specified point */
+var scrollBottomTo = function (value) {
+  scrollTopTo(value - $(window).height());
+};
+
+/* Scrolls all the way to the bottom of the screen */
+var scrollToBottom = function () {
+    scrollTopTo($('html').height() - $(window).height());
+};
+
+/* At last, we scroll the view so that .new objects are in view. */
+var endOutputTransaction = function () {
+    if (!interactive) return; // We're loading a save; do nothing at all.
+    var
+        $new = $('.new'),
+        viewHeight = $(window).height(),
+        newTop, newBottom, newHeight, optionHeight = 0;
+
+    if ($new.length === 0) return; /* Somehow, there's nothing new. */
+
+    newTop = $new.first().offset().top,
+    newBottom = $new.last().offset().top + $new.last().height(),
+    newHeight = newBottom - newTop;
+
+    /* We take the options list into account, because we don't want the new
+     * content to scroll offscreen when the list disappears. So we calculate
+     * scroll points as though the option list was already gone. */
+    if ($('.options').not('.new').length)
+        optionHeight = $('.options').not('new').height();
+
+    if (newHeight > (viewHeight - optionHeight - 50)) {
+        /* The new content is too long for our viewport, so we scroll the
+         * top of the new content to roughly 75% of the way up the viewport's
+         * height. */
+        scrollTopTo(newTop-(viewHeight*0.25) - optionHeight);
+    }
+    else {
+
+        if (newTop > $('body').height() - viewHeight) {
+            /* If we scroll right to the bottom, the new content will be in
+             * view. So we do that.*/
+            scrollToBottom();
+        }
+        else {
+            /* Our new content is too far up the page. So we scroll to place
+             * it somewhere near the bottom. */
+            scrollBottomTo(newBottom+100 - optionHeight);
+        }
+    }
+};
+
+/* This gets called when a link needs to be followed, regardless
+ * of whether it was user action that initiated it. */
+var linkRe = /^([a-z0-9_-]+|\.)(\/([0-9a-z_-]+))?$/;
+var processLink = function(code) {
+    // Check if we should do this now, or if processing is already
+    // underway.
+    if (linkStack !== null) {
+        linkStack.push(code);
+        return;
+    }
+
+    // Track where we're about to add new content.
+    startOutputTransaction();
+
+    // We're processing, so make the stack available.
+    linkStack = [];
+
+    // Handle each link in turn.
+    processOneLink(code);
+    while (linkStack.length > 0) {
+        code = linkStack.shift();
+        processOneLink(code);
+    }
+
+    // We're done, so remove the stack to prevent future pushes.
+    linkStack = null;
+
+    // Scroll to the top of the new content.
+    endOutputTransaction();
+
+    // We're able to save, if we weren't already.
+    $("#save").removeClass('disabled');
+};
+
+/* This gets called to actually do the work of processing a code.
+ * When one doLink is called (or a link is clicked), this may set call
+ * code that further calls doLink, and so on. This method processes
+ * each one, and processLink manages this.
+ */
+var processOneLink = function(code) {
+    var match = code.match(linkRe);
+    assert(match, "link_not_valid".l({link:code}));
+
+    var situation = match[1];
+    var action = match[3];
+
+    // Change the situation
+    if (situation !== '.') {
+        if (situation !== current) {
+            doTransitionTo(situation);
+        }
+    } else {
+        // We should have an action if we have no situation change.
+        assert(action, "link_no_action".l());
+    }
+
+    // Carry out the action
+    if (action) {
+        situation = getCurrentSituation();
+        if (situation) {
+            if (game.beforeAction) {
+                // Try the global act handler, and see if we need
+                // to notify the situation.
+                var consumed = game.beforeAction(
+                    character, system, current, action
+                );
+                if (consumed !== true) {
+                    situation.act(character, system, action);
+                }
+            } else {
+                // We have no global act handler, always notify
+                // the situation.
+                situation.act(character, system, action);
+            }
+            if (game.afterAction) {
+                game.afterAction(character, system, current, action);
+            }
+        }
+    }
+};
+
+/* This gets called when the user clicks a link to carry out an
+ * action. */
+var processClick = function(code) {
+    var now = (new Date()).getTime() * 0.001;
+    system.time = now - startTime;
+    progress.sequence.push({link:code, when:system.time});
+    processLink(code);
+};
+
+/* Transitions between situations. */
+var doTransitionTo = function(newSituationId) {
+    var oldSituationId = current;
+    var oldSituation = getCurrentSituation();
+    var newSituation = game.situations[newSituationId];
+
+    assert(newSituation, "unknown_situation".l({id:newSituationId}));
+
+    // We might not have an old situation if this is the start of
+    // the game.
+    if (oldSituation) {
+        if (game.exit) {
+            game.exit(character, system, oldSituationId, newSituationId);
+        }
+
+        //  Remove links and transient sections.
+        $('#content a').each(function(index, element) {
+            var a = $(element);
+            if (a.hasClass('sticky') || a.attr("href").match(/[?&]sticky[=&]?/))
+                return;
+            a.replaceWith($("<span>").addClass("ex_link").html(a.html()));
+        });
+        var contentToHide = $('#content .transient, #content ul.options');
+        contentToHide.add($("#content a").filter(function(){
+            return $(this).attr("href").match(/[?&]transient[=&]?/);
+        }));
+        if (interactive) {
+            contentToHide.
+                animate({opacity: 0}, 350).
+                slideUp(500, function() {
+                  $(this).remove();
+                });
+        } else {
+            contentToHide.remove();
+        }
+    }
+
+    // Move the character.
+    current = newSituationId;
+
+    // Notify the incoming situation.
+    if (game.enter) {
+        game.enter(character, system, oldSituationId, newSituationId);
+    }
+    newSituation.entering(character, system, oldSituationId);
+
+    // additional hook for when the situation text has already been printed
+    if (game.afterEnter) {
+        game.afterEnter(character, system, oldSituationId, newSituationId);
+    }
+};
+
+/* Returns HTML from the given content with the non-raw links
+ * wired up. */
+var augmentLinks = function(content) {
+    var output = $(content);
+
+    // Wire up the links for regular <a> tags.
+    output.find("a").each(function(index, element) {
+        var a = $(element);
+        var href = a.attr('href');
+        if (!a.hasClass("raw")|| href.match(/[?&]raw[=&]?/)) {
+            if (href.match(linkRe)) {
+                a.click(function(event) {
+                    event.preventDefault();
+
+                    // If we're a once-click, remove all matching
+                    // links.
+                    if (a.hasClass("once") || href.match(/[?&]once[=&]?/)) {
+                        system.clearLinks(href);
+                    }
+
+                    processClick(href);
+                    return false;
+                });
+            } else {
+                a.addClass("raw");
+            }
+        }
+    });
+
+    return output;
+};
+
+/* Erases the character in local storage. This is permanent!
+/* To restart the game afterwards, we perform a simple page refresh.
+/* This guarantees authors don't have to care about "tainting" the
+/* game state across save/erase cycles, meaning that character.sandbox
+/* no longer has to be the end-all be-all repository of game state. */
+var doErase = function(force) {
+    var saveId = getSaveId();
+    if (localStorage.getItem(saveId)) {
+        if (force || confirm("erase_message".l())) {
+            localStorage.removeItem(saveId);
+            window.location.reload();
+        }
+    }
+};
+
+/* Find and return a list of ids for all situations with the given tag. */
+var getSituationIdsWithTag = function(tag) {
+    var result = [];
+    for (var situationId in game.situations) {
+        var situation = game.situations[situationId];
+
+        for (var i = 0; i < situation.tags.length; ++i) {
+            if (situation.tags[i] == tag) {
+                result.push(situationId);
+                break;
+            }
+        }
+    }
+    return result;
+};
+
+/* Set up the screen from scratch to reflect the current game
+ * state. */
+var initGameDisplay = function() {
+    // Transition into the first situation,
+    $("#content").empty();
+
+    var situation = getCurrentSituation();
+    assert(situation, "no_current_situation".l());
+
+    showQualities();
+};
+
+/* Clear the current game output and start again. */
+var startGame = function() {
+    progress.seed = new Date().toString();
+
+    character = new Character();
+    system.rnd = new Random(progress.seed);
+    progress.sequence = [{link:game.start, when:0}];
+
+    // Empty the display
+    $("#content").empty();
+
+    // Start the game
+    startTime = new Date().getTime() * 0.001;
+    system.time = 0;
+    if (game.init) game.init(character, system);
+    showQualities();
+
+    // Do the first state.
+    doTransitionTo(game.start);
+};
+
+/* Saves the character to local storage. */
+var saveGame = function() {
+    // Store when we're saving the game, to avoid exploits where a
+    // player loads their file to gain extra time.
+    var now = (new Date()).getTime() * 0.001;
+    progress.saveTime = now - startTime;
+
+    // Save the game.
+    localStorage.setItem(getSaveId(), JSON.stringify(progress));
+
+    // Switch the button highlights.
+    $("#erase").removeClass('disabled');
+    $("#load").removeClass('disabled');
+    $("#save").addClass('disabled');
+};
+
+/* Loads the game from the given data */
+var loadGame = function(characterData) {
+    progress = characterData;
+
+    character = new Character();
+    system.rnd = new Random(progress.seed);
+
+    // Empty the display
+    $("#content").empty();
+    $("#intro").empty();
+    showQualities();
+
+    // Now play through the actions so far:
+    if (game.init) game.init(character, system);
+
+    // Run through all the player's history.
+    interactive = false;
+    for (var i = 0; i < progress.sequence.length; i++) {
+        var step = progress.sequence[i];
+        // The action must be done at the recorded time.
+        system.time = step.when;
+        processLink(step.link);
+    }
+    interactive = true;
+
+    // Reverse engineer the start time.
+    var now = new Date().getTime() * 0.001;
+    startTime = now - progress.saveTime;
+
+    // Because we did the run through non-interactively, now we
+    // need to update the UI.
+    showQualities();
+};
+
+// -----------------------------------------------------------------------
+// Setup
+// -----------------------------------------------------------------------
+
+var begin = function () {
+/* Set up the game when everything is loaded. */
+
+    // Handle storage.
+    if (hasLocalStorage()) {
+        var erase = $("#erase").click(function() {
+            doErase();
+        });
+        var save = $("#save").click(saveGame);
+
+        var storedCharacter = localStorage.getItem(getSaveId());
+        if (storedCharacter) {
+            try {
+                loadGame(JSON.parse(storedCharacter));
+                save.addClass('disabled')
+                erase.removeClass('disabled')
+            } catch(err) {
+                doErase(true);
+            }
+        } else {
+            startGame();
+        }
+    } else {
+        startGame();
+    }
+    // Any point that an option list appears, its options are its
+    // first links.
+    $("body").on('click', "ul.options li, #menu li", function(event) {
+        // Make option clicks pass through to their first link.
+        var link = $("a", this);
+        if (link.length > 0) {
+            $(link.get(0)).click();
+        }
+    });
+};
+
+/* Export our API. */
+module.exports = {
+    Situation: Situation,
+
+    QualityDefinition: QualityDefinition,
+    IntegerQuality: IntegerQuality,
+    NonZeroIntegerQuality: NonZeroIntegerQuality,
+    NumericQuality: NumericQuality,
+    WordScaleQuality: WordScaleQuality,
+    FudgeAdjectivesQuality: FudgeAdjectivesQuality,
+    OnOffQuality: OnOffQuality,
+    YesNoQuality: YesNoQuality,
+
+    QualityGroup: QualityGroup,
+
+    game: game,
+    begin: begin,
+
+    language: languages,
+
+    processClick: processClick, // you need this if you want to have some additional link blocks
+
+    isInteractive: function() { return interactive; },
+};
diff --git a/package.json b/package.json
index a3a1a38..01258b2 100644
--- a/package.json
+++ b/package.json
@@ -1,9 +1,5 @@
 {
   "dependencies": {
-    "undum": "git://github.com/oreolek/undum-commonjs#commonjs",
-    "raconteur": "git://github.com/sequitur/raconteur.git#stable",
-    "jquery": "^2.1.3",
-    "markdown-it": "^4.1.0"
   },
   "private": true,
   "devDependencies": {
@@ -13,16 +9,15 @@
     "browserify-shim": "^3.8.8",
     "coffeeify": "^1.0.0",
     "gulp": "^3.8.11",
-    "gulp-gzip": "^1.1.0",
-    "gulp-less": "^3.0.2",
-    "gulp-minify-css": "^1.0.0",
     "gulp-uglify": "^1.2.0",
+    "gulp-coffee": "^2.3.1",
     "gulp-util": "^3.0.4",
     "gulp-zip": "^3.0.2",
+    "gulp-concat": "^2.6.0",
+    "gulp-sass": "^2.1.1",
     "lodash": "^3.6.0",
     "vinyl-buffer": "^1.0.0",
     "vinyl-source-stream": "^1.1.0",
-    "watchify": "^3.1.0",
-    "shortid": "^2.2.4"
+    "watchify": "^3.1.0"
   }
 }
diff --git a/sass/main.scss b/sass/main.scss
index bee3e4b..fed65b9 100644
--- a/sass/main.scss
+++ b/sass/main.scss
@@ -51,13 +51,6 @@ body {
       margin-bottom: 1em;
     }
   }
-  .click_message {
-    display: none;
-    font-size: 0.9em;
-    font-style: italic;
-    text-align: center;
-    color: #987;
-  }
   .noscript_message {
     left: 0;
     right: 0;
@@ -70,24 +63,8 @@ body {
   }
 }
 #tools_wrapper {
-  display: none; // Shown by Javascript
-  /*
-  .tools {
-    background: $secondary-bg;
-    border-radius: 5px;
-    padding: 0.5em;
-    @include col(4, 5);
-    @media (min-width: breakpoint-min(sm)) {
-      @include make-col-offset(1);
-    }
-  }
-  */
   .ways {
-    h2 {
-      display: none; // Shown by Javascript
-    }
     padding: 0.5em;
-  //  @include col(4, 5);
     @include col(9, 10);
     @media (min-width: breakpoint-min(sm)) {
       @include make-col-offset(1);
@@ -103,11 +80,10 @@ body {
   }
 }
 #content_wrapper {
-  display: none; // Shown by Javascript
   background: $text_background;
   border-radius: 5px;
 }
-#content {
+.content {
   @include col(10, 12);
   @media (min-width: breakpoint-min(sm)) {
     @include make-col-offset(1);
@@ -163,7 +139,6 @@ body {
   margin-top: 1em;
   color: darken($body-color, 10%);
   font-size: smaller;
-  display: none; // Shown by Javascript
   #footleft {
     @include make-col();
     @media (min-width: breakpoint-min(sm)) {