@slugbugblue/trax 0.12.0 → 0.14.0

package/src/threats.js

@@ -1,23 +1,12 @@
-/* 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.
+/** Threats database: hand-coded threats
+ * @copyright 2022
+ * @author Chad Transtrum <chad@transtrum.net>
+ * @license Apache-2.0
  */
 
-// Threats database: hand-coded threats
-
 const REGEX = {
-  a: '[am]', // White that pairs with the next white
-  c: '[cp]', // White that forms a connectable pair with next white
+  a: '[am]', // White that pairs with the next white (m=hollow)
+  c: '[cp]', // White that forms a connectable pair with next white (p=hollow)
   l: '[lmp]', // White in a hollow
   w: '[aclmpw]', // Any white
   '!': '(?:b[acw])*?', // Ripple black/white
@@ -26,14 +15,16 @@ const REGEX = {
   '?': 'b?', // Zero or one black piece
 }
 
-class CustomInspectableThreat {
+class Threat {
   #depth = 0
   #pattern = ''
   #rx = null
+  #reforms = false
 
-  constructor(depth, pattern) {
+  constructor(depth, pattern, reforms = false) {
     this.#depth = depth
     this.#pattern = pattern
+    this.#reforms = reforms
 
     let rx = ''
     for (const char of pattern) {
@@ -55,20 +46,26 @@ class CustomInspectableThreat {
     return this.#rx
   }
 
+  get value() {
+    return this.#reforms ? 2 : 1
+  }
+
   // To make life at the REPL a little easier
   [Symbol.for('nodejs.util.inspect.custom')](_, out) {
     const style = out.stylize
-    return [
+    const display = [
       '[' + style('Threat', 'special') + ']',
       '{',
       style(this.#pattern, 'string') + ':',
       style(this.#depth, 'number'),
+      this.#reforms ? '!' : '',
       '}',
-    ].join(' ')
+    ]
+    return display.filter((d) => d !== '').join(' ')
   }
 }
 
-class CustomInspectableThreatsDB {
+class ThreatsDB {
   #db = {}
   #depth = 0
 
@@ -78,9 +75,10 @@ class CustomInspectableThreatsDB {
     }
   }
 
-  add(depth, pattern) {
+  add(depth, pattern, reforms = false) {
     this.#depth = Math.max(depth, this.#depth)
-    this.#db[pattern] = new CustomInspectableThreat(depth, pattern)
+    if (pattern in this.#db) throw new Error('Duplicate pattern:' + pattern)
+    this.#db[pattern] = new Threat(depth, pattern, reforms)
     return this.#db[pattern]
   }
 
@@ -113,8 +111,8 @@ class CustomInspectableThreatsDB {
   }
 }
 
-const pre = true
-const post = true
+const pre = true // This pattern can appear first in an L threat
+const post = true // This pattern can come second in an L threat
 const corners = {
   arw: { pre, post }, // Simple corner
   abrw: { post }, // Wide-first corner
@@ -125,7 +123,7 @@ const corners = {
   cbw: {}, // Wide connectable pair
 }
 
-export const threats = new CustomInspectableThreatsDB(Object.keys(corners))
+export const threats = new ThreatsDB(Object.keys(corners))
 
 // Attacks
 const attacks = [
@@ -134,15 +132,19 @@ const attacks = [
 attacks.map((a) => threats.add(1, a))
 
 // Re-forming attacks
-const reform = [
+const reformAttacks = [
   'rm?lr', // Cave/wide cave attack
-  'rp?lr',
   'rbm?lbr', // Deep cave/deep wide cave attack (impossibly rare?)
-  'rbp?lbr',
   'ralmrw', // Attack at top of cave
   'arlmwr', // Reversed
 ]
-reform.map((r) => threats.add(2, r))
+reformAttacks.map((ra) => threats.add(1, ra, true))
+
+const reformThreats = [
+  'rp?lr', // Cave/wide cave threat
+  'rbp?lbr', // Deep cave/deept wide cave attach (impossibly rare?)
+]
+reformThreats.map((rt) => threats.add(2, rt))
 
 // Create multi-stage threats
 for (const one of Object.keys(corners)) {
@@ -151,14 +153,16 @@ for (const one of Object.keys(corners)) {
     const [before, after] = [corners[one].post, corners[two].pre]
     if (before || after) {
       const start = one.replace('w', 'l')
-      threats.add(2, start + (before ? '?¡' : '¡') + two)
+      const pre = before ? '?' : ''
+      const post = after ? '?' : ''
+      threats.add(2, start + pre + '¡' + two) // Make an L
+      threats.add(3, start + pre + 'rb¡' + two) // Make a three-stage threat
       const end = two.replace('a', 'm').replace('c', 'p')
-      threats.add(2, one + (after ? '?!' : '!') + end)
+      threats.add(2, one + post + '!' + end) // L
+      threats.add(3, one + post + '!br' + end) // Three-stage
     }
 
     // Edge threats
     threats.add(3, one + '!b*b¡' + two)
   }
 }
-
-// Create edge threats

package/src/tty.js

@@ -17,12 +17,21 @@
 
 import process from 'node:process'
 
-import { Trax } from './engine.js'
+import { Trax } from '@slugbugblue/trax'
 
 const esc = '\u001B[' // Start of console color escape code
 const off = esc + 'm' // Color reset code
-
-// Colorize a string
+const ENV = process.env
+const NERD = ENV.NERDFONT
+const POWER = ENV.POWERLINE || ENV.P9K_TTY || ENV.P9K_SSH
+const leftBubble = NERD ? '' : POWER ? '' : '▐'
+const rightBubble = NERD ? '' : POWER ? '' : '▌'
+
+/** Colorize a string.
+ * @arg {string} contents
+ * @arg {string|number} [fgcolor]
+ * @arg {string|number} [bgcolor]
+ */
 export const color = (contents = '', fgcolor = '', bgcolor = '') => {
   const c = []
   if (fgcolor) c.push('38;5;' + fgcolor)
@@ -35,9 +44,7 @@ export const outty = (message, fgcolor, bgcolor) => {
   console.log(color(message, fgcolor, bgcolor) + off)
 }
 
-let set = 'trax' // Which color set should we draw with?
-
-// a little magic to display the game in progress
+// A little magic to display the game in progress
 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
@@ -48,6 +55,8 @@ const colorSets = {
   tentative: { b: 235, B: 18, e: 19, t: 244, w: 252, W: 217 },
 }
 
+let set = colorSets.trax // Which color set should we draw with?
+
 export const name = (rules) => {
   if (Trax.variants.has(rules)) {
     return color(Trax.names[rules], colorSets[rules].t)
@@ -67,7 +76,12 @@ export const bubble = (clr, text) => {
   }
 
   const c = colors[clr]
-  return color('', c.bg) + color(text, c.fg, c.bg) + off + color('', c.bg)
+  return (
+    color(leftBubble, c.bg) +
+    color(text, c.fg, c.bg) +
+    off +
+    color(rightBubble, c.bg)
+  )
 }
 
 const ln = 'm\u2584' // Lower half block -- with the leading m to terminate ansi color escape
@@ -124,7 +138,7 @@ const tileTty = (tile, top) => {
     }
   }
 
-  let value = false
+  let value = ''
   if (tile in tiles) {
     tile = tiles[tile]
     if (top) {
@@ -154,7 +168,7 @@ const mergeTentative = () => {
 
 const printIcon = (icon, setName) => {
   set = colorSets[setName] || colorSets.trax
-  mergeTentative(set)
+  mergeTentative()
   const on = esc + '38;5;' + String(set.t) + ';48;5;' + String(set.e) + 'm'
   let o1 = '   '
   let o2 = '1  '
@@ -208,10 +222,11 @@ const printIcon = (icon, setName) => {
   }
 }
 
-// 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
+/** Flexible way to get a Trax game object.
+ * @arg {Trax|TraxVariant} [game] - existing Trax instance or a string indicating the variant name
+ * @arg {string|string[]} [moves] - optional list or string of moves to be made on the game
+ * @returns {Trax} a Trax instance
+ */
 export const traxGame = (game = 'trax', moves = '') => {
   let trax
   if (game instanceof Trax) {
@@ -253,7 +268,7 @@ const printNotation = (trax, tentative, show = Number.POSITIVE_INFINITY) => {
 export const display = (
   game,
   players,
-  tentative = false,
+  tentative = '',
   showMove = Number.POSITIVE_INFINITY,
 ) => {
   const trax = traxGame(game)
@@ -266,7 +281,7 @@ export const display = (
     if (drops.valid || drops.dropped.length > 0) {
       icon = trax.dropsIcon(drops)
     } else {
-      tentative = false
+      tentative = ''
     }
   } else if (showMove <= trax.moves.length) {
     icon = trax.dropsIcon({

package/src/types.d.ts

@@ -0,0 +1,105 @@
+/** Type information.
+ * @author Chad Transtrum <chad@transtrum.net>
+ * @license Apache-2.0
+ */
+
+/** Color is a single character to represent white or black. */
+type Color = 'w' | 'b'
+
+/** Colorize is a fancy function for colorizing text. */
+type Colorize = (text: string, def?: string | number) => string
+
+/** Colorer is a little too fancy. Hence the gnarly typescript. */
+type Colorer = {
+  (text: string, def?: string | number): string
+  black: Colorize
+  command: Colorize
+  default: Colorize
+  error: Colorize
+  fatal: Colorize
+  help: Colorize
+  id: Colorize
+  variable: Colorize
+  optional: Colorize
+  short: Colorize
+  white: Colorize
+}
+
+/** A point-like object has numerical x and y properties. */
+type PointLike = {
+  x: number
+  y: number
+}
+
+/** A puzzle. */
+type Puzzle = {
+  id: string
+  src: string
+  game: TraxVariant
+  notation: string
+  icon: string
+  level: number
+  max: number
+  player: number
+  title?: string
+  desc?: string
+  hint?: string
+  hints?: string[]
+}
+
+type PuzzleSource = {
+  name: string
+  copyright?: string
+  url?: string
+}
+
+/** Treat the save state as an opaque object,
+ * produced by save() and fed into restore().
+ */
+type SaveState = {
+  id: string
+  move: number
+  turn: number
+  over: boolean
+  left: number
+  right: number
+  top: number
+  bottom: number
+  notation: string
+  tiles: string
+  path: string
+  invalid: boolean
+}
+
+/** Representations of the different ways a tile can curve.
+ * Matches the symbols used in Trax notation.
+ */
+type Slash = '/' | '\\' | '+'
+
+/** A single tile on the board. */
+type Tile = {
+  id: TileId
+  loc: Point
+  type: TileType
+  move: number
+  seq: number
+}
+
+/** When a tile is dropped, this object represents the results. */
+type TileDrop = {
+  dropped: Tile[]
+  notation: string
+  valid: boolean
+}
+
+/** A TileId is just a string. */
+type TileId = string
+
+/** Invalid tiles are represented by 'x'. */
+type TileType = ValidTiles | 'x'
+
+/** All of the variants supported by the engine. */
+type TraxVariant = 'trax' | 'traxloop' | 'trax8'
+
+/** Tile types are represented by one of the following single characters. */
+type ValidTiles = 'a' | 'b' | 'c' | 'd' | 'e' | 'f'

package/src/version.js

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