def _update_sprites(self):
if self.text_sprite is None:
self.text_sprite = sprites.TextSprite(spriteref.UI_FG_LAYER,
0,
0,
self.get_text_for_display(),
font_lookup=self.font)
abs_xy = self.get_xy(absolute=True)
text_xy = abs_xy
if self.has_outline():
text_xy = (text_xy[0] + self.outline_inset,
text_xy[1] + self.outline_inset)
self.text_sprite.update(new_x=text_xy[0],
new_y=text_xy[1],
new_text=self.get_text_for_display(),
new_scale=self.scale,
new_color=self.color)
if self.has_outline():
abs_size = self.get_size()
outline_box = [abs_xy[0], abs_xy[1], abs_size[0], abs_size[1]]
if self.bg_sprite is None:
self.bg_sprite = sprites.BorderBoxSprite(
spriteref.UI_BG_LAYER,
outline_box,
color=self.outline_color,
all_borders=spriteref.overworld_sheet().border_thin)
self.bg_sprite.update(new_rect=outline_box)
def get_size(self):
if self._dummy_text_for_size_calc is None:
# hope it's monospaced~
self._dummy_text_for_size_calc = sprites.TextSprite(
spriteref.UI_FG_LAYER,
0,
0,
"X" * self.char_limit,
scale=self.scale,
font_lookup=self.font)
self._dummy_text_for_size_calc.update(new_text="X" * self.char_limit)
size = self._dummy_text_for_size_calc.size()
if self.has_outline():
size = (size[0] + self.outline_inset * 2,
size[1] + self.outline_inset * 2)
return size
def update_sprites(self):
util.extend_or_empty_list_to_length(
self._sprites,
len(self.options),
creator=lambda: sprites.TextSprite(spriteref.UI_FG_LAYER, 0, 0,
"abc"))
max_w = 0
# first build the sprites
for i in range(0, len(self.options)):
spr = self._sprites[i]
rect, text, do_action, is_enabled = self.options[i]
if not is_enabled():
new_color = colors.DARK_GRAY
elif i == self.selected_idx:
new_color = colors.PERFECT_RED
else:
new_color = colors.PERFECT_WHITE
spr.update(new_text=text,
new_color=new_color,
new_outline_thickness=1 if self.outlined else 0)
max_w = max(spr.size()[0], max_w)
abs_xy = self.get_xy(absolute=True)
y = 0
# then figure out the final positions and move the sprites
for i in range(0, len(self.options)):
spr = self._sprites[i]
rect, text, do_action, is_enabled = self.options[i]
new_rect = [
0 if self.alignment == OptionsList.LEFT_ALIGN else
int(max_w / 2 - spr.size()[0] / 2), y,
spr.size()[0],
spr.size()[1]
]
self.options[i] = (new_rect, text, do_action, is_enabled)
spr.update(new_x=abs_xy[0] + new_rect[0],
new_y=abs_xy[1] + new_rect[1])
y += new_rect[3] + self.y_spacing
def update_sprites(self):
xy = self.get_xy(absolute=True)
screen_size = renderengine.get_instance().get_game_size()
size = self.get_size()
if self.bg_sprite is None:
self.bg_sprite = sprites.ImageSprite.new_sprite(
spriteref.UI_BG_LAYER, depth=10)
bg_model = spritesheets.get_white_square_img(self.bg_opacity)
self.bg_sprite = self.bg_sprite.update(
new_model=bg_model,
new_x=xy[0],
new_y=xy[1],
new_ratio=(size[0] / bg_model.width(),
size[1] / bg_model.height()),
new_color=colors.PERFECT_BLACK)
text_rect = [
xy[0] + self.inset, xy[1] + self.inset, size[0] - self.inset * 2,
size[1] - self.inset * 2
]
all_sprites = self.current_dialog.get_speaker_sprites()
if len(all_sprites) > 0:
speaker_img = all_sprites[gs.get_instance().anim_tick() // 8 %
len(all_sprites)]
else:
speaker_img = None
if speaker_img is not None:
speaker_sc = 3
speaker_size = speaker_img.size(scale=speaker_sc)
speaker_on_right_side = self.current_dialog.put_speaker_sprite_on_right_side(
)
if speaker_on_right_side:
speaker_x = xy[0] + size[0] - speaker_size[0] - self.inset
text_rect = [
xy[0] + self.inset, xy[1] + self.inset,
size[0] - self.inset * 2 - speaker_size[0],
size[1] - self.inset * 2
]
else:
speaker_x = xy[0] + self.inset
text_rect = [
speaker_x + speaker_size[0] + self.inset,
xy[1] + self.inset,
size[0] - self.inset * 2 - speaker_size[0],
size[1] - self.inset * 2
]
if self.speaker_sprite is None:
self.speaker_sprite = sprites.ImageSprite.new_sprite(
spriteref.UI_FG_LAYER)
self.speaker_sprite = self.speaker_sprite.update(
new_model=speaker_img,
new_x=speaker_x,
new_y=screen_size[1] - speaker_size[1],
new_xflip=speaker_on_right_side,
new_scale=speaker_sc)
else:
self.speaker_sprite = None
text_color = self.current_dialog.get_text_color()
visible_text = "\n".join(
sprites.TextSprite.wrap_text_to_fit(self._get_visible_text(),
text_rect[2],
scale=1,
font_lookup=self.get_font()))
if self.text_sprite is None:
self.text_sprite = sprites.TextSprite(spriteref.UI_FG_LAYER,
0,
0,
"blah",
font_lookup=self.get_font())
self.text_sprite.update(new_x=text_rect[0],
new_y=text_rect[1],
new_text=visible_text,
new_color=text_color)
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)