Arreglar error que hacia que un jugador incorrecto inicie. Mejorar conf. inicial del juego

src/Application.kt

@@ -44,10 +44,6 @@ fun Application.module(testing: Boolean = false) {
     }
 
     routing {
-        get("/json/gson") {
-            call.respond(mapOf("hello" to "world"))
-        }
-
         this.crearJuego()
         this.wssala()
         this.juegows()

src/juego/DatosJuego.kt

@@ -2,15 +2,14 @@ package dev.araozu.juego
 
 data class DatosJuego(
     val dora: ArrayList<Int>,
-    val doraOculto: ArrayList<Int>,
     val manos: HashMap<String, Mano>,
     val cartasRestantes: Int,
     val ordenJugadores: Array<String>,
     val turnoActual: String,
     val turnosHastaDora: Int,
-    val dragonPartida: Dragon
+    val dragonPartida: Dragon,
+    val oportunidadesRestantes: Int
 ) {
-
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (javaClass != other?.javaClass) return false
@@ -18,27 +17,26 @@ data class DatosJuego(
         other as DatosJuego
 
         if (dora != other.dora) return false
-        if (doraOculto != other.doraOculto) return false
         if (manos != other.manos) return false
         if (cartasRestantes != other.cartasRestantes) return false
         if (!ordenJugadores.contentEquals(other.ordenJugadores)) return false
         if (turnoActual != other.turnoActual) return false
         if (turnosHastaDora != other.turnosHastaDora) return false
         if (dragonPartida != other.dragonPartida) return false
+        if (oportunidadesRestantes != other.oportunidadesRestantes) return false
 
         return true
     }
 
     override fun hashCode(): Int {
         var result = dora.hashCode()
-        result = 31 * result + doraOculto.hashCode()
         result = 31 * result + manos.hashCode()
         result = 31 * result + cartasRestantes
         result = 31 * result + ordenJugadores.contentHashCode()
         result = 31 * result + turnoActual.hashCode()
         result = 31 * result + turnosHastaDora
         result = 31 * result + dragonPartida.hashCode()
+        result = 31 * result + oportunidadesRestantes
         return result
     }
-
 }

src/juego/GestorDora.kt

@@ -1,37 +1,36 @@
 package dev.araozu.juego
 
-class GestorDora(private val cartas: ArrayList<Int>) {
+class GestorDora(cartasIniciales: Array<Int>) {
 
-    private val doraCerrado = arrayListOf(cartas[0])
+    private val cartas = Array(5) {-1}
-    private val doraAbierto = arrayListOf<Int>()
+    val dora = arrayListOf(cartas[0])
     private var turnosSigDora = 20
-    var turnosRestantesDoraCerrado = turnosSigDora // 20 15 10 5
+    var turnosRestantesDora = turnosSigDora // 20 15 10 5
         private set
 
+    init {
+        for (i in 0 until 5) {
+            cartas[i] = cartasIniciales[i]
+        }
+    }
+
     operator fun component1(): ArrayList<Int> {
-        return doraCerrado
+        return dora
     }
 
-    operator fun component2(): ArrayList<Int> {
+    fun actualizarDora() {
-        return doraAbierto
+        if (dora.size >= 5) return
-    }
+        turnosRestantesDora--
 
-    fun actualizarDoraCerrado() {
+        if (turnosRestantesDora == 0) {
-        if (doraCerrado.size >= 5) return
+            dora.add(cartas[dora.size])
-        turnosRestantesDoraCerrado--
-        if (turnosRestantesDoraCerrado == 0) {
-            doraCerrado.add(cartas[doraCerrado.size])
             turnosSigDora -= 5
-            turnosRestantesDoraCerrado = turnosSigDora
+            turnosRestantesDora = turnosSigDora
         }
-        if (doraCerrado.size == 5) {
+
-            turnosRestantesDoraCerrado = -1
+        if (dora.size == 5) {
+            turnosRestantesDora = -1
         }
     }
 
-    fun actualizarDoraAbierto() {
-        if (doraAbierto.size >= 5) return
-        doraAbierto.add(cartas[5 + doraAbierto.size])
-    }
-
 }

src/juego/Juego.kt

@@ -9,11 +9,12 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
     val conexiones: HashMap<String, WebSocketSession> = HashMap()
     private val ordenJugadores = Array(4) { "" }
     private val manos: HashMap<String, Mano> = HashMap()
-    private var gestorDora: GestorDora? = null
+    private var gestorDora = GestorDora(cartas)
     private var estadoJuego = EstadoJuego.Espera
-    private var posCartaActual = 0
+    private var posCartaActual = 10
-    private var turnoActual = 0
+    private var posJugadorActual = 0
     private var dragonPartida = Dragon.Negro
+    private var oportunidadesRestantes = 0
 
     suspend fun iniciarJuego(ws: WebSocketSession) {
         if (estadoJuego != EstadoJuego.Espera) return
@@ -25,24 +26,12 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
 
         estadoJuego = EstadoJuego.Iniciado
 
-        // Inicializar dora
-        val dora: ArrayList<Int> = arrayListOf()
-        for (i in posCartaActual until (posCartaActual + 10)) {
-            dora.add(cartas[i])
-        }
-        gestorDora = GestorDora(dora)
-        posCartaActual += 10
-
         // Asignar orden de jugadores
         var i = 0
         val posInicio = (Math.random() * 4).toInt()
-        var idJugadorInicial = ""
         conexiones.forEach { (idUsuario, _) ->
-            if (i == posInicio) idJugadorInicial = idUsuario
-
             ordenJugadores[i] = idUsuario
             val dragonActual = Dragon.get(i)
-            i++
 
             val cartasL = arrayListOf<Int>()
 
@@ -51,11 +40,12 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             }
             posCartaActual += 10
 
-            val mano = if (idJugadorInicial == idUsuario) {
+            val mano = if (i == posInicio) {
                 val sigCarta = cartas[posCartaActual]
                 posCartaActual++
-                gestorDora!!.actualizarDoraCerrado()
+                gestorDora.actualizarDora()
                 dragonPartida = dragonActual
+                posJugadorActual = i
 
                 Mano(cartasL, sigCarta = sigCarta, dragon = dragonActual)
             } else {
@@ -63,6 +53,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             }
 
             manos[idUsuario] = mano
+            i++
         }
 
         conexiones.forEach { (_, socket) ->
@@ -83,17 +74,17 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             }
         }
 
-        val idJugadorTurnoActual = ordenJugadores[turnoActual]
+        val idJugadorTurnoActual = ordenJugadores[posJugadorActual]
-        val (doraCerrado, doraAbierto) = gestorDora!!
+        val doraCerrado = gestorDora.dora
         val datosJuego = DatosJuego(
             doraCerrado,
-            doraAbierto,
             manosS,
             108 - posCartaActual,
             ordenJugadores,
             idJugadorTurnoActual,
-            gestorDora!!.turnosRestantesDoraCerrado,
+            gestorDora.turnosRestantesDora,
-            dragonPartida
+            dragonPartida,
+            oportunidadesRestantes
         )
         ws.send(Frame.Text("{\"operacion\": \"actualizar_datos\", \"datos\": ${gson.toJson(datosJuego)}}"))
     }
@@ -117,9 +108,10 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
 
     private fun cambiarTurnoSigJugadorConsecutivo() {
         // Cambiar turno al sig jugador consecutivo
-        turnoActual = (turnoActual + 1) % 4
+        posJugadorActual = (posJugadorActual + 1) % 4
+        oportunidadesRestantes = 0
 
-        val idSigUsuario = ordenJugadores[turnoActual]
+        val idSigUsuario = ordenJugadores[posJugadorActual]
 
         // Extraer sig carta. TODO: Verificar que no quedan cartas y establecer empate
         val sigCarta = cartas[posCartaActual]
@@ -148,7 +140,11 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
     }
 
     suspend fun manejarDescarte(idUsuario: String, carta: Int) {
-        if (ordenJugadores[turnoActual] != idUsuario) return
+        if (ordenJugadores[posJugadorActual] != idUsuario) return
+
+        // Si el jugador del turno actual ya descarto, otros jugadores tienen oportunidades
+        // e intento descartar de nuevo
+        if (oportunidadesRestantes > 0) return
 
         val m = manos[idUsuario]!!
 
@@ -170,7 +166,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
 
         m.descartes.add(carta)
 
-        // Verificar seq/tri/quad/win
+        // Verificar seq/tri/win
         var hayOportunidades = false
         for ((idUsuarioActual, mano) in manos) {
             // No buscar oportunidades en el usuario que acaba de descartar.
@@ -181,6 +177,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
                 val oportunidadSeq = OportunidadSeq.verificar(carta, mano.cartas)
                 if (oportunidadSeq != null) {
                     hayOportunidades = true
+                    oportunidadesRestantes++
                     mano.oportunidades.add(oportunidadSeq)
                 }
             }
@@ -189,6 +186,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             val oportunidadTri = OportunidadTri.verificar(carta, mano.cartas)
             if (oportunidadTri != null) {
                 hayOportunidades = true
+                oportunidadesRestantes++
                 mano.oportunidades.add(oportunidadTri)
             }
 
@@ -196,6 +194,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             val oportunidadWin = OportunidadWin.verificar(carta, mano.cartas, mano.cartasReveladas)
             if (oportunidadWin != null) {
                 hayOportunidades = true
+                oportunidadesRestantes++
                 mano.oportunidades.add(oportunidadWin)
             }
         }
@@ -207,7 +206,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             cambiarTurnoSigJugadorConsecutivo()
 
             // Actualizar dora
-            gestorDora!!.actualizarDoraCerrado()
+            gestorDora.actualizarDora()
 
             // Enviar datos
             enviarDatosATodos()
@@ -218,14 +217,16 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
     suspend fun ignorarOportunidadSeq(idUsuario: String) {
 
         var aunHayOportunidades = false
+        oportunidadesRestantes--
+
         for ((id, mano) in manos) {
             // Eliminar oportunidad del usuario
             if (id == idUsuario) {
                 mano.oportunidades = arrayListOf()
+                enviarDatos(id, conexiones[id]!!)
                 continue
             }
 
-            // TODO: Notificar al jugador que su oportunidad ha sido ignorada
             // Si algun otro jugador tiene una oportunidad
             if (mano.oportunidades.isNotEmpty()) {
                 aunHayOportunidades = true
@@ -237,7 +238,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             cambiarTurnoSigJugadorConsecutivo()
 
             // Actualizar dora
-            gestorDora!!.actualizarDoraCerrado()
+            gestorDora.actualizarDora()
 
             // Enviar los nuevos datos
             enviarDatosATodos()
@@ -247,14 +248,14 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
     private fun cambiarTurnoSegunIdUsuario(idUsuario: String) {
         for ((posJugador, i) in ordenJugadores.withIndex()) {
             if (i == idUsuario) {
-                turnoActual = posJugador
+                posJugadorActual = posJugador
                 break
             }
         }
     }
 
     suspend fun manejarSeqTri(idUsuario: String, cartaDescartada: Int, combinacion: Pair<Int, Int>) {
-        val manoJugadorDescarte = manos[ordenJugadores[turnoActual]]!!
+        val manoJugadorDescarte = manos[ordenJugadores[posJugadorActual]]!!
         val descartesJ = manoJugadorDescarte.descartes
 
         // La carta solicitada para robar es invalida
@@ -284,6 +285,7 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
 
         // Eliminar las oportunidades
         manoRobador.oportunidades = arrayListOf()
+        oportunidadesRestantes = 0
 
         // Cambiar turno al robador sin dar carta
         // turnoActual = (turnoActual + 1) % 4

src/juego/Mano.kt

@@ -19,4 +19,6 @@ data class Mano(
         )
     }
 
+
+
 }