Schachspiel-Programm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Main:\n",
    "Ablauf des Programms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from pylab import *\n",
    "spielfeld = np.array(\n",
    "    [[\"T\",\"S\",\"L\",\"D\",\"K\",\"L\",\"S\",\"T\"],\n",
    "     [\"B\",\"B\",\"B\",\"B\",\"B\",\"B\",\"B\",\"B\"],\n",
    "     [\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],\n",
    "     [\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],\n",
    "     [\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],\n",
    "     [\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],\n",
    "     [\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\"],\n",
    "     [\"t\",\"s\",\"l\",\"d\",\"k\",\"l\",\"s\",\"t\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anzahl der Spieler? ich\n",
      "Bitte eine gültige Anzahl an Spielern eintragen(1 oder 2 )\n",
      "Anzahl der Spieler? 1\n",
      "Ich bin ich\n",
      "Hallo ich und viel Spaß beim Spielen \n",
      "Weiß ist am Zug (b,d,k,t,..)\n",
      "    1   2   3   4   5   6   7   8\n",
      "A ['T' 'S' 'L' 'D' 'K' 'L' 'S' 'T']\n",
      "B ['B' 'B' 'B' 'B' 'B' 'B' 'B' 'B']\n",
      "C ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "D ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "E ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "F ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "G ['b' 'b' 'b' 'b' 'b' 'b' 'b' 'b']\n",
      "H ['t' 's' 'l' 'd' 'k' 'l' 's' 't']\n",
      "Welches Feld soll angewählt werden(A1)? B1\n",
      "Zu welchem Feld soll die Figur geschoben werden(B1)? C1\n",
      "2\n",
      "21->31\n",
      "Die angewählte Figur ist nicht ihre\n",
      "Welches Feld soll angewählt werden(A1)? G1\n",
      "Zu welchem Feld soll die Figur geschoben werden(B1)? F1\n",
      "7\n",
      "71->61\n",
      "Schwarz ist am Zug (B,D,K,T,..)\n",
      "    1   2   3   4   5   6   7   8\n",
      "A ['T' 'S' 'L' 'D' 'K' 'L' 'S' 'T']\n",
      "B ['B' 'B' 'B' 'B' 'B' 'B' 'B' 'B']\n",
      "C ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "D ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "E ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "F ['b' '0' '0' '0' '0' '0' '0' '0']\n",
      "G ['0' 'b' 'b' 'b' 'b' 'b' 'b' 'b']\n",
      "H ['t' 's' 'l' 'd' 'k' 'l' 's' 't']\n",
      "Welches Feld soll angewählt werden(A1)? B3\n",
      "Zu welchem Feld soll die Figur geschoben werden(B1)? C3\n",
      "2\n",
      "23->33\n",
      "Weiß ist am Zug (b,d,k,t,..)\n",
      "    1   2   3   4   5   6   7   8\n",
      "A ['T' 'S' 'L' 'D' 'K' 'L' 'S' 'T']\n",
      "B ['B' 'B' '0' 'B' 'B' 'B' 'B' 'B']\n",
      "C ['0' '0' 'B' '0' '0' '0' '0' '0']\n",
      "D ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "E ['0' '0' '0' '0' '0' '0' '0' '0']\n",
      "F ['b' '0' '0' '0' '0' '0' '0' '0']\n",
      "G ['0' 'b' 'b' 'b' 'b' 'b' 'b' 'b']\n",
      "H ['t' 's' 'l' 'd' 'k' 'l' 's' 't']\n"
     ]
    }
   ],
   "source": [
    "from pylab import *\n",
    "\n",
    "spielfertig = False\n",
    "Name1 = \"Spieler1\" \n",
    "Name2 = \"Spieler2\"\n",
    "\n",
    "#Erstellung des 8*8 Arrays des Spielfeldes zu Beginn:\n",
    "spielfeld = np.array([[\"T\",\"S\",\"L\",\"D\",\"K\",\"L\",\"S\",\"T\"],[\"B\",\"B\",\"B\",\"B\",\"B\",\"B\",\"B\",\"B\"],[\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\",\"0\"],[\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\"],[\"t\",\"s\",\"l\",\"d\",\"k\",\"l\",\"s\",\"t\"]])\n",
    "\n",
    "\n",
    "#Erstellt ein Dictionary (\"Einstellungen\" mit den vorgefassten Optionen)\n",
    "einstellungen = settings() \n",
    "\n",
    "\n",
    "while spielfertig == False: #so lange spielfertig == False, läuft das Spiel\n",
    "    \n",
    "    #Zug von Weiß:\n",
    "    print(\"Weiß ist am Zug (b,d,k,t,..)\")\n",
    "    brettzeichnen(spielfeld)\n",
    "    spielfeld = zug(spielfeld, \"weiß\") #weiß == klein\n",
    "    if schachmatt() == True:\n",
    "        gewinner = Spieler1 \n",
    "        break\n",
    "    #FEHLT: Verwandlung Bauer\n",
    "    \n",
    "    #Zug von Schwarz\n",
    "    print(\"Schwarz ist am Zug (B,D,K,T,..)\")\n",
    "    brettzeichnen(spielfeld)\n",
    "    spielfeld = zug(spielfeld, \"schwarz\") #schwarz == groß\n",
    "    if schachmatt() == True:\n",
    "        gewinner = Spieler2\n",
    "        break\n",
    "    \n",
    "    \n",
    "    \n",
    "siegerehrung(gewinner)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funktionen:\n",
    "\n",
    "Funktionen mit dem Status (fertig) sind fertig\n",
    "\n",
    "Funktionen mit dem Status (getestet) sind fertig und wurden auf ihre Richtigkeit getestet\n",
    "\n",
    "Funktionen ohne Status wurden sind nicht fertig und wurden nur zur vervollständigung/Vorrausplanung aufgeschrieben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen für den allgemeinen Spielverlauf:\n",
    "\n",
    "- Funktionen mit dem Status (fertig) sind fertig\n",
    "- Funktionen mit dem Status (getestet) sind fertig und wurden auf ihre Richtigkeit getestet\n",
    "- Funktionen ohne Status wurden sind nicht fertig und wurden nur zur vervollständigung/Vorrausplanung aufgeschrieben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funktionen, die für einen Zug benutzt werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def zug(feld, farbe):#(fertig) Führt einen Zug von Schwarz oder Weiß durch\n",
    "    zugkorrekt = False\n",
    "    \n",
    "    while zugkorrekt == False:#wenn der Zug korrekt ist, wird die while Schleife nicht mehr wiederholt, wenn er falsch ist wird nach einer richtigen Eingabe gefragt\n",
    "        \n",
    "        #Eingabe des Zuges:\n",
    "        zugarray4 = zugeingabe() #gibt Array mit 4 Zahlen von 0-8 zurück [x-Koordinate davor,y-Koordinate davor, x danach, y danach]\n",
    "        \n",
    "        \n",
    "        #Prüfung des Zuges:\n",
    "        zugkorrekt = zugpruefung(feld, zugarray4, farbe) #darf der Zug gemacht werden ? -> True, darf er nicht gemacht werden -> False\n",
    "        \n",
    "    #Durchführung des korrekten Zuges:\n",
    "    feld = zugdurchfuehren(feld,zugarray4)\n",
    "    \n",
    "    return(feld)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def zugeingabe(): #(getestet) der Spieler gibt seinen Zug ein, dieser wird in einem Array gespeichert und zurückgegeben\n",
    "   \n",
    "    syntax = False #wird zur Überprüfung des Syntax des Zuges benutzt\n",
    "    \n",
    "    #Eingabe des Zuges:\n",
    "    while syntax == False: #While Schleife wird beendet, wenn der Syntax stimmt\n",
    "        zugarray2 = [input(\"Welches Feld soll angewählt werden(A1)? \"),input(\"Zu welchem Feld soll die Figur geschoben werden(B1)? \")]\n",
    "        syntax = syntaxpruefung(zugarray2) #gibt True zurück, wenn der Syntax stimmt\n",
    "       \n",
    "    zugarray4 = zuguebersetzung(zugarray2)\n",
    "    \n",
    "    #Ausgabe zur Information, welcher Zug ausgeführt worden ist:\n",
    "    print(str(zugarray4[0]) + str(zugarray4[1]) + \"->\" + str(zugarray4[2]) + str(zugarray4[3]))\n",
    "    \n",
    "    return zugarray4\n",
    "    \n",
    "def zuguebersetzung(zugarray2):#(getestet) Übersetzt das zugarray der Form [A-H,1-8][A-H,1-8] in die Form [1-8,1-8,1-8,1-8]\n",
    "    buchstabenzuordnen = np.array([[None,\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\"],[None,\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\"]])# wird zur Zuordnung der Buchstaben zu Zahlen benutzt\n",
    "    \n",
    "    #Übersetzung der Buchstabenkoordinate in eine Zahlkoordinate\n",
    "    for z in range(2):#übersetzt die Buchstaben in Zahlen:\n",
    "        for x in range(9):\n",
    "            if (zugarray2[0])[0] == buchstabenzuordnen[z][x]:\n",
    "                a = x\n",
    "                print(a)\n",
    "                      \n",
    "    for z in range(2):\n",
    "        for x in range(9):\n",
    "            if (zugarray2[1])[0] == buchstabenzuordnen[z][x]:\n",
    "                b = x\n",
    "    #Rueckgabe des zugarray4 in der oben genannten Form:            \n",
    "    return [a,int((zugarray2[0])[1]),b,int((zugarray2[1])[1])]#Variable Zug ist nun in der Form ([1,1,1,2])\n",
    "\n",
    "def syntaxpruefung(zugarray2): #(getestet)Überprüft ob der eingegangene Zug den richtigen Syntax besitzt\n",
    "    buchstaben = [\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\",\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\"]\n",
    "    zahlen = [\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\"]\n",
    "    rueckgabe = True #Diese Variabel wird im Laufe der Funktion verändert und am Schluss zurückgegeben\n",
    "    \n",
    "    #Längenüberprüfung:\n",
    "    if len(list(zugarray2[0])) == 2 and len(list(zugarray2[1])) == 2 :\n",
    "            rueckgabe = True    \n",
    "    else :\n",
    "        print(\"LängenError - Ihre Eingaben hatten nicht die gewünschte Länge. Bitte geben sie ihren Zug erneut ein\")\n",
    "        rueckgabe = False\n",
    "    \n",
    "    #Zeichenüberprüfung:\n",
    "    if not((zugarray2[0])[0] in buchstaben and (zugarray2[0])[1] in zahlen and (zugarray2[1])[0] in buchstaben and (zugarray2[1])[1] in zahlen):\n",
    "        rueckgabe = False\n",
    "        print(\"ZeichenError - Ihre Eingabe war nicht in der benötigten Form. Bitte geben sie ihren Zug erneut ein\")\n",
    "        \n",
    "    return rueckgabe\n",
    "\n",
    "def zugpruefung(feld, zugarray, farbe): #prüft ob der zug korrekt war und gibt dann True zurück,wenn er falsch war: False\n",
    "    rueckgabe = True #Diese Variabel wird im Laufe der Funktion verändert und am Schluss zurückgegeben\n",
    "    sF = [\"T\",\"S\",\"L\",\"D\",\"K\",\"B\"]\n",
    "    wF = [\"t\",\"s\",\"l\",\"d\",\"k\",\"b\"]\n",
    "    \n",
    "    za =  [zugarray[0]-1 , zugarray[1]-1 , zugarray[2]-1 , zugarray[3]-1] # nun haben alle zahlen den Wert 0-7 statt 0-8\n",
    "    \n",
    "    #1.Fehlermöglichkeit: Auf dem angewählten Feld befindet sich keine Figur des eigenen Teams\n",
    "    if feld[za[0]][za[1]] == \"0\":\n",
    "        rueckgabe = False\n",
    "        print(\"Auf dem angewählten Feld befindet sich keine Figur\")\n",
    "        \n",
    "    #Besitzt die angewählte Figur der Person, der diesen Zug ausführt?:\n",
    "    elif farbe == \"weiß\" and (feld[za[0]][za[1]] in sF):\n",
    "        rueckgabe = False\n",
    "        print(\"Die angewählte Figur ist nicht ihre\") \n",
    "    elif farbe == \"schwarz\" and (feld[za[0]][za[1]] in wF):\n",
    "        rueckgabe = False\n",
    "        print(\"Die angewählte Figur ist nicht ihre\")\n",
    "    else:\n",
    "        #Hier Erfolgt die Prüfung, ob der gewählte Zug möglich ist (sich im Array der möglichen Züge \"m\" befindet)\n",
    "        m = moeglichezuege(za[0],za[1],feld, farbe) # za[0] = y, za[1] = x ; in m werden alle möglichen Ziele der Figur auf dem Feld mit den Koordinate za[0],za[1] gespeichert\n",
    "        \n",
    "         \n",
    "    return rueckgabe\n",
    "\n",
    "\n",
    "def zugdurchfuehren(feld,zugarray):#(getestet) führt den Zug auf dem Feldarray durch und gibt das Feldarray wieder\n",
    "    \n",
    "    #Für die Übersichtlichkeit: Definierung der Indizes für den Zugriff aufs Zugarray \n",
    "    x0 = zugarray[0]-1 #Wert:0-7\n",
    "    x1 = zugarray[1]-1 #Wert:0-7\n",
    "    x2 = zugarray[2]-1 #Wert:0-7\n",
    "    x3 = zugarray[3]-1 #Wert:0-7\n",
    "    \n",
    "    feld[x2][x3] = feld[x0][x1]\n",
    "    feld[x0][x1] = \"0\" #das feld, von dem sich die Figur wegbewegt wird leer(also\"0\")\n",
    "\n",
    "    return feld\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funktion, welche alle Zugmöglichkeiten als Array zurückgibt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def moeglichezuege(y, x, feld, farbe): #x,y == 0-7 /gibt ein Array zurück, in dem alle möglichen Züge der Figur auf der Position x,y gespeichert sind\n",
    "    #Zur Erinnerung: Weiß == kleine Buchstaben, Schwarz == große Buchstaben\n",
    "    m = []#nach und nach werden hier alle möglichen Züge der Figur mit den Koordinaten x,y gespeichert \n",
    "    # -> diese sind gespeichert in der der Form [yZiel1,xZiel1,yZiel2,xZiel2,...,yZieln,xZieln]\n",
    "    \n",
    "    sF = [\"T\",\"S\",\"L\",\"D\",\"K\",\"B\"]\n",
    "    wF = [\"t\",\"s\",\"l\",\"d\",\"k\",\"b\"]\n",
    "    aF = sF + wF\n",
    "    \n",
    "    #print(feld[y][x])\n",
    "    \n",
    "    #y von oben nach unten, x links nach rechts\n",
    "    # Weiß spielt nach oben, Schwarz spielt nach unten\n",
    "    \n",
    "    #Mit if - Abfragen wird geklärt, welche Figur ausgewählt wird:\n",
    "    \n",
    "    #Bauer, der Farb1e weiß (getestet):\n",
    "    if feld[y][x] == \"b\" and farbe == \"weiß\":#Bauer, kann nur nach oben\n",
    "        if y != 0 and feld[y-1][x] == \"0\": #wenn das obere Feld leer ist\n",
    "            m.append(y - 1)\n",
    "            m.append(x)\n",
    "            \n",
    "            if y == 6 and feld[y-2][x] == \"0\":#zweier Sprung möglich, wenn noch am ursprünglichen Platz und Ziel frei\n",
    "                m.append(y - 2)\n",
    "                m.append(x)\n",
    "                \n",
    "        if x != 0 and y != 0 and (feld[y - 1][x - 1] in sF):#Schlag nach Links\n",
    "            m.append(y - 1)\n",
    "            m.append(x - 1)\n",
    "        \n",
    "        if x != 7 and y != 0 and (feld[y - 1][x + 1] in sF):#Schlag nach Rechts\n",
    "            m.append(y - 1)\n",
    "            m.append(x + 1)\n",
    "        \n",
    "    #Bauer, der Farbe schwarz (getestet):    \n",
    "    elif feld[y][x] == \"B\" and farbe == \"schwarz\":#Bauer, kann nur nach unten\n",
    "        if y != 7 and feld[y+1][x] == \"0\": #wenn das untere Feld leer ist\n",
    "            m.append(y + 1)\n",
    "            m.append(x)\n",
    "            \n",
    "            if y == 1 and feld[y+2][x] == \"0\":#zweier Sprung möglich, wenn noch am ursprünglichen Platz und Ziel frei\n",
    "                m.append(y + 2)\n",
    "                m.append(x)\n",
    "                \n",
    "        if x != 0 and y != 7 and (feld[y + 1][x - 1] in wF): #Schlag nach Links\n",
    "            m.append(y + 1)\n",
    "            m.append(x - 1)\n",
    "        \n",
    "        if x != 7 and y != 7 and (feld[y + 1][x + 1] in wF): #Schlag nach Rechts\n",
    "            m.append(y + 1)\n",
    "            m.append(x + 1)\n",
    "                \n",
    "        \n",
    "        \n",
    "    #Turm (getestet):    \n",
    "    elif feld[y][x] == \"T\" or feld[y][x] == \"t\" :\n",
    "        \n",
    "        if farbe == \"weiß\": # == klein:\n",
    "            GegnerFiguren = sF\n",
    "        else : #Farbe == \"schwarz\" == groß\n",
    "            GegnerFiguren = wF\n",
    "            \n",
    "        i = y + 1 #es wird mit der nächsten Position begonnen \n",
    "        while i <= 7:\n",
    "            if feld[i][x] in GegnerFiguren:#Schlag auf \"y-Reihe\" -> von der Figur nach unten\n",
    "                m.append(i)\n",
    "                m.append(x)\n",
    "            if feld[i][x] in aF:\n",
    "                break\n",
    "            else:#mögliche Bewegungszüge auf \"y-Reihe\" ->von der Figur nach unten\n",
    "                m.append(i)\n",
    "                m.append(x) \n",
    "                i = i + 1\n",
    "                \n",
    "        i = y - 1 \n",
    "        while i >= 0:\n",
    "            if feld[i][x] in GegnerFiguren:#Schlag auf \"y-Reihe\" -> von der Figur nach oben\n",
    "                m.append(i)\n",
    "                m.append(x)\n",
    "            if feld[i][x] in aF:\n",
    "                break\n",
    "            else:#mögliche Bewegungszüge auf \"y-Reihe\" ->von der Figur nach oben\n",
    "                m.append(i)\n",
    "                m.append(x) \n",
    "                i = i - 1\n",
    "            \n",
    "        i = x + 1\n",
    "        while i <= 7:\n",
    "            if feld[y][i] in GegnerFiguren:#Schlag auf \"x-Reihe\" -> von der Figur nach rechts\n",
    "                m.append(y)\n",
    "                m.append(i)\n",
    "            if feld[y][i] in aF: #Die Schleife wird unterbrochen, wenn der Turm auf eine Figur trifft\n",
    "                break\n",
    "            else: #mögliche Bewegungszüge (ohne Schlagen) auf \"x-Achse\" -> von der Figur nach rechts\n",
    "                m.append(y)\n",
    "                m.append(i) \n",
    "            i = i + 1\n",
    "        \n",
    "        \n",
    "        i = x - 1\n",
    "        while i >= 0:\n",
    "            if feld[y][i] in GegnerFiguren:#Schlag auf \"y-Reihe\" -> von der Figur nach links\n",
    "                m.append(y)\n",
    "                m.append(i)\n",
    "            if feld[y][i] in aF:\n",
    "                break\n",
    "            else:#mögliche Bewegungszüge auf \"y-Reihe\" -> von der Figur nach links\n",
    "                m.append(y)\n",
    "                m.append(i) \n",
    "            i = i - 1\n",
    "                \n",
    "            \n",
    "        \n",
    "      \n",
    "    #Springer(getestet):    \n",
    "    elif feld[y][x] == \"S\" or feld[y][x] == \"s\" :\n",
    "        if farbe == \"weiß\": # == klein:\n",
    "            Gegnerund0 = sF + [\"0\"]\n",
    "        else : #Farbe == \"schwarz\" == groß\n",
    "            Gegnerund0 = wF + [\"0\"]\n",
    "        \n",
    "        if (y + 2) <= 7 and (x + 1) <= 7: #Schlag oder Bewegung unten2 rechts1\n",
    "            if feld[y + 2][x + 1] in Gegnerund0 :\n",
    "                m.append(y + 2)\n",
    "                m.append(x + 1)\n",
    "        if (y + 2) <= 7 and (x - 1) >= 0: #Schlag oder Bewegung unten2 links1\n",
    "            if feld[y + 2][x - 1] in Gegnerund0:\n",
    "                m.append(y + 2)\n",
    "                m.append(x - 1)\n",
    "        if (y - 2) <= 0 and (x + 1) <= 7: #Schlag oder Bewegung oben2 rechts1\n",
    "            if feld[y - 2][x + 1] in Gegnerund0:\n",
    "                m.append(y - 2)\n",
    "                m.append(x + 1)\n",
    "        if (y - 2) <= 0 and (x - 1) >= 0: #Schlag oder Bewegung oben2 links1\n",
    "            if feld[y - 2][x - 1] in Gegnerund0:\n",
    "                m.append(y - 2)\n",
    "                m.append(x - 1)\n",
    "        if (y + 1) <= 7 and (x + 2) <= 7: #Schlag oder Bewegung unten1 rechts2\n",
    "            if feld[y + 1][x + 2] in Gegnerund0 :\n",
    "                m.append(y + 1)\n",
    "                m.append(x + 2)\n",
    "        if (y + 1) <= 7 and (x - 2) >= 0: #Schlag oder Bewegung unten1 links2\n",
    "            if feld[y + 1][x - 2] in Gegnerund0:\n",
    "                m.append(y + 1)\n",
    "                m.append(x - 2)\n",
    "        if (y - 1) <= 0 and (x + 2) <= 7: #Schlag oder Bewegung oben1 rechts2\n",
    "            if feld[y - 1][x + 2] in Gegnerund0:\n",
    "                m.append(y - 1)\n",
    "                m.append(x + 2)\n",
    "        if (y - 1) <= 0 and (x - 2) >= 0: #Schlag oder Bewegung oben1 links2\n",
    "             if feld[y - 1][x - 2] in Gegnerund0:\n",
    "                m.append(y - 1)\n",
    "                m.append(x - 2)\n",
    "                \n",
    "    #Läufer(getestet):\n",
    "    elif feld[y][x] == \"L\" or feld[y][x] == \"l\" :\n",
    "        if farbe == \"weiß\": # == klein:\n",
    "            Gegnerund0 = sF + [\"0\"]\n",
    "        else : #Farbe == \"schwarz\" == groß\n",
    "            Gegnerund0 = wF + [\"0\"]\n",
    "            \n",
    "            \n",
    "        # i und j sind die Zählvariabeln: \n",
    "        \n",
    "        # Züge nach rechts unten:\n",
    "        i = y + 1 #überprüft das nächste Feld und nicht das Feld selbst\n",
    "        j = x + 1\n",
    "        while i <= 7 and j <= 7: \n",
    "            if feld[i][j] in Gegnerund0: \n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: #wenn die Reihe eine Figur trifft, sind die Positionen keine Möglichkeiten mehr-> deshalb break\n",
    "                break\n",
    "            i = i + 1 #geht ein Feld weiter\n",
    "            j = j + 1\n",
    "        \n",
    "        # Züge nach rechts oben\n",
    "        i = y - 1\n",
    "        j = x + 1\n",
    "        while i >= 0 and j <= 7:\n",
    "            if feld[i][j] in Gegnerund0:\n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: \n",
    "                break\n",
    "            i = i - 1\n",
    "            j = j + 1\n",
    "        \n",
    "        # Züge nach links unten\n",
    "        i = y + 1\n",
    "        j = x - 1\n",
    "        while i <= 7 and j >= 0:\n",
    "            if feld[i][j] in Gegnerund0:\n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: \n",
    "                break\n",
    "            i = i + 1\n",
    "            j = j - 1\n",
    "        \n",
    "        # Züge nach links oben\n",
    "        i = y - 1\n",
    "        j = x - 1\n",
    "        while i >= 0 and j >= 0:\n",
    "            if feld[i][j] in Gegnerund0:\n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: \n",
    "                break\n",
    "            i = i - 1\n",
    "            j = j - 1\n",
    "        \n",
    "            \n",
    "    #Dame(getestet):\n",
    "    elif feld[y][x] == \"D\" or feld[y][x] == \"d\" :\n",
    "        if farbe == \"weiß\": # == klein:\n",
    "            GegnerFiguren = sF\n",
    "            Gegnerund0 = sF + [\"0\"]\n",
    "        else : #Farbe == \"schwarz\" == groß\n",
    "            GegnerFiguren = wF\n",
    "            Gegnerund0 = wF + [\"0\"]\n",
    "    # Code für den Läufer / Turm:\n",
    "            \n",
    "        # i und j sind die Zählvariabeln: \n",
    "        \n",
    "        # Züge nach rechts unten:\n",
    "        i = y + 1 #überprüft das nächste Feld und nicht das Feld selbst\n",
    "        j = x + 1\n",
    "        while i <= 7 and j <= 7: \n",
    "            if feld[i][j] in Gegnerund0: \n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: #wenn die Reihe eine Figur trifft, sind die Positionen keine Möglichkeiten mehr-> deshalb break\n",
    "                break\n",
    "            i = i + 1 #geht ein Feld weiter\n",
    "            j = j + 1\n",
    "        \n",
    "        # Züge nach rechts oben\n",
    "        i = y - 1\n",
    "        j = x + 1\n",
    "        while i >= 0 and j <= 7:\n",
    "            if feld[i][j] in Gegnerund0:\n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: \n",
    "                break\n",
    "            i = i - 1\n",
    "            j = j + 1\n",
    "        \n",
    "        # Züge nach links unten\n",
    "        i = y + 1\n",
    "        j = x - 1\n",
    "        while i <= 7 and j >= 0:\n",
    "            if feld[i][j] in Gegnerund0:\n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: \n",
    "                break\n",
    "            i = i + 1\n",
    "            j = j - 1\n",
    "        \n",
    "        # Züge nach links oben\n",
    "        i = y - 1\n",
    "        j = x - 1\n",
    "        while i >= 0 and j >= 0:\n",
    "            if feld[i][j] in Gegnerund0:\n",
    "                m.append(i)\n",
    "                m.append(j)\n",
    "            if feld[i][j] in aF: \n",
    "                break\n",
    "            i = i - 1\n",
    "            j = j - 1\n",
    "        \n",
    "        #JETZT Turm\n",
    "        i = y + 1 #es wird mit der nächsten Position begonnen \n",
    "        while i <= 7:\n",
    "            if feld[i][x] in GegnerFiguren:#Schlag auf \"y-Reihe\" -> von der Figur nach unten\n",
    "                m.append(i)\n",
    "                m.append(x)\n",
    "            if feld[i][x] in aF:\n",
    "                break\n",
    "            else:#mögliche Bewegungszüge auf \"y-Reihe\" ->von der Figur nach unten\n",
    "                m.append(i)\n",
    "                m.append(x) \n",
    "                i = i + 1\n",
    "                \n",
    "        i = y - 1 \n",
    "        while i >= 0:\n",
    "            if feld[i][x] in GegnerFiguren:#Schlag auf \"y-Reihe\" -> von der Figur nach oben\n",
    "                m.append(i)\n",
    "                m.append(x)\n",
    "            if feld[i][x] in aF:\n",
    "                break\n",
    "            else:#mögliche Bewegungszüge auf \"y-Reihe\" ->von der Figur nach oben\n",
    "                m.append(i)\n",
    "                m.append(x) \n",
    "                i = i - 1\n",
    "            \n",
    "        i = x + 1\n",
    "        while i <= 7:\n",
    "            if feld[y][i] in GegnerFiguren:#Schlag auf \"x-Reihe\" -> von der Figur nach rechts\n",
    "                m.append(y)\n",
    "                m.append(i)\n",
    "            if feld[y][i] in aF: #Die Schleife wird unterbrochen, wenn der Turm auf eine Figur trifft\n",
    "                break\n",
    "            else: #mögliche Bewegungszüge (ohne Schlagen) auf \"x-Achse\" -> von der Figur nach rechts\n",
    "                m.append(y)\n",
    "                m.append(i) \n",
    "            i = i + 1\n",
    "        \n",
    "        \n",
    "        i = x - 1\n",
    "        while i >= 0:\n",
    "            if feld[y][i] in GegnerFiguren:#Schlag auf \"y-Reihe\" -> von der Figur nach links\n",
    "                m.append(y)\n",
    "                m.append(i)\n",
    "            if feld[y][i] in aF:\n",
    "                break\n",
    "            else:#mögliche Bewegungszüge auf \"y-Reihe\" -> von der Figur nach links\n",
    "                m.append(y)\n",
    "                m.append(i) \n",
    "            i = i - 1\n",
    "    \n",
    "    \n",
    "    #König(getestet)#ROCHADE HINZUFÜGEN, wenn alles auf Spyder übertragen wurde\n",
    "    elif feld[y][x] == \"K\" or feld[y][x] == \"k\" :\n",
    "        if farbe == \"weiß\": # == klein:\n",
    "            GegnerFiguren = sF\n",
    "            Gegnerund0 = sF + [\"0\"]\n",
    "        else : #Farbe == \"schwarz\" == groß\n",
    "            GegnerFiguren = wF\n",
    "            Gegnerund0 = wF + [\"0\"]\n",
    "        \n",
    "        if (feld[y + 1][x] in Gegnerund0) and ((y + 1) <= 7): #Feld unten\n",
    "            if genugabstandkönige(y + 1,x,farbe,feld) == True:#überprüft ob nach diesem Zug der Abstand der Könige noch größer als 1 ist\n",
    "                m.append(y + 1)\n",
    "                m.append(x)\n",
    "        if (feld[y][x + 1] in Gegnerund0) and ((x + 1) <= 7): #Feld rechts\n",
    "            if genugabstandkönige(y,x + 1,farbe,feld) == True:\n",
    "                m.append(y)\n",
    "                m.append(x + 1)\n",
    "        if (feld[y + 1][x + 1] in Gegnerund0) and ((y + 1) <= 7) and ((x + 1) <= 7): #Feld rechts unten\n",
    "            if genugabstandkönige(y + 1,x + 1,farbe,feld) == True:\n",
    "                m.append(y + 1)\n",
    "                m.append(x + 1)\n",
    "        if (feld[y - 1][x - 1] in Gegnerund0) and ((y - 1) >= 0) and ((x - 1) >=0): #Feld links oben  \n",
    "            if genugabstandkönige(y - 1,x - 1,farbe,feld) == True:\n",
    "                m.append(y - 1)\n",
    "                m.append(x - 1)\n",
    "        if (feld[y - 1][x] in Gegnerund0) and ((y - 1) >= 0): #Feld oben\n",
    "            if genugabstandkönige(y - 1,x,farbe,feld) == True:\n",
    "                m.append(y - 1)\n",
    "                m.append(x)\n",
    "        if (feld[y][x - 1] in Gegnerund0) and ((x - 1) >=0): #Feld links\n",
    "            if genugabstandkönige(y,x - 1,farbe,feld) == True:\n",
    "                m.append(y)\n",
    "                m.append(x - 1)\n",
    "        if (feld[y + 1][x - 1] in Gegnerund0) and ((y + 1) <= 7) and ((x - 1) >=0):#Feld links unten\n",
    "            if genugabstandkönige(y + 1,x - 1,farbe,feld) == True:\n",
    "                m.append(y + 1)\n",
    "                m.append(x - 1)\n",
    "        if (feld[y - 1][x + 1] in Gegnerund0) and ((y - 1) >= 0) and ((x + 1) <= 7): #Feld oben rechts\n",
    "            if genugabstandkönige(y - 1,x + 1,farbe,feld) == True:\n",
    "                m.append(y - 1)\n",
    "                m.append(x + 1)\n",
    "            \n",
    "   \n",
    "                \n",
    "            \n",
    "            \n",
    "        \n",
    "    else: #Fehlermeldung\n",
    "        print(feld[y][x],farbe)\n",
    "        raise NameError(\"Error - Schwerwiegender Fehler in moeglichezuege(x,y,feld,farbe) - Figur nicht erkannt\")\n",
    "        \n",
    "    return m\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sonstige"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def schachmatt():\n",
    "    return False\n",
    "\n",
    "def genugabstandkönige (y,x,farbe,feld): # (getestet) bekommt y - des Königs, x - des Königs, Farb - Wert des abgefragten Königs und Spielfeld\n",
    "    if farbe == \"schwarz\":\n",
    "        for a in range(0,8):\n",
    "            for b in range(0,8):\n",
    "                if feld[a][b] == \"k\": \n",
    "                    ykK = a #Abstand auf y-Achse könig-König\n",
    "                    xkK = b #Abstand auf x-Achse könig-König\n",
    "                    \n",
    "                                    \n",
    "    elif farbe == \"weiß\" :  \n",
    "        for a in range(0,8):\n",
    "            for b in range(0,8):\n",
    "                if feld[a][b] == \"K\": \n",
    "                    ykK = a\n",
    "                    xkK = b\n",
    "                    \n",
    "        \n",
    "    if (abs(y - ykK) > 1) or (abs(x - xkK) > 1): #wenn der Abstand zwischen den y und x Werten der Könige größer als 1 ist, dann ist das in ordnung : return(True)\n",
    "        genug = True\n",
    "    else:\n",
    "        genug = False\n",
    "            \n",
    "    return (genug) \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen, die die Einstellungen zu Beginn des Spiels festlegen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def settings(): #(getestet) die Einstellungen des Spiels werden nach Eingabe in einem Dictionary gespeichert\n",
    "    Name1,Name2 = spielernamen()\n",
    "    einstellungen = {\"Name1\" : Name1, \"Name2\" : Name2}\n",
    "    #FEHLT: möglichkeit ohne einschränkungen (wie regeln) zu spielen \n",
    "    \n",
    "    return einstellungen\n",
    "\n",
    "def spielernamen(): #(getestet) gibt die Namen der Spieler in 2 Variabeln (Name1, Name2) zurück, welche zuvor vom Benutzer kreiiert worden sind\n",
    "    # Spieleranzahlabfrage\n",
    "    AnzahlderSpieler = 0\n",
    "    while AnzahlderSpieler != \"1\" and AnzahlderSpieler != \"2\":\n",
    "        AnzahlderSpieler = (input(\"Anzahl der Spieler? \"))\n",
    "        if AnzahlderSpieler == \"1\":\n",
    "            Name1 = input(\"Ich bin \",)\n",
    "            Name2 = \"CPU\"\n",
    "            print(\"Hallo\",Name1,\"und viel Spaß beim Spielen \")\n",
    "        elif AnzahlderSpieler == \"2\":\n",
    "            Name1 = input(\"Spieler 1 heißt \")\n",
    "            Name2 = input(\"Spieler 2 heißt \")\n",
    "            print(\"Hallo\",Name1,\"und\",Name2,\". Viel Spaß beim Spielen\")\n",
    "        else :\n",
    "            print(\"Bitte eine gültige Anzahl an Spielern eintragen(1 oder 2 )\")\n",
    "    return (Name1,Name2) #gibt die Namen der Spieler zurück"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen für die graphische Ausgabe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def brettzeichnen(spielfeld):# zeichnet den jetzigen Zustand des Feldes (FEHLT: ABCD usw. am Rand, Lösung: mit print Befehlen)\n",
    "    print(\"   \",1,\" \",2,\" \",3,\" \",4,\" \",5,\" \",6,\" \",7,\" \",8)\n",
    "    print(\"A\", spielfeld[0][:]) \n",
    "    print(\"B\", spielfeld[1][:])\n",
    "    print(\"C\", spielfeld[2][:])\n",
    "    print(\"D\", spielfeld[3][:]) \n",
    "    print(\"E\", spielfeld[4][:])\n",
    "    print(\"F\", spielfeld[5][:])\n",
    "    print(\"G\", spielfeld[6][:])\n",
    "    print(\"H\", spielfeld[7][:]) \n",
    "  \n",
    "def brettzeichnenschön(feld):# Zeichnet das Feld mit der turtle\n",
    "    None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen für den CPU:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Error:\n",
    "\n",
    "LängenError: in Funktion: syntaxpruefung, wenn die Zugeingabe nicht 2 groß ist\n",
    "\n",
    "ZeichenError: in Funktion: syntaxpruefung, wenn die Zugeingabe nicht in der Form [A-H,1-8][A-H,1-8] war\n",
    "\n",
    "ZugError: in Funktion: zugpruefung, wenn ein Fehler beim Ziehen vorliegt (falsche Figurenbewegung)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}