@slugbugblue/trax 0.13.0 → 0.15.0

package/src/threats.js

@@ -5,20 +5,26 @@
  */
 
 const REGEX = {
-  a: '[am]', // White that pairs with the next white
-  c: '[cp]', // White that forms a connectable pair with next white
-  l: '[lmp]', // White in a hollow
-  w: '[aclmpw]', // Any white
+  // Some of these are one for one:
+  // a: White that pairs with the next white
+  A: '[am]', // White maybe in a hollow that pairs with next white
+  // c: White that forms a connectable pair with next white
+  C: '[cp]', // White maybe in a hollow connectable pair with next white
+  l: '[lmp]', // Any White in a hollow
+  // m: "a" in a hollow
+  // p: "c" in a hollow)
+  w: '[acw]', // Any white except in hollows
+  W: '[aclmpw]', // Any white at all
   '!': '(?:b[acw])*?', // Ripple black/white
   '¡': '(?:[acw]b)*?', // Ripple white/black
   '*': 'b*?', // Zero or more black pieces
   '?': 'b?', // Zero or one black piece
 }
 
-class CustomInspectableThreat {
+export const Threat = class {
   #depth = 0
   #pattern = ''
-  #rx = null
+  #rx
   #reforms = false
 
   constructor(depth, pattern, reforms = false) {
@@ -31,7 +37,8 @@ class CustomInspectableThreat {
       rx += REGEX[char] || char
     }
 
-    this.#rx = new RegExp(rx, 'g')
+    // Create the regex with lookahead assertions to allow overlapping matches
+    this.#rx = new RegExp('(?=(' + rx + '))', 'g')
   }
 
   get depth() {
@@ -65,7 +72,7 @@ class CustomInspectableThreat {
   }
 }
 
-class CustomInspectableThreatsDB {
+export const ThreatsDB = class {
   #db = {}
   #depth = 0
 
@@ -75,9 +82,15 @@ class CustomInspectableThreatsDB {
     }
   }
 
+  compose(depth, pattern) {
+    pattern = pattern.replaceAll(/(?<=.)A/g, 'a').replaceAll(/W(?=.)/g, 'w')
+    return this.add(depth, pattern)
+  }
+
   add(depth, pattern, reforms = false) {
     this.#depth = Math.max(depth, this.#depth)
-    this.#db[pattern] = new CustomInspectableThreat(depth, pattern, reforms)
+    if (pattern in this.#db) throw new Error('Duplicate pattern:' + pattern)
+    this.#db[pattern] = new Threat(depth, pattern, reforms)
     return this.#db[pattern]
   }
 
@@ -96,68 +109,93 @@ class CustomInspectableThreatsDB {
   // To make life at the REPL a little easier
   [Symbol.for('nodejs.util.inspect.custom')](_, out) {
     const style = out.stylize
-    const inspection = '[' + style('Threats', 'special') + '] { '
+    const inspection = '[' + style('Threats', 'special') + ':'
     let total = 0
-    const keys = []
+    const keys = ['{']
 
     for (let x = 0; x <= this.#depth; x++) {
       const count = this.level(x).length
-      keys.push(style(x, 'string') + ': ' + style(count, 'number'))
+      keys.push(style(x, 'string') + ':' + style(count, 'number'))
       total += count
     }
 
-    return inspection + keys.join(', ') + ' } total: ' + total
+    return inspection + style(total, 'number') + '] ' + keys.join(' ') + ' }'
   }
 }
 
-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
-  arbw: { pre }, // Wide-second corner
-  abrbw: {}, // Wide corner
-  'ab?bw': { pre, post }, // Flat corner and wide flat corner
-  cw: { pre, post }, // Connectable pair
-  cbw: {}, // Wide connectable pair
+  ArW: { pre, post }, // Simple corner
+  AbrW: { post }, // Wide-first corner
+  ArbW: { pre }, // Wide-second corner
+  AbrbW: {}, // Wide corner
+  'ab?bW': { pre, post }, // Flat corner and wide flat corner
+  CW: { pre, post }, // Connectable pair
+  CbW: {}, // Wide connectable pair
 }
 
-export const threats = new CustomInspectableThreatsDB(Object.keys(corners))
+export const threats = new ThreatsDB(Object.keys(corners))
+
+// Attacks
+const attacks = [
+  'a?W', // Simple attack and wide attack
+  'm?W', // Simple and wide attack in a corner
+]
+attacks.map((a) => threats.add(1, a))
 
 // Re-forming attacks
 const reformAttacks = [
   'rm?lr', // Cave/wide cave attack
   'rbm?lbr', // Deep cave/deep wide cave attack (impossibly rare?)
-  'ralmrw', // Attack at top of cave
+  'ralmrW', // Attack at top of cave
   'arlmwr', // Reversed
 ]
 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?)
+  'rbp?lbr', // Deep cave/deep wide cave threat (impossibly rare?)
+  'rmbb???w', // Black corner with a long white loop potential
+  'abb???lr', // Reverse
 ]
 reformThreats.map((rt) => threats.add(2, rt))
 
-// Attacks
-const attacks = [
-  'a?w', // Simple attack and wide attack
-]
-attacks.map((a) => threats.add(1, a))
-
 // Create multi-stage threats
 for (const one of Object.keys(corners)) {
+  const start = one.replace('W', 'l')
+  let end = one.replace(/[aA]/, 'm').replace('C', 'p')
+  const pre = corners[one].post ? '?' : ''
+  let post = corners[one].pre ? '?' : ''
+  threats.compose(3, start + pre + '¡rm?W') // Attacking 3-stage threat
+  threats.compose(3, 'a?lr!' + post + end) // Reverse
+  threats.compose(3, one + '¡ab*bwr') // Corner by reforming hollow potential
+  threats.compose(3, 'rab*bw!' + one) // Reverse
+  threats.compose(3, one + '!brm*bW') // Corner by hollow attack, defends to edge
+  threats.compose(3, one + '!bbrmW') // Same, but slightly different layout
+  threats.compose(3, 'ab*lrb¡' + one) // Reverse
+  threats.compose(3, 'alrbb¡' + one) // Reverse of different layout
+
   for (const two of Object.keys(corners)) {
-    // L threats
-    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 end = two.replace('a', 'm').replace('c', 'p')
-      threats.add(2, one + (after ? '?!' : '!') + end)
+    end = two.replace(/[aA]/, 'm').replace('C', 'p')
+    post = corners[two].pre ? '?' : ''
+    if (pre) {
+      threats.compose(2, start + pre + '¡' + two) // Make an L
+      threats.compose(3, start + pre + 'rb¡' + two) // Make a three-stage threat
+      threats.compose(3, start + '?!rb¡' + two) // Attack to form an L threat
     }
 
-    // Edge threats
-    threats.add(3, one + '!b*b¡' + two)
+    if (post) {
+      threats.compose(2, one + post + '!' + end) // L
+      threats.compose(3, one + post + '!br' + end) // Three-stage
+      threats.compose(3, one + '!br¡?' + end) // Attack to form an L threat
+    }
+
+    threats.compose(3, one + '!b*b¡' + two) // Edge threat
   }
 }
+
+threats.add(3, 'ralbmrW') // Attack into a wide cave
+threats.add(3, 'Arlbmwr') // Reversed
+
+threats.add(4, 'ArlbmrW') // Wide cave ready for an attack

package/src/tty.js

@@ -22,7 +22,7 @@ import { Trax } from '@slugbugblue/trax'
 const esc = '\u001B[' // Start of console color escape code
 const off = esc + 'm' // Color reset code
 const ENV = process.env
-const NERD = ENV.NERDFONT
+const NERD = ENV.NERDFONT || ENV.NERDFONTS
 const POWER = ENV.POWERLINE || ENV.P9K_TTY || ENV.P9K_SSH
 const leftBubble = NERD ? '' : POWER ? '' : '▐'
 const rightBubble = NERD ? '' : POWER ? '' : '▌'

package/src/types.d.ts

@@ -25,12 +25,56 @@ type Colorer = {
   white: Colorize
 }
 
+/** An object representing a space on the perimeter of a Trax position.
+ * x,y: the coordinates of the space
+ * c: the color present beside the space (w, b, l: both w and b, r: none)
+ * t: the type of possible moves: n-normal, x-none, c-cave, C-restricted cave
+ * b,w: if present, the number of the line to match with its other end
+ * pb, pw: if present, can pair with the next line in one turn
+ * xb, xw: the label of this space for each color
+ */
+type EdgeLocation = {
+  x: number
+  y: number
+  c: string
+  t: string
+  b?: number
+  w?: number
+  pb?: boolean
+  pw?: boolean
+  zb?: string
+  zw?: string
+}
+
+type EdgeObject = {
+  b: string
+  w: string
+  edge: RawEdge
+}
+
+/** Object representing a concrete threat found in a position. */
+type FoundThreat = { threat: string; match: string; at: number; value: number }
+
+/** An object with keys representing each level, with arrays for each threat of
+ * that level. */
+type FoundThreats = Record<string, FoundThreat[]>
+
+/** All the threats found for both the white and black player. */
+type FoundThreatsCollection = { b: ColorThreats; w: ColorThreats }
+
 /** A point-like object has numerical x and y properties. */
 type PointLike = {
   x: number
   y: number
 }
 
+/** An object used to track an analysis on a position. */
+type PositionScore = {
+  move: string
+  score: number
+  analysis?: Analysis
+}
+
 /** A puzzle. */
 type Puzzle = {
   id: string
@@ -53,6 +97,10 @@ type PuzzleSource = {
   url?: string
 }
 
+/** Array of objects representing the spaces surrounding the perimeter of a
+ * Trax position. */
+type RawEdge = EdgeLocation[]
+
 /** Treat the save state as an opaque object,
  * produced by save() and fed into restore().
  */
@@ -76,6 +124,14 @@ type SaveState = {
  */
 type Slash = '/' | '\\' | '+'
 
+/** Threat definition. */
+type Threat = {
+  depth: number
+  pattern: string
+  rx: RegExp
+  value: number
+}
+
 /** A single tile on the board. */
 type Tile = {
   id: TileId

package/src/version.js

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