emulinker/org.emulinker.kaillera.model/KailleraGame

KailleraGame

class KailleraGame(val id: Int, val romName: String, val owner: KailleraUser, val server: KailleraServer, val bufferSize: Int, flags: RuntimeFlags, clock: Clock) : KoinComponent

Represents a game instance on the server.

Synchronization Handshake

The game uses a lock-step synchronization model with an initial handshake to establish lag compensation. The handshake consists of three phases verified by E2E tests:

Buffering (Frames 1-6): The server buffers incoming packets from the client to build up a delay buffer (determined by totalDelay). During this phase, the server sends back "Zero Packets" (packets of the same size as input but zeroed) to the client.
Draining (Frames 7-12): Once the buffer is full, the server begins "draining" the buffer. It processes and fans out the old packets stored during Phase 1. Crucially, strictly "new" inputs received during this draining phase are DROPPED to allow the stream to align with the buffered history.
Synced (Frames 13+): The buffer is now managing the flow. The server fans out packets in real-time order, effectively delayed by the buffer size. Received[T] == Sent[T] (relative to the shifted timeline).

Constructors

constructor(id: Int, romName: String, owner: KailleraUser, server: KailleraServer, bufferSize: Int, flags: RuntimeFlags, clock: Clock)

Types

object Companion

Properties

var aConnection: String

var aEmulator: String

autoFireDetector

val autoFireDetector: AutoFireDetector

val bufferSize: Int

val clientType: String?

val currentGameLag: Duration

The total duration that the game has drifted over the lagstat measurement window.

var gameLogBuilder: GameLog.Builder?

Record of all game log events.

highestUserFrameDelay

var highestUserFrameDelay: Int

val id: Int

ignoringUnnecessaryServerActivity

var ignoringUnnecessaryServerActivity: Boolean

var lagometer: Lagometer?

var maxPing: Int

var maxUsers: Int

val mutedUsers: MutableList<String>

val owner: KailleraUser

playerActionQueues

var playerActionQueues: Array<PlayerActionQueue>?

val players: MutableList<KailleraUser>

val romName: String

var sameDelay: Boolean

Frame delay is synced with others users in the same game (see /samedelay).

val server: KailleraServer

singleFrameDurationForLagCalculationOnlyNs

var singleFrameDurationForLagCalculationOnlyNs: Long

val startDate: Date

var startN: Int

var status: GameStatus

var swap: Boolean

var waitingOnData: Boolean

Whether the game is holding data for the current frame, waiting on one or more players before fanning out.

waitingOnPlayerNumber

val waitingOnPlayerNumber: BooleanArray

If waitingOnPlayerNumber[playerNumber - 1] is true, we are waiting on data for that player.

Functions

fun addData(user: KailleraUser, playerNumber: Int, data: ByteBuf): AddDataResult

Adds data and suspends until all data is available, at which time it returns the sends new data back to the client.

fun announce(announcement: String, toUser: KailleraUser? = null)

fun chat(user: KailleraUser, message: String)

fun close(user: KailleraUser)

fun drop(user: KailleraUser, playerNumber: Int)

fun droppedPacket(user: KailleraUser)

open fun getKoin(): Koin

fun getPlayer(playerNumber: Int): KailleraUser?

getPlayerNumber

fun getPlayerNumber(user: KailleraUser): Int

fun join(user: KailleraUser): Int

fun kick(requester: KailleraUser, userID: Int)

fun maybeSendData(user: KailleraUser): AddDataResult

Checks if any user has a full set of new data to send.

fun quit(user: KailleraUser, playerNumber: Int)

fun ready(user: KailleraUser, playerNumber: Int)

fun setGameFps(fps: Double)

Sets the game framerate for lag measuring purposes.

fun start(user: KailleraUser)

open override fun toString(): String