@slugbugblue/trax 0.1.0 → 0.4.0

package/.eslintrc.yaml

@@ -36,7 +36,7 @@ rules:
     - unix
   max-len:
     - warn
-    - code: 119
+    - code: 99
       tabWidth: 2
   no-alert: error
   no-caller: error

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# @slugbugblue/trax
+
+## 0.3.0
+
+Display a tentative move on the screen
+
+* Add `trax.tentative_icon()` function
+* `tty.display()` now accepts a tentative move
+
+## 0.2.0
+
+Breaking changes:
+
+* Converted from CommonJS to ESM
+* `trax.normalized` now prepends turn information to the string
+
+More convenience:
+
+* `trax.color`: the color of the player whose turn it is
+* `Trax.color_of[num]`: go from player number to color
+* `Trax.player_num[color]`: or from color to player number
+* `Trax.other[color]`: easily switch from 'w' to 'b' and back
+
+## 0.1.0
+
+Initial release:
+
+* engine.js
+  * create a new Trax game with `trax = new Trax()`
+  * play one move at a time with `trax.play('@0/')`
+  * ... etc
+
+* tty.js
+  * display a game with `tty.display(trax)`

package/README.md

@@ -26,11 +26,21 @@ The main Trax engine is provided as `engine.js`,
 which can be used as follows:
 
 ```javascript
-const Trax = require('@slugbugblue/trax')
+import Trax from '@slugbugblue/trax'
 
+// default constructor gives you a Trax game
 let trax = new Trax()
-
 trax.play('@0/')
+
+// but you can also select Loop Trax
+let loops = new Trax('traxloop')
+
+// or 8x8 Trax
+let tiny = new Trax('trax8')
+
+// and the constructor lets you start with an initial set of moves
+let puzzle = new Trax('trax', '@0/ a0\\ @2/')
+puzzle.play('@2\\')
 ```
 
 Explore the file `engine.js` for more information
@@ -48,7 +58,7 @@ until I get around to documenting the functionality.
 
 This project is built by [Chad Transtrum][ctrans]
 for [slugbugblue.com][sbb].
-Issues can be opened on the 
+Issues can be opened on the
 [gitlab project page][repo].
 
 ## Contributing
@@ -66,18 +76,21 @@ and for his generosity in allowing me to
 add the game to [GoldToken.com][goldtoken].
 
 Thanks to his widow Colleen Foley-Smith
-for extending that generosity
-to allow me to include Trax on [slugbugblue.com][sbb].
+for extending that courtesy
+to allow me to include Trax on [slugbugblue.com][sbb]
+as well.
 
 I would also like to extend a huge heartfelt appreciation
 to the magnanimous [Donald G. Bailey][dgb],
 who, through his excellent [book][traxbook],
-taught me the basics (and more!) of Trax
-and was always ready to share his insights
+taught me the basics (and more!) of Trax.
+I found him always ready to share his insights
 on the mechanics of the game,
-various approaches to encoding its complexities,
-and for his undeserved kindness
-in indulging my many questions.
+as well as various approaches to encoding its complexities.
+His undeserved kindness
+and infinite patience
+in indulging my many questions
+can never be repaid.
 
 ## License
 
@@ -98,7 +111,7 @@ limitations under the License.
 
 ## Trax rules copyright
 
-In the United States, game mechanics may not be copyrighted,
+In the United States, game mechanics may not be copyrighted;
 however, the specific wording of game rules does fall under copyright law.
 
 The official rules for Trax are found at http://traxgame.com/about_rules.php.

package/engine.js

@@ -1,11 +1,11 @@
-/* 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.
  * 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.
@@ -19,6 +19,7 @@
 // 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
 
 // fun trax helper constants
 
@@ -33,7 +34,9 @@ const symmetry = {  // convert tile to different views
 
 const notation_regex = /^ *([@a-z]+) *(\d+) *([/\\+]) *$/i
 
-const variants = ['trax', 'traxloop', 'trax8']  // known variants
+const color_of = { 1: 'w', 2: 'b' }
+const player_num = { b: 2, w: 1 }
+const other = { b: 'w', w: 'b' }
 
 // fun trax helper functions
 
@@ -84,16 +87,17 @@ 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 }
-      }
-      this.play_move(move.move, move.notation)
-    })
+    if (moves) {
+      if (typeof moves === 'string') moves = moves.split(' ')
+      moves.forEach(move => {
+        if (typeof move === 'string') {
+          move = { move: this.move, notation: move }
+        }
+        this.play_move(move.move, move.notation)
+      })
+    }
   }
 
   save () { // in order to evaluate potential moves, we have to modify the state
@@ -108,7 +112,6 @@ const Trax = class {
       notation: this.notation,
       tiles: JSON.stringify(this.tiles),
       path: JSON.stringify(this.path),
-      count: this.count,
       invalid: this.invalid,
     }
   }
@@ -124,10 +127,17 @@ 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
   }
 
+  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 game_over () { // returns true if the game is over
     return this.over
   }
@@ -147,7 +157,6 @@ const Trax = class {
       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)
@@ -194,17 +203,27 @@ const Trax = class {
       if (this.width > 7 && (x < this.left || x > this.right)) return false
       if (this.height > 7 && (y < this.top || y > this.bottom)) return false
     }
-    return this.tile_at(x-1, y) || this.tile_at(x+1, y) || this.tile_at(x, y-1) || this.tile_at(x, y+1)
+    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)
+    )
   }
 
   possible_locations () {
-    let possibles = []
-    for (let x = this.left - 1 ; x <= this.right + 1 ; x++) {
-      for (let y = this.top -1 ; y <= this.bottom + 1 ; y ++) {
-        if (this.valid_location(x, y)) possibles.push({x, y})
-      }
+    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 }
     }
-    return possibles
+    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)
+    }
+    // get rid of all the real tiles and return all the maybes
+    return Object.values(locs).filter(l => l !== 'tile')
   }
 
   possible_moves () { // returns a list of every currently possible move
@@ -293,13 +312,12 @@ const Trax = class {
 
   check_win (tiles) {
     let winner = false
-    let colors = this.turn === 1 ? ['w', 'b'] : ['b', 'w'] // check win for current player first
+    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
@@ -314,12 +332,14 @@ const Trax = class {
     })
     if (winner) {
       this.over = true
-      this.turn = winner === 'w' ? 1 : 2
+      this.turn = player_num[winner]
     } else {
       // 8x8 Trax can end in a tie once there are no valid moves left
-      if (this.rules === 'trax8' && this.possible_moves().length < 1) {
-        this.over = true
-        this.turn = 0 // tie
+      if (this.rules === 'trax8' && this.width > 7 && this.height > 7) {
+        if (this.possible_moves().length < 1) {
+          this.over = true
+          this.turn = 0 // tie
+        }
       }
     }
   }
@@ -371,56 +391,66 @@ const Trax = class {
         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
-        if (!tentative) this.check_win(dropped, tentative)
         if (this.invalid || tentative) {
-          valid = false
+          if (this.invalid) valid = false
           this.restore(saved) // abort! abort!
-        } else if (!this.over) {
-          this.turn = this.turn === 1 ? 2 : 1
+        } else {
+          this.check_win(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
+  move_rotations (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
-  }
-
-  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(':')
+    if (match === null) return []
+    let x = decode_col(match[1])
+    let y = Number(match[2])
+    let s = match[3]
+    let slashes = s === '+' ? [s] : ['/', '\\']
+    let moves = new Set()
+    // this isn't super precise, but it limits the search space ... maybe #TODO?
+    for (let slash of slashes) {
+      moves.add(encode_col(x) + String(y) + slash)
+      moves.add(encode_col(y) + String(x) + slash)
+      moves.add(encode_col(this.height - x + 1) + String(this.width - y + 1) + slash)
+      moves.add(encode_col(this.width - y + 1) + String(this.height -x + 1) + slash)
+    }
+    return [...moves]
+  }
+
+  provisional_move (from, to, via) { // test a provisional move against the current state
+    let rows = from.slice(1).split(':')
     let cols = rows.reduce((acc, cur) => Math.max(acc, code_row_len(cur)), 0)
     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 (prov[1] === this.normalized) {
-      let move = prov[2]
+    if (from === this.normalized) {
       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
+      for (let move of this.move_rotations(via)) { // try all symmetrical moves
+        let drop = this.drop_tile(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()
   }
 
+  tentative_icon (drops) {
+    return this.position_code(undefined, undefined, undefined, undefined, drops)
+  }
+
   // symmetry helper
-  position_code (right_to_left, bottom_to_top, rotate, swap_colors) {
+  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
@@ -439,6 +469,9 @@ const Trax = class {
         if (this.path.includes(this.tile_id(x, y))) {
           tile = String.fromCharCode(tile.charCodeAt(0) + this.turn * 6)
         }
+        if (drops && drops.dropped) {
+          if (drops.dropped.filter(t => t.x === x && t.y === y).length) tile = tile.toUpperCase()
+        }
         line += tile
       } else {
         line = add_blank(line)
@@ -481,7 +514,7 @@ const Trax = class {
         })
       })
     })
-    return norm
+    return (this.color || 't').toUpperCase() + norm
   }
 
   get normalized () {
@@ -490,7 +523,13 @@ const Trax = class {
   }
 }
 
-Trax.column = (col) => encode_col(col)
+// 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
 
-module.exports = Trax
+export default Trax

package/jsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "module": "commonjs",
+    "module": "es2020",
     "target": "es2020"
   },
   "checkJs": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slugbugblue/trax",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "Trax game engine and friends",
   "keywords": [
     "trax",
@@ -11,18 +11,20 @@
   "bugs": "https://gitlab.com/slugbugblue/trax/issues",
   "license": "Apache-2.0",
   "author": "Chad Transtrum <chad@transtrum.net>",
-  "main": "engine.js",
+  "exports": "./engine.js",
   "repository": "gitlab:slugbugblue/trax",
   "scripts": {
-    "test": "tape tests.js"
+    "test": "c8 tap --no-coverage",
+    "preversion": "npm test",
+    "postversion": "git push && git push --tags"
   },
   "devDependencies": {
-    "eslint": "8.x",
-    "tape": "5.x",
-    "typescript": "^4.5.4",
-    "typescript-language-server": "^0.8.1"
+    "c8": "^7.11.0",
+    "eslint": "^8.7.0",
+    "tap": "^15.1.6"
   },
+  "type": "module",
   "engines": {
-    "node": ">=16.0.0"
+    "node": "^14.14.0 || >=16.0.0"
   }
 }

package/tty.js

@@ -1,11 +1,11 @@
 /* Copyright 2021 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.
@@ -13,17 +13,12 @@
  * limitations under the License.
  */
 
-// Console functions for Trax
+// Ever wanted to draw Trax boards on the console? I have.
 
-/* eslint-disable no-console */
-
-const Trax = require('./engine')
-
-// fix Javascript's broken typeof
-const TypeOf = o => ({}).toString.call(o).slice(8,-1)
+import Trax from './engine.js'
 
 const esc = '\x1b['  // start of console color escape code
-const off = esc + 'm'
+const off = esc + 'm'  // color reset code
 
 // display a message with optional color
 const out = (message, fgcolor, bgcolor) => {
@@ -34,34 +29,44 @@ const out = (message, fgcolor, bgcolor) => {
   console.log(ansi + message + off)
 }
 
+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
+  // 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 },
   trax8: { b: 236, B: 21, e: 58, t: 137, w: 254, W: 117 },
   traxloop: { b: 235, B: 20, e: 17, t: 61, w: 253, W: 222 },
+  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
+// 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
+// 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' }
+
 // return the ANSI codes to display a 3x1.5 block tile, one line at a time
-const tile_tty = (set, tile, top) => { // top: true for first line, false for second
-  const ln = 'm\u2584'  // lower half block -- with the leading m to terminate a terminal color escape sequence
-  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
-  // 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 tile_tty = (tile, top) => { // top: true for first line, false for second
   // quick access to tile color and its opposite in upper case
-  const colors = { b: 'b', w: 'w', B: 'w', W: 'b' }
+  let colors = { b: 'b', w: 'w', B: 'w', W: 'b' }
+  let save = set
+  let tentative = tile !== tile.toLowerCase()
+  if (tentative) set = color_sets.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) {
@@ -73,19 +78,30 @@ const tile_tty = (set, tile, top) => { // top: true for first line, false for se
       colors.W = 'B'
     }
   }
+  let val = false
   if (tile in tiles) {
     tile = tiles[tile]
-    if (top) return uptty(colors[tile[0]])
-    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)
-    return horiztty(colors[tile[3]]) + centertty + horiztty(colors[tile[1]]) + sp
+    if (top) {
+      val = 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()
+    }
   }
-  if (top) return '??? '
-  return '\'\'\' '
+  set = save
+  return val || (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 print_icon = (icon, set_name) => {
-  let set = color_sets[set_name] || color_sets.trax
+  set = color_sets[set_name] || color_sets.trax
+  merge_tentative(set)
   const on = esc + '38;5;' + String(set.t) + ';48;5;' + String(set.e) + 'm'
   let o1 = '   '
   let o2 = '1  '
@@ -110,8 +126,8 @@ const print_icon = (icon, set_name) => {
       o2 += ' '.repeat(empty * 4)
       line_width += empty
     } else {
-      o1 += tile_tty(set, c, 'top')
-      o2 += tile_tty(set, c)
+      o1 += tile_tty(c, 'top')
+      o2 += tile_tty(c)
       line_width++
     }
   }
@@ -144,7 +160,7 @@ const trax_game = (game='trax', moves) => {
   if (game instanceof Trax) {
     trax = game
     if (moves) {
-      if (TypeOf(moves) === 'String') moves = moves.split(' ')
+      if (typeof moves === 'string') moves = moves.split(' ')
       moves.forEach(move => trax.drop_tile(move))
     }
   } else {
@@ -153,23 +169,33 @@ const trax_game = (game='trax', moves) => {
   return trax
 }
 
-const display_game = (game='trax', moves='') => {
+const display_game = (game='trax', moves='', tentative) => {
   let trax = trax_game(game, moves)
+  let icon = trax.icon
+  if (tentative) {
+    let drops = trax.drop_tile(tentative)
+    if (drops.valid) {
+      icon = trax.tentative_icon(drops)
+    } else {
+      tentative = false
+    }
+  }
   console.info(trax.notation)
-  print_icon(trax.icon, trax.rules)
-  let name = {0: 'nobody', 1: 'white', 2: 'black'}[trax.turn]
+  print_icon(icon, trax.rules)
+  if (tentative) console.info('--- tentative position ---')
+  let name = {1: 'white', 2: 'black'}[trax.turn]
   if (trax.over) {
     if (trax.turn) {
       console.info(name + ' wins')
     } else {
-      console.info('game ended in a draw')
+      console.info('game end' + (tentative ? 's' : 'ed') + ' in a draw')
     }
   } else if (trax.turn) {
-    console.info(name +' to play')
+    console.info((tentative ? 'leaving ' : '') + name +' to play')
   }
 }
 
-module.exports = {
+export default {
   display: display_game,
   game: trax_game,
   out,