Momentum-Apps/chess/smallchesslib.h

#ifndef SMALLCHESSLIB_H
#define SMALLCHESSLIB_H

/**
  @file smallchesslib.h

  Small and simple single header C99 public domain chess library and engine.

  author: Miloslav Ciz (drummyfish)
  license: CC0 1.0 (public domain)
           found at https://creativecommons.org/publicdomain/zero/1.0/
           + additional waiver of all IP
  version: 0.8d

  Default notation format for this library is a coordinate one, i.e.
  
    squarefrom squareto [promotedpiece]

  e.g.: e2e4 or A2A1q

  This work's goal is to never be encumbered by any exclusive intellectual
  property rights. The work is therefore provided under CC0 1.0 + additional
  WAIVER OF ALL INTELLECTUAL PROPERTY RIGHTS that waives the rest of
  intellectual property rights not already waived by CC0 1.0. The WAIVER OF ALL
  INTELLECTUAL PROPERTY RGHTS is as follows:

  Each contributor to this work agrees that they waive any exclusive rights,
  including but not limited to copyright, patents, trademark, trade dress,
  industrial design, plant varieties and trade secrets, to any and all ideas,
  concepts, processes, discoveries, improvements and inventions conceived,
  discovered, made, designed, researched or developed by the contributor either
  solely or jointly with others, which relate to this work or result from this
  work. Should any waiver of such right be judged legally invalid or
  ineffective under applicable law, the contributor hereby grants to each
  affected person a royalty-free, non transferable, non sublicensable, non
  exclusive, irrevocable and unconditional license to this right.
*/

#include <stdint.h>

#ifndef SCL_DEBUG_AI
/** AI will print out a Newick-like tree of searched moves. */
#define SCL_DEBUG_AI 0
#endif

/**
  Maximum number of moves a chess piece can have (a queen in the middle of the
  board).
*/
#define SCL_CHESS_PIECE_MAX_MOVES 25
#define SCL_BOARD_SQUARES         64

typedef uint8_t (*SCL_RandomFunction)(void);

#if defined(SCL_COUNT_EVALUATED_POSITIONS) && SCL_COUNT_EVALUATED_POSITIONS
uint32_t SCL_positionsEvaluated = 0; /**< If enabled by 
                                            SCL_COUNT_EVALUATED_POSITIONS, this
                                            will increment with every
                                            dynamically evaluated position (e.g.
                                            when AI computes its move). */
#endif

#ifndef SCL_CALL_WDT_RESET
#define SCL_CALL_WDT_RESET \
    0 /**< Option that should be enabled on some
                                    Arduinos. If 1, call to watchdog timer
                                    reset will be performed during dynamic
                                    evaluation (without it if AI takes long the
                                    program will reset). */
#endif

/**
  Returns a pseudorandom byte. This function has a period 256 and returns each
  possible byte value exactly once in the period.
*/
uint8_t SCL_randomSimple(void);
void SCL_randomSimpleSeed(uint8_t seed);

/**
  Like SCL_randomSimple, but internally uses a 16 bit value, so the period is
  65536.
*/
uint8_t SCL_randomBetter(void);
void SCL_randomBetterSeed(uint16_t seed);

#ifndef SCL_EVALUATION_FUNCTION
/**
    If defined, AI will always use the static evaluation function with this
    name. This helps avoid pointers to functions and can be faster but the
    function can't be changed at runtime.
  */
#define SCL_EVALUATION_FUNCTION
#undef SCL_EVALUATION_FUNCTION
#endif

#ifndef SCL_960_CASTLING
/**
    If set, chess 960 (Fisher random) castling will be considered by the library
    rather than normal castling. 960 castling is slightly different (e.g.
    requires the inital rook positions to be stored in board state). The
    castling move is performed as "capturing own rook".
  */
#define SCL_960_CASTLING 0
#endif

#ifndef SCL_ALPHA_BETA
/**
    Turns alpha-beta pruning (AI optimization) on or off. This can gain
    performance and should normally be turned on. AI behavior should not
    change at all.
  */
#define SCL_ALPHA_BETA 1
#endif

/**
  A set of game squares as a bit array, each bit representing one game square.
  Useful for representing e.g. possible moves. To easily iterate over the set
  use provided macros (SCL_SQUARE_SET_ITERATE, ...).
*/
typedef uint8_t SCL_SquareSet[8];

#define SCL_SQUARE_SET_EMPTY {0, 0, 0, 0, 0, 0, 0, 0}

void SCL_squareSetClear(SCL_SquareSet squareSet);
void SCL_squareSetAdd(SCL_SquareSet squareSet, uint8_t square);
uint8_t SCL_squareSetContains(const SCL_SquareSet squareSet, uint8_t square);
uint8_t SCL_squareSetSize(const SCL_SquareSet squareSet);
uint8_t SCL_squareSetEmpty(const SCL_SquareSet squareSet);

/**
  Returns a random square from a square set.
*/
uint8_t SCL_squareSetGetRandom(const SCL_SquareSet squareSet, SCL_RandomFunction randFunc);

#define SCL_SQUARE_SET_ITERATE_BEGIN(squareSet)                  \
    {                                                            \
        uint8_t iteratedSquare = 0;                              \
        uint8_t iterationEnd = 0;                                \
        for(int8_t _i = 0; _i < 8 && !iterationEnd; ++_i) {      \
            uint8_t _row = squareSet[_i];                        \
            if(_row == 0) {                                      \
                iteratedSquare += 8;                             \
                continue;                                        \
            }                                                    \
                                                                 \
            for(uint8_t _j = 0; _j < 8 && !iterationEnd; ++_j) { \
                if(_row & 0x01) {
/*
  Between SCL_SQUARE_SET_ITERATE_BEGIN and _END iteratedSquare variable
  represents the next square contained in the set. To break out of the
  iteration set iterationEnd to 1.
*/

#define SCL_SQUARE_SET_ITERATE_END \
    }                              \
    _row >>= 1;                    \
    iteratedSquare++;              \
    }                              \
    } /*for*/                      \
    }

#define SCL_SQUARE_SET_ITERATE(squareSet, command) \
    SCL_SQUARE_SET_ITERATE_BEGIN(squareSet){command} SCL_SQUARE_SET_ITERATE_END

#define SCL_BOARD_STATE_SIZE 69

/**
  Represents chess board state as a string in this format:
  - First 64 characters represent the chess board (A1, B1, ... H8), each field
    can be either a piece (PRNBKQprnbkq) or empty ('.'). I.e. the state looks
    like this:

      0 (A1) RNBQKBNR 
             PPPPPPPP
             ........
             ........
             ........
             ........
             pppppppp
             rnbqkbnr 63 (H8)

  - After this more bytes follow to represent global state, these are:
    - 64: bits holding en-passant and castling related information:
      - bits 0-3 (lsb): Column of the pawn that can, in current turn, be
        taken by en-passant (0xF means no pawn can be taken this way).
      - bit 4: Whether white is not prevented from short castling by previous
        king or rook movement.
      - bit 5: Same as 4, but for long castling.
      - bit 6: Same as 4, but for black.
      - bit 7: Same as 4, but for black and long castling.
    - 65: Number saying the number of ply (half-moves) that have already been
      played, also determining whose turn it currently is.
    - 66: Move counter used in the 50 move rule, says the number of ply since
      the last pawn move or capture.
    - 67: Extra byte, left for storing additional info in variants. For normal
      chess this byte should always be 0.
    - 68: The last byte is always 0 to properly terminate the string in case
      someone tries to print it.
  - The state is designed so as to be simple and also print-friendly, i.e. you
    can simply print it with line break after 8 characters to get a human
    readable representation of the board.

  NOTE: there is a much more compact representation which however trades some
  access speed which would affect the AI performance and isn't print friendly,
  so we don't use it. In it each square takes 4 bits, using 15 out of 16
  possible values (empty square and W and B pieces including 2 types of pawns,
  one "en-passant takeable"). Then only one extra byte needed is for castling
  info (4 bits) and ply count (4 bits).
*/
typedef char SCL_Board[SCL_BOARD_STATE_SIZE];

#define SCL_BOARD_ENPASSANT_CASTLE_BYTE 64
#define SCL_BOARD_PLY_BYTE              65
#define SCL_BOARD_MOVE_COUNT_BYTE       66
#define SCL_BOARD_EXTRA_BYTE            67

#if SCL_960_CASTLING
#define _SCL_EXTRA_BYTE_VALUE (0 | (7 << 3)) // rooks on classic positions
#else
#define _SCL_EXTRA_BYTE_VALUE 0
#endif

#define SCL_BOARD_START_STATE                     \
    {82,         78,  66,  81,                    \
     75,         66,  78,  82,                    \
     80,         80,  80,  80,                    \
     80,         80,  80,  80,                    \
     46,         46,  46,  46,                    \
     46,         46,  46,  46,                    \
     46,         46,  46,  46,                    \
     46,         46,  46,  46,                    \
     46,         46,  46,  46,                    \
     46,         46,  46,  46,                    \
     46,         46,  46,  46,                    \
     46,         46,  46,  46,                    \
     112,        112, 112, 112,                   \
     112,        112, 112, 112,                   \
     114,        110, 98,  113,                   \
     107,        98,  110, 114,                   \
     (char)0xff, 0,   0,   _SCL_EXTRA_BYTE_VALUE, \
     0}

#define SCL_FEN_START "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

#define SCL_FEN_HORDE "ppp2ppp/pppppppp/pppppppp/pppppppp/3pp3/8/PPPPPPPP/RNBQKBNR w KQ - 0 1"

#define SCL_FEN_UPSIDE_DOWN "RNBKQBNR/PPPPPPPP/8/8/8/8/pppppppp/rnbkqbnr w - - 0 1"

#define SCL_FEN_PEASANT_REVOLT "1nn1k1n1/4p3/8/8/8/8/PPPPPPPP/4K3 w - - 0 1"

#define SCL_FEN_ENDGAME "4k3/pppppppp/8/8/8/8/PPPPPPPP/4K3 w - - 0 1"

#define SCL_FEN_KNIGHTS "N6n/1N4n1/2N2n2/3Nn3/k2nN2K/2n2N2/1n4N1/n6N w - - 0 1"

/**
  Holds an info required to undo a single move.
*/
typedef struct {
    uint8_t squareFrom; ///< start square
    uint8_t squareTo; ///< target square
    char enPassantCastle; ///< previous en passant/castle byte
    char moveCount; ///< previous values of the move counter byte
    uint8_t other; /**< lowest 7 bits: previous value of target square,
                                highest bit: if 1 then the move was promotion or
                                en passant */
} SCL_MoveUndo;

#define SCL_GAME_STATE_PLAYING         0x00
#define SCL_GAME_STATE_WHITE_WIN       0x01
#define SCL_GAME_STATE_BLACK_WIN       0x02
#define SCL_GAME_STATE_DRAW            0x10 ///< further unspecified draw
#define SCL_GAME_STATE_DRAW_STALEMATE  0x11 ///< draw by stalemate
#define SCL_GAME_STATE_DRAW_REPETITION 0x12 ///< draw by repetition
#define SCL_GAME_STATE_DRAW_50         0x13 ///< draw by 50 move rule
#define SCL_GAME_STATE_DRAW_DEAD       0x14 ///< draw by dead position
#define SCL_GAME_STATE_END             0xff ///< end without known result

/**
  Converts square in common notation (e.g. 'c' 8) to square number. Only accepts
  lowercase column.
*/
#define SCL_SQUARE(colChar, rowInt) (((rowInt) - 1) * 8 + ((colChar) - 'a'))
#define SCL_S(c, r)                 SCL_SQUARE(c, r)

void SCL_boardInit(SCL_Board board);
void SCL_boardCopy(const SCL_Board boardFrom, SCL_Board boardTo);

/**
  Initializes given chess 960 (Fisher random) position. If SCL_960_CASTLING
  is not set, castling will be disabled by this function.
*/
void SCL_boardInit960(SCL_Board board, uint16_t positionNumber);

void SCL_boardDisableCastling(SCL_Board board);

uint32_t SCL_boardHash32(const SCL_Board board);

#define SCL_PHASE_OPENING 0
#define SCL_PHASE_MIDGAME 1
#define SCL_PHASE_ENDGAME 2

/**
  Estimates the game phase: opening, midgame or endgame.
*/
uint8_t SCL_boardEstimatePhase(SCL_Board board);

/**
  Sets the board position. The input string should be 64 characters long zero
  terminated C string representing the board as squares A1, A2, ..., H8 with
  each char being either a piece (RKBKQPrkbkqp) or an empty square ('.').
*/
void SCL_boardSetPosition(
    SCL_Board board,
    const char* pieces,
    uint8_t castlingEnPassant,
    uint8_t moveCount,
    uint8_t ply);

uint8_t SCL_boardsDiffer(SCL_Board b1, SCL_Board b2);

/**
  Gets a random move on given board for the player whose move it is.
*/
void SCL_boardRandomMove(
    SCL_Board board,
    SCL_RandomFunction randFunc,
    uint8_t* squareFrom,
    uint8_t* squareTo,
    char* resultProm);

#define SCL_FEN_MAX_LENGTH 90

/**
  Converts a position to FEN (Forsyth–Edwards Notation) string. The string has
  to have at least SCL_FEN_MAX_LENGTH bytes allocated to guarantee the
  function won't write to unallocated memory. The string will be terminated by
  0 (this is included in SCL_FEN_MAX_LENGTH). The number of bytes written
  (including the terminating 0) is returned.
*/
uint8_t SCL_boardToFEN(SCL_Board board, char* string);

/**
  Loads a board from FEN (Forsyth–Edwards Notation) string. Returns 1 on
  success, 0 otherwise. XFEN isn't supported fully but a start position in
  chess960 can be loaded with this function. 
*/
uint8_t SCL_boardFromFEN(SCL_Board board, const char* string);

/**
  Returns an approximate/heuristic board rating as a number, 0 meaning equal
  chances for both players, positive favoring white, negative favoring black.
*/
typedef int16_t (*SCL_StaticEvaluationFunction)(SCL_Board);

/* 
  NOTE: int8_t as a return value was tried for evaluation function, which would
  be simpler, but it fails to capture important non-material position
  differences counted in fractions of pawn values, hence we have to use int16_t.
*/

/**
  Basic static evaluation function. WARNING: this function supposes a standard
  chess game, for non-standard positions it may either not work well or even
  crash the program. You should use a different function for non-standard games.
*/
int16_t SCL_boardEvaluateStatic(SCL_Board board);

/**
  Dynamic evaluation function (search), i.e. unlike SCL_boardEvaluateStatic,
  this one performs a recursive search for deeper positions to get a more
  accurate score. Of course, this is much slower and hugely dependent on
  baseDepth (you mostly want to keep this under 5).
*/
int16_t SCL_boardEvaluateDynamic(
    SCL_Board board,
    uint8_t baseDepth,
    uint8_t extensionExtraDepth,
    SCL_StaticEvaluationFunction evalFunction);

#define SCL_EVALUATION_MAX_SCORE 32600 // don't increase this, we need a margin

/**
  Checks if the board position is dead, i.e. mate is impossible (e.g. due to
  insufficient material), which by the rules results in a draw. WARNING: This
  function may fail to detect some dead positions as this is a non-trivial task.
*/
uint8_t SCL_boardDead(SCL_Board board);

/**
  Tests whether given player is in check.
*/
uint8_t SCL_boardCheck(SCL_Board board, uint8_t white);

/**
  Checks whether given move resets the move counter (used in the 50 move rule).
*/
uint8_t SCL_boardMoveResetsCount(SCL_Board board, uint8_t squareFrom, uint8_t squareTo);

uint8_t SCL_boardMate(SCL_Board board);

/**
  Performs a move on a board WITHOUT checking if the move is legal. Returns an
  info with which the move can be undone.
*/
SCL_MoveUndo
    SCL_boardMakeMove(SCL_Board board, uint8_t squareFrom, uint8_t squareTo, char promotePiece);

void SCL_boardUndoMove(SCL_Board board, SCL_MoveUndo moveUndo);

/**
  Checks if the game is over, i.e. the current player to move has no legal
  moves, the game is in dead position etc.
*/
uint8_t SCL_boardGameOver(SCL_Board board);

/**
  Checks if given move is legal.
*/
uint8_t SCL_boardMoveIsLegal(SCL_Board board, uint8_t squareFrom, uint8_t squareTo);

/**
  Checks if the player to move has at least one legal move.
*/
uint8_t SCL_boardMovePossible(SCL_Board board);

#define SCL_POSITION_NORMAL    0x00
#define SCL_POSITION_CHECK     0x01
#define SCL_POSITION_MATE      0x02
#define SCL_POSITION_STALEMATE 0x03
#define SCL_POSITION_DEAD      0x04

uint8_t SCL_boardGetPosition(SCL_Board board);

/**
  Returns 1 if the square is attacked by player of given color. This is used to
  examine checks, so for performance reasons the functions only checks whether
  or not the square is attacked (not the number of attackers).
*/
uint8_t SCL_boardSquareAttacked(SCL_Board board, uint8_t square, uint8_t byWhite);

/**
  Gets pseudo moves of a piece: all possible moves WITHOUT eliminating moves
  that lead to own check. To get only legal moves use SCL_boardGetMoves.
*/
void SCL_boardGetPseudoMoves(
    SCL_Board board,
    uint8_t pieceSquare,
    uint8_t checkCastling,
    SCL_SquareSet result);

/**
  Gets all legal moves of given piece.
*/
void SCL_boardGetMoves(SCL_Board board, uint8_t pieceSquare, SCL_SquareSet result);

static inline uint8_t SCL_boardWhitesTurn(SCL_Board board);

static inline uint8_t SCL_pieceIsWhite(char piece);
static inline uint8_t SCL_squareIsWhite(uint8_t square);
char SCL_pieceToColor(uint8_t piece, uint8_t toWhite);

/**
  Converts square coordinates to square number. Each coordinate must be a number
  <1,8>. Validity of the coordinates is NOT checked.
*/
static inline uint8_t SCL_coordsToSquare(uint8_t row, uint8_t column);

#ifndef SCL_VALUE_PAWN
#define SCL_VALUE_PAWN 256
#endif

#ifndef SCL_VALUE_KNIGHT
#define SCL_VALUE_KNIGHT 768
#endif

#ifndef SCL_VALUE_BISHOP
#define SCL_VALUE_BISHOP 800
#endif

#ifndef SCL_VALUE_ROOK
#define SCL_VALUE_ROOK 1280
#endif

#ifndef SCL_VALUE_QUEEN
#define SCL_VALUE_QUEEN 2304
#endif

#ifndef SCL_VALUE_KING
#define SCL_VALUE_KING 0
#endif

#define SCL_ENDGAME_MATERIAL_LIMIT \
    (2 *                           \
     (SCL_VALUE_PAWN * 4 + SCL_VALUE_QUEEN + SCL_VALUE_KING + SCL_VALUE_ROOK + SCL_VALUE_KNIGHT))

#define SCL_START_MATERIAL                                                                    \
    (16 * SCL_VALUE_PAWN + 4 * SCL_VALUE_ROOK + 4 * SCL_VALUE_KNIGHT + 4 * SCL_VALUE_BISHOP + \
     2 * SCL_VALUE_QUEEN + 2 * SCL_VALUE_KING)

#ifndef SCL_RECORD_MAX_LENGTH
#define SCL_RECORD_MAX_LENGTH 256
#endif

#define SCL_RECORD_MAX_SIZE (SCL_RECORD_MAX_LENGTH * 2)

/**
  Records a single chess game. The format is following:

  Each record item consists of 2 bytes which record a single move (ply):

  abxxxxxx cdyyyyyy

    xxxxxx  Start square of the move, counted as A0, A1, ...
    yyyyyy  End square of the move in the same format as the start square.
    ab      00 means this move isn't the last move of the game, other possible
            values are 01: white wins, 10: black wins, 11: draw or end for
            other reasons.
    cd      In case of pawn promotion move this encodes the promoted piece as
            00: queen, 01: rook, 10: bishop, 11: knight (pawn isn't allowed by
            chess rules).

  Every record should be ended by an ending move (ab != 00), empty record should
  have one move where xxxxxx == yyyyyy == 0 and ab == 11.
*/
typedef uint8_t SCL_Record[SCL_RECORD_MAX_SIZE];

#define SCL_RECORD_CONT  0x00
#define SCL_RECORD_W_WIN 0x40
#define SCL_RECORD_B_WIN 0x80
#define SCL_RECORD_END   0xc0

#define SCL_RECORD_PROM_Q 0x00
#define SCL_RECORD_PROM_R 0x40
#define SCL_RECORD_PROM_B 0x80
#define SCL_RECORD_PROM_N 0xc0

#define SCL_RECORD_ITEM(s0, s1, p, e) ((e) | (s0)), ((p) | (s1))

void SCL_recordInit(SCL_Record r);

void SCL_recordCopy(SCL_Record recordFrom, SCL_Record recordTo);

/**
  Represents a complete game of chess (or a variant with different staring
  position). This struct along with associated functions allows to easily
  implement a chess game that allows undoing moves, detecting draws, recording
  the moves etc. On platforms with extremely little RAM one can reduce
  SCL_RECORD_MAX_LENGTH to reduce the size of this struct (which will however
  possibly limit how many moves can be undone).
*/
typedef struct {
    SCL_Board board;
    SCL_Record record; /**< Holds the game record. This record is here 
                              firstly because games are usually recorded and
                              secondly this allows undoing moves up to the 
                              beginning of the game. This infinite undoing will
                              only work as long as the record is able to hold
                              the whole game; if the record is full, undoing is
                              no longet possible. */
    uint16_t state;
    uint16_t ply; ///< ply count (board ply counter is only 8 bit)

    uint32_t prevMoves[14]; ///< stores last moves, for repetition detection

    const char* startState; /**< Optional pointer to the starting board state.
                              If this is null, standard chess start position is
                              assumed. This is needed for undoing moves with
                              game record. */
} SCL_Game;

/**
  Initializes a new chess game. The startState parameter is optional and allows
  for setting up chess variants that differ by starting positions, setting this
  to 0 will assume traditional starting position. WARNING: if startState is
  provided, the pointed to board mustn't be deallocated afterwards, the string
  is not internally copied (for memory saving reasons).
*/
void SCL_gameInit(SCL_Game* game, const SCL_Board startState);

void SCL_gameMakeMove(SCL_Game* game, uint8_t squareFrom, uint8_t squareTo, char promoteTo);

uint8_t SCL_gameUndoMove(SCL_Game* game);

/**
  Gets a move which if played now would cause a draw by repetition. Returns 1
  if such move exists, 0 otherwise. The results parameters can be set to 0 in
  which case they will be ignored and only the existence of a draw move will be
  tested.
*/
uint8_t SCL_gameGetRepetiotionMove(SCL_Game* game, uint8_t* squareFrom, uint8_t* squareTo);

/**
  Leads a game record from PGN string. The function will probably not strictly
  adhere to the PGN input format, but should accept most sanely written PGN
  strings.
*/
void SCL_recordFromPGN(SCL_Record r, const char* pgn);

uint16_t SCL_recordLength(const SCL_Record r);

/**
  Gets the move out of a game record, returns the end state of the move
  (SCL_RECORD_CONT, SCL_RECORD_END etc.)
*/
uint8_t SCL_recordGetMove(
    const SCL_Record r,
    uint16_t index,
    uint8_t* squareFrom,
    uint8_t* squareTo,
    char* promotedPiece);

/**
  Adds another move to the game record. Terminating the record is handled so
  that the last move is always marked with end flag, endState is here to only
  indicate possible game result (otherwise pass SCL_RECORD_CONT). Returns 1 if
  the item was added, otherwise 0 (replay was already of maximum size).
*/
uint8_t SCL_recordAdd(
    SCL_Record r,
    uint8_t squareFrom,
    uint8_t squareTo,
    char promotePiece,
    uint8_t endState);

/**
  Removes the last move from the record, returns 1 if the replay is non-empty
  after the removal, otherwise 0.
*/
uint8_t SCL_recordRemoveLast(SCL_Record r);

/**
  Applies given number of half-moves (ply) to a given board (the board is
  automatically initialized at the beginning).
*/
void SCL_recordApply(const SCL_Record r, SCL_Board b, uint16_t moves);

int16_t SCL_pieceValue(char piece);
int16_t SCL_pieceValuePositive(char piece);

#define SCL_PRINT_FORMAT_NONE         0
#define SCL_PRINT_FORMAT_NORMAL       1
#define SCL_PRINT_FORMAT_COMPACT      2
#define SCL_PRINT_FORMAT_UTF8         3
#define SCL_PRINT_FORMAT_COMPACT_UTF8 4

/**
  Gets the best move for the currently moving player as computed by AI. The
  return value is the value of the move (with the same semantics as the value
  of an evaluation function). baseDepth is depth in plys to which all moves will
  be checked. If baseDepth 0 is passed, the function makes a random move and
  returns the evaluation of the board. extensionExtraDepth is extra depth for
  checking specific situations like exchanges and checks. endgameExtraDepth is
  extra depth which is added to baseDepth in the endgame. If the randomness
  function is 0, AI will always make the first best move it finds, if it is
  not 0 and randomness is 0, AI will randomly pick between the equally best
  moves, if it is not 0 and randomness is positive, AI will randomly choose
  between best moves with some bias (may not pick the best rated move).
*/
int16_t SCL_getAIMove(
    SCL_Board board,
    uint8_t baseDepth,
    uint8_t extensionExtraDepth,
    uint8_t endgameExtraDepth,
    SCL_StaticEvaluationFunction evalFunc,
    SCL_RandomFunction randFunc,
    uint8_t randomness,
    uint8_t repetitionMoveFrom,
    uint8_t repetitionMoveTo,
    uint8_t* resultFrom,
    uint8_t* resultTo,
    char* resultProm);

/**
  Function that prints out a single character. This is passed to printing
  functions.
*/
typedef void (*SCL_PutCharFunction)(char);

/**
  Prints given chessboard using given format and an abstract printing function.
*/
void SCL_printBoard(
    SCL_Board board,
    SCL_PutCharFunction putCharFunc,
    SCL_SquareSet highlightSquares,
    uint8_t selectSquare,
    uint8_t format,
    uint8_t offset,
    uint8_t labels,
    uint8_t blackDown);

void SCL_printBoardSimple(
    SCL_Board board,
    SCL_PutCharFunction putCharFunc,
    uint8_t selectSquare,
    uint8_t format);

void SCL_printSquareUTF8(uint8_t square, SCL_PutCharFunction putCharFunc);
void SCL_printPGN(SCL_Record r, SCL_PutCharFunction putCharFunc, SCL_Board initialState);

/**
  Reads a move from string (the notation format is described at the top of this
  file). The function is safe as long as the string is 0 terminated. Returns 1
  on success or 0 on fail (invalid move string).
*/
uint8_t SCL_stringToMove(
    const char* moveString,
    uint8_t* resultFrom,
    uint8_t* resultTo,
    char* resultPromotion);

char* SCL_moveToString(SCL_Board board, uint8_t s0, uint8_t s1, char promotion, char* string);

/**
  Function used in drawing, it is called to draw the next pixel. The first
  parameter is the pixel color, the second one if the sequential number of the
  pixel.
*/
typedef void (*SCL_PutPixelFunction)(uint8_t, uint16_t);

#define SCL_BOARD_PICTURE_WIDTH 64

/**
  Draws a simple 1bit 64x64 pixels board using a provided abstract function for
  drawing pixels. The function renders from top left to bottom right, i.e. no
  frame buffer is required.
*/
void SCL_drawBoard(
    SCL_Board board,
    SCL_PutPixelFunction putPixel,
    uint8_t selectedSquare,
    SCL_SquareSet highlightSquares,
    uint8_t blackDown);

/**
  Converts square number to string representation (e.g. "d2"). This function
  will modify exactly the first two bytes of the provided string.
*/
static inline char* SCL_squareToString(uint8_t square, char* string);

/**
  Converts a string, such as "A1" or "b4", to square number. The string must
  start with a letter (lower or upper case) and be followed by a number <1,8>.
  Validity of the string is NOT checked.
*/
uint8_t SCL_stringToSquare(const char* square);

//=============================================================================
// privates:

#define SCL_UNUSED(v) (void)(v)

uint8_t SCL_currentRandom8 = 0;

uint16_t SCL_currentRandom16 = 0;

void SCL_randomSimpleSeed(uint8_t seed) {
    SCL_currentRandom8 = seed;
}

uint8_t SCL_randomSimple(void) {
    SCL_currentRandom8 *= 13;
    SCL_currentRandom8 += 7;
    return SCL_currentRandom8;
}

uint8_t SCL_randomBetter(void) {
    SCL_currentRandom16 *= 13;
    SCL_currentRandom16 += 7;
    return (SCL_currentRandom16 % 256) ^ (SCL_currentRandom16 / 256);
}

void SCL_randomBetterSeed(uint16_t seed) {
    SCL_currentRandom16 = seed;
}

void SCL_squareSetClear(SCL_SquareSet squareSet) {
    for(uint8_t i = 0; i < 8; ++i)
        squareSet[i] = 0;
}

uint8_t SCL_stringToSquare(const char* square) {
    return (square[1] - '1') * 8 +
           (square[0] - ((square[0] >= 'A' && square[0] <= 'Z') ? 'A' : 'a'));
}

char* SCL_moveToString(SCL_Board board, uint8_t s0, uint8_t s1, char promotion, char* string) {
    char* result = string;

    SCL_squareToString(s0, string);
    string += 2;
    string = SCL_squareToString(s1, string);
    string += 2;

    char c = board[s0];

    if(c == 'p' || c == 'P') {
        uint8_t rank = s1 / 8;

        if(rank == 0 || rank == 7) {
            *string = promotion;
            string++;
        }
    }

    *string = 0;

    return result;
}

uint8_t SCL_boardWhitesTurn(SCL_Board board) {
    return (board[SCL_BOARD_PLY_BYTE] % 2) == 0;
}

uint8_t SCL_coordsToSquare(uint8_t row, uint8_t column) {
    return row * 8 + column;
}

uint8_t SCL_pieceIsWhite(char piece) {
    return piece < 'a';
}

char* SCL_squareToString(uint8_t square, char* string) {
    string[0] = 'a' + square % 8;
    string[1] = '1' + square / 8;

    return string;
}

uint8_t SCL_squareIsWhite(uint8_t square) {
    return (square % 2) != ((square / 8) % 2);
}

char SCL_pieceToColor(uint8_t piece, uint8_t toWhite) {
    return (SCL_pieceIsWhite(piece) == toWhite) ? piece : (piece + (toWhite ? -32 : 32));
}

/**
  Records the rook starting positions in the board state. This is required in
  chess 960 in order to be able to correctly perform castling (castling rights
  knowledge isn't enough as one rook might have moved to the other side and we
  wouldn't know which one can castle and which not).
*/
void _SCL_board960RememberRookPositions(SCL_Board board) {
    uint8_t pos = 0;
    uint8_t rooks = 2;

    while(pos < 8 && rooks != 0) {
        if(board[pos] == 'R') {
            board[SCL_BOARD_EXTRA_BYTE] = rooks == 2 ? pos :
                                                       (board[SCL_BOARD_EXTRA_BYTE] | (pos << 3));

            rooks--;
        }

        pos++;
    }
}

void SCL_boardInit(SCL_Board board) {
    /*
    We might use SCL_BOARD_START_STATE and copy it to the board, but that might
    waste RAM on Arduino, so we init the board by code.
  */

    char* b = board;

    *b = 'R';
    b++;
    *b = 'N';
    b++;
    *b = 'B';
    b++;
    *b = 'Q';
    b++;
    *b = 'K';
    b++;
    *b = 'B';
    b++;
    *b = 'N';
    b++;
    *b = 'R';
    b++;

    char* b2 = board + 48;

    for(uint8_t i = 0; i < 8; ++i, b++, b2++) {
        *b = 'P';
        *b2 = 'p';
    }

    for(uint8_t i = 0; i < 32; ++i, b++)
        *b = '.';

    b += 8;

    *b = 'r';
    b++;
    *b = 'n';
    b++;
    *b = 'b';
    b++;
    *b = 'q';
    b++;
    *b = 'k';
    b++;
    *b = 'b';
    b++;
    *b = 'n';
    b++;
    *b = 'r';
    b++;

    for(uint8_t i = 0; i < SCL_BOARD_STATE_SIZE - SCL_BOARD_SQUARES; ++i, ++b)
        *b = 0;

    board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] = (char)0xff;

#if SCL_960_CASTLING
    _SCL_board960RememberRookPositions(board);
#endif
}

void _SCL_boardPlaceOnNthAvailable(SCL_Board board, uint8_t pos, char piece) {
    char* c = board;

    while(1) {
        if(*c == '.') {
            if(pos == 0) break;

            pos--;
        }

        c++;
    }

    *c = piece;
}

void SCL_boardInit960(SCL_Board board, uint16_t positionNumber) {
    SCL_Board b;

    SCL_boardInit(b);

    for(uint8_t i = 0; i < SCL_BOARD_STATE_SIZE; ++i)
        board[i] = ((i >= 8 && i < 56) || i >= 64) ? b[i] : '.';

    uint8_t helper = positionNumber % 16;

    board[(helper / 4) * 2] = 'B';
    board[1 + (helper % 4) * 2] = 'B';

    helper = positionNumber / 16;

    // maybe there's a simpler way :)

    _SCL_boardPlaceOnNthAvailable(board, helper % 6, 'Q');
    _SCL_boardPlaceOnNthAvailable(board, 0, helper <= 23 ? 'N' : 'R');

    _SCL_boardPlaceOnNthAvailable(
        board, 0, (helper >= 7 && helper <= 23) ? 'R' : (helper > 41 ? 'K' : 'N'));

    _SCL_boardPlaceOnNthAvailable(
        board,
        0,
        (helper <= 5 || helper >= 54) ?
            'R' :
            (((helper >= 12 && helper <= 23) || (helper >= 30 && helper <= 41)) ? 'K' : 'N'));

    _SCL_boardPlaceOnNthAvailable(
        board,
        0,
        (helper <= 11 || (helper <= 29 && helper >= 24)) ?
            'K' :
            (((helper >= 18 && helper <= 23) || (helper >= 36 && helper <= 41) ||
              (helper >= 48 && helper <= 53)) ?
                 'R' :
                 'N'));

    uint8_t rooks = 0;

    for(uint8_t i = 0; i < 8; ++i)
        if(board[i] == 'R') rooks++;

    _SCL_boardPlaceOnNthAvailable(board, 0, rooks == 2 ? 'N' : 'R');

    for(uint8_t i = 0; i < 8; ++i)
        board[56 + i] = SCL_pieceToColor(board[i], 0);

#if SCL_960_CASTLING
    _SCL_board960RememberRookPositions(board);
#else
    SCL_boardDisableCastling(board);
#endif
}

uint8_t SCL_boardsDiffer(SCL_Board b1, SCL_Board b2) {
    const char *p1 = b1, *p2 = b2;

    while(p1 < b1 + SCL_BOARD_STATE_SIZE) {
        if(*p1 != *p2) return 1;

        p1++;
        p2++;
    }

    return 0;
}

void SCL_recordInit(SCL_Record r) {
    r[0] = 0 | SCL_RECORD_END;
    r[1] = 0;
}

void SCL_recordFromPGN(SCL_Record r, const char* pgn) {
    SCL_Board board;

    SCL_boardInit(board);

    SCL_recordInit(r);

    uint8_t state = 0;
    uint8_t evenMove = 0;

    while(*pgn != 0) {
        switch(state) {
        case 0: // skipping tags and spaces, outside []
            if(*pgn == '1')
                state = 2;
            else if(*pgn == '[')
                state = 1;

            break;

        case 1: // skipping tags and spaces, inside []
            if(*pgn == ']') state = 0;

            break;

        case 2: // reading move number
            if(*pgn == '{')
                state = 3;
            else if((*pgn >= 'a' && *pgn <= 'h') || (*pgn >= 'A' && *pgn <= 'Z')) {
                state = 4;
                pgn--;
            }

            break;

        case 3: // initial comment
            if(*pgn == '}') state = 2;

            break;

        case 4: // reading move
        {
            char piece = 'p';
            char promoteTo = 'q';
            uint8_t castle = 0;
            uint8_t promotion = 0;

            int8_t coords[4];

            uint8_t ranks = 0, files = 0;

            for(uint8_t i = 0; i < 4; ++i)
                coords[i] = -1;

            while(*pgn != ' ' && *pgn != '\n' && *pgn != '\t' && *pgn != '{' && *pgn != 0) {
                if(*pgn == '=') promotion = 1;
                if(*pgn == 'O' || *pgn == '0') castle++;
                if(*pgn >= 'A' && *pgn <= 'Z') {
                    if(promotion)
                        promoteTo = *pgn;
                    else
                        piece = *pgn;
                } else if(*pgn >= 'a' && *pgn <= 'h') {
                    coords[files * 2] = *pgn - 'a';
                    files++;
                } else if(*pgn >= '1' && *pgn <= '8') {
                    coords[1 + ranks * 2] = *pgn - '1';
                    ranks++;
                }

                pgn++;
            }

            if(castle) {
                piece = 'K';

                coords[0] = 4;
                coords[1] = 0;
                coords[2] = castle < 3 ? 6 : 2;
                coords[3] = 0;

                if(evenMove) {
                    coords[1] = 7;
                    coords[3] = 7;
                }
            }

            piece = SCL_pieceToColor(piece, evenMove == 0);

            if(coords[2] < 0) {
                coords[2] = coords[0];
                coords[0] = -1;
            }

            if(coords[3] < 0) {
                coords[3] = coords[1];
                coords[1] = -1;
            }

            uint8_t squareTo = coords[3] * 8 + coords[2];

            if(coords[0] < 0 || coords[1] < 0) {
                // without complete starting coords we have to find the piece

                for(int i = 0; i < SCL_BOARD_SQUARES; ++i)
                    if(board[i] == piece) {
                        SCL_SquareSet s;

                        SCL_squareSetClear(s);

                        SCL_boardGetMoves(board, i, s);

                        if(SCL_squareSetContains(s, squareTo) &&
                           (coords[0] < 0 || coords[0] == i % 8) &&
                           (coords[1] < 0 || coords[1] == i / 8)) {
                            coords[0] = i % 8;
                            coords[1] = i / 8;
                            break;
                        }
                    }
            }

            uint8_t squareFrom = coords[1] * 8 + coords[0];

            SCL_boardMakeMove(board, squareFrom, squareTo, promoteTo);

            // for some reason tcc bugs here, the above line sets squareFrom to 0 lol
            // can be fixed with doing "squareFrom = coords[1] * 8 + coords[0];" again

            SCL_recordAdd(r, squareFrom, squareTo, promoteTo, SCL_RECORD_CONT);

            while(*pgn == ' ' || *pgn == '\n' || *pgn == '\t' || *pgn == '{') {
                if(*pgn == '{')
                    while(*pgn != '}')
                        pgn++;

                pgn++;
            }

            if(*pgn == 0) return;

            pgn--;

            if(evenMove) state = 2;

            evenMove = !evenMove;

            break;
        }

        default:
            break;
        }

        pgn++;
    }
}

uint16_t SCL_recordLength(const SCL_Record r) {
    if((r[0] & 0x3f) == (r[1] & 0x3f)) // empty record that's only terminator
        return 0;

    uint16_t result = 0;

    while((r[result] & 0xc0) == 0)
        result += 2;

    return (result / 2) + 1;
}

uint8_t SCL_recordGetMove(
    const SCL_Record r,
    uint16_t index,
    uint8_t* squareFrom,
    uint8_t* squareTo,
    char* promotedPiece) {
    index *= 2;

    uint8_t b = r[index];

    *squareFrom = b & 0x3f;
    uint8_t result = b & 0xc0;

    index++;

    b = r[index];

    *squareTo = b & 0x3f;

    b &= 0xc0;

    switch(b) {
    case SCL_RECORD_PROM_Q:
        *promotedPiece = 'q';
        break;
    case SCL_RECORD_PROM_R:
        *promotedPiece = 'r';
        break;
    case SCL_RECORD_PROM_B:
        *promotedPiece = 'b';
        break;
    case SCL_RECORD_PROM_N:
    default:
        *promotedPiece = 'n';
        break;
    }

    return result;
}

uint8_t SCL_recordAdd(
    SCL_Record r,
    uint8_t squareFrom,
    uint8_t squareTo,
    char promotePiece,
    uint8_t endState) {
    uint16_t l = SCL_recordLength(r);

    if(l >= SCL_RECORD_MAX_LENGTH) return 0;

    l *= 2;

    if(l != 0) r[l - 2] &= 0x3f; // remove the end flag from previous item

    if(endState == SCL_RECORD_CONT) endState = SCL_RECORD_END;

    r[l] = squareFrom | endState;

    uint8_t p;

    switch(promotePiece) {
    case 'n':
    case 'N':
        p = SCL_RECORD_PROM_N;
        break;
    case 'b':
    case 'B':
        p = SCL_RECORD_PROM_B;
        break;
    case 'r':
    case 'R':
        p = SCL_RECORD_PROM_R;
        break;
    case 'q':
    case 'Q':
    default:
        p = SCL_RECORD_PROM_Q;
        break;
    }

    l++;

    r[l] = squareTo | p;

    return 1;
}

uint8_t SCL_recordRemoveLast(SCL_Record r) {
    uint16_t l = SCL_recordLength(r);

    if(l == 0) return 0;

    if(l == 1)
        SCL_recordInit(r);
    else {
        l = (l - 2) * 2;

        r[l] = (r[l] & 0x3f) | SCL_RECORD_END;
    }

    return 1;
}

void SCL_recordApply(const SCL_Record r, SCL_Board b, uint16_t moves) {
    SCL_boardInit(b);

    uint16_t l = SCL_recordLength(r);

    if(moves > l) moves = l;

    for(uint16_t i = 0; i < moves; ++i) {
        uint8_t s0, s1;
        char p;

        SCL_recordGetMove(r, i, &s0, &s1, &p);
        SCL_boardMakeMove(b, s0, s1, p);
    }
}

void SCL_boardUndoMove(SCL_Board board, SCL_MoveUndo moveUndo) {
#if SCL_960_CASTLING
    char squareToNow = board[moveUndo.squareTo];
#endif

    board[moveUndo.squareFrom] = board[moveUndo.squareTo];
    board[moveUndo.squareTo] = moveUndo.other & 0x7f;
    board[SCL_BOARD_PLY_BYTE]--;
    board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] = moveUndo.enPassantCastle;
    board[SCL_BOARD_MOVE_COUNT_BYTE] = moveUndo.moveCount;

    if(moveUndo.other & 0x80) {
        moveUndo.squareTo /= 8;

        if(moveUndo.squareTo == 0 || moveUndo.squareTo == 7)
            board[moveUndo.squareFrom] = SCL_pieceIsWhite(board[moveUndo.squareFrom]) ? 'P' : 'p';
        // ^ was promotion
        else
            board[(moveUndo.squareFrom / 8) * 8 + (moveUndo.enPassantCastle & 0x0f)] =
                (board[moveUndo.squareFrom] == 'P') ? 'p' : 'P'; // was en passant
    }
#if !SCL_960_CASTLING
    else if(
        board[moveUndo.squareFrom] == 'k' && // black castling
        moveUndo.squareFrom == 60) {
        if(moveUndo.squareTo == 58) {
            board[59] = '.';
            board[56] = 'r';
        } else if(moveUndo.squareTo == 62) {
            board[61] = '.';
            board[63] = 'r';
        }
    } else if(
        board[moveUndo.squareFrom] == 'K' && // white castling
        moveUndo.squareFrom == 4) {
        if(moveUndo.squareTo == 2) {
            board[3] = '.';
            board[0] = 'R';
        } else if(moveUndo.squareTo == 6) {
            board[5] = '.';
            board[7] = 'R';
        }
    }
#else // 960 castling
    else if(
        ((moveUndo.other & 0x7f) == 'r') && // black castling
        (squareToNow == '.' || !SCL_pieceIsWhite(squareToNow))) {
        board[moveUndo.squareTo < moveUndo.squareFrom ? 59 : 61] = '.';
        board[moveUndo.squareTo < moveUndo.squareFrom ? 58 : 62] = '.';

        board[moveUndo.squareFrom] = 'k';
        board[moveUndo.squareTo] = 'r';
    } else if(
        ((moveUndo.other & 0x7f) == 'R') && // white castling
        (squareToNow == '.' || SCL_pieceIsWhite(squareToNow))) {
        board[moveUndo.squareTo < moveUndo.squareFrom ? 3 : 5] = '.';
        board[moveUndo.squareTo < moveUndo.squareFrom ? 2 : 6] = '.';

        board[moveUndo.squareFrom] = 'K';
        board[moveUndo.squareTo] = 'R';
    }
#endif
}

/**
  Potentially disables castling rights according to whether something moved from
  or to a square with a rook.
*/
void _SCL_handleRookActivity(SCL_Board board, uint8_t rookSquare) {
#if !SCL_960_CASTLING
    switch(rookSquare) {
    case 0:
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x20;
        break;
    case 7:
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x10;
        break;
    case 56:
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x80;
        break;
    case 63:
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x40;
        break;
    default:
        break;
    }
#else // 960 castling
    if(rookSquare == (board[SCL_BOARD_EXTRA_BYTE] & 0x07))
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x20;
    else if(rookSquare == (board[SCL_BOARD_EXTRA_BYTE] >> 3))
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x10;
    else if(rookSquare == 56 + (board[SCL_BOARD_EXTRA_BYTE] & 0x07))
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x80;
    else if(rookSquare == 56 + (board[SCL_BOARD_EXTRA_BYTE] >> 3))
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= (uint8_t)~0x40;
#endif
}

SCL_MoveUndo
    SCL_boardMakeMove(SCL_Board board, uint8_t squareFrom, uint8_t squareTo, char promotePiece) {
    char s = board[squareFrom];

    SCL_MoveUndo moveUndo;

    moveUndo.squareFrom = squareFrom;
    moveUndo.squareTo = squareTo;
    moveUndo.moveCount = board[SCL_BOARD_MOVE_COUNT_BYTE];
    moveUndo.enPassantCastle = board[SCL_BOARD_ENPASSANT_CASTLE_BYTE];
    moveUndo.other = board[squareTo];

    // reset the en-passant state
    board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] |= 0x0f;

    if(SCL_boardMoveResetsCount(board, squareFrom, squareTo))
        board[SCL_BOARD_MOVE_COUNT_BYTE] = 0;
    else
        board[SCL_BOARD_MOVE_COUNT_BYTE]++;

#if SCL_960_CASTLING
    uint8_t castled = 0;
#endif

    if((s == 'k') || (s == 'K')) {
#if !SCL_960_CASTLING
        if((squareFrom == 4) || (squareFrom == 60)) // check castling
        {
            int8_t difference = squareTo - squareFrom;

            char rook = SCL_pieceToColor('r', SCL_pieceIsWhite(s));

            if(difference == 2) // short
            {
                board[squareTo - 1] = rook;
                board[squareTo + 1] = '.';
            } else if(difference == -2) // long
            {
                board[squareTo - 2] = '.';
                board[squareTo + 1] = rook;
            }
        }
#else // 960 castling
        uint8_t isWhite = SCL_pieceIsWhite(s);
        char rook = SCL_pieceToColor('r', isWhite);

        if(board[squareTo] == rook) {
            castled = 1;

            board[squareFrom] = '.';
            board[squareTo] = '.';

            if(squareTo > squareFrom) // short
            {
                board[isWhite ? 6 : (56 + 6)] = s;
                board[isWhite ? 5 : (56 + 5)] = rook;
            } else // long
            {
                board[isWhite ? 2 : (56 + 2)] = s;
                board[isWhite ? 3 : (56 + 3)] = rook;
            }
        }
#endif

        // after king move disable castling
        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= ~(0x03 << ((s == 'K') ? 4 : 6));
    } else if((s == 'p') || (s == 'P')) {
        uint8_t row = squareTo / 8;

        int8_t rowDiff = squareFrom / 8 - row;

        if(rowDiff == 2 || rowDiff == -2) // record en passant column
        {
            board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] =
                (board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & 0xf0) | (squareFrom % 8);
        }

        if(row == 0 || row == 7) {
            // promotion
            s = SCL_pieceToColor(promotePiece, SCL_pieceIsWhite(s));

            moveUndo.other |= 0x80;
        } else {
            // check en passant move

            int8_t columnDiff = (squareTo % 8) - (squareFrom % 8);

            if((columnDiff != 0) && (board[squareTo] == '.')) {
                board[squareFrom + columnDiff] = '.';
                moveUndo.other |= 0x80;
            }
        }
    } else if((s == 'r') || (s == 'R'))
        _SCL_handleRookActivity(board, squareFrom);

    char taken = board[squareTo];

    // taking a rook may also disable castling:

    if(taken == 'R' || taken == 'r') _SCL_handleRookActivity(board, squareTo);

#if SCL_960_CASTLING
    if(!castled)
#endif
    {
        board[squareTo] = s;
        board[squareFrom] = '.';
    }

    board[SCL_BOARD_PLY_BYTE]++; // increase ply count

    return moveUndo;
}

void SCL_boardSetPosition(
    SCL_Board board,
    const char* pieces,
    uint8_t castlingEnPassant,
    uint8_t moveCount,
    uint8_t ply) {
    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, pieces++)
        if(*pieces != 0)
            board[i] = *pieces;
        else
            break;

    board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] = castlingEnPassant;
    board[SCL_BOARD_PLY_BYTE] = ply;
    board[SCL_BOARD_MOVE_COUNT_BYTE] = moveCount;
    board[SCL_BOARD_STATE_SIZE - 1] = 0;
}

void SCL_squareSetAdd(SCL_SquareSet squareSet, uint8_t square) {
    squareSet[square / 8] |= 0x01 << (square % 8);
}

uint8_t SCL_squareSetContains(const SCL_SquareSet squareSet, uint8_t square) {
    return squareSet[square / 8] & (0x01 << (square % 8));
}

uint8_t SCL_squareSetSize(const SCL_SquareSet squareSet) {
    uint8_t result = 0;

    for(uint8_t i = 0; i < 8; ++i) {
        uint8_t byte = squareSet[i];

        for(uint8_t j = 0; j < 8; ++j) {
            result += byte & 0x01;
            byte >>= 1;
        }
    }

    return result;
}

uint8_t SCL_squareSetEmpty(const SCL_SquareSet squareSet) {
    for(uint8_t i = 0; i < 8; ++i)
        if(squareSet[i] != 0) return 0;

    return 1;
}

uint8_t SCL_squareSetGetRandom(const SCL_SquareSet squareSet, SCL_RandomFunction randFunc) {
    uint8_t size = SCL_squareSetSize(squareSet);

    if(size == 0) return 0;

    uint8_t n = (randFunc() % size) + 1;
    uint8_t i = 0;

    while(i < SCL_BOARD_SQUARES) {
        if(SCL_squareSetContains(squareSet, i)) {
            n--;

            if(n == 0) break;
        }

        ++i;
    }

    return i;
}

void SCL_boardCopy(const SCL_Board boardFrom, SCL_Board boardTo) {
    for(uint8_t i = 0; i < SCL_BOARD_STATE_SIZE; ++i)
        boardTo[i] = boardFrom[i];
}

uint8_t SCL_boardSquareAttacked(SCL_Board board, uint8_t square, uint8_t byWhite) {
    const char* currentSquare = board;

    /* We need to place a temporary piece on the tested square in order to test if
     the square is attacked (consider testing if attacked by a pawn). */

    char previous = board[square];

    board[square] = SCL_pieceToColor('r', !byWhite);

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, ++currentSquare) {
        char s = *currentSquare;

        if((s == '.') || (SCL_pieceIsWhite(s) != byWhite)) continue;

        SCL_SquareSet moves;
        SCL_boardGetPseudoMoves(board, i, 0, moves);

        if(SCL_squareSetContains(moves, square)) {
            board[square] = previous;
            return 1;
        }
    }

    board[square] = previous;
    return 0;
}

uint8_t SCL_boardCheck(SCL_Board board, uint8_t white) {
    const char* square = board;
    char kingChar = white ? 'K' : 'k';

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, ++square)
        if((*square == kingChar && SCL_boardSquareAttacked(board, i, !white))) return 1;

    return 0;
}

uint8_t SCL_boardGameOver(SCL_Board board) {
    uint8_t position = SCL_boardGetPosition(board);

    return (position == SCL_POSITION_MATE) || (position == SCL_POSITION_STALEMATE) ||
           (position == SCL_POSITION_DEAD);
}

uint8_t SCL_boardMovePossible(SCL_Board board) {
    uint8_t white = SCL_boardWhitesTurn(board);

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i) {
        char s = board[i];

        if((s != '.') && (SCL_pieceIsWhite(s) == white)) {
            SCL_SquareSet moves;

            SCL_boardGetMoves(board, i, moves);

            if(SCL_squareSetSize(moves) != 0) return 1;
        }
    }

    return 0;
}

uint8_t SCL_boardMate(SCL_Board board) {
    return SCL_boardGetPosition(board) == SCL_POSITION_MATE;
}

void SCL_boardGetPseudoMoves(
    SCL_Board board,
    uint8_t pieceSquare,
    uint8_t checkCastling,
    SCL_SquareSet result) {
    char piece = board[pieceSquare];

    SCL_squareSetClear(result);

    uint8_t isWhite = SCL_pieceIsWhite(piece);
    int8_t horizontalPosition = pieceSquare % 8;
    int8_t pawnOffset = -8;

    switch(piece) {
    case 'P':
        pawnOffset = 8;
        /* FALLTHROUGH */
    case 'p': {
        uint8_t square = pieceSquare + pawnOffset;
        uint8_t verticalPosition = pieceSquare / 8;

        if(board[square] == '.') // forward move
        {
            SCL_squareSetAdd(result, square);

            if(verticalPosition == (1 + (piece == 'p') * 5)) // start position?
            {
                uint8_t square2 = square + pawnOffset;

                if(board[square2] == '.') SCL_squareSetAdd(result, square2);
            }
        }

#define checkDiagonal(hor, add)                                                           \
    if(horizontalPosition != hor) {                                                       \
        uint8_t square2 = square + add;                                                   \
        char c = board[square2];                                                          \
        if(c != '.' && SCL_pieceIsWhite(c) != isWhite) SCL_squareSetAdd(result, square2); \
    }

        // diagonal moves
        checkDiagonal(0, -1) checkDiagonal(7, 1)

            uint8_t enPassantRow = 4;
        uint8_t enemyPawn = 'p';

        if(piece == 'p') {
            enPassantRow = 3;
            enemyPawn = 'P';
        }

        // en-passant moves
        if(verticalPosition == enPassantRow) {
            uint8_t enPassantColumn = board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & 0x0f;
            uint8_t column = pieceSquare % 8;

            for(int8_t offset = -1; offset < 2; offset += 2)
                if((enPassantColumn == column + offset) &&
                   (board[pieceSquare + offset] == enemyPawn)) {
                    SCL_squareSetAdd(result, pieceSquare + pawnOffset + offset);
                    break;
                }
        }

#undef checkDiagonal
    } break;

    case 'r': // rook
    case 'R':
    case 'b': // bishop
    case 'B':
    case 'q': // queen
    case 'Q': {
        const int8_t offsets[8] = {-8, 1, 8, -1, -7, 9, -9, 7};
        const int8_t columnDirs[8] = {0, 1, 0, -1, 1, 1, -1, -1};

        uint8_t from = (piece == 'b' || piece == 'B') * 4;
        uint8_t to = 4 + (piece != 'r' && piece != 'R') * 4;

        for(uint8_t i = from; i < to; ++i) {
            int8_t offset = offsets[i];
            int8_t columnDir = columnDirs[i];
            int8_t square = pieceSquare;
            int8_t col = horizontalPosition;

            while(1) {
                square += offset;
                col += columnDir;

                if(square < 0 || square > 63 || col < 0 || col > 7) break;

                char squareC = board[square];

                if(squareC == '.')
                    SCL_squareSetAdd(result, square);
                else {
                    if(SCL_pieceIsWhite(squareC) != isWhite) SCL_squareSetAdd(result, square);

                    break;
                }
            }
        }
    } break;

    case 'n': // knight
    case 'N': {
        const int8_t offsets[4] = {6, 10, 15, 17};
        const int8_t columnsMinus[4] = {2, -2, 1, -1};
        const int8_t columnsPlus[4] = {-2, 2, -1, 1};
        const int8_t *off, *col;

#define checkOffsets(op, comp, limit, dir)                             \
    off = offsets;                                                     \
    col = columns##dir;                                                \
    for(uint8_t i = 0; i < 4; ++i, ++off, ++col) {                     \
        int8_t square = pieceSquare op(*off);                          \
        if(square comp limit) /* out of board? */                      \
            break;                                                     \
        int8_t horizontalCheck = horizontalPosition + (*col);          \
        if(horizontalCheck < 0 || horizontalCheck >= 8) continue;      \
        char squareC = board[square];                                  \
        if((squareC == '.') || (SCL_pieceIsWhite(squareC) != isWhite)) \
            SCL_squareSetAdd(result, square);                          \
    }

        checkOffsets(-, <, 0, Minus) checkOffsets(+, >=, SCL_BOARD_SQUARES, Plus)

#undef checkOffsets
    } break;

    case 'k': // king
    case 'K': {
        uint8_t verticalPosition = pieceSquare / 8;

        uint8_t u = verticalPosition != 0, d = verticalPosition != 7, l = horizontalPosition != 0,
                r = horizontalPosition != 7;

        uint8_t square2 = pieceSquare - 9;

#define checkSquare(cond, add)                                                             \
    if(cond && ((board[square2] == '.') || (SCL_pieceIsWhite(board[square2])) != isWhite)) \
        SCL_squareSetAdd(result, square2);                                                 \
    square2 += add;

        checkSquare(l && u, 1) checkSquare(u, 1) checkSquare(r && u, 6) checkSquare(l, 2)
            checkSquare(r, 6) checkSquare(l && d, 1) checkSquare(d, 1) checkSquare(r && d, 0)
#undef checkSquare

            // castling:

            if(checkCastling) {
            uint8_t bitShift = 4 + 2 * (!isWhite);

            if((board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & (0x03 << bitShift)) &&
               !SCL_boardSquareAttacked(board, pieceSquare, !isWhite)) // no check?
            {
#if !SCL_960_CASTLING
                // short castle:
                pieceSquare++;

                if((board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & (0x01 << bitShift)) &&
                   (board[pieceSquare] == '.') && (board[pieceSquare + 1] == '.') &&
                   (board[pieceSquare + 2] == SCL_pieceToColor('r', isWhite)) &&
                   !SCL_boardSquareAttacked(board, pieceSquare, !isWhite))
                    SCL_squareSetAdd(result, pieceSquare + 1);

                /* note: don't check the final square for check, it will potentially
             be removed later (can't end up in check) */

                // long castle:
                pieceSquare -= 2;

                if((board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & (0x02 << bitShift)) &&
                   (board[pieceSquare] == '.') && (board[pieceSquare - 1] == '.') &&
                   (board[pieceSquare - 2] == '.') &&
                   (board[pieceSquare - 3] == SCL_pieceToColor('r', isWhite)) &&
                   !SCL_boardSquareAttacked(board, pieceSquare, !isWhite))
                    SCL_squareSetAdd(result, pieceSquare - 1);
#else // 960 castling
                for(int i = 0; i < 2; ++i) // short and long
                    if(board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & ((i + 1) << bitShift)) {
                        uint8_t rookPos = board[SCL_BOARD_EXTRA_BYTE] >> 3, targetPos = 5;

                        if(i == 1) {
                            rookPos = board[SCL_BOARD_EXTRA_BYTE] & 0x07, targetPos = 3;
                        }

                        if(!isWhite) {
                            rookPos += 56;
                            targetPos += 56;
                        }

                        uint8_t ok = board[rookPos] == SCL_pieceToColor('r', isWhite);

                        if(!ok) continue;

                        int8_t inc = 1 - 2 * (targetPos > rookPos);

                        while(targetPos != rookPos) // check vacant squares for the rook
                        {
                            if(board[targetPos] != '.' && targetPos != pieceSquare) {
                                ok = 0;
                                break;
                            }

                            targetPos += inc;
                        }

                        if(!ok) continue;

                        targetPos = i == 0 ? 6 : 2;

                        if(!isWhite) targetPos += 56;

                        inc = 1 - 2 * (targetPos > pieceSquare);

                        while(targetPos != pieceSquare) // check squares for the king
                        {
                            if((board[targetPos] != '.' && targetPos != rookPos) ||
                               SCL_boardSquareAttacked(board, targetPos, !isWhite)) {
                                ok = 0;
                                break;
                            }

                            targetPos += inc;
                        }

                        if(ok) SCL_squareSetAdd(result, rookPos);
                    }
#endif
            }
        }
    } break;

    default:
        break;
    }
}

void SCL_printSquareSet(SCL_SquareSet set, SCL_PutCharFunction putCharFunc) {
    uint8_t first = 1;

    putCharFunc('(');

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i) {
        if(!SCL_squareSetContains(set, i)) continue;

        if(!first)
            putCharFunc(',');
        else
            first = 0;

        putCharFunc('A' + i % 8);
        putCharFunc('1' + i / 8);
    }

    putCharFunc(')');
}

void SCL_printSquareUTF8(uint8_t square, SCL_PutCharFunction putCharFunc) {
    uint32_t val = 0;

    switch(square) {
    case 'r':
        val = 0x9c99e200;
        break;
    case 'n':
        val = 0x9e99e200;
        break;
    case 'b':
        val = 0x9d99e200;
        break;
    case 'q':
        val = 0x9b99e200;
        break;
    case 'k':
        val = 0x9a99e200;
        break;
    case 'p':
        val = 0x9f99e200;
        break;
    case 'R':
        val = 0x9699e200;
        break;
    case 'N':
        val = 0x9899e200;
        break;
    case 'B':
        val = 0x9799e200;
        break;
    case 'Q':
        val = 0x9599e200;
        break;
    case 'K':
        val = 0x9499e200;
        break;
    case 'P':
        val = 0x9999e200;
        break;
    case '.':
        val = 0x9296e200;
        break;
    case ',':
        val = 0x9196e200;
        break;
    default:
        putCharFunc(square);
        return;
        break;
    }

    uint8_t count = 4;

    while((val % 256 == 0) && (count > 0)) {
        val /= 256;
        count--;
    }

    while(count > 0) {
        putCharFunc(val % 256);
        val /= 256;
        count--;
    }
}

void SCL_boardGetMoves(SCL_Board board, uint8_t pieceSquare, SCL_SquareSet result) {
    SCL_SquareSet allMoves;

    SCL_squareSetClear(allMoves);

    for(uint8_t i = 0; i < 8; ++i)
        result[i] = 0;

    SCL_boardGetPseudoMoves(board, pieceSquare, 1, allMoves);

    // Now only keep moves that don't lead to one's check:

    SCL_SQUARE_SET_ITERATE_BEGIN(allMoves)

    SCL_MoveUndo undo = SCL_boardMakeMove(board, pieceSquare, iteratedSquare, 'q');

    if(!SCL_boardCheck(board, !SCL_boardWhitesTurn(board)))
        SCL_squareSetAdd(result, iteratedSquare);

    SCL_boardUndoMove(board, undo);

    SCL_SQUARE_SET_ITERATE_END
}

uint8_t SCL_boardDead(SCL_Board board) {
    /*
    This byte represents material by bits:

    MSB _ _ _ _ _ _ _ _ LSB
          | | |   | | \_ white knight
          | | |   |  \__ white bishop on white
          | | |    \____ white bishop on black
          | |  \________ black knight
          |  \__________ black bishop on white
           \____________ black bishop on black
  */
    uint8_t material = 0;

    const char* p = board;

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i) {
        char c = *p;

        switch(c) {
        case 'n':
            material |= 0x01;
            break;
        case 'N':
            material |= 0x10;
            break;
        case 'b':
            material |= (0x02 << (!SCL_squareIsWhite(i)));
            break;
        case 'B':
            material |= (0x20 << (!SCL_squareIsWhite(i)));
            break;
        case 'p':
        case 'P':
        case 'r':
        case 'R':
        case 'q':
        case 'Q':
            return 0; // REMOVE later if more complex check are performed
            break;

        default:
            break;
        }

        p++;
    }

    // TODO: add other checks than only insufficient material

    // possible combinations of insufficient material:

    return (material == 0x00) || // king vs king
           (material == 0x01) || // king and knight vs king
           (material == 0x10) || // king and knight vs king
           (material == 0x02) || // king and bishop vs king
           (material == 0x20) || // king and bishop vs king
           (material == 0x04) || // king and bishop vs king
           (material == 0x40) || // king and bishop vs king
           (material == 0x22) || // king and bishop vs king and bishop (same color)
           (material == 0x44); // king and bishop vs king and bishop (same color)
}

uint8_t SCL_boardGetPosition(SCL_Board board) {
    uint8_t check = SCL_boardCheck(board, SCL_boardWhitesTurn(board));
    uint8_t moves = SCL_boardMovePossible(board);

    if(check)
        return moves ? SCL_POSITION_CHECK : SCL_POSITION_MATE;
    else if(!moves)
        return SCL_POSITION_STALEMATE;

    if(SCL_boardDead(board)) return SCL_POSITION_DEAD;

    return SCL_POSITION_NORMAL;
}

uint8_t SCL_stringToMove(
    const char* moveString,
    uint8_t* resultFrom,
    uint8_t* resultTo,
    char* resultPromotion) {
    char c;

    uint8_t* dst = resultFrom;

    for(uint8_t i = 0; i < 2; ++i) {
        c = *moveString;

        *dst = (c >= 'a') ? (c - 'a') : (c - 'A');

        if(*dst > 7) return 0;

        moveString++;
        c = *moveString;

        *dst += 8 * (c - '1');

        if(*dst > 63) return 0;

        moveString++;

        dst = resultTo;
    }

    c = *moveString;

    if(c < 'A') c = c - 'A' + 'a';

    switch(c) {
    case 'N':
    case 'n':
        *resultPromotion = 'n';
        break;
    case 'B':
    case 'b':
        *resultPromotion = 'b';
        break;
    case 'R':
    case 'r':
        *resultPromotion = 'r';
        break;
    case 'Q':
    case 'q':
    default:
        *resultPromotion = 'q';
        break;
    }

    return 1;
}

void SCL_printBoard(
    SCL_Board board,
    SCL_PutCharFunction putCharFunc,
    SCL_SquareSet highlightSquares,
    uint8_t selectSquare,
    uint8_t format,
    uint8_t offset,
    uint8_t labels,
    uint8_t blackDown) {
    if(labels) {
        for(uint8_t i = 0; i < offset + 2; ++i)
            putCharFunc(' ');

        for(uint8_t i = 0; i < 8; ++i) {
            if((format != SCL_PRINT_FORMAT_COMPACT) && (format != SCL_PRINT_FORMAT_COMPACT_UTF8))
                putCharFunc(' ');

            putCharFunc(blackDown ? ('H' - i) : ('A' + i));
        }

        putCharFunc('\n');
    }

    int8_t i = 7;
    int8_t add = 1;

    if(!blackDown) {
        i = 56;
        add = -1;
    }

    for(int8_t row = 0; row < 8; ++row) {
        for(uint8_t j = 0; j < offset; ++j)
            putCharFunc(' ');

        if(labels) {
            putCharFunc(!blackDown ? ('8' - row) : ('1' + row));
            putCharFunc(' ');
        }

        const char* square = board + i;

        for(int8_t col = 0; col < 8; ++col) {
            switch(format) {
            case SCL_PRINT_FORMAT_COMPACT:
                putCharFunc(
                    (*square == '.') ?
                        (((i != selectSquare) ?
                              (!SCL_squareSetContains(highlightSquares, i) ? *square : '*') :
                              '#')) :
                        *square);
                break;

            case SCL_PRINT_FORMAT_UTF8: {
                char squareChar = SCL_squareIsWhite(i) ? '.' : ',';
                char pieceChar = (*square == '.') ? squareChar : *square;

                if(i == selectSquare) {
                    putCharFunc('(');

                    if(*square == '.')
                        putCharFunc(')');
                    else
                        SCL_printSquareUTF8(pieceChar, putCharFunc);
                } else if(!SCL_squareSetContains(highlightSquares, i)) {
                    SCL_printSquareUTF8(squareChar, putCharFunc);
                    SCL_printSquareUTF8(pieceChar, putCharFunc);
                } else {
                    putCharFunc('[');

                    if(*square == '.')
                        putCharFunc(']');
                    else
                        SCL_printSquareUTF8(*square, putCharFunc);
                }

                break;
            }

            case SCL_PRINT_FORMAT_COMPACT_UTF8:
                SCL_printSquareUTF8(
                    (*square == '.') ?
                        (SCL_squareSetContains(highlightSquares, i) ?
                             '*' :
                             (i == selectSquare ? '#' : ((SCL_squareIsWhite(i) ? '.' : ',')))) :
                        *square,
                    putCharFunc);
                break;

            case SCL_PRINT_FORMAT_NORMAL:
            default: {
                uint8_t c = *square;

                char squareColor = SCL_squareIsWhite(i) ? ' ' : ':';

                putCharFunc(
                    (i != selectSquare) ?
                        (!SCL_squareSetContains(highlightSquares, i) ? squareColor : '#') :
                        '@');

                putCharFunc(c == '.' ? squareColor : *square);
                break;
            }
            }

            i -= add;
            square -= add;
        }

        putCharFunc('\n');

        i += add * 16;
    } // for rows
}

int16_t SCL_pieceValuePositive(char piece) {
    switch(piece) {
    case 'p':
    case 'P':
        return SCL_VALUE_PAWN;
        break;
    case 'n':
    case 'N':
        return SCL_VALUE_KNIGHT;
        break;
    case 'b':
    case 'B':
        return SCL_VALUE_BISHOP;
        break;
    case 'r':
    case 'R':
        return SCL_VALUE_ROOK;
        break;
    case 'q':
    case 'Q':
        return SCL_VALUE_QUEEN;
        break;
    case 'k':
    case 'K':
        return SCL_VALUE_KING;
        break;
    default:
        break;
    }

    return 0;
}

int16_t SCL_pieceValue(char piece) {
    switch(piece) {
    case 'P':
        return SCL_VALUE_PAWN;
        break;
    case 'N':
        return SCL_VALUE_KNIGHT;
        break;
    case 'B':
        return SCL_VALUE_BISHOP;
        break;
    case 'R':
        return SCL_VALUE_ROOK;
        break;
    case 'Q':
        return SCL_VALUE_QUEEN;
        break;
    case 'K':
        return SCL_VALUE_KING;
        break;
    case 'p':
        return -1 * SCL_VALUE_PAWN;
        break;
    case 'n':
        return -1 * SCL_VALUE_KNIGHT;
        break;
    case 'b':
        return -1 * SCL_VALUE_BISHOP;
        break;
    case 'r':
        return -1 * SCL_VALUE_ROOK;
        break;
    case 'q':
        return -1 * SCL_VALUE_QUEEN;
        break;
    case 'k':
        return -1 * SCL_VALUE_KING;
        break;
    default:
        break;
    }

    return 0;
}

#define ATTACK_BONUS          3
#define MOBILITY_BONUS        10
#define CENTER_BONUS          7
#define CHECK_BONUS           5
#define KING_CASTLED_BONUS    30
#define KING_BACK_BONUS       15
#define KING_NOT_CENTER_BONUS 15
#define PAWN_NON_DOUBLE_BONUS 3
#define PAWN_PAIR_BONUS       3
#define KING_CENTERNESS       10

int16_t _SCL_rateKingEndgamePosition(uint8_t position) {
    int16_t result = 0;
    uint8_t rank = position / 8;
    position %= 8;

    if(position > 1 && position < 6) result += KING_CENTERNESS;

    if(rank > 1 && rank < 6) result += KING_CENTERNESS;

    return result;
}

int16_t SCL_boardEvaluateStatic(SCL_Board board) {
    uint8_t position = SCL_boardGetPosition(board);

    int16_t total = 0;

    switch(position) {
    case SCL_POSITION_MATE:
        return SCL_boardWhitesTurn(board) ? -1 * SCL_EVALUATION_MAX_SCORE :
                                            SCL_EVALUATION_MAX_SCORE;
        break;

    case SCL_POSITION_STALEMATE:
    case SCL_POSITION_DEAD:
        return 0;
        break;

        /*
      main points are assigned as follows:
      - points for material as a sum of all material on board
      - for playing side: if a piece attacks piece of greater value, a fraction
        of the value difference is gained (we suppose exchange), this is only
        gained once per every attacking piece (maximum gain is taken), we only
        take fraction so that actually taking the piece is favored
      - ATTACK_BONUS points for any attacked piece

      other points are assigned as follows (in total these shouldn't be more
      than the value of one pawn)
      - mobility: MOBILITY_BONUS points for each piece with at least 4 possible
        moves
      - center control: CENTER_BONUS points for a piece on a center square
      - CHECK_BONUS points for check
      - king:
        - safety (non endgame): KING_BACK_BONUS points for king on staring rank,
          additional KING_CASTLED_BONUS if the kind if on castled square or
          closer to the edge, additional KING_NOT_CENTER_BONUS for king not on
          its start neighbouring center square
        - center closeness (endgame): up to 2 * KING_CENTERNESS points for
          being closer to center
      - non-doubled pawns: PAWN_NON_DOUBLE_BONUS points for each pawn without
        same color pawn directly in front of it 
      - pawn structure: PAWN_PAIR_BONUS points for each pawn guarding own pawn
      - advancing pawns: 1 point for each pawn's rank in its move
        direction
    */

    case SCL_POSITION_CHECK:
        total += SCL_boardWhitesTurn(board) ? -1 * CHECK_BONUS : CHECK_BONUS;
        /* FALLTHROUGH */
    case SCL_POSITION_NORMAL:
    default: {
        SCL_SquareSet moves;

        const char* p = board;

        int16_t positiveMaterial = 0;
        uint8_t endgame = 0;

        // first count material to see if this is endgame or not
        for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, ++p) {
            char s = *p;

            if(s != '.') {
                positiveMaterial += SCL_pieceValuePositive(s);
                total += SCL_pieceValue(s);
            }
        }

        endgame = positiveMaterial <= SCL_ENDGAME_MATERIAL_LIMIT;

        p = board;

        for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, ++p) {
            char s = *p;

            if(s != '.') {
                uint8_t white = SCL_pieceIsWhite(s);

                switch(s) {
                case 'k': // king safety
                    if(endgame)
                        total -= _SCL_rateKingEndgamePosition(i);
                    else if(i >= 56) {
                        total -= KING_BACK_BONUS;

                        if(i != 59) {
                            total -= KING_NOT_CENTER_BONUS;

                            if(i >= 62 || i <= 58) total -= KING_CASTLED_BONUS;
                        }
                    }
                    break;

                case 'K':
                    if(endgame)
                        total += _SCL_rateKingEndgamePosition(i);
                    else if(i <= 7) {
                        total += KING_BACK_BONUS;

                        if(i != 3) {
                            total += KING_NOT_CENTER_BONUS;

                            if(i <= 2 || i >= 6) total += KING_CASTLED_BONUS;
                        }
                    }
                    break;

                case 'P': // pawns
                case 'p': {
                    int8_t rank = i / 8;

                    if(rank != 0 && rank != 7) {
                        if(s == 'P') {
                            total += rank;

                            char* tmp = board + i + 8;

                            if(*tmp != 'P') total += PAWN_NON_DOUBLE_BONUS;

                            if(i % 8 != 7) {
                                tmp++;

                                if(*tmp == 'P') total += PAWN_PAIR_BONUS;

                                if(*(tmp - 16) == 'P') total += PAWN_PAIR_BONUS;
                            }
                        } else {
                            total -= 7 - rank;

                            char* tmp = board + i - 8;

                            if(*tmp != 'p') total -= PAWN_NON_DOUBLE_BONUS;

                            if(i % 8 != 7) {
                                tmp += 17;

                                if(*tmp == 'p') total -= PAWN_PAIR_BONUS;

                                if(*(tmp - 16) == 'p') total -= PAWN_PAIR_BONUS;
                            }
                        }
                    }

                    break;
                }

                default:
                    break;
                }

                if(i >= 27 && i <= 36 && (i >= 35 || i <= 28)) // center control
                    total += white ? CENTER_BONUS : (-1 * CENTER_BONUS);

                // for performance we only take pseudo moves
                SCL_boardGetPseudoMoves(board, i, 0, moves);

                if(SCL_squareSetSize(moves) >= 4) // mobility
                    total += white ? MOBILITY_BONUS : (-1 * MOBILITY_BONUS);

                int16_t exchangeBonus = 0;

                SCL_SQUARE_SET_ITERATE_BEGIN(moves)

                if(board[iteratedSquare] != '.') {
                    total += white ? ATTACK_BONUS : (-1 * ATTACK_BONUS);

                    if(SCL_boardWhitesTurn(board) == white) {
                        int16_t valueDiff = SCL_pieceValuePositive(board[iteratedSquare]) -
                                            SCL_pieceValuePositive(s);

                        valueDiff /= 4; // only take a fraction to favor taking

                        if(valueDiff > exchangeBonus) exchangeBonus = valueDiff;
                    }
                }

                SCL_SQUARE_SET_ITERATE_END

                if(exchangeBonus != 0) total += white ? exchangeBonus : -1 * exchangeBonus;
            }
        } // for each square

        return total;

        break;

    } // normal position
    } // switch

    return 0;
}

#undef ATTACK_BONUS
#undef MOBILITY_BONUS
#undef CENTER_BONUS
#undef CHECK_BONUS
#undef KING_CASTLED_BONUS
#undef KING_BACK_BONUS
#undef PAWN_NON_DOUBLE_BONUS
#undef PAWN_PAIR_BONUS
#undef KING_CENTERNESS

SCL_StaticEvaluationFunction _SCL_staticEvaluationFunction;
int16_t _SCL_currentEval;
int8_t _SCL_depthHardLimit;

/**
  Inner recursive function for SCL_boardEvaluateDynamic. It is passed a square
  (or -1) at which last capture happened, to implement capture extension.
*/
int16_t _SCL_boardEvaluateDynamic(
    SCL_Board board,
    int8_t depth,
    int16_t alphaBeta,
    int8_t takenSquare) {
#if defined(SCL_COUNT_EVALUATED_POSITIONS) && SCL_COUNT_EVALUATED_POSITIONS
    SCL_positionsEvaluated++;
#endif

#if SCL_CALL_WDT_RESET
    wdt_reset();
#endif

    uint8_t whitesTurn = SCL_boardWhitesTurn(board);
    int8_t valueMultiply = whitesTurn ? 1 : -1;
    int16_t bestMoveValue = -1 * SCL_EVALUATION_MAX_SCORE;
    uint8_t shouldCompute = depth > 0;
    uint8_t extended = 0;
    uint8_t positionType = SCL_boardGetPosition(board);

    if(!shouldCompute) {
        /* here we do two extensions (deeper search): taking on a same square 
      (exchanges) and checks (good for mating and preventing mates): */
        extended = (depth > _SCL_depthHardLimit) &&
                   (takenSquare >= 0 || (SCL_boardGetPosition(board) == SCL_POSITION_CHECK));

        shouldCompute = extended;
    }

#if SCL_DEBUG_AI
    char moveStr[8];
    uint8_t debugFirst = 1;
#endif

    if(shouldCompute &&
       (positionType == SCL_POSITION_NORMAL || positionType == SCL_POSITION_CHECK)) {
#if SCL_DEBUG_AI
        putchar('(');
#endif

        alphaBeta *= valueMultiply;
        uint8_t end = 0;
        const char* b = board;

        depth--;

        for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, ++b) {
            char s = *b;

            if(s != '.' && SCL_pieceIsWhite(s) == whitesTurn) {
                SCL_SquareSet moves;

                SCL_squareSetClear(moves);

                SCL_boardGetMoves(board, i, moves);

                if(!SCL_squareSetEmpty(moves)) {
                    SCL_SQUARE_SET_ITERATE_BEGIN(moves)

                    int8_t captureExtension = -1;

                    if(board[iteratedSquare] != '.' && // takes a piece
                       (takenSquare == -1 || // extend on first taken sq.
                        (extended && takenSquare != -1) || // ignore check extension
                        (iteratedSquare == takenSquare))) // extend on same sq. taken
                        captureExtension = iteratedSquare;

                    SCL_MoveUndo undo = SCL_boardMakeMove(board, i, iteratedSquare, 'q');

                    uint8_t s0Dummy, s1Dummy;
                    char pDummy;

                    SCL_UNUSED(s0Dummy);
                    SCL_UNUSED(s1Dummy);
                    SCL_UNUSED(pDummy);

#if SCL_DEBUG_AI
                    if(debugFirst)
                        debugFirst = 0;
                    else
                        putchar(',');

                    if(extended) putchar('*');

                    printf("%s ", SCL_moveToString(board, i, iteratedSquare, 'q', moveStr));
#endif

                    int16_t value = _SCL_boardEvaluateDynamic(
                                        board,
                                        depth, // this is depth - 1, we decremented it
#if SCL_ALPHA_BETA
                                        valueMultiply * bestMoveValue,
#else
                                        0,
#endif
                                        captureExtension) *
                                    valueMultiply;

                    SCL_boardUndoMove(board, undo);

                    if(value > bestMoveValue) {
                        bestMoveValue = value;

#if SCL_ALPHA_BETA
                        // alpha-beta pruning:

                        if(value > alphaBeta) // no, >= can't be here
                        {
                            end = 1;
                            iterationEnd = 1;
                        }
#endif
                    }

                    SCL_SQUARE_SET_ITERATE_END
                } // !squre set empty?
            } // valid piece?

            if(end) break;

        } // for each square

#if SCL_DEBUG_AI
        putchar(')');
#endif
    } else // don't dive recursively, evaluate statically
    {
        bestMoveValue = valueMultiply *
#ifndef SCL_EVALUATION_FUNCTION
                        _SCL_staticEvaluationFunction(board);
#else
                        SCL_EVALUATION_FUNCTION(board);
#endif

        /* For stalemate return the opposite value of the board, i.e. if the
       position is good for white, then stalemate is good for black and vice
       versa. */
        if(positionType == SCL_POSITION_STALEMATE) bestMoveValue *= -1;
    }

    /* Here we either improve (if the move worsens the situation) or devalve (if
     it improves the situation) the result: this needs to be done so that good
     moves far away are seen as worse compared to equally good moves achieved
     in fewer moves. Without this an AI in winning situation may just repeat
     random moves and draw by repetition even if it has mate in 1 (it sees all
     moves as leading to mate). */
    bestMoveValue += bestMoveValue > _SCL_currentEval * valueMultiply ? -1 : 1;

#if SCL_DEBUG_AI
    printf("%d", bestMoveValue * valueMultiply);
#endif

    return bestMoveValue * valueMultiply;
}

int16_t SCL_boardEvaluateDynamic(
    SCL_Board board,
    uint8_t baseDepth,
    uint8_t extensionExtraDepth,
    SCL_StaticEvaluationFunction evalFunction) {
    _SCL_staticEvaluationFunction = evalFunction;
    _SCL_currentEval = evalFunction(board);
    _SCL_depthHardLimit = 0;
    _SCL_depthHardLimit -= extensionExtraDepth;

    return _SCL_boardEvaluateDynamic(
        board,
        baseDepth,
        SCL_boardWhitesTurn(board) ? SCL_EVALUATION_MAX_SCORE : (-1 * SCL_EVALUATION_MAX_SCORE),
        -1);
}

void SCL_boardRandomMove(
    SCL_Board board,
    SCL_RandomFunction randFunc,
    uint8_t* squareFrom,
    uint8_t* squareTo,
    char* resultProm) {
    *resultProm = (randFunc() < 128) ? ((randFunc() < 128) ? 'r' : 'n') :
                                       ((randFunc() < 128) ? 'b' : 'q');

    SCL_SquareSet set;
    uint8_t white = SCL_boardWhitesTurn(board);
    const char* s = board;

    SCL_squareSetClear(set);

    // find squares with pieces that have legal moves

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, ++s) {
        char c = *s;

        if(c != '.' && SCL_pieceIsWhite(c) == white) {
            SCL_SquareSet moves;

            SCL_boardGetMoves(board, i, moves);

            if(SCL_squareSetSize(moves) != 0) SCL_squareSetAdd(set, i);
        }
    }

    *squareFrom = SCL_squareSetGetRandom(set, randFunc);

    SCL_boardGetMoves(board, *squareFrom, set);

    *squareTo = SCL_squareSetGetRandom(set, randFunc);
}

void SCL_printBoardSimple(
    SCL_Board board,
    SCL_PutCharFunction putCharFunc,
    uint8_t selectSquare,
    uint8_t format) {
    SCL_SquareSet s;

    SCL_squareSetClear(s);

    SCL_printBoard(board, putCharFunc, s, selectSquare, format, 1, 1, 0);
}

int16_t SCL_getAIMove(
    SCL_Board board,
    uint8_t baseDepth,
    uint8_t extensionExtraDepth,
    uint8_t endgameExtraDepth,
    SCL_StaticEvaluationFunction evalFunc,
    SCL_RandomFunction randFunc,
    uint8_t randomness,
    uint8_t repetitionMoveFrom,
    uint8_t repetitionMoveTo,
    uint8_t* resultFrom,
    uint8_t* resultTo,
    char* resultProm) {
#if SCL_DEBUG_AI
    puts("===== AI debug =====");
    putchar('(');
    unsigned char debugFirst = 1;
    char moveStr[8];
#endif

    if(baseDepth == 0) {
        SCL_boardRandomMove(board, randFunc, resultFrom, resultTo, resultProm);
#ifndef SCL_EVALUATION_FUNCTION
        return evalFunc(board);
#else
        return SCL_EVALUATION_FUNCTION(board);
#endif
    }

    if(SCL_boardEstimatePhase(board) == SCL_PHASE_ENDGAME) baseDepth += endgameExtraDepth;

    *resultFrom = 0;
    *resultTo = 0;
    *resultProm = 'q';

    int16_t bestScore = SCL_boardWhitesTurn(board) ? -1 * SCL_EVALUATION_MAX_SCORE - 1 :
                                                     (SCL_EVALUATION_MAX_SCORE + 1);

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i)
        if(board[i] != '.' && SCL_boardWhitesTurn(board) == SCL_pieceIsWhite(board[i])) {
            SCL_SquareSet moves;

            SCL_squareSetClear(moves);

            SCL_boardGetMoves(board, i, moves);

            SCL_SQUARE_SET_ITERATE_BEGIN(moves)

            int16_t score = 0;

#if SCL_DEBUG_AI
            if(debugFirst)
                debugFirst = 0;
            else
                putchar(',');

            printf("%s ", SCL_moveToString(board, i, iteratedSquare, 'q', moveStr));

#endif

            if(i != repetitionMoveFrom || iteratedSquare != repetitionMoveTo) {
                SCL_MoveUndo undo = SCL_boardMakeMove(board, i, iteratedSquare, 'q');

                score =
                    SCL_boardEvaluateDynamic(board, baseDepth - 1, extensionExtraDepth, evalFunc);

                SCL_boardUndoMove(board, undo);
            }

            if(randFunc != 0 && randomness > 1 && score < 16000 && score > -16000) {
                /*^ We limit randomizing by about half the max score for two reasons:
            to prevent over/under flows and secondly we don't want to alter
            the highest values for checkmate -- these are modified by tiny
            values depending on their depth so as to prevent endless loops in
            which most moves are winning, biasing such values would completely
            kill that algorithm */

                int16_t bias = randFunc();
                bias = (bias - 128) / 2;
                bias *= randomness - 1;
                score += bias;
            }

            uint8_t comparison = score == bestScore;

            if((comparison != 1) && ((SCL_boardWhitesTurn(board) && score > bestScore) ||
                                     (!SCL_boardWhitesTurn(board) && score < bestScore)))
                comparison = 2;

            uint8_t replace = 0;

            if(randFunc == 0)
                replace = comparison == 2;
            else
                replace =
                    (comparison == 2) ||
                    ((comparison == 1) && (randFunc() < 160)); // not uniform distr. but simple

            if(replace) {
                *resultFrom = i;
                *resultTo = iteratedSquare;
                bestScore = score;
            }

            SCL_SQUARE_SET_ITERATE_END
        }

#if SCL_DEBUG_AI
    printf(")%d %s\n", bestScore, SCL_moveToString(board, *resultFrom, *resultTo, 'q', moveStr));
    puts("===== AI debug end ===== ");
#endif

    return bestScore;
}

uint8_t SCL_boardToFEN(SCL_Board board, char* string) {
    uint8_t square = 56;
    uint8_t spaces = 0;
    uint8_t result = 0;

#define put(c)         \
    {                  \
        *string = (c); \
        string++;      \
        result++;      \
    }

    while(1) // pieces
    {
        char s = board[square];

        if(s == '.') {
            spaces++;
        } else {
            if(spaces != 0) {
                put('0' + spaces) spaces = 0;
            }

            put(s)
        }

        square++;

        if(square % 8 == 0) {
            if(spaces != 0) {
                put('0' + spaces) spaces = 0;
            }

            if(square == 8) break;

            put('/');

            square -= 16;
        }
    }

    put(' ');
    put(SCL_boardWhitesTurn(board) ? 'w' : 'b');
    put(' ');

    uint8_t b = board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & 0xf0;

    if(b != 0) // castling
    {
        if(b & 0x10) put('K');
        if(b & 0x20) put('Q');
        if(b & 0x40) put('k');
        if(b & 0x80) put('q');
    } else
        put('-');

    put(' ');

    b = board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] & 0x0f;

    if(b < 8) {
        put('a' + b);
        put(SCL_boardWhitesTurn(board) ? '6' : '3');
    } else
        put('-');

    for(uint8_t i = 0; i < 2; ++i) {
        put(' ');

        uint8_t moves = i == 0 ? ((uint8_t)board[SCL_BOARD_MOVE_COUNT_BYTE]) :
                                 (((uint8_t)board[SCL_BOARD_PLY_BYTE]) / 2 + 1);

        uint8_t hundreds = moves / 100;
        uint8_t tens = (moves % 100) / 10;

        if(hundreds != 0) {
            put('0' + hundreds);
            put('0' + tens);
        } else if(tens != 0)
            put('0' + tens);

        put('0' + moves % 10);
    }

    *string = 0; // terminate the string

    return result + 1;

#undef put
}

uint8_t SCL_boardFromFEN(SCL_Board board, const char* string) {
    uint8_t square = 56;

    while(1) {
        char c = *string;

        if(c == 0) return 0;

        if(c != '/' && c != ' ') // ignore line separators
        {
            if(c < '9') // empty square sequence
            {
                while(c > '0') {
                    board[square] = '.';
                    square++;
                    c--;
                }
            } else // piece
            {
                board[square] = c;
                square++;
            }
        } else {
            if(square == 8) break;

            square -= 16;
        }

        string++;
    }

#define nextChar \
    string++;    \
    if(*string == 0) return 0;

    nextChar // space

        board[SCL_BOARD_PLY_BYTE] = *string == 'b';
    nextChar

        nextChar // space

            uint8_t castleEnPassant = 0x0;

    while(*string != ' ') {
        switch(*string) {
        case 'K':
            castleEnPassant |= 0x10;
            break;
        case 'Q':
            castleEnPassant |= 0x20;
            break;
        case 'k':
            castleEnPassant |= 0x40;
            break;
        case 'q':
            castleEnPassant |= 0x80;
            break;
        default:
            castleEnPassant |= 0xf0;
            break; // for partial XFEN compat.
        }

        nextChar
    }

    nextChar // space

        if(*string != '-') {
        castleEnPassant |= *string - 'a';
        nextChar
    }
    else castleEnPassant |= 0x0f;

    nextChar

        board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] = castleEnPassant;

    for(uint8_t i = 0; i < 2; ++i) {
        nextChar // space

            uint8_t ply = 0;

        while(1) {
            char c = *string;

            if(c < '0' || c > '9') break;

            ply = ply * 10 + (c - '0');

            string++;
        }

        if(i == 0 && *string == 0) return 0;

        if(i == 0)
            board[SCL_BOARD_MOVE_COUNT_BYTE] = ply;
        else
            board[SCL_BOARD_PLY_BYTE] += (ply - 1) * 2;
    }

#if SCL_960_CASTLING
    _SCL_board960RememberRookPositions(board);
#endif

    return 1;
#undef nextChar
}

uint8_t SCL_boardEstimatePhase(SCL_Board board) {
    uint16_t totalMaterial = 0;

    uint8_t ply = board[SCL_BOARD_PLY_BYTE];

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i) {
        char s = *board;

        if(s != '.') {
            int16_t v = SCL_pieceValue(s);

            if(!SCL_pieceIsWhite(s)) v *= -1;

            totalMaterial += v;
        }

        board++;
    }

    if(totalMaterial < SCL_ENDGAME_MATERIAL_LIMIT) return SCL_PHASE_ENDGAME;

    if(ply <= 10 && (totalMaterial >= SCL_START_MATERIAL - 3 * SCL_VALUE_PAWN))
        return SCL_PHASE_OPENING;

    return SCL_PHASE_MIDGAME;
}

#define SCL_IMAGE_COUNT 12

static const uint8_t SCL_images[8 * SCL_IMAGE_COUNT] = {
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81,
    0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0xe7, 0xf7,
    0xf7, 0xaa, 0xff, 0xbd, 0xe7, 0xf7, 0xf7, 0xaa, 0xff, 0xc3, 0xc3, 0xe3, 0xc1, 0x80,
    0xff, 0x99, 0xdb, 0xeb, 0xc9, 0x94, 0xe7, 0xc3, 0x81, 0xc1, 0x94, 0x80, 0xe7, 0xdb,
    0xbd, 0xdd, 0xbe, 0xbe, 0xc3, 0xc3, 0x91, 0xe3, 0x80, 0x80, 0xdb, 0x99, 0x8d, 0xeb,
    0xaa, 0xbe, 0xc3, 0x81, 0xe1, 0xc1, 0xc1, 0xc1, 0xdb, 0xbd, 0xdd, 0xe3, 0xdd, 0xdd,
    0x81, 0x81, 0xc1, 0x9c, 0xc1, 0xc1, 0x81, 0x81, 0xc1, 0x9c, 0xc1, 0xc1};

void SCL_drawBoard(
    SCL_Board board,
    SCL_PutPixelFunction putPixel,
    uint8_t selectedSquare,
    SCL_SquareSet highlightSquares,
    uint8_t blackDown) {
    uint8_t row = 0;
    uint8_t col = 0;
    uint8_t x = 0;
    uint8_t y = 0;
    uint16_t n = 0;
    uint8_t s = 0;

    uint8_t pictureLine = 0;
    uint8_t loadLine = 1;

    while(row < 8) {
        if(loadLine) {
            s = blackDown ? (row * 8 + (7 - col)) : ((7 - row) * 8 + col);

            char piece = board[s];

            if(piece == '.')
                pictureLine = (y == 4) ? 0xef : 0xff;
            else {
                uint8_t offset = SCL_pieceIsWhite(piece) ? 6 : 0;
                piece = SCL_pieceToColor(piece, 1);

                switch(piece) {
                case 'R':
                    offset += 1;
                    break;
                case 'N':
                    offset += 2;
                    break;
                case 'B':
                    offset += 3;
                    break;
                case 'K':
                    offset += 4;
                    break;
                case 'Q':
                    offset += 5;
                    break;
                default:
                    break;
                }

                pictureLine = SCL_images[y * SCL_IMAGE_COUNT + offset];
            }

            if(SCL_squareSetContains(highlightSquares, s)) pictureLine &= (y % 2) ? 0xaa : 0x55;

            if(s == selectedSquare) pictureLine &= (y == 0 || y == 7) ? 0x00 : ~0x81;

            loadLine = 0;
        }

        putPixel(pictureLine & 0x80, n);
        pictureLine <<= 1;

        n++;
        x++;

        if(x == 8) {
            col++;
            loadLine = 1;
            x = 0;
        }

        if(col == 8) {
            y++;
            col = 0;
            x = 0;
        }

        if(y == 8) {
            row++;
            y = 0;
        }
    }
}

uint32_t SCL_boardHash32(const SCL_Board board) {
    uint32_t result = (board[SCL_BOARD_PLY_BYTE] & 0x01) +
                      (((uint32_t)((uint8_t)board[SCL_BOARD_ENPASSANT_CASTLE_BYTE])) << 24) +
                      board[SCL_BOARD_MOVE_COUNT_BYTE];

    const char* b = board;

    for(uint8_t i = 0; i < SCL_BOARD_SQUARES; ++i, ++b) {
        switch(*b) {
#define C(p, n)                \
    case p:                    \
        result ^= (i + 1) * n; \
        break;
            // the below number are primes
            C('P', 4003)
            C('R', 84673)
            C('N', 93911)
            C('B', 999331)
            C('Q', 909091)
            C('K', 2796203)
            C('p', 4793)
            C('r', 19391)
            C('n', 391939)
            C('b', 108301)
            C('q', 174763)
            C('k', 2474431)
#undef C
        default:
            break;
        }
    }

    // for extra spread of values we swap the low/high parts:
    result = (result >> 16) | (result << 16);

    return result;
}

void SCL_boardDisableCastling(SCL_Board board) {
    board[SCL_BOARD_ENPASSANT_CASTLE_BYTE] &= 0x0f;
}

uint8_t SCL_boardMoveResetsCount(SCL_Board board, uint8_t squareFrom, uint8_t squareTo) {
    return board[squareFrom] == 'P' || board[squareFrom] == 'p' || board[squareTo] != '.';
}

void SCL_printPGN(SCL_Record r, SCL_PutCharFunction putCharFunc, SCL_Board initialState) {
    if(SCL_recordLength(r) == 0) return;

    uint16_t pos = 0;

    SCL_Board board;

    if(initialState != 0)
        for(uint8_t i = 0; i < SCL_BOARD_STATE_SIZE; ++i)
            board[i] = initialState[i];
    else
        SCL_boardInit(board);

    while(1) {
        uint8_t s0, s1;
        char p;

        uint8_t state = SCL_recordGetMove(r, pos, &s0, &s1, &p);

        pos++;

        if(pos % 2) {
            uint8_t move = pos / 2 + 1;

            if(move / 100 != 0) putCharFunc('0' + move / 100);

            if(move / 10 != 0 || move / 100 != 0) putCharFunc('0' + (move % 100) / 10);

            putCharFunc('0' + move % 10);

            putCharFunc('.');
            putCharFunc(' ');
        }

#if !SCL_960_CASTLING
        if((board[s0] == 'K' && s0 == 4 && (s1 == 2 || s1 == 6)) ||
           (board[s0] == 'k' && s0 == 60 && (s1 == 62 || s1 == 58)))
#else
        if((board[s0] == 'K' && board[s1] == 'R') || (board[s0] == 'k' && board[s1] == 'r'))
#endif
        {
            putCharFunc('O');
            putCharFunc('-');
            putCharFunc('O');

#if !SCL_960_CASTLING
            if(s1 == 58 || s1 == 2)
#else
            if((s1 == (board[SCL_BOARD_EXTRA_BYTE] & 0x07)) ||
               (s1 == 56 + (board[SCL_BOARD_EXTRA_BYTE] & 0x07)))
#endif
            {
                putCharFunc('-');
                putCharFunc('O');
            }
        } else {
            uint8_t pawn = board[s0] == 'P' || board[s0] == 'p';

            if(!pawn) {
                putCharFunc(SCL_pieceToColor(board[s0], 1));

                // disambiguation:

                uint8_t specify = 0;

                for(int i = 0; i < SCL_BOARD_SQUARES; ++i)
                    if(i != s0 && board[i] == board[s0]) {
                        SCL_SquareSet s;

                        SCL_squareSetClear(s);

                        SCL_boardGetMoves(board, i, s);

                        if(SCL_squareSetContains(s, s1)) specify |= (s0 % 8 != s1 % 8) ? 1 : 2;
                    }

                if(specify & 0x01) putCharFunc('a' + s0 % 8);

                if(specify & 0x02) putCharFunc('1' + s0 / 8);
            }

            if(board[s1] != '.' || (pawn && s0 % 8 != s1 % 8 && board[s1] == '.')) // capture?
            {
                if(pawn) putCharFunc('a' + s0 % 8);

                putCharFunc('x');
            }

            putCharFunc('a' + s1 % 8);
            putCharFunc('1' + s1 / 8);

            if(pawn && (s1 >= 56 || s1 <= 7)) // promotion?
            {
                putCharFunc('=');
                putCharFunc(SCL_pieceToColor(p, 1));
            }
        }

        SCL_boardMakeMove(board, s0, s1, p);

        uint8_t position = SCL_boardGetPosition(board);

        if(position == SCL_POSITION_CHECK) putCharFunc('+');

        if(position == SCL_POSITION_MATE) {
            putCharFunc('#');
            break;
        } else if(state != SCL_RECORD_CONT) {
            putCharFunc('*');
            break;
        }

        putCharFunc(' ');
    }
}

void SCL_recordCopy(SCL_Record recordFrom, SCL_Record recordTo) {
    for(uint16_t i = 0; i < SCL_RECORD_MAX_SIZE; ++i)
        recordTo[i] = recordFrom[i];
}

void SCL_gameInit(SCL_Game* game, const SCL_Board startState) {
    game->startState = startState;

    if(startState != 0)
        SCL_boardCopy(startState, game->board);
    else
        SCL_boardInit(game->board);

    SCL_recordInit(game->record);

    for(uint8_t i = 0; i < 14; ++i)
        game->prevMoves[i] = 0;

    game->state = SCL_GAME_STATE_PLAYING;
    game->ply = 0;

    SCL_recordInit(game->record);
}

uint8_t SCL_gameGetRepetiotionMove(SCL_Game* game, uint8_t* squareFrom, uint8_t* squareTo) {
    if(squareFrom != 0 && squareTo != 0) {
        *squareFrom = 0;
        *squareTo = 0;
    }

    /*  pos. 1st         2nd         3rd
            |           |           |
            v           v           v       
             01 23 45 67 89 AB CD EF
     move    ab cd ba dc ab cd ba dc */

    if(game->ply >= 7 && game->prevMoves[0] == game->prevMoves[5] &&
       game->prevMoves[0] == game->prevMoves[8] && game->prevMoves[0] == game->prevMoves[13] &&

       game->prevMoves[1] == game->prevMoves[4] && game->prevMoves[1] == game->prevMoves[9] &&
       game->prevMoves[1] == game->prevMoves[12] &&

       game->prevMoves[2] == game->prevMoves[7] && game->prevMoves[2] == game->prevMoves[10] &&

       game->prevMoves[3] == game->prevMoves[6] && game->prevMoves[3] == game->prevMoves[11]) {
        if(squareFrom != 0 && squareTo != 0) {
            *squareFrom = game->prevMoves[3];
            *squareTo = game->prevMoves[2];
        }

        return 1;
    }

    return 0;
}

void SCL_gameMakeMove(SCL_Game* game, uint8_t squareFrom, uint8_t squareTo, char promoteTo) {
    uint8_t repetitionS0, repetitionS1;

    SCL_gameGetRepetiotionMove(game, &repetitionS0, &repetitionS1);
    SCL_boardMakeMove(game->board, squareFrom, squareTo, promoteTo);
    SCL_recordAdd(game->record, squareFrom, squareTo, promoteTo, SCL_RECORD_CONT);
    // ^ TODO: SCL_RECORD_CONT

    game->ply++;

    for(uint8_t i = 0; i < 14 - 2; ++i)
        game->prevMoves[i] = game->prevMoves[i + 2];

    game->prevMoves[12] = squareFrom;
    game->prevMoves[13] = squareTo;

    if(squareFrom == repetitionS0 && squareTo == repetitionS1)
        game->state = SCL_GAME_STATE_DRAW_REPETITION;
    else if(game->board[SCL_BOARD_MOVE_COUNT_BYTE] >= 50)
        game->state = SCL_GAME_STATE_DRAW_50;
    else {
        uint8_t position = SCL_boardGetPosition(game->board);

        switch(position) {
        case SCL_POSITION_MATE:
            game->state = SCL_boardWhitesTurn(game->board) ? SCL_GAME_STATE_BLACK_WIN :
                                                             SCL_GAME_STATE_WHITE_WIN;
            break;

        case SCL_POSITION_STALEMATE:
            game->state = SCL_GAME_STATE_DRAW_STALEMATE;
            break;

        case SCL_POSITION_DEAD:
            game->state = SCL_GAME_STATE_DRAW_DEAD;
            break;

        default:
            break;
        }
    }
}

uint8_t SCL_gameUndoMove(SCL_Game* game) {
    if(game->ply == 0) return 0;

    if((game->ply - 1) > SCL_recordLength(game->record)) return 0; // can't undo, lacking record

    SCL_Record r;

    SCL_recordCopy(game->record, r);

    uint16_t applyMoves = game->ply - 1;

    SCL_gameInit(game, game->startState);

    for(uint16_t i = 0; i < applyMoves; ++i) {
        uint8_t s0, s1;
        char p;

        SCL_recordGetMove(r, i, &s0, &s1, &p);
        SCL_gameMakeMove(game, s0, s1, p);
    }

    return 1;
}

uint8_t SCL_boardMoveIsLegal(SCL_Board board, uint8_t squareFrom, uint8_t squareTo) {
    if(squareFrom >= SCL_BOARD_SQUARES || squareTo >= SCL_BOARD_SQUARES) return 0;

    char piece = board[squareFrom];

    if((piece == '.') || (SCL_boardWhitesTurn(board) != SCL_pieceIsWhite(piece))) return 0;

    SCL_SquareSet moves;

    SCL_boardGetMoves(board, squareFrom, moves);

    return SCL_squareSetContains(moves, squareTo);
}

#endif // guard