S'inscrire
section-icon

Forums

Parlez de tout ce que vous voulez!

Viewing 8 posts - 1 through 8 (of 8 total)
  • Author
    Posts
  • 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é 1 an, 2 mois ago par avatar-image Vlade .
      Admin

        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

            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

                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

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

                  Admin

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

                  2

                  Voix

                  7

                  Réponses

                  Viewing 8 posts - 1 through 8 (of 8 total)
                  • Vous devez être connecté pour répondre à ce sujet.