08-Loesung.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Breakout\n",
    "### - Lösung - "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Just Another Brick in the Wall"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Breakout (heute auch bekannt als Brick Breaker) ist ein Computerspiel, das 1976 u. a. von Steve Wozniak entwickelt wurde. Steve Wozniak war später maßgeblich an der Gründung der Firma Apple beteiligt. Weitere Informationen zum Spiel findest du auf https://de.wikipedia.org/wiki/Breakout_(Computerspiel).\n",
    "\n",
    "Hier kannst du eine JavaScript-Version ausprobieren: http://breakout.enclavegames.com/lesson10.html\n",
    "\n",
    "![Breakout](https://media.prod.mdn.mozit.cloud/attachments/2015/04/09/10383/6b9c394b49bb049e52f1eac29b2bed8e/mdn-breakout-gameplay.png)\n",
    "(Quelle: https://media.prod.mdn.mozit.cloud/attachments/2015/04/09/10383/6b9c394b49bb049e52f1eac29b2bed8e/mdn-breakout-gameplay.png)\n",
    "\n",
    "Diese Aufgabe beschäftigt sich mit der Entwicklung eines Breakout-Spiels. Dazu musst du dir eine lokale Python-Installation aufsetzen.\n",
    "\n",
    "Möglicherweise funktioniert Python 3 auf deinem System bereits. Du musst Python 3 für diese Aufgabe verwenden, denn der Umgang mit Sonderzeichen (Umlaute etc.) ist in Python 2 nicht besonders komfortabel. Überprüfe zunächst deine Python Version; dazu musst du zunächst ein Terminal öffnen:\n",
    " - Windows: öffne das Startmenü, indem du die \"Windows\"-Taste drückst. Suche dann nach \"cmd\" und starte die \"Eingabeaufforderung\" (\"cmd.exe\").\n",
    " - MacOS: Öffne ein Terminal, indem du \"Command+Leertaste\" drückst und nach \"Terminal\" suchst. Starte das Terminal mit einem Doppelklick.\n",
    " - Linux: öffne ein Terminal (auf Ubuntu und ähnlichen Systemen mit \"Strg+Alt+T\", auf kde-Systemen mit \"Alt+F2\" und gib dann \"konsole\" ein).\n",
    "\n",
    "Führe dann den folgenden Befehl aus: \"python3 --version\" (oder wenn dies eine Fehlermeldung wirft, versuche es mit \"python --version\"). Wenn du bei einem der Befehle keine Fehlermeldung bekommst und in der Konsole etwas ähnliches steht wie \"Python 3.7.5\", kannst du den dazugehörigen Befehl ab nun zum Starten von Python 3 verwenden. Wichtig: wenn hier etwas wie \"Python 2.7.17\" steht, hast du eine Installation der Version 2, welche für die Aufgabe nicht verwendet werden kann. Wenn du beidesmal eine Fehlermeldung bekommst, gehe direkt zur Installation.\n",
    "\n",
    "Ab hier wird die Aufgabe mit dem Befehl \"python3\" gestellt, auf deinem System kann aber auch der Befehl \"python\" die korrekte Installation der Version 3 starten (wie zuvor beschrieben).\n",
    "\n",
    "Führe nun den folgenden Befehl aus, um zu testen, ob du das GUI-Toolkit Tkinter installiert hast: \"python3 -m tkinter\". Wenn du ein kleines Testfenster siehst, hast du Python und Tkinter bereits korrekt installiert.\n",
    "\n",
    "Wenn du eine Fehlermeldung bekommen hast, lade dir Python (mit Tkinter) kostenfrei hier herunter:\n",
    " - Windows: https://www.python.org/ftp/python/3.8.2/python-3.8.2-amd64.exe\n",
    " - MacOS: https://www.python.org/ftp/python/3.8.2/python-3.8.2-macosx10.9.pkg\n",
    " - Linux: auf den meisten Linux-Systemen ist Python bereits vorinstalliert. Jedoch fehlt meistens das Modul \"tkinter\". Auf Ubuntu-ähnlichen Systemen kannst du dieses mit diesem Befehl nachinstallieren: \"sudo apt-get install python3-tk\". Für andere Linux-Systeme, folge bitte diesen Lösungsvorschlägen: https://stackoverflow.com/questions/4783810/install-tkinter-for-python\n",
    "\n",
    "Jetzt sollte deine Python 3-Installation mit Tkinter funktionieren. Um dies zu testen, kopiere die folgende Vorlage in eine neue leere Datei \"breakout.py\". Achte darauf, dass du in deinem Editor zum Abspeichern \"UTF-8\" als Encoding verwendest, sonst funktionieren die Umlaute und Sonderzeichen in der deutschen Sprache nicht.\n",
    "\n",
    "Mögliche Editoren zum Bearbeiten von Python-Skripten sind etwa: PyCharm, Notepad++, Sublime Text, Atom Editor, Eclipse mit Python Plugins, vim (Linux und MacOS), gedit (Linux). Aber die Wahl deines Lieblingseditors steht dir frei.\n",
    "\n",
    "Auf Windows solltest du die Datei mit einem Doppelklick ausführen können. Auf anderen Systemen musst du mit dem Terminal in das Verzeichnis wechseln, in dem diese neue Datei liegt. Das kannst du mit dem Befehl \"cd </vollständiger/Pfad/zu/der/Datei>\" machen. Dann kannst du die Datei mit \"python3 breakout.py\" ausführen. Achte darauf, dass du Python 3 verwendest.\n",
    "\n",
    "Wenn alles richtig installiert ist, erscheint ein Fenster, in dem das Breakout-Spiel Form annehmen soll.\n",
    "\n",
    "Du musst den Code in der Datei \"breakout.py\" bei \"...\" erweitern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Das ist die Vorlage, die du in die neue leere Datei \"breakout.py\" kopieren kannst.\n",
    "\n",
    "# Das Encoding muss UTF-8 sein wegen der Sonderzeichen in der deutschen Sprache:\n",
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "# importiere benötigte Module\n",
    "from tkinter import *\n",
    "\n",
    "# folgende Elemente gibt es im Spiel:\n",
    "#\n",
    "# _____________________________    obere Begrenzung\n",
    "# |=== === === === === === ===|\n",
    "# |=== === === === === === ===|    Ziegelsteine, die abzuräumen sind\n",
    "# |=== === === === === === ===|\n",
    "# |                           |\n",
    "# |                           |    linke und rechte Begrenzung\n",
    "# |                           |\n",
    "# |          O                |    Ball\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |   #####                   |    Plattform, mit der der Ball im Spiel gehalten werden muss\n",
    "\n",
    "# das Koordinatensystem des Spielfensters is folgendermaßen aufgebaut:\n",
    "# der Ursprung ist in der linken oberen Ecke und die x-Koordinate läuft nach rechts.\n",
    "# die y-Koordinate läuft nach unten.\n",
    "# Alle Koordinaten in diesem Fenster beziehen sich auf dieses Koordinatensystem.\n",
    "# Das bedeutet, dass die Plattform eine große y-Koordinate hat, auch wenn sie\n",
    "# unten im Fenster angezeigt wird und das zunächst nicht intuitiv erscheint.\n",
    "# Jedoch entstammt diese Denkweise der Art, wie man in Europa schreibt:\n",
    "# von links nach rechts und von oben nach unten. Auf einem Blatt Papier ist der\n",
    "# \"Ursprung\" auch links oben; dort beginnt man zu schreiben.\n",
    "#\n",
    "# O___x->______________________\n",
    "# |    === === === === ===    |\n",
    "# y    === === === === ===    |\n",
    "# |    === === === === ===    |\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |                           |\n",
    "# |   #####                   |\n",
    "\n",
    "\n",
    "# der Faktor bestimmt, wie groß das Fenster dargestellt wird\n",
    "skalierungs_faktor = 2\n",
    "\n",
    "# definiere dafür benötigte Größen in Pixelwertenspielfeld_breite = 195 * skalierungs_faktor\n",
    "spielfeld_breite = 195 * skalierungs_faktor\n",
    "spielfeld_höhe = 195 * skalierungs_faktor\n",
    "ball_radius = 3 * skalierungs_faktor\n",
    "plattform_breite = 50 * skalierungs_faktor\n",
    "plattform_höhe = 5 * skalierungs_faktor\n",
    "ziegelstein_breite = 26 * skalierungs_faktor\n",
    "ziegelstein_höhe = 5 * skalierungs_faktor\n",
    "ziegelsteine_abstand = 2 * skalierungs_faktor\n",
    "\n",
    "# am Anfang ist das Spiel pausiert\n",
    "pausiert = True\n",
    "\n",
    "# am Anfang ist das Spiel noch nicht gewonnen\n",
    "gewonnen = False\n",
    "\n",
    "# am Anfang ist das Spiel noch nicht verloren\n",
    "verloren = False\n",
    "\n",
    "# lege die Startpositionen der Plattform und des Balls fest\n",
    "# die Position des Balls hat x- und y-Koordinaten;\n",
    "# der Ball beginnt sitzend auf der Mitte der Plattform\n",
    "ball_position = [spielfeld_breite / 2 - ball_radius / 2, spielfeld_höhe - plattform_höhe - ball_radius]\n",
    "\n",
    "# die Position der Plattform hat nur eine x-Koordinate,\n",
    "# da die Pattform am unteren Spielfeldrand bleibt;\n",
    "# sie startet in der Bildschirmmitte unten\n",
    "plattform_position = spielfeld_breite / 2 - plattform_breite / 2\n",
    "\n",
    "# außerdem haben der Ball und die Plattform eine Geschwindigkeit, mit der sie sich bewegen\n",
    "# der Ball hat eine Geschwindigkeit in x- und y-Richtung,\n",
    "# die Plattform nur in x-Richtung\n",
    "# (die Pattform bleibt am unteren Spielfeldrand)\n",
    "ball_geschwindigkeit = [1 * skalierungs_faktor, -3 * skalierungs_faktor]\n",
    "plattform_geschwindigkeit = 0 * skalierungs_faktor\n",
    "\n",
    "# die Liste der Ziegelsteine, die man abräumen muss\n",
    "ziegelsteine = []\n",
    "\n",
    "# In dieser Funktion wird der Ball um eine Position weiter bewegt\n",
    "# und dann ausgewertet, ob eine Begrenzung, ein Ziegelstein oder\n",
    "# die Plattform getroffen wurde.\n",
    "# Dazu wird nur die Geschwindigkit des Balls verwendet und die Position\n",
    "# des Balls geändert.\n",
    "def bewege_ball():\n",
    "    # mache die benötigten Variablen sichtbar\n",
    "    global ball_position\n",
    "    global ball_geschwindigkeit\n",
    "    global gewonnen\n",
    "    global verloren\n",
    "    \n",
    "    # wenn das Spiel pausiert ist, bewege den Ball nicht\n",
    "    if pausiert == True:\n",
    "        return;\n",
    "\n",
    "    # bewege den Ball um seine aktuelle Geschwindigkeit weiter\n",
    "    ball_position[0] += ball_geschwindigkeit[0]\n",
    "    ball_position[1] += ball_geschwindigkeit[1]\n",
    "    \n",
    "    # überprüfe, ob etwas getroffen wurde und reagiere entsprechend\n",
    "    if ball_trifft_plattform():\n",
    "        # mit dieser Formel wird beschrieben, wo der Ball die Plattform getroffen hat\n",
    "        getroffene_stelle = (ball_position[0] - (plattform_position + plattform_breite / 2))\n",
    "        # der x-Wert der Geschwindigkeit des Balls wird daraufhin angepasst\n",
    "        # so kann man mit den Ecken der Plattform den Ball etwas \"zielen\"\n",
    "        ball_geschwindigkeit[0] += getroffene_stelle / 15\n",
    "        # die y-Geschwindigkeit wird umgekehrt, damit prallt der Ball zurück\n",
    "        ball_geschwindigkeit[1] = -ball_geschwindigkeit[1]\n",
    "    elif ball_trifft_ziegelstein() != None:\n",
    "        # der Ball hat einen Ziegelstein getroffen\n",
    "        # der Ziegestein muss abgeräumt werden und der Ball zurückprallen\n",
    "        ziegelstein = ball_trifft_ziegelstein()\n",
    "        ziegelsteine.remove(ziegelstein)\n",
    "        ball_geschwindigkeit[1] = -ball_geschwindigkeit[1]\n",
    "        # wenn es keine Ziegelsteine mehr gibt, hat man gewonnen\n",
    "        if len(ziegelsteine) == 0:\n",
    "            gewonnen = True\n",
    "    elif ball_trifft_begrenzung_oben():\n",
    "        # der Ball hat die Begrenzung oben getroffen\n",
    "        # und muss zurückprallen\n",
    "        ball_geschwindigkeit[1] = -ball_geschwindigkeit[1]\n",
    "    elif ball_trifft_begrenzung_unten():\n",
    "        # der Ball hat die Begrenzung unten getroffen\n",
    "        # er ist aus dem Spielfeld raus und man hat verloren\n",
    "        # ja, das ist Hardcore-Breakout :-)\n",
    "        verloren = True\n",
    "    elif ball_trifft_begrenzung_links():\n",
    "        # der Ball hat die Begrenzung links getroffen\n",
    "        # und muss zurückprallen\n",
    "        ball_geschwindigkeit[0] = -ball_geschwindigkeit[0]\n",
    "    elif ball_trifft_begrenzung_rechts():\n",
    "        # der Ball hat die Begrenzung rechts getroffen\n",
    "        # und muss zurückprallen\n",
    "        ball_geschwindigkeit[0] = -ball_geschwindigkeit[0]\n",
    "\n",
    "# In dieser Funktion wird die Plattform um eine Position weiter bewegt\n",
    "# und dann ausgewertet, ob eine Begrenzung getroffen wurde.\n",
    "# Dazu wird nur die Geschwindigkit der Plattform verwendet und die Position\n",
    "# der Plattform geändert.\n",
    "def bewege_plattform():\n",
    "    # mache die benötigten Variablen sichtbar\n",
    "    global plattform_position\n",
    "    global plattform_geschwindigkeit\n",
    "    \n",
    "    # wenn das Spiel pausiert ist, bewege die Plattform nicht\n",
    "    if pausiert == True:\n",
    "        return;\n",
    "    \n",
    "    # die Plattform bremst von selbst ab, sonst wäre sie unmöglich zu kontrollieren\n",
    "    plattform_geschwindigkeit /= 1.2\n",
    "    \n",
    "    # bewege die Plattform um ihre aktuelle Geschwindigkeit weiter\n",
    "    plattform_position += plattform_geschwindigkeit\n",
    "    \n",
    "    # überprüfe, ob eine Begrenzung getroffen wurde und reagiere entsprechend\n",
    "    if plattform_stoppt_links():\n",
    "        # die Plattform hat die Begrenzung links getroffen und muss stoppen\n",
    "        plattform_position = 0\n",
    "        plattform_geschwindigkeit = 0\n",
    "    elif plattform_stoppt_rechts():\n",
    "        # die Plattform hat die Begrenzung rechts getroffen und muss stoppen\n",
    "        plattform_position = spielfeld_breite - plattform_breite\n",
    "        plattform_geschwindigkeit = 0\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob der Ball mit seiner aktuellen\n",
    "# Position die Plattform berührt oder sogar schon in der Plattform ist.\n",
    "# Da wir das Spiel als Simulation aufgebaut haben und sich der Ball in\n",
    "# schnellen kleinen Schritten fortbewegt, kann es passieren, dass wir den\n",
    "# Moment verpasst haben, als sich der Ball über die Umrandung der Plattform\n",
    "# in diese hinein bewegt hat. Wenn wir nun aber schnell genug reagieren und\n",
    "# den Ball direkt zurückprallen lassen, sieht man das bei den schnellen kleinen\n",
    "# Schritten nicht.\n",
    "# Du kannst immer mit der Variable \"ball_radius\" versuchen, dass nicht das\n",
    "# Zentrum des Balls für die Berechnung verwendet wird, sondern dessen Rand,\n",
    "# dann sieht das Spiel etwas hübscher aus.\n",
    "def ball_trifft_plattform():\n",
    "    # die x-Koordinate des Balls muss innerhalb der Grenzen der Plattform sein\n",
    "    # wenn der Ball geradeaus nach unten fliegen würde, träfe er also auf die Plattform\n",
    "    horizontal_berührt = ball_position[0] > plattform_position and ball_position[0] < plattform_position + plattform_breite\n",
    "    # die y-Koordinate des Balls muss so sein, dass der Ball die Plattform gerade berührt\n",
    "    # oder aber der Ball fliegt gerade seitlich vorbei\n",
    "    vertikal_berührt = ball_position[1] + ball_radius > spielfeld_höhe - plattform_höhe and ball_position[1] < spielfeld_höhe\n",
    "    # wenn diese beiden Bedingungen zugleich zutreffen, prallt der Ball zurück\n",
    "    return horizontal_berührt and vertikal_berührt\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob der Ball mit seiner aktuellen\n",
    "# Position einen der Ziegelsteine berührt oder sogar schon darin ist.\n",
    "# Hier gilt das Gleiche wie bei der Plattform, jedoch müssen wir die Liste der\n",
    "# Ziegelsteine durchschauen, ob einer davon getroffen wurde.\n",
    "def ball_trifft_ziegelstein():\n",
    "    for z in ziegelsteine:\n",
    "        # die x-Koordinate des Balls muss innerhalb der Grenzen des Ziegelsteins sein\n",
    "        # wenn der Ball geradeaus nach oben fliegen würde, träfe er also den Ziegelstein\n",
    "        horizontal_berührt = ball_position[0] > z[0] and ball_position[0] < z[0] + ziegelstein_breite\n",
    "        # die y-Koordinate des Balls muss so sein, dass der Ball den Ziegelstein gerade berührt\n",
    "        # oder aber der Ball fliegt gerade seitlich vorbei\n",
    "        vertikal_berührt = ball_position[1] > z[1] and ball_position[1] < z[1] + ziegelstein_höhe\n",
    "        # wenn diese beiden Bedingungen zugleich zutreffen, prallt der Ball zurück\n",
    "        if horizontal_berührt and vertikal_berührt:\n",
    "            return z\n",
    "    # wenn kein Ziegelstein getroffen wurde, gib None zurück\n",
    "    return None\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob der Ball mit seiner aktuellen\n",
    "# Position oben an die Begrenzung stößt, oder sogar schon darüber hinaus ist.\n",
    "def ball_trifft_begrenzung_oben():\n",
    "    return ball_position[1] - ball_radius < 0\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob der Ball mit seiner aktuellen\n",
    "# Position unten an die Begrenzung stößt, oder sogar schon darüber hinaus ist.\n",
    "def ball_trifft_begrenzung_unten():\n",
    "    return ball_position[1] > spielfeld_höhe\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob der Ball mit seiner aktuellen\n",
    "# Position links an die Begrenzung stößt, oder sogar schon darüber hinaus ist.\n",
    "def ball_trifft_begrenzung_links():\n",
    "    return ball_position[0] - ball_radius < 0\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob der Ball mit seiner aktuellen\n",
    "# Position rechts an die Begrenzung stößt, oder sogar schon darüber hinaus ist.\n",
    "def ball_trifft_begrenzung_rechts():\n",
    "    return ball_position[0] + ball_radius > spielfeld_breite\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob die Plattform mit ihrer aktuellen\n",
    "# Position links an die Begrenzung stößt, oder sogar schon darüber hinaus ist.\n",
    "def plattform_stoppt_links():\n",
    "    return plattform_position < 0\n",
    "\n",
    "# In dieser Funktion wird ausgewertet, ob die Plattform mit ihrer aktuellen\n",
    "# Position rechts an die Begrenzung stößt, oder sogar schon darüber hinaus ist.\n",
    "def plattform_stoppt_rechts():\n",
    "    return plattform_position + plattform_breite > spielfeld_breite\n",
    "\n",
    "# initialisiere die Ziegelsteine\n",
    "# die Liste der Ziegelsteine enthält die linken oberen Eckpositionen der Ziegelsteine\n",
    "# da wir bereits festgelegt haben, wie hoch und breit ein Ziegelstein ist, sind diese\n",
    "# damit eindeutig definiert\n",
    "def initialisiere_ziegelsteine():\n",
    "    global ziegelsteine\n",
    "    ziegelsteine = []\n",
    "    for y in range(0, 3 * ziegelstein_höhe, ziegelstein_höhe + ziegelsteine_abstand):\n",
    "        for x in range(0, spielfeld_breite - ziegelstein_breite, ziegelstein_breite + ziegelsteine_abstand):\n",
    "            ziegelsteine.append([x, y])\n",
    "\n",
    "# Funktion, welche die Tastaturevents verwaltet\n",
    "# damit lässt sich die Plattform mit der Tastatur steuern,\n",
    "# es werden die Pfeiltasten nach links und rechts verwendet.\n",
    "def tastatur_events(event):\n",
    "    # mache die benötigten Variablen sichtbar\n",
    "    global pausiert\n",
    "    global gewonnen\n",
    "    global verloren\n",
    "    global ball_position\n",
    "    global ball_geschwindigkeit\n",
    "    global plattform_position\n",
    "    global plattform_position\n",
    "    global plattform_geschwindigkeit\n",
    "    \n",
    "    # wertet die gedrückte Taste aus\n",
    "    taste = event.keysym\n",
    "    if taste == 'space':\n",
    "        # mit der Leertaste kann man pausieren und fortfahren\n",
    "        pausiert = not pausiert\n",
    "        # starte ein neues Spiel, wenn eines gewonnen oder verloren wurde\n",
    "        if gewonnen == True or verloren == True:\n",
    "            initialisiere_ziegelsteine()\n",
    "            gewonnen = False\n",
    "            verloren = False\n",
    "            ball_position = [spielfeld_breite / 2 - ball_radius / 2, spielfeld_höhe - plattform_höhe - ball_radius]\n",
    "            ball_geschwindigkeit = [1, -3]\n",
    "            plattform_position = spielfeld_breite / 2 - plattform_breite / 2\n",
    "            plattform_geschwindigkeit = 0\n",
    "            pausiert = True\n",
    "    elif taste == 'Left':\n",
    "        # beschleunige die Plattform, wenn die Taste links gedrückt wurde\n",
    "        plattform_geschwindigkeit -= 4 * skalierungs_faktor\n",
    "    elif taste == 'Right':\n",
    "        # beschleunige die Plattform, wenn die Taste rechts gedrückt wurde\n",
    "        plattform_geschwindigkeit += 4 * skalierungs_faktor\n",
    "\n",
    "# diese Funktion wird jeden Zeitschritt aufgerufen,\n",
    "# das Spiel ist also eine Simulation\n",
    "def zeitschritt():\n",
    "    # mache die benötigten Variablen sichtbar\n",
    "    global pausiert\n",
    "    global verloren\n",
    "    global gewonnen\n",
    "    \n",
    "    # jeden Zeitschritt bewegt sich der Ball und  \n",
    "    bewege_ball()\n",
    "    bewege_plattform()\n",
    "    \n",
    "    # die Zeichenfläche leeren\n",
    "    zeichenfläche.delete(\"all\")\n",
    "    \n",
    "    # alle nötigen Objekte zeichen\n",
    "    # zeichne zunächst die Ziegelsteine\n",
    "    for z in ziegelsteine:\n",
    "        zeichenfläche.create_rectangle(z[0], z[1], z[0] + ziegelstein_breite, z[1] + ziegelstein_höhe, fill='blue')\n",
    "    \n",
    "    # zeichne den Ball\n",
    "    y0 = ball_position[1] - ball_radius\n",
    "    x0 = ball_position[0] - ball_radius\n",
    "    y1 = ball_position[1] + ball_radius\n",
    "    x1 = ball_position[0] + ball_radius\n",
    "    zeichenfläche.create_oval(int(x0), int(y0), int(x1), int(y1), fill='green')\n",
    "    \n",
    "    # zeichne die Plattform\n",
    "    zeichenfläche.create_rectangle(plattform_position, spielfeld_höhe - plattform_höhe, plattform_position + plattform_breite, spielfeld_höhe, fill='red')\n",
    "\n",
    "    # wenn das Spiel verloren ist, zeige einen Text\n",
    "    if verloren == True:\n",
    "        nachricht = \"Verloren!\\n<Leertaste> zum Neustart.\"\n",
    "        zeichenfläche.create_text(spielfeld_breite / 2, spielfeld_höhe / 2, text=nachricht, font=('Helvetica', 10, 'bold'), justify=CENTER)\n",
    "        pausiert = True\n",
    "\n",
    "    # wenn das Spiel gewonnen ist, zeige einen Text\n",
    "    if gewonnen == True:\n",
    "        nachricht = \"Gewonnen!\\n<Leertaste> zum Neustart.\"\n",
    "        zeichenfläche.create_text(spielfeld_breite / 2, spielfeld_höhe / 2, text=nachricht, font=('Helvetica', 10, 'bold'), justify=CENTER)\n",
    "        pausiert = True\n",
    "\n",
    "    # wenn das Spiel pausiert ist, zeige einen Text\n",
    "    if pausiert == True and gewonnen == False and verloren == False:\n",
    "        nachricht = \"Pausiert.\\n<Leertaste> zum Fortfahren.\"\n",
    "        zeichenfläche.create_text(spielfeld_breite / 2, spielfeld_höhe / 2, text=nachricht, font=('Helvetica', 10, 'bold'), justify=CENTER)\n",
    "    \n",
    "    # zeichne die Zeichenfläche (also das gesamte Spielfeld) neu\n",
    "    zeichenfläche.update()\n",
    "\n",
    "    # einen Timer starten, dass die Funktion \"zeitschritt\" nach 20 Millisekunden erneut aufgerufen wird\n",
    "    # das ist das Herzstück der Simulation\n",
    "    fenster.after(20, zeitschritt)\n",
    "\n",
    "# verschiebe das Fenster in die Bildschirmmitte\n",
    "def zentriereFenster(fenster):\n",
    "    fenster.update_idletasks()\n",
    "    b = fenster.winfo_width()\n",
    "    h = fenster.winfo_height()\n",
    "    x = (fenster.winfo_screenwidth() // 2) - (b // 2)\n",
    "    y = (fenster.winfo_screenheight() // 2) - (h // 2)\n",
    "    fenster.geometry('{}x{}+{}+{}'.format(b, h, x, y))\n",
    "\n",
    "# öffne das Fenster, in dem das Spiel dargestellt wird\n",
    "fenster = Tk(className = 'Breakout')\n",
    "zeichenfläche = Canvas(fenster, width=spielfeld_breite, height=spielfeld_höhe)\n",
    "zeichenfläche.pack()\n",
    "zentriereFenster(fenster)\n",
    "\n",
    "# binde die Funktion \"tastatur_events\" an das Fenster,\n",
    "# so dass diese bei Tastenevents aufgerufen wird\n",
    "fenster.bind('<Key>', tastatur_events)\n",
    "\n",
    "# initialisiere die Ziegelsteine\n",
    "initialisiere_ziegelsteine()\n",
    "\n",
    "# starte die Simulation\n",
    "zeitschritt()\n",
    "\n",
    "# Tkinter behandelt Timer- und Tastaturevents in der Funktion \"mainloop()\"\n",
    "mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fragen & Feedback:\n",
    "\n",
    "**Wenn ihr Fragen oder Anregungen zu der Aufgabe (oder Lösung) habt, dann tauscht euch gerne im [Chat](https://spectrum.chat/bwki/aufgabenarchiv/) darüber aus oder schreibt uns eine E-Mail (an info@bw-ki.de).**\n",
    "\n",
    "Wir freuen uns auch immer über **Feedback** (auch unter info@bw-ki.de):\n",
    "\n",
    "- War diese Aufgabe zu leicht, zu schwer oder genau richtig?\n",
    "- Wie lang hast du für diese Aufgabe ungefähr gebraucht?\n",
    "- Welche Art von Aufgaben wünschst du dir in Zukunft?"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:bwki_env]",
   "language": "python",
   "name": "conda-env-bwki_env-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}