Implement kill counter

Author: DRSchlaubi

client/build.gradle.kts

@@ -8,9 +8,13 @@ plugins {
 version = "1.0.0"
 
 dependencies {
+    implementation(projects.common)
+    implementation(libs.kotlinx.serialization.json)
     implementation(libs.jnativehook)
     implementation(libs.ktor.client.cio)
     implementation(libs.ktor.client.websockets)
+    implementation(libs.ktor.client.resources)
+    implementation(libs.ktor.serialization.kotlinx.json)
     implementation(libs.kotlin.logging)
     implementation(libs.slf4j.simple)
 }

client/src/main/kotlin/Main.kt

@@ -3,11 +3,17 @@ package dev.schlaubi.mastermind
 import com.github.kwhat.jnativehook.GlobalScreen
 import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent
 import com.github.kwhat.jnativehook.keyboard.NativeKeyListener
+import dev.schlaubi.gtakiller.common.Event
+import dev.schlaubi.gtakiller.common.KillGtaEvent
+import dev.schlaubi.gtakiller.common.Route
 import io.github.oshai.kotlinlogging.KotlinLogging
 import io.ktor.client.*
+import io.ktor.client.plugins.resources.*
 import io.ktor.client.plugins.websocket.*
-import io.ktor.websocket.*
+import io.ktor.http.*
+import io.ktor.serialization.kotlinx.*
 import kotlinx.coroutines.*
+import kotlinx.serialization.json.Json
 import java.util.concurrent.Executors
 import kotlin.jvm.optionals.getOrNull
 import kotlin.time.Duration.Companion.seconds
@@ -22,19 +28,27 @@ private val LoomDispatcher = Executors
 private val client = HttpClient {
     install(WebSockets) {
         pingInterval = 2.seconds
+        contentConverter = KotlinxWebsocketSerializationConverter(Json)
     }
+    install(Resources)
 }
 
 private fun CoroutineScope.connect() {
     launch {
-        session = client.webSocketSession("wss://ks.haxis.me")
+        session = client.webSocketSession {
+            url {
+                takeFrom("ws://localhost:8080")
+                client.href(Route.Events(), this)
+            }
+
+            headers.append("X-Username", System.getProperty("user.name"))
+        }
 
         LOG.info { "Connection established" }
-        for (frame in session.incoming) {
+        while (isActive) {
+            val frame = session.receiveDeserialized<Event>()
             LOG.trace { "Got frame: $frame" }
-            val incoming = (frame as? Frame.Text)?.readText() ?: continue
-            LOG.debug { "Got frame text: $incoming" }
-            if (incoming == "KILL_GTA") {
+            if (frame is KillGtaEvent) {
                 kill()
             }
         }
@@ -74,7 +88,7 @@ private fun kill() {
     }
 }
 
-private suspend fun report() = session.outgoing.send(Frame.Text("KILL_GTA"))
+private suspend fun report() = session.sendSerialized<Event>(KillGtaEvent)
 
 private suspend fun reportAndKill() {
     kill()

common/build.gradle.kts

@@ -0,0 +1,10 @@
+plugins {
+    id("buildsrc.convention.kotlin-jvm")
+    alias(libs.plugins.kotlin.serialization)
+}
+
+dependencies {
+    api(libs.kotlinx.serialization.json)
+    api(libs.kotlinx.datetime)
+    api(libs.ktor.resources)
+}

common/src/main/kotlin/Events.kt

@@ -0,0 +1,15 @@
+package dev.schlaubi.gtakiller.common
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+sealed interface Event
+
+@SerialName("kill")
+@Serializable
+data object KillGtaEvent : Event
+
+@SerialName("update_kill_counter")
+@Serializable
+data class UpdateKillCounterEvent(val killCount: Int, val kill: Kill) : Event

common/src/main/kotlin/Routes.kt

@@ -0,0 +1,11 @@
+package dev.schlaubi.gtakiller.common
+
+import io.ktor.resources.*
+
+class Route {
+    @Resource("events")
+    class Events
+
+    @Resource("status")
+    class Status
+}

common/src/main/kotlin/Status.kt

@@ -0,0 +1,26 @@
+package dev.schlaubi.gtakiller.common
+
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Status(
+    val kills: List<Kill>,
+    val count: Int
+) {
+    val scoreboard: List<ScoreboardEntry>
+        get() = kills
+            .groupBy { it.user }
+            .map { ScoreboardEntry(it.key, it.value.size) }
+            .sortedByDescending { it.kills }
+
+}
+
+@Serializable
+data class ScoreboardEntry(val user: String, val kills: Int)
+
+@Serializable
+data class Kill(
+    val timestamp: Instant,
+    val user: String
+)

gradle/libs.versions.toml

@@ -1,16 +1,31 @@
 [versions]
 kotlin = "2.1.10"
 ktor = "3.1.0"
+kotlinx-serialization = "1.8.0"
 
 [libraries]
 kotlinGradlePlugin = { group = "org.jetbrains.kotlin", name = "kotlin-gradle-plugin", version.ref = "kotlin" }
 jnativehook = { group = "com.github.kwhat", name = "jnativehook", version = "2.2.2" }
 
+kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-json-io = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json-io", version.ref = "kotlinx-serialization" }
+kotlinx-datetime = { group = "org.jetbrains.kotlinx", name = "kotlinx-datetime", version = "0.6.2" }
+kotlinx-io-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-io-core", version = "0.6.0" }
+
+ktor-resources = { group = "io.ktor", name = "ktor-resources", version.ref = "ktor" }
 ktor-client-cio = { group = "io.ktor", name = "ktor-client-cio", version.ref = "ktor" }
+ktor-client-resources = { group = "io.ktor", name = "ktor-client-resources", version.ref = "ktor" }
 ktor-client-websockets = { group = "io.ktor", name = "ktor-client-websockets", version.ref = "ktor" }
 ktor-server-netty = { group = "io.ktor", name = "ktor-server-netty", version.ref = "ktor" }
 ktor-server-websockets = { group = "io.ktor", name = "ktor-server-websockets", version.ref = "ktor" }
 ktor-server-forwarded-header = { group = "io.ktor", name = "ktor-server-forwarded-header", version.ref = "ktor" }
+ktor-server-resources = { group = "io.ktor", name = "ktor-server-resources", version.ref = "ktor" }
+ktor-server-content-negotiation = { group = "io.ktor", name = "ktor-server-content-negotiation", version.ref = "ktor" }
+
+ktor-serialization-kotlinx-json = { group = "io.ktor", name = "ktor-serialization-kotlinx-json", version.ref = "ktor" }
 
 kotlin-logging = { group = "io.github.oshai", name = "kotlin-logging", version = "7.0.4" }
 slf4j-simple = { group = "org.slf4j", name = "slf4j-simple", version = "2.0.16" }
+
+[plugins]
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

server/build.gradle.kts

@@ -4,9 +4,15 @@ plugins {
 }
 
 dependencies {
+    implementation(projects.common)
+    implementation(libs.kotlinx.serialization.json.io)
+    implementation(libs.kotlinx.io.core)
     implementation(libs.ktor.server.netty)
     implementation(libs.ktor.server.websockets)
     implementation(libs.ktor.server.forwarded.header)
+    implementation(libs.ktor.server.resources)
+    implementation(libs.ktor.serialization.kotlinx.json)
+    implementation(libs.ktor.server.content.negotiation)
     implementation(libs.kotlin.logging)
     implementation(libs.slf4j.simple)
 }

server/src/main/kotlin/Server.kt

@@ -1,46 +1,87 @@
 package dev.schlaubi.gtakiller
 
+import dev.schlaubi.gtakiller.common.Kill
+import dev.schlaubi.gtakiller.common.KillGtaEvent
+import dev.schlaubi.gtakiller.common.Route
+import dev.schlaubi.gtakiller.common.UpdateKillCounterEvent
 import io.github.oshai.kotlinlogging.KotlinLogging
+import io.ktor.serialization.kotlinx.*
+import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.application.*
 import io.ktor.server.engine.*
 import io.ktor.server.netty.*
 import io.ktor.server.plugins.*
+import io.ktor.server.plugins.contentnegotiation.*
 import io.ktor.server.plugins.forwardedheaders.*
+import io.ktor.server.resources.*
+import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import io.ktor.server.websocket.*
-import io.ktor.websocket.*
+import kotlinx.coroutines.isActive
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.serialization.json.Json
+import kotlin.time.Duration.Companion.seconds
 
 private val LOG = KotlinLogging.logger { }
 
+private var lastKill: Instant? = null
+
 fun main() {
     val sessions = mutableListOf<DefaultWebSocketServerSession>()
 
     embeddedServer(Netty, port = 8080, host = "0.0.0.0") {
-        install(WebSockets)
+        install(WebSockets) {
+            contentConverter = KotlinxWebsocketSerializationConverter(Json)
+        }
+        install(Resources)
+        install(ContentNegotiation) {
+            json()
+        }
         install(XForwardedHeaders)
 
         routing {
-            webSocket {
-                sessions += this
+            resource<Route.Events> {
+                webSocket {
+                    sessions += this
 
-                LOG.info { "Got session from: ${call.request.origin.remoteHost}" }
+                    val name = call.request.headers["X-Username"] ?: "Anonymous"
 
-                for (frame in incoming) {
-                    LOG.debug { "GOT FRAME: $frame" }
+                    LOG.info { "Got session from: ${call.request.origin.remoteHost}" }
 
-                    if (frame is Frame.Text) {
-                        val text = frame.readText()
-                        LOG.debug { "Got frame text: $text" }
+                    while (isActive) {
+                        val event = receiveEvent()
+                        LOG.debug { "GOT FRAME: $event" }
 
                         sessions.forEach {
-                            it.send(text)
+                            it.send(event)
+                        }
+
+                        if (event is KillGtaEvent) {
+                            val kill = Kill(Clock.System.now(), name)
+                            val timeSinceLastKill = Clock.System.now() - (lastKill ?: Instant.DISTANT_PAST)
+                            if (timeSinceLastKill >= 10.seconds) {
+                                writeStats(
+                                    stats.copy(
+                                        stats.kills + kill,
+                                        count = stats.count + 1
+                                    )
+                                )
+                            }
+                            sessions.forEach {
+                                it.send(UpdateKillCounterEvent(stats.count, kill))
+                            }
                         }
                     }
-                }
 
-                sessions -= this
+                    sessions -= this
+
+                    LOG.info { "Lost session: ${call.request.origin.remoteHost}" }
+                }
+            }
 
-                LOG.info { "Lost session: ${call.request.origin.remoteHost}" }
+            get<Route.Status> {
+                call.respond(stats)
             }
         }
     }.start(wait = true)

server/src/main/kotlin/Storage.kt

@@ -0,0 +1,47 @@
+@file:OptIn(ExperimentalSerializationApi::class)
+
+package dev.schlaubi.gtakiller
+
+import dev.schlaubi.gtakiller.common.Status
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.io.buffered
+import kotlinx.io.files.Path
+import kotlinx.io.files.SystemFileSystem
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.io.decodeFromSource
+import kotlinx.serialization.json.io.encodeToSink
+
+private val mutex = Mutex()
+
+var stats = readStats()
+    private set
+
+private val file get() = Path("store/stats.json")
+
+private val fs get() = SystemFileSystem
+
+private fun readStats(): Status {
+    if (!fs.exists(file)) {
+        return Status(emptyList(), 0)
+    }
+
+    return fs.source(file).buffered().use {
+        Json.decodeFromSource(it)
+    }
+}
+
+suspend fun writeStats(status: Status) {
+    stats = status
+
+    if (!fs.exists(file.parent!!)) {
+        fs.createDirectories(file.parent!!)
+    }
+
+    mutex.withLock {
+        fs.sink(file).buffered().use {
+            Json.encodeToSink(status, it)
+        }
+    }
+}