refactor: make choices object, move out style

this should allow to write 'isBeating' function over choices.
and maybe move to enums

14-rock-paper-scissors/src/main/resources/templates/index.html

@@ -86,9 +86,9 @@
               --translation: 50%;
               position: absolute;
             "
-            th:style="| --diameter: ${choiceBadgeData.c.diameter};
+            th:style="| --diameter: ${choiceBadgeData.s.diameter};
-                         --bg-dark: ${choiceBadgeData.c.bgDark};
+                         --bg-dark: ${choiceBadgeData.s.bgDark};
-                         --bg-bright: ${choiceBadgeData.c.bgBright};
+                         --bg-bright: ${choiceBadgeData.s.bgBright};
                          ${choiceBadgeData.p.toStyle}; |"
           >
             <div

14-rock-paper-scissors/src/main/scala/rockpaperscissors/Models.scala

@@ -23,14 +23,13 @@ position: absolute;
     }
   }
 
-  sealed trait Choice {
+  // yeah, maybe better to do in outer html div
-    def diameter: String
+  final case class Styling(
-    def bgDark: String
+      var diameter: String,
-    def bgBright: String
+      var bgDark: String,
-    def name: String
+      var bgBright: String
-    def iconPath: String
+  )
-  }
+  object Styling {
-  object Choice {
     val scissorsDark = "hsl(39, 89%, 49%)"
     val scissorsBright = "hsl(40, 84%, 53%)"
     val paperDark = "hsl(230, 89%, 62%)"
@@ -38,54 +37,86 @@ position: absolute;
     val rockDark = "hsl(349, 71%, 52%)"
     val rockBright = "hsl(349, 70%, 56%)"
 
-    case class Paper(
+    def paperStyling(
         diameter: String,
         bgDark: String = paperDark,
         bgBright: String = paperBright
-    ) extends Choice {
+    ) = Styling(diameter, bgDark, bgBright)
-      def name: String = "paper"
+
-      def iconPath: String = "public/images/icon-paper.svg"
+    def scissorsStyling(
-    }
-    case class Scissors(
         diameter: String,
         bgDark: String = scissorsDark,
         bgBright: String = scissorsBright
-    ) extends Choice {
+    ) = Styling(diameter, bgDark, bgBright)
-      def name: String = "scissors"
+
-      def iconPath: String = "public/images/icon-scissors.svg"
+    def rockStyling(
-    }
-    case class Rock(
         diameter: String,
         bgDark: String = rockDark,
         bgBright: String = rockBright
-    ) extends Choice {
+    ) = Styling(diameter, bgDark, bgBright)
+  }
+
+  sealed trait Choice {
+    def name: String
+    def iconPath: String
+  }
+  object Choice {
+    case object Paper extends Choice {
+      def name: String = "paper"
+      def iconPath: String = "public/images/icon-paper.svg"
+    }
+    case object Scissors extends Choice {
+      def name: String = "scissors"
+      def iconPath: String = "public/images/icon-scissors.svg"
+    }
+    case object Rock extends Choice {
       def name: String = "rock"
       def iconPath: String = "public/images/icon-rock.svg"
     }
+
   }
 
   /** this will be Data Transfer Object, because Thymeleaf wants var and i want
     * vals and enums
     */
   final case class ChoiceBadge(
+      var s: Styling,
       var c: Choice,
       var p: Positioning
   )
 
   val choiceSelectionItems = {
     List(
-      ChoiceBadge(Choice.Paper("8rem"), Positioning.Absolute("6rem", "6rem")),
       ChoiceBadge(
-        Choice.Scissors("8rem"),
+        Styling.paperStyling("8rem"),
+        Choice.Paper,
+        Positioning.Absolute("6rem", "6rem")
+      ),
+      ChoiceBadge(
+        Styling.scissorsStyling("8rem"),
+        Choice.Scissors,
         Positioning.Absolute("6rem", "17rem")
       ),
-      ChoiceBadge(Choice.Rock("8rem"), Positioning.Absolute("15rem", "11.5rem"))
+      ChoiceBadge(
+        Styling.rockStyling("8rem"),
+        Choice.Rock,
+        Positioning.Absolute("15rem", "11.5rem")
+      )
     )
   }
 
   final case class ShowdownState(
-    var playersChoice: ChoiceBadge,
+      var playersChoice: ChoiceBadge,
-    var houseChoice: Option[ChoiceBadge],
+      var houseChoice: Option[ChoiceBadge],
-    var gameEnded: Boolean
+      var gameEnded: Boolean
-  )
+  ) {
+    def isPlayerVictorious(): Option[Boolean] = {
+      houseChoice.map(houseSelectedChoice => {
+        val player = playersChoice.c
+        val house = houseSelectedChoice.c
+        false
+      })
+
+    }
+  }
 }