src/chess/rules.h

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 Mike Becker. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef RULES_H
#define	RULES_H

#include <stdint.h>
#include <stdbool.h>

#define VALID_MOVE_SYNTAX      0
#define VALID_MOVE_SEMANTICS   0 /* use same code for a success */
#define INVALID_MOVE_SYNTAX    1
#define INVALID_POSITION       2
#define AMBIGUOUS_MOVE         3
#define NEED_PROMOTION         4
#define PIECE_PINNED           5
#define KING_IN_CHECK          6
#define KING_MOVES_INTO_CHECK  7
#define RULES_VIOLATED        10

#define ENPASSANT_THREAT 0x40

#define WHITE 0x10
#define BLACK 0x20
#define opponent_color(color) ((color)==WHITE?BLACK:WHITE)

#define PIECE_MASK 0x0F
#define COLOR_MASK 0x30

#define PAWN   0x01
#define ROOK   0x02
#define KNIGHT 0x03
#define BISHOP 0x04
#define QUEEN  0x05
#define KING   0x06

#define WPAWN   (WHITE|PAWN)
#define WROOK   (WHITE|ROOK)
#define WKNIGHT (WHITE|KNIGHT)
#define WBISHOP (WHITE|BISHOP)
#define WQUEEN  (WHITE|QUEEN)
#define WKING   (WHITE|KING)
#define BPAWN   (BLACK|PAWN)
#define BROOK   (BLACK|ROOK)
#define BKNIGHT (BLACK|KNIGHT)
#define BBISHOP (BLACK|BISHOP)
#define BQUEEN  (BLACK|QUEEN)
#define BKING   (BLACK|KING)

typedef uint8_t Board[8][8];

struct movetimeval {
    uint64_t tv_sec;
    int32_t tv_usec; // important that this is signed b/c potential carry
};

typedef struct {
    uint8_t piece;
    uint8_t fromfile;
    uint8_t fromrow;
    uint8_t tofile;
    uint8_t torow;
    uint8_t promotion;
    uint8_t check;
    uint8_t capture;
    struct movetimeval timestamp;
    struct movetimeval movetime;
    char string[8];
} Move;

typedef struct {
    uint8_t servercolor;
    /** 1: play with timecontrol, 0: play without time control */
    uint8_t timecontrol;
    /** If timecontrol is 1, initial clock time in seconds */
    uint16_t time;
    /** If timecontrol is 1, time added per move in seconds */
    uint16_t addtime;
    /** If timecontrol is 1, delay before the clock starts ticking down */
    uint16_t delay;
} GameInfo;

/** The buffer length for player names in GameState structures. */
#define PLAYER_NAME_BUFLEN 32

typedef struct {
    GameInfo info;
    Board board;
    Move* moves;
    /** optional name of the white player */
    char wname[PLAYER_NAME_BUFLEN];
    /** optional name of the black player */
    char bname[PLAYER_NAME_BUFLEN];
    /** capacity of the move array */
    unsigned movecapacity;
    /** number of (half-)moves (counting BOTH colors) */
    unsigned int movecount;
    /** a premove that shall be evaluated next time it's our turn */
    char premove[8];
    bool checkmate;
    bool stalemate;
    bool threefold;
    bool remis;
    bool wresign;
    bool bresign;
    /** this flag is only supposed to be set when the opponent disconnects */
    bool ragequit;
    bool review;
} GameState;

#define is_game_running(gamestate) !((gamestate)->checkmate || \
    (gamestate)->wresign || (gamestate)->bresign || (gamestate)->threefold || \
    (gamestate)->stalemate || (gamestate)->remis || (gamestate)->review)

#define last_move(gamestate) \
    ((gamestate)->moves[(gamestate)->movecount-1])

#define POS_UNSPECIFIED UINT8_MAX
#define mdst(b,m) b[(m)->torow][(m)->tofile]
#define msrc(b,m) b[(m)->fromrow][(m)->fromfile]

#define isidx(idx) ((uint8_t)(idx) < 8)

#define isfile(file) (file >= 'a' && file <= 'h')
#define isrow(row) (row >= '1' && row <= '8')

#define rowidx(row) (row-'1')
#define fileidx(file) (file-'a')

#define rowchr(row) (row+'1')
#define filechr(file) (file+'a')

#define chkidx_from(move) (isidx((move)->fromfile) && isidx((move)->fromrow))
#define chkidx_to(move) (isidx((move)->tofile) && isidx((move)->torow))
#define chkidx(move) (chkidx_from(move) && chkidx_to(move))

/* secure versions - use, if index is not checked with isidx() */
#define fileidx_s(c) (isfile(c)?fileidx(c):POS_UNSPECIFIED)
#define rowidx_s(c) (isrow(c)?rowidx(c):POS_UNSPECIFIED)


/**
 * Initializes a game state and prepares the chess board.
 * @param gamestate the game state to initialize
 */
void gamestate_init(GameState *gamestate);

/**
 * Cleans up a game state and frees the memory for the movement list.
 * @param gamestate the game state to clean up
 */
void gamestate_cleanup(GameState *gamestate);

/**
 * Maps a character to a piece.
 * 
 * Does not work for pawns, since they don't have a character.
 * 
 * @param c one of R,N,B,Q,K
 * @return numeric value for the specified piece
 */
uint8_t getpiece(char c);

/**
 * Maps a piece to a character.
 * 
 * Does not work for pawns, scince they don't have a character.
 * 
 * @param piece may have color or additional flags
 * @return character value for the specified piece
 */
char getpiecechr(uint8_t piece);

/**
 * Maps a piece to a unicode character sequence.
 * 
 * The returned unicode is for black pieces.
 * You may colorize the output by setting the terminal foreground color.
 * 
 * @param piece the piece to dispaly
 * @return unicode character sequence for the specified piece
 */
char* getpieceunicode(uint8_t piece);

/**
 * Returns the color of the player who is next to move.
 *
 * @param gamestate the current game state
 * @return the color of the player who is next to move
 */
uint8_t current_color(GameState *gamestate);

/**
 * Checks, if a specified field is covered by a piece of a certain color.
 * 
 * The out-parameters may both be NULL, but if any of them is set, the other
 * must be set, too.
 * 
 * @param gamestate the current game state
 * @param row row of the field to check
 * @param file file of the field to check
 * @param color the color of the piece that should threaten the field
 * @param threats the array where to store the threats (should be able to hold
 * the rare maximum of 16 elements)
 * @param threatcount a pointer to an uint8_t where the count of threats is
 * stored
 * @return true, if any piece of the specified color threatens the specified
 * field (i.e. could capture an opponent piece)
 */
bool get_threats(GameState *gamestate, uint8_t row, uint8_t file,
        uint8_t color, Move* threats, uint8_t* threatcount);

/**
 * Checks, if a specified field is covered by a piece of a certain color AND
 * if this piece is not pinned and therefore able to perform the move.
 * 
 * The out-parameters may both be NULL, but if any of them is set, the other
 * must be set, too.
 * 
 * @param gamestate the current game state
 * @param row row of the field to check
 * @param file file of the field to check
 * @param color the color of the piece that should threaten the field
 * @param threats the array where to store the threats (should be able to hold
 * the rare maximum of 16 elements)
 * @param threatcount a pointer to an uint8_t where the count of threats is
 * stored
 * @return true, if any piece of the specified color threatens the specified
 * field (i.e. could capture an opponent piece)
 */
bool get_real_threats(GameState *gamestate, uint8_t row, uint8_t file,
        uint8_t color, Move* threats, uint8_t* threatcount);

/**
 * Checks, if a specified field is covered by a piece of a certain color.
 * 
 * @param gamestate the current game state
 * @param row row of the field to check
 * @param file file of the field to check
 * @param color the color of the piece that should cover the field
 * @return true, if any piece of the specified color threatens the specified
 * field
 */
#define is_covered(gamestate, row, file, color) \
    get_threats(gamestate, row, file, color, NULL, NULL)

/**
 * Checks, if a specified field is attacked by a piece of a certain color.
 * 
 * I.e. the field is covered by a piece AND this piece is not pinned and
 * therefore able to perform the move.
 * 
 * @param gamestate the current game state
 * @param row row of the field to check
 * @param file file of the field to check
 * @param color the color of the piece that should cover the field
 * @return true, if any piece of the specified color threatens the specified
 * field and could capture an opponent piece
 */
#define is_attacked(gamestate, row, file, color) \
    get_real_threats(gamestate, row, file, color, NULL, NULL)

/**
 * Checks, if a specified field is protected by a piece of a certain color.
 * 
 * I.e. the field is covered by a piece that is NOT the king AND this piece is
 * not pinned and therefore able to perform the move.
 * 
 * @param gamestate the current game state
 * @param row row of the field to check
 * @param file file of the field to check
 * @param color the color of the piece that should cover the field
 * @return true, if any piece (excluding the king) of the specified color
 * threatens the specified field and could capture an opponent piece
 */
bool is_protected(GameState *gamestate, uint8_t row, uint8_t file,
        uint8_t color);

/**
 * Checks, if the specified move cannot be performed, because the piece is
 * either pinned or cannot remove the check.
 * 
 * Note: in chess a piece is pinned, when it can't be moved because the move
 * would result in a check position. But this function <u>also</u> returns true,
 * if the king is already in check position and the specified move does not
 * protect the king.
 * 
 * @param gamestate the current game state
 * @param move the move to check
 * @return true, if the move cannot be performed because the king would be in
 * check after the move
 */
bool is_pinned(GameState *gamestate, Move *move);

/**
 * Evaluates a move syntactically and stores the move data in the specified
 * object.
 *
 * When short algebraic notation is used, the source position is determined by
 * the evaluating the allowed moves according to the current game state.
 *
 * For a purely syntactic check, regardless of whether a piece exists that is
 * allowed to move that way, use check_move().
 * 
 * @param gamestate the current game state
 * @param mstr the input string to parse
 * @param move a pointer to object where the move data shall be stored
 * @param color the color of the player to evaluate the move for
 * @return status code (see macros in this file for the list of codes)
 */
int eval_move(GameState *gamestate, char *mstr, Move *move, uint8_t color);

/**
 * Syntactically checks a move without verifying that a piece exists that is
 * allowed to move that way.
 *
 * @param mstr the input string to parse
 * @param color the color of the player to evaluate the move for
 * @return status code (see macros in this file for the list of codes)
 */
int check_move(char *mstr, uint8_t color);

/**
 * Validates move by applying chess rules.
 * @param gamestate the current game state
 * @param move the move to validate
 * @return status code (see macros in this file for the list of codes)
 */
int validate_move(GameState *gamestate, Move *move);

/**
 * Applies a move and deletes captured pieces.
 * 
 * @param gamestate the current game state
 * @param move the move to apply
 */
void apply_move(GameState *gamestate, Move *move);

/**
 * Copies the state of the game at the specified move number.
 *
 * This function is helpful to generate a game state for reviewing past moves.
 *
 * @param gamestate the current game state
 * @param move_number the half-move that would now be played
 * @param replay the struct to populate with the state at the specified move
 */
void gamestate_at_move(GameState *gamestate,
        unsigned move_number, GameState *replay);

/**
 * Returns the remaining time on the clock for the specified
 * half-move number.
 *
 * @param gamestate the current game state
 * @param move_number the half-move that is now going to be played
 * @return the remaining time - if time control is disabled, this function
 * always returns zero
 */
uint16_t remaining_movetime2(GameState *gamestate, unsigned move_number);

/**
 * Returns the remaining time on the clock for the specified player.
 *
 * @param gamestate the current game state
 * @param color either BLACK or WHITE
 * @return the remaining time - if time control is disabled, this function
 * always returns zero
 */
uint16_t remaining_movetime(GameState *gamestate, uint8_t color);

/**
 * Converts clock time to string.
 *
 * @param time the time to format
 * @param str the target buffer (should be at least 10 chars large)
 * @param always_hours if hours should always be printed
 */
int print_clk(uint16_t time, char *str, bool always_hours);

/**
 * Checks if the current position already appeared two times before.
 *
 * This does not set the threefold flag in the game state as this flag is
 * intended to be set only when the game ends after actually claiming a draw.
 *
 * By standard chess rules this is not automatically a draw.
 * But implementation may choose to automatically draw the game anyway.
 *
 * @param gamestate the current game state
 * @return true if the game is in a threefold repetition position
 */
bool check_threefold_repetition(GameState *gamestate);

#endif	/* RULES_H */