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 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()
def setBackground(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
def startGame(self):
self.nodes = NodeGroup("maze.txt")
self.pacman = Pacman(self.nodes)
self.ghosts = GhostGroup(self.nodes)
self.gameover = False
def update(self):
if not self.gameover:
dt = self.clock.tick(30) / 1000.0
self.pacman.update(dt)
self.ghosts.update(dt, self.pacman)
self.checkGhostEvents()
self.checkEvents()
self.render()
def checkGhostEvents(self):
ghost = self.pacman.eatGhost(self.ghosts)
if ghost is not None:
if ghost.mode.name == "FREIGHT":
ghost.spawnMode(speed=2)
self.pacman.visible = False
ghost.visible = False
elif ghost.mode.name == "CHASE" or ghost.mode.name == "SCATTER":
#self.pacman.loseLife()
exit()
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()
def restartLevel(self):
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes)
#def resolveDeath(self):
#if self.pacman.lives == 0:
#self.gameover = True
#else:
#self.restartLevel()
def render(self):
self.screen.blit(self.background, (0, 0))
self.nodes.render(self.screen)
self.pacman.render(self.screen)
self.ghosts.render(self.screen)
#self.pacman.renderLives(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.level = 0
self.setBackGround()
self.clock = pygame.time.Clock()
self.score = 0
self.ghostScore = 200
self.lives = 5
self.idleTimer = 0
self.displayedLevel = 0
self.maxLevels = 2
self.displayedFruits = []
self.sheet = SpriteSheet()
self.lifeIcons = Lives(self.sheet)
self.maze = Maze(self.level, self.sheet)
self.maze.fillMaze(self.background)
self.allText = TextGroup()
self.allText.add("hi_score_label", "HI SCORE", align="left")
self.allText.add("score_label", "SCORE", align="center")
self.allText.add("level_label", "LEVEL", align="right")
self.allText.add("score", self.score, y=HEIGHT, align="center")
self.allText.add("level",
self.displayedLevel,
y=2 * HEIGHT,
align="right")
self.levelFlashTime = 0.3
self.levelFlashTimer = 0
self.drawBackgroundFlash = False
self.flashLevel = False
self.fruitScoreTimer = 0
self.fruitEaten = False
def setBackGround(self):
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
self.backgroundFlash = pygame.surface.Surface(SCREENSIZE).convert()
self.backgroundFlash.fill(BLACK)
def commonSetup(self):
self.pacman = Pacman(self.nodes, self.level, self.sheet)
self.ghosts = GhostGroup(self.nodes, self.level, self.sheet)
self.paused = True
self.fruit = None
self.fruitTimer = 0
self.pauseTimer = 0
self.pauseTime = 5
self.playerPaused = False
self.startDelay = False
self.restartDelay = False
self.scoreAccumulator = 0
self.maxLives = 5
self.allText.add("start_label",
"BEGIN",
y=20 * HEIGHT,
align="center",
color=YELLOW)
self.flashLevel = False
self.drawBackgroundFlash = False
self.levelFlashTimer = 0
self.fruitScoreTimer = 0
def startGame(self):
self.setBackGround()
self.maze = Maze(self.level, self.sheet)
self.maze.fillMaze(self.background)
self.mazeFlash = Maze(self.level, self.sheet, startcol=11)
self.mazeFlash.fillMaze(self.backgroundFlash)
self.nodes = NodeGroup(self.level)
self.pellets = PelletGroup(self.level)
self.commonSetup()
def restartLevel(self):
self.commonSetup()
def update(self):
dt = self.clock.tick(30) / 1000.0
if not self.paused:
self.pacman.update(dt)
self.ghosts.update(dt, self.pacman)
self.checkPelletEvents(dt)
self.checkGhostEvents(dt)
self.checkFruitEvents(dt)
self.applyScore()
else:
if not self.playerPaused:
if not self.pacman.alive:
self.pacman.update(dt)
if self.pacman.deathSequenceFinished:
if self.lives > 0:
self.restartLevel()
else:
self.allText.add("game_over_label",
"GAME OVER",
y=20 * HEIGHT,
align="center",
color=RED)
else:
self.pauseTimer += dt
if self.pauseTimer >= self.pauseTime:
self.paused = False
self.allText.remove("ghost_score")
self.allText.remove("start_label")
self.pacman.draw = True
for ghost in self.ghosts:
ghost.draw = True
if self.startDelay == True:
self.startGame()
if self.restartDelay == True:
self.restartLevel()
if self.flashLevel:
self.levelFlashTimer += dt
if self.levelFlashTimer >= self.levelFlashTime:
self.levelFlashTimer = 0
self.drawBackgroundFlash = not self.drawBackgroundFlash
if self.fruitEaten:
self.fruitScoreTimer += dt
if self.fruitScoreTimer >= self.fruitScoreTime:
self.allText.remove("fruit_score")
self.fruitScoreTimer = 0
self.fruitEaten = False
self.checkEvents()
self.render()
def checkEvents(self):
for event in pygame.event.get():
if event.type == QUIT:
exit()
if event.type == KEYDOWN:
if event.key == K_SPACE:
self.allText.remove("start_label")
self.allText.remove("fruit_score")
if self.paused:
self.playerPaused = False
self.allText.remove("paused_label")
else:
self.playerPaused = True
self.allText.add("paused_label",
"PAUSED",
y=20 * HEIGHT,
align="center",
color=GREEN)
self.paused = not self.paused
def checkPelletEvents(self, dt):
pellet = self.pacman.eatPellets(self.pellets.pelletList)
if pellet:
self.pellets.numEaten += 1
if (self.pellets.numEaten == 70 or self.pellets.numEaten == 140):
self.fruit = CollectedFruit(self.nodes, self.level,
self.displayedLevel, self.sheet)
self.idleTimer = 0
self.scoreAccumulator += pellet.value
self.pellets.pelletList.remove(pellet)
if pellet.name == "powerpellet":
self.pellets.powerPellets.remove(pellet)
self.ghosts.setFreightMode()
self.ghostScore = 200
if (self.ghosts.anyInFreightOrSpawn()):
self.pacman.boostSpeed()
else:
self.pacman.reduceSpeed()
if self.pellets.isEmpty():
self.paused = True
self.pauseTime = 3
self.pauseTimer = 0
self.startDelay = True
self.flashLevel = True
self.increaseLevel()
else:
self.idleTimer += dt
if (self.ghosts.anyInFreightOrSpawn()):
self.pacman.boostSpeed()
else:
if self.idleTimer >= 0.5:
self.pacman.normalSpeed()
for pellet in self.pellets.powerPellets:
pellet.update(dt)
def checkGhostEvents(self, dt):
ghost = self.pacman.eatGhost(self.ghosts)
if ghost is not None:
if ghost.mode.name == "FREIGHT":
self.allText.add("ghost_score",
self.ghostScore,
x=ghost.position.x,
y=ghost.position.y,
size=0.5)
ghost.setRespawnMode()
self.scoreAccumulator += self.ghostScore
self.ghostScore *= 2
self.paused = True
self.pauseTime = 0.5
self.pauseTimer = 0
self.pacman.draw = False
ghost.draw = False
elif ghost.mode.name != "SPAWN":
self.paused = True
#self.pauseTime = 1
self.pauseTimer = 0
self.restartDelay = True
self.lives -= 1
if self.lives == 0:
self.lives = 5
self.startDelay = True
self.pacman.alive = False
self.ghosts.noDraw()
#ghost.draw = False
self.pacman.animate.setAnimation("death", 0)
if self.pellets.numEaten >= 30 or self.idleTimer >= 10:
self.ghosts.release("inky")
if self.pellets.numEaten >= 60 or self.idleTimer >= 10:
self.ghosts.release("clyde")
def checkFruitEvents(self, dt):
if self.fruit is not None:
if self.pacman.eatFruit(self.fruit):
self.allText.add("fruit_score",
self.fruit.value,
x=self.fruit.position.x,
y=self.fruit.position.y,
size=0.5)
self.scoreAccumulator += self.fruit.value
self.addDisplayedFruit()
self.fruitTimer = 0
self.fruit = None
self.fruitScoreTime = 1
self.fruitScoreTimer = 0
self.fruitEaten = True
else:
self.fruitTimer += dt
if self.fruitTimer >= 10:
self.fruitTimer = 0
self.fruit = None
def applyScore(self):
if self.scoreAccumulator > 0:
newScore = self.score + self.scoreAccumulator
if ((newScore % 10000 - self.score % 10000) < 0
or newScore - self.score >= 10000):
if self.lives < self.maxLives:
self.lives += 1
self.score += self.scoreAccumulator
self.scoreAccumulator = 0
self.allText.remove("score")
self.score = newScore
self.allText.add("score", self.score, y=HEIGHT, align="center")
def addDisplayedFruit(self):
fruitNames = [n.name for n in self.displayedFruits]
if self.fruit.name not in fruitNames:
fruit = DisplayedFruit(self.fruit)
fruit.setPosition(len(self.displayedFruits))
self.displayedFruits.append(fruit)
def increaseLevel(self):
self.level += 1
self.displayedLevel += 1
self.level %= self.maxLevels
def render(self):
if self.drawBackgroundFlash:
self.screen.blit(self.backgroundFlash, (0, 0))
else:
self.screen.blit(self.background, (0, 0))
#self.nodes.render(self.screen)
self.pellets.render(self.screen)
for fruit in self.displayedFruits:
fruit.render(self.screen)
if not self.playerPaused:
if self.fruit is not None:
self.fruit.render(self.screen)
self.ghosts.render(self.screen)
self.pacman.render(self.screen)
self.lifeIcons.render(self.screen, self.lives - 1)
self.allText.render(self.screen)
pygame.display.update()
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()
class GameController:
"""
This the class that controls our basic game loop, what this method does
is update what happens in game based on other events, and what just keeps
game running until we end it
"""
def __init__(self):
pygame.init()
self.nodes = None
self.pacman = None
self.ghosts = None
self.game = None
self.pellets_eaten = 0
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = None
self.set_background()
self.clock = pygame.time.Clock()
def set_background(self):
"""
We create a background and set it to the color BLACK that we defined in
the constants.py file.
"""
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
def start_game(self):
self.sheet = Spritesheet()
self.nodes = NodeGroup("maze.txt")
self.pellets = Pellets_Group("maze.txt")
self.pacman = Pacman(self.nodes, self.sheet)
self.ghosts = GhostGroup(self.nodes, self.sheet)
self.life_icons = LifeIcon(self.sheet)
self.paused = False
self.maze = Maze(self.sheet)
self.maze.get_maze("maze")
self.maze.combine_maze(self.background)
def update(self):
"""
The update method is a method that we call once per frame of the game.
It's basically our game loop
"""
dt = self.clock.tick(30) / 1000.0
if not self.paused:
self.pacman.update(dt)
self.ghosts.update(dt, self.pacman)
self.check_updater()
self.render()
def check_ghost_collision(self):
self.ghosts.escape(self.pellets_eaten)
ghost = self.pacman.collide_ghost(self.ghosts.ghosts)
if ghost is not None:
if ghost.mode.name == "FEAR":
ghost.respawn()
elif ghost.mode.name != "SPAWN":
if self.pacman.lives == 0:
self.start_game()
else:
self.pacman.lives -= 1
self.restart_level()
def check_updater(self):
"""
This method checks for certain events.
Right now it is just checking to see when we exit out of the game.
:return:
"""
for event in pygame.event.get():
if event.type == QUIT:
exit()
elif event.type == KEYDOWN:
if event.key == K_SPACE:
self.paused = not self.paused
self.check_collision()
self.check_ghost_collision()
def render(self):
"""
The render method is the method we'll use to draw the images to the screen.
it uses the update method, it is consistently running until the
window is closed, right now it just keeps drawing what we want on screen
"""
self.screen.blit(self.background, (0, 0))
#self.nodes.render(self.screen)
self.pellets.render(self.screen)
self.pacman.render(self.screen)
self.ghosts.render(self.screen)
self.life_icons.render(self.screen, self.pacman.lives - 1)
pygame.display.update()
def check_collision(self):
"""
This method finds the pellet collison and it has collided, it will
remove that pellet from the pellet list and then it will also update
the score accordingly.
"""
self.paclives = self.pacman.lives
pellete = self.pacman.collide_pellets(self.pellets.pellets_list)
if pellete:
self.pellets.pellets_list.remove(pellete)
# self.pacman.get_score(pellete.points)
self.pellets_eaten += 1
if pellete.name == "powerpellet":
self.pellets_eaten += 1
self.ghosts.engage_chase()
if self.pellets.is_empty():
self.start_game()
self.pacman.lives = self.paclives
else:
pass
def restart_level(self):
self.paused = True
self.pacman.reset()
self.ghosts = GhostGroup(self.nodes, self.sheet)
def get_score(self, points):
"""
Updates the score with given points and return the final score.
"""
self.pacman.score += points
return self.pacman.score