def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/Pac-Man-Theme-Song.mp3')
self.screen = pygame.display.set_mode((550, 800))
pygame.display.set_caption('PacMan Portal')
self.clock = pygame.time.Clock()
self.score_keeper = ScoreController(
screen=self.screen,
sb_pos=((self.screen.get_width() / 5),
(self.screen.get_height() * 0.965)),
items_image='img/berry.png',
itc_pos=(int(self.screen.get_width() * 0.6),
self.screen.get_height() * 0.965))
self.maze = Maze(self.screen, 'maze.txt')
self.life_counter = Counter(
screen=self.screen,
ct_pos=((self.screen.get_width() // 3),
(self.screen.get_height() * 0.965)),
images_size=(self.maze.block_size, self.maze.block_size))
self.game_over = True
self.player = PacMan(screen=self.screen, maze=self.maze)
self.ghosts = pygame.sprite.Group()
self.ghost_active_interval = 2500
self.ghosts_to_activate = None
self.first_ghost = None
self.other_ghosts = []
self.enemies()
self.actions = {pygame.USEREVENT: self.reset_maze}
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/IDKMAN.wav')
self.screen = pygame.display.set_mode(
(800, 600)
)
pygame.display.set_caption('PacMan Portal')
self.clock = pygame.time.Clock()
self.score_keeper = ScoreController(screen=self.screen,
sb_pos=((self.screen.get_width() // 5),
(self.screen.get_height() * 0.965)),
items_image='cherry.png',
itc_pos=(int(self.screen.get_width() * 0.6),
self.screen.get_height() * 0.965))
self.maze = Maze(screen=self.screen, maze_map_file='maze_map.txt')
self.life_counter = PacManCounter(screen=self.screen, ct_pos=((self.screen.get_width() // 3),
(self.screen.get_height() * 0.965)),
images_size=(self.maze.block_size, self.maze.block_size))
self.level_transition = LevelTransition(screen=self.screen, score_controller=self.score_keeper)
self.game_over = True
self.pause = False
self.player = PacMan(screen=self.screen, maze=self.maze)
self.ghosts = pygame.sprite.Group()
self.ghost_sound_manager = SoundManager(sound_files=['RunForestRun.wav', 'Eaten3.wav', 'babySharkPacman.wav'],
keys=['blue', 'eaten', 'std'],
channel=Ghost.GHOST_AUDIO_CHANNEL)
self.ghost_active_interval = 2500
self.ghosts_to_activate = None
self.first_ghost = None
self.other_ghosts = []
self.spawn_ghosts()
self.actions = {PacManPortalGame.START_EVENT: self.init_ghosts,
PacManPortalGame.REBUILD_EVENT: self.rebuild_maze,
PacManPortalGame.LEVEL_TRANSITION_EVENT: self.next_level}
def test_pacman_PacMan_extra_should_add_1_to_variable(self):
# Arrange
PacMan.extra()
# Act
actual = PacMan.lives
expected = 3
# Assert
self.assertEqual(actual, expected)
def test_pacman_PacMan_die_should_subtract_1_from_variable(self):
# Arrange
PacMan.die()
# Act
actual = PacMan.lives
expected = 2
# Assert
self.assertEqual(actual, expected)
def test_pacman_PacMan_consume_should_add_numbers_to_variable_and_then_multiply_before_adding_again(
self):
# Arrange
PacMan.consume() # should add 200 to score
PacMan.consume() # should add 400 (200*2) to score
# Act
actual = PacMan.points
expected = 5600 # base 5000 + 200 + 400
# Assert
self.assertEqual(actual, expected)
def __init__(self):
pygame.init()
self.tela = model.Tela()
self.pacman = PacMan(tamanho=model.TAMANHO_ATORES,
linha=1,
coluna=1,
eixo_x=model.LARGURA // 2,
eixo_y=model.ALTURA // 2,
velocidade_eixo_x=0,
velocidade_eixo_y=0)
qtd_linhas = 600 // 30
self.cenario = Cenario(tela=self.tela(),
pacman=self.pacman,
tamanho=qtd_linhas)
def test_pacman_PacMan_eat_should_add_number_to_variable(self):
# Arrange
dot = 10
# Act
actual = PacMan.eat(dot)
expected = 5610 # base 5000 + 10 from dot + 600 from next test (not sure why it adds now)
# Assert
self.assertEqual(actual, expected)
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/bg-music.wav')
self.game_screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption('PacMan Portal')
self.tick_component = pygame.time.Clock()
self.hold_score = ScoreController(
screen=self.game_screen,
sb_pos=((self.game_screen.get_width() // 5),
(self.game_screen.get_height() * 0.965)),
items_image='apple.png',
itc_pos=(int(self.game_screen.get_width() * 0.6),
self.game_screen.get_height() * 0.965))
self.map_layout = Maze(screen=self.game_screen,
maze_map_file='maze_map.txt')
self.lives_left = PacManCounter(
screen=self.game_screen,
ct_pos=((self.game_screen.get_width() // 3),
(self.game_screen.get_height() * 0.965)),
images_size=(self.map_layout.block_size,
self.map_layout.block_size))
self.next_level = LevelTransition(screen=self.game_screen,
score_controller=self.hold_score)
self.lost_game = True
self.pause_game = False
self.pacman_player = PacMan(screen=self.game_screen,
maze=self.map_layout)
self.pacman_ghosts = pygame.sprite.Group()
self.pacman_ghosts_sound = SoundManager(
sound_files=['ghost-blue.wav', 'ghost-eaten.wav', 'ghost-std.wav'],
keys=['blue', 'eaten', 'std'],
channel=Ghost.ghost_audio)
self.pacman_ghosts_interval_active = 2500
self.pacman_ghosts_begin_chase = None
self.pacman_ghosts_blinky = None
self.pacman_ghosts_others = []
self.blit_ghosts()
self.game_actions = {
PacManPortalGame.event_start: self.init_ghosts,
PacManPortalGame.event_remake: self.rebuild_maze,
PacManPortalGame.event_next_level: self.next_level
}
def runGame(self):
players = [
PacMan(self.world.pacManCoords, self.pacManSolution),
Ghost(self.world.ghostCoords[0], self.ghostSolution),
Ghost(self.world.ghostCoords[1], self.ghostSolution),
Ghost(self.world.ghostCoords[2], self.ghostSolution)
]
gameRunning = True
won = False
while gameRunning:
oldPlayerCoords = [self.world.pacManCoords
] + self.world.ghostCoords
decisions = []
for player in range(len(players)):
currPlayer = players[player]
validMoves = self.world.validMoves[player]
choice = currPlayer.move(validMoves, self.world)
decisions.append(choice)
self._movePlayers(players, decisions)
self.world.time -= 1
newPlayerCoords = [self.world.pacManCoords
] + self.world.ghostCoords
if self._pacManGhostCollision(oldPlayerCoords, newPlayerCoords):
gameRunning = False
break
self._removePills()
self._removeFruit()
if len(self.world.pillCoords) == 0:
won = True
gameRunning = False
break
if self.world.time == 0:
gameRunning = False
break
self._addFruit(self.world)
self.worldTracker.addSnapshot(self.world)
self.world.validMoves = self.worldTracker.getValidMoves(self.world)
if won and self.world.time != 0:
percentTime = int((self.world.time / self.world.timeStart) * 100)
score = self.world.score + percentTime
self.world.score = score
self.worldTracker.addSnapshot(self.world)
self.score = self.world.score
def game_loop(self):
"""Main loop. """
pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
score = 0
high_score = 0
maze = Maze(self.maze_tiles, HORIZONTAL_TILES, VERTICAL_TILES)
maze.load_level(maze.MAZE)
pac = PacMan(104, 204, self.pacman_tiles)
delta = (0, 0)
while True:
event = pygame.event.poll()
if event.type == pygame.QUIT:
sys.exit(0)
if event.type == pygame.KEYUP:
if event.key == pygame.K_ESCAPE:
sys.exit(0)
pressed = pygame.key.get_pressed()
if pressed[pygame.K_LEFT]:
delta = (-1, 0)
elif pressed[pygame.K_RIGHT]:
delta = (1, 0)
elif pressed[pygame.K_DOWN]:
delta = (0, 1)
elif pressed[pygame.K_UP]:
delta = (0, -1)
x, y = self.screen_to_tile(pac.x, pac.y)
if maze[(x, y)] > 0:
score += 10
maze[(x, y)] = 0
if score > high_score:
high_score = score
if self.legal_move(maze, pac, delta):
pac.delta = delta
elif not self.legal_move(maze, pac, pac.delta):
pac.delta = (0, 0)
pac.move()
maze.draw()
pac.draw()
self.write_message(3, 0, "1UP")
self.write_message(4, 1, str(score))
self.write_message(9, 0, "HIGH SCORE")
self.write_message(10, 1, str(score))
pygame.display.flip()
def prep_pacman(self):
self.pacmen_lives = Group()
x_location = 5
for pacman_number in range(self.pacman_left):
pacman = PacMan(self.screen, self.pacmen, self.ghosts, self.maze,
self)
pacman.change_location(x_location, 5)
x_location += 5
pacman.update()
pacman.rect.x = 10 + pacman_number * pacman.rect.width
pacman.rect.y = 10
self.pacmen_lives.add(pacman)
class Jogo:
def __init__(self):
pygame.init()
self.tela = model.Tela()
self.pacman = PacMan(tamanho=model.TAMANHO_ATORES,
linha=1,
coluna=1,
eixo_x=model.LARGURA // 2,
eixo_y=model.ALTURA // 2,
velocidade_eixo_x=0,
velocidade_eixo_y=0)
qtd_linhas = 600 // 30
self.cenario = Cenario(tela=self.tela(),
pacman=self.pacman,
tamanho=qtd_linhas)
def game_loop(self):
blinky = Fantasma(cor=model.VERMELHO, tamanho=model.TAMANHO_ATORES)
inky = Fantasma(cor=model.CIANO, tamanho=model.TAMANHO_ATORES)
clyde = Fantasma(cor=model.LARANJA, tamanho=model.TAMANHO_ATORES)
pinky = Fantasma(cor=model.ROSA, tamanho=model.TAMANHO_ATORES)
self.cenario.adicionar_ator(self.pacman)
self.cenario.adicionar_ator(blinky)
self.cenario.adicionar_ator(inky)
self.cenario.adicionar_ator(clyde)
self.cenario.adicionar_ator(pinky)
while True:
# Calcular regras
self.cenario.calcular_regras()
blinky.calcular_regras(self.cenario.estado)
inky.calcular_regras(self.cenario.estado)
clyde.calcular_regras(self.cenario.estado)
pinky.calcular_regras(self.cenario.estado)
self.pacman.calcular_regras()
# Pinta
self.tela().fill(model.PRETO)
self.cenario.pintar(self.tela())
self.pacman.pintar(self.tela())
blinky.pintar(self.tela())
inky.pintar(self.tela())
clyde.pintar(self.tela())
pinky.pintar(self.tela())
pygame.display.update()
pygame.time.delay(100)
# Eventos
eventos = pygame.event.get()
self.cenario.processar_eventos(eventos)
self.pacman.processar_eventos(eventos, self.cenario.estado)
def main_game_loop(self):
#Game logic setup
playing = True
game_clock = pygame.time.Clock()
all_sprites_list = pygame.sprite.Group()
#Create all sprites and put them into the sprites list
pacman = PacMan()
blinky = Ghost("blinky", "up", pacman, 50, 0)
clyde = Ghost("clyde", "down", pacman, 100, 0)
inky = Ghost("inky", "up", pacman, 150, 0)
pinky = Ghost("pinky", "down", pacman, 200, 0)
all_sprites_list.add(pacman)
all_sprites_list.add(blinky)
all_sprites_list.add(clyde)
all_sprites_list.add(inky)
all_sprites_list.add(pinky)
while playing:
for game_event in pygame.event.get():
if game_event.type == pygame.QUIT:
playing = False
#Game logic
blinky.ghost_general_presentation()
clyde.ghost_general_presentation()
inky.ghost_general_presentation()
pinky.ghost_general_presentation()
all_sprites_list.update()
#Draw all the sprites at once
all_sprites_list.draw(self.screen)
#Refresh the screen
pygame.display.flip()
#Set the number of frames per second e.g. 60
game_clock.tick(60)
pygame.quit()
import tile from tile import Tile pygame.init() SCREENSIZE=(600,400) screen = pygame.display.set_mode(SCREENSIZE, 0, 32) #FIN INIT #INIT SUPPLEMENTAIRE clock=pygame.time.Clock() background = pygame.surface.Surface(SCREENSIZE).convert() background.fill((0,0,0)) pacman = PacMan((50,50), [500,200]) tile = Tile((150,150), [150,100]) tile2 = Tile((16,16), [300,300]) #GAMELOOP while True: time_passed=clock.tick(30) #framerate du jeu #key_pressed=pygame.key.get_pressed() for event in pygame.event.get(): if event.type == QUIT: exit() pacman.move() pacman.collide(tile)
class PacManPortalGame:
game_color = (0, 0, 0)
event_start = pygame.USEREVENT + 1
event_remake = pygame.USEREVENT + 2
event_next_level = pygame.USEREVENT + 3
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/bg-music.wav')
self.game_screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption('PacMan Portal')
self.tick_component = pygame.time.Clock()
self.hold_score = ScoreController(
screen=self.game_screen,
sb_pos=((self.game_screen.get_width() // 5),
(self.game_screen.get_height() * 0.965)),
items_image='apple.png',
itc_pos=(int(self.game_screen.get_width() * 0.6),
self.game_screen.get_height() * 0.965))
self.map_layout = Maze(screen=self.game_screen,
maze_map_file='maze_map.txt')
self.lives_left = PacManCounter(
screen=self.game_screen,
ct_pos=((self.game_screen.get_width() // 3),
(self.game_screen.get_height() * 0.965)),
images_size=(self.map_layout.block_size,
self.map_layout.block_size))
self.next_level = LevelTransition(screen=self.game_screen,
score_controller=self.hold_score)
self.lost_game = True
self.pause_game = False
self.pacman_player = PacMan(screen=self.game_screen,
maze=self.map_layout)
self.pacman_ghosts = pygame.sprite.Group()
self.pacman_ghosts_sound = SoundManager(
sound_files=['ghost-blue.wav', 'ghost-eaten.wav', 'ghost-std.wav'],
keys=['blue', 'eaten', 'std'],
channel=Ghost.ghost_audio)
self.pacman_ghosts_interval_active = 2500
self.pacman_ghosts_begin_chase = None
self.pacman_ghosts_blinky = None
self.pacman_ghosts_others = []
self.blit_ghosts()
self.game_actions = {
PacManPortalGame.event_start: self.init_ghosts,
PacManPortalGame.event_remake: self.rebuild_maze,
PacManPortalGame.event_next_level: self.next_level
}
def play_game(self):
event_iterator = EventLoop(loop_running=True,
actions={
**self.pacman_player.event_map,
**self.game_actions
})
self.next_level.set_show_transition()
self.lost_game = False
if self.pacman_player.dead:
self.pacman_player.revive()
self.hold_score.reset_level()
self.lives_left.reset_counter()
self.rebuild_maze()
while event_iterator.loop_running:
self.tick_component.tick(60)
event_iterator.check_events()
self.update_screen()
if self.lost_game:
pygame.mixer.stop()
self.hold_score.reset_level()
event_iterator.loop_running = False
def run(self):
play_menu = Menu(self.game_screen)
high_score_menu = HighScoreScreen(self.game_screen, self.hold_score)
intro_ghost_chase = Intro(self.game_screen)
event_iterator = EventLoop(
loop_running=True,
actions={pygame.MOUSEBUTTONDOWN: play_menu.check_buttons})
while event_iterator.loop_running:
self.tick_component.tick(60)
event_iterator.check_events()
self.game_screen.fill(PacManPortalGame.game_color)
if not play_menu.high_score_menu:
intro_ghost_chase.update()
intro_ghost_chase.blit()
play_menu.blit()
else:
high_score_menu.blit()
high_score_menu.check_done()
if play_menu.ready_to_play:
pygame.mixer.music.stop()
self.play_game()
for g in self.pacman_ghosts:
g.reset_speed()
play_menu.ready_to_play = False
self.hold_score.save_high_scores()
high_score_menu.prep_images()
high_score_menu.position()
elif not pygame.mixer.music.get_busy():
pygame.mixer.music.play(-1)
pygame.display.flip()
def init_ghosts(self):
if not self.pacman_ghosts_blinky.state['enabled']:
self.pacman_ghosts_blinky.enable()
self.pacman_ghosts_begin_chase = self.pacman_ghosts_others.copy()
pygame.time.set_timer(PacManPortalGame.event_start, 0)
pygame.time.set_timer(PacManPortalGame.event_start,
self.pacman_ghosts_interval_active)
else:
try:
g = self.pacman_ghosts_begin_chase.pop()
g.enable()
except IndexError:
pygame.time.set_timer(PacManPortalGame.event_start, 0)
def blit_ghosts(self):
ghost_images_file = [
'ghost-pink.png', 'ghost-lblue.png', 'ghost-orange.png',
'ghost-red.png'
]
location = 0
while len(self.map_layout.ghost_spawn) > 0:
spawn_info = self.map_layout.ghost_spawn.pop()
g = Ghost(screen=self.game_screen,
maze=self.map_layout,
target=self.pacman_player,
spawn_info=spawn_info,
ghost_file=ghost_images_file[location],
sound_manager=self.pacman_ghosts_sound)
if ghost_images_file[location] == 'ghost-red.png':
self.pacman_ghosts_blinky = g
else:
self.pacman_ghosts_others.append(g)
self.pacman_ghosts.add(g)
location = (location + 1) % len(ghost_images_file)
def next_level(self):
pygame.time.set_timer(PacManPortalGame.event_next_level, 0)
self.pacman_player.clear_portals()
self.hold_score.increment_level()
self.rebuild_maze()
def rebuild_maze(self):
if self.lives_left.lives > 0:
for g in self.pacman_ghosts:
if g.state['enabled']:
g.disable()
self.map_layout.build_maze()
self.pacman_player.reset_position()
for g in self.pacman_ghosts:
g.reset_position()
if self.pacman_player.dead:
self.pacman_player.revive()
if self.pause_game:
self.pause_game = False
self.next_level.set_show_transition()
else:
self.lost_game = True
pygame.time.set_timer(PacManPortalGame.event_remake, 0)
def check_player(self):
pacman_player_score, pacman_player_fruits, pacman_player_ability = self.pacman_player.eat(
)
self.hold_score.add_score(
score=pacman_player_score,
items=pacman_player_fruits if pacman_player_fruits > 0 else None)
if pacman_player_ability:
for g in self.pacman_ghosts:
g.begin_blue_state()
touch_ghost = pygame.sprite.spritecollideany(self.pacman_player,
self.pacman_ghosts)
if touch_ghost and touch_ghost.state['blue']:
touch_ghost.set_eaten()
self.hold_score.add_score(200)
elif touch_ghost and not (self.pacman_player.dead
or touch_ghost.state['return']):
self.lives_left.decrement()
self.pacman_player.clear_portals()
self.pacman_player.set_death()
for g in self.pacman_ghosts:
if g.state['enabled']:
g.disable()
pygame.time.set_timer(PacManPortalGame.event_start, 0)
pygame.time.set_timer(PacManPortalGame.event_remake, 4000)
elif not self.map_layout.pellets_left() and not self.pause_game:
pygame.mixer.stop()
self.pause_game = True
pygame.time.set_timer(PacManPortalGame.event_next_level, 1000)
def update_screen(self):
if not self.next_level.transition_show:
self.game_screen.fill(PacManPortalGame.game_color)
self.check_player()
self.map_layout.blit()
if not self.pause_game:
self.pacman_ghosts.update()
self.pacman_player.update()
self.map_layout.teleport.check_teleport(
self.pacman_player.rect)
for g in self.pacman_ghosts:
if self.hold_score.level > 3:
if not g.state['speed_boost']:
g.increase_speed()
self.map_layout.teleport.check_teleport(g.rect)
g.blit()
self.pacman_player.blit()
self.hold_score.blit()
self.lives_left.blit()
elif self.pacman_player.dead:
self.pacman_player.update()
self.pacman_player.blit()
else:
self.next_level.draw()
if not self.next_level.transition_show:
self.init_ghosts()
pygame.display.flip()
def __init__(self):
self.nodes = NodeGroup(gridUnit, gridUnit)
self.nodes.createNodeListFromFile("map.txt")
# initialize agents
self.agentRed = Ghost(self.nodes.nodeList[randint(0, 2499)])
self.agentRed.color = (255, 0, 0)
#print self.clyde1.id
self.agentGreen = Ghost(self.nodes.nodeList[randint(0, 2499)])
self.agentGreen.color = (0, 255, 0)
#print self.clyde2.id
self.agentBlue = Ghost(self.nodes.nodeList[randint(0, 2499)])
self.agentBlue.color = (0, 0, 255)
#print self.clyde3.id
self.agentYellow = Ghost(self.nodes.nodeList[randint(0, 2499)])
self.agentYellow.color = (255, 255, 0)
#print self.clyde4.id
self.agentPurple = Ghost(self.nodes.nodeList[randint(0, 2499)])
self.agentPurple.color = (128, 0, 128)
#print self.clyde5.id
# initialize targets
self.targetRed1 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentRed.id)
self.targetRed1.color = (240, 128, 128)
self.targetRed2 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentRed.id)
self.targetRed2.color = (240, 128, 128)
self.targetRed3 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentRed.id)
self.targetRed3.color = (240, 128, 128)
self.targetRed4 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentRed.id)
self.targetRed4.color = (240, 128, 128)
self.targetRed5 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentRed.id)
self.targetRed5.color = (240, 128, 128)
self.targetGreen1 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentGreen.id)
self.targetGreen1.color = (128, 240, 128)
self.targetGreen2 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentGreen.id)
self.targetGreen2.color = (128, 240, 128)
self.targetGreen3 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentGreen.id)
self.targetGreen3.color = (128, 240, 128)
self.targetGreen4 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentGreen.id)
self.targetGreen4.color = (128, 240, 128)
self.targetGreen5 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentGreen.id)
self.targetGreen5.color = (128, 240, 128)
self.targetBlue1 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentBlue.id)
self.targetBlue1.color = (128, 128, 240)
self.targetBlue2 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentBlue.id)
self.targetBlue2.color = (128, 128, 240)
self.targetBlue3 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentBlue.id)
self.targetBlue3.color = (128, 128, 240)
self.targetBlue4 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentBlue.id)
self.targetBlue4.color = (128, 128, 240)
self.targetBlue5 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentBlue.id)
self.targetBlue5.color = (128, 128, 240)
self.targetYellow1 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentYellow.id)
self.targetYellow1.color = (240, 240, 128)
self.targetYellow2 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentYellow.id)
self.targetYellow2.color = (240, 240, 128)
self.targetYellow3 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentYellow.id)
self.targetYellow3.color = (240, 240, 128)
self.targetYellow4 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentYellow.id)
self.targetYellow4.color = (240, 240, 128)
self.targetYellow5 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentYellow.id)
self.targetYellow5.color = (240, 240, 128)
self.targetPurple1 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentPurple.id)
self.targetPurple1.color = (240, 128, 240)
self.targetPurple2 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentPurple.id)
self.targetPurple2.color = (240, 128, 240)
self.targetPurple3 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentPurple.id)
self.targetPurple3.color = (240, 128, 240)
self.targetPurple4 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentPurple.id)
self.targetPurple4.color = (240, 128, 240)
self.targetPurple5 = PacMan(self.nodes.nodeList[randint(0, 2499)],
self.agentPurple.id)
self.targetPurple5.color = (240, 128, 240)
self.Agents = [
self.agentRed, self.agentGreen, self.agentBlue, self.agentYellow,
self.agentPurple
]
self.Targets = [
self.targetRed1, self.targetRed2, self.targetRed3, self.targetRed4,
self.targetRed5, self.targetGreen1, self.targetGreen2,
self.targetGreen3, self.targetGreen4, self.targetGreen5,
self.targetBlue1, self.targetBlue2, self.targetBlue3,
self.targetBlue4, self.targetBlue5, self.targetYellow1,
self.targetYellow2, self.targetYellow3, self.targetYellow4,
self.targetYellow5, self.targetPurple1, self.targetPurple2,
self.targetPurple3, self.targetPurple4, self.targetPurple5
]
#for target in self.Targets:
# print target.owner
self.checkList = []
from pacman import PacMan
from enemy import Enemy
from graph import Graph
CEILSIZE = 30
FPS = 10
if __name__ == "__main__":
pygame.init()
clock = pygame.time.Clock()
game = Game()
while True:
graph = Graph()
enemy = Enemy()
pacman = PacMan()
game.reload()
graph.completeVertex(game)
graph.shortestPath((pacman.positionPacman), (enemy.positionEnemy))
if game.map[0] == 'FileNotFoundError':
height = 15 * CEILSIZE
width = 30 * CEILSIZE
else:
height = len(game.map) * CEILSIZE
width = (len(game.map[0]) - 1) * CEILSIZE
screen = pygame.display.set_mode((width, height))
############### MENU #################
pygame.display.set_caption('PacMan')
def setup_method(self):
self.pacman = PacMan(1, 1)
class TestPacMan:
def setup_method(self):
self.pacman = PacMan(1, 1)
def test_pacman_init__1(self):
""""""
assert self.pacman.pos_x == 1
def test_pacman_init__2(self):
""""""
assert self.pacman.pos_z == 1
def test_pacman_init__3(self):
""""""
assert self.pacman.direction == ""
def test_pacman_init__4(self):
""""""
assert self.pacman.next_direction == ""
def test_pacman_init__5(self):
"""PacMan step must be able to be mulitplied to 1"""
avaiable_step = (1, 0.5, 0.25, 0.2, 0.125, 0.1, 0.0625, 0.05)
assert self.pacman.step in avaiable_step
def test_move1(self):
""""""
self.pacman.direction = 'N'
self.pacman.move()
assert self.pacman.rotate == 0
def test_move2(self):
""""""
pos, self.pacman.direction = self.pacman.pos_z, "N"
self.pacman.move()
assert self.pacman.pos_z == pos - self.pacman.step
def test_move3(self):
""""""
self.pacman.direction = 'S'
self.pacman.move()
assert self.pacman.rotate == 180
def test_move4(self):
""""""
pos, self.pacman.direction = self.pacman.pos_z, "S"
self.pacman.move()
assert self.pacman.pos_z == pos + self.pacman.step
def test_move5(self):
""""""
self.pacman.direction = 'W'
self.pacman.move()
assert self.pacman.rotate == 90
def test_move6(self):
""""""
pos, self.pacman.direction = self.pacman.pos_x, "W"
self.pacman.move()
assert self.pacman.pos_x == pos - self.pacman.step
def test_move7(self):
""""""
self.pacman.direction = 'E'
self.pacman.move()
assert self.pacman.rotate == 270
def test_move8(self):
""""""
pos, self.pacman.direction = self.pacman.pos_x, "E"
self.pacman.move()
assert self.pacman.pos_x == pos + self.pacman.step
if y1 == y2 and (x2 <= x1 <= x2 + CELL_SIZE or x1 <= x2 <= x1 + CELL_SIZE):
return True
elif x1 == x2 and (y2 <= y1 <= y2 + CELL_SIZE
or y1 <= y2 <= y1 + CELL_SIZE):
return True
return False
pygame.init()
sc = pygame.display.set_mode((WIGHT, HEIGHT))
end_image = pygame.image.load('image/end.png').convert_alpha()
pacman1 = PacMan(sc, 4, 27, IMAGE_NAME_PACMAN_1, 2)
pacman2 = PacMan(sc, 47, 4, IMAGE_NAME_PACMAN_2)
red1 = RedBlinky(sc, 5, 4, IMAGE_NAME_RED_GHOST_1)
red2 = RedBlinky(sc, 45, 27, IMAGE_NAME_RED_GHOST_2)
blue1 = BlueInky(sc, 6, 4, IMAGE_NAME_BLUE_GHOST_1)
blue2 = BlueInky(sc, 46, 27, IMAGE_NAME_BLUE_GHOST_2)
pink1 = PinkPinky(sc, 7, 4, IMAGE_NAME_PINK_GHOST_1)
pink2 = PinkPinky(sc, 47, 27, IMAGE_NAME_PINK_GHOST_2)
orange1 = OrangeBlinky(sc, 8, 4, IMAGE_NAME_ORANGE_GHOST_1)
orange2 = OrangeBlinky(sc, 48, 27, IMAGE_NAME_ORANGE_GHOST_2)
pacman1.hp_coord = [0, SPACE]
pacman2.hp_coord = [CELL_SIZE * CELL_WIGHT + SPACE, SPACE]
wall_image = pygame.transform.scale(
pygame.image.load('image/wall.png').convert_alpha(),
NUM_FRAME = 1000000
parser = argparse.ArgumentParser(description="Train and test different networks on Space Invaders")
# Parse arguments
parser.add_argument("-n", "--network", type=str, action='store', help="Please specify the network you wish to use, either DQN or DDQN", required=True)
parser.add_argument("-m", "--mode", type=str, action='store', help="Please specify the mode you wish to run, either train or test", required=True)
parser.add_argument("-l", "--load", type=str, action='store', help="Please specify the file you wish to load weights from(for example saved.h5)", required=False)
parser.add_argument("-s", "--save", type=str, action='store', help="Specify folder to render simulation of network in", required=False)
parser.add_argument("-x", "--statistics", action='store_true', help="Specify to calculate statistics of network(such as average score on game)", required=False)
parser.add_argument("-v", "--view", action='store_true', help="Display the network playing a game of space-invaders. Is overriden by the -s command", required=False)
args = parser.parse_args()
print(args)
game_instance = PacMan(args.network)
if args.load:
game_instance.load_network(args.load)
if args.mode == "train":
game_instance.train(NUM_FRAME)
if args.statistics:
stat = game_instance.calculate_mean()
print("Game Statistics")
print(stat)
if args.save:
import pygame
from pygame.locals import *
from pacman import PacMan
from constants import *
from groups import GhostGroup
from levelnodes import Level1NodesPacMan
from pellets import PelletGroup
from gamecontrol import Observer
pygame.init()
screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
background = pygame.surface.Surface(SCREENSIZE).convert()
background.fill(BLACK)
nodes = Level1NodesPacMan() #similar for level2, 3, 4, etc...
pacman = PacMan(nodes)
clock = pygame.time.Clock()
ghosts = GhostGroup()
pellets = PelletGroup('pellet_map.txt')
pellets.setupPellets()
control = Observer()
while True:
for event in pygame.event.get():
if event.type == QUIT:
exit()
dt = clock.tick(30) / 1000.0
key_pressed = pygame.key.get_pressed()
class PacManPortalGame:
BLACK_BG = (0, 0, 0)
START_EVENT = pygame.USEREVENT + 1
REBUILD_EVENT = pygame.USEREVENT + 2
LEVEL_TRANSITION_EVENT = pygame.USEREVENT + 3
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/bg-music.wav')
self.screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption('PacMan')
self.clock = pygame.time.Clock()
self.score_keeper = ScoreController(
screen=self.screen,
sb_pos=((self.screen.get_width() // 5),
(self.screen.get_height() * 0.965)),
items_image='cherry.png',
itc_pos=(int(self.screen.get_width() * 0.6),
self.screen.get_height() * 0.965))
self.maze = Maze(screen=self.screen, maze_map_file='maze_map.txt')
self.life_counter = PacManCounter(
screen=self.screen,
ct_pos=((self.screen.get_width() // 3),
(self.screen.get_height() * 0.965)),
images_size=(self.maze.block_size, self.maze.block_size))
self.level_transition = LevelTransition(
screen=self.screen, score_controller=self.score_keeper)
self.game_over = True
self.pause = False
self.player = PacMan(screen=self.screen, maze=self.maze)
self.ghosts = pygame.sprite.Group()
self.ghost_sound_manager = SoundManager(
sound_files=['ghost-blue.wav', 'ghost-eaten.wav', 'ghost-std.wav'],
keys=['blue', 'eaten', 'std'],
channel=Ghost.GHOST_AUDIO_CHANNEL)
self.ghost_active_interval = 2500
self.ghosts_to_activate = None
self.first_ghost = None
self.other_ghosts = []
self.spawn_ghosts()
self.actions = {
PacManPortalGame.START_EVENT: self.init_ghosts,
PacManPortalGame.REBUILD_EVENT: self.rebuild_maze,
PacManPortalGame.LEVEL_TRANSITION_EVENT: self.next_level
}
def init_ghosts(self):
if not self.first_ghost.state['enabled']:
self.first_ghost.enable()
self.ghosts_to_activate = self.other_ghosts.copy()
pygame.time.set_timer(PacManPortalGame.START_EVENT,
0) # disable timer repeat
pygame.time.set_timer(PacManPortalGame.START_EVENT,
self.ghost_active_interval)
else:
try:
g = self.ghosts_to_activate.pop()
g.enable()
except IndexError:
pygame.time.set_timer(PacManPortalGame.START_EVENT,
0) # disable timer repeat
def spawn_ghosts(self):
files = [
'ghost-pink.png', 'ghost-lblue.png', 'ghost-orange.png',
'ghost-red.png'
]
idx = 0
while len(self.maze.ghost_spawn) > 0:
spawn_info = self.maze.ghost_spawn.pop()
g = Ghost(screen=self.screen,
maze=self.maze,
target=self.player,
spawn_info=spawn_info,
ghost_file=files[idx],
sound_manager=self.ghost_sound_manager)
if files[idx] == 'ghost-red.png':
self.first_ghost = g # red ghost should be first
else:
self.other_ghosts.append(g)
self.ghosts.add(g)
idx = (idx + 1) % len(files)
def next_level(self):
pygame.time.set_timer(PacManPortalGame.LEVEL_TRANSITION_EVENT, 0)
self.score_keeper.increment_level()
self.rebuild_maze()
def rebuild_maze(self):
if self.life_counter.lives > 0:
for g in self.ghosts:
if g.state['enabled']:
g.disable()
self.maze.build_maze()
self.player.reset_position()
for g in self.ghosts:
g.reset_position()
if self.player.dead:
self.player.revive()
if self.pause:
self.pause = False
self.level_transition.set_show_transition()
else:
self.game_over = True
pygame.time.set_timer(PacManPortalGame.REBUILD_EVENT,
0) # disable timer repeat
def check_player(self):
n_score, n_fruits, power = self.player.eat()
self.score_keeper.add_score(score=n_score,
items=n_fruits if n_fruits > 0 else None)
if power:
for g in self.ghosts:
g.begin_blue_state()
ghost_collide = pygame.sprite.spritecollideany(self.player,
self.ghosts)
if ghost_collide and ghost_collide.state['blue']:
ghost_collide.set_eaten()
self.score_keeper.add_score(200)
elif ghost_collide and not (self.player.dead
or ghost_collide.state['return']):
self.life_counter.decrement()
self.player.set_death()
for g in self.ghosts:
if g.state['enabled']:
g.disable()
pygame.time.set_timer(PacManPortalGame.START_EVENT,
0) # cancel start event
pygame.time.set_timer(PacManPortalGame.REBUILD_EVENT, 4000)
elif not self.maze.pellets_left() and not self.pause:
pygame.mixer.stop()
self.pause = True
pygame.time.set_timer(PacManPortalGame.LEVEL_TRANSITION_EVENT,
1000)
def update_screen(self):
if not self.level_transition.transition_show:
self.screen.fill(PacManPortalGame.BLACK_BG)
self.check_player()
self.maze.blit()
if not self.pause:
self.ghosts.update()
self.player.update()
for g in self.ghosts:
if self.score_keeper.level > 3:
if not g.state['speed_boost']:
g.increase_speed()
g.blit()
self.player.blit()
self.score_keeper.blit()
self.life_counter.blit()
elif self.player.dead:
self.player.update()
self.player.blit()
else:
self.level_transition.draw()
# if transition just finished, init ghosts
if not self.level_transition.transition_show:
self.init_ghosts()
pygame.display.flip()
def run(self):
menu = Menu(self.screen)
hs_screen = HighScoreScreen(self.screen, self.score_keeper)
intro_seq = Intro(self.screen)
e_loop = EventLoop(
loop_running=True,
actions={pygame.MOUSEBUTTONDOWN: menu.check_buttons})
while e_loop.loop_running:
self.clock.tick(60) # 60 fps limit
e_loop.check_events()
self.screen.fill(PacManPortalGame.BLACK_BG)
if not menu.hs_screen:
intro_seq.update() # display intro/menu
intro_seq.blit()
menu.update()
menu.blit()
else:
hs_screen.blit() # display highs score screen
hs_screen.check_done()
if menu.ready_to_play:
pygame.mixer.music.stop() # stop menu music
self.play_game() # player selected play, so run game
for g in self.ghosts:
g.reset_speed()
menu.ready_to_play = False
self.score_keeper.save_high_scores(
) # save high scores only on complete play
hs_screen.prep_images() # update high scores page
hs_screen.position()
elif not pygame.mixer.music.get_busy():
pygame.mixer.music.play(-1) # music loop
pygame.display.flip()
def play_game(self):
e_loop = EventLoop(loop_running=True,
actions={
**self.player.event_map,
**self.actions
})
self.level_transition.set_show_transition()
self.game_over = False
if self.player.dead:
self.player.revive()
self.score_keeper.reset_level()
self.life_counter.reset_counter()
self.rebuild_maze()
while e_loop.loop_running:
self.clock.tick(60) # 60 fps limit
e_loop.check_events()
self.update_screen()
if self.game_over:
pygame.mixer.stop()
self.score_keeper.reset_level()
e_loop.loop_running = False
class Game:
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/Pac-Man-Theme-Song.mp3')
self.screen = pygame.display.set_mode((550, 800))
pygame.display.set_caption('PacMan Portal')
self.clock = pygame.time.Clock()
self.score_keeper = ScoreController(
screen=self.screen,
sb_pos=((self.screen.get_width() / 5),
(self.screen.get_height() * 0.965)),
items_image='img/berry.png',
itc_pos=(int(self.screen.get_width() * 0.6),
self.screen.get_height() * 0.965))
self.maze = Maze(self.screen, 'maze.txt')
self.life_counter = Counter(
screen=self.screen,
ct_pos=((self.screen.get_width() // 3),
(self.screen.get_height() * 0.965)),
images_size=(self.maze.block_size, self.maze.block_size))
self.game_over = True
self.player = PacMan(screen=self.screen, maze=self.maze)
self.ghosts = pygame.sprite.Group()
self.ghost_active_interval = 2500
self.ghosts_to_activate = None
self.first_ghost = None
self.other_ghosts = []
self.enemies()
self.actions = {pygame.USEREVENT: self.reset_maze}
def enemies(self):
types = ['pink', 'cyan', 'red', 'orange']
index = 0
while len(self.maze.ghost_spawn) > 0:
spawn_info = self.maze.ghost_spawn.pop()
g = Ghost(screen=self.screen,
maze=self.maze,
info=spawn_info,
file=types[index])
if types[index] == 'ghost-red.png':
self.first_ghost = g # red ghost should be first
else:
self.other_ghosts.append(g)
self.ghosts.add(g)
index = (index + 1) % len(types)
def reset_maze(self):
if self.life_counter.lives > 0:
pygame.mixer.music.stop()
self.maze.build_maze()
self.player.reset_position()
if self.player.dead:
self.player.revive()
else:
self.game_over = True
def check_player(self):
n_score, n_fruits, power = self.player.collide()
self.score_keeper.add_score(n_score, n_fruits)
if power:
for g in self.ghosts:
g.trigger()
ghost_collide = pygame.sprite.spritecollideany(self.player,
self.ghosts)
if ghost_collide and ghost_collide.kill:
ghost_collide.set_eaten()
self.score_keeper.add_score(200)
elif ghost_collide and not (self.player.dead or ghost_collide.ret):
self.life_counter.decrement()
self.player.set_death()
for g in self.ghosts:
if g.state.on:
g.disable()
def update_screen(self):
if not self.player.dead:
self.screen.fill(Colors().black)
self.check_player()
self.maze.blit()
self.player.update()
for enemy in self.ghosts:
enemy.update()
enemy.blit()
self.player.blit()
self.score_keeper.blit()
self.life_counter.blit()
elif self.player.dead:
self.player.update()
self.player.blit()
pygame.display.flip()
def play(self):
menu = Menu(self.screen)
hs_screen = HighScoreScreen(self.screen, self.score_keeper)
intro_seq = Intro(self.screen)
loop = Events(runs=True, actions={pygame.MOUSEBUTTONDOWN: menu.check})
while loop.runs:
self.clock.tick(60)
loop.check_events()
self.screen.fill((0, 0, 0))
if not menu.hs_screen:
intro_seq.update()
intro_seq.blit()
menu.update()
menu.blit()
else:
hs_screen.blit()
hs_screen.check_done()
if menu.ready_to_play:
pygame.mixer.music.stop()
pygame.mixer.music.load('sounds/waka.wav')
pygame.mixer.music.play()
self.play_game()
menu.ready_to_play = False
self.score_keeper.save_high_scores()
hs_screen.prep_images()
hs_screen.position()
elif not pygame.mixer.music.get_busy():
pygame.mixer.music.play(-1)
pygame.display.flip()
def play_game(self):
loop = Events(True, {**self.player.event_map, **self.actions})
self.game_over = False
if self.player.dead:
self.player.revive()
self.score_keeper.reset_level()
self.life_counter.reset_counter()
self.reset_maze()
while loop.runs:
loop.check_events()
self.update_screen()
if self.game_over:
pygame.mixer.stop()
self.score_keeper.reset_level()
loop.runs = False
class PacManPortalGame:
"""Contains the main logic and methods
for the running and updating of the PacMan portal game"""
BLACK_BG = (0, 0, 0)
START_EVENT = pygame.USEREVENT + 1
REBUILD_EVENT = pygame.USEREVENT + 2
LEVEL_TRANSITION_EVENT = pygame.USEREVENT + 3
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/IDKMAN.wav')
self.screen = pygame.display.set_mode(
(800, 600)
)
pygame.display.set_caption('PacMan Portal')
self.clock = pygame.time.Clock()
self.score_keeper = ScoreController(screen=self.screen,
sb_pos=((self.screen.get_width() // 5),
(self.screen.get_height() * 0.965)),
items_image='cherry.png',
itc_pos=(int(self.screen.get_width() * 0.6),
self.screen.get_height() * 0.965))
self.maze = Maze(screen=self.screen, maze_map_file='maze_map.txt')
self.life_counter = PacManCounter(screen=self.screen, ct_pos=((self.screen.get_width() // 3),
(self.screen.get_height() * 0.965)),
images_size=(self.maze.block_size, self.maze.block_size))
self.level_transition = LevelTransition(screen=self.screen, score_controller=self.score_keeper)
self.game_over = True
self.pause = False
self.player = PacMan(screen=self.screen, maze=self.maze)
self.ghosts = pygame.sprite.Group()
self.ghost_sound_manager = SoundManager(sound_files=['RunForestRun.wav', 'Eaten3.wav', 'babySharkPacman.wav'],
keys=['blue', 'eaten', 'std'],
channel=Ghost.GHOST_AUDIO_CHANNEL)
self.ghost_active_interval = 2500
self.ghosts_to_activate = None
self.first_ghost = None
self.other_ghosts = []
self.spawn_ghosts()
self.actions = {PacManPortalGame.START_EVENT: self.init_ghosts,
PacManPortalGame.REBUILD_EVENT: self.rebuild_maze,
PacManPortalGame.LEVEL_TRANSITION_EVENT: self.next_level}
def init_ghosts(self):
"""kick start the ghost AI over a period of time"""
if not self.first_ghost.state['enabled']:
self.first_ghost.enable()
self.ghosts_to_activate = self.other_ghosts.copy()
pygame.time.set_timer(PacManPortalGame.START_EVENT, 0) # disable timer repeat
pygame.time.set_timer(PacManPortalGame.START_EVENT, self.ghost_active_interval)
else:
try:
g = self.ghosts_to_activate.pop()
g.enable()
except IndexError:
pygame.time.set_timer(PacManPortalGame.START_EVENT, 0) # disable timer repeat
def spawn_ghosts(self):
"""Create all ghosts at their starting positions"""
files = ['ghost-pink.png', 'ghost-lblue.png', 'ghost-orange.png', 'ghost-red.png']
idx = 0
while len(self.maze.ghost_spawn) > 0:
spawn_info = self.maze.ghost_spawn.pop()
g = Ghost(screen=self.screen, maze=self.maze, target=self.player,
spawn_info=spawn_info, ghost_file=files[idx], sound_manager=self.ghost_sound_manager)
if files[idx] == 'ghost-red.png':
self.first_ghost = g # red ghost should be first
else:
self.other_ghosts.append(g)
self.ghosts.add(g)
idx = (idx + 1) % len(files)
def next_level(self):
"""Increment the game level and then continue the game"""
pygame.time.set_timer(PacManPortalGame.LEVEL_TRANSITION_EVENT, 0) # reset timer
self.score_keeper.increment_level()
self.rebuild_maze()
def rebuild_maze(self):
"""Resets the maze to its initial state if the game is still active"""
if self.life_counter.lives > 0:
for g in self.ghosts:
if g.state['enabled']:
g.disable()
self.maze.build_maze()
self.player.reset_position()
for g in self.ghosts:
g.reset_position()
if self.player.dead:
self.player.revive()
if self.pause:
self.pause = False
self.level_transition.set_show_transition()
else:
self.game_over = True
pygame.time.set_timer(PacManPortalGame.REBUILD_EVENT, 0) # disable timer repeat
def check_player(self):
"""Check the player to see if they have been hit by an enemy, or if they have consumed pellets/fruit"""
n_score, n_fruits, power = self.player.eat()
self.score_keeper.add_score(score=n_score, items=n_fruits if n_fruits > 0 else None)
if power:
for g in self.ghosts:
g.begin_blue_state()
ghost_collide = pygame.sprite.spritecollideany(self.player, self.ghosts)
if ghost_collide and ghost_collide.state['blue']:
ghost_collide.set_eaten()
self.score_keeper.add_score(200)
elif ghost_collide and not (self.player.dead or ghost_collide.state['return']):
self.life_counter.decrement()
self.player.set_death()
for g in self.ghosts:
if g.state['enabled']: # disable any ghosts
g.disable()
pygame.time.set_timer(PacManPortalGame.START_EVENT, 0) # cancel start event
pygame.time.set_timer(PacManPortalGame.REBUILD_EVENT, 4000)
elif not self.maze.pellets_left() and not self.pause:
pygame.mixer.stop()
self.pause = True
pygame.time.set_timer(PacManPortalGame.LEVEL_TRANSITION_EVENT, 1000)
def update_screen(self):
"""Update the game screen"""
if not self.level_transition.transition_show:
self.screen.fill(PacManPortalGame.BLACK_BG)
self.check_player()
self.maze.blit()
if not self.pause:
self.ghosts.update()
self.player.update()
# self.maze.teleport.check_teleport(self.player.rect) # teleport player/projectiles
for g in self.ghosts:
if self.score_keeper.level > 3:
if not g.state['speed_boost']:
g.increase_speed()
self.maze.teleport.check_teleport(g.rect) # teleport ghosts
g.blit()
self.player.blit()
self.score_keeper.blit()
self.life_counter.blit()
elif self.player.dead:
self.player.update()
self.player.blit()
else:
self.level_transition.draw()
# if transition just finished, init ghosts
if not self.level_transition.transition_show:
self.init_ghosts()
pygame.display.flip()
def run(self):
"""Run the game application, starting from the menu"""
menu = Menu(self.screen)
hs_screen = HighScoreScreen(self.screen, self.score_keeper)
e_loop = EventLoop(loop_running=True, actions={pygame.MOUSEBUTTONDOWN: menu.check_buttons})
while e_loop.loop_running:
self.clock.tick(60) # 60 fps limit
e_loop.check_events()
self.screen.fill(PacManPortalGame.BLACK_BG)
if not menu.hs_screen:
menu.update()
menu.blit()
else:
hs_screen.blit() # display highs score screen
hs_screen.check_done()
if menu.ready_to_play:
pygame.mixer.music.stop() # stop menu music
self.play_game() # player selected play, so run game
for g in self.ghosts:
g.reset_speed()
menu.ready_to_play = False
self.score_keeper.save_high_scores() # save high scores only on complete play
hs_screen.prep_images() # update high scores page
hs_screen.position()
elif not pygame.mixer.music.get_busy():
pygame.mixer.music.play(-1) # music loop
pygame.display.flip()
def play_game(self):
"""Run the game's event loop, using an EventLoop object"""
e_loop = EventLoop(loop_running=True, actions={**self.player.event_map, **self.actions})
# game init signal
# pygame.time.set_timer(PacManPortalGame.START_EVENT, self.level_transition.transition_time)
self.level_transition.set_show_transition()
self.game_over = False
if self.player.dead:
self.player.revive()
self.score_keeper.reset_level()
self.life_counter.reset_counter()
self.rebuild_maze()
while e_loop.loop_running:
self.clock.tick(60) # 60 fps limit
e_loop.check_events()
self.update_screen()
if self.game_over:
pygame.mixer.stop()
self.score_keeper.reset_level()
e_loop.loop_running = False
