def main(): """Main program loop""" pygame.init() screen = pygame.display.set_mode(opt.window_size) sys_font = Font(get_default_font(), opt.font_size) clock = Clock() manager = YarsManager() running = True while running: #limit framerate and prepare FPS display text clock.tick(opt.max_framerate) fps = clock.get_fps() fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, opt.white) if event.get(pygame.QUIT): sys.exit() running = manager.handle_events(event.get(), key.get_pressed()) manager.update() screen.fill(opt.black) manager.draw(screen) screen.blit(fps_text, fps_text.get_rect(top = 0, right = opt.width)) pygame.display.update() sys.exit()
def main(): """The main function of the game. Initializes PyGame objects and then enters the game loop """ pygame.init() screen = pygame.display.set_mode(window_size) sys_font = Font(get_default_font(), font_size) clock = Clock() #now that pygame is initialized, initialize inherited classes properly global enemy_wave, player enemy_wave = EnemyGroup(evil_bullets) player = Player(window_size, ship_filename, ship_speed) while 1: #limit framerate and prepare FPS display text clock.tick(max_framerate) fps = clock.get_fps() fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, white) score_text = sys_font.render("SCORE: {}".format(score), False, white) lives_text = sys_font.render("MANS: {}".format(lives), False, white) #check for QUIT event to prevent endless loopage for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() #call the game's thinking functions check_gameover() keyboard() evil_bullets.update() good_bullets.update() enemy_wave.update() collisions() #draw the stuff screen.fill(black) good_bullets.draw(screen) evil_bullets.draw(screen) enemy_wave.draw(screen) screen.blit(player.image, player.rect) screen.blit(score_text, score_text.get_rect(top = 0, left = 0)) screen.blit(lives_text, lives_text.get_rect(top = 0, centerx = width / 2)) screen.blit(fps_text, fps_text.get_rect(top = 0, right = width)) pygame.display.update()
class Time(object): """ A helper class for dealing with time. """ _instance = None def __init__(self): if Time._instance is None: Time._instance = self else: pass self._delta_time = 0 self._time_scale = 1 self._clock = Clock() def update(self): self._delta_time = self._clock.tick(Configuration.instance().frame_cap ) @property def delta_time(self): return self._delta_time / self.time_scale @property def time_scale(self): return self._time_scale @time_scale.setter def time_scale(self, time_scale): self._time_scale = time_scale @property def clock(self): return self._clock @property def frame_rate(self): """ :return: The frame rate which the game is current running. """ return self._clock.get_fps() @staticmethod def instance(): if Time._instance is None: Time._instance = Time() return Time._instance
class ClockController: """...""" def __init__(self, event_manager): self.event_manager = event_manager self.event_manager.register_listener(self) self._clock = Clock() self.application_active = True def run(self): while self.application_active: event = TickEvent(self._clock.tick(), self._clock.get_fps()) self.event_manager.post(event) def notify(self, event): if isinstance(event, QuitEvent): # this will stop the while loop from running self.application_active = False
class Game: #Constants #Properties world = None player = None display = None controls = None clock = None is_running = False fps = -1 def __init__(self): self.world = World() self.display = Display() self.controls = Controls() self.clock = Clock() self.fps = -1 #self.is_running = False ? def init(self): self.display.initWindow() self.world.loadTextWorld('sample') self.display.initMinimap(self.world) self.player = Player(Vector(self.world.starting_point)+0.5) def startLoop(self): time_to_exit = False while not time_to_exit: self.clock.tick(30) self.fps = self.clock.get_fps() keys = self.controls.getInput() self.player.move(self.world, keys) self.display.draw(self) time_to_exit = keys[self.controls.ESCAPE] def close(self): self.display.close()
import Camera from pygame.time import Clock running = True paused = False Game = Camera.Camera() gameClock = Clock() while running: while not paused: gameClock.tick(60) fps = gameClock.get_fps() Game.updateScreen(fps)
def run_game(): clock = Clock() pygame.init() pygame.font.init() game_state = GS(GS.INVASION) screen_state = ScS(ScS.NONE) ai_settings = Settings() screen = pygame.display.set_mode( (ai_settings.screen_width, ai_settings.screen_height)) pygame.display.set_caption("Faceless Invasion") # Make a player player = Player(ai_settings, screen) # Make a group to store daggers in daggers = Group() # Make a Faceless group faceless_horde = Group() # Create the horde of faceless gf.create_horde(ai_settings, screen, player, faceless_horde) black_screen = pygame.Surface( (ai_settings.screen_width, ai_settings.screen_height)) black_screen.fill((0, 0, 0)) black_screen.set_alpha(0) fade_alpha = 0 invasion_filename = 'images/Invasion Background.png' invasion_background = pygame.image.load(invasion_filename) invasion_background = pygame.transform.scale( invasion_background, (ai_settings.screen_width, ai_settings.screen_height)) shop_filename = 'images/Awakening Support Background.jpg' shop_background = pygame.image.load(shop_filename) shop_background = pygame.transform.scale( shop_background, (ai_settings.screen_width, ai_settings.screen_height)) shop_menu = ShopMenu(screen_state, ai_settings) while True: clock.tick(ai_settings.fps) # dt = clock.tick() # print(dt) gf.check_events(ai_settings, screen, player, daggers, game_state, screen_state, shop_menu) if game_state.get_state() == GS.INVASION or game_state.get_state( ) == GS.VICTORY: player.update(ai_settings) if game_state.get_state() == GS.INVASION: daggers.update() gf.update_daggers(ai_settings, screen, player, faceless_horde, daggers, game_state) gf.update_horde(ai_settings, faceless_horde) if screen_state.get_state() == ScS.FADE_OUT: if fade_alpha < 255: fade_alpha += ai_settings.fade_speed black_screen.set_alpha(fade_alpha) elif fade_alpha >= 255: if game_state.get_state() == GS.VICTORY: game_state.set_state(GS.SHOP) elif game_state.get_state() == GS.SHOP: game_state.set_state(GS.INVASION) gf.create_horde(ai_settings, screen, player, faceless_horde) screen_state.set_state(ScS.FADE_IN) if screen_state.get_state() == ScS.FADE_IN: if fade_alpha > 0: fade_alpha -= ai_settings.fade_speed black_screen.set_alpha(fade_alpha) elif fade_alpha <= 0: screen_state.set_state(ScS.NONE) gf.update_screen(ai_settings, screen, player, faceless_horde, daggers, black_screen, invasion_background, shop_background, shop_menu, game_state, screen_state) pygame.display.set_caption( "FPS: %i Game State: %s Screen State: %s" % (clock.get_fps(), game_state.get_name(), screen_state.get_name()))
class Scene: ''' Describe a Scene in a game. This is a base class for every scene in the game, has a main_loop that can be called from the main process and the functions start and update to controll the first and sucesives ticks respectively. ''' def __init__(self, screen: Surface): ''' Constructor of the class, takes the screen to gain control over the render of the game objects ''' # Get display info info = Info() # Get Clock to ensure frame rating self.clock = Clock() # The default return value of the Scene self.return_value = -1 # Set the continue condition self.running = True # Get the relevant information from info self.screen_h, self.screen_w = info.current_h, info.current_w # Set the screen of the Scene self.screen: Surface = screen # Main Sprite groups self.event_group = Group() self.update_group = Group() self.render_group = LayeredDirty() def start(self): ''' This function will is the first function called when the scene starts running, here you can configure the position and starting behaviour of your scene ''' pass def update(self): ''' This function will be called every tick of the game and needs to be overrided in every scene to fill the desired behaviour ''' pass def clear(self): ''' This function will be called on the end of the scene to clean any configuration or variables to the next scene. It will raise NotImplementedError if it's not implemented, at least needs a pass function if no work is needed ''' raise NotImplementedError def exit(self, return_value): ''' This function will end the scene and return the value to the parent ''' self.running = False self.return_value = return_value self.event_group.empty() self.update_group.empty() self.render_group.empty() self.clear() def main_loop(self): ''' This is the main loop of the scene, don't overrive if not necesary. Here you will find the main workflow for an scene ''' # Ensures the starts conditions self.running = True self.return_value = -1 # Calls the start function, to configurate the scene self.start() # Main loop of the scene while self.running: # Event catch # Set the event queue of the objet itself self.events = [] for e in event.get(): self.events.append(e) for s in self.event_group.sprites(): s.add_event(e) if e.type == QUIT: self.exit(-1) # Group update self.update_group.update(self.clock.get_time()) # Calls the update function for every tick of the game self.update() # Render group self.render_group.draw(self.screen) display.flip() # Ensure frame rate if DEBUG: print(self.clock.get_fps()) self.clock.tick(60) return self.return_value
class Game(): def __init__(self, framerate=0, surface_x=272, surface_y=153, scaler=4, debug=True): logging.info("Initializing game.") self.framerate = framerate if debug: logging.warn("Game loading in debug mode.") self.surface_x = surface_x * scaler self.surface_y = surface_y * scaler self.scaler = scaler self.debug = debug pygame.init() self.main_surface = pygame.display.set_mode( (self.surface_x, self.surface_y), pygame.HWSURFACE | pygame.DOUBLEBUF) self.clock = Clock() self.state = GameState.INTRO # self.font = pygame.font.Font( # join('assets', 'font', 'Diary-of-an-8-bit-mage.woff'), # 16) # self.font = pygame.font.SysFont("Courier", 16) self.font = pygame.font.Font( join('assets', 'font', 'C&C-Red-Alert-[INET].ttf'), 16) self.menue = Menue(self.main_surface, self.font) self.background = assets.load.image("parallax-mountain-bg.png") self.background = pygame.transform.scale( self.background, tuple(i * self.scaler for i in self.background.get_rect().size)) def run(self): """Start the game loop.""" while True: self.clock.tick(self.framerate) self.handle_events() self.update_state() self.display() #print(self.clock.get_fps()) def handle_events(self): """Event handler. Figures out what to do from the events it polled. """ for event in pygame.event.get(): if event.type == pygame.QUIT: self.quit() if event.type == pygame.KEYDOWN: if pygame.key.name(event.key) == 'escape': if self.state == GameState.INTRO: self.state = GameState.MAIN elif self.state == GameState.PAUSED: self.state = GameState.MAIN elif self.state == GameState.MAIN: self.state = GameState.PAUSED print(pygame.key.name(event.key)) def intro(self): self.main_surface.blit(self.background, (0, 0)) def update_state(self): if self.state == GameState.INTRO: self.intro() if self.state == GameState.MAIN: self.menue.draw('main') if self.state == GameState.PAUSED: self.menue.draw('paused') if self.state == GameState.RUNNING: pass def display_fps(self): fps_counter = "FPS: {0}".format(self.clock.get_fps()) fps_rendered = self.font.render(fps_counter, True, (0, 0, 0)) self.main_surface.blit(fps_rendered, (10, 10)) def display(self): if self.debug: self.display_fps() pygame.display.flip() def quit(self): """Handle all cleanup code.""" logging.info("Closing game.") pygame.quit() sys.exit()
class Game: """Object handling main loop and IO.""" def __init__(self, config): pygame.mixer.pre_init(frequency=44100) pygame.init() self.headless = config.headless and config.server if config.muted or self.headless: pygame.mixer.quit() else: pygame.mixer.music.load(NOISE if config.space else MUSIC) pygame.mixer.music.set_volume(config.musicvol) pygame.mixer.music.play(-1) pygame.display.set_icon(ICON) if config.server: self.server = socket() self.server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.server.bind((config.host, config.port)) self.server.listen(1) print('Socket server is listening on {}:{}'.format(config.host, config.port)) self.timeout = config.timeout self.sockinp = 0, 0, -pi * 3 / 4, 0, 0 # freeze and point to NW else: self.server = self.sockinp = None # self.fps is a float to make sure floordiv won't be used in Python 2 self.max_fps, self.fps = config.max_fps, float(config.max_fps) self.musicvol = config.musicvol self.key, self.mouse = config.key, config.mouse self.maze = Maze(config.max_fps, config.size, config.headless, config.export_dir, 1000.0 / config.export_rate) self.hero = self.maze.hero self.clock, self.paused = Clock(), False def __enter__(self): return self def export_txt(self): """Export maze data to string.""" export = self.maze.update_export(forced=True) return '{} {} {} {}\n{}{}{}{}'.format( len(export['m']), len(export['e']), len(export['b']), export['s'], ''.join(row + '\n' for row in export['m']), join(export['h']), ''.join(map(join, export['e'])), ''.join(map(join, export['b']))) def update(self): """Draw and handle meta events on Pygame window. Return False if QUIT event is captured, True otherwise. """ events = pygame.event.get() for event in events: if event.type == QUIT: return False elif event.type == VIDEORESIZE: self.maze.resize((event.w, event.h)) elif event.type == KEYDOWN: if event.key == self.key['mute']: if pygame.mixer.get_init() is None: pygame.mixer.init(frequency=44100) pygame.mixer.music.load(MUSIC) pygame.mixer.music.set_volume(self.musicvol) pygame.mixer.music.play(-1) else: pygame.mixer.quit() elif not self.server: if event.key == self.key['new']: self.maze.reinit() elif event.key == self.key['pause'] and not self.hero.dead: self.paused ^= True # Compare current FPS with the average of the last 10 frames new_fps = self.clock.get_fps() if new_fps < self.fps: self.fps -= 1 elif self.fps < self.max_fps and not self.paused: self.fps += 5 if not self.paused: self.maze.update(self.fps) if not self.headless: self.maze.draw() self.clock.tick(self.fps) return True def move(self, x, y): """Command the hero to move faster in the given direction.""" maze = self.maze velocity = maze.distance * HERO_SPEED / self.fps accel = velocity * HERO_SPEED / self.fps if x == y == 0: maze.set_step() x, y = maze.stepx, maze.stepy else: x, y = -x, -y # or move the maze in the reverse direction if maze.next_move > 0 or not x: maze.vx -= sign(maze.vx) * accel if abs(maze.vx) < accel * 2: maze.vx = 0.0 elif x * maze.vx < 0: maze.vx += x * 2 * accel else: maze.vx += x * accel if abs(maze.vx) > velocity: maze.vx = x * velocity if maze.next_move > 0 or not y: maze.vy -= sign(maze.vy) * accel if abs(maze.vy) < accel * 2: maze.vy = 0.0 elif y * maze.vy < 0: maze.vy += y * 2 * accel else: maze.vy += y * accel if abs(maze.vy) > velocity: maze.vy = y * velocity def control(self, x, y, angle, firing, slashing): """Control how the hero move and attack.""" self.move(x, y) self.hero.update_angle(angle) self.hero.firing = firing self.hero.slashing = slashing def remote_control(self): """Handle remote control though socket server. This function is supposed to be run in a Thread. """ clock = Clock() while True: connection, address = self.server.accept() connection.settimeout(self.timeout) time = get_ticks() print('[{}] Connected to {}:{}'.format(time, *address)) self.maze.reinit() while True: if self.hero.dead: connection.send('0000000'.encode()) break data = self.export_txt().encode() alpha = deg(self.hero.angle) connection.send('{:07}'.format(len(data)).encode()) connection.send(data) try: buf = connection.recv(7) except: # client is closed or timed out break if not buf: break try: move, angle, attack = map(int, buf.decode().split()) except ValueError: # invalid input break y, x = (i - 1 for i in divmod(move, 3)) # Time is the essence. angle = self.hero.angle if angle == alpha else radians(angle) self.sockinp = x, y, angle, attack & 1, attack >> 1 clock.tick(self.fps) self.sockinp = 0, 0, -pi * 3 / 4, 0, 0 new_time = get_ticks() print('[{0}] {3}:{4} scored {1} points in {2}ms'.format( new_time, self.maze.get_score(), new_time - time, *address)) connection.close() if not self.hero.dead: self.maze.lose() def user_control(self): """Handle direct control from user's mouse and keyboard.""" if not self.hero.dead: keys = pygame.key.get_pressed() right = keys[self.key['right']] - keys[self.key['left']] down = keys[self.key['down']] - keys[self.key['up']] buttons = pygame.mouse.get_pressed() try: autove = keys[self.key['autove']] except KeyError: autove = buttons[self.mouse['autove']] try: firing = keys[self.key['shot']] except KeyError: firing = buttons[self.mouse['shot']] try: slashing = keys[self.key['slash']] except KeyError: slashing = buttons[self.mouse['slash']] # Follow the mouse cursor x, y = pygame.mouse.get_pos() maze = self.maze if right or down: maze.destx = maze.desty = MIDDLE maze.stepx = maze.stepy = 0 elif autove: maze.destx, maze.desty = maze.get_grid(x, y) maze.set_step(maze.is_displayed) if maze.stepx == maze.stepy == 0: maze.destx = maze.desty = MIDDLE angle = atan2(y - self.hero.y, x - self.hero.x) self.control(right, down, angle, firing, slashing) def __exit__(self, exc_type, exc_value, traceback): if self.server is not None: self.server.close() if not self.hero.dead: self.maze.dump_records() pygame.quit()
class StatusBar(object): pausestring = _(u'*** PAUSED ***') timestrings = [ _(u'\u2155 speed'), _(u'\u00bd speed'), _(u'Normal speed'), _(u'2\u00d7 speed'), _(u'5\u00d7 speed') ] fpsstring = _(u'{num:d} {g}FPS') def __init__(self, game, player, prefs): self.game = game player.history.setcrier(self._eventcrier) self._prefs = prefs self.sprites = LayeredDirty() self.scale(self._prefs.font) self.clock = Clock() self.lasttime = None self.fps = deque() def _eventcrier(self, event): text = event.description contd = False width = self.background.get_width() while True: try: self.announcesprite.image = self.font.render(text + ('...' if contd else ''), True, (255, 255, 255)) except error: self.announcesprite.image = None if (self.announcesprite.image and self.announcesprite.image.get_width() < width): break words = text.split() if len(words) == 1: if len(words[0]) <= 1: break text = words[0][:-1] contd = True else: text = ' '.join(words[:-1]) contd = True self.announcesprite.rect = self.announcesprite.image.get_rect() self.announcesprite.dirty = 1 self.announcesprite.time = time() def _sprite(self, text, x, y, color = None): color = color if color is not None else (255,255,255) sprite = DirtySprite() sprite.image = self.font.render(text, True, color) sprite.rect = sprite.image.get_rect().move(x, y) return sprite def scale(self, font): self.font = font self.sprites.empty() x = 0 self.announcesprite = self._sprite(' ', x, 0) self.announcesprite.time = None self.sprites.add(self.announcesprite) y = self.announcesprite.rect.height self.pausesprite = self._sprite(self.pausestring, x, y) x += self.pausesprite.rect.width self.timesprites = [self._sprite(t, x, y) for t in self.timestrings] x += max([s.rect.width for s in self.timesprites]) self.fpssprites = [self._sprite(self.fpsstring.format(num=9999, g=g), x, y) for g in '','G'] self.fpssprites[1].rect.move_ip(self.fpssprites[1].rect.width, 0) apply(self.sprites.add, [self.pausesprite] + self.timesprites + self.fpssprites) self._dirty() def _dirty(self): self.paused = None self.timeindex = -1 def resize(self, size): self.background = Surface(size, flags=SRCALPHA) self.background.fill((0,0,0)) self._dirty() def draw(self, surface): t = time() if (self.announcesprite.time and t - self.announcesprite.time > self._prefs.announcementtimeout): self.announcesprite.image.fill((0,0,0)) self.announcesprite.dirty = True self.announcesprite.time = None paused = self.game.paused if self.paused != paused: self.paused = paused self.pausesprite.visible = self.paused self.pausesprite.dirty = True timeindex = self.game.timescales.index(0.1 / self.game.dt) if self.timeindex != timeindex: self.timeindex = timeindex for i in range(len(self.timesprites)): self.timesprites[i].visible = i == self.timeindex self.timesprites[i].dirty = True self.fps.clear() if not self.lasttime: self.lasttime = self.game.world.time, t else: if self.paused: fps = 0 self.lasttime = self.game.world.time, t else: frames = self.game.world.time - self.lasttime[0] secs = t - self.lasttime[1] if secs > 0: if len(self.fps) > 20: self.fps.popleft() self.fps.append(frames/secs) fps = sum(self.fps)/len(self.fps) else: fps = None self.lasttime = self.game.world.time, t if fps is not None: image = self.font.render( self.fpsstring.format(num=int(fps+0.5), g=''), True, (255,255,255)) self.fpssprites[0].image.fill((0,0,0)) self.fpssprites[0].image.blit(image, (self.fpssprites[0].rect.width- image.get_width(), 0)) self.fpssprites[0].dirty = True image = self.font.render( self.fpsstring.format(num=int(self.clock.get_fps()+0.5), g='G'), True, (255,255,255)) self.fpssprites[1].image.fill((0,0,0)) self.fpssprites[1].image.blit(image, (self.fpssprites[1].rect.width- image.get_width(), 0)) self.fpssprites[1].dirty = True self.sprites.clear(surface, self.background) self.sprites.draw(surface) self.clock.tick()
def Game_loop(): size = DISPLAY_WIDTH / 16.0 posx = (DISPLAY_WIDTH - (size // 2) * 17) * 27 // 100 posy = 0 court = generate_court(size=size, start_posx=posx, start_posy=posy) snake = [(8, 18, 9), (8, 16, 8), (8, 14, 7)] prey = 0 button_group = Group() left_button = Text(text=u'<', x=5, y=50, size=22, font_file='a_Albionic.ttf', color=(250, 250, 250), surface=screen) right_button = Text(text=u'>', x=85, y=50, size=22, font_file='a_Albionic.ttf', color=(250, 250, 250), surface=screen) button_group.add(left_button, right_button) menu_button = Hexagon_Button(lable=u'меню', posx=87, posy=2, font_size=3, font_file='a_Albionic.ttf', color=(35, 125, 30), text_color=(210, 205, 10), border_color=(210, 205, 10)) wasted = Text(text=u'Потрачено!', x=6, y=35, size=7, font_file='a_Albionic.ttf', color=(250, 150, 120), surface=screen) win = Text(text=u'Победа!', x=20, y=35, size=14, font_file='a_Albionic.ttf', color=(250, 150, 120), surface=screen) points_label = Text(text=u'Очки: 0', x=2, y=2, size=3, font_file='a_Albionic.ttf', color=(85, 170, 10), surface=screen) fps = Text(text=u'', x=5, y=2, size=2, font_file='a_Albionic.ttf', color=(85, 170, 10), surface=screen) apple_eat_sound = mixer.Sound('sounds/Apple_eat.ogg') apple_eat_sound.set_volume(1.0) finally_background = Surface((DISPLAY_WIDTH, DISPLAY_HEIGHT)) vector = 1 alpha = 0 id = 8 x = 14 y = 7 dt = 0 clock = Clock() done = False while not done: mp = mouse.get_pos() for event in get(): if event.type == QUIT: done = True continue if event.type == KEYDOWN: if vector > 0: if event.key == K_LEFT: vector -= 1 if event.key == K_RIGHT: vector += 1 if event.type == MOUSEBUTTONDOWN: if vector > 0: if left_button.rect.collidepoint(mp): vector -= 1 elif right_button.rect.collidepoint(mp): vector += 1 if menu_button.rect.collidepoint(mp): done = True continue if vector < 1 and vector > -1: vector = 6 elif vector > 6: vector = 1 if not prey: prey = choice(tuple(court)) while prey.id_and_pos in snake: prey = choice(tuple(court)) if dt > 400: dt = 0 if vector == 1: x -= 2 y -= 1 elif vector == 2: x -= 1 if x % 2 != 0: y -= 1 id += 1 elif vector == 3: x += 1 if x % 2 == 0: y += 1 id += 1 elif vector == 4: x += 2 y += 1 elif vector == 5: x += 1 if x % 2 == 0: y += 1 id -= 1 elif vector == 6: x -= 1 if x % 2 != 0: y -= 1 id -= 1 next_step = (id, x, y) if next_step not in snake: if prey.id_and_pos != next_step: snake.append(next_step) snake.pop(0) else: snake.append(next_step) apple_eat_sound.play(0) points_label.set_text(text=u'Очки: %s' % str(len(snake) - 3)) prey = 0 #if len(snake) > 13: # vector = -1 #delay(10) else: vector = -1 if id < 0 or id > 16 or y < 0 or y > 9: vector = -1 screen.fill((20, 20, 40)) court.update(screen, snake, prey) if vector == -1: if alpha < 200: alpha += 3 finally_background.set_alpha(alpha) screen.blit(finally_background, (0, 0)) #if len(snake) < 12: # wasted.draw() #else: # win.draw() wasted.set_text(text=u'Уничтожено %s жертв!' % str(len(snake) - 3)) wasted.draw() fps.set_text(u'FPS: %s' % clock.get_fps()) fps.draw() button_group.draw(screen) menu_button.draw(screen, mp) points_label.draw() window.blit(screen, (0, 0)) flip() clock.tick(40) dt += clock.get_tick()
class Instance: log = Logger(__name__).get() def __init__(self, caption: str = 'kappa game'): pygame.init() self.info = pygame.display.Info() Instance.log.info(self.info) self.caption: str = caption self.clock: Clock = None self.screen: Screen = None self.running = True self.max_fps = 0 def init(self): self.clock = Clock() pygame.display.set_caption(self.caption) self.screen.init() def start(self): while self.running: self.__tick() def destroy(self): if pygame.font.get_init(): pygame.font.quit() pygame.quit() @timed def __tick(self): self.clock.tick(self.max_fps) self.__handle_events() self.__update() self.__display() @timed def __handle_events(self): for event in pygame.event.get(): Instance.log.debug("Caught Event = {}".format(event)) if not self.parse_event(event): self.running = False def parse_event(self, event): return 1 @timed def __update(self): self.update() def update(self): self.screen.update() @timed def __display(self): self.screen.display() pygame.display.flip() Instance.log.debug("Current FPS : {}".format(self.fps)) @property def fps(self): return self.clock.get_fps()
def main(): pygame.init() directory = Path(__file__).parent font = Font(str(directory.joinpath("demo_font.dfont")), 13) screen_size = (500, 500) dialog_margin = 30 dialog_padding = 5 outer_dialog_size = (screen_size[0] - dialog_margin * 2, 330) dialog_size = (outer_dialog_size[0] - dialog_padding * 2, outer_dialog_size[1] - dialog_padding * 2) picture_component_size = (dialog_size[0], 200) screen = pygame.display.set_mode(screen_size) dialog_surface = Surface(dialog_size) dialog_pos = (dialog_margin + dialog_padding, dialog_margin + dialog_padding) dialog_rect = Rect(dialog_pos, dialog_size) images = { "demo1_background": filled_surface(picture_component_size, (0, 50, 35)) } animations = {"demo1_animation": create_animation(picture_component_size)} text_blip_sound = load_sound("blip.ogg") select_blip_sound = load_sound("blip_2.ogg") select_blip_sound_id = "blip" sound_player = SoundPlayer( sounds={select_blip_sound_id: select_blip_sound}, text_blip_sound=text_blip_sound) dialog_closed_node_id = "DIALOG_CLOSED" dialog_graph = DialogGraph( root_node_id="ROOT", nodes=[ DialogNode( node_id="ROOT", text= "This is a minimal demo app. Let this text slowly appear or click any key to skip it. " "Use the UP/DOWN keys to switch between your dialog choices, and click RETURN to go " "for that choice. Or you could just use the mouse!", choices=[ DialogChoice("See this dialog again", "ROOT"), DialogChoice("Close dialog", dialog_closed_node_id) ], graphics=NodeGraphics(animation_id="demo1_animation")), DialogNode(node_id=dialog_closed_node_id, text="", choices=[], graphics=NodeGraphics(animation_id="demo1_animation")), ], title="DEMO 1", background_image_id="demo1_background") pygame.display.set_caption(dialog_graph.title) dialog_component = DialogComponent( surface=dialog_surface, dialog_font=font, choice_font=font, images=images, animations=animations, sound_player=sound_player, dialog_graph=dialog_graph, picture_size=picture_component_size, select_blip_sound_id=select_blip_sound_id) clock = Clock() is_dialog_shown = True while True: elapsed_time = Millis(clock.tick()) for event in pygame.event.get(): if event.type == pygame.QUIT: _exit_game() elif event.type == pygame.KEYDOWN: if is_dialog_shown: dialog_component.skip_text() if event.key == pygame.K_RETURN: dialog_component.commit_selected_choice() if dialog_component.current_node_id( ) == dialog_closed_node_id: is_dialog_shown = False elif event.key == pygame.K_DOWN: dialog_component.move_choice_selection(1) elif event.key == pygame.K_UP: dialog_component.move_choice_selection(-1) elif event.type == pygame.MOUSEBUTTONDOWN: ui_coordinates = translate_screen_to_ui_coordinates( dialog_rect, pygame.mouse.get_pos()) if ui_coordinates: dialog_component.commit_choice_at_position(ui_coordinates) if dialog_component.current_node_id( ) == dialog_closed_node_id: is_dialog_shown = False elif event.type == pygame.MOUSEMOTION: ui_coordinates = translate_screen_to_ui_coordinates( dialog_rect, pygame.mouse.get_pos()) if ui_coordinates: dialog_component.select_choice_at_position(ui_coordinates) if is_dialog_shown: dialog_component.update(elapsed_time) dialog_component.redraw() screen.fill(BLACK) if is_dialog_shown: screen.blit(dialog_component.surface, dialog_pos) pygame.draw.rect(screen, (255, 100, 100), Rect((dialog_margin, dialog_margin), outer_dialog_size), width=1) fps_string = str(int(clock.get_fps())).rjust(3, ' ') rendered_fps = font.render(f"FPS: {fps_string}", True, WHITE, (0, 0, 0)) screen.blit(rendered_fps, (5, 5)) screen.blit( font.render( "The dialog library is confined to the red rectangle above.", True, WHITE), (15, 400)) screen.blit( font.render("This text is handled separately from the dialog.", True, WHITE), (15, 430)) if not is_dialog_shown: screen.blit( font.render( "Oops, you closed the dialog. Restart app to see it again.", True, (255, 150, 150)), (15, 460)) pygame.display.update()
class Game: """Object handling main loop and IO.""" def __init__(self, config: ConfigReader): pygame.init() self.headless = config.headless and config.server if not self.headless: pygame.display.set_icon(ICON) self.actx = None if self.headless else Context(Device()) self._mute = config.muted if config.server: self.server = socket() self.server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.server.bind((config.host, config.port)) self.server.listen(1) print('Socket server is listening on {}:{}'.format( config.host, config.port)) self.timeout = config.timeout self.sockinp = 0, 0, -pi * 3 / 4, 0, 0 # freeze and point to NW else: self.server = self.sockinp = None self.max_fps, self.fps = config.max_fps, config.max_fps self.musicvol = config.musicvol self.touch = config.touch self.key, self.mouse = config.key, config.mouse self.maze = Maze(config.max_fps, config.size, config.headless, config.export_dir, 1000 / config.export_rate) self.hero = self.maze.hero self.clock, self.paused = Clock(), False def __enter__(self): if self.actx is not None: use_context(self.actx) self.actx.listener.position = MIDDLE, -MIDDLE, 0 self.actx.listener.gain = not self._mute self._source = play(SFX_NOISE) self._source.looping = True return self def __exit__(self, exc_type, exc_value, traceback): if self.server is not None: self.server.close() if not self.hero.dead: self.maze.dump_records() if self.actx is not None: free(SFX) self._source.stop() self.actx.update() use_context(None) self.actx.destroy() self.actx.device.close() pygame.quit() @property def mute(self): """Mute state.""" return getattr(self, '_mute', 1) @mute.setter def mute(self, value): """Mute state.""" self._mute = int(bool(value)) self.actx.listener.gain = not self._mute def export_txt(self): """Export maze data to string.""" export = self.maze.update_export(forced=True) return '{} {} {} {}\n{}{}{}{}'.format( len(export['m']), len(export['e']), len(export['b']), export['s'], ''.join(row + '\n' for row in export['m']), join(export['h']), ''.join(map(join, export['e'])), ''.join(map(join, export['b']))) def update(self): """Draw and handle meta events on Pygame window. Return False if QUIT event is captured, True otherwise. """ events = pygame.event.get() for event in events: if event.type == QUIT: return False elif event.type == VIDEORESIZE: self.maze.resize((event.w, event.h)) elif event.type == KEYDOWN: if event.key == self.key['mute']: self.mute ^= 1 elif not self.server: if event.key == self.key['new']: self.maze.reinit() elif event.key == self.key['pause'] and not self.hero.dead: self.paused ^= True elif event.type == MOUSEBUTTONUP and self.touch: # We're careless about which mouse button is clicked. maze = self.maze if self.hero.dead: maze.reinit() else: x, y = pygame.mouse.get_pos() maze.destx, maze.desty = maze.get_grid(x, y) if maze.set_step(maze.isdisplayed): maze.target = maze.get_target(x, y) self.hero.firing = not maze.target.retired if maze.stepx == maze.stepy == 0: maze.destx = maze.desty = MIDDLE # Compare current FPS with the average of the last 10 frames new_fps = self.clock.get_fps() if new_fps < self.fps: self.fps -= 1 elif self.fps < self.max_fps and not self.paused: self.fps += 5 if not self.paused: self.maze.update(self.fps) if not self.headless: self.maze.draw() self.clock.tick(self.fps) self.actx.update() return True def move(self, x=0, y=0): """Command the hero to move faster in the given direction.""" maze = self.maze velocity = maze.distance * HERO_SPEED / self.fps accel = velocity * HERO_SPEED / self.fps if x == y == 0: maze.set_step() x, y = maze.stepx, maze.stepy else: x, y = -x, -y # or move the maze in the reverse direction if maze.next_move > 0 or not x: maze.vx -= sign(maze.vx) * accel if abs(maze.vx) < accel * 2: maze.vx = 0.0 elif x * maze.vx < 0: maze.vx += x * 2 * accel else: maze.vx += x * accel if abs(maze.vx) > velocity: maze.vx = x * velocity if maze.next_move > 0 or not y: maze.vy -= sign(maze.vy) * accel if abs(maze.vy) < accel * 2: maze.vy = 0.0 elif y * maze.vy < 0: maze.vy += y * 2 * accel else: maze.vy += y * accel if abs(maze.vy) > velocity: maze.vy = y * velocity def control(self, x, y, angle, firing, slashing): """Control how the hero move and attack.""" self.move(x, y) self.hero.update_angle(angle) self.hero.firing = firing self.hero.slashing = slashing def remote_control(self): """Handle remote control though socket server. This function is supposed to be run in a Thread. """ clock = Clock() while True: connection, address = self.server.accept() connection.settimeout(self.timeout) time = get_ticks() print('[{}] Connected to {}:{}'.format(time, *address)) self.maze.reinit() while True: if self.hero.dead: connection.send('0000000'.encode()) break data = self.export_txt().encode() alpha = deg(self.hero.angle) connection.send('{:07}'.format(len(data)).encode()) connection.send(data) try: buf = connection.recv(7) except: # client is closed or timed out break if not buf: break try: move, angle, attack = map(int, buf.decode().split()) except ValueError: # invalid input break y, x = (i - 1 for i in divmod(move, 3)) # Time is the essence. angle = self.hero.angle if angle == alpha else radians(angle) self.sockinp = x, y, angle, attack & 1, attack >> 1 clock.tick(self.fps) self.sockinp = 0, 0, -pi * 3 / 4, 0, 0 new_time = get_ticks() print('[{0}] {3}:{4} scored {1} points in {2}ms'.format( new_time, self.maze.get_score(), new_time - time, *address)) connection.close() if not self.hero.dead: self.maze.lose() def touch_control(self): """Handle touch control.""" maze, hero = self.maze, self.hero if maze.target.retired: hero.firing = False if hero.firing: x, y = maze.get_pos(maze.target.x, maze.target.y) else: x, y = pygame.mouse.get_pos() hero.update_angle(atan2(y - hero.y, x - hero.x)) self.move() def user_control(self): """Handle direct control from user's mouse and keyboard.""" if self.hero.dead: return keys = pygame.key.get_pressed() buttons = pygame.mouse.get_pressed() right = keys[self.key['right']] - keys[self.key['left']] down = keys[self.key['down']] - keys[self.key['up']] x, y = pygame.mouse.get_pos() angle = atan2(y - self.hero.y, x - self.hero.x) try: firing = keys[self.key['shot']] except KeyError: firing = buttons[self.mouse['shot']] try: slashing = keys[self.key['slash']] except KeyError: slashing = buttons[self.mouse['slash']] self.control(right, down, angle, firing, slashing)
class Application(object): """ @type _config: configparser.ConfigParser @type _display: pygame.Surface @type _manager: Manager @type _scene: AbstractScene @type _clock: Clock @type _camera: Camera @type _run: bool @type _state: int """ _config = None _display = None _manager = None _scene = None _clock = None _camera = None _state = GAME_STATE_LOADING _run = False def __init__(self, config): """ @type config: configparser.ConfigParser """ self._config = config self._manager = Manager(self) pygame.mixer.init() pygame.init() def init(self): config_display = self._config["DISPLAY"] display_width = int(config_display.get("width", 800)) display_height = int(config_display.get("height", 600)) display_tup = (display_width, display_height) pygame.init() fullscreen = int(config_display.get("fullscreen", 0)) display_flags = DOUBLEBUF | HWSURFACE if fullscreen == 1: display_flags |= FULLSCREEN videoinfo = pygame.display.Info() # we have to limit our display to FullHD, to use only one monitor untill pygame with SDL > 1.2.14 released display_tup = (min(videoinfo.current_w, 1920), min(videoinfo.current_h, 1080)) self._display = pygame.display.set_mode(display_tup, display_flags) self._camera = Camera(self._display.get_size()) self._clock = Clock() self.set_scene(self._manager.get_scene(MainMenuScene)) def get_display(self): return self._display def get_camera(self): return self._camera def set_state(self, state): """ @type state: int """ self._state = state def get_state(self): return self._state def set_scene(self, scene: AbstractScene): self._scene = scene def running(self): return bool(self._run) def run(self, run=False): self._run = run while self.running(): events = pygame.event.get() for e in events: if e.type == EVENT_LOAD_MAP: camera = self._manager.get_camera() map_loading_thread = slg.map.map.MapLoadingThread( e.map_name, slg.map.map.Map(self._manager), camera ) map_loading_thread.start() if e.type == QUIT: self._run = False if e.type == KEYDOWN: if e.key == K_F4 and pygame.key.get_mods() & pygame.KMOD_ALT: self._run = False if e.key == K_t and pygame.key.get_mods() & pygame.KMOD_ALT: print(self.get_state()) self._manager.handle(events) if self._scene: self._scene.handle_events(events) self._scene.draw() pygame.display.update() pygame.display.set_caption( "FPS: %.2f" % (self._clock.get_fps()) + "ticks: %.2f" % (self._clock.tick(FPS)) ) def get_time(self): return self._clock.get_time()
class Camera(): def __init__(self, name, shots=[], dir="figs", comic_strip=None): self.dir = os.path.join(os.getcwd(), dir) if not os.path.exists(self.dir): os.makedirs(self.dir) self.clock = Clock() self.name = name try: self.shots = sorted(shots) self.remaining_shots = sorted(shots) except TypeError: self.shots = shots self.remaining_shots = shots self.total_ticks = 0 self.made_comic_strip = False self.comic_strip = comic_strip def set_window(self, window): self.window = window def is_shooting(self): # print(self.shots, self.remaining_shots, self.made_comic_strip, self.comic_strip) if self.shots and not self.remaining_shots and ( self.made_comic_strip or not self.comic_strip): return False else: return True def indexes(self): if type(self.shots) == int: return range(0, self.shots) else: return range(0, len(self.shots)) def make_comic_strip(self): # https://stackoverflow.com/questions/30227466/combine-several-images-horizontally-with-python import sys from PIL import Image image_files = [ os.path.join(self.dir, self.name + str(idx) + ".png") for idx in self.indexes() ] images = list(map(Image.open, image_files)) width, height = images[0].size total_width = width * self.comic_strip max_height = height * int(ceil(len(images) / float(self.comic_strip))) new_im = Image.new('RGB', (total_width, max_height)) for i, im in enumerate(images): x_offset = (i % self.comic_strip) * width y_offset = (i // self.comic_strip) * height # print('offsets',(x_offset,y_offset)) new_im.paste(im, (x_offset, y_offset)) new_im.save(os.path.join(self.dir, self.name + '_comic_strip.png')) self.made_comic_strip = True def should_shoot(self): if type(self.remaining_shots) == int: return self.get_fps() > 0 and (self.remaining_shots > 0) else: return (self.remaining_shots and self.total_ticks >= self.remaining_shots[0]) def shoot(self): if type(self.remaining_shots) == int: idx = self.shots - self.remaining_shots self.remaining_shots = self.remaining_shots - 1 else: idx = self.shots.index(self.remaining_shots[0]) self.remaining_shots.pop(0) # print('taking shot', idx) image_name = os.path.join(self.dir, self.name + str(idx) + ".png") save(self.window, image_name) def tick(self): res = self.clock.tick() self.total_ticks += res # print("tick", self.total_ticks, self.remaining_shots) if self.should_shoot(): self.shoot() elif self.comic_strip and not self.made_comic_strip and not self.remaining_shots: # print('making comic strip') self.make_comic_strip() return res def get_fps(self): return self.clock.get_fps()
if collision_pnt: e1.collide(e2.id, collision_pnt) e2.collide(e1.id, collision_pnt) entity_control.kill_finalize() player = entity_control.entity_dict[player_id] camera.set_pos(player.pos-player.velocity*delta) #draw loop draw_list = Draw_Call_List() for e in entity_control.yield_entities(): draw_list.append(e.draw(debug)) draw_list.draw() draw.draw_text(str(clock/1000.0), (0,0), 255, 255, 255) draw.draw_text(str(fps_clock.get_fps()), (40,0), 255, 255, 255) draw.draw_text(str(map(int, player.pos.tuple())), (0,30), 255, 255, 255) draw.draw_text(str(input.player_move), (0,15), 255, 255, 255) delta = fps_clock.get_time() fps_clock.tick() draw.flip() pygame.quit()
class Visualization: def __init__(self, engine): self.running = True self.display_surf = None self.size = self.width, self.height = 800, 600 self.center = self.width / 2, self.height / 2 self.clock = Clock() self.font = None self.engine = engine self.engine.on_simulation_step = self.build_scene self.scene = [] self.target_fps = 60.0 self.focused_car = 0 self.metadata = [] def on_init(self): pygame.init() pygame.font.init() self.display_surf = pygame.display.set_mode( self.size, pygame.HWSURFACE | pygame.DOUBLEBUF) self.running = True self.font = pygame.font.Font(pygame.font.get_default_font(), 12) self.sprites = [ Sprite("images/blue-small.png"), Sprite("images/orange-small.png"), ] self.engine.restart() def build_scene(self, engine): self.scene = [] self.metadata = [] # if there are no cars break if not self.engine.cars or len(self.engine.cars) == 0: self.scene.append((self.center, 0, self.sprites[0])) return if self.focused_car >= len(self.engine.cars): self.focused_car = 0 center = self.engine.cars[self.focused_car].position for idx, car in enumerate(self.engine.cars): car_pos = self.center - (center - car.position) * meter2pixel self.scene.append( (car_pos, car._angle, self.sprites[idx % len(self.sprites)])) self.metadata.append(((int(car_pos.x), int(car_pos.y)), 0)) # for v in car.vertices(): # relpos = self.center - (center-v) * meter2pixel # self.metadata.append((relpos.astype(np.int), 1)) if car == self.engine.cars[self.focused_car]: for s in car._sensors: if isinstance(s, LidarSensor): for v in s._intersections: if v is not None: relpos = self.center - (center - v) * meter2pixel self.metadata.append( (relpos.astype(np.int), 1)) def on_event(self, event): if event.type == pygame.QUIT: self.running = False if event.type == pygame.KEYDOWN: pressed = pygame.key.get_pressed() if pressed[pygame.K_ESCAPE]: self.running = False if pressed[pygame.K_SPACE]: if self.engine.is_running: self.engine.interrupt() else: self.engine.run() if pressed[pygame.K_x]: self.engine.restart() if pressed[pygame.K_TAB]: self.move_focus() def move_focus(self): self.focused_car += 1 self.build_scene(self.engine) def on_loop(self): pass def on_render(self): self.display_surf.fill(pygame.Color(0, 0, 0)) for pos, angle, sprite in self.scene: rotated = pygame.transform.rotate(sprite.image, angle) rect = rotated.get_rect() relpos = pos - (rect.width / 2, rect.height / 2) self.display_surf.blit(rotated, relpos) for pos, typ in self.metadata: if typ == 0: pygame.draw.circle(self.display_surf, (255, 0, 0), pos, 3) if typ == 1: pygame.draw.circle(self.display_surf, (0, 255, 0), pos, 3) # FPS writing fps_surface = self.font.render( "{:.0f} FPS".format(self.clock.get_fps()), True, (255, 255, 255)) self.display_surf.blit( fps_surface, (self.display_surf.get_width() - fps_surface.get_width(), 0)) # Simulation steps writing step_surface = self.font.render( "{} steps".format(self.engine.step_count), True, (255, 255, 255)) self.display_surf.blit( step_surface, (self.display_surf.get_width() - step_surface.get_width(), fps_surface.get_height() + 5)) # Simulation control keys lines = '''SPACE - start/stop simulation X - restart simulation TAB - move focus ESC - quit''' y = 5 for line in lines.split('\n'): text = self.font.render(line.strip(), True, (255, 255, 255)) self.display_surf.blit(text, (5, y)) y += 5 + text.get_height() pygame.display.flip() self.clock.tick(self.target_fps) def on_cleanup(self): pygame.quit() def on_execute(self): if self.on_init() == False: self.running = False while (self.running): for event in pygame.event.get(): self.on_event(event) self.on_loop() self.on_render() self.on_cleanup()
def main(): pygame.init() screen = pygame.display.set_mode(SCREEN_RESOLUTION) clock = Clock() set_timer(USEREVENT_EACH_SECOND, 1000) font = Font('resources/Arial Rounded Bold.ttf', 14) background_color = (0, 0, 0) grid = BackgroundGrid(SCREEN_RESOLUTION, Color(20, 20, 20), 32) fps_text = FormattedText(font, COLOR_WHITE, "FPS: %i", 0) debug_texts = [ fps_text, StaticText(font, COLOR_WHITE, "debug: 2"), StaticText(font, COLOR_WHITE, "debug: 3"), ] debug_window = ListContainer(width=200, height="fit_contents", children=debug_texts, margin=5, padding=5, orientation=Orientation.VERTICAL, style=Style(border_color=COLOR_WHITE)) left_buttons = [ button(font, (200, 48), callback=lambda: print("hello"), label="click"), button(font, (200, 48), callback=lambda: print("hello"), label="click"), button(font, (200, 48), callback=lambda: print("hello"), label="click"), ] counter = Counter((50, 50), FormattedText(font, COLOR_WHITE, "%i", 0), style=Style(background_color=Color(100, 100, 100))) right_buttons = [ button(font, (200, 32), callback=lambda: counter.increment(), label="Increment (I)", hotkey=pygame.K_i), button(font, (200, 32), callback=lambda: counter.decrement(), label="Decrement (D)", hotkey=pygame.K_d), checkbox(font, (200, 32), callback=lambda checked: debug_window.set_visible(checked), label="Show debug", checked=debug_window.is_visible()), checkbox(font, (200, 32), callback=lambda checked: print("B: %s" % checked), label="B"), checkbox(font, (200, 32), callback=lambda checked: print("C: %s" % checked), label="C"), checkbox(font, (200, 32), callback=lambda checked: print("D: %s" % checked), label="D"), checkbox(font, (200, 32), callback=lambda checked: print("E: %s" % checked), label="E"), checkbox(font, (200, 32), callback=lambda checked: print("F: %s" % checked), label="F"), ] left_menu_bar = ListContainer(width="fit_contents", height="fill_parent", children=left_buttons, margin=5, padding=5, orientation=Orientation.VERTICAL, style=Style(background_color=Color( 150, 150, 255), border_color=COLOR_WHITE)) right_menu_bar = ScrollContainer(height=166, children=right_buttons, margin=5, padding=5, orientation=Orientation.VERTICAL, style=Style(background_color=Color( 150, 210, 255), border_color=COLOR_WHITE)) text_field = TextArea(font, COLOR_WHITE, (100, 100), padding=5, style=Style(border_color=COLOR_WHITE)) icon_background = load_and_scale_image('resources/stone_tile.png', (32, 32)) grid_children = [ number_button(font, text_field, "1", pygame.K_1), number_button(font, text_field, "2", pygame.K_2), number_button(font, text_field, "3", pygame.K_3), number_button(font, text_field, "4", pygame.K_4), number_button(font, text_field, "5", pygame.K_5), number_button(font, text_field, "6", pygame.K_6), icon(font, (32, 32), icon_background, "A", pygame.K_a), icon(font, (32, 32), icon_background, "B", pygame.K_b), icon(font, (32, 32), icon_background, "C", pygame.K_c), number_button(font, text_field, "0", pygame.K_0), backspace_button(font, text_field) ] grid_container = GridContainer(children=grid_children, dimensions=(3, 4), padding=5, margin=2, style=Style(background_color=Color( 150, 130, 100), border_color=COLOR_WHITE)) img = image_surface('resources/stone_tile.png', (100, 100)) hud = ListContainer( width=800, height=200, children=[right_menu_bar, counter, grid_container, text_field, img], margin=5, padding=5, orientation=Orientation.HORIZONTAL, style=Style(border_color=COLOR_WHITE, background_color=Color(0, 0, 150))) container = AbsolutePosContainer(SCREEN_RESOLUTION, [(Vector2(5, 5), debug_window), (Vector2(0, 400), hud)]) container.set_pos(Vector2(0, 0)) while True: for event in pygame.event.get(): handle_exit(event) if event.type == pygame.MOUSEBUTTONDOWN: container.handle_mouse_was_clicked(pygame.mouse.get_pos()) elif event.type == pygame.MOUSEBUTTONUP: container.handle_mouse_was_released() elif event.type == pygame.MOUSEMOTION: container.handle_mouse_motion(pygame.mouse.get_pos()) elif event.type == USEREVENT_EACH_SECOND: fps_text.format_text(int(clock.get_fps())) elif event.type == pygame.KEYDOWN: container.handle_key_was_pressed(event.key) elif event.type == pygame.KEYUP: container.handle_key_was_released(event.key) elapsed_time = clock.tick() container.update(elapsed_time) screen.fill(background_color) grid.render(screen) container.render(screen) pygame.display.flip()
class Loop: def __init__(self, util: Util, cfg: Config, sfx: SfxHolder, txt: Text, drawer: Drawer): self.util = util self.cfg = cfg self.sfx = sfx self.txt = txt self.drawer = drawer self.clock = Clock() def main(self, screen, game: Game) -> bool: # Dump first tick to ignore past self.clock.tick(self.cfg.frames_per_second) while True: # Get change in time dt = self.clock.tick(self.cfg.frames_per_second) # Loop over events (quit, key down, key up) for event in pg.event.get(): if user_quit(event): return False elif event.type == pg.KEYDOWN: if event.key in self.cfg.all_keys: game.press_key(event.key) elif event.type == pg.KEYUP: if event.key in self.cfg.all_keys: game.release_key(event.key) # Move and draw game (with possible paused screen and fps) if not game.paused: game.move(dt) if not game.game_over: self.drawer.draw_game(screen, game, dt) if game.paused: self.drawer.draw_paused_overlay(screen) if self.cfg.draw_fps: self.drawer.draw_fps(screen, self.clock.get_fps()) # Update display pg.display.update() # Break if game no longer running if game.game_over: return True def game_over(self, screen, game: Game, scores: ScoresList) -> bool: score_saved = False # not saved yet self.sfx.game_over.play() # play audio i = 0 while True: # Fade-in game over screen if i < 256: pg.event.get() # dummy get self.drawer.draw_game(screen, game, 0) # draw game self.drawer.draw_game_over_overlay( screen, i, score_saved) # fade-in game over screen self.clock.tick(60) # slow-down the fade-in # Refresh screen pg.display.flip() i += 1 # Check for quit or restart events for event in pg.event.get(): if user_quit(event): return False elif event.type == pg.MOUSEBUTTONDOWN: if self.txt.restart_rect.collidepoint(*event.pos): return True elif not score_saved and \ self.txt.save_score_rect.collidepoint(*event.pos): for score in game.get_scores(): scores.add_score(score) scores.write() score_saved = True
elif i > new_value: i = max(i-INCREMENTS_PER_FRAME, new_value) # If we're taking away power, clip the result to the new value print(str(i)+"\r", end=" ") kit.continuous_servo[pi_mapping[control]].throttle = i last_values[control] = i clock = Clock() def apply_continue(): global controls_dict while True: apply_controls(controls_dict) clock.tick(FRAMERATE) motor_thread = Thread(target=apply_continue) motor_thread.start() fps = 0 while True: data, from_address = sock.recvfrom(4096) controls = data.decode().split(";")[-2] if len(controls) > 0: #print(controls) eval(controls) # Get the last command, evaluate it, and apply the controls fps = clock.get_fps()