Mercurial > hg > terminal-chess / file revision

 /*

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * Copyright 2014 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 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 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;

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

     uint8_t mycolor;

     MoveList* movelist;

     MoveList* lastmove;

     _Bool checkmate;

     _Bool stalemate;

 } 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)

 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 one of ROOK, KNIGHT, BISHOP, QUEEN, KING

  * @return character value for the specified piece

  */

 char getpiecechr(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_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

  * @return status code (see rules/rules.h for the list of codes)

  */

 int eval_move(GameState *gamestate, char *mstr, Move *move);

 /**

  * Validates move by applying chess rules.

  * @param gamestate the current game state

  * @param move the move to validate

  * @return TRUE, if the move complies to chess rules, FALSE otherwise

  */

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