Add table persistence, organize files

2021-12-01 22:47:19 +01:00
parent 7265fd0f0d
commit cde63c03d6
9 changed files with 410 additions and 214 deletions
--- a/Sources/App/Management/ClientConnection.swift
+++ b/Sources/App/Management/ClientConnection.swift
@ -0,0 +1,32 @@
+import Foundation
+import WebSocketKit
+
+private let encoder = JSONEncoder()
+
+enum ClientMessageType: String {
+
+    /// The names and connection states of th player, plus table name and id
+    case tableInfo = "t"
+    
+    /// The hand cards of the player and the cards on the table
+    case cardInfo = "c"
+    
+    /// The game is in the bidding phase
+    case biddingInfo = "b"
+    
+    /// 
+}
+
+protocol ClientMessage: Encodable {
+    
+    static var type: ClientMessageType { get }
+}
+
+extension WebSocket {
+
+    func send<T>(_ data: T) where T: ClientMessage {
+        let json = try! encoder.encode(data)
+        let string = String(data: json, encoding: .utf8)!
+        self.send(T.type.rawValue + string)
+    }
+}
--- a/Sources/App/Management/Database.swift
+++ b/Sources/App/Management/Database.swift
@ -0,0 +1,108 @@
+import Foundation
+import Vapor
+
+final class Database {
+
+    private let players: PlayerManagement
+
+    private let tables: TableManagement
+
+    init(storageFolder: URL) throws {
+        self.players = try PlayerManagement(storageFolder: storageFolder)
+        self.tables = try TableManagement(storageFolder: storageFolder)
+    }
+
+    // MARK: Players & Sessions
+
+    func registerPlayer(named name: PlayerName, hash: PasswordHash) -> SessionToken? {
+        players.registerPlayer(named: name, hash: hash)
+    }
+
+    func passwordHashForExistingPlayer(named name: PlayerName) -> PasswordHash? {
+        players.passwordHash(ofRegisteredPlayer: name)
+    }
+
+    func deletePlayer(named name: PlayerName) {
+        _ = players.deletePlayer(named: name)
+        tables.remove(player: name)
+    }
+
+    func isValid(sessionToken token: SessionToken) -> Bool {
+        players.isValid(sessionToken: token)
+    }
+
+    func startSession(socket: WebSocket, sessionToken: SessionToken) -> Bool {
+        guard let player = players.registeredPlayerExists(withSessionToken: sessionToken) else {
+            return false
+        }
+        return tables.connect(player: player, using: socket)
+    }
+
+    private func didReceive(message: String, forSessionToken token: SessionToken) {
+        // TODO: Handle client requests
+        print("Session \(token.prefix(6)): \(message)")
+    }
+
+    func endSession(forSessionToken sessionToken: SessionToken) {
+        guard let player = players.endSession(forSessionToken: sessionToken) else {
+            return
+        }
+        tables.disconnect(player: player)
+    }
+
+    /**
+     Start a new session for an existing user.
+     - Parameter name: The user name
+     - Returns: The generated access token for the session
+     */
+    func startNewSessionForRegisteredPlayer(named name: PlayerName) -> SessionToken {
+        players.startNewSessionForRegisteredPlayer(named: name)
+    }
+
+    func registeredPlayerExists(withSessionToken token: SessionToken) -> PlayerName? {
+        players.registeredPlayerExists(withSessionToken: token)
+    }
+
+    func currentTableOfPlayer(named player: PlayerName) -> TableId {
+        tables.currentTableOfPlayer(named: player) ?? ""
+    }
+
+    // MARK: Tables
+
+    /**
+     Create a new table with optional players.
+     - Parameter name: The name of the table
+     - Parameter players: The player creating the table
+     - Parameter visible: Indicates that this is a game joinable by everyone
+     - Returns: The table id
+     */
+    func createTable(named name: TableName, player: PlayerName, visible: Bool) -> TableId {
+        tables.createTable(named: name, player: player, visible: visible)
+    }
+
+    func getPublicTableInfos() -> [TableInfo] {
+        tables.getPublicTableInfos()
+    }
+
+    func join(tableId: TableId, playerToken: SessionToken) -> JoinTableResult {
+        guard let player = players.registeredPlayerExists(withSessionToken: playerToken) else {
+            return .invalidToken
+        }
+        return tables.join(tableId: tableId, player: player)
+    }
+    
+    func leaveTable(playerToken: SessionToken) -> Bool {
+        guard let player = players.registeredPlayerExists(withSessionToken: playerToken) else {
+            return false
+        }
+        tables.remove(player: player)
+        return true
+    }
+    
+    func dealCards(playerToken: SessionToken) -> DealCardResult {
+        guard let player = players.registeredPlayerExists(withSessionToken: playerToken) else {
+            return .invalidToken
+        }
+        return tables.dealCards(player: player)
+    }
+}
--- a/Sources/App/Management/DiskWriter.swift
+++ b/Sources/App/Management/DiskWriter.swift
@ -0,0 +1,62 @@
+//
+//  File.swift
+//  
+//
+//  Created by iMac on 01.12.21.
+//
+
+import Foundation
+
+
+protocol DiskWriter {
+    
+    var storageFile: FileHandle { get }
+    
+    var storageFileUrl: URL { get }
+}
+
+extension DiskWriter {
+    
+    static func prepareFile(at url: URL) throws -> FileHandle {
+        if !FileManager.default.fileExists(atPath: url.path) {
+            try Data().write(to: url)
+        }
+        return try FileHandle(forUpdating: url)
+    }
+    
+    func writeToDisk(line: String) -> Bool {
+        let data = (line + "\n").data(using: .utf8)!
+        do {
+            if #available(macOS 10.15.4, *) {
+                try storageFile.write(contentsOf: data)
+            } else {
+                storageFile.write(data)
+            }
+            try storageFile.synchronize()
+            return true
+        } catch {
+            print("Failed to save data to file: \(storageFileUrl.path): \(error)")
+            return false
+        }
+    }
+    
+    func readLinesFromDisk() throws -> [String] {
+        if #available(macOS 10.15.4, *) {
+            guard let data = try storageFile.readToEnd() else {
+                try storageFile.seekToEnd()
+                return []
+            }
+            return parseLines(data: data)
+        } else {
+            let data = storageFile.readDataToEndOfFile()
+            return parseLines(data: data)
+        }
+    }
+    
+    private func parseLines(data: Data) -> [String] {
+        String(data: data, encoding: .utf8)!
+            .components(separatedBy: "\n")
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { $0 != "" }
+    }
+}
--- a/Sources/App/Management/PlayerManagement.swift
+++ b/Sources/App/Management/PlayerManagement.swift
@ -0,0 +1,146 @@
+import Foundation
+
+typealias PlayerName = String
+typealias PasswordHash = String
+typealias SessionToken = String
+
+/// Manages player registration, session tokens and password hashes
+final class PlayerManagement: DiskWriter {
+
+    /// A mapping between player name and their password hashes
+    private var playerPasswordHashes = [PlayerName: PasswordHash]()
+
+    /// A mapping between player name and generated access tokens for a session
+    private var sessionTokenForPlayer = [PlayerName: SessionToken]()
+
+    /// A reverse mapping between generated access tokens and player name
+    private var playerNameForToken = [SessionToken: PlayerName]()
+    
+    let storageFile: FileHandle
+    
+    let storageFileUrl: URL
+
+    init(storageFolder: URL) throws {
+        let url = storageFolder.appendingPathComponent("passwords.txt")
+        
+        storageFileUrl = url
+        storageFile = try Self.prepareFile(at: url)
+        
+        try readLinesFromDisk().forEach { line in
+            let parts = line.components(separatedBy: ":")
+            // Token may contain the separator
+            guard parts.count >= 2 else {
+                print("Invalid line in password file")
+                return
+            }
+            let name = parts[0]
+            let token = parts.dropFirst().joined(separator: ":")
+            if token == "" {
+                playerPasswordHashes[name] = nil
+            } else {
+                playerPasswordHashes[name] = token
+            }
+        }
+        
+        print("Loaded \(playerPasswordHashes.count) players")
+    }
+    
+    private func save(password: PasswordHash, forPlayer player: PlayerName) -> Bool {
+        writeToDisk(line: player + ":" + password)
+    }
+    
+    private func deletePassword(forPlayer player: PlayerName) -> Bool {
+        writeToDisk(line: player + ":")
+    }
+
+    /**
+     Check if a player exists.
+     - Parameter name: The name of the player
+     - Returns: true, if the player exists
+     */
+    func hasRegisteredPlayer(named user: PlayerName) -> Bool {
+        playerPasswordHashes[user] != nil
+    }
+
+    /**
+     Get the password hash for a player, if the player exists.
+     - Parameter name: The name of the player
+     - Returns: The stored password hash, if the player exists
+     */
+    func passwordHash(ofRegisteredPlayer name: PlayerName) -> PasswordHash? {
+        playerPasswordHashes[name]
+    }
+
+    /**
+     Create a new player and assign an access token.
+     - Parameter name: The name of the new player
+     - Parameter hash: The password hash of the player
+     - Returns: The generated access token for the session
+     */
+    func registerPlayer(named name: PlayerName, hash: PasswordHash) -> SessionToken? {
+        guard !hasRegisteredPlayer(named: name) else {
+            return nil
+        }
+        guard save(password: hash, forPlayer: name) else {
+            return nil
+        }
+        self.playerPasswordHashes[name] = hash
+        return startNewSessionForRegisteredPlayer(named: name)
+    }
+
+    /**
+     Delete a player
+     - Parameter name: The name of the player to delete.
+     - Returns: The session token of the current player, if one exists
+     */
+    func deletePlayer(named name: PlayerName) -> SessionToken? {
+        guard deletePassword(forPlayer: name) else {
+            return nil
+        }
+        playerPasswordHashes.removeValue(forKey: name)
+        guard let sessionToken = sessionTokenForPlayer.removeValue(forKey: name) else {
+            return nil
+        }
+        playerNameForToken.removeValue(forKey: sessionToken)
+        return sessionToken
+    }
+
+    func isValid(sessionToken token: SessionToken) -> Bool {
+        playerNameForToken[token] != nil
+    }
+
+    func sessionToken(forPlayer player: PlayerName) -> SessionToken? {
+        sessionTokenForPlayer[player]
+    }
+
+    /**
+     Start a new session for an existing player.
+     - Parameter name: The player name
+     - Returns: The generated access token for the session
+     */
+    func startNewSessionForRegisteredPlayer(named name: PlayerName) -> SessionToken {
+        let token = SessionToken.newToken()
+        self.sessionTokenForPlayer[name] = token
+        self.playerNameForToken[token] = name
+        return token
+    }
+
+    func endSession(forSessionToken token: SessionToken) -> PlayerName? {
+        guard let player = playerNameForToken.removeValue(forKey: token) else {
+            return nil
+        }
+        sessionTokenForPlayer.removeValue(forKey: player)
+        return player
+    }
+
+    /**
+     Get the player for a session token.
+     - Parameter token: The access token for the player
+     - Returns: The name of the player, if it exists
+     */
+    func registeredPlayerExists(withSessionToken token: SessionToken) -> PlayerName? {
+        playerNameForToken[token]
+    }
+
+
+}
--- a/Sources/App/Management/TableManagement.swift
+++ b/Sources/App/Management/TableManagement.swift
@ -0,0 +1,252 @@
+import Foundation
+import WebSocketKit
+import Vapor
+
+let maximumPlayersPerTable = 4
+
+typealias TableId = String
+typealias TableName = String
+
+final class TableManagement: DiskWriter {
+    
+    /// A list of table ids for public games
+    private var publicTables = Set<TableId>()
+    
+    /// A mapping from table id to table name (for all tables)
+    private var tableNames = [TableId: TableName]()
+    
+    /// A mapping from table id to participating players
+    private var tablePlayers = [TableId: [PlayerName]]()
+    
+    /// A reverse list of players and their table id
+    private var playerTables = [PlayerName: TableId]()
+    
+    private var playerConnections = [PlayerName : WebSocket]()
+    
+    private var tablePhase = [TableId: GamePhase]()
+    
+    
+    let storageFile: FileHandle
+    
+    let storageFileUrl: URL
+    
+    init(storageFolder: URL) throws {
+        let url = storageFolder.appendingPathComponent("tables.txt")
+        
+        storageFileUrl = url
+        storageFile = try Self.prepareFile(at: url)
+        
+        var entries = [TableId : (name: TableName, public: Bool, players: [PlayerName])]()
+        try readLinesFromDisk().forEach { line in
+            // Each line has parts: ID | NAME | PLAYER, PLAYER, ...
+            let parts = line.components(separatedBy: ":")
+            guard parts.count == 4 else {
+                print("Invalid line in table file")
+                return
+            }
+            let id = parts[0]
+            let name = parts[1]
+            let isPublic = parts[2] == "public"
+            let players = parts[3].components(separatedBy: ",")
+            if name == "" {
+                entries[id] = nil
+            } else {
+                entries[id] = (name, isPublic, players)
+            }
+        }
+        entries.forEach { id, table in
+            tableNames[id] = table.name
+            if table.public {
+                publicTables.insert(id)
+            }
+            tablePlayers[id] = table.players
+            tablePhase[id] = .waitingForPlayers
+            for player in table.players {
+                playerTables[player] = id
+            }
+        }
+        print("Loaded \(tableNames.count) tables")
+    }
+    
+    @discardableResult
+    private func save(table tableId: TableId) -> Bool {
+        let name = tableNames[tableId]!
+        let visible = publicTables.contains(tableId) ? "public" : "private"
+        let players = tablePlayers[tableId]!
+        let entry = [tableId, name, visible, players.joined(separator: ",")].joined(separator: ":")
+        return writeToDisk(line: entry)
+    }
+    
+    @discardableResult
+    private func deleteTable(tableId: TableId) -> Bool {
+        let entry = [tableId, "", "", ""].joined(separator: ":")
+        return writeToDisk(line: entry)
+    }
+    
+    /**
+     Create a new table with optional players.
+     - Parameter name: The name of the table
+     - Parameter players: The player creating the table
+     - Parameter visible: Indicates that this is a game joinable by everyone
+     - Returns: The table id
+     */
+    func createTable(named name: TableName, player: PlayerName, visible: Bool) -> TableId {
+        let tableId = TableId.newToken()
+        
+        tableNames[tableId] = name
+        tablePlayers[tableId] = [player]
+        playerTables[player] = tableId
+        
+        if visible {
+            publicTables.insert(tableId)
+        }
+        save(table: tableId)
+        return tableId
+    }
+    
+    func getPublicTableInfos() -> [TableInfo] {
+        publicTables.map(tableInfo).sorted()
+    }
+    
+    private func tableInfo(id tableId: TableId) -> TableInfo {
+        let players = tablePlayers[tableId]!.map(playerState)
+        return TableInfo(
+            id: tableId,
+            name: tableNames[tableId]!,
+            players: players,
+            tableIsFull: players.count == maximumPlayersPerTable)
+    }
+    
+    private func playerState(_ player: PlayerName) -> TableInfo.PlayerState {
+        .init(name: player, connected: playerIsConnected(player))
+    }
+    
+    private func playerIsConnected(_ player: PlayerName) -> Bool {
+        playerConnections[player] != nil
+    }
+    
+    func currentTableOfPlayer(named player: PlayerName) -> TableId? {
+        playerTables[player]
+    }
+    
+    /**
+     Join a table.
+     - Returns: The result of the join operation
+     */
+    func join(tableId: TableId, player: PlayerName) -> JoinTableResult {
+        guard var players = tablePlayers[tableId] else {
+            return .tableNotFound
+        }
+        guard !players.contains(player) else {
+            return .success
+        }
+        guard players.count < maximumPlayersPerTable else {
+            return .tableIsFull
+        }
+        players.append(player)
+        if let oldTable = playerTables[tableId] {
+            remove(player: player, fromTable: oldTable)
+        }
+        tablePlayers[tableId] = players
+        playerTables[player] = tableId
+        save(table: tableId)
+        return .success
+    }
+    
+    func remove(player: PlayerName, fromTable tableId: TableId) {
+        tablePlayers[tableId] = tablePlayers[tableId]?.filter { $0 != player }
+        disconnect(player: player)
+        playerTables[player] = nil
+        // TODO: End game if needed
+        // TODO: Remove table if empty
+        save(table: tableId)
+    }
+    
+    func remove(player: PlayerName) {
+        guard let tableId = playerTables[player] else {
+            return
+        }
+        // Already saves table to disk
+        remove(player: player, fromTable: tableId)
+    }
+    
+    func connect(player: PlayerName, using socket: WebSocket) -> Bool {
+        guard let tableId = playerTables[player] else {
+            return false
+        }
+        guard let players = tablePlayers[tableId] else {
+            print("Player \(player) was assigned to missing table \(tableId.prefix(5))")
+            playerTables[player] = nil
+            return false
+        }
+        guard players.contains(player) else {
+            print("Player \(player) wants updates for table \(tableId.prefix(5)) it didn't join")
+            return false
+        }
+        playerConnections[player] = socket
+        sendTableInfo(toTable: tableId)
+        // TODO: Send cards to player
+        return true
+    }
+    
+    func disconnect(player: PlayerName) {
+        if let socket = playerConnections.removeValue(forKey: player) {
+            if !socket.isClosed {
+                _ = socket.close()
+            }
+        }
+        guard let tableId = playerTables[player] else {
+            return
+        }
+        sendTableInfo(toTable: tableId)
+        // Change table phase to waiting
+    }
+    
+    private func sendTableInfo(toTable tableId: TableId) {
+        let name = tableNames[tableId]!
+        var players = tablePlayers[tableId]!
+        let isFull = players.count == maximumPlayersPerTable
+        for _ in players.count..<maximumPlayersPerTable {
+            players.append("")
+        }
+        let states = players.map(playerState)
+        players.enumerated().forEach { index, player in
+            guard let socket = playerConnections[player] else {
+                return
+            }
+            let info = TableInfo(
+                id: tableId,
+                name: name,
+                players: states.rotated(toStartAt: index),
+                tableIsFull: isFull)
+            socket.send(info)
+        }
+    }
+    
+    func dealCards(player: PlayerName) -> DealCardResult {
+        guard let tableId = playerTables[player] else {
+            return .noTableJoined
+        }
+        guard let players = tablePlayers[tableId] else {
+            playerTables[player] = nil
+            print("Player \(player) assigned to missing table \(tableId.prefix(5))")
+            return .noTableJoined
+        }
+        guard players.count == maximumPlayersPerTable else {
+            return .tableNotFull
+        }
+        
+        let cards = Dealer.deal()
+        let handCards = ["", "", "", ""]
+        players.enumerated().forEach { index, player in
+            guard let socket = playerConnections[player] else {
+                return
+            }
+            let info = CardInfo(
+                cards: cards[index].map { .init(card: $0.id, playable: false) },
+                tableCards: handCards.rotated(toStartAt: index))
+            socket.send(info)
+        }
+        return .success
+    }
+}