Small changes to documentation.

docs/tutorial-game.md

@@ -213,7 +213,7 @@ Pig.prototype.moves = function moves() {
 };
 ```
 
-The most complicated part would be to calculate the next state given a game state and a move. This is not because the game logic is complex in itself, but because it involves a die, which is a random variable. Simply put, if the player decides to roll the game state's `next` method must return a `Contingent` state. By default, this instances hold references to the state and moves that originated them. They also have a set of `Aleatory` variables. The values of these random variables (called `haps`) resolved the indetermination in the flow of the game. Once determined the actual value of these haps, the `next` method is called again on the original state with the same moves and the values for the haps. The `next` method will then calculate the actual next state.
+The most complicated part would be to calculate the next state given a game state and a move. This is not because the game logic is complex in itself, but because it involves a die, which is a random variable. Simply put, if the player decides to roll the game state's `next` method must return a `Contingent` state. By default, this instances hold references to the state and moves that originated them. They also have a set of `Aleatory` variables. The values of these random variables (called `haps`) resolve the indetermination in the flow of the game. Once determined the actual value of these haps, the `next` method is called again on the original state with the same moves and the values for the haps. The `next` method will then calculate the actual next state.
 
 In this case, the only random variable involved is a six-sided die, which is already defined in `ludorum.aleatories.dice.D6`. If `haps` are provided, the `next` method calculates a game state; else it builds a contingent state. 
 

src/Contingent.js

@@ -13,15 +13,9 @@ var Contingent = exports.Contingent = declare({
 	the `next` method for further details.
 	*/
 	constructor: function Contingent(haps, state, moves) {
-		if (haps) {
-			this.__haps__ = haps;
-		}
-		if (state) {
-			this.__state__ = state;
-		}
-		if (moves) {
-			this.__moves__ = moves;
-		}
+		this.__haps__ = haps || null;
+		this.__state__ = state || null;
+		this.__moves__ = moves || null;
 	},
 
 	/** A contingent state's `haps` are the equivalent of `moves` in normal game states. The method 
@@ -86,10 +80,12 @@ var Contingent = exports.Contingent = declare({
 
 	// ## Utilities ################################################################################
 
+	/** Serialization and materialization using Sermat.
+	*/
 	'static __SERMAT__': {
 		identifier: 'Contingent',
 		serializer: function serialize_Contingent(obj) {
-			return [obj.__haps__ || null, obj.__state__ || null, obj.__moves__ || null];
+			return [obj.__haps__, obj.__state__, obj.__moves__];
 		}
 	}
 });

src/aleatories/Aleatory.js

@@ -1,12 +1,11 @@
 /** # Aleatory
 
 Aleatories are different means of non determinism that games can use, like: dice, card decks, 
-roulettes, etc. They are used by `Aleatoric` game states.
+roulettes, etc. They are used by `Contingent` game states.
 */
 var Aleatory = exports.aleatories.Aleatory = declare({
 	/** The base class implements an integer uniform random variable between a minimum and maximum
 	value (inclusively).
-	+ 
 	*/
 	constructor: function Aleatory(min, max) {
 		switch (arguments.length) {

src/aleatories/Dice.js

@@ -37,4 +37,4 @@ var dice = aleatories.dice = {
 				}).sum();
 		}
 	}
-}; //// declare Dice.
+}; // dice.