chore: Tidy ups 01

Author: SeriousSoftware

src/main/scala-2.11/nl/amsscala/simplegame/game.scala

@@ -29,7 +29,7 @@ protected trait Game {
     def gameLoop = () => {
       val now = js.Date.now()
       val delta = now - prev
-      val updated = oldUpdated.getOrElse(new GameState(canvas, -1)).updateGame(delta / 1000, keysPressed, canvas)
+      val updated = oldUpdated.getOrElse(new GameState(canvas, -1, true)).updateGame(delta / 1000, keysPressed, canvas)
 
       if (oldUpdated.isEmpty || (oldUpdated.get.hero.pos != updated.hero.pos))
         oldUpdated = SimpleCanvasGame.render(updated)
@@ -62,8 +62,14 @@ protected trait Game {
  * @param hero           Hero object with its position
  * @param monster        Monster object with its position
  * @param monstersCaught The score
+ * @param newGame        Flags new game
  */
-private case class GameState(hero: Hero[Int], monster: Monster[Int], monstersCaught: Int = 0) {
+private case class GameState(
+    hero: Hero[Int],
+    monster: Monster[Int],
+    monstersCaught: Int = 0,
+    newGame: Boolean
+) {
 
   /**
    * Update game objects according the pressed keys.
@@ -92,11 +98,10 @@ private case class GameState(hero: Hero[Int], monster: Monster[Int], monstersCau
     if (keysDown.isEmpty) this
     else {
       val newHero = new Hero(displacements.fold(hero.pos) { (z, i) => z + i * (Hero.speed * latency).toInt })
-      val correctedThis = newHero.pos + Hero.size
 
       if (newHero.pos.isValidPosition(Position(canvas.width, canvas.height), Hero.size)) // Are they touching?
         if (newHero.pos.areTouching(monster.pos, Hero.size)) // Reset the game when the player catches a monster
-          new GameState(canvas, monstersCaught)
+          new GameState(canvas, monstersCaught, true)
         else copy(hero = newHero)
       else this
     }
@@ -110,20 +115,22 @@ private case class GameState(hero: Hero[Int], monster: Monster[Int], monstersCau
    * @param canvas   The visual html element
    * @param oldScore Score accumulator
    */
-  def this(canvas: dom.html.Canvas, oldScore: Int) {
+  def this(canvas: dom.html.Canvas, oldScore: Int, newGame: Boolean) {
     this(
       Hero(canvas.width / 2, canvas.height / 2),
       // Throw the monster somewhere on the screen randomly
       Monster((math.random * (canvas.width - Hero.size)).toInt, (math.random * (canvas.height - Hero.size)).toInt),
-      oldScore + 1
+      oldScore + 1,
+      newGame
     )
   }
 }
 
 /**
+ * Monster class, holder for its coordinates, copied as extentension to the Hero class
  *
- * @param pos
- * @tparam T
+ * @param pos Monsters' position
+ * @tparam T  Numeric generic abstraction
  */
 private class Monster[T: Numeric](val pos: Position[T]) {
   override def equals(that: Any): Boolean = that match {
@@ -132,31 +139,18 @@ private class Monster[T: Numeric](val pos: Position[T]) {
   }
 
   override def toString = s"${this.getClass.getSimpleName} $pos"
-  protected[simplegame] def isValidPosition(canvas: dom.html.Canvas) = {
-    pos.isValidPosition(
-      Position(canvas.width, canvas.height).asInstanceOf[Position[T]],
-      Hero.size.asInstanceOf[T]
-    )
-  }
+  protected[simplegame] def isValidPosition(canvas: dom.html.Canvas) =
+    pos.isValidPosition(Position(canvas.width, canvas.height).asInstanceOf[Position[T]], Hero.size.asInstanceOf[T])
 }
 
-/**
- *
- */
 private object Monster {
   // def apply[T: Numeric](pos: Position[T]) = new Monster(pos)
   def apply[T: Numeric](x: T, y: T) = new Monster(Position(x, y))
 }
 
-/**
- * @param pos
- * @tparam A
- */
 private class Hero[A: Numeric](override val pos: Position[A]) extends Monster[A](pos)
 
-/**
- * Compagnion object of class Hero
- */
+/** Compagnion object of class Hero */
 private object Hero {
   val size = 32
   val speed = 256

src/main/scala-2.11/nl/amsscala/simplegame/package.scala

@@ -1,26 +1,38 @@
 package nl.amsscala
 
 /**
- * Provides generic classes and operators for dealing with 2D positions.
- *
+ * Provides generic class and operators for dealing with 2D positions.
+ * As well dealing with 2D areas.
  */
 package object simplegame {
   // Experimental timestamp and position, displacement is a function of time
   type keysBufferType = scala.collection.mutable.Map[Int, (Double, Position[Int])]
 
+  /**
+   * Generic base class Position, holding the two coordinates
+   *
+   * @param x
+   * @param y
+   * @tparam P
+   */
   case class Position[P: Numeric](x: P, y: P) {
 
     import Numeric.Implicits.infixNumericOps
     import Ordering.Implicits.infixOrderingOps
 
+    /** Binaire sum operator for two coordinates */
     def +(p: Position[P]) = Position(x + p.x, y + p.y)
 
+    /** Binaire sum operator e,g. (a, b) + n => (a + n, b +n) */
     def +(term: P) = Position(x + term, y + term)
 
+    /** Binaire subtract operator for the difference of two coordinates */
     def -(p: Position[P]) = Position(x - p.x, y - p.y)
 
+    /** Binaire multiply operator for two coordinates, multplies each of the ordinate */
     def *(p: Position[P]) = Position(x * p.x, y * p.y)
 
+    /** Binaire multiply operator e,g. (a, b) * n=> (a * n, b * n) */
     def *(factor: P) = Position(x * factor, y * factor)
 
     private def interSectsArea[P: Numeric](p0: Position[P], p1: Position[P], p2: Position[P], p3: Position[P]) = {
@@ -30,17 +42,24 @@ package object simplegame {
         intersectsWith(p0.y, p1.y, p2.y, p3.y)
     }
 
-    def isValidPosition(canvasPos: Position[P], size: P): Boolean = {
+    /**
+     * Check if the square area is within the rectangle area
+     *
+     * @param canvasPos
+     * @param side
+     * @return
+     */
+    def isValidPosition(canvasPos: Position[P], side: P): Boolean = {
       // println(s"Testing: $x, $y")
 
-      interSectsArea(Position(0, 0).asInstanceOf[Position[P]], canvasPos, this + size, this)
+      interSectsArea(Position(0, 0).asInstanceOf[Position[P]], canvasPos, this + side, this)
     }
 
     /**
      * Checks that two squares intersects
      *
      * @param posB Position of the second square
-     * @param side size of both two squares
+     * @param side side of both two squares
      * @return     True if a intersection occurs
      */
     def areTouching(posB: Position[P], side: P): Boolean = interSectsArea(this, this + side, posB, posB + side)

src/test/scala-2.11/nl/amsscala/simplegame/GameSuite.scala

@@ -81,7 +81,7 @@ class GameSuite extends SuiteSpec {
         game.updateGame(1D, mutable.Map(0 -> dummyTimeStamp), canvas) shouldBe game
       }
       it("bad path") { // No move due a of out canvas limit case
-        game.updateGame(1.48828125, mutable.Map(Right -> dummyTimeStamp, Down -> dummyTimeStamp), canvas) shouldBe game
+        game.updateGame(1.48828125D, mutable.Map(Right -> dummyTimeStamp, Down -> dummyTimeStamp), canvas) shouldBe game
       }
       it("experiment") {