def init(name_of_game):
print("INFO: pygame version: " + pygame.version.ver)
print("INFO: initializing sounds...")
pygame.mixer.pre_init(44100, -16, 1, 2048)
pygame.mixer.init()
pygame.init()
window_icon = pygame.image.load(Utils.resource_path("assets/icon.png"))
pygame.display.set_icon(window_icon)
window.create_instance(window_size=DEFAULT_SCREEN_SIZE,
min_size=MINIMUM_SCREEN_SIZE)
window.get_instance().set_caption(name_of_game)
window.get_instance().show()
render_eng = renderengine.create_instance()
render_eng.init(*DEFAULT_SCREEN_SIZE)
render_eng.set_min_size(*MINIMUM_SCREEN_SIZE)
# REPLACE with a call to a function that builds the real assets surface
sprite_atlas = spritesheets.create_instance()
sprite_atlas.add_sheet(DemoJunk.demo_sheet)
atlas_surface = sprite_atlas.create_atlas_surface()
# uncomment to save out the full texture atlas
# pygame.image.save(atlas_surface, "texture_atlas.png")
texture_data = pygame.image.tostring(atlas_surface, "RGBA", 1)
width = atlas_surface.get_width()
height = atlas_surface.get_height()
render_eng.set_texture(texture_data, width, height)
# REPLACE with whatever layers you need
COLOR = True
SORTS = True
render_eng.add_layer(
layers.ImageLayer(DemoJunk.FLOOR_LAYER, 0, False, COLOR))
render_eng.add_layer(
layers.ImageLayer(DemoJunk.SHADOW_LAYER, 5, False, COLOR))
render_eng.add_layer(
layers.ImageLayer(DemoJunk.WALL_LAYER, 10, False, COLOR))
render_eng.add_layer(layers.PolygonLayer(DemoJunk.POLYGON_LAYER, 12,
SORTS))
render_eng.add_layer(
layers.ImageLayer(DemoJunk.ENTITY_LAYER, 15, SORTS, COLOR))
render_eng.add_layer(
layers.ImageLayer(DemoJunk.UI_FG_LAYER, 20, SORTS, COLOR))
render_eng.add_layer(
layers.ImageLayer(DemoJunk.UI_BG_LAYER, 19, SORTS, COLOR))
inputs.create_instance()
px_scale = _calc_pixel_scale(DEFAULT_SCREEN_SIZE)
render_eng.set_pixel_scale(px_scale)
DemoJunk.px_scale = px_scale
def __init__(self, game):
self._game = game
self._clock = pygame.time.Clock()
print("INFO: pygame version: " + pygame.version.ver)
print("INFO: initializing sounds...")
pygame.mixer.pre_init(44100, -16, 1, 2048)
pygame.mixer.init()
pygame.init()
window_icon = pygame.image.load(Utils.resource_path("assets/icon.png"))
pygame.display.set_icon(window_icon)
window.create_instance(window_size=configs.default_window_size,
min_size=configs.minimum_window_size)
window.get_instance().set_caption(configs.name_of_game)
window.get_instance().show()
render_eng = renderengine.create_instance()
render_eng.init(*configs.default_window_size)
render_eng.set_min_size(*configs.minimum_window_size)
sprite_atlas = spritesheets.create_instance()
for sheet in self._game.create_sheets():
sprite_atlas.add_sheet(sheet)
atlas_surface = sprite_atlas.create_atlas_surface()
# uncomment to save out the full texture atlas
# pygame.image.save(atlas_surface, "texture_atlas.png")
texture_data = pygame.image.tostring(atlas_surface, "RGBA", 1)
width = atlas_surface.get_width()
height = atlas_surface.get_height()
render_eng.set_texture(texture_data, width, height)
for layer in self._game.create_layers():
renderengine.get_instance().add_layer(layer)
inputs.create_instance()
px_scale = self._calc_pixel_scale(
window.get_instance().get_display_size())
render_eng.set_pixel_scale(px_scale)
def _update_triangles(self):
p1 = self.p1()
p2 = self.p2()
if p1 == p2:
self._triangle1 = self._triangle1.update(new_points=(p1, p1, p1),
new_color=self.color(),
new_depth=self.depth())
self._triangle2 = self._triangle2.update(new_points=(p1, p1, p1),
new_color=self.color(),
new_depth=self.depth())
else:
thickness = self.thickness()
color = self.color()
line_vec = Utils.sub(p2, p1)
ortho_up = Utils.set_length(Utils.rotate(line_vec, 3.141529 / 2),
thickness // 2)
ortho_down = Utils.set_length(
Utils.rotate(line_vec, -3.141529 / 2),
int(0.5 + thickness / 2))
# r1-------r2
# p1 - p2
# | - |
# r4-------r3
r1 = Utils.sum([p1, ortho_up])
r2 = Utils.sum([p1, line_vec, ortho_up])
r3 = Utils.sum([p1, line_vec, ortho_down])
r4 = Utils.sum([p1, ortho_down])
self._triangle1 = self._triangle1.update(new_points=(r1, r2, r4),
new_color=color,
new_depth=self.depth())
self._triangle2 = self._triangle2.update(new_points=(r3, r4, r2),
new_color=color,
new_depth=self.depth())
def _play_song_forcefully(song):
if song is None or song.is_continue():
raise ValueError("_play_song_forcefully needs a real song, instead got: {}".format(song))
global _MASTER_VOLUME, CURRENT_SONG
if not CURRENT_SONG.is_silence():
if CURRENT_SONG != song:
print("INFO: stopping song {}".format(CURRENT_SONG))
pygame.mixer.music.stop()
if song.is_silence():
CURRENT_SONG = Songs.SILENCE
else:
if CURRENT_SONG == song:
print("WARN: starting song that's already playing {}".format(song))
else:
print("INFO: starting song {}".format(song))
real_filename = Utils.resource_path(os.path.join("assets", "songs", song.filename))
pygame.mixer.music.set_volume(_MASTER_VOLUME * song.volume)
pygame.mixer.music.load(real_filename)
pygame.mixer.music.play(-1, 0)
CURRENT_SONG = song
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 set_volume(volume):
global _MASTER_VOLUME
_MASTER_VOLUME = Utils.bound(volume, 0.0, 1.0)
def init(name_of_game):
print("INFO: pygame version: " + pygame.version.ver)
print("INFO: initializing sounds...")
pygame.mixer.pre_init(44100, -16, 1, 2048)
pygame.mixer.init()
pygame.init()
window_icon = pygame.image.load(Utils.resource_path("assets/icon.png"))
pygame.display.set_icon(window_icon)
window.create_instance(window_size=DEFAULT_SCREEN_SIZE,
min_size=MINIMUM_SCREEN_SIZE)
window.get_instance().set_caption(name_of_game)
window.get_instance().show()
render_eng = renderengine.create_instance()
render_eng.init(*DEFAULT_SCREEN_SIZE)
render_eng.set_min_size(*MINIMUM_SCREEN_SIZE)
sprite_atlas = spritesheets.create_instance()
spriteref.MAIN_SHEET = sprite_atlas.add_sheet(spriteref.MainSheet())
atlas_surface = sprite_atlas.create_atlas_surface()
# uncomment to save out the full texture atlas
# pygame.image.save(atlas_surface, "texture_atlas.png")
texture_data = pygame.image.tostring(atlas_surface, "RGBA", 1)
width = atlas_surface.get_width()
height = atlas_surface.get_height()
render_eng.set_texture(texture_data, width, height)
COLOR = True
SORTS = True
render_eng.add_layer(
layers.ImageLayer(spriteref.LAYER_SCENE_BG, 0, False, COLOR))
render_eng.add_layer(
layers.ImageLayer(spriteref.LAYER_SCENE_ENVIRONMENT, 5, False, COLOR))
render_eng.add_layer(
layers.ImageLayer(spriteref.LAYER_SCENE_FG, 10, SORTS, COLOR))
render_eng.add_layer(
layers.ImageLayer(spriteref.LAYER_UI_BG, 12, SORTS, COLOR))
render_eng.add_layer(
layers.ImageLayer(spriteref.LAYER_UI_FG, 15, SORTS, COLOR))
render_eng.add_layer(
layers.ImageLayer(spriteref.LAYER_UI_TOOLTIP, 20, SORTS, COLOR))
import src.game.towers as towers # bleh
towers.init_towers()
gs.create_instance()
gs.get_instance().set_game_state(gamestate.GameState())
inputs.create_instance()
px_scale = _calc_pixel_scale(DEFAULT_SCREEN_SIZE)
render_eng.set_pixel_scale(px_scale)
def run():
clock = pygame.time.Clock()
running = True
ignore_resize_events_next_tick = False
while running:
# processing user input events
all_resize_events = []
toggled_fullscreen = False
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 py_event.type == pygame.KEYDOWN and py_event.key == pygame.K_F4:
toggled_fullscreen = True
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 toggled_fullscreen:
# print("INFO {}: toggled fullscreen".format(gs.get_instance().tick_counter))
win = window.get_instance()
win.set_fullscreen(not win.is_fullscreen())
new_size = win.get_display_size()
new_pixel_scale = _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]
print("INFO: resizing to {}, {}".format(last_resize_event.w,
last_resize_event.h))
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 = _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(gs.get_instance().tick_count)
sounds.update()
if gs.get_instance().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()
if input_state.was_pressed(pygame.K_F5):
current_scale = gs.get_instance().px_scale
options = gs.get_instance().px_scale_options
if current_scale in options:
new_scale = (options.index(current_scale) + 1) % len(options)
else:
print("WARN: illegal pixel scale={}, reverting to default".
format(current_scale))
new_scale = options[0]
gs.get_instance().px_scale = new_scale
display_size = window.get_instance().get_display_size()
new_pixel_scale = _calc_pixel_scale(display_size,
px_scale_opt=new_scale)
renderengine.get_instance().set_pixel_scale(new_pixel_scale)
if input_state.was_pressed(pygame.K_r):
print("INFO: restarting game")
renderengine.get_instance().clear_all_sprites() # full nuke
gs.get_instance().set_game_state(gamestate.GameState())
renderengine.get_instance().set_clear_color((0, 0, 0))
gs.get_instance().update_all()
renderengine.get_instance().render_layers()
pygame.display.flip()
slo_mo_mode = gs.get_instance().is_dev() and input_state.is_held(
pygame.K_TAB)
if slo_mo_mode:
clock.tick(15)
else:
clock.tick(60)
gs.get_instance().tick_count += 1
if gs.get_instance().tick_count % 60 == 0:
if clock.get_fps() < 55 and gs.get_instance().is_dev(
) and not slo_mo_mode:
print("WARN: fps drop: {} ({} sprites)".format(
round(clock.get_fps() * 10) / 10.0,
renderengine.get_instance().count_sprites()))
print("INFO: quitting game")
pygame.quit()
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()
def set_master_volume(val):
global _MASTER_VOLUME, CURRENT_SONG
if val != _MASTER_VOLUME:
print("INFO: setting master music volume to {}".format(val))
_MASTER_VOLUME = Utils.bound(val, 0.0, 1.0)
pygame.mixer.music.set_volume(_MASTER_VOLUME * CURRENT_SONG.volume)