def setUp(self):
pm1 = Pacman(2, 3, "NORTH")
pm2 = Pacman(1, 2, "WEST")
pm3 = Pacman(2, 1, "SOUTH")
pm4 = Pacman(3, 2, "EAST")
self.list = [pm1, pm2, pm3, pm4]
pass
def test_place(self):
test_pacman = Pacman()
result_pacman = Pacman(direction=Direction(1.0, 2.0),
facing=0.5,
grid=grid,
orientations=orientations)
test_pacman = test_pacman.place(direction=Direction(0.0, 0.0),
facing=0.0,
grid=grid)
test_pacman.__eq__(result_pacman)
def test_move(self):
test_pacman = Pacman(direction=Direction(0.0, 0.0),
facing=0.0,
grid=grid,
orientations=orientations)
test_pacman = test_pacman.move()
result_pacman = Pacman(direction=Direction(0.0, 1.0),
facing=0.0,
grid=grid,
orientations=orientations)
test_pacman.__eq__(result_pacman)
def game_start():
global tilegrp
global tiles
global nodegrp
global nodes
global coingrp
global coins
global ghostgrp
global ghosts
global pacman
global pacman1
global pacman2
global pacman3
global score
score = 0
#code to add tiles in the screen
tilegrp = Tilegroup(width, height)
tiles = tilegrp.createTileList(maze_filename)
#nodes added, not displayed on the screen, only for navigation purpose
nodegrp = NodeGroup(width, height)
nodes = nodegrp.createNodeList(maze_filename)
#adding coins to our maze
coingrp = Coingroup(width)
coins = coingrp.createCoinList(coin_and_ghosts_filename)
#ghosts added
ghostgrp = Ghostgroup(width, height)
ghosts = ghostgrp.create_ghostlist(maze_filename, coin_and_ghosts_filename,
nodes)
#pacman added
from random import randint
ind = randint(0, len(nodes) - 1)
ind1 = randint(0, len(nodes) - 1)
ind2 = randint(0, len(nodes) - 1)
ind3 = randint(0, len(nodes) - 1)
pacman = Pacman(nodes[ind], (width, height),
[nodes[ind].position.x, nodes[ind].position.y])
pacman1 = Pacman(nodes[ind1], (width, height),
[nodes[ind].position.x, nodes[ind].position.y])
pacman2 = Pacman(nodes[ind2], (width, height),
[nodes[ind].position.x, nodes[ind].position.y])
pacman3 = Pacman(nodes[ind3], (width, height),
[nodes[ind].position.x, nodes[ind].position.y])
#if we are controlling pacman manually
if args.manual:
pacman.speed = 0.8
for g in ghosts:
g.speed = 0.4
def start(self, screen, is_restart=False, is_new_level=False):
with open("level.txt", 'r') as f:
self.map = f.read().split('\n')
if is_restart:
self.pacman = Pacman(screen, 13.5, 23, self.map, self.wall_size)
self.ghosts = []
if is_restart:
self.bigdots = []
self.dots = []
self.ghosts.append(
Speedy(screen, 12, 13, 'red', self.map, self.wall_size,
self.pacman))
self.ghosts.append(
Speedy(screen, 15, 13, 'yellow', self.map, self.wall_size,
self.pacman))
self.ghosts.append(
Speedy(screen, 12, 15, 'blue', self.map, self.wall_size,
self.pacman))
self.ghosts.append(
Speedy(screen, 15, 15, 'pink', self.map, self.wall_size,
self.pacman))
for j, string in enumerate(self.map):
for i, char in enumerate(string):
if char == '-':
wall = Wall(i * self.wall_size, j * self.wall_size + 100,
self.wall_size)
self.walls.append(wall)
elif char == '*' and (is_restart or is_new_level):
food = Dot(i * self.wall_size + self.wall_size // 2,
j * self.wall_size + 100 + self.wall_size // 2,
self.wall_size // 6)
self.dots.append(food)
elif char == '+' and (is_restart or is_new_level):
bigfood = Bigdot(
i * self.wall_size + self.wall_size // 2,
j * self.wall_size + 100 + self.wall_size // 2,
self.wall_size // 2.5)
self.bigdots.append(bigfood)
if is_restart:
self.health = 5
self.score = 0
self.level = 1
self.pacman = Pacman(screen, 13.5, 23, self.map, self.wall_size)
else:
last_score = self.pacman.score
self.pacman = Pacman(screen, 13.5, 23, self.map, self.wall_size)
self.pacman.score = last_score
def __init__(self, solutionFilePath, logFilePath, height, width,
pillDensity, wallDensity, fruitProbability, fruitScore,
timeMultiplier):
self.pacman1 = Pacman(0, height - 1)
self.ghost1 = Ghost(width - 1, 0, 1)
self.ghost2 = Ghost(width - 1, 0, 2)
self.ghost3 = Ghost(width - 1, 0, 3)
self.solutionFilePath = solutionFilePath
self.logFilePath = logFilePath
self.height = height
self.width = width
self.pillDensity = pillDensity
self.wallDensity = wallDensity
self.fruitProbability = fruitProbability
self.fruitScore = fruitScore
self.timeMultiplier = timeMultiplier
self.time = timeMultiplier * width * height
self.grid = [[]]
self.hasFruit = False
self.logger = Logger(self.solutionFilePath, self.logFilePath)
self.numPills = 0 #pills pacman currently has
self.totalPills = 0
self.didSpawn = False
self.fruitx = -1 #fruit position
self.fruity = -1
self.solution = []
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((680, 740))
self.ai_settings = Settings()
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen,
mazefile='map.txt',
brickfile='square',
portalfile='square',
shieldfile='shield',
pointfile='point',
dotfile='dot',
powerpillfile='powerpill')
self.pacman = Pacman(self.ai_settings, self.screen, self.maze)
self.ghosts = Ghosts(self.ai_settings, self.screen, self.maze,
self.pacman)
self.displayname = Button(self.screen, "PacmanPortal")
self.play_button = Button(self.screen, "PLAY GAME")
self.highscore_button = Button(self.screen, "HIGH SCORES")
self.blinkyname = Button(self.screen, "BLiNKY")
self.pinkyname = Button(self.screen, "PiNKY")
self.clydename = Button(self.screen, "CLYDE")
self.inkeyname = Button(self.screen, "iNKEY")
self.back = Button(self.screen, "Back")
self.sb = Scoreboard(self.ai_settings, self.screen, self.maze,
self.pacman)
self.score = Button(self.screen, "hello")
self.blues = 0
def run_game():
# Initialize pygame, settings, and screen object.
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.mixer.init()
pygame.init()
game_settings = GameSettings()
screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("Pac Man Portal")
# Open sprite sheet
sprite_sheet = SpriteSheet(file_name='images/spritesheet.png')
# Make the Play and Scores button.
play_button = Button(screen=screen, msg="Play", order=0)
score_button = Button(screen=screen, msg="High Scores", order=1)
# Open high score file
try:
high_score_file = open("high_score_file.txt", "r+")
except FileNotFoundError:
high_score_file = open("high_score_file.txt", "w+")
# Open maze layout file
maze_file = open('mazelayout.txt', 'r')
# Make sound manager
sounds = Sounds()
# Initialize game stats and scoreboard
stats = GameStats(game_settings=game_settings)
sb = Scoreboard(screen=screen, game_settings=game_settings, stats=stats, sprite_sheet=sprite_sheet,
high_score_file=high_score_file, sounds=sounds)
# Initialize pacman
pacman = Pacman(screen=screen, game_settings=game_settings, stats=stats, sb=sb,
image_list=sprite_sheet.pacman_image, death_anim_list=sprite_sheet.pacman_death_image,
sounds=sounds)
# Initialize maze
maze = Maze(screen=screen, game_settings=game_settings, maze_file=maze_file, sprite_sheet=sprite_sheet,
pacman=pacman, sounds=sounds)
# Initialize the event handler
event_handler = EventHandler(pacman=pacman, play_button=play_button, score_button=score_button, stats=stats, sb=sb,
maze=maze, sounds=sounds)
# Initialize the display manager
display = Display(screen=screen, game_settings=game_settings, stats=stats, sb=sb, sprite_sheet=sprite_sheet,
play_button=play_button, score_button=score_button, maze=maze, pacman=pacman,
event_handler=event_handler, sounds=sounds)
# Start the main loop for the game
while True:
event_handler.check_events()
if stats.game_active:
pacman.update(maze=maze, display=display)
maze.update_ghosts()
maze.update_bullets()
maze.update_portals()
display.update_screen()
def prep_ships(self):
self.pacmans = Group()
for ship_number in range(self.stats.ships_left + 1):
pacman = Pacman(self.screen, self.maze, self)
pacman.rect.x = 10 + ship_number * pacman.rect.width
pacman.rect.y = 10
self.pacmans.add(pacman)
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
def __init__(self):
pygame.init()
self.screen_width = 599
self.screen_height = 800
self.screen = pygame.display.set_mode(
(self.screen_width, self.screen_height))
pygame.display.set_caption('Pacman')
self.clock = pygame.time.Clock()
self.WHITE = (255, 255, 255)
self.BLACK = (0, 0, 0)
self.hovered = False
# self.blinky = Ghost(self.screen, self.maze, 'blinky')
#self.ghosts = Group()
# Give files needed to populate the maze
self.expandfile = ExpandFile('test.txt', expandBy=2)
self.maze = Maze(self.screen, 'test.txt', 'images/wall',
'images/foodPellet', 'images/portal_1',
'images/portal_2')
self.player = Pacman(self.screen, self.maze, self.maze.pacmanposition)
self.blinky = Ghost(self.screen, 'blinky', self.maze,
self.maze.blinky_position, self.player)
self.clyde = Ghost(self.screen, 'clyde', self.maze,
self.maze.clyde_position, self.player)
self.inkey = Ghost(self.screen, 'inkey', self.maze,
self.maze.inkey_position, self.player)
self.pinky = Ghost(self.screen, 'pinky', self.maze,
self.maze.pinky_position, self.player)
self.intro_music = pygame.mixer.Sound("sounds/intro.wav")
self.intro_logo = pygame.image.load('images/pacmanLogo.png')
def __init__(self):
pygame.init()
pygame.mixer.pre_init(44100, 16, 2, 4096)
self.settings = Settings()
self.settings.start_intro_music()
self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Pacman Portal")
self.clock = pygame.time.Clock()
self.radius = 1
self.start = 1
self.end = 10
self.begin = pygame.time.get_ticks()
self.wait = 800
self.startup = Start(self.screen, self.settings)
self.stats = Stats(self.settings)
self.sb = Scoreboard(self.settings, self.screen, self.stats)
self.maze = Maze(self.screen, mazefile='images/pacman_portal_maze.txt',
brickfile='square', orangeportalfile='portal_orange', blueportalfile='portal_blue',
shieldfile='shield', pointfile='point_pill', gatefile="gate")
self.pacman = Pacman(self.screen, mazefile='images/pacman_portal_maze.txt')
self.red = Red(self.screen, mazefile='images/pacman_portal_maze.txt')
self.blue = Blue(self.screen, mazefile='images/pacman_portal_maze.txt')
self.orange = Orange(self.screen, mazefile='images/pacman_portal_maze.txt')
self.pink = Pink(self.screen, mazefile='images/pacman_portal_maze.txt')
self.inc = 0
def init(data):
# load data.xyz as appropriate
data.maze = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0],
[0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0],
[0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
data.gameOver = False
data.timer = 0
data.cellSize = 30
data.board = Board(data.maze)
data.rows, data.cols = len(data.maze), len(data.maze[0])
#moves by width and height of each cell
data.speedX, data.speedY = data.cellSize, data.cellSize
data.counter = 0
data.directions = ['up', 'down', 'left', 'right']
data.mdirection = 'right'
data.direction = 'Right'
data.pacman = Pacman(data.cols // 2 - 1, data.rows // 2 - 1, data)
data.center = None
data.lives = 3
data.score = 0
data.monsterCenter = 0, 1
data.monster = Monster(data)
data.food = copy.deepcopy(data.maze)
def __init__(self):
pygame.init()
pygame.display.set_caption("Pacman Portal")
self.screen = pygame.display.set_mode((800, 600))
self.maze = Maze(screen=self.screen, maze_map_file='pacmanportalmaze.txt')
self.clock = pygame.time.Clock()
self.ghost_sounds = Sounds(sound_files=['ghost-blue.wav', 'ghost-eaten.wav', 'ghost-std.wav'],
keys=['blue', 'eaten', 'std'],
channel=Ghost.audio)
self.stock = PacmanLives(screen=self.screen, ct_pos=((self.screen.get_width() // 3),
(self.screen.get_height() * 0.965)),
images_size=(self.maze.block_size, self.maze.block_size))
self.score = ScoreController(screen=self.screen,
sb_pos=((self.screen.get_width() // 5),
(self.screen.get_height() * 0.965)),
items_image='cherry.png',
itc_pos=(int(self.screen.get_width() * 0.6),
self.screen.get_height() * 0.965))
self.next_level = NextLevel(screen=self.screen, score_controller=self.score)
self.game_over = True
self.pause = False
self.player = Pacman(screen=self.screen, maze=self.maze)
self.ghosts = Group()
self.ghost_time = 2500
self.ghosts_stack = None
self.top_ghost = None
self.arr_ghost = []
self.spawn_ghosts()
self.events = {PacmanPortal.START_EVENT: self.init_ghosts, PacmanPortal.REBUILD_EVENT: self.rebuild_maze, PacmanPortal.LEVEL_EVENT: self.clear_level}
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/fortnite-dance.wav')
self.game_screen = pygame.display.set_mode((900, 700))
pygame.display.set_caption('Pacman')
self.tick_component = pygame.time.Clock()
self.hold_score = ScoreController(screen=self.game_screen,
sb_pos=((self.game_screen.get_width() // 5),
(self.game_screen.get_height() * 0.965)),
items_image='strawb.png',
itc_pos=(int(self.game_screen.get_width() * 0.6),
self.game_screen.get_height() * 0.965))
self.map_layout = Maze(screen=self.game_screen, maze_map_file='maze_map.txt')
self.lives_left = Counter(screen=self.game_screen, ct_pos=((self.game_screen.get_width() // 3),
(self.game_screen.get_height() * 0.965)),
images_size=(self.map_layout.block_size, self.map_layout.block_size))
self.next_level = LevelTransition(screen=self.game_screen, score_controller=self.hold_score)
self.lost_game = True
self.pause_game = False
self.pacman_player = Pacman(screen=self.game_screen, maze=self.map_layout)
self.pacman_ghosts = pygame.sprite.Group()
self.pacman_ghosts_sound = SoundManager(sound_files=['ghost.wav', 'pacman_eatghost.wav', 'pacman_siren.wav'],
keys=['blue', 'eaten', 'siren'],
channel=Ghost.ghost_audio)
self.pacman_ghosts_interval_active = 2500
self.pacman_ghosts_begin_chase = None
self.pacman_ghosts_blinky = None
self.pacman_ghosts_others = []
self.blit_ghosts()
self.game_actions = {PlayGame.event_start: self.init_ghosts,
PlayGame.event_remake: self.rebuild_maze,
PlayGame.event_next_level: self.next_level}
def main():
if len(sys.argv) != 2:
"please pass the file of the commands"
exit(0)
Commands = readFile(sys.argv[1])
orientations = ["NORTH", "EAST", "SOUTH", "WEST"]
grid = Grid()
pacman = Pacman(orientations=orientations)
if "PLACE" not in Commands[0]:
print("The first valid command to the pacman is a PLACE command, please specify it")
elif "PLACE" in Commands[0]:
for command in Commands:
if "PLACE" in command:
command_splitted = preprocessCommands(command)
x_axis = float(command_splitted[0])
y_axis = float(command_splitted[1])
facing = command_splitted[2]
orientations_index = orientations.index(facing)
pacman_position = Direction(x_axis=x_axis, y_axis=y_axis)
pacman = pacman.place(Direction=pacman_position,grid=grid,facing=orientations_index/2.0)
else:
pacman = getattr(pacman,command.lower())()
def check_play(self, mouse_x, mouse_y):
"""Checks if play button is pressed"""
button_clicked = self.play.rect2.collidepoint(mouse_x, mouse_y)
if button_clicked and not self.stats.game_active:
self.settings.music.play()
pygame.mouse.set_visible(False)
# Reset the game statistics
self.stats.reset_stats()
self.stats.game_active = True
# Reset the scoreboard image
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_pacmen()
self.pac.empty()
self.points.empty()
self.pills.empty()
self.fruits.empty()
self.ghosts.empty()
self.maze.build()
self.maze.build_points()
self.pacman = Pacman(self.screen, self.settings, self.maze,
self.portal, self.stats)
self.pac.add(self.pacman)
EventLoop.create_ghosts(self)
def joue(scr):
curses.curs_set(0)
pacman = Pacman()
pacman.x = 1
pacman.y = 1
with open("terrain.txt") as f:
pacman.maze.loadMaze(f.read())
scr.timeout(150)
while True:
for i in range(pacman.maze.largeur):
for j in range(pacman.maze.longueur):
scr.addstr(j, i, pacman.maze.get(i, j))
scr.addstr(pacman.y, pacman.x, pacman.tronche)
scr.addstr(
pacman.maze.longueur, pacman.maze.largeur + 5,
"Score plutôt que String toute entière : " + str(pacman.score))
scr.refresh()
c = scr.getch()
if c == curses.KEY_UP:
pacman.direction = Pacman.Up
elif c == curses.KEY_DOWN:
pacman.direction = Pacman.Down
elif c == curses.KEY_LEFT:
pacman.direction = Pacman.Left
elif c == curses.KEY_RIGHT:
pacman.direction = Pacman.Right
elif c == curses.KEY_F1:
return
pacman.bouge()
def test_point_collect_points(self):
self.game.point_count = 86
test_pacman = Pacman(40, 460, False, False, True)
hit = self.point.collect_points(self, test_pacman, self.game.points)
self.game.point_count += hit
self.game._get_points()
self.assertEqual(self.game.game_win, True)
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((716, 793 + 60))
pygame.display.set_caption("Pacman Portal")
self.bricks = Group()
self.shields = Group()
self.powerpills = Group()
self.qpills = Group()
self.maze = Maze(self.screen,
self.bricks,
self.shields,
self.powerpills,
self.qpills,
brickfile='square',
mazefile='images/pacmanportalmaze.txt',
shieldfile='shield',
powerpill='powerpill')
self.increase = False
self.scoreboard = Scorebord(self.screen, self)
self.pacman = Pacman(self.screen, self.scoreboard, self)
self.play_button = Button(self.screen, "PLAY GAME", 80 / 100)
self.score_button = Button(self.screen, "HIGH SCORES", 90 / 100)
self.menu = Menu()
self.audio = Audio()
self.fruit = Fruit(self.screen)
self.blinky = Blinky(self.screen, self.pacman, self.scoreboard)
self.inky = Inky(self.screen, self.pacman, self.scoreboard)
self.pinky = Pinky(self.screen, self.pacman, self.scoreboard)
self.clyde = Clyde(self.screen, self.pacman, self.scoreboard)
self.oportal = Portal('o', self.pacman)
self.bportal = Portal('b', self.pacman)
self.active = False
self.pause = False
def test_eat_dots():
game_controller = GameController(600, 600)
maze = Maze(600, 600, 150, 450, 150, 450, game_controller)
pacman = Pacman(maze, game_controller)
pacman.y = 150
pacman.x = 0
assert len(pacman.maze.dots.top_row) == 9
pacman.eat_dots()
assert len(pacman.maze.dots.top_row) == 8
pacman.y = 450
pacman.x = 150
assert len(pacman.maze.dots.bottom_row) == 9
assert len(pacman.maze.dots.left_col) == 9
pacman.eat_dots()
assert len(pacman.maze.dots.bottom_row) == 8
assert len(pacman.maze.dots.left_col) == 8
pacman.y = 450
pacman.x = 450
assert len(pacman.maze.dots.bottom_row) == 8
assert len(pacman.maze.dots.right_col) == 9
pacman.eat_dots()
assert len(pacman.maze.dots.bottom_row) == 7
assert len(pacman.maze.dots.right_col) == 8
pacman.y = 150
pacman.x = 600
assert len(pacman.maze.dots.top_row) == 8
pacman.eat_dots()
assert len(pacman.maze.dots.top_row) == 7
def start_game(self):
self.level.reset()
level_map = self.level.get_level()
self.game_over = False
self.stats = GameStats(settings=self.settings)
self.sb = Scoreboard(settings=self.settings,
screen=self.screen,
stats=self.stats)
self.sound = Sound()
self.maze = Maze(settings=self.settings, screen=self.screen)
self.maze.get_maze()
self.grid_pts = Grid_Pnts_Group(settings=self.settings,
screen=self.screen,
txt_file=level_map["mazename"])
self.foods = FoodGroup(settings=self.settings,
screen=self.screen,
food_file=level_map["foodname"])
self.pacman = Pacman(game=self,
settings=self.settings,
screen=self.screen,
grid_pts=self.grid_pts,
foods=self.foods,
sb=self.sb)
self.ghosts = Ghost_Group(game=self,
settings=self.settings,
screen=self.screen,
grid_pts=self.grid_pts)
self.pellets_eaten = 0
self.settings.pacman_lives = self.settings.starting_lives
self.fruit = None
self.pause.force(True)
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 load_playing_field(self, score, hp):
f = open(
'game_process_for_{}/level{}.txt'.format(self.count_pacmans,
self.level), 'r')
data = list(f.read().split(sep='\n'))
for i in range(len(data)):
data[i] = list(data[i])
f.close()
field = []
k = 0
for x in range(len(data[k])):
h = []
for y in range(len(data)):
h.append(data[y][x])
k += 1
field.append(h)
width = WIDTH_CELL
height = HEIGHT_CELL
self.field_width = len(field) * WIDTH_CELL
self.field_height = len(field[0]) * HEIGHT_CELL
for i in range(len(field)):
for k in range(len(field[i])):
x = INDENT_X + i * width
y = INDENT_Y + k * height
if field[i][k] != '1':
self.floor.append(
Floor(x, y, width, height, 0, constants.BLACK))
if field[i][k] == '1':
self.walls.append(
Wall(x, y, width, height, 1, constants.BROWN))
if field[i][k] == '2':
self.grains.append(
Grain(x, y, width, height, 2, constants.LIGHT_ORANGE))
if field[i][k] == '3':
self.grains.append(
SuperGrain(x, y, width, height, 3,
constants.LIGHT_ORANGE))
if field[i][k] == '5' and self.count_pacmans != len(
self.pacmans):
self.pacmans.append(
Pacman(x + 1, y + 1, width + LESS_OBJECT,
height + LESS_OBJECT, 3, None,
score[len(self.pacmans)],
hp[len(self.pacmans)]))
self.initial_coordinates['pacmans'].append((x + 1, y + 1))
self.status_bars.append(
StatusBar(
INDENT_X, self.walls[0].rect.y -
(len(self.status_bars) + 1) * 22))
if field[i][k] == '6':
self.ghosts.append(
Ghost(x + 1, y + 1, width + LESS_OBJECT,
height + LESS_OBJECT, 3, WHITE))
self.initial_coordinates['ghosts'].append((x + 1, y + 1))
if field[i][k] == '4':
self.teleports.append(
Teleport(x, y, width, height, 4, constants.BLACK))
def test_constructor():
"""Test Pacman constructor"""
game_controller = GameController(600, 400)
maze = Maze(600, 400, 150, 450,
100, 300, game_controller)
pacman = Pacman(maze, game_controller)
assert pacman.gc is game_controller
assert pacman.maze is maze
def _create_birds_population(self, **kwargs):
self.birds_pop = deque([])
for i in range(kwargs['birds_pop_size']):
self.birds_pop.append(
Pacman(x=kwargs['bird_x'],
y=kwargs['bird_y'],
radius=kwargs['bird_radius'],
height=kwargs['window_height']))
def __init__(self, player_input, settings, screen):
self.settings = settings
self.screen = screen
self.player_input = player_input
self.pacman = Pacman(self)
self.maze = Maze(self)
self.scoreboard = Scoreboard(self)
def test_pacman_and_ghosts_collision(self):
test_pacman1 = Pacman(100, 461, False, True, False)
self.game.ghost_collision = self.ghosts.ghost_collision(
self, test_pacman1, self.game.ghosts_list)
self.assertEqual(self.game.ghost_collision, True)
self.game.ghost_collision = self.ghosts.ghost_collision(
self, self.game.pacman, self.game.ghosts_list)
self.assertEqual(self.game.ghost_collision, False)
def prep_pacmans(self):
"""Show how many pacmans are left."""
self.pacmans = Group()
for pacman_number in range(self.stats.pacmans_left):
pacman = Pacman(self.ai_settings, self.screen)
pacman.rect.x = 10 + pacman_number * pacman.rect.width * 1.25
pacman.rect.y = 10
self.pacmans.add(pacman)
def prep_pacmans(self):
"""SHow how many ships are left."""
self.pacmans = Group()
for pacman_number in range(self.ai_settings.lives_left):
pacman = Pacman(self.ai_settings, self.screen, self.maze)
pacman.rect.x = 10 + pacman_number * pacman.rect.width
pacman.rect.y = 10
self.pacmans.add(pacman)
