Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

suivant les différentes structure et mapping, " struct Game { address player1; address…

  1. User

    suivant les différentes structure et mapping, " struct Game { address player1; address player2; address activePlayer; uint64 gameId; uint256 _requestId; uint32 playerMove; GameStatus status; }” “struct Find { Game game; string word; string firstLetter; string letterToGuess; string letterWin; string wordToGuess; }” “PlayerManagement public playerManagement;” “mapping(uint64 => Game) public games;” " mapping(address => mapping(uint => bool)) public guessedLetters;“ " mapping(address => mapping(uint => string)) public guessedWords;” “string[] private wordList; uint8 public wordLength; uint8 public wordListLength;”. peux tu vérifier qu'il n'y a pas d'erreurs dans la fonction "setWordToGuess" ?“function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress { require(_gameId < _gameId, “Identifiant de jeu invalide”); address activePlayerAddress = playerManagement.getActivePlayer(_gameId); require(msg.sender == activePlayerAddress, “Vous n’etes pas le joueur dans ce jeu.”);

    address otherPlayer; string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess); _wordToGuess = filteredWordToGuess;

    if (keccak256(abi.encodePacked(_wordToGuess)) == keccak256(abi.encodePacked(games[_gameId].word))) { require(bytes(_wordToGuess).length == wordLength, “il n y a pas le bon nombre de lettres”); guessedWords[msg.sender][games[_gameId].playerMove] = _wordToGuess; emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess); games[_gameId].status = GameStatus.finished; uint256 currentPot = games[_gameId].pot; games[_gameId].pot = 0; gameBalances[_gameId][msg.sender] += currentPot;

    playerManagement.endGame(_gameId);

    emit GameEnded(_gameId, msg.sender, otherPlayer); emit PotWon(_gameId, msg.sender, currentPot); } else { if (msg.sender == games[_gameId].player1) { otherPlayer = games[_gameId].player2; } else if (msg.sender == games[_gameId].player2) { otherPlayer = games[_gameId].player1; }

    guessedWords[msg.sender][games[_gameId].playerMove] = _wordToGuess; emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);

    playerManagement.playersSwitched(_gameId); } }”

  2. Assistant

    La fonction "setWordToGuess" semble correcte dans son ensemble, mais il y a quelques erreurs mineures que j'ai corrigées dans le code suivant:

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        require(_gameId < gameCount, “Identifiant de jeu invalide”);
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, “Vous n’etes pas le joueur dans ce jeu.”);
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        _wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(_wordToGuess)) == keccak256(abi.encodePacked(games[_gameId].word))) {
            require(bytes(_wordToGuess).length == wordLength, “il n y a pas le bon nombre de lettres”);
            guessedWords[msg.sender][games[_gameId].playerMove] = _wordToGuess;
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            games[_gameId].status = GameStatus.finished;
            uint256 currentPot = games[_gameId].pot;
            games[_gameId].pot = 0;
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == games[_gameId].player1) {
                otherPlayer = games[_gameId].player2;
            } else if (msg.sender == games[_gameId].player2) {
                otherPlayer = games[_gameId].player1;
            }
    
            guessedWords[msg.sender][games[_gameId].playerMove] = _wordToGuess;
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    Voici les modifications que j'ai apportées:

    1. Remplacez require(_gameId < _gameId, “Identifiant de jeu invalide”); par require(_gameId < gameCount, “Identifiant de jeu invalide”);. Le nombre total de jeux doit être utilisé comme condition pour vérifier l'identifiant du jeu.
    2. Dans la déclaration if, la comparaison devrait être faite avec la 'wordToGuess' de la structure Find. J'ai modifié cela en utilisant games[_gameId].word au lieu de games[_gameId].wordToGuess.
  3. User

    je ne vois pas la correction avec la structure Find " “struct Find { Game game; string word; string firstLetter; string letterToGuess; string letterWin; string wordToGuess;" ?

  4. Assistant

    Je m'excuse pour la confusion. J'avais mal compris la question précédente. Vous avez raison, nous avons besoin d'utiliser la structure Find pour accéder à la propriété wordToGuess. Voici la fonction corrigée:

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        require(_gameId < gameCount, “Identifiant de jeu invalide”);
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, “Vous n’etes pas le joueur dans ce jeu.”);
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        _wordToGuess = filteredWordToGuess;
    
        Find memory currentFind = finds[_gameId]; // Ajout de cette ligne pour accéder à la structure Find
    
        if (keccak256(abi.encodePacked(_wordToGuess)) == keccak256(abi.encodePacked(currentFind.wordToGuess))) { // Modification de cette ligne pour utiliser currentFind.wordToGuess
            require(bytes(_wordToGuess).length == wordLength, “il n y a pas le bon nombre de lettres”);
            guessedWords[msg.sender][games[_gameId].playerMove] = _wordToGuess;
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            games[_gameId].status = GameStatus.finished;
            uint256 currentPot = games[_gameId].pot;
            games[_gameId].pot = 0;
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == games[_gameId].player1) {
                otherPlayer = games[_gameId].player2;
            } else if (msg.sender == games[_gameId].player2) {
                otherPlayer = games[_gameId].player1;
            }
    
            guessedWords[msg.sender][games[_gameId].playerMove] = _wordToGuess;
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    Les modifications apportées sont les suivantes :

    1. Ajout de la ligne Find memory currentFind = finds[_gameId]; pour obtenir l'objet Find associé à l'_gameId.
    2. Remplacement de games[_gameId].wordToGuess par currentFind.wordToGuess dans la condition if.
  5. User

    puisque la structure "Find" fait référence à la structure "Game" en ayant l'élément Game game, dans sa structure, cela ne devrait être Find memory game ?

  6. Assistant

    Vous avez raison. La structure Find fait référence à la structure Game, donc nous devrions avoir l'élément Game game dans sa structure, et pour obtenir les informations du jeu, nous devons accéder à l'élément game de Find.

    Voici la fonction corrigée avec les modifications approppriées :

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        require(_gameId < gameCount, “Identifiant de jeu invalide”);
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, “Vous n’etes pas le joueur dans ce jeu.”);
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        _wordToGuess = filteredWordToGuess;
    
        Find memory currentFind = finds[_gameId]; // Ajout de cette ligne pour accéder à la structure Find
    
        if (keccak256(abi.encodePacked(_wordToGuess)) == keccak256(abi.encodePacked(currentFind.wordToGuess))) { // Modification de cette ligne pour utiliser currentFind.wordToGuess
            require(bytes(_wordToGuess).length == wordLength, “il n y a pas le bon nombre de lettres”);
            guessedWords[msg.sender][currentFind.game.playerMove] = _wordToGuess; // Modification de cette ligne pour utiliser currentFind.game.playerMove
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentFind.game.status = GameStatus.finished; // Modification de cette ligne pour utiliser currentFind.game.status
            uint256 currentPot = currentFind.game.pot; // Modification de cette ligne pour utiliser currentFind.game.pot
            currentFind.game.pot = 0; // Modification de cette ligne pour utiliser currentFind.game.pot
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentFind.game.player1) { // Modification de cette ligne pour utiliser currentFind.game.player1
                otherPlayer = currentFind.game.player2; // Modification de cette ligne pour utiliser currentFind.game.player2
            } else if (msg.sender == currentFind.game.player2) { // Modification de cette ligne pour utiliser currentFind.game.player2
                otherPlayer = currentFind.game.player1; // Modification de cette ligne pour utiliser currentFind.game.player1
            }
    
            guessedWords[msg.sender][currentFind.game.playerMove] = _wordToGuess; // Modification de cette ligne pour utiliser currentFind.game.playerMove
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    Les modifications apportées sont les suivantes :

    1. Remplacer toutes les occurrences de games[_gameId] par currentFind.game.
    2. Conserver l'utilisation de currentFind.wordToGuess dans la condition if, car nous avons besoin de vérifier l'égalité avec le mot à deviner stocké dans la structure Find.
  7. User

    wordToGuess fait partie de la structure Find " struct Find { Game game; string word; string firstLetter; string letterToGuess; string letterWin; string wordToGuess;
    }" et les mots sont stockés dans le mapping "mapping(address => mapping(uint => string)) public guessedWords;" peux tu vérifier à nouveau la fonction setWordToGuess ? "function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress { Find storage currentGame = games[_gameId];

        require(_gameId < currentGame.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'etes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        currentGame.wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(currentGame.wordToGuess)) == keccak256(abi.encodePacked(currentGame.word))) {
            require(bytes(currentGame.wordToGuess).length == wordLength, "il n y a pas le bon nombre de lettres");
            guessedWords[msg.sender][currentGame.playerMove] = wordToGuess;
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentGame.game.status = GameStatus.finished;
            uint256 currentPot = game.game.pot;
            games[_gameId].pot = 0;
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentGame.game.player1) {
                otherPlayer = currentGame.game.player2;
            } else if (msg.sender == currentGame.game.player2) {
                otherPlayer = currentGame.game.player1;
            }
    
            guessedWords[msg.sender][currentGame.game.playerMove] = _wordToGuess;
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }"
    
  8. Assistant

    Je m'excuse pour la confusion précédente. Maintenant que je comprends mieux le contexte, j'ai mis à jour la fonction setWordToGuess en conséquence :

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        Find storage currentGame = games[_gameId];
    
        require(_gameId < currentGame.game.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'etes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        currentGame.wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(currentGame.wordToGuess)) == keccak256(abi.encodePacked(currentGame.word))) {
            require(bytes(currentGame.wordToGuess).length == wordLength, "il n y a pas le bon nombre de lettres");
            guessedWords[msg.sender][currentGame.game.playerMove] = _wordToGuess; // Modification ici pour utiliser currentGame.game.playerMove
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentGame.game.status = GameStatus.finished;
            uint256 currentPot = currentGame.game.pot; // Modification ici pour utiliser currentGame.game.pot
            currentGame.game.pot = 0; // Modification ici pour utiliser currentGame.game.pot
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentGame.game.player1) {
                otherPlayer = currentGame.game.player2;
            } else if (msg.sender == currentGame.game.player2) {
                otherPlayer = currentGame.game.player1;
            }
    
            guessedWords[msg.sender][currentGame.game.playerMove] = _wordToGuess; // Modification ici pour utiliser currentGame.game.playerMove
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    J'ai modifié la fonction pour utiliser les éléments appropriés de la structure Find. Voici les modifications que j'ai apportées :

    1. Remplacez games[_gameId] par currentGame.game chaque fois que nous avons besoin d'accéder à l'objet Game de la structure Find.
    2. Utilisez currentGame.wordToGuess pour accéder au mot à deviner dans la structure Find.
  9. User

    pot correspond à la structure Bet " struct Bet{ Game game; uint256 pot; uint256 amount; // Montant du retrait uint256 withdraw; bool player1hasWithdrawn; bool player2hasWithdrawn; // Montant retiré du solde }" et utilise la mapping "mapping(uint64 => mapping(address => Bet)) public gameBets;" peux tu vérifier à nouveau la fonction "setWordToGuess"function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress { Find storage currentGame = games[_gameId];

        require(_gameId < currentGame.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'etes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        currentGame.wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(currentGame.wordToGuess)) == keccak256(abi.encodePacked(currentGame.word))) {
            require(bytes(currentGame.wordToGuess).length == wordLength, "il n y a pas le bon nombre de lettres");
            guessedWords[msg.sender][currentGame.game.playerMove] = wordToGuess;
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentGame.game.status = GameStatus.finished;
            uint256 currentPot = game.game.pot;
            games[_gameId].pot = 0;
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentGame.game.player1) {
                otherPlayer = currentGame.game.player2;
            } else if (msg.sender == currentGame.game.player2) {
                otherPlayer = currentGame.game.player1;
            }
    
            guessedWords[msg.sender][currentGame.game.playerMove] = _wordToGuess;
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }"
    
  10. Assistant

    Puisque le pot correspond à la structure Bet et utilise le mapping gameBets, voici la fonction setWordToGuess mise à jour pour prendre en compte ces changements:

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        Find storage currentGame = games[_gameId];
        Bet storage currentBet = gameBets[_gameId][msg.sender]; // Ajout de cette ligne pour accéder à la structure Bet
    
        require(_gameId < currentGame.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'etes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        currentGame.wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(currentGame.wordToGuess)) == keccak256(abi.encodePacked(currentGame.word))) {
            require(bytes(currentGame.wordToGuess).length == wordLength, "il n y a pas le bon nombre de lettres");
            guessedWords[msg.sender][currentGame.game.playerMove] = _wordToGuess;
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentGame.game.status = GameStatus.finished;
            uint256 currentPot = currentBet.pot; // Modification de cette ligne pour utiliser currentBet.pot
            currentBet.pot = 0; // Modification de cette ligne pour utiliser currentBet.pot
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentGame.game.player1) {
                otherPlayer = currentGame.game.player2;
            } else if (msg.sender == currentGame.game.player2) {
                otherPlayer = currentGame.game.player1;
            }
    
            guessedWords[msg.sender][currentGame.game.playerMove] = _wordToGuess;
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    Les modifications apportées sont les suivantes:

    1. Ajout de la ligne Bet storage currentBet = gameBets[_gameId][msg.sender]; pour obtenir l'objet Bet associé à l'_gameId et au msg.sender.
    2. Remplacer toutes les occurrences de games[_gameId].pot par currentBet.pot.

    Ainsi, la fonction setWordToGuess intègre maintenant correctement la structure Bet et le mapping gameBets.

  11. User

    ce qui m'ennuie c'est qu'on déclare une variable locale currentPot. est-elle liée à "pot" ou dois-je quand même déclaré cette variable locale dans la structure Bet (ce qui ne doit pas être ait normalement) ?

  12. Assistant

    La variable locale currentPot est juste une variable temporaire utilisée dans la fonction setWordToGuess. Elle stocke la valeur de pot de la structure Bet pour le _gameId et le msg.sender avant de le réinitialiser à 0. La variable currentPot n'affecte pas directement la structure Bet.

    Cette variable locale est utile dans ce contexte pour stocker temporairement la valeur du pot afin de l'utiliser plus tard dans la fonction, sans affecter directement la valeur du pot dans la structure Bet.

    Il n'est pas nécessaire de déclarer currentPot dans la structure Bet, car il s'agit simplement d'une variable utilisée localement dans la fonction pour manipuler les montants et effectuer des transferts de pot entre les joueurs. La variable pot de la structure Bet est mise à jour indépendamment de la variable locale currentPot.

  13. User

    es tu d'accord avec cette analyse ? "La ligne Find storage currentGame = games[_gameId]; doit être modifiée pour accéder à la structure Game au lieu de Find. Vous pouvez utiliser Game storage currentGame = games[_gameId].game;.

    La ligne Bet storage currentBet = gameBets[_gameId][msg.sender]; n'est pas utilisée dans la fonction et peut être supprimée.

    Dans la ligne guessedWords[msg.sender][currentGame.game.playerMove] = wordToGuess;, la variable wordToGuess doit être remplacée par currentGame.wordToGuess.

    Dans la ligne uint256 currentPot = game.game.pot;, la variable game doit être remplacée par currentGame"

  14. Assistant

    Je suis d'accord avec votre analyse et les modifications que vous proposez. Voici la fonction setWordToGuess mise à jour en fonction de votre analyse:

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        Game storage currentGame = games[_gameId].game; // Modification de cette ligne pour accéder directement à la structure Game
    
        require(_gameId < currentGame.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'etes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        currentGame.wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(currentGame.wordToGuess)) == keccak256(abi.encodePacked(currentGame.word))) {
            require(bytes(currentGame.wordToGuess).length == wordLength, "il n y a pas le bon nombre de lettres");
            guessedWords[msg.sender][currentGame.playerMove] = currentGame.wordToGuess; // Modification ici pour utiliser currentGame.wordToGuess
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentGame.status = GameStatus.finished;
            uint256 currentPot = currentGame.pot; // Modification ici pour utiliser currentGame.pot
            currentGame.pot = 0;
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentGame.player1) {
                otherPlayer = currentGame.player2;
            } else if (msg.sender == currentGame.player2) {
                otherPlayer = currentGame.player1;
            }
    
            guessedWords[msg.sender][currentGame.playerMove] = currentGame.wordToGuess; // Modification ici pour utiliser currentGame.wordToGuess
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    Les modifications apportées sont les suivantes:

    1. Modifier la ligne Find storage currentGame = games[_gameId]; en Game storage currentGame = games[_gameId].game; pour accéder directement à la structure Game.
    2. Supprimer la ligne Bet storage currentBet = gameBets[_gameId][msg.sender]; car elle n'est pas utilisée dans la fonction.
    3. Remplacer wordToGuess par currentGame.wordToGuess dans l'affectation de la variable guessedWords[msg.sender][currentGame.playerMove].
    4. Remplacer game.game.pot par currentGame.pot pour accéder correctement au pot de la structure Game.
  15. User

    ici" Game storage currentGame = games[_gameId].game;" je ne vois pas la référence à la strcture Find qui contient la strcture des mots?

  16. Assistant

    Vous avez raison, mon erreur; j'ai mal compris votre question précédente. Puisque la structure Find contient la structure Game et les informations sur les mots, nous devons continuer à utiliser la structure Find pour accéder à la structure Game. Pour cela, nous devons également conserver la déclaration de la variable currentGame de type Find storage.

    Voici la fonction setWordToGuess corrigée en fonction de ces éléments :

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        Find storage currentGame = games[_gameId];
    
        require(_gameId < currentGame.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'etes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        currentGame.wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(currentGame.wordToGuess)) == keccak256(abi.encodePacked(currentGame.word))) {
            require(bytes(currentGame.wordToGuess).length == wordLength, "il n y a pas le bon nombre de lettres");
            guessedWords[msg.sender][currentGame.game.playerMove] = currentGame.wordToGuess;
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentGame.game.status = GameStatus.finished;
            uint256 currentPot = currentGame.game.pot;
            currentGame.game.pot = 0;
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentGame.game.player1) {
                otherPlayer = currentGame.game.player2;
            } else if (msg.sender == currentGame.game.player2) {
                otherPlayer = currentGame.game.player1;
            }
    
            guessedWords[msg.sender][currentGame.game.playerMove] = _wordToGuess;
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    Dans cette version, nous conservons la déclaration Find storage currentGame = games[_gameId];, et nous continuons à utiliser currentGame.game pour accéder à la structure Game et currentGame.wordToGuess pour accéder au mot à deviner stocké dans la structure Find.

    J'espère que cette réponse est plus claire et répond correctement à votre question.

  17. User

    tu utilises "Find storage currentGame = games[_gameId];" mais on me dit que cela devrait etre "Find storage currentGame = games[_gameId].game;" je sus perdue, peux tu m'expliquer ?

  18. Assistant

    Je présente mes excuses pour la confusion. Il semble y avoir une incompréhension dans l'utilisation de la structure Game et Find. Pour clarifier, puisque la structure Find contient la structure Game, nous devrions accéder à la structure Game en utilisant l'objet Find.

    Cependant, il y a une incohérence dans notre discussion précédente. Sur la base de votre code initial, vous avez utilisé un mapping mapping(uint64 => Game) public games;. Dans ce cas, lors de l'accès à games[_gameId], nous accédons directement à l'objet Game, pas à l'objet Find.

    Cela signifie que pour accéder à la structure Find, nous avons besoin d'un mapping séparé pour stocker les objets Find (par exemple, mapping(uint64 => Find) public finds;). Ensuite, pour accéder à l'objet Find, nous utiliserions Find storage currentFind = finds[_gameId];, et pour accéder à l'objet Game, nous utiliserions Game storage currentGame = finds[_gameId].game;.

    Voici un exemple de la fonction setWordToGuess en tenant compte de ces éléments :

    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        Find storage currentFind = finds[_gameId]; // Utiliser un mapping séparé pour accéder à la structure Find
        Game storage currentGame = currentFind.game; // Accéder à la structure Game à l'intérieur de la structure Find
    
        require(_gameId < currentGame.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'etes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filteredWordToGuess = filterSpecialCharacter(_wordToGuess);
        currentFind.wordToGuess = filteredWordToGuess;
    
        if (keccak256(abi.encodePacked(currentFind.wordToGuess)) == keccak256(abi.encodePacked(currentFind.word))) {
            require(bytes(currentFind.wordToGuess).length == wordLength, "il n y a pas le bon nombre de lettres");
            guessedWords[msg.sender][currentGame.playerMove] = currentFind.wordToGuess;
            emit WordWin(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
            currentGame.status = GameStatus.finished;
            uint256 currentPot = currentGame.pot;
            currentGame.pot = 0;
            gameBalances[_gameId][msg.sender] += currentPot;
    
            playerManagement.endGame(_gameId);
    
            emit GameEnded(_gameId, msg.sender, otherPlayer);
            emit PotWon(_gameId, msg.sender, currentPot);
        } else {
            if (msg.sender == currentGame.player1) {
                otherPlayer = currentGame.player2;
            } else if (msg.sender == currentGame.player2) {
                otherPlayer = currentGame.player1;
            }
    
            guessedWords[msg.sender][currentGame.playerMove] = _wordToGuess;
            emit WordGuessed(_gameId, activePlayerAddress, otherPlayer, _wordToGuess);
    
            playerManagement.playersSwitched(_gameId);
        }
    }
    

    Dans cet exemple, nous utilisons un mapping finds pour stocker les objets Find, ce qui nous permet d'accéder à la fois aux structures Game et Find. Si vous n'avez pas de mapping finds, vous devriez en ajouter un pour stocker les objets Find.

  19. User

    que fait-on de ce mapping alors ? "mapping(address => mapping(uint => string)) public guessedWords;" est-il obsolete si on utilise le mapping Find ?

  20. Assistant

    Le mapping guessedWords est utilisé pour stocker les mots devinés associés à chaque joueur et à chaque tour de jeu. Il ne devient pas obsolète lorsque vous utilisez le mapping Find, car il a un objectif différent.

    Le mapping Find est utilisé pour stocker les informations sur chaque partie de jeu, comme les lettres devinées et le mot à deviner. Le mapping guessedWords est utilisé pour stocker les mots devinés pour chaque joueur à chaque tour de jeu.

    Dans la fonction setWordToGuess, vous pouvez voir que guessedWords est utilisé pour stocker le mot deviné en cours :

    guessedWords[msg.sender][currentGame.playerMove] = currentFind.wordToGuess;
    

    À chaque tour, un joueur soumet un nouveau mot deviné, et ce mot est stocké dans le mapping guessedWords en utilisant l'adresse du joueur et le numéro de tour actuel.

    Donc, à moins que vous ne vouliez déplacer cette fonctionnalité à l'intérieur des structures Game ou Find, vous devez conserver le mapping guessedWords.

  21. User

    je comprends, ceci dit le mapping guessedWord ressemble plus à logique de mon code puisqu'il permet de relier le joueur à une partie encours avec le mot deviné. le mapping "guessedWord" faisait référence à la structure Game car la structure Game contenait les players les mots etc... mais elle a été divisée en plusieurs structure dont la structure "Find" pour éviter les débordement de pile. maintenant, la structure Find contient tout ce qui est relié au mot et la structure Game tout ce qui est relié au player. dans cette configuration, le mapping guessesWord, est-il toujours cohérent avec la structure Game ? Si non, peut-on modifier ce mapping afin qu'il respecte la nouvelle configuration ?

  22. Assistant

    Le mapping guessedWords stocke les mots devinés pour chaque joueur à chaque tour de jeu et n'a pas besoin de changer même si la logique est répartie entre les structures Game et Find. Le mapping utilise les adresses des joueurs et les numéros de tour pour stocker les mots, et il est indépendant de la manière dont les structures sont organisées.

    Cependant, si vous souhaitez intégrer le mapping guessedWords dans la nouvelle configuration avec les structures Game et Find, vous pouvez le faire en ajoutant un mapping guessedWords à la structure Find elle-même.

    Voici comment vous pourriez le faire :

    1. Ajoutez le mapping guessedWords dans la structure Find :
    struct Find {
        Game game;
        string word;
        string firstLetter;
        string letterToGuess;
        string letterWin;
        string wordToGuess;
        mapping(address => mapping(uint => string)) guessedWords; // Ajout de cette ligne
    }
    
    1. Mettez à jour la fonction setWordToGuess pour utiliser le mapping guessedWords dans la structure Find :
    function setWordToGuess(uint64 _gameId, string memory _wordToGuess) public inProgress {
        Find storage currentFind = finds[_gameId];
        Game storage currentGame = currentFind.game;
    
        require(_gameId < currentGame.gameId, "Identifiant de jeu invalide");
        address activePlayerAddress = playerManagement.getActivePlayer(_gameId);
        require(msg.sender == activePlayerAddress, "Vous n'êtes pas le joueur dans ce jeu.");
    
        address otherPlayer;
        string memory filtered