3-Karten-Blackjack

Blackjack mit fester Zahl an Karten

Mit dem Wissen aus den vorherigen Kapiteln kannst du nun ein vereinfachtes Blackjack-Spiel programmieren, bei dem der Spieler genau drei Karten zieht.

Aufgabe

Alternativ zur Bearbeitung in BlueJ kannst du das Programm auch hier online testen:

class Stapel {

    private val karten: MutableList<Karte> = mutableListOf()
   
    fun zaehleKarten(): Int = karten.size
   
    fun erzeugeBlaetter(anzahlBlaetter: Int) {
        val raenge = listOf(
            "2", "3", "4", "5", "6", "7", "8", "9", "10",
            "B", "D", "K", "A"
        )
        val farben = listOf("Herz", "Karo", "Pik", "Kreuz")

        repeat(anzahlBlaetter) {
            for (farbe in farben) {
                for (rang in raenge) {
                    karten.add(Karte(farbe, rang))
                }
            }
        }
    }

    fun mischen() = karten.shuffle()

    private fun zieheKarte(): Karte? {
        if (karten.isEmpty())
            return null
        else
            return karten.removeAt(0)
    }
    
    fun zieheUndZeige() {
        if (karten.isEmpty()) {
            println("Es ist keine Karte mehr übrig")
        }
        else {
            zeigeObersteKarte()
            zieheKarte()
        }
    }

    fun zeigeObersteKarte() {
        if (karten.isEmpty()) 
            println("Stapel ist leer")
        else
            karten.first().druckeKarte()
    }

    fun druckeAlle() {
        for (karte in karten) {
            karte.druckeKarte()
        }
    }
}


class Karte(
    farbe: String,   // "Herz", "Karo", "Pik", "Kreuz" (ausgeschrieben, Groß/Kleinschreibung egal)
    rang: String     // "2"–"10", "B"/"Bube", "D"/"Dame", "K"/"Koenig", "A"/"Ass"
    ) {

    val rang: String = kuerzeRang(rang)
    val farbe: String = normalisiereFarbe(farbe)

    fun berechneWert(): Int {
        return when (rang) {
            "A" -> 11
            "B", "D", "K" -> 10
            else -> rang.toInt()
        }
    }

    fun druckeKarte() {
        val symbol = when (farbe) {
            "herz" -> "♥"
            "karo" -> "♦"
            "pik" -> "♠"
            "kreuz" -> "♣"
            else -> "?"
        }

        val right = rang.padStart(2, ' ')
        val left = rang.padEnd(2, ' ')

        println("┌─────┐")
        println("│$left   │")
        println("│  $symbol  │")
        println("│   $right│")
        println("└─────┘")
    }

    private fun kuerzeRang(roherRang: String): String {
        val normalisiert = roherRang.trim().lowercase()
        return when (normalisiert) {
            "a", "ass" -> "A"
            "k", "koenig", "könig" -> "K"
            "d", "dame" -> "D"
            "b", "bube" -> "B"
            else -> {
                val zahl = normalisiert.toIntOrNull()
                    ?: throw IllegalArgumentException("Unbekannter Rang: $roherRang")
                if (zahl in 2..10) zahl.toString()
                else throw IllegalArgumentException("Rang ausserhalb des Bereichs: $roherRang")
            }
        }
    }

    private fun normalisiereFarbe(roheFarbe: String): String {
        return when (val normalisiert = roheFarbe.trim().lowercase()) {
            "herz", "karo", "pik", "kreuz" -> normalisiert
            else -> throw IllegalArgumentException("Unbekannte Farbe: $roheFarbe")
        }
    }
}

fun main() {

}