503 abalone

README.md

@@ -4,8 +4,7 @@ It is entirely functional, immutable, and free of side effects.
 
 strategygames is a fork from [scalachess](https://github.com/lichess-org/scalachess) which is the equivalent Chess API for [lichess.org](https://lichess.org).
 
-INSTALL
--------
+## INSTALL
 
 Clone scalachess
 
@@ -26,7 +25,12 @@ To run the tests (with coverage):
     clean coverage test
     coverageReport
 
+To run only 1 test:
+
+    sbt "testOnly **.TestNameTest"
+
 Code formatting
+
 ###
 
 This repository uses [scalafmt](https://scalameta.org/scalafmt/).

src/main/scala/Action.scala

@@ -19,6 +19,7 @@ abstract class Action(
   def toTogyzkumalak: togyzkumalak.Action
   def toGo: go.Action
   def toBackgammon: backgammon.Action
+  def toAbalone: abalone.Action
 }
 
 object Action {
@@ -58,6 +59,10 @@ object Action {
     case et: backgammon.EndTurn  => EndTurn.Backgammon(et)
   }
 
+  def wrap(action: abalone.Action): Action = action match {
+    case m: abalone.Move => Move.Abalone(m)
+  }
+
   def toChess(action: Action): chess.Action = action match {
     case Move.Chess(m) => m
     case Drop.Chess(d) => d
@@ -101,4 +106,9 @@ object Action {
     case _                       => sys.error("Expecting a backgammon action e.g. move, drop, lift, diceroll or endTurn")
   }
 
+  def toAbalone(action: Action): abalone.Move = action match {
+    case Move.Abalone(m) => m
+    case _               => sys.error("Expecting a abalone action e.g. move")
+  }
+
 }

src/main/scala/Actor.scala

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

src/main/scala/Board.scala

@@ -38,6 +38,7 @@ sealed abstract class Board(
   def toTogyzkumalak: togyzkumalak.Board
   def toGo: go.Board
   def toBackgammon: backgammon.Board
+  def toAbalone: abalone.Board
 }
 
 object Board {
@@ -80,6 +81,7 @@ object Board {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a chess 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")
 
   }
 
@@ -120,6 +122,7 @@ object Board {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a draughts 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")
 
   }
 
@@ -161,6 +164,7 @@ object Board {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a fairysf 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")
 
   }
 
@@ -201,6 +205,7 @@ object Board {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a samurai 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")
 
   }
 
@@ -243,6 +248,7 @@ object Board {
     def toTogyzkumalak = b
     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")
 
   }
 
@@ -284,6 +290,7 @@ object Board {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a go 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")
 
   }
 
@@ -328,6 +335,48 @@ object Board {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a backgammon 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")
+
+  }
+
+  case class Abalone(b: abalone.Board)
+      extends Board(
+        b.pieces.map { case (pos, piece) => (Pos.Abalone(pos), (Piece.Abalone(piece), 1)) },
+        History.Abalone(b.history),
+        Variant.Abalone(b.variant)
+      ) {
+
+    def withHistory(h: History): Board = h match {
+      case History.Abalone(h) => Abalone(b.withHistory(h))
+      case _                  => sys.error("Not passed abalone objects")
+    }
+
+    def usedDice: List[Int] = List.empty
+
+    def situationOf(player: Player): Situation = Situation.Abalone(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.Abalone(history), Variant.Abalone(variant)) =>
+        Abalone(b.copy(history = history, variant = variant))
+      case _                                                    => sys.error("Unable to copy a abalone board with non-abalone arguments")
+    }
+    def copy(history: History): Board                   = history match {
+      case History.Abalone(history) => Abalone(b.copy(history = history))
+      case _                        => sys.error("Unable to copy a abalone board with non-abalone arguments")
+    }
+
+    def toFairySF      = sys.error("Can't make a fairysf board from a abalone board")
+    def toChess        = sys.error("Can't make a chess board from a abalone board")
+    def toDraughts     = sys.error("Can't make a draughts board from a abalone board")
+    def toSamurai      = sys.error("Can't make a samurai board from a abalone board")
+    def toTogyzkumalak = sys.error("Can't make a togyzkumalak board from a abalone 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
 
   }
 
@@ -405,6 +454,16 @@ object Board {
             variant
           )
         )
+      case (GameLogic.Abalone(), Variant.Abalone(variant))           =>
+        Abalone(
+          abalone.Board.apply(
+            pieces.flatMap {
+              case (Pos.Abalone(pos), (Piece.Abalone(piece), _)) => Some((pos, piece))
+              case _                                             => None
+            },
+            variant
+          )
+        )
       case _                                                         => sys.error("Mismatched gamelogic types 27")
     }
 
@@ -415,6 +474,7 @@ object Board {
   implicit def togyzkumalakBoard(b: togyzkumalak.Board) = Board.Togyzkumalak(b)
   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)
 
   def init(lib: GameLogic, variant: Variant): Board = (lib, variant) match {
     case (GameLogic.Draughts(), Variant.Draughts(variant))         => Draughts(draughts.Board.init(variant))
@@ -425,6 +485,7 @@ object Board {
       Togyzkumalak(togyzkumalak.Board.init(variant))
     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 _                                                         => sys.error("Mismatched gamelogic types 28")
   }
 

src/main/scala/DiceRoll.scala

@@ -50,6 +50,7 @@ object DiceRoll {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak DiceRoll from a chess 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")
 
   }
 
@@ -76,6 +77,7 @@ object DiceRoll {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak DiceRoll from a backgammon 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")
 
   }
 

src/main/scala/Drop.scala

@@ -53,6 +53,7 @@ object Drop {
     def toTogyzkumalak = sys.error("Can't make a togy drop from a chess 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")
 
   }
 
@@ -79,6 +80,7 @@ object Drop {
     def toTogyzkumalak = sys.error("Can't make a togy drop from a fairysf 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")
 
   }
 
@@ -105,6 +107,7 @@ object Drop {
     def toTogyzkumalak = sys.error("Can't make a togy drop from a go 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")
 
   }
 
@@ -131,6 +134,7 @@ object Drop {
     def toTogyzkumalak = sys.error("Can't make a togy drop from a backgammon 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")
 
   }
 

src/main/scala/EndTurn.scala

@@ -45,6 +45,7 @@ object EndTurn {
     def toTogyzkumalak = sys.error("Can't make a togyzkumalak endturn from a backgammon 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")
 
   }