chessboard-types.h

Go to the documentation of this file.

// Hoover Chess Utilities / PGN reader
// Copyright (C) 2024-2025  Sami Kiminki
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef HOOVER_CHESS_UTILS__PGN_READER__CHESSBOARD_TYPES_H_INCLUDED
#define HOOVER_CHESS_UTILS__PGN_READER__CHESSBOARD_TYPES_H_INCLUDED
 
#include <array>
#include <bit>
#include <cassert>
#include <cinttypes>
#include <cstdint>
#include <string_view>
#include <type_traits>
 
 
namespace hoover_chess_utils::pgn_reader
{
 
 
using SquareUnderlyingType = std::uint_fast8_t;
 
using SquareCompactType = std::uint8_t;
 
using ColorUnderlyingType = std::uint_fast8_t;
 
using ColorCompactType = std::uint8_t;
 
using PieceUnderlyingType = std::uint_fast8_t;
 
using PieceCompactType = std::uint8_t;
 
using PieceAndColorUnderlyingType = std::uint_fast8_t;
 
using PieceAndColorCompactType = std::uint8_t;
 
using PositionStatusUnderlyingType = std::uint_fast8_t;
 
using PositionStatusCompactType = std::uint8_t;
 
using RowColumnUnderlyingType = std::uint_fast8_t;
 
using RowColumnCompactType = std::uint8_t;
 
using RowColumn = RowColumnUnderlyingType;
 
enum class Square : SquareUnderlyingType
{
    A1 = 0U, 
    B1 = 1U, 
    C1 = 2U, 
    D1 = 3U, 
    E1 = 4U, 
    F1 = 5U, 
    G1 = 6U, 
    H1 = 7U, 
    A2 = 8U, 
    B2 = 9U, 
    C2 = 10U, 
    D2 = 11U, 
    E2 = 12U, 
    F2 = 13U, 
    G2 = 14U, 
    H2 = 15U, 
    A3 = 16U, 
    B3 = 17U, 
    C3 = 18U, 
    D3 = 19U, 
    E3 = 20U, 
    F3 = 21U, 
    G3 = 22U, 
    H3 = 23U, 
    A4 = 24U, 
    B4 = 25U, 
    C4 = 26U, 
    D4 = 27U, 
    E4 = 28U, 
    F4 = 29U, 
    G4 = 30U, 
    H4 = 31U, 
    A5 = 32U, 
    B5 = 33U, 
    C5 = 34U, 
    D5 = 35U, 
    E5 = 36U, 
    F5 = 37U, 
    G5 = 38U, 
    H5 = 39U, 
    A6 = 40U, 
    B6 = 41U, 
    C6 = 42U, 
    D6 = 43U, 
    E6 = 44U, 
    F6 = 45U, 
    G6 = 46U, 
    H6 = 47U, 
    A7 = 48U, 
    B7 = 49U, 
    C7 = 50U, 
    D7 = 51U, 
    E7 = 52U, 
    F7 = 53U, 
    G7 = 54U, 
    H7 = 55U, 
    A8 = 56U, 
    B8 = 57U, 
    C8 = 58U, 
    D8 = 59U, 
    E8 = 60U, 
    F8 = 61U, 
    G8 = 62U, 
    H8 = 63U, 
 
    NONE = 64U,
};
 
enum class Color : ColorUnderlyingType
{
    WHITE = 0U,
 
    BLACK = 8U,
};
 
enum class Piece : PieceUnderlyingType
{
    NONE = 0U, 
    PAWN,      
    KNIGHT,    
    BISHOP,    
    ROOK,      
    QUEEN,     
    KING,      
};
 
enum class PieceAndColor : PieceAndColorUnderlyingType
{
    NONE = 0U,       
 
    WHITE_PAWN = 1U, 
    WHITE_KNIGHT,    
    WHITE_BISHOP,    
    WHITE_ROOK,      
    WHITE_QUEEN,     
    WHITE_KING,      
 
    BLACK_PAWN = 9U, 
    BLACK_KNIGHT,    
    BLACK_BISHOP,    
    BLACK_ROOK,      
    BLACK_QUEEN,     
    BLACK_KING,      
 
    WHITE_NONE = 0U, 
    BLACK_NONE = 8U, 
};
 
enum class PieceAndColorCompact : PieceAndColorCompactType
{
    NONE = 0U,       
 
    WHITE_PAWN = 1U, 
    WHITE_KNIGHT,    
    WHITE_BISHOP,    
    WHITE_ROOK,      
    WHITE_QUEEN,     
    WHITE_KING,      
 
    BLACK_PAWN = 9U, 
    BLACK_KNIGHT,    
    BLACK_BISHOP,    
    BLACK_ROOK,      
    BLACK_QUEEN,     
    BLACK_KING,      
 
    WHITE_NONE = 0U, 
    BLACK_NONE = 8U, 
};
 
enum class PositionStatus : PositionStatusUnderlyingType
{
    NORMAL,
 
    CHECK,
 
    STALEMATE,
 
    MATE
};
 
constexpr inline bool isValidValue(Square sq) noexcept
{
    return (sq <= Square::NONE);
}
 
constexpr inline bool isValidSquare(Square sq) noexcept
{
    return (sq <= Square::H8);
}
 
constexpr inline Square makeSquare(RowColumn col, RowColumn row) noexcept
{
    assert(col <= 7U);
    assert(row <= 7U);
 
    [[assume(row <= 7U)]];
    [[assume(col <= 7U)]];
 
    return Square((row * 8U) + col);
}
 
constexpr inline RowColumn columnOf(Square sq) noexcept
{
    assert(sq <= Square::H8);
    [[assume(sq <= Square::H8)]];
 
    return static_cast<SquareUnderlyingType>(sq) & 7U;
}
 
constexpr inline RowColumn rowOf(Square sq) noexcept
{
    assert(sq <= Square::H8);
    [[assume(sq <= Square::H8)]];
 
    return static_cast<SquareUnderlyingType>(sq) / 8U;
}
 
constexpr inline Square getSquareForIndex(std::size_t index) noexcept
{
    assert(index <= 63U);
    [[assume(index <= 63U)]];
 
    return Square(index);
}
 
constexpr inline std::size_t getIndexOfSquare(Square sq) noexcept
{
    assert(sq <= Square::H8);
    [[assume(sq <= Square::H8)]];
 
    return static_cast<std::size_t>(sq);
}
 
constexpr inline Square addToSquareNoOverflowCheck(Square sq, std::int_fast8_t shift) noexcept
{
    return Square(static_cast<SquareUnderlyingType>(sq) + shift);
}
 
constexpr inline bool isValidValue(Color c) noexcept
{
    return c == Color::WHITE || c == Color::BLACK;
}
 
constexpr inline Color oppositeColor(Color c) noexcept
{
    return Color(static_cast<ColorUnderlyingType>(c) ^ 0x08U);
}
 
constexpr inline Color colorOf(PieceAndColor pc) noexcept
{
    assert((pc >= PieceAndColor::WHITE_NONE && pc <= PieceAndColor::WHITE_KING) ||
           (pc >= PieceAndColor::BLACK_NONE && pc <= PieceAndColor::BLACK_KING));
 
    return Color(static_cast<PieceAndColorUnderlyingType>(pc) & 0x8U);
}
 
 
constexpr inline bool isValidValue(Piece p) noexcept
{
    return p <= Piece::KING;
}
 
constexpr inline bool isValidValue(PieceAndColor pc) noexcept
{
    return (pc <= PieceAndColor::WHITE_KING) || (pc >= PieceAndColor::BLACK_NONE && pc <= PieceAndColor::BLACK_KING);
}
 
constexpr inline Piece pieceOf(PieceAndColor pc) noexcept
{
    assert(isValidValue(pc));
    [[assume(pc <= PieceAndColor::BLACK_KING)]];
 
    return Piece(static_cast<PieceAndColorUnderlyingType>(pc) & 0x7U);
}
 
constexpr inline PieceAndColor makePieceAndColor(Piece p, Color c) noexcept
{
    assert(isValidValue(p));
    assert(isValidValue(c));
 
    return PieceAndColor(
        static_cast<PieceUnderlyingType>(p) |
        static_cast<ColorUnderlyingType>(c));
}
 
 
constexpr inline PieceAndColorCompact toCompactType(PieceAndColor pc) noexcept
{
    return PieceAndColorCompact(static_cast<PieceAndColorUnderlyingType>(pc));
}
 
constexpr inline PieceAndColor toFastType(PieceAndColorCompact pc) noexcept
{
    return PieceAndColor(static_cast<PieceAndColorCompactType>(pc));
}
 
 
 
}
 
#endif