Show proper game summary

Sources/App/Model/Tables/DealingTable.swift

@@ -9,7 +9,6 @@ final class DealingTable: AbstractTable<DealingPlayer> {
             player.cards = cards[index]
         }
         super.init(table: table, players: players)
-        print("\(self.players[0].cards.count) cards")
     }
 
     /// All players either doubled or didn't double

Sources/App/Model/Tables/FinishedTable.swift

@@ -4,42 +4,60 @@ final class FinishedTable: AbstractTable<FinishedPlayer> {
 
     let game: GameType
 
+    let totalNumberOfDoubles: Int
+
+    let leadingTrumps: Int
+
+    var cost: Int {
+        guard !isBettel else {
+            return game.basicCost * 2^^totalNumberOfDoubles
+        }
+        var cost = game.basicCost
+        if isSchwarz {
+            cost += 10
+        } else if isSchneider {
+            cost += 5
+        }
+        cost += 5 * leadingTrumps
+        return cost * 2^^totalNumberOfDoubles
+    }
+
+    var gameSelector: FinishedPlayer {
+        players.first { $0.selectedGame }!
+    }
+
+    let selectorDidWin: Bool
+
+    var coPlayers: [FinishedPlayer] {
+        let selector = gameSelector
+        return players.filter { $0 != selector && $0.leadsGame == selector.leadsGame }
+    }
+
     var winners: [FinishedPlayer] {
-        leadersHaveWon ? leaders : opponents
+        let selectorLeads = gameSelector.leadsGame
+        return players.filter { $0.leadsGame == (selectorDidWin == selectorLeads) }
     }
 
-    var loosers: [FinishedPlayer] {
-        leadersHaveWon ? opponents : leaders
+    var selectorTeamPoints: Int {
+        gameSelector.points + coPlayers.map { $0.points }.reduce(0, +)
     }
 
-    var leaders: [FinishedPlayer] {
-        players.filter { $0.leadsGame }
-    }
-
-    var opponents: [FinishedPlayer] {
-        players.filter { !$0.leadsGame }
-    }
-
-    var winningPoints: Int {
-        leadersHaveWon ? leadingPoints : 120 - leadingPoints
-    }
-
-    var loosingPoints: Int {
-        leadersHaveWon ? 120 - leadingPoints : leadingPoints
-    }
-
-    let leadingPoints: Int
-
-    var leadersHaveWon: Bool {
-        leadingPoints > 60
+    var isBettel: Bool {
+        game == .bettel
     }
 
     var isSchwarz: Bool {
-        loosingPoints == 0
+        !isBettel && (selectorTeamPoints == 0 || selectorTeamPoints == 120)
     }
 
     var isSchneider: Bool {
-        loosingPoints < (leadersHaveWon ? 30 : 31)
+        guard !isBettel else {
+            return false
+        }
+        let points = selectorTeamPoints
+        let leads = gameSelector.leadsGame
+        let limit = leads ? 31 : 30
+        return points < limit || 120 - points < limit
     }
 
     override var playedGame: GameType? {
@@ -47,16 +65,29 @@ final class FinishedTable: AbstractTable<FinishedPlayer> {
     }
 
     init(table: PlayingTable)  {
-
         let players = table.players.map(FinishedPlayer.init)
+        let selector = table.players.first { $0.selectsGame }!
         self.game = table.game
-        leadingPoints = players
-            .filter { $0.leadsGame }
+        self.totalNumberOfDoubles = table.totalNumberOfDoubles
+        defer {
+            for player in winners {
+                player.isNextActor = true
+            }
+        }
+
+        guard table.game != .bettel else {
+            self.selectorDidWin = selector.wonTricks.isEmpty
+            self.leadingTrumps = 0
+            super.init(table: table, players: players)
+            return
+        }
+        let selectorLeads = selector.leadsGame
+        let teamPoints = players
+            .filter { $0.leadsGame == selectorLeads }
             .map { $0.points }
             .reduce(0, +)
-        // TODO: Set isNextActor for winners
-        // TODO: Check for bettel
-        // TODO: Set schneider, schwarz, cost
+        self.selectorDidWin = teamPoints > (selectorLeads ? 60 : 59)
+        self.leadingTrumps = table.leadingTrumps
         super.init(table: table, players: players)
     }
 

Sources/App/Model/Tables/PlayingTable.swift

@@ -4,6 +4,8 @@ final class PlayingTable: AbstractTable<PlayingPlayer> {
 
     let game: GameType
 
+    let leadingTrumps: Int
+
     var indexOfTrickStarter = 0
 
     var didDoubleInCurrentRound = false
@@ -32,6 +34,12 @@ final class PlayingTable: AbstractTable<PlayingPlayer> {
         !players.contains { !$0.cards.isEmpty }
     }
 
+    var totalNumberOfDoubles: Int {
+        players.map {
+            $0.numberOfRaises + ($0.didDouble ? 1 : 0)
+        }.reduce(0,+)
+    }
+
     override var playedGame: GameType? {
         game
     }
@@ -53,6 +61,11 @@ final class PlayingTable: AbstractTable<PlayingPlayer> {
 
     private init(table: ManageableTable, players: [PlayingPlayer], game: GameType) {
         self.game = game
+        let selectorCards = players.filter { $0.leadsGame || $0.isCallee }.map { $0.cards }.reduce([], +)
+        let otherCards = players.filter { !$0.leadsGame && !$0.isCallee }.map { $0.cards }.reduce([], +)
+        let selectorTrumps = game.sortingType.consecutiveTrumps(selectorCards)
+        let otherTrumps = game.sortingType.consecutiveTrumps(otherCards)
+        self.leadingTrumps = max(selectorTrumps, otherTrumps)
         super.init(table: table, players: players)
         players.forEach { $0.sortCards(for: game) }
         players.first!.isNextActor = true
@@ -75,7 +88,7 @@ final class PlayingTable: AbstractTable<PlayingPlayer> {
             print("Player \(name) is not allowed to raise")
             return (.tableStateInvalid, nil)
         }
-        player.numberOfDoubles += 1
+        player.numberOfRaises += 1
         players.forEach { $0.switchLead() }
         self.didDoubleInCurrentRound = true
         return (.success, nil)
@@ -122,8 +135,8 @@ final class PlayingTable: AbstractTable<PlayingPlayer> {
         winner.wonTricks.append(trick)
         winner.isNextActor = true
 
-        if game == .bettel && winner.leadsGame {
-            // A bettel is lost if a single trick is won by the leader
+        if game == .bettel && winner.selectsGame {
+            // A bettel is lost if a single trick is won by the game selector
             return finishedGame()
         }
 
@@ -136,7 +149,6 @@ final class PlayingTable: AbstractTable<PlayingPlayer> {
 
     private func finishedGame() -> (result: PlayerActionResult, table: ManageableTable?) {
         let table = FinishedTable(table: self)
-        print("\(table.winners) have won with \(table.winningPoints) to \(table.loosingPoints) points")
         return (.success, table)
     }
 }