code wiki / (root) / nx_folkgame_play.nx
`nx_folkgame_play.nx` source

↩ module page · 289 lines · 11362 B
1// nx_folkgame_play.nx -- NATIVE terminal player for any align-family folk game. THE POINT OF THIS
2// ORGAN IS THAT IT CAN BE PLAYED, and the operator's own standing correction is why it exists:
3// an internal GREEN gate is not a thing anyone can open and play. Built by the Nishi toolchain
4// (nx_cc -> nxasm_x86, no gcc) to a NATIVE binary that runs on this host -- no WebAssembly, no
5// browser, no borrowed VM anywhere in the path.
6//
7// usage: nx_folkgame_play <slug> [depth]     slug is a section of knowledge/compare/folkgames.align
8//
9// The opponent is full-width alpha-beta over the SAME move generator the gate validated against the
10// published Tic-Tac-Toe game-tree constant. It is not a second rules implementation: if it could
11// make a move the gate's generator does not admit, the two would disagree and this file would be
12// the duplicate-ruler defect.
13// Depth and evaluation weights are conf rows (knowledge/folkgames.conf), never literals.
14// license_tier: ORIGINAL   No hw writes (Rule 26).
15import "nx_folkgame_lib.nx"
16// The opponent lives in a shared lib so the gate proves the SAME search this organ plays with.
17import "nx_folkgame_ai_lib.nx"
18import "nx_lineconf_lib.nx"
19
20const FGP_SPEC: *u8 = "knowledge/compare/folkgames.align"
21const FGP_CONF: *u8 = "knowledge/folkgames.conf"
22const FGP_LINECAP: i64 = 256
23const FGP_GRIDCAP: i64 = 4096
24const FGP_HUMAN: i64 = 1
25const FGP_AI: i64 = 2
26const FGP_SP: i64 = 32
27const FGP_DOT: i64 = 46
28const FGP_X: i64 = 88
29const FGP_O: i64 = 79
30
31func fgp_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
32func fgp_num(v: i64) -> i64 {
  let b: *u8 = sys_mmap(FG_NUMSCRATCH)
  let t: *u8 = sys_mmap(FG_NUMSCRATCH)
  var m: i64 = v
  if m < 0 { m = 0 - m; sys_write(1, "-" as *u8, 1) }
  var k: i64 = 0
  if m == 0 { t[0] = FG_ZERO as u8; k = 1 }
  while m > 0 { t[k] = (FG_ZERO + (m % FG_DECIMAL)) as u8; m = m / FG_DECIMAL; k = k + 1 }
  var i: i64 = 0
  while i < k { b[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(1, b, k)
  sys_munmap(b, FG_NUMSCRATCH)
  sys_munmap(t, FG_NUMSCRATCH)
  return 0
46}
47
48// The board is drawn from the (x,y) every cell carries -- set explicitly by an xy row for the Morris
49// boards and derived from the grid for Tic-Tac-Toe and Gomoku. One renderer serves both because the
50// layout is data either way.
51func fgp_render(base: i64) -> i64 {
  var maxx: i64 = 0
  var maxy: i64 = 0
  var c: i64 = 0
  while c < fg_cells(base) {
      if fg_xy_x(base, c) > maxx { maxx = fg_xy_x(base, c) }
      if fg_xy_y(base, c) > maxy { maxy = fg_xy_y(base, c) }
      c = c + 1
  }
  let w: i64 = maxx + 1
  let h: i64 = maxy + 1
  let g: *u8 = sys_mmap(FGP_GRIDCAP)
  var i: i64 = 0
  while i < w * h { g[i] = FGP_SP as u8; i = i + 1 }
  var k: i64 = 0
  while k < fg_cells(base) {
      let p: i64 = fg_xy_y(base, k) * w + fg_xy_x(base, k)
      var ch: i64 = FGP_DOT
      if fg_at(base, k) == 1 { ch = FGP_X }
      if fg_at(base, k) == 2 { ch = FGP_O }
      g[p] = ch as u8
      k = k + 1
  }
  fgp_puts("\n" as *u8)
  var y: i64 = 0
  while y < h {
      fgp_puts("   " as *u8)
      var x: i64 = 0
      while x < w {
          sys_write(1, ((g as i64) + y * w + x) as *u8, 1)
          fgp_puts(" " as *u8)
          x = x + 1
      }
      fgp_puts("\n" as *u8)
      y = y + 1
  }
  sys_munmap(g, FGP_GRIDCAP)
  fgp_puts("\n" as *u8)
  return 0
90}
91
92// Cell numbers, printed on request, so a player can name a square without counting.
93func fgp_render_ids(base: i64) -> i64 {
  fgp_puts("   cell ids by row:\n" as *u8)
  var maxy: i64 = 0
  var c: i64 = 0
  while c < fg_cells(base) {
      if fg_xy_y(base, c) > maxy { maxy = fg_xy_y(base, c) }
      c = c + 1
  }
  var y: i64 = 0
  while y <= maxy {
      fgp_puts("   " as *u8)
      var k: i64 = 0
      while k < fg_cells(base) {
          if fg_xy_y(base, k) == y { fgp_num(k); fgp_puts(" " as *u8) }
          k = k + 1
      }
      fgp_puts("\n" as *u8)
      y = y + 1
  }
  return 0
113}
114
115func fgp_readline(buf: *u8, cap: i64) -> i64 {
  var n: i64 = 0
  var done: i64 = 0
  while done == 0 {
      if n >= cap - 1 { done = 1 }
      if done == 0 {
          let got: i64 = sys_read(0, ((buf as i64) + n) as *u8, 1)
          if got <= 0 { done = 1 }
          if got > 0 {
              if buf[n] == (FG_NL as u8) { done = 1 }
              if done == 0 { n = n + 1 }
          }
      }
  }
  buf[n] = 0 as u8
  return n
131}
132
133// Reads up to two integers from a line. Returns how many it found, so the caller can tell a place
134// (one number) from a move (two) without guessing.
135func fgp_ints(buf: *u8, n: i64, out: *i64) -> i64 {
  var found: i64 = 0
  var i: i64 = 0
  while i < n {
      let ch: i64 = buf[i] as i64
      var isd: i64 = 0
      if ch >= FG_ZERO { if ch <= FG_NINE { isd = 1 } }
      if isd == 1 {
          var v: i64 = 0
          while i < n {
              let c2: i64 = buf[i] as i64
              if c2 < FG_ZERO { break }
              if c2 > FG_NINE { break }
              v = v * FG_DECIMAL + (c2 - FG_ZERO)
              i = i + 1
          }
          if found < 2 { out[found] = v; found = found + 1 }
      }
      if isd == 0 { i = i + 1 }
  }
  return found
156}
157
158func fgp_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) {
      if a[i] != b[i] { return 0 }
      i = i + 1
  }
  if b[i] != (0 as u8) { return 0 }
  return 1
166}
167
168func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 {
      fgp_puts("usage: nx_folkgame_play <slug> [depth] | nx_folkgame_play selfplay <slug> [depth]\n" as *u8)
      return 2
  }
  // selfplay runs the opponent against itself to a finish. It exists for two reasons: an
  // interactive game cannot be proven from a tool call, and Tic-Tac-Toe under perfect play is a
  // DRAW -- another published constant, so the SEARCH gets an external check instead of a
  // self-grade. A search that blunders anywhere in a 9-cell game loses one of those selfplays.
  var selfplay: i64 = 0
  if fgp_streq(argv[1] as *u8, "selfplay" as *u8) == 1 { selfplay = 1 }
  var slugi: i64 = 1
  if selfplay == 1 { slugi = 2 }
  if argc < slugi + 1 {
      fgp_puts("usage: nx_folkgame_play selfplay <slug> [depth]\n" as *u8)
      return 2
  }
  let slug: *u8 = argv[slugi] as *u8
  let base: i64 = fg_parse_named_file(FGP_SPEC, slug)
  if base == 0 { fgp_puts("no such game in the family spec\n" as *u8); return 3 }
188
  let pw: i64 = lcf_int_of(FGP_CONF, "ai-piece-weight" as *u8)
  let win: i64 = lcf_int_of(FGP_CONF, "ai-win-score" as *u8)
  var depth: i64 = lcf_int_of(FGP_CONF, "ai-depth" as *u8)
  if pw == LCF_MISS { fgp_puts("REFUSED: ai-piece-weight missing from knowledge/folkgames.conf\n" as *u8); return 4 }
  if win == LCF_MISS { fgp_puts("REFUSED: ai-win-score missing from knowledge/folkgames.conf\n" as *u8); return 4 }
  if depth == LCF_MISS { fgp_puts("REFUSED: ai-depth missing from knowledge/folkgames.conf\n" as *u8); return 4 }
  let maxplies: i64 = lcf_int_of(FGP_CONF, "selfplay-max-plies" as *u8)
  if maxplies == LCF_MISS { fgp_puts("REFUSED: selfplay-max-plies missing from knowledge/folkgames.conf\n" as *u8); return 4 }
  if fg_cells(base) == 9 {
      let d9: i64 = lcf_int_of(FGP_CONF, "ai-depth-tictactoe" as *u8)
      if d9 != LCF_MISS { depth = d9 }
  }
  if argc >= slugi + 2 {
      let a2: *u8 = argv[slugi + 1] as *u8
      var nn: i64 = 0
      while a2[nn] != (0 as u8) { nn = nn + 1 }
      let ov: *i64 = sys_mmap(FG_WORD * 2) as *i64
      if fgp_ints(a2, nn, ov) == 1 { depth = ov[0] }
  }
208
  let sw: i64 = fg_snapwords(base)
  let mm: i64 = fg_maxmoves(base)
  let plies: i64 = fg_cells(base) + fg_cells(base) + depth + 2
  let snap: *i64 = sys_mmap(plies * sw * FG_WORD) as *i64
  let mvb: *i64 = sys_mmap(plies * mm * FG_WORD) as *i64
  let scr: *i64 = sys_mmap(mm * FG_WORD) as *i64
  let line: *u8 = sys_mmap(FGP_LINECAP)
  let ints: *i64 = sys_mmap(FG_WORD * 2) as *i64
217
  fgp_puts("\n=== " as *u8)
  fgp_puts(slug)
  fgp_puts(" === you are X and move first; the opponent is alpha-beta at depth " as *u8)
  fgp_num(depth)
  fgp_puts("\n" as *u8)
  fgp_render_ids(base)
224
  var running: i64 = 1
  while running == 1 {
      if selfplay == 1 {
          let scl: *i64 = fg_scal(base)
          if scl[FG_S_PLIES] > maxplies {
              fgp_puts("UNRESOLVED: selfplay reached the ply cap without a terminal position\n" as *u8)
              running = 0
          }
      }
      let t: i64 = fg_terminal(base, scr)
      if t != FG_T_ONGOING {
          fgp_render(base)
          if t == FG_T_P1 { fgp_puts("YOU WIN\n" as *u8) }
          if t == FG_T_P2 { fgp_puts("THE OPPONENT WINS\n" as *u8) }
          if t == FG_T_DRAW { fgp_puts("DRAW\n" as *u8) }
          running = 0
      }
      if running == 1 {
          var human_turn: i64 = 0
          if selfplay == 0 { if fg_side(base) == FGP_HUMAN { human_turn = 1 } }
          if human_turn == 1 {
              fgp_render(base)
              if fg_phase(base) == FG_PH_PLACE { fgp_puts("place a piece -- type a cell id: " as *u8) }
              if fg_phase(base) == FG_PH_MOVE { fgp_puts("move -- type two cell ids, from and to: " as *u8) }
              if fg_phase(base) == FG_PH_CAPTURE { fgp_puts("you made a mill -- type an enemy cell id to remove: " as *u8) }
              let ln: i64 = fgp_readline(line, FGP_LINECAP)
              let got: i64 = fgp_ints(line, ln, ints)
              if got == 0 { fgp_puts("no cell id in that line\n" as *u8) }
              if got > 0 {
                  let n: i64 = fg_moves(base, mvb)
                  var picked: i64 = 0 - 1
                  var i: i64 = 0
                  while i < n {
                      let mv: i64 = mvb[i]
                      let kd: i64 = fg_mv_kind(mv)
                      if kd == FG_MK_MOVE {
                          if got == 2 {
                              if fg_mv_from(mv) == ints[0] { if fg_mv_to(mv) == ints[1] { picked = mv } }
                          }
                      }
                      if kd != FG_MK_MOVE {
                          if fg_mv_to(mv) == ints[0] { picked = mv }
                      }
                      i = i + 1
                  }
                  if picked < 0 { fgp_puts("that is not a legal move here\n" as *u8) }
                  if picked >= 0 { fg_apply(base, picked) }
              }
          }
          if human_turn == 0 {
              let mv: i64 = fgai_best(base, depth, snap, sw, mvb, mm, scr, pw, win)
              if mv < 0 { running = 0 }
              if mv >= 0 {
                  fgp_puts("opponent plays " as *u8)
                  if fg_mv_kind(mv) == FG_MK_MOVE { fgp_num(fg_mv_from(mv)); fgp_puts(" to " as *u8) }
                  if fg_mv_kind(mv) == FG_MK_REMOVE { fgp_puts("remove " as *u8) }
                  fgp_num(fg_mv_to(mv))
                  fgp_puts("\n" as *u8)
                  fg_apply(base, mv)
              }
          }
      }
  }
  return 0
289}
nx_folkgame_play.nx source

`nx_folkgame_play.nx` source
