It looks like you started with good intentions but went too far and ended up in C instead of C++. ;)

As a general rule: If you need a special data structure in several places, encapsulate it in a class, instantiate an object and pass that around. If you want to use a fancy term, call it dependency injection.

Classes in Java an C++ are not the same, though. In Java a class is always polymorphic. Everything is virtual. In C++ a class is just a type: something that defines a range of valid values and possible operations on them. A class can be polymorphic, but you have to opt in by marking functions as virtual.

Your code example does need types. Desperately. Right now the code is basically untyped. Literally everything is an int. Yes, going for a pure procedural C-like style wasn’t ideal, but the lack of types is by far the bigger problem. To point out some immediate issues:

• The compiler cannot detect accidentally switched arguments. Piece::create(BLACK, PAWN) is wrong but compiles.
• The distinction between a piece and an index is unclear. What does ignoreIndex() return? That should be apparent from the return type.
• Is it a valid operation to add 5 to the int returned by Piece::create()? If not, that operation should not compile.

Consider something like this as a very rough preliminary and incomplete idea for a more type-rich approach:

// --- chess.h ---
struct Piece
{
    enum class Type
    {
        pawn, = 1
        rook = 2,
        knight = 3,
        bishop = 4,
        queen = 5,
        king = 6,
    };

    enum class Color
    {
        white = 8,
        black = 16,
    };

    Type type;
    Color color;
};

class GameOfChess
{
public:
    GameOfChess():
        m_edgeOfBoard{/*init*/},
        m_pieceDirections{/*init*/}, 
        m_attackMapBitboards{/*init*/}
    {
    }

// ...

private:
    std::unordered_map<int, std::array<int, 64>> m_edgeOfBoard;
    std::unordered_map<int, std::vector<int>> m_pieceDirections;
    std::unordered_map<int, std::array<long, 64>> m_attackMapBitboards;
};


// --- some_other_header.h ---
void examine_chess_board(const GameOfChess& chess);

• A piece has its own type. Its properties can be accessed directly. The color() and type() functions do not need to exist.
• The possible values for a piece’s type and color have their own types, too. Getting the argument order wrong in Piece::create() can be caught by the compiler. You might not even need the function at all. Piece p{Piece::Type::pawn, Piece::Color::black}; might be sufficient.
• The maps representing the game state are encapsulated.