Morpion en C++

#include <iostream>
#include <array>
#include <limits>

struct Grid
{
    Grid();
    void update(bool player1);
    void print();

    std::array<char, 9> content;
    std::array<std::array<int, 3>, 8> winPositions;
};

bool gameWon(const Grid & grid);
std::size_t checkEntry(std::size_t & entry, const Grid* grid);
void printResults(const bool player1, int counter, const Grid & grid);

int main()
{
    Grid grid;
    bool player1 { true };;
    int counter { 0 };

    while (!(gameWon(grid)) && counter != 9) {
        grid.update(player1);
        grid.print();
        player1 = !(player1);
        ++counter;
    }

    printResults(!(player1), counter, grid);

    return 0;
}

Grid::Grid()
{
    content.fill('-');

    winPositions[0] = { 0, 1, 2 };
    winPositions[1] = { 3, 4, 5 };
    winPositions[2] = { 6, 7, 8 };
    winPositions[3] = { 0, 3, 6 };
    winPositions[4] = { 1, 4, 7 };
    winPositions[5] = { 2, 5, 8 };
    winPositions[6] = { 0, 4, 8 };
    winPositions[7] = { 2, 4, 6 };
}

void Grid::update(bool player1)
{
    const int playerNumber { (player1 ? 1 : 2) };
    char c { player1 ? 'X' : 'O' };

    std::cout << "Player " << playerNumber << ", pick a position (1-9): ";
    std::size_t pick { checkEntry(pick, this) };

    --pick;
    content[pick] = c;
}

void Grid::print()
{
    for (std::size_t i { 0 }; i < 9; ++i) {
        std::cout << content[i] << ' ';
        if (i == 2 || i == 5 || i == 8)
            std::cout << std::endl;
    }
}

bool gameWon(const Grid & grid)
{
    for (const auto & line : grid.winPositions) {
        if (grid.content[line[0]] == grid.content[line[1]]
                && grid.content[line[1]] == grid.content[line[2]]
                && grid.content[line[2]] != '-')
            return true;
    }

    return false;
}

std::size_t checkEntry(std::size_t & entry, const Grid* grid)
{
    while (!(std::cin >> entry) || entry > 9 || entry < 1 || grid->content[entry-1] != '-') {
        std::cout << "Invalid entry, please try again: ";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }

    return entry;
}

void printResults(const bool player1, const int counter, const Grid & grid)
{
    const int playerNumber { player1 ? 1 : 2 };

    if (counter == 9 && !(gameWon(grid)))
        std::cout << "It's a draw." << std::endl;
    else
        std::cout << "Player " << playerNumber << " wins." << std::endl;
}

// main.cpp
// Le morpion

#include <iostream>
#include <vector>
#include <array>
#include <limits>
#include <cmath>

// On part du principe que l'utilisateur utilise une valeur qui est un carré parfait
// (carré d'un entier)
#define GRID_SIZE 9
#define GRID_SIZE_SQUARED static_cast<size_t>(sqrt(GRID_SIZE))

enum struct Cell { empty, cross, circle };
using Grid = std::array<Cell, GRID_SIZE>;
using Lines = std::vector<std::vector<std::size_t>>;

Lines victoryLinesGenerator();
void update(Grid & grid, bool player1);
std::ostream& operator<<(std::ostream& os, Cell cell);
void print(const Grid & grid);
bool playerVictory(const Grid & grid, const Lines & victoryLines);
std::size_t positionPrompt(std::size_t & entry, const Grid & grid);
void printResults(const bool player1, const int filledCells, const Grid & grid, const Lines & victoryLines);

int main()
{
    Grid grid;
    grid.fill(Cell::empty);
    bool player1 { true };
    int filledCells { 0 };
    Lines victoryLines { victoryLinesGenerator() };

    while (!playerVictory(grid, victoryLines) && filledCells != GRID_SIZE) {
        update(grid, player1);
        print(grid);
        player1 = !player1;
        ++filledCells;
    }

    printResults(!player1, filledCells, grid, victoryLines);

    return 0;
}

Lines victoryLinesGenerator()
{
    Lines victoryLines;
    std::vector<std::size_t> horizontal;
    std::vector<std::size_t> vertical;
    std::vector<std::size_t> diagonal;

    // on génère les horizontales et les verticales

    for (std::size_t i { 0 }; i < GRID_SIZE_SQUARED; ++i) {
        for (std::size_t j { 0 }; j < GRID_SIZE_SQUARED; ++j) {
            horizontal.push_back(GRID_SIZE_SQUARED*i + j);
            vertical.push_back(i + GRID_SIZE_SQUARED*j);
        }

        victoryLines.push_back(horizontal);
        victoryLines.push_back(vertical);

        horizontal.clear();
        vertical.clear();
    }

    // on génère les lignes diagonales (formules trouvées au crayon...)

    for (std::size_t i { 0 }; i < GRID_SIZE_SQUARED; ++i) {
        diagonal.push_back(i + GRID_SIZE_SQUARED*i);
    }

    victoryLines.push_back(diagonal);
    diagonal.clear();

    for (std::size_t i { 0 }; i < GRID_SIZE_SQUARED; ++i) {
        diagonal.push_back(GRID_SIZE_SQUARED-1 + GRID_SIZE_SQUARED*i - i);
    }

    victoryLines.push_back(diagonal);

    return victoryLines;
}

void update(Grid & grid, bool player1)
{
    const int playerNumber { (player1 ? 1 : 2) };
    // le joueur 1 représente les croix, le joueur 2 les cercles
    Cell c { player1 ? Cell::cross : Cell::circle };

    std::cout << "Player " << playerNumber << ", pick a position (1-" << GRID_SIZE << "): ";
    std::size_t pick { positionPrompt(pick, grid) };

    --pick;
    grid[pick] = c;
}

std::ostream& operator<<(std::ostream& os, Cell cell)
{
    char symbol { 0 };

    // peut-être dans la définition de Cell remplacer cross par player1
    // et circle par player2 puis décider de comment les afficher ici ?

    switch (cell) {
    case Cell::empty:
        symbol = '-';
        break;
    case Cell::cross:
        symbol = 'X';
        break;
    case Cell::circle:
        symbol = 'O';
        break;
    }

    return os << symbol;
}

void print(const Grid & grid)
{
    for (std::size_t i { 0 }; i < GRID_SIZE; ++i) {
        std::cout << grid[i] << ' ';
        // l'affichage donne un carré
        if (i % GRID_SIZE_SQUARED == GRID_SIZE_SQUARED-1)
            std::cout << std::endl;
    }
}

bool playerVictory(const Grid & grid, const Lines & victoryLines)
{
    unsigned int alignment { 0 };

    // ici, on regarde si deux cases avec le même symbole s'enchaînent sur une ligne
    // si oui, on incrémente alignment, le but c'est d'enchaîner les symboles sur une ligne
    // soit alignment = taille de la grille - 1 (on commence à 0)
    // alignment == GRID_SIZE_SQUARED-1 est notre condition de victoire

    for (const auto & line : victoryLines) {
        for (std::size_t i { 0 }; i < GRID_SIZE_SQUARED-1; ++i)
            if (grid[line[i+1]] == grid[line[i]] && grid[line[i]] != Cell::empty)
                ++alignment;

        // le joueur a gagné
        if (alignment == GRID_SIZE_SQUARED-1)
            return true;

        // sinon , on remet le compteur à 0 et on passe à la ligne suivante
        alignment = 0;
    }

    return false;
}

std::size_t positionPrompt(std::size_t & entry, const Grid & grid)
{
    // on vérifie l'entrée de l'utilisateur (si la case est déjà remplie ou non,
    // si l'entrée est correcte...

    while (!(std::cin >> entry) || entry > GRID_SIZE || entry < 1 || grid[entry-1] != Cell::empty) {
        std::cout << "Invalid entry, please try again: ";
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }

    return entry;
}

void printResults(const bool player1, const int filledCells, const Grid & grid, const Lines & victoryLines)
{
    const int playerNumber { player1 ? 1 : 2 };

    if (filledCells == GRID_SIZE && !(playerVictory(grid, victoryLines)))
        std::cout << "It's a draw." << std::endl;
    else
        std::cout << "Player " << playerNumber << " wins." << std::endl;
}