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.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 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 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()