Remove symbolic links to outer folders

Author: CodeKommissar

docs/code

@@ -0,0 +1,128 @@
+// test: no
+
+(function() {
+  "use strict"
+
+  let active = null
+
+  const places = {
+    "Alice's House": {x: 279, y: 100},
+    "Bob's House": {x: 295, y: 203},
+    "Cabin": {x: 372, y: 67},
+    "Daria's House": {x: 183, y: 285},
+    "Ernie's House": {x: 50, y: 283},
+    "Farm": {x: 36, y: 118},
+    "Grete's House": {x: 35, y: 187},
+    "Marketplace": {x: 162, y: 110},
+    "Post Office": {x: 205, y: 57},
+    "Shop": {x: 137, y: 212},
+    "Town Hall": {x: 202, y: 213}
+  }
+  const placeKeys = Object.keys(places)
+
+  const speed = 2
+
+  class Animation {
+    constructor(worldState, robot, robotState) {
+      this.worldState = worldState
+      this.robot = robot
+      this.robotState = robotState
+      this.turn = 0
+
+      let outer = (window.__sandbox ? window.__sandbox.output.div : document.body), doc = outer.ownerDocument
+      this.node = outer.appendChild(doc.createElement("div"))
+      this.node.style.cssText = "position: relative; line-height: 0.1; margin-left: 10px"
+      this.map = this.node.appendChild(doc.createElement("img"))
+      this.map.src = "img/village2x.png"
+      this.map.style.cssText = "vertical-align: -8px"
+      this.robotElt = this.node.appendChild(doc.createElement("div"))
+      this.robotElt.style.cssText = `position: absolute; transition: left ${0.8 / speed}s, top ${0.8 / speed}s;`
+      let robotPic = this.robotElt.appendChild(doc.createElement("img"))
+      robotPic.src = "img/robot_moving2x.gif"
+      this.parcels = []
+
+      this.text = this.node.appendChild(doc.createElement("span"))
+      this.button = this.node.appendChild(doc.createElement("button"))
+      this.button.style.cssText = "color: white; background: #28b; border: none; border-radius: 2px; padding: 2px 5px; line-height: 1.1; font-family: sans-serif; font-size: 80%"
+      this.button.textContent = "Stop"
+
+      this.button.addEventListener("click", () => this.clicked())
+      this.schedule()
+
+      this.updateView()
+      this.updateParcels()
+
+      this.robotElt.addEventListener("transitionend", () => this.updateParcels())
+    }
+
+
+    updateView() {
+      let pos = places[this.worldState.place]
+      this.robotElt.style.top = (pos.y - 38) + "px"
+      this.robotElt.style.left = (pos.x - 16) + "px"
+
+      this.text.textContent = ` Turn ${this.turn} `
+    }
+
+    updateParcels() {
+      while (this.parcels.length) this.parcels.pop().remove()
+      let heights = {}
+      for (let {place, address} of this.worldState.parcels) {
+        let height = heights[place] || (heights[place] = 0)
+        heights[place] += 14
+        let node = document.createElement("div")
+        let offset = placeKeys.indexOf(address) * 16
+        node.style.cssText = "position: absolute; height: 16px; width: 16px; background-image: url(img/parcel2x.png); background-position: 0 -" + offset + "px";
+        if (place == this.worldState.place) {
+          node.style.left = "25px"
+          node.style.bottom = (20 + height) + "px"
+          this.robotElt.appendChild(node)
+        } else {
+          let pos = places[place]
+          node.style.left = (pos.x - 5) + "px"
+          node.style.top = (pos.y - 10 - height) + "px"
+          this.node.appendChild(node)
+        }
+        this.parcels.push(node)
+      }
+    }
+
+    tick() {
+      let {direction, memory} = this.robot(this.worldState, this.robotState)
+      this.worldState = this.worldState.move(direction)
+      this.robotState = memory
+      this.turn++
+      this.updateView()
+      if (this.worldState.parcels.length == 0) {
+        this.button.remove()
+        this.text.textContent = ` Finished after ${this.turn} turns`
+        this.robotElt.firstChild.src = "img/robot_idle2x.png"
+      } else {
+        this.schedule()
+      }
+    }
+
+    schedule() {
+      this.timeout = setTimeout(() => this.tick(), 1000 / speed)
+    }
+
+    clicked() {
+      if (this.timeout == null) {
+        this.schedule()
+        this.button.textContent = "Stop"
+        this.robotElt.firstChild.src = "img/robot_moving2x.gif"
+      } else {
+        clearTimeout(this.timeout)
+        this.timeout = null
+        this.button.textContent = "Start"
+        this.robotElt.firstChild.src = "img/robot_idle2x.png"
+      }
+    }
+  }
+
+  window.runRobotAnimation = function(worldState, robot, robotState) {
+    if (active && active.timeout != null)
+      clearTimeout(active.timeout)
+    active = new Animation(worldState, robot, robotState)
+  }
+})()

docs/code/animatevillage.js

@@ -0,0 +1,54 @@
+var journal = [];
+
+function addEntry(events, squirrel) {
+  journal.push({events, squirrel});
+}
+
+function phi(table) {
+  return (table[3] * table[0] - table[2] * table[1]) /
+    Math.sqrt((table[2] + table[3]) *
+              (table[0] + table[1]) *
+              (table[1] + table[3]) *
+              (table[0] + table[2]));
+}
+
+function tableFor(event, journal) {
+  let table = [0, 0, 0, 0];
+  for (let i = 0; i < journal.length; i++) {
+    let entry = journal[i], index = 0;
+    if (entry.events.includes(event)) index += 1;
+    if (entry.squirrel) index += 2;
+    table[index] += 1;
+  }
+  return table;
+}
+
+function journalEvents(journal) {
+  let events = [];
+  for (let entry of journal) {
+    for (let event of entry.events) {
+      if (!events.includes(event)) {
+        events.push(event);
+      }
+    }
+  }
+  return events;
+}
+
+for (let entry of JOURNAL) {
+  if (entry.events.includes("peanuts") &&
+     !entry.events.includes("brushed teeth")) {
+    entry.events.push("peanut teeth");
+  }
+}
+
+var list = {
+  value: 1,
+  rest: {
+    value: 2,
+    rest: {
+      value: 3,
+      rest: null
+    }
+  }
+};

docs/code/chapter/.keep

@@ -0,0 +1,43 @@
+function repeat(n, action) {
+  for (let i = 0; i < n; i++) {
+    action(i);
+  }
+}
+
+function characterScript(code) {
+  for (let script of SCRIPTS) {
+    if (script.ranges.some(([from, to]) => code >= from &&
+                                           code < to)) {
+      return script;
+    }
+  }
+  return null;
+}
+
+function countBy(items, groupName) {
+  let counts = [];
+  for (let item of items) {
+    let name = groupName(item);
+    let known = counts.findIndex(c => c.name == name);
+    if (known == -1) {
+      counts.push({name, count: 1});
+    } else {
+      counts[known].count++;
+    }
+  }
+  return counts;
+}
+
+function textScripts(text) {
+  let scripts = countBy(text, char => {
+    let script = characterScript(char.codePointAt(0));
+    return script ? script.name : "none";
+  }).filter(({name}) => name != "none");
+
+  let total = scripts.reduce((n, {count}) => n + count, 0);
+  if (total == 0) return "No scripts found";
+
+  return scripts.map(({name, count}) => {
+    return `${Math.round(count * 100 / total)}% ${name}`;
+  }).join(", ");
+}

docs/code/chapter/04_data.js

@@ -0,0 +1,89 @@
+function speak(line) {
+  console.log(`The ${this.type} rabbit says '${line}'`);
+}
+var whiteRabbit = {type: "white", speak};
+var hungryRabbit = {type: "hungry", speak};
+
+
+var Rabbit = class Rabbit {
+  constructor(type) {
+    this.type = type;
+  }
+  speak(line) {
+    console.log(`The ${this.type} rabbit says '${line}'`);
+  }
+}
+
+var killerRabbit = new Rabbit("killer");
+var blackRabbit = new Rabbit("black");
+
+Rabbit.prototype.toString = function() {
+  return `a ${this.type} rabbit`;
+};
+
+var toStringSymbol = Symbol("toString");
+
+var Matrix = class Matrix {
+  constructor(width, height, content = (x, y) => undefined) {
+    this.width = width;
+    this.height = height;
+    this.content = [];
+
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        this.content[y * width + x] = content(x, y);
+      }
+    }
+  }
+
+  get(x, y) {
+    return this.content[y * this.width + x];
+  }
+  set(x, y, value) {
+    this.content[y * this.width + x] = value;
+  }
+}
+
+var MatrixIterator = class MatrixIterator {
+  constructor(matrix) {
+    this.x = 0;
+    this.y = 0;
+    this.matrix = matrix;
+  }
+
+  next() {
+    if (this.y == this.matrix.height) return {done: true};
+
+    let value = {x: this.x,
+                 y: this.y,
+                 value: this.matrix.get(this.x, this.y)};
+    this.x++;
+    if (this.x == this.matrix.width) {
+      this.x = 0;
+      this.y++;
+    }
+    return {value, done: false};
+  }
+}
+
+Matrix.prototype[Symbol.iterator] = function() {
+  return new MatrixIterator(this);
+};
+
+var SymmetricMatrix = class SymmetricMatrix extends Matrix {
+  constructor(size, content = (x, y) => undefined) {
+    super(size, size, (x, y) => {
+      if (x < y) return content(y, x);
+      else return content(x, y);
+    });
+  }
+
+  set(x, y, value) {
+    super.set(x, y, value);
+    if (x != y) {
+      super.set(y, x, value);
+    }
+  }
+}
+
+var matrix = new SymmetricMatrix(5, (x, y) => `${x},${y}`);