Finalizar refactorizacion inicial

src/GestorJuegos.kt

@@ -56,14 +56,17 @@ object GestorJuegos {
         broadcast(juego, mensaje)
 
         var str = "["
-        for ((idUsuarioAct, _) in juego.usuarios) {
+        for (jugador in juego.jugadores) {
-            val nombreUsuarioAct = GestorUsuarios.obtenerNombreUsuario(idUsuarioAct)
+            val nombreUsuarioAct =
+                if (jugador.idUsuario.startsWith("Bot")) jugador.idUsuario
+                else GestorUsuarios.obtenerNombreUsuario(jugador.idUsuario)
+
             if (str.length != 1) str += ","
-            str += "{\"idUsuario\": \"$idUsuarioAct\", \"nombreUsuario\": \"$nombreUsuarioAct\"}"
+            str += "{\"idUsuario\": \"${jugador.idUsuario}\", \"nombreUsuario\": \"$nombreUsuarioAct\"}"
         }
         str += "]"
+
         juego.agregarConexion(idUsuario, ws)
-        juego.agregarUsuario(idUsuario)
         ws.send(Frame.Text("{\"operacion\": \"conexion_exitosa\", \"jugadores\": $str}"))
     }
 

src/MetodosJuego.kt

@@ -18,7 +18,7 @@ fun Routing.crearJuego() {
             sigId = GestorJuegos.generarId()
         }
 
-        val juego = Juego(arrayListOf())
+        val juego = Juego(sigId)
         GestorJuegos.juegos[sigId] = juego
 
         call.respondText("{\"id\": \"$sigId\"}", contentType = ContentType.Application.Json)

src/juego/GestorDora.kt

@@ -3,7 +3,7 @@ package dev.araozu.juego
 class GestorDora(cartasIniciales: Array<Int>) {
 
     private val cartas = Array(5) {-1}
-    val dora = arrayListOf(cartas[0])
+    val dora: ArrayList<Int>
     private var turnosSigDora = 20
     var turnosRestantesDora = turnosSigDora // 20 15 10 5
         private set
@@ -12,6 +12,7 @@ class GestorDora(cartasIniciales: Array<Int>) {
         for (i in 0 until 5) {
             cartas[i] = cartasIniciales[i]
         }
+        dora = arrayListOf(cartas[0])
     }
 
     operator fun component1(): ArrayList<Int> {

src/juego/Juego.kt

@@ -3,11 +3,13 @@ package dev.araozu.juego
 import dev.araozu.*
 import io.ktor.http.cio.websocket.*
 
-class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
+class Juego(val idJuego: String) {
 
     private val cartas: Array<Int> = GestorJuegos.generarCartas()
 
-    internal var jugadores = Array<Jugador>(4) { JugadorBot(this, "Bot $it") }
+    internal var jugadores = Array<Jugador>(4) {
+        JugadorBot(this, GestorUsuarios.crearUsuario("Bot $it - $idJuego"))
+    }
     private var ordenJugadores = Array(4) { jugadores[it].idUsuario }
 
     private var gestorDora = GestorDora(cartas)
@@ -22,13 +24,17 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
 
         estadoJuego = EstadoJuego.Iniciado
 
-        val nuevoArrJugadores = Array<Jugador>(4) { JugadorBot(this, "-") }
+        val nuevoArrJugadores = Array<Jugador>(4) {
+            JugadorBot(this, GestorUsuarios.crearUsuario("Bot init $it - $idJuego"))
+        }
         val jugadoresRestantes = arrayListOf(0, 1, 2, 3)
 
+        // TODO: Logica erronea
         for (i in 0 until 4) {
             val nuevoIndice = (Math.random() * jugadoresRestantes.size).toInt()
-            nuevoArrJugadores[i] = jugadores[nuevoIndice]
+            val nuevaPosicion = jugadoresRestantes[nuevoIndice]
-            jugadoresRestantes.remove(nuevoIndice)
+            nuevoArrJugadores[i] = jugadores[nuevaPosicion]
+            jugadoresRestantes.removeAt(nuevoIndice)
         }
 
         dragonPartida = Dragon.get((Math.random() * 4).toInt())
@@ -47,12 +53,25 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
 
         jugadores = nuevoArrJugadores
         ordenJugadores = Array(4) { jugadores[it].idUsuario }
+
+
+        // Dar carta al primer jugador y empezar el juego
+        val sigCarta = cartas[posCartaActual]
+        posCartaActual++
+
+        // Asignar carta
+        jugadores[posJugadorActual].recibirCarta(sigCarta)
+        // Verificar Tsumo
+        jugadores[posJugadorActual].verificarTsumo()
+
+        enviarDatosATodos()
     }
 
     private fun obtenerDatosJuegoActuales(): DatosJuego {
         val idJugadorTurnoActual = jugadores[posJugadorActual].idUsuario
+        // TODO: Agregar EstadoJuego
         return DatosJuego(
-            dora = arrayListOf(),
+            dora = gestorDora.dora,
             manos = hashMapOf(),
             cartasRestantes = 108 - posCartaActual,
             ordenJugadores = ordenJugadores,
@@ -70,8 +89,6 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
     }
 
     suspend fun agregarConexion(idUsuario: String, conexion: WebSocketSession) {
-        if (estadoJuego != EstadoJuego.Espera) return
-
         // Buscar si el jugador ya existia
         jugadores.forEach {
             if (it.idUsuario == idUsuario) {
@@ -81,20 +98,19 @@ class Juego(val usuarios: ArrayList<Pair<String, Boolean>>) {
             }
         }
 
-        // El jugador es nuevo. Asignarlo.
+        // El jugador es nuevo. Verificar que aun se este en la sala
+        if (estadoJuego != EstadoJuego.Espera) return
+
+        // Asignarlo.
         val nuevoJugador = JugadorHumano(this, idUsuario, conexion)
         for (i in 0 until 4) {
-            if (jugadores[i] !is JugadorBot) {
+            if (jugadores[i] is JugadorBot) {
                 jugadores[i] = nuevoJugador
                 break
             }
         }
     }
 
-    fun agregarUsuario(idUsuario: String) {
-        if (estadoJuego == EstadoJuego.Espera) usuarios.add(Pair(idUsuario, true))
-    }
-
     private fun cambiarTurnoSigJugadorConsecutivo() {
         // Cambiar turno al sig jugador consecutivo
         posJugadorActual = (posJugadorActual + 1) % 4

src/juego/Jugador.kt

@@ -178,14 +178,14 @@ class JugadorBot(juego: Juego, idUsuario: String) : Jugador(juego, idUsuario) {
     override fun actualizarConexion(ws: WebSocketSession) {}
 
     override suspend fun enviarDatos(datos: DatosJuego) {
-        println("Bot pensando")
+        println("Bot $idUsuario pensando")
 
         // Si el bot tiene una carta adicional
         if (mano.sigCarta != 1) {
             // Espera 1s y la descarta
             GlobalScope.launch {
                 delay(1000)
-                println("Bot descartando la carta que recibio")
+                println("Bot $idUsuario descartando la carta que recibio")
                 juego.manejarDescarte(idUsuario, mano.sigCarta)
             }
         }
@@ -195,7 +195,7 @@ class JugadorBot(juego: Juego, idUsuario: String) : Jugador(juego, idUsuario) {
             // Espera 1s e ignora oportunidades
             GlobalScope.launch {
                 delay(1000)
-                println("Bot ignorando sus oportunidades")
+                println("Bot $idUsuario ignorando sus oportunidades")
                 juego.ignorarOportunidades(idUsuario)
             }
         }