[Membres Vlade @vlade Participant]

#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;  // Player's set of tiles
};

// Function to initialize the game grid
void initializeGrid(vector<vector<char>> &grid, int gridSize) {
    grid.assign(gridSize, vector<char>(gridSize, '.'));  // Initialize grid with '.' representing empty squares
}

// Function to display the current state of the grid
void displayGrid(const vector<vector<char>> &grid) {
    for (const auto &row : grid) {
        for (char square : row) {
            cout << square << " ";
        }
        cout << endl;
    }
}

// Function to determine the winner based on the size of the covered square
int determineWinner(const vector<vector<char>> &grid) {
    // Your logic to determine the winner goes here
}

// Function to generate a random order of tiles
vector<char> generateRandomTileOrder() {
    vector<char> tilesOrder(TOTAL_TILES);
    for (int i = 0; i < TOTAL_TILES; ++i) {
        tilesOrder[i] = 'A' + i;  // Assuming tile shapes are represented by letters
    }
    random_shuffle(tilesOrder.begin(), tilesOrder.end());
    return tilesOrder;
}

// Function to distribute tiles to players
void distributeTiles(vector<Player> &players, const 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));  // Seed for random number generation

    int numPlayers;
    cout << "Enter the number of players (2 to 9): ";
    cin >> numPlayers;

    if (numPlayers < 2 || numPlayers > MAX_PLAYERS) {
        cout << "Invalid number of players. Exiting program." << endl;
        return 1;
    }

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

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

    vector<Player> players;
    players.resize(numPlayers);

    // Player setup
    for (int i = 0; i < numPlayers; ++i) {
        cout << "Enter the name for Player " << i + 1 << ": ";
        cin >> players[i].name;

        cout << "Choose a color (single character) for " << players[i].name << ": ";
        cin >> players[i].color;

        // Initialize starting tile for each player
        players[i].startX = rand() % gridSize;
        players[i].startY = rand() % gridSize;

        // Place starting tile on the grid
        grid[players[i].startX][players[i].startY] = players[i].color;

        // Initialize tile exchange coupons
        players[i].tileExchangeCoupons = 1;
    }

    // Generate random order of tiles
    vector<char> tilesOrder = generateRandomTileOrder();

    // Distribute tiles to players
    distributeTiles(players, tilesOrder);

    // Display initial grid
    cout << "\nInitial state of the grid:\n";
    displayGrid(grid);

    // Your game loop goes here

    return 0;
}

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

Bonjour,
Je comprends que c’est un jeu de société.
Malheureusement, tu n’as pas fait de demande, tu as juste mis ton code ! Quelle est ta demande concernant ce code ?

[Membres Vlade @vlade Participant]

je voudrais savoir pourquoi le iostream ne marche pas quand je lance

[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.

[Membres Vlade @vlade Participant]

d’accord merci je voudrais savoir sur quelle plateforme vous utiliser code blocks ou vs code

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

Je n’ai pas pu tester le code car je suis sur Sublime Text pour le moment, mais sinon, oui, j’utilise VS Code.

Ma correction fonctionne-t-elle ?

[Membres Vlade @vlade Participant]

négatif je pense que c’est du a code blocks

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

Ok, je te laisse passer sur VS Code tu me diras !

[Auteur]

Messages