play

#!/usr/bin/env coffee
require './rejection_handler'
readline = require 'readline'
{
  Board
  BLACK
  WHITE
  EMPTY
  pos_from_str
  square_to_char
  pos_to_str
} = require './board'
{ PatternBoard } = require './pattern'
Player = require './player'
pattern_eval = require './pattern_eval'
{ format_eval } = require './util'

argv = require 'yargs'
  .options
    black:
      alias: 'b'
      desc: 'Black player'
      choices: ['uct', 'human', 'minimax', 'simple', 'invert']
      default: 'uct'
      requiresArg: true
    white:
      alias: 'w'
      desc: 'White player'
      choices: ['uct', 'human', 'minimax', 'simple', 'invert']
      default: 'minimax'
      requiresArg: true
    search:
      alias: 's'
      desc: 'Number of UCT search'
      type: 'number'
      default: require('./uct').defaults.max_search
      requiresArg: true
    book:
      desc: 'Opening book'
      choices: ['static', 'db', 'none']
      default: 'static'
      requiresArg: true
    book_random:
      alias: 'r'
      desc: 'Randomness of opening book'
      type: 'number'
      default: .7
      requiresArg: true
    random:
      alias: 'R'
      desc: 'UCT randomness'
      type: 'number'
      default: 0
      requiresArg: true
    depth:
      alias: 'd'
      desc: 'Search depth of minimax'
      type: 'number'
      default: require('./minmax').defaults.max_depth
      requiresArg: true
    leafs:
      alias: 'l'
      desc: 'Maximum number of leafs to search of minimax'
      type: 'number'
      default: require('./minmax').defaults.max_leafs
      requiresArg: true
    wld:
      alias: 'W'
      desc: 'Depth of win-loss-draw endgame search'
      type: 'number'
      default: Player.defaults.solve_wld
      requiresArg: true
    full:
      alias: 'f'
      desc: 'Depth of ful endgame search'
      type: 'number'
      default: Player.defaults.solve_full
      requiresArg: true
    h:
      alias: 'help'
  .version false
  .strict()
  .argv

input = (prompt) -> new Promise (resolve) ->
  rl = readline.createInterface process.stdin, process.stdout
  rl.question prompt, (answer) ->
    resolve answer
    rl.close()

human = (board, turn) ->
  prompt = square_to_char(turn) + '? '
  while true
    pos = await input(prompt)
    if pos.toLowerCase() == 'undo'
      return 'undo'
    try
      pos = pos_from_str(pos)
    catch e
      console.log 'invalid position'
      continue
    if board.can_move(turn, pos)
      break
    else
      console.log 'illegal move'
  {move:pos}

book =
  if argv.book == 'static'
    require('./static_book_player')(random: argv.book_random)
  else if argv.book == 'db'
    require('./db_book_player')(random: argv.book_random)
  else
    null

normal_eval = pattern_eval('weights.json')
logistic = normal_eval.logistic

simple = Player
  book: book
  strategy: require('./uct')
    evaluate: require('./simple_eval')
    max_search: argv.search
    board_class: Board
    random: argv.random
  solve_wld: argv.wld
  solve_full: argv.full
  endgame_eval: normal_eval

minmax = Player
  book: book
  strategy: require('./minmax')
    evaluate: normal_eval
    max_depth: argv.depth
    max_leafs: argv.leafs
    shuffle: false
    #cache_size: 0
  solve_wld: argv.wld
  solve_full: argv.full
  endgame_eval: normal_eval

uct = Player
  book: book
  strategy: require('./uct')
    evaluate: normal_eval
    max_search: argv.search
    random: argv.random
  solve_wld: argv.wld
  solve_full: argv.full
  endgame_eval: normal_eval

invert = do->
  do_invert = null
  (board, turn, moves) ->
    unless do_invert
      invert_eval = pattern_eval('weights.json', true)
      do_invert = Player
        book: null
        strategy: require('./uct')
          evaluate: invert_eval
          max_search: argv.search
          inverted: true
          random: argv.random
        inverted: true
        solve_wld: argv.wld
        solve_full: argv.full
        endgame_eval: invert_eval
    do_invert(board, turn, moves)

time_tbl = {}

choose_player = (turn) ->
  switch (if turn==BLACK then argv.black else argv.white)
    when 'uct' then uct
    when 'human' then human
    when 'minimax' then minmax
    when 'simple' then simple
    when 'invert' then invert

do ->
  board = new PatternBoard
  turn = BLACK
  pass = 0
  undo_stack = []
  while true
    console.log board.dump true
    console.log square_to_char(BLACK), board.count(BLACK), 'discs', board.list_moves(BLACK).length, 'moves'
    console.log square_to_char(WHITE), board.count(WHITE), 'discs', board.list_moves(WHITE).length, 'moves'
    console.log "#{board.count(EMPTY)} empty squares"
    console.log square_to_char(turn), 'to move'
    player = choose_player turn
    if board.any_moves(turn)
      while true
        t = Date.now()
        {move, value, solved} = await player(board, turn)
        t = Date.now() - t
        time_tbl[turn] = (time_tbl[turn] or 0) + t
        if move == 'undo'
          undo_done = false
          while undo_stack.length
            [t, move, flips]= undo_stack.pop()
            board.undo t, move, flips
            if t == turn
              undo_done = true
              break
          if not undo_done
            console.log 'cannot undo'
            continue
          console.log board.dump true
          continue
        break
      flips = board.move turn, move
      console.assert flips.length
      undo_stack.push [turn, move, flips]
      console.log "#{square_to_char turn} moved to #{pos_to_str move}"
      if value?
        console.log "estimated value #{format_eval(value, logistic, solved)}"
    else
      if board.any_moves(-turn)
        console.log 'PASS'
        if player == human
          await input 'Press Enter'
      else
        break
    turn = -turn
  console.log "Time consumed by #{square_to_char(BLACK)}: #{time_tbl[BLACK]/1000} seconds"
  console.log "Time consumed by #{square_to_char(WHITE)}: #{time_tbl[WHITE]/1000} seconds"