init

client/src/commonMain/kotlin/start.kt

@@ -28,7 +28,7 @@ suspend fun start() {
 
     }))
 
-    Korge(icon = "images/logo.png", scaleMode = ScaleMode.COVER, backgroundColor = ColorPalette.background) {
+    Korge(title = "Skeep", icon = "images/logo.png", scaleMode = ScaleMode.COVER, backgroundColor = ColorPalette.background) {
         sceneContainer = sceneContainer()
         sceneContainer.changeTo({ MainScene() })
     }

client/src/commonMain/kotlin/ui/waitingRoom.kt

@@ -1,30 +1,26 @@
 package ui
 
+import io.ktor.websocket.serialization.*
+import korlibs.event.Key
 import korlibs.image.color.Colors
 import korlibs.image.text.HorizontalAlign
 import korlibs.image.text.TextAlignment
 import korlibs.io.lang.Cancellable
 import korlibs.korge.annotations.KorgeExperimental
-import korlibs.korge.input.onClick
-import korlibs.korge.input.onMouseDragCloseable
-import korlibs.korge.input.onUp
-import korlibs.korge.input.onUpAnywhere
+import korlibs.korge.input.*
 import korlibs.korge.style.styles
 import korlibs.korge.style.textAlignment
-import korlibs.korge.ui.uiButton
-import korlibs.korge.ui.uiContainer
-import korlibs.korge.ui.uiMaterialLayer
-import korlibs.korge.ui.uiText
+import korlibs.korge.ui.*
 import korlibs.korge.view.*
 import korlibs.korge.view.align.*
 import korlibs.math.geom.Size
 import korlibs.math.geom.bezier.Bezier
 import kotlinx.uuid.UUID
-import network.ViewedRoom
-import network.getRoomName
+import network.*
 import scene.styler
 import sceneContainer
 import ui.custom.customUiButton
+import ui.custom.customUiScrollable
 import ui.custom.customUiText
 import ui.custom.customUiTextInput
 import util.ColorPalette
@@ -56,6 +52,15 @@ suspend fun waitingRoom(room: UUID) {
             }
             positionX(padding)
             positionY(sceneContainer.height - padding - size.height)
+        }
+        lateinit var chats: View
+        customUiScrollable(size = inputBarSize) {
+            it.backgroundColor = Colors.TRANSPARENT
+            uiVerticalStack {
+                chats = this
+                uiSpacing(Size(1f, padding))
+                styles(styler)
+            }
         }
             uiContainer {
                 val input = customUiTextInput(size = inputBarSize.minus(Size(padding/2, 0f))) {
@@ -64,6 +69,12 @@ suspend fun waitingRoom(room: UUID) {
                     controller.textView.alignment = TextAlignment.MIDDLE_LEFT
                     controller.caretContainer.alignY(this, 0.75, false)
                     positionX(padding/2)
+                    keys {
+                        down(Key.ENTER) {
+                            send(ClientPacket.CHAT, text)
+                            text = " "
+                        }
+                    }
                 }.zIndex(2)
                 uiMaterialLayer(input.size) {
                     shadowColor = Colors.TRANSPARENT

server/src/main/kotlin/application/configuration/authentication.kt

@@ -24,7 +24,7 @@ fun Application.configureAuthentication() {
                 println(transaction { Session.all().map { it.id } })
                 //throw exception when not found
                 val uuid = UUID(session.password)
-                transaction { Session.find(model.Sessions.id eq uuid) }
+                transaction { Session.find(model.Sessions.id eq uuid).first() }
                 UserSession(uuid)
             }
         }

server/src/main/kotlin/application/websocket.kt

@@ -13,10 +13,13 @@ import kotlinx.serialization.json.Json
 import kotlinx.uuid.UUID
 import model.Room
 import model.Rooms
+import model.Session
+import model.Sessions
 import network.PacketController
 import network.PacketFrame
-import network.ServerPacket
-import network.ServerPacket.GET_ROOM_NUMBER
+import network.ClientPacket
+import network.ClientPacket.CHAT
+import network.ClientPacket.GET_ROOM_NUMBER
 import network.packet
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.transaction
@@ -38,36 +41,37 @@ fun Application.configureWebsocket() {
     }
     routing {
         webSocket {
-            for (frame in incoming) {
-                frame.readBytes()
+            while (true) {
                 val packet = receiveDeserialized<PacketFrame>()
-                val serverPacketCT = serverPacket(ServerPacket.values()[packet.type])
-                serverPacketCT.invoke(serverPacketCT.decode(packet.data)!!)
+                val clientPacketCT = serverPacket(ClientPacket.values()[packet.type])
+                transaction { Session.find(Sessions.id eq packet.session).first() }
+                clientPacketCT.invoke(clientPacketCT.decode(packet.data)!!)
             }
         }
     }
 }
 
 @OptIn(InternalSerializationApi::class, ExperimentalStdlibApi::class, ExperimentalSerializationApi::class)
 private fun PacketController<*>.decode(data: String): Any? {
-    val type = clazz.createType(clazz.allSupertypes.map { KTypeProjection(null, it) })
-    val typeInfo = typeInfoImpl(type.javaType, clazz, type)
     val serializer = serialFormat.serializersModule.serializerForTypeInfo(typeInfo)
     @Suppress("UNCHECKED_CAST")
     return serialFormat.decodeFromString(serializer as KSerializer<Any?>, data)
 }
 
 @Suppress("UNCHECKED_CAST")
-fun serverPacket(serverPacket: ServerPacket): PacketController<Any> = when(serverPacket) {
+fun serverPacket(clientPacket: ClientPacket): PacketController<Any> = when(clientPacket) {
     GET_ROOM_NUMBER -> packet<UUID> {
         transaction { Room.find(Rooms.id eq it).first().name }
     }
-    ServerPacket.LEAVE_ROOM -> packet {
+    ClientPacket.LEAVE_ROOM -> packet {
 
     }
+    CHAT -> packet<String> {
+        println(it)
+    }
 } as PacketController<Any>
 
 inline fun <reified T : Any> transactionPacket(crossinline code: (T) -> Any) = object : PacketController<T> {
     override fun invoke(t: T) = transaction { code(t) }
-    override val clazz: KClass<T> = T::class
+    override val typeInfo: TypeInfo = typeInfo<T>()
 }

shared/src/commonMain/kotlin/network/Client.kt

@@ -8,9 +8,16 @@ import io.ktor.client.request.*
 import io.ktor.http.*
 import io.ktor.serialization.kotlinx.*
 import io.ktor.serialization.kotlinx.json.*
+import io.ktor.util.*
+import io.ktor.util.reflect.*
+import io.ktor.utils.io.charsets.*
 import io.ktor.websocket.*
+import io.ktor.websocket.serialization.*
+import korlibs.io.lang.UTF8
 import kotlinx.coroutines.InternalCoroutinesApi
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.Json.Default.encodeToString
 import org.koin.mp.KoinPlatform
 
 val currentUrl get() = KoinPlatform.getKoin().get<URLProvider>().url
@@ -22,6 +29,14 @@ lateinit var websocket: WebSocketSession
 interface URLProvider { val url: String }
 interface ClientEngineFactory { fun getEngine(): HttpClientEngineFactory<HttpClientEngineConfig> }
 
+val converter = KotlinxWebsocketSerializationConverter(Json)
+
+@OptIn(InternalAPI::class)
+suspend inline fun <reified T> send(clientPacket: ClientPacket, t: T) {
+    val packetFrame = PacketFrame(clientPacket.ordinal, sessionUUID, Json.encodeToString<T>(t))
+    websocket.sendSerializedBase(packetFrame, typeInfo<PacketFrame>(), converter, Charsets.UTF_8)
+}
+
 suspend inline fun <reified T> sendHttp(path: String, body: T, auth: Boolean = true) =
     client().post("$currentUrl/$path") {
         if (auth) basicAuth(username, sessionId)
@@ -49,7 +64,7 @@ suspend fun client(): HttpClient = run {
 private suspend fun initializeClient() = run {
     clientInst = HttpClient(clientEngine) {
         install(io.ktor.client.plugins.websocket.WebSockets) {
-            contentConverter = KotlinxWebsocketSerializationConverter(Json)
+            contentConverter = converter
         }
         install(ContentNegotiation) {
             json()

shared/src/commonMain/kotlin/network/Login.kt

@@ -6,9 +6,11 @@ import kotlinx.uuid.generateUUID
 
 val username: String = generateUsername()
 lateinit var sessionId: String
+lateinit var sessionUUID: UUID
 
 private fun generateUsername() = UUID.generateUUID().toString().substring(0, 4)
 
 suspend fun login() {
-    sessionId = sendHttp("login", LoginRequest(username), auth = false).body<UUID>().toString()
+    sessionUUID = sendHttp("login", LoginRequest(username), auth = false).body<UUID>()
+    sessionId = sessionUUID.toString()
 }

shared/src/commonMain/kotlin/network/packet.kt

@@ -1,17 +1,18 @@
 package network
 
+import io.ktor.util.reflect.*
 import kotlinx.serialization.Serializable
 import kotlinx.uuid.UUID
 import kotlin.reflect.KClass
 
 interface PacketController<T : Any> {
-    val clazz: KClass<T>
+    val typeInfo: TypeInfo
     fun invoke(t: T): Any
 }
 
 inline fun <reified T : Any> packet(clazz: KClass<T> = T::class, crossinline code: (T) -> Any) = object : PacketController<T> {
     override fun invoke(t: T) = code(t)
-    override val clazz: KClass<T> = clazz
+    override val typeInfo: TypeInfo = typeInfo<T>()
 }
 
 
@@ -22,7 +23,8 @@ data class PacketFrame(
     val data: String
 )
 
-enum class ServerPacket {
+enum class ClientPacket {
     GET_ROOM_NUMBER,
-    LEAVE_ROOM
-}
+    LEAVE_ROOM,
+    CHAT
+}