Add spectator protocol and server for LAN games

This commit is contained in:
2026-10-25 10:42:39 +02:00
parent 2d0e605dfa
commit fb58dfb4ae
11 changed files with 1918 additions and 0 deletions
@@ -0,0 +1,26 @@
package cc.skysparkle.matewave.network
import java.io.Reader
/** Result of reading one newline-delimited message from a socket. */
sealed class LineResult {
data class Line(val text: String) : LineResult()
object TooLong : LineResult()
object EndOfStream : LineResult()
}
/** Reads one line of at most [maxChars] characters; longer lines are reported, not buffered. */
fun readBoundedLine(reader: Reader, maxChars: Int): LineResult {
val builder = StringBuilder()
while (true) {
val ch = reader.read()
if (ch == -1) {
return if (builder.isEmpty()) LineResult.EndOfStream
else LineResult.Line(builder.toString())
}
if (ch == '\n'.code) return LineResult.Line(builder.toString())
if (ch == '\r'.code) continue
if (builder.length >= maxChars) return LineResult.TooLong
builder.append(ch.toChar())
}
}
@@ -0,0 +1,58 @@
package cc.skysparkle.matewave.spectate
enum class PresenceStatus { ONLINE, IN_GAME, OFFLINE }
/** Where to watch a game: the host's address and spectator port. */
data class SpectateTarget(val host: String, val port: Int, val gameTag: String)
/** A player seen on the network, reduced to what spectating needs. */
data class NearbyPlayerGame(
val playerId: String,
val host: String,
val gameTag: String,
val spectatePort: Int
)
data class FriendGameStatus(
val status: PresenceStatus,
val target: SpectateTarget? = null,
/** Live count from the host, null until it has answered. */
val spectators: Int? = null,
val max: Int = MAX_SPECTATORS
) {
val full: Boolean get() = spectators != null && spectators >= max
}
/**
* Online, In game or Offline for one player, and where to watch. Both players of a game announce
* the same tag, but only the host serves spectators, so the guest's game is watched through the
* host. A host that says its game has ended overrides an announcement that is not updated yet.
*/
object FriendStatusResolver {
fun resolve(
playerId: String,
nearby: Map<String, NearbyPlayerGame>,
probes: Map<SpectateTarget, SpectatorMessage.Status>
): FriendGameStatus {
val player = nearby[playerId] ?: return FriendGameStatus(PresenceStatus.OFFLINE)
if (player.gameTag.isEmpty()) return FriendGameStatus(PresenceStatus.ONLINE)
val host = hostOf(player, nearby) ?: return FriendGameStatus(PresenceStatus.IN_GAME)
val target = SpectateTarget(host.host, host.spectatePort, host.gameTag)
val probe = probes[target]
if (probe != null && !probe.inGame) return FriendGameStatus(PresenceStatus.ONLINE)
return FriendGameStatus(PresenceStatus.IN_GAME, target, probe?.count, probe?.max ?: MAX_SPECTATORS)
}
/** Every host worth asking for a live spectator count. */
fun targets(nearby: Collection<NearbyPlayerGame>): Set<SpectateTarget> =
nearby.filter { it.gameTag.isNotEmpty() && it.spectatePort > 0 && it.host.isNotEmpty() }
.map { SpectateTarget(it.host, it.spectatePort, it.gameTag) }
.toSet()
private fun hostOf(player: NearbyPlayerGame, nearby: Map<String, NearbyPlayerGame>): NearbyPlayerGame? {
if (player.spectatePort > 0 && player.host.isNotEmpty()) return player
return nearby.values.firstOrNull {
it.playerId != player.playerId && it.gameTag == player.gameTag && it.spectatePort > 0 && it.host.isNotEmpty()
}
}
}
@@ -0,0 +1,47 @@
package cc.skysparkle.matewave.spectate
/**
* What this device adds to its network announcement while it plays a watchable LAN game: a short
* tag shared by both players of the game, and, on the host, the spectator port. Older app versions
* ignore these attributes.
*/
object SpectatorAdvert {
const val KEY_GAME = "g"
const val KEY_PORT = "sp"
data class State(val gameTag: String = "", val spectatePort: Int = 0)
@Volatile var current = State()
private set
/** Returns true when the announcement has to be published again. */
@Synchronized
fun update(state: State): Boolean {
if (state == current) return false
current = state
return true
}
fun clear(): Boolean = update(State())
fun attributes(state: State = current): Map<String, String> = buildMap {
if (state.gameTag.isNotEmpty()) put(KEY_GAME, state.gameTag)
if (state.gameTag.isNotEmpty() && state.spectatePort > 0) put(KEY_PORT, state.spectatePort.toString())
}
/** Reads the attributes of a discovered player; anything malformed counts as absent. */
fun parse(attribute: (String) -> String): State {
val tag = attribute(KEY_GAME).takeIf { TAG_PATTERN.matches(it) } ?: return State()
val port = attribute(KEY_PORT).toIntOrNull()?.takeIf { it in 1..65_535 } ?: 0
return State(tag, port)
}
/** Short tag of a game id, so the game id itself is not announced. */
fun tagOf(gameId: String): String {
if (gameId.isEmpty()) return ""
val digest = java.security.MessageDigest.getInstance("SHA-256").digest(gameId.toByteArray(Charsets.UTF_8))
return digest.take(4).joinToString("") { "%02x".format(it) }
}
private val TAG_PATTERN = Regex("^[0-9a-f]{8}$")
}
@@ -0,0 +1,189 @@
package cc.skysparkle.matewave.spectate
import cc.skysparkle.matewave.network.LineResult
import cc.skysparkle.matewave.network.readBoundedLine
import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.IOException
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.net.InetSocketAddress
import java.net.Socket
import java.util.concurrent.Executors
import java.util.concurrent.RejectedExecutionException
/**
* One spectator's connection to a hosted game. Events arrive on a background thread, in order.
* Silence longer than [Timing.silenceTimeoutMs] (the host pings every few seconds) means the host
* is gone, which also covers Wi-Fi switching off on either side.
*/
class SpectatorClient(
private val host: String,
private val port: Int,
private val onEvent: (Event) -> Unit,
private val timing: Timing = Timing(),
private val version: Int = SpectatorProtocol.VERSION,
private val minVersion: Int = SpectatorProtocol.MIN_COMPATIBLE_VERSION
) {
data class Timing(val connectTimeoutMs: Int = 5_000, val silenceTimeoutMs: Int = 15_000)
enum class Failure { UNREACHABLE, FULL, NO_GAME, UPDATE_THIS_APP, UPDATE_HOST_APP }
sealed class Event {
data class Joined(val welcome: SpectatorMessage.Welcome) : Event()
data class Received(val message: SpectatorMessage) : Event()
data class JoinFailed(val failure: Failure) : Event()
/** The connection ended after joining; [hostClosed] is true when the host said goodbye. */
data class Disconnected(val hostClosed: Boolean) : Event()
}
@Volatile private var socket: Socket? = null
@Volatile private var output: BufferedWriter? = null
@Volatile private var stopped = false
private val writer = Executors.newSingleThreadExecutor { r ->
Thread(r, "spectator-send").apply { isDaemon = true }
}
fun start() {
Thread({ run() }, "spectator-receive").apply { isDaemon = true }.start()
}
fun requestResync() = send(SpectatorMessage.Resync)
fun stop() {
if (stopped) return
stopped = true
try {
writer.execute {
writeLine(SpectatorMessage.Leave)
closeSocket()
}
} catch (e: RejectedExecutionException) {
closeSocket()
}
writer.shutdown()
// A send stuck on a dead connection must not keep the socket open.
Thread({
try { Thread.sleep(STOP_GRACE_MS) } catch (_: InterruptedException) {}
closeSocket()
}, "spectator-stop").apply { isDaemon = true }.start()
}
private fun run() {
val s = Socket()
socket = s
val reader: BufferedReader
try {
if (stopped) throw IOException("Stopped")
s.tcpNoDelay = true
s.connect(InetSocketAddress(host, port), timing.connectTimeoutMs)
s.soTimeout = timing.silenceTimeoutMs
output = BufferedWriter(OutputStreamWriter(s.getOutputStream(), Charsets.UTF_8))
reader = BufferedReader(InputStreamReader(s.getInputStream(), Charsets.UTF_8))
} catch (e: IOException) {
closeSocket()
emit(Event.JoinFailed(Failure.UNREACHABLE))
return
}
send(SpectatorMessage.Hello(minVersion))
var joined = false
var hostClosed = false
try {
while (!stopped) {
val read = readBoundedLine(reader, SpectatorProtocol.MAX_HOST_LINE_CHARS)
if (read !is LineResult.Line) break
val envelope = SpectatorProtocol.decode(read.text) ?: continue
val message = envelope.message
if (!joined) {
// reject keeps its shape across versions, so read it before the version gate.
if (message is SpectatorMessage.Reject) {
emit(Event.JoinFailed(failureOf(message)))
return
}
if (envelope.version < minVersion) {
emit(Event.JoinFailed(Failure.UPDATE_HOST_APP))
return
}
if (message is SpectatorMessage.Welcome) {
joined = true
emit(Event.Joined(message))
}
continue
}
when (message) {
null -> Unit
SpectatorMessage.Closing -> hostClosed = true
is SpectatorMessage.Ping -> {
send(SpectatorMessage.Pong)
emit(Event.Received(message))
}
else -> emit(Event.Received(message))
}
}
} catch (e: IOException) {
// Silence timeout or connection reset.
} finally {
closeSocket()
}
if (joined) emit(Event.Disconnected(hostClosed)) else emit(Event.JoinFailed(Failure.UNREACHABLE))
}
private fun failureOf(reject: SpectatorMessage.Reject): Failure = when (reject.reason) {
RejectReason.FULL -> Failure.FULL
RejectReason.NO_GAME -> Failure.NO_GAME
RejectReason.UPDATE_REQUIRED ->
if (version < reject.minVersion) Failure.UPDATE_THIS_APP else Failure.UPDATE_HOST_APP
RejectReason.OTHER -> Failure.UNREACHABLE
}
private fun emit(event: Event) {
if (!stopped) onEvent(event)
}
private fun send(message: SpectatorMessage) {
try {
writer.execute { writeLine(message) }
} catch (e: RejectedExecutionException) {
// Stopped.
}
}
private fun writeLine(message: SpectatorMessage) {
val out = output ?: return
try {
out.write(SpectatorProtocol.encode(message, version))
out.write("\n")
out.flush()
} catch (e: IOException) {
closeSocket()
}
}
private fun closeSocket() {
try { socket?.close() } catch (_: IOException) {}
}
private companion object {
const val STOP_GRACE_MS = 500L
}
}
/** One-shot status query, used to show live spectator counts in the Friends list. */
object SpectatorProbe {
fun query(host: String, port: Int, timeoutMs: Int = 2_000): SpectatorMessage.Status? = try {
Socket().use { s ->
s.connect(InetSocketAddress(host, port), timeoutMs)
s.soTimeout = timeoutMs
val out = s.getOutputStream()
out.write((SpectatorProtocol.encode(SpectatorMessage.StatusQuery) + "\n").toByteArray(Charsets.UTF_8))
out.flush()
val reader = BufferedReader(InputStreamReader(s.getInputStream(), Charsets.UTF_8))
val read = readBoundedLine(reader, SpectatorProtocol.MAX_HOST_LINE_CHARS)
(read as? LineResult.Line)?.let { SpectatorProtocol.decode(it.text)?.message as? SpectatorMessage.Status }
}
} catch (e: IOException) {
null
}
}
@@ -0,0 +1,162 @@
package cc.skysparkle.matewave.spectate
import cc.skysparkle.matewave.engine.Board
import cc.skysparkle.matewave.engine.ChessEngine
import cc.skysparkle.matewave.engine.GameStatus
import cc.skysparkle.matewave.engine.Move
import cc.skysparkle.matewave.engine.Notation
import cc.skysparkle.matewave.engine.PieceColor
import cc.skysparkle.matewave.engine.opposite
/** What a spectator sees of a game. */
data class SpectatorView(
val gameId: String,
val white: SpectatorPlayer,
val black: SpectatorPlayer,
val startBoard: Board,
val board: Board,
val movesUci: List<String>,
val moveSans: List<String>,
val lastMove: Move?,
val initialSeconds: Int,
val incrementSeconds: Int,
val clock: SpectatorClock?,
val result: SpectatorResult?
) {
val ply: Int get() = movesUci.size
}
/**
* The spectator's copy of the game, rebuilt from a snapshot and moved forward by live moves. Moves
* are checked against the rules; anything that does not follow on asks for a fresh snapshot.
*/
class SpectatorGame {
enum class Applied { APPLIED, IGNORED, NEEDS_RESYNC }
var view: SpectatorView? = null
private set
fun load(snapshot: SpectatorSnapshot): Boolean {
val start = Board.startPosition()
var board = start
val sans = ArrayList<String>(snapshot.movesUci.size)
var last: Move? = null
for (uci in snapshot.movesUci) {
val move = resolve(board, uci) ?: return false
sans.add(Notation.toSan(board, move))
board = ChessEngine.applyMove(board, move)
last = move
}
view = SpectatorView(
gameId = snapshot.gameId,
white = snapshot.white,
black = snapshot.black,
startBoard = start,
board = board,
movesUci = snapshot.movesUci,
moveSans = sans,
lastMove = last,
initialSeconds = snapshot.initialSeconds,
incrementSeconds = snapshot.incrementSeconds,
clock = snapshot.clock,
result = snapshot.result
)
return true
}
fun onMove(message: SpectatorMessage.MovePlayed): Applied {
val current = view ?: return Applied.NEEDS_RESYNC
if (message.gameId != current.gameId) return Applied.NEEDS_RESYNC
if (current.result != null || message.ply <= current.ply) return Applied.IGNORED
if (message.ply != current.ply + 1) return Applied.NEEDS_RESYNC
val move = resolve(current.board, message.uci) ?: return Applied.NEEDS_RESYNC
view = current.copy(
board = ChessEngine.applyMove(current.board, move),
movesUci = current.movesUci + move.toUci(),
moveSans = current.moveSans + Notation.toSan(current.board, move),
lastMove = move,
clock = message.clock ?: current.clock
)
return Applied.APPLIED
}
fun onGameOver(message: SpectatorMessage.GameOver): Applied {
val current = view ?: return Applied.NEEDS_RESYNC
if (message.gameId != current.gameId) return Applied.NEEDS_RESYNC
view = current.copy(
result = message.result,
clock = (message.clock ?: current.clock)?.copy(running = null)
)
return Applied.APPLIED
}
fun onClock(clock: SpectatorClock?) {
val current = view ?: return
if (clock == null || current.result != null) return
view = current.copy(clock = clock)
}
private fun resolve(board: Board, uci: String): Move? {
if (uci.length !in 4..5) return null
val candidate = runCatching { Move.fromUci(uci) }.getOrNull() ?: return null
if (candidate.from !in 0..63 || candidate.to !in 0..63) return null
val matches = ChessEngine.legalMoves(board).filter { it.from == candidate.from && it.to == candidate.to }
return matches.firstOrNull { it.promotion == candidate.promotion } ?: matches.firstOrNull()
}
}
/** Turns successive host snapshots into the messages spectators need to follow along. */
object SpectatorDiff {
fun between(old: SpectatorSnapshot?, new: SpectatorSnapshot): List<SpectatorMessage> {
if (old == null) return emptyList()
if (old.gameId != new.gameId || old.white != new.white || old.black != new.black) {
return listOf(SpectatorMessage.NewGame(new))
}
val events = ArrayList<SpectatorMessage>()
val before = old.movesUci
val after = new.movesUci
if (after != before) {
if (after.size <= before.size || after.subList(0, before.size) != before) {
return listOf(SpectatorMessage.NewGame(new))
}
for (i in before.size until after.size) {
val isLast = i == after.lastIndex
events += SpectatorMessage.MovePlayed(new.gameId, i + 1, after[i], if (isLast) new.clock else null)
}
}
when {
old.result == null && new.result != null -> events += SpectatorMessage.GameOver(new.gameId, new.result, new.clock)
old.result != null && new.result != old.result -> return listOf(SpectatorMessage.NewGame(new))
}
return events
}
}
/** Result of a finished game as spectators are told it. */
object SpectatorResults {
fun of(
status: GameStatus,
sideToMove: PieceColor,
timedOutSide: PieceColor?,
resignedSide: PieceColor?,
leftMidGame: Boolean
): SpectatorResult? = when (status) {
GameStatus.ONGOING -> null
GameStatus.CHECKMATE -> SpectatorResult(SpectatorOutcome.CHECKMATE, sideToMove.opposite())
GameStatus.STALEMATE -> SpectatorResult(SpectatorOutcome.STALEMATE, null)
GameStatus.DRAW_50_MOVES -> SpectatorResult(SpectatorOutcome.FIFTY_MOVES, null)
GameStatus.DRAW_REPETITION -> SpectatorResult(SpectatorOutcome.REPETITION, null)
GameStatus.DRAW_MATERIAL -> SpectatorResult(SpectatorOutcome.INSUFFICIENT_MATERIAL, null)
GameStatus.TIMEOUT -> SpectatorResult(SpectatorOutcome.TIMEOUT, timedOutSide?.opposite())
GameStatus.TIMEOUT_DRAW -> SpectatorResult(SpectatorOutcome.TIMEOUT_DRAW, null)
GameStatus.RESIGNATION -> SpectatorResult(
if (leftMidGame) SpectatorOutcome.LEFT else SpectatorOutcome.RESIGNATION,
resignedSide?.opposite()
)
GameStatus.DRAW_AGREEMENT -> SpectatorResult(SpectatorOutcome.AGREEMENT, null)
}
fun leftBy(side: PieceColor) = SpectatorResult(SpectatorOutcome.LEFT, side.opposite())
val interrupted = SpectatorResult(SpectatorOutcome.INTERRUPTED, null)
}
@@ -0,0 +1,364 @@
package cc.skysparkle.matewave.spectate
import cc.skysparkle.matewave.network.LineResult
import cc.skysparkle.matewave.network.readBoundedLine
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.Closeable
import java.io.IOException
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.ServerSocket
import java.net.Socket
import java.net.SocketTimeoutException
import java.util.concurrent.ArrayBlockingQueue
import java.util.concurrent.Executors
import java.util.concurrent.RejectedExecutionException
import java.util.concurrent.ThreadFactory
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger
/**
* Runs on the host player's device and streams the game to up to [maxSpectators] spectators on
* its own listening socket; the players' connection is never touched. Each spectator gets its own
* bounded queue and writer thread, so a slow or vanished spectator is dropped without delaying
* the game or anyone else. Spectators can only listen: anything they send besides keepalives and
* resync requests is ignored.
*/
class SpectatorHub(
private val maxSpectators: Int = MAX_SPECTATORS,
private val timing: Timing = Timing(),
private val log: (String) -> Unit = {}
) {
data class Timing(
val helloTimeoutMs: Int = 5_000,
val pingIntervalMs: Long = 5_000,
/** A spectator that answers no ping for this long is gone (e.g. its Wi-Fi went off). */
val silenceTimeoutMs: Int = 20_000,
val queueCapacity: Int = 512
)
private val lock = Any()
private val spectators = LinkedHashSet<Spectator>()
private var latest: SpectatorSnapshot? = null
private var latestAtNanos = 0L
private var closed = false
private var server: ServerSocket? = null
private val handshaking = AtomicInteger()
private val threads = Executors.newCachedThreadPool(daemonThreads("spectator"))
private val ticker = Executors.newSingleThreadScheduledExecutor(daemonThreads("spectator-ping"))
private val _count = MutableStateFlow(0)
val count: StateFlow<Int> = _count
val port: Int get() = server?.localPort ?: 0
/** Opens the spectator socket on [bindAddress] (all interfaces by default) and returns its port. */
fun start(bindAddress: InetAddress? = null): Int {
val socket = synchronized(lock) {
check(!closed) { "Hub is closed" }
server?.let { return it.localPort }
ServerSocket().also {
it.reuseAddress = true
it.bind(InetSocketAddress(bindAddress, 0))
server = it
}
}
threads.execute { acceptLoop(socket) }
ticker.scheduleAtFixedRate(
{ runCatching { sendPings() } },
timing.pingIntervalMs, timing.pingIntervalMs, TimeUnit.MILLISECONDS
)
return socket.localPort
}
/** Replaces the current game state and sends [events] to every spectator, atomically. */
fun publish(snapshot: SpectatorSnapshot, events: List<SpectatorMessage> = emptyList()) {
synchronized(lock) {
if (closed) return
latest = snapshot
latestAtNanos = System.nanoTime()
if (events.isEmpty() || spectators.isEmpty()) return
val targets = spectators.toList()
events.forEach { deliver(targets, SpectatorProtocol.encode(it)) }
}
}
/** Sends [finalEvents] and a goodbye to everyone, then stops accepting and closes. */
fun close(finalEvents: List<SpectatorMessage> = emptyList()) {
val targets = synchronized(lock) {
if (closed) return
closed = true
spectators.toList().also { spectators.clear() }
}
_count.value = 0
val lines = finalEvents.map { SpectatorProtocol.encode(it) } + SpectatorProtocol.encode(SpectatorMessage.Closing)
targets.forEach { spectator ->
lines.forEach { spectator.offer(it) }
spectator.finish()
}
closeQuietly(server)
ticker.shutdownNow()
threads.shutdown()
}
private fun acceptLoop(socket: ServerSocket) {
while (!socket.isClosed) {
val client = try {
socket.accept()
} catch (e: IOException) {
if (socket.isClosed) return
log("Spectator accept failed: ${e.message}")
continue
}
if (handshaking.incrementAndGet() > MAX_HANDSHAKING) {
handshaking.decrementAndGet()
closeQuietly(client)
continue
}
try {
threads.execute { serve(client) }
} catch (e: RejectedExecutionException) {
handshaking.decrementAndGet()
closeQuietly(client)
}
}
}
private fun serve(client: Socket) {
var spectator: Spectator? = null
var reader: BufferedReader? = null
try {
client.tcpNoDelay = true
client.soTimeout = timing.helloTimeoutMs
reader = BufferedReader(InputStreamReader(client.getInputStream(), Charsets.UTF_8))
val first = readBoundedLine(reader, SpectatorProtocol.MAX_CLIENT_LINE_CHARS)
val envelope = (first as? LineResult.Line)?.let { SpectatorProtocol.decode(it.text) }
when (envelope?.message) {
SpectatorMessage.StatusQuery -> reply(client, status())
is SpectatorMessage.Hello -> {
if (envelope.version < SpectatorProtocol.MIN_COMPATIBLE_VERSION) {
log("Spectator with protocol ${envelope.version} told to update")
reply(client, SpectatorMessage.Reject(RejectReason.UPDATE_REQUIRED, SpectatorProtocol.MIN_COMPATIBLE_VERSION))
} else {
spectator = admit(client)
}
}
else -> Unit
}
} catch (e: IOException) {
// Timed out or closed before saying hello.
} finally {
handshaking.decrementAndGet()
if (spectator == null) closeQuietly(client)
}
val admitted = spectator ?: return
listen(admitted, reader ?: return)
}
private fun admit(client: Socket): Spectator? {
var reject: RejectReason? = null
var spectator: Spectator? = null
synchronized(lock) {
val game = latest
when {
closed || game == null -> reject = RejectReason.NO_GAME
spectators.size >= maxSpectators -> reject = RejectReason.FULL
else -> {
val joined = Spectator(client, timing.queueCapacity)
val others = spectators.toList()
spectators.add(joined)
val n = spectators.size
_count.value = n
joined.offer(SpectatorProtocol.encode(SpectatorMessage.Welcome(n, maxSpectators, liveSnapshot(game))))
deliver(others, SpectatorProtocol.encode(SpectatorMessage.Count(n, maxSpectators)))
spectator = joined
}
}
}
reject?.let {
reply(client, SpectatorMessage.Reject(it, SpectatorProtocol.MIN_COMPATIBLE_VERSION))
return null
}
val joined = spectator ?: return null
try {
threads.execute { write(joined) }
} catch (e: RejectedExecutionException) {
drop(joined)
return null
}
return joined
}
private fun listen(spectator: Spectator, reader: BufferedReader) {
try {
spectator.socket.soTimeout = timing.silenceTimeoutMs
while (true) {
val read = readBoundedLine(reader, SpectatorProtocol.MAX_CLIENT_LINE_CHARS)
if (read !is LineResult.Line) break
when (SpectatorProtocol.decode(read.text)?.message) {
SpectatorMessage.Resync -> synchronized(lock) {
val game = latest
if (game != null && !closed) {
deliver(listOf(spectator), SpectatorProtocol.encode(SpectatorMessage.NewGame(liveSnapshot(game))))
}
}
SpectatorMessage.Leave -> break
else -> Unit
}
}
} catch (e: SocketTimeoutException) {
log("Spectator silent for ${timing.silenceTimeoutMs / 1000} s, dropped")
} catch (e: IOException) {
// Connection reset.
} finally {
drop(spectator)
}
}
private fun write(spectator: Spectator) {
try {
val out = BufferedWriter(OutputStreamWriter(spectator.socket.getOutputStream(), Charsets.UTF_8))
while (true) {
val item = spectator.queue.take()
if (item === POISON) break
out.write(item as String)
out.write("\n")
if (spectator.queue.isEmpty()) out.flush()
}
out.flush()
} catch (e: IOException) {
// Spectator went away.
} catch (e: InterruptedException) {
Thread.currentThread().interrupt()
} finally {
drop(spectator)
closeQuietly(spectator.socket)
}
}
private fun sendPings() {
val line: String
val targets: List<Spectator>
synchronized(lock) {
if (closed || spectators.isEmpty()) return
line = SpectatorProtocol.encode(SpectatorMessage.Ping(liveClock()))
targets = spectators.toList()
}
deliver(targets, line)
}
private fun deliver(targets: List<Spectator>, line: String) {
for (spectator in targets) {
if (!spectator.offer(line)) {
log("Spectator too slow, dropped")
drop(spectator)
}
}
}
private fun drop(spectator: Spectator) {
val others: List<Spectator>
val remaining: Int
synchronized(lock) {
// Already dropped, or the hub is closing and its writer is flushing the goodbye.
if (!spectators.remove(spectator)) return
remaining = spectators.size
_count.value = remaining
others = spectators.toList()
}
spectator.shutdown()
if (!closed) deliver(others, SpectatorProtocol.encode(SpectatorMessage.Count(remaining, maxSpectators)))
}
private fun status(): SpectatorMessage.Status = synchronized(lock) {
val game = latest
SpectatorMessage.Status(
inGame = !closed && game != null && game.result == null,
count = spectators.size,
max = maxSpectators,
minVersion = SpectatorProtocol.MIN_COMPATIBLE_VERSION
)
}
private fun elapsedMs(): Long = (System.nanoTime() - latestAtNanos) / 1_000_000L
private fun liveClock(): SpectatorClock? = latest?.clock?.advancedBy(elapsedMs())
private fun liveSnapshot(game: SpectatorSnapshot): SpectatorSnapshot =
if (game.clock == null) game else game.copy(clock = game.clock.advancedBy(elapsedMs()))
private fun reply(client: Socket, message: SpectatorMessage) {
try {
val out = client.getOutputStream()
out.write((SpectatorProtocol.encode(message) + "\n").toByteArray(Charsets.UTF_8))
out.flush()
} catch (e: IOException) {
// Nothing more to tell a peer that is gone.
}
}
/** One spectator's outgoing queue; one slot is kept free for the end marker. */
private class Spectator(val socket: Socket, private val capacity: Int) {
val queue = ArrayBlockingQueue<Any>(capacity + 1)
private var open = true
@Synchronized
fun offer(line: String): Boolean = open && queue.size < capacity && queue.offer(line)
/** Lets the writer send what is queued, then close. */
@Synchronized
fun finish() {
if (!open) return
open = false
queue.offer(POISON)
}
/** Stops at once, discarding anything unsent. */
@Synchronized
fun shutdown() {
open = false
queue.clear()
queue.offer(POISON)
closeQuietly(socket)
}
}
private companion object {
val POISON = Any()
/** Connections allowed to sit in the hello phase at once. */
const val MAX_HANDSHAKING = 32
fun closeQuietly(c: Closeable?) {
try { c?.close() } catch (_: IOException) {}
}
fun daemonThreads(name: String): ThreadFactory {
val n = AtomicInteger()
return ThreadFactory { r -> Thread(r, "$name-${n.incrementAndGet()}").apply { isDaemon = true } }
}
}
}
/** Feeds a hub from the host's game: each new snapshot becomes the messages spectators need. */
class SpectatorBroadcaster(val hub: SpectatorHub) {
private var last: SpectatorSnapshot? = null
fun update(snapshot: SpectatorSnapshot) {
val events = SpectatorDiff.between(last, snapshot)
last = snapshot
hub.publish(snapshot, events)
}
/** Stops spectating; [final] is the last state, e.g. the result of a game left midway. */
fun close(final: SpectatorSnapshot? = null) {
val events = if (final != null) SpectatorDiff.between(last, final) else emptyList()
hub.close(events)
}
}
@@ -0,0 +1,250 @@
package cc.skysparkle.matewave.spectate
import cc.skysparkle.matewave.engine.PieceColor
import org.json.JSONArray
import org.json.JSONObject
/** Most spectators one hosted game accepts at the same time. */
const val MAX_SPECTATORS = 20
data class SpectatorPlayer(val id: String, val name: String, val elo: Int)
data class SpectatorClock(val whiteMs: Long, val blackMs: Long, val running: PieceColor?) {
/** The same clock [elapsedMs] later. */
fun advancedBy(elapsedMs: Long): SpectatorClock {
if (elapsedMs <= 0) return this
return when (running) {
PieceColor.WHITE -> copy(whiteMs = (whiteMs - elapsedMs).coerceAtLeast(0))
PieceColor.BLACK -> copy(blackMs = (blackMs - elapsedMs).coerceAtLeast(0))
null -> this
}
}
}
enum class SpectatorOutcome(val wire: String) {
CHECKMATE("checkmate"),
STALEMATE("stalemate"),
FIFTY_MOVES("fifty"),
REPETITION("repetition"),
INSUFFICIENT_MATERIAL("material"),
TIMEOUT("timeout"),
TIMEOUT_DRAW("timeout_draw"),
RESIGNATION("resign"),
AGREEMENT("agreement"),
LEFT("left"),
INTERRUPTED("interrupted"),
UNKNOWN("unknown");
companion object {
fun fromWire(value: String): SpectatorOutcome = entries.firstOrNull { it.wire == value } ?: UNKNOWN
}
}
/** How a game ended; [winner] is null for draws and interrupted games. */
data class SpectatorResult(val outcome: SpectatorOutcome, val winner: PieceColor?)
/** Everything a spectator needs to show a game from any point: players, moves, clocks, result. */
data class SpectatorSnapshot(
val gameId: String,
val white: SpectatorPlayer,
val black: SpectatorPlayer,
val movesUci: List<String>,
val initialSeconds: Int,
val incrementSeconds: Int,
val clock: SpectatorClock?,
val result: SpectatorResult? = null
)
enum class RejectReason(val wire: String) {
FULL("full"),
UPDATE_REQUIRED("update"),
NO_GAME("no_game"),
OTHER("other");
companion object {
fun fromWire(value: String): RejectReason = entries.firstOrNull { it.wire == value } ?: OTHER
}
}
sealed class SpectatorMessage {
// Spectator to host.
data class Hello(val minVersion: Int = SpectatorProtocol.MIN_COMPATIBLE_VERSION) : SpectatorMessage()
data object StatusQuery : SpectatorMessage()
data object Pong : SpectatorMessage()
data object Resync : SpectatorMessage()
data object Leave : SpectatorMessage()
// Host to spectator.
data class Welcome(val count: Int, val max: Int, val game: SpectatorSnapshot) : SpectatorMessage()
data class Status(val inGame: Boolean, val count: Int, val max: Int, val minVersion: Int) : SpectatorMessage()
data class Reject(val reason: RejectReason, val minVersion: Int) : SpectatorMessage()
data class MovePlayed(val gameId: String, val ply: Int, val uci: String, val clock: SpectatorClock?) : SpectatorMessage()
data class GameOver(val gameId: String, val result: SpectatorResult, val clock: SpectatorClock?) : SpectatorMessage()
data class NewGame(val game: SpectatorSnapshot) : SpectatorMessage()
data class Count(val count: Int, val max: Int) : SpectatorMessage()
data class Ping(val clock: SpectatorClock?) : SpectatorMessage()
data object Closing : SpectatorMessage()
}
/** One decoded line: the sender's protocol version and the message, or null for an unknown type. */
data class SpectatorEnvelope(val version: Int, val message: SpectatorMessage?)
/**
* Wire format between a hosted game and its spectators: one JSON object per line, each carrying
* the sender's protocol version in "sv". Unknown types are skipped, never fatal.
*/
object SpectatorProtocol {
/**
* Bump on incompatible changes and raise [MIN_COMPATIBLE_VERSION] to the oldest version still
* understood. hello, status and reject keep their shape so any two versions can still tell
* each other that an update is required.
*/
const val VERSION = 1
const val MIN_COMPATIBLE_VERSION = 1
const val MAX_HOST_LINE_CHARS = 64_000
const val MAX_CLIENT_LINE_CHARS = 1_024
private const val MAX_NAME_CHARS = 40
private const val MAX_PLIES = 2_000
fun encode(message: SpectatorMessage, version: Int = VERSION): String {
val o = JSONObject()
o.put("sv", version)
when (message) {
is SpectatorMessage.Hello -> { o.put("type", "hello"); o.put("min", message.minVersion) }
SpectatorMessage.StatusQuery -> o.put("type", "query")
SpectatorMessage.Pong -> o.put("type", "pong")
SpectatorMessage.Resync -> o.put("type", "resync")
SpectatorMessage.Leave -> o.put("type", "leave")
is SpectatorMessage.Welcome -> {
o.put("type", "welcome"); o.put("n", message.count); o.put("max", message.max)
o.put("game", snapshotJson(message.game))
}
is SpectatorMessage.Status -> {
o.put("type", "status"); o.put("live", message.inGame)
o.put("n", message.count); o.put("max", message.max); o.put("min", message.minVersion)
}
is SpectatorMessage.Reject -> {
o.put("type", "reject"); o.put("reason", message.reason.wire); o.put("min", message.minVersion)
}
is SpectatorMessage.MovePlayed -> {
o.put("type", "move"); o.put("gid", message.gameId); o.put("ply", message.ply); o.put("uci", message.uci)
message.clock?.let { o.put("clock", clockJson(it)) }
}
is SpectatorMessage.GameOver -> {
o.put("type", "end"); o.put("gid", message.gameId); o.put("result", resultJson(message.result))
message.clock?.let { o.put("clock", clockJson(it)) }
}
is SpectatorMessage.NewGame -> { o.put("type", "game"); o.put("game", snapshotJson(message.game)) }
is SpectatorMessage.Count -> { o.put("type", "count"); o.put("n", message.count); o.put("max", message.max) }
is SpectatorMessage.Ping -> {
o.put("type", "ping")
message.clock?.let { o.put("clock", clockJson(it)) }
}
SpectatorMessage.Closing -> o.put("type", "closing")
}
return o.toString()
}
/** Null when the line is not a protocol message at all. */
fun decode(line: String): SpectatorEnvelope? {
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
val type = o.optString("type", "")
if (type.isEmpty()) return null
val version = o.optInt("sv", 0)
val message = runCatching { decodeMessage(type, o) }.getOrNull()
return SpectatorEnvelope(version, message)
}
private fun decodeMessage(type: String, o: JSONObject): SpectatorMessage? = when (type) {
"hello" -> SpectatorMessage.Hello(o.optInt("min", o.optInt("sv", 0)))
"query" -> SpectatorMessage.StatusQuery
"pong" -> SpectatorMessage.Pong
"resync" -> SpectatorMessage.Resync
"leave" -> SpectatorMessage.Leave
"welcome" -> SpectatorMessage.Welcome(o.getInt("n"), o.getInt("max"), parseSnapshot(o.getJSONObject("game")))
"status" -> SpectatorMessage.Status(o.getBoolean("live"), o.getInt("n"), o.getInt("max"), o.optInt("min", 0))
"reject" -> SpectatorMessage.Reject(RejectReason.fromWire(o.getString("reason")), o.optInt("min", 0))
"move" -> SpectatorMessage.MovePlayed(
o.getString("gid"), o.getInt("ply"), o.getString("uci"), o.optJSONObject("clock")?.let(::parseClock)
)
"end" -> SpectatorMessage.GameOver(
o.getString("gid"), parseResult(o.getJSONObject("result")), o.optJSONObject("clock")?.let(::parseClock)
)
"game" -> SpectatorMessage.NewGame(parseSnapshot(o.getJSONObject("game")))
"count" -> SpectatorMessage.Count(o.getInt("n"), o.getInt("max"))
"ping" -> SpectatorMessage.Ping(o.optJSONObject("clock")?.let(::parseClock))
"closing" -> SpectatorMessage.Closing
else -> null
}
private fun sideWire(side: PieceColor?): String = when (side) {
PieceColor.WHITE -> "w"
PieceColor.BLACK -> "b"
null -> ""
}
private fun sideOf(wire: String): PieceColor? = when (wire) {
"w" -> PieceColor.WHITE
"b" -> PieceColor.BLACK
else -> null
}
private fun clockJson(c: SpectatorClock) = JSONObject().apply {
put("w", c.whiteMs); put("b", c.blackMs)
if (c.running != null) put("r", sideWire(c.running))
}
private fun parseClock(o: JSONObject) = SpectatorClock(
whiteMs = o.getLong("w").coerceAtLeast(0),
blackMs = o.getLong("b").coerceAtLeast(0),
running = sideOf(o.optString("r", ""))
)
private fun resultJson(r: SpectatorResult) = JSONObject().apply {
put("o", r.outcome.wire)
if (r.winner != null) put("w", sideWire(r.winner))
}
private fun parseResult(o: JSONObject) = SpectatorResult(
outcome = SpectatorOutcome.fromWire(o.getString("o")),
winner = sideOf(o.optString("w", ""))
)
private fun playerJson(p: SpectatorPlayer) = JSONObject().apply {
put("id", p.id); put("name", p.name); put("elo", p.elo)
}
private fun parsePlayer(o: JSONObject) = SpectatorPlayer(
id = o.optString("id", "").take(64),
name = o.optString("name", "").take(MAX_NAME_CHARS),
elo = o.optInt("elo", 0)
)
private fun snapshotJson(s: SpectatorSnapshot) = JSONObject().apply {
put("gid", s.gameId)
put("wp", playerJson(s.white))
put("bp", playerJson(s.black))
put("moves", JSONArray().also { array -> s.movesUci.forEach { array.put(it) } })
put("ti", s.initialSeconds)
put("tx", s.incrementSeconds)
s.clock?.let { put("clock", clockJson(it)) }
s.result?.let { put("result", resultJson(it)) }
}
private fun parseSnapshot(o: JSONObject): SpectatorSnapshot {
val array = o.getJSONArray("moves")
require(array.length() <= MAX_PLIES)
return SpectatorSnapshot(
gameId = o.getString("gid"),
white = parsePlayer(o.getJSONObject("wp")),
black = parsePlayer(o.getJSONObject("bp")),
movesUci = List(array.length()) { array.getString(it) },
initialSeconds = o.optInt("ti", 0),
incrementSeconds = o.optInt("tx", 0),
clock = o.optJSONObject("clock")?.let(::parseClock),
result = o.optJSONObject("result")?.let(::parseResult)
)
}
}
@@ -0,0 +1,99 @@
package cc.skysparkle.matewave
import cc.skysparkle.matewave.spectate.FriendStatusResolver
import cc.skysparkle.matewave.spectate.MAX_SPECTATORS
import cc.skysparkle.matewave.spectate.NearbyPlayerGame
import cc.skysparkle.matewave.spectate.PresenceStatus
import cc.skysparkle.matewave.spectate.SpectateTarget
import cc.skysparkle.matewave.spectate.SpectatorAdvert
import cc.skysparkle.matewave.spectate.SpectatorMessage
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
class FriendStatusTest {
private val tag = SpectatorAdvert.tagOf("game-1")
private val host = NearbyPlayerGame("host", "192.168.1.10", tag, 40_123)
private val guest = NearbyPlayerGame("guest", "192.168.1.11", tag, 0)
private val idle = NearbyPlayerGame("idle", "192.168.1.12", "", 0)
private val nearby = listOf(host, guest, idle).associateBy { it.playerId }
private val target = SpectateTarget("192.168.1.10", 40_123, tag)
private fun status(count: Int, live: Boolean = true) = SpectatorMessage.Status(live, count, MAX_SPECTATORS, 1)
@Test
fun notVisibleIsOffline() {
assertEquals(PresenceStatus.OFFLINE, FriendStatusResolver.resolve("nobody", nearby, emptyMap()).status)
}
@Test
fun visibleWithoutAGameIsOnline() {
val s = FriendStatusResolver.resolve("idle", nearby, emptyMap())
assertEquals(PresenceStatus.ONLINE, s.status)
assertNull(s.target)
}
@Test
fun hostInGameCanBeWatchedWithTheLiveCount() {
val s = FriendStatusResolver.resolve("host", nearby, mapOf(target to status(7)))
assertEquals(PresenceStatus.IN_GAME, s.status)
assertEquals(target, s.target)
assertEquals(7, s.spectators)
assertFalse(s.full)
}
@Test
fun guestIsWatchedThroughTheHost() {
val s = FriendStatusResolver.resolve("guest", nearby, mapOf(target to status(3)))
assertEquals(PresenceStatus.IN_GAME, s.status)
assertEquals(target, s.target)
assertEquals(3, s.spectators)
}
@Test
fun fullGameIsReportedAsFull() {
assertTrue(FriendStatusResolver.resolve("host", nearby, mapOf(target to status(MAX_SPECTATORS))).full)
}
@Test
fun countIsUnknownUntilTheHostAnswers() {
val s = FriendStatusResolver.resolve("host", nearby, emptyMap())
assertEquals(PresenceStatus.IN_GAME, s.status)
assertNull(s.spectators)
assertFalse(s.full)
}
@Test
fun hostSayingTheGameEndedWinsOverAStaleAnnouncement() {
val ended = mapOf(target to status(0, live = false))
assertEquals(PresenceStatus.ONLINE, FriendStatusResolver.resolve("host", nearby, ended).status)
assertEquals(PresenceStatus.ONLINE, FriendStatusResolver.resolve("guest", nearby, ended).status)
}
@Test
fun guestWhoseHostIsHiddenIsInGameWithoutWatch() {
val s = FriendStatusResolver.resolve("guest", mapOf("guest" to guest), emptyMap())
assertEquals(PresenceStatus.IN_GAME, s.status)
assertNull(s.target)
}
@Test
fun onlyHostsAreProbed() {
assertEquals(setOf(target), FriendStatusResolver.targets(nearby.values))
}
@Test
fun advertRoundTripsAndRejectsJunk() {
val state = SpectatorAdvert.State(tag, 40_123)
val attrs = SpectatorAdvert.attributes(state)
assertEquals(state, SpectatorAdvert.parse { attrs[it] ?: "" })
assertEquals(SpectatorAdvert.State(), SpectatorAdvert.parse { "" })
assertEquals(SpectatorAdvert.State(), SpectatorAdvert.parse { if (it == "g") "not-a-tag" else "1" })
assertEquals(SpectatorAdvert.State(tag, 0), SpectatorAdvert.parse { if (it == "g") tag else "99999" })
assertEquals(emptyMap<String, String>(), SpectatorAdvert.attributes(SpectatorAdvert.State()))
assertEquals(8, tag.length)
assertEquals("", SpectatorAdvert.tagOf(""))
}
}
@@ -0,0 +1,149 @@
package cc.skysparkle.matewave
import cc.skysparkle.matewave.engine.GameStatus
import cc.skysparkle.matewave.engine.PieceColor
import cc.skysparkle.matewave.engine.PieceType
import cc.skysparkle.matewave.spectate.SpectatorClock
import cc.skysparkle.matewave.spectate.SpectatorDiff
import cc.skysparkle.matewave.spectate.SpectatorGame
import cc.skysparkle.matewave.spectate.SpectatorGame.Applied
import cc.skysparkle.matewave.spectate.SpectatorMessage
import cc.skysparkle.matewave.spectate.SpectatorOutcome
import cc.skysparkle.matewave.spectate.SpectatorPlayer
import cc.skysparkle.matewave.spectate.SpectatorResult
import cc.skysparkle.matewave.spectate.SpectatorResults
import cc.skysparkle.matewave.spectate.SpectatorSnapshot
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
class SpectatorGameTest {
private fun snapshot(moves: List<String>, gameId: String = "g1", result: SpectatorResult? = null) = SpectatorSnapshot(
gameId = gameId,
white = SpectatorPlayer("u1", "Alice", 1500),
black = SpectatorPlayer("u2", "Bob", 1400),
movesUci = moves,
initialSeconds = 180,
incrementSeconds = 2,
clock = SpectatorClock(170_000, 175_000, if (moves.size % 2 == 0) PieceColor.WHITE else PieceColor.BLACK),
result = result
)
private fun move(ply: Int, uci: String, gameId: String = "g1") = SpectatorMessage.MovePlayed(gameId, ply, uci, null)
@Test
fun loadReplaysTheMoveListWithTurnAndLastMove() {
val game = SpectatorGame()
assertTrue(game.load(snapshot(listOf("e2e4", "e7e5", "e1e2"))))
val view = game.view!!
assertEquals(listOf("e4", "e5", "Ke2"), view.moveSans)
assertEquals(PieceColor.BLACK, view.board.sideToMove)
assertEquals("e1e2", view.lastMove!!.toUci())
assertEquals(3, view.ply)
assertEquals(180, view.initialSeconds)
}
@Test
fun illegalHistoryIsRefused() {
assertFalse(SpectatorGame().load(snapshot(listOf("e2e5"))))
assertFalse(SpectatorGame().load(snapshot(listOf("zz99"))))
}
@Test
fun liveMovesFollowOnAndDuplicatesAreIgnored() {
val game = SpectatorGame()
game.load(snapshot(listOf("d2d4")))
assertEquals(Applied.APPLIED, game.onMove(move(2, "d7d5")))
assertEquals(Applied.IGNORED, game.onMove(move(2, "d7d5")))
assertEquals(Applied.IGNORED, game.onMove(move(1, "d2d4")))
assertEquals(listOf("d4", "d5"), game.view!!.moveSans)
}
@Test
fun gapsIllegalMovesAndForeignGamesAskForResync() {
val game = SpectatorGame()
game.load(snapshot(listOf("d2d4")))
assertEquals(Applied.NEEDS_RESYNC, game.onMove(move(3, "c2c4")))
assertEquals(Applied.NEEDS_RESYNC, game.onMove(move(2, "d4d5")))
assertEquals(Applied.NEEDS_RESYNC, game.onMove(move(2, "d7d5", gameId = "other")))
assertEquals(Applied.NEEDS_RESYNC, SpectatorGame().onMove(move(1, "e2e4")))
assertEquals(1, game.view!!.ply)
}
@Test
fun promotionIsKept() {
val game = SpectatorGame()
val moves = listOf("h2h4", "g7g5", "h4g5", "h7h6", "g5h6", "g8f6", "h6h7", "f6g8")
assertTrue(game.load(snapshot(moves)))
assertEquals(Applied.APPLIED, game.onMove(move(9, "h7g8n")))
assertEquals(PieceType.KNIGHT, game.view!!.lastMove!!.promotion)
assertEquals("hxg8=N", game.view!!.moveSans.last())
}
@Test
fun gameOverStopsTheClockAndLaterMovesAreIgnored() {
val game = SpectatorGame()
game.load(snapshot(listOf("f2f3", "e7e5", "g2g4", "d8h4")))
val result = SpectatorResult(SpectatorOutcome.CHECKMATE, PieceColor.BLACK)
assertEquals(Applied.APPLIED, game.onGameOver(SpectatorMessage.GameOver("g1", result, null)))
assertEquals(result, game.view!!.result)
assertNull(game.view!!.clock!!.running)
assertEquals(Applied.IGNORED, game.onMove(move(5, "a2a3")))
game.onClock(SpectatorClock(1, 1, PieceColor.WHITE))
assertNull(game.view!!.clock!!.running)
}
@Test
fun diffTurnsNewMovesIntoLiveMessagesWithTheLatestClock() {
val before = snapshot(listOf("e2e4"))
val after = snapshot(listOf("e2e4", "e7e5", "g1f3"))
val events = SpectatorDiff.between(before, after)
assertEquals(2, events.size)
val first = events[0] as SpectatorMessage.MovePlayed
val second = events[1] as SpectatorMessage.MovePlayed
assertEquals(2 to "e7e5", first.ply to first.uci)
assertNull(first.clock)
assertEquals(3 to "g1f3", second.ply to second.uci)
assertEquals(after.clock, second.clock)
}
@Test
fun diffReportsTheEndOnceAndRestartsOnANewGame() {
val playing = snapshot(listOf("e2e4"))
val over = playing.copy(result = SpectatorResult(SpectatorOutcome.RESIGNATION, PieceColor.WHITE))
assertEquals(listOf(SpectatorMessage.GameOver("g1", over.result!!, over.clock)), SpectatorDiff.between(playing, over))
assertEquals(emptyList<SpectatorMessage>(), SpectatorDiff.between(over, over))
val rematch = snapshot(emptyList(), gameId = "g2")
assertEquals(listOf(SpectatorMessage.NewGame(rematch)), SpectatorDiff.between(over, rematch))
assertEquals(emptyList<SpectatorMessage>(), SpectatorDiff.between(null, rematch))
// Clock ticks alone are carried by pings, not extra messages.
assertEquals(emptyList<SpectatorMessage>(), SpectatorDiff.between(playing, playing.copy(clock = SpectatorClock(1, 2, null))))
}
@Test
fun diffFallsBackToAFullSnapshotWhenHistoryChanges() {
val a = snapshot(listOf("e2e4", "e7e5"))
val b = snapshot(listOf("d2d4"))
assertEquals(listOf(SpectatorMessage.NewGame(b)), SpectatorDiff.between(a, b))
}
@Test
fun resultsMapEveryWayAGameCanEnd() {
fun of(status: GameStatus, timedOut: PieceColor? = null, resigned: PieceColor? = null, left: Boolean = false) =
SpectatorResults.of(status, PieceColor.WHITE, timedOut, resigned, left)
assertNull(of(GameStatus.ONGOING))
assertEquals(SpectatorResult(SpectatorOutcome.CHECKMATE, PieceColor.BLACK), of(GameStatus.CHECKMATE))
assertEquals(SpectatorResult(SpectatorOutcome.TIMEOUT, PieceColor.WHITE), of(GameStatus.TIMEOUT, timedOut = PieceColor.BLACK))
assertEquals(SpectatorResult(SpectatorOutcome.RESIGNATION, PieceColor.BLACK), of(GameStatus.RESIGNATION, resigned = PieceColor.WHITE))
assertEquals(SpectatorResult(SpectatorOutcome.LEFT, PieceColor.WHITE), of(GameStatus.RESIGNATION, resigned = PieceColor.BLACK, left = true))
assertEquals(SpectatorResult(SpectatorOutcome.STALEMATE, null), of(GameStatus.STALEMATE))
assertEquals(SpectatorResult(SpectatorOutcome.FIFTY_MOVES, null), of(GameStatus.DRAW_50_MOVES))
assertEquals(SpectatorResult(SpectatorOutcome.REPETITION, null), of(GameStatus.DRAW_REPETITION))
assertEquals(SpectatorResult(SpectatorOutcome.INSUFFICIENT_MATERIAL, null), of(GameStatus.DRAW_MATERIAL))
assertEquals(SpectatorResult(SpectatorOutcome.TIMEOUT_DRAW, null), of(GameStatus.TIMEOUT_DRAW))
assertEquals(SpectatorResult(SpectatorOutcome.AGREEMENT, null), of(GameStatus.DRAW_AGREEMENT))
assertEquals(SpectatorResult(SpectatorOutcome.LEFT, PieceColor.BLACK), SpectatorResults.leftBy(PieceColor.WHITE))
}
}
@@ -0,0 +1,460 @@
package cc.skysparkle.matewave
import cc.skysparkle.matewave.engine.PieceColor
import cc.skysparkle.matewave.spectate.MAX_SPECTATORS
import cc.skysparkle.matewave.spectate.RejectReason
import cc.skysparkle.matewave.spectate.SpectatorBroadcaster
import cc.skysparkle.matewave.spectate.SpectatorClient
import cc.skysparkle.matewave.spectate.SpectatorClient.Event
import cc.skysparkle.matewave.spectate.SpectatorClient.Failure
import cc.skysparkle.matewave.spectate.SpectatorClock
import cc.skysparkle.matewave.spectate.SpectatorGame
import cc.skysparkle.matewave.spectate.SpectatorHub
import cc.skysparkle.matewave.spectate.SpectatorMessage
import cc.skysparkle.matewave.spectate.SpectatorOutcome
import cc.skysparkle.matewave.spectate.SpectatorPlayer
import cc.skysparkle.matewave.spectate.SpectatorProbe
import cc.skysparkle.matewave.spectate.SpectatorProtocol
import cc.skysparkle.matewave.spectate.SpectatorResults
import cc.skysparkle.matewave.spectate.SpectatorSnapshot
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertTrue
import org.junit.Assert.fail
import org.junit.Test
import java.io.BufferedReader
import java.io.Closeable
import java.io.IOException
import java.io.InputStreamReader
import java.net.InetAddress
import java.net.ServerSocket
import java.net.Socket
import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.CountDownLatch
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit
class SpectatorHubTest {
private val loopback: InetAddress = InetAddress.getLoopbackAddress()
private val hubTiming = SpectatorHub.Timing(helloTimeoutMs = 1_000, pingIntervalMs = 150, silenceTimeoutMs = 900)
private val clientTiming = SpectatorClient.Timing(connectTimeoutMs = 2_000, silenceTimeoutMs = 900)
private val hubs = CopyOnWriteArrayList<SpectatorHub>()
private val clients = CopyOnWriteArrayList<SpectatorClient>()
private val closeables = CopyOnWriteArrayList<Closeable>()
@After
fun tearDown() {
clients.forEach { it.stop() }
hubs.forEach { it.close() }
closeables.forEach { runCatching { it.close() } }
}
private fun snapshot(
moves: List<String> = emptyList(),
clock: SpectatorClock? = SpectatorClock(300_000, 300_000, PieceColor.WHITE),
gameId: String = "g1"
) = SpectatorSnapshot(
gameId = gameId,
white = SpectatorPlayer("u1", "Alice", 1500),
black = SpectatorPlayer("u2", "Bob", 1400),
movesUci = moves,
initialSeconds = 300,
incrementSeconds = 0,
clock = clock
)
private fun hub(initial: SpectatorSnapshot? = snapshot()): SpectatorHub {
val hub = SpectatorHub(timing = hubTiming)
hubs += hub
hub.start(loopback)
if (initial != null) hub.publish(initial)
return hub
}
private class Recorder {
val events = LinkedBlockingQueue<Event>()
fun next(timeoutMs: Long = 3_000): Event =
events.poll(timeoutMs, TimeUnit.MILLISECONDS) ?: throw AssertionError("No event within $timeoutMs ms")
/** Skips pings and counts until an event matching [predicate]. */
fun awaitEvent(timeoutMs: Long = 3_000, predicate: (Event) -> Boolean): Event {
val deadline = System.currentTimeMillis() + timeoutMs
while (true) {
val left = deadline - System.currentTimeMillis()
if (left <= 0) throw AssertionError("Expected event did not arrive")
val event = events.poll(left, TimeUnit.MILLISECONDS) ?: continue
if (predicate(event)) return event
}
}
fun awaitMessage(timeoutMs: Long = 3_000, predicate: (SpectatorMessage) -> Boolean): SpectatorMessage =
(awaitEvent(timeoutMs) { it is Event.Received && predicate(it.message) } as Event.Received).message
}
private fun watch(
port: Int,
recorder: Recorder = Recorder(),
version: Int = SpectatorProtocol.VERSION,
minVersion: Int = SpectatorProtocol.MIN_COMPATIBLE_VERSION
): Pair<SpectatorClient, Recorder> {
val client = SpectatorClient("127.0.0.1", port, { recorder.events.add(it) }, clientTiming, version, minVersion)
clients += client
client.start()
return client to recorder
}
private fun awaitCount(hub: SpectatorHub, expected: Int, timeoutMs: Long = 3_000) {
val deadline = System.currentTimeMillis() + timeoutMs
while (hub.count.value != expected) {
if (System.currentTimeMillis() > deadline) fail("Spectator count ${hub.count.value}, expected $expected")
Thread.sleep(10)
}
}
private fun joined(recorder: Recorder): SpectatorMessage.Welcome {
val event = recorder.next()
assertTrue("Expected to join, got $event", event is Event.Joined)
return (event as Event.Joined).welcome
}
@Test
fun twentySpectatorsJoinAndTheTwentyFirstIsRefused() {
val hub = hub()
val watchers = List(MAX_SPECTATORS) { watch(hub.port).second }
watchers.forEach { joined(it) }
awaitCount(hub, MAX_SPECTATORS)
val (_, late) = watch(hub.port)
assertEquals(Event.JoinFailed(Failure.FULL), late.next())
assertEquals(MAX_SPECTATORS, hub.count.value)
// Everyone already watching still gets the game.
hub.publish(snapshot(listOf("e2e4")), listOf(SpectatorMessage.MovePlayed("g1", 1, "e2e4", null)))
watchers.forEach { recorder ->
val move = recorder.awaitMessage { it is SpectatorMessage.MovePlayed } as SpectatorMessage.MovePlayed
assertEquals("e2e4", move.uci)
}
}
@Test
fun simultaneousJoinsNeverExceedTheLimit() {
val hub = hub()
val start = CountDownLatch(1)
val recorders = List(MAX_SPECTATORS + 10) { Recorder() }
val threads = recorders.map { r -> Thread { start.await(); watch(hub.port, r) }.apply { start() } }
start.countDown()
threads.forEach { it.join() }
val outcomes = recorders.map { it.next(5_000) }
assertEquals(MAX_SPECTATORS, outcomes.count { it is Event.Joined })
assertEquals(10, outcomes.count { it == Event.JoinFailed(Failure.FULL) })
assertEquals(MAX_SPECTATORS, hub.count.value)
}
@Test
fun joiningMidGameGetsFullStateThenFollowsLive() {
val hub = hub()
val broadcaster = SpectatorBroadcaster(hub)
val opening = listOf("e2e4", "e7e5", "g1f3")
broadcaster.update(snapshot())
broadcaster.update(snapshot(opening, SpectatorClock(290_000, 295_000, PieceColor.BLACK)))
val (_, recorder) = watch(hub.port)
val welcome = joined(recorder)
assertEquals(1, welcome.count)
assertEquals(opening, welcome.game.movesUci)
assertEquals("Alice", welcome.game.white.name)
assertEquals(300, welcome.game.initialSeconds)
val clock = welcome.game.clock!!
assertEquals(PieceColor.BLACK, clock.running)
assertEquals(290_000, clock.whiteMs)
assertTrue(clock.blackMs in 290_000..295_000)
val game = SpectatorGame()
assertTrue(game.load(welcome.game))
assertEquals(PieceColor.BLACK, game.view!!.board.sideToMove)
assertEquals(listOf("e4", "e5", "Nf3"), game.view!!.moveSans)
broadcaster.update(snapshot(opening + "b8c6", SpectatorClock(290_000, 293_000, PieceColor.WHITE)))
val move = recorder.awaitMessage { it is SpectatorMessage.MovePlayed } as SpectatorMessage.MovePlayed
assertEquals(4, move.ply)
assertEquals(SpectatorGame.Applied.APPLIED, game.onMove(move))
assertEquals(PieceColor.WHITE, game.view!!.board.sideToMove)
assertEquals("Nc6", game.view!!.moveSans.last())
}
@Test
fun hostLeavingMidGameShowsTheResultThenSaysGoodbye() {
val hub = hub()
val broadcaster = SpectatorBroadcaster(hub)
val playing = snapshot(listOf("e2e4"))
broadcaster.update(playing)
val (_, recorder) = watch(hub.port)
joined(recorder)
broadcaster.close(playing.copy(result = SpectatorResults.leftBy(PieceColor.WHITE)))
val end = recorder.awaitMessage { it is SpectatorMessage.GameOver } as SpectatorMessage.GameOver
assertEquals(SpectatorOutcome.LEFT, end.result.outcome)
assertEquals(PieceColor.BLACK, end.result.winner)
assertEquals(Event.Disconnected(hostClosed = true), recorder.awaitEvent { it is Event.Disconnected })
}
@Test
fun hostDroppingOffIsSeenAsConnectionLost() {
val hub = hub()
val link = FlakyLink(hub.port)
val (_, recorder) = watch(link.port)
joined(recorder)
link.cut()
assertEquals(Event.Disconnected(hostClosed = false), recorder.awaitEvent { it is Event.Disconnected })
}
@Test
fun wifiSwitchingOffIsDetectedOnBothSides() {
val hub = hub()
val link = FlakyLink(hub.port)
val (_, cutOff) = watch(link.port)
val (_, direct) = watch(hub.port)
joined(cutOff)
joined(direct)
awaitCount(hub, 2)
// No more packets either way, but no connection reset: what a dead Wi-Fi link looks like.
link.silent = true
assertEquals(Event.Disconnected(hostClosed = false), cutOff.awaitEvent { it is Event.Disconnected })
awaitCount(hub, 1)
// The remaining spectator's counter follows.
assertNotNull(direct.awaitMessage { it is SpectatorMessage.Count && it.count == 1 })
// The spectator who still has a connection keeps watching.
hub.publish(snapshot(listOf("d2d4")), listOf(SpectatorMessage.MovePlayed("g1", 1, "d2d4", null)))
assertNotNull(direct.awaitMessage { it is SpectatorMessage.MovePlayed })
}
@Test
fun spectatorsLeavingFreeTheirSlotsWhileOthersKeepWatching() {
val hub = hub()
val watchers = List(MAX_SPECTATORS) { watch(hub.port) }
watchers.forEach { joined(it.second) }
awaitCount(hub, MAX_SPECTATORS)
watchers.take(5).forEach { it.first.stop() }
awaitCount(hub, MAX_SPECTATORS - 5)
val (_, newcomer) = watch(hub.port)
assertEquals(MAX_SPECTATORS - 4, joined(newcomer).count)
hub.publish(snapshot(listOf("c2c4")), listOf(SpectatorMessage.MovePlayed("g1", 1, "c2c4", null)))
(watchers.drop(5).map { it.second } + newcomer).forEach {
assertNotNull(it.awaitMessage { m -> m is SpectatorMessage.MovePlayed })
}
}
@Test
fun stalledSpectatorsNeverSlowDownTheHost() {
val hub = hub()
val link = FlakyLink(hub.port)
repeat(5) { joined(watch(link.port).second) }
link.silent = true
val started = System.nanoTime()
repeat(2_000) { i ->
hub.publish(snapshot(), listOf(SpectatorMessage.Count(i, MAX_SPECTATORS)))
}
val elapsedMs = (System.nanoTime() - started) / 1_000_000
assertTrue("publish took $elapsedMs ms", elapsedMs < 1_000)
}
@Test
fun outdatedSpectatorIsToldToUpdate() {
val hub = hub()
val (_, recorder) = watch(hub.port, version = 0, minVersion = 0)
assertEquals(Event.JoinFailed(Failure.UPDATE_THIS_APP), recorder.next())
assertEquals(0, hub.count.value)
}
@Test
fun outdatedHostIsReported() {
val hub = hub()
val newer = SpectatorProtocol.VERSION + 1
val (_, recorder) = watch(hub.port, version = newer, minVersion = newer)
assertEquals(Event.JoinFailed(Failure.UPDATE_HOST_APP), recorder.next())
}
@Test
fun rawOldClientGetsAClearRejectInsteadOfACrash() {
val hub = hub()
Socket(loopback, hub.port).use { s ->
s.soTimeout = 2_000
s.getOutputStream().write("{\"type\":\"hello\",\"sv\":0}\n".toByteArray())
val reply = BufferedReader(InputStreamReader(s.getInputStream())).readLine()
val reject = SpectatorProtocol.decode(reply)!!.message as SpectatorMessage.Reject
assertEquals(RejectReason.UPDATE_REQUIRED, reject.reason)
assertEquals(SpectatorProtocol.MIN_COMPATIBLE_VERSION, reject.minVersion)
}
}
@Test
fun garbageAndOversizedInputCloseOnlyThatConnection() {
val hub = hub()
val (_, watcher) = watch(hub.port)
joined(watcher)
for (payload in listOf("hello?\n", "x".repeat(SpectatorProtocol.MAX_CLIENT_LINE_CHARS + 10) + "\n")) {
Socket(loopback, hub.port).use { s ->
s.soTimeout = 2_000
s.getOutputStream().write(payload.toByteArray())
// Closed with unread input the host may answer with a reset instead of a clean close.
val read = try { s.getInputStream().read() } catch (e: IOException) { -1 }
assertEquals(-1, read)
}
}
assertEquals(1, hub.count.value)
hub.publish(snapshot(listOf("e2e4")), listOf(SpectatorMessage.MovePlayed("g1", 1, "e2e4", null)))
assertNotNull(watcher.awaitMessage { it is SpectatorMessage.MovePlayed })
}
@Test
fun silentConnectionThatNeverSaysHelloIsClosed() {
val hub = hub()
Socket(loopback, hub.port).use { s ->
s.soTimeout = 3_000
assertEquals(-1, s.getInputStream().read())
}
assertEquals(0, hub.count.value)
}
@Test
fun noGameYetIsRefused() {
val hub = hub(initial = null)
val (_, recorder) = watch(hub.port)
assertEquals(Event.JoinFailed(Failure.NO_GAME), recorder.next())
}
@Test
fun statusProbeReportsLiveCountWithoutTakingASlot() {
val hub = hub()
repeat(3) { joined(watch(hub.port).second) }
awaitCount(hub, 3)
val status = SpectatorProbe.query("127.0.0.1", hub.port)!!
assertTrue(status.inGame)
assertEquals(3, status.count)
assertEquals(MAX_SPECTATORS, status.max)
assertEquals(3, hub.count.value)
hub.publish(snapshot().copy(result = SpectatorResults.interrupted))
assertFalse(SpectatorProbe.query("127.0.0.1", hub.port)!!.inGame)
}
@Test
fun probeOfAClosedHostIsNull() {
val hub = hub()
val port = hub.port
hub.close()
assertEquals(null, SpectatorProbe.query("127.0.0.1", port, timeoutMs = 500))
}
@Test
fun resyncSendsAFreshSnapshot() {
val hub = hub(snapshot(listOf("e2e4", "c7c5")))
val (client, recorder) = watch(hub.port)
joined(recorder)
client.requestResync()
val fresh = recorder.awaitMessage { it is SpectatorMessage.NewGame } as SpectatorMessage.NewGame
assertEquals(listOf("e2e4", "c7c5"), fresh.game.movesUci)
}
@Test
fun rematchReachesSpectatorsAsANewGame() {
val hub = hub()
val broadcaster = SpectatorBroadcaster(hub)
val first = snapshot(listOf("f2f3", "e7e5", "g2g4", "d8h4"))
broadcaster.update(first)
val (_, recorder) = watch(hub.port)
joined(recorder)
broadcaster.update(first.copy(result = SpectatorResults.of(
cc.skysparkle.matewave.engine.GameStatus.CHECKMATE, PieceColor.WHITE, null, null, false
)))
val end = recorder.awaitMessage { it is SpectatorMessage.GameOver } as SpectatorMessage.GameOver
assertEquals(PieceColor.BLACK, end.result.winner)
broadcaster.update(snapshot(gameId = "g2"))
val next = recorder.awaitMessage { it is SpectatorMessage.NewGame } as SpectatorMessage.NewGame
assertEquals("g2", next.game.gameId)
}
@Test
fun clocksKeepRunningBetweenHostUpdates() {
val hub = hub(snapshot(clock = SpectatorClock(60_000, 60_000, PieceColor.WHITE)))
Thread.sleep(400)
val (_, recorder) = watch(hub.port)
val clock = joined(recorder).game.clock!!
assertTrue("white ${clock.whiteMs}", clock.whiteMs in 50_000..59_700)
assertEquals(60_000, clock.blackMs)
val ping = recorder.awaitMessage { it is SpectatorMessage.Ping } as SpectatorMessage.Ping
assertTrue(ping.clock!!.whiteMs <= clock.whiteMs)
}
@Test
fun closingTheHubEndsEveryoneAndRefusesNewcomers() {
val hub = hub()
val recorders = List(3) { watch(hub.port).second }
recorders.forEach { joined(it) }
val port = hub.port
hub.close()
recorders.forEach { assertEquals(Event.Disconnected(hostClosed = true), it.awaitEvent { e -> e is Event.Disconnected }) }
assertEquals(0, hub.count.value)
val (_, late) = watch(port)
assertEquals(Event.JoinFailed(Failure.UNREACHABLE), late.next())
}
/** A TCP relay that can go silent (dead Wi-Fi) or drop every connection (host gone). */
private inner class FlakyLink(target: Int) : Closeable {
private val server = ServerSocket(0, 50, loopback)
private val sockets = CopyOnWriteArrayList<Socket>()
@Volatile var silent = false
val port: Int get() = server.localPort
init {
closeables += this
Thread {
while (!server.isClosed) {
val inbound = try { server.accept() } catch (e: IOException) { break }
val outbound = Socket(loopback, target)
sockets += inbound
sockets += outbound
pump(inbound, outbound)
pump(outbound, inbound)
}
}.apply { isDaemon = true }.start()
}
private fun pump(from: Socket, to: Socket) = Thread {
val buffer = ByteArray(8_192)
try {
while (true) {
val n = from.getInputStream().read(buffer)
if (n < 0) break
if (!silent) to.getOutputStream().write(buffer, 0, n)
}
} catch (_: IOException) {
} finally {
runCatching { from.close() }
runCatching { to.close() }
}
}.apply { isDaemon = true }.start()
fun cut() = sockets.forEach { runCatching { it.close() } }
override fun close() {
runCatching { server.close() }
cut()
}
}
}
@@ -0,0 +1,114 @@
package cc.skysparkle.matewave
import cc.skysparkle.matewave.engine.PieceColor
import cc.skysparkle.matewave.spectate.MAX_SPECTATORS
import cc.skysparkle.matewave.spectate.RejectReason
import cc.skysparkle.matewave.spectate.SpectatorClock
import cc.skysparkle.matewave.spectate.SpectatorMessage
import cc.skysparkle.matewave.spectate.SpectatorOutcome
import cc.skysparkle.matewave.spectate.SpectatorPlayer
import cc.skysparkle.matewave.spectate.SpectatorProtocol
import cc.skysparkle.matewave.spectate.SpectatorResult
import cc.skysparkle.matewave.spectate.SpectatorSnapshot
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
class SpectatorProtocolTest {
private val clock = SpectatorClock(295_000, 300_000, PieceColor.BLACK)
private val snapshot = SpectatorSnapshot(
gameId = "g1",
white = SpectatorPlayer("u1", "Владимир", 1350),
black = SpectatorPlayer("u2", "Bob", 1200),
movesUci = listOf("e2e4", "e7e5", "g1f3"),
initialSeconds = 300,
incrementSeconds = 2,
clock = clock
)
private fun roundTrip(message: SpectatorMessage) {
val envelope = SpectatorProtocol.decode(SpectatorProtocol.encode(message))
assertNotNull(envelope)
assertEquals(SpectatorProtocol.VERSION, envelope!!.version)
assertEquals(message, envelope.message)
}
@Test fun hello() = roundTrip(SpectatorMessage.Hello(1))
@Test fun query() = roundTrip(SpectatorMessage.StatusQuery)
@Test fun pong() = roundTrip(SpectatorMessage.Pong)
@Test fun resync() = roundTrip(SpectatorMessage.Resync)
@Test fun leave() = roundTrip(SpectatorMessage.Leave)
@Test fun welcome() = roundTrip(SpectatorMessage.Welcome(7, MAX_SPECTATORS, snapshot))
@Test fun status() = roundTrip(SpectatorMessage.Status(true, 7, MAX_SPECTATORS, 1))
@Test fun reject() = roundTrip(SpectatorMessage.Reject(RejectReason.FULL, 1))
@Test fun move() = roundTrip(SpectatorMessage.MovePlayed("g1", 4, "b8c6", clock))
@Test fun moveWithoutClock() = roundTrip(SpectatorMessage.MovePlayed("g1", 4, "e7e8q", null))
@Test fun count() = roundTrip(SpectatorMessage.Count(3, MAX_SPECTATORS))
@Test fun ping() = roundTrip(SpectatorMessage.Ping(clock))
@Test fun closing() = roundTrip(SpectatorMessage.Closing)
@Test fun newGame() = roundTrip(SpectatorMessage.NewGame(snapshot.copy(movesUci = emptyList(), clock = null)))
@Test
fun gameOverKeepsWinnerAndDraws() {
roundTrip(SpectatorMessage.GameOver("g1", SpectatorResult(SpectatorOutcome.CHECKMATE, PieceColor.WHITE), clock.copy(running = null)))
roundTrip(SpectatorMessage.GameOver("g1", SpectatorResult(SpectatorOutcome.AGREEMENT, null), null))
roundTrip(SpectatorMessage.GameOver("g1", SpectatorResult(SpectatorOutcome.INTERRUPTED, null), null))
}
@Test
fun everyMessageCarriesTheSenderVersion() {
val line = SpectatorProtocol.encode(SpectatorMessage.Pong, version = 7)
assertEquals(7, SpectatorProtocol.decode(line)!!.version)
}
@Test
fun unknownTypeFromANewerVersionIsSkippedNotFatal() {
val envelope = SpectatorProtocol.decode("""{"type":"emote","sv":9,"what":"wave"}""")
assertNotNull(envelope)
assertEquals(9, envelope!!.version)
assertNull(envelope.message)
}
@Test
fun unknownOutcomeAndRejectReasonDegradeGracefully() {
val end = SpectatorProtocol.decode("""{"type":"end","sv":2,"gid":"g1","result":{"o":"abandoned"}}""")!!.message
assertEquals(SpectatorOutcome.UNKNOWN, (end as SpectatorMessage.GameOver).result.outcome)
val reject = SpectatorProtocol.decode("""{"type":"reject","sv":2,"reason":"banned","min":2}""")!!.message
assertEquals(RejectReason.OTHER, (reject as SpectatorMessage.Reject).reason)
}
@Test
fun malformedInputNeverThrows() {
assertNull(SpectatorProtocol.decode("not json"))
assertNull(SpectatorProtocol.decode("{}"))
assertNull(SpectatorProtocol.decode(""))
// Known type with missing fields: skipped like an unknown one.
assertNull(SpectatorProtocol.decode("""{"type":"move","sv":1}""")!!.message)
assertNull(SpectatorProtocol.decode("""{"type":"welcome","sv":1,"n":1}""")!!.message)
}
@Test
fun oldHelloWithoutMinimumStillParses() {
val hello = SpectatorProtocol.decode("""{"type":"hello","sv":1}""")!!.message
assertEquals(SpectatorMessage.Hello(1), hello)
}
@Test
fun clockAdvancesOnlyForTheRunningSide() {
val later = clock.advancedBy(1_500)
assertEquals(295_000, later.whiteMs)
assertEquals(298_500, later.blackMs)
assertEquals(0, SpectatorClock(1_000, 5_000, PieceColor.WHITE).advancedBy(9_000).whiteMs)
assertEquals(clock.copy(running = null), clock.copy(running = null).advancedBy(5_000))
}
@Test
fun hugeMoveListIsRejected() {
val moves = (1..2_001).joinToString(",") { "\"e2e4\"" }
val line = """{"type":"game","sv":1,"game":{"gid":"g","wp":{},"bp":{},"moves":[$moves]}}"""
assertNull(SpectatorProtocol.decode(line)!!.message)
assertTrue(SpectatorProtocol.MAX_CLIENT_LINE_CHARS < SpectatorProtocol.MAX_HOST_LINE_CHARS)
}
}