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 <sys/time.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 PIECE_MASK       0x0F
#define COLOR_MASK       0x30
#define ENPASSANT_THREAT 0x40

#define WHITE 0x10
#define BLACK 0x20

#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;
};

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 MoveList MoveList;

struct MoveList {
    Move move;
    MoveList* next;
};

    
typedef struct {
    uint8_t servercolor;
    uint8_t timecontrol;
    uint16_t time;
    uint16_t addtime;
} GameInfo;

typedef struct {
    Board board;
    MoveList* movelist;
    MoveList* lastmove;
    unsigned int movecount; /* number of (half-)moves (counting BOTH colors) */
    _Bool checkmate;
    _Bool stalemate;
    _Bool remis;
    _Bool resign;
} GameState;

#define opponent_color(color) ((color)==WHITE?BLACK:WHITE)

#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(move) (isidx((move)->fromfile) && isidx((move)->fromrow) && \
        isidx((move)->tofile) && isidx((move)->torow))

/* 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)

#define is_game_running(gamestate) !((gamestate)->checkmate || \
    (gamestate)->resign || (gamestate)->stalemate || (gamestate)->remis)


/**
 * 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
 */
unsigned char* getpieceunicode(uint8_t piece);

/**
 * 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.
 * 
 * @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);

/**
 * 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);


/**
 * Returns the remaining time on the clock for the specified player.
 *
 * @param gameinfo the information about the game
 * @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(GameInfo *gameinfo, GameState *gamestate,
        uint8_t color);

#endif	/* RULES_H */