[Admin Shiloh @shiloh Maître des clés]

Plusieurs problème dans ton code :

1 – il manque les mécaniques de jeu de base et la logique pour déterminer le gagnant.
2 – Le programme suppose également un certain format pour l’entrée du joueur et ne gère pas de manière robuste les erreurs ou les entrées invalides.
3 – Pour finir, la façon dont les tuiles sont distribuées doit être révisée, car elle semble actuellement retirer les tuiles déjà distribuées du pool global, ce qui pourrait entraîner des erreurs.

Je ne suis pas un expert mais essaie ceci :

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using namespace std;

const int MAX_PLAYERS = 9;
const int SMALL_GRID_SIZE = 20;
const int LARGE_GRID_SIZE = 30;
const int TOTAL_TILES = 96;
const int TILES_PER_PLAYER = 10;

struct Player {
    string name;
    char color;
    int startX;
    int startY;
    int tileExchangeCoupons;
    vector<char> tiles;  // Ensemble de tuiles du joueur
};

void initializeGrid(vector<vector<char>> &grid, int gridSize) {
    grid.assign(gridSize, vector<char>(gridSize, '.'));  // Initialisation de la grille avec '.' pour les cases vides
}

void displayGrid(const vector<vector<char>> &grid) {
    for (const auto &row : grid) {
        for (char square : row) {
            cout << square << " ";
        }
        cout << endl;
    }
}

int determineWinner(const vector<vector<char>> &grid, const vector<Player> &players) {
    vector<int> scores(players.size(), 0);

    // Calcul des scores pour chaque joueur
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[i].size(); j++) {
            for (int k = 0; k < players.size(); k++) {
                if (grid[i][j] == players[k].color) {
                    scores[k]++;
                }
            }
        }
    }

    // Trouver le joueur avec le score le plus élevé
    int maxScore = 0, winnerIndex = -1;
    for (int i = 0; i < scores.size(); i++) {
        if (scores[i] > maxScore) {
            maxScore = scores[i];
            winnerIndex = i;
        }
    }

    return winnerIndex;
}

vector<char> generateRandomTileOrder() {
    vector<char> tilesOrder(TOTAL_TILES);
    for (int i = 0; i < TOTAL_TILES; ++i) {
        tilesOrder[i] = 'A' + i;  // Tuiles représentées par des lettres
    }
    random_shuffle(tilesOrder.begin(), tilesOrder.end());
    return tilesOrder;
}

void distributeTiles(vector<Player> &players, vector<char> &tilesOrder) {
    for (Player &player : players) {
        player.tiles.assign(tilesOrder.begin(), tilesOrder.begin() + TILES_PER_PLAYER);
        tilesOrder.erase(tilesOrder.begin(), tilesOrder.begin() + TILES_PER_PLAYER);
    }
}

int main() {
    srand(time(0));  // Initialisation du générateur de nombres aléatoires

    int numPlayers;
    cout << "Entrez le nombre de joueurs (2 à 9) : ";
    cin >> numPlayers;

    if (numPlayers < 2 || numPlayers > MAX_PLAYERS) {
        cout << "Nombre de joueurs invalide. Fin du programme." << endl;
        return 1;
    }

    int gridSize = (numPlayers <= 4) ? SMALL_GRID_SIZE : LARGE_GRID_SIZE;

    vector<vector<char>> grid;
    initializeGrid(grid, gridSize);

    vector<Player> players(numPlayers);

    // Configuration des joueurs
    for (int i = 0; i < numPlayers; ++i) {
        cout << "Entrez le nom pour le Joueur " << i + 1 << " : ";
        cin >> players[i].name;

        cout << "Choisissez une couleur (caractère unique) pour " << players[i].name << " : ";
        cin >> players[i].color;

        // Initialisation de la position de départ
        players[i].startX = rand() % gridSize;
        players[i].startY = rand() % gridSize;
        grid[players[i].startX][players[i].startY] = players[i].color;

        players[i].tileExchangeCoupons = 1;  // Initialisation des coupons d'échange de tuile
    }

    // Génération et distribution des tuiles
    vector<char> tilesOrder = generateRandomTileOrder();
    distributeTiles(players, tilesOrder);

    // Affichage de la grille initiale
    cout << "\nÉtat initial de la grille :\n";
    displayGrid(grid);

    // Boucle de jeu
    bool gameOver = false;
    int currentPlayerIndex = 0;

    while (!gameOver) {
        // Logique du jeu ici
        // Exemple : Chaque joueur place une tuile à tour de rôle
        // ...

        // Vérification de la fin du jeu
        // gameOver = ...;  // À déterminer selon les règles du jeu

        currentPlayerIndex = (currentPlayerIndex + 1) % numPlayers;
    }

    int winnerIndex = determineWinner(grid, players);
    if (winnerIndex != -1) {
        cout << "Le gagnant est " << players[winnerIndex].name << " !" << endl;
    } else {
        cout << "Pas de gagnant." << endl;
    }

    return 0;
}

Dans ce code, j’ai ajouté une logique de jeu basique et une fonction determineWinner pour déterminer le gagnant et j’ai corrigé différentes érreurs.