fixes Lesson 2

fr/2/00-overview.md

@@ -8,4 +8,4 @@ Vous m'impressionnez humain ! Vous êtes un meilleur codeur que j'aurais pensé.
 
 La Leçon 2 va vous apprendre à **multiplier votre armée de zombie en les nourrissant avec d'autres formes de vie**.
 
-Nous allons voir des concepts Solidity plus avancé, nous vous recommandons fortement d'avoir fini la Leçon 1 avant de commencer.
+Nous allons voir des concepts Solidity plus avancés, nous vous recommandons fortement d'avoir fini la Leçon 1 avant de commencer.

fr/2/1-overview.md

@@ -11,14 +11,14 @@ material:
     answer: 1
 ---
 
-Avec la leçon 1, nous avons créé une fonction qui prend un nom, et qui l'utilise pour générer un zombie aléatoire, ce zombie est ajouté à la base de donnée stockée sur la blockchain de notre jeu.
+Avec la Leçon 1, nous avons créé une fonction qui prend un nom, et qui l'utilise pour générer un zombie aléatoire, ce zombie est ajouté à la base de donnée de notre jeu stockée sur la blockchain.
 
-Avec la leçon 2, nous allons faire que notre application ressemble plus à un jeu : Nous allons la rendre multijoueur, et nous allons aussi ajouter des manières plus amusantes de créer des zombies, au lieu de les générer juste aléatoirement.
+Avec la Leçon 2, nous allons modifier notre application pour qu'elle ressemble plus à un jeu : Nous allons la rendre multijoueur, et nous allons aussi ajouter des manières plus amusantes de créer des zombies, au lieu de les générer juste aléatoirement.
 
-Comment allons nous créer de nouveaux zombie ? En faisant manger d'autres formes de vie à nos zombies !
+Comment allons nous créer de nouveaux zombies ? En faisant manger d'autres formes de vie à nos zombies !
 
 
-## Alimentation des Zombies
+## Alimentation des zombies
 
 Quand un zombie mange, il infecte l'hôte avec un virus. Le virus transforme l'hôte en un nouveau zombie qui va rejoindre votre armée. L'ADN du nouveau zombie va être calculée à partir de l'ADN du zombie et de l'ADN de l'hôte.
 
@@ -29,8 +29,8 @@ Pour le savoir... Vous allez devoir finir la Leçon 2 !
 
 # A votre tour
 
-Il y a un petit exemple à droite. Cliquez sur un humain pour voir ce qu'il arrive quand votre zombie mange !
+Il y a un petit exemple à droite. Cliquez sur un humain pour voir ce qu'il arrive quand votre zombie le mange !
 
-Vous pouvez voir que l'ADN du nouveau zombie est déterminé par l'ADN de votre zombie et l'ADN de l'hôte.
+Vous pouvez voir que l'ADN du nouveau zombie est déterminée par l'ADN de votre zombie et celui de l'hôte.
 
 Quand vous êtes prêt, cliquez sur "Prochain Chapitre" et nous allons rendre ce jeu multijoueur.

fr/2/10-interactingcontracts.md

@@ -101,11 +101,11 @@ Eh bien, il se trouve que les CryptoZombies adorent manger des...
 
 **CryptoKitties!** 😱😱😱
 
-(Oui, Je suis sérieux 😆 )
+(Oui, Je suis sérieux 😆)
 
 Pour pouvoir faire ça, nous allons avoir besoin de lire l'ADN des chatons (kittyDna) depuis le smart contract CryptoKitties. Nous pouvons le faire car les données de CryptoKitties sont stockées ouvertement sur la blockchain. C'est pas génial la blockchain ?!
 
-Ne vous en faites pas - notre jeu ne va faire de mal à aucun CryptoKitty. Nous allons seulement *lire* les données de CryptoKitties, nous ne sommes pas capables de les supprimer 😉
+Ne vous en faites pas - notre jeu ne va faire de mal à aucun CryptoKitty. Nous allons seulement *lire* les données de CryptoKitties, nous ne sommes pas capables de les supprimer 😉.
 
 ## Interagir avec d'autres contrats
 
@@ -126,7 +126,7 @@ contract LuckyNumber {
   }
 }
 ```
-Cela serait un simple contrat où n'importe qui pourrait stocker leur nombre porte-bonheur, et il serait associé à leur adresse Ethereum. Ensuite n'importe qui pourrait regarder leur nombre porte-bonheur en utilisant leur adresse.
+Cela serait un simple contrat où n'importe qui pourrait stocker son nombre porte-bonheur, et il serait associé à leur adresse Ethereum. Ensuite n'importe qui pourrait regarder leur nombre porte-bonheur en utilisant leur adresse.
 
 Maintenant, imaginons que nous avons un contrat externe qui voudrait lire les données de ce contrat en utilisant la fonction `getNum`.
 
@@ -142,15 +142,15 @@ Vous remarquerez que cela ressemble à la définition d'un contrat, avec quelque
 
 Deuxièmement, nous ne définissons par de corps de fonction, à la place des `{` et `}`, nous finissons simplement la déclaration de la fonction avec un `;`.
 
-C'est un peu comme un squelette d'un contrat. C'est comme ça que le compilateur sait que c'est une interface.
+C'est un peu comme le squelette d'un contrat. C'est comme ça que le compilateur sait que c'est une interface.
 
-En incluant cette interface dans le code de notre dapp, notre contrat sait à quoi ressemble les fonctions de l'autre contrat, comment les appeler, et quelle type réponse en attendre.
+En incluant cette interface dans le code de notre dapp, notre contrat sait à quoi ressemble les fonctions de l'autre contrat, comment les appeler, et quelle type de réponse en attendre.
 
 Nous verrons comment appeler les fonctions de l'autre contrat dans la prochaine leçon, pour l'instant nous allons déclarer notre interface pour le contrat CryptoKitties.
 
 # A votre tour
 
-Nous avons regardé le code source de CryptoKitties pour vous, et avons trouvé une fonction appelée `getKitty` qui retourne tous les données des chatons, "gènes" inclus (c'est ce dont nous avons besoin pour créer un nouveau zombie !).
+Nous avons regardé le code source de CryptoKitties pour vous, et avons trouvé une fonction appelée `getKitty` qui retourne toutes les données des chatons, "gènes" inclus (c'est ce dont nous avons besoin pour créer un nouveau zombie !).
 
 La fonction ressemble à :
 ```
@@ -168,7 +168,7 @@ function getKitty(uint256 _id) external view returns (
 ) {
     Kitty storage kit = kitties[_id];
 
-    // si cette variable est 0 alors il n'est pas en gestation
+    // si cette variable est 0 alors elle n'est pas en gestation
     isGestating = (kit.siringWithId != 0);
     isReady = (kit.cooldownEndBlock <= block.number);
     cooldownIndex = uint256(kit.cooldownIndex);
@@ -182,10 +182,10 @@ function getKitty(uint256 _id) external view returns (
 }
 ```
 
-La fonction est un peu différente que ce dont nous avons l'habitude. Vous pouvez voir qu'elle retourne... un tas de différentes valeurs. Si vous venez d'un langage de prgramation comme Javascript, c'est différent - en Solidity une fonction peut retourner plus d'une valeur.
+La fonction est un peu différente que ce dont nous avons l'habitude. Vous pouvez voir qu'elle retourne... un tas de différentes valeurs. Si vous venez d'un langage de programmation comme Javascript, c'est différent - en Solidity une fonction peut retourner plus d'une valeur.
 
 Maintenant que nous savons à quoi ressemble notre fonction, nous pouvons l'utiliser pour créer une interface :
 
 1. Définissez une interface appelée `KittyInterface`. C'est comme déclarer un nouveau contrat - nous utilisons le mot clé `contract`.
 
-2. Dans l'interface, définissez une fonction `getKitty` (qui devrait être un copier/coller de la fonction ci-dessus, mais avec un `;` après la déclaration `returns` au lieu de tout ce qu'il y a entre les {}).
+2. Dans l'interface, définissez une fonction `getKitty` (qui devrait être un copier/coller de la fonction ci-dessus, mais avec un `;` après la déclaration `returns` au lieu de tout ce qu'il y a entre les `{}`).

fr/2/11-interactingcontracts2.md

@@ -128,7 +128,7 @@ contract MyContract {
   address NumberInterfaceAddress = 0xab38...
   // ^ L'adresse du contrat FavoriteNumber sur Ethereum
   NumberInterface numberContract = NumberInterface(NumberInterfaceAddress)
-  // Mainteant `numberContract` pointe vers l'autre contrat
+  // Maintenant `numberContract` pointe vers l'autre contrat
 
   function someFunction() public {
     //Nous pouvons maintenant appeler `getNum` à partir de ce contrat :

fr/2/12-multiplereturns.md

@@ -38,7 +38,7 @@ material:
             _createZombie("NoName", newDna);
           }
 
-          // definissez la fonction ici
+          // définissez la fonction ici
 
         }
       "zombiefactory.sol": |
@@ -133,7 +133,7 @@ function processMultipleReturns() external {
   uint a;
   uint b;
   uint c;
-  // C'est comme ca que vous faites une affectation multiple :
+  // C'est comme ça que vous faites une affectation multiple :
   (a, b, c) = multipleReturns();
 }
 

fr/2/13-kittygenes.md

@@ -1,5 +1,5 @@
 ---
-title: "Bonus : gènes de chatton"
+title: "Bonus : gènes de chaton"
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -135,9 +135,9 @@ material:
 
 La logique de notre fonction est terminée... mais nous allons ajouter une fonctionnalité bonus.
 
-Nous allons faire que les zombies créés à partir de chattons aient une caractéristique unique, qui montrera qu'ils sont des zombie-chats.
+Nous allons faire que les zombies créés à partir de chatons aient une caractéristique unique, qui montrera qu'ils sont des zombie-chats.
 
-Pour cela, nous allons ajouter un code spécial chatton à l'ADN du zombie.
+Pour cela, nous allons ajouter un code spécial chaton à l'ADN du zombie.
 
 Si vous vous rappelez de la leçon 1, nous n'utilisons seulement les 12 premiers chiffres de notre ADN à 16 chiffres pour déterminer l'apparence du zombie. Nous allons utiliser les 2 derniers chiffres inutilisés pour gérer les caractéristiques "spéciales".
 
@@ -161,11 +161,11 @@ function eatBLT(string sandwich) public {
 
 Nous allons implémenter les gènes de chat dans notre code zombie.
 
-1. Premièrement, changez la définition de fonction de `feedAndMultiply` qu'elle prenne un 3ème paramètres : un `string` nommé `_species`
+1. Premièrement, changez la définition de la fonction `feedAndMultiply` pour qu'elle prenne un 3ème paramètre : un `string` nommé `_species`
 
-2. Ensuite, après avoir calculé le nouvel ADN zombie, rajoutez un déclaration `if` pour comparer le hachage `keccak256` de `_species` et la chaîne de caractère `"kitty"`.
+2. Ensuite, après avoir calculé le nouvel ADN zombie, rajoutez une déclaration `if` pour comparer le hachage `keccak256` de `_species` et la chaîne de caractère `"kitty"`.
 
-3. Dans cette déclaration `if`, nous voulons remplacer les 2 derniers chiffres de l'ADN par `99`. Une façon de le faire et d'utiliser cette logique : `newDna = newDna - newDna % 100 + 99;`.
+3. Dans cette déclaration `if`, nous voulons remplacer les 2 derniers chiffres de l'ADN par `99`. Une façon de le faire est d'utiliser cette logique : `newDna = newDna - newDna % 100 + 99;`.
 
   > Explication : Si `newDna` est `334455`. Alors `newDna % 100` est `55`, donc `newDna - newDna % 100` est `334400`. Enfin on ajoute `99` pour avoir `334499`.
 

fr/2/14-wrappingitup.md

@@ -13,11 +13,11 @@ material:
 
 Et voila, vous avez terminé la leçon 2 !
 
-Vous pouvez voir comment cela fonctionne avec la démo à droite. Allez-y, je sais que nous avez hâte d'arriver en bas de cette page 😉. Cliquez sur un chatton pour l'attaquer et regardez le nouveau zombie que vous obtiendrez !
+Vous pouvez voir comment cela fonctionne avec la démo à droite. Allez-y, je sais que nous avez hâte d'arriver en bas de cette page 😉. Cliquez sur un chaton pour l'attaquer et regardez le nouveau zombie que vous obtiendrez !
 
 ## Implémentation Javascript
 
-Une fois que nous sommes prêt à déployer ce contrat sur Ethereum, nous avons juste besoin de compiler et déployer `ZombieFeeding` - vu que c'est notre contrat final qui hérite de `ZombieFactory`, and qui a accès à tous les fonctions publiques des deux contrats.
+Une fois que nous sommes prêt à déployer ce contrat sur Ethereum, nous avons juste besoin de compiler et déployer `ZombieFeeding` - vu que c'est notre contrat final qui hérite de `ZombieFactory`, et qui a accès à tous les fonctions publiques des deux contrats.
 
 Voici un exemple d'interaction avec notre contrat déployé utilisant Javascript et web3.js:
 
@@ -27,29 +27,29 @@ var ZombieFeedingContract = web3.eth.contract(abi)
 var contractAddress = /* l'adresse de notre contrat sur Ethereum une fois déployé */
 var ZombieFeeding = ZombieFeedingContract.at(contractAddress)
 
-// En supposant que nous avons l'ADN de notre zombie et l'ID du chatton que l'on veut attaquer
+// En supposant que nous ayons l'ADN de notre zombie et l'ID du chaton que l'on veut attaquer
 let zombieId = 1;
 let kittyId = 1;
 
 // Pour obtenir l'image CryptoKitty, nous avons besoin d'interroger leur API web.
 // Cette information n'est pas stockée sur la blockchain, seulement sur leur
 // serveur web. Si tout était stocké sur la blockchain, nous n'aurions pas
 // besoin de s'inquiéter que les serveurs tombent en panne, qu'ils changent leur
-// API et que la compagnie décide de nous bloquer l'accès à leurs images s'ils
+// API ou que la compagnie décide de nous bloquer l'accès à leurs images s'ils
 // n'aiment pas notre jeu de zombie ;)
 let apiUrl = "https://api.cryptokitties.co/kitties/" + kittyId
 $.get(apiUrl, function(data) {
   let imgUrl = data.image_url
   // faire quelque chose pour afficher l'image
 })
 
-// Quand l'utilisateur clique sur un chatton :
+// Quand l'utilisateur clique sur un chaton :
 $(".kittyImage").click(function(e) {
   // Appeler la fonction `feedOnKitty` de notre contrat
   ZombieFeeding.feedOnKitty(zombieId, kittyId)
 })
 
-// Écouter pour un évènement NewZombie de notre contrat pour l'afficher :
+// Écoute un évènement NewZombie de notre contrat pour l'afficher :
 ZombieFactory.NewZombie(function(error, result) {
   if (error) return
   // Cette fonction va afficher le zombie, comme dans la leçon 1 :
@@ -61,6 +61,6 @@ ZombieFactory.NewZombie(function(error, result) {
 
 Choisissez un chaton que vous voulez donner à manger. L'ADN de votre zombie et celui du chaton vont se mélanger, et vous aurez un nouveau zombie dans votre armée !
 
-Vous avez vu ces jolies jambes de chat sur votre nouveau zombie ? C'est grâce au chiffres `99` à la fin de notre ADN 😉
+Vous avez vu ces jolies jambes de chat sur votre nouveau zombie ? C'est grâce aux chiffres `99` à la fin de notre ADN 😉
 
-Vous pouvez recommencer si vous le souhaitez. Quand vous avez un zombie qui vous plait (vous n'en aurez qu'un), continuez et passez au prochain chapitre pour terminer la leçon 2 !
+Vous pouvez recommencer si vous le souhaitez. Quand vous avez un zombie qui vous plaît (vous n'en aurez qu'un), continuez et passez au prochain chapitre pour terminer la leçon 2 !

fr/2/2-mappings.md

@@ -1,5 +1,5 @@
 ---
-title: Mappage et adresses
+title: Mappages et adresses
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -80,13 +80,13 @@ material:
 
 Rendons notre jeu multijoueur en attribuant aux zombies de notre base de donnée un propriétaire.
 
-Pour cela, nous allons avoir besoin de 2 nouveaux types de données : `mappage` et `adresse`.
+Pour cela, nous allons avoir besoin de 2 nouveaux types de données : `mapping` (mappage) et `address` (adresse).
 
 ## Adresses
 
-La blockchain Ethereum est constituée de **_comptes_**, un peu comme des des comptes en banque. Un compte à un montant d'**_Ether_** (c'est la monnaie utilisée sur la blockchain Ethereum), et vous pouvez envoyer des Ethers à d'autres comptes ou en recevoir, de la même manière que vous pouvez transférer de l'argent d'un compte bancaire à un autre.
+La blockchain Ethereum est constituée de **_comptes_**, un peu comme des comptes en banque. Un compte à un montant d'**_Ether_** (c'est la monnaie utilisée sur la blockchain Ethereum), et vous pouvez envoyer des Ethers à d'autres comptes ou en recevoir, de la même manière que vous pouvez transférer de l'argent d'un compte bancaire à un autre.
 
-Chaque compte à une `adresse`, qui est l'équivalent d'un numéro de compte bancaire. c'est un identifiant unique qui désigne un compte et qui ressemble à :
+Chaque compte à une `address`, qui est l'équivalent d'un numéro de compte bancaire. c'est un identifiant unique qui désigne un compte et qui ressemble à :
 
 `0x0cE446255506E92DF41614C46F1d6df9Cc969183`
 
@@ -97,25 +97,25 @@ Nous entrerons dans les détails des adresses dans une prochaine leçon, pour l'
 Nous pouvons donc l'utiliser comme un ID unique pour définir l'appartenance de nos zombies. Quand un utilisateur crée de nouveaux zombies en interagissant avec notre application, nous pourrons définir l'appartenance de ces zombies à l'adresse Ethereum utilisée pour appeler la fonction.
 
 
-## Mappage
+## Mappages
 
-Dans la Leçon 1 nous avec vu les **_structures_** et les **_tableaux_**. Les **_mappages_** sont une autres façon d'organiser des données en Solidity.
+Dans la Leçon 1 nous avec vu les **_structures_** et les **_tableaux_**. Les **_mappages_** sont une autre façon d'organiser des données en Solidity.
 
-Voici un exemple de `mappage` :
+Voici un exemple de `mapping` :
 
 ```
-// Pour une application financière , stockage d'un uint qui correspond à la balance d'un compte utilisateur :
+// Pour une application financière , stockage d'un `uint` qui correspond à la balance d'un compte utilisateur :
 mapping (address => uint) public accountBalance;
 // Ou peut être utilisé pour stocker puis rechercher le nom d'utilisateur en fonction d'un userId.
 mapping (uint => string) userIdToName;
 ```
 
-Un mappage est fondamentalement un stockage de valeur-clé pour stocker et rechercher des données. Dans le premier exemple, la clé est une `adresse` et la valeur est un `uint`, et dans le second exemple, la clé est un `uint` et la valeur une `chaine de caractère`.
+Un mappage est fondamentalement un stockage de valeur-clé pour stocker et rechercher des données. Dans le premier exemple, la clé est une `address` et la valeur est un `uint`, et dans le second exemple, la clé est un `uint` et la valeur un `string`.
 
 
 # A votre tour
 
-Pour savoir à qui appartient un zombie. Nous allons utiliser 2 mappages : un qui va stocker l'adresse associé à un zombie, et l'autre qui va stocker combien de zombies un utilisateur possède.
+Pour savoir à qui appartient un zombie. Nous allons utiliser 2 mappages : un qui va stocker l'adresse associée à un zombie, et l'autre qui va stocker combien de zombies un utilisateur possède.
 
 1. Créez un mappage appelé `zombieToOwner`. La clé est un `uint` (nous stockerons et rechercherons le zombie avec son id) et la valeur est une `address`.
 Ce mappage sera `public`.