Agregado codigo para aceptar enviar el estado actual del juego

src/Application.kt

@@ -49,7 +49,8 @@ fun Application.module(testing: Boolean = false) {
         }
 
         this.crearJuego()
-        this.wsjuego()
+        this.wssala()
+        this.juegows()
         this.usuarios()
     }
 }

src/DatosJuego.kt

@@ -0,0 +1,35 @@
+package dev.araozu
+
+data class DatosJuego(
+    val dora: Array<Int>,
+    val doraOculto: Array<Int>,
+    val manos: HashMap<String, Mano>,
+    val cartasRestantes: Int,
+    val ordenJugadores: Array<String>
+) {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as DatosJuego
+
+        if (!dora.contentEquals(other.dora)) return false
+        if (!doraOculto.contentEquals(other.doraOculto)) return false
+        if (manos != other.manos) return false
+        if (cartasRestantes != other.cartasRestantes) return false
+        if (!ordenJugadores.contentEquals(other.ordenJugadores)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = dora.contentHashCode()
+        result = 31 * result + doraOculto.contentHashCode()
+        result = 31 * result + manos.hashCode()
+        result = 31 * result + cartasRestantes
+        result = 31 * result + ordenJugadores.contentHashCode()
+        return result
+    }
+
+}

src/Juego.kt

@@ -6,11 +6,14 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
 
     private val cartas: Array<Int> = GestorJuegos.generarCartas()
     val conexiones: HashMap<String, WebSocketSession> = HashMap()
+    private val ordenJugadores = Array(4) {""}
     private val manos: HashMap<String, Mano> = HashMap()
     private val dora: ArrayList<Int> = arrayListOf()
+    private val doraPublico = Array(5) {0}
+    private val doraOculto = Array(5) {0}
     var estadoJuego = EstadoJuego.Espera
     var posCartaActual = 0
-    var doraDescubiertos = 1
+    var cartasRestantes = 58
 
     suspend fun iniciarJuego(ws: WebSocketSession) {
         if (estadoJuego != EstadoJuego.Espera) return
@@ -25,6 +28,8 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             dora.add(cartas[i])
         }
         posCartaActual += 10
+        doraPublico[0] = dora[0]
+        doraOculto[0] = dora[4]
 
         for ((idUsuario, _) in usuarios) {
             val cartasL = arrayListOf<Int>()
@@ -38,19 +43,43 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             manos[idUsuario] = mano
         }
 
-        conexiones.forEach { (_, socket) ->
+        var i = 0
+        conexiones.forEach { (idUsuario, socket) ->
+            ordenJugadores[i] = idUsuario
+            i++
             socket.send(Frame.Text("{\"operacion\": \"juego_iniciado\"}"))
         }
         conexiones.clear()
-        println("Parametros del juego creados!")
     }
 
-    fun agregarConexion(idUsuario: String, conexion: WebSocketSession) {
+    private suspend fun enviarDatos(idUsuario: String, ws: WebSocketSession) {
+        var doraOcultoS = Array(5) {0}
+        val manosS = HashMap<String, Mano>()
+
+        for ((idUsuarioAct, mano) in manos) {
+            if (idUsuarioAct == idUsuario) {
+                if (mano.allIn) {
+                    doraOcultoS = doraOculto
+                }
+                manosS[idUsuarioAct] = mano
+            } else {
+                manosS[idUsuarioAct] = mano.obtenerManoPrivada()
+            }
+        }
+
+        val datosJuego = DatosJuego(doraPublico, doraOcultoS, manosS, cartasRestantes, ordenJugadores)
+        ws.send(Frame.Text("{\"operacion\": \"actualizar_datos\", \"datos\": ${gson.toJson(datosJuego)}}"))
+    }
+
+    suspend fun agregarConexion(idUsuario: String, conexion: WebSocketSession) {
         conexiones[idUsuario] = conexion
+        if (estadoJuego == EstadoJuego.Iniciado) {
+            enviarDatos(idUsuario, conexion)
+        }
     }
 
     fun agregarUsuario(idUsuario: String) {
-        usuarios.add(Pair(idUsuario, true))
+        if (estadoJuego == EstadoJuego.Espera) usuarios.add(Pair(idUsuario, true))
     }
 
 }

src/JuegoWS.kt

@@ -0,0 +1,28 @@
+package dev.araozu
+
+import com.google.gson.Gson
+import io.ktor.http.cio.websocket.*
+import io.ktor.routing.*
+import io.ktor.websocket.*
+
+val gson = Gson()
+
+fun Routing.juegows() {
+
+    webSocket("/juego") {
+
+        for (frame in incoming) when (frame) {
+            is Frame.Text -> {
+                val sol = gson.fromJson(frame.readText(), Conexion::class.java)
+                when (sol.operacion) {
+                    "conectar" -> {
+                        val datos = gson.fromJson(sol.datos, ConexionNueva::class.java)
+                        GestorJuegos.conectarASala(datos.idJuego, datos.idUsuario, this)
+                    }
+                }
+            }
+        }
+
+    }
+
+}

src/Mano.kt

@@ -1,9 +1,15 @@
 package dev.araozu
 
-class Mano(cartas: ArrayList<Int>) {
+class Mano(
-
+    val cartas: List<Int>,
-    val allIn: Boolean = false
+    val allIn: Boolean = false,
-    val cartaSig: Int? = null
+    val cartaSig: Int? = null,
     val cartasReveladas: ArrayList<ArrayList<Int>> = ArrayList()
+) {
+
+    fun obtenerManoPrivada(): Mano {
+        val l = cartas.map { 0 }
+        return Mano(l, allIn, cartaSig, cartasReveladas)
+    }
 
 }

src/WSSala.kt

@@ -9,7 +9,7 @@ data class Conexion(val operacion: String, val datos: String)
 
 data class ConexionNueva(val idJuego: String, val idUsuario: String)
 
-fun Routing.wsjuego() {
+fun Routing.wssala() {
     val gson = Gson()
     webSocket("/socket") {