translation v1 done

fr/5/12-safemath-4.md

@@ -1,5 +1,5 @@
 ---
-title: SafeMath Part 4
+title: SafeMath partie 4
 actions: ['vérifierLaRéponse', 'indice']
 requireLogin: true
 material:
@@ -16,7 +16,7 @@ material:
           uint attackVictoryProbability = 70;
 
           function randMod(uint _modulus) internal returns(uint) {
-            // Here's one!
+            // En voila un !
             randNonce++;
             return uint(keccak256(now, msg.sender, randNonce)) % _modulus;
           }
@@ -26,13 +26,13 @@ material:
             Zombie storage enemyZombie = zombies[_targetId];
             uint rand = randMod(100);
             if (rand <= attackVictoryProbability) {
-              // Here's 3 more!
+              // Et 3 de plus !
               myZombie.winCount++;
               myZombie.level++;
               enemyZombie.lossCount++;
               feedAndMultiply(_zombieId, enemyZombie.dna, "zombie");
             } else {
-              // ...annnnd another 2!
+              // ...eeeet encore 2 !
               myZombie.lossCount++;
               enemyZombie.winCount++;
               _triggerCooldown(myZombie);
@@ -372,10 +372,10 @@ material:
       }
 ---
 
-Great, now we can implement SafeMath on all the types of `uint`s we used in our DApp!
+Bien, maintenant nous pouvons implémenter SafeMath pour tous les types de `uint` que nous utilisons dans notre DApp !
 
-Let's fix all those potential issues in `ZombieAttack`. (There was also one `zombies[_zombieId].level++;` that needed to be fixed in `ZombieHelper`, but we've taken care of that one for you so we don't take an extra chapter to do so 😉).
+Corrigeons toutes les problèmes potentiels dans `ZombieAttack`. (Il y en avait aussi un dans `zombies[_zombieId].level++;` qui devait être corrigé dans `ZombieHelper`, mais on s'en est chargé pour vous, ça fait un chapitre de moins 😉).
 
-## Putting it to the Test
+## A votre tour
 
-Go ahead and implement SafeMath methods on all the `++` increments in `ZombieAttack`. We've left comments in the code to make them easy to find.
+Implémentez les méthodes SafeMath pour tous les incrémentations `++` de `ZombieAttack`. Nous avons mis des commentaires pour vous aider à les trouver.

fr/5/13-comments.md

@@ -1,5 +1,5 @@
 ---
-title: Comments
+title: Commentaires
 actions: ['vérifierLaRéponse', 'indice']
 requireLogin: true
 material:
@@ -13,7 +13,7 @@ material:
         import "./erc721.sol";
         import "./safemath.sol";
 
-        /// TODO: Replace this with natspec descriptions
+        /// TODO : A remplacez avec par des cescriptions natspec
         contract ZombieOwnership is ZombieAttack, ERC721 {
 
           using SafeMath for uint256;
@@ -381,85 +381,88 @@ material:
       }
 ---
 
-The Solidity code for our zombie game is finally finished!
+Le code Solidity de notre jeu zombie est enfin terminé !
 
-In the next lessons, we'll look at how to deploy the code to Ethereum, and how to interact with it with Web3.js.
+Dans les prochaines leçons, nous allons regarder comment déployer le code sur Ethereum, et comment interagir avec en utilisant Web3.js.
 
-But one final thing before we let you go in Lesson 5: Let's talk about **commenting your code**.
+Mais il reste une dernière chose dans la Leçon 5 avec de vous laisser partir : Nous allons voir comment **commenter votre code**.
 
-## Syntax for comments
 
-Commenting in Solidity is just like JavaScript. You've already seen some examples of single line comments throughout the CryptoZombies lessons:
+## Syntaxe pour commenter
+
+commenter en Solidity est la même chose qu'en JavaScript. Vous avez déjà vu quelques exemples de commentaire sur une seule ligne au cours des leçons de CryptoZombies :
 
 ```
-// This is a single-line comment. It's kind of like a note to self (or to others)
+// Ceci est un commentaire sur une seule ligne. C'est une note pour nous-même (ou pour les autres)
 ```
 
-Just add double `//` anywhere and you're commenting. It's so easy that you should do it all the time.
+Il suffit d'ajouter un `//` n'importe où et vous pouvez commentez. C'est tellement simple que vous devriez le faire tout le temps.
+
+Mais je sais — parfois une seule ligne n'est pas assez. Vous êtes un écrivain né, après tout !
 
-But I hear you — sometimes a single line is not enough. You are born a writer, after all!
+C'est pourquoi il existe aussi des commentaires multi-ligne :
 
-Thus we also have multi-line comments:
 
 ```
 contract CryptoZombies {
-  /* This is a multi-lined comment. I'd like to thank all of you
-    who have taken your time to try this programming course.
-    I know it's free to all of you, and it will stay free
-    forever, but we still put our heart and soul into making
-    this as good as it can be.
-
-    Know that this is still the beginning of Blockchain development.
-    We've come very far but there are so many ways to make this
-    community better. If we made a mistake somewhere, you can
-    help us out and open a pull request here:
+  /* Ceci est un commentaire multi-ligne. Je voudrais tous vous
+    remercier d'avoir pris le temps de faire ce cours de programmation.
+    Je sais que c'est accessible gratuitement, et ça le restera toujours,
+    mais nous avons quand même mis toute notre énergie pour que ce cours
+    soit le meilleur possible.
+
+    Nous en sommes simplement au début de la programmation sur Blockchain.
+    Nous avons déjà bien avancé, mais il y a tellement de façon de rendre
+    cette communauté meilleure. Si nous avons fait une erreur quelque part,
+    vous pouvez nous aider avec une pull request ici :
     https://github.com/loomnetwork/cryptozombie-lessons
 
-    Or if you have some ideas, comments, or just want to say
-    hi - drop by our Telegram community at https://t.me/loomnetwork
+    Ou si vous avez des idées, commentaires, ou si vous voulez
+    tout simplement dire bonjour - rejoignez-nous sur notre communauté
+    Telegram à https://t.me/loomnetwork
   */
 }
 ```
 
-In particular, it's good practice to comment your code to explain the expected behavior of every function in your contract. This way another developer (or you, after a 6 month hiatus from a project!) can quickly skim and understand at a high level what your code does without having to read the code itself.
+C'est particulièrement une bonne habitude de commenter son code pour expliquer le comportement attendu de chaque fonction de votre contrat. De cette manière, un autre développeur (ou vous, après 6 mois loin de votre projet !) peut parcourir votre code pour avoir une compréhension rapide du fonctionnement sans avoir à lire tous le code.
 
-The standard in the Solidity community is to use a format called **_natspec_**, which looks like this:
+Le standard dans la communauté Solidity est d'utiliser un format appelé **_natspec_**, qui ressemble à ça :
 
 ```
-/// @title A contract for basic math operations
+/// @title Un contract pour des opérations mathématiques basiques
 /// @author H4XF13LD MORRIS 💯💯😎💯💯
-/// @notice For now, this contract just adds a multiply function
+/// @notice Pour l'instant, ce contrat rajouter simpelment une fonction multiplication
 contract Math {
-  /// @notice Multiplies 2 numbers together
-  /// @param x the first uint.
-  /// @param y the second uint.
-  /// @return z the product of (x * y)
-  /// @dev This function does not currently check for overflows
+  /// @notice Multiplie 2 nombres ensemble
+  /// @param x le premier uint.
+  /// @param y le deuxième uint.
+  /// @return z le résultat de (x * y)
+  /// @dev Cette fonction ne vérifie pas les débordement pour l'instant
   function multiply(uint x, uint y) returns (uint z) {
-    // This is just a normal comment, and won't get picked up by natspec
+    // C'est un commentaire normal, qui ne sera pas pris en compte par natspec
     z = x * y;
   }
 }
 ```
 
-`@title` and `@author` are straightforward.
+`@title` (titre) and `@author` (auteur) sont plutôt évidents.
 
-`@notice` explains to a **user** what the contract / function does. `@dev` is for explaining extra details to developers.
+`@notice` explique à un **utilisateur** ce que le contrat / fonction fait. `@dev` est pour donner plus de détails aux développeurs.
 
-`@param` and `@return` are for describing what each parameter and return value of a function are for.
+`@param` et `@return` servent à décrirent chaque paramètres et ce que la fonction renvoie.
 
-Note that you don't always have to use all of these tags for every function — all tags are optional. But at the very least, leave a `@dev` note explaining what each function does.
+Vous n'avez pas tout le temps besoin d'utiliser tous ces tags pour chaque fonction — tous les tags sont optionnels. Au minimum, laissez une note `@dev` pour expliquer ce que chaque fonction fait.
 
-# Put it to the test
+# A votre tour
 
-If you haven't noticed by now, the CryptoZombies answer-checker ignores comments when it checks your answers. So we can't actually check your natspec code for this chapter ;)
+Si vous ne l'avex pas encore remarqué, le vérificateur de réponse de CryptoZombies ignore les commentaires quand il vérifie vos réponses. Nous ne pouvons donc pas vérifier votre code natspec dans ce chapitre ;)
 
-However, by now you're a Solidity whiz — we're just going to assume you've got this!
+Cependant, maintenant que vous êtes un expert Solidity — nous allons supposer que vous l'avez fait !
 
-Give it a try anyway, and try adding some natspec tags to `ZombieOwnership`:
+Essayez d'ajouter des tags natspec à `ZombieOwnership`:
 
-1. `@title` — E.g. A contract that manages transfering zombie ownership
+1. `@title` — Par exemple : Un contrat qui permet de gère le transfère de propriété d'un zombie
 
-2. `@author` — Your name!
+2. `@author` — Votre nom !
 
-3. `@dev` — E.g. Compliant with OpenZeppelin's implementation of the ERC721 spec draft
+3. `@dev` — Par exemple : Conforme aux spécificités provisoires de l'implémentation ERC721 d'OpenZeppelin

fr/5/14-wrappingitup.md

@@ -1,5 +1,5 @@
 ---
-title: Wrapping It Up
+title: Conclusion
 actions: ['vérifierLaRéponse', 'indice']
 requireLogin: true
 skipCheckAnswer: true
@@ -12,27 +12,27 @@ material:
     answer: 1
 ---
 
-Congratulations! That concludes Lesson 5.
+Félicitations ! Vous avez terminé la Leçon 5.
 
-As a reward, we've transferred you your very own Level 10 **H4XF13LD MORRIS 💯💯😎💯💯** zombie!
+Comme récompense, nous vous avons transféré votre propre zombie de niveau 10 **H4XF13LD MORRIS 💯💯😎💯💯** !
 
-(Omg, the legendary **H4XF13LD MORRIS 💯💯😎💯💯** zombie!!!!111)
+(Omg, le légendaire zombie **H4XF13LD MORRIS 💯💯😎💯💯** zombie!!!!)
 
-Now you have 4 zombies in your army.
+Maintenant vous avez 4 zombies dans votre armée.
 
-Before you move on, you have the option to rename any of them if you'd like by clicking on them to the right and entering a new name. (Though I don't know why you would ever want to rename **H4XF13LD MORRIS 💯💯😎💯💯**, clearly the best name ever).
+Avons de continuer, vous avez la possibilité de renommer vos zombies en cliquant dessus. (Même si je ne vois pas pourquoi vous voudriez renommer **H4XF13LD MORRIS 💯💯😎💯💯**, c'est clairement le meilleur nom possible).
 
-## Let's recap:
+## Récapitulons :
 
-In this lesson we learned about:
+Dans cette leçon nous avons appris :
 
-- Tokens, the ERC721 standard, and tradable assets/zombies
-- Libraries and how to use them
-- How to prevent overflows and underflows using the SafeMath library
-- Commenting your code and the natspec standard
+- Tokens, le standard ERC721, et les actifs/zombies échangeables
+- Les bibliothèques et comment s'en servir
+- Comment empêcher les débordements en utilisant la bibliothèque SafeMath
+- Commenter son code et le standard natspec
 
-This lesson concludes our game's Solidity code! (For now — we may add even more lessons in the future).
+Cette leçon termine le code de notre jeu Solidity ! (Pour l'instant — il est possible de nous rajouterons plus de leçons).
 
-In the next 2 lessons, we're going to look at how to deploy your contracts and interact with them using **_web3.js_** (so you can build a front-end for your DApp).
+Dans les 2 prochaines leçons, nous allons voir comment déployer vos contrats et comment intéragir avec en utilisant **_web3.js_** (afin que vous puissiez faire un front-end pour votre DApp).
 
-Go ahead and rename any of your zombies if you like, then proceed to the next chapter to complete the lesson.
+Renommez un de vos zombies si vous le souhaitez, et passez au chapitre suivant pour terminer la leçon.

fr/5/15-lessoncomplete.md

@@ -1,5 +1,5 @@
 ---
-title: Lesson 5 Complete!
+title: Lesson 5 terminée !
 actions: ['vérifierLaRéponse', 'indice']
 material:
   lessonComplete: