def render_layers(self): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # clear out sprites that weren't updated this tick cur_tick = globaltimer.tick_count() ids_to_remove = [ sprite_id for sprite_id in self.sprite_info_lookup if self.sprite_info_lookup[sprite_id].last_updated_tick < cur_tick ] for sprite_id in ids_to_remove: sprite_info = self.sprite_info_lookup[sprite_id] self.layers[sprite_info.sprite.layer_id()].remove(sprite_id) del self.sprite_info_lookup[sprite_id] for layer in self.ordered_layers: if layer.is_dirty(): layer.rebuild(self.sprite_info_lookup) if layer.get_layer_id() in self.hidden_layers: continue offs = layer.get_offset() self.set_matrix_offset(-offs[0], -offs[1]) layer.render(self)
def update(self, sprite): if sprite is None: return if sprite.is_parent(): for child_sprite in sprite.all_sprites(): self.update(child_sprite) else: uid = sprite.uid() cur_tick = globaltimer.tick_count() if uid not in self.sprite_info_lookup: self.sprite_info_lookup[uid] = _SpriteInfoBundle( sprite, cur_tick) else: self.sprite_info_lookup[uid].sprite = sprite self.sprite_info_lookup[uid].last_updated_tick = cur_tick layer = self.layers[sprite.layer_id()] if layer.accepts_sprite_type(sprite.sprite_type()): layer.update(uid, sprite.last_modified_tick()) else: raise ValueError("Incompatible sprite type: {}".format( sprite.sprite_type()))
def update(self): """ Relies on globaltimer.tick_count(). Remember that this gets called *after* inputs are passed in, and *before* game updates occur. """ self._current_time = globaltimer.tick_count() if self._end_drags_when_mouse_leaves_window and not self.mouse_in_window( ): self._mouse_down_pos.clear()
def update(self): """ Relies on globaltimer.tick_count(). Remember that this gets called *after* inputs are passed in, and *before* game updates occur. """ self._current_time = globaltimer.tick_count() self._pressed_this_frame.clear() self._pressed_this_frame.update(self._pressed_last_frame) self._pressed_last_frame.clear()
def get_text_for_display(self): anim_tick = (globaltimer.tick_count() // 20) % 2 if anim_tick == 0 and self.is_focused() and len( self.text) < self.char_limit: if self.cursor_pos >= len(self.text): return self.text + TextEditElement.CURSOR_CHAR else: l = list(self.text) l[max(0, self.cursor_pos)] = TextEditElement.CURSOR_CHAR return "".join(l) else: return self.text
def update(self): self._handle_global_keybinds() scenes.get_instance().update() gs.get_instance().update() songsystem.get_instance().update() if globaltimer.tick_count() % 15 == 0: window.get_instance().set_caption_info( "SPRITES", renderengine.get_instance().count_sprites()) window.get_instance().set_caption_info( "NO_GL_MODE", None if window.get_instance().is_opengl_mode() else "True") return not gs.get_instance().should_exit()
def render_layers(self): self.clear_screen() # clear out sprites that weren't updated this tick cur_tick = globaltimer.tick_count() ids_to_remove = [sprite_id for sprite_id in self.sprite_info_lookup if self.sprite_info_lookup[sprite_id].last_updated_tick < cur_tick] for sprite_id in ids_to_remove: sprite_info = self.sprite_info_lookup[sprite_id] self.layers[sprite_info.sprite.layer_id()].remove(sprite_id) del self.sprite_info_lookup[sprite_id] for layer in self.ordered_layers: if layer.is_dirty(): layer.rebuild(self.sprite_info_lookup) if layer.get_layer_id() in self.hidden_layers: continue self.render_layer(layer)
def run(self): running = True ignore_resize_events_next_tick = False while running: # processing user input events all_resize_events = [] input_state = inputs.get_instance() input_state.pre_update() for py_event in pygame.event.get(): if py_event.type == pygame.QUIT: running = False continue elif py_event.type == pygame.KEYDOWN: input_state.set_key(py_event.key, True, ascii_val=py_event.unicode) keybinds.get_instance().do_global_action_if_necessary( py_event.key) elif py_event.type == pygame.KEYUP: input_state.set_key(py_event.key, False) elif py_event.type in (pygame.MOUSEMOTION, pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): scr_pos = window.get_instance().window_to_screen_pos( py_event.pos) game_pos = util.round_vec( util.mult( scr_pos, 1 / renderengine.get_instance().get_pixel_scale())) input_state.set_mouse_pos(game_pos) if py_event.type == pygame.MOUSEBUTTONDOWN: input_state.set_mouse_down(True, button=py_event.button) elif py_event.type == pygame.MOUSEBUTTONUP: input_state.set_mouse_down(False, button=py_event.button) elif py_event.type == pygame.VIDEORESIZE: all_resize_events.append(py_event) if not pygame.mouse.get_focused(): input_state.set_mouse_pos(None) ignore_resize_events_this_tick = ignore_resize_events_next_tick ignore_resize_events_next_tick = False if self._requested_fullscreen_toggle_this_tick: # TODO I have no idea if this **** is still necessary in pygame 2+ win = window.get_instance() win.set_fullscreen(not win.is_fullscreen()) new_size = win.get_display_size() new_pixel_scale = window.calc_pixel_scale(new_size) if new_pixel_scale != renderengine.get_instance( ).get_pixel_scale(): renderengine.get_instance().set_pixel_scale( new_pixel_scale) renderengine.get_instance().resize(new_size[0], new_size[1], px_scale=new_pixel_scale) # when it goes from fullscreen to windowed mode, pygame sends a VIDEORESIZE event # on the next frame that claims the window has been resized to the maximum resolution. # this is annoying so we ignore it. we want the window to remain the same size it was # before the fullscreen happened. ignore_resize_events_next_tick = True self._requested_fullscreen_toggle_this_tick = False if not ignore_resize_events_this_tick and len( all_resize_events) > 0: last_resize_event = all_resize_events[-1] window.get_instance().set_window_size(last_resize_event.w, last_resize_event.h) display_w, display_h = window.get_instance().get_display_size() new_pixel_scale = window.calc_pixel_scale( (last_resize_event.w, last_resize_event.h)) renderengine.get_instance().resize(display_w, display_h, px_scale=new_pixel_scale) input_state.update() sounds.update() # updates the actual game state still_running = self._game.update() if still_running is False: running = False # draws the actual game state for spr in self._game.all_sprites(): if spr is not None: renderengine.get_instance().update(spr) renderengine.get_instance().set_clear_color( self._game.get_clear_color()) renderengine.get_instance().render_layers() pygame.display.flip() slo_mo_mode = configs.is_dev and input_state.is_held(pygame.K_TAB) target_fps = configs.target_fps if not slo_mo_mode else configs.target_fps // 4 self._wait_until_next_frame(target_fps) globaltimer.inc_tick_count() if globaltimer.get_show_fps(): if globaltimer.tick_count() % 20 == 0: window.get_instance().set_caption_info( "FPS", "{:.1f}".format(globaltimer.get_fps())) elif globaltimer.tick_count() % configs.target_fps == 0: if globaltimer.get_fps( ) < 0.9 * configs.target_fps and configs.is_dev and not slo_mo_mode: print("WARN: fps drop: {} ({} sprites)".format( round(globaltimer.get_fps() * 10) / 10.0, renderengine.get_instance().count_sprites())) if slo_mo_mode: self._slo_mo_timer += 1 elif self._slo_mo_timer > 0: # useful for timing things in the game print("INFO: slow-mo mode ended after {} tick(s)".format( self._slo_mo_timer)) self._slo_mo_timer = 0 self._game.cleanup() print("INFO: quitting game") pygame.quit()
def __init__(self, sprite_type, layer_id, uid=None): self._sprite_type = sprite_type self._layer_id = layer_id self._uid = gen_unique_id() if uid is None else uid self._last_modified_tick = globaltimer.tick_count()
def update(self): if len(self.entity_sprites) == 0: self.entity_sprites.append( sprites.ImageSprite.new_sprite(DemoGame.ENTITY_LAYER, scale=1)) # player self.entity_sprites.append( sprites.ImageSprite.new_sprite(DemoGame.ENTITY_LAYER, scale=1)) # tv if len(self.wall_sprites) == 0: for pos in self.wall_positions: new_sprite = sprites.ImageSprite( DemoGame.demo_sheet.wall_model, pos[0] * DemoGame.cell_size, pos[1] * DemoGame.cell_size, DemoGame.WALL_LAYER, scale=2) self.wall_sprites.append(new_sprite) if len(self.floor_sprites) == 0: for pos in self.floor_positions: new_sprite = sprites.ImageSprite( DemoGame.demo_sheet.floor_model, pos[0] * DemoGame.cell_size, pos[1] * DemoGame.cell_size, DemoGame.FLOOR_LAYER, scale=2) self.floor_sprites.append(new_sprite) if len(self.shadow_sprites) == 0: for _ in self.entity_sprites: self.shadow_sprites.append( sprites.ImageSprite(DemoGame.demo_sheet.shadow_model, 0, 0, DemoGame.SHADOW_LAYER, scale=1)) if self.triangle_sprite is None: self.triangle_sprite = sprites.TriangleSprite( DemoGame.POLYGON_LAYER, color=(0, 0, 0)) while len(self.cube_line_sprites) < 12: self.cube_line_sprites.append( sprites.LineSprite(DemoGame.POLYGON_LAYER, thickness=self.cube_line_thickness)) anim_tick = globaltimer.tick_count() // 16 speed = 2 dx = 0 new_xflip = None if inputs.get_instance().is_held([pygame.K_a, pygame.K_LEFT]): dx -= speed new_xflip = False elif inputs.get_instance().is_held([pygame.K_d, pygame.K_RIGHT]): dx += speed new_xflip = True dy = 0 if inputs.get_instance().is_held([pygame.K_w, pygame.K_UP]): dy -= speed elif inputs.get_instance().is_held([pygame.K_s, pygame.K_DOWN]): dy += speed player_x = self.entity_positions[0][0] + dx new_y = self.entity_positions[0][1] + dy player_y = max(new_y, int(1.1 * DemoGame.cell_size)) # collision with walls~ self.entity_positions[0] = (player_x, player_y) new_model = DemoGame.demo_sheet.player_models[anim_tick % len( DemoGame.demo_sheet.player_models)] player_sprite = self.entity_sprites[0] player_scale = player_sprite.scale() self.entity_sprites[0] = player_sprite.update( new_model=new_model, new_x=player_x - new_model.width() * player_scale // 2, new_y=player_y - new_model.height() * player_scale, new_xflip=new_xflip, new_depth=-player_y) tv_model = DemoGame.demo_sheet.tv_models[(anim_tick // 2) % len( DemoGame.demo_sheet.tv_models)] tv_x = self.entity_positions[1][0] tv_y = self.entity_positions[1][1] tv_xflip = player_x > tv_x # turn to face player tv_sprite = self.entity_sprites[1] tv_scale = tv_sprite.scale() self.entity_sprites[1] = tv_sprite.update( new_model=tv_model, new_x=tv_x - tv_model.width() * tv_scale // 2, new_y=tv_y - tv_model.height() * tv_scale, new_xflip=tv_xflip, new_depth=-tv_y) for i in range(0, len(self.entity_positions)): xy = self.entity_positions[i] shadow_sprite = self.shadow_sprites[i] shadow_model = self.demo_sheet.shadow_model shadow_x = xy[0] - shadow_sprite.scale() * shadow_model.width() // 2 shadow_y = xy[1] - shadow_sprite.scale() * shadow_model.height( ) // 2 self.shadow_sprites[i] = shadow_sprite.update( new_model=shadow_model, new_x=shadow_x, new_y=shadow_y) min_rot_speed = 0.3 max_rot_speed = 4 if self.triangle_sprite is not None: tri_center = self.triangle_center tri_angle = self.triangle_angle * 2 * 3.141529 / 360 tri_length = self.triangle_length p1 = Utils.add(tri_center, Utils.rotate((tri_length, 0), tri_angle)) p2 = Utils.add( tri_center, Utils.rotate((tri_length, 0), tri_angle + 3.141529 * 2 / 3)) p3 = Utils.add( tri_center, Utils.rotate((tri_length, 0), tri_angle + 3.141529 * 4 / 3)) self.triangle_sprite = self.triangle_sprite.update(new_points=(p1, p2, p3)) player_dist = Utils.dist(self.entity_positions[0], tri_center) if player_dist > 100: rot_speed = min_rot_speed else: rot_speed = Utils.linear_interp(min_rot_speed, max_rot_speed, (100 - player_dist) / 100) self.triangle_angle += rot_speed text_inset = 4 title_text = "Demo Scene" if self.title_text_sprite is None: self.title_text_sprite = sprites.TextSprite( DemoGame.UI_FG_LAYER, 0, text_inset, title_text) title_text_width = self.title_text_sprite.get_size()[0] title_text_x = renderengine.get_instance().get_game_size( )[0] - title_text_width - text_inset self.title_text_sprite = self.title_text_sprite.update( new_x=title_text_x) if self.fps_text_sprite is None: self.fps_text_sprite = sprites.TextSprite(DemoGame.UI_FG_LAYER, text_inset, text_inset, "FPS: 0") fps_text = "FPS: {}".format(int(globaltimer.get_fps())) self.fps_text_sprite = self.fps_text_sprite.update(new_x=text_inset, new_y=text_inset, new_text=fps_text) player_to_tv_dist = Utils.dist(self.entity_positions[0], self.entity_positions[1]) info_text = "There's something wrong with the TV. Maybe it's better this way." if player_to_tv_dist < 32 else None info_text_w = 400 - 32 info_text_h = 48 info_text_rect = [ renderengine.get_instance().get_game_size()[0] // 2 - info_text_w // 2, renderengine.get_instance().get_game_size()[1] - info_text_h - 16, info_text_w, info_text_h ] if info_text is None: self.text_box_text_sprite = None self.text_box_sprite = None else: wrapped_text = "\n".join( sprites.TextSprite.wrap_text_to_fit(info_text, info_text_rect[2])) if self.text_box_text_sprite is None: self.text_box_text_sprite = sprites.TextSprite( DemoGame.UI_FG_LAYER, 0, 0, wrapped_text) self.text_box_text_sprite = self.text_box_text_sprite.update( new_x=info_text_rect[0], new_y=info_text_rect[1], new_text=wrapped_text) if self.text_box_sprite is None: self.text_box_sprite = sprites.BorderBoxSprite( DemoGame.UI_BG_LAYER, info_text_rect, all_borders=DemoGame.demo_sheet.border_models) self.text_box_sprite = self.text_box_sprite.update( new_rect=info_text_rect, new_scale=2) if len(self.cube_line_sprites) == 12: cube_center = self.cube_center cube_angle = self.cube_angle * 2 * 3.141529 / 360 cube_length = self.cube_length cube_color = self.cube_color cube_top_pts = [] cube_btm_pts = [] for i in range(0, 4): dx = cube_length / 2 * math.cos(cube_angle + i * 3.141529 / 2) dy = cube_length / 2 * math.sin( cube_angle + i * 3.141529 / 2) / 2 # foreshortened in the y-axis cube_btm_pts.append(Utils.add(cube_center, (dx, dy))) cube_top_pts.append( Utils.add(cube_center, (dx, dy - cube_length))) for i in range(0, 12): if i < 4: # bottom lines p1 = cube_btm_pts[i % 4] p2 = cube_btm_pts[(i + 1) % 4] elif i < 8: # top lines p1 = cube_top_pts[i % 4] p2 = cube_top_pts[(i + 1) % 4] else: # bottom to top lines p1 = cube_btm_pts[i % 4] p2 = cube_top_pts[i % 4] self.cube_line_sprites[i].update(new_p1=p1, new_p2=p2, new_color=cube_color) player_dist = Utils.dist(self.entity_positions[0], cube_center) if player_dist > 100: rotation_speed = min_rot_speed else: rotation_speed = Utils.linear_interp(min_rot_speed, max_rot_speed, (100 - player_dist) / 100) self.cube_angle += rotation_speed # setting layer positions camera_x = player_x - renderengine.get_instance().get_game_size( )[0] // 2 camera_y = player_y - renderengine.get_instance().get_game_size( )[1] // 2 for layer_id in DemoGame.world_layer_ids: renderengine.get_instance().set_layer_offset( layer_id, camera_x, camera_y)
def run(self): running = True ignore_resize_events_next_tick = False while running: # processing user input events all_resize_events = [] input_state = inputs.get_instance() for py_event in pygame.event.get(): if py_event.type == pygame.QUIT: running = False continue elif py_event.type == pygame.KEYDOWN: input_state.set_key(py_event.key, True) elif py_event.type == pygame.KEYUP: input_state.set_key(py_event.key, False) elif py_event.type in (pygame.MOUSEMOTION, pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): scr_pos = window.get_instance().window_to_screen_pos( py_event.pos) game_pos = Utils.round( Utils.mult( scr_pos, 1 / renderengine.get_instance().get_pixel_scale())) input_state.set_mouse_pos(game_pos) if py_event.type == pygame.MOUSEBUTTONDOWN: input_state.set_mouse_down(True, button=py_event.button) elif py_event.type == pygame.MOUSEBUTTONUP: input_state.set_mouse_down(False, button=py_event.button) elif py_event.type == pygame.VIDEORESIZE: all_resize_events.append(py_event) if not pygame.mouse.get_focused(): input_state.set_mouse_pos(None) ignore_resize_events_this_tick = ignore_resize_events_next_tick ignore_resize_events_next_tick = False if input_state.was_pressed( pygame.K_F4) and configs.allow_fullscreen: win = window.get_instance() win.set_fullscreen(not win.is_fullscreen()) new_size = win.get_display_size() new_pixel_scale = self._calc_pixel_scale(new_size) if new_pixel_scale != renderengine.get_instance( ).get_pixel_scale(): renderengine.get_instance().set_pixel_scale( new_pixel_scale) renderengine.get_instance().resize(new_size[0], new_size[1], px_scale=new_pixel_scale) # when it goes from fullscreen to windowed mode, pygame sends a VIDEORESIZE event # on the next frame that claims the window has been resized to the maximum resolution. # this is annoying so we ignore it. we want the window to remain the same size it was # before the fullscreen happened. ignore_resize_events_next_tick = True if not ignore_resize_events_this_tick and len( all_resize_events) > 0: last_resize_event = all_resize_events[-1] window.get_instance().set_window_size(last_resize_event.w, last_resize_event.h) display_w, display_h = window.get_instance().get_display_size() new_pixel_scale = self._calc_pixel_scale( (last_resize_event.w, last_resize_event.h)) renderengine.get_instance().resize(display_w, display_h, px_scale=new_pixel_scale) if configs.is_dev and input_state.was_pressed(pygame.K_F1): # used to help find performance bottlenecks import src.utils.profiling as profiling profiling.get_instance().toggle() input_state.update() sounds.update() # updates the actual game state self._game.update() # draws the actual game state for spr in self._game.all_sprites(): if spr is not None: renderengine.get_instance().update(spr) renderengine.get_instance().set_clear_color(configs.clear_color) renderengine.get_instance().render_layers() pygame.display.flip() slo_mo_mode = configs.is_dev and input_state.is_held(pygame.K_TAB) target_fps = configs.target_fps if not slo_mo_mode else configs.target_fps // 4 self._wait_until_next_frame(target_fps) globaltimer.inc_tick_count() if globaltimer.tick_count() % configs.target_fps == 0: if globaltimer.get_fps( ) < 0.9 * configs.target_fps and configs.is_dev and not slo_mo_mode: print("WARN: fps drop: {} ({} sprites)".format( round(globaltimer.get_fps() * 10) / 10.0, renderengine.get_instance().count_sprites())) print("INFO: quitting game") pygame.quit()