A (GUI) .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "\n",
    "\n",
    "class Vertex:\n",
    "    def __init__(self, vertex, armies, ownValue):\n",
    "        self.name = vertex\n",
    "        self.neighbors = []\n",
    "        self.armies = armies\n",
    "        self.own = ownValue\n",
    "\n",
    "    def add_neighbor(self, neighbor):\n",
    "        if isinstance(neighbor, Vertex):\n",
    "            if neighbor.name not in self.neighbors:\n",
    "                self.neighbors.append(neighbor.name)\n",
    "                neighbor.neighbors.append(self.name)\n",
    "                self.neighbors = sorted(self.neighbors)\n",
    "                neighbor.neighbors = sorted(neighbor.neighbors)\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def add_neighbors(self, neighbors):\n",
    "        for neighbor in neighbors:\n",
    "            if isinstance(neighbor, Vertex):\n",
    "                if neighbor.name not in self.neighbors:\n",
    "                    self.neighbors.append(neighbor.name)\n",
    "                    neighbor.neighbors.append(self.name)\n",
    "                    self.neighbors = sorted(self.neighbors)\n",
    "                    neighbor.neighbors = sorted(neighbor.neighbors)\n",
    "            else:\n",
    "                return False\n",
    "\n",
    "\n",
    "####################################################################################\n",
    "\n",
    "\n",
    "class Graph:\n",
    "    def __init__(self):\n",
    "        self.vertices = {}\n",
    "        self.neighbors = {}\n",
    "\n",
    "    def add_vertex(self, vertex):\n",
    "        if isinstance(vertex, Vertex):\n",
    "            self.neighbors[vertex.name] = vertex.neighbors\n",
    "            self.vertices[vertex.name] = vertex\n",
    "\n",
    "    def getVertexByName(self, vertexname):\n",
    "        return self.vertices[vertexname]\n",
    "\n",
    "    def add_vertices(self, vertices):\n",
    "        for vertex in vertices:\n",
    "            if isinstance(vertex, Vertex):\n",
    "                self.neighbors[vertex.name] = vertex.neighbors\n",
    "                self.vertices[vertex.name] = vertex\n",
    "\n",
    "    def add_edge(self, vertex_from, vertex_to):\n",
    "        if isinstance(vertex_from, Vertex) and isinstance(vertex_to, Vertex):\n",
    "            vertex_from.add_neighbor(vertex_to)\n",
    "            if isinstance(vertex_from, Vertex) and isinstance(vertex_to, Vertex):\n",
    "                self.neighbors[vertex_from.name] = vertex_from.neighbors\n",
    "                self.neighbors[vertex_to.name] = vertex_to.neighbors\n",
    "\n",
    "    def add_edges(self, edges):\n",
    "        for edge in edges:\n",
    "            self.add_edge(edge[0], edge[1])\n",
    "\n",
    "    def adjacencyList(self):\n",
    "        if len(self.vertices) >= 1:\n",
    "            return [str(key) + \":\" + str(self.neighbors[key]) for key in self.neighbors.keys()]\n",
    "        else:\n",
    "            return dict()\n",
    "\n",
    "    def adjacencyMatrix(self):\n",
    "        if len(self.neighbors) >= 1:\n",
    "            self.vertex_names = sorted(g.neighbors.keys())\n",
    "            self.vertex_indices = dict(zip(self.vertex_names, range(len(self.vertex_names))))\n",
    "            import numpy as np\n",
    "            self.adjacency_matrix = np.zeros(shape=(len(self.neighbors), len(self.neighbors)))\n",
    "            for i in range(len(self.vertex_names)):\n",
    "                for j in range(i, len(self.neighbors)):\n",
    "                    for el in g.neighbors[self.vertex_names[i]]:\n",
    "                        j = g.vertex_indices[el]\n",
    "                        self.adjacency_matrix[i, j] = 1\n",
    "            return self.adjacency_matrix\n",
    "        else:\n",
    "            return dict()\n",
    "\n",
    "    def getMatrixNeighbours(self, i):\n",
    "        self.neighbours = []\n",
    "        for j in range(len(self.adjacencyMatrix()[0])):\n",
    "            a = int(self.adjacencyMatrix()[i][int(j)])\n",
    "            self.neighbours.append(a)\n",
    "        return self.neighbours\n",
    "\n",
    "\n",
    "##################################################################################\n",
    "\n",
    "\n",
    "def graph(g1):\n",
    "    \"\"\" Function to print a graph as adjacency list and adjacency matrix. \"\"\"\n",
    "    return str(g1.adjacencyList()) + '\\n' + '\\n' + str(g1.adjacencyMatrix())\n",
    "\n",
    "\n",
    "###################################################################################\n",
    "h = []\n",
    "turns = 0\n",
    "\n",
    "\n",
    "###################################################################################\n",
    "\n",
    "\n",
    "###################################################################################\n",
    "def numNeighbours(graph6, index, own7):\n",
    "    num = 0\n",
    "    neighbours2 = graph6.getMatrixNeighbours(index)\n",
    "    for ii in range(len(neighbours2)):\n",
    "        if neighbours2[ii] == 1 and own7[ii] == 0:\n",
    "            num = num + 1\n",
    "    return num\n",
    "\n",
    "\n",
    "###################################################################################\n",
    "\n",
    "\n",
    "def add_bonus(graph7, A3, own3, bonus):\n",
    "    maximum = -1\n",
    "    index111 = 0\n",
    "    for y in range(len(A3)):\n",
    "        if own3[y] == 1:\n",
    "            numNei = numNeighbours(graph7, y, own3)\n",
    "            if numNei > maximum:\n",
    "                maximum = numNei\n",
    "                index111 = y\n",
    "    A3[index111] += bonus\n",
    "    return index111\n",
    "\n",
    "\n",
    "###################################################################################\n",
    "\n",
    "\n",
    "def add_enemy_bonus(A4, own4):\n",
    "    minimum = 1000000\n",
    "    index222 = 0\n",
    "    for n in range(len(A4)):\n",
    "        if own4[n] == 0 and A4[n] < minimum:\n",
    "            minimum = A4[n]\n",
    "            index222 = n\n",
    "    A4[index222] += 2\n",
    "    return index222\n",
    "\n",
    "\n",
    "###################################################################################\n",
    "\n",
    "\n",
    "def inHeap(myHeap, enemy, my):\n",
    "    for l in range(len(myHeap)):\n",
    "        if myHeap[l][1] == enemy and myHeap[l][2] == my:\n",
    "            return 1\n",
    "    return 0\n",
    "\n",
    "\n",
    "###################################################################################\n",
    "\n",
    "\n",
    "def can_attack(graph2, index12, own2, A2, heuristics):\n",
    "    # get enemy's territory with maximum armies\n",
    "    # maximum2 = 0\n",
    "    # index2 = -1\n",
    "    global h\n",
    "    neighbours = graph2.getMatrixNeighbours(index12)\n",
    "    for i in range(len(neighbours)):\n",
    "        if own2[i] == 0 and neighbours[i] == 1 and own2[index12] == 1:\n",
    "            if inHeap(h, i, heuristics) == 0:\n",
    "                if A2[index12] - A2[i] > 1:\n",
    "                    heapq.heappush(h, (heuristics - 1, i, index12))\n",
    "                # else:\n",
    "                #     heapq.heappush(h, (heuristics, i, index12))\n",
    "            else:\n",
    "                for j in range(len(h)):\n",
    "                    if h[j][1] == i and h[j][2] == index12:\n",
    "                        if A2[index12] - A2[i] > 1:\n",
    "                            # never accessed\n",
    "                            te = h[j][0]\n",
    "                            te = min(te, heuristics - 1)\n",
    "                            h[j] = list(h[j])\n",
    "                            h[j][0] = te\n",
    "                            h[j] = tuple(h[j])\n",
    "                        # else:\n",
    "                        # te = h[j][0]\n",
    "                        # te = min(te, heuristics)\n",
    "                        # h[j] = list(h[j])\n",
    "                        # h[j][0] = te\n",
    "                        # h[j] = tuple(h[j])\n",
    "\n",
    "\n",
    "###############################################################\n",
    "def make_completed_continent_list(continents3, continentList):\n",
    "    for jj in range(len(continents3)):\n",
    "        if continents3[jj] not in continentList:\n",
    "            continentList.append(continents3[jj])\n",
    "\n",
    "\n",
    "###############################################################\n",
    "\n",
    "\n",
    "###############################################################\n",
    "def make_continent_list(continents3, continentList):\n",
    "    for jj in range(len(continents3)):\n",
    "        if continents3[jj] not in continentList:\n",
    "            continentList.append(continents3[jj])\n",
    "\n",
    "\n",
    "###############################################################\n",
    "\n",
    "###############################################################\n",
    "# def add_continent_bonus(graph9, A8, own8, attackedIndex, continentList1, completedList, bonusList):\n",
    "#     for m in continentList1:\n",
    "#         counter = 0\n",
    "#         for mm in range(len(continentList1)):\n",
    "#             if continentList1[mm] == m and own8[mm] == 1 and m not in completedList:\n",
    "#                 counter = counter + 1\n",
    "#         if counter == :\n",
    "#             add_bonus(graph9, A8, own8, bonusList[m])\n",
    "###############################################################\n",
    "\n",
    "# ######################A* Method##########################\n",
    "\n",
    "\n",
    "def A_Star(graph1, continent, numCountries, bonus):\n",
    "    global h\n",
    "    global gameA\n",
    "    global gameOwn\n",
    "    global attacking_list\n",
    "    global target_list\n",
    "\n",
    "    A1 = []\n",
    "    own1 = []\n",
    "    turnsTerminationCounter = 0\n",
    "    for kk in range(numCountries):\n",
    "        kk = kk + 1\n",
    "        vert = graph1.getVertexByName(kk)\n",
    "        A1.append(vert.armies)\n",
    "        own1.append(vert.own)\n",
    "    index = add_bonus(graph1, A1, own1, 2)\n",
    "    # Change\n",
    "    attacking_list.append(index)\n",
    "    target_list.append(0)\n",
    "    gameA.append(A1.copy())\n",
    "    gameOwn.append(own1.copy())\n",
    "    for k in range(len(A1)):\n",
    "        can_attack(graph1, k, own1, A1, A_star_cost(own1))\n",
    "    while True:\n",
    "        if len(h) == 0:\n",
    "            # change\n",
    "            attacking_list.append(0)\n",
    "            target_list.append(0)\n",
    "            if turnsTerminationCounter == 10:\n",
    "                return False\n",
    "            turnsTerminationCounter = turnsTerminationCounter + 1\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            index = add_enemy_bonus(A1, own1)\n",
    "            # Change\n",
    "            attacking_list.append(index)\n",
    "            target_list.append(0)\n",
    "            # Change\n",
    "            attacking_list.append(0)\n",
    "            target_list.append(0)\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            # Added second time because passive agent\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            index = add_bonus(graph1, A1, own1, 2)\n",
    "            # Change\n",
    "            attacking_list.append(index)\n",
    "            target_list.append(0)\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            for k in range(len(A1)):\n",
    "                can_attack(graph1, k, own1, A1, A_star_cost(own1))\n",
    "            continue\n",
    "        else:\n",
    "            turnsTerminationCounter = 0\n",
    "            element = heapq.heappop(h)\n",
    "            attacked = element[1]\n",
    "            attacking = element[2]\n",
    "            numNeiAttacked = numNeighbours(graph1, attacked, own1)\n",
    "            numNeiAttacking = numNeighbours(graph1, attacking, own1)\n",
    "            if A1[attacking] > A1[attacked]:\n",
    "                # change\n",
    "                attacking_list.append(attacking)\n",
    "                target_list.append(attacked)\n",
    "                if numNeiAttacked > numNeiAttacking:\n",
    "                    A1[attacking] -= A1[attacked]\n",
    "                    A1[attacked] = A1[attacking] - 1\n",
    "                    A1[attacking] = 1\n",
    "                else:\n",
    "                    A1[attacking] -= A1[attacked]\n",
    "                    A1[attacking] = A1[attacking] - 1\n",
    "                    A1[attacked] = 1\n",
    "                own1[attacked] = 1\n",
    "            else:\n",
    "                attacking_list.append(0)\n",
    "                target_list.append(0)\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            if enemy_territories(own1) == 0:\n",
    "                return True\n",
    "            # add_continent_bonus()\n",
    "            index = add_enemy_bonus(A1, own1)\n",
    "            # Change\n",
    "            attacking_list.append(index)\n",
    "            target_list.append(0)\n",
    "            # Change\n",
    "            attacking_list.append(0)\n",
    "            target_list.append(0)\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            index = add_bonus(graph1, A1, own1, 2)\n",
    "            # Change\n",
    "            attacking_list.append(index)\n",
    "            target_list.append(0)\n",
    "            gameA.append(A1.copy())\n",
    "            gameOwn.append(own1.copy())\n",
    "            can_attack(graph1, attacked, own1, A1, A_star_cost(own1))\n",
    "            global turns\n",
    "            turns = turns + 1\n",
    "\n",
    "    # return False\n",
    "\n",
    "\n",
    "##############################################################\n",
    "\n",
    "\n",
    "def enemy_territories(own4):\n",
    "    counter = 0\n",
    "    for m in range(len(own4)):\n",
    "        if own4[m] == 0:\n",
    "            counter = counter + 1\n",
    "    return counter\n",
    "\n",
    "\n",
    "##############################################################\n",
    "import re\n",
    "def get_risk_graph_alg(file_name):\n",
    "    global countries_1\n",
    "    global countries_2\n",
    "    global troops_1\n",
    "    global troops_2\n",
    "\n",
    "    #G = pydot.Dot(graph_type='graph')\n",
    "    g = Graph()\n",
    "    partition_bonus = []\n",
    "    partitions = {}\n",
    "    file = open(file_name, \"r\")\n",
    "    line_1 = file.readline()\n",
    "    line_1 = re.split(' |\\n',line_1)\n",
    "    line_1.remove('')\n",
    "    n_nodes = int(line_1[0])\n",
    "    n_edges = int(line_1[1])\n",
    "    n_partitions = int(line_1[2])\n",
    "    start_index = 2\n",
    "    for i in range(start_index, start_index + n_nodes):\n",
    "        start_index = i+1\n",
    "        line = file.readline()\n",
    "        line = re.split(' |\\n|  |\\r|\\t',line)\n",
    "        node_name = line[0]\n",
    "        pl = line[1]\n",
    "        army = line[2]\n",
    "        if(pl == '2'):\n",
    "            pl = '0'\n",
    "        node = Vertex(int(node_name), int(army), int(pl))\n",
    "        g.add_vertex(node)\n",
    "    for i in range(start_index, start_index + n_edges):\n",
    "        start_index = i+1\n",
    "        line = file.readline(i)\n",
    "        line = re.split(' |\\n|  |\\r|\\t',line)\n",
    "        node1 = line[0]\n",
    "        node2 = line[1]\n",
    "        node1 = g.getVertexByName(int(node1))\n",
    "        node2 = g.getVertexByName(int(node2))\n",
    "        g.add_edge(node1, node2)\n",
    "    for i in range(start_index, start_index + n_partitions):\n",
    "        line = file.readline(i)\n",
    "        line = re.split(' |\\n',line)\n",
    "        line.remove('')\n",
    "        bonus_value = int(line[0])\n",
    "        partition_bonus.append(bonus_value)\n",
    "        del line[0]\n",
    "        for node_name in line:\n",
    "            partitions[int(node_name)] = i-start_index + 1\n",
    "    file.close()\n",
    "    return (g, partition_bonus, partitions, n_nodes, n_partitions)\n",
    "\n",
    "###################################################################################\n",
    "\n",
    "###################################################################################\n",
    "def A_star_cost(own8):\n",
    "    return enemy_territories(own8) + turns\n",
    "###################################################################################\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Graph imports\n",
    "import re\n",
    "import pydot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "#GUI imports\n",
    "import io\n",
    "import _tkinter\n",
    "import tkinter as tk\n",
    "from tkinter import * \n",
    "from tkinter import ttk\n",
    "from tkinter import filedialog\n",
    "from PIL import Image, ImageTk\n",
    "from IPython.core.display import Image as image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_risk_graph(file_name):\n",
    "    global countries_1\n",
    "    global countries_2\n",
    "    global troops_1\n",
    "    global troops_2\n",
    "    G = pydot.Dot(graph_type='graph')    \n",
    "    #Assumption max of 6 Partitions\n",
    "    partitions_colors = ['red','yellow','green','blue','violet','pink']\n",
    "    nodes_bonus = {}\n",
    "    file = open(file_name, \"r\")\n",
    "    line_1 = file.readline()\n",
    "    line_1 = re.split(' |\\n',line_1)\n",
    "    line_1.remove('')\n",
    "    n_nodes = int(line_1[0])\n",
    "    n_edges = int(line_1[1])\n",
    "    n_partitions = int(line_1[2])\n",
    "    start_index = 2\n",
    "    for i in range(start_index, start_index + n_nodes):\n",
    "        start_index = i+1\n",
    "        line = file.readline()\n",
    "        line = re.split(' |\\n|  |\\r|\\t',line)        \n",
    "        node_name = line[0]\n",
    "        pl = line[1]   \n",
    "        army = line[2]\n",
    "        node_label = node_name + \" (\" + army + \")\"\n",
    "        if(pl == \"1\"):\n",
    "            countries_1 += 1\n",
    "            node_label = \"*\" + node_label\n",
    "            troops_1[node_name] = int(army)\n",
    "        else:\n",
    "            countries_2 += 1\n",
    "            troops_2[node_name] = int(army)\n",
    "        node = pydot.Node(node_name, style='filled',shape='circle',fillcolor='pink')\n",
    "        node.set_label(node_label)\n",
    "        G.add_node(node)\n",
    "    for i in range(start_index, start_index + n_edges):\n",
    "        start_index = i+1\n",
    "        line = file.readline(i)\n",
    "        line = re.split(' |\\n|  |\\r|\\t',line)        \n",
    "        node1 = line[0]\n",
    "        node2 = line[1]\n",
    "        edge = pydot.Edge(node1, node2)\n",
    "        G.add_edge(edge)\n",
    "    for i in range(start_index, start_index + n_partitions):\n",
    "        line = file.readline(i)\n",
    "        line = re.split(' |\\n',line)\n",
    "        line.remove('')\n",
    "        bonus_value = int(line[0])\n",
    "        del line[0]        \n",
    "        node_color = partitions_colors[i-start_index]\n",
    "        for node_name in line:\n",
    "            nodes_bonus[node_name] = bonus_value\n",
    "            node = G.get_node(node_name)            \n",
    "            node[0].set_fillcolor(node_color)             \n",
    "    file.close()\n",
    "    return (G,nodes_bonus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_risk_graph_alg(file_name):\n",
    "    global countries_1\n",
    "    global countries_2\n",
    "    global troops_1\n",
    "    global troops_2\n",
    "    #G = pydot.Dot(graph_type='graph')    \n",
    "    g = Graph()\n",
    "    partition_bonus = []\n",
    "    partitions = {}\n",
    "    file = open(file_name, \"r\")\n",
    "    line_1 = file.readline()\n",
    "    line_1 = re.split(' |\\n',line_1)\n",
    "    line_1.remove('')\n",
    "    n_nodes = int(line_1[0])\n",
    "    n_edges = int(line_1[1])\n",
    "    n_partitions = int(line_1[2])\n",
    "    start_index = 2\n",
    "    for i in range(start_index, start_index + n_nodes):\n",
    "        start_index = i+1\n",
    "        line = file.readline()\n",
    "        line = re.split(' |\\n|  |\\r|\\t',line)        \n",
    "        node_name = line[0]\n",
    "        pl = line[1]   \n",
    "        army = line[2]\n",
    "        if(pl == '2'):\n",
    "            pl = '0'\n",
    "        node = Vertex(int(node_name), int(army), int(pl))\n",
    "        g.add_vertex(node)\n",
    "    for i in range(start_index, start_index + n_edges):\n",
    "        start_index = i+1\n",
    "        line = file.readline(i)\n",
    "        line = re.split(' |\\n|  |\\r|\\t',line)        \n",
    "        node1 = line[0]\n",
    "        node2 = line[1]\n",
    "        node1 = g.getVertexByName(int(node1))\n",
    "        node2 = g.getVertexByName(int(node2))\n",
    "        g.add_edge(node1, node2)\n",
    "    for i in range(start_index, start_index + n_partitions):\n",
    "        line = file.readline(i)\n",
    "        line = re.split(' |\\n',line)\n",
    "        line.remove('')\n",
    "        bonus_value = int(line[0])\n",
    "        partition_bonus.append(bonus_value)        \n",
    "        del line[0]       \n",
    "        for node_name in line:\n",
    "            partitions[int(node_name)] = i-start_index + 1                         \n",
    "    file.close()\n",
    "    return (g, partition_bonus, partitions, n_nodes, n_partitions)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculate troops number given troops dictionary\n",
    "def get_troops(dic):\n",
    "    sum = 0\n",
    "    for key, value in dic.items():\n",
    "        sum = sum + value\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "gameA = []\n",
    "gameOwn = []\n",
    "attacking_list = []\n",
    "target_list = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Initializing root frame \n",
    "root=tk.Tk()\n",
    "root.title(\"RISK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initializaing Global Variables Game\n",
    "current_player = 1\n",
    "## Globals of place frame\n",
    "place_list = [\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\",\"10\",\"11\",\"12\"]\n",
    "player_str = StringVar()\n",
    "stage_str = StringVar()\n",
    "countries_str = StringVar()\n",
    "troops_str = StringVar()\n",
    "bonus_str = StringVar()\n",
    "place_str = StringVar()\n",
    "change_str = StringVar()\n",
    "control_frame = ttk.Frame(root)\n",
    "attack_frame = ttk.Frame(root)\n",
    "winner_frame = ttk.Frame(root)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initializaing Global Variables\n",
    "countries = 0 \n",
    "troops = 0\n",
    "bonus = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initializaing Global Variables Player 1\n",
    "countries_1 = 0\n",
    "troops_1 = {}\n",
    "bonus_1 = 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initializaing Global Variables Player 2\n",
    "countries_2 = 0\n",
    "troops_2 = {}\n",
    "bonus_2 = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Allowing expansion with scale\n",
    "root.columnconfigure(0,weight=1)\n",
    "root.columnconfigure(1,weight=1)\n",
    "root.columnconfigure(2,weight=1)\n",
    "root.columnconfigure(3,weight=1)\n",
    "root.rowconfigure(0,weight=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#Load Game File\n",
    "file_name = filedialog.askopenfilename(filetypes = ((\"Text files\",\"*.txt\"),(\"All files\",\"*.*\")))\n",
    "G,nodes_bonus = get_risk_graph(file_name)\n",
    "g, partition_bonus, partitions, n_nodes, n_partitions = get_risk_graph_alg(file_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "draw_game = A_Star(g, partitions, n_nodes, partition_bonus)\n",
    "draw_game = not draw_game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initialize variables for first game for player 1 \n",
    "countries = countries_1\n",
    "troops = get_troops(troops_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "117\n"
     ]
    }
   ],
   "source": [
    "game_index = -1\n",
    "game_turns = len(gameA)\n",
    "print(game_turns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_ctrl_frame():\n",
    "    global control_frame\n",
    "    global current_player\n",
    "    #Design the screen - control frame\n",
    "    control_frame = ttk.Frame(root)\n",
    "    control_frame.config(width = 300, height = 800)\n",
    "    #control_frame.grid(row=0,column=2,columnspan=2)\n",
    "    control_frame.pack(side = RIGHT)\n",
    "    #Components inside control frame - Placement mode \n",
    "    player_label = Label(control_frame, font=\"Times 18\", textvariable = player_str)\n",
    "    player_str.set(\"Player \" + str(current_player))\n",
    "    player_label.pack()\n",
    "    stage_label = Label(control_frame,font=\"Times 18\", textvariable = stage_str)\n",
    "    stage_str.set(\"Troop Placement\")\n",
    "    stage_label.pack()\n",
    "    countries_label = Label(control_frame,font=\"Times 14\", textvariable = countries_str)\n",
    "    countries_str.set(\"Countries = \" + str(countries))\n",
    "    countries_label.pack()\n",
    "    troops_label = Label(control_frame,font=\"Times 14\", textvariable = troops_str)\n",
    "    troops_str.set(\"Troops = \" + str(troops))\n",
    "    troops_label.pack()\n",
    "    bonus_label = Label(control_frame,font=\"Times 14\", textvariable = bonus_str)\n",
    "    bonus_str.set(\"Bonus = \" + str(bonus))\n",
    "    bonus_label.pack()\n",
    "    place_button = tk.Button(control_frame, text=\"Next\",command=lambda: show_attack_frame())\n",
    "    place_button.pack()\n",
    "    change_label = Label(control_frame,font=\"Times 14\", textvariable = change_str)\n",
    "    change_label.pack()\n",
    "    #prev_button = tk.Button(control_frame, text=\"Previous\",command=lambda: show_attack_prev())\n",
    "   # prev_button.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_attack_frame():\n",
    "    global attack_frame\n",
    "    global current_player\n",
    "    #Design the screen - attack frame\n",
    "    attack_frame = ttk.Frame(root)\n",
    "    attack_frame.config(width = 300, height = 800)\n",
    "    attack_frame.pack(side = RIGHT)\n",
    "    #Components inside control frame - Placement mode \n",
    "    player_label = Label(attack_frame, font=\"Times 18\", textvariable = player_str)\n",
    "    player_str.set(\"Player \" + str(current_player))\n",
    "    player_label.pack()\n",
    "    stage_label = Label(attack_frame,font=\"Times 18\", textvariable = stage_str)\n",
    "    stage_str.set(\"Attacking\")\n",
    "    stage_label.pack()\n",
    "    countries_label = Label(attack_frame,font=\"Times 14\", textvariable = countries_str)\n",
    "    countries_str.set(\"Countries = \" + str(countries))\n",
    "    countries_label.pack()\n",
    "    troops_label = Label(attack_frame,font=\"Times 14\", textvariable = troops_str)\n",
    "    troops_str.set(\"Troops = \" + str(troops))\n",
    "    troops_label.pack()    \n",
    "    skip_button = tk.Button(attack_frame, text=\"Next\",command=lambda: show_control())\n",
    "    skip_button.pack()\n",
    "    change_label = Label(attack_frame,font=\"Times 14\", textvariable = change_str)\n",
    "    change_label.pack()\n",
    "    #prev2_button = tk.Button(attack_frame, text=\"Previous\",command=lambda: show_control_prev())\n",
    "    #prev2_button.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_winner_frame():\n",
    "    global winner_frame\n",
    "    global current_player\n",
    "    #Design the screen - attack frame\n",
    "    winner_frame = ttk.Frame(root)\n",
    "    winner_frame.config(width = 300, height = 800)\n",
    "    winner_frame.pack(side = RIGHT)\n",
    "    #Components inside control frame - Placement mode \n",
    "    player_label = Label(winner_frame, font=\"Times 18\", textvariable = player_str)\n",
    "    if(draw_game == False):\n",
    "        player_str.set(\"Player \" + str(current_player) + \"Wins !!\")\n",
    "    else:\n",
    "        player_str.set(\"Game is Draw\")\n",
    "    player_label.pack()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_player(current_player):\n",
    "    if (current_player == 1):\n",
    "        return 2\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_countries(current_player):\n",
    "    if (current_player == 1):\n",
    "        return countries_1\n",
    "    else:\n",
    "        return countries_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_troops(current_player):\n",
    "    if (current_player == 1):\n",
    "        return get_troops(troops_1)\n",
    "    else:\n",
    "        return get_troops(troops_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convert A/Own to G\n",
    "def get_new_G(A,own):\n",
    "    global G\n",
    "    global countries_1\n",
    "    global countries_2\n",
    "    global troops_1\n",
    "    global troops_2\n",
    "    i=0\n",
    "    countries_1 = 0\n",
    "    countries_2 = 0\n",
    "    for army in A:\n",
    "        i=i+1\n",
    "        node_name = str(i)\n",
    "        pl = own[i-1]           \n",
    "        node_label = node_name + \" (\" + str(army) + \")\"\n",
    "        if(pl == 1):\n",
    "            node_label = \"*\" + node_label\n",
    "            troops_1[node_name] = int(army)\n",
    "            countries_1 += 1\n",
    "        else:\n",
    "            troops_2[node_name] = int(army)\n",
    "            countries_2 += 1\n",
    "        node = G.get_node(node_name) \n",
    "        node[0].set_label(node_label)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_winner():\n",
    "    global attack_frame\n",
    "    attack_frame.pack_forget()\n",
    "    build_winner_frame() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def show_control_prev():\n",
    "    global game_index\n",
    "    global game_turns\n",
    "    game_index -= 1\n",
    "    if(game_index <= 0):\n",
    "        game_index += 1\n",
    "        return \n",
    "    A = gameA[game_index]\n",
    "    own = gameOwn[game_index]\n",
    "    get_new_G(A,own)\n",
    "    show_graph()\n",
    "    global current_player\n",
    "    global countries \n",
    "    global troops\n",
    "    global bonus     \n",
    "    countries = new_countries(current_player) \n",
    "    troops = new_troops(current_player)\n",
    "    bonus = 2\n",
    "    global attack_frame\n",
    "    attack_frame.pack_forget()\n",
    "    build_ctrl_frame()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_control():\n",
    "    global game_index\n",
    "    global game_turns\n",
    "    game_index += 1\n",
    "    if(game_index >= game_turns):\n",
    "        show_winner()\n",
    "        return \n",
    "    A = gameA[game_index]\n",
    "    own = gameOwn[game_index]\n",
    "    get_new_G(A,own)\n",
    "    show_graph()\n",
    "    global current_player\n",
    "    global countries \n",
    "    global troops\n",
    "    global bonus \n",
    "    current_player = new_player(current_player)\n",
    "    countries = new_countries(current_player) \n",
    "    troops = new_troops(current_player)\n",
    "    change_str.set(new_change())\n",
    "    bonus = 2\n",
    "    global attack_frame\n",
    "    attack_frame.pack_forget()\n",
    "    build_ctrl_frame()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def show_attack_prev():\n",
    "    global game_index\n",
    "    global game_turns\n",
    "    game_index -= 1\n",
    "    if(game_index <= 0):\n",
    "        game_index += 1\n",
    "        return\n",
    "    A = gameA[game_index]\n",
    "    own = gameOwn[game_index]\n",
    "    get_new_G(A,own)\n",
    "    show_graph()    \n",
    "    global countries \n",
    "    global troops\n",
    "    global bonus  \n",
    "    current_player = new_player(current_player)\n",
    "    countries = new_countries(current_player) \n",
    "    troops = new_troops(current_player)\n",
    "    bonus = 2\n",
    "    global control_frame\n",
    "    control_frame.pack_forget()\n",
    "    build_attack_frame()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_change():\n",
    "    global attacking_list\n",
    "    global target_list\n",
    "    global game_index\n",
    "    if(game_index < 0 or attacking_list[game_index] == 0):\n",
    "        return \"No change in last turn\"\n",
    "    elif (attacking_list[game_index] > 0 and target_list[game_index] > 0):\n",
    "        return \"Country \" + str(attacking_list[game_index] + 1) +\" attacked \" + str(target_list[game_index] + 1)\n",
    "    else:\n",
    "        return \"Country \" + str(attacking_list[game_index] + 1) +\" changed\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_attack_frame():\n",
    "    global game_index\n",
    "    global game_turns\n",
    "    global attacking_list\n",
    "    global target_list\n",
    "    game_index += 1\n",
    "    if(game_index >= game_turns):\n",
    "        show_winner()\n",
    "        return\n",
    "    A = gameA[game_index]\n",
    "    own = gameOwn[game_index]\n",
    "    get_new_G(A,own)\n",
    "    show_graph()    \n",
    "    global countries \n",
    "    global troops\n",
    "    global bonus    \n",
    "    countries = new_countries(current_player) \n",
    "    troops = new_troops(current_player)\n",
    "    change_str.set(new_change())\n",
    "    bonus = 2\n",
    "    global control_frame\n",
    "    control_frame.pack_forget()\n",
    "    build_attack_frame()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Start Building Ctrl Frame\n",
    "change_str.set(\"No Change  Yet\")\n",
    "build_ctrl_frame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding scroll\n",
    "yscroll = Scrollbar(root)\n",
    "yscroll.pack(side=RIGHT)\n",
    "xscroll = Scrollbar(root)\n",
    "xscroll.pack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "canvas = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Show the main Graph of the Game\n",
    "def build_graph():\n",
    "    global canvas\n",
    "    global G\n",
    "    pilimg = Image.open(io.BytesIO(G.create_png()))\n",
    "    image_tk = ImageTk.PhotoImage(pilimg, master = root)\n",
    "    canvas = Canvas(root, bg = 'white', height = 800, width = 300, yscrollcommand = yscroll.set, xscrollcommand = xscroll.set)\n",
    "    canvas.image = image_tk\n",
    "    canvas.create_image(0,0,image=canvas.image,anchor='nw')\n",
    "    canvas.pack(side = LEFT, expand = YES, fill=BOTH)\n",
    "    yscroll.config(command=canvas.yview)\n",
    "    xscroll.config(command=canvas.xview, orient = HORIZONTAL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Show the main Graph of the Game\n",
    "def show_graph():\n",
    "    global canvas\n",
    "    global G\n",
    "    pilimg = Image.open(io.BytesIO(G.create_png()))\n",
    "    image_tk = ImageTk.PhotoImage(pilimg, master = root)    \n",
    "    canvas.image = image_tk\n",
    "    canvas.create_image(0,0,image=canvas.image,anchor='nw')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initial Graph\n",
    "build_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "root.mainloop()"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}