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