Merge branch 'master' of https://github.com/loomnetwork/cryptozombie-…

…lessons into translation-fr

en/2/7-storage.md

@@ -90,7 +90,7 @@ contract SandwichFactory {
     // Sandwich mySandwich = sandwiches[_index];
 
     // ^ Seems pretty straightforward, but solidity will give you a warning
-    // telling you you should explicitly declare `storage` or `memory` here.
+    // telling you that you should explicitly declare `storage` or `memory` here.
 
     // So instead, you should declare with the `storage` keyword, like:
     Sandwich storage mySandwich = sandwiches[_index];

en/3/09-zombiemodifiers.md

@@ -210,4 +210,4 @@ function driveCar(uint _userId) public olderThan(16, _userId) {
 
 3. Then the function should set `zombies[_zombieId].name` equal to `_newName`.
 
-3. Create another function named `changeDna` below `changeName`. Its definition and contents will be almost identical to `changeName`, except its second argument will be `_newDna` (a `uint`), and it should pass in `20` for the `_level` parameter on `aboveLevel`. And of course, it should set the zombie's `dna` to `_newDna` instead of setting the zombie's name.
+4. Create another function named `changeDna` below `changeName`. Its definition and contents will be almost identical to `changeName`, except its second argument will be `_newDna` (a `uint`), and it should pass in `20` for the `_level` parameter on `aboveLevel`. And of course, it should set the zombie's `dna` to `_newDna` instead of setting the zombie's name.

en/index.ts

@@ -24,7 +24,7 @@ import l2_overview from './2/00-overview.md'
 import overview from './2/1-overview.md'
 import mappings from './2/2-mappings.md'
 import msgsender from './2/3-msgsender.md'
-import require from './2/4-require.md'
+import l2_require from './2/4-require.md'
 import inheritance from './2/5-inheritance.md'
 import importfiles from './2/6-importfiles.md'
 import storage from './2/7-storage.md'
@@ -97,7 +97,7 @@ export default {
     overview,
     mappings,
     msgsender,
-    require,
+    l2_require,
     inheritance,
     importfiles,
     storage,

en/lander.yml

@@ -32,6 +32,6 @@ en:
   footer_contact_jobs: Jobs
   footer_email: Email
   footer_about: About
-  footer_desc: CryptoZombies.io is a free teaching platform to teach existing developers or complete newcomers the ins and out of programming for the Blockchain. Powered by Loom Network - a platform for building commerical scale apps on Ethereum.
+  footer_desc: CryptoZombies.io is a free teaching platform to teach existing developers or complete newcomers the ins and out of programming for the Blockchain. Powered by Loom Network - a platform for building commercial scale apps on Ethereum.
   telegram_open_chat: Open Chat
   telegram_link: https://t.me/loomnetwork

es/1/00-overview.md

@@ -0,0 +1,12 @@
+---
+title: Creando la Fábrica de Zombies
+header: ¡Bienvenido, humano!
+roadmap: roadmap.jpg
+---
+
+¿Parece que crees tener lo que se necesita para convertirte en un **CryptoZombie**, eh?
+
+Este curso te enseñará cómo **crear un juego en Ethereum**.
+
+Está diseñado para principiantes en Solidity, pero asume que tienes alguna experiencia
+programando en algún otro lenguage (por ejemplo Javascript).

es/1/arrays.md

@@ -0,0 +1,75 @@
+---
+title: Arrays
+actions: ['checkAnswer', 'hints']
+material:
+  editor:
+    language: sol
+    startingCode: |
+      pragma solidity ^0.4.19;
+
+      contract ZombieFactory {
+
+          uint dnaDigits = 16;
+          uint dnaModulus = 10 ** dnaDigits;
+
+          struct Zombie {
+              string name;
+              uint dna;
+          }
+
+          // empieza aquí
+
+      }
+    answer: >
+      pragma solidity ^0.4.19;
+
+
+      contract ZombieFactory {
+
+          uint dnaDigits = 16;
+          uint dnaModulus = 10 ** dnaDigits;
+
+          struct Zombie {
+              string name;
+              uint dna;
+          }
+
+          Zombie[] public zombies;
+
+      }
+---
+
+Cuando quieres tener una colección de algo, puedes usar un **_array_**. Hay dos tipos de arrays en Solidity: arrays **_fijos_** y arrays **_dinámicos_**:
+
+```
+// Un Array con una longitud fija de 2 elementos:
+uint[2] fixedArray;
+// otro Array fijo, con longitud de 5 elementos:
+string[5] stringArray;
+// un Array dinámico, sin longitud fija que puede seguir creciendo:
+uint[] dynamicArray;
+```
+
+Tambien puedes crear arrays de **_structuras_**. Si usásemos la estructura `Person` del capítulo anterior:
+
+```
+Person[] people; // Array dinámico, podemos seguir añadiéndole elementos
+```
+
+¿Recuerdas que las variables de estado quedan guardadas permanentemente en la blockchain? Así que crear un array de estructuras puede ser muy útil para guardar datos estructurados en tu contrato, como una base de datos.
+
+## Arrays Públicos
+
+Puedes declarar un array como `público`, y Solidity creará automaticamente una función **_getter_** para acceder a él. La sintaxis es así:
+
+```
+Person[] public people;
+```
+
+Otros contratos podrían entonces leer (pero no escribir) de este array. Es un patrón de uso muy útil para guardar datos públicos en tu contrato.
+
+# Vamos a probarlo
+
+Vamos a guardar un ejército de zombis en nuestra aplicación. Y vamos a querer mostrar todos nuestros zombis a otras applicaciones, así que lo queremos público:
+
+1. Crear un array público de **_structuras_** `Zombie` y llámalo `zombies`.

es/1/arraysstructs2.md

@@ -0,0 +1,94 @@
+---
+title: Trabajando con estructuras y arrays
+actions: ['checkAnswer', 'hints']
+material:
+  editor:
+    language: sol
+    startingCode: |
+      pragma solidity ^0.4.19;
+
+      contract ZombieFactory {
+
+          uint dnaDigits = 16;
+          uint dnaModulus = 10 ** dnaDigits;
+
+          struct Zombie {
+              string name;
+              uint dna;
+          }
+
+          Zombie[] public zombies;
+
+          function createZombie(string _name, uint _dna) {
+              // empieza aquí
+          }
+
+      }
+    answer: >
+      pragma solidity ^0.4.19;
+
+
+      contract ZombieFactory {
+
+          uint dnaDigits = 16;
+          uint dnaModulus = 10 ** dnaDigits;
+
+          struct Zombie {
+              string name;
+              uint dna;
+          }
+
+          Zombie[] public zombies;
+
+          function createZombie(string _name, uint _dna) {
+              zombies.push(Zombie(_name, _dna));
+          }
+
+      }
+---
+
+### Creando nuevas Estructuras (Structs)
+
+¿Recuerdas las estructura `Person` en el ejemplo anterior?
+
+```
+struct Person {
+  uint age;
+  string name;
+}
+
+Person[] public people;
+```
+
+Ahora aprenderemos como crear un nuevo `Person` y añadirlo a nuestro array `people`.
+
+```
+// crear un nuevo `Person`
+Person satoshi = Person(172, "Satoshi");
+
+// añadir esta persona a nuestro array
+people.push(satoshi);
+```
+
+También podemos combinar estas dos cosas para hacerlas en una sola línea y mantener el código limpio:
+
+```
+people.push(Person(16, "Vitalik"));
+```
+
+Date cuenta que `array.push()` añade algo al **final** del array, así que los elementos siguen el orden de añadido. Observa este ejemplo:
+
+```
+uint[] numbers;
+numbers.push(5);
+numbers.push(10);
+numbers.push(15);
+// el array `numbers` es ahora [5, 10, 15]
+```
+
+# Vamos a probarlo
+
+¡Hagamos hacer algo a nuestra función `createZombie`!
+
+1. Rellena el cuerpo de la función para que cree un nuevo `Zombie` y añádelo al array `zombies`. El nombre (`name`) y ADN (`dna`) del nuevo Zombi debería venir de los argumentos pasados a la función.
+2. Hagámoslo en una sola línea de código para que quede bonito.

es/1/contracts.md

@@ -0,0 +1,56 @@
+---
+title: "Contratos"
+actions: ['checkAnswer', 'hints']
+material:
+  editor:
+    language: sol
+    startingCode: |
+      pragma solidity //1. Poner la versión de Solidity aquí
+
+      //2. Crear el contrato aquí
+    answer: >
+      pragma solidity ^0.4.19;
+
+
+      contract ZombieFactory {
+
+      }
+---
+
+Empecemos con lo más fundamental:
+
+El código Solidity está encapsulado en **contratos**. Un `contrato` es el bloque de construcción más básico de las aplicaciones de Ethereum — todas las variables y las funciones pertenecen a un contrato, y este será el punto de partida de todos tus proyectos.
+
+Un contrato vacio llamado `HolaMundo` se parecería a esto:
+
+```
+contract HolaMundo {
+
+}
+```
+
+## Versión Pragma
+
+Todo el código fuente en Solidity debería empezar con una declaración "version pragma" de la versión del compilador que debe de usarse para ese código. Esto previene problemas con versiones futuras del compilador que podrían no ser compatibles y fallar con tu código.
+
+Esta declaración se asemeja a esto: `pragma solidity ^0.4.19;` (para usar la última versión del compilador de Solidity actual, la 0.4.19).
+
+Poniendo todo junto, este es el esqueleto de como se empieza un contrato — lo primero que escribirás cada vez que empieces un nuevo proyecto:
+
+```
+pragma solidity ^0.4.19;
+
+contract HolaMundo {
+
+}
+```
+
+# Vamos a probarlo
+
+Para empezar a crear tu ejército de Zombis, vamos a crear un contrato base llamado `ZombieFactory` (Fábrica de Zombis).
+
+1. En la caja de la derecha, haz lo necesario para que el contrato use la versión de Solidity `0.4.19`.
+
+2. Crea un contrato vacio que se llame `ZombieFactory`.
+
+Cuando hayas terminado, haz clic en "comprobar respuesta" abajo. Si te quedas atascado, haz clic en "pistas".

es/1/datatypes.md

@@ -0,0 +1,50 @@
+---
+title: Variables de Estado y Números Enteros
+actions: ['checkAnswer', 'hints']
+material:
+  editor:
+    language: sol
+    startingCode: |
+      pragma solidity ^0.4.19;
+
+      contract ZombieFactory {
+
+          // empieza aquí
+
+      }
+    answer: >
+      pragma solidity ^0.4.19;
+
+
+      contract ZombieFactory {
+
+          uint dnaDigits = 16;
+
+      }
+---
+
+¡Buen trabajo! Ahora que tenemos una capa para nuestro contrato, aprendamos cómo maneja las variables Solidity.
+
+Las **_Variables de estado_** se guardan permanentemente en el almacenamiento del contrato. Esto significa que se escriben en la cadena de bloques de Ethereum. Piensa en ellos como en escribir en una base de datos.
+
+##### Ejemplo:
+```
+contract Example {
+  // Esto se guardará permanentemente en la cadena de bloques
+  uint myUnsignedInteger = 100;
+}
+```
+
+En este contrato de ejemplo, hemos creado un `uint` llamado `myUnsignedInteger` y le hemos dado el valor 100.
+
+## Enteros sin Signo: `uint`
+
+El tipo de dato `uint` es un entero sin signo, esto es **su valor siempre debe ser no-negativo**. Hay también un tipo de dato `int` para números enteros con signo.
+
+> Nota: En Solidity, `uint` es realmente un alias para `uint256`, un número entero de 256-bits. Puedes declarar uints con menos bits — `uint8`, `uint16`, `uint32`, etc.. Pero por lo general usaremos `uint` excepto en casos específicos, de los que hablaremos en otras lecciones más adelante.
+
+# Vamos a probarlo
+
+El ADN de nuestro Zombi va a estar determinado por un número de 16 dígitos.
+
+Declara una variable de tipo `uint` llamada `dnaDigits`, y asígnale el valor `16`.