So wird gespielt

Zwei Spielerinnen oder Spieler spielen abwechselnd. Beide erstellen ein Tier, das zu Beginn eine bestimmte Menge an Energie und Glückslevel hat. Außerdem besitzen beide eine bestimmte Menge an Futter-Vorrat. In jedem Zug steht eine der folgenden Aktionen zur Auswahl:

Nach jeder Aktion wird geprüft: Ein glückliches Tier, das nicht verhungert ist, gewinnt. Ein trauriges oder verhungertes Tier verliert.

Das BlueJ-Projekt vervollständigen

Die Klasse Spiel ist bereits fertig implementiert. Du kannst in BlueJ eine neue Klasse Spiel erstellen und den folgenden Code in diese Klasse kopieren, um das BlueJ-Projekt zu vervollständigen. Um die Seite nicht zu überladen, versteckt sich der Code hinter dem folgenden Button. Du kannst den gesamten Code kopieren, indem du oben rechts auf Copy klickst.

class Spiel {
    private val namen = mutableListOf("", "")
    private val tiere = mutableListOf<Tier>()
    private val futter = mutableListOf(5, 5)

    fun starten() {
        neuesSpielZuruecksetzen()
        konsoleLeeren()

        for (nr in 1..2) {
            println("=== Daten für Spieler $nr ===")

            namen[nr - 1] =
                liesText("Name von Spieler $nr: ", "Spieler $nr")

            val tierName = liesText(
                "Name des Tieres von ${namen[nr - 1]}: ",
                "Tier $nr"
            )

            tiere.add(Tier(tierName))
        }

        konsoleLeeren()

        var aktuell = 0

        while (true) {
            val anderer = 1 - aktuell
            val tier = tiere[aktuell]

            zugBildschirm(aktuell)

            val aktion = liesAktion()

            if (aktion == 0) {
                println()
                println("Spiel beendet.")
                return
            } else if (aktion == 1) {
                fuettern(aktuell)
            } else if (aktion == 2) {
                tier.spielen()
                println("${namen[aktuell]} spielt mit ${tier.name}.")
            } else {
                val gefunden = (1..9).random()
                futter[aktuell] += gefunden
                tier.langweilen()

                println(
                    "${namen[aktuell]} sucht Futter und findet $gefunden."
                )
            }

            konsoleLeeren()

            println("=== Neuer Zustand nach der Aktion ===")
            println("Übrige Futtermenge : ${futter[aktuell]}")
            println()

            zustandAusgeben(tier)
            println()

            if (tier.istGluecklich() && !tier.istVerhungert()) {
                println()
                println(
                    "🎉 ${namen[aktuell]} gewinnt! " +
                    "${tier.name} ist glücklich."
                )
                return
            }

            if (tier.istTraurig()) {
                println()
                println("😢 ${tier.name} ist sehr traurig.")
                println("🏆 ${namen[anderer]} gewinnt!")
                return
            }

            if (tier.istVerhungert()) {
                println()
                println("💀 ${tier.name} hat keine Energie mehr.")
                println("🏆 ${namen[anderer]} gewinnt!")
                return
            }

            println()
            print("ENTER für Spielerwechsel ...")
            readLine()

            konsoleLeeren()
            aktuell = anderer
        }
    }

    private fun neuesSpielZuruecksetzen() {
        namen[0] = ""
        namen[1] = ""

        tiere.clear()

        futter[0] = 5
        futter[1] = 5
    }

    private fun zugBildschirm(nr: Int) {
        val tier = tiere[nr]

        println("===================================")
        println("${namen[nr]}, du bist am Zug")
        println("Du hast noch ${futter[nr]} Futter-Portionen")
        println("===================================")

        zustandAusgeben(tier)
        println()

        println("Aktionen:")
        println("1) ${tier.name} füttern")
        println("2) Mit ${tier.name} spielen")
        println("3) Futter suchen")
        println("0) Spiel beenden")
        println()
    }

    private fun zustandAusgeben(tier: Tier) {
        println("${tier.name}s Zustand")
        println("Energie     : ${tier.energie}")
        println("Glückslevel : ${tier.glueckslevel}")
    }

    private fun fuettern(nr: Int) {
        val tier = tiere[nr]

        if (futter[nr] <= 0) {
            println("Kein Futter vorhanden!")
            return
        }

        val menge = liesZahlImBereich(
            "Wie viel Futter soll ${tier.name} bekommen " +
                "(1-${futter[nr]})? ",
            1,
            futter[nr]
        )

        futter[nr] -= menge
        tier.fuettern(menge)

        println("${namen[nr]} füttert ${tier.name} mit $menge.")
    }

    private fun liesAktion(): Int {
        while (true) {
            val eingabe = liesZahl("Bitte Zahl eingeben: ")

            if (eingabe in 0..3) {
                return eingabe
            }

            println("Ungültige Eingabe.")
        }
    }

    private fun konsoleLeeren() {
        print('\u000C')
    }

    private fun liesText(frage: String, standard: String): String {
        print(frage)

        val eingabe = readLine()?.trim()

        return if (eingabe.isNullOrEmpty()) {
            standard
        } else {
            eingabe
        }
    }

    private fun liesZahl(frage: String): Int {
        while (true) {
            print(frage)

            val zahl = readLine()
                ?.trim()
                ?.toIntOrNull()

            if (zahl != null) {
                return zahl
            }

            println("Bitte eine ganze Zahl eingeben.")
        }
    }

    private fun liesZahlImBereich(
        frage: String,
        min: Int,
        max: Int
    ): Int {
        while (true) {
            val zahl = liesZahl(frage)

            if (zahl in min..max) {
                return zahl
            }

            println("Bitte eine Zahl zwischen $min und $max eingeben.")
        }
    }
}

Aufgabe 1

Zufallszahlen

Aktuell ist der Verlauf des Spiels sehr vorhersehbar, da die Aktionen der Spieler immer die gleichen Auswirkungen haben. Um das Spiel interessanter zu machen, können wir bei den Methoden spielen und langweilen Zufallszahlen verwenden, um die energie und den glueckslevel des Tiers zufällig - innerhalb eines bestimmten Bereichs - zu verändern. Das folgende Code-Fragment demonstriert die Verwendung von Zufallszahlen in Kotlin.

fun main() {
    var zahl = 5
    println(zahl)

    zahl = zahl + (2..4).random()
    println(zahl)
}

Wenn du in späteren Abschnitten noch einmal Zufallszahlen verwenden möchtest, und nicht mehr genau weißt, wie das funktioniert, kannst du in den Tipps zu Kotlin nachschauen, wo die Verwendung von Zufallszahlen ausführlich erklärt wird.

Aufgabe 2

Aufgabe 3