Actualizar funcion para robar carta y formar seq/tri

src/GestorJuegos.kt

@@ -43,8 +43,8 @@ object GestorJuegos {
     }
 
     private suspend fun broadcast(juego: Juego, mensaje: String) {
-        juego.conexiones.forEach { (_, socket) ->
-            if (socket.isActive) socket.send(Frame.Text(mensaje))
+        juego.jugadores.forEach {
+            if (it.isActive) it.send(Frame.Text(mensaje))
         }
     }
 
@@ -70,7 +70,7 @@ object GestorJuegos {
     suspend fun iniciarJuego(idJuego: String, ws: WebSocketSession) {
         val juego = juegos[idJuego]
         if (juego != null) {
-            juego.iniciarJuego(ws)
+            juego.iniciarJuego()
         } else {
             ws.send(Frame.Text("{\"operacion\": \"error\", \"razon\": \"Juego invalido\"}"))
         }

src/juego/Juego.kt

@@ -49,7 +49,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
         ordenJugadores = Array(4) { jugadores[it].idUsuario }
     }
 
-    fun obtenerDatosJuegoActuales(): DatosJuego {
+    private fun obtenerDatosJuegoActuales(): DatosJuego {
         val idJugadorTurnoActual = jugadores[posJugadorActual].idUsuario
         return DatosJuego(
             dora = arrayListOf(),
@@ -174,42 +174,21 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
     }
 
     suspend fun manejarSeqTri(idUsuario: String, cartaDescartada: Int, combinacion: Pair<Int, Int>) {
-        val manoJugadorDescarte = manos[ordenJugadores[posJugadorActual]]!!
-        val descartesJ = manoJugadorDescarte.descartes
+        val jugadorOportunidad = jugadores.find { it.idUsuario == idUsuario } ?: return
+        val jugadorDescate = jugadores[posJugadorActual]
 
-        // La carta solicitada para robar es invalida
-        if (descartesJ[descartesJ.size - 1] != cartaDescartada) {
-            println("La carta a robar es invalida")
+        val roboExitoso = jugadorOportunidad.manejarTriSeq(jugadorDescate, cartaDescartada, combinacion)
+
+        if (!roboExitoso) {
             return
         }
 
-        descartesJ.removeAt(descartesJ.size - 1)
-
-        val manoRobador = manos[idUsuario]!!
-        val cartasRobador = manoRobador.cartas
-        val (vCarta1, vCarta2) = combinacion
-
-        // El jugador no tiene las cartas con las que formar seq
-        if (!cartasRobador.contains(vCarta1) || !cartasRobador.contains(vCarta2)) {
-            println("El jugador no tiene las cartas que dice que tiene: $vCarta1, $vCarta2")
-            return
-        }
-
-        // Quitar cartas de la mano y moverlas a cartas reveladas
-        cartasRobador.remove(vCarta1)
-        cartasRobador.remove(vCarta2)
-        val seq = arrayListOf(cartaDescartada, vCarta1, vCarta2)
-        seq.sort()
-        manoRobador.cartasReveladas.add(seq)
-
-        // Eliminar las oportunidades
-        manoRobador.oportunidades = arrayListOf()
-        oportunidadesRestantes = 0
+        // Eliminar oportunidades del resto. TODO: Implementar prioridad: Win -> Tri -> Seq
+        jugadores.forEach { it.ignorarOportunidades() }
 
         // Cambiar turno al robador sin dar carta
         // turnoActual = (turnoActual + 1) % 4
         cambiarTurnoSegunIdUsuario(idUsuario)
-
         enviarDatosATodos()
     }
 

src/juego/Jugador.kt

@@ -92,6 +92,41 @@ sealed class Jugador(val juego: Juego, val idUsuario: String) {
         }
     }
 
+    fun manejarTriSeq(jugadorDescarte: Jugador, cartaARobar: Int, combinacion: Pair<Int, Int>): Boolean {
+        // Este jugador es el que roba
+
+        if (!jugadorDescarte.ultimaCartaDescartadaEs(cartaARobar)) {
+            System.err.println("Un jugador intento robar una carta no descartada")
+            return false
+        }
+
+        val (vCarta1, vCarta2) = combinacion
+
+        // El robador no tiene las cartas con las que formar seq
+        if (!mano.cartas.contains(vCarta1) || !mano.cartas.contains(vCarta2)) {
+            System.err.println("El jugador no tiene las cartas que dice que tiene: $vCarta1, $vCarta2")
+            return false
+        }
+
+        // Quitar cartas de la mano y moverlas a cartas reveladas
+        mano.cartas.remove(vCarta1)
+        mano.cartas.remove(vCarta2)
+        val grupoAbierto = arrayListOf(cartaARobar, vCarta1, vCarta2)
+        grupoAbierto.sort()
+        mano.cartasReveladas.add(grupoAbierto)
+
+        jugadorDescarte.eliminarUltimaCartaDescartada()
+
+        return true
+    }
+
+    private fun ultimaCartaDescartadaEs(carta: Int): Boolean =
+        mano.descartes[mano.descartes.size - 1] == carta
+
+    private fun eliminarUltimaCartaDescartada() {
+        mano.descartes.removeAt(mano.descartes.size - 1)
+    }
+
     abstract fun verificarTsumo()
 
 }