Spanish translation (es_MX)

README-es_MX.md

@@ -0,0 +1,55 @@
+[![Code-samples-compile](https://github.com/iolivia/rust-sokoban/workflows/Code-samples-compile/badge.svg)](https://github.com/iolivia/rust-sokoban/actions?query=workflow%3ACode-samples-compile)
+[简体中文](README-zh_CN.md) [English](README.md)
+
+# [Rust sokoban](https://sokoban.iolivia.me)
+
+## :dart: ¿Qué tenemos aquí?
+Este repositorio hospeda el libro Rust Sokoban y el código fuente utilizado en el libro. Utiliza [mdbook](https://github.com/rust-lang/mdBook). Puedes leer el libro en [sokoban.iolivia.me](https://sokoban.iolivia.me/es_mx). 
+
+<img src="books/es_MX/src/images/readme.gif" width="80%">
+
+## :running: ¿Cómo?
+
+### Hospedar el libro de forma local
+Si aún no lo haces, instala mdbook.
+
+```
+$ cargo install mdbook
+```
+
+Sirve el libro y navega a http://localhost:3000 en tu navegador local.
+```
+$ mdbook serve
+```
+
+### Ejecutar el código de forma local
+```
+$ cd code/rust-sokoban-c01-01
+$ cargo run --release
+```
+
+## :muscle: Contribuir
+
+### Agregar una nueva sección
+1. Copia la versión más reciente de la carpeta `code/rust-sokoban-x` a `code/rust-sokoban-x+1`
+1. Agrega los cambios al código del tema que quieres ilustrar, intenta mantener cada sección autocontenida y relativamente sencilla de comprender
+1. Asegúrate de que el código compila (idealmente sin advertencias)
+1. Agrega una nueva entrada en `src/SUMMARY.md` - cada archivo md debería seguir el formato  `cxx-yy-text.md`
+1. Llena el contenido utilizando sintaxis markdown y para las referencias de código utiliza números de línea que apunten a la carpeta `code/rust-sokoban-x+1`
+1. Agrega un gif hacia el final de la nueva sección para demostrar la nueva característica - crea una grabación de la pantalla y conviértela a gif (yo utilizo ffmpeg para esto - `ffmpeg -i Screen_Recording.mov -r 60 -f gif - > moves.gif`)
+1. Si agregas un listado de árbol de directorios, utiliza tree - `tree --dirsfirst -I target`
+1. Crea un pull request y espera por los :clap: :tada:
+
+### Crear una incidencia
+Da un vistazo a las incidencias ya existentes para asegurar que tu duda aún no ha sido resuelta, si no la encuentras ¡crea una nueva!
+
+### Ayuda con una traducción
+1. Crea una copia de la carpeta books/en_US con el código ISO de la nueva traducción (por ejemplo fr_FR, ve la [lista](http://www.lingoes.net/en/translator/langcode.htm))
+1. Indica el idioma en book.toml
+1. Traduce SUMMARY.md en primer lugar
+1. Traduce cada capítulo/sub-capítulo, intenta no modificar ninguna des las imágenes/sonidos/videos o alguna parte de la estructura del libro
+1. Siéntete libre de crear un pull request borrador tan pronto como tengas unas cuantas páginas traducidas, esto dará a conocer tu trabajo a otros colaboradores
+1. Cuando la traducción esté lista, notifica al dueño del repositorio, se requiere un cambio en el CI para publicar el libro a un nuevo subdominio (sokoban.iolivia.me/fr_fr en este ejemplo)
+
+## :car: License
+MIT

README.md

@@ -1,5 +1,5 @@
 [![Code-samples-compile](https://github.com/iolivia/rust-sokoban/workflows/Code-samples-compile/badge.svg)](https://github.com/iolivia/rust-sokoban/actions?query=workflow%3ACode-samples-compile)
-[简体中文](README-zh_CN.md)
+[简体中文](README-zh_CN.md) [Spanish](README-es_MX.md)
 # [Rust sokoban](https://sokoban.iolivia.me)
 
 ## :dart: What is it?

books/es_MX/book.toml

@@ -0,0 +1,16 @@
+[book]
+title = "Rust sokoban"
+authors = []
+language = "es"
+multilingual = false
+src = "src"
+
+[build]
+build-dir = "./../../build"
+
+[output.html]
+google-analytics = "UA-26280927-4"
+additional-css = ["custom.css"]
+additional-js = ["custom.js"]
+git-repository-url = "https://github.com/iolivia/rust-sokoban"
+git-repository-icon = "fa-github"

books/es_MX/custom.css

@@ -0,0 +1,32 @@
+/* Themes */
+
+.ayu {
+    --codelink-bg: #232930;
+    --codelink-border: #464e59;
+}
+
+.coal {
+    --codelink-bg: #4a4a4a;
+    --codelink-border: #a9a9a9;
+}
+
+.light {
+    --codelink-bg: #f0feeb;
+    --codelink-border: #e9e9e9;
+}
+
+.navy {
+    --codelink-bg: #24262b;
+    --codelink-border: #14191f;
+}
+
+.rust {
+    --codelink-bg: #fff2e3;
+    --codelink-border: #d2d2d2;
+}
+
+blockquote.code-link {
+    background-color: var(--codelink-bg);
+    border-top: .1em solid var(--codelink-border);
+    border-bottom: .1em solid var(--codelink-border);
+}

books/es_MX/custom.js

@@ -0,0 +1,11 @@
+function addCodeLinkClass() {
+    var elements = document.getElementsByTagName("blockquote");
+    for (var i = 0; i < elements.length; i += 1) {
+        var element = elements.item(i);
+        if (element.innerHTML.includes("CODELINK")) {
+            element.className = "code-link";
+        }
+    }
+}
+
+addCodeLinkClass();

books/es_MX/src/SUMMARY.md

@@ -0,0 +1,19 @@
+# Índice
+
+- [Juego base](./c01-00-intro.md)
+    - [Configuración del proyecto](./c01-01-setup.md)
+    - [Entidades, componentes y sistemas](./c01-02-ecs.md)
+    - [Componentes y entidades](./c01-03-entities-components.md)
+    - [Sistema de renderizado](./c01-04-rendering.md)
+- [Jugabilidad](./c02-00-intro.md)
+    - [Carga del mapa](./c02-01-map-loading.md)
+    - [Moviendo al jugador](./c02-02-move-player.md)
+    - [Empujando cajas](./c02-03-push-box.md)
+    - [Módulos](./c02-04-modules.md)
+    - [Jugabilidad](./c02-05-gameplay.md)
+- [Jugabilidad avanzada](./c03-00-intro.md)
+    - [Cajas de colores](./c03-01-colours.md)
+    - [Animaciones](./c03-02-animations.md)
+    - [Sonidos y eventos](./c03-03-sounds-events.md)
+    - [Renderizado por lotes](./c03-04-batch-rendering.md)
+

books/es_MX/src/c01-00-intro.md

@@ -0,0 +1,42 @@
+# Capítulo 1: Juego base
+¡Bienvenido a **Rust Sokoban**!
+
+## ¿Qué es Rust Sokoban?
+Rust Sokoban es un tutorial sobre cómo crear una copia del juego [Sokoban](https://en.wikipedia.org/wiki/Sokoban) en el lenguaje de programación Rust. Haremos uso de un motor de juegos 2D ya existente, materiales pre hechos y al final tendremos un juego completamente funcional.
+
+## ¿Quién creó este libro? 
+Este libro fue escrito por [@oliviff](https://twitter.com/oliviff) con la ayuda de varios colaboradores impresionantes: [Blaine](https://github.com/wbprice), [Ivan](https://github.com/zubivan), [cobans](https://github.com/cobans), [Hector](https://github.com/rojashr), [Matt](https://github.com/mysterycommand), [Guilhermo](https://github.com/GuilhermoReadonly) y [Christian](https://github.com/ChristianIsaacRoy).
+
+## ¿Por qué Rust?
+Inicié mi aprendizaje de Rust en marzo de 2019 y desde entonces he estado creando un juego en este lenguaje. En el proceso he aprendido mucho sobre Rust, sobre crear juegos, escrito algunos artículos en línea y aprendido mucho sobre el ecosistema de desarrollo de juegos en Rust. En este libro estoy escribiéndolo todo y con suerte ayudando a más personas a involucrarse en el desarrollo de juegos con Rust.
+
+## ¿Necesito saber Rust?
+¡No, no necesitas saber Rust! Este libro debería servir como introducción a la creción de juegos en Rust, explicará algo de la sintaxis y conceptos básicos de Rust, y está enfocado para darte suficiente información que puedas leer por tu cuenta sobre cada tema y concepto. Recomiendo seguir todo el libro paso por paso y si hay algo que te gustaría entender mejor, usualmente encontrarás un enlace web hacia un recurso que lo explique con más detalle. Este libro no está enfocado en ser un recorrido a fondo de todas las características de Rust, sino una amable introducción al lenguaje realizando una tarea pequeña y divertida.
+
+## Formato del libro
+Verás enlaces como este que te llevarán a recursos donde puedes aprender más sobre los conceptos presentados, ya sea relacionados con Rust o con el desarrollo de juegos.
+> **_MORE:_**  Más información aquí.
+
+También verás enlaces como el siguiente que apuntarán al código completo del capítulo. En ocasiones no todo el código estará incluído en la sección, así que echa un ojo a estos para tener detalles como las importaciones, el orden del código, etc.
+> **_CODELINK:_**  Puedes encontrar el código completo de este ejemplo aquí.
+
+
+## Recursos
+Si necesitas ayuda o tienes alguna pregunta, aquí hay algunos buenos lugares a los cuales recurrir:
+* [The Rust programming language book](https://amzn.to/2tXzRdP)
+* [Rust learning by example](https://doc.rust-lang.org/rust-by-example/)
+* [Rust in motion course](https://www.manning.com/livevideo/rust-in-motion?a_aid=cnichols&a_bid=6a993c2e)
+* [r/rust](http://reddit.com/r/rust)
+* [r/rustgamedev](http://reddit.com/r/rust_gamedev)
+* [#rustlang](https://twitter.com/hashtag/rustlang)
+* [@rustlang](https://twitter.com/rustlang)
+* [@rust_gamedev](https://twitter.com/rust_gamedev)
+
+
+Una de las mejores cosas de Rust es la gente detrás. Hay una comunidad increíble allá afuera así que por favor siéntete animado a comunicarte con cualquiera de nosotros.
+
+Ahora que hemos terminado la introducción, empecemos con la creción de nuestro primer juego en Rust (bueno, técnicamente será mi segundo, pero con ilusión tu primero).
+
+
+_______
+Hecho con 🦀 y 🧡 por [@oliviff](https://twitter.com/oliviff)

books/es_MX/src/c01-01-setup.md

@@ -0,0 +1,157 @@
+# Configuración del proyecto
+Vamos a instalar [rustup](https://www.rust-lang.org/tools/install), con esto tendremos Rust y el compilador Rust. Ahora revisemos que todo esté instalado correctamente mediante los siguientes dos comandos; las versiones no deberían importar demasiado así que no te preocupes si las tuyas son diferentes.
+
+```
+$ rustc --version
+rustc 1.40.0
+$ cargo --version
+cargo 1.40.0
+```
+
+## Creación de un proyecto
+
+Cargo es el administrador de paquetes de Rust, lo utilizaremos para crear nuestro proyecto de juego. Muévete a un directorio en donde te gustaría que se encuentre el juego y ejecuta el comando siguiente, con esto crearemos un nuevo proyecto llamado `rust-sokoban` utilizando cargo.
+
+```
+$ cargo init rust-sokoban
+```
+
+Después de que el comando se ha ejecutado deberías tener la siguiente estructura de carpetas.
+
+```
+├── src
+│   └── main.rs
+└── Cargo.toml
+```
+
+Ahora podemos ejectuar `cargo run` en este directorio y deberíamos ver algo como lo siguiente.
+
+```
+$ cargo run
+   Compiling rust-sokoban v0.1.0
+    Finished dev [unoptimized + debuginfo] target(s) in 1.30s
+     Running `../rust-sokoban/target/debug/rust-sokoban`
+Hello, world!
+```
+
+## Convirtiéndolo en un juego
+¡Es momento de converitr este proyecto básico hola mundo en un juego! Utilizaremos [ggez](https://ggez.rs/), uno de los motores de juegos 2D populares que existen.
+
+¿Recuerdas el archivo `Cargo.toml` que vimos en nuestro directorio? Ese archivo se utiliza para la administración de crates (equivalente a biblioteca, dependencia o paquete en otros lenguajes), si queremos utilizar alguno de los crates de Rust los agregaremos a este archivo. Agreguemos [ggez](https://github.com/ggez/ggez) como una de nuestras dependencias.
+
+> **_MORE:_**  Lee más sobre Cargo y los archivos toml [aquí](https://doc.rust-lang.org/book/ch01-03-hello-cargo.html).
+
+```toml
+[dependencies]
+{{#include ../../../code/rust-sokoban-c01-01/Cargo.toml:10}}
+```
+
+
+Ahora ejecutemos `cargo run` nuevamente y deberías ver algo como lo siguiente. Debería tomar un poco más de tiempo ya que buscará estas nuevas dependencias en [crates.io](https://crates.io), luego las compilará y finalmente las enlazará a nuestra biblioteca.
+
+```
+cargo run
+    Updating crates.io index
+    Downloaded ....
+    ....
+    Compiling ....
+    ....
+    Finished dev [unoptimized + debuginfo] target(s) in 2m 15s
+    Running `.../rust-sokoban/target/debug/rust-sokoban`
+    Hello, world!
+```
+
+> **_NOTA:_** Si estás siguiendo esta guía en Ubuntu, podrías necesitar instalar algunas dependencias adicionales. Si el paso anterior falla y ves algunos errores relacionados con `alsa` y `libudev`, instálalos ejecutando
+```sudo apt-get install libudev-dev libasound2-dev```.
+
+Ahora utilicemos ggez en el archivo principal y configuremos nuestra ventana. Este es el ejemplo más simple de un programa ggez que nos mostrará una ventana y nada más. Copia y pega lo siguiente en el archivo `main.rs` y ejecútalo de nuevo.
+
+```rust
+{{#include ../../../code/rust-sokoban-c01-01/src/main.rs}}
+```
+
+Deberías poder ver algo como esto.
+
+![Screenshot](./images/window.png)
+
+## Conceptos básicos y sintaxis
+
+Ahora que tenemos nuestra ventana básica, ahondaremos en el código que tenemos en main para entender algunos conceptos y la sintaxis de Rust.
+
+### Importaciones
+Posiblemente este es un concepto familiar de otros lenguajes de programación que conozcas, para poder tener disponibles tipos y espacios de nombre de nuestras dependencias (o crates) simplemente tenemos que declararlos utilizando `use`.
+
+```rust
+// esto importará conf, event, Context y GameResult del espacio de nombres ggez
+{{#include ../../../code/rust-sokoban-c01-01/src/main.rs:1}}
+```
+
+### Declarando una estructura
+```rust
+// Esta estructura contrendrá todo el estado de nuestro juego
+// Por ahora no hay nada, pero pronto agregaremos cosas
+{{#include ../../../code/rust-sokoban-c01-01/src/main.rs:4:7}}
+```
+
+> **_MORE:_**  Lee más sobre estructuras [aquí](https://doc.rust-lang.org/book/ch05-00-structs.html).
+
+
+### Implementando un trait
+Un trait es como una interfaz en otros lenguajes, nos permite asociar cierto comportamiento a un tipo en particular. En este caso queremos implementar el trait EventHandler y agregar comportamiento a nuestra estructura Game.
+
+```rust
+// Este es el ciclo principal. ggez nos indica que implementemos
+// dos cosas:
+// - actualización (update)
+// - renderizado (draw)
+{{#include ../../../code/rust-sokoban-c01-01/src/main.rs:9:23}}
+```
+
+> **_MORE:_**  Lee más sobre traits [aquí](https://doc.rust-lang.org/book/ch10-02-traits.html).
+
+
+### Funciones
+También vamos a aprender cómo declarar funciones en Rust.
+
+```rust
+{{#include ../../../code/rust-sokoban-c01-01/src/main.rs:14:17}}
+```
+
+Quizá te preguntes qué es `self`, en este caso indica que la función update es una función miembro, que pertenece a una instancia de la estructura game y que no puede ser llamada en un contexto estático.
+
+> **_MORE:_**  Lee más sobre funciones [aquí](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html).
+
+### Sintaxis mut
+También estarás preguntándote qué significa `&mut` en `&mut self` en la función update. La mutabilidad de un objeto simplemente indica si dicho objeto puede o no modificarse. Revisa el siguiente ejemplo al declarar variables.
+
+```rust
+let a = 10; // el valor de a no puede modificarse porque no fue declarada como mutable
+let mut b = 20; // b puede ser modificada porque se declaró como mutable
+```
+
+De vuelta a la función update, cuando se utiliza mut con self, se hace referencia a la instancia de la clase a la que pertenece la función. Tomemos otro ejemplo:
+
+```rust
+// Estructura simple con una variable num
+struct X {
+    num: u32
+}
+
+// Bloque de implementación de la estructura X
+impl X {
+    fn a(&self) { self.num = 5 } 
+    // a no puede modificar la instancia de x aquí
+    // debido a &self, esto no compilará
+
+    fn b(&mut self) { self.num = 5 } 
+    // b puede modificar la instancia de x aquí
+    // gracias a &mut self, esta parte si compila
+}
+```
+
+> **_MORE:_**  Lee más sobre la mutabilidad [aquí](https://web.mit.edu/6.005/www/fa15/classes/09-immutability/) (esta conferencia utiliza Java pero los conceptos son válidos para cualquier otro lenguaje), y más sobre las variables y su mutabilidad en Rust [aquí](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html).
+
+
+Después de esta breve introducción a la sintaxis y código de Rust, ¡estamos listos para continuar! ¡Nos vemos en la siguiente sección!
+
+> **_CODELINK:_**  Puedes ver el código completo de este ejemplo [aquí](https://github.com/iolivia/rust-sokoban/tree/master/code/rust-sokoban-c01-01).

books/es_MX/src/c01-02-ecs.md

@@ -0,0 +1,42 @@
+# Entidades, componentes y sistemas
+
+En esta sección discutiremos con más detalle Sokoban y la arquitectura de nuestro juego.
+
+## Sokoban
+Así es como luce un juego de Sokoban, en caso de que no estés ya familiarizado con el modo de juego. Tenemos paredes y cajas, y la meta del jugador es empujar las cajas hasta su lugar correcto.
+
+![Sokoban play](./images/sokoban.gif)
+
+## ECS
+Entidad-Componente-Sistema (del inglés Entity Component System) es un patrón de arquitectura de software utilizado para crear videojuegos que siguen el principio de composición sobre herencia. En este proyecto utilizaremos muchísimo ECS, como la mayoría de juegos creados con Rust, así que ahora tomemos un poco de tiempo para familiarizarnos con los conceptos clave:
+ * **Componentes** - estructuras de solo datos que contienen diferentes características de las entidades: algunos ejemplos de componentes: Posición, Renderizable, Movimiento, etc. El punto clave aquí es que son solo datos, sin comportamiento alguno.
+* **Entidades** - las entidades están compuestas de múltiples componentes, por ejemplo un jugador podría estar compuesto de Posición, Renderizable y Movimiento, mientras que el piso podría ser solo Posición & Renderizable ya que no cuenta con movimiento. Las entidades son prácticamente contenedores "tontos" de uno o más componentes con un identificador único.
+* **Sistemas** - los sistemas utilizan entidades y componentes, contienen comportamiento y lógica basados en ellos. Por ejemplo, podríamos tener un sistema de renderizado que itere todas las entidades que contienen componentes renderizables y los dibuje. El punto clave aquí es que los componentes en si mismos no contienen ningún comportamiento, en lugar de ello se utiliza un sistema para interpretar la información y actuar sobre ella.
+
+Si lo anterior no hace sentido no te preocupes, en la siguiente sección discutiremos algunos ejemplos prácticos aplicados a nuestro juego Sokoban.
+
+
+## Arquitectura para Sokoban
+Basados en lo que conocemos sobre cómo debería funcionar un juego Sokoban, necesitaremos unos cuantos tipos diferentes de "cosas": paredes, un jugador, pisos, cajas y lugares para las cajas. Estos serán nuestras *entidades*.
+
+Ahora debemos identificar de qué estarán hechas estas entidades, o qué *componentes* necesitamos. Primero que nada necesitaremos mantener registro de dónde se encuentra todo en el mapa, así que necesitamos algún tipo de componente de posición. Después, algunas (pero no todas) entidades pueden moverse. El jugador puede moverse, las cajas se pueden mover si son empujadas por el jugador. Finalmente, necesitamos alguna forma de renderizar cada entidad, así que necesitamos un componente renderizable.
+
+Así es como se ve nuestra primera idea de entidades y componentes:
+1. **Entidad Player**: Position, Renderable, Movable
+1. **Entidad Wall**: Position, Renderable
+1. **Entidad Floor**: Position, Renderable
+1. **Entidad Box**: Position, Renderable, Movable
+1. **Entidad Box spot**: Position, Renderable
+
+Al principio, pensar en términos de ECS puede ser difícil, así que no te preocupes si no entiendes todo o si no te parece similar con la forma como has hecho las cosas en otros lenguajes.
+
+## Specs
+Finalmente, utilizaremos un crate ECS. Hay muchísimos, pero en este libro utilizaremos [specs](https://specs.amethyst.rs/docs/tutorials/).
+
+```
+{{#include ../../../code/rust-sokoban-c01-03/Cargo.toml:9:11}}
+```
+
+A continuación, ¡empezaremos la implementación de las entidades y componentes!
+
+> **_CODELINK:_**  Puedes ver el código completo de este ejemplo [aquí](https://github.com/iolivia/rust-sokoban/tree/master/code/rust-sokoban-c01-03).