Agregada funcionalidad llamar/ignorar seq

src/GestorJuegos.kt

@@ -87,4 +87,9 @@ object GestorJuegos {
         juego.ignorarOportunidadSeq(idUsuario)
     }
 
+    suspend fun manejarLlamarSeq(idJuego: String, idUsuario: String, cartaDescartada: Int, combinacion: Pair<Int, Int>) {
+        val juego = juegos[idJuego]!!
+        juego.manejarSeq(idUsuario, cartaDescartada, combinacion)
+    }
+
 }

src/JuegoWS.kt

@@ -8,8 +8,13 @@ import io.ktor.websocket.*
 val gson = Gson()
 
 data class DatosDescarte(val idJuego: String, val idUsuario: String, val carta: Int)
-
 data class DatosIgnorarOportunidad(val idJuego: String, val idUsuario: String)
+data class DatosLlamarSeq(
+    val idJuego: String,
+    val idUsuario: String,
+    val cartaDescartada: Int,
+    val combinacion: Pair<Int, Int>
+)
 
 fun Routing.juegows() {
 
@@ -31,6 +36,15 @@ fun Routing.juegows() {
                         val datos = gson.fromJson(sol.datos, DatosIgnorarOportunidad::class.java)
                         GestorJuegos.manejarIgnorarOportunidad(datos.idJuego, datos.idUsuario)
                     }
+                    "llamar_seq" -> {
+                        val datos = gson.fromJson(sol.datos, DatosLlamarSeq::class.java)
+                        GestorJuegos.manejarLlamarSeq(
+                            datos.idJuego,
+                            datos.idUsuario,
+                            datos.cartaDescartada,
+                            datos.combinacion
+                        )
+                    }
                 }
             }
         }

src/juego/Carta.kt

@@ -1,8 +1,6 @@
 package dev.araozu.juego
 
-import kotlin.reflect.KClass
-
-sealed class Carta(private val valor: Int) {
+sealed class Carta(val valor: Int) {
     companion object {
         fun obtenerCartaEspecifica(valor: Int): Carta {
             return when (valor) {
@@ -16,31 +14,43 @@ sealed class Carta(private val valor: Int) {
                 224 -> CartaRealezaQ()
                 256 -> CartaRealezaK()
                 else -> {
-                    throw IllegalArgumentException("Valor de carta ilegal.")
+                    throw IllegalArgumentException("Valor de carta ilegal. $valor")
                 }
             }
         }
 
-        /**
-         * Filtra un array list de cartas segun su tipo de clase. El parámetro T debe ser la misma clase
-         * que el parametro clase, o su clase padre.
-         * @param valores El ArrayList del cual se filtrará
-         * @param clase La clase que determina el filtro
-         */
-        fun <T: Carta> filtrarCartas(valores: ArrayList<Int>, clase: KClass<out Carta>): ArrayList<T> {
-            val arrl = arrayListOf<T>()
+    }
+}
+
+sealed class CartaNumero(valor: Int, val numero: Int = (valor shl 27) ushr 28) : Carta(valor) {
+
+    companion object {
+        fun filtrarCartasRojo(valores: ArrayList<Int>): ArrayList<CartaNumeroRojo> {
+            val arrl = arrayListOf<CartaNumeroRojo>()
 
             valores.forEach {
+                println("Creando carta para filtrar: $it")
                 val carta = obtenerCartaEspecifica(it)
-                if (carta::class == clase) arrl.add(carta as T)
+                if (carta is CartaNumeroRojo) arrl.add(carta)
+            }
+
+            return arrl
+        }
+
+        fun filtrarCartasNegro(valores: ArrayList<Int>): ArrayList<CartaNumeroNegro> {
+            val arrl = arrayListOf<CartaNumeroNegro>()
+
+            valores.forEach {
+                println("Creando carta para filtrar: $it")
+                val carta = obtenerCartaEspecifica(it)
+                if (carta is CartaNumeroNegro) arrl.add(carta)
             }
 
             return arrl
         }
     }
-}
 
-sealed class CartaNumero(valor: Int, val numero: Int = (valor shl 27) ushr 28) : Carta(valor)
+}
 
 class CartaNumeroNegro(valor: Int) : CartaNumero(valor)
 class CartaNumeroRojo(valor: Int) : CartaNumero(valor)

src/juego/Juego.kt

@@ -204,4 +204,43 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
         enviarDatosATodos()
     }
 
+    suspend fun manejarSeq(idUsuario: String, cartaDescartada: Int, combinacion: Pair<Int, Int>) {
+
+        val manoJugadorDescarte = manos[ordenJugadores[turnoActual]]!!
+        val descartesJ = manoJugadorDescarte.descartes
+
+        // La carta solicitada para robar es invalida
+        if (descartesJ[descartesJ.size - 1] != cartaDescartada) {
+            println("La carta a robar es invalida")
+            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)
+        manoRobador.cartasReveladas.add(seq)
+
+        // Eliminar las oportunidades
+        manoRobador.oportunidades = arrayListOf()
+
+        // Cambiar turno al robador sin dar carta
+        turnoActual = (turnoActual + 1) % 4
+        gestorDora!!.actualizarDoraCerrado()
+
+        enviarDatosATodos()
+    }
+
 }

src/juego/OportunidadSeq.kt

@@ -7,23 +7,25 @@ data class OportunidadSeq(override val cartaDescartada: Int, val combinaciones:
 
     companion object {
 
-        private fun arrlCartasContiene(arrl: ArrayList<CartaNumero>, v1: Int, v2: Int): Pair<Int, Int>? {
+        private fun <T : CartaNumero> arrlCartasContiene(arrl: ArrayList<T>, v1: Int, v2: Int): Pair<Int, Int>? {
             var v1E: Int? = null
             var v2E: Int? = null
             for (c in arrl) {
-                if (c.numero == v1) v1E = c.numero
-                if (c.numero == v2) v2E = c.numero
+                if (c.numero == v1) v1E = c.valor
+                if (c.numero == v2) v2E = c.valor
                 if (v1E != null && v2E != null) return Pair(v1E, v2E)
             }
             return null
         }
 
         fun verificar(valorCarta: Int, cartasMano: ArrayList<Int>): OportunidadSeq? {
-            return when (val carta = Carta.obtenerCartaEspecifica(valorCarta)) {
-                is CartaNumero -> {
-                    val valor = carta.numero
-
-                    val cartasFiltradas = Carta.filtrarCartas<CartaNumero>(cartasMano, carta::class)
+            println("Verificando carta seq $valorCarta")
+            val carta = Carta.obtenerCartaEspecifica(valorCarta)
+            val (valor, cartasFiltradas) = when (carta) {
+                is CartaNumeroRojo -> Pair(carta.numero, CartaNumero.filtrarCartasRojo(cartasMano))
+                is CartaNumeroNegro -> Pair(carta.numero, CartaNumero.filtrarCartasNegro(cartasMano))
+                else -> return null
+            }
 
             val arrlRetorno = arrayListOf<Pair<Int, Int>>()
 
@@ -36,10 +38,6 @@ data class OportunidadSeq(override val cartaDescartada: Int, val combinaciones:
 
             return if (arrlRetorno.isNotEmpty()) OportunidadSeq(valorCarta, arrlRetorno) else null
         }
-                else -> null
-            }
-
-        }
     }
 
 }