Sync push

Sources/App/Infos/CardInfo.swift

@@ -1,19 +0,0 @@
-import Foundation
-
-struct CardInfo: ClientMessage {
-    
-    static let type: ClientMessageType = .cardInfo
-    
-    struct HandCard: Codable {
-        
-        let card: CardId
-        
-        let playable: Bool
-    }
-    
-    /// The cards for a player
-    let cards: [HandCard]
-    
-    // The cards on the table, as seen from the players perspective
-    let tableCards: [CardId]
-}

Sources/App/Infos/GameType.swift

@@ -1,88 +0,0 @@
-import Foundation
-
-enum GameType: Codable {
-    
-    case rufEichel
-    case rufBlatt
-    case rufSchelln
-    case hochzeit
-    case bettel
-    case wenz
-    case geier
-    case soloEichel
-    case soloBlatt
-    case soloHerz
-    case soloSchelln
-    
-    var gameClass: Int {
-        switch self {
-        case .rufEichel, .rufBlatt, .rufSchelln:
-            return 1
-        case .hochzeit:
-            return 2
-        case .bettel:
-            return 3
-        case .wenz, .geier:
-            return 4
-        case .soloEichel, .soloBlatt, .soloHerz, .soloSchelln:
-            return 5
-        }
-    }
-    
-    var isSingleGame: Bool {
-        switch self {
-        case .rufEichel, .rufBlatt, .rufSchelln, .hochzeit:
-            return false
-        default:
-            return true
-        }
-    }
-    
-    var basicCost: Int {
-        switch self {
-        case .rufEichel, .rufBlatt, .rufSchelln:
-            return 5
-        case .hochzeit:
-            return 10
-        case .bettel:
-            return 15
-        case .wenz, .geier:
-            return 20
-        case .soloEichel, .soloBlatt, .soloHerz, .soloSchelln:
-            return 20
-        }
-    }
-    
-    var sortingType: CardSortingStrategy {
-        switch self {
-        case .wenz:
-            return .wenz
-        case .geier:
-            return .geier
-        case .soloEichel:
-            return .soloEichel
-        case .soloBlatt:
-            return .soloBlatt
-        case .soloSchelln:
-            return .soloSchelln
-        default:
-            return .normal
-        }
-    }
-}
-
-enum CardSortingStrategy {
-    
-    /// The sorting for most games, where heart is trump
-    case normal
-    
-    case wenz
-    
-    case geier
-    
-    case soloEichel
-    
-    case soloBlatt
-    
-    case soloSchelln
-}

Sources/App/Infos/PlayerInfo.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+struct PlayerInfo: Codable, Equatable {
+    
+    let name: PlayerName
+    
+    let connected: Bool
+    
+    /// The player is the next one to perform an action
+    let active: Bool
+    
+    /// The cards in the hand of the player
+    let cards: [CardInfo]
+    
+    /// The action the player can perform
+    let actions: [String]
+    
+    init(player: Player, isMasked: Bool) {
+        self.name = player.name
+        self.connected = player.isConnected
+        self.active = player.isNextActor
+        if isMasked {
+            self.cards = []
+            self.actions = []
+        } else {
+            self.actions = player.actions.map { $0.path }
+            self.cards = player.handCards.map { $0.cardInfo }
+        }
+    }
+}

Sources/App/Infos/PublicTableInfo.swift

@@ -0,0 +1,27 @@
+import Foundation
+
+struct PublicTableInfo: Codable {
+    
+    let id: TableId
+
+    let name: TableName
+
+    let players: [PlayerName]
+    
+    let tableIsFull: Bool
+    
+    init(id: TableId, name: String, players: [PlayerName]) {
+        self.id = id
+        self.name = name
+        self.players = players
+        self.tableIsFull = players.count == maximumPlayersPerTable
+    }
+}
+
+extension PublicTableInfo: Comparable {
+
+    static func < (lhs: PublicTableInfo, rhs: PublicTableInfo) -> Bool {
+        lhs.name < rhs.name
+    }
+}
+

Sources/App/Infos/TableInfo.swift

@@ -1,30 +1,34 @@
 import Foundation
 
-struct TableInfo: ClientMessage {
+struct TableInfo: Codable {
     
-    static let type: ClientMessageType = .tableInfo
-
     let id: String
 
     let name: String
-
-    let players: [PlayerState]
     
-    let tableIsFull: Bool
+    let player: PlayerInfo
     
-    struct PlayerState: Codable, Equatable {
-        
-        let name: PlayerName
-        
-        let connected: Bool
-        
-        init(name: PlayerName, connected: Bool) {
-            self.name = name
-            self.connected = connected
-        }
+    let playerLeft: PlayerInfo?
+    
+    let playerAcross: PlayerInfo?
+    
+    let playerRight: PlayerInfo?
+    
+    init(_ table: Table, forPlayerAt playerIndex: Int) {
+        self.id = table.id
+        self.name = table.name
+        self.player = table.player(at: playerIndex)!.info(masked: false)
+        self.playerLeft = table.player(leftOf: playerIndex)?.info(masked: true)
+        self.playerAcross = table.player(acrossOf: playerIndex)?.info(masked: true)
+        self.playerRight = table.player(rightOf: playerIndex)?.info(masked: true)
     }
 }
 
+extension TableInfo {
+    
+    
+}
+
 extension TableInfo: Comparable {
 
     static func < (lhs: TableInfo, rhs: TableInfo) -> Bool {