@slugbugblue/trax-cli 0.11.0

package/src/cmds/list.js

@@ -0,0 +1,177 @@
+/* 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 list command
+
+import process from 'node:process'
+
+import { Trax } from '@slugbugblue/trax'
+
+export const listCmd = {
+  name: 'list',
+  alt: 'ls',
+  args: '[sort|filter...] ["reverse"]',
+  desc: 'list all games',
+  comp:
+    'id|number game|rules|name player1|p1 player2|p2 move|status turn' +
+    ' active|over trax|8x8|loop reverse',
+  help: [
+    'Valid sort options are:',
+    '  "id": sort by game id',
+    '  "game": sort by game type',
+    '  "player1" or "player2": sort by player name',
+    '  "moves": sort by the number of moves',
+    'Available filters:',
+    '  #id: match a game or a certain number of moves',
+    '  "active" or "over": whether a game is in progress or not',
+    '  "loop" or "8x8" or "trax": filter by game type',
+    "  <other text>: match a player's name or the latest game note",
+    'Add the "reverse" option to reverse the sort order.',
+  ],
+}
+
+const alphaSort = (a, b) => {
+  a = String(a).toLowerCase()
+  b = String(b).toLowerCase()
+  if (a < b) return -1
+  if (b < a) return 1
+  return 0
+}
+
+const sortBy = (sort) => {
+  if (!sort) return 'id'
+  sort = sort.toLowerCase()
+  if (sort === '#') return 'sid'
+  if ('ids'.startsWith(sort)) return 'sid'
+  if ('games'.startsWith(sort)) return 'rules'
+  if ('rules'.startsWith(sort)) return 'rules'
+  if ('names'.startsWith(sort)) return 'rules'
+  if ('numbers'.startsWith(sort)) return 'sid'
+  if ('moves'.startsWith(sort)) return 'smoves'
+  if ('status'.startsWith(sort)) return 'smoves'
+  if ('turn'.startsWith(sort)) return 'sturn'
+  if ('player'.startsWith(sort) && sort.endsWith('1')) return 'p1'
+  if ('player'.startsWith(sort) && sort.endsWith('2')) return 'p2'
+  if ('reverse'.startsWith(sort)) return 'reverse'
+  return sort
+}
+
+const listSort = (list, filters) => {
+  if (list.length === 0) return list
+  let reverse = false
+  for (const sort of filters) {
+    const by = sortBy(sort)
+    if (by === 'reverse') {
+      reverse = true
+    } else if (list[0]?.[by]) {
+      list.sort((a, b) => alphaSort(a[by], b[by]))
+    } else if (by === 'trax') {
+      list = list.filter((g) => g.rules === by)
+    } else if (['over', 'active'].includes(by)) {
+      list = list.filter((g) => (by === 'over' ? g.over : !g.over))
+    } else {
+      list = list.filter((g) => {
+        return (
+          g.id.endsWith(by) ||
+          Trax.names[g.rules].toLowerCase().includes(by) ||
+          g.p1.toLowerCase().includes(by) ||
+          g.p2.toLowerCase().includes(by) ||
+          g.moves.startsWith(by + ' ') ||
+          g.note.includes(by)
+        )
+      })
+    }
+  }
+
+  if (reverse) list.reverse()
+
+  return list
+}
+
+/** Find how many columns are left over after all the other columns arefilled.
+ * @arg {Record<string, number>} sizes
+ * @returns {number} number of columns left over
+ */
+const leftover = (sizes) => {
+  let left = process.stdout.columns
+  for (const size of Object.values(sizes)) {
+    left -= size
+  }
+
+  return left
+}
+
+listCmd.fn = (CLI, ...filters) => {
+  if (Object.keys(CLI.GAMES).length === 0) {
+    return CLI.error('No games. Type "new" to start a new game.')
+  }
+
+  const puzzle = filters.find((f) => f.length > 1 && 'puzzles'.startsWith(f))
+  if (puzzle) return CLI.do('puzzles', ...filters.filter((f) => f !== puzzle))
+
+  let list = []
+  const size = {
+    spacing: 13, // Amount of space taken up by fixed-length and between columns
+    id: 1,
+    name: 1,
+    moves: 1,
+    p1: 1,
+    p2: 1,
+  }
+  let noteSize = Number.POSITIVE_INFINITY
+
+  for (const game of Object.values(CLI.GAMES)) {
+    const moves = game.moves.length === 0 ? 0 : game.moves.split(' ').length
+    list.push({
+      sid: String(game.id).padStart(9, '0'),
+      id: (game.id === CLI.GAME.id ? '* #' : '#') + String(game.id),
+      name: game.name?.length || 0,
+      rules: game.rules,
+      moves: game.over ? 'game over' : CLI.plural(moves, 'move'),
+      smoves: game.over ? '9999' : String(moves).padStart(9, '0'),
+      sturn: String(game.turn),
+      p1: game.players?.[0] || 'white',
+      p2: game.players?.[1] || 'black',
+      turn: game.turn,
+      over: game.over,
+      note: game.notes?.[game.notes.length - 1]?.note || '',
+    })
+  }
+
+  list = listSort(list, filters)
+
+  for (const game of list) {
+    size.id = Math.max(size.id, game.id.length)
+    size.name = Math.max(size.name, game.name)
+    size.moves = Math.max(size.moves, game.moves.length)
+    size.p1 = Math.max(size.p1, game.p1.length)
+    size.p2 = Math.max(size.p2, game.p2.length)
+    noteSize = Math.min(noteSize, leftover(size))
+  }
+
+  for (const game of list) {
+    CLI.out(
+      CLI.color(game.id.padStart(size.id) + ' ') +
+        Trax.names[game.rules] +
+        ' '.repeat(size.name - game.name + 1) +
+        CLI.bubble(game.turn === 1 ? 'wh' : 'w', game.p1) +
+        CLI.color('vs '.padStart(size.p1 - game.p1.length + 4)) +
+        CLI.bubble(game.turn === 2 ? 'bh' : 'b', game.p2) +
+        CLI.color(' '.padStart(size.p2 - game.p2.length + 1)) +
+        CLI.color(game.moves.padEnd(size.moves)) +
+        CLI.color.help(' ' + game.note.slice(0, noteSize)),
+    )
+  }
+}

package/src/cmds/new.js

@@ -0,0 +1,136 @@
+/* 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 new command
+
+export const newCmd = {
+  name: 'new',
+  alt: 'start',
+  args: '[variant] [[p1 name] "vs" [p2 name]]',
+  comp: 'trax|loop|8x8 vs',
+  desc: 'start a new game',
+  help: [
+    'Valid variants are "trax", "loop", and "8x8". Defaults to "trax" if not',
+    'specified. Use the "vs" keyword to use specific names for the players.',
+  ],
+}
+
+// Okay, yes, this is silly
+const pairs = [
+  ['Abbott', 'Costello'],
+  ['Adam', 'Eve'],
+  ['Anne Boleyn', 'Henry VIII'],
+  ['Ash', 'Pikachu'],
+  ['Barbie', 'Ken'],
+  ['Batman', 'Robin'],
+  ['Bert', 'Ernie'],
+  ['Bonnie', 'Clyde'],
+  ['Calvin', 'Hobbes'],
+  ['Chip', 'Dale'],
+  ['Donald', 'Daisy'],
+  ['Fred', 'Barney'],
+  ['Fred', 'George'],
+  ['Frodo', 'Samwise'],
+  ['Han', 'Chewie'],
+  ['Harry', 'Ron'],
+  ['Holmes', 'Watson'],
+  ['Jekyll', 'Hyde'],
+  ['Jim', 'Pam'],
+  ['Joe', 'Volcano'],
+  ['John', 'Yoko'],
+  ['King Kong', 'Godzilla'],
+  ['Lewis', 'Clark'],
+  ['Lilo', 'Stitch'],
+  ['Luke', 'Leia'],
+  ['Marge', 'Homer'],
+  ['Mario', 'Luigi'],
+  ['Marlin', 'Dory'],
+  ['Mary-Kate', 'Ashley'],
+  ['Mickey', 'Minnie'],
+  ['Miss Piggy', 'Kermit'],
+  ['Mork', 'Mindy'],
+  ['Obi-Wan', 'Anakin'],
+  ['Pan', 'Hook'],
+  ['Phineas', 'Ferb'],
+  ['player 1', 'player 2'],
+  ['p1', 'p2'],
+  ['R2-D2', 'C-3PO'],
+  ['Ren', 'Stimpy'],
+  ['Rick', 'Morty'],
+  ['Romeo', 'Juliet'],
+  ['Shaggy', 'Scooby'],
+  ['Shrek', 'Fiona'],
+  ['Simon', 'Garfunkel'],
+  ['Snoopy', 'Woodstock'],
+  ['Sonny', 'Cher'],
+  ['Spongebob', 'Patrick'],
+  ['Tarzan', 'Jane'],
+  ['Thelma', 'Louise'],
+  ['Thing 1', 'Thing 2'],
+  ['Tom', 'Huckleberry'],
+  ['Tom', 'Jerry'],
+  ['Tweety', 'Sylvester'],
+  ['Waldorf', 'Statler'],
+  ['Wallace', 'Gromit'],
+  ['white', 'black'],
+  ['Woody', 'Buzz'],
+]
+
+const pairUp = () => {
+  const duo = pairs[Math.floor(Math.random() * pairs.length)]
+  if (duo[0].toLowerCase() !== duo[0] && Math.random() < 0.5) duo.reverse()
+  return duo
+}
+
+newCmd.fn = (CLI, variant, ...names) => {
+  let rules = ''
+  if (variant) {
+    variant = variant.toLowerCase()
+    if (variant.length > 1 && 'puzzles'.startsWith(variant)) {
+      return CLI.do('puzzles', 'new', ...names)
+    }
+
+    if (['8x8', '8', 'trax8x8', '8trax', '8x8trax'].includes(variant)) {
+      rules = 'trax8'
+    }
+
+    if (['loop', 'l', 'looptrax'].includes(variant)) rules = 'traxloop'
+    if (variant === 't') rules = 'trax'
+    if (['trax', 'traxloop', 'trax8'].includes(variant)) rules = variant
+
+    if (!rules) {
+      if (names.includes('vs') || names.includes('VS')) {
+        // We don't have a variant, we have player names
+        names.unshift(variant)
+      } else {
+        CLI.error('Unknown Trax variant.')
+        return CLI.do('help', 'new')
+      }
+    }
+  }
+
+  const players = pairUp()
+  if (names.length > 0) {
+    let vs = names.indexOf('vs')
+    if (vs === -1) vs = names.indexOf('VS')
+    if (vs >= 0) {
+      players[0] = names.slice(0, vs).join(' ') || 'white'
+      players[1] = names.slice(vs + 1).join(' ') || 'black'
+    }
+  }
+
+  const id = CLI.newGame(rules, players, '')
+  CLI.out(CLI.color('Started new game #' + id))
+}

package/src/cmds/notes.js

@@ -0,0 +1,37 @@
+/** Notes CLI command.
+ * @copyright 2022
+ * @author Chad Transtrum <chad@transtrum.net>
+ * @license Apache-2.0
+ */
+
+export const notesCmd = {
+  name: 'notes',
+  args: '[#id] <text>',
+  desc: 'add a note to a game',
+  help: [
+    'Add a short note to a game that will be shown when the game is',
+    'displayed, listed, or exported.',
+  ],
+}
+
+notesCmd.fn = (CLI, id, ...note) => {
+  const current = String(CLI.GAME.id)
+  if (!id) id = current
+  if (!/^#?\d+$/.test(id)) {
+    note.unshift(id)
+    id = current
+  }
+
+  if (id.startsWith('#')) id = id.slice(1)
+
+  const game = CLI.GAMES[id]
+
+  if (!game) return CLI.error('Game not found.')
+
+  const notes = game.notes || []
+  const move = game.moves.length > 0 ? game.moves.split(' ').length : 0
+
+  notes.push({ move, note: note.join(' ') })
+  game.notes = notes
+  CLI.save()
+}

package/src/cmds/play-try.js

@@ -0,0 +1,175 @@
+/* Copyright 2022-2023 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
+
+import { suggest } from '@slugbugblue/trax-analyst'
+import { timeString } from '@slugbugblue/trax-cli/utils'
+
+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 bot = (CLI) => {
+  const game = CLI.GAME
+  const trax = CLI.TRAX
+  const players = game.players || ['a', 'b']
+  const name = players[trax.turn - 1]
+  if (trax.over && game.puzzle) {
+    if (trax.move <= game.max && name !== 'puzzlebot') {
+      CLI.puzzleSolved(game.puzzle)
+      return 'win'
+    }
+
+    return 'lose'
+  }
+
+  if (!trax.over && /bot\b/i.test(name)) {
+    if (game.puzzle && trax.move >= game.max) {
+      trax.play('puzzled')
+      return 'lose'
+    }
+
+    CLI.do('view')
+    CLI.out(CLI.bubble(trax.color + 'd', `${name} thinking...`))
+    const start = Date.now()
+    const move = suggest(trax)?.pick?.move
+    const ms = Date.now() - start
+    if (move) {
+      CLI.out(
+        CLI.bubble(trax.color + 'd', `${name} chooses ${move}`) +
+          CLI.color.black(' in ' + timeString(ms)),
+      )
+      trax.play(move)
+    }
+
+    if (game.puzzle) return ' and win by move ' + String(game.max)
+  }
+
+  return ''
+}
+
+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')
+  }
+
+  const game = CLI.GAME
+  const trax = CLI.TRAX
+
+  if (trax.over) {
+    return CLI.error('The game is over.')
+  }
+
+  const start = trax.move
+  let checkMove
+
+  for (let move of moves) {
+    if (notationRx.test(move)) {
+      const moveNumber = trax.move
+      move = CLI.fixNotation(move)
+      if (checkMove) {
+        trax.play(checkMove, move)
+      } else {
+        trax.play(move)
+      }
+
+      if (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 (trax.move !== start) {
+    const result = bot(CLI)
+    CLI.updateGameData()
+    CLI.do('view')
+    if (result === 'lose') {
+      CLI.error('Failed to complete puzzle ' + game.puzzle)
+    } else if (result === 'win') {
+      CLI.out(CLI.color.success('You completed puzzle ' + game.puzzle))
+    } else if (result) {
+      CLI.out(result)
+    }
+  }
+}
+
+tryCmd.fn = (CLI, move) => {
+  if (!move || 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 = CLI.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.')
+  }
+}