@slugbugblue/trax 0.5.0 → 0.9.0

package/{engine.js → src/engine.js}

@@ -15,13 +15,16 @@
 
 // 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
 
-// fun trax helper constants
+import { Point } from './point.js'
 
-const notationRegex = /^ *([@a-z]+) *(\d+) *([/\\+]) *$/i
+// Fun trax helper constants
+
+const zero = new Point(0, 0)
+const notationRegex = /^([@a-z]+)(\d+)([/\\+])$/i
 
 const slash = { a: '\\', b: '+', c: '/', d: '/', e: '+', f: '\\' }
 
@@ -51,18 +54,14 @@ const rightColor = (t) =>
   'ade'.includes(t) ? 'b' : 'bcf'.includes(t) ? 'w' : false
 const leftColor = (t) =>
   'cef'.includes(t) ? 'b' : 'abd'.includes(t) ? 'w' : false
-const squaresAround = (x, y) => [
-  { x: x - 1, y },
-  { x: x + 1, y },
-  { x, y: y - 1 },
-  { x, y: y + 1 },
-]
 
 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)
+  if (lastNumber > 47 && lastNumber < 57) {
     return code.slice(0, -1) + String.fromCodePoint(lastNumber + 1)
+  }
+
   return code + '0'
 }
 
@@ -73,9 +72,16 @@ const codeRowLength = (row) =>
 // This is where the magic happens
 export const Trax = class {
   // Static class properties
-  static variants = new Set(['trax', 'traxloop', 'trax8']) // Known variants
+  static names = {
+    trax: 'Trax',
+    traxloop: 'Loop Trax',
+    trax8: '8x8 Trax',
+  }
+
+  static variants = new Set(Object.keys(this.names)) // 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])
@@ -121,13 +127,11 @@ export const Trax = class {
     this.invalid = false
     // Moves might be a notation string
     if (moves) {
-      if (typeof moves === 'string') moves = moves.split(' ')
-      for (let move of moves) {
-        if (typeof move === 'string') {
-          move = { move: this.move, notation: move }
+      if (typeof moves === 'string') moves = moves.split(/\s+/)
+      for (const move of moves) {
+        if (notationRegex.test(move)) {
+          this.dropTile(move)
         }
-
-        this.playMove(move.move, move.notation)
       }
     }
   }
@@ -162,6 +166,15 @@ export const Trax = class {
     this.tiles = JSON.parse(saved.tiles)
     this.path = JSON.parse(saved.path)
     this.invalid = saved.invalid
+    // Reconstitute the locations
+    for (const tile of Object.values(this.tiles)) {
+      tile.loc = new Point(tile.loc)
+    }
+  }
+
+  get name() {
+    // Get the name of this variant
+    return Trax.names[this.rules]
   }
 
   get count() {
@@ -184,39 +197,42 @@ export const Trax = class {
     return this.over ? this.turn : false // Or 1 or 2 for a win, or 0 for a tie
   }
 
-  tileId(x, y) {
-    return this.id + '-' + String(x) + 'x' + String(y)
+  tileId(loc) {
+    return this.id + '-' + String(loc.x) + 'x' + String(loc.y)
   }
 
-  addTile(type, x, y) {
+  addTile(type, loc) {
     // Note: no validity checking is done here
-    const id = this.tileId(x, y)
-    const tile = { type, x, y, id, move: this.move, seq: this.count }
+    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
     } else {
       this.tiles[id] = tile
-      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
   }
 
-  tileAt(x, y) {
-    return (this.tiles[this.tileId(x, y)] || {}).type
+  tileAt(loc) {
+    return (this.tiles[this.tileId(loc)] || {}).type
   }
 
-  validTile(type, x, y) {
-    if (this.count === 0 && x === 0 && y === 0)
+  validTile(type, loc) {
+    if (this.count === 0 && loc.x === 0 && loc.y === 0) {
       return type === 'd' || type === 'e'
-    const up = downColor(this.tileAt(x, y - 1))
-    const down = upColor(this.tileAt(x, y + 1))
-    const left = rightColor(this.tileAt(x - 1, y))
-    const right = leftColor(this.tileAt(x + 1, y))
+    }
+
+    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)) &&
@@ -224,11 +240,11 @@ export const Trax = class {
     )
   }
 
-  possibleTiles(x, y, s = false) {
+  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, x, y)) possibles.push(t)
+      if ((!s || s === slash[t]) && this.validTile(t, loc)) possibles.push(t)
     }
 
     return possibles
@@ -242,41 +258,42 @@ export const Trax = class {
     return this.right - this.left + 1
   }
 
-  validLocation(x, y) {
+  validLocation(loc) {
     if (this.over) return false
-    if (this.tileAt(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.tileAt(x - 1, y) ||
-        this.tileAt(x + 1, y) ||
-        this.tileAt(x, y - 1) ||
-        this.tileAt(x, y + 1),
-    )
+    for (const location of loc.around) {
+      if (this.tileAt(location)) return true
+    }
+
+    return false
   }
 
   possibleLocations() {
-    const locs = { '0x0': { x: 0, y: 0 } } // If no tiles are placed, we can play a starting tile
-    const maybe = (x, y) => {
+    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 loc = x + 'x' + y
-      locs[loc] = locs[loc] || { x, y }
+      const id = this.tileId(loc)
+      locs[id] = locs[id] || loc
     }
 
     for (const 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)
+      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')
+    return Object.values(locs).filter((loc) => loc !== 'tile')
   }
 
   possibleMoves() {
@@ -285,8 +302,8 @@ export const Trax = class {
     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.x, loc.y)) {
-        const drop = this.dropTile(tile, loc.x, loc.y, 'tentative')
+      for (const tile of this.possibleTiles(loc)) {
+        const drop = this.dropTile(tile, loc, 'tentative')
         if (drop.valid) possibles.push(drop.notation)
       }
     }
@@ -294,22 +311,22 @@ export const Trax = class {
     return possibles
   }
 
-  forcedMoves(x, y) {
-    // We just played at x, y, so return all forced moves
+  forcedMoves(loc) {
+    // We just played at loc, so return all forced moves
     const forced = []
     const invalids = {}
-    let check = squaresAround(x, y)
+    let check = loc.around
     while (check.length > 0) {
       const pos = check.shift()
-      if (this.validLocation(pos.x, pos.y)) {
-        const possibles = this.possibleTiles(pos.x, pos.y)
+      if (this.validLocation(pos)) {
+        const possibles = this.possibleTiles(pos)
         if (possibles.length === 1) {
           // Only 1 possible move
-          forced.push(this.addTile(possibles[0], pos.x, pos.y))
-          check = [...check, ...squaresAround(pos.x, pos.y)]
+          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.x, pos.y)
+          const invalid = this.addTile('x', pos)
           if (!invalids[invalid.id]) forced.push(invalid)
           invalids[invalid.id] = true
         }
@@ -319,62 +336,72 @@ export const Trax = class {
     return forced
   }
 
-  notate(type, x, y) {
+  notate(type, loc) {
     // Notation depends on the position of the board BEFORE the move
-    return (
-      Trax.encodeCol(x - this.left + 1) + String(y - this.top + 1) + slash[type]
-    )
+    let notation = Trax.encodeCol(loc.x - this.left + 1)
+    notation += String(loc.y - this.top + 1)
+    notation += slash[type]
+    return notation
   }
 
   decodeNotation(notation) {
-    // Return {type, x, y} from a notation
-    const r = { type: 'x', x: 0, y: 0 } // Default to an invalid move
+    // Return {type, loc} from a notation
+    const bad = { type: 'x', loc: zero }
     const match = notation.match(notationRegex)
-    if (match === null) return r
-    r.x = this.left - 1 + Trax.decodeCol(match[1])
-    r.y = this.top - 1 + Number(match[2])
-    const possible = this.possibleTiles(r.x, r.y, match[3])
-    if (possible) r.type = possible[0]
-    return r
+    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) {
+  follow(color, loc, from) {
     const path = []
-    let id = this.tileId(x, y)
-    let tile = this.tileAt(x, y)
+    let id = this.tileId(loc)
+    let tile = this.tileAt(loc)
     while (tile && path[0] !== id) {
       if (from !== 'top' && upColor(tile) === color) {
         from = 'bottom'
-        y--
+        loc = loc.up
       } else if (from !== 'bottom' && downColor(tile) === color) {
         from = 'top'
-        y++
+        loc = loc.down
       } else if (from !== 'left' && leftColor(tile) === color) {
         from = 'right'
-        x--
+        loc = loc.left
       } else if (from !== 'right' && rightColor(tile) === color) {
         from = 'left'
-        x++
+        loc = loc.right
       }
 
       path.push(id)
-      id = this.tileId(x, y)
-      tile = this.tileAt(x, y)
+      id = this.tileId(loc)
+      tile = this.tileAt(loc)
     }
 
-    return { x, y, path }
+    return { loc, path }
   }
 
-  findEnds(color, x, y) {
+  findEnds(color, loc) {
     const ends = []
-    const tile = this.tileAt(x, y)
-    if (upColor(tile) === color) ends.push(this.follow(color, x, y, 'top'))
-    if (downColor(tile) === color) ends.push(this.follow(color, x, y, 'bottom'))
-    if (leftColor(tile) === color) ends.push(this.follow(color, x, y, 'left'))
-    if (rightColor(tile) === color) ends.push(this.follow(color, x, y, 'right'))
+    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
   }
 
+  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
     const colors = [this.color, Trax.other(this.color)] // Check win for current player first
@@ -382,15 +409,11 @@ export const Trax = class {
       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.x, tile.y)
-        if (ends[0].x === ends[1].x && ends[0].y === ends[1].y) {
+        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.rules !== 'traxloop' && // Check for line win
-          ((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))
-        ) {
+        } 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)]
         }
@@ -418,8 +441,8 @@ export const Trax = class {
   }
 
   playMove(moveNumber, notation) {
-    // Generic API call for dropTile
-    if (moveNumber === this.move) return this.dropTile(notation)
+    // Generic API call for playing a move with move number safety
+    if (moveNumber === this.move + 1) return this.dropTile(notation)
     return { valid: false }
   }
 
@@ -441,7 +464,7 @@ export const Trax = class {
       .filter((n) => !n.endsWith('.'))
   }
 
-  dropTile(type, x, y, tentative = false) {
+  dropTile(type, loc, tentative = false) {
     // Pass in tentative to not save the move
     let dropped = []
     let notation = ''
@@ -461,16 +484,18 @@ export const Trax = class {
     } else {
       if (type.search(notationRegex) === 0) {
         // We were passed a notation
-        ;({ type, x, y } = this.decodeNotation(type))
+        const decoded = this.decodeNotation(type)
+        type = decoded.type
+        loc = decoded.loc
       }
 
-      if (this.validLocation(x, y) && this.validTile(type, x, y)) {
+      if (loc && this.validLocation(loc) && this.validTile(type, loc)) {
         valid = true
         const saved = this.save() // Just in case we need to roll back
-        notation = this.notate(type, x, y) // Determine notation BEFORE we play the move
+        notation = this.notate(type, loc) // Determine notation BEFORE we play the move
         this.updateNotation(notation)
-        dropped.push(this.addTile(type, x, y)) // Play the tile
-        dropped = [...dropped, ...this.forcedMoves(x, y)] // Play all forced moves
+        dropped.push(this.addTile(type, loc)) // Play the tile
+        dropped = [...dropped, ...this.forcedMoves(loc)] // Play all forced moves
         if (this.invalid || tentative) {
           if (this.invalid) valid = false
           this.restore(saved) // Abort! abort!
@@ -490,6 +515,8 @@ export const Trax = class {
     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()
@@ -497,16 +524,8 @@ export const Trax = class {
     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(this.height - x + 1) +
-          String(this.width - y + 1) +
-          slash,
-      )
-      moves.add(
-        Trax.encodeCol(this.width - y + 1) +
-          String(this.height - x + 1) +
-          slash,
-      )
+      moves.add(Trax.encodeCol(X) + String(Y) + slash)
+      moves.add(Trax.encodeCol(Y) + String(X) + slash)
     }
 
     return [...moves]
@@ -547,7 +566,7 @@ export const Trax = class {
     return this.positionCode()
   }
 
-  tentativeIcon(drops) {
+  dropsIcon(drops) {
     return this.positionCode(undefined, undefined, undefined, drops)
   }
 
@@ -562,19 +581,22 @@ export const Trax = class {
     let x = startX
     let y = startY
     do {
-      let tile = this.tileAt(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) {
         tile = applySymmetry(tile, rightToLeft, bottomToTop, rotate)
-        if (this.path.includes(this.tileId(x, y))) {
+        if (this.path.includes(this.tileId(loc))) {
           tile = String.fromCodePoint(tile.codePointAt(0) + this.turn * 6)
         }
 
         if (
           drops &&
           drops.dropped &&
-          drops.dropped.some((t) => t.x === x && t.y === y)
-        )
+          drops.dropped.some((t) => loc.eq(t.loc))
+        ) {
           tile = tile.toUpperCase()
+        }
+
         line += tile
       } else {
         line = addBlank(line)

package/src/point.js

@@ -0,0 +1,116 @@
+/* Copyright 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.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const is = (v, s) => (typeof v).slice(0, 3) === s // Sigh
+
+// Are you tired of doing x,y movements in multiple statements? I am.
+
+// Point: an immutable two-dimensional location (x,y)
+// with functions for moving around quickly to neighboring points
+export const Point = class {
+  #x = 0
+  #y = 0
+
+  constructor(x, y) {
+    if (is(x, 'obj') && is(x.x, 'num') && is(x.y, 'num')) {
+      // You can call this with new Point(point) or new Point({x,y})
+      this.#x = x.x
+      this.#y = x.y
+    } else {
+      // Or with new Point(x, y)
+      if (!is(x, 'num')) throw new SyntaxError('x must be a number')
+      if (!is(y, 'num')) throw new SyntaxError('y must be a number')
+      this.#x = x
+      this.#y = y
+    }
+  }
+
+  get x() {
+    return this.#x
+  }
+
+  set x(_) {
+    throw new ReferenceError('Point is immutable')
+  }
+
+  get y() {
+    return this.#y
+  }
+
+  set y(_) {
+    throw new ReferenceError('Point is immutable')
+  }
+
+  get up() {
+    return new Point(this.#x, this.#y - 1)
+  }
+
+  get down() {
+    return new Point(this.#x, this.#y + 1)
+  }
+
+  get left() {
+    return new Point(this.#x - 1, this.#y)
+  }
+
+  get right() {
+    return new Point(this.#x + 1, this.#y)
+  }
+
+  get around() {
+    return [this.up, this.down, this.left, this.right]
+  }
+
+  dir(direction) {
+    const error = 'direction must be one of: up, down, left, right, u, d, l, r'
+    if (!is(direction, 'str')) throw new SyntaxError(error)
+    if (direction[0] === 'u') return this.up
+    if (direction[0] === 'd') return this.down
+    if (direction[0] === 'l') return this.left
+    if (direction[0] === 'r') return this.right
+    throw new SyntaxError(error)
+  }
+
+  distX(from) {
+    return Math.abs(this.#x - from.x)
+  }
+
+  distY(from) {
+    return Math.abs(this.#y - from.y)
+  }
+
+  distance(from) {
+    return Math.hypot(this.distX(from), this.distY(from))
+  }
+
+  eq(that) {
+    return this.#x === that.x && this.#y === that.y
+  }
+
+  // Play nicely with the rest of the world
+
+  toString() {
+    return 'Point(' + this.#x + ',' + this.#y + ')'
+  }
+
+  toJSON() {
+    return { x: this.#x, y: this.#y }
+  }
+
+  [Symbol.for('nodejs.util.inspect.custom')](_, options) {
+    const [y, s, n] = [options.stylize, 'special', 'number']
+    return `${y('Point', s)}(${y(this.#x, n)},${y(this.#y, n)})`
+  }
+}