Muehle_GUI.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%HTML\n",
    "<style>\n",
    ".container { width:100% }\n",
    "</style>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GUI - Graphical User Interface / Benutzeroberfläche\n",
    "In diesem Abschnitt soll die graphische Oberfläche des Spiels entwickelt werden. Dies beinhaltet die Interaktion des Spielers mit dem Spielaufbau."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mögliche Positionen\n",
    "Die Grafik unten zeigt die Notation für die Position der Spielsteine. Die Positionen werden als Tupel bestehend aus Ringnummer und Zellnummer beschrieben. Die Ringe, in der Abbildung farbig markiert, sind dabei von außen beginnend mit 0, 1 und 2 nummeriert. Für die Bezeichnung der Zellen wird in jedem Ring oben links mit 0 begonnen und im Uhrzeigersinn bis 7 weitergezählt. So ergibt sich eine eindeutige Notation der Form `(ring, cell)`.\n",
    "\n",
    "<img src=\"images/board_positions.png\" alt=\"Mögliche Positionen\" width=\"800\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definitionen\n",
    "Zunächst werden einige Definitionen für die gesamte Implementation festgesetzt: \n",
    "* `ring` = eines der 3 Quadrate (Wertebereich: 0-2)\n",
    "* `cell` = ein Punkt auf einem Ring (Wertebereich: 0-7)\n",
    "* `position` = Tupel: (ring, cell)\n",
    "* `board` = Liste aus 3 Listen, die angeben, ob, und wenn ja welcher Stein dort sitzt. Dabei symbolisiert jede Liste einen Ring. In jeder Liste sind neun Werte. Je einer für eine Zelle im Ring. Eine 0 sagt dabei aus, dass an der entsprechenden Position kein Stein ist. Eine 1 oder 2 stehen für einen Stein des zugehörigen Spielers.\n",
    "* `remaining` = \\[Anzahl noch nicht gesetzter Steine Spieler 1, Anzahl noch nicht gesetzte Steine Spieler 2\\]\n",
    "* `state` = \\[remaining, board\\]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importe\n",
    "Zur Visualisierung des Spielbrettes wird [ipycanvas](https://ipycanvas.readthedocs.io/en/latest/index.html) verwendet. Die Statusanzeigen sind Widgets der [ipywidget-Library](https://ipywidgets.readthedocs.io/en/latest/index.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run ./Muehle_Logic.ipynb\n",
    "%run ./Muehle_Algo.ipynb\n",
    "import ipycanvas\n",
    "from ipycanvas import MultiCanvas\n",
    "\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "\n",
    "from IPython.display import clear_output\n",
    "from pathlib import Path\n",
    "import time\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Konstanten\n",
    "\n",
    "Um den Quellcode besser les- und wartbar zu machen, werden einige Konstanten definiert.\n",
    "Für das Aussehen des Spielfelds:\n",
    "* `BOARD_SIZE` = Größe des Spielfeldes in Pixeln\n",
    "* `DOT_RADIUS` = Radius der schwarzen kleinen Punkte, die mögliche Positionen markieren (in Abhängigkeit von der Spielfeldgröße)\n",
    "* `PIECE_RADIUS` = Radius der Spielsteine\n",
    "* `COLOUR` = Farben der [dots, pieces_player_1, pieces_player_2]\n",
    "* `COLOUR_HINT` = Farbe, in der mögliche Zielfelder markiert werden\n",
    "* `COLOUR_OPPONENT` = Farbe, in der entfernbare Steine markiert werden\n",
    "* `PADDING` = relativer Abstand des äußersten Quadrats zum Spielfeldrand\n",
    "* `DISTANCE` = relativer Abstand zwischen den Quadraten des Spielfelds\n",
    "* `TRANSPARENCY_DEFAULT` = Standardwert für die Transparenz\n",
    "* `TRANSPARENCY_HINT` = Transparenz der Kreise möglicher Zielfelder und entfernbarer Steine\n",
    "\n",
    "Für die Funktion des Spielfelds:\n",
    "* `PLAYER` = Liste der Spieler\n",
    "* `PLAYER_COLOUR` = Liste der Spielsteinfarben der Spieler\n",
    "* `START_STATE` = Startzustand des Spielfelds, beide Spieler haben noch keinen Stein gesetzt und das Spielfeld ist leer\n",
    "* `MAX_MOVES_WITHOUT_MILL` = Anzahl der erlaubten Halbzüge, ohne dass eine Mühle entsteht. Ist das Limit überschritten, endet das Spiel unentschieden (Ein Zug = zwei Halbzüge = eine Aktion von weiß und eine Aktion von schwarz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aussehen\n",
    "BOARD_SIZE      = 400\n",
    "DOT_RADIUS      = BOARD_SIZE * 0.025\n",
    "PIECE_RADIUS    = BOARD_SIZE * 0.04\n",
    "COLOUR          = ['black', 'white', 'sienna']\n",
    "COLOUR_HINT     = 'green'\n",
    "COLOUR_OPPONENT = 'red'\n",
    "PADDING         = 0.05\n",
    "DISTANCE        = 0.15\n",
    "TRANSPARENCY_DEFAULT = 1.0\n",
    "TRANSPARENCY_HINT    = 0.5\n",
    "\n",
    "# Spiel\n",
    "PLAYER          = [1, 2]\n",
    "PLAYER_COLOUR   = ['Weiß', 'Braun']\n",
    "START_STATE     = [[9, 9], [          # Anzahl zu setzender Steine (Spieler_1 (Weiß), Spieler_2 (Braun))\n",
    "                  [0, 0, 0, 0, 0, 0, 0, 0], # ring 0\n",
    "                  [0, 0, 0, 0, 0, 0, 0, 0], # ring 1\n",
    "                  [0, 0, 0, 0, 0, 0, 0, 0]  # ring 2\n",
    "                  ]]    \n",
    "MAX_MOVES_WITHOUT_MILL = 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Die Funktion `row()` liefert einen relativen Wert für die Position der eingegebenen Reihe. `col()` macht dies für die Spalten. Der Eingabeparameter `number` gibt dabei an, die wievielte Zeile von oben bzw. die wievielte Spalte von links ausgegeben werden soll. Der Rückgabewert ist eine rationale Zahl zwischen 0,05 und 0,95. Multipliziert mit der Spielfeldbreite bzw. -höhe ergibt sich die absolute Position der Ecken und Schnittpunkte der Spielfeldlinien."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reihe von oben nach unten (0-6)\n",
    "def row(number):\n",
    "    return PADDING + DISTANCE * number\n",
    "#Spalte von links nach rechts (0-6)\n",
    "def col(number):\n",
    "    return row(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`POSITIONS` beschreibt die möglichen Punkte, an denen Steine sitzen können. Der Aufruf der Positionen erfolgt gemäß der oben vorgestellten Notation im Format `POSITIONS[ring][cell]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "POSITIONS = [([col(0), row(0)], [col(3), row(0)], [col(6), row(0)], [col(6), row(3)], [col(6), row(6)], [col(3), row(6)], [col(0), row(6)], [col(0), row(3)]), #ring 0\n",
    "             ([col(1), row(1)], [col(3), row(1)], [col(5), row(1)], [col(5), row(3)], [col(5), row(5)], [col(3), row(5)], [col(1), row(5)], [col(1), row(3)]), #ring 1\n",
    "             ([col(2), row(2)], [col(3), row(2)], [col(4), row(2)], [col(4), row(3)], [col(4), row(4)], [col(3), row(4)], [col(2), row(4)], [col(2), row(3)])] #ring 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zeichenfunktionen\n",
    "`init_canvas()` zeichnet das Spielfeld. Dies erfolgt mit Hilfe von ipycanvas. Das Spielbrett (`canvas`) besteht aus drei übereinanderliegenden Ebenen. Ebene 0 ist der Hintergrund, ein beiges Quadrat. Ebene 1 beinhaltet die schwarzen Striche und Punkte auf dem Spielfeld. Diese setzen sich aus drei schwarzen Quadraten, vier horizontalen bzw. waagrechten Linien und 24 Punkten an den Kreuzungen der Linien, die die möglichen Positionen der Steine markieren, zusammen. Dabei wird bei der Erstellung mit relativen Positionsangaben gearbeitet, um das Spielfeld einfach skalieren zu können. In der Ebene 2 liegen schließlich die Spielsteine. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_canvas():\n",
    "    #canvas[Hintergrund, Linien, Steine]\n",
    "    canvas = MultiCanvas(3, width = BOARD_SIZE, height = BOARD_SIZE)\n",
    "\n",
    "    # Hintergrund\n",
    "    canvas[0].fill_style = '#ffffcc'\n",
    "    canvas[0].fill_rect(0, 0, BOARD_SIZE)\n",
    "\n",
    "    # Strichstärke\n",
    "    canvas[1].line_width = 5\n",
    "\n",
    "    # Quadrate\n",
    "    canvas[1].stroke_rect(BOARD_SIZE * col(0), BOARD_SIZE * row(0), BOARD_SIZE * (1 - 2 * row(0))) #ring 0\n",
    "    canvas[1].stroke_rect(BOARD_SIZE * col(1), BOARD_SIZE * row(1), BOARD_SIZE * (1 - 2 * row(1))) #ring 1\n",
    "    canvas[1].stroke_rect(BOARD_SIZE * col(2), BOARD_SIZE * row(2), BOARD_SIZE * (1 - 2 * row(2))) #ring 2\n",
    "\n",
    "    # Mittelinien\n",
    "    canvas[1].begin_path()\n",
    "    canvas[1].move_to(BOARD_SIZE * col(3), BOARD_SIZE * row(0)) #oben\n",
    "    canvas[1].line_to(BOARD_SIZE * col(3), BOARD_SIZE * row(2))\n",
    "    canvas[1].move_to(BOARD_SIZE * col(6), BOARD_SIZE * row(3)) #rechts\n",
    "    canvas[1].line_to(BOARD_SIZE * col(4), BOARD_SIZE * row(3))\n",
    "    canvas[1].move_to(BOARD_SIZE * col(3), BOARD_SIZE * row(6)) #unten\n",
    "    canvas[1].line_to(BOARD_SIZE * col(3), BOARD_SIZE * row(4))\n",
    "    canvas[1].move_to(BOARD_SIZE * col(0), BOARD_SIZE * row(3)) #links\n",
    "    canvas[1].line_to(BOARD_SIZE * col(2), BOARD_SIZE * row(3))\n",
    "    canvas[1].stroke()\n",
    "\n",
    "    # Punkte (außen, mitte, innen)\n",
    "    for ring in POSITIONS:\n",
    "        for x, y in ring:\n",
    "            canvas[1].fill_arc(BOARD_SIZE * x, BOARD_SIZE * y, DOT_RADIUS, 0, 360)\n",
    "    return canvas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion `draw_piece()` zeichnet an einer zu übergebenen Position einen Spielstein für den eingegebenen Spieler. Dieser besteht aus einem mit der Spielerfarbe gefüllten Kreis als Hintergrund und zwei Innenringen um die Steine realistischer aussehen zu lassen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_piece(canvas, ring, cell, player):\n",
    "    #Hintergrund\n",
    "    canvas[2].fill_style = COLOUR[player]\n",
    "    canvas[2].fill_arc(BOARD_SIZE * POSITIONS[ring][cell][0], BOARD_SIZE * POSITIONS[ring][cell][1], PIECE_RADIUS, 0, 360)\n",
    "    \n",
    "    #Ringe\n",
    "    canvas[2].stroke_style = 'silver' if player == 1 else 'chocolate'\n",
    "        \n",
    "    canvas[2].stroke_arc(BOARD_SIZE * POSITIONS[ring][cell][0], BOARD_SIZE * POSITIONS[ring][cell][1], PIECE_RADIUS,       0, 360)\n",
    "    canvas[2].stroke_arc(BOARD_SIZE * POSITIONS[ring][cell][0], BOARD_SIZE * POSITIONS[ring][cell][1], PIECE_RADIUS * 0.7, 0, 360)\n",
    "    canvas[2].stroke_arc(BOARD_SIZE * POSITIONS[ring][cell][0], BOARD_SIZE * POSITIONS[ring][cell][1], PIECE_RADIUS * 0.3, 0, 360)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit Hilfe von `highlight_positions()` werden alle Positionen aus einer Liste mit einem transparenten Kreis markiert. Falls keine andere Farbe übergeben wird, wird die in den Konstanten definierte default-Farbe verwendet. Diese Funktion kann verwendet werden, um die schlagbaren Steine des Gegners oder die möglichen Zugpositionen zu bestimmen. Wenn `just_inner` True ist, dann wird nur das innere des Steins markiert. Dies wird verwendet, um den zuletzt bewegten Stein zu markieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def highlight_positions(canvas, highlight_positions, colour = COLOUR_HINT, just_inner = False):\n",
    "    with ipycanvas.hold_canvas(canvas):\n",
    "        for (ring, cell) in highlight_positions:\n",
    "            if(ring, cell) != (None, None):\n",
    "                canvas[2].fill_style = colour\n",
    "                canvas[2].global_alpha = TRANSPARENCY_HINT\n",
    "                radius = PIECE_RADIUS if not just_inner else PIECE_RADIUS * 0.3\n",
    "                canvas[2].fill_arc(BOARD_SIZE * POSITIONS[ring][cell][0], BOARD_SIZE * POSITIONS[ring][cell][1], radius, 0, 360)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion `show_start_button()` zeichnet auf dem Spielfeld ein Rechteck, dass das Wort \"Start\" enthält und optisch einem Button ähnelt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_start_button(canvas):\n",
    "    with ipycanvas.hold_canvas(canvas):\n",
    "        # Hintergrund\n",
    "        canvas[2].clear()\n",
    "        canvas[2].fill_style = 'black'\n",
    "        canvas[2].global_alpha = TRANSPARENCY_HINT\n",
    "        canvas[2].fill_rect(0, 0, BOARD_SIZE, BOARD_SIZE)\n",
    "        \n",
    "        # Button\n",
    "        canvas[2].global_alpha = TRANSPARENCY_DEFAULT\n",
    "        canvas[2].shadow_color = 'black'\n",
    "        canvas[2].shadow_offset_x = 5\n",
    "        canvas[2].shadow_offset_y = 5\n",
    "        canvas[2].shadow_blur = 5\n",
    "        canvas[2].fill_style = 'silver'\n",
    "        canvas[2].fill_rect(BOARD_SIZE/3, (BOARD_SIZE/5)*2, BOARD_SIZE/3, height=BOARD_SIZE/5)\n",
    "        \n",
    "        canvas[2].shadow_offset_x = 0\n",
    "        canvas[2].shadow_offset_y = 0\n",
    "        canvas[2].shadow_blur = 0\n",
    "        \n",
    "        canvas[2].stroke_style = 'black'\n",
    "        canvas[2].stroke_rect(BOARD_SIZE/3, (BOARD_SIZE/5)*2, BOARD_SIZE/3, height=BOARD_SIZE/5)\n",
    "        \n",
    "        # Text\n",
    "        canvas[2].fill_style = 'black'\n",
    "        canvas[2].font = '30px Arial'\n",
    "        canvas[2].fill_text('Start', BOARD_SIZE/2 *0.83, BOARD_SIZE/2*1.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Die Klasse Game - Status des Spielfelds\n",
    "Die Klasse `Game` speichert die aktuelle Situation des Spielfeldes. Die `__init__()` Funktion setzt die Werte der Game-Klasse. Dabei kann falls notwendig der aktuelle Spieler übergeben werden, falls beispielsweise Spieler 2 starten soll. Standardmäßig wird als Zustand der Startzustand übergeben, wobei davon zuvor eine Deepcopy angefertigt werden muss. Dies ist notwendig, da ansonsten die Referenz auf `START_STATE` übergeben wird und die Konstante somit im Laufe des Spiel verändert werden würde. Außerdem kann angegeben werden, dass die Spieler statt manuell zu spielen einen Such-Algorithmus zur Bestimmung des nächsten Spiel-Zustands verwenden. Hierfür existieren die Variablen `mode_player_one` und `mode_player_two` die die gewünschte Option für Spieler 1 bzw. 2 angeben und folgende Werte annehmen können:\n",
    "* None = Der Spieler spielt manuell\n",
    "* 'minimax' = Der Spieler nutzt das Suchverfahren Minimax\n",
    "* 'alpha-beta' = Der Spieler nutzt das Suchverfahren Alpha-Beta-Pruning\n",
    "\n",
    "Die Klasse beinhaltet mehrere Variablen. `state` gibt wie in der Definition beschrieben an, ob und wenn ja welcher Stein sich an einer Position auf dem Spielfeld befindet. Dabei gilt:\n",
    "* 0 = kein Stein\n",
    "* 1 = weißer Stein\n",
    "* 2 = brauner Stein\n",
    "\n",
    "Außerdem beinhaltet die Variable Angaben über die Steine, die die beiden Spieler noch setzen können.\n",
    "`current_player` gibt an, welcher Spieler, 1 oder 2, gerade am Zug ist. `canvas` ist ein ipycanvas-Objekt, das mittels `init_canvas()` erzeugt wird. Es handelt sich dabei um die visuelle Ausgabe des Spielfeldes. In `number_pieces_to_remove` wird gespeichert, wie viele Steine der aktuelle Spieler aufgrund von Mühlen noch entfernen darf. `selected_piece` ist ein Tupel, das die Position eines ausgewählten Steins speichert. Dieses Tupel hat die Form `(ring, cell)`. Dies ist notwendig für Zug- und Springvorgänge. Ist die Variable ungleich `None`, befindet sich der Spieler gerade in einer Zug- oder Sprungaktion. Ist die Variable  belegt, so hat der Spieler bereits den zu versetzenden Stein ausgewählt und muss noch auf das Zielfeld klicken. Die Position ist in Phase 2 des Spiels relevant, um valide Zielfelder zu ermitteln. In der Phase 1 kann es vorkommen, dass kein Stein gesetzt wird, weil kein passendes Feld ausgewählt wurde, um zu verhindern, dass der Spieler trotzdem wechselt, wird die Variable `do_not_change` auf True gesetzt und diese vor Spielerwechsel abgefragt. Das Gleiche geschieht in den Phasen 2 und 3, falls kein passender Stein ausgewählt wird. Die Form `(ring, cell)` hat auch die Variable `moved_piece`, die speichert, welcher Stein zuletzt bewegt wurde. `winner` ist None, solange das Spiel noch läuft. Ansonsten gilt:\n",
    "* winner = 0: Unentschieden\n",
    "* winner = 1: Spieler 1 hat gewonnen\n",
    "* winner = 2: Spieler 2 hat gewonnen\n",
    "\n",
    "Die Variable `pause` ist nur direkt nach der Initialisierung `True`. Beim ersten Klicken auf das Spielfeld, dem Starten des Spiels, wird sie auf `False` gesetzt. Dies ist notwendig, um die Berechnung des nächsten Zustands anzustoßen, falls der erste Zug durch einen Such-Algorithmus erfolgt.\n",
    "\n",
    "`moves_without_mill` gibt an, wie viele Halbzüge (ein schwarzer Zug oder ein weißer Zug) getätigt wurden, ohne dass eine Mühle entstanden ist.\n",
    "Die Variable `savegame` ist eine Liste, in der der Spielverlauf in Form der aufeinander folgenden Zustände abgelegt wird. Initiiert wird diese Liste deshalb mit dem Startzustand. Die Variable `saved` ist ein Indikator dafür, ob das aktuelle Spiel bereits gesichert wurde.\n",
    "\n",
    "Ein Spieler kann entweder eine menschliche Person oder ein Such-Algorithmus sein. Als Algorithmen sind Minimax und Alpha-Beta-Pruning implementiert. Standardmäßig sind Spieler reale Personen. Um was es sich handelt, ist in den Variablen `mode_player_one` und `mode_player_two` gespeichert.\n",
    "\n",
    "Zur späteren Auswertung im Bezug auf die Performance werden hier folgende Variablen initialisiert:\n",
    "* `ab_moves` = Anzahl der mit dem Alpha-Beta-Algorithmus getätigten Züge\n",
    "* `ab_time`  = Akkumulierte Rechenzeit des Alpha-Beta-Algorithmus\n",
    "* `mm_moves` = Anzahl der mit dem Minimax-Algorithmus getätigten Züge\n",
    "* `mm_time`  = Akkumulierte Rechenzeit des Minimax-Algorithmus\n",
    "\n",
    "Zur Steuerung der Suchtiefe der Algorithmen dienen folgende Variablen:\n",
    "* `ab_depth` = Suchtiefe des Alpha-Beta-Algorithmus\n",
    "* `mm_depth` = Suchtiefe des Minimax-Algorithmus\n",
    "\n",
    "Nach der Initialisierung der Variablen wird noch festgelegt, dass bei einem Klick auf das Spielfeld die klasseneigene Funktion `play_game()` aufgerufen wird. Diese wird gleich noch definiert.\n",
    "\n",
    "Mit Hilfe der Funktion `__str__()` kann der Status später mit dem Befehl `print(Game)` formatiert ausgegeben werden. Dies ist besonders zum Überprüfen des aktuellen Spielstandes hilfreich."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Game():\n",
    "    def __init__(self, current_player = 1, mode_player_one = None, mode_player_two = None):\n",
    "        self.state          = copy.deepcopy(START_STATE)\n",
    "        self.current_player = current_player\n",
    "        self.canvas         = init_canvas()\n",
    "        self.number_pieces_to_remove = 0\n",
    "        self.selected_piece = (None, None)\n",
    "        self.moved_piece    = (None, None)\n",
    "        self.do_not_change  = False\n",
    "        self.winner         = None\n",
    "        self.pause          = True\n",
    "        self.moves_without_mill      = 0\n",
    "        self.savegame       = [copy.deepcopy(START_STATE)]\n",
    "        self.saved          = False\n",
    "        \n",
    "        self.mode_player_one = mode_player_one \n",
    "        self.mode_player_two = mode_player_two\n",
    "        \n",
    "        self.canvas[2].on_mouse_down(self.play_game)\n",
    "\n",
    "        self.ab_moves    = 0\n",
    "        self.ab_time     = 0\n",
    "        self.mm_moves    = 0\n",
    "        self.mm_time     = 0\n",
    "\n",
    "        self.ab_depth    = 6\n",
    "        self.mm_depth    = 5\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"state: \" + str(self.state) \\\n",
    "            + \"\\nmode player 1: \" + str(self.mode_player_one) \\\n",
    "            + \"\\nmode player 2: \" + str(self.mode_player_two) \\\n",
    "            + \"\\ncurrent player: \" + str(self.current_player) \\\n",
    "            + \"\\nnumber pieces to remove: \" + str(self.number_pieces_to_remove) \\\n",
    "            + \"\\nselected piece: \" + str(self.selected_piece) \\\n",
    "            + \"\\nmoved piece: \" + str(self.moved_piece) \\\n",
    "            + \"\\ndo not change: \" + str(self.do_not_change) \\\n",
    "            + \"\\nwinner: \" + str(self.winner) \\\n",
    "            + \"\\npause: \" + str(self.pause) \\\n",
    "            + \"\\nmoves without mill: \" + str(self.moves_without_mill)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion `play_game()` der Klasse `Game` steuert das Spiel. Sie wird später aufgerufen, wenn der Spieler irgendwo hin klickt. Dabei werden die Variablen `x` und `y` übergeben, die die relative Position auf der Leinwand in x- bzw. y-Richtung ausgehend von der oberen linken Ecke liefern. Wenn das Spiel noch nicht vorbei ist, wird überprüft, ob das Spiel gerade pausiert ist. Das ist beim ersten Klicken der Fall, in welchem dann auch die Funktion `first_click()` aufgerufen wird. Bei jedem weiteren Klick wird überprüft, ob dieser an einer Position, also im Bereich um einen schwarzen Punkt, erfolgt ist. Wenn nein, wird gegebenenfalls die Auswahl eines Steins zurückgesetzt, um einen Wechsel des zu setzenden Steins zu ermöglichen. Handelt es sich bei dem angeklickten Stein um einen eigenen, wird dieser als neue Auswahl angenommen.  Wenn ja, kann eine der folgenden Situationen eintreten, wobei die erste aufgelistete Situation Priorität hat:\n",
    "1. **Es müssen noch Steine entfernt werden**  - Aufgrund von Mühlen, die zuvor geschlossen wurden, dürfen noch Steine entfernt werden. Der zuvor geklickte Stein wird der Funktion `remove_piece()` übergeben, die ihn vom Spielfeld löscht.\n",
    "2. **Der Spieler befindet sich in Phase 1** - Auf die ausgewählte Position wird mit Hilfe von `place_piece()` ein Stein gesetzt.\n",
    "3. **Es wurde ein Stein ausgewählt** - Da sich der Spieler in der Zug- oder Springphase befindet, handelt es sich bei dem ausgewählten Feld um ein Zielfeld, auf das der zuvor ausgewählte Stein mittels `move_piece()` bewegt wird.\n",
    "4. **Es wurde zuvor kein Stein ausgewählt** - Da sich der Spieler wie zuvor überprüft nicht in Phase 1 und somit in der Zug- oder Springphase befindet, und bisher kein Startfeld ausgewählt wurde, kann dies nun geschehen. Dazu wird die Funktion `select_piece()` aufgerufen.\n",
    "Nach dem Abarbeiten der Situationen übernimmt `finish_move()` letzte Aktionen, wie das Überprüfen, ob das Spiel beendet ist, den Spielerwechsel oder das Anzeigen von entfernbaren Steinen. `algo_step()` wird aufgerufen, um zu überprüfen, ob der nächste Zug ein Zug der KI ist, der gegebenenfalls ausgeführt werden muss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_game(self, x, y):\n",
    "    self.check_if_finished()\n",
    "    if self.winner != None: return\n",
    "    if self.pause: self.first_click(); return \n",
    "    \n",
    "    old_state = copy.deepcopy(self.state)\n",
    "    phase     = get_player_phase(self.state, self.current_player)\n",
    "    piece     = self.get_clicked_piece(x, y)\n",
    "    if piece != None: (ring, cell) = piece \n",
    "    \n",
    "    # Steinauswahl zurücksetzen\n",
    "    if piece == None and self.number_pieces_to_remove == 0:\n",
    "        self.selected_piece = (None, None)\n",
    "        self.update_canvas()\n",
    "        return\n",
    "    \n",
    "    # Steinauswahl wechseln\n",
    "    if self.selected_piece != (None, None) and self.state[1][ring][cell] == self.current_player: self.select_piece(piece); return\n",
    "        \n",
    "    # Situationen überprüfen\n",
    "    if self.number_pieces_to_remove > 0:      self.remove_piece(piece) # Situation 1\n",
    "    elif phase == 1:                          self.place_piece(piece)  # Situation 2\n",
    "    elif self.selected_piece != (None, None): self.move_piece(piece)   # Situation 3\n",
    "    else:                                     self.select_piece(piece) # Situation 4\n",
    "\n",
    "    self.finish_move(old_state)\n",
    "    self.algo_step()\n",
    "Game.play_game = play_game\n",
    "del play_game"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion `first_click()` führt alle notwendigen Operationen nach klicken auf den Start-Button aus. Dies beinhaltet das Deaktivieren der Spielmodusauswahl sowie das überprüfen, ob ein Algorithmus als erstes dran ist. Ist dem so, führt dieser seinen Zug durch. Ansonsten wird das Spielbrett lediglich aktualisiert, um dem manuellen Spieler zu sagen, was er zu tun hat. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_click(self):\n",
    "    self.pause = False\n",
    "    gamemode_toggle_one.disabled = True\n",
    "    gamemode_toggle_two.disabled = True\n",
    "    self.update_canvas()\n",
    "    if self.alpha_beta_turn() or self.minimax_turn():\n",
    "        self.algo_step()\n",
    "Game.first_click = first_click\n",
    "del first_click"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`finish_move()` wird am Ende eines manuellen Zuges aufgerufen. Falls nach abarbeiten der Situationen noch Steine zu entfernen sind, werden diese markiert. Außerdem wird überprüft, ob das Spiel zu Ende ist. Falls sich der Spieler nicht in einem Zwischenzustand von Phase 2 oder 3 (Startfeld ausgewählt, Zielfeld noch nicht bekannt) befindet, keine Steine mehr entfernt werden müssen, das Spiel nicht zu Ende ist und vorher alle korrekt gelaufen ist, ist der nächste Spieler an der Reihe und das Spielfeld wird aktualisiert. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def finish_move(self, old_state):\n",
    "    if self.number_pieces_to_remove > 0:\n",
    "        self.update_canvas()\n",
    "        highlight_positions(self.canvas, get_opponent_beatable_pieces(self.state[1], self.current_player), colour = COLOUR_OPPONENT)\n",
    "\n",
    "    self.check_if_finished()\n",
    "\n",
    "    if self.selected_piece == (None, None) and not self.number_pieces_to_remove > 0 and self.winner == None and not self.do_not_change:\n",
    "        self.current_player = opponent(self.current_player) # Spielerwechsel, wenn nicht noch eine Aktion ausgeführt werden muss\n",
    "        self.moves_without_mill += 1\n",
    "        self.check_if_finished()                 \n",
    "        self.update_canvas()\n",
    "        highlight_positions(self.canvas, [self.moved_piece], \"blue\", just_inner = True)\n",
    "Game.finish_move = finish_move\n",
    "del finish_move"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die beiden folgenden Methoden überprüfen, ob einer der beiden Algorithmen gerade an der Reihe ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alpha_beta_turn(self):\n",
    "    return (self.current_player == 1 and self.mode_player_one == \"alpha-beta\") or (self.current_player == 2 and self.mode_player_two == \"alpha-beta\")\n",
    "Game.alpha_beta_turn = alpha_beta_turn\n",
    "del alpha_beta_turn\n",
    "\n",
    "def minimax_turn(self):\n",
    "    return (self.current_player == 1 and self.mode_player_one == \"minimax\") or (self.current_player == 2 and self.mode_player_two == \"minimax\")\n",
    "Game.minimax_turn = minimax_turn\n",
    "del minimax_turn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion `get_clicked_piece()` der Klasse `Game` überprüft, ob die übergebenen x- und y- Koordinaten auf einer validen Position, also einem Spielfeldpunkt liegen. Wenn ja, wird diese Position in der Form `(ring, cell)` zurückgegeben, ansonsten `None`. Zur Ermittlung wird über alle möglichen Positionen iteriert und geprüft, ob die Klick-Koordinaten in einem Pufferbereich rund um den Mittelpunkt der Position liegen. Ist dies für beide Koordinaten der Fall, wurde der angeklickte Punkt gefunden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_clicked_piece(self, x, y):\n",
    "    piece = None\n",
    "    for ring in POSITIONS:\n",
    "        for pos in ring:\n",
    "            check_x = pos[0] * BOARD_SIZE - PIECE_RADIUS < x < pos[0] * BOARD_SIZE + PIECE_RADIUS\n",
    "            check_y = pos[1] * BOARD_SIZE - PIECE_RADIUS < y < pos[1] * BOARD_SIZE + PIECE_RADIUS\n",
    "            if check_x and check_y:\n",
    "                piece = (POSITIONS.index(ring), ring.index(pos))\n",
    "    return piece\n",
    "Game.get_clicked_piece = get_clicked_piece\n",
    "del get_clicked_piece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Phase 1 wird durch `place_piece()` der Klasse `Game` überprüft, ob das angeklickte Feld noch frei ist. Wenn ja, wird dort ein Stein des Spielers positioniert und die eigene Steinanzahl in `remaining` um 1 reduziert. Um zu überprüfen, ob bei der Aktion neue Mühlen entstanden sind, wird vor und nach dem Setzen des Steins alle Mühlen gesucht. Anschließend wird geprüft, ob und wenn ja, wie viele, neue Mühlen sich in der Menge der Mühlen nach dem Setzen des Steins befinden. Dies ist notwendig, um zu ermitteln, wie viele Steine des Gegners entfernt werden dürfen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def place_piece(self, piece):\n",
    "    remaining, board = self.state\n",
    "    if piece in empty_positions(board):\n",
    "        self.do_not_change = False\n",
    "        ring, cell = piece\n",
    "        board[ring][cell] = self.current_player\n",
    "        remaining[self.current_player - 1] -= 1 \n",
    "        self.moved_piece = piece\n",
    "        self.number_pieces_to_remove = len(find_new_mills(board, piece))\n",
    "        self.update_canvas()\n",
    "    else:\n",
    "        self.do_not_change = True\n",
    "        change_status_label('Du kannst Deinen Stein nur auf ein leeres Feld setzen. Bitte probiere es erneut!')\n",
    "Game.place_piece = place_piece\n",
    "del place_piece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`remove_piece()` der Klasse `Game` entfernt den übergebenen Stein vom Spielfeld, falls es erlaubt ist, diesen zu entfernen. Dazu  werden alle schlagbaren Steine des Gegners ermittelt und überprüft, ob der angeklickte Stein dazu gehört. Ist dies der Fall, wird der Stein entfernt, indem an dieser Stelle eine `0` eingetragen wird. Andernfalls wird eine Fehlermeldung geworfen und der Spieler kann einen anderen Stein zum Entfernen auswählen. Falls noch mehr Steine entfernt werden müssen, werden die möglichen Positionen am Ende markiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_piece(self, piece):\n",
    "    _, board = self.state\n",
    "    ring, cell = piece\n",
    "    beatable_pieces = get_opponent_beatable_pieces(board, self.current_player)\n",
    "    if piece in beatable_pieces:\n",
    "        board[ring][cell] = 0\n",
    "        self.number_pieces_to_remove -= 1\n",
    "        self.update_canvas()\n",
    "    else:\n",
    "        change_status_label('Du kannst diesen Stein nicht entfernen. Bitte probiere es erneut!')\n",
    "    if self.number_pieces_to_remove > 0:\n",
    "        highlight_positions(self.canvas, get_opponent_beatable_pieces(board, self.current_player), colour = COLOUR_OPPONENT)\n",
    "        \n",
    "    self.moves_without_mill = -1\n",
    "Game.remove_piece = remove_piece\n",
    "del remove_piece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`move_piece()` der Klasse `Game` bewegt den zuvor ausgewählten Stein, falls zulässig, auf die übergebene Position. Das Startfeld ist dabei in der Variable `selected_piece` gespeichert. Damit das Zielfeld valide ist, muss es in der Liste sein, die durch `next_positions()` ausgehend vom ausgewählten Stein ermittelt werden. Ist dies der Fall, wird das alte Feld auf `0` gesetzt und das Zielfeld mit dem Wert des aktuellen Spielers belegt. Um zu überprüfen, ob bei der Aktion neue Mühlen entstanden sind, wird vor und nach dem Versetzen des Steins alle Mühlen gesucht. Anschließend wird geprüft, ob und wenn ja, wie viele, neue Mühlen sich in der Menge der Mühlen nach dem Bewegen des Steins befinden. Dies ist notwendig, um zu ermitteln, wie viele Steine des Gegners entfernt werden dürfen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def move_piece(self, piece):\n",
    "    _, board = self.state\n",
    "    start_ring, start_cell = self.selected_piece\n",
    "    goal_ring,  goal_cell  = piece\n",
    "    possible_positions = next_positions(self.state, self.current_player, start_ring, start_cell)\n",
    "    if piece in possible_positions:\n",
    "        board[start_ring][start_cell] = 0\n",
    "        board[goal_ring] [goal_cell]  = self.current_player\n",
    "        self.moved_piece = piece\n",
    "        self.number_pieces_to_remove = len(find_new_mills(board, piece))\n",
    "        self.selected_piece = (None, None)\n",
    "        self.update_canvas()\n",
    "    else:\n",
    "        change_status_label('Du kannst Deinen Stein nicht auf dieses Feld setzen. Bitte probiere es erneut!')\n",
    "Game.move_piece = move_piece\n",
    "del move_piece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Falls sich der Spieler in der Zug- oder Springphase befindet, und noch kein Startfeld ausgewählt wurde, wird `select_piece()` der Klasse `Game` aufgerufen. Diese Funktion überprüft, ob der übergebene Stein ein eigener Stein ist. Wenn ja wird er in der Variable `selected_piece` gespeichert und ausgehend davon mögliche Zielfelder berechnet, um diese hervorheben zu können. Nach erfolgreicher Durchführung befindet sich der Spieler in einem Zwischenzustand, da das Zielfeld noch nicht bekannt ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_piece(self, piece):\n",
    "    if piece in player_pieces(self.state[1], self.current_player):\n",
    "        self.do_not_change = False\n",
    "        self.selected_piece = piece\n",
    "        change_status_label('Zielort für den eigenen Stein auswählen.')\n",
    "        ring, cell = piece\n",
    "        possible_positions = next_positions(self.state, self.current_player, ring, cell)\n",
    "        self.update_canvas()\n",
    "        highlight_positions(self.canvas, possible_positions)\n",
    "    else:\n",
    "        self.do_not_change = True\n",
    "        change_status_label('Das ist nicht Dein Stein. Bitte probiere es erneut!')\n",
    "Game.select_piece = select_piece\n",
    "del select_piece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Funktion `algo_step()` der Klasse `Game` führt einen Zug aus, falls der aktuelle Spieler ein Algorithmus ist. Als Algorithmen stehen Alpha-Beta-Pruning und Minimax zur Verfügung. Dazu wird zunächst überprüft, ob nicht vielleicht das Spiel schon beendet ist. In diesem Fall würde gar nichts geschehen. Andernfalls wird geprüft, um welchen Algorithmus es sich handelt. Anschließend wird die entsprechende Funktion aufgerufen, die den nächsten Zustand berechnet und ausgibt. Dies ist entweder `alpha_beta_pruning()` oder `minimax()`. Der Zustand des Spiels wird auf den berechneten Zustand gesetzt und es wird geprüft, ob das Spiel mit dem Zug beendet wurde. Der Spieler wechselt und das Spielbrett wird aktualisiert. Falls das Spiel noch nicht beendet ist, wird die Funktion nochmal aufgerufen, da der nächste Spieler ebenfalls ein Such-Algorithmus sein könnte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def algo_step(self):\n",
    "    start = time.time()\n",
    "    self.check_if_finished()\n",
    "    if self.winner != None: return\n",
    "    number_opponent_stones_before = count_player_pieces(self.state[1], opponent(self.current_player))\n",
    "    old_state = copy.deepcopy(self.state)\n",
    "    if self.alpha_beta_turn():\n",
    "        change_status_label(\"Der Computer rechnet noch... Ein Moment bitte.\")\n",
    "        value, self.state = alpha_beta_pruning(self.state, self.current_player, depth=self.ab_depth)\n",
    "        self.ab_time += (time.time()-start)\n",
    "        self.ab_moves += 1\n",
    "    elif self.minimax_turn():\n",
    "        change_status_label(\"Der Computer rechnet noch... Ein Moment bitte.\")\n",
    "        value, self.state = minimax(self.state, self.current_player, depth=self.mm_depth)\n",
    "        self.mm_time += (time.time()-start)\n",
    "        self.mm_moves += 1\n",
    "    else:\n",
    "        return\n",
    "    number_opponent_stones_after = count_player_pieces(self.state[1], opponent(self.current_player))\n",
    "    if number_opponent_stones_before > number_opponent_stones_after:\n",
    "        self.moves_without_mill = -1 # Reset\n",
    "    self.moves_without_mill += 1\n",
    "    \n",
    "    moved_piece = get_moved_piece(old_state[1], self.state[1], self.current_player)\n",
    "                                                       \n",
    "    self.check_if_finished()\n",
    "    end = time.time()\n",
    "    change_time_label(end-start)\n",
    "    change_value_label(value)\n",
    "    self.current_player = opponent(self.current_player)\n",
    "    self.update_canvas()\n",
    "    highlight_positions(self.canvas, [moved_piece], \"blue\", just_inner = True)\n",
    "    if self.winner == None: self.algo_step()\n",
    "Game.algo_step = algo_step\n",
    "del algo_step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`update_canvas()` zeichnet die obere Ebene des Spielbretts nach jeder Veränderung neu. So werden Positionsänderungen oder Hinweise zu möglichen Zielfeldern und schlagbaren Steinen sichtbar. Zusätzlich wird hier die Aktualisierung der Statusanzeige angestoßen. Falls das Spiel gerade pausiert ist, wird außerdem ein Start-Button eingeblendet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_canvas(self):\n",
    "    self.save_game()\n",
    "    gamemode_side_by_side = widgets.HBox([gamemode_toggle_one, gamemode_toggle_two])\n",
    "    one_below_other       = widgets.VBox([gamemode_side_by_side, turn_label, status_label, mill_label, pieces_status_label, pieces_player_one, pieces_player_two,\\\n",
    "                                          cache_label, time_label, value_label, restart_button])\n",
    "    side_by_side          = widgets.HBox([self.canvas, one_below_other])\n",
    "    display(side_by_side)\n",
    "\n",
    "    with ipycanvas.hold_canvas(self.canvas):\n",
    "        self.canvas[2].clear()\n",
    "        self.canvas[2].global_alpha = TRANSPARENCY_DEFAULT\n",
    "        for ring in range(3):\n",
    "            for cell in range(8):\n",
    "                value = self.state[1][ring][cell]\n",
    "                if value in PLAYER: draw_piece(self.canvas, ring, cell, value) \n",
    "        update_status_widgets(self)    \n",
    "    if self.pause == True:\n",
    "        show_start_button(self.canvas)\n",
    "Game.update_canvas = update_canvas\n",
    "del update_canvas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`check_if_finished()`prüft, ob das Spiel zu Ende ist und setzt gegebenenfalls den Gewinner. Falls die Maximalanzahl der Züge ohne Mühle erreicht wurde, endet das Spiel unentschieden. Mit Hilfe von `finished()` wird überprüft, ob es sich um einen Terminal-Zustand handelt. Wenn ja, ermittelt `utility()`, ob der aktuelle Spieler oder der Gegner der Gewinner ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_if_finished(self):\n",
    "    if self.moves_without_mill >= MAX_MOVES_WITHOUT_MILL:\n",
    "        self.winner = 0\n",
    "        self.update_canvas()\n",
    "    elif finished(self.state, self.current_player):\n",
    "        util = utility(self.state, self.current_player)\n",
    "        if   util ==  0:\n",
    "            self.winner = 0\n",
    "        elif util ==  1:\n",
    "            self.winner = self.current_player\n",
    "        elif util == -1:\n",
    "            self.winner = opponent(self.current_player)\n",
    "        self.update_canvas()\n",
    "Game.check_if_finished = check_if_finished\n",
    "del check_if_finished"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Methode `save_game()` wird von `update_canvas()` aufgerufen und speichert die Zugfolge in einer Liste. Nach dem Spielende wird dieser Spielverlauf als Text-Datei im Ordner \"savegames\" abgelegt. Falls dieser noch nicht existiert, wird er zunächst erstellt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_game(self):\n",
    "    if self.state != self.savegame[-1]:\n",
    "        self.savegame.append(copy.deepcopy(self.state))\n",
    "    if self.winner != None and self.saved == False:\n",
    "        Path(\"savegames\").mkdir(parents=True, exist_ok=True)\n",
    "        filename = 'savegames/savegame_' + str(time.time()) + '.txt'\n",
    "        f = open(filename,'w')\n",
    "        f.write('Game: ' + str(gamemode_toggle_one.value)+ ' vs. ' + str(gamemode_toggle_two.value)+' | Winner = ' + str(self.winner)+'\\n')\n",
    "        for state in self.savegame:\n",
    "            f.write(str(state)+'\\n')\n",
    "        f.close()\n",
    "        self.saved = True\n",
    "\n",
    "Game.save_game= save_game\n",
    "del save_game"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Die Statusanzeige - Initialisierung und Funktionen der Status-Widgets und des Restart-Button\n",
    "\n",
    "Die Methode `restart()` wird durch den restart_button aufgerufen und setzt den Status des Spieles wieder zurück, indem eine neue Instanz der Klasse `Game` erzeugt und das Spielfeld anschließend aktualisiert wird. Außerdem wird die Spielmodusauswahl aktiviert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def restart(b):\n",
    "    gamemode_toggle_one.disabled = False\n",
    "    gamemode_toggle_one.value = None\n",
    "    gamemode_toggle_two.disabled = False\n",
    "    gamemode_toggle_two.value = None\n",
    "    global game\n",
    "    game = Game()\n",
    "    clear_output(wait = True)\n",
    "    game.update_canvas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Methoden `change_gamemode_one()` und `_two()` sind die Handler für das game_toggle-Widget und ändern den Spielmodus nach dem aktuellen Wert der gamemode_toggle-Widgets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_gamemode_one(change):\n",
    "    global game\n",
    "    game.mode_player_one = gamemode_toggle_one.value if gamemode_toggle_one.value != 'manually' else None\n",
    "        \n",
    "def change_gamemode_two(change):\n",
    "    global game\n",
    "    game.mode_player_two = gamemode_toggle_two.value if gamemode_toggle_two.value != 'manually' else None\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An dieser Stelle findet die Initialisierung der unterschiedlichen Statuselemente statt.\n",
    "*  Das `turn_label` ist ein Label, das den Spieler anzeigt, der aktuell an der Reihe ist\n",
    "*  Das `status_label` ist für weitere Statusanzeigen vorgesehen, wie die Aufforderung an den aktuellen Spieler, im Fall einer Mühle, einen Stein des Gegners zu entfernen.\n",
    "* Das `mill_label` zeigt an, wie viele Züge ohne Mühlen noch möglich sind.\n",
    "*  Das `pieces_status_label` zeigt je nach Spielphase entweder die Anzahl der Steine, die noch gesetzt werden können (Phase 1), oder die noch übrig sind (Phase 2 und 3). \n",
    "* Das `time_label` zeigt die Rechenzeit des Computers für den letzten Zug an.\n",
    "* Das `value_label` wird die Bewertung des vom Computer ermittelten Zustands wiedergeben.\n",
    "*  Der `restart_button` ruft die Methode `restart()` auf und setzt somit das Spiel auf den Startzustand zurück\n",
    "*  `pieces_player_one` und `pieces_player_two` zeigen jeweils einen horizontalen Balken, der in Phase 1 nach jedem gesetzten Stein kleiner wird, bis keiner mehr vorhanden ist. In Phase 2 und 3 ist die Auslenkung des Balkens von der Anzahl der Steine des jeweiligen Spielers abhängig. Somit ist schnell erkennbar, welcher Spieler gerade vorne liegt.\n",
    "* Die Dropdowns `gamemode_toggle_one` und `_two` ermöglichen die Auswahl des Spielmodus der beiden Spieler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "turn_label          = widgets.Label(value = 'X ist an der Reihe')\n",
    "status_label        = widgets.Label(value = 'Status:')\n",
    "mill_label          = widgets.Label(value = 'Verbleibende Halbzüge ohne Mühle: ')\n",
    "pieces_status_label = widgets.Label(value = 'Setzbare Steine:')\n",
    "cache_label         = widgets.Label(value = 'Zustände im Cache:')\n",
    "time_label          = widgets.Label(value = 'Rechenzeit Computer:')\n",
    "value_label         = widgets.Label(value = 'Wert:')\n",
    "\n",
    "restart_button      = widgets.Button(description = 'Neustart')\n",
    "restart_button.on_click(restart)\n",
    "\n",
    "pieces_player_one   = widgets.FloatProgress(value = 9, max = 9, min = 0, description = PLAYER_COLOUR[0], style={'bar_color': 'silver'})\n",
    "pieces_player_two   = widgets.FloatProgress(value = 9, max = 9, min = 0, description = PLAYER_COLOUR[1], style={'bar_color': COLOUR[2]})\n",
    "\n",
    "gamemode_toggle_one = widgets.Dropdown(\n",
    "                            options = [('Manuell', 'manually'), ('Alpha-Beta', 'alpha-beta'), ('Minimax', 'minimax')],\n",
    "                            value = 'manually', description='Spieler 1:',)\n",
    "\n",
    "gamemode_toggle_two = widgets.Dropdown(\n",
    "                            options = [('Manuell', 'manually'), ('Alpha-Beta', 'alpha-beta'), ('Minimax', 'minimax')],\n",
    "                            value = 'manually', description='Spieler 2:')\n",
    "gamemode_toggle_one.observe(change_gamemode_one, 'value')\n",
    "gamemode_toggle_two.observe(change_gamemode_two, 'value')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Methode `change_status_label()` nimmt einen beliebigen Status-Text entgegen und setzt diesen mit dem Präfix 'Status: ' als Text des `status_label`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_status_label(message):\n",
    "    status_label.value = 'Status: ' + message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Methode `change_time_label()` nimmt die Rechenzeit des Computers entgegen und setzt diesen mit einem Präfix und Suffix als Text des `time_label`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_time_label(time):\n",
    "    time_label.value = 'Rechenzeit Computer: ' + str(round(time, 2)) + ' Sekunden'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Methode `change_value_label()` nimmt den von der Heuristik ermittelten Wert des Computers entgegen und setzt diesen mit einem Präfix und Suffix als Text des `value_label`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_value_label(value):\n",
    "    value_label.value = 'Wert: ' + str(round(value, 3)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Methode `update_status_widgets()` aktualisiert die unterschiedlichen Statusanzeigen passend zur aktuellen Spielphase und den zuletzt getätigten bzw. erwarteten Aktionen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_status_widgets(self):\n",
    "    remaining, board = self.state\n",
    "    player = self.current_player\n",
    "    turn_label.value  = PLAYER_COLOUR[player - 1] + ' ist an der Reihe.'\n",
    "    cache_label.value = 'Zustände im Cache: Alpha-Beta: ' + str(len(Cache_AB)) + \", Minimax: \" + str(len(Cache_Memoize))\n",
    "    mill_label.value  = 'Verbleibende Halbzüge ohne Mühle: ' + str(MAX_MOVES_WITHOUT_MILL - self.moves_without_mill)\n",
    "    \n",
    "    phase = get_player_phase(self.state, player)\n",
    "    if phase == 1: change_status_label('Bitte einen Stein auf dem Spielfeld platzieren.')\n",
    "    if phase == 2 and self.selected_piece == (None, None): change_status_label('Bitte einen Stein zum Ziehen auswählen.')\n",
    "    if phase == 3 and self.selected_piece == (None, None): change_status_label('Bitte einen Stein zum Springen auswählen.')\n",
    "        \n",
    "    if self.pause: change_status_label('Bitte oben den Spielmodus auswählen und anschließend auf \"Start\" klicken.')\n",
    "        \n",
    "    if remaining[0] == remaining[1] == 0:\n",
    "        pieces_status_label.value = 'Verbleibende Steine:'\n",
    "        pieces_player_one.value = count_player_pieces(board, 1)\n",
    "        pieces_player_two.value = count_player_pieces(board, 2)\n",
    "    else:\n",
    "        pieces_status_label.value = 'Setzbare Steine:'\n",
    "        pieces_player_one.value = remaining[0]\n",
    "        pieces_player_two.value = remaining[1]\n",
    "         \n",
    "    if self.winner in PLAYER: change_status_label(PLAYER_COLOUR[self.winner - 1] + ' hat gewonnen!')\n",
    "    elif self.winner == 0: change_status_label('Unentschieden!')    \n",
    "    if self.number_pieces_to_remove == 1: change_status_label('Mühle! Bitte noch 1 Stein des Gegners entfernen.') \n",
    "    elif self.number_pieces_to_remove > 1:  change_status_label('Mühle! Bitte noch ' + str(self.number_pieces_to_remove) + ' Steine des Gegners entfernen.') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spielen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schließlich kann das Spielfeld erzeugt und ein Spiel gestartet werden. Dabei wird bei jedem Mausklick auf das Spielfeld `play_game()` mit den Koordinaten des Klicks aufgerufen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "game = Game()\n",
    "game.update_canvas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}