Refactor

src/chess.c

@@ -0,0 +1,124 @@
+
+#include "common.h"
+#include "graphics.h"
+#include "pieces.h"
+
+#include <ctype.h>  /* isalpha, isdigit ... */
+#include <locale.h> /* setlocale */
+#include <stdio.h>  /* printf, scanf */
+#include <string.h> /* memcpy */
+
+int    do_turn(int turn_no, tile_t board[BOARD_SIZE]);
+void    init_board(tile_t board[BOARD_SIZE]);
+index_t input_to_index(char input[2]);
+
+int main()
+{
+    int turn = 0;
+
+    setlocale(LC_ALL, "C.UTF-8");
+
+    tile_t board[8 * 8] = { 0 };
+
+    init_board(board);
+
+    while (true) {
+        printf("\033[2J"); // clear screen
+        print_board(board);
+
+		// turn increments on valid inputs,
+		// otherwise refreshes screen
+        turn = do_turn(turn, board);
+    }
+
+    return 0;
+}
+
+/**
+ * Resets/initializes the board
+ *
+ * Sets all the tiles of the board to match the starting position of chess.
+ *
+ * \param board Pointer to list of tiles representing board state
+ */
+void init_board(tile_t board[BOARD_SIZE])
+{
+    // black pieces are prefixed by a minus (-)
+    const tile_t start[]
+        = { -R, -N, -B, -Q, -K, -B, -N, -R, -P, -P, -P, -P, -P, -P, -P, -P,
+            E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,
+            E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,  E,
+            P,  P,  P,  P,  P,  P,  P,  P,  R,  N,  B,  Q,  K,  B,  N,  R };
+
+    memcpy(board, start, sizeof(start));
+}
+
+// TODO: Implement algebaric notation
+/** Asks for move, validates move and does move if valid
+ *
+ * \param turn_no Turn number
+ * \param board   Pointer to list of tiles representing board state
+ *
+ * \return turn+1 if successful, turn+0 if invalid input from player
+ * */
+int do_turn(int turn_no, tile_t board[BOARD_SIZE])
+{
+    char input[3] = { 0 };
+
+    int from = -1, to = -1;
+
+    printf("\nPlayer %i, your turn to move", 1 + turn_no % 2);
+	printf("\nMove piece\nfrom: ");
+
+	scanf(" %2s", input);
+
+	from = input_to_index(input);
+
+	if (from == -1)
+		return turn_no;
+
+	printf("\nto: ");
+	scanf(" %2s", input);
+
+	to = input_to_index(input);
+
+	if (to == -1)
+		return turn_no;
+
+	if (! move_ok(board, from, to, turn_no % 2 ? BLACK : WHITE))
+		return turn_no;
+
+    board[to]   = board[from];
+    board[from] = E;
+
+	/* increment to make it next turn */
+	return turn_no+1;
+}
+
+/**
+ * Translates A1, 3B etc. to the 1D index of the board
+ *
+ *	\param input string of length 2 representing tile, e.g. "A3"
+ *
+ * */
+index_t input_to_index(char input[2])
+{
+    int x = -1, y = -1, c;
+
+    for (int i = 0; i < 2; i++) {
+        c = input[i];
+
+        if (isalpha(c))
+            c = toupper(input[0]);
+
+        if ('A' <= c && c <= 'H')
+            x = c - 'A';
+        else if ('1' <= c && c <= '8')
+            y = c - '1';
+    }
+
+    if (x != -1 && y != -1)
+        return 8 * (7 - y) + x;
+    else
+        return -1;
+}

src/graphics.c

@@ -0,0 +1,95 @@
+
+#include "graphics.h"
+
+#include "common.h"
+#include "util.h"
+
+#include <stdio.h>
+
+/** Set background to dark blue */
+#define BG_DARKBLUE() setcolor(0, 100, 100, 150)
+
+/** Set background to light blue */
+#define BG_LIGHTBLUE() setcolor(0, 150, 150, 200)
+
+/** Set foreground to black */
+#define FG_BLACK() setcolor(1, 0, 0, 0)
+
+/** Set foreground to white */
+#define FG_WHITE() setcolor(1, 0xff, 0xff, 0xff)
+
+/** 0x2659 == ♙ */
+#define UNICODE_CHESS_SYMBOL 0x2659
+
+static inline void
+setcolor(const int mode, const int r, const int g, const int b);
+
+/**
+ * Sets the foreground or background color for subsequent writes.
+ *
+ * Uses Select Graphic Renditions (SGR) to set the color of the terminal output.
+ * See https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit for more details.
+ *
+ * \param mode 0 - change background, 1 - change foreground, 2 - reset colors
+ * \param r    amount of red (0 to 255)
+ * \param b    amount of blue (0 to 255)
+ * \param g    amount of green (0 to 255)
+ */
+static inline void
+setcolor(const int mode, const int r, const int g, const int b)
+{
+    if (mode == 2)
+        printf("\033[0m");
+    else
+        printf("\033[%i;2;%i;%i;%im", mode ? 38 : 48, r, g, b);
+};
+
+/**
+ * Prints the board
+ *
+ * Uses unicode symbols and ANSI escape features to print a chessboard on the
+ * display.
+ *
+ * \param board A pointer to a list of tiles representing the board state
+ *
+ * */
+void print_board(const tile_t board[BOARD_SIZE])
+{
+    /* https://en.wikipedia.org/wiki/Chess_symbols_in_Unicode
+
+       The unicode symbols for the pieces are calculated from adding
+           0x2653 (#define'd as UNICODE_CHESS_SYMBOL) with the piece value. */
+
+    for (size_t i = 0; i < 8; i++) {
+        printf("\n %zu ", 8 - i); // number coordinates
+
+        for (size_t j = 0; j < 8; j++) {
+            tile_t t = board[i * 8 + j];
+
+            if ((i + j) % 2)
+                BG_DARKBLUE();
+            else
+                BG_LIGHTBLUE();
+
+            if (tile_empty(t)) {
+                printf("  ");
+                continue;
+            }
+
+            if (t > 0)
+                FG_WHITE();
+            else
+                FG_BLACK();
+
+            printf("%lc ", UNICODE_CHESS_SYMBOL + abs_tile(t));
+        }
+
+        setcolor(2, 0, 0, 0); // reset text attributes
+    }
+
+    /* horizontal letter coordinates */
+    printf("\n  ");
+
+    for (int i = 0; i < 8; i++)
+        printf(" %c", 'a' + i);
+}

src/pieces.c

@@ -0,0 +1,221 @@
+
+#include "common.h"
+#include "util.h"
+
+ bool
+bishop_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to);
+ bool
+cardinal_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to);
+ bool
+diagonal_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to);
+ bool
+king_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to);
+ bool knight_move_ok(index_t from, index_t to);
+ bool pawn_move_ok(const tile_t board[BOARD_SIZE],
+                         index_t      from,
+                         index_t      to,
+                         int          player);
+ bool
+queen_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to);
+ bool
+rook_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to);
+
+/**
+ * Returns true if move is a valid pawn move
+ *
+ *  \param board  Array of tiles representing chess board state
+ *  \param from   Index of board piece starts at
+ *  \param to     Index of board piece wants to move to
+ *  \param player Player to move
+ */
+bool pawn_move_ok(const tile_t board[BOARD_SIZE],
+                  index_t      from,
+                  index_t      to,
+                  int          player)
+{
+    const index_t diff = (to - from) * -player;
+
+    switch (diff) {
+    default:
+        return false;
+
+    case ROW: /* single move */
+        return tile_empty(board[to]);
+
+    case ROW - 1:
+    case ROW + 1: /* diagonal attack */
+        return opposite_color(board[to], board[from]);
+
+    case 2 * ROW: /* double move */
+        return tile_empty(board[to]) && tile_empty(board[from - ROW * player])
+            && (row(from) == 1 || row(from) == 6);
+    }
+}
+
+/**
+ * Returns true if `to` is on a diagonal line of `from`, false otherwise
+ *
+ *  \param board Array of tiles representing chess board state
+ *  \param from  Index of board piece is at
+ *  \param to    Index of board piece tries to move to
+ */
+bool diagonal_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to)
+{
+    const index_t col_diff = column(to) - column(from);
+    const index_t row_diff = row(to) - row(from);
+
+    const index_t x_step = col_diff / abs_pos(col_diff);
+    const index_t y_step = ROW * row_diff / abs_pos(row_diff);
+    const index_t step   = x_step + y_step;
+
+    if (abs_pos(col_diff) != abs_pos(row_diff))
+        return false;
+
+    for (index_t p = from + step; p != to; p += step)
+        if (! tile_empty(board[p]))
+            return false;
+
+    return true;
+}
+
+/**
+ * Returns true if index `to` is on a cardinal line of `from`, false otherwise
+ *
+ *  \param board Array of tiles representing chess board state
+ *  \param from  Index of board piece is at
+ *  \param to    Index of board piece tries to move to
+ */
+bool cardinal_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to)
+{
+    const index_t col_diff = column(to) - column(from);
+    const index_t row_diff = row(to) - row(from);
+
+    /* cardinal moves means one direction has to be zero */
+    if (row_diff > 0 && col_diff > 0)
+        return false;
+
+    index_t step = row_diff ? ROW * row_diff / abs_pos(row_diff) :
+                              col_diff / abs_pos(col_diff);
+
+    for (index_t p = from + step; p != to; p += step)
+        if (! tile_empty(board[p]))
+            return false;
+
+    return true;
+}
+
+/**
+ * Returns true if move is a valid bishop move
+ *
+ *  \param board Array of tiles representing chess board state
+ *  \param from  Index of board piece is at
+ *  \param to    Index of board piece tries to move to
+ */
+bool bishop_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to)
+{
+    return diagonal_move_ok(board, from, to);
+}
+
+/**
+ * Returns true if move is a valid rook move
+ *
+ *  \param board Array of tiles representing chess board state
+ *  \param from  Index of board piece is at
+ *  \param to    Index of board piece tries to move to
+ */
+bool rook_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to)
+{
+    return cardinal_move_ok(board, from, to);
+}
+
+/**
+ * Returns true if move is a valid knight move
+ *
+ *  \param from  Index of board piece is at
+ *  \param to    Index of board piece tries to move to
+ */
+bool knight_move_ok(index_t from, index_t to)
+{
+    const index_t c = abs_pos(column(to) - column(from));
+    const index_t r = abs_pos(row(to - from));
+
+    return (c == 1 && r == 2) || (c == 2 && r == 1);
+}
+
+/**
+ * Returns true if move is a valid king move
+ *
+ *  \param board Array of tiles representing chess board state
+ *  \param from  Index of board piece is at
+ *  \param to    Index of board piece tries to move to
+ */
+bool king_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to)
+{
+    const index_t abs_col_diff = abs_pos(column(to) - column(from));
+    const index_t abs_row_diff = abs_pos(row(to) - row(from));
+
+    (void)board;
+
+    return abs_col_diff <= 1 && abs_row_diff <= 1;
+}
+
+/**
+ * Returns true if move is a valid queen move
+ *
+ *  \param board Array of tiles representing chess board state
+ *  \param from  Index of board piece is at
+ *  \param to    Index of board piece tries to move to
+ */
+bool queen_move_ok(const tile_t board[BOARD_SIZE], index_t from, index_t to)
+{
+    return diagonal_move_ok(board, from, to)
+        || cardinal_move_ok(board, from, to);
+}
+
+/**
+ * Returns true if a move is valid, false otherwise
+ *
+ * \param board  Pointer to list of tiles representing board state
+ * \param from   Tile to move piece from
+ * \param to     Tile to move piece to
+ * \param player The current player to move
+ * */
+bool move_ok(const tile_t board[BOARD_SIZE],
+             index_t      from,
+             index_t      to,
+             int          player)
+{
+    /* player must own piece it moves */
+    if (board[from] * player < 0)
+        return false;
+
+    if (tile_empty(board[from]))
+        return false;
+
+    /* player can't take own pieces or move piece onto itself*/
+    if (same_color(board[from], board[to]))
+        return false;
+
+    /* check piece specific moves */
+    switch (abs_tile(board[from])) {
+    case P:
+        return pawn_move_ok(board, from, to, player);
+
+    case B:
+        return bishop_move_ok(board, from, to);
+
+    case R:
+        return rook_move_ok(board, from, to);
+
+    case N:
+        return knight_move_ok(from, to);
+
+    case K:
+        return king_move_ok(board, from, to);
+
+    case Q:
+        return queen_move_ok(board, from, to);
+    }
+
+    return false;
+}

src/util.c

@@ -0,0 +1,80 @@
+
+#include "util.h"
+
+/**
+ * Returns the absolute value of an index_t value
+ *
+ * \param p positive or negative index_t
+ */
+index_t abs_pos(index_t p)
+{
+    if (p < 0)
+        return -1 * p;
+
+    return p;
+}
+
+/**
+ * Returns the absolute value of a tile_t value
+ *
+ * \param t positive or negative tile_t
+ * */
+tile_t abs_tile(tile_t t)
+{
+    if (t < 0)
+        return -1 * t;
+
+    return t;
+}
+
+/**
+ * Returns true if tile is empty, false otherwise
+ *
+ *	\param t tile to check if empty
+ * */
+bool tile_empty(tile_t t)
+{
+    return t == E;
+}
+
+/**
+ * Returns row number of 1D board index
+ *
+ * \param i index to get row number of
+ * */
+index_t row(index_t i)
+{
+    return i / ROW;
+}
+
+/**
+ * Returns column number of board index
+ *
+ * \param i index to get column number of
+ * */
+index_t column(index_t i)
+{
+    return i % ROW;
+}
+
+/**
+ * Returns true if a and b are tiles of opposite color, false otherwise
+ *
+ * \param a Tile to compare
+ * \param b Tile to compare it with
+ * */
+bool opposite_color(tile_t a, tile_t b)
+{
+    return a * b < 0;
+}
+
+/**
+ * Returns true if a and b are pieces of the same color, false otherwise
+ *
+ * \param a Tile to compare
+ * \param b Tile to compare it with
+ * */
+bool same_color(tile_t a, tile_t b)
+{
+    return a * b > 0;
+}