def play(self):
while True:
mloop = MenuLoop(self.screen,
self.stats,
finished=False,
highscore_screen=False)
while not mloop.finished:
mloop.check_events()
mloop.update()
self.update_menu_screen(mloop)
if mloop.highscore_screen == True:
while mloop.highscore_screen:
mloop.check_highscore_events()
mloop.update_highscore_screen()
self.update_highscore_screen(mloop)
self.maze = Maze(self.screen, self.mazefile, 'square', 'shield',
'left_bigman_1', 'powerpill', 'tablet',
'up_clyde_1', 'up_pinky_1', 'up_inky_1',
'up_blinky_1', self.stats)
eloop = EventLoop(self.maze, self.screen, finished=False)
while not eloop.finished:
eloop.check_events()
eloop.update(self.settings, self.screen, self.stats)
self.update_screen()
def run(self):
play_menu = Menu(self.game_screen)
high_score_menu = HighScoreScreen(self.game_screen, self.hold_score)
intro_ghost_chase = Intro(self.game_screen)
event_iterator = EventLoop(loop_running=True, actions={pygame.MOUSEBUTTONDOWN: play_menu.check_buttons})
while event_iterator.loop_running:
self.tick_component.tick(60)
event_iterator.check_events()
self.game_screen.fill(PlayGame.game_color)
if not play_menu.high_score_menu:
intro_ghost_chase.update()
intro_ghost_chase.blit()
play_menu.blit()
else:
high_score_menu.blit()
high_score_menu.check_done()
if play_menu.ready_to_play:
pygame.mixer.music.stop()
self.play_game()
for g in self.pacman_ghosts:
g.reset_speed()
play_menu.ready_to_play = False
self.hold_score.save_high_scores()
high_score_menu.prep_images()
high_score_menu.position()
elif not pygame.mixer.music.get_busy():
pygame.mixer.music.play(-1)
pygame.display.flip()
def main():
# Monitor the button for events.
global eventloop
eventloop = EventLoop()
eventloop.monitor_gpio_button(args.gpio_pin,
button_handler,
doubleclick_speed=0)
say("Device is in Service Mode. Press button to navigate through the menu. "
"Long press to enter the menu section or perform an action.")
# Read current configuration values.
with open(args.config_path) as config_file:
for line in config_file:
key, value = line.partition("=")[::2]
# Ignore empty lines.
key = key.strip()
if key:
config[key] = value.strip()
logger.info('Current environment variables: %s', config)
ready()
# Run the event loop forever.
eventloop.loop()
def __init__(self, app, doc_file=''):
UCDocPresenter.__init__(self, config, app.appdata)
self.app = app
self.eventloop = EventLoop(self)
self.selection = Selection(self)
if doc_file:
self.load(doc_file)
self.doc_name = os.path.basename(self.doc_file)
else:
self.new()
self.doc_name = self.app.get_new_docname()
self.cms = self.app.default_cms
self.api = PresenterAPI(self)
self.docarea = DocArea(self.app, self)
self.canvas = self.docarea.canvas
self.api.view = self.canvas
self.app.mw.add_tab(self.docarea)
self.eventloop.connect(self.eventloop.DOC_MODIFIED, self.modified)
self.traced_objects = [
self.eventloop, self.api, self.docarea.hruler, self.docarea.vruler,
self.docarea.corner, self.docarea, self.canvas.renderer,
self.canvas, self.selection, self
]
def main(): loop = EventLoop() keybinder = XKeyBinder(loop) config.activate_key_bindings(keybinder) loop.run()
def play(self):
eventloop = EventLoop(finished=False)
while not eventloop.finished:
self.clock.tick(30)
eventloop.check_events(self.player)
self.player.update()
self.update_screen()
def play(self):
eloop = EventLoop(self.ai_settings.finished)
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.pacman)
self.pacman.check_dot_collision(self.ai_settings, self.maze.dots,
self.maze.pills, self.sb)
self.sb.check_high_score(self.sb)
self.update_screen()
self.pacman.check_wall_collision(self.maze.bricks)
self.pacman.update()
self.ghost.update_ghost(self.pacman, self.maze.nodes)
def main():
# Load the database of items we know about.
global db
db = ImageDatabase(options)
# Initialize the camera object we'll use to take pictures.
global camera
camera = Camera(options.video_source,
options.video_width,
options.video_height,
options.video_fps)
with open(get_sound('shutter.raw'), 'rb') as f:
global SHUTTER_TONE
SHUTTER_TONE = f.read()
# Set up the audio devices if they are configured
if options.audio_out_device:
audioutils.ALSA_SPEAKER = options.audio_out_device
if options.audio_in_device:
audioutils.ALSA_MICROPHONE = options.audio_in_device
# If log path is set, make sure the corresponding directory exists.
if options.log_path and not os.path.isdir(options.log_path):
os.makedirs(options.log_path)
# If --web-server was specified, run a web server in a separate process
# to expose the files in that directory.
# Note that we're using port 80, assuming we'll always run as root.
if options.web_server:
subprocess.Popen(['python', '-m', 'SimpleHTTPServer', '80'],
cwd=options.web_server_root)
# Monitor the button for events
global eventloop
eventloop = EventLoop()
eventloop.monitor_gpio_button(options.gpio_pin, button_handler,
doubleclick_speed=0)
# If you don't have a button, use --cmd-ui to monitor the keyboard instead.
if options.cmd_ui:
# Print instructions.
keyboard_handler()
# Monitor it on the event loop.
eventloop.monitor_console(keyboard_handler, prompt="Command: ")
# Let the user know we're ready
ready()
# Run the event loop forever
eventloop.loop()
def play(self):
# sleep(4)
#pygame.mixer.Sound.play(self.intro)
sleep(1)
eventloop = EventLoop(finished=False)
pygame.mixer.Sound.play(self.intro)
while not eventloop.finished:
#self.clock.tick(60)
eventloop.check_events(self.screen, self.player, self.sb, self.play_button, self.stats, self.set)
self.player.update()
self.update_screen()
def play(self):
# self.displayname = Button(self.screen, "Portal Pacman")
self.displayname.rect.centery -= 300
self.displayname.msg_image_rect.center = self.displayname.rect.center
# self.highscore_button = Button(self.screen, "Portal Pacman")
self.highscore_button.rect.centery += 330
self.highscore_button.msg_image_rect.center = self.highscore_button.rect.center
# self.play_button = Button(self.screen, "Portal Pacman")
self.play_button.rect.centery += 280
self.play_button.msg_image_rect.center = self.play_button.rect.center
hs_file = open("score.txt", "r")
self.ai_settings.hs = int(hs_file.read())
hs_file.close()
msgg = 'The high score is ' + str(self.ai_settings.hs)
self.score = Button(self.screen, msgg)
self.score.rect.centery -= 150
self.score.msg_image_rect.center = self.score.rect.center
self.ghosts.intro()
self.pacman.intro()
self.blues = pygame.mixer.Sound('sounds/blueghosts.wav')
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.ai_settings, self.pacman, self.maze,
self.play_button, self.highscore_button,
self.back, self.ghosts, self.blues, self.sb)
if self.ai_settings.score > self.ai_settings.hs and self.ai_settings.game_active:
self.ai_settings.hs = self.ai_settings.score
msgg = 'The high score is ' + str(self.ai_settings.hs)
score = Button(self.screen, msgg)
score.rect.centery += 150
score.msg_image_rect.center = score.rect.center
if len(self.maze.dots) == 1:
self.maze = Maze(self.screen,
mazefile='map.txt',
brickfile='square',
portalfile='square',
shieldfile='shield',
pointfile='point',
dotfile='dot',
powerpillfile='powerpill')
self.pacman.reset()
self.ghosts.reset()
self.ai_settings.level += 1
if not self.ai_settings.game_active:
pygame.mouse.set_visible(True)
self.update_screen()
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.screen, self.player, self.maze, self.stats,
self.button)
if self.stats.game_active:
eloop.check_wall_collision(self.player, self.maze)
eloop.check_pill_collision(self.player, self.maze, self.stats)
eloop.check_killpill_collision(self.player, self.maze,
self.stats)
self.player.update()
self.update_screen()
self.check_high_score()
self.score_board = Scoreboard(self.screen, self.stats)
self.score_board.prep_high_score()
def base_server(path_args: Dict[str, pathlib.Path],
event_loop: asyncio.AbstractEventLoop) -> Iterator[Server]:
evtloop = EventLoop()
args = {
'config_file': str(path_args['moonraker.conf']),
'log_file': str(path_args.get("moonraker.log", "")),
'software_version': "moonraker-pytest"
}
ql = logger = None
if args["log_file"]:
ql, logger, warning = utils.setup_logging(args)
if warning:
args["log_warning"] = warning
yield Server(args, logger, evtloop)
if ql is not None:
ql.stop()
def play(self):
eloop = EventLoop(self.ai_settings.finished,
self.ai_settings.display_lives)
self.load_data()
while not eloop.finished:
eloop.check_events(self.ai_settings, self.menu, self.mario)
self.mario.update(self.map.rock, self.map.metal, self.map.stone,
self.map.brick, self.map.q, self.map.pipe,
self.map.pipe_1, self.map.coins)
self.enemies.update()
self.powerups.update()
self.update_screen()
self.sb.check_high_score(self.sb)
if self.enemies.g_rect.left == self.ai_settings.screen_width:
Mobs(self.ai_settings, self.screen, self.map, self)
def play(self):
clock = pygame.time.Clock()
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.settings, self.stats, self.player, self.pb, self.maze)
self.menu.prep_screen()
if self.stats.game_active:
self.player.update(self.maze)
self.red.update(self.maze)
self.blue.update(self.maze)
self.orange.update(self.maze)
self.pink.update(self.maze)
self.display_game()
clock.tick(20)
def play_game(self):
event_iterator = EventLoop(loop_running=True, actions={**self.pacman_player.event_map, **self.game_actions})
self.next_level.set_show_transition()
self.lost_game = False
if self.pacman_player.dead:
self.pacman_player.revive()
self.hold_score.reset_level()
self.lives_left.reset_counter()
self.rebuild_maze()
while event_iterator.loop_running:
self.tick_component.tick(60)
event_iterator.check_events()
self.update_screen()
if self.lost_game:
pygame.mixer.stop()
self.hold_score.reset_level()
event_iterator.loop_running = False
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((680, 740))
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen,
mazefile='maze.txt',
brickfile='square',
portalfile='close_portal',
shieldfile='shield',
powerfile='powerpil',
pointsfile='points',
foodfile='cherry')
self.menu = Startup(self.screen, 'title.png', 'playbutton.png')
self.pacman = Pacman(self.screen)
self.ghosts = Ghosts(self.screen)
self.eloop = EventLoop(finished=False)
def play(self):
loop = EventLoop(self.p_man, self.maze, self.ghosts, self.stats,
self.pb)
while not loop.finished:
loop.check_events()
if self.stats.game_active:
self.pinky.start(loop.start_time)
self.inky.start(loop.start_time)
self.blinky.start(loop.start_time)
self.clyde.start(loop.start_time)
loop.check_collisions()
self.update_screen()
self.clock.tick(60)
self.lost = self.p_man.finished
self.won = loop.won
if self.won:
self.stats.game_active = False
elif self.lost:
self.stats.game_active = False
def play(self):
eloop = EventLoop(finished=True, settings=self.settings)
self.reset_game()
while True:
while eloop.finished:
eloop.check_play_button(self.stats, self.sb, self.play_button)
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
while self.settings.begin.get_busy():
eloop.check_events(self.stats, self.player)
self.settings.begin.get_busy()
while not eloop.finished:
eloop.check_events(self.stats, self.player)
self.update_screen()
self.player_ghost_update()
if self.stats.lives_left == 0:
self.reset_game()
while self.game_over_screen.counter != 2:
eloop.check_events(self.stats, self.player)
self.game_over_screen.blit_me()
pygame.display.flip()
eloop.finished = True
