Se agrego el proyecto final poker. se utilizo random para cargar las cartas y…

Se agrego el proyecto final poker. se utilizo random para cargar las cartas y las jugadas para cada mano que en este caso es 2 jugadores pero puede agregarse mas manualmente

Se agrego el proyecto final poker. se utilizo random para cargar las cartas y…
Se agrego el proyecto final poker. se utilizo random para cargar las cartas y las jugadas para cada mano que en este caso es 2 jugadores pero puede agregarse mas manualmente
b0c4569a · Miguel Do Carmo · 0c01a638 · 0c01a638 · b0c4569a · 0c01a638
Commit b0c4569a authored Apr 22, 2020 by Miguel Do Carmo
8 changed files
--- a/out/production/tp-kotlin-miguel/CartaJugada.class
+++ b/out/production/tp-kotlin-miguel/CartaJugada.class
--- a/out/production/tp-kotlin-miguel/META-INF/tp-kotlin-miguel.kotlin_module
+++ b/out/production/tp-kotlin-miguel/META-INF/tp-kotlin-miguel.kotlin_module
--- a/out/production/tp-kotlin-miguel/PokerKt$main$$inlined$compareBy$1.class
+++ b/out/production/tp-kotlin-miguel/PokerKt$main$$inlined$compareBy$1.class
--- a/out/production/tp-kotlin-miguel/PokerKt$main$$inlined$compareBy$2.class
+++ b/out/production/tp-kotlin-miguel/PokerKt$main$$inlined$compareBy$2.class
--- a/out/production/tp-kotlin-miguel/PokerKt.class
+++ b/out/production/tp-kotlin-miguel/PokerKt.class
--- a/out/production/tp-kotlin-miguel/codigos/Const.class
+++ b/out/production/tp-kotlin-miguel/codigos/Const.class
--- a/src/codigos/Const.kt
+++ b/src/codigos/Const.kt
@@ -4,4 +4,7 @@ object Const {
    val PALOS = arrayOf(
        'S','D','H','C'
    )
+    var MESA = Array(4) { arrayOf(0,0,0,0,0,0,0,0,0,0,0,0,0) }
 }
\ No newline at end of file
--- a/src/codigos/poker.kt
+++ b/src/codigos/poker.kt
-import codigos.Const
+package codigos
+import kotlin.random.Random
-/************Data class es una clase especial de KOTLIN que
- * te abstrae de los getters y setters o implementa automaticamente**/
 data class CartaJugada(val valor: Char, val palo: Char)
 fun main() {
-    val jugada = arrayListOf<CartaJugada>()
+    println("  A  2  3  4  5  6  7  8  9  T  J  Q  K")
-    val jugada2 = arrayListOf<CartaJugada>()
+    jugadaMesa()
-    var CartajugadasMesa : String
-    var Carta2jugadasMesa : String
+    val jugada1 = decodificar(1)
-    println("Primera jugada:")
+    val jugada2 = decodificar(2)
-    do {
-        CartajugadasMesa = readLine()!!.toString().toUpperCase()
-    }while (valido(CartajugadasMesa))
-    println("Segunda jugada:")
-    do {
-        Carta2jugadasMesa = readLine()!!.toString().toUpperCase()
-    }while (valido(Carta2jugadasMesa))
    /*********Analiza Jugada************/
-    jugada.add(CartaJugada(valor = CartajugadasMesa[0], palo = CartajugadasMesa[1]))
-    jugada.add(CartaJugada(valor = CartajugadasMesa[2], palo = CartajugadasMesa[3]))
+    val jugada1Ordenada = jugada1.sortedWith(compareBy {it.valor})
-    jugada.add(CartaJugada(valor = CartajugadasMesa[4], palo = CartajugadasMesa[5]))
-    jugada.add(CartaJugada(valor = CartajugadasMesa[6], palo = CartajugadasMesa[7]))
-    jugada.add(CartaJugada(valor = CartajugadasMesa[8], palo = CartajugadasMesa[9]))
-    jugada2.add(CartaJugada(valor = Carta2jugadasMesa[0], palo = Carta2jugadasMesa[1]))
-    jugada2.add(CartaJugada(valor = Carta2jugadasMesa[2], palo = Carta2jugadasMesa[3]))
-    jugada2.add(CartaJugada(valor = Carta2jugadasMesa[4], palo = Carta2jugadasMesa[5]))
-    jugada2.add(CartaJugada(valor = Carta2jugadasMesa[6], palo = Carta2jugadasMesa[7]))
-    jugada2.add(CartaJugada(valor = Carta2jugadasMesa[8], palo = Carta2jugadasMesa[9]))
-    val jugadaOrdenada = jugada.sortedWith(compareBy {it.valor})
    val jugada2Ordenada = jugada2.sortedWith(compareBy {it.valor})
-    println("Judada 1")
-    for (indice in jugadaOrdenada.indices)
-    {
-        print("${jugadaOrdenada[indice].valor}${jugadaOrdenada[indice].palo} ")
-    }
-    println("\nJudada 2")
-    for (indice in jugada2Ordenada.indices)
-    {
-        print("${jugada2Ordenada[indice].valor}${jugada2Ordenada[indice].palo} ")
-    }
-    val resultado1 = analizaJugadaOrdenada(jugadaOrdenada)
-    val resultado2 = analizaJugadaOrdenada(jugada2Ordenada)
+    val resultado1 = analizajugada1Ordenada(jugada1Ordenada)
-    println("\narchivo Poker Jugada 1 Leida: $CartajugadasMesa es un/a $resultado1")
+    val resultado2 = analizajugada1Ordenada(jugada2Ordenada)
-    println("archivo Poker Jugada 2 Leida: $Carta2jugadasMesa es un/a $resultado2")
-    println("La mano ganadora es: "+jugadaGanadora(jugadaOrdenada, jugada2Ordenada, resultado1, resultado2))
+    println("\nJugada 1 tiene -> $resultado1")
-}
+    jugada1Ordenada.forEach{data -> print("${data.valor}${data.palo} ")}
-fun valido(CartajugadasMesa : String) : Boolean{
+    println("\nJugada 2 tiene -> $resultado2")
-    var result  = true
+    jugada2Ordenada.forEach{data -> print("${data.valor}${data.palo} ")}
-    if (CartajugadasMesa.length == 10 && !encuentraRepetidos(CartajugadasMesa)) {
-        for (indice in 1..9 step 2) {
+    println("\nLa mano ganadora es: "+
-            result = !( CartajugadasMesa[indice] == Const.PALOS[0] ||
+            jugadaGanadora(jugada1Ordenada,resultado1,
-                    CartajugadasMesa[indice] == Const.PALOS[1] ||
+                jugada2Ordenada,resultado2)
-                    CartajugadasMesa[indice] == Const.PALOS[2] ||
+    )
-                    CartajugadasMesa[indice] == Const.PALOS[3])
-        }
-    }else {
-        println("INVALIDO.\nIngrese de nuevo: ")
-    }
-    return result
-}
-fun encuentraRepetidos(cartasMesa: String) : Boolean{
-    var mantieneCorrecto = false
-    for (caracteres in 0..4 step 2){
-        for (caracteresRepite in caracteres+2..8 step 2){
-            if ((cartasMesa[caracteres] == cartasMesa[caracteresRepite]) && (cartasMesa[caracteres+1] == cartasMesa[caracteresRepite+1])){
-                mantieneCorrecto = true
-            }
-        }
-    }
-    return mantieneCorrecto
 }
-fun analizaJugadaOrdenada(jugadaOrdenada : List<CartaJugada>): String{
-    var palosJugados = arrayOf(0,0,0,0)
+fun analizajugada1Ordenada(jugada1Ordenada : List<CartaJugada>): String{
-    var valoresJugados = arrayOf(0,0,0,0,0,0,0,0,0,0,0,0,0)
+    val palosJugados = arrayOf(0,0,0,0)
+    val valoresJugados = arrayOf(0,0,0,0,0,0,0,0,0,0,0,0,0)
    var result = "NADA"
-    for (palos in jugadaOrdenada){
+    for (palos in jugada1Ordenada){
        when(palos.palo){
            'S' -> palosJugados[0]++
            'C' -> palosJugados[1]++
@@ -86,7 +46,7 @@ fun analizaJugadaOrdenada(jugadaOrdenada : List<CartaJugada>): String{
            'H' -> palosJugados[3]++
        }
    }
-    for (valores in jugadaOrdenada){
+    for (valores in jugada1Ordenada){
        when(valores.valor){
            'A' -> valoresJugados[0]++
            '2' -> valoresJugados[1]++
@@ -152,62 +112,50 @@ fun analizaJugadaOrdenada(jugadaOrdenada : List<CartaJugada>): String{
    }
    return result
 }
-fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tipo1 :String, tipo2 : String) : String{
-    var ganador : String = "NINGUNO"
+fun cargarPalos(jugada : List<CartaJugada>) : Array<Int>{
-    var palosJugados1 = arrayOf(0,0,0,0)
+    val result = arrayOf(0,0,0,0)
-    var valoresJugados1 = arrayOf(0,0,0,0,0,0,0,0,0,0,0,0,0)
+    for (palos in jugada){
-    for (palos in jugada1){
-        when(palos.palo){
-            'S' -> palosJugados1[0]++
-            'C' -> palosJugados1[1]++
-            'D' -> palosJugados1[2]++
-            'H' -> palosJugados1[3]++
-        }
-    }
-    for (valores in jugada1){
-        when(valores.valor){
-            'A' -> valoresJugados1[0]++
-            '2' -> valoresJugados1[1]++
-            '3' -> valoresJugados1[2]++
-            '4' -> valoresJugados1[3]++
-            '5' -> valoresJugados1[4]++
-            '6' -> valoresJugados1[5]++
-            '7' -> valoresJugados1[6]++
-            '8' -> valoresJugados1[7]++
-            '9' -> valoresJugados1[8]++
-            'T' -> valoresJugados1[9]++
-            'J' -> valoresJugados1[10]++
-            'Q' -> valoresJugados1[11]++
-            'K' -> valoresJugados1[12]++
-        }
-    }
-    var palosJugados2 = arrayOf(0,0,0,0)
-    var valoresJugados2 = arrayOf(0,0,0,0,0,0,0,0,0,0,0,0,0)
-    for (palos in jugada2){
        when(palos.palo){
-            'S' -> palosJugados2[0]++
+            'S' -> result[0]++
-            'C' -> palosJugados2[1]++
+            'C' -> result[1]++
-            'D' -> palosJugados2[2]++
+            'D' -> result[2]++
-            'H' -> palosJugados2[3]++
+            'H' -> result[3]++
        }
    }
-    for (valores in jugada2){
+    return result
+}
+fun cargarValores(jugada : List<CartaJugada>) : Array<Int>{
+    val result = arrayOf(0,0,0,0,0,0,0,0,0,0,0,0,0)
+    for (valores in jugada){
        when(valores.valor){
-            'A' -> valoresJugados2[0]++
+            'A' -> result[0]++
-            '2' -> valoresJugados2[1]++
+            '2' -> result[1]++
-            '3' -> valoresJugados2[2]++
+            '3' -> result[2]++
-            '4' -> valoresJugados2[3]++
+            '4' -> result[3]++
-            '5' -> valoresJugados2[4]++
+            '5' -> result[4]++
-            '6' -> valoresJugados2[5]++
+            '6' -> result[5]++
-            '7' -> valoresJugados2[6]++
+            '7' -> result[6]++
-            '8' -> valoresJugados2[7]++
+            '8' -> result[7]++
-            '9' -> valoresJugados2[8]++
+            '9' -> result[8]++
-            'T' -> valoresJugados2[9]++
+            'T' -> result[9]++
-            'J' -> valoresJugados2[10]++
+            'J' -> result[10]++
-            'Q' -> valoresJugados2[11]++
+            'Q' -> result[11]++
-            'K' -> valoresJugados2[12]++
+            'K' -> result[12]++
        }
    }
+    return result
+}
+fun jugadaGanadora(jugada1 : List<CartaJugada>, tipo1 :String,
+                   jugada2 : List<CartaJugada>, tipo2 :String) : String{
+    var ganador = "NINGUNO"
+    val palosJugados1 = cargarPalos(jugada1)
+    val valoresJugados1 = cargarValores(jugada1)
+    val palosJugados2 = cargarPalos(jugada2)
+    val valoresJugados2 = cargarValores(jugada2)
    val jugadas: ArrayList<Int> = arrayListOf(0,0,0,0,0,0,0,0,0,0)
    when(tipo1){
        "ESCALERA REAL" -> jugadas[0]++
@@ -233,7 +181,8 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
        "PAREJA" -> jugadas[8]++
        "CARTA ALTA" -> jugadas[9]++
    }
-    var posGanador = -1
+    val posGanador: Int
    var segundo = 0
    loop@ for(casos in jugadas.indices){
        when(jugadas[casos]) {
@@ -255,6 +204,7 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                break@loop
            }
            2->{
+                //"NADA"
                when(casos){
                    0 -> { //"ESCALERA REAL"
                        ganador = "EMPATE"
@@ -264,6 +214,7 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        var kicker1 = 0
                        var kicker2 = 0
                        loopjugado1@ for (indice in valoresJugados1.indices) {
+                            print("${indice+1} ${valoresJugados1[indice]}, ")
                            if (valoresJugados1[indice] == 1) {
                                if (ultimo == 5) {
                                    kicker1 = indice
@@ -275,6 +226,7 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        ultimo = 1
                        println()
                        loopjugado2@ for (indice in valoresJugados2.indices){
+                            print("${indice+1} ${valoresJugados2[indice]}, ")
                            if (valoresJugados2[indice] == 1) {
                                if (ultimo == 5){
                                    kicker2 = indice
@@ -357,6 +309,7 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        var kicker1 = 0
                        var kicker2 = 0
                        loopjugado1@ for (indice in valoresJugados1.indices) {
+                            print("${indice+1} ${valoresJugados1[indice]}, ")
                            if (valoresJugados1[indice] == 1) {
                                if (ultimo == 5 || indice == 0) {
                                    kicker1 = indice
@@ -368,6 +321,7 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        ultimo = 1
                        println()
                        loopjugado2@ for (indice in valoresJugados2.indices){
+                            print("${indice+1} ${valoresJugados2[indice]}, ")
                            if (valoresJugados2[indice] == 1) {
                                if (ultimo == 5 || indice == 0){
                                    kicker2 = indice
@@ -392,6 +346,7 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        var kicker1 = 0
                        var kicker2 = 0
                        loopjugado1@ for (indice in valoresJugados1.indices) {
+                            print("${indice+1} ${valoresJugados1[indice]}, ")
                            if (valoresJugados1[indice] == 1) {
                                if (ultimo == 5 || (indice == 0 && valoresJugados1[9] == 1 && valoresJugados1[10] == 1 && valoresJugados1[11] == 1 && valoresJugados1[12] == 1)){
                                    kicker1 = indice
@@ -403,6 +358,7 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        ultimo = 1
                        println()
                        loopjugado2@ for (indice in valoresJugados2.indices){
+                            print("${indice+1} ${valoresJugados2[indice]}, ")
                            if (valoresJugados2[indice] == 1) {
                                if (ultimo == 5 || (indice == 0 && valoresJugados1[9] == 1 && valoresJugados1[10] == 1 && valoresJugados1[11] == 1 && valoresJugados1[12] == 1)){
                                    kicker2 = indice
@@ -452,7 +408,6 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                            if (segundo == 1){
                                if (valoresJugados1[indice] == 2){
                                    segundoDoble = indice
-                                    segundo = 0
                                    break@loopintern
                                }
                            }
@@ -503,7 +458,6 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        var kicker2 = 0
                        var primerDoble = -1
-                        var segundo = false
                        for (indice in valoresJugados1.indices){
                            if (valoresJugados1[indice] == 2){
                                primerDoble = indice
@@ -576,7 +530,6 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                                ultimo++
                            }
                        }
-                        println("kicker1 = $kicker1 kicker2 = $kicker2")
                        ganador = if (kicker1 == 0 && kicker2 != 0){
                            "JUGADOR 1"
                        }else if (kicker2 == 0 && kicker1 != 0) {
@@ -588,12 +541,88 @@ fun jugadaGanadora(jugada1 : List<CartaJugada>, jugada2 : List<CartaJugada>, tip
                        } else "JUGADOR 2"
                    }
-                    else ->{ //"NADA"
+                    else -> ganador = "ERROR 5: JUGADA NO ENCONTRADA"
-                        "ERROR 5: JUGADA NO ENCONTRADA"
-                    }
                }
            }
        }
    }
    return ganador
+}
+fun jugadaMesa(){
+    var core = 1
+    do {
+        val tipoPalo = Random.nextInt(0, 3)
+        val cartaSelect = Random.nextInt(0, 12)
+        when(core) {
+            in 1..5 ->   if (Const.MESA[tipoPalo][cartaSelect] == 0) {
+                val column = Const.MESA[tipoPalo]
+                column[cartaSelect] = 1
+                Const.MESA[tipoPalo] = column
+                core++
+            }
+            6, 7 ->if (Const.MESA[tipoPalo][cartaSelect] == 0) {
+                val column = Const.MESA[tipoPalo]
+                column[cartaSelect] = 2
+                Const.MESA[tipoPalo] = column
+                core++
+            }
+            8, 9 ->if (Const.MESA[tipoPalo][cartaSelect] == 0) {
+                val column = Const.MESA[tipoPalo]
+                column[cartaSelect] = 3
+                Const.MESA[tipoPalo] = column
+                core++
+            }
+        }
+    }while (core <= 9)
+    //imprime jugadas Poker
+    for (fila in Const.MESA.indices){
+        when(fila){
+            0 -> print("S ")
+            1 -> print("D ")
+            2 -> print("H ")
+            3 -> print("C ")
+        }
+        for (columnas in Const.MESA[fila].indices)
+            print("${Const.MESA[fila][columnas]}, ")
+        println()
+    }
+}
+fun decodificar(jugador: Int): ArrayList<CartaJugada>{
+    val jugadordecodif = jugador +1
+    val jugada = ArrayList<CartaJugada>()
+    for (fila in Const.MESA.indices){
+        for (columnas in Const.MESA[fila].indices)
+            if (Const.MESA[fila][columnas] == jugadordecodif || Const.MESA[fila][columnas] == 1) {
+                val caracterPalo =when(fila){
+                    0->'S'
+                    1->'C'
+                    2->'D'
+                    3->'H'
+                    else -> 'x'
+                }
+                val caracterValor =when(columnas){
+                    0 -> 'A'
+                    1 -> '2'
+                    2 -> '3'
+                    3 -> '4'
+                    4 -> '5'
+                    5 -> '6'
+                    6 -> '7'
+                    7 -> '8'
+                    8 -> '9'
+                    9 -> 'T'
+                    10 -> 'J'
+                    11 -> 'Q'
+                    12 -> 'K'
+                    else -> 'x'
+                }
+                jugada.add(CartaJugada(valor = caracterValor, palo = caracterPalo))
+            }
+    }
+    return jugada
 }
\ No newline at end of file