import pygame
from vector import myVector 
from settings import *
import numpy as np

class Node(object):   
    def __init__(self, x, y, isGhostHome=False):
        self.position = myVector(x, y)
        self.neighbors = {UP:None, DOWN:None, LEFT:None, RIGHT:None, PORTAL:None}
        self.isGhostHome = isGhostHome

class Maze(object):
    def __init__(self, level):
        self.level = level
        self.nodes = {} # The Maze's attribute "nodes" is a dictionary that contains all the game's nodes.
        self.nodeSymbols = ['+', 'P', 'n', 'G']
        self.pathSymbols = ['.', '-', '|', 'p']
        self.homekey = None
        self.buildMaze()

   def buildMaze(self):
        """ It builds or generates a maze from the file [MAZEFILE](https://pacmancode.com/graphical-mazes)."""
        # The only difference is the 18th row...
        # G - - - - - + - - n 5 X X X X X X 5 n - - + - - - - - G
        lines = self.readMazeFile() # Firstly, we read the file.
        self.createNodeTable(lines) # Secondly, we create the nodes.
        self.connectHorizontally(lines) # Thirdly, we connect the nodes horizontally.
        self.connectVertically(lines) # Finally, we connect the nodes vertically.

    def readMazeFile(self):
    # It reads the file containing the [maze](https://pacmancode.com/graphical-mazes), removes all the spaces, and returns a list containing each line in the file as a list element. 
        with open(MAZEFILE) as f:
            lines = f.readlines()
        lines = [line.replace(' ', '') for line in lines]
        return lines

    def createNodeTable(self, lines, xoffset=0, yoffset=0, isHome=False):
    # It creates all the maze's nodes.
        for row, line in enumerate(lines):
            for col, character in enumerate(line):
                if character in self.nodeSymbols:
                    x, y = self.convertPixel(col+xoffset, row+yoffset)
                    self.nodes[(x, y)] = Node(x, y, isHome)
                    
    def convertPixel(self, x, y):
    # It converts a character's position (aka maze coordinates: row and column) in our text file to actual pixel values on the screen by multiplying x and y by TILEWIDITH and TILEHEIGHT respectively. 
        return x * TILEWIDTH, y * TILEHEIGHT

    def connectHorizontally(self, lines, xoffset=0, yoffset=0):    
    # It connects the game's nodes horizontally.    
      for row, line in enumerate(lines):
        key = None
          for col, character in enumerate(line):
            if character in self.nodeSymbols:
              if key is None: # We have not found a node in this row yet.
                 key = self.convertPixel(col+xoffset, row+yoffset)
              else: # key is a node previously found, so we connect it to our new node. 
                 otherkey = self.convertPixel(col+xoffset, row+yoffset)
                 self.nodes[key].neighbors[RIGHT] = self.nodes[otherkey] # Observe that we are moving from left to right, i.e., key is on the left.
                 self.nodes[otherkey].neighbors[LEFT] = self.nodes[key]
                 key = otherkey

              if character == "G": # We are using the symbol "G" for gateway or portal. One important part of any Pac-Man game is the ability to move from one side of the screen to the other side through portals.
                if col==0:
                  self.setPortal((col, row), (len(line)-2, row))
                else:
                  self.setPortal((0, row), (col, row))

            elif character not in self.pathSymbols:
              key = None

    def connectVertically(self, lines, xoffset=0, yoffset=0):
    # It connects the game's nodes vertically. First, we transpose the list "lines", so from now on we are reading the original file vertically, and we need to consider that the "key" node is on top of "otherkey" (*) 
      lines = map(lambda *a: list(a), *lines) # It transposes the list "lines".
      for col, line in enumerate(lines): 
        key = None 
        for row, character in enumerate(line):
          if character in self.nodeSymbols:
            if key is None: # We have not found a node in this column yet.
              key = self.convertPixel(col+xoffset, row+yoffset)
            else: # key is a node previously found, so we connect it to our new node.
              otherkey = self.convertPixel(col+xoffset, row+yoffset)
              self.nodes[key].neighbors[DOWN] = self.nodes[otherkey] # key is on top of otherkey (*)
              self.nodes[otherkey].neighbors[UP] = self.nodes[key]
              key = otherkey
          elif character not in self.pathSymbols:
            key = None

    # It creates a portal between two nodes given their maze coordinates. All maze coordinates are written as (col, row).
    def setPortal(self, pair1, pair2):
        key1 = self.convertPixel(*pair1)
        key2 = self.convertPixel(*pair2)
        if key1 in self.nodes.keys() and key2 in self.nodes.keys():
            self.nodes[key1].neighbors[PORTAL] = self.nodes[key2]
            self.nodes[key2].neighbors[PORTAL] = self.nodes[key1]

    # It returns the node, if any, that corresponds to the maze coordinates given as parameters.
    def getNodeFromTiles(self, col, row):
        x, y = self.convertPixel(col, row)
        if (x, y) in self.nodes.keys():
            return self.nodes[(x, y)]
        return None

    # It returns the node coordinates, if any, that corresponds to the pixel coordinates given as parameters.
    def getNodeFromPosition(self, col, row):
        for x in range(NCOLS):
            for y in range(NROWS):
                if abs(col - x * TILEWIDTH)<=TILEWIDTH and abs(row - y * TILEWIDTH)<=TILEHEIGHT:
                    return (y, x)
        return None

   def createHomeGhost(self, xoffset, yoffset):
        # It uses a 5*5 matrix (HOMEMAZE) containing the symbols for the nodes and paths to build the ghosts home. 
        self.createNodeTable(HOMEMAZE, xoffset, yoffset, True) # Please take notice that the four argument is True indicating that these nodes are part of our ghosts' home.
        self.connectHorizontally(HOMEMAZE, xoffset, yoffset)
        self.connectVertically(HOMEMAZE, xoffset, yoffset)

MAZEFILE="myMaze.txt" 
HOMEMAZE = [['X','X','+','X','X'], ['X','X','.','X','X'],['+','X','.','X','+'],['+','.','+','.','+'], ['+','X','X','X','+']]
HOMEGHOSTS = (11.5, 14) 
SPAWNGHOST = (2+11.5, 3+14) 
CONNECTLEFT = (12, 14) 
CONNECTRIGHT = (15, 14)

# The next lines allow us to connect the ghosts home with the rest of the maze.
        self.homekey = self.convertPixel(xoffset+2, yoffset)
        self.connectHomeNodes(CONNECTLEFT, LEFT)
        self.connectHomeNodes(CONNECTRIGHT, RIGHT)
        return self.homekey
   
   def connectHomeNodes(self, otherkey, direction):     
        key = self.convertPixel(*otherkey)
        self.nodes[self.homekey].neighbors[direction] = self.nodes[key]
        self.nodes[key].neighbors[direction*-1] = self.nodes[self.homekey]

import pygame
from pygame.locals import *
from vector import myVector
from settings import *
from random import randint
import copy
import maze
import search

class Entity(object):
    # All entities have a name, a speed, and they could move in the maze in four directions or stay stationary.  
    def __init__(self, node, maze = None):
        self.name = None
        self.directions = {UP:myVector(0, -1),DOWN:myVector(0, 1), 
                          LEFT:myVector(-1, 0), RIGHT:myVector(1, 0), STOP:myVector()}
        self.direction = STOP
        self.maze = maze
        self.setSpeed(NORMAL_SPEED)
        self.radius = 10
        self.collideRadius = 10
        self.target = node
        self.visible = True
        self.goal = None
        self.directionMethod = self.randomDirection # By default, when an entity reaches a node, it will choose a random direction to go next.  
        self.setStartNode(node)
        self.image = None

    # This is used for an "entity" (ghost, Pac-Man) to position itself between two maze's nodes.
    def setBetweenNodes(self, direction):
        if self.node.neighbors[direction] is not None:
            self.target = self.node.neighbors[direction]
            self.position = (self.node.position + self.target.position) / 2.0

    def setStartNode(self, node):
        self.node = node
        self.startNode = node
        self.target = node
        self.setPosition()

    def setPosition(self):
        self.position = copy.copy(self.node.position)
    
    # It checks if the "direction" passed as an argument is a valid direction to go next. Please observe that Pac-Man is not allowed to go to the ghosts' home.      
    def validDirection(self, direction):
        if direction is STOP:
            return False
        if self.node.neighbors[direction] is None:
            return False
        if self.name == "PACMAN" and self.node.neighbors[direction].isHome:
            return False

        return True
    
    # If direction is a valid one for the entity to go next, it returns the node that this direction leads from the current node.
    def getNewTarget(self, direction):
        if self.validDirection(direction):
            return self.node.neighbors[direction]
        return self.node

    # It checks if the entity has already overshot its target node.
    def overshotTarget(self):
        if self.target is not None:
            vec1 = self.target.position - self.node.position
            vec2 = self.position - self.node.position
            return vec2.magnitude() >= vec1.magnitude()
        return False

    # If direction is not STOP and is indeed the opposite direction from the current direction that the entity is moving in, it reverses its direction and updates (swaps) its node and target.
    def reverseDirection(self, direction):
        if direction is not STOP:
            if direction == self.direction * -1:
                self.direction *= -1
                self.node, self.target = self.target, self.node
    
    # It sets a new speed for the entity.    
    def setSpeed(self, mode=NORMAL_SPEED):
        if mode==NORMAL_SPEED:
            self.speed = 100 * TILEWIDTH / 16
        elif mode==SUPER_SPEED:
            self.speed = 125 * TILEWIDTH / 16
        elif mode==LOW_SPEED:
            self.speed = 75 * TILEWIDTH / 16
    
    # If the entity has an image and is "visible", it renders it with its position adjusted to the node's size. Otherwise, it draws a circle. 
    def render(self, screen):
        if self.visible:
            if self.image is not None:
                p = self.position - myVector(TILEWIDTH, TILEHEIGHT)/2
                screen.blit(self.image, p.getVector())
            else:
                p = self.position.getVectorAsInt()
                pygame.draw.circle(screen, self.color, p, self.radius)

    def update(self, dt):
        self.position += self.directions[self.direction]*self.speed*dt
         
        if self.overshotTarget():  # If the entity has overshot the target node, then we set the target node as the current node and find the next target node. 
            self.node = self.target
            directions = self.validDirections() # It gets a list of all valid directions.
            direction = self.directionMethod(directions) # It calls the method "directionMethod" to select one direction from the previous list.  
            if self.node.neighbors[PORTAL] is not None: # If the node is a portal, we set its paired node that is linked by the portal (node.neighbors[PORTAL]) as the new current node.
                self.node = self.node.neighbors[PORTAL]
            self.target = self.getNewTarget(direction) # It tries to find a new target node for the entity.
            if self.target is not self.node: # It means that it was successful, it has just found a new target for the entity, so we update the entity's direction accordingly. 
                self.direction = direction
            else: # If it failed to find a new target, we continue in the same direction.
                self.target = self.getNewTarget(self.direction)

            self.setPosition()

    # It returns a list with all valid directions that the entity can move in. If this list is empty, it means that the only valid direction is the one from which the entity came in. 
    def validDirections(self):
        directions = []
        for key in [UP, DOWN, LEFT, RIGHT]:
            if self.validDirection(key):
                if key != self.direction * -1:
                    directions.append(key)
        if len(directions) == 0:
            directions.append(self.direction * -1)
        return directions

def update(self, dt):
        self.position += self.directions[self.direction]*self.speed*dt

        if self.overshotTarget():
            self.node = self.target
            directions = self.validDirections()
            direction = self.directionMethod(directions)
             [...]

# Game's mode (settings.py). It selects the ghosts' AI. CLASSSIC_MODE = 0 ADVANCED_MODE = 1 STUPID_MODE = 2 
GAME_MODE = CLASSSIC_MODE

    def randomDirection(self, directions):
        return directions[randint(0, len(directions)-1)]

    # It selects the direction that minimizes the entity's distance to its goal. Typically, a ghost will want to minimize its distance to Pac-Man.
    def goalDirection(self, directions):
        distances = []
        for direction in directions:
            vec = self.node.position + self.directions[direction]*TILEWIDTH - self.goal
            distances.append(vec.magnitude())
        index = distances.index(min(distances))
        return directions[index]

    def astar(self, directions):
      distances = []
      for direction in directions:
        vec = self.node.position + self.directions[direction]*TILEWIDTH
        x, y = self.maze.getNodeFromPosition(vec.x, vec.y)
        x2, y2 = self.maze.getNodeFromPosition(self.pacman.position.x, self.pacman.position.y)
        myMaze = search.Maze(x, y, x2, y2, NROWS, NCOLS, 0.2, MAZEFILE)
        solution = myMaze.astar()
        if solution != None:
          distances.append(len(solution.path_solution()))
        else:
          distances.append(100000)

      index = distances.index(min(distances))
      return directions[index]

    # It resets the entity to its repose state (self.direction = STOP) in its starting node.
    def reset(self):
        self.setStartNode(self.startNode)
        self.direction = STOP
        self.setSpeed(NORMAL_SPEED)
        self.visible = True

import pygame
from pygame.locals import *
from vector import myVector
from settings import *
import copy
import math
from entity import Entity
from sprites import PacmanSprites

class Pacman(Entity):
    def __init__(self, app):
        Entity._init__(self, app.myMaze.getNodeFromTiles(15, 26), app.myMaze )
        self.name = PACMAN    
        self.color = YELLOW
        self.app = app # We need a pointer or reference to the game's object.
        self.direction = LEFT # Pac-Man is alive and is initially positioned between two maze's nodes and pointing to the left.
        self.setBetweenNodes(LEFT)
        self.alive = True
        self.sprites = PacmanSprites(self)

    def reset(self):
        Entity.reset(self)
        self.direction = LEFT
        self.setBetweenNodes(LEFT)
        self.alive = True
        self.image = self.sprites.getStartImage()
        self.sprites.reset()

    def die(self):
        self.alive = False
        self.direction = STOP

    def setStartNode(self, node):
        self.node = node
        self.startNode = node
        self.target = node
        self.setPosition()

    def eatPellets(self):
        """ It checks whether Pac-Man has collided with a pellet or not and returns the pellet or None."""
        for pellet in self.app.pellets:
            # It iterates through the game object's pellet list and checks if Pac-Man is colliding with one of them.
            if self.collideCheck(pellet):
                return pellet
        return None

    def collideGhost(self, ghost):
        """ It checks whether Pac-Man has collided with a ghost or not."""
        return self.collideCheck(ghost)

    def collideCheck(self, other):
        """ It checks whether Pac-Man has collided with "other" entity, such as a ghost, pellet, or fruit."""
        distanceSelfOther = (self.position - other.position).magnitude()
        return distanceSelfOther <= self.collideRadius + other.collideRadius

    def updateDirectionTarget(self):
        # This method updates Pac-Man's direction based on the user's input. As we have seen in other tutorials, we always handle the events associated with the user's input in our game class, that's why we need a reference to the game object "self.app".
        if self.app.KEYUP:
            direction = UP
        elif self.app.KEYDOWN:
            direction = DOWN
        elif self.app.KEYLEFT:
            direction = LEFT
        elif self.app.KEYRIGHT:
            direction = RIGHT
        else:
            direction = STOP

        return direction

     def update(self, dt):
        self.sprites.update(dt)	
        self.position += self.directions[self.direction]*self.speed*dt
        direction = self.updateDirectionTarget()
        if self.overshotTarget(): # If Pac-Man has overshot the target node, then we set the target node as the current node and find the next target node. 
            self.node = self.target
            if self.node.neighbors[PORTAL] is not None: # If the node is a portal, we set its paired node that is linked by the portal (node.neighbors[PORTAL]) as the new current node.
                self.node = self.node.neighbors[PORTAL]
            self.target = self.getNewTarget(direction) # It tries to find a new target node for our main character Pac-Man.
            if self.target is not self.node: # It means that it was successful. It found a new target for Pac-Man, so we need to update its direction accordingly. 
                self.direction = direction
            else:  # It failed to find a new target; we continue in the same direction.
                self.target = self.getNewTarget(self.direction)

            if self.target is self.node: # If we find ourselves in the same node, then Pac-Man needs to stop. 
                self.direction = STOP
            self.setPosition()
        else: # If Pac-Man has not overshot the target node, then we need to check if "direction" is actually the opposite direction (the player has made a quick U-turn) and if so, update its node and target.
            self.reverseDirection(direction)