TypeScript chess.js.Chess类代码示例

 it ("when not disambiguration for pawn moves in sloppy mode", () => {
     var chess = new Chess()
     var move
     move = chess.move("e4")
     expect(move).not.toBeNull()
     move = chess.move("d5")
     expect(move).not.toBeNull()
     move = chess.move("xd5", {sloppy: true})
     expect(move).not.toBeNull()
     //console.log(chess.ascii())
 })

 /**
  * Creates an instance of PgnGame. Is constructed normally be the PgnReader.
  * @param config a hash with all parameters given
  * @memberOf PGN
  * 
  */
 constructor(pgnMoves: PgnMove[], startPosition: string, result: string, pgnString: string) {
     this.chess = new Chess()
     this.pgnString = pgnString
     this.pgnMoves = pgnMoves
     this.result = result
     if (pgnString !== undefined) {
         this.pgnString = pgnString
     }
     if ( (startPosition === undefined) || (startPosition === null) ) {
         this.chess.reset()
         this.startPosition = this.chess.fen()
     } else {
         this.startPosition = startPosition
         this.chess.load(this.startPosition)
     }
 }

import * as chessjs from "chess.js";

const fen = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1";

// --- constructors --- \\

// $ExpectType ChessInstance
chessjs.Chess(fen);

// $ExpectType ChessInstance
const chess = new chessjs.Chess();

// $ExpectType "w"
chess.WHITE;

// $ExpectType "b"
chess.BLACK;

// $ExpectType "p"
chess.PAWN;

// $ExpectType "n"
chess.KNIGHT;

// $ExpectType "b"
chess.BISHOP;

// $ExpectType "r"
chess.ROOK;

// $ExpectType "q"

    /**
     * Validates the given moves, and changes them in place.
     * Throws an error if a move is not valid, with an expressive error message.
     * @param moves an array of PgnMove
     */
    public validate(moves: PgnMove[], startPosition: string): void {
        // No moves, no validation
        if (moves.length === 0) return
        if ( (startPosition === undefined) || (startPosition === null) ) {
            startPosition = this.defaultStartPosition()
        }

        for(let move of moves) {
            // Ensure that position before the move is setup
            if ( (move.previousMove === null) || (move.previousMove === undefined) ) {
                this.chess.load(startPosition)
            } else {
                this.chess.load(move.previousMove.fen)
            }
            // Try to make the move, if non-null result, it was successful
            let pgnMove = this.chess.move(move.notation, {sloppy: true})
            if (pgnMove) {
                move.fen = this.chess.fen()
                move.notation = pgnMove.san
                var currentMoveNumber = PgnReader.getMoveNumberFromPosition(move.fen)
                if (move.moveNumber) {
                    if (move.moveNumber !== currentMoveNumber) {
                        throw "Wrong move number for " + move.notation
                    }
                }
                move.moveNumber = currentMoveNumber
                if (this.chess.in_check()) {
                    move.check = "+"
                } else if (this.chess.in_checkmate()) {
                    move.check = "#"
                } else {
                    move.check = ''
                }
                if ( (pgnMove.flags == 'c') || (pgnMove.flags == 'e') ) {
                    move.strike = 'x'
                } else {
                    move.strike = ''
                }
                this.checkNAGs(move)
                // let disam = this.chess.get_disambiguator(PgnMove, true)
                // move.disc = disam
            } else {
                // This is the edge case: something went wrong with the move, so next moves will fail (no FEN)
                throw "Notation: " + move.notation + "  not valid."
            }
        }
    }

 private defaultStartPosition() {
     this.chess.reset()
     return this.chess.fen()
 }