Add Dameo Game Logic

src/main/scala/Action.scala

@@ -20,6 +20,7 @@ abstract class Action(
   def toGo: go.Action
   def toBackgammon: backgammon.Action
   def toAbalone: abalone.Action
+  def toDameo: dameo.Action
 }
 
 object Action {
@@ -63,6 +64,10 @@ object Action {
     case m: abalone.Move => Move.Abalone(m)
   }
 
+  def wrap(action: dameo.Action): Action = action match {
+    case m: dameo.Move => Move.Dameo(m)
+  }
+
   def toChess(action: Action): chess.Action = action match {
     case Move.Chess(m) => m
     case Drop.Chess(d) => d
@@ -111,4 +116,9 @@ object Action {
     case _               => sys.error("Expecting a abalone action e.g. move")
   }
 
+  def toDameo(action: Action): dameo.Move = action match {
+    case Move.Dameo(m) => m
+    case _             => sys.error("Expecting a dameo action e.g. move")
+  }
+
 }

src/main/scala/Actor.scala

@@ -71,4 +71,11 @@ object Actor {
         Board.Abalone(a.board)
       ) {}
 
+  final case class Dameo(a: dameo.Actor)
+      extends Actor(
+        Piece.Dameo(a.piece),
+        Pos.Dameo(a.pos),
+        Board.Dameo(a.board)
+      ) {}
+
 }

src/main/scala/Board.scala

@@ -40,6 +40,7 @@ sealed abstract class Board(
   def toGo: go.Board
   def toBackgammon: backgammon.Board
   def toAbalone: abalone.Board
+  def toDameo: dameo.Board
 }
 
 object Board {
@@ -83,6 +84,7 @@ object Board {
     def toGo           = sys.error("Can't make a go board from a chess board")
     def toBackgammon   = sys.error("Can't make a backgammon board from a chess board")
     def toAbalone      = sys.error("Can't make a abalone board from a chess board")
+    def toDameo        = sys.error("Can't make a dameo board from a chess board")
 
   }
 
@@ -124,6 +126,7 @@ object Board {
     def toGo           = sys.error("Can't make a go board from a draughts board")
     def toBackgammon   = sys.error("Can't make a backgammon board from a draughts board")
     def toAbalone      = sys.error("Can't make a abalone board from a draughts board")
+    def toDameo        = sys.error("Can't make a dameo board from a draughts board")
 
   }
 
@@ -166,6 +169,7 @@ object Board {
     def toGo           = sys.error("Can't make a go board from a fairysf board")
     def toBackgammon   = sys.error("Can't make a backgammon board from a fairysf board")
     def toAbalone      = sys.error("Can't make a abalone board from a fairysf board")
+    def toDameo        = sys.error("Can't make a dameo board from a fairysf board")
 
   }
 
@@ -207,6 +211,7 @@ object Board {
     def toGo           = sys.error("Can't make a go board from a samurai board")
     def toBackgammon   = sys.error("Can't make a backgammon board from a samurai board")
     def toAbalone      = sys.error("Can't make a abalone board from a samurai board")
+    def toDameo        = sys.error("Can't make a dameo board from a samurai board")
 
   }
 
@@ -250,6 +255,7 @@ object Board {
     def toGo           = sys.error("Can't make a go board from a togyzkumalak board")
     def toBackgammon   = sys.error("Can't make a backgammon board from a togyzkumalak board")
     def toAbalone      = sys.error("Can't make a abalone board from a togyzkumalak board")
+    def toDameo        = sys.error("Can't make a dameo board from a togyzkumalak board")
 
   }
 
@@ -292,6 +298,7 @@ object Board {
     def toGo           = b
     def toBackgammon   = sys.error("Can't make a backgammon board from a go board")
     def toAbalone      = sys.error("Can't make a abalone board from a go board")
+    def toDameo        = sys.error("Can't make a dameo board from a go board")
 
   }
 
@@ -338,6 +345,7 @@ object Board {
     def toGo           = sys.error("Can't make a go board from a backgammon board")
     def toBackgammon   = b
     def toAbalone      = sys.error("Can't make a abalone board from a backgammon board")
+    def toDameo        = sys.error("Can't make a dameo board from a backgammon board")
 
   }
 
@@ -379,6 +387,49 @@ object Board {
     def toGo           = sys.error("Can't make a go board from a abalone board")
     def toBackgammon   = sys.error("Can't make a backgammon board from a abalone board")
     def toAbalone      = b
+    def toDameo        = sys.error("Can't make a dameo board from a abalone board")
+
+  }
+
+  case class Dameo(b: dameo.Board)
+      extends Board(
+        b.pieces.map { case (pos, piece) => (Pos.Dameo(pos), (Piece.Dameo(piece), 1)) },
+        History.Dameo(b.history),
+        Variant.Dameo(b.variant)
+      ) {
+
+    def withHistory(h: History): Board = h match {
+      case History.Dameo(h) => Dameo(b.withHistory(h))
+      case _                  => sys.error("Not passed dameo objects")
+    }
+
+    def usedDice: List[Int] = List.empty
+
+    def situationOf(player: Player): Situation = Situation.Dameo(b.situationOf(player))
+
+    def materialImbalance: Int = b.materialImbalance
+
+    override def toString: String = b.toString
+
+    def copy(history: History, variant: Variant): Board = (history, variant) match {
+      case (History.Dameo(history), Variant.Dameo(variant)) =>
+        Dameo(b.copy(history = history, variant = variant))
+      case _                                                    => sys.error("Unable to copy a dameo board with non-dameo arguments")
+    }
+    def copy(history: History): Board                   = history match {
+      case History.Dameo(history) => Dameo(b.copy(history = history))
+      case _                        => sys.error("Unable to copy a dameo board with non-dameo arguments")
+    }
+
+    def toFairySF      = sys.error("Can't make a fairysf board from a dameo board")
+    def toChess        = sys.error("Can't make a chess board from a dameo board")
+    def toDraughts     = sys.error("Can't make a draughts board from a dameo board")
+    def toSamurai      = sys.error("Can't make a samurai board from a dameo board")
+    def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a dameo board")
+    def toGo           = sys.error("Can't make a go board from a dameo board")
+    def toBackgammon   = sys.error("Can't make a backgammon board from a dameo board")
+    def toAbalone      = sys.error("Can't make a abalone board from a dameo board")
+    def toDameo        = b
 
   }
 
@@ -466,6 +517,16 @@ object Board {
             variant
           )
         )
+      case (GameLogic.Dameo(), Variant.Dameo(variant))           =>
+        Dameo(
+          dameo.Board.apply(
+            pieces.flatMap {
+              case (Pos.Dameo(pos), (Piece.Dameo(piece), _)) => Some((pos, piece))
+              case _                                         => None
+            },
+            variant
+          )
+        )
       case _                                                         => sys.error("Mismatched gamelogic types 27")
     }
 
@@ -477,6 +538,7 @@ object Board {
   implicit def goBoard(b: go.Board)                     = Board.Go(b)
   implicit def backgammonBoard(b: backgammon.Board)     = Board.Backgammon(b)
   implicit def abaloneBoard(b: abalone.Board)           = Board.Abalone(b)
+  implicit def dameoBoard(b: dameo.Board)               = Board.Dameo(b)
 
   def init(lib: GameLogic, variant: Variant): Board = (lib, variant) match {
     case (GameLogic.Draughts(), Variant.Draughts(variant))         => Draughts(draughts.Board.init(variant))
@@ -488,6 +550,7 @@ object Board {
     case (GameLogic.Go(), Variant.Go(variant))                     => Go(go.Board.init(variant))
     case (GameLogic.Backgammon(), Variant.Backgammon(variant))     => Backgammon(backgammon.Board.init(variant))
     case (GameLogic.Abalone(), Variant.Abalone(variant))           => Abalone(abalone.Board.init(variant))
+    case (GameLogic.Dameo(), Variant.Dameo(variant))               => Dameo(dameo.Board.init(variant))
     case _                                                         => sys.error("Mismatched gamelogic types 28")
   }
 

src/main/scala/CubeAction.scala

@@ -50,6 +50,7 @@ object CubeAction {
     def toGo           = sys.error("Can't make a go cubeaction from a backgammon cubeaction")
     def toBackgammon   = c
     def toAbalone      = sys.error("Can't make a abalone cubeaction from a backgammon cubeaction")
+    def toDameo        = sys.error("Can't make a dameo cubeaction from a backgammon cubeaction")
 
   }
 
@@ -83,6 +84,7 @@ object CubeInteraction {
     def toGo           = sys.error("Can't make a go cubeinteraction from a backgammon cubeinteraction")
     def toBackgammon   = c
     def toAbalone      = sys.error("Can't make a abalone cubeinteraction from a backgammon cubeinteraction")
+    def toDameo        = sys.error("Can't make a dameo cubeinteraction from a backgammon cubeinteraction")
 
   }
 

src/main/scala/DiceRoll.scala

@@ -51,6 +51,7 @@ object DiceRoll {
     def toGo           = sys.error("Can't make a go DiceRoll from a chess DiceRoll")
     def toBackgammon   = sys.error("Can't make a backgammon DiceRoll from a chess DiceRoll")
     def toAbalone      = sys.error("Can't make a abalone DiceRoll from a chess DiceRoll")
+    def toDameo        = sys.error("Can't make a dameo DiceRoll from a chess DiceRoll")
 
   }
 
@@ -78,6 +79,7 @@ object DiceRoll {
     def toGo           = sys.error("Can't make a go DiceRoll from a backgammon DiceRoll")
     def toBackgammon   = dr
     def toAbalone      = sys.error("Can't make a abalone DiceRoll from a backgammon DiceRoll")
+    def toDameo        = sys.error("Can't make a dameo DiceRoll from a backgammon DiceRoll")
 
   }
 

src/main/scala/Drop.scala

@@ -54,6 +54,7 @@ object Drop {
     def toGo           = sys.error("Can't make a go drop from a chess drop")
     def toBackgammon   = sys.error("Can't make a backgammon drop from a chess drop")
     def toAbalone      = sys.error("Can't make a abalone drop from a chess drop")
+    def toDameo        = sys.error("Can't make a dameo drop from a chess drop")
 
   }
 
@@ -81,6 +82,7 @@ object Drop {
     def toGo           = sys.error("Can't make a go drop from a fairysf drop")
     def toBackgammon   = sys.error("Can't make a backgammon drop from a fairysf drop")
     def toAbalone      = sys.error("Can't make a abalone drop from a fairysf drop")
+    def toDameo        = sys.error("Can't make a dameo drop from a fairysf drop")
 
   }
 
@@ -108,6 +110,7 @@ object Drop {
     def toGo           = d
     def toBackgammon   = sys.error("Can't make a backgammon drop from a go drop")
     def toAbalone      = sys.error("Can't make a abalone drop from a go drop")
+    def toDameo        = sys.error("Can't make a dameo drop from a go drop")
 
   }
 
@@ -135,6 +138,7 @@ object Drop {
     def toGo           = sys.error("Can't make a go drop from a backgammon drop")
     def toBackgammon   = d
     def toAbalone      = sys.error("Can't make a abalone drop from a backgammon drop")
+    def toDameo        = sys.error("Can't make a dameo drop from a backgammon drop")
 
   }
 

src/main/scala/EndTurn.scala

@@ -46,6 +46,7 @@ object EndTurn {
     def toGo           = sys.error("Can't make a go endturn from a backgammon endturn")
     def toBackgammon   = et
     def toAbalone      = sys.error("Can't make a abalone endturn from a backgammon endturn")
+    def toDameo        = sys.error("Can't make a dameo endturn from a backgammon endturn")
 
   }