diff --git a/src/GestorJuegos.kt b/src/GestorJuegos.kt index 9b5c67a..08bcf5e 100644 --- a/src/GestorJuegos.kt +++ b/src/GestorJuegos.kt @@ -87,4 +87,9 @@ object GestorJuegos { juego.ignorarOportunidadSeq(idUsuario) } + suspend fun manejarLlamarSeq(idJuego: String, idUsuario: String, cartaDescartada: Int, combinacion: Pair) { + val juego = juegos[idJuego]!! + juego.manejarSeq(idUsuario, cartaDescartada, combinacion) + } + } diff --git a/src/JuegoWS.kt b/src/JuegoWS.kt index 2d28b4d..4ebc2f8 100644 --- a/src/JuegoWS.kt +++ b/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 +) 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 + ) + } } } } diff --git a/src/juego/Carta.kt b/src/juego/Carta.kt index 470e1c1..e241740 100644 --- a/src/juego/Carta.kt +++ b/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 filtrarCartas(valores: ArrayList, clase: KClass): ArrayList { - val arrl = arrayListOf() + } +} + +sealed class CartaNumero(valor: Int, val numero: Int = (valor shl 27) ushr 28) : Carta(valor) { + + companion object { + fun filtrarCartasRojo(valores: ArrayList): ArrayList { + val arrl = arrayListOf() 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): ArrayList { + val arrl = arrayListOf() + + 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) diff --git a/src/juego/Juego.kt b/src/juego/Juego.kt index 1eba6ce..59f0c46 100644 --- a/src/juego/Juego.kt +++ b/src/juego/Juego.kt @@ -204,4 +204,43 @@ class Juego(val usuarios: ArrayList>) { enviarDatosATodos() } + suspend fun manejarSeq(idUsuario: String, cartaDescartada: Int, combinacion: Pair) { + + 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() + } + } diff --git a/src/juego/OportunidadSeq.kt b/src/juego/OportunidadSeq.kt index 3fc3f96..abb1d5f 100644 --- a/src/juego/OportunidadSeq.kt +++ b/src/juego/OportunidadSeq.kt @@ -7,38 +7,36 @@ data class OportunidadSeq(override val cartaDescartada: Int, val combinaciones: companion object { - private fun arrlCartasContiene(arrl: ArrayList, v1: Int, v2: Int): Pair? { + private fun arrlCartasContiene(arrl: ArrayList, v1: Int, v2: Int): Pair? { 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): OportunidadSeq? { - return when (val carta = Carta.obtenerCartaEspecifica(valorCarta)) { - is CartaNumero -> { - val valor = carta.numero - - val cartasFiltradas = Carta.filtrarCartas(cartasMano, carta::class) - - val arrlRetorno = arrayListOf>() - - val seq1 = arrlCartasContiene(cartasFiltradas, valor + 1, valor + 2) - if (seq1 != null) arrlRetorno.add(seq1) - val seq2 = arrlCartasContiene(cartasFiltradas, valor - 1, valor + 1) - if (seq2 != null) arrlRetorno.add(seq2) - val seq3 = arrlCartasContiene(cartasFiltradas, valor - 1, valor - 2) - if (seq3 != null) arrlRetorno.add(seq3) - - return if (arrlRetorno.isNotEmpty()) OportunidadSeq(valorCarta, arrlRetorno) else null - } - else -> null + 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>() + + val seq1 = arrlCartasContiene(cartasFiltradas, valor + 1, valor + 2) + if (seq1 != null) arrlRetorno.add(seq1) + val seq2 = arrlCartasContiene(cartasFiltradas, valor - 1, valor + 1) + if (seq2 != null) arrlRetorno.add(seq2) + val seq3 = arrlCartasContiene(cartasFiltradas, valor - 1, valor - 2) + if (seq3 != null) arrlRetorno.add(seq3) + + return if (arrlRetorno.isNotEmpty()) OportunidadSeq(valorCarta, arrlRetorno) else null } }