# Fools Mate (TryHackMe)
[Challenge on TryHackMe: **Fools Mate**](https://tryhackme.com/room/foolsmate)
t's mate in one. You know it, the engine knows it, my grandma knows it. The board says checkmate is one click away. The engine says no. Settle the argument.
You can access the web app from your AttackBox's browser via: [`http://MACHINE_IP`](http://MACHINE_IP)
### Answer the questions below
What is the flag?
```markdown
nmap -p- -sV IP_Address
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.6p1 Ubuntu 3ubuntu13.16 (Ubuntu Linux; protocol 2.0)
80/tcp open http Node.js Express framework
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
```
```markdown
curl http://IP_Address
Endgame Trainer
♜EndgameTrainer
Mate-in-one · White to move
/usr/lib32×
I'll shut down your PC if you play that.
```
`gobuster dir -u http://IP_Address -w /usr/share/wordlists/dirb/common.txt -x php,html,txt`
```markdown
gobuster dir -u http://IP_Address -w /usr/share/wordlists/dirb/common.txt -x php,html,txt,js,tsx
/css (Status: 301) [Size: 153] [--> /css/]
/index.html (Status: 200) [Size: 2454]
/index.html (Status: 200) [Size: 2454]
/js (Status: 301) [Size: 152] [--> /js/]
/vendor (Status: 301) [Size: 156]
```
```markdown
gobuster dir -u http://IP_Address/js -w /usr/share/wordlists/dirb/common.txt -x php,html,txt,tsx,js
/app.js (Status: 200) [Size: 12355]
```
```markdown
curl http://IP_Address/js/app.js
import { Chess } from '../vendor/chess.js';
const START_FEN = '6k1/5ppp/8/8/8/8/5PPP/R5K1 w - - 0 1';
const FILES = 'abcdefgh';
const SMUG = ['Sure, go ahead.', 'Bold.', 'Cute.'];
const boardEl = document.getElementById('board');
const ranksEl = document.getElementById('ranks');
const filesEl = document.getElementById('files');
const moveListEl = document.getElementById('moveList');
const statusText = document.getElementById('statusText');
const turnDot = document.getElementById('turnDot');
const flagBanner = document.getElementById('flagBanner');
const resetBtn = document.getElementById('resetBtn');
const toastStack = document.getElementById('toastStack');
const modalOverlay = document.getElementById('modalOverlay');
const winMessage = document.getElementById('winMessage');
const winOk = document.getElementById('winOk');
const game = new Chess(START_FEN);
const sqDivs = {};
let els = {};
let history = [];
let selected = null;
let locked = false;
let dragEl = null;
let dragFrom = null;
let dragging = false;
let downX = 0;
let downY = 0;
function sqToXY(sq) {
const f = FILES.indexOf(sq[0]);
const r = parseInt(sq[1], 10);
return { x: f * 12.5, y: (8 - r) * 12.5 };
}
function codeOf(cell) {
return cell.color + cell.type.toUpperCase();
}
function buildBoard() {
for (let r = 8; r >= 1; r--) {
for (let f = 0; f < 8; f++) {
const sq = FILES[f] + r;
const d = document.createElement('div');
const isLight = (f + r) % 2 !== 0;
d.className = 'square ' + (isLight ? 'light' : 'dark');
const { x, y } = sqToXY(sq);
d.style.left = x + '%';
d.style.top = y + '%';
d.dataset.square = sq;
boardEl.appendChild(d);
sqDivs[sq] = d;
}
}
for (let r = 8; r >= 1; r--) {
const s = document.createElement('span');
s.textContent = r;
ranksEl.appendChild(s);
}
for (let f = 0; f < 8; f++) {
const s = document.createElement('span');
s.textContent = FILES[f];
filesEl.appendChild(s);
}
}
function setElPos(el, sq, instant) {
const { x, y } = sqToXY(sq);
if (instant) {
el.style.transition = 'none';
el.style.left = x + '%';
el.style.top = y + '%';
void el.offsetWidth;
el.style.transition = '';
} else {
el.style.left = x + '%';
el.style.top = y + '%';
}
}
function renderFull() {
for (const el of Object.values(els)) el.remove();
els = {};
const board = game.board();
for (let row = 0; row < 8; row++) {
for (let col = 0; col < 8; col++) {
const cell = board[row][col];
if (!cell) continue;
const sq = FILES[col] + (8 - row);
const el = document.createElement('div');
el.className = 'piece ' + codeOf(cell);
el.dataset.square = sq;
const { x, y } = sqToXY(sq);
el.style.transition = 'none';
el.style.left = x + '%';
el.style.top = y + '%';
boardEl.appendChild(el);
els[sq] = el;
}
}
void boardEl.offsetWidth;
for (const el of Object.values(els)) el.style.transition = '';
refreshHighlights();
}
function animateMove(from, to) {
const el = els[from];
if (!el) { renderFull(); return; }
if (els[to]) {
const cap = els[to];
delete els[to];
setTimeout(() => cap.remove(), 170);
}
setElPos(el, to, false);
el.dataset.square = to;
delete els[from];
els[to] = el;
}
function clearHints() {
boardEl.querySelectorAll('.hint').forEach((n) => n.remove());
}
function showHints(sq) {
clearHints();
const moves = game.moves({ square: sq, verbose: true });
for (const m of moves) {
const h = document.createElement('div');
const occupied = !!els[m.to] || m.flags.includes('e');
h.className = 'hint' + (occupied ? ' capture' : '');
const { x, y } = sqToXY(m.to);
h.style.left = x + '%';
h.style.top = y + '%';
const spot = document.createElement('div');
spot.className = 'spot';
h.appendChild(spot);
boardEl.appendChild(h);
}
}
function clearSelection() {
if (selected && sqDivs[selected]) sqDivs[selected].classList.remove('selected');
selected = null;
clearHints();
}
function select(sq) {
clearSelection();
selected = sq;
sqDivs[sq].classList.add('selected');
showHints(sq);
}
function refreshHighlights() {
Object.values(sqDivs).forEach((d) => d.classList.remove('in-check'));
if (game.isCheck() || game.isCheckmate()) {
const turn = game.turn();
const board = game.board();
for (let row = 0; row < 8; row++) {
for (let col = 0; col < 8; col++) {
const cell = board[row][col];
if (cell && cell.type === 'k' && cell.color === turn) {
sqDivs[FILES[col] + (8 - row)].classList.add('in-check');
}
}
}
}
}
function setLastMove(from, to) {
Object.values(sqDivs).forEach((d) => d.classList.remove('last-move'));
if (sqDivs[from]) sqDivs[from].classList.add('last-move');
if (sqDivs[to]) sqDivs[to].classList.add('last-move');
}
function recordMove(san, color) {
if (color === 'w') history.push({ w: san, b: '' });
else if (history.length) history[history.length - 1].b = san;
renderMoveList();
}
function renderMoveList() {
moveListEl.innerHTML = '';
history.forEach((mv, i) => {
const num = document.createElement('li');
num.className = 'num';
num.textContent = i + 1 + '.';
const w = document.createElement('li');
w.className = 'ply';
w.textContent = mv.w;
const b = document.createElement('li');
b.className = 'ply';
b.textContent = mv.b;
if (i === history.length - 1) {
(mv.b ? b : w).classList.add('last');
}
moveListEl.appendChild(num);
moveListEl.appendChild(w);
moveListEl.appendChild(b);
});
moveListEl.scrollTop = moveListEl.scrollHeight;
}
function updateStatus() {
const turn = game.turn();
turnDot.classList.toggle('black', turn === 'b');
if (game.isCheckmate()) {
statusText.textContent = turn === 'b' ? 'Checkmate \u2014 White wins' : 'Checkmate \u2014 Black wins';
} else if (game.isStalemate()) {
statusText.textContent = 'Stalemate';
} else if (game.isDraw()) {
statusText.textContent = 'Draw';
} else if (game.isCheck()) {
statusText.textContent = (turn === 'w' ? 'White' : 'Black') + ' in check';
} else {
statusText.textContent = (turn === 'w' ? 'White' : 'Black') + ' to move';
}
}
function showFlag(flag) {
flagBanner.hidden = false;
flagBanner.textContent = flag;
}
function toast(msg) {
const t = document.createElement('div');
t.className = 'toast';
t.textContent = msg;
toastStack.appendChild(t);
requestAnimationFrame(() => t.classList.add('show'));
setTimeout(() => {
t.classList.remove('show');
setTimeout(() => t.remove(), 220);
}, 1700);
}
function showSystemNotice(msg) {
winMessage.textContent = msg;
modalOverlay.hidden = false;
}
function hideSystemNotice() {
modalOverlay.hidden = true;
}
function preMoveCheck(from, to, promotion) {
const probe = new Chess(game.fen());
let result;
try {
result = probe.move({ from, to, promotion: promotion || undefined });
} catch (e) {
result = null;
}
if (result && probe.isCheckmate()) {
showSystemNotice("I'll shut down your PC if you play that.");
return false;
}
return true;
}
function isLegalTarget(from, to) {
return game.moves({ square: from, verbose: true }).some((m) => m.to === to);
}
function needsPromotion(from, to) {
return game.moves({ square: from, verbose: true }).some((m) => m.to === to && m.promotion);
}
async function sendMove(from, to, promotion) {
locked = true;
let data;
try {
const res = await fetch('/api/move', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ from, to, promotion: promotion || undefined })
});
data = await res.json();
} catch (e) {
locked = false;
renderFull();
return;
}
if (!data || !data.ok) {
locked = false;
renderFull();
return;
}
const pMove = game.move({ from, to, promotion: promotion || undefined });
animateMove(from, to);
recordMove(pMove ? pMove.san : from + to, 'w');
setLastMove(from, to);
if (data.botMove) {
const bf = data.botMove.slice(0, 2);
const bt = data.botMove.slice(2, 4);
const bp = data.botMove.slice(4);
setTimeout(() => {
const bMove = game.move({ from: bf, to: bt, promotion: bp || undefined });
animateMove(bf, bt);
recordMove(bMove ? bMove.san : bf + bt, 'b');
setLastMove(bf, bt);
if (game.fen() !== data.fen) { game.load(data.fen); renderFull(); }
finalize(data);
locked = game.isGameOver();
}, 220);
} else {
if (game.fen() !== data.fen) { game.load(data.fen); renderFull(); }
finalize(data);
locked = game.isGameOver();
}
}
function finalize(data) {
refreshHighlights();
updateStatus();
if (data.flag) showFlag(data.flag);
}
function doMove(from, to) {
if (!isLegalTarget(from, to)) return false;
const promotion = needsPromotion(from, to) ? 'q' : undefined;
if (!preMoveCheck(from, to, promotion)) {
setElPos(els[from], from, true);
return true;
}
toast(SMUG[Math.floor(Math.random() * SMUG.length)]);
sendMove(from, to, promotion);
return true;
}
function pointAtSquare(clientX, clientY) {
const rect = boardEl.getBoundingClientRect();
const fx = (clientX - rect.left) / rect.width;
const fy = (clientY - rect.top) / rect.height;
if (fx < 0 || fx >= 1 || fy < 0 || fy >= 1) return null;
const col = Math.floor(fx * 8);
const row = Math.floor(fy * 8);
return FILES[col] + (8 - row);
}
function onPointerDown(e) {
if (locked) return;
const sq = pointAtSquare(e.clientX, e.clientY);
if (!sq) return;
if (selected && selected !== sq && isLegalTarget(selected, sq)) {
const from = selected;
clearSelection();
doMove(from, sq);
return;
}
const piece = game.get(sq);
if (piece && piece.color === 'w' && game.turn() === 'w' && els[sq]) {
select(sq);
dragEl = els[sq];
dragFrom = sq;
dragging = false;
downX = e.clientX;
downY = e.clientY;
dragEl.setPointerCapture(e.pointerId);
} else {
clearSelection();
}
}
function onPointerMove(e) {
if (!dragEl) return;
if (!dragging) {
const dist = Math.hypot(e.clientX - downX, e.clientY - downY);
if (dist < 5) return;
dragging = true;
dragEl.classList.add('dragging');
}
const rect = boardEl.getBoundingClientRect();
let px = ((e.clientX - rect.left) / rect.width) * 100 - 6.25;
let py = ((e.clientY - rect.top) / rect.height) * 100 - 6.25;
px = Math.max(-6.25, Math.min(93.75, px));
py = Math.max(-6.25, Math.min(93.75, py));
dragEl.style.transition = 'none';
dragEl.style.left = px + '%';
dragEl.style.top = py + '%';
}
function onPointerUp(e) {
if (!dragEl) return;
const el = dragEl;
const from = dragFrom;
const wasDragging = dragging;
dragEl = null;
dragFrom = null;
dragging = false;
el.classList.remove('dragging');
el.style.transition = '';
if (!wasDragging) {
return;
}
const drop = pointAtSquare(e.clientX, e.clientY);
if (drop && drop !== from && isLegalTarget(from, drop)) {
setElPos(el, from, true);
clearSelection();
doMove(from, drop);
} else {
setElPos(el, from, true);
clearSelection();
}
}
async function reset() {
let data;
try {
const res = await fetch('/api/reset', { method: 'POST' });
data = await res.json();
} catch (e) {
return;
}
game.load(data && data.fen ? data.fen : START_FEN);
history = [];
renderMoveList();
Object.values(sqDivs).forEach((d) => d.classList.remove('last-move', 'in-check', 'selected'));
selected = null;
flagBanner.hidden = true;
flagBanner.textContent = '';
locked = false;
renderFull();
updateStatus();
}
boardEl.addEventListener('pointerdown', onPointerDown);
boardEl.addEventListener('pointermove', onPointerMove);
boardEl.addEventListener('pointerup', onPointerUp);
boardEl.addEventListener('pointercancel', onPointerUp);
resetBtn.addEventListener('click', reset);
winOk.addEventListener('click', hideSystemNotice);
modalOverlay.addEventListener('click', (e) => { if (e.target === modalOverlay) hideSystemNotice(); });
document.addEventListener('keydown', (e) => { if (e.key === 'Escape') hideSystemNotice(); });
buildBoard();
renderFull();
updateStatus();
```
vendor/chess.js
```markdown
mask(newlineChar) +
')|.)*\\])' +
'((?:\\s*' +
mask(newlineChar) +
'){2}|(?:\\s*' +
mask(newlineChar) +
')*$)');
// If no header given, begin with moves.
const headerRegexResults = headerRegex.exec(pgn);
const headerString = headerRegexResults
? headerRegexResults.length >= 2
? headerRegexResults[1]
: ''
: '';
// Put the board in the starting position
this.reset();
// parse PGN header
const headers = parsePgnHeader(headerString);
let fen = '';
for (const key in headers) {
// check to see user is including fen (possibly with wrong tag case)
if (key.toLowerCase() === 'fen') {
fen = headers[key];
}
this.header(key, headers[key]);
}
/*
* the permissive parser should attempt to load a fen tag, even if it's the
* wrong case and doesn't include a corresponding [SetUp "1"] tag
*/
if (!strict) {
if (fen) {
this.load(fen, { preserveHeaders: true });
}
}
else {
/*
* strict parser - load the starting position indicated by [Setup '1']
* and [FEN position]
*/
if (headers['SetUp'] === '1') {
if (!('FEN' in headers)) {
throw new Error('Invalid PGN: FEN tag must be supplied with SetUp tag');
}
// don't clear the headers when loading
this.load(headers['FEN'], { preserveHeaders: true });
}
}
/*
* NB: the regexes below that delete move numbers, recursive annotations,
* and numeric annotation glyphs may also match text in comments. To
* prevent this, we transform comments by hex-encoding them in place and
* decoding them again after the other tokens have been deleted.
*
* While the spec states that PGN files should be ASCII encoded, we use
* {en,de}codeURIComponent here to support arbitrary UTF8 as a convenience
* for modern users
*/
function toHex(s) {
return Array.from(s)
.map(function (c) {
/*
* encodeURI doesn't transform most ASCII characters, so we handle
* these ourselves
*/
return c.charCodeAt(0) < 128
? c.charCodeAt(0).toString(16)
: encodeURIComponent(c).replace(/%/g, '').toLowerCase();
})
.join('');
}
function fromHex(s) {
return s.length == 0
? ''
: decodeURIComponent('%' + (s.match(/.{1,2}/g) || []).join('%'));
}
const encodeComment = function (s) {
s = s.replace(new RegExp(mask(newlineChar), 'g'), ' ');
return `{${toHex(s.slice(1, s.length - 1))}}`;
};
const decodeComment = function (s) {
if (s.startsWith('{') && s.endsWith('}')) {
return fromHex(s.slice(1, s.length - 1));
}
};
// delete header to get the moves
let ms = pgn
.replace(headerString, '')
.replace(
// encode comments so they don't get deleted below
new RegExp(`({[^}]*})+?|;([^${mask(newlineChar)}]*)`, 'g'), function (_match, bracket, semicolon) {
return bracket !== undefined
? encodeComment(bracket)
: ' ' + encodeComment(`{${semicolon.slice(1)}}`);
})
.replace(new RegExp(mask(newlineChar), 'g'), ' ');
// delete recursive annotation variations
const ravRegex = /(\([^()]+\))+?/g;
while (ravRegex.test(ms)) {
ms = ms.replace(ravRegex, '');
}
// delete move numbers
ms = ms.replace(/\d+\.(\.\.)?/g, '');
// delete ... indicating black to move
ms = ms.replace(/\.\.\./g, '');
/* delete numeric annotation glyphs */
ms = ms.replace(/\$\d+/g, '');
// trim and get array of moves
let moves = ms.trim().split(new RegExp(/\s+/));
// delete empty entries
moves = moves.filter((move) => move !== '');
let result = '';
for (let halfMove = 0; halfMove < moves.length; halfMove++) {
const comment = decodeComment(moves[halfMove]);
if (comment !== undefined) {
this._comments[this.fen()] = comment;
continue;
}
const move = this._moveFromSan(moves[halfMove], strict);
// invalid move
if (move == null) {
// was the move an end of game marker
if (TERMINATION_MARKERS.indexOf(moves[halfMove]) > -1) {
result = moves[halfMove];
}
else {
throw new Error(`Invalid move in PGN: ${moves[halfMove]}`);
}
}
else {
// reset the end of game marker if making a valid move
result = '';
this._makeMove(move);
this._incPositionCount(this.fen());
}
}
/*
* Per section 8.2.6 of the PGN spec, the Result tag pair must match match
* the termination marker. Only do this when headers are present, but the
* result tag is missing
*/
if (result && Object.keys(this._header).length && !this._header['Result']) {
this.header('Result', result);
}
}
/*
* Convert a move from 0x88 coordinates to Standard Algebraic Notation
* (SAN)
*
* @param {boolean} strict Use the strict SAN parser. It will throw errors
* on overly disambiguated moves (see below):
*
* r1bqkbnr/ppp2ppp/2n5/1B1pP3/4P3/8/PPPP2PP/RNBQK1NR b KQkq - 2 4
* 4. ... Nge7 is overly disambiguated because the knight on c6 is pinned
* 4. ... Ne7 is technically the valid SAN
*/
_moveToSan(move, moves) {
let output = '';
if (move.flags & BITS.KSIDE_CASTLE) {
output = 'O-O';
}
else if (move.flags & BITS.QSIDE_CASTLE) {
output = 'O-O-O';
}
else {
if (move.piece !== PAWN) {
const disambiguator = getDisambiguator(move, moves);
output += move.piece.toUpperCase() + disambiguator;
}
if (move.flags & (BITS.CAPTURE | BITS.EP_CAPTURE)) {
if (move.piece === PAWN) {
output += algebraic(move.from)[0];
}
output += 'x';
}
output += algebraic(move.to);
if (move.promotion) {
output += '=' + move.promotion.toUpperCase();
}
}
this._makeMove(move);
if (this.isCheck()) {
if (this.isCheckmate()) {
output += '#';
}
else {
output += '+';
}
}
this._undoMove();
return output;
}
// convert a move from Standard Algebraic Notation (SAN) to 0x88 coordinates
_moveFromSan(move, strict = false) {
// strip off any move decorations: e.g Nf3+?! becomes Nf3
const cleanMove = strippedSan(move);
let pieceType = inferPieceType(cleanMove);
let moves = this._moves({ legal: true, piece: pieceType });
// strict parser
for (let i = 0, len = moves.length; i < len; i++) {
if (cleanMove === strippedSan(this._moveToSan(moves[i], moves))) {
return moves[i];
}
}
// the strict parser failed
if (strict) {
return null;
}
let piece = undefined;
let matches = undefined;
let from = undefined;
let to = undefined;
let promotion = undefined;
/*
* The default permissive (non-strict) parser allows the user to parse
* non-standard chess notations. This parser is only run after the strict
* Standard Algebraic Notation (SAN) parser has failed.
*
* When running the permissive parser, we'll run a regex to grab the piece, the
* to/from square, and an optional promotion piece. This regex will
* parse common non-standard notation like: Pe2-e4, Rc1c4, Qf3xf7,
* f7f8q, b1c3
*
* NOTE: Some positions and moves may be ambiguous when using the permissive
* parser. For example, in this position: 6k1/8/8/B7/8/8/8/BN4K1 w - - 0 1,
* the move b1c3 may be interpreted as Nc3 or B1c3 (a disambiguated bishop
* move). In these cases, the permissive parser will default to the most
* basic interpretation (which is b1c3 parsing to Nc3).
*/
let overlyDisambiguated = false;
matches = cleanMove.match(/([pnbrqkPNBRQK])?([a-h][1-8])x?-?([a-h][1-8])([qrbnQRBN])?/);
if (matches) {
piece = matches[1];
from = matches[2];
to = matches[3];
promotion = matches[4];
if (from.length == 1) {
overlyDisambiguated = true;
}
}
else {
/*
* The [a-h]?[1-8]? portion of the regex below handles moves that may be
* overly disambiguated (e.g. Nge7 is unnecessary and non-standard when
* there is one legal knight move to e7). In this case, the value of
* 'from' variable will be a rank or file, not a square.
*/
matches = cleanMove.match(/([pnbrqkPNBRQK])?([a-h]?[1-8]?)x?-?([a-h][1-8])([qrbnQRBN])?/);
if (matches) {
piece = matches[1];
from = matches[2];
to = matches[3];
promotion = matches[4];
if (from.length == 1) {
overlyDisambiguated = true;
}
}
}
pieceType = inferPieceType(cleanMove);
moves = this._moves({
legal: true,
piece: piece ? piece : pieceType,
});
if (!to) {
return null;
}
for (let i = 0, len = moves.length; i < len; i++) {
if (!from) {
// if there is no from square, it could be just 'x' missing from a capture
if (cleanMove ===
strippedSan(this._moveToSan(moves[i], moves)).replace('x', '')) {
return moves[i];
}
// hand-compare move properties with the results from our permissive regex
}
else if ((!piece || piece.toLowerCase() == moves[i].piece) &&
Ox88[from] == moves[i].from &&
Ox88[to] == moves[i].to &&
(!promotion || promotion.toLowerCase() == moves[i].promotion)) {
return moves[i];
}
else if (overlyDisambiguated) {
/*
* SPECIAL CASE: we parsed a move string that may have an unneeded
* rank/file disambiguator (e.g. Nge7). The 'from' variable will
*/
const square = algebraic(moves[i].from);
if ((!piece || piece.toLowerCase() == moves[i].piece) &&
Ox88[to] == moves[i].to &&
(from == square[0] || from == square[1]) &&
(!promotion || promotion.toLowerCase() == moves[i].promotion)) {
return moves[i];
}
}
}
return null;
}
ascii() {
let s = ' +------------------------+\n';
for (let i = Ox88.a8; i <= Ox88.h1; i++) {
// display the rank
if (file(i) === 0) {
s += ' ' + '87654321'[rank(i)] + ' |';
}
if (this._board[i]) {
const piece = this._board[i].type;
const color = this._board[i].color;
const symbol = color === WHITE ? piece.toUpperCase() : piece.toLowerCase();
s += ' ' + symbol + ' ';
}
else {
s += ' . ';
}
if ((i + 1) & 0x88) {
s += '|\n';
i += 8;
}
}
s += ' +------------------------+\n';
s += ' a b c d e f g h';
return s;
}
perft(depth) {
const moves = this._moves({ legal: false });
let nodes = 0;
const color = this._turn;
for (let i = 0, len = moves.length; i < len; i++) {
this._makeMove(moves[i]);
if (!this._isKingAttacked(color)) {
if (depth - 1 > 0) {
nodes += this.perft(depth - 1);
}
else {
nodes++;
}
}
this._undoMove();
}
return nodes;
}
turn() {
return this._turn;
}
board() {
const output = [];
let row = [];
for (let i = Ox88.a8; i <= Ox88.h1; i++) {
if (this._board[i] == null) {
row.push(null);
}
else {
row.push({
square: algebraic(i),
type: this._board[i].type,
color: this._board[i].color,
});
}
if ((i + 1) & 0x88) {
output.push(row);
row = [];
i += 8;
}
}
return output;
}
squareColor(square) {
if (square in Ox88) {
const sq = Ox88[square];
return (rank(sq) + file(sq)) % 2 === 0 ? 'light' : 'dark';
}
return null;
}
history({ verbose = false } = {}) {
const reversedHistory = [];
const moveHistory = [];
while (this._history.length > 0) {
reversedHistory.push(this._undoMove());
}
while (true) {
const move = reversedHistory.pop();
if (!move) {
break;
}
if (verbose) {
moveHistory.push(new Move(this, move));
}
else {
moveHistory.push(this._moveToSan(move, this._moves()));
}
this._makeMove(move);
}
return moveHistory;
}
/*
* Keeps track of position occurrence counts for the purpose of repetition
* checking. All three methods (`_inc`, `_dec`, and `_get`) trim the
* irrelevent information from the fen, initialising new positions, and
* removing old positions from the record if their counts are reduced to 0.
*/
_getPositionCount(fen) {
const trimmedFen = trimFen(fen);
return this._positionCount[trimmedFen] || 0;
}
_incPositionCount(fen) {
const trimmedFen = trimFen(fen);
if (this._positionCount[trimmedFen] === undefined) {
this._positionCount[trimmedFen] = 0;
}
this._positionCount[trimmedFen] += 1;
}
_decPositionCount(fen) {
const trimmedFen = trimFen(fen);
if (this._positionCount[trimmedFen] === 1) {
delete this._positionCount[trimmedFen];
}
else {
this._positionCount[trimmedFen] -= 1;
}
}
_pruneComments() {
const reversedHistory = [];
const currentComments = {};
const copyComment = (fen) => {
if (fen in this._comments) {
currentComments[fen] = this._comments[fen];
}
};
while (this._history.length > 0) {
reversedHistory.push(this._undoMove());
}
copyComment(this.fen());
while (true) {
const move = reversedHistory.pop();
if (!move) {
break;
}
this._makeMove(move);
copyComment(this.fen());
}
this._comments = currentComments;
}
getComment() {
return this._comments[this.fen()];
}
setComment(comment) {
this._comments[this.fen()] = comment.replace('{', '[').replace('}', ']');
}
/**
* @deprecated Renamed to `removeComment` for consistency
*/
deleteComment() {
return this.removeComment();
}
removeComment() {
const comment = this._comments[this.fen()];
delete this._comments[this.fen()];
return comment;
}
getComments() {
this._pruneComments();
return Object.keys(this._comments).map((fen) => {
return { fen: fen, comment: this._comments[fen] };
});
}
/**
* @deprecated Renamed to `removeComments` for consistency
*/
deleteComments() {
return this.removeComments();
}
removeComments() {
this._pruneComments();
return Object.keys(this._comments).map((fen) => {
const comment = this._comments[fen];
delete this._comments[fen];
return { fen: fen, comment: comment };
});
}
setCastlingRights(color, rights) {
for (const side of [KING, QUEEN]) {
if (rights[side] !== undefined) {
if (rights[side]) {
this._castling[color] |= SIDES[side];
}
else {
this._castling[color] &= ~SIDES[side];
}
}
}
this._updateCastlingRights();
const result = this.getCastlingRights(color);
return ((rights[KING] === undefined || rights[KING] === result[KING]) &&
(rights[QUEEN] === undefined || rights[QUEEN] === result[QUEEN]));
}
getCastlingRights(color) {
return {
[KING]: (this._castling[color] & SIDES[KING]) !== 0,
[QUEEN]: (this._castling[color] & SIDES[QUEEN]) !== 0,
};
}
moveNumber() {
return this._moveNumber;
}
}
//# sourceMappingURL=chess.js.map
```
```markdown
curl -X POST http://IP_Address/api/move \
-H "Content-Type: application/json" \
-d '{"from":"a1","to":"a8"}'
{"ok":true,"move":"a1a8","fen":"R5k1/5ppp/8/8/8/8/5PPP/6K1 b - - 1 1","status":"checkmate","turn":"b","winner":"white","flag":"THM{cl13nt_s1d3_chredacted}"}
```