Dockerfile

@@ -1,7 +0,0 @@
-FROM eclipse-temurin:11
-EXPOSE 8080:8080
-
-# When this is run, Jenkins has already built the FAT JAR
-RUN mkdir /app
-COPY ./build/libs/rimajon-0.0.1-all.jar /app/backend.jar
-ENTRYPOINT ["java","-jar","/app/backend.jar"]

Jenkinsfile

@@ -1,20 +0,0 @@
-pipeline {
-    agent {
-        docker {
-            image "gradle:7.6.4-jdk11"
-        }
-    }
-
-    stages {
-        stage('Build FAT JAR') {
-            steps {
-                sh 'gradle shadowJar'
-            }
-        }
-        stage("Deploy jar") {
-            steps {
-                sh "echo ':D (need to spin up container)'"
-            }
-        }
-    }
-}

build.gradle

@@ -8,10 +8,6 @@ buildscript {
     }
 }
 
-plugins {
-    id 'com.github.johnrengelman.shadow' version '7.0.0'
-}
-
 apply plugin: 'kotlin'
 apply plugin: 'application'
 
@@ -32,12 +28,6 @@ repositories {
     maven { url 'https://kotlin.bintray.com/ktor' }
 }
 
-shadowJar {
-    manifest {
-        attributes 'Main-Class': 'com.example.ApplicationKt'
-    }
-}
-
 dependencies {
     compile("org.jetbrains.exposed:exposed-core:0.24.1")
     compile("org.jetbrains.exposed:exposed-dao:0.24.1")
@@ -50,5 +40,4 @@ dependencies {
     implementation "io.ktor:ktor-gson:$ktor_version"
     implementation 'com.google.code.gson:gson:2.8.5'
     testImplementation "io.ktor:ktor-server-tests:$ktor_version"
-    // testImplementation 'io.kotest:kotest-runner-junit5:$version'
 }

docker-compose.yml

@@ -1,6 +0,0 @@
-services:
-  web:
-    build: .
-    ports:
-      - "9124:8080"
-

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

resources/META-INF/MANIFEST.MF

@@ -1,3 +0,0 @@
-Manifest-Version: 1.0
-Main-Class: dev.araozu.ApplicationKt
-

src/GestorJuegos.kt

@@ -89,18 +89,9 @@ object GestorJuegos {
         juego.ignorarOportunidades(idUsuario)
     }
 
-    suspend fun manejarLlamarSeq(
-        idJuego: String,
-        idUsuario: String,
-        cartaDescartada: Int,
-        combinacion: Pair<Int, Int>
-    ) {
+    suspend fun manejarLlamarSeq(idJuego: String, idUsuario: String, cartaDescartada: Int, combinacion: Pair<Int, Int>) {
         val juego = juegos[idJuego]!!
         juego.manejarSeqTri(idUsuario, cartaDescartada, combinacion)
     }
 
-    suspend fun manejarRon(idJuego: String, idUsuario: String) {
-        juegos[idJuego]!!.manejarRon(idUsuario)
-    }
-
 }

src/JuegoWS.kt

@@ -46,17 +46,13 @@ fun Routing.juegows() {
                         )
                     }
                     "llamar_ron" -> {
-                        val datos = gson.fromJson(sol.datos, DatosIgnorarOportunidad::class.java)
-                        GestorJuegos.manejarRon(datos.idJuego, datos.idUsuario)
+                        TODO()
                     }
                     "llamar_tsumo" -> {
-                        TODO("Tsumo no implementado")
+                        TODO()
                     }
                 }
             }
-            else -> {
-                System.err.println("Tipo de dato enviado al socket no admitido")
-            }
         }
 
     }

src/juego/ContenedorGrupos.kt

@@ -12,7 +12,8 @@ class ContenedorGrupos(
         arrayListOf<ArrayList<Carta>>(),
         arrayListOf<ArrayList<Carta>>(),
         arrayListOf<Carta>()
-    )
+    ) {
+    }
 
     fun agregarDesdeContenedor(c: ContenedorGrupos) {
         tris.addAll(c.tris)

src/juego/DatosJuego.kt

@@ -8,7 +8,7 @@ data class DatosJuego(
     val turnoActual: String,
     val turnosHastaDora: Int,
     val dragonPartida: Dragon,
-    val estadoJuego: EstadoJuego
+    val oportunidadesRestantes: Int
 ) {
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -23,7 +23,7 @@ data class DatosJuego(
         if (turnoActual != other.turnoActual) return false
         if (turnosHastaDora != other.turnosHastaDora) return false
         if (dragonPartida != other.dragonPartida) return false
-        if (estadoJuego != other.estadoJuego) return false
+        if (oportunidadesRestantes != other.oportunidadesRestantes) return false
 
         return true
     }
@@ -36,7 +36,7 @@ data class DatosJuego(
         result = 31 * result + turnoActual.hashCode()
         result = 31 * result + turnosHastaDora
         result = 31 * result + dragonPartida.hashCode()
-        result = 31 * result + estadoJuego.hashCode()
+        result = 31 * result + oportunidadesRestantes
         return result
     }
 }

src/juego/GestorDora.kt

@@ -4,8 +4,8 @@ class GestorDora(cartasIniciales: Array<Int>) {
 
     private val cartas = Array(5) {-1}
     val dora: ArrayList<Int>
-    private var turnosSigDora = 31 // 31 15 7 3
-    var turnosRestantesDora = turnosSigDora
+    private var turnosSigDora = 20
+    var turnosRestantesDora = turnosSigDora // 20 15 10 5
         private set
 
     init {
@@ -25,7 +25,7 @@ class GestorDora(cartasIniciales: Array<Int>) {
 
         if (turnosRestantesDora == 0) {
             dora.add(cartas[dora.size])
-            turnosSigDora = (turnosSigDora - 1) / 2
+            turnosSigDora -= 5
             turnosRestantesDora = turnosSigDora
         }
 

src/juego/Juego.kt

@@ -78,7 +78,7 @@ class Juego(val idJuego: String) {
             turnoActual = idJugadorTurnoActual,
             turnosHastaDora = gestorDora.turnosRestantesDora,
             dragonPartida = dragonPartida,
-            estadoJuego = estadoJuego
+            oportunidadesRestantes = oportunidadesRestantes
         )
     }
 
@@ -208,15 +208,4 @@ class Juego(val idJuego: String) {
         enviarDatosATodos()
     }
 
-    suspend fun manejarRon(idUsuario: String) {
-        val jugadorRon = jugadores.find { it.idUsuario == idUsuario } ?: return
-
-        val ronExitoso = jugadorRon.manejarRon()
-
-        if (!ronExitoso) return
-
-        estadoJuego = EstadoJuego.Terminado
-        enviarDatosATodos()
-    }
-
 }

src/juego/Jugador.kt

@@ -69,10 +69,10 @@ sealed class Jugador(val juego: Juego, val idUsuario: String) {
             }
 
             // Oportunidades win (ron)
-            val oportunidadRon = OportunidadRon.verificar(cartaDescartada, mano.cartas, mano.cartasReveladas)
-            if (oportunidadRon != null) {
+            val oportunidadWin = OportunidadWin.verificar(cartaDescartada, mano.cartas, mano.cartasReveladas)
+            if (oportunidadWin != null) {
                 hayOportunidad = true
-                mano.oportunidades.add(oportunidadRon)
+                mano.oportunidades.add(oportunidadWin)
             }
 
             if (hayOportunidad) oportunidadesRestantes++
@@ -121,16 +121,6 @@ sealed class Jugador(val juego: Juego, val idUsuario: String) {
         return true
     }
 
-    fun manejarRon(): Boolean {
-        mano.oportunidades.find { it is OportunidadRon } ?: return false
-
-        // Limpiar oportunidades
-        mano.oportunidades.clear()
-
-        mano.esGanador = true
-        return true
-    }
-
     private fun ultimaCartaDescartadaEs(carta: Int): Boolean =
         mano.descartes[mano.descartes.size - 1] == carta
 
@@ -185,20 +175,21 @@ class JugadorBot(juego: Juego, idUsuario: String) : Jugador(juego, idUsuario) {
     private val mutexOportunidad = Mutex()
 
     override suspend fun send(v: Frame.Text) {
-
+        println("Datos enviados a bot, pero ignorados.")
     }
 
     override fun actualizarConexion(ws: WebSocketSession) {}
 
     override suspend fun enviarDatos(datos: DatosJuego) {
+        println("Bot $idUsuario pensando")
 
         // Si el bot tiene una carta adicional
         if (mano.sigCarta != -1) {
             // Espera 1s y la descarta
             GlobalScope.launch {
                 mutexDescarte.lock()
-                delay((Math.random() * 5 + 1).toLong() * 1000)
-
+                delay(1000)
+                println("Bot $idUsuario descartando la carta que recibio (${mano.sigCarta})")
                 juego.manejarDescarte(idUsuario, mano.sigCarta)
                 mutexDescarte.unlock()
             }
@@ -209,8 +200,8 @@ class JugadorBot(juego: Juego, idUsuario: String) : Jugador(juego, idUsuario) {
             // Espera 1s e ignora oportunidades
             GlobalScope.launch {
                 mutexOportunidad.lock()
-                delay((Math.random() * 5 + 1).toLong() * 1000)
-
+                delay(1000)
+                println("Bot $idUsuario ignorando sus oportunidades (${mano.oportunidades.size}")
                 juego.ignorarOportunidades(idUsuario)
                 mutexOportunidad.unlock()
             }
@@ -219,7 +210,7 @@ class JugadorBot(juego: Juego, idUsuario: String) : Jugador(juego, idUsuario) {
     }
 
     override fun verificarTsumo() {
-
+        System.err.println("Tsumo no implementado D:")
     }
 
 }

src/juego/Mano.kt

@@ -6,13 +6,10 @@ data class Mano(
     val descartes: ArrayList<Int> = arrayListOf(),
     var sigCarta: Int = -1,
     var oportunidades: ArrayList<Oportunidad> = arrayListOf(),
-    var dragon: Dragon = Dragon.Negro,
-    var esGanador: Boolean = false
+    var dragon: Dragon = Dragon.Negro
 ) {
 
     fun obtenerManoPrivada(): Mano {
-        if (esGanador) return this
-
         val l = ArrayList<Int>()
         l.addAll(cartas.map { 0 })
         return this.copy(

src/juego/OportunidadWin.kt

@@ -3,7 +3,7 @@ package dev.araozu.juego
 import dev.araozu.juego.yaku.Yaku
 import dev.araozu.juego.yaku.obtenerListaYakus
 
-class OportunidadRon(override val cartaDescartada: Int, val yaku: ArrayList<Yaku>) : Oportunidad {
+class OportunidadWin(override val cartaDescartada: Int, val yaku: ArrayList<Yaku>) : Oportunidad {
 
     override val nombreOportunidad = "Win"
 
@@ -148,11 +148,7 @@ class OportunidadRon(override val cartaDescartada: Int, val yaku: ArrayList<Yaku
             return if (valorCont1 > valorCont2) contenedor1 else contenedor2
         }
 
-        fun verificar(
-            valorCarta: Int,
-            cartasMano: ArrayList<Int>,
-            gruposAbiertos: ArrayList<ArrayList<Int>> = arrayListOf()
-        ): OportunidadRon? {
+        fun verificar(valorCarta: Int, cartasMano: ArrayList<Int>, gruposAbiertos: ArrayList<ArrayList<Int>>): OportunidadWin? {
             val narrl = ArrayList<Int>(cartasMano.size + 1)
             narrl.addAll(cartasMano)
             narrl.add(valorCarta)
@@ -174,7 +170,9 @@ class OportunidadRon(override val cartaDescartada: Int, val yaku: ArrayList<Yaku
             contenedorGrupos.agregarDesdeContenedor(obtenerContenedorCartasNumero(cartasRojo))
             contenedorGrupos.agregarDesdeContenedor(obtenerContenedorCartasNumero(cartasNegro))
 
-            val esManoAbierta = gruposAbiertos.isNotEmpty()
+            if (!contenedorGrupos.estaListo()) return null
+
+            val esManoAbierta = gruposAbiertos.isEmpty()
 
             if (esManoAbierta) {
                 // Agregar los grupos abiertos al contenedor
@@ -190,12 +188,10 @@ class OportunidadRon(override val cartaDescartada: Int, val yaku: ArrayList<Yaku
                 }
             }
 
-            if (!contenedorGrupos.estaListo()) return null
-
             // Obtener yaku
             val yaku = obtenerListaYakus(contenedorGrupos, esManoAbierta)
 
-            return if (yaku.isNotEmpty()) OportunidadRon(valorCarta, yaku) else null
+            return if (yaku.isNotEmpty()) OportunidadWin(valorCarta, yaku) else null
         }
 
     }

src/juego/yaku/Yaku.kt

@@ -3,37 +3,34 @@ package dev.araozu.juego.yaku
 import dev.araozu.juego.ContenedorGrupos
 
 enum class Yaku {
-    // 10
+    // 15
     DragonesFull,
     Verde,
 
-    // 7
+    // 10
     RealezaDragones,
     RealezaFull,
-    EscaleraPerfecta,
-    A10,
 
     // 5
-    EscaleraFull,
-
-    // 3
     TripleTriplesCerrados,
+    EscaleraFull,
     Exterior,
 
-    // 2
+    // 4
     Escalera,
+    TripleCuadruples,
     Negro,
     Rojo,
     SemiExterior,
-    DobleSecuenciaPura,
 
-    // 1
+    // 3
+    ParUnico,
     Dragones,
     Interior,
     TripleTriples,
+    TripleSecuenciaCerrada,
     Realeza,
-    DobleSecuencia,
-    ManoCerrada
+    DobleSecuenciaPura
 }
 
 fun obtenerListaYakus(contenedorGrupos: ContenedorGrupos, esManoAbierta: Boolean): ArrayList<Yaku> {
@@ -48,7 +45,7 @@ fun obtenerListaYakus(contenedorGrupos: ContenedorGrupos, esManoAbierta: Boolean
         return arrayListOf()
     }
 
-    // 10 puntos
+    // 15 puntos
     if (yakuDragonesFull(contenedorGrupos)) {
         listaYakus.add(Yaku.DragonesFull)
         return listaYakus
@@ -58,7 +55,7 @@ fun obtenerListaYakus(contenedorGrupos: ContenedorGrupos, esManoAbierta: Boolean
         return listaYakus
     }
 
-    // 7 puntos
+    // 10 puntos
     if (yakuRealezaDragones(contenedorGrupos)) {
         listaYakus.add(Yaku.RealezaDragones)
         return listaYakus
@@ -69,9 +66,6 @@ fun obtenerListaYakus(contenedorGrupos: ContenedorGrupos, esManoAbierta: Boolean
     }
 
     // 5 puntos
-    // TODO
-
-    // 3 puntos
     if (yakuExterior(contenedorGrupos)) {
         listaYakus.add(Yaku.Exterior)
     }
@@ -86,10 +80,11 @@ fun obtenerListaYakus(contenedorGrupos: ContenedorGrupos, esManoAbierta: Boolean
     var verificarTripleTriples = true
     if (!esManoAbierta && yakuTripleTriples(contenedorGrupos)) {
         listaYakus.add(Yaku.TripleTriplesCerrados)
+        listaYakus.add(Yaku.TripleTriples)
         verificarTripleTriples = false
     }
 
-    // 2 puntos
+    // 4 puntos
     if (yakuSemiExterior(contenedorGrupos)) {
         listaYakus.add(Yaku.SemiExterior)
     }
@@ -99,18 +94,24 @@ fun obtenerListaYakus(contenedorGrupos: ContenedorGrupos, esManoAbierta: Boolean
     if (yakuNegro(contenedorGrupos)) {
         listaYakus.add(Yaku.Negro)
     }
+    if (yakuTripleCuadruples(contenedorGrupos)) {
+        listaYakus.add(Yaku.TripleCuadruples)
+    }
     if (verificarEscalera && yakuEscalera(contenedorGrupos)) {
         listaYakus.add(Yaku.Escalera)
     }
 
-    // 1 punto
-    if (yakuDobleSecuencia(contenedorGrupos)) {
-        listaYakus.add(Yaku.DobleSecuencia)
+    // 3 puntos
+    if (yakuDobleSecuenciaPura(contenedorGrupos)) {
+        listaYakus.add(Yaku.DobleSecuenciaPura)
     }
     val cantidad = yakuRealeza(contenedorGrupos)
     if (cantidad > 0) {
         listaYakus.add(Yaku.Realeza)
     }
+    if (!esManoAbierta && yakuTripleSecuenciaCerrada(contenedorGrupos)) {
+        listaYakus.add(Yaku.TripleSecuenciaCerrada)
+    }
     if (verificarTripleTriples && yakuTripleTriples(contenedorGrupos)) {
         listaYakus.add(Yaku.TripleTriples)
     }
@@ -121,8 +122,8 @@ fun obtenerListaYakus(contenedorGrupos: ContenedorGrupos, esManoAbierta: Boolean
     if (cantidadDragon > 0) {
         listaYakus.add(Yaku.Dragones)
     }
-    if (!esManoAbierta) {
-        listaYakus.add(Yaku.ManoCerrada)
+    if (yakuParUnico(contenedorGrupos)) {
+        listaYakus.add(Yaku.ParUnico)
     }
 
     return listaYakus

src/juego/yaku/yaku1.kt

@@ -1,56 +0,0 @@
-package dev.araozu.juego.yaku
-
-import dev.araozu.juego.CartaNumero
-import dev.araozu.juego.ContenedorGrupos
-
-// TODO
-internal fun yakuDobleSecuencia(contenedorGrupos: ContenedorGrupos): Boolean {
-
-    return false
-}
-
-internal fun yakuRealeza(contenedorGrupos: ContenedorGrupos): Int {
-    var cantidadRealeza = 0
-    for (carrl in contenedorGrupos.tris) {
-        val cartaTri = carrl[0]
-        if (cartaTri.esRey()) cantidadRealeza++
-    }
-
-    return cantidadRealeza
-}
-
-internal fun yakuTripleTriples(contenedorGrupos: ContenedorGrupos) =
-    contenedorGrupos.tris.size == 3
-
-internal fun yakuInterior(contenedorGrupos: ContenedorGrupos): Boolean {
-
-    for (carrl in contenedorGrupos.seqs) {
-        for (c in carrl) {
-            if (c !is CartaNumero) return false
-            if (c.esExterior()) return false
-        }
-    }
-
-    for (carrl in contenedorGrupos.tris) {
-        for (c in carrl) {
-            if (c !is CartaNumero) return false
-            if (c.esExterior()) return false
-        }
-    }
-
-    for (carrl in contenedorGrupos.pares) {
-        for (c in carrl) {
-            if (c !is CartaNumero) return false
-            if (c.esExterior()) return false
-        }
-    }
-
-    return true
-}
-
-// TODO
-internal fun yakuDragones(contenedorGrupos: ContenedorGrupos): Int {
-
-    return 0
-}
-

src/juego/yaku/yaku10.kt

@@ -1,42 +1,36 @@
 package dev.araozu.juego.yaku
 
-import dev.araozu.juego.CartaDragon
+import dev.araozu.juego.CartaRealeza
 import dev.araozu.juego.ContenedorGrupos
 
-internal fun yakuDragonesFull(contenedorGrupos: ContenedorGrupos): Boolean {
+internal fun yakuRealezaDragones(contenedorGrupos: ContenedorGrupos): Boolean {
 
     if (contenedorGrupos.tris.size != 3) return false
 
     for (carrl in contenedorGrupos.tris) {
         for (c in carrl) {
-            if (c !is CartaDragon) return false
+            if (!c.esDragonORey()) return false
         }
     }
 
     for (carrl in contenedorGrupos.pares) {
         for (c in carrl) {
-            if (c !is CartaDragon) return false
+            if (!c.esDragonORey()) return false
         }
     }
 
     return true
 }
 
-internal fun yakuVerde(contenedorGrupos: ContenedorGrupos): Boolean {
+internal fun yakuRealezaFull(contenedorGrupos: ContenedorGrupos): Boolean {
 
     if (contenedorGrupos.tris.size != 3) return false
 
     for (carrl in contenedorGrupos.tris) {
         for (c in carrl) {
-            if (!c.esCartaVerde()) return false
+            if (c !is CartaRealeza) return false
         }
     }
 
-    for (carrl in contenedorGrupos.pares) {
-        for (c in carrl) {
-            if (!c.esCartaVerde()) return false
-        }
-    }
-
-    return true
+    return false
 }

src/juego/yaku/yaku15.kt

@@ -0,0 +1,42 @@
+package dev.araozu.juego.yaku
+
+import dev.araozu.juego.CartaDragon
+import dev.araozu.juego.ContenedorGrupos
+
+internal fun yakuDragonesFull(contenedorGrupos: ContenedorGrupos): Boolean {
+
+    if (contenedorGrupos.tris.size != 3) return false
+
+    for (carrl in contenedorGrupos.tris) {
+        for (c in carrl) {
+            if (c !is CartaDragon) return false
+        }
+    }
+
+    for (carrl in contenedorGrupos.pares) {
+        for (c in carrl) {
+            if (c !is CartaDragon) return false
+        }
+    }
+
+    return true
+}
+
+internal fun yakuVerde(contenedorGrupos: ContenedorGrupos): Boolean {
+
+    if (contenedorGrupos.tris.size != 3) return false
+
+    for (carrl in contenedorGrupos.tris) {
+        for (c in carrl) {
+            if (!c.esCartaVerde()) return false
+        }
+    }
+
+    for (carrl in contenedorGrupos.pares) {
+        for (c in carrl) {
+            if (!c.esCartaVerde()) return false
+        }
+    }
+
+    return true
+}

src/juego/yaku/yaku3.kt

@@ -3,24 +3,66 @@ package dev.araozu.juego.yaku
 import dev.araozu.juego.CartaNumero
 import dev.araozu.juego.ContenedorGrupos
 
-internal fun yakuExterior(contenedorGrupos: ContenedorGrupos): Boolean {
+// TODO
+internal fun yakuDobleSecuenciaPura(contenedorGrupos: ContenedorGrupos): Boolean {
 
-    if (contenedorGrupos.tris.size != 3) return false
+    return false
+}
+
+internal fun yakuRealeza(contenedorGrupos: ContenedorGrupos): Int {
+    var cantidadRealeza = 0
+    for (carrl in contenedorGrupos.tris) {
+        val cartaTri = carrl[0]
+        if (cartaTri.esRey()) cantidadRealeza++
+    }
+
+    return cantidadRealeza
+}
+
+internal fun yakuTripleSecuenciaCerrada(contenedorGrupos: ContenedorGrupos) =
+    contenedorGrupos.tris.size == 3
+
+internal fun yakuTripleTriples(contenedorGrupos: ContenedorGrupos) =
+    contenedorGrupos.tris.size == 3
+
+internal fun yakuInterior(contenedorGrupos: ContenedorGrupos): Boolean {
+
+    for (carrl in contenedorGrupos.seqs) {
+        for (c in carrl) {
+            if (c !is CartaNumero) return false
+            if (c.esExterior()) return false
+        }
+    }
 
     for (carrl in contenedorGrupos.tris) {
         for (c in carrl) {
-            if (!c.esDragonORey() || c !is CartaNumero || !c.esExterior())
-                return false
+            if (c !is CartaNumero) return false
+            if (c.esExterior()) return false
         }
     }
 
     for (carrl in contenedorGrupos.pares) {
         for (c in carrl) {
-            if (!c.esDragonORey() || c !is CartaNumero || !c.esExterior())
-                return false
+            if (c !is CartaNumero) return false
+            if (c.esExterior()) return false
         }
     }
 
     return true
 }
 
+// TODO
+internal fun yakuDragones(contenedorGrupos: ContenedorGrupos): Int {
+
+    return 0
+}
+
+internal fun yakuParUnico(contenedorGrupos: ContenedorGrupos): Boolean {
+    val par = contenedorGrupos.pares[0]
+    val c1 = par[0]
+    val c2 = par[1]
+
+    if (c1 !is CartaNumero || c2 !is CartaNumero) return false
+
+    return c1.valor == c2.valor
+}

src/juego/yaku/yaku4.kt

@@ -3,11 +3,6 @@ package dev.araozu.juego.yaku
 import dev.araozu.juego.CartaNumero
 import dev.araozu.juego.ContenedorGrupos
 
-internal fun yakuDobleSecuenciaPura(contenedorGrupos: ContenedorGrupos): Boolean {
-
-    return false
-}
-
 internal fun yakuSemiExterior(contenedorGrupos: ContenedorGrupos): Boolean {
 
     for (carrl in contenedorGrupos.seqs) {
@@ -89,6 +84,17 @@ internal fun yakuNegro(contenedorGrupos: ContenedorGrupos): Boolean {
     return true
 }
 
+internal fun yakuTripleCuadruples(contenedorGrupos: ContenedorGrupos): Boolean {
+
+    if (contenedorGrupos.tris.size != 3) return false
+
+    for (triple in contenedorGrupos.tris) {
+        if (triple.size != 4) return false
+    }
+
+    return true
+}
+
 // TODO: Las secuencias pueden no estar en orden
 internal fun yakuEscalera(contenedorGrupos: ContenedorGrupos): Boolean {
 

src/juego/yaku/yaku5.kt

@@ -3,6 +3,26 @@ package dev.araozu.juego.yaku
 import dev.araozu.juego.CartaNumero
 import dev.araozu.juego.ContenedorGrupos
 
+internal fun yakuExterior(contenedorGrupos: ContenedorGrupos): Boolean {
+
+    if (contenedorGrupos.tris.size != 3) return false
+
+    for (carrl in contenedorGrupos.tris) {
+        for (c in carrl) {
+            if (!c.esDragonORey() || c !is CartaNumero || !c.esExterior())
+                return false
+        }
+    }
+
+    for (carrl in contenedorGrupos.pares) {
+        for (c in carrl) {
+            if (!c.esDragonORey() || c !is CartaNumero || !c.esExterior())
+                return false
+        }
+    }
+
+    return true
+}
 
 // TODO: Las secuencias pueden no estar en orden
 internal fun yakuEscaleraFull(contenedorGrupos: ContenedorGrupos): Boolean {
@@ -37,3 +57,4 @@ internal fun yakuEscaleraFull(contenedorGrupos: ContenedorGrupos): Boolean {
 
     return true
 }
+

src/juego/yaku/yaku7.kt

@@ -1,46 +0,0 @@
-package dev.araozu.juego.yaku
-
-import dev.araozu.juego.CartaRealeza
-import dev.araozu.juego.ContenedorGrupos
-
-internal fun yakuA10(contenedorGrupos: ContenedorGrupos): Boolean {
-
-    return false
-}
-
-internal fun yakuEscaleraPerfecta(contenedorGrupos: ContenedorGrupos): Boolean {
-
-    return false
-}
-
-internal fun yakuRealezaDragones(contenedorGrupos: ContenedorGrupos): Boolean {
-
-    if (contenedorGrupos.tris.size != 3) return false
-
-    for (carrl in contenedorGrupos.tris) {
-        for (c in carrl) {
-            if (!c.esDragonORey()) return false
-        }
-    }
-
-    for (carrl in contenedorGrupos.pares) {
-        for (c in carrl) {
-            if (!c.esDragonORey()) return false
-        }
-    }
-
-    return true
-}
-
-internal fun yakuRealezaFull(contenedorGrupos: ContenedorGrupos): Boolean {
-
-    if (contenedorGrupos.tris.size != 3) return false
-
-    for (carrl in contenedorGrupos.tris) {
-        for (c in carrl) {
-            if (c !is CartaRealeza) return false
-        }
-    }
-
-    return true
-}

src/tests/Yaku10Test.kt

@@ -1,46 +0,0 @@
-package dev.araozu.tests
-
-import dev.araozu.juego.*
-import dev.araozu.juego.yaku.Yaku
-
-fun testYakuVerde(): Boolean {
-    val cartasMano = carr(
-        CartaDragonVerde(),
-        CartaDragonVerde(),
-        CartaRealezaJ(),
-        CartaRealezaJ(),
-        CartaRealezaK(),
-        CartaRealezaK(),
-        CartaRealezaK(),
-        CartaRealezaQ(),
-        CartaRealezaQ(),
-        CartaRealezaQ()
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = c(CartaDragonVerde()),
-        cartasMano = cartasMano
-    )
-
-    return existeYaku(op, Yaku.Verde)
-}
-
-fun testYakuDragonesFull(): Boolean {
-    val cartas = carr(
-        CartaDragonVerde(),
-        CartaDragonAzul(),
-        CartaDragonAzul(),
-        CartaDragonAzul(),
-        CartaDragonRojo(),
-        CartaDragonRojo(),
-        CartaDragonRojo(),
-        CartaDragonNegro(),
-        CartaDragonNegro(),
-        CartaDragonNegro()
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = c(CartaDragonVerde()),
-        cartasMano = cartas
-    )
-
-    return existeYaku(op, Yaku.DragonesFull)
-}

src/tests/Yaku1Test.kt

@@ -1,60 +0,0 @@
-package dev.araozu.tests
-
-import dev.araozu.juego.*
-import dev.araozu.juego.yaku.Yaku
-
-fun testYakuDobleSecuencia(): Boolean {
-    val cartas = arrayListOf(
-        10, 11, 12, 12, 14, 15, 52, 52, 192, 192
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 52,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.DobleSecuencia)
-}
-
-fun testYakuRealeza(): Boolean {
-    val cartas = arrayListOf(
-        6, 8, 10, 40, 42, 44, 96, 96, 256, 256
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 256,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.Realeza)
-}
-
-fun testYakuTripleTriples(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        2,
-        3,
-        20,
-        20,
-        96,
-        96
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 96,
-        cartasMano = cartas,
-        gruposAbiertos = arrayListOf(
-            arrayListOf(34, 34, 35)
-        )
-    )
-    return existeYaku(op, Yaku.TripleTriples)
-}
-
-fun testYakuInterior(): Boolean {
-    val cartas = arrayListOf(
-        4, 6, 8, 6, 8, 10, 48
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 48,
-        cartasMano = cartas,
-        gruposAbiertos = arrayListOf(
-            arrayListOf(44, 44, 45)
-        )
-    )
-    return existeYaku(op, Yaku.Interior)
-}

src/tests/Yaku2Test.kt

@@ -1,86 +0,0 @@
-package dev.araozu.tests
-
-import dev.araozu.juego.*
-import dev.araozu.juego.yaku.Yaku
-
-fun testYakuDobleSecuenciaPura(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        2,
-        4,
-        4,
-        6,
-        6,
-        34,
-        34,
-        35,
-        96
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 96,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.DobleSecuenciaPura)
-}
-
-fun testYakuSemiExterior(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        4,
-        6,
-        20,
-        20,
-        34,
-        36,
-        38,
-        96,
-        96
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 96,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.SemiExterior)
-}
-
-fun testYakuRojo(): Boolean {
-    val cartas = arrayListOf(
-        38,
-        38,
-        38,
-        52,
-        52,
-        34,
-        34,
-        35,
-        c(CartaDragonRojo()),
-        c(CartaDragonRojo())
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = c(CartaDragonRojo()),
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.Rojo)
-}
-
-fun testYakuNegro(): Boolean {
-    val cartas = arrayListOf(
-        2, 2, 2, 10, 10, 10, 16, 16, 20, 20
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 20,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.Negro)
-}
-
-fun testYakuEscalera(): Boolean {
-    val cartas = arrayListOf(
-        2, 4, 6, 8, 10, 12, 14, 16, 18, 96
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 96,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.Escalera)
-}

src/tests/Yaku3Test.kt

@@ -1,44 +0,0 @@
-package dev.araozu.tests
-
-import dev.araozu.juego.*
-import dev.araozu.juego.yaku.Yaku
-
-fun testYakuExterior(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        2,
-        3,
-        20,
-        20,
-        34,
-        34,
-        35,
-        96,
-        96
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 96,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.Exterior)
-}
-
-fun testYakuTripleTriplesCerrados(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        2,
-        3,
-        20,
-        20,
-        34,
-        34,
-        35,
-        96,
-        96
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 96,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.TripleTriplesCerrados)
-}

src/tests/Yaku5Test.kt

@@ -1,24 +0,0 @@
-package dev.araozu.tests
-
-import dev.araozu.juego.*
-import dev.araozu.juego.yaku.Yaku
-
-fun testYakuEscaleraFull(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        3,
-        4,
-        6,
-        8,
-        10,
-        13,
-        14,
-        16,
-        18
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 20,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.EscaleraFull)
-}

src/tests/Yaku7Test.kt

@@ -1,84 +0,0 @@
-package dev.araozu.tests
-
-import dev.araozu.juego.*
-import dev.araozu.juego.yaku.Yaku
-
-fun testYakuA10(): Boolean {
-    val cartasMano = arrayListOf(
-        2,
-        2,
-        3,
-        20,
-        20,
-        21,
-        34,
-        34,
-        52,
-        52
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 35,
-        cartasMano = cartasMano
-    )
-    return existeYaku(op, Yaku.A10)
-}
-
-fun testYakuEscaleraPerfecta(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        2,
-        4,
-        6,
-        8,
-        10,
-        12,
-        14,
-        16,
-        18
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 20,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.EscaleraPerfecta)
-}
-
-fun testYakuRealezaFull(): Boolean {
-    val cartas = arrayListOf(
-        2,
-        192,
-        192,
-        192,
-        224,
-        224,
-        224,
-        256,
-        256,
-        256
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 2,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.RealezaFull)
-}
-
-fun testYakuRealezaDragones(): Boolean {
-    val cartas = arrayListOf(
-        256,
-        64,
-        64,
-        64,
-        128,
-        128,
-        128,
-        192,
-        192,
-        192
-    )
-    val op = OportunidadRon.verificar(
-        valorCarta = 256,
-        cartasMano = cartas
-    )
-    return existeYaku(op, Yaku.RealezaDragones)
-}

src/tests/YakuTest.kt

@@ -1,53 +0,0 @@
-package dev.araozu.tests
-
-import dev.araozu.juego.*
-import dev.araozu.juego.yaku.Yaku
-
-fun c(c: Carta): Int = c.valor
-fun carr(vararg carr: Carta): ArrayList<Int> {
-    val cartas = arrayListOf<Int>()
-    cartas.addAll(carr.map(::c))
-    return cartas
-}
-
-fun existeYaku(op: OportunidadRon?, yaku: Yaku): Boolean {
-    if (op == null) return false
-    return null != op.yaku.find { it == yaku }
-}
-
-fun impErr(res: Boolean, nombreYaku: String) {
-    if (!res) System.err.println("Error al ejecutar yaku $nombreYaku")
-}
-
-fun main() {
-    // Yaku10
-    impErr(testYakuVerde(), "Verde")
-    impErr(testYakuDragonesFull(), "Dragones Full")
-
-    // Yaku7
-    impErr(testYakuA10(), "A-10")
-    impErr(testYakuEscaleraPerfecta(), "Escalera Perfecta")
-    impErr(testYakuRealezaFull(), "Realeza Full")
-    impErr(testYakuRealezaDragones(), "Realeza y Dragones")
-
-    // Yaku5
-    impErr(testYakuEscaleraFull(), "Escalera Full")
-
-    // Yaku3
-    impErr(testYakuExterior(), "Exterior")
-    impErr(testYakuTripleTriplesCerrados(), "Triple Triples Cerrados")
-
-    // Yaku2
-    impErr(testYakuDobleSecuenciaPura(), "Doble Secuencia Pura")
-    impErr(testYakuSemiExterior(), "Semi Exterior")
-    impErr(testYakuRojo(), "Rojo")
-    impErr(testYakuNegro(), "Negro")
-    impErr(testYakuEscalera(), "Escalera")
-
-    // Yaku1
-    impErr(testYakuDobleSecuencia(), "Doble Secuencia")
-    impErr(testYakuRealeza(), "Realeza")
-    impErr(testYakuTripleTriples(), "Triple Triples")
-    impErr(testYakuInterior(), "Interior")
-
-}