terminal-chess: src/chess/rules.h@02c509a44e98 (annotated)

src/chess/rules.h@02c509a44e98 (annotated)

src/chess/rules.h

Wed, 11 Jun 2014 16:54:20 +0200

author: Mike Becker <universe@uap-core.de>
date: Wed, 11 Jun 2014 16:54:20 +0200
changeset 49: 02c509a44e98
parent 48: 0cedda2544da
child 50: 41017d0a72c5
permissions: -rw-r--r--

logging string representation of moves in short algebraic notation

 /*
  * 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 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;
     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)
 /**
  * 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 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 macros in this file 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 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 */

Mercurial > hg > terminal-chess / annotate

src/chess/rules.h@02c509a44e98 (annotated)

src/chess/rules.h