kni 4.0.2 → 5.0.0

package/entry.js

@@ -0,0 +1,88 @@
+import Engine from './engine.js';
+import Document from './document.js';
+import story from 'virtual:story';
+
+const handler = {
+  storageKey: 'kni',
+
+  shouldLog: true,
+  log(...args) {
+    if (this.shouldLog) {
+      console.log(...args);
+    }
+  },
+
+  load() {
+    if (window.location.hash.length > 1) {
+      const json = atob(window.location.hash.slice(1));
+      return JSON.parse(json);
+    }
+    const json = window.localStorage.getItem(this.storageKey);
+    if (json) {
+      const state = JSON.parse(json);
+      window.history.replaceState(state, '', `#${btoa(json)}`);
+      return state;
+    }
+    return null;
+  },
+  waypoint(waypoint) {
+    const json = JSON.stringify(waypoint);
+    window.history.pushState(waypoint, '', `#${btoa(json)}`);
+    localStorage.setItem(this.storageKey, json);
+  },
+  goto(label) {
+    this.log(label);
+  },
+  answer(text) {
+    this.log('>', text);
+  },
+};
+
+const meterFaultButton = document.createElement('a');
+meterFaultButton.innerText = 'Continue…';
+meterFaultButton.addEventListener('click', () => {
+  engine.clearMeterFault();
+});
+
+const doc = new Document(document.body, {
+  meterFaultButton,
+  pageTurnBehavior: 'fade',
+});
+
+const engine = new Engine({
+  story: story,
+  render: doc,
+  dialog: doc,
+  handler,
+});
+
+window.onpopstate = event => {
+  handler.log('>', 'back');
+  engine.resume(event.state);
+};
+
+window.onkeypress = event => {
+  const code = event.code;
+  const match = /^Digit(\d+)$/.exec(code);
+  if (match) {
+    engine.answer(match[1]);
+  } else if (code === 'KeyR') {
+    engine.reset();
+  }
+};
+
+const reset = document.querySelector('.reset');
+if (reset) {
+  reset.onclick = () => {
+    engine.reset();
+  };
+}
+
+doc.clear();
+
+try {
+  engine.resume(handler.load());
+} catch (error) {
+  console.error('unable to load prior state, restarting', error);
+  engine.resume(null);
+}

package/evaluate.js

@@ -1,249 +1,242 @@
-'use strict';
-
-module.exports = evaluate;
-
-function evaluate(scope, randomer, args) {
-    var name = args[0];
-    if (unary[name] && args.length === 2) {
-        return unary[name](
-            evaluate(scope, randomer, args[1]),
-            scope,
-            randomer
-        );
-    } else if (binary[name] && args.length === 3) {
-        return binary[name](
-            evaluate(scope, randomer, args[1]),
-            evaluate(scope, randomer, args[2]),
-            scope,
-            randomer
-        );
-    } else if (name === 'val') {
-        return args[1];
-    } else if (name === 'get') {
-        return scope.get(args[1]);
-    // istanbul ignore else
-    } else if (name === 'var') {
-        return scope.get(nominate(scope, randomer, args));
-    } else if (name === 'call') {
-        var name = args[1][1];
-        var f = functions[name];
-        if (!f) {
-            // TODO thread line number for containing instruction
-            throw new Error('No function named ' + name);
-        }
-        var values = [];
-        for (var i = 2; i < args.length; i++) {
-            values.push(evaluate(scope, randomer, args[i]));
-        }
-        return f.apply(null, values);
-    } else {
-        throw new Error('Unexpected operator ' + JSON.stringify(args));
+const evaluate = (scope, randomer, args) => {
+  const name = args[0];
+  if (unary[name] && args.length === 2) {
+    return unary[name](evaluate(scope, randomer, args[1]), scope, randomer);
+  } else if (binary[name] && args.length === 3) {
+    return binary[name](
+      evaluate(scope, randomer, args[1]),
+      evaluate(scope, randomer, args[2]),
+      scope,
+      randomer
+    );
+  } else if (name === 'val') {
+    return args[1];
+  } else if (name === 'get') {
+    return scope.get(args[1]);
+  } else if (name === 'var') {
+    return scope.get(nominate(scope, randomer, args));
+  } else if (name === 'call') {
+    const func = args[1][1];
+    const f = functions[func];
+    if (!f) {
+      // TODO thread line number for containing instruction
+      throw new Error(`No function named ${func}`);
+    }
+    const values = [];
+    for (let i = 2; i < args.length; i++) {
+      values.push(evaluate(scope, randomer, args[i]));
     }
-}
+    return f.apply(null, values);
+  } else {
+    throw new Error(`Unexpected operator ${JSON.stringify(args)}`);
+  }
+};
 
+const nominate = (scope, randomer, args) => {
+  if (args[0] === 'get') {
+    return args[1];
+  }
+  const literals = args[1];
+  const variables = args[2];
+  let name = '';
+  let i;
+  for (i = 0; i < variables.length; i++) {
+    name += literals[i] + evaluate(scope, randomer, variables[i]);
+  }
+  name += literals[i];
+  return name;
+};
 evaluate.nominate = nominate;
-function nominate(scope, randomer, args) {
-    if (args[0] === 'get') {
-        return args[1];
+
+const functions = {
+  abs: Math.abs,
+  acos: Math.acos,
+  asin: Math.asin,
+  atan2: Math.atan2,
+  atan: Math.atan,
+  exp: Math.exp,
+  log: Math.log,
+  max: Math.max,
+  min: Math.min,
+  pow: Math.pow,
+  sin: Math.sin,
+  tan: Math.tan,
+
+  floor: Math.floor,
+  ceil: Math.ceil,
+  round: Math.round,
+
+  sign: x => {
+    if (x < 0) {
+      return -1;
     }
-    var literals = args[1];
-    var variables = args[2];
-    var name = '';
-    for (var i = 0; i < variables.length; i++) {
-        name += literals[i] + evaluate(scope, randomer, variables[i]);
+    if (x > 0) {
+      return 1;
     }
-    name += literals[i];
-    return name;
-}
-
-var functions = {
-    abs: Math.abs,
-    acos: Math.acos,
-    asin: Math.asin,
-    atan2: Math.atan2,
-    atan: Math.atan,
-    exp: Math.exp,
-    log: Math.log,
-    max: Math.max,
-    min: Math.min,
-    pow: Math.pow,
-    sin: Math.sin,
-    tan: Math.tan,
-
-    floor: Math.floor,
-    ceil: Math.floor,
-    round: Math.floor,
-
-    sign: function (x) {
-        if (x < 0) {
-            return -1;
-        }
-        if (x > 0) {
-            return 1;
-        }
-        return 0;
-    },
-
-    mean: function () {
-        var mean = 0;
-        for (var i = 0; i < arguments.length; i++) {
-            mean += arguments[i];
-        }
-        return mean / i;
-    },
-
-    root: function root(x, y) {
-        if (y === 2 || y == null) {
-            return Math.sqrt(x);
-        }
-        return Math.pow(x, 1 / y);
-    },
-
-    distance: function distance(x1, y1, x2, y2) {
-        return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
-    },
-
-    manhattan: function distance(x1, y1, x2, y2) {
-        return Math.abs(x2 - x1, 2) + Math.abs(y2 - y1);
-    },
-
-    // TODO parameterize these functions in terms of the expected turns to
-    // go from 25% to 75% of capacity, to adjust the rate. This will maybe
-    // almost make them understandable.
-    //
-    // sigmoid: function (steps, cap) {
-    //     if (steps === -Infinity) {
-    //         return 0;
-    //     } else if (steps === Infinity) {
-    //         return cap;
-    //     } else {
-    //         return cap / (1 + Math.pow(Math.E, -steps));
-    //     }
-    // },
-
-    // diomgis: function (pop, cap) {
-    //     if (pop <= 0) {
-    //         return -Infinity;
-    //     }
-    //     var ratio = cap / pop - 1;
-    //     if (ratio === 0) {
-    //         return Infinity;
-    //     }
-    //     return -Math.log(ratio, Math.E);
-    // },
+    return 0;
+  },
+
+  mean: function () {
+    let mean = 0;
+    let i;
+    for (i = 0; i < arguments.length; i++) {
+      mean += arguments[i];
+    }
+    return mean / i;
+  },
 
+  root: (x, y) => {
+    if (y === 2 || y == null) {
+      return Math.sqrt(x);
+    }
+    return Math.pow(x, 1 / y);
+  },
+
+  distance: (x1, y1, x2, y2) => {
+    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+  },
+
+  manhattan: (x1, y1, x2, y2) => {
+    return Math.abs(x2 - x1) + Math.abs(y2 - y1);
+  },
+
+  // TODO parameterize these functions in terms of the expected turns to
+  // go from 25% to 75% of capacity, to adjust the rate. This will maybe
+  // almost make them understandable.
+  //
+  // sigmoid: (steps, cap) => {
+  //     if (steps === -Infinity) {
+  //         return 0;
+  //     } else if (steps === Infinity) {
+  //         return cap;
+  //     } else {
+  //         return cap / (1 + Math.pow(Math.E, -steps));
+  //     }
+  // },
+
+  // diomgis: (pop, cap) => {
+  //     if (pop <= 0) {
+  //         return -Infinity;
+  //     }
+  //     const ratio = cap / pop - 1;
+  //     if (ratio === 0) {
+  //         return Infinity;
+  //     }
+  //     return -Math.log(ratio, Math.E);
+  // },
 };
 
-var binary = {
-    '+': function (x, y) {
-        return x + y;
-    },
-    '-': function (x, y) {
-        return x - y;
-    },
-    '*': function (x, y) {
-        return x * y;
-    },
-    '/': function (x, y) {
-        return (x / y) >> 0;
-    },
-    '%': function (x, y) {
-        return ((x % y) + y) % y;
-    },
-    '**': function (x, y) {
-        return Math.pow(x, y);
-    },
-    'or': function (x, y) {
-        return x || y ? 1 : 0;
-    },
-    'and': function (x, y) {
-        return x && y ? 1 : 0;
-    },
-    '>=': function (x, y) {
-        return x >= y ? 1 : 0;
-    },
-    '>': function (x, y) {
-        return x > y ? 1 : 0;
-    },
-    '<=': function (x, y) {
-        return x <= y ? 1 : 0;
-    },
-    '<': function (x, y) {
-        return x < y ? 1 : 0;
-    },
-    '==': function (x, y) {
-        return x === y ? 1 : 0;
-    },
-    '<>': function (x, y) {
-        return x != y ? 1 : 0;
-    },
-    '#': function (x, y) {
-        return hilbert(x, y);
-    },
-    '~': function (x, y, scope, randomer) {
-        var r = 0;
-        for (var i = 0; i < x; i++) {
-            r += randomer.random() * y;
-        }
-        return Math.floor(r);
+const binary = {
+  '+': (x, y) => {
+    return x + y;
+  },
+  '-': (x, y) => {
+    return x - y;
+  },
+  '*': (x, y) => {
+    return x * y;
+  },
+  '/': (x, y) => {
+    return (x / y) >> 0;
+  },
+  '%': (x, y) => {
+    return ((x % y) + y) % y;
+  },
+  '**': (x, y) => {
+    return Math.pow(x, y);
+  },
+  or: (x, y) => {
+    return x || y ? 1 : 0;
+  },
+  and: (x, y) => {
+    return x && y ? 1 : 0;
+  },
+  '>=': (x, y) => {
+    return x >= y ? 1 : 0;
+  },
+  '>': (x, y) => {
+    return x > y ? 1 : 0;
+  },
+  '<=': (x, y) => {
+    return x <= y ? 1 : 0;
+  },
+  '<': (x, y) => {
+    return x < y ? 1 : 0;
+  },
+  '==': (x, y) => {
+    return x === y ? 1 : 0;
+  },
+  '<>': (x, y) => {
+    return x != y ? 1 : 0;
+  },
+  '#': (x, y) => {
+    return hilbert(x, y);
+  },
+  '~': (x, y, _scope, randomer) => {
+    let r = 0;
+    for (let i = 0; i < x; i++) {
+      r += randomer.random() * y;
     }
+    return Math.floor(r);
+  },
 };
 
-// istanbul ignore next
-var unary = {
-    'not': function (x) {
-        return x ? 0 : 1;
-    },
-    '-': function (x) {
-        return -x;
-    },
-    '~': function (x, scope, randomer) {
-        return Math.floor(randomer.random() * x);
-    },
-    '#': function (x) {
-        return hash(x);
-    }
+const unary = {
+  not: x => {
+    return x ? 0 : 1;
+  },
+  '-': x => {
+    return -x;
+  },
+  '~': (x, _scope, randomer) => {
+    return Math.floor(randomer.random() * x);
+  },
+  '#': x => {
+    return hash(x);
+  },
 };
 
 // Robert Jenkins's 32 bit hash function
 // https://gist.github.com/badboy/6267743
+const hash = a => {
+  a = a + 0x7ed55d16 + (a << 12);
+  a = a ^ 0xc761c23c ^ (a >>> 19);
+  a = a + 0x165667b1 + (a << 5);
+  a = (a + 0xd3a2646c) ^ (a << 9);
+  a = a + 0xfd7046c5 + (a << 3);
+  a = a ^ 0xb55a4f09 ^ (a >>> 16);
+  return a;
+};
 evaluate.hash = hash;
-function hash(a) {
-    a = (a+0x7ed55d16) + (a<<12);
-    a = (a^0xc761c23c) ^ (a>>>19);
-    a = (a+0x165667b1) + (a<<5);
-    a = (a+0xd3a2646c) ^ (a<<9);
-    a = (a+0xfd7046c5) + (a<<3);
-    a = (a^0xb55a4f09) ^ (a>>>16);
-    return a;
-}
 
 // hilbert in range from 0 to 2^32
 // x and y in range from 0 to 2^16
 // each dimension has origin at 2^15
-var dimensionWidth = (-1 >>> 16) + 1;
-var halfDimensionWidth = dimensionWidth / 2;
-function hilbert(x, y) {
-    x += halfDimensionWidth;
-    y += halfDimensionWidth;
-    var rx = 0;
-    var ry = y;
-    var scalar = 0;
-    for (var scale = dimensionWidth; scale > 0; scale /= 2) {
-        rx = x & scale;
-        ry = y & scale;
-        scalar += scale * ((3 * rx) ^ ry);
-        // rotate
-        if (!ry) {
-            if (rx) {
-                x = scale - 1 - x;
-                y = scale - 1 - y;
-            }
-            // transpose
-            var t = x;
-            x = y;
-            y = t;
-        }
+const dimensionWidth = (-1 >>> 16) + 1;
+const halfDimensionWidth = dimensionWidth / 2;
+const hilbert = (x, y) => {
+  x += halfDimensionWidth;
+  y += halfDimensionWidth;
+  let rx = 0;
+  let ry = y;
+  let scalar = 0;
+  for (let scale = dimensionWidth; scale > 0; scale /= 2) {
+    rx = x & scale;
+    ry = y & scale;
+    scalar += scale * ((3 * rx) ^ ry);
+    // rotate
+    if (!ry) {
+      if (rx) {
+        x = scale - 1 - x;
+        y = scale - 1 - y;
+      }
+      // transpose
+      const t = x;
+      x = y;
+      y = t;
     }
-    return scalar;
-}
+  }
+  return scalar;
+};
+
+export default evaluate;