#! /usr/bin/env python

import os, sys
import pygame
from pygame.locals import *

#...

the_maze = Maze()
while not the_maze.finished():
 the_maze.play()
the_maze.done()

grid_size = 30
margin = grid_size

background_color = Color.black
wall_color = make_color(0.6, 0.9, 0.9)

#The shape of the maze. Each character
#represents a different type of object.
#  % - Wall
#  . - Food
#  o - Capsule
#  G - Ghost (Python, Lynux, Unix, MSACS)
#  P - Garridoman (Pacman)
# Other characters are ignored.

the_layout = [
  "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%",
  "%.....%.................%.....%",
  "%o%%%.%.%%%.%%%%%%%.%%%.%.%%%o%",
  "%.%.....%......%......%.....%.%",
  "%...%%%.%.%%%%.%.%%%%.%.%%%...%",
  "%%%.%...%.%.........%.%...%.%%%",
  "%...%.%%%.%.%%%%%%%.%.%%%.%...%",
  "%.%%%.......%GG GG%.......%%%.%",
  "%...%.%%%.%.%%%%%%%.%.%%%.%...%",
  "%%%.%...%.%.........%.%...%.%%%",
  "%...%%%.%.%%%%.%.%%%%.%.%%%...%",
  "%.%.....%......%......%.....%.%",
  "%o%%%.%.%%%.%%%%%%%.%%%.%.%%%o%",
  "%.....%........P........%.....%",
  "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"]

class Maze:
  #...
  
  def set_layout(self, layout):
    height = len(layout)
    width = len(layout[0])
    self.make_window(width, height)
    self.make_map(width, height)

    max_y = height - 1
    for x in range(width):
      for y in range(height):
        char = layout[max_y - y][x]
        self.make_object((x, y), char)
   
  def to_screen(self, point):
    (x, y) = point
    x = x*grid_size + margin
    y = y*grid_size + margin
    return (x, y)

  def make_map(self, width, height):
    self.width = width
    self.height = height
    self.map = []
    for y in range(height):
      new_row = []
      for x in range(width):
        new_row.append(Nothing())
      self.map.append(new_row)

  def make_object(self, point, character):
    (x, y) = point
    if character == '%':
      self.map[y][x] = Wall(self, point)

  def finished(self):
    return self.game_over

  def play(self):
    sleep(0.05)

  def done(self):
    end_graphic()
    self.map = [] 

  def make_object(self, point, character):
    (x, y) = point
    if character == '%':
      self.map[y][x] = Wall(self, point)
    elif character == 'P':
      garridoman = Garridoman(self, point)
      self.movable.append(garridoman)

  def set_layout(self, layout):
    height = len(layout)
    width = len(layout[0])
    self.make_window(width, height)
    self.make_map(width, height)
    self.movables = []
    
    max_y = height - 1
    for x in range(width):
      for y in range(height):
        char = layout[max_y - y][x]
        self.make_object((x, y), char)

    for movable in self.movables:
      movable.draw()

  def done(self):
    end_graphics()
    self.map = []
    self.movables = []

  def play(self):
    for movable in self.movables:
      movable.move()
    sleep(0.05)

  def set_layout(self, layout):
    height = len(layout)
    width = len(layout)[0])
    self.make_window(width, height)
    self.movable = []
    self.food_count = 0

    max_y = height - 1
    for x in range(width):
      for y in range(height):
        char = layout[max_y - y][x]
    
    for movable in self.movables:
      movable.draw()

  def make_object(self, point, character):
    (x, y) = point
    if character == '%':
      self.map[y][x] = Wall(self, point)
    elif character == 'P':
    garridoman = Garridoman(self, point)
    self.movables.append(garridoman)
    elif character == '.':
      self.food_count = self.food_count + 1
      self.map[y][x] Food(self, point)

  def make_object(self, point, character):
    elif character == 'G'
      ghost = Ghost(self, point)
      self.movables.append(ghost)

ghost_colors = []
ghost_colors.append(Color.red)
ghost_colors.append(Color.green)
ghost_colors.append(Color.blue)
ghost_colors.append(Color.purple)

ghost_speed = 0.25

def garridoman_is(self, garridoman, point):
  for movable in self.movable:
    movable.garridoman_is(garridoman, point)
   pass

def lose(self):
  print "You lose!"
  self.game_over = 1

def make_object(self, point, character):

elif character == 'o':
  self.map[y][x] = Capsule(self, point)

def remove_capsule(self, place):
  (x, y) = place
  self.map[y][x] = Nothing()
  for movable in self.movables:
     movable.capsule_eaten()

class Capsule(Immovable):
  def _init_(self, maze, point):
     self.place = point
     self.screen_point = maze.to_screen(point)
     self.maze = maze
     self.draw()

capsule_color = Color_white
capsule_size = grid_size * 0.3

def draw(self):
  (screen_x, screen_y) = self.screen_point
  self.dot = circle(screen_x, screen_y,
                    capsule_size, 
                    color = capsule_color,
                    filled = 1)

def eat(self, garridoman):
  remove_from_screen(self.dot)
  self.maze.remove_capsule(self.place)


class Ghost(Movable):
  def _init_(self, maze, start):
    global ghost_colors

    self.next_point = start
    self.movement = (0, 0)

    self.color = ghost_colors[0]
    ghost_colors[:1] = []
    ghost_colors.append(self.colors)

    self.original_color = self.color
    self.time_left = 0

    Movable.-init_(self, maze,
                   start, ghost_speed)

   def capsule_eaten(self):
     self.change_color(scared_color)
     self.time_left = scared_time

   def change_color(self, new_color):
     self.color = new_color
     self.redraw()
   
ghost_shape = [
    (0,     -0.5),
    (0.25,  -0.75),
    (0.5,   -0.5),
    (0.75,  -0.75),
    (0.75,   0.5),
    (0.5,    0.75),
    (-0.5,   0.75),
    (-0.75,  0.5),
    (-0.75,  -0.75),
    (-0.5,   -0.5),
    (-0.25,  -0.75)
  ]

  def draw(self):
    maze = self.maze
    (screen_x, screen_y) = (
        maze.to_screen(self.place) )
    coords = []
    for (x, y) in ghost_shape:
      coords.append(x*grid_size + screen_x,
                    y*grid_size + screen_y)
    
    self.body = polygon(coords, self.color,
                        closed = 1,
                        filled = 1)
  def choose_move(self):
    (move_x, move_y) = self.movement
    (nearest_x, nearest_y) = (
        self.nearest_grid_point() _
    possible_moves = []
   
    if move_x >= 0 and self.can.move_by((1, 0)):
      possible_moves.append((1, 0))

    if move_x <= 0 and self.can_move_by((-1, 0))
      possible_moves.append((-1, 0))

    if move_y >= 0 and self.can.move_by((0, 1)):
      possible_moves.append((0, 1))

    if move_y <= 0 and self.canmove_by(0, -1)):
      possible_moves.append((0, -1))

    if len(possible_moves) != 0:
      move = random_choice(possible_moves)
      (move_x, move_y) = move

    else:
      move_x = -move_x
      move_y = -move_y
      move = (move_x, move_y)

    (x, y) = self.place
    self.next_point = (x+move_x, y+move_y)

    self.movement = move
    return self.furthest_move(move)

    def can_move_by(self, move):
      move = self.further_move(move)
      return move != (0, 0)

    def move_by(self, move):
       (old_x, old_y) = self.place
       (move_x, move_y) = move
 
       (new_x, new_y) = (old_x+move_x, old_y+move_y)
       self.place = (new_x, new_y)

       screen_move = (move_x * grid_size,
                   move_y * grid_size)
       move_by(self.body, screen_move)

  def captured(self, garridoman):
    self.place = self.start
    self color = self.original_color
    self.time_left = 0
    self.redraw()

  def garridoman_is(self, garridoman, point):
    (my_x, my_y) = self.place
    (his_x, his_y) = point
    X = my_x - his_x
    Y = my_y - his_y
    DxD = X*X + Y*Y
    limit = 1.6*1.6
    if DxD < limit:
      self.bump_into(garridoman)

  def bump_into(self, garridoman):
    if self.time_left != 0:
      self.captured(garridoman)
  else:
    self.maze.lose()

  def redraw(self):
    old_body = self.body
    self.draw()
    remove_from_screen(old_body)

  warning_time = 50

  def move(self):
    (current_x, current_y) = self.place
    (next_x, next_y) = self.next_point
    move = (next_x - current_x,
            next_y - current_y)
    move = self.furthest_move(move)
    if move == (0, 0):
      move = self.choose_move()
    self.move_by(move)
    if self.time_left > 0:
      self.update_scared()

  def update_scared(self): 
    self.time_left = self.time_left -1
    time_left = self.time_left
    if time_left % 2 ==0:
      color = self.original_color
    else:
      color = scared_color
    self.change_color(color)

class Food(Immovable):
  def _init_(self, maze, point):
    self.place = point
    self. screen_point = maze.to_screen(point)
    self.maze = maze
    self.draw()

food_color = Color.orange
food_size = grid_size * 0.15

  def draw(self):
    (screen_x, screen_y) = self.screen_point
    self.dot = circle(screen_x, screen_y,
                      food_size,
                      color = food_color,
                      filled = 1)

  def eat(self, garridoman):
    remove_from_screen(self.dot)
    self.maze.remove_food(self.place)

  def remove_food(self, place):
    (x, y) = place
    self.map[y][x] = Nothing()
    self.food_count = self.food_count - 1
    if self.food_count == 0:
      self.win()

  def win(self):
    print "You win!"
    self.game_over = 1


class Immovable:
  pass

  def is_a_wall(self):
    return 0
  
  def eat(self, pacman):
   pass

class Nothin(Immovable):
  pass

class Wall(Immovable):
  def _init_(self, maze, point):
    self.place = point
    self.screen_point = maze.to_screen(point)
    self.maze = maze
    self.draw()

  def draw(self):
    (screen_x, screen_y) = self.screen_point
    forbid_movable()
    dot_size = grid_size * 0.2
    circle(screen_x, screen_y, dot_size,
           color = wall_color, filled = 1)
    (x, y) = self.place
    neighbors = [ (x+1, y), (x-1, y),
                  (x, y+1), (x, y-1)]  
    for neighbor in neighbors:
     self.check_neighbor(neighbor)
    allow_movables()
   
     maze = self.maze
     screen_point = maze.to_screen(self.place)
     angle = self.get_angle()
     endpoints = (self.direction + angle,
                  self.direction + 360 - angle)
     self.body = circle(screen_point, garridoman_color,
                        color = garridoman_color,
                        filled = 1,
                        endpoints = endpoints)

  def get_angle(self):
    (x, y) = self.place
    (nearest_x, nearest_y) = (
        self.nearest_grid_point() )
   distance =  ( abs(x-nearest_x) +
                 abs(y-nearest_y) )
   return 1 +  90*distance  

  def check_neighbor(self, neighbor):
    maze + self.maze
    object = maze.object_at(neighbor)
    if object.is_a_wall():
      here = self.screen_point
      there = maze.to_screen(neighbor)
      line(here, there, color = wall_color)

    allow_movables()

  def object_at(self, point):
    (x, y) = point
    
    if y < 0 or y >= self.width:
      return Nothing()

    return self.map[y][x]

  def is_a_wall(self):
    return 1 

class Movable:
  def _init_(self, maze, point, speed):
    self.maze = maze
    self.place = point
    self.speed = speed
    self.start = point

  def furthest_move(self, movement):
    (move_x, move_y) = movement
    (current_x, current_y) = self.place
    nearest = self.nearest_grid_point()
    (nearest_x, nearest_y) = nearest
    maze = self.maze
     
     if move_x > 0:
       next_point = (nearest_x+1, nearest_y)
       if maze.object_at(next_point).is_a_wall():
         if current_x+move_x > nearest_x:
           move_x = nearest_x - current_x

     elif move_x < 0:
         next_point = (nearest_x-1, nearest_y)
         if maze.object_at(next_point).is_a_wall():
           if current_x+move_x < nearest_x:
             move_x = nearest_x - current_x

     if move_y > 0:
       next_point = (nearest_x, nearest_y+1)
       if maze.object_at(next_point).is_a_wall():
         if current_y+move_y > nearest_y:
           move_y = nearest_y - current_y

     elif move_y < 0:
       next_point = (nearest x, nearest_y-1)
       if maze.object_at(next_point).is_a_wall():
         if current_y+move_y < nearest_y:
           move_y = nearest_y - current_y

     if move_x > self.speed:
       move_x = self.speed
     elif move_x < -self.speed:
       move_x = -self.speed

     if move_y > self.speed:
       move_y = self.speed
     elif move_y < -self.speed:
       move_y = -self.speed

     return (move_x, move_y) 

  def nearest_grid_point(self):
    (current_x, current_y) = self.place
    grid_x = int(current_x + 0.5)
    grid_y = int(current_y + 0.5)
    return (grid_x, grid_y)
  
  garridoman_color = Color.yellow
  garridoman_size = grid_size * 0.8
  garridoman_speed = 0.25

def capsule_eaten(self):
  pass

scared_color = Color.white

scared_time = 300

class Garridoman(Movable):
  def _init_(self, maze, point):
    Movable._init_(self, maze, point
                   garridoman_speed)

  def move(self):
    keys = keys_pressed()
    if   'z' in keys: self.move_left()  
    elif 'x' in keys: self.move_right()
    elif ';' in keys: self.move_up()
    elif '.' in keys: self.move_down()
    self.maze.garridoman_is(self, self.place)

  def move_left(self):
    self.try_move((-1, 0))
  
  def move_right(self):
    self.try_move((1, 0))

  def move_up(self):
    self.try_move((0, 1))

  def move_down(self):
    self.try_move((0, -1))

  def try_move(self, move):
    (move_x, move_y) = move
    (current_x, current_y) = self.place
    (nearest_x, nearest_y) = (
        self.nearest_grid_point() )

    if self.furthest_move(move) == (0,0):
       return
    
    if move_x != 0 and current_y != nearest_y:
      move_x = 0
      move_y = nearest_y - current_y
    
    elif move_y != 0 and current_x != nearest_x:
      move_y = 0
      move_x = nearest_x - current_x

    move = self.furthest_move((move_x, move_y))
    self.move_by(move)
      
  def _init_(self, maze, point):
    self.direction = 0
    Moveable._init_(self, maze, point,
                    garridoman_speed)
  
  def move_by(self, move):
    self.update_position(move)
    old_body = self.body
    self.draw()
    remove_from_screen(old_body)
  
  def update_position(self, move):
     (old_x, old_y) = self.place
     (move_x, move_y) = move
     (new_x, new_y) = (old_x+move_x, old_y+move_y)
    self.place = (new_x, new_y)

    if move_x > 0:
      self.direction = 0
    elif move_y > 0:
      self.direction = 90
    elif move_x < 0:
      self.direction = 180
    elif move_y < 0:
      self.direction = 270

  def move_by(self, move):
    self.update_position(move) 
    old_body = self.body
    self.draw()
    remove_from_screen(old_body)

    (x, y) = self.place
    nearest_point = self.nearest_grid_point()
     (nearest_x, nearest_y) = nearest_point
    distance = ( abs(x-nearest_x) +
                 abs(y-nearest_y))

    if distance < self.speed * 3/4:

      object = self.maze.object_at(nearest_point)
      object.eat(self)

width = len(layout)[0])

      garridoman = Garridoman(self, point)
      self.movables.append(garridoman)

self.map[y][x] Food(self, point)

elif character == 'G'