class GameController(object):
def __init__(self):
pygame.init()
pygame.mixer.music.load('sound/pacman_beginning.wav')
pygame.mixer.music.play(-1)
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = None
self.background_flash = None
self.setBackground()
self.clock = pygame.time.Clock()
self.pelletsEaten = 0
self.fruit = None
self.pause = Pauser(True)
self.level = LevelController()
self.text = TextGroup()
self.score = 0
self.gameover = False
self.sheet = Spritesheet()
self.maze = Maze(self.sheet)
self.flashBackground = False
self.eat_sound = pygame.mixer.Sound("sound/pacman_chomp.wav")
self.music_sound = pygame.mixer.Sound("sound/pacman_beginning.wav")
self.death_sound = pygame.mixer.Sound("sound/pacman_death.wav")
self.eatghost_sound = pygame.mixer.Sound("sound/pacman_eatghost.wav")
self.eatfruit_sound = pygame.mixer.Sound("sound/pacman_eatfruit.wav")
self.intermission_sound = pygame.mixer.Sound(
"sound/pacman_intermission.wav")
def setBackground(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background_flash = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
def startGame(self):
print("Start game")
self.level.reset()
levelmap = self.level.getLevel()
self.maze.getMaze(levelmap["name"].split(".")[0])
self.maze.constructMaze(self.background, self.background_flash,
levelmap["row"])
self.nodes = NodeGroup(levelmap["name"])
self.pellets = PelletGroup(levelmap["name"])
self.pacman = Pacman(self.nodes, self.sheet)
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pelletsEaten = 0
self.fruit = None
self.pause.force(True)
self.text.showReady()
self.text.updateLevel(self.level.level + 1)
self.gameover = False
self.maze.reset()
self.flashBackground = False
def startLevel(self):
print("Start new level")
levelmap = self.level.getLevel()
self.setBackground()
self.maze.getMaze(levelmap["name"].split(".")[0])
self.maze.constructMaze(self.background, self.background_flash,
levelmap["row"])
self.nodes = NodeGroup(levelmap["name"])
self.pellets = PelletGroup(levelmap["name"])
self.pacman.nodes = self.nodes
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pelletsEaten = 0
self.fruit = None
self.pause.force(True)
self.text.updateLevel(self.level.level + 1)
self.flashBackground = False
self.maze.reset()
def restartLevel(self):
print("Restart current level")
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pause.force(True)
self.fruit = None
self.flashBackground = False
self.maze.reset()
def update(self):
if not self.gameover:
dt = self.clock.tick(30) / 1000.0
if not self.pause.paused:
self.pacman.update(dt)
self.ghosts.update(dt, self.pacman)
if self.fruit is not None:
self.fruit.update(dt)
if self.pause.pauseType != None:
self.pause.settlePause(self)
self.checkPelletEvents()
self.checkGhostEvents()
self.checkFruitEvents()
else:
if self.flashBackground:
self.maze.flash(dt)
if self.pacman.animateDeath:
self.pacman.updateDeath(dt)
self.pause.update(dt)
self.pellets.update(dt)
self.text.update(dt)
self.checkEvents()
self.text.updateScore(self.score)
self.render()
def checkEvents(self):
for event in pygame.event.get():
if event.type == QUIT:
exit()
elif event.type == KEYDOWN:
if event.key == K_SPACE:
if self.gameover:
self.startGame()
else:
self.pause.player()
if self.pause.paused:
pygame.mixer.music.pause()
self.text.showPause()
else:
self.text.hideMessages()
pygame.mixer.music.unpause()
def checkPelletEvents(self):
pellet = self.pacman.eatPellets(self.pellets.pelletList)
if pellet:
pygame.mixer.music.pause()
pygame.mixer.Sound.play(self.eat_sound)
pygame.mixer.music.unpause()
self.pelletsEaten += 1
self.score += pellet.points
if (self.pelletsEaten == 70 or self.pelletsEaten == 140):
if self.fruit is None:
levelmap = self.level.getLevel()
self.fruit = Fruit(self.nodes, self.sheet,
levelmap["fruit"])
self.pellets.pelletList.remove(pellet)
if pellet.name == "powerpellet":
self.ghosts.resetPoints()
self.ghosts.freightMode()
if self.pellets.isEmpty():
self.pacman.visible = False
self.ghosts.hide()
self.pause.startTimer(3, "clear")
self.flashBackground = True
def checkGhostEvents(self):
self.ghosts.release(self.pelletsEaten)
ghost = self.pacman.eatGhost(self.ghosts)
if ghost is not None:
if ghost.mode.name == "FREIGHT":
pygame.mixer.music.pause()
pygame.mixer.Sound.play(self.eatghost_sound)
pygame.mixer.music.unpause()
self.ghosts.updatePoints()
ghost.spawnMode(speed=2)
self.pause.startTimer(1)
self.pacman.visible = False
ghost.visible = False
elif ghost.mode.name != "SPAWN":
self.pacman.loseLife()
self.ghosts.hide()
self.pause.startTimer(3, "die")
def checkFruitEvents(self):
if self.fruit is not None:
if self.pacman.eatFruit(self.fruit):
pygame.mixer.music.pause()
pygame.mixer.Sound.play(self.eatfruit_sound)
pygame.mixer.music.unpause()
self.score += self.fruit.points
self.text.createTemp(self.fruit.points, self.fruit.position)
self.fruit = None
elif self.fruit.destroy:
self.fruit = None
def resolveDeath(self):
if self.pacman.lives == 0:
self.gameover = True
self.pacman.visible = False
self.text.showGameOver()
#pygame.mixer.music.pause()
#pygame.mixer.Sound.play(self.death_sound)
pygame.mixer.music.stop()
else:
pygame.mixer.music.pause()
pygame.mixer.Sound.play(self.death_sound)
pygame.mixer.music.unpause()
self.restartLevel()
self.pause.pauseType = None
def resolveLevelClear(self):
pygame.mixer.music.pause()
self.level.nextLevel()
self.startLevel()
pygame.mixer.music.unpause()
self.pause.pauseType = None
def render(self):
self.screen.blit(self.maze.background, (0, 0))
#self.nodes.render(self.screen)
self.pellets.render(self.screen)
if self.fruit is not None:
self.fruit.render(self.screen)
self.pacman.render(self.screen)
self.ghosts.render(self.screen)
self.pacman.renderLives(self.screen)
self.text.render(self.screen)
pygame.display.update()
class GameController(object):
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = None
self.setBackground()
self.clock = pygame.time.Clock()
self.hiscore = 0
self.hiscoreLabel = Text(str(self.hiscore).zfill(8), WHITE, 0, 16, 16)
self.level = 1
self.levelLabel = Text(str(self.level).zfill(2), WHITE, 368, 16, 16)
self.sheet = Spritesheet()
self.maze = Maze(self.sheet)
self.trophies = FruitTrophy()
self.startLabel = Text("START!", RED, 190, 320, 16)
self.pauseLabel = Text("PAUSED!", RED, 180, 320, 16)
self.started = False
self.pausedByPlayer = False
self.pauseTime = 0
self.timer = 0
self.nextLevelAfterPause = False
self.startAfterPause = False
self.restartAfterPause = False
self.flash_background = False
self.flash_rate = 0.2
self.flashtime = 0
self.show_white_background = False
self.ghost_score = None
self.fruit_score = None
self.gameover = False
def setBackground(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background_white = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
def startGame(self):
print("Restarting the game")
self.maze.setup(self.level)
self.nodes = NodeGroup(self.maze.filename + ".txt")
self.pellets = PelletGroup(self.maze.filename + ".txt")
self.pacman = Pacman(self.nodes, self.sheet)
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.paused = True
self.fruit = None
self.pelletsEaten = 0
self.lifeIcons = LifeIcon(self.sheet)
self.maze.stitchMaze(self.background, self.background_white)
self.hiScoreTxtStatic = Text("HI SCORE", WHITE, 0, 0, 16)
self.scoreTxtStatic = Text("SCORE", WHITE, 208, 0, 16)
self.levelTxtStatic = Text("LEVEL", WHITE, 368, 0, 16)
self.score = 0
self.scoreLabel = Text(str(self.score).zfill(8), WHITE, 208, 16, 16)
self.started = False
self.pausedByPlayer = False
self.pauseTime = 0
self.timer = 0
self.nextLevelAfterPause = False
self.startAfterPause = False
self.restartAfterPause = False
self.flash_background = False
self.flash_rate = 0.2
self.flashtime = 0
self.show_white_background = False
self.gameover = False
self.level = 1 #####
def restartLevel(self):
print("Restarting the level")
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.paused = True
self.started = False
self.pausedByPlayer = False
self.fruit = None
self.pauseTime = 0
self.timer = 0
self.nextLevelAfterPause = False
self.startAfterPause = False
self.restartAfterPause = False
self.gameover = False
self.flash_background = False
self.flash_rate = 0.2
self.flashtime = 0
self.show_white_background = False
def nextLevel(self):
self.setBackground() ###
self.level += 1
self.maze.setup(self.level)
self.nodes = NodeGroup(self.maze.filename + ".txt")
self.pellets = PelletGroup(self.maze.filename + ".txt")
self.pacman.updateNodes(self.nodes)
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.paused = True
self.started = False
self.pausedByPlayer = False
self.fruit = None
self.pelletsEaten = 0
self.lifeIcons = LifeIcon(self.sheet)
self.maze.stitchMaze(self.background, self.background_white)
self.pellets = PelletGroup(self.maze.filename + ".txt")
self.levelLabel.updateText(str(self.level).zfill(2))
self.pauseTime = 0
self.timer = 0
self.nextLevelAfterPause = False
self.startAfterPause = False
self.restartAfterPause = False
self.gameover = False
self.flash_background = False
self.flash_rate = 0.2
self.flashtime = 0
self.show_white_background = False
def update(self):
dt = self.clock.tick(30) / 1000.0
self.pellets.update(dt)
if not self.paused:
self.pacman.update(dt)
self.ghosts.update(dt, self.pacman)
if self.fruit is not None:
self.fruit.update(dt)
else:
if not self.pacman.alive:
print("death sequence")
self.pacman.updateAnimation(dt)
self.checkEvents()
if self.pauseTime > 0:
self.paused = True
self.timer += dt
if self.timer >= self.pauseTime:
self.paused = False
self.pauseTime = 0
self.timer = 0
self.ghost_score = None
if self.nextLevelAfterPause:
self.nextLevel()
if self.startAfterPause:
self.startGame()
if self.restartAfterPause:
self.restartLevel()
if self.flash_background:
self.flashtime += dt
if self.flashtime >= self.flash_rate:
self.flashtime = 0
self.show_white_background = not self.show_white_background
if self.fruit_score is not None:
self.fruit_score.update(dt)
if self.fruit_score.hide:
self.fruit_score = None
self.render()
def checkEvents(self):
for event in pygame.event.get():
if event.type == QUIT:
exit()
elif event.type == KEYDOWN:
if event.key == K_SPACE:
self.started = True
self.paused = not self.paused
self.pausedByPlayer = self.paused
if not self.paused:
self.checkPelletEvents()
self.checkGhostEvents()
self.checkFruitEvents()
def checkPelletEvents(self):
pellet = self.pacman.eatPellets(self.pellets.pelletList)
if pellet:
self.pelletsEaten += 1
self.updateScores(pellet.points)
self.ghosts.resetPoints()
if (self.pelletsEaten == 70 or self.pelletsEaten == 140):
if self.fruit is None:
self.fruit = Fruit(self.nodes, self.sheet, self.level)
self.pellets.pelletList.remove(pellet)
if pellet.name == "powerpellet":
self.ghosts.freightMode()
if self.pellets.isEmpty():
self.pauseTime = 3
self.nextLevelAfterPause = True
self.flash_background = True
def checkGhostEvents(self):
self.ghosts.release(self.pelletsEaten)
ghost = self.pacman.eatGhost(self.ghosts)
if ghost is not None:
if ghost.mode.name == "FREIGHT":
self.pauseTime = 0.5
self.ghost_score = Text(str(self.ghosts.points), WHITE,
ghost.position.x, ghost.position.y, 8)
ghost.spawnMode()
self.updateScores(self.ghosts.points)
self.ghosts.doublePoints()
elif ghost.mode.name != "SPAWN":
self.pacman.alive = False
self.paused = True
self.pauseTime = 2
self.pacman.decreaseLives()
self.gameover = self.pacman.lives == 0
if self.gameover:
print("All of Pacmans lives are gone")
self.startAfterPause = True
else:
print("Lost a life, but still going")
self.restartAfterPause = True
def checkFruitEvents(self):
if self.fruit is not None:
if self.pacman.eatFruit(self.fruit):
self.updateScores(self.fruit.points)
self.trophies.add(self.fruit.name, self.fruit.collect())
self.fruit_score = Text(str(self.fruit.points), WHITE,
self.fruit.position.x,
self.fruit.position.y, 8)
self.fruit_score.lifespan = 1
self.fruit = None
else:
if self.fruit.killme:
self.fruit = None
def updateScores(self, value):
self.score += value
self.scoreLabel.updateText(str(self.score).zfill(8))
if self.score > self.hiscore:
self.hiscore = self.score
self.hiscoreLabel.updateText(str(self.hiscore).zfill(8))
def render(self):
if self.show_white_background:
self.screen.blit(self.background_white, (0, 0))
else:
self.screen.blit(self.background, (0, 0))
self.nodes.render(self.screen)
self.pellets.render(self.screen)
if self.fruit is not None:
self.fruit.render(self.screen)
if not self.paused or not self.started:
self.pacman.render(self.screen)
self.ghosts.render(self.screen)
self.lifeIcons.render(self.screen, self.pacman.lives - 1)
self.hiScoreTxtStatic.render(self.screen)
self.scoreTxtStatic.render(self.screen)
self.levelTxtStatic.render(self.screen)
self.scoreLabel.render(self.screen)
self.hiscoreLabel.render(self.screen)
self.levelLabel.render(self.screen)
self.trophies.render(self.screen)
if self.pausedByPlayer:
self.pauseLabel.render(self.screen)
if not self.started:
self.startLabel.render(self.screen)
if self.ghost_score is not None:
self.ghost_score.render(self.screen)
if self.fruit_score is not None:
self.fruit_score.render(self.screen)
if self.paused and not self.pacman.alive:
self.pacman.render(self.screen)
pygame.display.update()
class GameMain(Game):
def __init__(self):
super().__init__()
# Snake settings
self.snake = Snake(self.screen)
# Snake bots settings
self.snake_bot = SnakeBot(self.screen)
self.snake_bot_2 = SnakeBot(self.screen)
# Fruits settings
self.fruit = Fruit(self.screen)
def run_game(self):
""" Main game loop """
while not self.game_over:
# Sets speed of the snake
self.FPS.tick(10)
# Check keyboard events
self.check_events()
# Checks for some kind of collision
self.check_collisions()
self.snake.move()
# Starting AI bot
self.snake_bot.initialize()
self.snake_bot_2.initialize()
# Renders everything
self.render_everything()
pygame.display.update()
def check_events(self, move=True):
""" Function that checks events coming from the keyboard """
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game_over = True
break
# Direction controls
if move:
self.snake.user_move(event)
def check_collisions(self):
""" Function that collects all collision checks """
# Collision with itself
if self.snake.collision_with_itself():
self.game_over = True
# check if one of the boats ate the fruit
if self.snake.collision_with_bot(
self.snake_bot) or self.snake.collision_with_bot(
self.snake_bot_2):
self.game_over = True
# Check collision with boundaries
if self.snake.collision_with_boundaries():
self.game_over = True
# Collision with a fruit
if self.snake.eat_fruit(self.fruit):
self.snake.grow_up(self.fruit)
# Collision bots with a fruit
if self.snake_bot.eat_fruit(self.fruit) or self.snake_bot_2.eat_fruit(
self.fruit):
self.snake_bot.grow_up(self.fruit)
self.snake_bot_2.grow_up(self.fruit)
if self.snake.growing_up % 5 == 0:
self.snake_bot.grow_up(self.fruit)
self.snake_bot_2.grow_up(self.fruit)
self.snake.growing_up = 1
if self.game_over:
print(self.snake.points)
new_screen = GameOver(self.snake.points)
new_screen.run_game()
def render_everything(self):
""" Function that brings together all renderings """
self.screen.fill((0, 0, 0))
self.fruit.render()
self.snake.render()
self.snake_bot.render()
self.snake_bot_2.render()
class GameController(object):
#general activation
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = None
self.setBackground()
self.clock = pygame.time.Clock()
self.pelletsEaten = 0
self.fruit = None
self.pause = Pauser(True)
self.level = LevelController()
self.text = TextGroup()
self.sheet = Spritesheet()
self.maze = Maze(self.sheet)
def setBackground(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
def startGame(self):
#Sets up the game
self.level.reset()
levelmap = self.level.getLevel()
self.maze.getMaze(levelmap["mazename"].split(".")[0])
self.maze.constructMaze(self.background)
self.nodes = NodeGroup(levelmap["mazename"])
self.pellets = PelletGroup(levelmap["pelletname"])
self.pacman = Pacman(self.nodes, self.sheet)
#self.ghosts = GhostGroup(self.nodes, self.sheet) Ghost command, removed to get rid of ghosts
self.pelletsEaten = 0
self.fruit = None
self.pause.force(False) #Was True, set to false for automatic start
self.gameover = False
self.score = 0
#self.text.showReady() #Removed, so that we don't have Ready permanently on screen
#self.text.updateLevel(self.level.level+1) #Removed to start same level each time
def startLevel(self):
#Begins the given level
levelmap = self.level.getLevel()
self.setBackground()
self.nodes = NodeGroup(levelmap["mazename"])
self.pellets = PelletGroup(levelmap["pelletname"])
self.pacman.nodes = self.nodes
self.pacman.reset()
#self.ghosts = GhostGroup(self.nodes, self.sheet) Ghost command, removed to get rid of ghosts
self.pelletsEaten = 0
self.fruit = None
self.pause.force(True)
self.text.showReady()
self.text.updateLevel(self.level.level + 1)
def restartLevel(self):
#Restarts the game.
self.pacman.reset()
#self.ghosts = GhostGroup(self.nodes, self.sheet) Ghost command, removed to get rid of ghosts
self.fruit = None
self.pause.force(True)
self.text.showReady()
def update(self):
#Where the game instances are run
if not self.gameover:
dt = self.clock.tick(300) / 300.0
# CHANGE TIME ( clock.tick( refresh rate ) / speed (lower number, higher speed)
if not self.pause.paused:
self.pacman.update(dt)
#self.ghosts.update(dt, self.pacman) Stopper spøgelser med at opdaterer
if self.fruit is not None:
self.fruit.update(dt)
if self.pause.pauseType != None:
self.pause.settlePause(self)
self.checkPelletEvents()
#self.checkGhostEvents() Ghost command, removed to get rid of ghosts
self.checkFruitEvents()
self.pause.update(dt)
self.pellets.update(dt)
self.text.update(dt)
self.checkEvents()
self.text.updateScore(self.score)
self.render()
def checkEvents(self):
#Simple commands while in game
for event in pygame.event.get():
if event.type == QUIT:
exit()
elif self.gameover:
self.startGame()
#Spacebar is removed, and instead game just restarts automatically
#elif event.type == KEYDOWN:
# if event.key == K_SPACE:
# if self.gameover:
# self.startGame()
# else:
# self.pause.player()
# if self.pause.paused:
# self.text.showPause()
# else:
# self.text.hideMessages()
def checkPelletEvents(self):
#This section is in charge of checking if Pacman is on a pellet.
pellet = self.pacman.eatPellets(self.pellets.pelletList)
if pellet:
self.pelletsEaten += 1
self.score += pellet.points
if (self.pelletsEaten == 70 or self.pelletsEaten == 140):
if self.fruit is None:
self.fruit = Fruit(self.nodes, self.sheet)
self.pellets.pelletList.remove(pellet)
if pellet.name == "powerpellet":
pass
#self.ghosts.resetPoints() Ghost command, removed to get rid of ghosts
#self.ghosts.freightMode() Ghost command, removed to get rid of ghosts
if self.pellets.isEmpty():
self.pacman.visible = False
#self.ghosts.hide() Ghost command, removed to get rid of ghosts
self.pause.startTimer(
0.1, "clear"
) #Used to be 3, has been set to 0.1. No reset timer.
def checkGhostEvents(self):
#In charge of ghosts
self.ghosts.release(self.pelletsEaten)
ghost = self.pacman.eatGhost(self.ghosts)
if ghost is not None:
if ghost.mode.name == "FREIGHT":
self.score += ghost.points
self.text.createTemp(ghost.points, ghost.position)
self.ghosts.updatePoints()
ghost.spawnMode(speed=2)
self.pause.startTimer(1)
self.pacman.visible = False
ghost.visible = False
elif ghost.mode.name == "CHASE" or ghost.mode.name == "SCATTER":
self.pacman.loseLife()
self.ghosts.hide()
self.pause.startTimer(
0.1, "die") #Death timer, set to 0 to optimize time.
def checkFruitEvents(self):
#basically in charge of fruits, in same way as above.
if self.fruit is not None:
if self.pacman.eatFruit(self.fruit):
self.score += self.fruit.points
self.text.createTemp(self.fruit.points, self.fruit.position)
self.fruit = None
elif self.fruit.destroy:
self.fruit = None
#if self.pacman.eatFruit(self.fruit) or self.fruit.destroy:
#self.fruit = None
def resolveDeath(self):
#Checks if the game needs to end by keeping track of death tol
if self.pacman.lives == 0:
self.gameover = False #This should be true, but has been changed to remove lives from the game
else:
self.restartLevel()
self.pause.pauseType = None
def resolveLevelClear(self):
#self.level.nextLevel()
#self.startLevel()
self.startGame()
self.pause.pauseType = None
def render(self):
#In charge of rendering all characters, ghosts, pellets, ghosts etc...
self.screen.blit(self.background, (0, 0))
#self.nodes.render(self.screen) (Not my doing)
self.pellets.render(self.screen)
if self.fruit is not None:
self.fruit.render(self.screen)
self.pacman.render(self.screen)
#self.ghosts.render(self.screen) Ghost command, removed to get rid of ghosts
self.pacman.renderLives(self.screen)
self.text.render(self.screen)
pygame.display.update()
class GameController(object):
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = None
self.background_flash = None
self.setBackground()
self.clock = pygame.time.Clock()
self.pelletsEaten = 0
self.fruit = None
self.pause = Pauser(True)
self.text = TextGroup()
self.score = 0
self.gameover = False
self.sheet = Spritesheet()
self.maze = Maze(self.sheet)
self.flashBackground = False
self.portal = None
self.portal2 = None
self.portal3 = None
self.portal4 = None
self.level = LevelController()
self.mainScreen = True
self.gameScreen = False
self.hsScreen = False
self.eat_sound = pygame.mixer.Sound("pacman_chomp.wav")
self.main_menu_sound = pygame.mixer.Sound("pacman_intermission.wav")
self.beginning_sound = pygame.mixer.Sound("pacman_beginning.wav")
self.eat_fruit = pygame.mixer.Sound("pacman_eatfruit.wav")
self.eat_ghost = pygame.mixer.Sound("pacman_eatghost.wav")
self.death_sound = pygame.mixer.Sound("pacman_death.wav")
def setBackground(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background_flash = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
def startGame(self):
print("Start game")
self.level.reset()
self.maze.getMaze("maze")
self.maze.constructMaze(self.background, self.background_flash, 0)
self.nodes = NodeGroup("maze.txt")
self.pellets = PelletGroup("maze.txt")
self.pacman = Pacman(self.nodes, self.sheet)
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pelletsEaten = 0
self.fruit = None
self.pause.force(True)
self.text.showReady()
self.gameover = False
self.maze.reset()
self.flashBackground = False
self.text.updateLevel(self.level.level + 1)
self.portal = None
self.portal2 = None
self.portal3 = None
self.portal4 = None
def startLevel(self):
print("Start game")
self.setBackground()
self.maze.getMaze("maze")
self.maze.constructMaze(self.background, self.background_flash, 0)
self.nodes = NodeGroup("maze.txt")
self.pellets = PelletGroup("maze.txt")
self.pacman.nodes = self.nodes
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pelletsEaten = 0
self.text.updateLevel(self.level.level+1)
self.fruit = None
self.pause.force(True)
self.flashBackground = False
self.maze.reset()
self.portal = None
self.portal2 = None
self.portal3 = None
self.portal4 = None
def resolveLevelClear(self):
self.level.nextLevel()
self.startLevel()
self.pause.pauseType = None
def restartLevel(self):
print("Restart game")
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pause.force(True)
self.fruit = None
self.flashBackground = False
self.maze.reset()
# self.portal = None # commented so portals dont disappear on reset/death
# self.portal2 = None
# self.portal3 = None
# self.portal4 = None
def update(self):
if not self.gameover:
dt = self.clock.tick(30) / 1000.0
if not self.pause.paused:
self.pacman.update(dt)
self.ghosts.update(dt, self.pacman)
if self.fruit is not None:
self.fruit.update(dt)
if self.portal is not None:
self.portal.update(dt)
self.portal2.update(dt)
if self.portal3 is not None:
self.portal3.update(dt)
self.portal4.update(dt)
if self.pause.pauseType != None:
self.pause.settlePause(self)
self.checkPelletEvents()
self.checkGhostEvents()
self.checkFruitEvents()
self.checkPortalEvents()
else:
if self.flashBackground:
self.maze.flash(dt)
if self.pacman.animateDeath:
self.pacman.updateDeath(dt)
self.pause.update(dt)
self.pellets.update(dt)
self.text.update(dt)
self.checkEvents()
self.text.updateScore(self.score)
self.render()
def checkEvents(self):
for event in pygame.event.get():
if event.type == QUIT:
if self.score > 0:
with open("high_scores.txt", 'a') as f:
f.write(f'Highscore was {game.score}\n')
exit()
elif event.type == KEYDOWN:
if event.key == K_SPACE:
if self.gameover:
self.startGame()
else:
self.pause.player()
if self.pause.paused:
self.text.showPause()
else:
self.text.hideMessages()
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
if self.play_button.rect.collidepoint(mouse_x, mouse_y):
self.mainScreen = False
self.gameScreen = True
elif self.score_button.rect.collidepoint(mouse_x, mouse_y):
self.mainScreen = False
self.hsScreen = True
elif self.back_button.rect.collidepoint(mouse_x, mouse_y):
self.mainScreen = True
self.hsScreen = False
def checkPelletEvents(self):
pellet = self.pacman.eatPellets(self.pellets.pelletList)
if pellet:
self.eat_sound.set_volume(0.2)
self.eat_sound.play()
self.pelletsEaten += 1
self.score += pellet.points
if self.pelletsEaten == 25 or self.pelletsEaten == 150:
if self.fruit is None:
self.fruit = Fruit(self.nodes, self.sheet, "cherry")
if self.pelletsEaten == 75:
if self.portal is None:
self.portal = Portal(self.nodes, self.sheet)
if self.portal2 is None:
self.portal2 = Portal(self.nodes, self.sheet)
if self.pelletsEaten == 125:
if self.portal3 is None:
self.portal3 = Portal2(self.nodes, self.sheet)
if self.portal4 is None:
self.portal4 = Portal2(self.nodes, self.sheet)
self.pellets.pelletList.remove(pellet)
if pellet.name == "powerpellet":
self.ghosts.resetPoints()
self.ghosts.freightMode()
if self.pellets.isEmpty():
self.pacman.visible = False
self.ghosts.hide()
self.pause.startTimer(3, "clear")
self.flashBackground = True
def checkGhostEvents(self):
self.ghosts.release(self.pelletsEaten)
ghost = self.pacman.eatGhost(self.ghosts)
if ghost is not None:
if ghost.mode.name == "FREIGHT":
self.eat_ghost.set_volume(0.2)
self.eat_ghost.play()
self.score += ghost.points
self.text.createTemp(ghost.points, ghost.position)
self.ghosts.updatePoints()
ghost.spawnMode(speed=2)
self.pause.startTimer(1)
self.pacman.visible = False
ghost.visible = False
elif ghost.mode.name != "SPAWN":
self.death_sound.set_volume(0.2)
self.death_sound.play()
self.pacman.loseLife()
self.ghosts.hide()
self.pause.startTimer(3, "die")
def checkFruitEvents(self):
if self.fruit is not None:
if self.pacman.eatFruit(self.fruit):
self.eat_fruit.set_volume(0.2)
self.eat_fruit.play()
self.score += self.fruit.points
self.text.createTemp(self.fruit.points, self.fruit.position)
self.fruit = None
elif self.fruit.destroy:
self.fruit = None
def checkPortalEvents(self):
if self.portal is not None:
if self.pacman.enterPortal(self.portal):
b = self.nodes.getNode(19*TILEWIDTH, 4*TILEHEIGHT, self.nodes.nodeList)
self.pacman.node = b
self.pacman.setPosition()
self.pacman.direction = STOP
elif self.portal.destroy:
self.portal = None
if self.portal2 is not None:
if self.pacman.enterPortal(self.portal2):
b = self.nodes.getNode(3*TILEWIDTH, 32*TILEHEIGHT, self.nodes.nodeList)
self.pacman.node = b
self.pacman.setPosition()
self.pacman.direction = STOP
elif self.portal2.destroy:
self.portal2 = None
if self.portal3 is not None:
if self.pacman.enterPortal(self.portal3):
b = self.nodes.getNode(21*TILEWIDTH, 32*TILEHEIGHT, self.nodes.nodeList)
self.pacman.node = b
self.pacman.setPosition()
self.pacman.direction = STOP
elif self.portal3.destroy:
self.portal3 = None
if self.portal4 is not None:
if self.pacman.enterPortal(self.portal4):
b = self.nodes.getNode(5*TILEWIDTH, 4*TILEHEIGHT, self.nodes.nodeList)
self.pacman.node = b
self.pacman.setPosition()
self.pacman.direction = STOP
elif self.portal4.destroy:
self.portal4 = None
def resolveDeath(self):
if self.pacman.lives == 0:
self.gameover = True
self.pacman.visible = False
self.text.showGameOver()
else:
self.restartLevel()
self.pause.pauseType = None
def render(self):
self.screen.blit(self.maze.background, (0,0))
#self.nodes.render(self.screen)
self.pellets.render(self.screen)
if self.fruit is not None:
self.fruit.render(self.screen)
if self.portal is not None:
self.portal.render(self.screen)
if self.portal2 is not None:
self.portal2.render(self.screen)
if self.portal3 is not None:
self.portal3.render(self.screen)
if self.portal4 is not None:
self.portal4.render(self.screen)
self.pacman.render(self.screen)
self.ghosts.render(self.screen)
self.pacman.renderLives(self.screen)
self.text.render(self.screen)
pygame.display.update()
def main_screen_ani(self, current_time):
if current_time <= 0.5:
self.screen.blit(self.sheet.getImage(4, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
elif 0.5 < current_time <= 1:
self.screen.blit(self.sheet.getImage(1, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (3*TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
elif 1 < current_time <= 1.5:
self.screen.blit(self.sheet.getImage(1, 1, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
elif 1.5 < current_time <= 2:
self.screen.blit(self.sheet.getImage(1, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
self.screen.blit(self.sheet.getImage(6, 2, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 2 < current_time <= 2.5:
self.screen.blit(self.sheet.getImage(4, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (12 * TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
self.screen.blit(self.sheet.getImage(6, 2, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 3, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 2.5 < current_time <= 3:
self.screen.blit(self.sheet.getImage(1, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (15 * TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
self.screen.blit(self.sheet.getImage(6, 2, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 3, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 4, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 3 < current_time <= 3.5:
self.screen.blit(self.sheet.getImage(1, 1, TILEWIDTH * 2, TILEHEIGHT * 2), (18 * TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
self.screen.blit(self.sheet.getImage(6, 2, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 3, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 4, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 5, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 3.5 < current_time <= 4:
self.screen.blit(self.sheet.getImage(1, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (21 * TILEWIDTH, 18 * TILEHEIGHT))
pygame.draw.circle(self.screen, WHITE, (25 * TILEWIDTH, 19.2 * TILEHEIGHT), 8)
self.screen.blit(self.sheet.getImage(6, 2, TILEWIDTH * 2, TILEHEIGHT * 2), (12 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 3, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 4, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 5, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
elif 4 < current_time <= 4.5:
self.screen.blit(self.sheet.getImage(4, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (23 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 2, TILEWIDTH * 2, TILEHEIGHT * 2), (15 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 3, TILEWIDTH * 2, TILEHEIGHT * 2), (12 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 4, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(6, 5, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
elif 4.5 < current_time <= 5:
self.screen.blit(self.sheet.getImage(0, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (23 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (15 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (12 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
elif 5 < current_time <= 5.5:
self.screen.blit(self.sheet.getImage(0, 1, TILEWIDTH * 2, TILEHEIGHT * 2), (21 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (12 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
elif 5.5 < current_time <= 6:
self.screen.blit(self.sheet.getImage(0, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (18 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 6 < current_time <= 6.5:
self.screen.blit(self.sheet.getImage(4, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (15 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 6.5 < current_time <= 7:
self.screen.blit(self.sheet.getImage(0, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (12 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(0, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 7 < current_time <= 7.5:
self.screen.blit(self.sheet.getImage(0, 1, TILEWIDTH * 2, TILEHEIGHT * 2), (9 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(self.sheet.getImage(2, 6, TILEWIDTH * 2, TILEHEIGHT * 2), (TILEWIDTH, 18 * TILEHEIGHT))
elif 7.5 < current_time <= 8:
self.screen.blit(self.sheet.getImage(0, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (6 * TILEWIDTH, 18 * TILEHEIGHT))
elif 8 < current_time <= 8.5:
self.screen.blit(self.sheet.getImage(4, 0, TILEWIDTH * 2, TILEHEIGHT * 2), (3 * TILEWIDTH, 18 * TILEHEIGHT))
elif 9 < current_time <= 11:
self.screen.blit(self.sheet.getImage(6, 2, TILEWIDTH * 2, TILEHEIGHT * 2), (21 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(pygame.image.load('blinky_text.png'), (10 * TILEWIDTH, 15 * TILEHEIGHT))
elif 11 < current_time <= 13:
self.screen.blit(self.sheet.getImage(6, 3, TILEWIDTH * 2, TILEHEIGHT * 2), (21 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(pygame.image.load('pinky_text.png'), (10 * TILEWIDTH, 15 * TILEHEIGHT))
elif 13 < current_time <= 15:
self.screen.blit(self.sheet.getImage(6, 4, TILEWIDTH * 2, TILEHEIGHT * 2), (21 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(pygame.image.load('inkey_text.png'), (10 * TILEWIDTH, 15 * TILEHEIGHT))
elif 15 < current_time <= 17:
self.screen.blit(self.sheet.getImage(6, 5, TILEWIDTH * 2, TILEHEIGHT * 2), (21 * TILEWIDTH, 18 * TILEHEIGHT))
self.screen.blit(pygame.image.load('clyde_text.png'), (10 * TILEWIDTH, 15 * TILEHEIGHT))
def main(self):
while True:
if self.mainScreen:
self.screen.blit(self.background, (0, 0))
self.play_button = Button(self.screen, 'Play Game', 10 * TILEWIDTH, 29 * TILEHEIGHT, TILEHEIGHT, 9)
self.score_button = Button(self.screen, 'High Score', 9.5 * TILEWIDTH, 32 * TILEHEIGHT, TILEHEIGHT, 10)
self.image = pygame.image.load('pacman_title.png')
self.screen.blit(self.image, (3 * TILEWIDTH, TILEHEIGHT))
self.timer = pygame.time.get_ticks() / 1000
self.main_screen_ani(self.timer)
self.main_menu_sound.set_volume(0.2)
self.main_menu_sound.play()
self.play_button.draw()
self.score_button.draw()
self.checkEvents()
elif self.gameScreen:
game.startGame()
self.main_menu_sound.stop()
self.beginning_sound.set_volume(0.2)
self.beginning_sound.play()
while True:
game.update()
elif self.hsScreen:
self.screen.blit(self.background, (0, 0))
self.row = 0
self.font = pygame.font.Font("PressStart2P-vaV7.ttf", TILEHEIGHT)
with open('high_scores.txt') as f:
for line in f:
temp_string = self.font.render(line, True, WHITE)
self.screen.blit(temp_string, (TILEWIDTH, self.row * TILEHEIGHT))
self.back_button = Button(self.screen, 'Go back', 20 * TILEWIDTH, 29 * TILEHEIGHT, TILEHEIGHT, 7)
self.back_button.draw()
self.checkEvents()
pygame.display.update()
self.clock.tick(30)
class Game:
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 1000)
self.background = None
self.background_flash = None
self.setBackground()
self.clock = pygame.time.Clock()
self.pelletsEaten = 0
self.fruit = None
self.sound = Sound(sound="sounds/pmanpellets.wav")
self.sound.play()
self.sound.pause_bg()
# self.play_button, self.quit_button = None
self.pause = Pauser(True)
self.level = LevelController()
self.text = TextGroup()
self.score = 0
self.gameover = False
self.sheet = Spritesheet()
self.maze = Maze(self.sheet)
self.flashBackground = False
def setBackground(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background_flash = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
# def show_menu(self):
# self.play_button = Button(screen=self.screen, msg="Play", x=800, y=500)
# self.quit_button = Button(screen=self.screen, msg="Quit", x=800, y=700)
def play(self):
print("Start game")
# game_state = ts.GameState.TITLE
#
# while True:
# if game_state is ts.GameState.TITLE:
# game_state = ts.title_screen(self.screen)
#
# if game_state is ts.GameState.PlAY:
self.level.reset()
levelmap = self.level.getLevel()
self.maze.getMaze(levelmap["name"].split(".")[0])
self.maze.constructMaze(self.background, self.background_flash, levelmap["row"])
self.nodes = NodeGroup(levelmap["name"])
self.pellets = PelletGroup(levelmap["name"])
self.pacman = Pacman(self.sound, self.nodes, self.sheet)
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pelletsEaten = 0
self.fruit = None
self.pause.force(True)
self.text.showReady()
self.sound.intro()
self.text.updateLevel(self.level.level + 1)
self.gameover = False
self.maze.reset()
self.flashBackground = False
# if game_state is ts.GameState.QUIT:
# exit()
def startLevel(self):
print("Start new level")
levelmap = self.level.getLevel()
self.setBackground()
self.maze.getMaze(levelmap["name"].split(".")[0])
self.maze.constructMaze(self.background, self.background_flash, levelmap["row"])
self.nodes = NodeGroup(levelmap["name"])
self.pellets = PelletGroup(levelmap["name"])
self.pacman.nodes = self.nodes
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pelletsEaten = 0
self.fruit = None
self.pause.force(True)
self.text.showReady()
self.sound.intro()
self.text.updateLevel(self.level.level + 1)
self.flashBackground = False
self.maze.reset()
def restartLevel(self):
print("Restart current level")
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.pause.force(True)
self.text.showReady()
self.fruit = None
self.flashBackground = False
self.maze.reset()
def update(self):
if not self.gameover:
dt = self.clock.tick(30) / 1000.0
if not self.pause.paused:
self.pacman.update(dt)
self.ghosts.update(dt, self.pacman)
if self.fruit is not None:
self.fruit.update(dt)
if self.pause.pauseType != None:
self.pause.settlePause(self)
self.checkPelletEvents()
self.checkGhostEvents()
self.checkFruitEvents()
else:
if self.flashBackground:
self.maze.flash(dt)
if self.pacman.animateDeath:
self.pacman.updateDeath(dt)
self.pause.update(dt)
self.pellets.update(dt)
self.text.update(dt)
self.checkEvents()
self.text.updateScore(self.score)
self.render()
def checkEvents(self):
for event in pygame.event.get():
if event.type == QUIT:
exit()
elif event.type == KEYDOWN:
if event.key == K_SPACE:
if self.gameover:
self.play()
else:
self.pause.player()
if self.pause.paused:
self.text.showPause()
else:
self.text.hideMessages()
def checkPelletEvents(self):
pellet = self.pacman.eatPellets(self.pellets.pelletList)
if pellet:
self.sound.eat_pellets()
self.pelletsEaten += 1
self.score += pellet.points
if (self.pelletsEaten == 70 or self.pelletsEaten == 140):
if self.fruit is None:
levelmap = self.level.getLevel()
self.fruit = Fruit(self.nodes, self.sheet, levelmap["fruit"])
self.pellets.pelletList.remove(pellet)
if pellet.name == "powerpellet":
self.ghosts.resetPoints()
self.ghosts.freightMode()
self.sound.strong_pac()
if self.pellets.isEmpty():
self.pacman.visible = False
self.ghosts.hide()
self.pause.startTimer(3, "clear")
self.flashBackground = True
def checkGhostEvents(self):
self.ghosts.release(self.pelletsEaten)
ghost = self.pacman.eatGhost(self.ghosts)
if ghost is not None:
if ghost.mode.name == "FREIGHT":
self.sound.eat_ghosts()
self.score += ghost.points
self.text.createTemp(ghost.points, ghost.position)
self.ghosts.updatePoints()
ghost.spawnMode(speed=2)
self.pause.startTimer(1)
self.pacman.visible = False
ghost.visible = False
elif ghost.mode.name != "SPAWN":
self.pacman.loseLife()
self.ghosts.hide()
self.pause.startTimer(3, "die")
def checkFruitEvents(self):
if self.fruit is not None:
if self.pacman.eatFruit(self.fruit):
self.sound.eat_fruits()
self.score += self.fruit.points
self.text.createTemp(self.fruit.points, self.fruit.position)
self.fruit = None
elif self.fruit.destroy:
self.fruit = None
def resolveDeath(self):
if self.pacman.lives == 0:
self.gameover = True
self.pacman.visible = False
self.text.showGameOver()
else:
self.restartLevel()
self.pause.pauseType = None
def resolveLevelClear(self):
self.level.nextLevel()
self.startLevel()
self.pause.pauseType = None
def render(self):
self.screen.blit(self.maze.background, (0, 0))
# self.nodes.render(self.screen)
self.pellets.render(self.screen)
if self.fruit is not None:
self.fruit.render(self.screen)
self.pacman.render(self.screen)
self.ghosts.render(self.screen)
self.pacman.renderLives(self.screen)
self.text.render(self.screen)
pygame.display.update()
