@slugbugblue/trax 0.4.0 → 0.8.0

package/engine.js

@@ -1,535 +0,0 @@
-/* Copyright 2019-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.
- */
-
-// Trax internals. Woot.
-
-// tile type names are determined by listing the color of line at each edge, clockwise
-// and then sorted alphabetically and given a single letter name, so 'bbww' becomes 'a'
-// which gives us six different tile names: a-f
-
-const variants = ['trax', 'traxloop', 'trax8']  // known variants
-
-// fun trax helper constants
-
-const slash = { a: '\\', b: '+', c: '/', d: '/', e: '+', f: '\\' }
-
-const symmetry = {  // convert tile to different views
-  flip: { a: 'd', b: 'b', c: 'f', d: 'a', e: 'e', f: 'c' },
-  mirror: { a: 'c', b: 'b', c: 'a', d: 'f', e: 'e', f: 'd' },
-  swap: { a: 'f', b: 'e', c: 'd', d: 'c', e: 'b', f: 'a' },
-  counterclock: { a: 'c', b: 'e', c: 'f', d: 'a', e: 'b', f: 'd' },
-}
-
-const notation_regex = /^ *([@a-z]+) *(\d+) *([/\\+]) *$/i
-
-const color_of = { 1: 'w', 2: 'b' }
-const player_num = { b: 2, w: 1 }
-const other = { b: 'w', w: 'b' }
-
-// fun trax helper functions
-
-// unexpected note: str.includes(t) is true if t is '' but false if t is undefined
-const up_color = t => 'abc'.includes(t) ? 'b' : 'def'.includes(t) ? 'w' : false
-const down_color = t => 'bdf'.includes(t) ? 'b' : 'ace'.includes(t) ? 'w' : false
-const right_color = t => 'ade'.includes(t) ? 'b' : 'bcf'.includes(t) ? 'w' : false
-const left_color = t => 'cef'.includes(t) ? 'b' : 'abd'.includes(t) ? 'w' : false
-const squares_around = (x, y) => [{x:x-1,y},{x:x+1,y},{x,y:y-1},{x,y:y+1}]
-const encode_col = col => { // for notation purposes: 0 -> @, 6 -> F, 28 -> AB
-  let n = ''
-  while (col > 0) {
-    n = String.fromCharCode(65 + (col - 1) % 26) + n
-    col = Math.floor((col - 1) / 26)
-  }
-  return n || '@'
-}
-const decode_col = col => { // turn letters back into numbers
-  col = col.toUpperCase()
-  let n = 0
-  while (col.length) {
-    n = n + (col.charCodeAt(0) - 64) * Math.pow(26, col.length - 1)
-    col = col.slice(1)
-  }
-  return n
-}
-const add_blank = code => { // encode missing tiles as digits 0-9, for 1-10 missing
-  let num = code.charCodeAt(code.length - 1) // this is NaN if code is empty, which is ok
-  if (num > 47 && num < 57) return code.slice(0, code.length -1) + String.fromCharCode(num + 1)
-  return code += '0'
-}
-// ugh, this is a dirty little function to get the length of an encoded position row
-const code_row_len = row => row.replace(/[0-9]/g, n => '.'.repeat(Number(n)+1)).length
-
-// this is where the magic happens
-const Trax = class {
-  constructor (rules='trax', moves=[], id='trax') {
-    if (!variants.includes(rules)) rules = 'trax'
-    this.id = String(id)
-    this.rules = rules
-    this.move = 0
-    this.turn = 1
-    this.over = false
-    this.left = 1
-    this.right = 0
-    this.top = 1
-    this.bottom = 0
-    this.notation = ''
-    this.tiles = {}
-    this.path = []
-    this.invalid = false
-    // moves might be a notation string
-    if (moves) {
-      if (typeof moves === 'string') moves = moves.split(' ')
-      moves.forEach(move => {
-        if (typeof move === 'string') {
-          move = { move: this.move, notation: move }
-        }
-        this.play_move(move.move, move.notation)
-      })
-    }
-  }
-
-  save () { // in order to evaluate potential moves, we have to modify the state
-    return {
-      move: this.move,
-      turn: this.turn,
-      over: this.over,
-      left: this.left,
-      right: this.right,
-      top: this.top,
-      bottom: this.bottom,
-      notation: this.notation,
-      tiles: JSON.stringify(this.tiles),
-      path: JSON.stringify(this.path),
-      invalid: this.invalid,
-    }
-  }
-
-  restore (saved) { // so we need to be able to restore it when we are done
-    this.move = saved.move
-    this.turn = saved.turn
-    this.over = saved.over
-    this.left = saved.left
-    this.right = saved.right
-    this.top = saved.top
-    this.bottom = saved.bottom
-    this.notation = saved.notation
-    this.tiles = JSON.parse(saved.tiles)
-    this.path = JSON.parse(saved.path)
-    this.invalid = saved.invalid
-  }
-
-  get count () {  // get the number of tiles currently in play
-    return Object.keys(this.tiles).length
-  }
-
-  get color () {  // get the color of the current player (w or b)
-    return color_of[this.turn]
-  }
-
-  get game_over () { // returns true if the game is over
-    return this.over
-  }
-
-  get winner () { // returns false if the game is still in progress
-    return this.over ? this.turn : false  // or 1 or 2 for a win, or 0 for a tie
-  }
-
-  tile_id (x, y) {
-    return this.id + '-' + String(x) + 'x' + String(y)
-  }
-
-  add_tile (type, x, y) { // note: no validity checking is done here
-    const id = this.tile_id(x, y)
-    const tile = { type, x, y, id, move: this.move, seq: this.count }
-    if (type === 'x') {
-      this.invalid = true // invalid tile is being played
-    } else {
-      this.tiles[id] = tile
-      this.left = Math.min(this.left, x)
-      this.right = Math.max(this.right, x)
-      this.top = Math.min(this.top, y)
-      this.bottom = Math.max(this.bottom, y)
-    }
-    return tile
-  }
-
-  tile_at (x, y) {
-    return (this.tiles[this.tile_id(x, y)] || {}).type
-  }
-
-  valid_tile (type, x, y) {
-    if (this.count === 0 && x === 0 && y === 0) return type === 'd' || type === 'e'
-    let up = down_color(this.tile_at(x, y - 1))
-    let down = up_color(this.tile_at(x, y + 1))
-    let left = right_color(this.tile_at(x - 1, y))
-    let right = left_color(this.tile_at(x + 1, y))
-    return (!up || up === up_color(type)) && (!down || down === down_color(type)) &&
-      (!left || left === left_color(type)) && (!right || right === right_color(type))
-  }
-
-  possible_tiles (x, y, s=false) { // s: slash (/ or \ or +)
-    let possibles = []
-    ;['a', 'b', 'c', 'd', 'e', 'f'].forEach(t => {
-      if ((!s || s === slash[t]) && this.valid_tile(t, x, y)) possibles.push(t)
-    })
-    return possibles
-  }
-
-  get height () {
-    return this.bottom - this.top + 1
-  }
-
-  get width () {
-    return this.right - this.left + 1
-  }
-
-  valid_location (x, y) {
-    if (this.over) return false
-    if (this.tile_at(x, y)) return false
-    if (this.count === 0 && x === 0 && y === 0) return true
-    if (this.rules === 'trax8') {
-      if (this.width > 7 && (x < this.left || x > this.right)) return false
-      if (this.height > 7 && (y < this.top || y > this.bottom)) return false
-    }
-    return Boolean(
-      this.tile_at(x-1, y) || this.tile_at(x+1, y) ||
-      this.tile_at(x, y-1) || this.tile_at(x, y+1)
-    )
-  }
-
-  possible_locations () {
-    let locs = { '0x0': { x:0, y:0 } }  // if no tiles are placed, we can play a starting tile
-    const maybe = (x, y) => {  // add a loc if a tile isn't already there
-      let loc = x + 'x' + y
-      locs[loc] = locs[loc] || { x, y }
-    }
-    for (let tile of Object.values(this.tiles)) {
-      locs[tile.x + 'x' + tile.y] = 'tile'  // add an existing tile
-      maybe(tile.x - 1, tile.y)  // and four maybe tiles around it
-      maybe(tile.x + 1, tile.y)  // which will either be replaced by real tiles
-      maybe(tile.x, tile.y - 1)  // or will be potentially valid locations
-      maybe(tile.x, tile.y + 1)
-    }
-    // get rid of all the real tiles and return all the maybes
-    return Object.values(locs).filter(l => l !== 'tile')
-  }
-
-  possible_moves () { // returns a list of every currently possible move
-    // as notations, ie ['@1+', '@1/', '@1\\', ...]
-    let possibles = []
-    if (this.over) return possibles  // shortcut if the game is over
-    this.possible_locations().forEach(loc => {
-      this.possible_tiles(loc.x, loc.y).forEach(tile => {
-        let drop = this.drop_tile(tile, loc.x, loc.y, 'tentative')
-        if (drop.valid) possibles.push(drop.notation)
-      })
-    })
-    return possibles
-  }
-
-  forced_moves (x, y) { // we just played at x, y, so return all forced moves
-    let forced = []
-    let invalids = {}
-    let check = squares_around(x, y)
-    while (check.length) {
-      let pos = check.shift()
-      if (this.valid_location(pos.x, pos.y)) {
-        let possibles = this.possible_tiles(pos.x, pos.y)
-        if (possibles.length === 1) { // only 1 possible move
-          forced.push(this.add_tile(possibles[0], pos.x, pos.y))
-          check = check.concat(squares_around(pos.x, pos.y))
-        } else if (possibles.length === 0) { // no possible moves at all
-          let invalid = this.add_tile('x', pos.x, pos.y)
-          if (!invalids[invalid.id]) forced.push(invalid)
-          invalids[invalid.id] = true
-        }
-      }
-    }
-    return forced
-  }
-
-  notate (type, x, y) { // notation depends on the position of the board BEFORE the move
-    return encode_col(x - this.left + 1) + String(y - this.top + 1) + slash[type]
-  }
-
-  decode_notation (notation) { // return {type, x, y} from a notation
-    let r = { type: 'x', x: 0, y: 0 } // default to an invalid move
-    let match = notation.match(notation_regex)
-    if (match === null) return r
-    r.x = this.left - 1 + decode_col(match[1])
-    r.y = this.top - 1 + Number(match[2])
-    let possible = this.possible_tiles(r.x, r.y, match[3])
-    if (possible) r.type = possible[0]
-    return r
-  }
-
-  follow (color, x, y, from) {
-    let path = []
-    let id = this.tile_id(x, y)
-    let tile = this.tile_at(x, y)
-    while (tile && path[0] !== id) {
-      if (from !== 'top' && up_color(tile) === color) {
-        from = 'bottom'
-        y--
-      } else if (from !== 'bottom' && down_color(tile) === color) {
-        from = 'top'
-        y++
-      } else if (from !== 'left' && left_color(tile) === color) {
-        from = 'right'
-        x--
-      } else if (from !== 'right' && right_color(tile) === color) {
-        from = 'left'
-        x++
-      }
-      path.push(id)
-      id = this.tile_id(x, y)
-      tile = this.tile_at(x, y)
-    }
-    return { x, y, path }
-  }
-
-  find_ends (color, x, y) {
-    let ends = []
-    let tile = this.tile_at(x, y)
-    if (up_color(tile) === color) ends.push(this.follow(color, x, y, 'top'))
-    if (down_color(tile) === color) ends.push(this.follow(color, x, y, 'bottom'))
-    if (left_color(tile) === color) ends.push(this.follow(color, x, y, 'left'))
-    if (right_color(tile) === color) ends.push(this.follow(color, x, y, 'right'))
-    return ends
-  }
-
-  check_win (tiles) {
-    let winner = false
-    let colors = [ this.color, other[this.color] ]  // check win for current player first
-    colors.forEach(color => {
-      if (winner) return // skip the second player if the first has won
-      tiles.forEach(tile => {
-        if (winner) return // skip the remaining tiles once we find a win
-        let ends = this.find_ends(color, tile.x, tile.y)
-        if (ends[0].x === ends[1].x && ends[0].y === ends[1].y) {
-          winner = color // loop win
-          this.path = ends[0].path // both paths are essentially the same
-        } else if (this.rules !== 'traxloop') { // check for line win
-          if (this.width > 7 && Math.abs(ends[0].x - ends[1].x) > this.width ||
-            this.height > 7 && Math.abs(ends[0].y - ends[1].y) > this.height) {
-            winner = color // line win, paths need to be combined
-            this.path = ends[0].path.reverse().concat(ends[1].path.slice(1))
-          }
-        }
-      })
-    })
-    if (winner) {
-      this.over = true
-      this.turn = player_num[winner]
-    } else {
-      // 8x8 Trax can end in a tie once there are no valid moves left
-      if (this.rules === 'trax8' && this.width > 7 && this.height > 7) {
-        if (this.possible_moves().length < 1) {
-          this.over = true
-          this.turn = 0 // tie
-        }
-      }
-    }
-  }
-
-  play (notation) { // fast and easy way to play a move
-    return this.drop_tile(notation)
-  }
-
-  play_move (move_num, notation) { // generic API call for drop_tile
-    if (move_num === this.move) return this.drop_tile(notation)
-    return { valid: false }
-  }
-
-  update_notation (notation) {
-    this.move++
-    let note = this.move +'. ' + notation
-    let line = this.notation.split('\n').pop()
-    if (line) {
-      note = (line.length + note.length > 79 ? '\n' : ' ') + note
-    }
-    this.notation += note
-  }
-
-  get moves () {
-    return this.notation.replace(/\n/g, ' ').split(' ').filter(n => !n.endsWith('.'))
-  }
-
-  drop_tile (type, x, y, tentative=false) { // pass in tentative to not save the move
-    let dropped = []
-    let notation = ''
-    let valid = false
-    if (['timeout', 'resign', 'draw', 'puzzled'].includes(type)) { // handle special events
-      this.over = true
-      if (type !== 'puzzled') {  // puzzled: puzzle was not completed; this player wins
-        this.turn = this.turn === 1 ? 2 : 1 // timeout, resign means the other player wins
-        if (type === 'draw') this.turn = 0 // draw means we both win
-      }
-      this.update_notation(type)
-      notation = type
-      valid = true
-    } else {
-      if (type.search(notation_regex) === 0) { // we were passed a notation
-        ({ type, x, y } = this.decode_notation(type))
-      }
-      if (this.valid_location(x, y) && this.valid_tile(type, x, y)) {
-        valid = true
-        let saved = this.save() // just in case we need to roll back
-        notation = this.notate(type, x, y) // determine notation BEFORE we play the move
-        this.update_notation(notation)
-        dropped.push(this.add_tile(type, x, y)) // play the tile
-        dropped = dropped.concat(this.forced_moves(x, y)) // play all forced moves
-        if (this.invalid || tentative) {
-          if (this.invalid) valid = false
-          this.restore(saved) // abort! abort!
-        } else {
-          this.check_win(dropped)
-          if (!this.over) this.turn = this.turn === 1 ? 2 : 1
-        }
-      }
-    }
-    return { dropped, notation, valid }
-  }
-
-  move_rotations (move) { // symmetry helper, rotate a move around the board
-    let match = move.match(notation_regex)
-    if (match === null) return []
-    let x = decode_col(match[1])
-    let y = Number(match[2])
-    let s = match[3]
-    let slashes = s === '+' ? [s] : ['/', '\\']
-    let moves = new Set()
-    // this isn't super precise, but it limits the search space ... maybe #TODO?
-    for (let slash of slashes) {
-      moves.add(encode_col(x) + String(y) + slash)
-      moves.add(encode_col(y) + String(x) + slash)
-      moves.add(encode_col(this.height - x + 1) + String(this.width - y + 1) + slash)
-      moves.add(encode_col(this.width - y + 1) + String(this.height -x + 1) + slash)
-    }
-    return [...moves]
-  }
-
-  provisional_move (from, to, via) { // test a provisional move against the current state
-    let rows = from.slice(1).split(':')
-    let cols = rows.reduce((acc, cur) => Math.max(acc, code_row_len(cur)), 0)
-    rows = rows.length
-    if (this.width > rows && this.height > cols || this.width > cols && this.height > rows) {
-      return 'delete-provisional' // current board is bigger than the provisional move
-    }
-    if (from === this.normalized) {
-      let saved = this.save() // save this position
-      for (let move of this.move_rotations(via)) { // try all symmetrical moves
-        let drop = this.drop_tile(move)
-        if (drop.valid) {
-          if (to === this.normalized) return move  // this move matched!
-          this.restore(saved) // put the board back how it was
-        }
-      }
-    }
-    return false
-  }
-
-  get icon () {
-    return this.position_code()
-  }
-
-  tentative_icon (drops) {
-    return this.position_code(undefined, undefined, undefined, undefined, drops)
-  }
-
-  // symmetry helper
-  position_code (right_to_left, bottom_to_top, rotate, swap_colors, drops) {
-    const start_x = right_to_left ? this.right : this.left
-    const start_y = bottom_to_top ? this.bottom : this.top
-    const inc_x = right_to_left ? -1 : 1
-    const inc_y = bottom_to_top ? -1 : 1
-    let code = []
-    let line = ''
-    let x = start_x
-    let y = start_y
-    do {
-      let tile = this.tile_at(x, y) // normal tile for normal orientation
-      if (tile) {
-        if (right_to_left) tile = symmetry.mirror[tile]
-        if (bottom_to_top) tile = symmetry.flip[tile]
-        if (rotate) tile = symmetry.counterclock[tile]
-        if (swap_colors) tile = symmetry.swap[tile]
-        if (this.path.includes(this.tile_id(x, y))) {
-          tile = String.fromCharCode(tile.charCodeAt(0) + this.turn * 6)
-        }
-        if (drops && drops.dropped) {
-          if (drops.dropped.filter(t => t.x === x && t.y === y).length) tile = tile.toUpperCase()
-        }
-        line += tile
-      } else {
-        line = add_blank(line)
-      }
-      if (rotate) { // increment y more often than x
-        y += inc_y
-        if (y < this.top || y > this.bottom) {
-          y = start_y
-          x += inc_x
-          // remove final number and add to code
-          code.push(line.replace(/[0-9]+$/, ''))
-          line = ''
-        }
-      } else { // this is the standard order
-        x += inc_x
-        if (x < this.left || x > this.right) {
-          x = start_x
-          y += inc_y
-          // remove final number and add to code
-          code.push(line.replace(/[0-9]+$/, ''))
-          line = ''
-        }
-      }
-    } while (x >= this.left && x <= this.right && y >= this.top && y <= this.bottom)
-    if (rotate) code.reverse()
-    return code.join(':')
-  }
-
-  normalize (swap_colors=false) {
-    // trax has the potential for symmetry, so this gives us the ability to
-    // examine horizontal, vertical, and rotational symmetry for a color
-    // --- pass in a truthy value to get a position for the opposite color
-    let norm = 'z'
-    let bools = [true, false]
-    bools.forEach(r_to_l => {
-      bools.forEach(b_to_t => {
-        bools.forEach(rot => {
-          let code = this.position_code(r_to_l, b_to_t, rot, swap_colors)
-          if (code < norm) norm = code
-        })
-      })
-    })
-    return (this.color || 't').toUpperCase() + norm
-  }
-
-  get normalized () {
-    // the default call does not check for color symmetry, because you rarely need that
-    return this.normalize()
-  }
-}
-
-// add class methods
-Trax.column = encode_col
-
-// and class constants
-Trax.variants = variants
-Trax.color_of = color_of
-Trax.player_num = player_num
-Trax.other = other
-
-export default Trax

package/jsconfig.json

@@ -1,8 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "es2020",
-    "target": "es2020"
-  },
-  "checkJs": true,
-  "exclude": ["node_modules"]
-}