class Game:
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
self.set = Settings()
self.screen = pygame.display.set_mode((600, 720))
pygame.display.set_caption('Pacman')
self.stats = GameStats(self.set)
# Create a pacman object to pass to maze
#sb = Scoreboard(set, self.screen, stats, self.maze)
#self.play_button = Button(self.screen, "Start munchin'")
# Give files needed to populate the maze
self.expandfile = ExpandFile('test.txt', expandBy=2)
self.maze = Maze(self.screen, 'newtest.txt', 'images/purptile4', 'images/foodPellet', 'B1', 'C/CL1', 'I/I1',
'P/P1')
self.intro = pygame.mixer.Sound("sounds/pacman_beginning.wav")
self.sb = Scoreboard(self.set, self.screen, self.stats, self.maze)
self.player = Pacman(self.screen, self.maze, self.sb)
self.blinky = Ghost(self.screen, self.maze, self.sb)
self.play_button = Button(self.screen, "Start munchin'")
# def __str__(self): return
def play(self):
# sleep(4)
#pygame.mixer.Sound.play(self.intro)
sleep(1)
eventloop = EventLoop(finished=False)
pygame.mixer.Sound.play(self.intro)
while not eventloop.finished:
#self.clock.tick(60)
eventloop.check_events(self.screen, self.player, self.sb, self.play_button, self.stats, self.set)
self.player.update()
self.update_screen()
def update_screen(self):
self.screen.fill(Game.BLACK)
self.maze.blitme()
self.player.blitme()
self.blinky.blitme()
#self.sb.show_score()
self.player.points_gathered()
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((900, 1000))
pygame.display.set_caption("Pacman Portal")
self.clock = pygame.time.Clock()
self.expandfile = ExpandFile('mazefile.txt', expandBy=6)
self.maze = Maze(self.screen, 'mazefile_expanded.txt', 'brick',
'orangeportal', 'blueportal', 'shield', 'point')
self.gamestats = GameStats()
self.pacmanGroup = Group()
self.pacman = Pacman(self.screen)
self.pacmanGroup.add(self.pacman)
def play(self):
pacman = self.pacman
maze = self.maze
ghost = []
for i in range(1):
g = Ghost(self.screen)
g.type = i
g.x += 30 * i
g.prep_ghost()
ghost.append(g)
eloop = EventLoop(status=False)
while not eloop.finished:
eloop.check_events(pacman)
eloop.update_screen(pacman)
pacman.update(maze, self.gamestats, self.pacmanGroup)
for i in range(1):
ghost[i].blit()
self.update_screen()
def update_screen(self):
self.screen.fill(Game.BLACK)
self.maze.blitme()
self.pacman.blitme()
pygame.display.flip()
self.clock.tick(120)
class Game:
settings: Settings
def __init__(self):
pygame.init()
self.settings = Settings()
self.settings.reset()
self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
self.intro = Intro(self.screen, self.settings)
self.menu = Menu(self.screen, self.settings)
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen, mazefile='pacmap.txt')
self.pacman = Pacman(self.screen)
self.dashboard = Dashboard(self.screen)
self.portal_enter = Portal("Enter", self.screen, self.settings)
self.portal_exit = Portal("Exit", self.screen, self.settings)
scoresheet = open('scoresheet.txt', 'r')
self.settings.score_high = int(scoresheet.read())
def __str__(self): return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.pacman, self.menu, self.portal_enter, self.portal_exit, self.settings)
self.update_screen()
def update_screen(self):
self.screen.fill((0, 0, 0))
if self.settings.mode == "Game":
self.maze.check_pac_conditions(self.pacman, self.settings, self.portal_enter, self.portal_exit)
self.maze.blitme(self.settings)
self.pacman.blitme(self.settings)
self.dashboard.blitme(self.settings)
self.portal_enter.blitme()
self.portal_exit.blitme()
elif self.settings.mode == "Menu":
self.menu.blitme()
pass
elif self.settings.mode == "Intro":
self.intro.blitme()
pygame.display.flip()
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((1200, 800))
pygame.display.set_caption("Pacman Portal")
# self.expandfile = ExpandFile('images/pacman_maze.txt', expandBy=3)
self.maze = Maze(self.screen,
mazefile='images/pacman_maze_expanded_pts.txt',
brickfile='brick',
pointfile='point')
self.pacman = Pacman(self.screen)
self.pac_group = Group()
self.ghosts = Ghosts(self.screen)
self.play_button = Button(self.screen, "Play")
self.stats = Stats()
def __str__(self):
return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
while not self.stats.game_active:
self.play_button.draw_button()
eloop.check_events(self.pacman, self.play_button, self.stats)
eloop.check_events(self.pacman, self.play_button, self.stats)
self.pacman.update(self.maze, self.pac_group)
self.update_screen()
def update_screen(self):
self.screen.fill(Game.BLACK)
self.maze.blitme()
self.pacman.blitme()
self.ghosts.blitme()
pygame.display.flip()
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((self.settings.screen_height, self.settings.screen_width))
pygame.display.set_caption("Pacman Portal")
self.play_button = Button(self.settings, self.screen, "PLAY GAME", (self.settings.screen_width * 2.75) / 7,(self.settings.screen_height * 5.25) / 7)
self.high_scores_button = Button(self.settings, self.screen, "HIGH SCORES", (self.settings.screen_width * 2.65) / 7, (self.settings.screen_height * 6) / 7)
self.stats = Stats(self.settings)
self.scoreboard = Scoreboard(self.settings, self.screen, self.stats)
self.maze = Maze(self.settings, self.screen, mazefile="maze.txt", brickfile="square", portalfile="portal", shieldfile="shield", pointfile="powerpill")
self.pacman_images = ["images/pacman_move_0.png", "images/pacman_move_1.png", "images/pacman_move_2.png"]
self.pacman = Pacman(self.settings, self.screen, self.pacman_images[0])
self.pacman_index = 0
self.inkey_images = [
{
"Up": [
"blue_ghost_up_1",
"blue_ghost_up_2"
]
},
{
"Down": [
"blue_ghost_down_1",
"blue_ghost_down_2"
]
},
{
"Left": [
"blue_ghost_left_1",
"blue_ghost_left_2"
]
},
{
"Right": [
"blue_ghost_right_1",
"blue_ghost_right_2"
]
}
]
self.inkey = Ghost(self.settings, self.screen, self.inkey_images, self.maze.ghost_location[0])
self.clyde_images = [
{
"Up": [
"yellow_ghost_up_1",
"yellow_ghost_up_2"
]
},
{
"Down": [
"yellow_ghost_down_1",
"yellow_ghost_down_2"
]
},
{
"Left": [
"yellow_ghost_left_1",
"yellow_ghost_left_2"
]
},
{
"Right": [
"yellow_ghost_right_1",
"yellow_ghost_right_2"
]
}
]
self.clyde = Ghost(self.settings, self.screen, self.clyde_images, self.maze.ghost_location[1])
self.pinky_images = [
{
"Up": [
"pink_ghost_up_1",
"pink_ghost_up_2"
]
},
{
"Down": [
"pink_ghost_down_1",
"pink_ghost_down_2"
]
},
{
"Left": [
"pink_ghost_left_1",
"pink_ghost_left_2"
]
},
{
"Right": [
"pink_ghost_right_1",
"pink_ghost_right_2"
]
}
]
self.pinky = Ghost(self.settings, self.screen, self.pinky_images, self.maze.ghost_location[2])
self.blinky_images = [
{
"Up": [
"red_ghost_up_1",
"red_ghost_up_2"
]
},
{
"Down": [
"red_ghost_down_1",
"red_ghost_down_2"
]
},
{
"Left": [
"red_ghost_left_1",
"red_ghost_left_2"
]
},
{
"Right": [
"red_ghost_right_1",
"red_ghost_right_2"
]
}
]
self.blinky = Ghost(self.settings, self.screen, self.blinky_images, self.maze.ghost_location[3])
self.menu = Menu(self.settings, self.screen)
def __str__(self):
return "Game((Pacman Portal), maze=" + str(self.maze) + ")"
def play(self):
eloop = EventLoop(self.settings, self.pacman, finished=False)
while not self.stats.game_active:
if self.settings.high_score_screen:
self.menu.high_scores()
else:
self.menu.start_menu(self.play_button, self.high_scores_button)
self.check_events()
pygame.display.update()
while not eloop.finished:
self.check_events()
eloop.check_events()
self.check_collision()
self.update_screen()
def update_screen(self):
self.screen.fill(Game.BLACK)
self.maze.blitme()
self.pacman.update(self.pacman_images, self.pacman_index, self.pacman.direction)
self.blit_characters()
self.scoreboard.show_score()
pygame.display.flip()
def blit_characters(self):
self.pacman.blitme()
self.inkey.blitme()
self.clyde.blitme()
self.pinky.blitme()
self.blinky.blitme()
def check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self.check_keydown_event(event)
elif event.type == pygame.KEYUP:
self.check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
self.check_play_button(self.settings, self.play_button, mouse_x, mouse_y)
self.check_high_scores(self.settings, self.high_scores_button, mouse_x, mouse_y)
def check_keydown_event(self, event):
if event.key == pygame.K_SPACE:
self.settings.high_score_screen = False
self.menu.reset_animation()
if event.key == pygame.K_q:
sys.exit()
if event.key == pygame.K_LEFT and self.pacman.move_left:
self.pacman.x_dir = -1
self.pacman.y_dir = 0
self.pacman.direction = "Left"
if event.key == pygame.K_RIGHT and self.pacman.move_right:
self.pacman.x_dir = 1
self.pacman.y_dir = 0
self.pacman.direction = "Right"
if event.key == pygame.K_UP and self.pacman.move_up:
self.pacman.y_dir = -1
self.pacman.x_dir = 0
self.pacman.direction = "Up"
if event.key == pygame.K_DOWN and self.pacman.move_down:
self.pacman.y_dir = 1
self.pacman.x_dir = 0
self.pacman.direction = "Down"
def check_keyup_events(self, event):
if event.key == pygame.K_RIGHT or event.key == pygame.K_LEFT:
self.pacman.x_dir = 0
if event.key == pygame.K_UP or event.key == pygame.K_DOWN:
self.pacman.y_dir = 0
# self.pacman.direction = None
def check_collision(self):
self.check_dot_collisions()
self.check_power_pill_collisions()
# self.check_brick_collisions()
def check_dot_collisions(self):
for dot in self.maze.dots:
if self.pacman.rect.colliderect(dot):
self.maze.dots.remove(dot)
self.stats.score += self.settings.dot_value
def check_power_pill_collisions(self):
for pill in self.maze.pills:
if self.pacman.rect.colliderect(pill):
self.maze.pills.remove(pill)
self.stats.score += self.settings.power_pill_value
# def check_brick_collisions(self):
# for brick in self.maze.bricks:
# if self.pacman.collider.collidepoint(brick.left[0], brick.left[1]):
# if self.pacman.collider.left <= brick.right and brick.bottom >= self.pacman.collider_y >= brick.top:
# self.pacman.move_left = False
# print("cant move left")
# else:
# self.pacman.move_left = True
# if self.pacman.collider.right >= brick.left and brick.bottom >= self.pacman.collider_y >= brick.top:
# self.pacman.move_right = False
# print("cant move right")
# else:
# self.pacman.move_right = True
# if self.pacman.collider.top <= brick.bottom and brick.left <= self.pacman.collider_x <= brick.right:
# self.pacman.move_up = False
# print("cant move up")
# else:
# self.pacman.move_up = True
# if self.pacman.collider.bottom >= brick.top and brick.left <= self.pacman.collider_x <= brick.right:
# self.pacman.move_down = False
# print("cant move down")
# else:
# self.pacman.move_down = True
# return
def check_play_button(self, settings, play_button, mouse_x, mouse_y):
"""Start a new game when the player clicks Play."""
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not settings.game_active:
# Reset the game settings.
settings.initialize_dynamic_settings()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
self.stats.game_active = True
def check_high_scores(self, settings, high_scores, mouse_x, mouse_y):
"""Load the list of high scores."""
button_clicked = high_scores.rect.collidepoint(mouse_x, mouse_y)
if button_clicked:
self.menu.high_scores()
settings.high_score_screen = True
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((716, 793 + 60))
pygame.display.set_caption("Pacman Portal")
self.bricks = Group()
self.shields = Group()
self.powerpills = Group()
self.qpills = Group()
self.maze = Maze(self.screen,
self.bricks,
self.shields,
self.powerpills,
self.qpills,
brickfile='square',
mazefile='images/pacmanportalmaze.txt',
shieldfile='shield',
powerpill='powerpill')
self.increase = False
self.scoreboard = Scorebord(self.screen, self)
self.pacman = Pacman(self.screen, self.scoreboard, self)
self.play_button = Button(self.screen, "PLAY GAME", 80 / 100)
self.score_button = Button(self.screen, "HIGH SCORES", 90 / 100)
self.menu = Menu()
self.audio = Audio()
self.fruit = Fruit(self.screen)
self.blinky = Blinky(self.screen, self.pacman, self.scoreboard)
self.inky = Inky(self.screen, self.pacman, self.scoreboard)
self.pinky = Pinky(self.screen, self.pacman, self.scoreboard)
self.clyde = Clyde(self.screen, self.pacman, self.scoreboard)
self.oportal = Portal('o', self.pacman)
self.bportal = Portal('b', self.pacman)
self.active = False
self.pause = False
def __str__(self):
return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def play(self):
while True:
pygame.time.Clock().tick(1800)
func.check_events(self.pacman, self.score_button, self.menu,
self.play_button, self, self.bportal,
self.oportal, self.screen, self.maze, self.audio)
self.update_screen()
if self.active:
func.check_collisions(self.pacman, self.bricks, self.shields,
self.powerpills, self.scoreboard,
self.blinky, self.pinky, self.inky,
self.clyde, self.qpills, self.fruit,
self.audio)
self.pacman.update(self.oportal, self.bportal, self.audio)
if not self.pause:
self.fruit.update()
self.blinky.update(self.oportal, self.bportal)
self.inky.update(self.oportal, self.bportal)
self.pinky.update(self.oportal, self.bportal)
self.clyde.update(self.oportal, self.bportal)
self.scoreboard.update_score(self)
if self.increase:
self.pacman.reset()
self.inky.reset()
self.clyde.reset()
self.pinky.reset()
self.fruit.reset()
self.blinky.reset()
self.maze.build()
self.increase = False
if self.scoreboard.lives == 0:
self.active = False
def update_screen(self):
self.screen.fill(Game.BLACK)
if self.active:
self.maze.blitme(self.screen)
self.scoreboard.show_score()
self.pacman.blitme()
self.blinky.blitme()
self.inky.blitme()
self.pinky.blitme()
self.clyde.blitme()
self.oportal.blitme(self.screen)
self.bportal.blitme(self.screen)
self.fruit.blitme()
elif not self.menu.show_scores:
self.menu.main(self.play_button, self.score_button, self.screen)
else:
self.menu.scores(self.score_button, self.screen)
pygame.display.flip()
class Game:
Black = (0, 0, 0)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((715, 850))
self.font = pygame.font.SysFont(None, 48)
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen,
mazefile='images/pacmanportalmaze.txt',
brickfile='square',
portalfile='portal',
shieldfile='shield',
pointfile='point')
self.pacman = Pacman(self.screen, self.maze)
self.ghost = []
self.ghost.append(Ghost(self.screen, self.maze, 'redghost', 0))
self.ghost.append(Ghost(self.screen, self.maze, 'cyanghost', 1))
self.ghost.append(Ghost(self.screen, self.maze, 'pinkghost', 2))
self.ghost.append(Ghost(self.screen, self.maze, 'orangeghost', 3))
self.score = 0
self.score_image = None
self.score_rect = None
self.screen_rect = self.screen.get_rect()
self.live_image = self.pacman.images[1]
self.live_rect = None
self.lives = 2
self.start_rect = None
self.scores_rect = None
self.titlepac = Pacman(self.screen, self.maze)
self.titleghost = list()
self.titleghost.append(Ghost(self.screen, self.maze, 'redghost', 0))
self.titleghost.append(Ghost(self.screen, self.maze, 'cyanghost', 1))
self.titleghost.append(Ghost(self.screen, self.maze, 'pinkghost', 2))
self.titleghost.append(Ghost(self.screen, self.maze, 'orangeghost', 3))
def __str__(self):
return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.pacman, self.start_rect)
self.update_screen()
self.pacman.update()
for ghost in self.ghost:
ghost.update()
def update_screen(self):
self.screen.fill(Game.Black)
if not self.pacman.active:
self.prepstartscreen()
else:
self.maze.blitme()
self.pacman.blitme()
self.prepscore()
self.preplives()
for ghost in self.ghost:
ghost.blitme()
pygame.display.flip()
def prepscore(self):
self.score = self.pacman.getscore()
score_str = '{:>3}'.format(self.score)
self.score_image = self.font.render('Score: ' + score_str, True,
(255, 255, 255), (0, 0, 0))
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.left + 300
self.score_rect.top = self.screen_rect.bottom - 30
self.screen.blit(self.score_image, self.score_rect)
def preplives(self):
self.lives = self.pacman.getlives()
lives_text = self.font.render('Lives: ', True, (255, 255, 255),
(0, 0, 0))
lives_text_rect = lives_text.get_rect()
lives_text_rect.right = self.screen_rect.left + 500
lives_text_rect.top = self.screen_rect.bottom - 35
self.screen.blit(lives_text, lives_text_rect)
for x in range(self.lives):
self.live_rect = self.live_image.get_rect()
self.live_rect.right = self.screen_rect.left + 550 + x * 50
self.live_rect.top = self.screen_rect.bottom - 35
self.screen.blit(self.live_image, self.live_rect)
def prepstartscreen(self):
titleimg = pygame.image.load('images/title.png')
titleimg = pygame.transform.scale(titleimg, (570, 150))
title_rect = titleimg.get_rect()
title_rect = (self.screen_rect.centerx - title_rect.width / 2,
(self.screen_rect.centery - title_rect.height / 2) - 250)
self.screen.blit(titleimg, title_rect)
self.titlepac.rect.x = 200
self.titlepac.rect.y = 450
self.titlepac.update()
self.titlepac.blitme()
for x in range(4):
self.titleghost[x].rect.x = 250 + x * 60
self.titleghost[x].rect.y = 450
self.titleghost[x].update()
self.titleghost[x].blitme()
# Play Button
startimg = pygame.image.load('images/play.png')
self.start_rect = startimg.get_rect()
self.start_rect.x = self.screen_rect.centerx - self.start_rect.width / 2
self.start_rect.y = self.screen_rect.centery - self.start_rect.height / 2 + 250
self.screen.blit(startimg, self.start_rect)
# High scores
scoresimg = pygame.image.load('images/scores.png')
scoresimg = pygame.transform.scale(scoresimg, (380, 100))
self.scores_rect = scoresimg.get_rect()
self.scores_rect.x = self.screen_rect.centerx - self.scores_rect.width / 2
self.scores_rect.y = self.screen_rect.centery - self.scores_rect.height / 2 + 350
self.screen.blit(scoresimg, self.scores_rect)
def displayscores(self):
scoresimg = pygame.image.load('images/scores.png')
# scoresimg = pygame.transform.scale(scoresimg, (380, 100))
scores_rect = scoresimg.get_rect()
scores_rect.x = self.screen_rect.centerx - scores_rect.width / 2
scores_rect.y = self.screen_rect.centery - scores_rect.height / 2
self.screen.blit(scoresimg, scores_rect)
class Game:
bg_color = (0, 0, 0)
def __init__(self):
pygame.init()
mixer.init()
ai_settings = Settings()
self.ai_settings = ai_settings
self.screen = pygame.display.set_mode(
(self.ai_settings.screen_width, self.ai_settings.screen_height))
pygame.display.set_caption("Pacman Portal")
self.menu = Menu(self.screen, 'Pacman Portal', 'HIGH SCORE:')
self.maze = Maze(self.screen, 'images/maze.txt', 'brick', 'dot',
'powerpill')
self.pacman = Pacman(self.screen, self.ai_settings)
self.pinky = Pinky(self.screen, self.ai_settings)
self.inky = Inky(self.screen, self.ai_settings)
self.blinky = Blinky(self.screen, self.ai_settings)
self.clyde = Clyde(self.screen, self.ai_settings)
self.sb = Scoreboard(self.ai_settings, self.screen)
self.load_data()
self.ghosts = Group()
self.ghosts.add(self.pinky)
self.ghosts.add(self.inky)
self.ghosts.add(self.blinky)
self.ghosts.add(self.clyde)
def load_data(self):
self.dir = path.dirname(__file__)
with open(path.join(self.dir, self.ai_settings.hs_file), 'r') as f:
try:
self.ai_settings.high_score = int(f.read())
except:
self.ai_settings.high_score = 0
def play(self):
eloop = EventLoop(self.ai_settings.finished)
self.load_data()
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.pacman)
self.pacman.check_dot_collision(self.ai_settings, self.maze.dots,
self.maze.pills, self.sb)
self.sb.check_high_score(self.sb)
self.update_screen()
self.pacman.check_wall_collision(self.maze.bricks)
self.pinky.check_wall_collision(self.maze.bricks)
self.inky.check_wall_collision(self.maze.bricks)
self.blinky.check_wall_collision(self.maze.bricks)
self.clyde.check_wall_collision(self.maze.bricks)
self.pacman.update()
self.ghosts.update()
eloop.update_collisions(self.ai_settings, self.pacman, self.ghosts,
self.maze)
def update_screen(self):
self.screen.fill(Game.bg_color)
if not self.ai_settings.finished:
self.menu.draw_menu()
self.sb.check_high_score(self.sb)
self.sb.prep_high_score()
self.sb.display_high_score()
else:
self.maze.blitme()
self.pacman.blitme()
self.ghosts.draw(self.screen)
self.sb.show_score()
pygame.display.flip()
class Maze:
BRICK_SIZE = 11
def __init__(self, screen, mazefile, stats, clock):
self.screen = screen
self.stats = stats
self.clock = clock
self.radio = pygame.mixer
self.radio.init()
self.filename = mazefile
with open(self.filename, 'r') as f:
self.rows = f.readlines()
self.maze_obj = []
size = Maze.BRICK_SIZE
self.brick = Image(screen, 'brick', size, size)
self.default_ports = pygame.sprite.Group()
self.def_port_list = []
self.lport = Portal(self.screen, 'blue')
self.rport = Portal(self.screen, 'orange')
self.pac_dots = pygame.sprite.Group()
self.pac_dot = Pacdot(screen, pygame.image.load('images/pacdot.png'))
self.pac_dot.image = pygame.transform.scale(self.pac_dot.image, (8, 8))
self.power_dots = pygame.sprite.Group()
self.power = Pacdot(screen, pygame.image.load('images/pacdot.png'))
self.power.image = pygame.transform.scale(self.power.image, (15, 15))
self.shield = Image(screen, 'shield', size, size)
self.pac_man = Pacman(screen, self)
self.blinky = Ghost(screen, self, 'blinky')
self.pinky = Ghost(screen, self, 'pinky')
self.inky = Ghost(screen, self, 'inky')
self.clyde = Ghost(screen, self, 'clyde')
self.ghosts = pygame.sprite.Group()
self.fruit = None
self.fruits = pygame.sprite.Group()
self.deltax = self.deltay = Maze.BRICK_SIZE
# used for menu purposes
self.title = None
self.title_rect = None
self.start_button = None
self.scores_button = None
# end of menu items
# used for sounds
self.intro = self.radio.Sound('sounds/intro.wav')
self.ambient = self.radio.Sound('sounds/ambient.wav')
self.eatdot = self.radio.Sound('sounds/eatdot.wav')
self.eatghost = self.radio.Sound('sounds/eatghost.wav')
self.powersound = self.radio.Sound('sounds/power.wav')
self.death = self.radio.Sound('sounds/death.wav')
self.gameover = self.radio.Sound('sounds/gameover.wav')
self.ambient_playing = False
self.power_playing = False
# end of sounds
self.lives_counter = pygame.sprite.Group()
self.lives_sprites = []
self.active_ports = pygame.sprite.Group()
self.bport = None
self.oport = None
self.blue_active = False
self.orange_active = False
self.build()
def build(self):
w, h = Maze.BRICK_SIZE, Maze.BRICK_SIZE
dx, dy = self.deltax, self.deltay
self.fruit = Fruit(self.screen, self.stats.current_level % 9)
self.fruits.add(self.fruit)
for i in range(0, self.stats.lives):
temp = Pacman(self.screen, self)
temp.rect.y = 650
temp.rect.x = i * 30
self.lives_counter.add(temp)
self.lives_sprites.append(temp)
for nrow in range(len(self.rows)):
row = self.rows[nrow]
for ncol in range(len(row)):
col = row[ncol]
current_rect = pygame.Rect(ncol * dx, nrow * dy, w, h)
if col == 'X':
self.maze_obj.append(('brick', current_rect))
elif col == '.':
temp = self.pac_dot.spawn()
temp.rect = current_rect
self.maze_obj.append(('pacdot', temp))
self.pac_dots.add(temp)
elif col == 'M':
self.pac_man.rect.x = current_rect.x - 11
self.pac_man.rect.y = current_rect.y - 11
self.maze_obj.append(('pacman', self.pac_man.rect))
elif col == 'P':
temp = self.power.spawn()
temp.rect = current_rect
temp.rect.x -= 3
temp.rect.y -= 3
self.maze_obj.append(('power', current_rect))
self.power_dots.add(temp)
elif col == 'S':
self.maze_obj.append(('shield', current_rect))
elif col == '1':
self.blinky.rect.x = current_rect.x - 10
self.blinky.rect.y = current_rect.y - 10
self.maze_obj.append(('blinky', self.blinky.rect))
self.ghosts.add(self.blinky)
elif col == '2':
self.pinky.rect.x = current_rect.x - 10
self.pinky.rect.y = current_rect.y - 10
self.maze_obj.append(('pinky', self.pinky.rect))
self.ghosts.add(self.pinky)
elif col == '3':
self.inky.rect.x = current_rect.x - 10
self.inky.rect.y = current_rect.y - 10
self.maze_obj.append(('inky', self.inky.rect))
self.ghosts.add(self.inky)
elif col == '4':
self.clyde.rect.x = current_rect.x - 10
self.clyde.rect.y = current_rect.y - 10
self.maze_obj.append(('clyde', self.clyde.rect))
self.ghosts.add(self.clyde)
elif col == 'B':
self.lport.rect = current_rect
self.maze_obj.append(('port1', self.lport.rect))
self.default_ports.add(self.lport)
self.def_port_list.append(self.lport)
elif col == 'O':
self.rport.rect = current_rect
self.maze_obj.append(('port2', self.rport.rect))
self.default_ports.add(self.rport)
self.def_port_list.append(self.rport)
def blitme(self):
self.pac_dots.draw(self.screen)
self.power_dots.draw(self.screen)
self.default_ports.draw(self.screen)
for obj in self.maze_obj:
if obj[0] == 'brick':
self.screen.blit(self.brick.image, obj[1])
elif obj[0] == 'shield':
self.screen.blit(self.shield.image, obj[1])
self.stats.blitme()
@staticmethod
def check_events(self):
keys = pygame.key.get_pressed()
if keys[pygame.K_UP] and self.top_is_clear(self.pac_man):
self.pac_man.moveup()
if keys[pygame.K_DOWN] and self.bot_is_clear(self.pac_man):
self.pac_man.movedown()
if keys[pygame.K_LEFT] and self.left_is_clear(self.pac_man):
self.pac_man.moveleft()
if keys[pygame.K_RIGHT] and self.right_is_clear(self.pac_man):
self.pac_man.moveright()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.stats.new_high_score(self.stats.current_score)
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
self.fire_blue_portal()
if event.key == pygame.K_e:
self.fire_orange_portal()
if event.key == pygame.K_SPACE:
self.active_ports.empty()
self.blue_active = False
self.orange_active = False
def update(self):
self.check_events(self)
self.screen.fill((0, 0, 0))
self.blitme()
self.dot_eating()
self.pac_portal_collision()
self.pac_active_portal_collision()
self.pac_ghost_collision()
self.ghost_active_portal_collision()
if self.stats.game_status == 0:
return
if self.pac_man.ghost_pt_mult == 5:
self.fruit.show_self()
if not self.pac_man.dying:
self.pac_man.move()
self.ghosts.update()
if self.pac_man.powered_up and not self.power_playing:
self.ambient.stop()
self.ambient_playing = False
self.powersound.play(-1)
self.power_playing = True
elif not self.pac_man.powered_up and self.power_playing:
self.powersound.stop()
self.power_playing = False
elif not self.pac_man.powered_up and not self.ambient_playing:
self.ambient.play(-1)
self.ambient_playing = True
else:
self.ambient.stop()
self.ambient_playing = False
self.fruit.set_invisible()
if self.stats.game_status == 1:
self.fruits.draw(self.screen)
self.active_ports.draw(self.screen)
self.pac_man.blitme()
self.blinky.blitme()
self.pinky.blitme()
self.inky.blitme()
self.clyde.blitme()
self.lives_counter.draw(self.screen)
def dot_eating(self):
dot_collisions = pygame.sprite.spritecollideany(
self.pac_man, self.pac_dots)
if dot_collisions:
dot_collisions.kill()
self.stats.current_score += 10
self.eatdot.play()
dot_collisions = pygame.sprite.spritecollideany(
self.pac_man, self.power_dots)
if dot_collisions:
dot_collisions.kill()
self.stats.current_score += 50
self.pac_man.powered_up = True
for ghost in self.ghosts:
ghost.scared = True
if len(self.pac_dots) == 0 and len(self.power_dots) == 0:
pygame.time.wait(1000)
self.new_level()
fruit_collision = pygame.sprite.spritecollideany(
self.pac_man, self.fruits)
if fruit_collision:
self.stats.current_score += 1000
self.eatghost.play()
fruit_collision.kill()
fruit_collision.visible = False
def pac_ghost_collision(self):
collisions = pygame.sprite.spritecollideany(self.pac_man, self.ghosts)
if collisions and not self.pac_man.powered_up:
for ghost in self.ghosts:
ghost.return_to_center()
if self.stats.lives > 0:
self.pac_man.die()
self.stats.lives -= 1
self.lives_sprites[self.stats.lives].kill()
self.death.play()
else:
self.stats.new_high_score(self.stats.current_score)
self.reset_game()
self.stats.game_status = 0
elif collisions and self.pac_man.powered_up:
collisions.return_to_center()
self.stats.current_score += (2 ^ self.pac_man.ghost_pt_mult) * 100
self.pac_man.ghost_pt_mult += 1
self.eatghost.play()
def pac_portal_collision(self):
collision = pygame.sprite.spritecollideany(self.pac_man,
self.default_ports)
if self.pac_man.is_teleporting >= 100:
self.pac_man.is_teleporting = 0
if collision and self.pac_man.is_teleporting == 0:
self.pac_man.is_teleporting += 1
if collision.color == 0:
self.pac_man.rect.x = self.def_port_list[1].rect.x
else:
self.pac_man.rect.x = self.def_port_list[0].rect.x
elif self.pac_man.is_teleporting != 0:
self.pac_man.is_teleporting += 1
def pac_active_portal_collision(self):
collision = pygame.sprite.spritecollideany(self.pac_man,
self.active_ports)
if self.pac_man.is_teleporting >= 100:
self.pac_man.is_teleporting = 0
if collision and self.pac_man.is_teleporting == 0 and self.blue_active and self.orange_active:
self.pac_man.is_teleporting += 1
if collision.color == 0:
self.pac_man.rect.centerx = self.oport.rect.centerx
self.pac_man.rect.centery = self.oport.rect.centery
else:
self.pac_man.rect.centerx = self.bport.rect.centerx
self.pac_man.rect.centery = self.bport.rect.centery
elif self.pac_man.is_teleporting != 0:
self.pac_man.is_teleporting += 1
def ghost_active_portal_collision(self):
collision = pygame.sprite.groupcollide(self.ghosts, self.active_ports,
False, False)
if collision:
for ghost in collision:
if ghost.is_teleporting == 0 and self.blue_active and self.orange_active \
and self.stats.current_level > 9:
ghost.is_teleporting += 1
if collision[ghost][0].color == 0:
ghost.rect.centerx = self.oport.rect.centerx
ghost.rect.centery = self.oport.rect.centery
else:
ghost.rect.centerx = self.bport.rect.centerx
ghost.rect.centery = self.bport.rect.centery
def fire_blue_portal(self):
if not self.blue_active:
port_loc = self.pac_man.find_portal_spot()
self.bport = Portal(self.screen, 'blue')
self.bport.rect.centerx = port_loc[0]
self.bport.rect.centery = port_loc[1]
self.active_ports.add(self.bport)
self.blue_active = True
def fire_orange_portal(self):
if not self.orange_active:
port_loc = self.pac_man.find_portal_spot()
self.oport = Portal(self.screen, 'orange')
self.oport.rect.centerx = port_loc[0]
self.oport.rect.centery = port_loc[1]
self.active_ports.add(self.oport)
self.orange_active = True
# returns x y position for retrieval of object from maze obj 2d array
# real=true for top left xy, real=false for bot right
@staticmethod
def get_obj_pos(obj):
x = int(obj.rect.x / Maze.BRICK_SIZE)
y = int(obj.rect.y / Maze.BRICK_SIZE)
return x, y
# checks for possible collision, direction is 1 up, 2 right, 3 down, 4 left
def front_path_is_clear(self, direction, obj):
obj_pos = self.get_obj_pos(obj)
if type(obj) is Pacman:
if direction == 1:
return self.rows[obj_pos[1]][
obj_pos[0] +
1] != 'X' and self.rows[obj_pos[1]][obj_pos[0] + 1] != 'S'
if direction == 2:
return self.rows[obj_pos[1] + 1][obj_pos[0] + 3] != 'X' \
and self.rows[obj_pos[1] + 1][obj_pos[0] + 3] != 'S'
if direction == 3:
return self.rows[obj_pos[1] + 3][obj_pos[0] + 1] != 'X' \
and self.rows[obj_pos[1] + 3][obj_pos[0] + 1] != 'S'
if direction == 4:
return self.rows[obj_pos[1] + 1][
obj_pos[0]] != 'X' and self.rows[obj_pos[1] +
1][obj_pos[0]] != 'S'
else:
if direction == 1:
return self.rows[obj_pos[1]][obj_pos[0] + 1] != 'X'
if direction == 2:
return self.rows[obj_pos[1] + 1][obj_pos[0] + 3] != 'X'
if direction == 3:
return self.rows[obj_pos[1] + 3][obj_pos[0] + 1] != 'X'
if direction == 4:
return self.rows[obj_pos[1] + 1][obj_pos[0]] != 'X'
def left_is_clear(self, obj):
flag = True
for i in range(2, 8):
if self.screen.get_at(
(obj.rect.x - 2, obj.rect.y + i)) == (36, 28, 252):
flag = False
for i in range(25, 32):
if self.screen.get_at(
(obj.rect.x - 2, obj.rect.y + i)) == (36, 28, 252):
flag = False
return flag
def right_is_clear(self, obj):
flag = True
for i in range(2, 8):
if self.screen.get_at(
(obj.rect.x + 35, obj.rect.y + i)) == (36, 28, 252):
flag = False
for i in range(25, 32):
if self.screen.get_at(
(obj.rect.x + 35, obj.rect.y + i)) == (36, 28, 252):
flag = False
return flag
def bot_is_clear(self, obj):
flag = True
for i in range(2, 8):
if self.screen.get_at(
(obj.rect.x + i, obj.rect.y + 35)) == (36, 28, 252):
flag = False
for i in range(25, 32):
if self.screen.get_at(
(obj.rect.x + i, obj.rect.y + 35)) == (36, 28, 252):
flag = False
return flag
def top_is_clear(self, obj):
flag = True
for i in range(2, 8):
if self.screen.get_at(
(obj.rect.x + i, obj.rect.y - 3)) == (36, 28, 252):
flag = False
for i in range(25, 32):
if self.screen.get_at(
(obj.rect.x + i, obj.rect.y - 3)) == (36, 28, 252):
flag = False
return flag
def new_level(self):
self.maze_obj = []
self.pac_dots.empty()
self.power_dots.empty()
self.active_ports.empty()
self.bport = None
self.oport = None
self.blue_active = False
self.orange_active = False
self.default_ports.empty()
self.def_port_list = []
for ghost in self.ghosts:
ghost.return_to_center()
ghost.scared_timer = 0
ghost.scared = False
self.ghosts.empty()
self.pac_man.power_timer = 0
self.pac_man.powered_up = False
self.stats.game_speed += 2
self.stats.current_level += 1
self.ambient.stop()
self.ambient_playing = False
self.powersound.stop()
self.power_playing = False
self.lives_sprites = []
self.lives_counter.empty()
self.fruits.empty()
self.build()
pygame.time.wait(700)
def reset_game(self):
self.maze_obj = []
self.lives_sprites = []
self.lives_counter.empty()
self.pac_dots.empty()
self.power_dots.empty()
self.active_ports.empty()
self.bport = None
self.oport = None
self.blue_active = False
self.orange_active = False
self.default_ports.empty()
self.def_port_list = []
for ghost in self.ghosts:
ghost.return_to_center()
self.ghosts.empty()
self.stats.game_speed = 60
self.stats.current_level = 0
self.stats.lives = 3
self.stats.current_score = 0
self.radio.stop()
self.ambient_playing = False
self.power_playing = False
self.fruits.empty()
self.gameover.play()
self.build()
self.screen.fill((0, 0, 0))
pygame.time.wait(700)
def show_menu(self, anim):
self.screen.fill((0, 0, 0))
self.check_menu_events()
anim.update()
self.screen.blit(self.title, self.title_rect)
self.start_button.draw_button()
self.scores_button.draw_button()
anim.blitme()
def create_menu(self):
self.title = pygame.image.load('images/title.png')
self.title = pygame.transform.scale(self.title, (750, 750))
self.title_rect = self.title.get_rect()
self.title_rect.x = 80
self.title_rect.y = 100
self.start_button = Button(self.screen, "PLAY GAME", 1)
self.scores_button = Button(self.screen, "HIGH SCORES", 2)
return Animation(self.screen, self)
def check_menu_events(self):
m_x, m_y = pygame.mouse.get_pos()
if self.start_button.rect.collidepoint(m_x, m_y):
self.start_button.lightup()
else:
self.start_button.lightdown()
if self.scores_button.rect.collidepoint(m_x, m_y):
self.scores_button.lightup()
else:
self.scores_button.lightdown()
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
m_x, m_y = pygame.mouse.get_pos()
if self.start_button.rect.collidepoint(m_x, m_y):
self.stats.game_status = 1
self.intro.play()
time.sleep(3.5)
elif self.scores_button.rect.collidepoint(m_x, m_y):
self.stats.show_score_list()
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
mixer.init()
ai_settings = Settings()
self.ai_settings = ai_settings
self.screen = pygame.display.set_mode(
(self.ai_settings.screen_width, self.ai_settings.screen_height))
pygame.display.set_caption("PacMan X Portal")
self.dir = False
self.menu = Menu(self.screen, 'PAC-MAN X PORTAL', 'HIGHSCORE:')
self.sb = Scoreboard(self.ai_settings, self.screen)
self.load_data()
self.maze = Maze(self.screen, 'images/pacmanportalmaze_dijkstra.txt',
'brick', 'dot', 'powerpill')
# self.maze = Maze(self.screen, 'images/maze.txt', 'brick', 'dot', 'powerpill')
self.pacman = Pacman(self.screen, self.ai_settings)
self.ghosts = Group()
self.ghost = Ghost(self.screen, ai_settings)
self.ghosts.add(self.ghost)
def __str__(self):
return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def load_data(self):
self.dir = path.dirname(__file__)
with open(path.join(self.dir, self.ai_settings.hs_file), 'r') as f:
try:
self.ai_settings.high_score = int(f.read())
except:
self.ai_settings.high_score = 0
def play(self):
eloop = EventLoop(self.ai_settings.finished)
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.pacman)
self.pacman.check_dot_collision(self.ai_settings, self.maze.dots,
self.maze.pills, self.sb)
self.sb.check_high_score(self.sb)
self.update_screen()
self.pacman.check_wall_collision(self.maze.bricks)
self.pacman.update()
self.ghost.update_ghost(self.pacman, self.maze.nodes)
def update_screen(self):
self.screen.fill(Game.BLACK)
if not self.ai_settings.finished:
self.menu.draw_menu()
self.sb.check_high_score(self.sb)
self.sb.prep_high_score()
self.sb.display_high_score()
else:
self.maze.blitme()
self.pacman.blitme()
self.ghost.blitme()
self.sb.show_score()
pygame.display.flip()
def run_game():
BLACK = (0, 0, 0)
pygame.init()
screen = pygame.display.set_mode((700, 780))
pygame.display.set_caption("Pacman Portal")
clock = pygame.time.Clock()
start_tick = pygame.time.get_ticks()
random.seed()
play_button = Button(screen, "Play")
sb = Scoreboard(screen)
# create pacman
pacman = Pacman(screen)
# create ghosts
ghost1 = Ghost(screen, 1)
ghost2 = Ghost(screen, 2)
ghost3 = Ghost(screen, 3)
ghost4 = Ghost(screen, 4)
ghosts = Group(ghost1, ghost2, ghost3, ghost4)
# create a group for the pills
pills = Group()
# create the maze
maze = Maze(screen,
pills,
mazefile='images/pacmanportalmaze.txt',
brickfile='blue_square',
shieldfile='shield',
portalfile='portal2',
powerpill='powerpill',
powerpill2='powerpill')
# def __str__(self): return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
# pacman intro sound
intro_music = pygame.mixer.Sound('music/pacman_beginning.wav')
intro_music.play()
# show the start screen
ss.Start_Screen(screen, play_button, sb)
# game main loop
while True:
if sb.game_active:
screen.fill(BLACK)
# seconds = int((pygame.time.get_ticks() - start_tick) / 500)
rand_num = random.randint(0, 100)
pacman.check_events()
pacman.update()
pacman.blitme()
maze.blitme()
for ghost in ghosts:
ghost.get_direction(rand_num)
ghost.update()
ghost.blitme()
gf.check_pill_collision(pacman, pills, sb, maze)
gf.check_ghost_collision(pacman, ghosts, sb)
sb.show_score()
pygame.display.flip()
# checks if no lives are left and displays the "game over" screen
if sb.lives_left == 0:
sb.game_active = False
sleep(1)
go.Game_Over(screen, play_button, sb)
sb.reset_stats()
maze.build()
pacman.reset()
for ghost in ghosts:
ghost.reset()
sb.prep_score()
sb.prep_high_score()
sb.prep_level()
sb.prep_lives()
pygame.display.flip()
# print("Game Active")
else:
pygame.mouse.set_visible(True)
pacman.reset()
for ghost in ghosts:
ghost.reset()
play_button.draw_button()
pygame.display.flip()
while not sb.game_active:
gf.check_button(play_button, sb)
# print("seconds = " + str(seconds))
# set the fps
clock.tick(60)
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((680, 740))
self.ai_settings = Settings()
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen,
mazefile='map.txt',
brickfile='square',
portalfile='square',
shieldfile='shield',
pointfile='point',
dotfile='dot',
powerpillfile='powerpill')
self.pacman = Pacman(self.ai_settings, self.screen, self.maze)
self.ghosts = Ghosts(self.ai_settings, self.screen, self.maze,
self.pacman)
self.displayname = Button(self.screen, "PacmanPortal")
self.play_button = Button(self.screen, "PLAY GAME")
self.highscore_button = Button(self.screen, "HIGH SCORES")
self.blinkyname = Button(self.screen, "BLiNKY")
self.pinkyname = Button(self.screen, "PiNKY")
self.clydename = Button(self.screen, "CLYDE")
self.inkeyname = Button(self.screen, "iNKEY")
self.back = Button(self.screen, "Back")
self.sb = Scoreboard(self.ai_settings, self.screen, self.maze,
self.pacman)
self.score = Button(self.screen, "hello")
self.blues = 0
def __str__(self):
return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def play(self):
# self.displayname = Button(self.screen, "Portal Pacman")
self.displayname.rect.centery -= 300
self.displayname.msg_image_rect.center = self.displayname.rect.center
# self.highscore_button = Button(self.screen, "Portal Pacman")
self.highscore_button.rect.centery += 330
self.highscore_button.msg_image_rect.center = self.highscore_button.rect.center
# self.play_button = Button(self.screen, "Portal Pacman")
self.play_button.rect.centery += 280
self.play_button.msg_image_rect.center = self.play_button.rect.center
hs_file = open("score.txt", "r")
self.ai_settings.hs = int(hs_file.read())
hs_file.close()
msgg = 'The high score is ' + str(self.ai_settings.hs)
self.score = Button(self.screen, msgg)
self.score.rect.centery -= 150
self.score.msg_image_rect.center = self.score.rect.center
self.ghosts.intro()
self.pacman.intro()
self.blues = pygame.mixer.Sound('sounds/blueghosts.wav')
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.ai_settings, self.pacman, self.maze,
self.play_button, self.highscore_button,
self.back, self.ghosts, self.blues, self.sb)
if self.ai_settings.score > self.ai_settings.hs and self.ai_settings.game_active:
self.ai_settings.hs = self.ai_settings.score
msgg = 'The high score is ' + str(self.ai_settings.hs)
score = Button(self.screen, msgg)
score.rect.centery += 150
score.msg_image_rect.center = score.rect.center
if len(self.maze.dots) == 1:
self.maze = Maze(self.screen,
mazefile='map.txt',
brickfile='square',
portalfile='square',
shieldfile='shield',
pointfile='point',
dotfile='dot',
powerpillfile='powerpill')
self.pacman.reset()
self.ghosts.reset()
self.ai_settings.level += 1
if not self.ai_settings.game_active:
pygame.mouse.set_visible(True)
self.update_screen()
def update_screen(self):
self.pacman.update()
self.ghosts.update()
self.screen.fill(Game.BLACK)
self.maze.blitme()
self.pacman.blitme()
self.ghosts.blitme()
self.sb.prep_score()
self.sb.prep_high_score()
# self.sb.prep_pacmans()
self.sb.show_score()
if not self.ai_settings.game_active:
self.screen.fill(self.ai_settings.bg_color)
self.displayname.draw_button()
self.highscore_button.draw_button()
self.play_button.draw_button()
self.ghosts.introupdate()
self.ghosts.blitme()
self.pacman.introupdate()
self.pacman.blitme()
if self.ai_settings.shs:
self.screen.fill(self.ai_settings.bg_color)
self.back.draw_button()
self.score.draw_button()
pygame.display.flip()
class Game:
def __init__(self):
pygame.init()
self.screen_width = 599
self.screen_height = 800
self.screen = pygame.display.set_mode(
(self.screen_width, self.screen_height))
pygame.display.set_caption('Pacman')
self.clock = pygame.time.Clock()
self.WHITE = (255, 255, 255)
self.BLACK = (0, 0, 0)
self.hovered = False
# self.blinky = Ghost(self.screen, self.maze, 'blinky')
#self.ghosts = Group()
# Give files needed to populate the maze
self.expandfile = ExpandFile('test.txt', expandBy=2)
self.maze = Maze(self.screen, 'test.txt', 'images/wall',
'images/foodPellet', 'images/portal_1',
'images/portal_2')
self.player = Pacman(self.screen, self.maze, self.maze.pacmanposition)
self.blinky = Ghost(self.screen, 'blinky', self.maze,
self.maze.blinky_position, self.player)
self.clyde = Ghost(self.screen, 'clyde', self.maze,
self.maze.clyde_position, self.player)
self.inkey = Ghost(self.screen, 'inkey', self.maze,
self.maze.inkey_position, self.player)
self.pinky = Ghost(self.screen, 'pinky', self.maze,
self.maze.pinky_position, self.player)
self.intro_music = pygame.mixer.Sound("sounds/intro.wav")
self.intro_logo = pygame.image.load('images/pacmanLogo.png')
def get_color(self):
if not self.hovered:
return (255, 255, 255)
else:
return (100, 100, 100)
def game_intro(self):
pygame.draw.rect(self.screen, (75, 80, 33),
(0, 0, self.screen_width, self.screen_height))
font = pygame.font.SysFont(None, 50)
self.screen_text = font.render("Play", True, self.get_color())
self.text_rect = self.screen_text.get_rect()
self.screen.blit(self.screen_text, (270, 400))
self.screen.blit(self.intro_logo, (110, 100))
intro = True
while intro:
for event in pygame.event.get():
print(event)
if event.type == pygame.QUIT:
pygame.quit()
quit()
elif event.type == pygame.MOUSEBUTTONDOWN:
pygame.mixer.Sound.play(self.intro_music)
self.play()
pygame.display.update()
def play(self):
eventloop = EventLoop(finished=False)
while not eventloop.finished:
self.clock.tick(30)
eventloop.check_events(self.player)
self.player.update()
self.update_screen()
def update_screen(self):
self.screen.fill(self.BLACK)
self.maze.blitme()
self.player.blitme()
self.blinky.blitme()
self.clyde.blitme()
self.inkey.blitme()
self.pinky.blitme()
# Draw scoreboard
self.player.points_gathered()
pygame.display.flip()
class Game:
BLACK = (0, 0, 0)
def __init__(self):
pygame.init()
pygame.mixer.pre_init(44100, 16, 2, 4096)
self.settings = Settings()
self.settings.start_intro_music()
self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Pacman Portal")
self.clock = pygame.time.Clock()
self.radius = 1
self.start = 1
self.end = 10
self.begin = pygame.time.get_ticks()
self.wait = 800
self.startup = Start(self.screen, self.settings)
self.stats = Stats(self.settings)
self.sb = Scoreboard(self.settings, self.screen, self.stats)
self.maze = Maze(self.screen, mazefile='images/pacman_portal_maze.txt',
brickfile='square', orangeportalfile='portal_orange', blueportalfile='portal_blue',
shieldfile='shield', pointfile='point_pill', gatefile="gate")
self.pacman = Pacman(self.screen, mazefile='images/pacman_portal_maze.txt')
self.red = Red(self.screen, mazefile='images/pacman_portal_maze.txt')
self.blue = Blue(self.screen, mazefile='images/pacman_portal_maze.txt')
self.orange = Orange(self.screen, mazefile='images/pacman_portal_maze.txt')
self.pink = Pink(self.screen, mazefile='images/pacman_portal_maze.txt')
self.inc = 0
def __str__(self): return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def open_portal(self, x, y, color):
for r in range(self.start, self.end):
pygame.gfxdraw.circle(self.screen, x, y, r, color)
now = pygame.time.get_ticks()
if now < self.begin + self.wait:
self.inc = 1
elif now < self.begin + 4 * self.wait:
self.inc = 0
else:
self.inc = -1
self.start += self.inc
self.start = max(1, self.start)
self.end += self.inc
def play(self):
clock = pygame.time.Clock()
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.screen, self.pacman, self.startup)
if self.startup.playing:
pygame.mixer.music.stop()
if not self.settings.flag_chomp:
self.settings.chomp_music()
self.settings.flag_chomp = True
self.settings.chomp_music()
self.pacman.update(self.maze, self.settings, self.stats, self.sb, self.red, self.blue, self.orange,
self.pink)
self.red.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.blue, self.pink,
self.orange, self.sb)
self.blue.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.red, self.pink,
self.orange, self.sb)
self.orange.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.blue,
self.pink, self.red, self.sb)
self.pink.update(self.maze, self.settings, self.stats, self.pacman, self.startup, self.blue, self.red,
self.orange, self.sb)
self.update_screen()
clock.tick(155)
def update_screen(self):
if not self.startup.playing:
self.startup.draw_bg()
self.startup.draw_button()
else:
self.screen.fill(Game.BLACK)
self.maze.blitme()
self.pacman.blitme()
self.red.blitme()
self.blue.blitme()
self.orange.blitme()
self.pink.blitme()
self.open_portal(100, 100, (240, 100, 20))
self.sb.show_score()
pygame.display.flip()
