1&2 translated

fr/2/1-overview.md

@@ -11,24 +11,26 @@ material:
     answer: 1
 ---
 
-In lesson 1, we created a function that takes a name, uses it to generate a random zombie, and adds that zombie to our app's zombie database on the blockchain.
+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.
 
-In lesson 2, we're going to make our app more game-like: We're going to make it multi-player, and we'll also be adding a more fun way to create zombies instead of just generating them randomly.
+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.
 
-How will we create new zombies? By having our zombies "feed" on other lifeforms!
+Comment allons nous créer de nouveaux zombie ? En faisant manger d'autres formes de vie à nos zombies !
 
-## Zombie Feeding
 
-When a zombie feeds, it infects the host with a virus. The virus then turns the host into a new zombie that joins your army. The new zombie's DNA will be calculated from the previous zombie's DNA and the host's DNA.
+## Alimentation des Zombies
 
-And what do our zombies like to feed on most?
+Quand un zombie mange, il infecte l'hôte avec un virus. The 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.
 
-To find that out... You'll have to complete lesson 2!
+Et qu'est ce que les zombie préfèrent manger ?
 
-# Put it to the test
+Pour le savoir... Vous allez devoir finir la Leçon 2 !
 
-There's a simple demo of feeding to the right. Click on a human to see what happens when your zombie feeds!
 
-You can see that the new zombie's DNA is determined by your original zombie's DNA, as well as the host's DNA.
+# A votre tour
 
-When you're ready, click "Next chapter" to move on, and let's get started by making our game multi-player.
+Il y a un petit exemple à droite. Cliquez sur un humain pour voir ce qu'il arrive quand votre zombie 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.
+
+Quand vous êtes prêt, cliquez sur "Prochain Chapitre" et nous allons rendre ce jeu multijoueur.

fr/2/2-mappings.md

@@ -1,5 +1,5 @@
 ---
-title: Mappings and Addresses
+title: Mappage et Adresses
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -21,7 +21,7 @@ material:
 
           Zombie[] public zombies;
 
-          // declare mappings here
+          // déclarez les mappages ici
 
           function _createZombie(string _name, uint _dna) private {
               uint id = zombies.push(Zombie(_name, _dna)) - 1;
@@ -78,43 +78,46 @@ material:
       }
 ---
 
-Let's make our game multi-player by giving the zombies in our database an owner.
+Rendons notre jeu multijoueur en attribuant aux zombies de notre base de donnée un propriétaire.
 
-To do this, we'll need 2 new data types: `mapping` and `address`.
+Pour cela, nous allons avoir besoin de 2 nouveaux types de données : `mappage` et `adresse`.
 
-## Addresses
+## Adresses
 
-The Ethereum blockchain is made up of **_accounts_**, which you can think of like bank accounts. An account has a balance of **_Ether_** (the currency used on the Ethereum blockchain), and you can send and receive Ether payments to other accounts, just like your bank account can wire transfer money to other bank accounts.
+La blockchain Ethereum est constitué 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.
 
-Each account has an `address`, which you can think of like a bank account number. It's a unique identifier that points to that account, and it looks like this:
+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 à :
 
 `0x0cE446255506E92DF41614C46F1d6df9Cc969183`
 
-(This address belongs to the CryptoZombies team. If you're enjoying CryptoZombies, you can send us some Ether! 😉 )
+(Cette adresse appartient à l'équipe de CryptoZombies. Si vous aimez CryptoZombies, vous pouvez nous envoyer quelques Ethers ! 😉 )
 
-We'll get into the nitty gritty of addresses in a later lesson, but for now you only need to understand that **an address is owned by a specific user** (or a smart contract).
+Nous entrerons dans les détails des adresses dans une prochaine leçon, pour l'instant, la seule chose que vous devez comprendre c'est que **une adresse appartient à un utilisateur unique** (ou a un smart contract).
 
-So we can use it as a unique ID for ownership of our zombies. When a user creates new zombies by interacting with our app, we'll set ownership of those zombies to the Ethereum address that called the function.
+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.
 
-## Mappings
 
-In Lesson 1 we looked at **_structs_** and **_arrays_**. **_Mappings_** are another way of storing organized data in Solidity.
+## Mappage
 
-Defining a `mapping` looks like this:
+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.
+
+Voici un exemple de `mappage` :
 
 ```
-// For a financial app, storing a uint that holds the user's account balance:
+// Pour une application financière , stockage d'un uint qui correspond à la balance d'un compte utilisateur :
 mapping (address => uint) public accountBalance;
-// Or could be used to store / lookup usernames based on userId
+// Ou peut être utilisé pour stocker puis rechercher le nom d'utilisateur en fonction d'un userId.
 mapping (uint => string) userIdToName;
 ```
 
-A mapping is essentially a key-value store for storing and looking up data. In the first example, the key is an `address` and the value is a `uint`, and in the second example the key is a `uint` and the value a `string`.
+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`.
+
 
-# Put it to the test
+# A votre tour
 
-To store zombie ownership, we're going to use two mappings: one that keeps track of the address that owns a zombie, and another that keeps track of how many zombies an owner has.
+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.
 
-1. Create a mapping called `zombieToOwner`. The key will be a `uint` (we'll store and look up the zombie based on its id) and the value an `address`. Let's make this mapping `public`.
+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`.
 
-2. Create a mapping called `ownerZombieCount`, where the key is an `address` and the value a `uint`.
+2. Créez un mappage appelé `ownerZombieCount`, où la clé est une `address` et la valeur un `uint`.