From 7dce867e02103dfd935335a6429a98b3d2f3ff1d Mon Sep 17 00:00:00 2001
From: Araozu <faraoz@unsa.edu.pe>
Date: Mon, 5 Oct 2020 20:15:54 -0500
Subject: [PATCH] =?UTF-8?q?Agregada=20clase=20para=20manejar=20la=20verifi?=
 =?UTF-8?q?caci=C3=B3n=20de=20Secuencias?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/juego/Carta.kt          | 59 +++++++++++++++++++++++++++++++++++++
 src/juego/Oportunidad.kt    |  1 -
 src/juego/OportunidadSeq.kt | 43 +++++++++++++++++++++++++--
 src/juego/OportunidadTri.kt |  2 +-
 4 files changed, 101 insertions(+), 4 deletions(-)
 create mode 100644 src/juego/Carta.kt

diff --git a/src/juego/Carta.kt b/src/juego/Carta.kt
new file mode 100644
index 0000000..470e1c1
--- /dev/null
+++ b/src/juego/Carta.kt
@@ -0,0 +1,59 @@
+package dev.araozu.juego
+
+import kotlin.reflect.KClass
+
+sealed class Carta(private val valor: Int) {
+    companion object {
+        fun obtenerCartaEspecifica(valor: Int): Carta {
+            return when (valor) {
+                in 2..21 -> CartaNumeroNegro(valor)
+                in 34..53 -> CartaNumeroRojo(valor)
+                64 -> CartaDragonNegro()
+                96 -> CartaDragonRojo()
+                128 -> CartaDragonVerde()
+                160 -> CartaDragonAzul()
+                192 -> CartaRealezaJ()
+                224 -> CartaRealezaQ()
+                256 -> CartaRealezaK()
+                else -> {
+                    throw IllegalArgumentException("Valor de carta ilegal.")
+                }
+            }
+        }
+
+        /**
+         * 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>()
+
+            valores.forEach {
+                val carta = obtenerCartaEspecifica(it)
+                if (carta::class == clase) arrl.add(carta as T)
+            }
+
+            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)
+
+sealed class CartaDragon(valor: Int) : Carta(valor)
+
+class CartaDragonNegro : CartaDragon(64)
+class CartaDragonRojo : CartaDragon(96)
+class CartaDragonVerde : CartaDragon(128)
+class CartaDragonAzul : CartaDragon(160)
+
+sealed class CartaRealeza(valor: Int) : Carta(valor)
+
+class CartaRealezaJ : CartaRealeza(192)
+class CartaRealezaQ : CartaRealeza(224)
+class CartaRealezaK : CartaRealeza(256)
diff --git a/src/juego/Oportunidad.kt b/src/juego/Oportunidad.kt
index 6c814c1..8f2e16c 100644
--- a/src/juego/Oportunidad.kt
+++ b/src/juego/Oportunidad.kt
@@ -3,6 +3,5 @@ package dev.araozu.juego
 interface Oportunidad {
 
     val cartaDescartada: Int
-    val cartasOportunidad: ArrayList<Int>
 
 }
diff --git a/src/juego/OportunidadSeq.kt b/src/juego/OportunidadSeq.kt
index 2b34ea1..f8f7b02 100644
--- a/src/juego/OportunidadSeq.kt
+++ b/src/juego/OportunidadSeq.kt
@@ -1,4 +1,43 @@
 package dev.araozu.juego
 
-data class OportunidadSeq(override val cartaDescartada: Int, override val cartasOportunidad: ArrayList<Int>) :
-    Oportunidad
+data class OportunidadSeq(override val cartaDescartada: Int, val combinaciones: ArrayList<Pair<Int, Int>>) :
+    Oportunidad {
+
+    companion object {
+
+        private fun arrlCartasContiene(arrl: ArrayList<CartaNumero>, 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 (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)
+
+                    val arrlRetorno = arrayListOf<Pair<Int, Int>>()
+
+                    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
+            }
+
+        }
+    }
+
+}
diff --git a/src/juego/OportunidadTri.kt b/src/juego/OportunidadTri.kt
index 3365f22..4044db5 100644
--- a/src/juego/OportunidadTri.kt
+++ b/src/juego/OportunidadTri.kt
@@ -1,4 +1,4 @@
 package dev.araozu.juego
 
-data class OportunidadTri(override val cartaDescartada: Int, override val cartasOportunidad: ArrayList<Int>) :
+data class OportunidadTri(override val cartaDescartada: Int) :
     Oportunidad