@slugbugblue/trax 0.7.0 → 0.10.0

package/src/cmds/play-try.js

@@ -0,0 +1,129 @@
+/* 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.
+ */
+
+// CLI play/try commands
+
+const moveRx = /^\d+\.?$/
+const notationRx = /^[@a-z]+\d+[bps/\\+]$/i
+
+export const playCmd = {
+  name: 'play',
+  alt: ['move', 'mv'],
+  args: '<move> [...]',
+  comp: '<play>',
+  desc: 'play a move',
+  rx: [moveRx, notationRx],
+  help: [
+    'Enter the move in standard Trax notation. The final character of the',
+    'notation can be replaced with a letter for ease of entering at the',
+    'command line. Use <s> for "/", <b> for "\\", and <p> for "+".',
+    'Multiple moves can be submitted at once. Move numbers are optional,',
+    'but if included, they will be checked for accuracy.',
+  ],
+}
+
+export const tryCmd = {
+  name: 'try',
+  alt: 'see',
+  args: '<move>',
+  comp: '<play>',
+  desc: 'see the effects of a move',
+  help: [
+    'View a move without committing to it. This is useful for seeing the',
+    'effects of forced tiles.',
+  ],
+}
+
+const fixNotation = (move) => {
+  if (move.endsWith('b')) return move.slice(0, -1) + '\\'
+  if (move.endsWith('s')) return move.slice(0, -1) + '/'
+  if (move.endsWith('p')) return move.slice(0, -1) + '+'
+  return move
+}
+
+playCmd.fn = (CLI, ...moves) => {
+  if (moves.length === 0 || !moves[0]) {
+    CLI.error('You must provide a move.')
+    return CLI.do('help', 'play')
+  }
+
+  if (!CLI.GAME?.id) {
+    CLI.do('new')
+  }
+
+  if (CLI.TRAX.over) {
+    return CLI.error('The game is over.')
+  }
+
+  const start = CLI.TRAX.move
+  let checkMove
+
+  for (let move of moves) {
+    if (notationRx.test(move)) {
+      const moveNumber = CLI.TRAX.move
+      move = fixNotation(move)
+      if (checkMove) {
+        CLI.TRAX.playMove(checkMove, move)
+      } else {
+        CLI.TRAX.play(move)
+      }
+
+      if (CLI.TRAX.move === moveNumber) {
+        CLI.error(
+          'Move "' +
+            (checkMove ? checkMove + '. ' : '') +
+            move +
+            '" is invalid.',
+        )
+      }
+    } else if (moveRx.test(move)) {
+      checkMove = Number(move)
+    } else if (move) {
+      CLI.error('Move "' + move + '" is not in the correct notation.')
+    }
+  }
+
+  if (CLI.TRAX.move !== start) {
+    CLI.updateGameData()
+    CLI.do('view')
+  }
+}
+
+tryCmd.fn = (CLI, move) => {
+  if (move.length === 0) {
+    CLI.error('You must provide a move.')
+    return CLI.do('help', 'try')
+  }
+
+  if (!CLI.TRAX) {
+    CLI.do('new')
+  }
+
+  if (CLI.TRAX.over) {
+    return CLI.error('The game is over.')
+  }
+
+  if (notationRx.test(move)) {
+    move = fixNotation(move)
+    const play = CLI.TRAX.dropTile(move, undefined, 'tentative')
+    if (play.valid || play.dropped.length > 0) {
+      CLI.display(CLI.TRAX, CLI.GAME.players, move)
+    } else {
+      CLI.error('Move is invalid.')
+    }
+  } else {
+    CLI.error('Move is invalid.')
+  }
+}

package/src/cmds/select.js

@@ -0,0 +1,47 @@
+/* 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.
+ */
+
+// CLI select command
+
+export const selectCmd = {
+  name: 'select',
+  alt: ['choose', '#'],
+  args: '#id [command]',
+  comp: '<id> <cmd>',
+  desc: 'select a different game',
+  rx: /^#\d+$/,
+  help: [
+    'Make another game the default game of future commands. If another',
+    'command is included, that command will be run immediately.',
+  ],
+}
+
+selectCmd.fn = (CLI, id, ...cmds) => {
+  if (!id) {
+    CLI.error('Missing id.')
+    return CLI.do('help', 'select')
+  }
+
+  if (id.startsWith('#')) id = id.slice(1)
+  CLI.load(id)
+  if (String(CLI.GAME?.id) === id) {
+    CLI.out(CLI.color(`Game #${id} selected.`))
+    if (cmds.length > 0) {
+      CLI.doNext(cmds.join(' '))
+    }
+  } else {
+    CLI.error('Invalid id. Type "list" to see available games.')
+  }
+}

package/src/cmds/undo.js

@@ -0,0 +1,40 @@
+/* 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.
+ */
+
+// CLI undo command
+
+export const undoCmd = {
+  name: 'undo',
+  args: '[n]',
+  comp: '<move>',
+  desc: 'undo the last move in a game',
+  help: [
+    'Backtrack one or more moves in a game. Type "undo" to take back the last',
+    'move, or "undo 2" to undo the last two moves.',
+  ],
+}
+
+undoCmd.fn = (CLI, n) => {
+  n = Math.max(1, Math.floor(Number(n) || 1)) // Get an integer 1 or higher
+
+  const { moves } = CLI.TRAX
+  const undo = moves.slice(0, 0 - n)
+  if (moves.length === undo.length) {
+    CLI.error('Unable to undo.')
+  } else {
+    CLI.setGame(undo)
+    CLI.do('view')
+  }
+}

package/src/cmds/view.js

@@ -0,0 +1,53 @@
+/* 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.
+ */
+
+// CLI view command
+
+export const viewCmd = {
+  name: 'view',
+  alt: ['show', 'display'],
+  args: '[move number]',
+  comp: '<move>',
+  desc: 'show the game board',
+  help: [
+    'Show the current game. Include a move number to see the board as it was at',
+    'that move.',
+  ],
+}
+
+viewCmd.fn = (CLI, move) => {
+  if (!CLI.GAME?.id) {
+    return CLI.error('No active game. Type "new" to start a game.')
+  }
+
+  const trax = CLI.TRAX
+
+  let show = Number.POSITIVE_INFINITY
+  if (move && Number(move) >= 0 && Number(move) <= trax.moves.length) {
+    show = Number(move)
+  }
+
+  const players = CLI.GAME.players || ['white', 'black']
+
+  CLI.out(
+    CLI.color('#' + CLI.ID + ' ') +
+      CLI.name(trax.rules) +
+      ' ' +
+      CLI.bubble('w' + (trax.turn === 1 ? 'h' : ''), players[0]) +
+      CLI.color(' vs ') +
+      CLI.bubble('b' + (trax.turn === 2 ? 'h' : ''), players[1]),
+  )
+  CLI.display(trax, players, false, show)
+}

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

@@ -24,7 +24,7 @@ import { Point } from './point.js'
 // Fun trax helper constants
 
 const zero = new Point(0, 0)
-const notationRegex = /^ *([@a-z]+) *(\d+) *([/\\+]) *$/i
+const notationRegex = /^([@a-z]+)(\d+)([/\\+])$/i
 
 const slash = { a: '\\', b: '+', c: '/', d: '/', e: '+', f: '\\' }
 
@@ -72,7 +72,13 @@ 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)
@@ -122,13 +128,9 @@ export const Trax = class {
     // 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)
+      for (const move of moves) {
+        if (notationRegex.test(move)) {
+          this.dropTile(move)
         }
       }
     }
@@ -170,6 +172,11 @@ export const Trax = class {
     }
   }
 
+  get name() {
+    // Get the name of this variant
+    return Trax.names[this.rules]
+  }
+
   get count() {
     // Get the number of tiles currently in play
     return Object.keys(this.tiles).length
@@ -433,9 +440,9 @@ export const Trax = class {
     return this.dropTile(notation)
   }
 
-  playMove(currentMoveNumber, nextMoveNotation) {
-    // Generic API call for dropTile
-    if (currentMoveNumber === this.move) return this.dropTile(nextMoveNotation)
+  playMove(moveNumber, notation) {
+    // Generic API call for playing a move with move number safety
+    if (moveNumber === this.move + 1) return this.dropTile(notation)
     return { valid: false }
   }
 
@@ -482,7 +489,7 @@ export const Trax = class {
         loc = decoded.loc
       }
 
-      if (this.validLocation(loc) && this.validTile(type, loc)) {
+      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, loc) // Determine notation BEFORE we play the move

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

@@ -23,6 +23,8 @@ export const Point = class {
   #x = 0
   #y = 0
 
+  static dirs = ['up', 'down', 'left', 'right']
+
   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})
@@ -76,6 +78,7 @@ export const Point = class {
   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)
+    direction = direction.toLowerCase()
     if (direction[0] === 'u') return this.up
     if (direction[0] === 'd') return this.down
     if (direction[0] === 'l') return this.left
@@ -99,6 +102,15 @@ export const Point = class {
     return this.#x === that.x && this.#y === that.y
   }
 
+  in(topLeft, bottomRight) {
+    return (
+      this.x >= topLeft.x &&
+      this.x <= bottomRight.x &&
+      this.y >= topLeft.y &&
+      this.y <= bottomRight.y
+    )
+  }
+
   // Play nicely with the rest of the world
 
   toString() {

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

@@ -22,13 +22,17 @@ 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
+// Colorize a string
+export const color = (contents = '', fgcolor = '', bgcolor = '') => {
+  const c = []
+  if (fgcolor) c.push('38;5;' + fgcolor)
+  if (bgcolor) c.push('48;5;' + bgcolor)
+  return esc + c.join(';') + 'm' + contents
+}
+
+// Display a message with optional color
 export const outty = (message, fgcolor, bgcolor) => {
-  let ansi = fgcolor || bgcolor ? esc : ''
-  if (fgcolor) ansi += '38;5;' + fgcolor
-  if (bgcolor) ansi += '48;5;' + bgcolor
-  if (ansi) ansi += 'm'
-  console.log(ansi + message + off)
+  console.log(color(message, fgcolor, bgcolor) + off)
 }
 
 let set = 'trax' // Which color set should we draw with?
@@ -44,6 +48,28 @@ const colorSets = {
   tentative: { b: 235, B: 18, e: 19, t: 244, w: 252, W: 217 },
 }
 
+export const name = (rules) => {
+  if (Trax.variants.has(rules)) {
+    return color(Trax.names[rules], colorSets[rules].t)
+  }
+
+  return rules
+}
+
+export const bubble = (clr, text) => {
+  const colors = {
+    w: { fg: 236, bg: 153 },
+    b: { fg: 250, bg: 18 },
+    wd: { fg: 236, bg: 248 },
+    bd: { fg: 248, bg: 236 },
+    wh: { fg: 63, bg: 123 },
+    bh: { fg: 220, bg: 20 },
+  }
+
+  const c = colors[clr]
+  return color('', c.bg) + color(text, c.fg, c.bg) + off + color('', c.bg)
+}
+
 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
@@ -201,29 +227,76 @@ export const traxGame = (game = 'trax', moves = '') => {
   return trax
 }
 
-export const displayGame = (game = 'trax', moves = '', tentative = false) => {
-  const trax = traxGame(game, moves)
+const printNotation = (trax, tentative, show = Number.POSITIVE_INFINITY) => {
+  let b = false
+  let n = 1
+  let out = ''
+  let length = 0
+  const t = tentative ? trax.moves.length - 1 : show
+  for (const move of trax.moves) {
+    const c = (b ? 'b' : 'w') + (t < n ? 'd' : show === n ? 'h' : '')
+    const notation = String(n) + ' ' + move
+    if (length + notation.length + 3 > process.stdout.columns) {
+      out += '\n'
+      length = 0
+    }
+
+    out += bubble(c, notation) + ' '
+    length += notation.length + 3
+    b = !b
+    n++
+  }
+
+  outty(out)
+}
+
+export const display = (
+  game,
+  players,
+  tentative = false,
+  showMove = Number.POSITIVE_INFINITY,
+) => {
+  const trax = traxGame(game)
+  const saved = trax.save()
+  const colors = ['white', 'black']
+  if (!Array.isArray(players)) players = colors
   let { icon } = trax
   if (tentative) {
     const drops = trax.dropTile(tentative)
-    if (drops.valid) {
+    if (drops.valid || drops.dropped.length > 0) {
       icon = trax.dropsIcon(drops)
     } else {
       tentative = false
     }
+  } else if (showMove <= trax.moves.length) {
+    icon = trax.dropsIcon({
+      dropped: Object.values(trax.tiles).filter((t) => t.move > showMove),
+    })
   }
 
-  console.info(trax.notation)
+  printNotation(trax, tentative, showMove)
   printIcon(icon, trax.rules)
-  if (tentative) console.info('--- tentative position ---')
-  const name = { 1: 'white', 2: 'black' }[trax.turn]
+  const nameColor = { 1: 'w', 2: 'b' }[trax.turn]
+  if (tentative) {
+    const otherColor = { w: 'bd', b: 'wd' }[nameColor] || 'wd'
+    outty('---' + bubble(otherColor, 'tentative position') + off + '---')
+  }
+
+  const name = players[trax.turn - 1] || colors[trax.turn - 1]
   if (trax.over) {
     if (trax.turn) {
-      console.info(name + ' wins')
+      outty(bubble(nameColor + 'h', name) + off + ' wins')
     } else {
-      console.info('game end' + (tentative ? 's' : 'ed') + ' in a draw')
+      outty('game end' + (tentative ? 's' : 'ed') + ' in a draw')
     }
   } else if (trax.turn) {
-    console.info((tentative ? 'leaving ' : '') + name + ' to play')
+    outty(
+      (tentative ? 'leaving ' : '') +
+        bubble(nameColor, name) +
+        off +
+        ' to play',
+    )
   }
+
+  if (tentative) trax.restore(saved)
 }

package/src/version.js

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '0.10.0'