@slugbugblue/trax 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # @slugbugblue/trax
 
+## 0.12.0 - 2022-10-28
+
+- `point.in()` now accepts any two opposing corners to define the bounding box
+- Fleshing out testing and debugging of `analyst.js`
+
 ## 0.11.0 - 2022-09-22
 
 - Breaking change: Refactor `play()` and `playMove()` into a single function

package/docs/point.md

@@ -89,9 +89,10 @@ Returns the distance between two points. This will never be a negative number.
 Returns `true` if the given point or point-like object is at the same location
 as the existing point.
 
-##### `in(topLeft, bottomRight)`
+##### `in(a, b)`
 
 Pass in two points (or point-like objects) to define a rectangular bounding box.
+Each point represents opposite corners of the box.
 
 Returns `true` if the calling point is located inside the box or along any of
 its edges (ie, both bounding points are considered "inside").

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slugbugblue/trax",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Trax game engine and friends",
   "keywords": [
     "trax",

package/src/analyst.js

@@ -21,6 +21,15 @@ import { Trax } from '@slugbugblue/trax'
 import { threats } from '@slugbugblue/trax/threats.js'
 
 // Helpers
+const id = () => {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+  let code = ''
+  while (code.length < 6) {
+    code += chars[Math.floor(Math.random() * chars.length)]
+  }
+
+  return 'analysis-' + code
+}
 
 // Make parseInt Array.map()-friendly
 const int = (s) => Number.parseInt(s, 10)
@@ -163,24 +172,28 @@ const threatCount = (from) =>
 
 // Analysis class
 export const Analysis = class {
+  #rules = 'trax'
+  #id = 'analysis'
+  #moves = []
+  #notation = ''
   #edge = undefined
   #game = {}
-  #move = 0
-  #save = {}
   #scores = {}
   #threats = undefined
 
   constructor(game) {
     // Make a copy of the game
-    this.#game = game
-    this.#save = game.save()
-    this.#move = game.move
+    this.#rules = game.rules
+    this.#moves = game.moves
+    this.#id = id()
+    this.#notation = game.notation
+    this.#game = new Trax(this.#rules, this.#moves, this.#id)
   }
 
   get game() {
     // Return a fresh copy of the game as presented on init
-    if (this.#game.move !== this.#move) {
-      this.#game = new Trax().restore(this.#save)
+    if (this.#game.notation !== this.#notation) {
+      this.#game = new Trax(this.#rules, this.#moves, this.#id)
     }
 
     return this.#game
@@ -217,7 +230,7 @@ export const Analysis = class {
 
     for (const dir of Point.dirs) {
       let look = loc.dir(dir)
-      while (look.in(topLeft, bottomRight) && !game.tileAt(loc)) {
+      while (look.in(topLeft, bottomRight) && !game.tileAt(look)) {
         look = look.dir(dir)
       }
 
@@ -287,7 +300,7 @@ export const Analysis = class {
   // c = in a cave but has no restrictions (converted to n in edge)
   // C = a cave where some moves are not allowed (converted to c in edge)
   // n = normal space
-  // x = we cannot play here
+  // x = no tile can be played here
   spaceType(loc) {
     const { game } = this
 
@@ -300,13 +313,25 @@ export const Analysis = class {
     }
 
     // Check to see if we have an invalid move
+    let someValid = false
+    let someInvalid = false
     for (const tile of game.possibleTiles(loc)) {
       const drop = game.dropTile(tile, loc, 'tentative')
-      if (!drop.valid) {
-        return 'C'
+      if (drop.valid) {
+        someValid = true
+      } else {
+        someInvalid = true
       }
     }
 
+    if (!someValid) {
+      return 'x'
+    }
+
+    if (someInvalid) {
+      return 'C'
+    }
+
     return 'c'
   }
 
@@ -390,6 +415,37 @@ export const Analysis = class {
 
     return matches
   }
+
+  // Make a reasonable inspect representation of the analysis
+  [Symbol.for('nodejs.util.inspect.custom')](depth, options, inspect) {
+    const sub = (object) => inspect(object, options).replace(/\n/g, '\n  ')
+    const style = options.stylize
+    if (depth < 0) return style('<Analysis>', 'special')
+    if (options.depth !== null) options.depth -= 1
+    const tbd = style('tbd', 'undefined')
+    let custom = style('Analysis', 'special') + ' {\n'
+    custom += '  game: ' + style(this.#rules, 'special')
+    custom += '(' + style(this.#moves, 'string') + '),\n'
+    custom += '  edge: '
+    if (this.#edge) {
+      custom += '{\n    w: ' + style(this.#edge.w, 'string')
+      custom += ',\n    b: ' + style(this.#edge.b, 'string')
+      custom += ',\n    edge: ' + style('[rawEdge]', 'special')
+      custom += '\n  }'
+    } else {
+      custom += tbd
+    }
+
+    custom += ',\n  threats: '
+    custom += this.#threats ? sub(this.#threats) : tbd
+    custom += ',\n  scores: '
+    custom += 'w' in this.#scores ? sub(this.#scores) : tbd
+    custom += ',\n  score: '
+    const score = 'w' in this.#scores ? this.score : null
+    custom += score === null ? tbd : style(score, 'number')
+
+    return custom + '\n}'
+  }
 }
 
 export const analyze = (game) => new Analysis(game)

package/src/cmds/analyze.js

@@ -40,7 +40,7 @@ const threatNames = {
 const listThreats = (threats, detailed) => {
   const summary = []
   for (const level of Object.keys(threats || {})) {
-    const name = (threatNames[level] || `stage-${level} threats`) + ': '
+    const name = (threatNames[level] || `${level}-stage threats`) + ': '
     const items = []
     if (detailed) {
       for (const item of threats[level]) {

package/src/point.js

@@ -15,6 +15,12 @@
 
 const is = (v, s) => (typeof v).slice(0, 3) === s // Sigh
 
+const between = (end1, mid, end2) => {
+  const low = Math.min(end1, end2)
+  const high = Math.max(end1, end2)
+  return low <= mid && mid <= high
+}
+
 // Are you tired of doing x,y movements in multiple statements? I am.
 
 // Point: an immutable two-dimensional location (x,y)
@@ -102,13 +108,10 @@ 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
-    )
+  in(a, b) {
+    // Allow for the bounding points to be passed in any order
+    // as long as they are opposite corners:
+    return between(a.x, this.x, b.x) && between(a.y, this.y, b.y)
   }
 
   // Play nicely with the rest of the world

package/src/version.js

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