S'inscrire
section-icon

Forums

Parlez de tout ce que vous voulez!

Vous lisez 6 fils de discussion
  • Auteur
    Messages
    • Membres

        #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;
        }`

        • Ce sujet a été modifié il y a 7 mois et 2 semaines par avatar-image Vlade .
      • Admin
        avatar-image

        Admin

        @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

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

          • Admin
            avatar-image

            Admin

            @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

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

              • Admin
                avatar-image

                Admin

                @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 ?

                • Admin
                  avatar-image

                  Admin

                  @shiloh

                  Maître des clés

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

                2

                Voix

                7

                Réponses

                Vous lisez 6 fils de discussion
                • Vous devez être connecté pour répondre à ce sujet.