Format (#66)

add scalafmt conf and check in CI

Author: huiwang

.github/workflows/ci.yml

@@ -8,4 +8,4 @@ jobs:
       - uses: actions/checkout@v1
       - uses: olafurpg/setup-scala@v5
       - name: Test
-        run: sbt test
+        run: sbt scalafmtCheckAll test

.scalafmt.conf

@@ -0,0 +1 @@
+version = 2.5.2

build.sbt

@@ -13,6 +13,7 @@ resolvers += Resolver.mavenLocal
 libraryDependencies += "org.scalatest" %% "scalatest" % "3.1.2" % "test"
 libraryDependencies += "com.github.writethemfirst" % "approvals-java" % "0.4" % "test"
 libraryDependencies += "org.scala-lang" % "scala-compiler" % "2.13.1" % "test"
+libraryDependencies += "org.scalameta" %% "scalafmt-core" % "2.5.2"
 
 enablePlugins(JmhPlugin)
 enablePlugins(JavaAppPackaging)

project/plugins.sbt

@@ -1,4 +1,5 @@
 logLevel := Level.Warn
 addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.3.3")
 addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.3")
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.0")
 

src/main/scala/com/truelaurel/algorithm/alphabeta/AlphaBetaAi.scala

@@ -7,8 +7,10 @@ import scala.annotation.tailrec
 /**
   * @param heuristic must represent higher chance of success for state.nextPlayer
   */
-case class AlphaBetaAi[S <: GameState[Boolean], M](rules: RulesFor2p[S, M],
-                                                   heuristic: S => Double) {
+case class AlphaBetaAi[S <: GameState[Boolean], M](
+    rules: RulesFor2p[S, M],
+    heuristic: S => Double
+) {
 
   val MIN = Double.MinValue
   val MAX = Double.MaxValue
@@ -18,20 +20,16 @@ case class AlphaBetaAi[S <: GameState[Boolean], M](rules: RulesFor2p[S, M],
     best(sorted, MIN, MAX, state, depth).move.getOrElse(sorted.head)
   }
 
-
   def sortedMoves(state: S): Seq[M] = {
     rules.validMoves(state).sortBy(m => heuristic(rules.applyMove(state, m)))
   }
 
-  def negamax(state: S,
-              depth: Int,
-              alpha: Double,
-              beta: Double): Double = {
+  def negamax(state: S, depth: Int, alpha: Double, beta: Double): Double = {
     val player = state.nextPlayer
     rules.outcome(state) match {
       case Wins(`player`) => MAX
-      case Wins(_) => MIN
-      case Draw => 0
+      case Wins(_)        => MIN
+      case Draw           => 0
       case Undecided =>
         val moves = sortedMoves(state)
         if (depth == 0 || moves.isEmpty) heuristic(state)
@@ -40,22 +38,30 @@ case class AlphaBetaAi[S <: GameState[Boolean], M](rules: RulesFor2p[S, M],
   }
 
   @tailrec
-  final def best(moves: Seq[M],
-                 alpha: Double,
-                 beta: Double,
-                 state: S,
-                 depth: Int,
-                 currentBest: Option[M] = None): ScoredMove = {
+  final def best(
+      moves: Seq[M],
+      alpha: Double,
+      beta: Double,
+      state: S,
+      depth: Int,
+      currentBest: Option[M] = None
+  ): ScoredMove = {
     if (beta > alpha && moves.nonEmpty) {
       val move = moves.head
       val nextState = rules.applyMove(state, move)
       val evaluation = -negamax(nextState, depth - 1, -beta, -alpha)
       val newBest = if (evaluation > alpha) Some(move) else currentBest
-      best(moves.tail, alpha max evaluation, beta max evaluation, state, depth, newBest)
+      best(
+        moves.tail,
+        alpha max evaluation,
+        beta max evaluation,
+        state,
+        depth,
+        newBest
+      )
     } else ScoredMove(alpha, currentBest)
   }
 
-
   case class ScoredMove(score: Double, move: Option[M])
 
 }

src/main/scala/com/truelaurel/algorithm/alphabeta/AlphaBetaAi2.scala

@@ -1,23 +1,26 @@
 package com.truelaurel.algorithm.alphabeta
 
 import com.truelaurel.algorithm.game._
-import com.truelaurel.samplegames.wondev.domain.{MutableWondevState, WondevAction}
+import com.truelaurel.samplegames.wondev.domain.{
+  MutableWondevState,
+  WondevAction
+}
 
 /**
   * @param heuristic must represent higher chance of success for state.nextPlayer
   */
-case class AlphaBetaAi2(rules: RulesFor2p[MutableWondevState, WondevAction],
-                        heuristic: MutableWondevState => Double,
-                        moveHeuristc: (WondevAction, MutableWondevState) => Double
-                       ) {
+case class AlphaBetaAi2(
+    rules: RulesFor2p[MutableWondevState, WondevAction],
+    heuristic: MutableWondevState => Double,
+    moveHeuristc: (WondevAction, MutableWondevState) => Double
+) {
 
   type S = MutableWondevState
   type M = WondevAction
 
   val MIN = Double.MinValue
   val MAX = Double.MaxValue
 
-
   def bestMove(state: S, depth: Int): M = {
     val moves = rules.validMoves(state).sortBy(moveHeuristc(_, state))
 
@@ -28,7 +31,13 @@ case class AlphaBetaAi2(rules: RulesFor2p[MutableWondevState, WondevAction],
     while (i < moves.size) {
       val move = moves(i)
 
-      val valueForMove = alphabeta(rules.applyMove(state, move), depth - 1, currentAlpha, MAX, maximizingPlayer = false)
+      val valueForMove = alphabeta(
+        rules.applyMove(state, move),
+        depth - 1,
+        currentAlpha,
+        MAX,
+        maximizingPlayer = false
+      )
       state.writable.undo()
       if (valueForMove > value) {
         bestMove = move
@@ -40,7 +49,13 @@ case class AlphaBetaAi2(rules: RulesFor2p[MutableWondevState, WondevAction],
     bestMove
   }
 
-  def alphabeta(state: S, depth: Int, alpha: Double, beta: Double, maximizingPlayer: Boolean): Double = {
+  def alphabeta(
+      state: S,
+      depth: Int,
+      alpha: Double,
+      beta: Double,
+      maximizingPlayer: Boolean
+  ): Double = {
     if (depth == 0) {
       heuristic(state)
     } else {
@@ -54,7 +69,16 @@ case class AlphaBetaAi2(rules: RulesFor2p[MutableWondevState, WondevAction],
           var currentAlpha = alpha
           while (i < moves.size) {
             val move = moves(i)
-            value = Math.max(value, alphabeta(rules.applyMove(state, move), depth - 1, currentAlpha, beta, maximizingPlayer = false))
+            value = Math.max(
+              value,
+              alphabeta(
+                rules.applyMove(state, move),
+                depth - 1,
+                currentAlpha,
+                beta,
+                maximizingPlayer = false
+              )
+            )
             state.writable.undo()
             currentAlpha = Math.max(currentAlpha, value)
             if (beta <= currentAlpha)
@@ -68,7 +92,16 @@ case class AlphaBetaAi2(rules: RulesFor2p[MutableWondevState, WondevAction],
           var currentBeta = beta
           while (i < moves.size) {
             val move = moves(i)
-            value = Math.min(value, alphabeta(rules.applyMove(state, move), depth - 1, alpha, currentBeta, maximizingPlayer = true))
+            value = Math.min(
+              value,
+              alphabeta(
+                rules.applyMove(state, move),
+                depth - 1,
+                alpha,
+                currentBeta,
+                maximizingPlayer = true
+              )
+            )
             state.writable.undo()
             currentBeta = Math.min(currentBeta, value)
             if (currentBeta <= alpha)

src/main/scala/com/truelaurel/algorithm/dichotomy/Dichotomy.scala

@@ -11,7 +11,8 @@ object Dichotomy {
     * @return the target value where we can't go lower anymore
     */
   def search(low: Int, high: Int, lower: Int => Boolean): Int = {
-    if (low == high) low else {
+    if (low == high) low
+    else {
       val mid = (low + high) / 2
       if (lower(mid)) {
         search(low, mid, lower)

src/main/scala/com/truelaurel/algorithm/game/GameRules.scala

@@ -13,9 +13,11 @@ trait GameRules[P, S <: GameState[P], M] {
   def outcome(state: S): Outcome[P]
 
   @tailrec
-  final def judge(players: Map[P, S => M],
-                  debug: S => Unit,
-                  state: S = initial): Outcome[P] = {
+  final def judge(
+      players: Map[P, S => M],
+      debug: S => Unit,
+      state: S = initial
+  ): Outcome[P] = {
     debug(state)
     outcome(state) match {
       case Undecided =>
@@ -40,10 +42,10 @@ trait GameRules[P, S <: GameState[P], M] {
     def playRec(s: S): Outcome[P] = {
       outcome(s) match {
         case Undecided => playRec(applyMove(s, selectMove(s)))
-        case decided => decided
+        case decided   => decided
       }
     }
 
     playRec(state)
   }
-}
+}

src/main/scala/com/truelaurel/algorithm/game/Outcome.scala

@@ -6,4 +6,4 @@ case class Wins[P](p: P) extends Outcome[P]
 
 case object Undecided extends Outcome[Nothing]
 
-case object Draw extends Outcome[Nothing]
+case object Draw extends Outcome[Nothing]

src/main/scala/com/truelaurel/algorithm/game/RulesFor2p.scala

@@ -1,12 +1,12 @@
 package com.truelaurel.algorithm.game
 
-trait RulesFor2p[S <: GameState[Boolean], M]
-  extends GameRules[Boolean, S, M] {
+trait RulesFor2p[S <: GameState[Boolean], M] extends GameRules[Boolean, S, M] {
 
-
-  def judge(truePl: S => M,
-            falsePl: S => M,
-            debug: S => Unit): Outcome[Boolean] =
+  def judge(
+      truePl: S => M,
+      falsePl: S => M,
+      debug: S => Unit
+  ): Outcome[Boolean] =
     judge(Map(true -> truePl, false -> falsePl), debug, initial)
 
 }