feat(notation): add epd parser and win-at-chess suite

Epd.scala

@@ -0,0 +1,80 @@
+package gambit
+
+final case class EpdPosition(
+    fen: String,
+    bestMoves: List[String],
+    avoidMoves: List[String],
+    id: String,
+    operations: Map[String, String]
+)
+
+final case class EpdResult(
+    position: EpdPosition,
+    solved: Boolean,
+    playedSan: String,
+    depth: Int,
+    nodes: Long,
+    timeMs: Long
+)
+
+object Epd:
+  def parse(line: String): EpdPosition =
+    val trimmed = line.trim
+    val fields = trimmed.split("\\s+")
+    val board = fields.take(4).mkString(" ")
+    val rest = trimmed.split("\\s+", 5)
+    val opsText = if rest.length >= 5 then rest(4) else ""
+    val operations = parseOperations(opsText)
+    val fen = s"$board ${operations.getOrElse("hmvc", "0")} ${operations.getOrElse("fmvn", "1")}"
+    EpdPosition(
+      fen = fen,
+      bestMoves = tokenizeMoves(operations.getOrElse("bm", "")),
+      avoidMoves = tokenizeMoves(operations.getOrElse("am", "")),
+      id = operations.getOrElse("id", "").replace("\"", ""),
+      operations = operations
+    )
+
+  private def tokenizeMoves(operand: String): List[String] =
+    operand.split("\\s+").filter(_.nonEmpty).toList
+
+  private def parseOperations(text: String): Map[String, String] =
+    val out = scala.collection.mutable.LinkedHashMap[String, String]()
+    for chunk <- text.split(";") do
+      val piece = chunk.trim
+      if piece.nonEmpty then
+        val space = piece.indexWhere(_.isWhitespace)
+        if space < 0 then out(piece) = ""
+        else out(piece.take(space)) = piece.drop(space).trim
+    out.toMap
+
+  def solve(position: EpdPosition, timeMs: Long, maxDepth: Int = 64): EpdResult =
+    val pos = Fen.parse(position.fen)
+    val good = resolve(pos, position.bestMoves)
+    val bad = resolve(pos, position.avoidMoves)
+    val searcher = new Searcher
+    val result = searcher.search(pos, maxDepth, timeMs)
+    val best = result.bestMove
+    val solved =
+      if position.bestMoves.nonEmpty then good.contains(best)
+      else if position.avoidMoves.nonEmpty then !bad.contains(best)
+      else false
+    val playedSan = if best != 0 then San.toSan(pos, best) else "(none)"
+    EpdResult(position, solved, playedSan, result.depth, result.nodes, timeMs)
+
+  private def resolve(pos: Position, sans: List[String]): Set[Int] =
+    sans.map(San.parse(pos, _)).filter(_ != 0).toSet
+
+  def runSuite(lines: Seq[String], timeMs: Long, maxDepth: Int = 64): List[EpdResult] =
+    lines.filter(_.trim.nonEmpty).map(line => solve(parse(line), timeMs, maxDepth)).toList
+
+  def report(results: List[EpdResult]): String =
+    val solved = results.count(_.solved)
+    val sb = new StringBuilder
+    for r <- results do
+      val flag = if r.solved then "ok  " else "MISS"
+      val label = if r.position.id.nonEmpty then r.position.id else r.position.fen
+      val target = if r.position.bestMoves.nonEmpty then s"bm ${r.position.bestMoves.mkString(" ")}"
+      else s"am ${r.position.avoidMoves.mkString(" ")}"
+      sb.append(f"[$flag] $label%-12s played ${r.playedSan}%-8s ($target) depth ${r.depth} nodes ${r.nodes}\n")
+    sb.append(s"solved ${solved}/${results.length}\n")
+    sb.toString