js-chess-engine 1.0.2 → 2.0.1-rc.0

package/lib/js-chess-engine.mjs

@@ -1,99 +0,0 @@
-import Board from './Board.mjs'
-import { printToConsole, getFEN } from './utils.mjs'
-
-export class Game {
-    constructor (configuration) {
-        this.board = new Board(configuration)
-    }
-
-    move (from, to) {
-        from = from.toUpperCase()
-        to = to.toUpperCase()
-        const possibleMoves = this.board.getMoves()
-        if (!possibleMoves[from] || !possibleMoves[from].includes(to)) {
-            throw new Error(`Invalid move from ${from} to ${to} for ${this.board.getPlayingColor()}`)
-        }
-        this.board.addMoveToHistory(from, to)
-        this.board.move(from, to)
-        return { [from]: to }
-    }
-
-    moves (from = null) {
-        return (from ? this.board.getMoves()[from.toUpperCase()] : this.board.getMoves()) || []
-    }
-
-    setPiece (location, piece) {
-        this.board.setPiece(location, piece)
-    }
-
-    removePiece (location) {
-        this.board.removePiece(location)
-    }
-
-    aiMove (level = 2) {
-        const move = this.board.calculateAiMove(level)
-        return this.move(move.from, move.to)
-    }
-
-    getHistory (reversed = false) {
-        return reversed ? this.board.history.reverse() : this.board.history
-    }
-
-    printToConsole () {
-        printToConsole(this.board.configuration)
-    }
-
-    exportJson () {
-        return this.board.exportJson()
-    }
-
-    exportFEN () {
-        return getFEN(this.board.configuration)
-    }
-}
-
-export function moves (config) {
-    if (!config) {
-        throw new Error('Configuration param required.')
-    }
-    const game = new Game(config)
-    return game.moves()
-}
-
-export function status (config) {
-    if (!config) {
-        throw new Error('Configuration param required.')
-    }
-    const game = new Game(config)
-    return game.exportJson()
-}
-
-export function getFen (config) {
-    if (!config) {
-        throw new Error('Configuration param required.')
-    }
-    const game = new Game(config)
-    return game.exportFEN()
-}
-
-export function move (config, from, to) {
-    if (!config) {
-        throw new Error('Configuration param required.')
-    }
-    const game = new Game(config)
-    game.move(from, to)
-    if (typeof config === 'object') {
-        return game.exportJson()
-    } else {
-        return game.exportFEN()
-    }
-}
-
-export function aiMove (config, level = 2) {
-    if (!config) {
-        throw new Error('Configuration param required.')
-    }
-    const game = new Game(config)
-    const move = game.board.calculateAiMove(level)
-    return { [move.from]: move.to }
-}

package/lib/utils.mjs

@@ -1,154 +0,0 @@
-import { COLUMNS, ROWS, COLORS, PIECES } from './const/board.mjs'
-
-export function printToConsole (configuration) {
-    process.stdout.write('\n')
-    let fieldColor = COLORS.WHITE
-    Object.assign([], ROWS).reverse().map(row => {
-        process.stdout.write(`${row}`)
-        COLUMNS.map(column => {
-            switch (configuration.pieces[`${column}${row}`]) {
-            case 'K': process.stdout.write('\u265A'); break
-            case 'Q': process.stdout.write('\u265B'); break
-            case 'R': process.stdout.write('\u265C'); break
-            case 'B': process.stdout.write('\u265D'); break
-            case 'N': process.stdout.write('\u265E'); break
-            case 'P': process.stdout.write('\u265F'); break
-            case 'k': process.stdout.write('\u2654'); break
-            case 'q': process.stdout.write('\u2655'); break
-            case 'r': process.stdout.write('\u2656'); break
-            case 'b': process.stdout.write('\u2657'); break
-            case 'n': process.stdout.write('\u2658'); break
-            case 'p': process.stdout.write('\u2659'); break
-            default: process.stdout.write(fieldColor === COLORS.WHITE ? '\u2588' : '\u2591')
-            }
-
-            fieldColor = fieldColor === COLORS.WHITE ? COLORS.BLACK : COLORS.WHITE
-        })
-        fieldColor = fieldColor === COLORS.WHITE ? COLORS.BLACK : COLORS.WHITE
-        process.stdout.write('\n')
-    })
-    process.stdout.write(' ')
-    COLUMNS.map(column => {
-        process.stdout.write(`${column}`)
-    })
-    process.stdout.write('\n')
-}
-
-export function getPieceValue (piece) {
-    const values = { k: 10, q: 9, r: 5, b: 3, n: 3, p: 1 }
-    return values[piece.toLowerCase()] || 0
-}
-
-export function getFEN (configuration) {
-    let fen = ''
-    Object.assign([], ROWS).reverse().map(row => {
-        let emptyFields = 0
-        if (row < 8) {
-            fen += '/'
-        }
-        COLUMNS.map(column => {
-            const piece = configuration.pieces[`${column}${row}`]
-            if (piece) {
-                if (emptyFields) {
-                    fen += emptyFields.toString()
-                    emptyFields = 0
-                }
-                fen += piece
-            } else {
-                emptyFields++
-            }
-        })
-        fen += `${emptyFields || ''}`
-    })
-
-    fen += configuration.turn === COLORS.WHITE ? ' w ' : ' b '
-
-    const { whiteShort, whiteLong, blackLong, blackShort } = configuration.castling
-    if (!whiteLong && !whiteShort && !blackLong && !blackShort) {
-        fen += '-'
-    } else {
-        if (whiteShort) fen += 'K'
-        if (whiteLong) fen += 'Q'
-        if (blackShort) fen += 'k'
-        if (blackLong) fen += 'q'
-    }
-
-    fen += ` ${configuration.enPassant ? configuration.enPassant.toLowerCase() : '-'}`
-
-    fen += ` ${configuration.halfMove}`
-
-    fen += ` ${configuration.fullMove}`
-
-    return fen
-}
-
-export function getJSONfromFEN (fen = '') {
-    const [board, player, castlings, enPassant, halfmove, fullmove] = fen.split(' ')
-
-    // pieces
-    const configuration = {
-        pieces: Object.fromEntries(board.split('/').flatMap((row, rowIdx) => {
-            let colIdx = 0
-            return row.split('').reduce((acc, sign) => {
-                const piece = sign.match(/k|b|q|n|p|r/i)
-                if (piece) {
-                    acc.push([`${COLUMNS[colIdx]}${ROWS[7 - rowIdx]}`, piece[0]])
-                    colIdx += 1
-                }
-                const squares = sign.match(/[1-8]/)
-                if (squares) {
-                    colIdx += Number(squares)
-                }
-                return acc
-            }, [])
-        })),
-    }
-
-    // playing player
-    if (player === 'b') {
-        configuration.turn = COLORS.BLACK
-    } else {
-        configuration.turn = COLORS.WHITE
-    }
-
-    // castlings
-    configuration.castling = {
-        whiteLong: false,
-        whiteShort: false,
-        blackLong: false,
-        blackShort: false,
-    }
-    if (castlings.includes('K')) {
-        configuration.castling.whiteShort = true
-    }
-    if (castlings.includes('k')) {
-        configuration.castling.blackShort = true
-    }
-    if (castlings.includes('Q')) {
-        configuration.castling.whiteLong = true
-    }
-    if (castlings.includes('q')) {
-        configuration.castling.blackLong = true
-    }
-
-    // enPassant
-    if (isLocationValid(enPassant)) {
-        configuration.enPassant = enPassant.toUpperCase()
-    }
-
-    // halfmoves
-    configuration.halfMove = parseInt(halfmove)
-
-    // fullmoves
-    configuration.fullMove = parseInt(fullmove)
-
-    return configuration
-}
-
-export function isLocationValid (location) {
-    return typeof location === 'string' && location.match('^[a-hA-H]{1}[1-8]{1}$')
-}
-
-export function isPieceValid (piece) {
-    return Object.values(PIECES).includes(piece)
-}

package/test/.eslintrc.json

@@ -1,11 +0,0 @@
-{
-  "plugins": [
-    "mocha"
-  ],
-  "extends": [
-    "plugin:mocha/recommended"
-  ],
-  "env": {
-    "mocha": true
-  }
-}

package/test/ai.test.mjs

@@ -1,132 +0,0 @@
-import chai from 'chai'
-import { Game } from '../lib/js-chess-engine.mjs'
-
-const expect = chai.expect
-
-describe('Should properly calculate BEST AI move', function () {
-    before(function () {
-        this.aiLevel = 4
-        console.time('UI test calculated in')
-    })
-
-    after(function () {
-        console.timeEnd('UI test calculated in')
-    })
-
-    it('Should do checkmate in one move', function () {
-        const game = new Game({
-            turn: 'white',
-            pieces: {
-                E1: 'K',
-                A7: 'R',
-                B6: 'R',
-                E8: 'k',
-            },
-        })
-        game.printToConsole()
-        game.aiMove(this.aiLevel)
-        expect(game.exportJson().checkMate).to.be.equal(true)
-    })
-
-    it('Should do checkmate in tree moves', function () {
-        const game = new Game({
-            pieces: {
-                E1: 'K',
-                A7: 'R',
-                A6: 'R',
-                E8: 'k',
-            },
-        })
-        game.printToConsole()
-        game.aiMove(this.aiLevel)
-        game.aiMove(0)
-        game.aiMove(this.aiLevel)
-        expect(game.exportJson().checkMate).to.be.equal(true)
-    })
-
-    it('Should not end with draw', function () {
-        const game = new Game({
-            pieces: {
-                E3: 'K',
-                F2: 'r',
-                D6: 'q',
-                E8: 'k',
-                G3: 'p',
-            },
-            turn: 'black',
-        })
-        game.printToConsole()
-        game.aiMove(this.aiLevel)
-        expect(game.exportJson().isFinished).to.be.equal(false)
-    })
-
-    it('Should move with knight', function () {
-        const game = new Game({
-            pieces: {
-                E1: 'K',
-                D3: 'R',
-                A3: 'B',
-                H1: 'B',
-                C7: 'N',
-                G1: 'N',
-                A2: 'P',
-                B4: 'P',
-                D2: 'P',
-                F2: 'P',
-                F3: 'P',
-                H2: 'P',
-                F7: 'k',
-                H8: 'r',
-                F8: 'b',
-                G8: 'n',
-                B8: 'n',
-                A7: 'p',
-                G4: 'p',
-                H6: 'p',
-            },
-            turn: 'black',
-        })
-        game.printToConsole()
-        const result = game.board.calculateAiMove(this.aiLevel)
-        expect(['B8', 'G8'].includes(result.from)).to.be.equal(true)
-        expect(['C6', 'F6'].includes(result.to)).to.be.equal(true)
-    })
-
-    it('Should move with pawn', function () {
-        const game = new Game({
-            pieces: {
-                D1: 'Q',
-                A1: 'R',
-                B2: 'P',
-                C2: 'P',
-                F2: 'P',
-                G2: 'P',
-                H2: 'P',
-                D8: 'q',
-                A8: 'r',
-                A7: 'p',
-                B7: 'p',
-                C7: 'p',
-                F7: 'p',
-                G7: 'p',
-                H7: 'p',
-                E4: 'P',
-                E5: 'N',
-                A3: 'P',
-                C5: 'p',
-                D5: 'N',
-                G8: 'k',
-                F8: 'r',
-                B5: 'B',
-                B8: 'n',
-                E6: 'b',
-                G1: 'K',
-                F1: 'R',
-            },
-            turn: 'black',
-        })
-        game.printToConsole()
-        const move = game.aiMove(this.aiLevel)
-        expect(move).to.be.deep.equal({ C7: 'C6' })
-    })
-})

package/test/badge.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="83" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><mask id="a"><rect width="83" height="20" rx="3" fill="#fff"/></mask><g mask="url(#a)"><path fill="#555" d="M0 0h41v20H0z"/><path fill="#4C1" d="M41 0h42v20H41z"/><path fill="url(#b)" d="M0 0h83v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,DejaVu Sans,Geneva,sans-serif" font-size="11"><text x="20.5" y="15" fill="#010101" fill-opacity=".3">Tests</text><text x="20.5" y="14">Tests</text><text x="61" y="15" fill="#010101" fill-opacity=".3">55/55</text><text x="61" y="14">55/55</text></g></svg>

package/test/importExport.mjs

@@ -1,108 +0,0 @@
-import chai from 'chai'
-import { Game } from '../lib/js-chess-engine.mjs'
-import { NEW_GAME_BOARD_CONFIG } from '../lib/const/board.mjs'
-
-const expect = chai.expect
-
-describe('Should properly export FEN', function () {
-    it('For new board', function () {
-        const expectedFen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'
-        const game = new Game()
-        expect(game.exportFEN()).to.be.deep.equal(expectedFen)
-    })
-    it('For new board after E2 to E4', function () {
-        const expectedFen = 'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1'
-        const game = new Game()
-        game.move('E2', 'E4')
-        expect(game.exportFEN()).to.be.deep.equal(expectedFen)
-    })
-    it('For new board after E2 to E4 and C7 to C5', function () {
-        const expectedFen = 'rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPP1PPP/RNBQKBNR w KQkq c6 0 2'
-        const game = new Game()
-        game.move('E2', 'E4')
-        game.move('C7', 'C5')
-        expect(game.exportFEN()).to.be.deep.equal(expectedFen)
-    })
-    it('For new board after E2 to E4 and C7 to C5 and E1 to E2', function () {
-        const expectedFen = 'rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPPKPPP/RNBQ1BNR b kq - 1 2'
-        const game = new Game()
-        game.move('E2', 'E4')
-        game.move('C7', 'C5')
-        game.move('E1', 'E2')
-        expect(game.exportFEN()).to.be.deep.equal(expectedFen)
-    })
-    it('For new board after E2 to E4 and C7 to C5 and E1 to E2 and D7 do D6', function () {
-        const expectedFen = 'rnbqkbnr/pp2pppp/3p4/2p5/4P3/8/PPPPKPPP/RNBQ1BNR w kq - 0 3'
-        const game = new Game()
-        game.move('E2', 'E4')
-        game.move('C7', 'C5')
-        game.move('E1', 'E2')
-        game.move('D7', 'D6')
-        expect(game.exportFEN()).to.be.deep.equal(expectedFen)
-    })
-    it('For new board after E2 to E4 and C7 to C5 and E1 to E2 and D7 do D6 nad G1 to F3', function () {
-        const expectedFen = 'rnbqkbnr/pp2pppp/3p4/2p5/4P3/5N2/PPPPKPPP/RNBQ1B1R b kq - 1 3'
-        const game = new Game()
-        game.move('E2', 'E4')
-        game.move('C7', 'C5')
-        game.move('E1', 'E2')
-        game.move('D7', 'D6')
-        game.move('G1', 'F3')
-        expect(game.exportFEN()).to.be.deep.equal(expectedFen)
-    })
-    it('For new board after E2 to E4 and C7 to C5 and E1 to E2 and D7 do D6 nad G1 to F3 and E8 to D7', function () {
-        const expectedFen = 'rnbq1bnr/pp1kpppp/3p4/2p5/4P3/5N2/PPPPKPPP/RNBQ1B1R w - - 2 4'
-        const game = new Game()
-        game.move('E2', 'E4')
-        game.move('C7', 'C5')
-        game.move('E1', 'E2')
-        game.move('D7', 'D6')
-        game.move('G1', 'F3')
-        game.move('E8', 'D7')
-        expect(game.exportFEN()).to.be.deep.equal(expectedFen)
-    })
-})
-
-describe('Should properly import FEN', function () {
-    beforeEach(function () {
-        this.newGameJson = JSON.parse(JSON.stringify(NEW_GAME_BOARD_CONFIG))
-    })
-
-    it('For new board', function () {
-        const gameFen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'
-        const game = new Game(gameFen)
-        const expectedConfiguration = this.newGameJson
-
-        expect(game.board.configuration).to.be.deep.equal(expectedConfiguration)
-    })
-
-    it('For new board after E2 to E4', function () {
-        const gameFen = 'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1'
-        const game = new Game(gameFen)
-        const expectedConfiguration = this.newGameJson
-        expectedConfiguration.turn = 'black'
-        expectedConfiguration.pieces.E4 = 'P'
-        delete expectedConfiguration.pieces.E2
-        expectedConfiguration.enPassant = 'E3'
-
-        expect(game.board.configuration).to.be.deep.equal(expectedConfiguration)
-    })
-
-    it('For new board after E2 to E4 and C7 to C5 and E1 to E2', function () {
-        const gameFen = 'rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPPKPPP/RNBQ1BNR b kq - 1 2'
-        const game = new Game(gameFen)
-        const expectedConfiguration = this.newGameJson
-        expectedConfiguration.turn = 'black'
-        expectedConfiguration.pieces.E4 = 'P'
-        expectedConfiguration.pieces.C5 = 'p'
-        expectedConfiguration.pieces.E2 = 'K'
-        delete expectedConfiguration.pieces.C7
-        delete expectedConfiguration.pieces.E1
-        expectedConfiguration.halfMove = 1
-        expectedConfiguration.fullMove = 2
-        expectedConfiguration.castling.whiteLong = false
-        expectedConfiguration.castling.whiteShort = false
-
-        expect(game.board.configuration).to.be.deep.equal(expectedConfiguration)
-    })
-})