if(logStream){

let time = new Date().getTime()

let elapsed = time - logFileT0

logFileT0 = time

logStream.write(`${elapsed} > ${content}\n`)

}

if(disableLogs){

return

}

console.log(content)

ssesend({

kind: "logPage",

content: content

})

return new Promise(resolve=>{

if(!state.fen){

resolve(null)

return

}

if(useSolution && (state.variant == "antichess")){

if(state.movesArray.length){

let url = `http://magma.maths.usyd.edu.au/~watkins/LOSING_CHESS/WEB/browse.php?${state.movesArray.join("+")}`

console.log("getting solution", url)

let timedOut = false

let solutionTimeout = setTimeout(_=>{

console.log("antichess solution timed out")

timedOut = true

resolve(null)

return

}, 5000)

fetch(url).then(response => response.text().then(content => {

clearTimeout(solutionTimeout)

if(timedOut){

return

}

let m = content.match(/<tr class="oddRow"><td><a href="browse.php?[^"]+">([^<]+)/)

if(m){

let san = m[1]

console.log("antichess solution move", san)

let result = makeUciMoves("antichess", state.fen, [])

let legalMovesUcis = result.legalMovesUcis

let uci = null

console.log("legal ucis", legalMovesUcis)

for(let test of legalMovesUcis){

let result = makeUciMoves("antichess", state.fen, [test])

let sanMoves = result.sanMoves

//console.log("convert", test, sanMoves[0])

if(sanMoves[0] == san){

console.log("solution move", test)

resolve({

source: "solution",

moves: [{

white: 1,

draws: 0,

black: 0,

uci: test

}]

})

}

}

resolve(null)

return

}else{

resolve(null)

return

}

}))

}else{

resolve({

source: "solution",

moves: [{

white: 1,

draws: 0,

black: 0,

uci: "e2e3"

}]

})

return

}

return

}

if(usePolyglot && lichessUtils.isStandard(state.variant)){

if(!book.loaded){

console.log("polyglot book not yet loaded")

resolve(null)

return

}

let entries = book.find(state.fen)

if((!entries) || (!entries.length)){

resolve(null)

return

}

resolve({

source: "polyglot",

moves: entries.map(entry => ({

white: 0,

draws: entry.weight,

black: 0,

uci: entry.algebraic_move

}))

})

return

}

let coll = (mongoVersion == 1) ? poscoll : movecoll

if( useMongoBook && coll ){

if(!disableEngineForMongo){

if((Math.random() * 100) < ignoreMongoPercent){

resolve(null)

return

}

}

let key = state.fen.split(" ").slice(0, 4).join(" ")

getBook(state.variant, key).then(result => {

if(result.length){

let moves = result.map(item => ({

uci: item.uci,

plays: item.plays,

score: Math.floor(item.score * 100)

}))

let filteredMoves = moves

if(!disableEngineForMongo){

filteredMoves = moves.filter(move => {

let perf = move.score / move.plays

if(move.plays < filterThresoldPlays) return true

if((Math.random() * 100) < bookForgiveness) return true

if(perf < mongoFilter) return false

return true

})

}

if(!filteredMoves.length){

resolve(null)

return

}

let blob = {

source: "mongo",

moves: filteredMoves.map(move => ({

uci: move.uci,

white: 0,

draws: move.score,

black: 0

}))

}

resolve(blob)

return

}else{

resolve(null)

}

})

return

}

if(!useBook){

resolve(null)

return

}

let reqUrl = `https://explorer.lichess.ovh/lichess?fen=${state.fen}&${urlArray("ratings", bookRatings)}&${urlArray("speeds", bookSpeeds)}&moves=${bookSpread}&variant=${state.variant}`

if(logApi) console.log(reqUrl)

fetch(reqUrl).then(response=>response.text().then(content=>{

try{

let blob = JSON.parse(content)

blob.source = "lichess"

resolve(blob)

}catch(err){resolve(null)}

}))

})

if(skipAfterFailed){

if(failedLookups.count >= skipAfterFailed){

logFile(`skip use book after ${failedLookups.count} failed lookups`)

return false

}

}

return (useBook || useMongoBook || usePolyglot || useSolution) && (moves.length <= bookDepth)

logFile(`makeMove ${gameId} ${state} ${moves} ${analyzejob} ${actualengine}`)

if(state.realtime && playingGameId && (gameId != playingGameId)){

logPage(`refused to make move for real time game ${gameId} ( already playing real time : ${playingGameId} )`)

return

}

logPage(`making move for game ${gameId}, variant ${state.variant}, fen ${state.fen}, moves ${moves}`)

engine.logProcessLine = false

let enginePromise

if(state.variant == "standard"){

if(moves.length == 0){

let randomOpeningMove = possibleOpeningMoves[Math.floor(Math.random() * possibleOpeningMoves.length)]

enginePromise = Promise.resolve({

bestmove: randomOpeningMove,

source: "own book"

})

}

if(moves.length == 1){

let responses = possibleOpeningResponses[moves[0]]

if(responses){

let randomOpeningResponse = responses[Math.floor(Math.random() * responses.length)]

enginePromise = Promise.resolve({

bestmove: randomOpeningResponse,

source: "own book"

})

}

}

}

let bookalgeb = null

let bookSource = null

if(getUseBook(moves, failedLookups)){

let blob = await requestBook(state)

if(blob){

let bmoves = blob.moves

if(bmoves && bmoves.length){

let grandTotal = 0

for(let bmove of bmoves){

bmove.total = bmove.white + bmove.draws + bmove.black

grandTotal += bmove.total

}

let rand = Math.round(Math.random() * grandTotal)

let currentTotal = 0

for(let bmove of bmoves){

currentTotal += bmove.total

if(currentTotal >= rand){

bookalgeb = bmove.uci

bookSource = blob.source

break

}

}

}

}

}

if(bookalgeb){

logPage(`${bookSource} book move found ${bookalgeb}`)

enginePromise = Promise.resolve({

bestmove: bookalgeb,

source: bookSource + " book"

})

}else{

failedLookups.count++

logFile(`failed lookups ${failedLookups.count}`)

}

if(!enginePromise){

logFile(`making engine move`)

let doPonder = ( ( state.botTime > ( 15 * SECOND ) ) || isEnvTrue("ALLOW_LATE_PONDER") ) && allowPonder

if(isEnvTrue('REDUCE_LATE_TIME')){

if(state.botTime < ( 30 * SECOND ) ) state.botTime = Math.floor(state.botTime * 0.75)

if(state.botTime < ( 15 * SECOND ) ) state.botTime = Math.floor(state.botTime * 0.75)

}

logPage(`engine time ${state.botTime} ponder ${doPonder} thinking with ${engineThreads} thread(s) at skill level ${engineSkillLevel} using ${engineHash} hash and overhead ${engineMoveOverhead} with contempt ${engineContempt}`)

analyzejob.position(`fen ${state.initialFen}`, moves)

let timecontrol = state.realtime ? {

wtime: state.botWhite ? state.botTime : state.wtime, winc: state.winc,

btime: state.botWhite ? state.btime : state.botTime, binc: state.binc,

ponderAfter: allowPonder

}

:

{

wtime: correspondenceThinkingTime * SECOND, winc: 0,

btime: correspondenceThinkingTime * SECOND, binc: 0

}

analyzejob.setTimecontrol(timecontrol)

analyzejob.processing = false

analyzejob.waiting = true

enginePromise = actualengine.enqueueJob(analyzejob)

}else{

if(state.realtime) engine.stop()

}

logFile(`launching search`)

enginePromise.then(result => {

let bestmove = result.bestmove

let ponder = result.ponder

let score = {unit: "none", value: "none"}

try{

scoreTemp = result.depthInfos[result.depthInfos.length - 1].score

if(scoreTemp) score = scoreTemp

}catch(err){/*console.log(err)*/}

let logMsg = `bestmove: ${bestmove}, ponder: ${ponder || "none"}, source: ${result.source || "engine"}, score unit: ${score.unit}, score value: ${score.value}`

logPage(logMsg)

logFile(`bestmove ${bestmove} ponder ${ponder} score ${score}`)

lichessUtils.postApi({

url: lichessUtils.makeBotMoveUrl(gameId, bestmove), log: logApi, token: process.env.TOKEN,

callback: content => {

logFile(`make move response ${content}`)

if(logApi) logPage(`move ack: ${content}`)

if(content.match(/error/)){

if(state.realtime && playingGameId && (gameId == playingGameId)){

logPage(`retry move for ${gameId} ${bestmove}`)

engine.spawn() // restart engine for retry move

setTimeout(_ => makeMove(gameId, state, moves, analyzejob, actualengine, failedLookups), 10 * SECOND)

}

}

}

})

})

console.log(`aborting game ${gameId}`)

lichessUtils.postApi({

url: lichessUtils.abortGameUrl(gameId), log: logApi, token: process.env.TOKEN,

callback: content => logPage(`abort game response: ${content}`)

})

if(playQueue.find(id => id == gameId)){

logFile(`game already in queue ${gameId}`)

return

}

playQueue.push(gameId)

logFile(`enqueued game ${gameId} , queue ${playQueue}`)

let abortGameTimeout = null

logPage(`playing game: ${gameId}`)

let actualengine, analyzejob, speed, correspondence, realtime, botWhite, variant, initialFen, whiteName, blackName, whiteTitle, blackTitle, whiteRating, blackRating, rated, mode

let playgame = true

let playgameTimeout = null

let duration = null

let storedChess = null

let storedMoves = null

let failedLookups = {

count: 0

}

streamNdjson({url: lichessUtils.streamBotGameUrl(gameId), token: process.env.TOKEN, timeout: generalTimeout, log: logApi, timeoutCallback: _=>{

logPage(`game ${gameId} timed out ( playing : ${playingGameId} )`)

if( (gameId == playingGameId) || correspondence ){

playGame(gameId)

}

}, callback: async function(blob){

logFile(`game event ${JSON.stringify(blob)}`)

if(!playgame) return

lastPlayedAt = new Date().getTime()

if(blob.type == "gameFull"){

speed = blob.speed

correspondence = ( speed == "correspondence" )

realtime = !correspondence

if(realtime && playingGameId && ( gameId != playingGameId )){

playgame = false

logPage(`can't start new game ${gameId}, already playing ${playingGameId}`)

return

}

if(realtime){

playingGameId = gameId

setTimeout(_=>lichessUtils.gameChat(gameId, "all", welcomeMessage), 2 * SECOND)

setTimeout(_=>lichessUtils.gameChat(gameId, "all", goodLuckMessage), 4 * SECOND)

engine.spawn()

engine

.setoption("Threads", engineThreads)

.setoption("Skill Level", engineSkillLevel)

.setoption("Hash", engineHash)

.setoption("Contempt", engineContempt)

.setoption("Move Overhead", engineMoveOverhead)

actualengine = engine

if(blob.clock){

const clock = blob.clock

console.log("clock", clock)

const initial = clock.initial || 0

const increment = clock.increment || 0

duration = initial + lichessUtils.AVERAGE_GAME_LENGTH * increment

}else{

duration = ( 180 * MINUTE ) + ( lichessUtils.AVERAGE_GAME_LENGTH * 180 * SECOND )

}

console.log("duration", duration)

}else{

actualengine = corrEngine

}

//console.log("actual engine", actualengine)

abortGameTimeout = setTimeout(_ => {

console.log(`opponent failed to make their opening move for ${abortAfter} seconds`)

abortGame(gameId)

}, abortAfter * SECOND)

whiteName = blob.white.name

whiteTitle = blob.white.title

whiteRating = blob.white.rating

blackName = blob.black.name

blackTitle = blob.black.title

blackRating = blob.black.rating

botWhite = whiteName == lichessBotName

variant = blob.variant.key

initialFen = blob.initialFen

rated = blob.rated

mode = rated ? "rated" : "casual"