@slugbugblue/trax 0.3.1 → 0.7.0

package/engine.js

@@ -1,4 +1,4 @@
-/* Copyright 2021 Chad Transtrum
+/* Copyright 2019-2022 Chad Transtrum
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,66 +15,97 @@
 
 // Trax internals. Woot.
 
-// tile type names are determined by listing the color of line at each edge, clockwise
+// Tile type names are determined by listing the color of line at each edge, clockwise
 // and then sorted alphabetically and given a single letter name, so 'bbww' becomes 'a'
 // which gives us six different tile names: a-f
 
-const variants = ['trax', 'traxloop', 'trax8']  // known variants
+import { Point } from './point.js'
 
-// fun trax helper constants
+// Fun trax helper constants
+
+const zero = new Point(0, 0)
+const notationRegex = /^ *([@a-z]+) *(\d+) *([/\\+]) *$/i
 
 const slash = { a: '\\', b: '+', c: '/', d: '/', e: '+', f: '\\' }
 
-const symmetry = {  // convert tile to different views
+const symmetry = {
+  // Convert tile to different views
   flip: { a: 'd', b: 'b', c: 'f', d: 'a', e: 'e', f: 'c' },
   mirror: { a: 'c', b: 'b', c: 'a', d: 'f', e: 'e', f: 'd' },
   swap: { a: 'f', b: 'e', c: 'd', d: 'c', e: 'b', f: 'a' },
   counterclock: { a: 'c', b: 'e', c: 'f', d: 'a', e: 'b', f: 'd' },
 }
 
-const notation_regex = /^ *([@a-z]+) *(\d+) *([/\\+]) *$/i
+// Fun trax helper functions
 
-const color_of = { 1: 'w', 2: 'b' }
-const player_num = { b: 2, w: 1 }
-const other = { b: 'w', w: 'b' }
+const applySymmetry = (tile, rightToLeft, bottomToTop, rotate) => {
+  if (rightToLeft) tile = symmetry.mirror[tile]
+  if (bottomToTop) tile = symmetry.flip[tile]
+  if (rotate) tile = symmetry.counterclock[tile]
+  return tile
+}
 
-// fun trax helper functions
+// Unexpected note: str.includes(t) is true if t is '' but false if t is undefined
+const upColor = (t) =>
+  'abc'.includes(t) ? 'b' : 'def'.includes(t) ? 'w' : false
+const downColor = (t) =>
+  'bdf'.includes(t) ? 'b' : 'ace'.includes(t) ? 'w' : false
+const rightColor = (t) =>
+  'ade'.includes(t) ? 'b' : 'bcf'.includes(t) ? 'w' : false
+const leftColor = (t) =>
+  'cef'.includes(t) ? 'b' : 'abd'.includes(t) ? 'w' : false
 
-// unexpected note: str.includes(t) is true if t is '' but false if t is undefined
-const up_color = t => 'abc'.includes(t) ? 'b' : 'def'.includes(t) ? 'w' : false
-const down_color = t => 'bdf'.includes(t) ? 'b' : 'ace'.includes(t) ? 'w' : false
-const right_color = t => 'ade'.includes(t) ? 'b' : 'bcf'.includes(t) ? 'w' : false
-const left_color = t => 'cef'.includes(t) ? 'b' : 'abd'.includes(t) ? 'w' : false
-const squares_around = (x, y) => [{x:x-1,y},{x:x+1,y},{x,y:y-1},{x,y:y+1}]
-const encode_col = col => { // for notation purposes: 0 -> @, 6 -> F, 28 -> AB
-  let n = ''
-  while (col > 0) {
-    n = String.fromCharCode(65 + (col - 1) % 26) + n
-    col = Math.floor((col - 1) / 26)
+const addBlank = (code) => {
+  // Encode missing tiles as digits 0-9, for 1-10 missing
+  const lastNumber = code.codePointAt(code.length - 1) // This is NaN if code is empty, which is ok
+  if (lastNumber > 47 && lastNumber < 57) {
+    return code.slice(0, -1) + String.fromCodePoint(lastNumber + 1)
   }
-  return n || '@'
-}
-const decode_col = col => { // turn letters back into numbers
-  col = col.toUpperCase()
-  let n = 0
-  while (col.length) {
-    n = n + (col.charCodeAt(0) - 64) * Math.pow(26, col.length - 1)
-    col = col.slice(1)
-  }
-  return n
-}
-const add_blank = code => { // encode missing tiles as digits 0-9, for 1-10 missing
-  let num = code.charCodeAt(code.length - 1) // this is NaN if code is empty, which is ok
-  if (num > 47 && num < 57) return code.slice(0, code.length -1) + String.fromCharCode(num + 1)
-  return code += '0'
+
+  return code + '0'
 }
-// ugh, this is a dirty little function to get the length of an encoded position row
-const code_row_len = row => row.replace(/[0-9]/g, n => '.'.repeat(Number(n)+1)).length
 
-// this is where the magic happens
-const Trax = class {
-  constructor (rules='trax', moves=[], id='trax') {
-    if (!variants.includes(rules)) rules = 'trax'
+// Ugh, this is a dirty little function to get the length of an encoded position row
+const codeRowLength = (row) =>
+  row.replace(/\d/g, (n) => '.'.repeat(Number(n) + 1)).length
+
+// This is where the magic happens
+export const Trax = class {
+  // Static class properties
+  static variants = new Set(['trax', 'traxloop', 'trax8']) // Known variants
+
+  // Static class methods
+  static point = (x, y) => new Point(x, y)
+  static colorOf = (playerNumber) => ({ 1: 'w', 2: 'b' }[playerNumber])
+  static playerNumber = (color) => ({ b: 2, w: 1 }[color])
+  static other = (color) => ({ b: 'w', w: 'b' }[color])
+
+  static encodeCol = (col) => {
+    // For notation purposes: 0 -> @, 6 -> F, 28 -> AB
+    let n = ''
+    while (col > 0) {
+      n = String.fromCodePoint(65 + ((col - 1) % 26)) + n
+      col = Math.floor((col - 1) / 26)
+    }
+
+    return n || '@'
+  }
+
+  static decodeCol = (col) => {
+    // Turn letters back into numbers
+    col = col.toUpperCase()
+    let n = 0
+    while (col.length > 0) {
+      n += (col.codePointAt(0) - 64) * 26 ** (col.length - 1)
+      col = col.slice(1)
+    }
+
+    return n
+  }
+
+  // Trax class constructor
+  constructor(rules = 'trax', moves = [], id = 'trax') {
+    if (!Trax.variants.has(rules)) rules = 'trax'
     this.id = String(id)
     this.rules = rules
     this.move = 0
@@ -87,19 +118,24 @@ const Trax = class {
     this.notation = ''
     this.tiles = {}
     this.path = []
-    this.count = 0
     this.invalid = false
-    // moves might be a notation string
-    if (typeof moves === 'string') moves = moves.split(' ')
-    moves.forEach(move => {
-      if (typeof move === 'string') {
-        move = { move: this.move, notation: move }
+    // Moves might be a notation string
+    if (moves) {
+      if (typeof moves === 'string') moves = moves.split(/\s+/)
+      for (let move of moves) {
+        if (typeof move === 'string') {
+          move = { move: this.move, notation: move }
+        }
+
+        if (notationRegex.test(move.notation)) {
+          this.playMove(move.move, move.notation)
+        }
       }
-      this.play_move(move.move, move.notation)
-    })
+    }
   }
 
-  save () { // in order to evaluate potential moves, we have to modify the state
+  save() {
+    // In order to evaluate potential moves, we have to modify the state
     return {
       move: this.move,
       turn: this.turn,
@@ -111,12 +147,12 @@ const Trax = class {
       notation: this.notation,
       tiles: JSON.stringify(this.tiles),
       path: JSON.stringify(this.path),
-      count: this.count,
       invalid: this.invalid,
     }
   }
 
-  restore (saved) { // so we need to be able to restore it when we are done
+  restore(saved) {
+    // So we need to be able to restore it when we are done
     this.move = saved.move
     this.turn = saved.turn
     this.over = saved.over
@@ -127,402 +163,488 @@ const Trax = class {
     this.notation = saved.notation
     this.tiles = JSON.parse(saved.tiles)
     this.path = JSON.parse(saved.path)
-    this.count = saved.count
     this.invalid = saved.invalid
+    // Reconstitute the locations
+    for (const tile of Object.values(this.tiles)) {
+      tile.loc = new Point(tile.loc)
+    }
+  }
+
+  get count() {
+    // Get the number of tiles currently in play
+    return Object.keys(this.tiles).length
   }
 
-  get color () {  // get the color of the current player (w or b)
-    return color_of[this.turn]
+  get color() {
+    // Get the color of the current player (w or b)
+    return Trax.colorOf(this.turn)
   }
 
-  get game_over () { // returns true if the game is over
+  get gameOver() {
+    // Returns true if the game is over
     return this.over
   }
 
-  get winner () { // returns false if the game is still in progress
-    return this.over ? this.turn : false  // or 1 or 2 for a win, or 0 for a tie
+  get winner() {
+    // Returns false if the game is still in progress
+    return this.over ? this.turn : false // Or 1 or 2 for a win, or 0 for a tie
   }
 
-  tile_id (x, y) {
-    return this.id + '-' + String(x) + 'x' + String(y)
+  tileId(loc) {
+    return this.id + '-' + String(loc.x) + 'x' + String(loc.y)
   }
 
-  add_tile (type, x, y) { // note: no validity checking is done here
-    const id = this.tile_id(x, y)
-    const tile = { type, x, y, id, move: this.move, seq: this.count }
+  addTile(type, loc) {
+    // Note: no validity checking is done here
+    const id = this.tileId(loc)
+    const tile = { type, loc, id, move: this.move, seq: this.count }
     if (type === 'x') {
-      this.invalid = true // invalid tile is being played
+      this.invalid = true // Invalid tile is being played
     } else {
       this.tiles[id] = tile
-      this.count++
-      this.left = Math.min(this.left, x)
-      this.right = Math.max(this.right, x)
-      this.top = Math.min(this.top, y)
-      this.bottom = Math.max(this.bottom, y)
+      this.left = Math.min(this.left, loc.x)
+      this.right = Math.max(this.right, loc.x)
+      this.top = Math.min(this.top, loc.y)
+      this.bottom = Math.max(this.bottom, loc.y)
     }
+
     return tile
   }
 
-  tile_at (x, y) {
-    return (this.tiles[this.tile_id(x, y)] || {}).type
+  tileAt(loc) {
+    return (this.tiles[this.tileId(loc)] || {}).type
   }
 
-  valid_tile (type, x, y) {
-    if (this.count === 0 && x === 0 && y === 0) return type === 'd' || type === 'e'
-    let up = down_color(this.tile_at(x, y - 1))
-    let down = up_color(this.tile_at(x, y + 1))
-    let left = right_color(this.tile_at(x - 1, y))
-    let right = left_color(this.tile_at(x + 1, y))
-    return (!up || up === up_color(type)) && (!down || down === down_color(type)) &&
-      (!left || left === left_color(type)) && (!right || right === right_color(type))
+  validTile(type, loc) {
+    if (this.count === 0 && loc.x === 0 && loc.y === 0) {
+      return type === 'd' || type === 'e'
+    }
+
+    const up = downColor(this.tileAt(loc.up))
+    const down = upColor(this.tileAt(loc.down))
+    const left = rightColor(this.tileAt(loc.left))
+    const right = leftColor(this.tileAt(loc.right))
+    return (
+      (up || down || left || right) &&
+      (!up || up === upColor(type)) &&
+      (!down || down === downColor(type)) &&
+      (!left || left === leftColor(type)) &&
+      (!right || right === rightColor(type))
+    )
   }
 
-  possible_tiles (x, y, s=false) { // s: slash (/ or \ or +)
-    let possibles = []
-    ;['a', 'b', 'c', 'd', 'e', 'f'].forEach(t => {
-      if ((!s || s === slash[t]) && this.valid_tile(t, x, y)) possibles.push(t)
-    })
+  possibleTiles(loc, s = false) {
+    // S: slash (/ or \ or +)
+    const possibles = []
+    for (const t of ['a', 'b', 'c', 'd', 'e', 'f']) {
+      if ((!s || s === slash[t]) && this.validTile(t, loc)) possibles.push(t)
+    }
+
     return possibles
   }
 
-  get height () {
+  get height() {
     return this.bottom - this.top + 1
   }
 
-  get width () {
+  get width() {
     return this.right - this.left + 1
   }
 
-  valid_location (x, y) {
+  validLocation(loc) {
     if (this.over) return false
-    if (this.tile_at(x, y)) return false
-    if (this.count === 0 && x === 0 && y === 0) return true
+    if (this.tileAt(loc)) return false
+    if (this.count === 0 && loc.eq(zero)) return true
     if (this.rules === 'trax8') {
-      if (this.width > 7 && (x < this.left || x > this.right)) return false
-      if (this.height > 7 && (y < this.top || y > this.bottom)) return false
+      if (this.width > 7 && (loc.x < this.left || loc.x > this.right)) {
+        return false
+      }
+
+      if (this.height > 7 && (loc.y < this.top || loc.y > this.bottom)) {
+        return false
+      }
     }
-    return Boolean(
-      this.tile_at(x-1, y) || this.tile_at(x+1, y) ||
-      this.tile_at(x, y-1) || this.tile_at(x, y+1)
-    )
+
+    for (const location of loc.around) {
+      if (this.tileAt(location)) return true
+    }
+
+    return false
   }
 
-  possible_locations () {
-    let locs = { '0x0': { x:0, y:0 } }  // if no tiles are placed, we can play a starting tile
-    const maybe = (x, y) => {  // add a loc if a tile isn't already there
-      let loc = x + 'x' + y
-      locs[loc] = locs[loc] || { x, y }
+  possibleLocations() {
+    const locs = { [this.tileId(zero)]: zero } // If no tiles are placed, we can play a starting tile
+    const maybe = (loc) => {
+      // Add a loc if a tile isn't already there
+      const id = this.tileId(loc)
+      locs[id] = locs[id] || loc
     }
-    for (let tile of Object.values(this.tiles)) {
-      locs[tile.x + 'x' + tile.y] = 'tile'  // add an existing tile
-      maybe(tile.x - 1, tile.y)  // and four maybe tiles around it
-      maybe(tile.x + 1, tile.y)  // which will either be replaced by real tiles
-      maybe(tile.x, tile.y - 1)  // or will be potentially valid locations
-      maybe(tile.x, tile.y + 1)
+
+    for (const tile of Object.values(this.tiles)) {
+      locs[tile.id] = 'tile' // Add an existing tile
+      tile.loc.around.map((loc) => maybe(loc))
     }
-    // get rid of all the real tiles and return all the maybes
-    return Object.values(locs).filter(l => l !== 'tile')
+
+    // Get rid of all the real tiles and return all the maybes
+    return Object.values(locs).filter((loc) => loc !== 'tile')
   }
 
-  possible_moves () { // returns a list of every currently possible move
+  possibleMoves() {
+    // Returns a list of every currently possible move
     // as notations, ie ['@1+', '@1/', '@1\\', ...]
-    let possibles = []
-    if (this.over) return possibles  // shortcut if the game is over
-    this.possible_locations().forEach(loc => {
-      this.possible_tiles(loc.x, loc.y).forEach(tile => {
-        let drop = this.drop_tile(tile, loc.x, loc.y, 'tentative')
+    const possibles = []
+    if (this.over) return possibles // Shortcut if the game is over
+    for (const loc of this.possibleLocations()) {
+      for (const tile of this.possibleTiles(loc)) {
+        const drop = this.dropTile(tile, loc, 'tentative')
         if (drop.valid) possibles.push(drop.notation)
-      })
-    })
+      }
+    }
+
     return possibles
   }
 
-  forced_moves (x, y) { // we just played at x, y, so return all forced moves
-    let forced = []
-    let invalids = {}
-    let check = squares_around(x, y)
-    while (check.length) {
-      let pos = check.shift()
-      if (this.valid_location(pos.x, pos.y)) {
-        let possibles = this.possible_tiles(pos.x, pos.y)
-        if (possibles.length === 1) { // only 1 possible move
-          forced.push(this.add_tile(possibles[0], pos.x, pos.y))
-          check = check.concat(squares_around(pos.x, pos.y))
-        } else if (possibles.length === 0) { // no possible moves at all
-          let invalid = this.add_tile('x', pos.x, pos.y)
+  forcedMoves(loc) {
+    // We just played at loc, so return all forced moves
+    const forced = []
+    const invalids = {}
+    let check = loc.around
+    while (check.length > 0) {
+      const pos = check.shift()
+      if (this.validLocation(pos)) {
+        const possibles = this.possibleTiles(pos)
+        if (possibles.length === 1) {
+          // Only 1 possible move
+          forced.push(this.addTile(possibles[0], pos))
+          check = [...check, ...pos.around]
+        } else if (possibles.length === 0) {
+          // No possible moves at all
+          const invalid = this.addTile('x', pos)
           if (!invalids[invalid.id]) forced.push(invalid)
           invalids[invalid.id] = true
         }
       }
     }
+
     return forced
   }
 
-  notate (type, x, y) { // notation depends on the position of the board BEFORE the move
-    return encode_col(x - this.left + 1) + String(y - this.top + 1) + slash[type]
+  notate(type, loc) {
+    // Notation depends on the position of the board BEFORE the move
+    let notation = Trax.encodeCol(loc.x - this.left + 1)
+    notation += String(loc.y - this.top + 1)
+    notation += slash[type]
+    return notation
   }
 
-  decode_notation (notation) { // return {type, x, y} from a notation
-    let r = { type: 'x', x: 0, y: 0 } // default to an invalid move
-    let match = notation.match(notation_regex)
-    if (match === null) return r
-    r.x = this.left - 1 + decode_col(match[1])
-    r.y = this.top - 1 + Number(match[2])
-    let possible = this.possible_tiles(r.x, r.y, match[3])
-    if (possible) r.type = possible[0]
-    return r
+  decodeNotation(notation) {
+    // Return {type, loc} from a notation
+    const bad = { type: 'x', loc: zero }
+    const match = notation.match(notationRegex)
+    if (match === null) return bad
+    const loc = new Point(
+      this.left - 1 + Trax.decodeCol(match[1]),
+      this.top - 1 + Number(match[2]),
+    )
+    const possible = this.possibleTiles(loc, match[3])
+    if (possible.length > 0) return { type: possible[0], loc }
+    return bad
   }
 
-  follow (color, x, y, from) {
-    let path = []
-    let id = this.tile_id(x, y)
-    let tile = this.tile_at(x, y)
+  follow(color, loc, from) {
+    const path = []
+    let id = this.tileId(loc)
+    let tile = this.tileAt(loc)
     while (tile && path[0] !== id) {
-      if (from !== 'top' && up_color(tile) === color) {
+      if (from !== 'top' && upColor(tile) === color) {
         from = 'bottom'
-        y--
-      } else if (from !== 'bottom' && down_color(tile) === color) {
+        loc = loc.up
+      } else if (from !== 'bottom' && downColor(tile) === color) {
         from = 'top'
-        y++
-      } else if (from !== 'left' && left_color(tile) === color) {
+        loc = loc.down
+      } else if (from !== 'left' && leftColor(tile) === color) {
         from = 'right'
-        x--
-      } else if (from !== 'right' && right_color(tile) === color) {
+        loc = loc.left
+      } else if (from !== 'right' && rightColor(tile) === color) {
         from = 'left'
-        x++
+        loc = loc.right
       }
+
       path.push(id)
-      id = this.tile_id(x, y)
-      tile = this.tile_at(x, y)
+      id = this.tileId(loc)
+      tile = this.tileAt(loc)
     }
-    return { x, y, path }
+
+    return { loc, path }
   }
 
-  find_ends (color, x, y) {
-    let ends = []
-    let tile = this.tile_at(x, y)
-    if (up_color(tile) === color) ends.push(this.follow(color, x, y, 'top'))
-    if (down_color(tile) === color) ends.push(this.follow(color, x, y, 'bottom'))
-    if (left_color(tile) === color) ends.push(this.follow(color, x, y, 'left'))
-    if (right_color(tile) === color) ends.push(this.follow(color, x, y, 'right'))
+  findEnds(color, loc) {
+    const ends = []
+    const tile = this.tileAt(loc)
+    if (upColor(tile) === color) ends.push(this.follow(color, loc, 'top'))
+    if (downColor(tile) === color) ends.push(this.follow(color, loc, 'bottom'))
+    if (leftColor(tile) === color) ends.push(this.follow(color, loc, 'left'))
+    if (rightColor(tile) === color) ends.push(this.follow(color, loc, 'right'))
     return ends
   }
 
-  check_win (tiles) {
+  lineWin(locA, locB) {
+    if (this.rules === 'traxloop') return false
+    if (this.width > 7 && locA.distX(locB) > this.width) return true
+    if (this.height > 7 && locA.distY(locB) > this.height) return true
+    return false
+  }
+
+  checkWin(tiles) {
     let winner = false
-    let colors = [ this.color, other[this.color] ]  // check win for current player first
-    colors.forEach(color => {
-      if (winner) return // skip the second player if the first has won
-      tiles.forEach(tile => {
-        if (winner) return // skip the remaining tiles once we find a win
-        let ends = this.find_ends(color, tile.x, tile.y)
-        if (ends.length !== 2) return // this should never happen, but if it does, don't die
-        if (ends[0].x === ends[1].x && ends[0].y === ends[1].y) {
-          winner = color // loop win
-          this.path = ends[0].path // both paths are essentially the same
-        } else if (this.rules !== 'traxloop') { // check for line win
-          if (this.width > 7 && Math.abs(ends[0].x - ends[1].x) > this.width ||
-            this.height > 7 && Math.abs(ends[0].y - ends[1].y) > this.height) {
-            winner = color // line win, paths need to be combined
-            this.path = ends[0].path.reverse().concat(ends[1].path.slice(1))
-          }
+    const colors = [this.color, Trax.other(this.color)] // Check win for current player first
+    for (const color of colors) {
+      if (winner) continue // Skip the second player if the first has won
+      for (const tile of tiles) {
+        if (winner) continue // Skip the remaining tiles once we find a win
+        const ends = this.findEnds(color, tile.loc)
+        if (ends[0].loc.eq(ends[1].loc)) {
+          winner = color // Loop win
+          this.path = ends[0].path // Both paths are essentially the same
+        } else if (this.lineWin(ends[0].loc, ends[1].loc)) {
+          winner = color // Line win, paths need to be combined
+          this.path = [...ends[0].path.reverse(), ...ends[1].path.slice(1)]
         }
-      })
-    })
+      }
+    }
+
     if (winner) {
       this.over = true
-      this.turn = player_num[winner]
-    } else {
+      this.turn = Trax.playerNumber(winner)
+    } else if (
       // 8x8 Trax can end in a tie once there are no valid moves left
-      if (this.rules === 'trax8' && this.width > 7 && this.height > 7) {
-        if (this.possible_moves().length < 1) {
-          this.over = true
-          this.turn = 0 // tie
-        }
-      }
+      this.rules === 'trax8' &&
+      this.width > 7 &&
+      this.height > 7 &&
+      this.possibleMoves().length === 0
+    ) {
+      this.over = true
+      this.turn = 0 // Tie
     }
   }
 
-  play (notation) { // fast and easy way to play a move
-    return this.drop_tile(notation)
+  play(notation) {
+    // Fast and easy way to play a move
+    return this.dropTile(notation)
   }
 
-  play_move (move_num, notation) { // generic API call for drop_tile
-    if (move_num === this.move) return this.drop_tile(notation)
+  playMove(currentMoveNumber, nextMoveNotation) {
+    // Generic API call for dropTile
+    if (currentMoveNumber === this.move) return this.dropTile(nextMoveNotation)
     return { valid: false }
   }
 
-  update_notation (notation) {
+  updateNotation(notation) {
     this.move++
-    let note = this.move +'. ' + notation
-    let line = this.notation.split('\n').pop()
+    let note = this.move + '. ' + notation
+    const line = this.notation.split('\n').pop()
     if (line) {
       note = (line.length + note.length > 79 ? '\n' : ' ') + note
     }
+
     this.notation += note
   }
 
-  get moves () {
-    return this.notation.replace(/\n/g, ' ').split(' ').filter(n => !n.endsWith('.'))
+  get moves() {
+    return this.notation
+      .replace(/\n/g, ' ')
+      .split(' ')
+      .filter((n) => !n.endsWith('.'))
   }
 
-  drop_tile (type, x, y, tentative=false) { // pass in tentative to not save the move
+  dropTile(type, loc, tentative = false) {
+    // Pass in tentative to not save the move
     let dropped = []
     let notation = ''
     let valid = false
-    if (['timeout', 'resign', 'draw', 'puzzled'].includes(type)) { // handle special events
+    if (['timeout', 'resign', 'draw', 'puzzled'].includes(type)) {
+      // Handle special events
       this.over = true
-      if (type !== 'puzzled') {  // puzzled: puzzle was not completed; this player wins
-        this.turn = this.turn === 1 ? 2 : 1 // timeout, resign means the other player wins
-        if (type === 'draw') this.turn = 0 // draw means we both win
+      if (type !== 'puzzled') {
+        // Puzzled: puzzle was not completed; this player wins
+        this.turn = this.turn === 1 ? 2 : 1 // Timeout, resign means the other player wins
+        if (type === 'draw') this.turn = 0 // Draw means we both win
       }
-      this.update_notation(type)
+
+      this.updateNotation(type)
       notation = type
       valid = true
     } else {
-      if (type.search(notation_regex) === 0) { // we were passed a notation
-        ({ type, x, y } = this.decode_notation(type))
+      if (type.search(notationRegex) === 0) {
+        // We were passed a notation
+        const decoded = this.decodeNotation(type)
+        type = decoded.type
+        loc = decoded.loc
       }
-      if (this.valid_location(x, y) && this.valid_tile(type, x, y)) {
+
+      if (this.validLocation(loc) && this.validTile(type, loc)) {
         valid = true
-        let saved = this.save() // just in case we need to roll back
-        notation = this.notate(type, x, y) // determine notation BEFORE we play the move
-        this.update_notation(notation)
-        dropped.push(this.add_tile(type, x, y)) // play the tile
-        dropped = dropped.concat(this.forced_moves(x, y)) // play all forced moves
+        const saved = this.save() // Just in case we need to roll back
+        notation = this.notate(type, loc) // Determine notation BEFORE we play the move
+        this.updateNotation(notation)
+        dropped.push(this.addTile(type, loc)) // Play the tile
+        dropped = [...dropped, ...this.forcedMoves(loc)] // Play all forced moves
         if (this.invalid || tentative) {
-          valid = false
-          this.restore(saved) // abort! abort!
+          if (this.invalid) valid = false
+          this.restore(saved) // Abort! abort!
         } else {
-          this.check_win(dropped)
+          this.checkWin(dropped)
           if (!this.over) this.turn = this.turn === 1 ? 2 : 1
         }
       }
     }
+
     return { dropped, notation, valid }
   }
 
-  rotate_move (move) { // symmetry helper, rotate a move around the board
-    let match = move.match(notation_regex)
-    if (match === null) return move
-    let x = this.width + 1 - Number(match[2])
-    let y = decode_col(match[1])
-    let s = { '/': '\\', '\\': '/', '+': '+'}[match[3]]
-    return encode_col(x) + String(y) + s
+  moveRotations(move) {
+    // Symmetry helper, rotate a move around the board
+    const match = move.match(notationRegex)
+    if (match === null) return []
+    const x = Trax.decodeCol(match[1])
+    const y = Number(match[2])
+    const X = this.height - x + 1
+    const Y = this.width - y + 1
+    const s = match[3]
+    const slashes = s === '+' ? [s] : ['/', '\\']
+    const moves = new Set()
+    // This isn't super precise, but it limits the search space ... maybe #TODO?
+    for (const slash of slashes) {
+      moves.add(Trax.encodeCol(x) + String(y) + slash)
+      moves.add(Trax.encodeCol(y) + String(x) + slash)
+      moves.add(Trax.encodeCol(X) + String(Y) + slash)
+      moves.add(Trax.encodeCol(Y) + String(X) + slash)
+    }
+
+    return [...moves]
   }
 
-  provisional_notation (provisional) { // test a provisional move against the current state
-    let prov = provisional.split(';') // return false if the provisional move does not match
-    if (prov.length !== 4) return 'delete-provisional' // <-- if the provisional move is bad
-    let notation = false // otherwise, return the notation required to make the move
-    let rows = prov[1].split(':')
-    let cols = rows.reduce((acc, cur) => Math.max(acc, code_row_len(cur)), 0)
+  provisionalMove(from, to, via) {
+    // Test a provisional move against the current state
+    let rows = from.slice(1).split(':')
+    let cols = 0
+    for (const row of rows) {
+      cols = Math.max(cols, codeRowLength(row))
+    }
+
     rows = rows.length
-    if (this.width > rows && this.height > cols || this.width > cols && this.height > rows) {
-      return 'delete-provisional' // current board is bigger than the provisional move
+    if (
+      (this.width > rows && this.height > cols) ||
+      (this.width > cols && this.height > rows)
+    ) {
+      return 'delete-provisional' // Current board is bigger than the provisional move
     }
-    if (prov[1] === this.normalized) {
-      let move = prov[2]
-      let saved = this.save() // save this position
-      for (let i = 0 ; i < 4 && !notation; i++) { // try all four orientations because symmetry
-        this.drop_tile(move)
-        if (prov[3] === this.normalized) notation = move // this move matched!
-        this.restore(saved) // put the board back how it was
-        move = this.rotate_move(move) // rotate to the next orientation
+
+    if (from === this.normalized) {
+      const saved = this.save() // Save this position
+      for (const move of this.moveRotations(via)) {
+        // Try all symmetrical moves
+        const drop = this.dropTile(move)
+        if (drop.valid) {
+          if (to === this.normalized) return move // This move matched!
+          this.restore(saved) // Put the board back how it was
+        }
       }
     }
-    return notation
+
+    return false
   }
 
-  get icon () {
-    return this.position_code()
+  get icon() {
+    return this.positionCode()
   }
 
-  tentative_icon (drops) {
-    return this.position_code(undefined, undefined, undefined, undefined, drops)
+  dropsIcon(drops) {
+    return this.positionCode(undefined, undefined, undefined, drops)
   }
 
-  // symmetry helper
-  position_code (right_to_left, bottom_to_top, rotate, swap_colors, drops) {
-    const start_x = right_to_left ? this.right : this.left
-    const start_y = bottom_to_top ? this.bottom : this.top
-    const inc_x = right_to_left ? -1 : 1
-    const inc_y = bottom_to_top ? -1 : 1
-    let code = []
+  // Symmetry helper, draw the board from different angles
+  positionCode(rightToLeft, bottomToTop, rotate, drops) {
+    const startX = rightToLeft ? this.right : this.left
+    const startY = bottomToTop ? this.bottom : this.top
+    const incX = rightToLeft ? -1 : 1
+    const incY = bottomToTop ? -1 : 1
+    const code = []
     let line = ''
-    let x = start_x
-    let y = start_y
+    let x = startX
+    let y = startY
     do {
-      let tile = this.tile_at(x, y) // normal tile for normal orientation
+      const loc = new Point(x, y)
+      let tile = this.tileAt(loc) // Normal tile for normal orientation
       if (tile) {
-        if (right_to_left) tile = symmetry.mirror[tile]
-        if (bottom_to_top) tile = symmetry.flip[tile]
-        if (rotate) tile = symmetry.counterclock[tile]
-        if (swap_colors) tile = symmetry.swap[tile]
-        if (this.path.includes(this.tile_id(x, y))) {
-          tile = String.fromCharCode(tile.charCodeAt(0) + this.turn * 6)
+        tile = applySymmetry(tile, rightToLeft, bottomToTop, rotate)
+        if (this.path.includes(this.tileId(loc))) {
+          tile = String.fromCodePoint(tile.codePointAt(0) + this.turn * 6)
         }
-        if (drops && drops.dropped) {
-          if (drops.dropped.filter(t => t.x === x && t.y === y).length) tile = tile.toUpperCase()
+
+        if (
+          drops &&
+          drops.dropped &&
+          drops.dropped.some((t) => loc.eq(t.loc))
+        ) {
+          tile = tile.toUpperCase()
         }
+
         line += tile
       } else {
-        line = add_blank(line)
+        line = addBlank(line)
       }
-      if (rotate) { // increment y more often than x
-        y += inc_y
+
+      if (rotate) {
+        // Increment y more often than x
+        y += incY
         if (y < this.top || y > this.bottom) {
-          y = start_y
-          x += inc_x
-          // remove final number and add to code
-          code.push(line.replace(/[0-9]+$/, ''))
+          y = startY
+          x += incX
+          // Remove final number and add to code
+          code.push(line.replace(/\d+$/, ''))
           line = ''
         }
-      } else { // this is the standard order
-        x += inc_x
+      } else {
+        // This is the standard order
+        x += incX
         if (x < this.left || x > this.right) {
-          x = start_x
-          y += inc_y
-          // remove final number and add to code
-          code.push(line.replace(/[0-9]+$/, ''))
+          x = startX
+          y += incY
+          // Remove final number and add to code
+          code.push(line.replace(/\d+$/, ''))
           line = ''
         }
       }
-    } while (x >= this.left && x <= this.right && y >= this.top && y <= this.bottom)
+    } while (
+      x >= this.left &&
+      x <= this.right &&
+      y >= this.top &&
+      y <= this.bottom
+    )
+
     if (rotate) code.reverse()
     return code.join(':')
   }
 
-  normalize (swap_colors=false) {
-    // trax has the potential for symmetry, so this gives us the ability to
+  normalize() {
+    // Trax has the potential for symmetry, so this gives us the ability to
     // examine horizontal, vertical, and rotational symmetry for a color
-    // --- pass in a truthy value to get a position for the opposite color
     let norm = 'z'
-    let bools = [true, false]
-    bools.forEach(r_to_l => {
-      bools.forEach(b_to_t => {
-        bools.forEach(rot => {
-          let code = this.position_code(r_to_l, b_to_t, rot, swap_colors)
+    const bools = [true, false]
+    for (const rightToLeft of bools) {
+      for (const bottomToTop of bools) {
+        for (const rotate of bools) {
+          const code = this.positionCode(rightToLeft, bottomToTop, rotate)
           if (code < norm) norm = code
-        })
-      })
-    })
+        }
+      }
+    }
+
     return (this.color || 't').toUpperCase() + norm
   }
 
-  get normalized () {
-    // the default call does not check for color symmetry, because you rarely need that
+  get normalized() {
     return this.normalize()
   }
 }
-
-// add class methods
-Trax.column = encode_col
-
-// and class constants
-Trax.variants = variants
-Trax.color_of = color_of
-Trax.player_num = player_num
-Trax.other = other
-
-export default Trax