Maze3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maze Loaded\n",
      " \n",
      " \n",
      "Locating start point...\n",
      "Tango Spotted, Grid: 1 1\n",
      " \n",
      "Locating Yellow key point...\n",
      "Tango Spotted, Grid: 15 1\n",
      " \n",
      "Locating Yellow door point...\n",
      "Tango Spotted, Grid: 8 6\n",
      " \n",
      "Locating Green key point...\n",
      "Tango Spotted, Grid: 6 8\n",
      " \n",
      "Locating Green door point...\n",
      "Tango Spotted, Grid: 13 6\n",
      " \n",
      "Locating Red key point...\n",
      "Tango Spotted, Grid: 15 11\n",
      " \n",
      "Locating Red door point...\n",
      "Tango Spotted, Grid: 4 7\n",
      " \n",
      "Locating Blue key point...\n",
      "Tango Spotted, Grid: 14 13\n",
      " \n",
      "Locating Blue door point...\n",
      "Tango Spotted, Grid: 4 15\n",
      " \n",
      "Locating end point...\n",
      "Tango Spotted, Grid: 5 16\n",
      " \n",
      "Destination Arrived : Yellow key Found\n",
      "The Logistic Path Is:\n",
      " [(2, 1), (3, 1), (4, 1), (4, 2), (5, 2), (6, 2), (6, 1), (7, 1), (8, 1), (8, 2), (9, 2), (10, 2), (10, 1), (11, 1), (12, 1), (13, 1), (13, 2), (14, 2), (15, 2)]\n",
      " \n",
      "Destination Arrived: Yellow Door Found and Unlocked\n",
      "The Logistic Path Is:\n",
      " [(15, 2), (14, 2), (13, 2), (13, 1), (12, 1), (11, 1), (10, 1), (10, 2), (9, 2), (8, 2), (8, 3), (7, 3), (7, 4), (7, 5), (8, 5)]\n",
      " \n",
      "Destination Arrived: Next Key Found\n",
      "The Logistic Path Is:\n",
      " [(8, 7), (8, 8), (7, 8)]\n",
      " \n",
      "Destination Arrived: Green Door Found and Unlocked\n",
      "The Logistic Path Is:\n",
      " [(7, 8), (8, 8), (8, 7), (8, 6), (8, 5), (9, 5), (10, 5), (10, 4), (11, 4), (12, 4), (13, 4), (13, 5)]\n",
      " \n",
      "Destination Arrived: Next Key Found\n",
      "The Logistic Path Is:\n",
      " [(8, 7), (8, 8), (7, 8), (14, 6), (15, 6), (15, 7), (15, 8), (14, 8), (13, 8), (12, 8), (11, 8), (11, 9), (11, 10), (11, 11), (10, 11), (9, 11), (9, 12), (9, 13), (10, 13), (10, 14), (11, 14), (12, 14), (12, 13), (12, 12), (13, 12), (13, 11), (13, 10), (14, 10), (15, 10)]\n",
      " \n",
      "Destination Arrived: Red Door Found and Unlocked\n",
      "The Logistic Path Is:\n",
      " [(15, 10), (14, 10), (13, 10), (13, 11), (13, 12), (12, 12), (12, 13), (12, 14), (11, 14), (10, 14), (10, 13), (9, 13), (9, 12), (9, 11), (10, 11), (11, 11), (11, 10), (11, 9), (11, 8), (12, 8), (13, 8), (14, 8), (15, 8), (15, 7), (15, 6), (14, 6), (13, 6), (13, 5), (13, 4), (12, 4), (11, 4), (10, 4), (10, 5), (9, 5), (8, 5), (7, 5), (6, 5), (5, 5), (4, 5), (4, 6)]\n",
      " \n",
      "Destination Arrived: Next Key Found\n",
      "The Logistic Path Is:\n",
      " [(8, 7), (8, 8), (7, 8), (14, 6), (15, 6), (15, 7), (15, 8), (14, 8), (13, 8), (12, 8), (11, 8), (11, 9), (11, 10), (11, 11), (10, 11), (9, 11), (9, 12), (9, 13), (10, 13), (10, 14), (11, 14), (12, 14), (12, 13), (12, 12), (13, 12), (13, 11), (13, 10), (14, 10), (15, 10), (3, 7), (2, 7), (1, 7), (1, 8), (1, 9), (2, 9), (3, 9), (3, 10), (3, 11), (4, 11), (5, 11), (5, 12), (6, 12), (7, 12), (7, 13), (7, 14), (7, 15), (8, 15), (9, 15), (9, 16), (10, 16), (11, 16), (12, 16), (13, 16), (13, 15), (14, 15), (15, 15), (15, 14), (15, 13)]\n",
      " \n",
      "Destination Arrived: Blue Door Found and Unlocked\n",
      "The Logistic Path Is:\n",
      " [(15, 13), (15, 14), (15, 15), (14, 15), (13, 15), (13, 16), (12, 16), (11, 16), (10, 16), (9, 16), (9, 15), (8, 15), (7, 15), (7, 14), (7, 13), (7, 12), (6, 12), (5, 12), (5, 11), (4, 11), (3, 11), (3, 10), (3, 9), (2, 9), (1, 9), (1, 10), (1, 11), (1, 12), (2, 12), (2, 13), (2, 14), (1, 14), (1, 15), (1, 16), (2, 16), (3, 16), (3, 15)]\n",
      " \n",
      "Destination Arrived: Reached Destination\n",
      "The Logistic Path Is:\n",
      " [(5, 15)]\n",
      " \n",
      "Check Your Map...\n",
      "Map:\n",
      "------------------------------------\n",
      "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n",
      "1 s 0 0 0 0 1 s s s s s s 1 s s s 1 \n",
      "1 s 1 0 1 0 1 s 1 s 1 1 s s s 1 s 1 \n",
      "1 s 1 0 1 1 1 s 1 s s s 1 1 1 s s 1 \n",
      "1 s s 1 0 s s g 0 1 1 s 1 0 1 h 1 1 \n",
      "1 1 s 0 1 s 1 1 1 0 0 s s 0 1 s e 1 \n",
      "1 s s 1 1 s 1 0 c 1 0 1 s 1 1 1 1 1 \n",
      "1 s 1 s s s 1 1 s 1 0 0 s s s s 0 1 \n",
      "1 s s s 1 s s s s 1 0 1 1 1 1 s 1 1 \n",
      "1 1 s 1 1 s 1 0 1 0 1 s s s 1 s s 1 \n",
      "1 s s 1 s s 1 0 1 0 1 s 1 s s 1 s 1 \n",
      "1 s 1 1 s 1 0 1 s s s s 1 1 s 1 s 1 \n",
      "1 s 1 0 s 1 0 1 s 1 1 1 s s s 1 s 1 \n",
      "1 s s 1 s s s 0 s 1 s s s 1 1 s s 1 \n",
      "1 1 s 1 1 1 s 1 s 1 s 1 1 i 1 s 1 1 \n",
      "1 a s 1 0 0 s s s 1 s f 1 s s s 0 1 \n",
      "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n",
      "------------------------------------\n",
      "█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ \n",
      "█ ╳ ░ ░ ░ ░ █ ╳ ╳ ╳ ╳ ╳ ╳ █ ╳ ╳ ╳ █ \n",
      "█ ╳ █ ░ █ ░ █ ╳ █ ╳ █ █ ╳ ╳ ╳ █ ╳ █ \n",
      "█ ╳ █ ░ █ █ █ ╳ █ ╳ ╳ ╳ █ █ █ ╳ ╳ █ \n",
      "█ ╳ ╳ █ ░ ╳ ╳ g ░ █ █ ╳ █ ░ █ h █ █ \n",
      "█ █ ╳ ░ █ ╳ █ █ █ ░ ░ ╳ ╳ ░ █ ╳ ╳ █ \n",
      "█ ╳ ╳ █ █ ╳ █ ░ c █ ░ █ ╳ █ █ █ █ █ \n",
      "█ ╳ █ ╳ ╳ ╳ █ █ ╳ █ ░ ░ ╳ ╳ ╳ ╳ ░ █ \n",
      "█ ╳ ╳ ╳ █ ╳ ╳ ╳ ╳ █ ░ █ █ █ █ ╳ █ █ \n",
      "█ █ ╳ █ █ ╳ █ ░ █ ░ █ ╳ ╳ ╳ █ ╳ ╳ █ \n",
      "█ ╳ ╳ █ ╳ ╳ █ ░ █ ░ █ ╳ █ ╳ ╳ █ ╳ █ \n",
      "█ ╳ █ █ ╳ █ ░ █ ╳ ╳ ╳ ╳ █ █ ╳ █ ╳ █ \n",
      "█ ╳ █ ░ ╳ █ ░ █ ╳ █ █ █ ╳ ╳ ╳ █ ╳ █ \n",
      "█ ╳ ╳ █ ╳ ╳ ╳ ░ ╳ █ ╳ ╳ ╳ █ █ ╳ ╳ █ \n",
      "█ █ ╳ █ █ █ ╳ █ ╳ █ ╳ █ █ i █ ╳ █ █ \n",
      "█ a ╳ █ ░ ░ ╳ ╳ ╳ █ ╳ f █ ╳ ╳ ╳ ░ █ \n",
      "█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ \n"
     ]
    }
   ],
   "source": [
    "#Python Code Three Day Chalenge \n",
    "#Team 20\n",
    "#Member's:-\n",
    "#Hiren Rathod | hiren.rathod@epita.fr\n",
    "#Prateek AREKALLU PRAFULLA CHANDRA | prateek.arekallu-prafulla-chandra@epita.fr\n",
    "#Vinay DARAPUREDDI | vinay.darapureddi@epita.fr\n",
    "\n",
    "\n",
    "#import part\n",
    "import time\n",
    "import sys\n",
    "import os\n",
    "from goto import with_goto\n",
    "#global values\n",
    "load = 0                                 # set initial loading value\n",
    "walk = [(1,0),(-1,0),(0,1),(0,-1)]       # set movements\n",
    "backtracker = []                         # set backtracker (remember that this is a stack)\n",
    "gmainmaze = []                           # set initial blank maze\n",
    "keyTracker = []\n",
    "YdoorTracker = []\n",
    "GdoorTracker = []\n",
    "RdoorTracker = []\n",
    "BdoorTracker = []\n",
    "FinalTracker = []\n",
    "\n",
    "def initialize():   #loading \n",
    "    sx = 0   # start x value\n",
    "    sy = 0   # start y value\n",
    "    ykx = 0  # Yellow Key X value\n",
    "    yky = 0  # Yellow Key Y value\n",
    "    ydx = 0  # Yellow Door X value\n",
    "    ydy = 0  # Yellow Door Y value\n",
    "    gkx = 0  # Green Key X value\n",
    "    gky = 0  # Green Key Y value\n",
    "    gdx = 0  # Green Door X value\n",
    "    gdy = 0  # Green Door Y value\n",
    "    rkx = 0  # Red Key X value\n",
    "    rky = 0  # Red Key Y value\n",
    "    rdx = 0  # Red Door X value\n",
    "    rdy = 0  # Red Door Y value\n",
    "    bkx = 0  # Blue Key X value\n",
    "    bky = 0  # Blue Key Y value\n",
    "    bdx = 0  # Blue Door X value\n",
    "    bdy = 0  # Blue Door Y value\n",
    "    ex = 0   # end x value\n",
    "    ey = 0   # end y value\n",
    "    while load == 0:    #just some cool animation\n",
    "        sys.stdout.write(\"\\rloading |\")\n",
    "        time.sleep(0.1)\n",
    "        sys.stdout.write(\"\\rloading /\")\n",
    "        time.sleep(0.1)\n",
    "        sys.stdout.write(\"\\rloading -\")\n",
    "        time.sleep(0.1)\n",
    "        sys.stdout.write(\"\\rloading \\\\\")\n",
    "        time.sleep(0.1)\n",
    "        sys.stdout.write(\"\\r\")\n",
    "        mainmaze = loadMaze(\"Maze3.txt\")\n",
    "        print(\"Maze Loaded\")\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\" \")\n",
    "        print(\"Locating start point...\")\n",
    "        sx, sy = spotter(\"s\",mainmaze)\n",
    "        time.sleep(1)\n",
    "        print(\" \")\n",
    "        print(\"Locating Yellow key point...\")\n",
    "        ykx, yky = spotter(\"a\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating Yellow door point...\")\n",
    "        ydx, ydy = spotter(\"b\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating Green key point...\")\n",
    "        gkx, gky = spotter(\"c\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating Green door point...\")\n",
    "        gdx, gdy = spotter(\"d\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating Red key point...\")\n",
    "        rkx, rky = spotter(\"f\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating Red door point...\")\n",
    "        rdx, rdy = spotter(\"g\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating Blue key point...\")\n",
    "        bkx, bky = spotter(\"i\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating Blue door point...\")\n",
    "        bdx, bdy = spotter(\"h\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        print(\"Locating end point...\")\n",
    "        ex, ey = spotter(\"e\",mainmaze)\n",
    "        print(\" \")\n",
    "        time.sleep(1)\n",
    "        return sx, sy, ykx, yky, ydx, ydy, gkx, gky, gdx, gdy, rkx, rky, rdx, rdy, bkx, bky, bdx, bdy, ey, ex, mainmaze;\n",
    "        break\n",
    "    print(\" \")\n",
    "    sys.stdout.write(\"\\rInitialized!\")\n",
    "    print(\" \")\n",
    "    time.sleep(3)\n",
    "    os.system(\"cls\")\n",
    "\n",
    "# Loading The Maze from File by using delimeter ','    \n",
    "def loadMaze(filename):\n",
    "    #load the data from the file into a 2D list\n",
    "    with open(filename) as i:\n",
    "        maze = []\n",
    "        for line in i:\n",
    "            line = line.strip()\n",
    "            spawnmaze = line.split(\", \")\n",
    "            maze.append(spawnmaze)\n",
    "    return maze\n",
    "\n",
    "\n",
    "# Function Created for spotting Start, Key, Door, End point and Enemy\n",
    "def spotter(num,maze):\n",
    "    #Locate the 'element' in the maze \n",
    "    num = str(num)\n",
    "    rowcounter = -1\n",
    "    linecounter = 0\n",
    "    for rows in maze:\n",
    "        rowcounter = rowcounter + 1\n",
    "        if num in rows:\n",
    "            for element in rows:\n",
    "                if element == num:\n",
    "                    print(\"Tango Spotted, Grid:\", rowcounter, linecounter)\n",
    "                    return rowcounter, linecounter;\n",
    "                    break\n",
    "                linecounter = linecounter + 1\n",
    "\n",
    "def valid(maze,x,y): # check if valid\n",
    "    height = len(maze) - 1\n",
    "    width = len(maze[0]) - 1\n",
    "    if 0 <= x <= height and 0 <= y <= width:\n",
    "        return 1\n",
    "    else: \n",
    "        return 0\n",
    "\n",
    "   \n",
    "def findKey(sx,sy,ykx,yky): \n",
    "    global gmainmaze   \n",
    "    for i in walk:          #try every direction\n",
    "        x = sx + i[0]       #make the move\n",
    "        y = sy + i[1]\n",
    "        if valid(gmainmaze,x,y): # check if still in the maze\n",
    "            if x == ykx and y == yky: #check if reached destination\n",
    "                print(\"Destination Arrived : Yellow key Found\")\n",
    "                print(\"The Logistic Path Is:\\n\",backtracker)\n",
    "                print(\" \")\n",
    "                return 1\n",
    "            else:\n",
    "                if gmainmaze[x][y] == \"0\" and (x,y) not in backtracker: #add to the stack\n",
    "                    backtracker.append((x,y))\n",
    "               \n",
    "                else:\n",
    "                    continue\n",
    "        else:\n",
    "            continue\n",
    "        \n",
    "        if findKey(x,y,ykx,yky) == 1: # Recursion (do the next step)\n",
    "            return 1\n",
    "        else:\n",
    "            continue\n",
    "    backtracker.pop(-1) #moveback while \n",
    "    return 0\n",
    "\n",
    "\n",
    "def YkeyToYDoor(ykx,yky,ydx,ydy):\n",
    "    global gmainmaze   \n",
    "    for i in walk:          #try every direction\n",
    "        x = ykx + i[0]       #make the move\n",
    "        y = yky + i[1]\n",
    "        if valid(gmainmaze,x,y): # check if still in the maze\n",
    "            if x == ydx and y == ydy: #check if reached destination\n",
    "                print(\"Destination Arrived: Yellow Door Found and Unlocked\")\n",
    "                print(\"The Logistic Path Is:\\n\",YdoorTracker)\n",
    "                print(\" \")\n",
    "                return 1\n",
    "            else:\n",
    "                if gmainmaze[x][y] == \"0\" and (x,y) not in YdoorTracker:\n",
    "                    YdoorTracker.append((x,y))\n",
    "                    \n",
    "                else:\n",
    "                    continue\n",
    "        else:\n",
    "            continue\n",
    "        \n",
    "        if YkeyToYDoor(x,y,ydx,ydy) == 1: # Recursion (do the next step)\n",
    "            return 1\n",
    "        else:\n",
    "            continue\n",
    "    YdoorTracker.pop(-1) #moveback while \n",
    "    return 0\n",
    "\n",
    "def GkeyToGDoor(a,b,c,d):\n",
    "    global gmainmaze   \n",
    "    for i in walk:          #try every direction\n",
    "        x = a + i[0]       #make the move\n",
    "        y = b + i[1]\n",
    "        if valid(gmainmaze,x,y): # check if still in the maze\n",
    "            if x == c and y == d: #check if reached destination\n",
    "                print(\"Destination Arrived: Green Door Found and Unlocked\")\n",
    "                print(\"The Logistic Path Is:\\n\",GdoorTracker)\n",
    "                print(\" \")\n",
    "                return 1\n",
    "            else:\n",
    "                if gmainmaze[x][y] == \"0\" and (x,y) not in GdoorTracker:\n",
    "                    GdoorTracker.append((x,y))\n",
    "                    \n",
    "                else:\n",
    "                    continue\n",
    "        else:\n",
    "            continue\n",
    "        \n",
    "        if GkeyToGDoor(x,y,c,d) == 1: # Recursion (do the next step)\n",
    "            return 1\n",
    "        else:\n",
    "            continue\n",
    "    GdoorTracker.pop(-1) #moveback while \n",
    "    return 0\n",
    "\n",
    "def RkeyToRDoor(a,b,c,d):\n",
    "    global gmainmaze   \n",
    "    for i in walk:          #try every direction\n",
    "        x = a + i[0]       #make the move\n",
    "        y = b + i[1]\n",
    "        if valid(gmainmaze,x,y): # check if still in the maze\n",
    "            if x == c and y == d: #check if reached destination\n",
    "                print(\"Destination Arrived: Red Door Found and Unlocked\")\n",
    "                print(\"The Logistic Path Is:\\n\",RdoorTracker)\n",
    "                print(\" \")\n",
    "                return 1\n",
    "            else:\n",
    "                if gmainmaze[x][y] == \"0\" and (x,y) not in RdoorTracker:\n",
    "                    RdoorTracker.append((x,y))\n",
    "                    \n",
    "                else:\n",
    "                    continue\n",
    "        else:\n",
    "            continue\n",
    "        \n",
    "        if RkeyToRDoor(x,y,c,d) == 1: # Recursion (do the next step)\n",
    "            return 1\n",
    "        else:\n",
    "            continue\n",
    "    RdoorTracker.pop(-1) #moveback while \n",
    "    return 0\n",
    "\n",
    "def BkeyToBDoor(a,b,c,d):\n",
    "    global gmainmaze   \n",
    "    for i in walk:          #try every direction\n",
    "        x = a + i[0]       #make the move\n",
    "        y = b + i[1]\n",
    "        if valid(gmainmaze,x,y): # check if still in the maze\n",
    "            if x == c and y == d: #check if reached destination\n",
    "                print(\"Destination Arrived: Blue Door Found and Unlocked\")\n",
    "                print(\"The Logistic Path Is:\\n\",BdoorTracker)\n",
    "                print(\" \")\n",
    "                return 1\n",
    "            else:\n",
    "                if gmainmaze[x][y] == \"0\" and (x,y) not in BdoorTracker:\n",
    "                    BdoorTracker.append((x,y))\n",
    "                else:\n",
    "                    continue\n",
    "        else:\n",
    "            continue\n",
    "        \n",
    "        if BkeyToBDoor(x,y,c,d) == 1: # Recursion (do the next step)\n",
    "            return 1\n",
    "        else:\n",
    "            continue\n",
    "    BdoorTracker.pop(-1) #moveback while \n",
    "    return 0\n",
    "\n",
    "def DoorToKey(a,b,c,d):\n",
    "    global gmainmaze   \n",
    "    for i in walk:          #try every direction\n",
    "        x = a + i[0]       #make the move\n",
    "        y = b + i[1]\n",
    "        if valid(gmainmaze,x,y): # check if still in the maze\n",
    "            if x == c and y == d: #check if reached destination\n",
    "                print(\"Destination Arrived: Next Key Found\")\n",
    "                print(\"The Logistic Path Is:\\n\",keyTracker)\n",
    "                print(\" \")\n",
    "                return 1\n",
    "            else:\n",
    "                if gmainmaze[x][y] == \"0\" and (x,y) not in keyTracker:\n",
    "                    keyTracker.append((x,y))\n",
    "                    \n",
    "                else:\n",
    "                    continue\n",
    "        else:\n",
    "            continue\n",
    "        \n",
    "        if DoorToKey(x,y,c,d) == 1: # Recursion (do the next step)\n",
    "            return 1\n",
    "        else:\n",
    "            continue\n",
    "    keyTracker.pop(-1) #moveback while \n",
    "    return 0\n",
    "\n",
    "\n",
    "def DoorToDestination(ydx,ydy,ex,ey):\n",
    "    global gmainmaze   \n",
    "    for i in walk:          #try every direction\n",
    "        x = ydx + i[0]       #make the move\n",
    "        y = ydy + i[1]\n",
    "        if valid(gmainmaze,x,y): # check if still in the maze\n",
    "            if x == ex and y == ey: #check if reached destination\n",
    "                print(\"Destination Arrived: Reached Destination\")\n",
    "                print(\"The Logistic Path Is:\\n\",FinalTracker)\n",
    "                print(\" \")\n",
    "                return 1\n",
    "            else:\n",
    "                if gmainmaze[x][y] == \"0\" and (x,y) not in FinalTracker:\n",
    "                    FinalTracker.append((x,y)) \n",
    "                else:\n",
    "                    continue\n",
    "        else:\n",
    "            continue\n",
    "        \n",
    "        if DoorToDestination(x,y,ex,ey) == 1: # Recursion (do the next step)\n",
    "            return 1\n",
    "        else:\n",
    "            continue\n",
    "    FinalTracker.pop(-1) #moveback while \n",
    "    return 0\n",
    "    \n",
    "def printMaze(maze):\n",
    "    for x in range(len(maze)):\n",
    "        for y in range(len(maze[x])):\n",
    "            print(maze[x][y], end=' ')\n",
    "        print(\"\")\n",
    "\n",
    "def visualize(maze):    # a cool function to visualize the maze\n",
    "    for x in range(len(maze)):\n",
    "        for y in range(len(maze[x])):\n",
    "            if maze[x][y] == \"s\":\n",
    "                maze[x][y] = \"╳\"    # path\n",
    "            elif maze[x][y] == \"0\":\n",
    "                maze[x][y] = \"░\"    # unbeen path\n",
    "            elif maze[x][y] == \"1\":\n",
    "                maze[x][y] = \"█\"    # wall\n",
    "            elif maze[x][y] == \"e\":\n",
    "                maze[x][y] = \"╳\"    # basically path as well\n",
    "            print(maze[x][y], end=' ')\n",
    "        print(\"\")\n",
    "\n",
    "     \n",
    "def main():\n",
    "    #initialize the maze\n",
    "    sx, sy, ykx, yky, ydx, ydy, gkx, gky, gdx, gdy, rkx, rky, rdx, rdy, bkx, bky, bdx, bdy, ey, ex, mainmaze = initialize()\n",
    "    global gmainmaze\n",
    "    gmainmaze = mainmaze\n",
    "    load = 1\n",
    "    \n",
    "    #solving the maze\n",
    "    \n",
    "    findKey(sx,sy,ykx,yky)                  #searching first key\n",
    "    YkeyToYDoor(ykx,yky,ydx,ydy)\n",
    "    DoorToKey(ydx,ydy,gkx,gky)\n",
    "    gmainmaze[ydx][ydy] = \"0\"              #replace door to path to create a path route for next door\n",
    "    GkeyToGDoor(gkx,gky,gdx,gdy)\n",
    "    DoorToKey(gdx,gdy,rkx,rky)\n",
    "    gmainmaze[gdx][gdy] = \"0\"              #replace door to path to create a path route for next door\n",
    "    RkeyToRDoor(rkx,rky,rdx,rdy)\n",
    "    DoorToKey(rdx,rdy,bkx,bky)\n",
    "    BkeyToBDoor(bkx,bky,bdx,bdy)\n",
    "    DoorToDestination(bdx,bdy,ex,ey)\n",
    "    for i in backtracker:\n",
    "        gmainmaze[i[0]][i[1]] = \"s\"\n",
    "\n",
    "    for i in YdoorTracker:\n",
    "        gmainmaze[i[0]][i[1]] = \"s\"\n",
    "        \n",
    "    for i in keyTracker:\n",
    "        gmainmaze[i[0]][i[1]] = \"s\"\n",
    "        \n",
    "   \n",
    "    \n",
    "    for i in GdoorTracker:\n",
    "        gmainmaze[i[0]][i[1]] = \"s\"\n",
    "    \n",
    "    for i in RdoorTracker:\n",
    "        gmainmaze[i[0]][i[1]] = \"s\"\n",
    "    \n",
    "    for i in BdoorTracker:\n",
    "        gmainmaze[i[0]][i[1]] = \"s\"\n",
    " \n",
    "    for i in FinalTracker:\n",
    "        gmainmaze[i[0]][i[1]] = \"s\"\n",
    "    \n",
    "    #print the maze\n",
    "    width = len(gmainmaze[0]) - 1\n",
    "    print(\"Check Your Map...\")\n",
    "    print(\"Map:\")\n",
    "    print(\"--\"*(width+1))\n",
    "    printMaze(gmainmaze)\n",
    "    print(\"--\"*(width+1))\n",
    "    #visualize the maze uncomment to establish the function (btw check if your terminal can print these unicodes)\n",
    "    visualize(gmainmaze)\n",
    "    time.sleep(1)\n",
    "\n",
    "main()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}