sjakkprog-l.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5e5c28f8",
   "metadata": {},
   "source": [
    "# Sjakk og programmering for lærere\n",
    "\n",
    "Målet med dette kurset er å gi undervisningsopplegg med sjakk, koding og matte som tema.\n",
    "Du vil her finne blokker av Python-kode, for eksempel: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "138cb339-60fd-4acd-a53b-06162e4916c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "test = 0\n",
    "for i in range(10):\n",
    "    test = test + 1 \n",
    "print(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91fd46d3-b4c8-46f6-a9be-ffabd5ec2332",
   "metadata": {},
   "source": [
    "Forsøk å klikke på kodeblokken og deretter trykke `Shift` + `Enter` på tastaturet.\n",
    "Da kjøres koden, og resultatet skrives ut under. \n",
    "Forsøk videre å klikke deg inn i koden, gjøre endringer og kjøre koden på nytt. \n",
    "\n",
    "Dette dokumentet er altså en blanding av tekst og kodeblokker, som både kan endres og kjøres. \n",
    "Senere vil du finne kodeblokker der du kan forsøke å løse oppgavene. \n",
    "Det anbefales at elevene koder i den samme plattformen, ved å for eksempel bruke elevversjonen av dette dokumentet, som finnes på [bit.ly/sjakkmatte](bit.ly/sjakkmatte).\n",
    "\n",
    "**Nyttig informasjon om plattformen:**\n",
    "* Når du lukker nettleseren og laster inn siden på nytt, så kommer du tilbake til originalversjonen av dokumentet. \n",
    "* Dersom du vil å ta vare på all koden du har skrevet til neste gang, bruker du menyvalget `File` -> `Download` og lagrer filen på din datamaskin. Når du laster inn denne siden senere, åpner du filen ved å trykke du på mappesymbolet (det øverste av de fire symbolene helt til venstre), deretter opplastingsknappen (pil oppover med horisontal strek under). \n",
    "* Dette dokumentet skal ikke gi noen feilmeldinger hvis koden kjøres i kronologisk rekkefølge. Du kan eventuelt kjøre all koden ved å bruke menyvalget `Run` -> `Run All Cells`\n",
    "* Hvis du har klikket deg inn i tekst eller kode, bruk `Shift` + `Enter` for å komme tilbake til lesemodus. Bruk `Ctrl/Cmd` + `Z` for å angre endringer.  \n",
    "* Det er nyttig å bruke innholdsfortegnelsen for å navigere dokumentet. For å åpne/lukke denne bruker du knappen med tre streker helt til venstre."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "297c2377-e2a6-4dd4-a20d-c7501f9e26aa",
   "metadata": {},
   "source": [
    "## Innføring\n",
    "Vi begynner med en innføring i å definere sjakkbrett og brikker i Python.\n",
    "### Sjakkbrett\n",
    "For å kunne begynne med sjakkoding, trenger vi en måte å lagre brettet og brikkenes plasseringer i datamaskinens minne. Utvidelsen [python-chess](https://python-chess.readthedocs.io/en/latest/) tar seg av detaljene for oss, så alt vi trenger å lære er noen få kommandoer. Dette gjør at vi raskt kan begynne med de logiske og kreative delene av oppgavene. \n",
    "\n",
    "Kjør følgende kode med `Shift`+ `Enter`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49d6d726",
   "metadata": {},
   "outputs": [],
   "source": [
    "from chess import *\n",
    "brett = Board(None) \n",
    "brett"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b81783-9e65-4536-9427-2c9654bffc3c",
   "metadata": {},
   "source": [
    "De tre kodelinjene gjør følgende: \n",
    "\n",
    "1. Vi importerer den nevnte utvidelsen, slik at vi kan ta i bruk kommandoene. \n",
    "2. Vi definerer variabelen `brett`. Ved å bruke kommandoen `Board(None)` sier vi at `brett` skal inneholde et tomt sjakkbrett. \n",
    "3. Vi skriver til slutt `brett` på en egen linje, som gjør at sjakkbrettet vises når vi kjører programmet. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aabf54a1-0d6b-4a8b-a097-1f139d7c9638",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Mer nysgjerrig?\n",
    "\n",
    "Du er kanksje vant til at en variabel inneholder et tall, en liste eller en tekststreng. Men en variabel kan også inneholde mer kompliserte strukturer, i dette tilfellet et sjakkbrett. Nøyaktig hvordan brettet lagres i datamaskinens minne bestemmes av Python-utvidelsen. En måte å gjøre det på selv er:\n",
    "\n",
    "* Definere et sjakkbrett som en liste av 64 tall. \n",
    "* De 8 første tallene i listen er feltene a1-a8, de neste 8 tallene er feltene b1-b8, og så videre. \n",
    "* Hvis tallet er 0, så betyr det at feltet er tomt, mens 1 betyr bonde, 2 betyr hest, og så videre.\n",
    "\n",
    "`None` er forøvrig et nøkkelord i Python på samme måte som `for` og `if`. Hvis vi skriver `test=None`, betyr det at vi oppretter variabelen `test` uten noe innhold - vi sier da at `test` er en \"tom variabel\". I kommandoen `Board(None)` brukes `None` for å definere at brettet skal være tomt."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55e012b2-0fd3-49ee-aa17-1ad5edba22b6",
   "metadata": {},
   "source": [
    "### Brikker \n",
    "\n",
    "For å unngå forvirring senere er det nyttig å lære de internasjonale symbolene for sjakkbrikkene. \n",
    "\n",
    "* P = Pawn = Bonde\n",
    "* N = kNight = Hest\n",
    "* B = Bishop = Løper\n",
    "* R = Rook = Tårn\n",
    "* Q = Queen = Dronning\n",
    "* K = King = Konge\n",
    "\n",
    "Kjør følgende kode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35263a32",
   "metadata": {},
   "outputs": [],
   "source": [
    "P = Piece(1, 1)\n",
    "N = Piece(2, 1)\n",
    "B = Piece(3, 1)\n",
    "R = Piece(4, 1)\n",
    "Q = Piece(5, 1)\n",
    "K = Piece(6, 1)\n",
    "\n",
    "p = Piece(1, 0)\n",
    "n = Piece(2, 0)\n",
    "b = Piece(3, 0)\n",
    "r = Piece(4, 0)\n",
    "q = Piece(5, 0)\n",
    "k = Piece(6, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d14a5d5-da6c-456a-8384-1e5c87996c8f",
   "metadata": {},
   "source": [
    "Her har vi brukt kommandoer til å lage variabler for alle brikketypene. \n",
    "Vi bruker store bokstaver for hvite brikker, og små bokstaver for svarte brikker, slik at `P` er hvit bonde og `p` er svart bonde. \n",
    "Husk å ikke bruke disse variabelnavnene igjen senere - da vil variablene overskrives.\n",
    "\n",
    "Vi skal nå sette inn brikker. Kjør følgende kode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "415c2476",
   "metadata": {},
   "outputs": [],
   "source": [
    "brett.set_piece_at(E4, R)\n",
    "brett.set_piece_at(H8, k)\n",
    "brett"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20ae9a9c-d78d-43f0-8570-3f232571998c",
   "metadata": {},
   "source": [
    "Vi har altså brukt kommondoen `brett.set_piece_at(E4,R)` for å sette et hvitt tårn på feltet e4, og tilsvarende kommando for å sette en svart konge på h8.\n",
    "\n",
    "* Det er viktig å skrive `brett.` først, ettersom vi kan ha flere variabler med sjakkbrett, og vi må spesifisere hvilken av disse vi skal plassere nye brikker på. \n",
    "* I parentesen skriver vi ønsket felt og brikketype, i den rekkefølgen og separert av komma. Variablene `E4` og `H8` må skrives med stor bokstav. Feltvariablene følger med utvidelsen, mens brikkevariablene definerte vi selv ovenfor.\n",
    "\n",
    "Vi kan erstatte tårnet med en hest ved å gjenta kommandoen. Vi fjerner kongen ved å skrive `None` i stedet for brikketype. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74ccec67",
   "metadata": {},
   "outputs": [],
   "source": [
    "brett.set_piece_at(E4,N)\n",
    "brett.set_piece_at(H8,None)\n",
    "brett"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d60c11e",
   "metadata": {},
   "source": [
    "For å fjerne alle brikkene på brettet skriver vi `brett = Board(None)` på nytt.\n",
    "\n",
    "### Oppsett av stilling med FEN\n",
    "\n",
    "Metoden ovenfor kan bli langtekkelig når vi skal ha mange brikker på brettet. \n",
    "Derfor skal vi også vise hvordan man bruker [FEN-kode](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation) for å definere brikkeplasseringer. \n",
    "\n",
    "La oss sette hvite bønder på alle felter (det spiller ingen rolle at dette er en ulovlig sjakkstilling). Da bruker vi FEN-koden: \n",
    "\n",
    "`PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP`\n",
    "\n",
    "Først har vi defintert den øverste raden, altså 8. raden. Deretter har vi satt skråstrek og definert 7. raden, og så videre.\n",
    "\n",
    "Kjør koden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "854253eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettA = Board(\"PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP\")\n",
    "brettA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1acebbf6-b451-4fcc-9963-d6ae5cef87f6",
   "metadata": {},
   "source": [
    "Istedenfor `Board(None)` har vi nå erstattet `None` med FEN-koden som definerer ønsket brikkeplasseringen. Det er viktig å ha anførselstegn rundt FEN-koden, fordi dette skal tolkes som en tekststreng. \n",
    "\n",
    "La oss nå sette hvite bønder bare på de mørke feltene. FEN-koden for det er:\n",
    "\n",
    "`1P1P1P1P/P1P1P1P1/1P1P1P1P/P1P1P1P1/1P1P1P1P/P1P1P1P1/1P1P1P1P/P1P1P1P1`\n",
    "\n",
    "Tallet 1 betyr at vi skal hoppe over ett felt før vi plasserer den neste bonden. For eksempel betyr det aller første 1-tallet at vi skal hoppe over feltet a8, som er et lyst felt. Kjør koden for å vise brettet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f82b395c-65ca-41df-aa66-e68eaf756900",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettB = Board(\"1P1P1P1P/P1P1P1P1/1P1P1P1P/P1P1P1P1/1P1P1P1P/P1P1P1P1/1P1P1P1P/P1P1P1P1\")\n",
    "brettB"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "894ffa69-0097-4b6e-a254-1656eaa433ef",
   "metadata": {},
   "source": [
    "Anta til slutt at vi kun ønsker bønder på venstre og høyre kant, altså i a-fila og h-fila. FEN-koden blir da:\n",
    "\n",
    "`P6P/P6P/P6P/P6P/P6P/P6P/P6P/P6P`\n",
    "\n",
    "På hver rad hopper vi altså over de 6 midtre feltene. Kjør koden for å se sjakkbrettet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "339f8e33-d3b5-4fd4-b03d-8361e7792eb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettC = Board(\"P6P/P6P/P6P/P6P/P6P/P6P/P6P/P6P\")\n",
    "brettC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2838884-387a-4981-b3d0-d0a6b5d487d5",
   "metadata": {},
   "source": [
    "For å definere et tomt sjakkbrett med FEN, må vi altså hoppe over alle 8 felter på hver rad:\n",
    "\n",
    "`8/8/8/8/8/8/8/8`\n",
    "\n",
    "Forsøk nå å leke deg med FEN-koden under og sjekk at brettet blir slik du ønsker. Husk de engelse brikkesymbolene - `PNBRQK` for hvit bonde, hest, springer, løper, tårn, dronning og konge. De små bokstavene `pnbrqk` brukes for svarte brikker. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52bcfaac-d050-49bd-8b9c-2cdeca3b4d9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettD = Board(\"8/8/8/8/8/8/8/8\")\n",
    "brettD"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72a9ea66-5208-492b-ae77-504ea3b6c52f",
   "metadata": {},
   "source": [
    "## Oppgaver\n",
    "\n",
    "Hovedoppgavene er\n",
    "\n",
    "* Angrepsstyrke\n",
    "* En enkel sjakkcomputer\n",
    "* Mer kommer\n",
    "\n",
    "I hver av disse vil du finne nødvendig tilleggsinformasjon og delspørsmål. Velg deg en av hovedoppgavene, som kan gi opplegg for 1-2 skoletimer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf6b88ab-7ada-4637-a949-4c285c450dba",
   "metadata": {},
   "source": [
    "### Angrepsstyrke\n",
    "\n",
    "I disse oppgavene skal ulike brikker plasseres på brettet slik at flest/færrest felter angripes. \n",
    "Dette kan for eksempel organiseres som en morsom konkurranse i klasserommet, og det er en tabell som kan fylles ut til slutt.\n",
    "\n",
    "Til disse oppgavene er det fint å kunne visualisere hvilke felter som angripes. Vi oppretter derfor en kommando for dette. Det er ikke meningen at du skal forstå denne koden, bare kjøre den:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c48c5b4c-e80c-49ac-a0bb-2ebbcc2f835e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from chess.svg import board as show_board\n",
    "def all_attacks(board):\n",
    "    all_attacks = SquareSet([])\n",
    "    pieces = SquareSet([])\n",
    "    for i in range(64):\n",
    "        all_attacks = all_attacks.union(board.attacks(i))\n",
    "        if board.piece_at(i) is not None:\n",
    "            pieces.add(i)\n",
    "    all_attacks = all_attacks.difference(pieces)\n",
    "    return all_attacks, pieces\n",
    "\n",
    "def show_attacks(board):\n",
    "    attacks, pieces = all_attacks(board)\n",
    "    print(len(pieces), \"brikker på brettet,\", len(attacks),  \"tomme felter angripes! \\n\")\n",
    "    return show_board(board, squares=attacks, size=390)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2672ac0-3bf8-4ba4-b23c-ed77e4125076",
   "metadata": {},
   "source": [
    "La oss prøve den nye kommandoen `show_attacks()` på et brett med løper, dronning og konge. Kjør koden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19c24149-fa07-45a1-ad91-181dc52f2153",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettF = Board(None)\n",
    "brettF.set_piece_at(A1, Q)\n",
    "brettF.set_piece_at(B1, B)\n",
    "brettF.set_piece_at(C1, K)\n",
    "show_attacks(brettF)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5969efb-f837-4eea-8cc3-180895e68740",
   "metadata": {},
   "source": [
    "I parentesen til `show_attacks()` skal du altså skrive variabelnavnet til sjakkbrettet. Merk at funksjonen også skriver ut en beskjed over figuren. Forsøk gjerne å endre på brikkeplasseringene og kjør koden på nytt. Hvis du for eksempel vil flytte dronningen, endrer du linjen `brettF.set_piece_at(A1, Q)`, ved å erstatte `A1` med ønsket felt. \n",
    "\n",
    "Elevene kan gjerne oppfordres til å sette opp de aktuelle brikkene på et fysisk sjakkbrett først, slik at de kan argumentere intuitivt for hvor de bør stå. Deretter kan de sjekke forslagene sine i programmet. Fordelen er at man slipper det langtekkelige arbeidet med å telle alle felter under angrep, og mest tid går til den kreative prosessen med å finne gode brikkeplasseringer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b89579b-76da-4184-adcd-fcd1a1414bd5",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### En av hver brikke, størst dominans\n",
    "\n",
    "Kjør koden under, og endre på brikkenes plasseringer slik at de angriper **flest** mulig felter på brettet. Husk at hvit bonde kun angriper på skrå fremover."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba59c889-dad2-491c-ba1c-caff257b863e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "brettG = Board(None)\n",
    "brettG.set_piece_at(A1, P)\n",
    "brettG.set_piece_at(B1, N)\n",
    "brettG.set_piece_at(C1, B)\n",
    "brettG.set_piece_at(D1, R)\n",
    "brettG.set_piece_at(E1, Q)\n",
    "brettG.set_piece_at(F1, K)\n",
    "show_attacks(brettG)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6095c2da-08a9-4c9c-9a65-35b60c45942a",
   "metadata": {},
   "source": [
    "#### En av hver brikke, minst dominans \n",
    "\n",
    "Kjør koden under, og endre på brikkenes plasseringer slik at de angriper **færrest** mulig felter på brettet.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bb084f0-4997-49e9-a358-c89785fc3fb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettH = Board(None)\n",
    "brettH.set_piece_at(A1, P)\n",
    "brettH.set_piece_at(B1, N)\n",
    "brettH.set_piece_at(C1, B)\n",
    "brettH.set_piece_at(D1, R)\n",
    "brettH.set_piece_at(E1, Q)\n",
    "brettH.set_piece_at(F1, K)\n",
    "show_attacks(brettH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3a22e2d-8895-4305-bf26-83f34b7c9752",
   "metadata": {},
   "source": [
    "#### Dominere brettet med færrest dronninger\n",
    "\n",
    "Kjør koden under. Legg på en ny dronning ved å kopiere linje 2 - husk å endre `E4` til et annet felt.\n",
    "\n",
    "Legg på flere dronninger og forsøk å dominere hele brettet med så få dronninger som mulig. Hva er det minste antallet dronninger som trengs? (Å dominere hele brettet vil si at ethvert felt enten er okkupert eller under angrep av en brikke.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8568599-0c41-4beb-b084-05f6a4ecf621",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettI = Board(None)\n",
    "brettI.set_piece_at(E4, Q)\n",
    "show_attacks(brettI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c26d4a76-2cea-4df9-bdf6-0ea7068b5003",
   "metadata": {},
   "source": [
    "#### Dominere brettet med færrest hester\n",
    "\n",
    "Kjør koden under, og legg til flere hester. Forsøk å dominere hele brettet med så få hester som mulig."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40001551-ddef-4fd7-8bda-09e5b5769489",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettJ = Board(None)\n",
    "brettJ.set_piece_at(C6, N)\n",
    "show_attacks(brettJ)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11781e48-d490-480a-aded-f1fd79f64173",
   "metadata": {},
   "source": [
    "#### Flest fredelige dronninger\n",
    "\n",
    "Vi ønsker nå å plassere flest dronninger på brettet uten at noen av dem angriper hverandre.\n",
    "Da har vi nytte av en litt annen kommando, som også setter kryss på brikker som angripes (selv om brikkene er av samme farge). \n",
    "Vi oppretter kommandoen `show_attacks2()` til dette formålet. Kjør koden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6cd0183-8ecc-4a15-87e5-34ce0bc501a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_attacks2(board):\n",
    "    all_attacks = SquareSet([])\n",
    "    pieces = SquareSet([])\n",
    "    for i in range(64):\n",
    "        all_attacks = all_attacks.union(board.attacks(i))\n",
    "        if board.piece_at(i) is not None:\n",
    "            pieces.add(i)\n",
    "    attacked_pieces = all_attacks.intersection(pieces)\n",
    "    return all_attacks, attacked_pieces\n",
    "\n",
    "def show_attacks2(board):\n",
    "    attacks, attacked_pieces = all_attacks2(board)\n",
    "    num = len(attacked_pieces)\n",
    "    if num == 0:\n",
    "        print(\"Ingen av brikkene angriper hverandre! Kan du legge til flere fredelige brikker? \\n\")\n",
    "    else: \n",
    "        print(num, \"brikker er under angrep! Flytt brikkene slik at de blir fredelige! \\n\")\n",
    "    return show_board(board, squares=attacks, size=390)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdc12c32-a2ac-43b7-806e-f2d263de614c",
   "metadata": {},
   "source": [
    "Kjør også den neste koden og legg merke til at de to dronningene angriper hverandre, markert med et kryss oppå dronningene. \n",
    "Endre plasseringen slik at de ikke angriper hverandre. \n",
    "Legg deretter på så mange fredelige dronninger som du klarer. (Brikker som ikke angriper hverandre er \"fredelige brikker\".)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e68cd67c-9ace-43c8-ad0d-ac62e02ff5c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettK = Board(None)\n",
    "brettK.set_piece_at(A1, Q)\n",
    "brettK.set_piece_at(G7, Q)\n",
    "show_attacks2(brettK)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e2f1b11-eeef-4f85-badd-673e7005ea4c",
   "metadata": {},
   "source": [
    "#### Flest fredelige løpere\n",
    "\n",
    "Hvor mange løpere klarer du å legge på brettet uten at noen angriper hverandre?\n",
    "Kjør koden under og legg på flere løpere!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a38c2a1-c16e-43d5-999e-d66d194039aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettL = Board(None)\n",
    "brettL.set_piece_at(A1, B)\n",
    "show_attacks2(brettL)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "199ce2cf-9d7d-4c61-9536-1bb8179c6429",
   "metadata": {},
   "source": [
    "#### Oppsummering\n",
    "\n",
    "Skriv opp tabellene under på papir, og fyll ut tall. Cellene som er merket med X svarer til oppgavene som er gitt ovenfor. For å løse de andre cellene kan du bruke kodeblokken under denne teksten til hjelp.\n",
    "Legg merke til at Min og Max betyr forskjellige ting i de to tabellene.\n",
    "\n",
    "**Tabell 1**\n",
    "\n",
    "* Min = færrest antall felter som kan angripes av brikkekombinasjonen\n",
    "* Max = flest antall felter som kan angripes av brikkekombinasjonen\n",
    "\n",
    "| Brikkekombinasjon  | Min  | Max  |\n",
    "|---|---|---|\n",
    "|  En av hver type |  X | X  |\n",
    "|  Andre kombinasjoner? |   |   |\n",
    "\n",
    "**Tabell 2**\n",
    "\n",
    "* Min = færrest antall brikker som kan dominere hele brettet\n",
    "* Max = flest antall fredelige brikker som kan plasseres på brettet\n",
    "\n",
    "| Brikketype  | Min  | Max  |\n",
    "|---|---|---|\n",
    "|  Hester |  X |   |\n",
    "|  Løpere |   | X  |\n",
    "|  Tårn |   |   |\n",
    "| Dronnninger  | X  | X  |\n",
    "| Konger  |   |   |\n",
    "\n",
    "**Kodeblokk til hjelp** \n",
    "\n",
    "Husk å endre til riktig kommando i nederste linje:\n",
    "* `show_attacks()` setter bare kryss på tomme felter under angrep\n",
    "* `show_attacks2()` setter også kryss på brikker under angrep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fdae9d4-ddf5-42a1-8a8d-17b08a05afb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettM = Board(None)\n",
    "brettM.set_piece_at(A1, R)\n",
    "show_attacks(brettM) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "509df906-2d07-472f-a9d9-f4e899047cb9",
   "metadata": {},
   "source": [
    "### Enkel sjakkcomputer\n",
    "\n",
    "Du har kanskje sett \"pila\" i sjakksendingene på NRK. Den vurderer stillingen på brettet og gir en poengsum. Den kan for eksempel vise 1.0 til hvit. Vi skriver dette som +1.0. Hvis det er 1.0 til svart, skriver vi -1.0. Det er kompliserte beregninger som ligger bak poengsummen. Vi skal lage en sjakkcomputer som gjør en veldig enkel beregning, nemlig å telle verdiene til brikkene, for hvit og for svart. Hvis hvit leder med en bonde, skal programmet vårt skrive ut +1. \n",
    "\n",
    "#### Introduksjon\n",
    "\n",
    "Siden denne oppgaven er litt komplisert, må vi starte med en liten introduksjon.\n",
    "\n",
    "Husk at vi bruker variablene `A1`, `A2` ... for å referere til feltene på sjakkbrettet. Hva gjemmer seg bak disse variablene? Kjør koden under for å finne ut! Erstatt gjerne `A1` med andre felter og kjør på nytt (for eksempel `B1`, `C1` og så videre). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58d7baac-6d28-4ce3-9356-4e75050f6ff7",
   "metadata": {},
   "outputs": [],
   "source": [
    "A1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d56290ab-9e82-498b-9537-57001cc6346e",
   "metadata": {},
   "source": [
    "Nå har du oppdaget at disse variablene bare inneholder tall! Du har kanskje også oppdaget hvordan feltene på brettet er nummerert? Følgende figur viser det: \n",
    "\n",
    "<img src=\"sjakkbrett.png\" width=\"300\"/>\n",
    "\n",
    "Vi lager nå et eksempelbrett som har en av hver brikketype. Kjør koden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d97f9e1b-db28-4b45-b691-d5f7096dc5f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettN = Board(\"8/8/8/8/8/8/8/PNBRQK2\")\n",
    "brettN"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3933fae7-0e77-4b18-a81f-2023608137af",
   "metadata": {},
   "source": [
    "Nå skal vi spørre programmet om hvilken brikke som står på feltet a1. Kjør koden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad34a7f7-1da5-49a1-b991-9a77a82bd639",
   "metadata": {},
   "outputs": [],
   "source": [
    "brettN.piece_type_at(0), brettN.color_at(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79cf463b-6935-4d09-9f4a-ab9d2ed87928",
   "metadata": {},
   "source": [
    "Her må vi forklare litt!\n",
    "* Begge kommandoene krever som vanlig at vi sier hvilket brett vi skal bruke. \n",
    "* I parentesen sier vi hvilket felt vi ønsker informasjon om. Her kunne vi ha skrevet `A1`, men vi har nå lært at denne variabelen inneholder tallet `0`, og vi kan dermed skrive tallet direkte. \n",
    "* I kommandoen `piece_type_at()` spør vi om brikketypen, og i `color_at()` spør vi om fargen på brikken. Resultatet `(1, True)` er kryptisk, men følgende tabeller er oppklarende:\n",
    "\n",
    "| `piece_type_at()` | Brikke  |\n",
    "|---|---|\n",
    "|  `None` | Tomt felt  |\n",
    "|  `1` |  Bonde |\n",
    "|  `2` |  Hest  |\n",
    "|  `3` |  Løper  |\n",
    "|  `4` |  Tårn  |\n",
    "|  `5` |  Dronning  |\n",
    "|  `6` |  Konge  |\n",
    "\n",
    "\n",
    "| `color_at()` | Farge på brikke  |\n",
    "|---|---|\n",
    "|  `None` | Tomt felt  |\n",
    "|  `True` |  Hvit |\n",
    "|  `False` |  Svart  |\n",
    "\n",
    "`(1, True)` forteller altså at det står en hvit bonde på `a1`.\n",
    "\n",
    "Vi kan nå sjekke hva som står på hvert eneste felt på sjakkbrettet. Hvordan gjør vi det? Siden feltene er nummerert fra `0` til `63`, kan vi ta utgangspunkt i en `for`-løkke fra `0` til `63`. Kjør følgende kode: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbb605dc-6996-4ccb-9e14-7edb95691a0c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for i in range(0, 64):\n",
    "    print(\"Felt \", i, \" har brikke \", brettN.piece_type_at(i), brettN.color_at(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afdceae5-caed-4483-a59c-59906b4eed6d",
   "metadata": {},
   "source": [
    "Sjekk at denne utskriften stemmer med brettet i siste figur. \n",
    "I neste kodeblokk kan du sette inn flere brikker på sjakkbrettet og sjekke at utskriften igjen stemmer. \n",
    "Prøv for eksempel å sette inn noen svarte brikker. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5dbcec46-7c59-4884-b389-337fa1fd352b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "brettN.set_piece_at(H1, q)\n",
    "for i in range(0, 64):\n",
    "    print(\"Felt \", i, \" har brikke \", brettN.piece_type_at(i), brettN.color_at(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00d465c5-14f1-4321-b9f8-8fad2fdd73d6",
   "metadata": {},
   "source": [
    "Vi skal nå ta utgangspunkt i en realistisk stilling fra et av Magnus Carlsens nylige partier. Kjør koden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6d6cf0c-03c4-4f8c-8451-ecfb629df6e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "carlsen_giri = Board(\"2r5/1R5p/p3npk1/8/P7/4B1P1/4PP1P/5K2\")\n",
    "carlsen_giri"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0bbcd7d-bf11-4f81-b6e7-cff7ab716f09",
   "metadata": {},
   "source": [
    "Først skal vi regne ut poengsummen til denne stillingen for hånd, slik at vi vet hva det riktige resultatet skal være. Verdien av de ulike brikkene er gitt i høyre kolonne av tabellen:\n",
    "\n",
    "| `piece_type_at()` | Brikke  | Poeng |\n",
    "|---|---|---|\n",
    "|  `1` |  Bonde | 1 |\n",
    "|  `2` |  Hest  |3 |\n",
    "|  `3` |  Løper  |3|\n",
    "|  `4` |  Tårn  |5|\n",
    "|  `5` |  Dronning  |9|\n",
    "|  `6` |  Konge  |Telles ikke|\n",
    "\n",
    "Nå kan vi begynne å telle poengene på brettet ovenfor:\n",
    "\n",
    "Hvits poeng = 5x Bonde + 1x Tårn + 1x Løper = 5 + 5 + 3 = 13\n",
    "\n",
    "Svarts poeng = 3x Bonde + 1x Tårn + 1x Hest = 3 + 5 + 3 = 11\n",
    "\n",
    "Poengsum = Hvits poeng - Svarts poeng = 13 - 11 = +2\n",
    "\n",
    "Poengsummen er altså +2, som betyr at hvit leder med 2 poeng. Nå er vi klare for å lage en enkel sjakkcomputer!\n",
    "\n",
    "#### Oppgaven\n",
    "\n",
    "Lag en funksjon som teller poengsummen på et sjakkbrett. Hint:\n",
    "\n",
    "* Gjør tilsvarende utregning som i eksempelet ovenfor.\n",
    "* Du må anta at programmet ikke vet hvilke felter som har brikker. Derfor må du gå gjennom alle feltene på sjakkbrettet.\n",
    "* Du må bruke kommandoene `piece_type_at()` og `color_at()` for å hente informasjon om eventuelle brikker på feltene. Bruk `if`-setninger for å håndtere ulike tilfeller. \n",
    "\n",
    "Vi har kalt funksjonen `evaluate()` i kodeblokken under. Funksjonen tar variabelen `brett` som argument og gir `poeng` som returverdi. Målet er å skrive kode som gjør at `poeng` inneholder poengsummen på brettet.  \n",
    "\n",
    "I siste linje tester vi den nye funksjonen på brettet fra Carlsens parti. Denne testen skal gi svaret 2, slik vi regnet ut for hånd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08fe6faf-605e-4960-b586-9d2d28cb46a7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def evaluation(brett):\n",
    "    poeng = 0\n",
    "    #erstatt dette med kode\n",
    "    return poeng\n",
    "\n",
    "evaluation(carlsen_giri) #test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33316c9b-9659-47df-8a09-4356b35f1ecd",
   "metadata": {},
   "source": [
    "Lag også funksjonen `print_evalutaion()`, som printer en av følgende meldinger, basert på resultatet av `evaluation()`:\n",
    "* Pila står på x poeng til hvit\n",
    "* Pila står på x poeng til svart\n",
    "* Pila står på null - uavgjort.\n",
    "\n",
    "Husk å først bruke funksjonen `evaluation()` for å hente poengsummen, og deretter `print()` for å skrive ut meldinger. Du trenger ikke returverdi i denne oppgaven."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e42d4fc-7b73-4d04-bf31-0c9bb9224e0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_evaluation(brett): \n",
    "    #erstatt dette med kode\n",
    "    return None\n",
    "\n",
    "print_evaluation(carlsen_giri) #test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "652b440e-1d14-4234-9ae9-8fab01e064b1",
   "metadata": {},
   "source": [
    "Under har vi gitt noen stillinger som du kan teste sjakkcomputeren på. Du trenger bare å kjøre kodeblokkene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9c23c7e-b950-451d-a07e-a217f0238a0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "startoppstilling = Board(\"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR\")\n",
    "print_evaluation(startoppstilling)\n",
    "startoppstilling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c758168e-bd07-41b8-bc3f-afca59b9b8a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "anand_carlsen = Board(\"2bqnrk1/5p1p/5PpQ/3pP1P1/2pP1R2/2P5/6BP/4qNK1\")\n",
    "print_evaluation(anand_carlsen)\n",
    "anand_carlsen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ee4e0ff-5efd-400f-a7a2-4f16abd5f468",
   "metadata": {},
   "outputs": [],
   "source": [
    "carlsen_anand = Board(\"r4b2/2p2p2/2k1bNnp/p2NP1p1/PpP1K1P1/7P/5P2/3RR3\")\n",
    "print_evaluation(carlsen_anand)\n",
    "carlsen_anand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0206280-9da0-4483-84f4-e9ef3e3881f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "carlsen_karjakin = Board(\"6k1/4bpp1/1p1p4/5R1P/4PQ2/5P2/r4q1P/2R4K\")\n",
    "print_evaluation(carlsen_karjakin)\n",
    "carlsen_karjakin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17158158-af33-4b6a-a269-d8c76a5c794d",
   "metadata": {},
   "outputs": [],
   "source": [
    "caruana_carlsen = Board(\"5k2/8/5pK1/5PbP/2Bn4/8/8/8\")\n",
    "print_evaluation(caruana_carlsen)\n",
    "caruana_carlsen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1907a466-8dad-4b0f-8418-6e78a37e8d32",
   "metadata": {},
   "outputs": [],
   "source": [
    "carlsen_nepo = Board(\"4k3/8/7q/4PR1N/5P1K/8/8/8\")\n",
    "print_evaluation(carlsen_nepo)\n",
    "carlsen_nepo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc6b52d0-3ffb-42db-bd68-c498aecd99a2",
   "metadata": {},
   "source": [
    "#### En sjakkcomputer som ser ett trekk fram\n",
    "\n",
    "For de spesielt interesserte skal vi nå gjøre sjakkcomputeren litt mer realistisk. (Kommer senere)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9beee27-71ff-4be5-9ad9-85bca2a08c86",
   "metadata": {},
   "source": [
    "## Løsningsforslag\n",
    "\n",
    "Her er løsningsforslag til oppgavene.\n",
    "\n",
    "### Angrepsstyrke \n",
    "\n",
    "Riktig utfylte tabeller er:\n",
    "\n",
    "| Brikkekombinasjon  | Min  | Max  |\n",
    "|---|---|---|\n",
    "|  En av hver type | 5 | 51 |\n",
    "|  Andre kombinasjoner? |   |   |\n",
    "\n",
    "\n",
    "| Brikketype  | Min  | Max  |\n",
    "|---|---|---|\n",
    "|  Hester |  12 |  32 |\n",
    "|  Løpere | 8  |  14 |\n",
    "|  Tårn | 8  |  8 |\n",
    "| Dronnninger  | 5 |  8 |\n",
    "| Konger  | 9  |  16 |\n",
    "\n",
    "\n",
    "Kjør programmene under for å se forslag til oppstillinger som løser oppgavene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04132f48-1dff-41ac-9821-49c61fcc37c0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "en_av_hver_min = Board(\"6BQ/5NRK/6P1/8/8/8/8/8\")\n",
    "show_attacks(en_av_hver_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cba3eca4-d75c-4574-ab8c-e03eb18431c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "en_av_hver_max = Board(\"8/5P2/3Q4/8/4B1N1/1K6/8/7R\")\n",
    "show_attacks(en_av_hver_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbf20254-6a9f-45d0-a9bd-6f13ae77ed5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "hester_min = Board(\"8/5N2/1NN1NN2/2N5/5N2/2NN1NN1/2N5/8\")\n",
    "show_attacks(hester_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0821705-c965-4cb0-99f3-539d35841ed0",
   "metadata": {},
   "outputs": [],
   "source": [
    "hester_max = Board(\"N1N1N1N1/1N1N1N1N/N1N1N1N1/1N1N1N1N/N1N1N1N1/1N1N1N1N/N1N1N1N1/1N1N1N1N\")\n",
    "show_attacks2(hester_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8dae5ff-0bdf-41bf-bba2-5e93b299081d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "lopere_min = Board(\"3B4/3B4/3B4/3B4/3B4/3B4/3B4/3B4\")\n",
    "show_attacks(lopere_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa2bae86-7f97-4fcb-a358-1d0636880e5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "lopere_max = Board(\"B7/B6B/B6B/B6B/B6B/B6B/B6B/B7\")\n",
    "show_attacks2(lopere_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34cefe70-0dc0-4696-9ff6-8c3a6e0107fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "tarn_min = Board(\"8/8/8/8/8/8/8/RRRRRRRR\")\n",
    "show_attacks(tarn_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33fbf24c-84ab-441e-a2ea-82b18ca6fdee",
   "metadata": {},
   "outputs": [],
   "source": [
    "tarn_max = Board(\"7R/6R1/5R2/4R3/3R4/2R5/1R6/R7\")\n",
    "show_attacks2(tarn_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77925176-ac70-48c1-9410-2fd159d96571",
   "metadata": {},
   "outputs": [],
   "source": [
    "dronninger_min = Board(\"8/5Q2/2Q5/4Q3/6Q1/3Q4/8/8\")\n",
    "show_attacks(dronninger_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e4f07b1-b057-495f-b9a5-b519649c1da7",
   "metadata": {},
   "outputs": [],
   "source": [
    "dronninger_max = Board(\"5Q2/3Q4/6Q1/Q7/7Q/1Q6/4Q3/2Q5\")\n",
    "show_attacks2(dronninger_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78a5edb6-927b-4ece-99bc-646a6263fe7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "konger_min = Board(\"1K2K2K/8/8/1K2K2K/8/8/1K2K2K/8\")\n",
    "show_attacks(konger_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbc9343e-d136-4ffe-b03c-40b2942f0255",
   "metadata": {},
   "outputs": [],
   "source": [
    "konger_max = Board(\"8/K1K1K1K1/8/K1K1K1K1/8/K1K1K1K1/8/K1K1K1K1\")\n",
    "show_attacks2(konger_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1895d397-9539-4cae-ae77-3b7ed12495bb",
   "metadata": {},
   "source": [
    "### Enkel sjakkcomputer\n",
    "\n",
    "Forslag til kode for funksjonen `evaluation()`, med grundige kommentarer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19b56c98-412e-4dab-8fc7-93b0d9061576",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluation(brett):\n",
    "    poeng = 0\n",
    "    hvit = 0  #hvits poeng\n",
    "    svart = 0 #svarts poeng\n",
    "    \n",
    "    #vi skal gå gjennom alle brikkene på sjakkbrettet:\n",
    "    \n",
    "    for i in range(0, 64):\n",
    "        brikke = brett.piece_type_at(i) #ber om brikketypen på felt nummer i\n",
    "        farge = brett.color_at(i) #ber om brikkefargen på felt nummer i\n",
    "        \n",
    "        #vi skal nå finne brikkeverdien på felt nummer i:\n",
    "        \n",
    "        brikkeverdi = 0\n",
    "        if (brikke == None) or (brikke == 6): #hvis feltet er tomt eller har konge\n",
    "            continue  #ingenting å telle på dette feltet og vi går til neste tall i for-løkka\n",
    "        elif (brikke == 1): #hvis feltet har bonde\n",
    "            brikkeverdi = 1\n",
    "        elif (brikke == 2) or (brikke == 3): #hvis feltet har hest eller løper\n",
    "            brikkeverdi = 3\n",
    "        elif (brikke == 4): #hvis feltet har tårn\n",
    "            brikkeverdi = 5\n",
    "        elif (brikke == 5): #hvis feltet har dronning\n",
    "            brikkeverdi = 9\n",
    "        \n",
    "        #brikkeverdien skal legges til enten svarts eller hvits poengsum:\n",
    "        \n",
    "        if (farge == True):  #hvis brikken er hvit\n",
    "            hvit = hvit + brikkeverdi\n",
    "        elif (farge == False):  #hvis brikken er svart\n",
    "            svart = svart + brikkeverdi\n",
    "            \n",
    "    #nå er vi ute av for-løkka og har regnet ut hvits og svarts poengsum\n",
    "    #vi kan dermed regne ut den totale poengsummen:\n",
    "    \n",
    "    poeng = hvit - svart\n",
    "    \n",
    "    return poeng\n",
    "\n",
    "evaluation(carlsen_giri)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c331d099-8696-481d-840a-1aca3c52188b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_evaluation(brett):\n",
    "    poengsum = evaluation(brett)\n",
    "    if (poengsum > 0):\n",
    "        print(\"Pila står på \", poengsum, \" poeng til hvit.\")\n",
    "    elif (poengsum < 0):\n",
    "        print(\"Pila står på \", abs(poengsum), \" poeng til svart.\")\n",
    "    elif (poengsum == 0):\n",
    "        print(\"Pila står på null - uavgjort.\")\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b07dfc8-401a-4908-b3e7-31cec9547839",
   "metadata": {},
   "outputs": [],
   "source": [
    "startoppstilling = Board(\"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR\")\n",
    "print_evaluation(startoppstilling)\n",
    "startoppstilling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d88e295b-3005-490f-a083-ab059f720e0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "anand_carlsen = Board(\"2bqnrk1/5p1p/5PpQ/3pP1P1/2pP1R2/2P5/6BP/4qNK1\")\n",
    "print_evaluation(anand_carlsen)\n",
    "anand_carlsen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ddce5e8-50b6-4f56-9955-fc1b9d7ea08e",
   "metadata": {},
   "outputs": [],
   "source": [
    "carlsen_anand = Board(\"r4b2/2p2p2/2k1bNnp/p2NP1p1/PpP1K1P1/7P/5P2/3RR3\")\n",
    "print_evaluation(carlsen_anand)\n",
    "carlsen_anand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a9bf7a2-829e-4629-8887-e81f669f7c9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "carlsen_karjakin = Board(\"6k1/4bpp1/1p1p4/5R1P/4PQ2/5P2/r4q1P/2R4K\")\n",
    "print_evaluation(carlsen_karjakin)\n",
    "carlsen_karjakin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbcfdae1-09ac-4b86-884d-f4b676671c11",
   "metadata": {},
   "outputs": [],
   "source": [
    "caruana_carlsen = Board(\"5k2/8/5pK1/5PbP/2Bn4/8/8/8\")\n",
    "print_evaluation(caruana_carlsen)\n",
    "caruana_carlsen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ffee056-db51-4ba0-802d-f26082225bc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "carlsen_nepo = Board(\"4k3/8/7q/4PR1N/5P1K/8/8/8\")\n",
    "print_evaluation(carlsen_nepo)\n",
    "carlsen_nepo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06681ccb-2a03-4b5f-9d6b-b5f778965bb4",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Referanse\n",
    "\n",
    "Her finner du en kortfattet versjon av all nødvendig informasjon. I elevversjonen gis kun denne oversikten - forklar elevene de relevante delene for oppgaven du velger, og gi eventuelt de mest interesserte elevene mulighet til å bruke dette lærerkurset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c751c26-2adc-458f-bd4f-c759c3ed0f38",
   "metadata": {
    "tags": []
   },
   "source": [
    "\n",
    "\n",
    "### Kommandoer\n",
    "\n",
    "|  Kommando |  Forklaring |\n",
    "|---|---|\n",
    "|  `1 = Board(None)` | Opprett nytt tomt sjakkbrett  |\n",
    "| `1 = Board(\"2\")`  |  Opprett sjakkbrett fra FEN-kode |\n",
    "|  `1.set_piece_at(3, 4)` |  På brett 1: sett brikke 4 på felt 3 |\n",
    "| `show_attacks(1)` | På brett 1: vis feltene som angripes | \n",
    "| `show_attacks(1)` | På brett 1: vis feltene og brikkene som angripes | \n",
    "|`1.piece_type_at(3)`|På brett 1: spør om hvilken brikke som står på felt 3|\n",
    "|`1.color_at(3)`|På brett 1: spør om hvilken farge det er på brikken på felt 3 | \n",
    "\n",
    "Istedenfor tallene 1-4 skal du skrive følgende:\n",
    "\n",
    "1. Et variabelnavn for sjakkbrettet\n",
    "2. FEN-kode: eksempelet `P6P/P6P/P6P/P6P/P6P/P6P/P6P/P6P` plasserer hvite bønder på venstre og høyre kant\n",
    "3. Felt: `A1`, `A2`, ..., `H8`, eller skriv tall mellom `0` og `63`\n",
    "4. Brikketype: `PNBRQK` for hvite brikker, `pnbrqk` for svarte brikker, `None` for å fjerne brikke \n",
    "\n",
    "* P = Pawn = Bonde\n",
    "* N = kNight = Hest\n",
    "* B = Bishop = Løper\n",
    "* R = Rook = Tårn\n",
    "* Q = Queen = Dronning\n",
    "* K = King = Konge\n",
    "\n",
    "<img src=\"sjakkbrett.png\" width=\"300\"/>\n",
    "\n",
    "Hva svaret på kommandoene `piece_type_at()` og `color_at()` betyr:\n",
    "\n",
    "| `piece_type_at()` | Brikke  |\n",
    "|---|---|\n",
    "|  `None` | Tomt felt  |\n",
    "|  `1` |  Bonde |\n",
    "|  `2` |  Hest  |\n",
    "|  `3` |  Løper  |\n",
    "|  `4` |  Tårn  |\n",
    "|  `5` |  Dronning  |\n",
    "|  `6` |  Konge  |\n",
    "\n",
    "\n",
    "| `color_at()` | Farge på brikke  |\n",
    "|---|---|\n",
    "|  `None` | Tomt felt  |\n",
    "|  `True` |  Hvit |\n",
    "|  `False` |  Svart  |\n",
    "\n",
    "### Kode som må kjøres for full funksjonalitet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f51f9458-5ecf-4007-917b-f13f26c2d4e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from chess import *\n",
    "\n",
    "P = Piece(1, 1)\n",
    "N = Piece(2, 1)\n",
    "B = Piece(3, 1)\n",
    "R = Piece(4, 1)\n",
    "Q = Piece(5, 1)\n",
    "K = Piece(6, 1)\n",
    "\n",
    "p = Piece(1, 0)\n",
    "n = Piece(2, 0)\n",
    "b = Piece(3, 0)\n",
    "r = Piece(4, 0)\n",
    "q = Piece(5, 0)\n",
    "k = Piece(6, 0)\n",
    "\n",
    "from chess.svg import board as show_board\n",
    "\n",
    "def all_attacks(board):\n",
    "    all_attacks = SquareSet([])\n",
    "    pieces = SquareSet([])\n",
    "    for i in range(64):\n",
    "        all_attacks = all_attacks.union(board.attacks(i))\n",
    "        if board.piece_at(i) is not None:\n",
    "            pieces.add(i)\n",
    "    all_attacks = all_attacks.difference(pieces)\n",
    "    return all_attacks, pieces\n",
    "\n",
    "def show_attacks(board):\n",
    "    attacks, pieces = all_attacks(board)\n",
    "    print(len(pieces), \"brikker på brettet,\", len(attacks),  \"tomme felter angripes! \\n\")\n",
    "    return show_board(board, squares=attacks, size=390)\n",
    "\n",
    "def all_attacks2(board):\n",
    "    all_attacks = SquareSet([])\n",
    "    pieces = SquareSet([])\n",
    "    for i in range(64):\n",
    "        all_attacks = all_attacks.union(board.attacks(i))\n",
    "        if board.piece_at(i) is not None:\n",
    "            pieces.add(i)\n",
    "    attacked_pieces = all_attacks.intersection(pieces)\n",
    "    return all_attacks, attacked_pieces\n",
    "\n",
    "def show_attacks2(board):\n",
    "    attacks, attacked_pieces = all_attacks2(board)\n",
    "    num = len(attacked_pieces)\n",
    "    if num == 0:\n",
    "        print(\"Ingen av brikkene angriper hverandre! Kan du legge til flere fredelige brikker? \\n\")\n",
    "    else: \n",
    "        print(num, \"brikker er under angrep! Flytt brikkene slik at de blir fredelige! \\n\")\n",
    "    return show_board(board, squares=attacks, size=390)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  },
  "toc-autonumbering": false,
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}