FrznChess/chessmcu
FrznChess/chessmcu
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

style: implement clang-format styling parameters

Browse source
This commit is contained in:
A.M. Rowsell 2026-09-22 02:06:49 -04:00
commit f2ce83335c
Signed by: amr
GPG key ID: E0879EDBDB0CA7B1
10 changed files with 462 additions and 547 deletions
Download patch file Download diff file Expand all files Collapse all files

90
inc/Board.hpp
View file

@ -8,7 +8,7 @@
/** @file Board.hpp
* @brief The header file for the Board class
*
*
* This contains the class definition for the logical representation of the chessboard
* itself, as well as a few ancillary enums and forward declarations to make the code
* easier to read (hopefully). Unlike the Piece.hpp header, there's no inheritance
@ -17,11 +17,11 @@
#ifndef BOARD_HPP
#define BOARD_HPP
#include "Piece.hpp"
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
#include "Piece.hpp"
class Piece;
/** @enum Players
@ -32,34 +32,31 @@ struct Square;
/** @class Board Board.hpp inc/Board.hpp
* @brief This class abstracts the chess board itself
*
*
* The heart of the entire code is contained in the member variable boardGrid, which
* is a representation of the board. It's a 2D vector of Pieces, which are stored using
* smart pointers. When other functions want to view the board, they do so with the included
* getPieceAt() getters, which return raw pointers so ownership isn't transferred.
*
*
* Outside functions/methods can also change the state of the board with setPieceAt() which
* can allow one to move a piece (empty squares being nullptr) or add pieces to the Board when
* required.
*/
class Board {
private:
std::vector<std::vector<std::unique_ptr<Piece>>> boardGrid; /**< This holds the game state.
* It is a 2D vector of Piece types, or nullptr for empty squares
* @image html boardGrid.svg "Logical diagram of boardGrid vector" */
std::vector<std::vector<std::unique_ptr<Piece>>>
boardGrid; /**< This holds the game state.
* It is a 2D vector of Piece types, or nullptr for empty squares
* @image html boardGrid.svg "Logical diagram of boardGrid vector" */
Players playerTurn;
Square enPassantTargetSquare = {INVALID_RANK, INVALID_FILE};
// let's get super object-oriented, baby
// these help the getters and setters access the boardGrid
// and also make them shorter and less duplicative
std::unique_ptr<Piece> &at(int r, int f) {
return boardGrid[r][f];
}
std::unique_ptr<Piece> &at(int r, int f) { return boardGrid[r][f]; }
const std::unique_ptr<Piece> &at(int r, int f) const {
return boardGrid[r][f];
}
const std::unique_ptr<Piece> &at(int r, int f) const { return boardGrid[r][f]; }
std::unique_ptr<Piece> &at(const Square &sq) {
return boardGrid[static_cast<int>(sq.rank)][static_cast<int>(sq.file)];
@ -68,6 +65,7 @@ class Board {
const std::unique_ptr<Piece> &at(const Square &sq) const {
return boardGrid[static_cast<int>(sq.rank)][static_cast<int>(sq.file)];
}
public:
Board();
virtual ~Board();
@ -75,69 +73,43 @@ class Board {
// These are to allow Piece to access Board in a controlled way
// instead of adding a friend declaration for every subclass
// ----- Getters -----
Piece *getPieceAt(int r, int f) {
return at(r, f).get();
}
const Piece *getPieceAt(int r, int f) const {
return at(r, f).get();
}
Piece *getPieceAt(int r, int f) { return at(r, f).get(); }
const Piece *getPieceAt(int r, int f) const { return at(r, f).get(); }
Piece *getPieceAt(const Square &sq) {
return at(sq).get();
}
const Piece *getPieceAt(const Square &sq) const {
return at(sq).get();
}
Square getEnPassantTargetSquare() const {
return enPassantTargetSquare;
}
Piece *getPieceAt(const Square &sq) { return at(sq).get(); }
const Piece *getPieceAt(const Square &sq) const { return at(sq).get(); }
Square getEnPassantTargetSquare() const { return enPassantTargetSquare; }
// ----- Setters -----
void setPieceAt(int r, int f, std::unique_ptr<Piece> piece) {
at(r, f) = std::move(piece);
}
void setPieceAt(const Square &sq, std::unique_ptr<Piece> piece) {
at(sq) = std::move(piece);
}
void setPieceAt(int r, int f, std::unique_ptr<Piece> piece) { at(r, f) = std::move(piece); }
void setPieceAt(const Square &sq, std::unique_ptr<Piece> piece) { at(sq) = std::move(piece); }
void clearSquare(int r, int f) {
at(r, f).reset();
}
void clearSquare(const Square &sq) {
at(sq).reset();
}
void clearSquare(int r, int f) { at(r, f).reset(); }
void clearSquare(const Square &sq) { at(sq).reset(); }
void setEnPassantTargetSquare(Square sq) {
enPassantTargetSquare = sq;
}
void clearEnPassantTargetSquare() {
enPassantTargetSquare = {INVALID_RANK, INVALID_FILE};
}
void setEnPassantTargetSquare(Square sq) { enPassantTargetSquare = sq; }
void clearEnPassantTargetSquare() { enPassantTargetSquare = {INVALID_RANK, INVALID_FILE}; }
// ----- Utility -----
bool isSquareEmpty(int r, int f) const {
return at(r, f) == nullptr;
}
bool isSquareEmpty(const Square &sq) const {
return at(sq) == nullptr;
}
bool isSquareEmpty(int r, int f) const { return at(r, f) == nullptr; }
bool isSquareEmpty(const Square &sq) const { return at(sq) == nullptr; }
/** A function to setup the initial board
*
*
* This initializes the boardGrid with the black and white pieces
* in their normal starting positions. All empty squares are set
* to nullptr.
*/
void setupInitialPosition();
/** This function sets the entire board to nullptr
*
*
* This should, if I understand correctly, destroy
* all the Piece instances that existed because they will no longer
* have any owners, and smart pointers should auto destruct.
*/
void clearBoard();
/** This does the actual moving of a piece from one square to another
*
*
* Beware! This function does \e not validate if the move is legal. It
* will simply do whatever it is told to do. So only call this once you
* are positive the move is legal.
@ -151,12 +123,12 @@ class Board {
void movePiece(Square from, Square to);
void nextTurn();
/** This function takes a standard FEN string and sets up the board.
*
*
* FEN is a standard notation that describes only an exact position and
* other important things like whose turn it is, whether sides can castle,
* but it does \e not include the move history of the game. This makes it
* a simpler format for sharing particular interesting positions.
*
*
* @param strFEN A std::string that contains a valid FEN position
* @return 0 on success, -1 if the FEN string is invalid
*/
@ -165,14 +137,14 @@ class Board {
// serial shift register stuff
uint64_t serialBoard = 0xFFFF00000000FFFF; // opening position
/** This takes an incoming serial stream and detects if anything has moved.
*
*
* The input is one bit per piece, so it can only detect the presence or
* absence of pieces on any particular square. This is the crux of our design,
* using simpler reed switches for detection instead of RFID or any other two-way
* communication with the pieces. This moves a lot of the complexity into software,
* though a lot of the complexity is actually quite easy to deal with from a software
* point of view.
*
*
* @param incomingBoard A 64-bit value, representing 1 bit per piece.
*/
void deserializeBoard(uint64_t incomingBoard);