Maze game

import turtle
import math
import random

window = turtle.Screen()
window.bgcolor("black")
window.title("Nerd Chase")
window.setup(700,700)
window.tracer(0)

#Sprites
images = ["nerd_right.gif", "nerd_left.gif", "arcade.gif", "wall.gif", "blob_left.gif",
          "blob_right.gif"]
for image in images:
    turtle.register_shape(image)

#Create Pen object
class Pen(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("square")
        self.color("white")
        self.penup()
        self.speed(0)

#Create player class
class Player(turtle.Turtle):
    def __init__(self):
        turtle.Turtle.__init__(self)
        self.shape("nerd_right.gif")
        self.color("blue")
        self.penup()
        self.speed(0)
        self.points = 0

    def go_up(self):
        #calc spot to go to
        move_to_x = self.xcor()
        move_to_y = self.ycor() + 24

        #check if wall detected
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)

    def go_down(self):
        #calc spot to go to
        move_to_x = self.xcor()
        move_to_y = self.ycor() - 24

        #check if wall detected
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)

    def go_left(self):
        #calc spot to go to
        move_to_x = self.xcor() - 24
        move_to_y = self.ycor()

        #check if wall detected
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)

        self.shape("nerd_left.gif")


    def go_right(self):
        #calc spot to go to
        move_to_x = player.xcor()+ 24
        move_to_y = player.ycor()

        self.shape("nerd_right.gif")

        #check if wall detected
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)

    #Checks for a collision between Arcade and player, Pythag theorem
    def is_collision(self, other):
        a = self.xcor()-other.xcor()
        b = self.ycor()-other.ycor()
        distance = math.sqrt((a ** 2) + (b ** 2) )

        if distance < 5:
            return True
        else:
            return False

#Create Arcade class(reward)
class Arcade(turtle.Turtle):
    def __init__(self, x, y):
        turtle.Turtle.__init__(self)
        self.shape("arcade.gif")
        self.color("green")
        self.penup()
        self.speed(0)
        self.points = 100
        self.goto(x, y)

    #Moving arcade off screen, hiding it
    def destroy(self):
        self.goto(2000, 2000)
        self.hideturtle()

#Blob class
class Enemy(turtle.Turtle):
    def __init__(self, x, y):
        turtle.Turtle.__init__(self)
        self.shape("blob_left.gif")
        self.color("red")
        self.penup()
        self.speed(0)
        self.points = 20
        self.goto(x, y)
        self.direction = random.choice(["up", "down", "left", "right"])

    def move(self):
        if self.direction == "up":
            dx = 0
            dy = 24
        elif self.direction == "down":
            dx = 0
            dy = -24
        elif self.direction == "left":
            dx = -24
            dy = 0
            self.shape("blob_right.gif")
        elif self.direction == "right":
            dx = 24
            dy = 0
            self.shape("blob_left.gif")
        else:
            dx = 0
            dy = 0

    def is_close(self, other):
        a = self.xcor()-other.xcor()
        b = self.ycor()-other.ycor()
        distance = math.sqrt((a ** 2) + (b ** 2) )

        if distance < 75:
            return True
        else:
            return False

        #Check is the player is in proximity to blob
        # If it is then follow
        if self.is_close(player):
            if player.xcor() < self.xcor():
                self.direction = "left"
            elif player.xcor() > self.xcor():
                self.direction = "right"
            elif player.ycor() < self.ycor():
                self.direction = "down"
            elif player.ycor() > self.ycor():
                self.direction = "up"


        #Calc spot to go to
        move_to_x = self.xcor() + dx
        move_to_y = self.ycor() + dy

        #check if wall detected
        if (move_to_x, move_to_y) not in walls:
            self.goto(move_to_x, move_to_y)
        else:
            #choose another direction
            self.direction = random.choice(["up", "down", "left", "right"])

        #set timer(miliseconds)
        turtle.ontimer(self.move, t=random.randint(100, 300))


    def is_close(self, other):
        a = self.xcor()-other.xcor()
        b = self.ycor()-other.ycor()
        distance = math.sqrt((a ** 2) + (b ** 2) )

        if distance < 75:
            return True
        else:
            return False


    def destroy(self):
        self.goto(2000, 2000)
        self.hideturtle()


#Create list for the levels
levels = [""]

#first level
level_1 = [
"XXXXXXXXXXXXXXXXXXXXXXXXX",
"XP  XXXXXXX         XXXXX",
"X  XXXXXXX          XXXXX",
"X       XX  XXXXXX  XXXXX",
"X       XX  XXX        XX",
"XXXXXX  XX  XXXB       XX",
"XXXXXX  XX  XXXXXX  XXXXX",
"XXXXXX  XX  XXXXXX  XXXXX",
"X  XXX       BXXXX  XXXXX",
"X  XXX  XXXXXXXXXXXXXXXXX",
"X         XXXXXXXXXXXX   ",
"XB            XXXXXXXXXXX",
"XXXXXXXXXXXXX   XXXXX   X",
"XXXXXXXXXXXXXX   XXX    X",
"XXX  XXXXXXX          XXX",
"XXXXXXXXXXXXXX          X",
"XXX  XXXXXXXXX          X",
"XXX                     X",
"XXXB                XXA X",
"XX  XXXXXXXXXXXXXX    X X",
"XXX  XXXXXXXXXXXXXX  X  X",
"XXXXX XXXXXXXXXXXXX  XXXX",
"XXXX            XXXXX   X",
"XXXXXXXXXXXXXXXXXXXXXXXXX"
]

#Add an arcade list
arcades = []

#enemy list
enemies = []

#Add maze to list
levels.append(level_1)

#Create function for levels
def setup_maze(level):
    for y in range(len(level)):
        for x in range(len(level[y])):
            #Get value at each (x,y) coord
            # switch places as we set up the list
            character = level[y][x]
            screen_x = -288 + (x * 24)
            screen_y = 288 - (y * 24)

            #Check if "X"
            if character == "X":
                pen.goto(screen_x,screen_y)
                pen.shape("wall.gif")
                pen.stamp()
                #Add coord to wall list
                walls.append((screen_x, screen_y))

            #Check if it is Player
            if character == "P":
                player.goto(screen_x,screen_y)

            #Check if it is A (Arcade)
            if character == "A":
                arcades.append(Arcade(screen_x, screen_y))

            #Check if "B" (blob creature)
            if character == "B":
                enemies.append(Enemy(screen_x, screen_y))


#These are class instances
pen = Pen()
player = Player()

#Create wall coord list
walls = []

#Set up level
setup_maze(levels[1])

#Keys
turtle.listen()
turtle.onkey(player.go_left, "Left")
turtle.onkey(player.go_right, "Right")
turtle.onkey(player.go_up, "Up")
turtle.onkey(player.go_down, "Down")

#turn off updates
window.tracer(0)

#Moving blobs
for enemy in enemies:
    turtle.ontimer(enemy.move, t=250)

#Game loop
while True:
    #Check collisions
    #Iterate Arcade list
    for arcade in arcades:
        if player.is_collision(arcade):
            #Add points from arcade to player
            player.points += arcade.points
            print ("You received: {} points".format(player.points))
            #destroy arcade
            arcade.destroy()
            #Remove arcade from list
            arcades.remove(arcade)

    for enemy in enemies:
        if player.is_collision(enemy):
            print ("Player died!")
            enemy.move()


    window.update()