Agregada funcionalidad descartar cartas

src/DatosJuego.kt

@@ -6,7 +6,8 @@ data class DatosJuego(
     val manos: HashMap<String, Mano>,
     val cartasRestantes: Int,
     val ordenJugadores: Array<String>,
-    val turnoActual: String
+    val turnoActual: String,
+    val turnosHastaDora: Int
 ) {
 
     override fun equals(other: Any?): Boolean {

src/GestorJuegos.kt

@@ -76,4 +76,9 @@ object GestorJuegos {
         }
     }
 
+    suspend fun manejarDescarte(idJuego: String, idUsuario: String, carta: Int) {
+        val juego = juegos[idJuego]!!
+        juego.manejarDescarte(idUsuario, carta)
+    }
+
 }

src/Juego.kt

@@ -6,14 +6,15 @@ 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 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}
+    private val doraPublico = Array(5) { 0 }
+    private val doraOculto = Array(5) { 0 }
     private var estadoJuego = EstadoJuego.Espera
     private var posCartaActual = 0
-    private val turnoActual = 0
+    private var turnoActual = 0
+    private var turnosHastaDora = 15
 
     suspend fun iniciarJuego(ws: WebSocketSession) {
         if (estadoJuego != EstadoJuego.Espera) return
@@ -49,6 +50,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             val mano = if (idJugadorInicial == idUsuario) {
                 val sigCarta = cartas[posCartaActual]
                 posCartaActual++
+                turnosHastaDora--
 
                 Mano(cartasL, sigCarta = sigCarta)
             } else {
@@ -66,7 +68,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
     }
 
     private suspend fun enviarDatos(idUsuario: String, ws: WebSocketSession) {
-        var doraOcultoS = Array(5) {0}
+        var doraOcultoS = Array(5) { 0 }
         val manosS = HashMap<String, Mano>()
 
         for ((idUsuarioAct, mano) in manos) {
@@ -87,7 +89,8 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             manosS,
             108 - posCartaActual,
             ordenJugadores,
-            idJugadorTurnoActual
+            idJugadorTurnoActual,
+            turnosHastaDora
         )
         ws.send(Frame.Text("{\"operacion\": \"actualizar_datos\", \"datos\": ${gson.toJson(datosJuego)}}"))
     }
@@ -103,4 +106,82 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
         if (estadoJuego == EstadoJuego.Espera) usuarios.add(Pair(idUsuario, true))
     }
 
+    suspend fun manejarDescarte(idUsuario: String, carta: Int) {
+        if (ordenJugadores[turnoActual] == idUsuario) {
+            val m = manos[idUsuario]!!
+
+            if (m.sigCarta == carta) {
+                m.sigCarta = -1
+            } else {
+                val posCarta = m.cartas.indexOf(carta)
+                if (posCarta != -1) {
+                    m.cartas.removeAt(posCarta)
+                    m.cartas.add(m.sigCarta)
+                    m.sigCarta = -1
+                } else {
+                    return
+                }
+            }
+
+            m.descartes.add(carta)
+
+            // Extraer, dar sig carta al sig jugador, cambiar turno
+            turnoActual = (turnoActual + 1) % 4
+            val idSigUsuario = ordenJugadores[turnoActual]
+            val sigCarta = cartas[posCartaActual]
+            posCartaActual++
+            turnosHastaDora--
+            manos[idSigUsuario]!!.sigCarta = sigCarta
+
+            // Actualizar dora
+            if (turnosHastaDora == 0) {
+                val sigPosDora = doraPublico.indexOf(0)
+                // Si aun quedan doras
+                if (sigPosDora != -1) {
+                    doraPublico[sigPosDora] = dora[sigPosDora]
+                    turnosHastaDora = 15
+                }
+                // Si ya no hay doras
+                else {
+                    turnosHastaDora = 108
+                }
+            }
+
+            // Enviar datos
+            for ((idUsuarioEnvio, ws) in conexiones) {
+                val manosS = HashMap<String, Mano>()
+                var doraOcultoS = Array(5) { 0 }
+
+                for ((idUsuarioAct, mano) in manos) {
+                    when (idUsuarioAct) {
+                        idUsuarioEnvio -> {
+                            manosS[idUsuarioAct] = mano
+                            if (mano.allIn) {
+                                doraOcultoS = doraOculto
+                            }
+                        }
+                        idUsuario -> {
+                            manosS[idUsuarioAct] = mano.obtenerManoPrivada()
+                        }
+                        idSigUsuario -> {
+                            manosS[idUsuarioAct] = mano.obtenerManoPrivada()
+                        }
+                    }
+                }
+
+                val datosJuego = DatosJuego(
+                    doraPublico,
+                    doraOcultoS,
+                    manosS,
+                    108 - posCartaActual,
+                    ordenJugadores,
+                    ordenJugadores[turnoActual],
+                    turnosHastaDora
+                )
+                ws.send(Frame.Text("{\"operacion\": \"actualizar_manos\", \"datos\": ${gson.toJson(datosJuego)}}"))
+            }
+
+        }
+    }
+
 }

src/JuegoWS.kt

@@ -7,6 +7,8 @@ import io.ktor.websocket.*
 
 val gson = Gson()
 
+data class DatosDescarte(val idJuego: String, val idUsuario: String, val carta: Int)
+
 fun Routing.juegows() {
 
     webSocket("/juego") {
@@ -19,6 +21,10 @@ fun Routing.juegows() {
                         val datos = gson.fromJson(sol.datos, ConexionNueva::class.java)
                         GestorJuegos.conectarASala(datos.idJuego, datos.idUsuario, this)
                     }
+                    "descarte" -> {
+                        val datos = gson.fromJson(sol.datos, DatosDescarte::class.java)
+                        GestorJuegos.manejarDescarte(datos.idJuego, datos.idUsuario, datos.carta)
+                    }
                 }
             }
         }

src/Mano.kt

@@ -1,15 +1,16 @@
 package dev.araozu
 
 data class Mano(
-    val cartas: List<Int>,
+    val cartas: ArrayList<Int>,
     val allIn: Boolean = false,
     val cartasReveladas: ArrayList<ArrayList<Int>> = ArrayList(),
-    val descartes: List<Int> = ArrayList(),
-    val sigCarta: Int = -1
+    val descartes: ArrayList<Int> = ArrayList(),
+    var sigCarta: Int = -1
 ) {
 
     fun obtenerManoPrivada(): Mano {
-        val l = cartas.map { 0 }
+        val l = ArrayList<Int>()
+        l.addAll(cartas.map { 0 })
         return this.copy(
             cartas = l,
             sigCarta = if (sigCarta != -1) 0 else sigCarta