fix typos

Author: sbaechler

doc/collision_detection.adoc

@@ -14,7 +14,7 @@ larger than the player's radius:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/collision/src/Hexagon.elm", lines="110:127" %}{% endcodesnippet %}
 
-With this function we can extend our `isGameOver`-rule:
+With this function we can extend our `isGameOver` rule:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/collision/src/Hexagon.elm", lines="146:149" %}{% endcodesnippet %}
 

doc/controls.adoc

@@ -9,34 +9,36 @@ which provides a model that holds the current state of the keyboard.
 == Model
 
 We first set up the model for the `Game`, which contains the `Player` with the Player's position
-(represented by an angle), the current 'direction' in which the player is moving, and a `keyboardModel`:
+(represented by an angle), the current `direction` in which the player is moving, and a `keyboardModel`:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="1:25", language="elm" %}{% endcodesnippet %}
 
-Elm 0.17 does not use Signals anymore. Instead we use a publication/subscription-pattern that uses messages.
+Elm 0.17 does not use Signals anymore. Instead we use a publication/subscription pattern that uses messages.
 We need to declare the type of the message here, which can be one of the following:
 
 * a `Step` with a timestamp. This represents a frame of the game-loop.
-* a `KeyboardExtraMsg` which is a keyboard-input
+* a `KeyboardExtraMsg` which is a keyboard input
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="26:30", language="elm" %}{% endcodesnippet %}
 
-We are also going to need some constant values, e.g. the screen-size and the radius of the player's periphery:
+We are also going to need some constant values, e.g. the screen size and the radius of the player's periphery:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="30:44", language="elm" %}{% endcodesnippet %}
 
 
 == Update
 
-We now define how the state of the game can change over time. This state-transition is done with the function `update : Msg -> Game -> Game`. This function will receive our `Msg` and will update the game-state accordingly. We distinguish here between `KeyboardExtraMsg` and `Step`:
+We now define how the state of the game can change over time. This state-transition is done with the function `update : Msg -> Game -> Game`. This function will receive our `Msg` and will update the game state accordingly. We distinguish here between `KeyboardExtraMsg` and `Step`:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="99:105", language="elm" %}{% endcodesnippet %}
 
 `onUserInput` will set the current direction based on the arrow-keys pressed on the keyboard:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="72:87", language="elm" %}{% endcodesnippet %}
 
-`onFrame` on the other hand will update the game's state on the next frame:
+`onFrame` on the other hand will update the game's state on the next frame.
+There is currently only one `nextCmd` value which does nothing. We are going to add
+more commands later on.
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="88:97", language="elm" %}{% endcodesnippet %}
 
@@ -48,14 +50,14 @@ We now define how the state of the game can change over time. This state-transit
 
 Elm provides different libraries to output html or to render 2d-graphics on a canvas. We use the `Graphics`-Package for this.
 
-The `Player` will be a small triangle that we rotate around the game's center.
-A black background will represent our game-screen. We also change the `Player`'s color depending on the angle (for fun and profit):
+The `Player` will be a small triangle that we rotate around the center of the game.
+A black background will represent our game screen. We also change the player's color depending on the angle (for fun and profit):
 
 // bgBlack, moveRadial, makePlayer
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="109:122" %}{% endcodesnippet %}
 
 The function `view : Game -> Html.Html Msg` is the main function of the view part of our application.
-It receives the current game-state and returns `Html`:
+It receives the current game state and returns `Html`:
 
 // view
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/controls/src/Hexagon.elm", lines="123:135" %}{% endcodesnippet %}

doc/dancefloor.adoc

@@ -33,15 +33,17 @@ The board is made of two elements: Six triangles in alternating dark and bright
 colors and a center hexagon.
 
 First, we create the function that calculates the color values. It takes the progress
-as an input and returns a `Colors` object that contains the values for the three colors.
+as an input and returns a `Colors` object that contains the values for the three colors. +
+`msRunning` is a `Float` and `hue` is an angle. So this function cycles through all
+the colors in the color wheel.
 
 // makeColors
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/dancefloor/src/Hexagon.elm", lines="230:239" %}{% endcodesnippet %}
 
 A triangle is defined by its three corner points. Each point is a tuple of floats.
 One point in every triangle is the center point (0, 0). The other two points are
 calculated using simple trigonometry. The radius depends on the canvas size.
-Its length is $$\sqrt2$$ * screen width. This way the triangles always cover the whole
+Its length is $$\sqrt2$$ * half screen width. This way the triangles always cover the whole
 field.
 
 The field itself consists of a group of Forms. Firstly we define two helper
@@ -64,7 +66,9 @@ The center element is a hexagon that has a dark fill color and a light outline.
 
 
 Now we can draw the element. We define the new colors in the let block of the view function.
-Then we can add the new elements and pass the whole group to a (yet empty) rotate function.
+Then we can add the new elements and pass the whole group to a (yet empty) rotate function. +
+The `makeCenterHole` function returns a list so we use `List.append` to merge the two lists in
+the view function.
 
 // view
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/dancefloor/src/Hexagon.elm", lines="240:257" %}{% endcodesnippet %}
@@ -73,7 +77,7 @@ Then we can add the new elements and pass the whole group to a (yet empty) rotat
 ## Adding Rotation
 
 Compared to the original game, the rotation in this version is much simpler. The rotation speed is
-defined with a sinus function. So it starts rotating in one direction, gets faster, then after
+defined with a sinus function. The board starts rotating in one direction, gets faster, then after
 having reached a maximum it gets slower until it rotates the other way. And so forth.
 
 To accomplish this we have to modify the angle that is passed to the `rotate` function.
@@ -83,12 +87,13 @@ That's why we added the two values `autoRotateAngle` and `autoRotateSpeed` to th
 derivate of `autoRotateAngle`.
 
 The two functions `updateAutoRotateAngle` and `updateAutoRotateSpeed` take care
-of this:
+of this. You can see the values change in the console when you add the
+`Debug.log` function. Don't forget to remove it later on.
 
 // updateAutoRotateAngle, updateAutoRotateSpeed
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/dancefloor/src/Hexagon.elm", lines="107:116" %}{% endcodesnippet %}
 
-the functions are called during the update cycle in the `onFrame` method:
+The functions are called during the update cycle in the `onFrame` method:
 
 // onFrame
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/dancefloor/src/Hexagon.elm", lines="144:163" %}{% endcodesnippet %}

doc/enemies.adoc

@@ -3,14 +3,13 @@ Enemies
 
 image:Bildschirmfoto 2016-06-26 um 15.31.42.png[alt=""]
 
-In the original game the shape of the "enemies" are defined in a large class and they are created in waves. For this tutorial we keep it simpler. We have some pre-defined enemy-arrangements that repeat themselves.
+In the original game the shape of the "enemies" is defined in a large class and they are created in waves. For this tutorial we keep it simpler. We have some predefined enemy arrangements that repeat themselves.
 
 Let's first introduce a new type `Enemy`:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="26:30", language="elm" %}{% endcodesnippet %}
 
 
-
 * radius: the distance of the enemies to the center
 * parts: a list of true/false that indicate where the enemy has a "hole"
 
@@ -22,7 +21,7 @@ We also need to add new initial states for our game:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="352:371", language="elm" %}{% endcodesnippet %}
 
-We further define a constant values `enemyThickness`, `enemyDistance`, `enemyInitialSpeed` and `enemyAcceleration`:
+We further define the constant values `enemyThickness`, `enemyDistance`, `enemyInitialSpeed` and `enemyAcceleration`:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="67:70", language="elm" %}{% endcodesnippet %}
 
@@ -38,7 +37,7 @@ As you may have noticed, we have only defined the `parts` property of the Enemy
 == Updating radius
 
 
-Let's introduce two new functions in the `onFrame`-Function that will update `enemies` and `enemySpeed` on the game state:
+Let's introduce two new functions in the `onFrame` function that will update `enemies` and `enemySpeed` on the game state:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="192:213", language="elm" %}{% endcodesnippet %}
 
@@ -72,11 +71,11 @@ We subtract the `enemyProgress`, so that value will be negative (for most enemie
 
 First we need a function to create a trapezoid:
 
-{% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="240:247", language="elm" %}{% endcodesnippet %}
+{% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="240:248" %}{% endcodesnippet %}
 
 We will now use this function to create a trapezoid for every occupied part of any enemy:
 
-{% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="250:263", language="elm" %}{% endcodesnippet %}
+{% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="250:263"  %}{% endcodesnippet %}
 
 This function returns a `Form` that contains a group of these trapezoids. Notice how we filter out parts by creating a tuple of `(index:Int, part:Bool)`, removing parts where part is `False` and sending the index to `makeEnemyPart`. Pure functional magic:
 
@@ -86,7 +85,7 @@ The following function `makeEnemies` will create a `List(Form)` for every enemy:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="264:266", language="elm" %}{% endcodesnippet %}
 
-Finally we add this function to our `view`-function:
+Finally we add this function to our `view` function:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/enemies/src/Hexagon.elm", lines="320:339", language="elm" %}{% endcodesnippet %}
 

doc/gameloop.adoc

@@ -1,9 +1,10 @@
 Game Loop and Debugger
 ----------------------
 
-In this chapter we introduce a progress in the form of miliseconds that have passed since start. This progress is used to calculate the rotations and the movement of the enemies and also represents the "score" of the player.
+In this chapter we introduce a progress counter in the form of miliseconds that have passed since the start of the game.
+This progress is used to calculate the rotations and the movement of the enemies and also represents the "score" of the player.
 
-We further extend the controls by a `Play`/`Pause`-behavior triggered by the space-key. For that we introduce a new type `State`:
+We further extend the controls by a `Play`/`Pause`-behavior triggered by the space key. For that we introduce a new type `State`:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/game-progress/src/Hexagon.elm", lines="16:17", language="elm" %}{% endcodesnippet %}
 
@@ -19,17 +20,19 @@ Because the player should only be able to move on the `Play`-`State` feature, we
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/game-progress/src/Hexagon.elm", lines="76:86", language="elm" %}{% endcodesnippet %}
 
-`onUserInput` needs also some modifications to fetch the space-key and update the game-state accordingly:
+`onUserInput` needs also some modifications to fetch the status of the space key and update the game state accordingly:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/game-progress/src/Hexagon.elm", lines="100:124", language="elm" %}{% endcodesnippet %}
 
 == Update times
 
-The function `onFrame` is called on every animation frame event (60 times a second). We add the timing-update behaviors there:
+The function `onFrame` is called on every animation frame event (60 times a second). We add the timing update behaviors there:
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/game-progress/src/Hexagon.elm", lines="126:143", language="elm" %}{% endcodesnippet %}
 
 with some additional functions:
+We add the current minus the last stored timestamp to `game.msRunning`. This is
+the time that has passed since the last call to `onFrame`.
 
 {% codesnippet "https://raw.githubusercontent.com/macrozone/elm-hexagon-tutorial/chapter/game-progress/src/Hexagon.elm", lines="86:98", language="elm" %}{% endcodesnippet %}