🥮 mooncakes.io

    xiangqi

    中国象棋规则与搜索本地候选

    Download zip
    Version
    0.4.0
    License
    MIT
    Repository
    Last updated
    4 hours ago
    Downloads
    1

    #可执行 API 示例

    增加同步 UCCI 命令核心：握手、准备、局面、走子、有限深度搜索及退出。这些例子调用公开 API，并随 moon test 执行。

    ///|
    test "UCCI ready position go quit session" {
      let e = @xiangqi.Engine::new()
      assert_true(e.command("ucci").has_suffix("ucciok"))
      assert_eq(e.command("isready"), "readyok")
      assert_eq(e.command("position startpos moves h2e2"), "")
      assert_true(e.command("go depth 1").has_prefix("bestmove "))
      assert_true(
        try {
          ignore(e.command("position startpos moves a0a9"))
          false
        } catch {
          _ => true
        },
      )
      assert_eq(e.command("quit"), "")
      assert_true(
        try {
          ignore(e.command("isready"))
          false
        } catch {
          _ => true
        },
      )
    }

    持续进程及异步停止见 node tools/engine.mjs。正式重复/长将/长捉裁决、开局库与专业棋力仍未完成。

    ChessError

    source
    pub suberror ChessError {
      Invalid(String)
    } derive(
    Debug    )

    Board

    source
    pub struct Board {
      cells : Array[Int]
      red : Bool
    } derive(Eq, 
    Debug    )

    Board::best_move

    source
    fn Board::best_move(self : Board, depth : Int, node_limit? : Int) -> Move? raise ChessError

    Board::fen

    source
    fn Board::fen(self : Board) -> String

    Board::in_check

    source
    fn Board::in_check(self : Board, red : Bool) -> Bool

    Board::legal_moves

    source
    fn Board::legal_moves(self : Board) -> Array[Move]

    Board::perft

    source
    fn Board::perft(self : Board, depth : Int) -> Int raise ChessError

    Board::play

    source
    fn Board::play(self : Board, coordinate : String) -> Board raise ChessError

    Board::search

    source
    fn Board::search(self : Board, depth : Int, node_limit? : Int, should_stop? : () -> Bool, on_iteration? : (SearchResult) -> Unit, history? : Array[String]) -> SearchResult raise ChessError

    Iterative alpha-beta with capture quiescence and a bounded move-order cache. Cancellation returns the last completed iteration (or a legal fallback). Repeated search-path positions score 0 as a heuristic, not tournament rules.

    Engine

    source
    pub struct Engine {
      game : Game
      closed : Bool
    } derive(
    Debug    )

    Synchronous, transport-independent UCCI command session.

    Engine::command

    source
    fn Engine::command(self : Engine, line : String) -> String raise ChessError

    Engine::fen

    source
    fn Engine::fen(self : Engine) -> String

    Engine::new

    source
    fn Engine::new() -> Engine

    Engine::search

    source
    fn Engine::search(self : Engine, depth : Int, node_limit? : Int, should_stop? : () -> Bool, on_iteration? : (SearchResult) -> Unit) -> SearchResult raise ChessError

    Engine::status

    source
    fn Engine::status(self : Engine) -> String

    Game

    source
    pub struct Game {
      positions : Array[Board]
    } derive(
    Debug    )

    Bounded game history with simple threefold/perpetual-check adjudication. Long-chase and tournament-specific exceptions are outside this policy.

    Game::board

    source
    fn Game::board(self : Game) -> Board

    Game::new

    source
    fn Game::new(board : Board) -> Game

    Game::play

    source
    fn Game::play(self : Game, coordinate : String) -> Unit raise ChessError

    Replay legal moves, including analysis lines beyond an earlier repetition.

    Game::search

    source
    fn Game::search(self : Game, depth : Int, node_limit? : Int, should_stop? : () -> Bool, on_iteration? : (SearchResult) -> Unit) -> SearchResult raise ChessError

    Game::status

    source
    fn Game::status(self : Game) -> String

    Move

    source
    pub(all) struct Move {
      from : Int
      to : Int
    } derive(Eq, 
    Debug    )

    Move::coordinate

    source
    fn Move::coordinate(self : Move) -> String

    SearchResult

    source
    pub(all) struct SearchResult {
      best : Move?
      score : Int
      depth : Int
      nodes : Int
      stopped : Bool
    } derive(Eq, 
    Debug    )

    Last fully completed iteration; depth 0 is the legal fallback before any iteration completed. Scores are from the root side, in internal pawn units.

    initial

    source
    fn initial() -> Board

    parse_fen

    source
    fn parse_fen(fen : String) -> Board raise ChessError

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io