Ahora el unico tipo de dato a enviar es una actualizacion de todas las manos.

src/juego/GestorDora.kt

@@ -4,7 +4,8 @@ class GestorDora(private val cartas: ArrayList<Int>) {
 
     private val doraCerrado = arrayListOf(cartas[0])
     private val doraAbierto = arrayListOf<Int>()
-    var turnosRestantesDoraCerrado = 32 // 32 16 8 4
+    var turnosSigDora = 32
+    var turnosRestantesDoraCerrado = turnosSigDora // 32 16 8 4
         private set
 
     operator fun component1(): Array<Int> {
@@ -23,18 +24,20 @@ class GestorDora(private val cartas: ArrayList<Int>) {
         }
     }
 
-    fun actualizarDoraTurno() {
+    fun actualizarDoraCerrado() {
         if (doraCerrado.size >= 5) return
         turnosRestantesDoraCerrado--
         if (turnosRestantesDoraCerrado == 0) {
             doraCerrado.add(cartas[doraCerrado.size])
+            turnosSigDora /= 2
+            turnosRestantesDoraCerrado = turnosSigDora
         }
         if (doraCerrado.size == 5) {
             turnosRestantesDoraCerrado = -1
         }
     }
 
-    fun actualizarDoraQuad() {
+    fun actualizarDoraAbierto() {
         if (doraCerrado.size >= 5) return
         doraAbierto.add(cartas[5 + doraAbierto.size])
     }

src/juego/Juego.kt

@@ -50,7 +50,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             val mano = if (idJugadorInicial == idUsuario) {
                 val sigCarta = cartas[posCartaActual]
                 posCartaActual++
-                gestorDora!!.actualizarDoraTurno()
+                gestorDora!!.actualizarDoraCerrado()
 
                 Mano(cartasL, sigCarta = sigCarta)
             } else {
@@ -92,6 +92,12 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
         ws.send(Frame.Text("{\"operacion\": \"actualizar_datos\", \"datos\": ${gson.toJson(datosJuego)}}"))
     }
 
+    private suspend fun enviarDatosATodos() {
+        for ((idUsuario, ws) in conexiones) {
+            enviarDatos(idUsuario, ws)
+        }
+    }
+
     suspend fun agregarConexion(idUsuario: String, conexion: WebSocketSession) {
         conexiones[idUsuario] = conexion
         if (estadoJuego == EstadoJuego.Iniciado) {
@@ -103,65 +109,13 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
         if (estadoJuego == EstadoJuego.Espera) usuarios.add(Pair(idUsuario, true))
     }
 
-    private fun arrContiene(v1: Int, v2: Int, arr: List<Int>): Boolean {
+    private fun cambiarTurnoSigJugadorConsecutivo() {
-        var v1E = false
+        // Extraer, dar sig carta al sig jugador, cambiar turno
-        var v2E = false
+        turnoActual = (turnoActual + 1) % 4
-        for (i in arr) {
+        val idSigUsuario = ordenJugadores[turnoActual]
-            if (i == v1) v1E = true
+        val sigCarta = cartas[posCartaActual]
-            if (i == v2) v2E = true
+        posCartaActual++
-
+        manos[idSigUsuario]!!.sigCarta = sigCarta
-            if (v1E && v2E) return true
-        }
-
-        return false
-    }
-
-    private fun verificarTri(carta: Int): HashMap<String, ArrayList<String>>? {
-        // La carta es dragon o rey
-        if (carta > 54) return null
-
-        val idSigJugador = ordenJugadores[(turnoActual + 1) % 4]
-        val manoJugador = manos[idSigJugador]!!
-        val cartasJugador = manoJugador.cartas
-
-        val obtValorCarta = { valor: Int -> (valor shl 27) ushr 28 }
-        val obtTipoCarta = { valor: Int -> (valor shl 23) ushr 28 }
-
-        val valorCarta = obtValorCarta(carta)
-        val cartasAComparar = {
-            val filtro = obtTipoCarta(carta)
-            cartasJugador.filter { obtTipoCarta(it) == filtro } .map(obtValorCarta)
-        }()
-
-        val oportunidades = HashMap<String, ArrayList<String>>()
-
-        val oportunidadesJugador = ArrayList<String>()
-        // Primer caso: Xoo
-        if (arrContiene(valorCarta + 1, valorCarta + 2, cartasAComparar)) {
-            oportunidadesJugador.add("seq")
-        }
-
-        // Segundo caso: oXo
-        if (arrContiene(valorCarta - 1, valorCarta + 1, cartasAComparar)) {
-            oportunidadesJugador.add("seq")
-        }
-
-        // Tercer caso: ooX
-        if (arrContiene(valorCarta - 1, valorCarta - 2, cartasAComparar)) {
-            oportunidadesJugador.add("seq")
-        }
-
-        if (oportunidadesJugador.isNotEmpty())
-            oportunidades[idSigJugador] = oportunidadesJugador
-
-        return if (oportunidades.isNotEmpty()) oportunidades else null
-    }
-
-    private suspend fun enviarOportunidades(oportunidades: HashMap<String, ArrayList<String>>, cartaDescartada: Int) {
-        for ((id, ops) in oportunidades) {
-            val oportunidadesL = OportunidadesJuego(ops, cartaDescartada)
-            conexiones[id]!!.send(Frame.Text("{\"operacion\": \"oportunidad\", \"datos\": ${gson.toJson(oportunidadesL)}}"))
-        }
     }
 
     suspend fun manejarDescarte(idUsuario: String, carta: Int) {
@@ -184,53 +138,27 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             m.descartes.add(carta)
 
             // Verificar seq/tri/quad/win
-            val oportunidades = verificarTri(carta)
+            var hayOportunidades = false
-            if (oportunidades != null) {
+            for ((_, mano) in manos) {
-                enviarOportunidades(oportunidades, carta)
+                val oportunidadSeq = OportunidadSeq.verificar(carta, mano.cartas)
-                return
+                if (oportunidadSeq != null) {
+                    hayOportunidades = true
+                    mano.oportunidades.add(oportunidadSeq)
+                }
             }
 
-            // Extraer, dar sig carta al sig jugador, cambiar turno
+            if (hayOportunidades) {
-            turnoActual = (turnoActual + 1) % 4
+                // Enviar datos
-            val idSigUsuario = ordenJugadores[turnoActual]
+                enviarDatosATodos()
-            val sigCarta = cartas[posCartaActual]
+            } else {
-            posCartaActual++
+                cambiarTurnoSigJugadorConsecutivo()
-            manos[idSigUsuario]!!.sigCarta = sigCarta
 
                 // Actualizar dora
-            gestorDora!!.actualizarDoraTurno()
+                gestorDora!!.actualizarDoraCerrado()
 
                 // Enviar datos
-            for ((idUsuarioEnvio, ws) in conexiones) {
+                enviarDatosATodos()
-                val manosS = HashMap<String, Mano>()
-
-                for ((idUsuarioAct, mano) in manos) {
-                    when (idUsuarioAct) {
-                        idUsuarioEnvio -> {
-                            manosS[idUsuarioAct] = mano
             }
-                        idUsuario -> {
-                            manosS[idUsuarioAct] = mano.obtenerManoPrivada()
-                        }
-                        idSigUsuario -> {
-                            manosS[idUsuarioAct] = mano.obtenerManoPrivada()
-                        }
-                    }
-                }
-
-                val (doraCerrado, doraAbierto) = gestorDora!!
-                val datosJuego = DatosJuego(
-                    doraCerrado,
-                    doraAbierto,
-                    manosS,
-                    108 - posCartaActual,
-                    ordenJugadores,
-                    ordenJugadores[turnoActual],
-                    gestorDora!!.turnosRestantesDoraCerrado
-                )
-                ws.send(Frame.Text("{\"operacion\": \"actualizar_manos\", \"datos\": ${gson.toJson(datosJuego)}}"))
-            }
-
         }
     }
 

src/juego/Mano.kt

@@ -2,9 +2,10 @@ package dev.araozu.juego
 
 data class Mano(
     val cartas: ArrayList<Int>,
-    val cartasReveladas: ArrayList<ArrayList<Int>> = ArrayList(),
+    val cartasReveladas: ArrayList<ArrayList<Int>> = arrayListOf(),
-    val descartes: ArrayList<Int> = ArrayList(),
+    val descartes: ArrayList<Int> = arrayListOf(),
-    var sigCarta: Int = -1
+    var sigCarta: Int = -1,
+    var oportunidades: ArrayList<Oportunidad> = arrayListOf()
 ) {
 
     fun obtenerManoPrivada(): Mano {

src/juego/Oportunidad.kt

@@ -3,5 +3,6 @@ package dev.araozu.juego
 interface Oportunidad {
 
     val cartaDescartada: Int
+    val nombreOportunidad: String
 
 }

src/juego/OportunidadSeq.kt

@@ -3,6 +3,8 @@ package dev.araozu.juego
 data class OportunidadSeq(override val cartaDescartada: Int, val combinaciones: ArrayList<Pair<Int, Int>>) :
     Oportunidad {
 
+    override val nombreOportunidad: String = "Seq"
+
     companion object {
 
         private fun arrlCartasContiene(arrl: ArrayList<CartaNumero>, v1: Int, v2: Int): Pair<Int, Int>? {

src/juego/OportunidadTri.kt

@@ -1,4 +1,8 @@
 package dev.araozu.juego
 
 data class OportunidadTri(override val cartaDescartada: Int) :
-    Oportunidad
+    Oportunidad {
+
+    override val nombreOportunidad: String = "Tri"
+
+}