terminal-chess: comparison src/game.c

-:2aed5418e142
+:6008840b859e
 #include <ncurses.h>
 #include <string.h>
 static const uint8_t boardx = 10, boardy = 10;
-static void draw_board(Board board, uint8_t mycolor) {
+static uint8_t getpiecechr(uint8_t piece) {
+switch (piece & PIECE_MASK) {
+case ROOK: return 'R';
+case KNIGHT: return 'N';
+case BISHOP: return 'B';
+case QUEEN: return 'Q';
+case KING: return 'K';
+default: return '\0';
+}
+}
+/**
+* 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
+*/
+static uint8_t getpiece(char c) {
+switch (c) {
+case 'R': return ROOK;
+case 'N': return KNIGHT;
+case 'B': return BISHOP;
+case 'Q': return QUEEN;
+case 'K': return KING;
+default: return 0;
+}
+}
+/**
+* Guesses the location of a piece for short algebraic notation.
+*
+* @param board the current state of the board
+* @param move the move date to operate on
+* @return status code (see rules/rules.h for the codes)
+*/
+static int getlocation(Board board, Move *move) {
+uint8_t piece = move->piece & PIECE_MASK;
+switch (piece) {
+case PAWN: return pawn_getlocation(board, move);
+case ROOK: return rook_getlocation(board, move);
+case KNIGHT: return knight_getlocation(board, move);
+case BISHOP: return bishop_getlocation(board, move);
+case QUEEN: return queen_getlocation(board, move);
+case KING: return king_getlocation(board, move);
+default: return INVALID_MOVE_SYNTAX;
+}
+}
+static void draw_board(Board board, MoveListRoot *movelist, uint8_t mycolor) {
 for (uint8_t y = 0 ; y < 8 ; y++) {
 for (uint8_t x = 0 ; x < 8 ; x++) {
 uint8_t col = board[y][x] & COLOR_MASK;
 uint8_t piece = board[y][x] & PIECE_MASK;
-char piecec = ' ';
+char piecec;
-switch (piece) {
+if (piece) {
-case PAWN: piecec = 'P'; break;
+piecec = piece == PAWN ? 'P' : getpiecechr(piece);
-case ROOK: piecec = 'R'; break;
+} else {
-case KNIGHT: piecec = 'N'; break;
+piecec = ' ';
-case BISHOP: piecec = 'B'; break;
-case QUEEN: piecec = 'Q'; break;
-case KING: piecec = 'K'; break;
 }
 attrset((col == WHITE ? A_BOLD : A_DIM) |
 COLOR_PAIR((y&1)==(x&1) ? COL_WB : COL_BW));
 int x = mycolor == WHITE ? boardx+i*3+1 : boardx+22-i*3;
 int y = mycolor == WHITE ? boardy-i : boardy-7+i;
 mvaddch(boardy+1, x, 'a'+i);
 mvaddch(y, boardx-2, '1'+i);
 }
+/* move log */
+// TODO: introduce window to avoid bugs with a long move log
+uint8_t logy = 0;
+const uint8_t logx = boardx + 30;
+int logi = 1;
+MoveList *logelem = movelist->first;
+while (logelem) {
+logi++;
+if (logi % 2 == 0) {
+if ((logi - 2) % 4 == 0) {
+logy++;
+wmove(tchess_window, logy, logx);
+}
+printw("%d. ", logi / 2);
+}
+if (logelem) {
+Move move = logelem->move;
+char logstr[] = {
+getpiecechr(move.piece),
+filechr(move.fromfile), rowchr(move.fromrow),
+move.capture ? 'x':'\0',
+filechr(move.tofile), rowchr(move.torow),
+move.check ? '+' : (move.checkmate ? '#' :
+(move.promotion ? '=' : '\0')),
+move.promotion ? getpiecechr(move.promotion) : '\0',
+' '
+};
+for (int stri = 0 ; stri < sizeof(logstr) ; stri++) {
+if (logstr[stri]) {
+addch(logstr[stri]);
+}
+}
+logelem = logelem->next;
+}
+}
 }
 /**
 * Applies a move and deletes captured pieces.
 *
 (move->fromrow == 1 && move->torow == 3) ||
 (move->fromrow == 6 && move->torow == 4))) {
 move->piece |= ENPASSANT_THREAT;
 }
-/* move (and maybe capture) */
+/* move (and maybe capture or promote) */
 msrc(board, move) = 0;
-mdst(board, move) = move->piece;
+if (move->promotion) {
+mdst(board, move) = move->promotion;
+} else {
+mdst(board, move) = move->piece;
+}
 /* castling */
 if (piece == KING &&
 move->fromfile == fileidx('e')) {
 return result;
 }
 /**
-* 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
-*/
-static uint8_t getpiece(char c) {
-switch (c) {
-case 'R': return ROOK;
-case 'N': return KNIGHT;
-case 'B': return BISHOP;
-case 'Q': return QUEEN;
-case 'K': return KING;
-default: return 0;
-}
-}
-/**
-* Guesses the location of a piece for short algebraic notation.
-*
-* @param board the current state of the board
-* @param move the move date to operate on
-* @return status code (see rules/rules.h for the codes)
-*/
-static int getlocation(Board board, Move *move) {
-uint8_t piece = move->piece & PIECE_MASK;
-switch (piece) {
-case PAWN: return pawn_getlocation(board, move);
-case ROOK: return rook_getlocation(board, move);
-case KNIGHT: return knight_getlocation(board, move);
-case BISHOP: return bishop_getlocation(board, move);
-case QUEEN: return queen_getlocation(board, move);
-case KING: return king_getlocation(board, move);
-default: return INVALID_MOVE_SYNTAX;
-}
-}
-/**
 * Evaluates a move syntactically and stores the move data in the specified
 * object.
 *
 * @param board the current state of the board
 * @param mycolor the color of the current player
 */
 static int eval_move(Board board, uint8_t mycolor, char *mstr, Move *move) {
 memset(move, 0, sizeof(Move));
 move->fromfile = POS_UNSPECIFIED;
 move->fromrow = POS_UNSPECIFIED;
-// TODO: promotion
 size_t len = strlen(mstr);
 /* evaluate check/checkmate flags */
 if (mstr[len-1] == '+') {
 len--; mstr[len] = '\0';
 move->check = TRUE;
 } else if (mstr[len-1] == '#') {
 len--; mstr[len] = '\0';
 move->checkmate = TRUE;
+}
+/* evaluate promotion */
+if (len > 3 && mstr[len-2] == '=') {
+move->promotion = getpiece(mstr[len-1]);
+if (!move->promotion) {
+return INVALID_MOVE_SYNTAX;
+} else {
+move->promotion |= mycolor;
+len -= 2;
+mstr[len] = 0;
+}
 }
 if (len == 2) {
 /* pawn move (e.g. "e4") */
 move->piece = PAWN;
 }
 }
 if (move->piece) {
+if (move->piece == PAWN && move->torow == (mycolor==WHITE?7:0)
+&& !move->promotion) {
+return NEED_PROMOTION;
+}
 move->piece |= mycolor;
 if (move->fromfile == POS_UNSPECIFIED
 || move->fromrow == POS_UNSPECIFIED) {
 return getlocation(board, move);
 } else {
 } else {
 return INVALID_MOVE_SYNTAX;
 }
 }
-static int sendmove(Board board, uint8_t mycolor, int opponent) {
+static int sendmove(Board board, MoveListRoot *movelist,
+uint8_t mycolor, int opponent) {
 const size_t buflen = 8;
 char movestr[buflen];
 _Bool remisrejected = FALSE;
 uint8_t code;
+int inputy = getmaxy(tchess_window) - 6;
 while (1) {
-move(boardy+3, 0);
+move(inputy, 0);
 if (remisrejected) {
 printw(
 "Use chess notation to enter your move.\n"
 "Remis offer rejected - type 'surr' to surrender.      \n\n"
 "Type your move: ");
 }
 } else {
 Move move;
 int eval_result = eval_move(board, mycolor, movestr, &move);
 switch (eval_result) {
 case VALID_MOVE_SYNTAX:
 net_send_code(opponent, NETCODE_MOVE);
 net_send_data(opponent, &move, sizeof(Move));
 code = net_recieve_code(opponent);
 move.check = code == NETCODE_CHECK;
 move.checkmate = code == NETCODE_CHECKMATE;
-// TODO: record move
+addmove(movelist, &move);
 if (code == NETCODE_DECLINE) {
 printw("Invalid move.");
+} else {
+apply_move(board, &move);
+if (move.checkmate) {
+printw("Checkmate!");
+clrtoeol();
+return 1;
 } else {
-apply_move(board, &move);
+return 0;
-if (move.checkmate) {
-printw("Checkmate!");
-clrtoeol();
-return 1;
-} else {
-return 0;
-}
 }
-break;
+}
-case AMBIGUOUS_MOVE:
+break;
-printw("Ambiguous move - "
+case AMBIGUOUS_MOVE:
-"please specify the piece to move.");
+printw("Ambiguous move - please specify the piece to move.");
 break;
 case INVALID_POSITION:
 printw("Cannot find the piece that shall be moved.");
 break;
-default:
+case NEED_PROMOTION:
-printw("Can't interpret move - "
+printw("You need to promote the pawn (append \"=Q\" e.g.)!");
-"please use algebraic notation.");
+break;
+default:
+printw("Can't interpret move - please use algebraic notation.");
 }
 clrtoeol();
 }
 }
 }
-static int recvmove(Board board, int opponent) {
+static int recvmove(Board board, MoveListRoot *movelist, int opponent) {
+int inputy = getmaxy(tchess_window) - 6;
 while (1) {
-move(boardy+3, 0);
+move(inputy, 0);
 printw("Awaiting opponent move...");
 clrtoeol();
 refresh();
 // TODO: nonblocking
 break;
 case NETCODE_MOVE:
 net_recieve_data(opponent, &move, sizeof(Move));
 if (validate_move(board, &move)) {
 apply_move(board, &move);
-// TODO: record move
+addmove(movelist, &move);
 if (move.check) {
 net_send_code(opponent, NETCODE_CHECK);
 } else if (move.checkmate) {
 net_send_code(opponent, NETCODE_CHECKMATE);
 } else {
 }
 }
 }
 }
+void freemovelist(MoveListRoot* list) {
+MoveList *elem;
+elem = list->first;
+while (elem) {
+MoveList *cur = elem;
+elem = elem->next;
+free(cur);
+};
+free(list);
+}
+void addmove(MoveListRoot* list, Move *move) {
+MoveList *elem = malloc(sizeof(MoveList));
+elem->next = NULL;
+elem->move = *move;
+if (list->last) {
+list->last->next = elem;
+list->last = elem;
+} else {
+list->first = list->last = elem;
+}
+}
 void game_start(Settings *settings, int opponent) {
 _Bool myturn = is_server(settings) ==
 (settings->gameinfo.servercolor == WHITE);
 uint8_t mycolor = myturn ? WHITE:BLACK;
 _Bool running;
+MoveListRoot* movelist = calloc(1, sizeof(MoveListRoot));
 Board board = {
 {WROOK, WKNIGHT, WBISHOP, WQUEEN, WKING, WBISHOP, WKNIGHT, WROOK},
 {WPAWN, WPAWN,   WPAWN,   WPAWN,  WPAWN, WPAWN,   WPAWN,   WPAWN},
 {0,     0,       0,       0,      0,     0,       0,       0},
 {BROOK, BKNIGHT, BBISHOP, BQUEEN, BKING, BBISHOP, BKNIGHT, BROOK}
 };
 do {
 clear();
-draw_board(board, mycolor);
+draw_board(board, movelist, mycolor);
 if (myturn) {
-running = !sendmove(board, mycolor, opponent);
+running = !sendmove(board, movelist, mycolor, opponent);
 } else {
-running = !recvmove(board, opponent);
+running = !recvmove(board, movelist, opponent);
 flushinp(); // flush any input the user hacked in while waiting
 }
 myturn ^= TRUE;
 }  while (running);
+freemovelist(movelist);
 mvaddstr(getmaxy(tchess_window)-1, 0,
 "Game has ended. Press any key to leave...");
 getch();
 }

Mercurial > hg > terminal-chess / file comparison

comparison: src/game.c

src/game.c