Merge pull request #783 from allanjoseph98/tiebreak-returned

Tiebreak: add lastRoundId to Tournament for ForeBuchholz

Author: ornicar

bench/src/main/scala/benchmarks/TiebreakBench.scala

@@ -24,7 +24,9 @@ class TiebreakBench:
 
   @Setup
   def setup(): Unit =
-    tournament = Tournament(Helper.games("FWWRC.pgn"))
+    val games = Helper.games("FWWRC.pgn")
+    val lastRoundId = Helper.lastRoundId(games)
+    tournament = Tournament(games, lastRoundId)
 
   @Benchmark
   def averageOfOpponentsBuchholz(bh: Blackhole) =

test-kit/src/test/scala/tiebreak/Helper.scala

@@ -47,3 +47,6 @@ object Helper:
       .groupBy(_._1)
       .map: (player, games) =>
         player.id -> PlayerWithGames(player, games.map(_._2))
+
+  def lastRoundId(gamesMap: Map[String, PlayerWithGames]): Option[String] =
+    gamesMap.values.maxByOption(_.games.size).flatMap(_.games.lastOption.flatMap(_.roundId))

test-kit/src/test/scala/tiebreak/TiebreakSnapshotTest.scala

@@ -9,48 +9,54 @@ import Helper.*
 class TiebreakSnapshotTest extends MunitExtensions with SnapshotAssertions:
 
   test("tiebreak games snapshot") {
+    val gamesMap = games("FWWRC.pgn")
     val result = Tiebreak
       .compute(
-        games("FWWRC.pgn"),
+        gamesMap,
         List(
           AverageOfOpponentsBuchholz,
           AveragePerfectPerformanceOfOpponents,
           DirectEncounter,
           PerfectTournamentPerformance,
           SonnebornBerger(CutModifier.None)
-        )
+        ),
+        lastRoundId(gamesMap)
       )
       .mkString("\n")
     assertFileSnapshot(result, "tiebreak/tournament.txt")
   }
 
   // https://chess-results.com/tnr1074691.aspx?lan=1&art=1&flag=30
   test("Women's world rapid championship") {
+    val gamesMap = games("FWWRC.pgn")
     val result = Tiebreak
       .compute(
-        games("FWWRC.pgn"),
+        gamesMap,
         List(
           Buchholz(CutModifier.Cut1),
           Buchholz(CutModifier.None),
           AverageRatingOfOpponents(CutModifier.Cut1)
-        )
+        ),
+        lastRoundId(gamesMap)
       )
       .mkString("\n")
     assertFileSnapshot(result, "tiebreak/official_tournament.txt")
   }
 
   // https://chess-results.com/tnr1175851.aspx?art=1
   test("Uzchess Cup"):
+    val gamesMap = games("uzchesscup.pgn")
     val result = Tiebreak
       .compute(
-        games("uzchesscup.pgn"),
+        gamesMap,
         List(
           DirectEncounter,
           SonnebornBerger(CutModifier.None),
           NbWins,
           NbBlackWins,
           KoyaSystem(LimitModifier.default)
-        )
+        ),
+        lastRoundId(gamesMap)
       )
       .mkString("\n")
     assertFileSnapshot(result, "tiebreak/uzchesscup.txt")

test-kit/src/test/scala/tiebreak/TiebreakTest.scala

@@ -39,12 +39,12 @@ class TiebreakTest extends ChessTest:
     playerA.draws(playerC, "2"),
     playerA.loses(playerD, "3"),
     playerA.beats(playerE, "4"),
-    playerB.beats(playerC, "1"),
-    playerB.draws(playerD, "2"),
-    playerB.loses(playerE, "3"),
-    playerC.beats(playerD, "1"),
-    playerC.draws(playerE, "2"),
-    playerD.beats(playerE, "1")
+    playerB.beats(playerC, "2"),
+    playerB.draws(playerD, "3"),
+    playerB.loses(playerE, "4"),
+    playerC.beats(playerD, "3"),
+    playerC.draws(playerE, "4"),
+    playerD.beats(playerE, "4")
   )
 
   def povGames(player: Player): Seq[Game] =
@@ -60,13 +60,15 @@ class TiebreakTest extends ChessTest:
   val playerE_Games = PlayerWithGames(playerE, povGames(playerE))
   val allGames =
     Seq(playerA_Games, playerB_Games, playerC_Games, playerD_Games, playerE_Games).mapBy(_.player.id)
+  val lastRoundId =
+    allGames.values.maxByOption(_.games.size).flatMap(_.games.lastOption).flatMap(_.roundId)
 
   def computeTournamentPoints(
       allGames: Map[PlayerId, PlayerWithGames],
       player: Player,
       tiebreak: Tiebreak
   ): Option[TiebreakPoint] =
-    Tournament(allGames)
+    Tournament(allGames, lastRoundId)
       .compute(List(tiebreak))
       .find(_.player.id == player.id)
       .flatMap(_.tiebreakPoints.headOption)
@@ -183,11 +185,11 @@ class TiebreakTest extends ChessTest:
     )
 
     val points1 = DirectEncounter
-      .compute(Tournament(allGames), previousPoints)
+      .compute(Tournament(allGames, lastRoundId), previousPoints)
       .get(playerA.id)
       .flatMap(_.lift(1))
     val points2 = DirectEncounter
-      .compute(Tournament(allGames), previousPoints)
+      .compute(Tournament(allGames, lastRoundId), previousPoints)
       .get(playerD.id)
       .flatMap(_.lift(1))
     assertEquals(points1, Some(TiebreakPoint(0f)))
@@ -201,11 +203,11 @@ class TiebreakTest extends ChessTest:
     )
 
     val points1 = DirectEncounter
-      .compute(Tournament(allGames), previousPoints)
+      .compute(Tournament(allGames, lastRoundId), previousPoints)
       .get(playerA.id)
       .flatMap(_.lift(1))
     val points2 = DirectEncounter
-      .compute(Tournament(allGames), previousPoints)
+      .compute(Tournament(allGames, lastRoundId), previousPoints)
       .get(playerD.id)
       .flatMap(_.lift(1))
     assertEquals(points1, Some(TiebreakPoint(0f)))
@@ -235,15 +237,15 @@ class TiebreakTest extends ChessTest:
         .mapBy(_.player.id)
 
     val points1 = DirectEncounter
-      .compute(Tournament(allGamesWithPartial), previousPoints)
+      .compute(Tournament(allGamesWithPartial, None), previousPoints)
       .get(playerA.id)
       .flatMap(_.lift(1))
     val points2 = DirectEncounter
-      .compute(Tournament(allGamesWithPartial), previousPoints)
+      .compute(Tournament(allGamesWithPartial, None), previousPoints)
       .get(playerD.id)
       .flatMap(_.lift(1))
     val pointsX = DirectEncounter
-      .compute(Tournament(allGamesWithPartial), previousPoints)
+      .compute(Tournament(allGamesWithPartial, None), previousPoints)
       .get(playerX_Games.player.id)
       .flatMap(_.lift(1))
     assertEquals(points1, Some(TiebreakPoint(0f)))

tiebreak/src/main/scala/Tiebreak.scala

@@ -258,6 +258,7 @@ trait Tournament:
   def toPlayerGames: Map[PlayerId, Tiebreak.PlayerWithGames]
   def opponentsOf: PlayerId => List[Player]
   def scoreOf: PlayerId => TournamentScore
+  def lastRoundId: Option[String]
   // def currentRound: Int
   // def totalRounds: Int
   // def byes: (PlayerId, Int) => Boolean // playerId, round => true if player has a bye in that round
@@ -297,12 +298,6 @@ trait Tournament:
       .map(opponent => scoreOf(opponent.id).into(TiebreakPoint))
       .sorted
 
-  lazy val lastRoundId: Option[String] = toPlayerGames.values
-    .maxBy(_.games.size)
-    .games
-    .lastOption
-    .flatMap(_.roundId)
-
   lazy val foreBuchholzSeq: PlayerId => Seq[TiebreakPoint] = memoize: id =>
     lastRoundId.fold(buchholzSeq(id)): lastRound =>
       opponentsOf(id)
@@ -340,7 +335,8 @@ trait Tournament:
 
 object Tournament:
 
-  private case class Impl(games: Map[PlayerId, Tiebreak.PlayerWithGames]) extends Tournament:
+  private case class Impl(games: Map[PlayerId, Tiebreak.PlayerWithGames], lastRoundId: Option[String])
+      extends Tournament:
 
     override def toPlayerGames: Map[PlayerId, PlayerWithGames] = games
 
@@ -375,8 +371,8 @@ object Tournament:
       if expectedScoreFor(mid, oppRatings) >= myScore then binarySearch(oppRatings, myScore)(low, mid)
       else binarySearch(oppRatings, myScore)(mid + 1, high)
 
-  def apply(games: Map[PlayerId, Tiebreak.PlayerWithGames]): Tournament =
-    Impl(games)
+  def apply(games: Map[PlayerId, Tiebreak.PlayerWithGames], lastRoundId: Option[String]): Tournament =
+    Impl(games, lastRoundId)
 
 enum CutModifier(val code: String, val name: String, val top: Int, val bottom: Int):
   case None extends CutModifier("", "", 0, 0)
@@ -442,9 +438,10 @@ object Tiebreak:
 
   def compute(
       games: Map[PlayerId, Tiebreak.PlayerWithGames],
-      tiebreaks: List[Tiebreak]
+      tiebreaks: List[Tiebreak],
+      lastRoundId: Option[String]
   ): List[PlayerWithScore] =
-    Tournament(games).compute(tiebreaks)
+    Tournament(games, lastRoundId).compute(tiebreaks)
 
   type PlayerPoints = Map[PlayerId, List[TiebreakPoint]]