TypeScript js.Chess.fen方法代码示例

 /**
  * 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)
     }
 }

    /**
     * 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."
            }
        }
    }

chess.in_draw();

// $ExpectType boolean
chess.insufficient_material();

// $ExpectType boolean
chess.in_threefold_repetition();

// $ExpectType boolean
chess.game_over();

// $ExpectType { valid: boolean; error_number: number; error: string; }
chess.validate_fen(fen);

// $ExpectType string
chess.fen();

// --- pgn --- \\

// $ExpectType string
chess.pgn({ max_width: 80, newline_char: '\n' });

// $ExpectType string
chess.pgn({ max_width: 120 });

// $ExpectType string
chess.pgn({ newline_char: '\r\n' });

// $ExpectType string
chess.pgn({});

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