Possible partialarchitecture of the application

[semjon00]

Coauthored w/ Matrinkrk

class Server:
    port: Int
    games: Map<Int(game_id),Game> // Int - game_id
    availableSlots: Set<Int(game_id)> // Int - game_id
    processInboundConnections() // "Main loop" for server, wait for client, find a game, assign to a client

class Client:
    currentGame: Game
    connectedServer: Socket
    ...

class Game:
    gameRoom: String // By invitation: random HEX string, random game: empty string
    currentTurn: Int // Which snake should play a turn now
    snakes: Array<AbstractSnake>
    currentSettings: GameSettings
    tiles: 2DArray<Int>
    Game(currentSettings, ...): Game
    addSnake(AbstractSnake): Void

class GameSettings:
    fieldWidth: Int
    fieldHeight: Int
    areWallsPortal: Bool
    isCorpseMode: Bool

class AbstractSnake:
    assignedGame: Int // game_id ???
    appearance: SnakeAppearance
    bonusJumpAvailable: Bool
    bonusDiagonal: Bool
    isDead: Bool
    checkSnakeGameover(): Bool // Actually checks if there are no more valid moves, has default implementation
    getMove(): SomebodyMovedGameEvent
    eventSink(GameEvent) : Void // This is very awkward, we probably should extract PeerConnection from AbstractSnake and make Game communicate with these.

class LocalSnake : AbstractSnake: // Our snake, we client controls it
    ...

class RemoteSnake : AbstractSnake: // Server-controlled snake
    ...

class ClientSnake : AbstractSnake: // Server game consists of these
    ...

class DumbAISnake : AbstractSnake: // Picks a random turn
    getMove(): SomebodyMovedGameEvent
    eventSink(GameEvent) : Void

class SnakeAppearance:
    color: Color
    texture: Int // Type of snake skin/eyes

class AbstractGameEvent: // serializable, can be sent from server to client and vice versa
    ...

class GameInitatedGameEvent : AbstractGameEvent:
    ...

class SomebodyMovedGameEvent : AbstractGameEvent:
    who: Int
    whereX: Int
    whereY: Int

class SomebodyDiedGameEvent : AbstractGameEvent: // Maybe excessive? Client can be smart enough to know themselves
    who: Int
    cause: EnumCause // No more moves, disconnect

class SomebodyWonGameEvent : AbstractGameEvent: // Maybe excessive?
    who: Int
    desiredEffect: Int // Display some emoji/text/firewark texture

[semjon00]

An idea:

class PeerConnection:
    eventSink(...): Void // Communicate event
    eventListener(...): ... // Validate and apply event
    allowedSnakes: Int // For snake access control

Game has an array of these, empty for local game, has 1 element if performing as client, multiple if performing as server