xchess/lib/end-state.js

Chess Engine

export {
	CheckmateState,
	ResignationState,
	ForfeitState,
	WinOnTimeState,
	StalemateState,
	DeadPositionState,
	ThreefoldRepetitionState,
	FivefoldRepetitionState,
	FiftyMovesState,
	SeventyFiveMovesState,
	DrawByAgreementState,
	DrawByResignationState,
	DrawOnTimeState,
}

import {EmptyMoveMap} from './move-map.js'
import {ProxyState, Immediate} from './proxy-state.js'
import {Color} from './color.js'
import {GAME_OVER} from './errors.js'

class EndState extends ProxyState {

	// Config

	get moves(){
		return EmptyMoveMap;
	}

	// Stat

	get isEnd(){
		return true;
	}

	get isDrawOffer(){
		return false;
	}

	// Game Events

	play(){
		throw GAME_OVER();
	}

	forfeit(color){
		throw GAME_OVER();
	}

	resign(color){
		throw GAME_OVER();
	}

	draw(color){
		throw GAME_OVER();
	}

	toDraw(color){
		throw GAME_OVER();
	}

	flagFall(){
		throw GAME_OVER();
	}

	move(move){
		throw GAME_OVER();
	}

	promote(piece){
		throw GAME_OVER();
	}
}

class WinState extends EndState {

	#winner;

	constructor(target, prev, loser){
		super(target, prev);
		this.#winner = Color.invert(loser);
	}

	get winner(){
		return this.#winner;
	}

	get loser(){
		return this.winner.invert();
	}

	get isWin(){
		return true;
	}

	get result(){
		switch(this.winner){
			case Color.white: return '1-0';
			case Color.black: return '0-1';
		}	return '?/?';
	}

	trigger(){
		this.emit(this.status);
		this.emit('win');
		this.emit('end');
	}
}

class DrawState extends EndState {

	get isDraw(){
		return true;
	}

	get result(){
		return '1/2-1/2'
	}

	trigger(){
		this.emit(this.status);
		this.emit('draw');
		this.emit('end');
	}
}

class ForcedDrawState extends DrawState {

	#subject;

	constructor(target, prev, subject){
		super(target, prev);
		this.#subject = Color.from(subject);
	}

	get subject(){
		return this.#subject;
	}
}

// Win

class CheckmateState extends Immediate(WinState) {

	get status(){
		return 'checkmate';
	}

	get isCheckmate(){
		return true;
	}
}

class ResignationState extends WinState {

	get status(){
		return 'resignation';
	}

	trigger(){
		this.emit('resign');
		this.emit('win');
		this.emit('end');
	}
}

class ForfeitState extends WinState {

	get status(){
		return 'forfeit';
	}
}

class WinOnTimeState extends WinState {

	get status(){
		return 'win-on-time';
	}

	trigger(){
		this.emit('flag-fall');
		this.emit('win');
		this.emit('end');
	}
}

// Draw

class StalemateState extends Immediate(DrawState) {

	get status(){
		return 'stalemate';
	}

	get isStalemate(){
		return true;
	}
}

class DeadPositionState extends Immediate(DrawState) {

	get status(){
		return 'dead-position';
	}

	get isDraw(){
		return true;
	}
}

class ThreefoldRepetitionState extends ForcedDrawState {

	get status(){
		return '3-repetition';
	}
}

class FivefoldRepetitionState extends Immediate(DrawState) {

	get status(){
		return '5-repetition';
	}
}

class FiftyMovesState extends ForcedDrawState {

	get status(){
		return '50-moves';
	}
}

class SeventyFiveMovesState extends Immediate(DrawState) {

	get status(){
		return '75-moves';
	}
}

class DrawByAgreementState extends ForcedDrawState {

	get status(){
		return 'draw-by-agreement';
	}
}

class DrawByResignationState extends ForcedDrawState {

	get status(){
		return 'draw-by-resignation';
	}

	trigger(){
		this.emit('resign');
		this.emit('draw');
		this.emit('end');
	}
}

class DrawOnTimeState extends DrawState {

	get status(){
		return 'draw-on-time';
	}

	trigger(){
		this.emit('flag-fall');
		this.emit('draw');
		this.emit('end');
	}
}