@slugbugblue/trax 0.3.1 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slugbugblue/trax",
-  "version": "0.3.1",
+  "version": "0.7.0",
   "description": "Trax game engine and friends",
   "keywords": [
     "trax",
@@ -14,16 +14,40 @@
   "exports": "./engine.js",
   "repository": "gitlab:slugbugblue/trax",
   "scripts": {
-    "test": "tape tests.js",
+    "test": "xo && c8 ava",
     "preversion": "npm test",
     "postversion": "git push && git push --tags"
   },
+  "dependencies": {
+    "env-paths": "^3.0.0",
+    "make-dir": "^3.1.0",
+    "yaml": "^2.0.0-11"
+  },
   "devDependencies": {
-    "eslint": "8.x",
-    "tape": "5.x"
+    "ava": "^4.1.0",
+    "c8": "^7.11.0",
+    "prettier": "^2.6.1",
+    "xo": "^0.48.0"
   },
   "type": "module",
   "engines": {
     "node": "^14.14.0 || >=16.0.0"
+  },
+  "prettier": {
+    "bracketSpacing": true,
+    "proseWrap": "always",
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "all",
+    "useTabs": false
+  },
+  "xo": {
+    "prettier": true,
+    "rules": {
+      "curly": [
+        "error",
+        "multi-line"
+      ]
+    }
   }
 }

package/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)})`
+  }
+}

package/tty.js

@@ -1,4 +1,4 @@
-/* Copyright 2021 Chad Transtrum
+/* Copyright 2021-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,13 +15,15 @@
 
 // Ever wanted to draw Trax boards on the console? I have.
 
-import Trax from './engine.js'
+import process from 'node:process'
 
-const esc = '\x1b['  // start of console color escape code
-const off = esc + 'm'  // color reset code
+import { Trax } from './engine.js'
+
+const esc = '\u001B[' // Start of console color escape code
+const off = esc + 'm' // Color reset code
 
 // display a message with optional color
-const out = (message, fgcolor, bgcolor) => {
+export const outty = (message, fgcolor, bgcolor) => {
   let ansi = fgcolor || bgcolor ? esc : ''
   if (fgcolor) ansi += '38;5;' + fgcolor
   if (bgcolor) ansi += '48;5;' + bgcolor
@@ -29,10 +31,11 @@ const out = (message, fgcolor, bgcolor) => {
   console.log(ansi + message + off)
 }
 
-let set = 'trax' // which color set should we draw with?
+let set = 'trax' // Which color set should we draw with?
 
 // a little magic to display the game in progress
-const color_sets = {  // Colors for terminal sequence: <Esc>[38;5;<color_num>m
+const colorSets = {
+  // Colors for terminal sequence: <Esc>[38;5;<color_num>m
   // b, B, w, W: color of line for each player, capital for a winning line
   // e: empty (ie, board) color, t: tile color
   trax: { b: 238, B: 57, e: 19, t: 74, w: 255, W: 184 },
@@ -41,149 +44,179 @@ const color_sets = {  // Colors for terminal sequence: <Esc>[38;5;<color_num>m
   tentative: { b: 235, B: 18, e: 19, t: 244, w: 252, W: 217 },
 }
 
-const ln = 'm\u2584'  // lower half block -- with the leading m to terminate ansi color escape
-const up = 'm\u2588'  // full block
-const lt = 'm\u2599'  // lower half and left half block
-const rt = 'm\u259f'  // lower half and right half block
-const fg = n => '38;5;' + String(set[n])  // foreground color_num
-const bg = n => '48;5;' + String(set[n])  // background color_num
-const sp = () => esc + bg('e') + 'm '  // lower space
+const ln = 'm\u2584' // Lower half block -- with the leading m to terminate ansi color escape
+const up = 'm\u2588' // Full block
+const lt = 'm\u2599' // Lower half and left half block
+const rt = 'm\u259F' // Lower half and right half block
+const fg = (n) => '38;5;' + String(set[n]) // Foreground color_num
+const bg = (n) => '48;5;' + String(set[n]) // Background color_num
+const sp = () => esc + bg('e') + 'm ' // Lower space
 // tiles are displayed on two lines; the top half of the first line is empty
 // and the second half is composed of three characters, up color surrounded by tile color
-const uptty = clr => esc + fg('t') + ';' + bg('e') + ln
-  + esc + fg(clr) + ln + esc + fg('t') + ln + ' '
-// the top half of the second line has both horizontal lines with a center transition
+const uptty = (clr) => {
+  const left = esc + fg('t') + ';' + bg('e') + ln
+  const center = esc + fg(clr) + ln
+  const right = esc + fg('t') + ln + ' '
+  return left + center + right
+}
+
+// The top half of the second line has both horizontal lines with a center transition
 // while the bottom half is the tile background color surrounding the down color
-const horiztty = clr => esc + fg('t') + ';' + bg(clr) + ln
-const dntty = (clr, oppclr, char) => esc + fg(clr) + (char === up ? '' : ';' + bg(oppclr)) + char
-// list of icon_char => tile line colors for easy reference in order up, right, down, left
-const tiles = { a: 'bbww', b: 'bwbw', c: 'bwwb', d: 'wbbw', e: 'wbwb', f: 'wwbb' }
+const horiztty = (clr) => esc + fg('t') + ';' + bg(clr) + ln
+const dntty = (clr, oppclr, char) =>
+  esc + fg(clr) + (char === up ? '' : ';' + bg(oppclr)) + char
+// List of icon_char => tile line colors for easy reference in order up, right, down, left
+const tiles = {
+  a: 'bbww',
+  b: 'bwbw',
+  c: 'bwwb',
+  d: 'wbbw',
+  e: 'wbwb',
+  f: 'wwbb',
+}
 
-// return the ANSI codes to display a 3x1.5 block tile, one line at a time
-const tile_tty = (tile, top) => { // top: true for first line, false for second
+// Return the ANSI codes to display a 3x1.5 block tile, one line at a time
+const tileTty = (tile, top) => {
+  // Top: true for first line, false for second
   // quick access to tile color and its opposite in upper case
-  let colors = { b: 'b', w: 'w', B: 'w', W: 'b' }
-  let save = set
-  let tentative = tile !== tile.toLowerCase()
-  if (tentative) set = color_sets.tentative
+  const colors = { b: 'b', w: 'w', B: 'w', W: 'b' }
+  const save = set
+  const tentative = tile !== tile.toLowerCase()
+  if (tentative) set = colorSets.tentative
   tile = tile.toLowerCase()
-  if (!(tile in tiles)) { // winning paths are represented by adding 6 to the tile char code
-    tile = String.fromCharCode(tile.charCodeAt(0) - 6)
+  if (!(tile in tiles)) {
+    // Winning paths are represented by adding 6 to the tile char code
+    tile = String.fromCodePoint(tile.codePointAt(0) - 6)
     if (tile in tiles) {
       colors.w = 'W'
       colors.B = 'W'
-    } else {  // and another six for a black win
-      tile = String.fromCharCode(tile.charCodeAt(0) - 6)
+    } else {
+      // And another six for a black win
+      tile = String.fromCodePoint(tile.codePointAt(0) - 6)
       colors.b = 'B'
       colors.W = 'B'
     }
   }
-  let val = false
+
+  let value = false
   if (tile in tiles) {
     tile = tiles[tile]
     if (top) {
-      val = uptty(colors[tile[0]])
+      value = uptty(colors[tile[0]])
     } else {
-      let center_char = tile[1] === tile[2] ? rt : tile[2] === tile[3] ? lt : up
-      let centertty = dntty(colors[tile[2]], colors[tile[2].toUpperCase()], center_char)
-      val = horiztty(colors[tile[3]]) + centertty + horiztty(colors[tile[1]]) + sp()
+      const centerChar =
+        tile[1] === tile[2] ? rt : tile[2] === tile[3] ? lt : up
+      const centertty = dntty(
+        colors[tile[2]],
+        colors[tile[2].toUpperCase()],
+        centerChar,
+      )
+      value =
+        horiztty(colors[tile[3]]) + centertty + horiztty(colors[tile[1]]) + sp()
     }
   }
+
   set = save
-  return val || (top ? '??? ' : '\'\'\' ')
+  return value || (top ? '??? ' : "''' ")
 }
 
-const merge_tentative = () => {
-  color_sets.tentative.e = set.e  // copy empty color to tentative set
-  color_sets.tentative.W = set.W
-  color_sets.tentative.B = set.B
+const mergeTentative = () => {
+  colorSets.tentative.e = set.e // Copy empty color to tentative set
+  colorSets.tentative.W = set.W
+  colorSets.tentative.B = set.B
 }
 
-const print_icon = (icon, set_name) => {
-  set = color_sets[set_name] || color_sets.trax
-  merge_tentative(set)
+const printIcon = (icon, setName) => {
+  set = colorSets[setName] || colorSets.trax
+  mergeTentative(set)
   const on = esc + '38;5;' + String(set.t) + ';48;5;' + String(set.e) + 'm'
   let o1 = '   '
   let o2 = '1  '
   let row = 1
   let width = 1
-  let info = []
-  let line_width = 0
-  while (icon.length) {
-    let c = icon[0]
+  const info = []
+  let lineWidth = 0
+  while (icon.length > 0) {
+    const c = icon[0]
     icon = icon.slice(1)
     if (c === ':') {
-      info.push({o: o1, w: line_width})
-      info.push({o: o2, w: line_width})
+      info.push({ o: o1, w: lineWidth }, { o: o2, w: lineWidth })
       row++
-      width = Math.max(width, line_width)
-      line_width = 0
+      width = Math.max(width, lineWidth)
+      lineWidth = 0
       o1 = '   '
       o2 = String(row).padEnd(3)
     } else if (c >= '0' && c <= '9') {
-      let empty = Number(c) + 1
+      const empty = Number(c) + 1
       o1 += ' '.repeat(empty * 4)
       o2 += ' '.repeat(empty * 4)
-      line_width += empty
+      lineWidth += empty
     } else {
-      o1 += tile_tty(c, 'top')
-      o2 += tile_tty(c)
-      line_width++
+      o1 += tileTty(c, 'top')
+      o2 += tileTty(c)
+      lineWidth++
     }
   }
-  if (o1.length) {
-    info.push({o: o1, w: line_width})
-    info.push({o: o2, w: line_width})
-    width = Math.max(width, line_width)
+
+  if (o1.length > 0) {
+    info.push({ o: o1, w: lineWidth }, { o: o2, w: lineWidth })
+    width = Math.max(width, lineWidth)
   }
-  let columns = process.stdout.columns || 0
-  let rows = process.stdout.rows || 0
+
+  const columns = process.stdout.columns || 0
+  const rows = process.stdout.rows || 0
   if (width * 4 < columns - 4 && info.length < rows - 2) {
-    let col_out = '   '
+    let colOut = '   '
     for (let col = 1; col <= width; col++) {
-      col_out += ' ' + Trax.column(col).padEnd(3)
+      colOut += ' ' + Trax.encodeCol(col).padEnd(3)
+    }
+
+    console.info(on + colOut.padEnd((width + 1) * 4) + off)
+    for (const line of info) {
+      console.info(on + line.o + ''.padEnd((width - line.w) * 4) + ' ' + off)
     }
-    console.info(on + col_out.padEnd((width + 1) * 4) + off)
-    info.forEach(line => console.info(on + line.o + ''.padEnd((width - line.w) * 4) + ' ' + off))
+
     console.info(on + ''.padEnd((width + 1) * 4) + off)
   } else {
     console.warn('Console is too small to display this game')
   }
 }
 
-// flexible way to get a Trax game object
+// Flexible way to get a Trax game object
 //    game = existing Trax instance, or a string indicating the variant name
 //    moves = optional list or string of moves to be made on the game
 // returns a Trax instance
-const trax_game = (game='trax', moves) => {
+export const traxGame = (game = 'trax', moves = '') => {
   let trax
   if (game instanceof Trax) {
     trax = game
     if (moves) {
       if (typeof moves === 'string') moves = moves.split(' ')
-      moves.forEach(move => trax.drop_tile(move))
+      for (const move of moves) trax.dropTile(move)
     }
   } else {
     trax = new Trax(game, moves, 'cli')
   }
+
   return trax
 }
 
-const display_game = (game='trax', moves='', tentative) => {
-  let trax = trax_game(game, moves)
-  let icon = trax.icon
+export const displayGame = (game = 'trax', moves = '', tentative = false) => {
+  const trax = traxGame(game, moves)
+  let { icon } = trax
   if (tentative) {
-    let drops = trax.drop_tile(tentative)
+    const drops = trax.dropTile(tentative)
     if (drops.valid) {
-      icon = trax.tentative_icon(drops)
+      icon = trax.dropsIcon(drops)
     } else {
       tentative = false
     }
   }
+
   console.info(trax.notation)
-  print_icon(icon, trax.rules)
+  printIcon(icon, trax.rules)
   if (tentative) console.info('--- tentative position ---')
-  let name = {1: 'white', 2: 'black'}[trax.turn]
+  const name = { 1: 'white', 2: 'black' }[trax.turn]
   if (trax.over) {
     if (trax.turn) {
       console.info(name + ' wins')
@@ -191,12 +224,6 @@ const display_game = (game='trax', moves='', tentative) => {
       console.info('game end' + (tentative ? 's' : 'ed') + ' in a draw')
     }
   } else if (trax.turn) {
-    console.info((tentative ? 'leaving ' : '') + name +' to play')
+    console.info((tentative ? 'leaving ' : '') + name + ' to play')
   }
 }
-
-export default {
-  display: display_game,
-  game: trax_game,
-  out,
-}

package/.eslintrc.yaml

@@ -1,68 +0,0 @@
-root: true
-
-extends:
-  - eslint:recommended
-
-parserOptions:
-  sourceType: module
-
-env:
-  node: true
-  es2021: true
-
-globals:
-  crypto: readonly
-
-rules:
-  curly:
-    - error
-    - multi-line
-    - consistent
-  dot-location:
-    - error
-    - property
-  dot-notation: warn
-  eqeqeq:
-    - warn
-    - smart
-  guard-for-in: warn
-  indent:
-    - warn
-    - 2
-    - MemberExpression: 0
-      SwitchCase: 1
-  linebreak-style:
-    - error
-    - unix
-  max-len:
-    - warn
-    - code: 99
-      tabWidth: 2
-  no-alert: error
-  no-caller: error
-  no-div-regex: warn
-  no-else-return:
-    - error
-    - allowElseIf: false
-  no-eval: error
-  no-extra-parens: warn
-  no-invalid-this: error
-  no-new: error
-  no-unused-vars: 
-    - warn
-    - vars: all
-      args: all
-      caughtErrors: all
-  no-with: error
-  quotes:
-    - warn
-    - single
-    - avoidEscape: true
-      allowTemplateLiterals: true
-  semi:
-    - error
-    - never
-    - beforeStatementContinuationChars: always
-  wrap-iife:
-    - error
-    - inside

package/jsconfig.json

@@ -1,8 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "es2020",
-    "target": "es2020"
-  },
-  "checkJs": true,
-  "exclude": ["node_modules"]
-}

package/tests.js

@@ -1,11 +0,0 @@
-import test from 'tape'
-import Trax from './engine.js'
-
-test('create trax game', t => {
-  let trax = new Trax('trax', '@0/', 'tape')
-  t.equal(trax.id, 'tape', 'id is assigned')
-  t.equal(trax.count, 1, '1 tile is played')
-  t.equal(trax.turn, 2, 'player 2 is next')
-  t.equal(trax.color, 'b', 'player 2 is black')
-  t.end()
-})