From 3e193a71a6820c04afbd074626d8bdc7c6b11063 Mon Sep 17 00:00:00 2001 From: Araozu Date: Tue, 20 Oct 2020 12:47:34 -0500 Subject: [PATCH] Creada clase ContenedorGrupos.kt que almacena los tris, seq, pares y huerfanos de una mano. --- src/juego/ContenedorGrupos.kt | 52 ++++++++++++++++++++++++++ src/juego/OportunidadWin.kt | 69 ++++++++++++++++++++++++++--------- 2 files changed, 103 insertions(+), 18 deletions(-) create mode 100644 src/juego/ContenedorGrupos.kt diff --git a/src/juego/ContenedorGrupos.kt b/src/juego/ContenedorGrupos.kt new file mode 100644 index 0000000..4722dd5 --- /dev/null +++ b/src/juego/ContenedorGrupos.kt @@ -0,0 +1,52 @@ +package dev.araozu.juego + +import com.sun.org.apache.xpath.internal.operations.Bool + +class ContenedorGrupos( + private val tris: ArrayList>, + private val seqs: ArrayList>, + private val pares: ArrayList>, + private val huerfanos: ArrayList +) { + + constructor () : this( + arrayListOf>(), + arrayListOf>(), + arrayListOf>(), + arrayListOf() + ) { + } + + fun agregarDesdeContenedor(c: ContenedorGrupos) { + tris.addAll(c.tris) + seqs.addAll(c.seqs) + pares.addAll(c.pares) + huerfanos.addAll(c.huerfanos) + } + + fun agregarSeqs(s: ArrayList>) { + seqs.addAll(s) + } + + fun agregarTris(a: ArrayList>) { + tris.addAll(a) + } + + fun agregarPares(a: ArrayList>) { + pares.addAll(a) + } + + fun agregarHuerfanos(a: ArrayList) { + for (c in a) { + huerfanos.add(c) + } + } + + fun heuristic(): Int = + tris.size + seqs.size + (if (pares.size <= 1) 1 else 0) - huerfanos.size + + fun estaListo(): Boolean = + pares.size == 1 && huerfanos.size == 0 + + +} diff --git a/src/juego/OportunidadWin.kt b/src/juego/OportunidadWin.kt index 3c2c2ea..0ca55f8 100644 --- a/src/juego/OportunidadWin.kt +++ b/src/juego/OportunidadWin.kt @@ -6,10 +6,9 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad { companion object { - private fun ArrayList.cartaExisteEnArrl(valorCarta: Int): Boolean { + private fun ArrayList.cartaExisteEnArrl(valorCarta: Int): Boolean { for (c in this) { - val valorCartaParActual = (c.valor ushr 1) shl 1 - if (valorCartaParActual == valorCarta) return true + if (valorCarta == c.numero) return true } return false } @@ -26,7 +25,18 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad { throw Error("El valor de la carta no existe en el array.") } - private fun obtTri(cartas: ArrayList): ArrayList> { + private fun ArrayList.eliminarCartaNumero(valorCarta: Int): CartaNumero { + for (c in this) { + if (c.numero == valorCarta) { + this.remove(c) + return c + } + } + + throw Error("El valor de la carta no existe en el array.") + } + + private fun obtTri(cartas: ArrayList): ArrayList> { val arrlR = arrayListOf>() var i = 0 while (i + 2 < cartas.size) { @@ -47,7 +57,7 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad { return arrlR } - private fun obtPar(cartas: ArrayList): ArrayList> { + private fun obtPar(cartas: ArrayList): ArrayList> { val arrlR = arrayListOf>() var i = 0 while (i + 2 < cartas.size) { @@ -66,20 +76,20 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad { return arrlR } - private fun obtSeq1(cartas: ArrayList): ArrayList> { - val arrlCartas = arrayListOf>() + private fun obtSeq1(cartas: ArrayList): ArrayList> { + val arrlCartas = arrayListOf>() var i = 0 while (i < cartas.size) { val primeraCarta = cartas[i] - val valorCartaPar = (primeraCarta.valor ushr 1) shl 1 + val valorCartaPar = primeraCarta.numero if ( cartas.cartaExisteEnArrl(valorCartaPar + 1) && cartas.cartaExisteEnArrl(valorCartaPar + 2) ) { - val c1 = cartas.eliminarCarta(valorCartaPar) - val c2 = cartas.eliminarCarta(valorCartaPar + 1) - val c3 = cartas.eliminarCarta(valorCartaPar + 2) + val c1 = cartas.eliminarCartaNumero(valorCartaPar) + val c2 = cartas.eliminarCartaNumero(valorCartaPar + 1) + val c3 = cartas.eliminarCartaNumero(valorCartaPar + 2) arrlCartas.add(arrayListOf(c1, c2, c3)) } else { i++ @@ -113,24 +123,47 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad { return arrlCartas } - private fun obtenerPosiblesSeq(cartas: ArrayList): Pair>, ArrayList>> { + private fun obtenerContenedorCartasNumero(cartas: ArrayList): ContenedorGrupos { val cartas2 = ArrayList(cartas.size) cartas2.addAll(cartas) - val seqOrden1 = obtSeq1(cartas) - val seqOrden2 = obtSeq2(cartas) + val contenedor1 = ContenedorGrupos() + contenedor1.agregarSeqs(obtSeq1(cartas)) + contenedor1.agregarTris(obtTri(cartas)) + contenedor1.agregarPares(obtPar(cartas)) + contenedor1.agregarHuerfanos(cartas) - return Pair(seqOrden1, seqOrden2) + val contenedor2 = ContenedorGrupos() + contenedor2.agregarSeqs(obtSeq1(cartas2)) + contenedor2.agregarTris(obtTri(cartas2)) + contenedor2.agregarPares(obtPar(cartas2)) + contenedor2.agregarHuerfanos(cartas2) + + val valorCont1 = contenedor1.heuristic() + val valorCont2 = contenedor2.heuristic() + + return if (valorCont1 > valorCont2) contenedor1 else contenedor2 } - fun verificar(valorCarta: Int, cartasMano: ArrayList, numGruposAbiertos: Int = 0) { - val narrl = arrayListOf() + fun verificar(valorCarta: Int, cartasMano: ArrayList) { + val narrl = ArrayList(cartasMano.size + 1) narrl.addAll(cartasMano) narrl.add(valorCarta) val (cartasRojo, cartasRestantes1) = CartaNumero.separarCartasRojo(narrl) val (cartasNegro, cartasRestantes2) = CartaNumero.separarCartasNegro(cartasRestantes1) - val restoCartas = cartasRestantes2.map { Carta.obtenerCartaEspecifica(it) } + val restoCartas = arrayListOf() + restoCartas.addAll(cartasRestantes2.map { Carta.obtenerCartaEspecifica(it) }) + + val contenedorGrupos = ContenedorGrupos() + + // Obtener tris y pares de las cartas que no son numeros + contenedorGrupos.agregarTris(obtTri(restoCartas)) + contenedorGrupos.agregarPares(obtPar(restoCartas)) + + // Obtener tris, pares y seq de las cartas de numeros + contenedorGrupos.agregarDesdeContenedor(obtenerContenedorCartasNumero(cartasRojo)) + contenedorGrupos.agregarDesdeContenedor(obtenerContenedorCartasNumero(cartasNegro)) }