fixes Lesson1

fr/1/00-overview.md

@@ -8,5 +8,5 @@ Vous pensez avoir ce qu´il faut pour devenir un **CryptoZombie**, hein ?
 
 Ce cours vous apprendra comment **réaliser un jeu basé sur Ethereum**.
 
-Il est conçu pour les débutants à Solidity, mais il est préférable que vous ayez de l'expérience en
+Il est conçu pour les débutants en Solidity, mais il est préférable que vous ayez de l'expérience en
 programmation dans un autre langage (Javascript par exemple).

fr/1/arrays.md

@@ -39,36 +39,36 @@ material:
       }
 ---
 
-Quand vous voulez regrouper des éléments, vous pouvez utiliser un **_tableau_** (array en anglais). il y a deux sortes de tableaux dans Solidity : les tableaux  **_fixes_** et les tableaux **_dynamiques_** :
+Quand vous voulez regrouper des éléments, vous pouvez utiliser un **_tableau_** (array). il y a deux sortes de tableaux dans Solidity : les tableaux  **_fixes_** et les tableaux **_dynamiques_** :
 
 ```
 // Tableau avec une longueur fixe de 2 éléments :
 uint[2] fixedArray;
-// Un autre Tableau fixe, qui peut contenir 5 chaînes de caractères (string en anglais) :
+// Un autre Tableau fixe, qui peut contenir 5 `string` :
 string[5] stringArray;
 // un Tableau dynamique, il n'a pas de taille fixe, il peut continuer de grandir :
 uint[] dynamicArray;
 ```
 
-Vous pouvez aussi créer un tableau de **_structs_**. En utilisant la structure Person du chapitre précédent :
+Vous pouvez aussi créer un tableau de **_structure_**. En utilisant la structure Person du chapitre précédent :
 
 ```
 Person[] people; // Tableau dynamique, on peut en rajouter sans limite.
 ```
 
-Rappelez-vous que les variables d'état sont stockées définitivement dans la blockchain. Il peut donc être utile de créer des tableaux dynamique de structures de ce type pour stocker des données structurées dans votre contrat, un peu comme une base de données.
+Vous vous rappelez que les variables d'état sont stockées définitivement dans la blockchain ? Il peut donc être utile de créer des tableaux dynamique de structure pour stocker des données structurées dans votre contrat, un peu comme une base de données.
 
-## Tableaux Public
+## Tableaux publics
 
-Vous pouvez déclarer un tableau comme `public`, et Solidity créera automatiquement une méthode **_ getter _**. La syntaxe ressemble à:
+Vous pouvez déclarer un tableau comme `public`, et Solidity créera automatiquement une méthode **_d'accès_**. La syntaxe ressemble à :
 
 ```
 Person[] public people;
 ```
-Les autres contrats vont pouvoir lire (mais pas écrire) ce tableau. C'est donc un modèle utile pour stocker des données publiques dans votre contrat.
+Les autres contrats vont pouvoir lire (mais pas écrire) ce tableau. C'est donc une façon utile pour stocker des données publiques dans votre contrat.
 
 # A votre tour
 
 Nous allons vouloir stocker une armée de zombies dans notre application. Et nous allons vouloir montrer tous nos zombies à d'autres applications, cette armée devra donc être publique.
 
-1. Créez un tableau public de **_structs_** `Zombie`, et appelez le `zombies`.
+1. Créez un tableau public de **_structures_** `Zombie`, et appelez le `zombies`.

fr/1/arraysstructs2.md

@@ -1,5 +1,5 @@
 ---
-title: Manipuler des Structures et des Tableaux
+title: Manipuler des structures et des tableaux
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -47,7 +47,7 @@ material:
       }
 ---
 
-### Creer de nouvelles Structures
+### Créer de nouvelles structures
 
 Vous vous rappelez de notre structure `Person` dans l'exemple précédent ?
 
@@ -69,7 +69,7 @@ Person satoshi = Person(172, "Satoshi");
 // L'ajouter au tableau :
 people.push(satoshi);
 ```
-Pour garder un code plus concis, on peut aussi écrire cela en une ligne en combinant les déclarations :
+Pour avoir un code plus concis, on peut aussi écrire cela en une ligne en combinant les déclarations :
 
 ```
 people.push(Person(16, "Vitalik"));
@@ -89,6 +89,6 @@ numbers.push(15);
 
 Faisons faire quelque chose à notre fonction createZombie !
 
-1. Remplissez le corps de la fonction afin qu'elle crée un nouveau `Zombie` et qu'elle l'ajoute au tableau` zombies`. Les noms `name` et `dna` pour le nouveau Zombie devraient provenir des arguments de la fonction.
+1. Remplissez le corps de la fonction afin qu'elle crée un nouveau `Zombie` et qu'elle l'ajoute au tableau `zombies`. Les noms `name` et `dna` pour le nouveau Zombie devraient provenir des arguments de la fonction.
 
-2. Faisons-le en une ligne de code pour garder les choses concises.
+2. Faites-le en une ligne de code pour garder les choses concises.

fr/1/contracts.md

@@ -19,19 +19,19 @@ material:
 
 Commençons par les bases :
 
-Un **contrats** permet d'encapsuler du code Solidity, c'est la composante fondamentale de toutes les applications Ethereum - toutes les variables et fonctions appartiennent à un contrat, et ce sera le point de départ de tous vos projets.
+Un **contrat** (contract) permet d'encapsuler du code Solidity, c'est la composante fondamentale de toutes applications Ethereum - toutes les variables et fonctions appartiennent à un contrat, et ce sera le point de départ de tous vos projets.
 
-Un contrat vide nommé `HelloWorld` ressemblerait à ceci:
+Un contrat vide nommé `HelloWorld` ressemblerait à ceci :
 
 ```
 contract HelloWorld {
 
 }
 ```
 
-## Pragma Version
+## Pragma version
 
-Tout code source de Solidity devrait commencer par un "pragma version" - une déclaration de la version du compilateur Solidity que ce code devra utiliser. Cela permet d'éviter d'éventuels problèmes liés aux changements introduits par des futures versions du compilateur.
+Tout code source en Solidity doit commencer par un "pragma version" - une déclaration de la version du compilateur Solidity que ce code devra utiliser. Cela permet d'éviter d'éventuels problèmes liés aux changements introduits par des futures versions du compilateur.
 
 Cela ressemble à ça : `pragma solidity ^0.4.19;` (la dernière version de Solidity au moment de la rédaction de cet article étant 0.4.19).
 
@@ -53,4 +53,4 @@ Pour commencer à créer notre armée de Zombies, créons un contrat de base app
 
 2. Créez un contrat vide appelé `ZombieFactory`.
 
-Lorsque vous avez terminé, cliquez sur "vérifier la réponse" ci-dessous. Si vous êtes bloqué, vous pouvez cliquer sur "indice".
+Lorsque vous avez terminé, cliquez sur "Vérifier La Réponse" ci-dessous. Si vous êtes bloqué, vous pouvez cliquer sur "Indice".

fr/1/datatypes.md

@@ -1,5 +1,5 @@
 ---
-title: Variables d'État et Entiers
+title: Variables d'état et entiers
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -25,7 +25,7 @@ material:
 
 Bien joué ! Maintenant que nous avons une structure pour notre contrat, voyons voir comment Solidity gère les variables.
 
-**_ Les variables d'état _** sont stockées de manière permanente dans le stockage du contrat. Cela signifie qu'elles sont écrites dans la blockchain Ethereum. C'est comme écrire dans une base de données.
+**_Les variables d'état_** sont stockées de manière permanente dans le stockage du contrat. Cela signifie qu'elles sont écrites dans la blockchain Ethereum. C'est comme écrire dans une base de données.
 
 ##### Exemple:
 ```
@@ -41,7 +41,7 @@ Dans cet exemple de contrat, nous avons créé un `uint` appelé `myUnsignedInte
 
 Le type de données `uint` est un entier non signé, cela veut dire que **sa valeur doit être non négative**. Il existe aussi un type de données `int` pour les entiers signés.
 
-> Remarque: Dans Solidity, `uint` est en fait un alias pour` uint256`, un entier non signé de 256 bits. Vous pouvez déclarer des uints avec moins de bits - `uint8`,` uint16`, `uint32`, etc. Mais en général il est plus simple d'utiliser `uint` sauf dans des cas spécifiques que nous aborderons dans les leçons suivantes.
+> Remarque: En Solidity, `uint` est en fait un alias pour` uint256`, un entier non signé de 256 bits. Vous pouvez déclarer des uints avec moins de bits - `uint8`,` uint16`, `uint32`, etc. Mais en général il est plus simple d'utiliser `uint` sauf dans des cas spécifiques que nous aborderons dans les leçons suivantes.
 
 
 # A votre tour

fr/1/events.md

@@ -73,19 +73,19 @@ material:
       }
 ---
 
-Notre contrat est presque fini ! nous allons maintenant ajouter un **_ évènement _**.
+Notre contrat est presque fini ! nous allons maintenant ajouter un **_ évènement _** (event).
 
 Un **_ évènement _** est un moyen pour votre contrat d'indiquer à votre application frontale (front-end) que quelque chose vient d'arriver sur la blockchain, l'application frontale pouvant être «à l'écoute» de certains événements pour prendre des mesures quand ils se produisent.
 
-Exemple:
+Exemple :
 
 ```
 // déclaration de l'évènement
 event IntegersAdded(uint x, uint y, uint result);
 
 function add(uint _x, uint _y) public {
   uint result = _x + _y;
-  // déclanchement de l'évènement pour indiquer à l'application que la fonction a été appelée :
+  // déclenchement de l'évènement pour indiquer à l'application que la fonction a été appelée :
   IntegersAdded(_x, _y, result);
   return result;
 }

fr/1/functions.md

@@ -45,7 +45,7 @@ material:
       }
 ---
 
-Une déclaration de fonction en Solidity ressemble à ça :
+Une déclaration de fonction (function) en Solidity ressemble à ça :
 
 ```
 function eatHamburgers(string _name, uint _amount) {
@@ -54,7 +54,7 @@ function eatHamburgers(string _name, uint _amount) {
 ```
 C'est une fonction appelée `eatHamburgers` qui prend 2 paramètres : un `string` et un `uint`. Le corps de la fonction est vide pour l'instant.
 
-> Remarque: Par convention (mais ce n'est pas obligatoire), les noms des arguments des fonctions commencent avec un trait de soulignement (`_`) afin de les différencier des variables globales. Nous utiliserons cette convention tout au long de notre tutoriel.
+> Remarque: Par convention (mais ce n'est pas obligatoire), les noms des paramètres des fonctions commencent avec un trait de soulignement (`_`) afin de les différencier des variables globales. Nous utiliserons cette convention tout au long de notre tutoriel.
 
 Vous pouvez appeler la fonction comme cela :
 

fr/1/functions2.md

@@ -1,5 +1,5 @@
 ---
-title: Fonctions Privées / Publiques
+title: Fonctions privées / publiques
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:

fr/1/functions3.md

@@ -56,6 +56,7 @@ material:
 Dans ce chapitre, nous allons apprendre les **_valeurs retournées_** des fonctions, ainsi que les modificateurs de fonction.
 
 ## Valeurs retournées
+
 Pour retourner une valeur à partir d'une fonction, cela ressemble à ça :
 
 ```
@@ -68,7 +69,7 @@ function sayHello() public returns (string) {
 
 En Solidity, une déclaration de fonction indique le type de la valeur retournée (dans ce cas `string`).
 
-## Modificateur de fonctions
+## Modificateurs de fonction
 
 La fonction ci-dessus ne change pas un état en Solidity - c.-à-d. elle ne change pas une valeur et n'écrit rien.
 
@@ -86,11 +87,11 @@ function _multiply(uint a, uint b) private pure returns (uint) {
 ```
 Cette fonction ne lit aucune donnée du contrat - elle retourne une valeur qui dépend seulement de ses arguments. Dans ce cas là, nous déclarerons la fonction comme **_pure_**.
 
-> Remarque: Il peut être difficile de se rappeler quand marquer les fonctions comme étant pure/view. Heureusement, le compilateur Solidity est bon pour vous avertir quand vous devriez utiliser l'un de ces modificateurs.
+> Remarque: Il peut être difficile de se rappeler quand marquer les fonctions comme étant pure/view. Heureusement, le compilateur Solidity est bon pour vous avertir quand vous devriez utiliser l'un ou l'autre de ces modificateurs.
 
 # A votre tour
 
-Nous allons vouloir une fonction d'aide pour générer un nombre ADN aléatoire à partir d'un string.
+Nous allons vouloir une fonction d'aide pour générer un nombre ADN aléatoire à partir d'une chaîne de caractères.
 
 1. Créez une fonction `private` appelée `_generateRandomDna`. Elle prendra un paramètre nommé `_str` (un `string`), et retournera un `uint`.
 

fr/1/keccak256.md

@@ -1,5 +1,5 @@
 ---
-title: Keccak256 et Conversion de type
+title: Keccak256 et conversion de type
 actions: ['vérifierLaRéponse', 'indice']
 material:
   editor:
@@ -56,9 +56,9 @@ material:
       }
 ---
 
-Nous voulons que notre fonction `_generateRandomDna` retourne un `uint` (presque) aléatoire. Comment pouvons-nous faire cela ?
+Comment faire pour que notre fonction `_generateRandomDna` retourne un `uint` (presque) aléatoire ?
 
-Ethereum a la fonction de hachage `keccak256` intégrée, qui est une version de SHA3. Une fonction de hachage permet fondamentalement de lier une chaîne d'entrée à un nombre hexadécimal aléatoire de 256 bits. Le moindre changement dans la chaîne provoquera un grand changement dans le hachage.
+Ethereum a la fonction de hachage `keccak256` intégrée, qui est une variante de SHA3. Une fonction de hachage permet fondamentalement de lier une chaîne d'entrée à un nombre hexadécimal aléatoire de 256 bits. Le moindre changement dans la chaîne provoquera un grand changement dans le hachage.
 
 Cela sert à beaucoup de chose pour Ethereum, mais pour l'instant nous allons simplement l'utiliser pour générer un nombre pseudo-aléatoire.
 
@@ -70,9 +70,9 @@ keccak256("aaaab");
 //b1f078126895a1424524de5321b339ab00408010b7cf0e6ed451514981e58aa9
 keccak256("aaaac");
 ```
-Comme vous pouvez le voir, les valeurs retournées sont complètement différentes alors qu'il y a seulement 1 caractère de changer à l'argument d'entrée.
+Comme vous pouvez le voir, les valeurs retournées sont complètement différentes alors qu'il y a seulement 1 caractère de changé à l'argument d'entrée.
 
-> Remarque: La génération de nombres aléatoires **sécurisés** dans la blockchain est un problème très complexe. Notre méthode ici n'est pas sécurisée, mais comme la sécurité n'est pas la grande priorité de notre ADN Zombie, cela sera suffisante pour notre usage.
+> Remarque: La génération de nombres aléatoires **sécurisés** dans la blockchain est un problème très complexe. Notre méthode ici n'est pas sécurisée, mais comme la sécurité n'est pas la grande priorité de notre ADN Zombie, cela sera suffisant pour notre usage.
 
 ## Conversion de type
 

fr/1/lessoncomplete.md

@@ -1,20 +1,20 @@
 ---
-title: Leçon 1 Complétée !
+title: Leçon 1 complétée !
 actions: ['vérifierLaRéponse', 'indice']
 material:
   lessonComplete:
     answer: 1
 ---
 
-Félicitations ! Vous avez terminé la leçon 1, et vous avez créé le premier zombie de votre armée.
+Félicitations ! Vous avez terminé la Leçon 1, et vous avez créé le premier zombie de votre armée.
 
 # Prochaines étapes
 
 Ce n'est que le début. Chaque semaine, nous allons publier une nouvelle leçon CryptoZombies, pour faire évoluer le jeu de plus en plus et continuer de faire grandir votre armée de zombies.
 
 ### 1. Connectez-vous pour sauvegarder vos progrès
 
-**_Connectez-vous_** pour sauvegarder vos progrès en cliquant sur le lien "Save Progress" en haut de la page. Nous vous informerons dès qu'une nouvelle leçon sera disponible.
+**_Connectez-vous_** pour sauvegarder vos progrès en cliquant sur le lien "Sauvegarder" en haut de la page. Nous vous informerons dès qu'une nouvelle leçon sera disponible.
 
 ### 2. Partagez votre zombie avec vos amis
 

fr/1/lessonoverview.md

@@ -1,5 +1,5 @@
 ---
-title: Aperçu de la leçon
+title: Aperçu de la Leçon
 actions: ['vérifierLaRéponse', 'indice']
 skipCheckAnswer: true
 material:
@@ -10,9 +10,9 @@ material:
     answer: 1
 ---
 
-Dans la leçon 1, vous allez faire une "usine de zombies" afin d'avoir une armée de zombies.
+Dans la Leçon 1, vous allez faire une "Usine de Zombies" pour avoir une armée de zombies.
 
-* Notre usine maintiendra une base de données des zombies de notre armée
+* Notre usine maintiendra une base de données de tous les zombies de notre armée
 * Notre usine aura une fonction pour créer de nouveaux zombies
 * Chaque zombie aura une apparence aléatoire et unique
 
@@ -28,9 +28,9 @@ L'apparence du zombie va dépendre de son "ADN Zombie". L'ADN d'un Zombie est si
 
 Tout comme l'ADN réel, différentes parties de ce nombre représenteront différents traits. Les 2 premiers chiffres correspondent au type de tête du zombie, les 2 derniers chiffres aux yeux du zombie, etc.
 
-> Remarque : Pour ce tutoriel, nous avons fait simple, et nos zombies peuvent avoir seulement 7 types de têtes différentes (même si 2 chiffres permettent 100 options possibles). Plus tard, nous pourrions ajouter plus de types de têtes si nous voulions augmenter le nombre de variations de zombies.
+> Remarque : Pour ce tutoriel, nous avons fait simple, et nos zombies peuvent avoir seulement 7 types de têtes différentes (même si 2 chiffres permettent 100 options possibles). Plus tard, nous pourrions ajouter plus de types de têtes si nous voulions augmenter le nombre de zombies possibles.
 
-Par exemple, les 2 premiers chiffres de note ADN exemple sont `83`. Pour faire correspondre à un type de tête, nous devons faire `83 % 7 + 1` = 7. Ce Zombie aura donc le 7ième type de tête.
+Par exemple, les 2 premiers chiffres de notre ADN exemple sont `83`. Pour les faire correspondre à un type de tête, nous devons faire `83 % 7 + 1` = 7. Ce Zombie aura donc le 7ième type de tête.
 
 Dans le panneau de droite, essayez de déplacer le curseur `head gene` (gène pour la tête) sur la 7ème tête (le bonnet de Noël) pour voir à quel trait correspond le `83`.
 
@@ -39,4 +39,4 @@ Dans le panneau de droite, essayez de déplacer le curseur `head gene` (gène po
 
 1. Jouez avec les curseurs sur le côté droit de la page. Testez pour voir comment les différentes valeurs numériques influent sur les différents aspects de l'apparence du zombie.
 
-Allez, assez jouer. Lorsque vous êtes prêt à continuer, cliquez sur "Next Chapter" ci-dessous, et plongeons dans l'apprentissage de Solidity !
+Allez, assez jouer. Lorsque vous êtes prêt à continuer, cliquez sur "Chapitre Suivant" ci-dessous, et plongeons dans l'apprentissage de Solidity !

fr/1/math.md

@@ -26,13 +26,13 @@ material:
 
 ---
 
-Les mathématiques en Solidity sont assez simples. Les opérations sont les mêmes dans la plupart des langages de programmation :
+Les opérations Mathématiques en Solidity sont assez simples. Les opérations sont les mêmes dans la plupart des langages de programmation :
 
 * Addition : `x + y`
-* Soustraction : `x - y`,
+* Soustraction : `x - y`
 * Multiplication : `x * y`
 * Division : `x / y`
-* Modulo / reste : `x % y` _(par exemple, `13 % 5` est `3`, car si vous divisez 13 par 5)_
+* Modulo / reste : `x % y` _(par exemple, `13 % 5` est `3`, car si vous divisez 13 par 5, le reste est 3)_
 
 Solidity prend aussi en charge l'**_opérateur exponentiel_** (c.-à-d. "x à la puissance y", x^y) :
 
@@ -42,6 +42,6 @@ uint x = 5 ** 2; // égal à 5^2 = 25
 
 # A votre tour
 
-Pour être sûr que notre ADN Zombie est de seulement 16 chiffres, définissons un autre `uint` égal à 10^16. Comme ça, nous pourrons plus tard utiliser l'opérateur modulo `%` pour raccourcir un entier à 16 chiffres.
+Pour être sûr que notre ADN Zombie est seulement de 16 chiffres, définissons un autre `uint` égal à 10^16. Comme ça, nous pourrons plus tard utiliser l'opérateur modulo `%` pour raccourcir un entier à 16 chiffres.
 
 1. Créez un `uint` appelé `dnaModulus`, et définissez-le égal à **10 à la puissance `dnaDigits`**.

fr/1/puttingittogether.md

@@ -64,7 +64,7 @@ material:
       }
 ---
 
-Nous avons bientôt terminé notre générateur de Zombie aléatoire ! Créons une fonction publique qui va regrouper le tout.
+Nous avons bientôt terminé notre générateur de Zombie aléatoire ! Créons une fonction publique qui va regrouper tout ça.
 
 Nous allons créer une fonction publique qui prend un paramètre, le nom du zombie, et utilise ce nom pour créer un zombie avec un ADN aléatoire.