def __init__(self, menu):
AbstractScreen.__init__(self, menu, "backgrounds/main_menu.jpg")
self._gui_elements.append(MainMenuButton(self, (self._x_total_half, self._y_total * 14 / 16)))
white = (255, 255, 255)
font_64 = ResourceManager.load_font_asset("8bit.ttf", 64)
# font_32 = ResourceManager.load_font_asset("8bit.ttf", 32)
font_24 = ResourceManager.load_font_asset("8bit.ttf", 24)
# font_16 = ResourceManager.load_font_asset("8bit.ttf", 16)
title = TextGUI(self, font_64, white, "Highscores", (self._x_total_half, self._y_total * 2 / 16))
hs_rect = HSBackground(self, (self._x_total_half, self._y_total>>1), 500, 325)
self.hs1 = TextGUI(self, font_24, white, "None", (self._x_total_half, self._y_total * 5 / 16))
self.hs2 = TextGUI(self, font_24, white, "None", (self._x_total_half, self._y_total * 6.5 / 16))
self.hs3 = TextGUI(self, font_24, white, "None", (self._x_total_half, self._y_total * 8 / 16))
self.hs4 = TextGUI(self, font_24, white, "None", (self._x_total_half, self._y_total * 9.5 / 16))
self.hs5 = TextGUI(self, font_24, white, "None", (self._x_total_half, self._y_total * 11 / 16))
back_button = TextGUI(self, font_24, white, "Menú Principal", (self._x_total_half, self._y_total * 14 / 16))
self._gui_elements.append(title)
self._gui_elements.append(hs_rect)
self._gui_elements.append(self.hs1)
self._gui_elements.append(self.hs2)
self._gui_elements.append(self.hs3)
self._gui_elements.append(self.hs4)
self._gui_elements.append(self.hs5)
self._gui_elements.append(back_button)
def __init__(self, menu):
AbstractScreen.__init__(self,
menu,
"backgrounds/main_menu.jpg",
song="ulerime.ogg")
self._gui_elements.append(PlayButton(self, (self._x_total_half, 270)))
self._gui_elements.append(
HighscoresButton(self, (self._x_total_half, 340)))
self._gui_elements.append(ExitButton(self, (self._x_total_half, 410)))
white = (255, 255, 255)
font_64 = ResourceManager.load_font_asset("8bit.ttf", 64)
font_32 = ResourceManager.load_font_asset("8bit.ttf", 32)
font_24 = ResourceManager.load_font_asset("8bit.ttf", 24)
font_16 = ResourceManager.load_font_asset("8bit.ttf", 16)
title = TextGUI(self, font_64, white, "COVIDeogame",
(self._x_total_half, 120))
play = TextGUI(self, font_32, white, "Jugar",
(self._x_total_half, 270))
highscores = TextGUI(self, font_32, white, "Highscores",
(self._x_total_half, 340))
exit = TextGUI(self, font_32, white, "Salir",
(self._x_total_half, 410))
group = TextGUI(self, font_24, white, "Universidade da Coruña",
(self._x_total_half, 570))
self._gui_elements.append(title)
self._gui_elements.append(play)
self._gui_elements.append(exit)
self._gui_elements.append(highscores)
self._gui_elements.append(group)
def __init__(self):
pygame.init()
self._font = pygame.font.Font(None, 30)
configuration = ResourceManager.load_config()
self._screen = pygame.display.set_mode(configuration.get_resolution())
pygame.display.set_caption(configuration.get_name())
self._director = ResourceManager.load_director()
self._farm_factory = None
def __init__(self, level, id, indic, once, coord, size, invert, action_data=None, locking=True):
AbstractPlatform.__init__(self, level, None, True, pygame.Rect(coord, size), invert, not indic)
self._id = id
self._locking = locking
self._once = once
self._action_data = action_data
self._director = ResourceManager.load_director()
self._text = ResourceManager.get_text_repository()
self._last = 0
self._has_interacted = False
def __init__(self, level, filename, scroll_x=0):
AbstractBackground.__init__(self, scroll_x)
resolution = ResourceManager.load_config().get_resolution()
image = ResourceManager.load_sprite(filename, level)
dest_resolution = (image.get_rect().width, resolution[1])
self.image = pygame.transform.scale(image, dest_resolution)
self.rect = self.image.get_rect()
self.rect.bottom = resolution[1]
self.subimage_rect = pygame.Rect((0, 0), resolution)
self.subimage_rect.left = scroll_x
def __init__(self, level, data, coord, speedx=25, speedy=40, invert=False, invincible=False):
Character.__init__(self, level, data, coord, invert, speedx, speedy)
self._repo = ResourceManager.get_player_repository()
self._text = ResourceManager.get_text_repository()
self._last_hit = Player.INVULNERABILITY_LAPSE
self._parry = Player.PARRY_CD
self._invincible = invincible
self._end_parry = True
self._pending_trigger = None
self._last_triggered = Player.TRIGGER_HYST
self._interact_last_displayed = AnimatedText.get_duration()
self._interact = False
def move_cpu(self):
width, _ = ResourceManager.load_config().get_resolution()
x_pos, _ = Farm.get_player()._position
if self._delay >= Covid.DELAY:
self._delay = 0
if self.rect.left >= -150 and self.rect.right <= width + 150:
dist_x = x_pos - self._position[0]
if dist_x <= 0:
direction_x = Character.LEFT
else:
direction_x = Character.RIGHT
inc = self.rect.width / 2 * (1 if direction_x
== Character.RIGHT else -1)
self.rect.left += inc
platform = Farm.platform_collision(self)
self.rect.left -= inc
if platform != None and platform._collides:
direction_y = Character.UP
else:
direction_y = Character.STILL
else:
direction_x = Character.STILL
direction_y = Character.STILL
self._last_x = direction_x
self._last_y = direction_y
Character.move(self, (self._last_x, self._last_y))
def parse_trigger(self, json):
event = json['event']
id = json.get('id')
indica = json['indicator'] and ResourceManager.load_config().is_debug()
once = json.get('once')
if once == None: #Once by default is true bro
once = True #Once by default aint shit as it is not required by json schema!
locking = json.get('locking')
if locking == None:
locking = True
# Not needed anymore
#if locking == True:
# once = True # This prevents getting locked inside the dialog!
coords = self.parse_coords(json['coords'])
invert = json['coords']['inverted']
size = self.parse_size(json['size'])
if event == 0 and id != None:
extra = id
elif event == 2 and id != None:
extra = self.dialogs[id]
elif event == 3:
extra = json['next_scene']
else:
extra = None
return Trigger(self.name, event, indica, once, coords, size, invert, extra, locking)
def _update_scroll(self):
player = Farm.get_player()
resolution = ResourceManager.load_config().get_resolution()
if player.rect.right > AbstractHorizontalScene.MAX_X:
displ = player.rect.right - AbstractHorizontalScene.MAX_X
if self._scroll_x + resolution[0] >= self._background.rect.right:
if player.rect.right >= resolution[0]:
player.set_global_position(
(self._background.rect.right - player.rect.width,
player._position[1]))
return False
self._scroll_x = min(self._scroll_x + displ,
self._background.rect.right - resolution[0])
return True
if player.rect.left < AbstractHorizontalScene.MIN_X:
displ = AbstractHorizontalScene.MIN_X - player.rect.left
self._scroll_x = max(self._scroll_x - displ, 0)
if self._scroll_x == 0 and player.rect.left < 0:
player.set_global_position((0, player._position[1]))
return False
else:
return True
return False
def __init__(self):
AbstractScene.__init__(self)
self._scroll_x = 0
self._hud = Hud()
self._hud.create_hud_group(PlayerRepository.ATTR_HEALTH, HudHeart,
(0, 0), Hud.GROW_RIGHT, 100)
self._hud.create_hud_group(PlayerRepository.ATTR_MASKS, HudMask,
(0, 6), Hud.GROW_RIGHT, 110)
self._hud.create_hud_group(PlayerRepository.ATTR_TOILET_PAPER,
HudToiletPaper, (80, 0), Hud.GROW_LEFT, 100)
self._text_repo = ResourceManager.get_text_repository()
self._player_repo = ResourceManager.get_player_repository()
self._background = None
self._sky = None
self._last_scroll = self._scroll_x
def update(self, elapsed_time):
self._dur += elapsed_time
self.image.set_alpha(self.duration / min(self._dur, self.duration) * 100)
_, vel_y = ResourceManager.load_config().get_pixels((0, -self.speed))
self._increase_position((0, vel_y * elapsed_time))
if self._dur > self.duration:
self.kill()
def __init__(self, menu):
AbstractScreen.__init__(self, menu, "backgrounds/main_menu.jpg")
Rocker.action(Rocker.AUD_DEFEAT)
self._gui_elements.append(RetryButton(self, (self._x_total_half, 270)))
self._gui_elements.append(ExitButton(self, (self._x_total_half, 340)))
white = (255, 255, 255)
font_64 = ResourceManager.load_font_asset("8bit.ttf", 64)
font_32 = ResourceManager.load_font_asset("8bit.ttf", 32)
title = TextGUI(self, font_64, white, "Has perdido",
(self._x_total_half, 120))
retry = TextGUI(self, font_32, white, "Reintentar",
(self._x_total_half, 270))
exit = TextGUI(self, font_32, white, "Salir",
(self._x_total_half, 340))
self._gui_elements.append(title)
self._gui_elements.append(retry)
self._gui_elements.append(exit)
def __init__(self):
(self._X_TOTAL, self._Y_TOTAL) = ResourceManager.load_config().get_resolution()
# We store here the sprite groups
self._sprite_groups = {}
self._sprite_group = pygame.sprite.Group()
# Set hud offsets
self._x_min_offset = self._X_TOTAL*self.X_RELATIVE_LEFT_OFFSET/100
self._y_min_offset = self._Y_TOTAL*self.Y_RELATIVE_TOP_OFFSET/100
self._x_max_offset = self._X_TOTAL - self._X_TOTAL*self.X_RELATIVE_RIGHT_OFFSET/100
self._y_max_offset = self._Y_TOTAL - self._Y_TOTAL*self.Y_RELATIVE_BOTTOM_OFFSET/100
def __init__(self, menu, image, song=None, transform=False):
res = ResourceManager.load_config().get_resolution()
self._menu = menu
self.image = ResourceManager.load_image_asset(image)
if transform:
self.image = pygame.transform.scale(self.image, res)
self.rect = self.image.get_rect()
self.rect.left = 0
self.rect.bottom = res[1]
self._song = song
self._clicked = None
self._gui_elements = []
(self._x_total,
self._y_total) = ResourceManager.load_config().get_resolution()
(self._x_total_half, self._y_total_half) = (self._x_total >> 1,
self._y_total >> 1)
def __init__(self,
level,
data,
position,
invert,
velocity_x=0,
velocity_y=0):
AbstractSprite.__init__(self)
self._coords = ResourceManager.load_coords(level, data)
self._sheet = ResourceManager.load_sheet(level, data, colorkey=-1)
self._level = level
self._data = data
if invert:
self._sheet = pygame.transform.flip(self._sheet, True, False)
self._left = False
self._animation_idx = 0
self._animation_dur = -1
self._text = ResourceManager.get_text_repository()
self._set_sprite("STILL")
self.rect = self.image.get_rect()
self.set_global_position(position)
self._is_jumping = False
self._jump = Character.JUMPING_DELAY
self._velocity = (0, 0)
self._velocity_x = velocity_x
self._velocity_y = velocity_y
self._dash = Character.DASH_CD
self._end_dash = True
self._movement_x = Character.STILL
self._movement_y = Character.STILL
self._orientation = Character.RIGHT
def __init__(self, menu):
AbstractScreen.__init__(self, menu, "backgrounds/main_menu.jpg")
self._gui_elements.append(ExitButton(self, (self._x_total_half, 480)))
repo = ResourceManager.get_player_repository()
score = int(repo.get_parameter(PlayerRepository.ATTR_TOTAL_TIME))
ResourceManager.append_hs(score)
white = (255, 255, 255)
font_64 = ResourceManager.load_font_asset("8bit.ttf", 64)
font_32 = ResourceManager.load_font_asset("8bit.ttf", 32)
title = TextGUI(self, font_64, white, "Has ganado",
(self._x_total_half, 120))
score = TextGUI(self, font_64, white, f"Score: {score} sec",
(self._x_total_half, 300))
exit = TextGUI(self, font_32, white, "Salir",
(self._x_total_half, 480))
self._gui_elements.append(title)
self._gui_elements.append(score)
self._gui_elements.append(exit)
def __init__(self, menu):
AbstractScreen.__init__(self, menu, "backgrounds/main_menu.jpg")
self._gui_elements.append(PlayButton(self, (self._x_total_half, 270)))
self._gui_elements.append(ExitButton(self, (self._x_total_half, 340)))
white = (255, 255, 255)
font_32 = ResourceManager.load_font_asset("8bit.ttf", 32)
play = TextGUI(self, font_32, white, "Reanudar",
(self._x_total_half, 270))
exit = TextGUI(self, font_32, white, "Salir",
(self._x_total_half, 340))
self._gui_elements.append(play)
self._gui_elements.append(exit)
def update(self, elapsed_time):
Enemy.update(self, elapsed_time)
width, _ = ResourceManager.load_config().get_resolution()
left = self.rect.left
right = self.rect.right
inc = self.rect.width / 2 * (-1 if self._velocity[0] < 0 else 1)
self.rect.left += inc
left = self.rect.left
right = self.rect.right
inc = self.rect.width / 2 * (-1 if self._velocity[0] < 0 else 1)
self.rect.left += inc
if Farm.touches_anything_visible(self) or left < -50 or right > width + 50:
self.kill()
self.rect.left += inc
def play_game(self):
# stop music
pygame.mixer.music.stop()
# init repo
repo = ResourceManager.get_player_repository()
repo.reset_attr()
repo.set_parameter(PlayerRepository.ATTR_TOTAL_TIME,
None,
accounted=False)
level0 = Level("Level0", self._hacks)
level1 = Level("Level1", self._hacks)
level2 = Level("Level2", self._hacks)
for level in [level2, level1, level0]:
for scene in level.get_scenes():
self._director.push_scene(scene)
def populate_hs_list(self, list):
font_24 = ResourceManager.load_font_asset("8bit.ttf", 24)
white = (255, 255, 255)
self._gui_elements.remove(self.hs1)
self._gui_elements.remove(self.hs2)
self._gui_elements.remove(self.hs3)
self._gui_elements.remove(self.hs4)
self._gui_elements.remove(self.hs5)
self.hs1 = TextGUI(self, font_24, white, f"{list[0][0]} - {list[0][1]} sec", (self._x_total_half, self._y_total * 5 / 16))
self.hs2 = TextGUI(self, font_24, white, f"{list[1][0]} - {list[1][1]} sec", (self._x_total_half, self._y_total * 6.5 / 16))
self.hs3 = TextGUI(self, font_24, white, f"{list[2][0]} - {list[2][1]} sec", (self._x_total_half, self._y_total * 8 / 16))
self.hs4 = TextGUI(self, font_24, white, f"{list[3][0]} - {list[3][1]} sec", (self._x_total_half, self._y_total * 9.5 / 16))
self.hs5 = TextGUI(self, font_24, white, f"{list[4][0]} - {list[4][1]} sec", (self._x_total_half, self._y_total * 11 / 16))
self._gui_elements.append(self.hs1)
self._gui_elements.append(self.hs2)
self._gui_elements.append(self.hs3)
self._gui_elements.append(self.hs4)
self._gui_elements.append(self.hs5)
def __init__(self, position=(0, 0), text="dummy", scroll=(0, 0), color=(255, 255, 255),
custom_duration=None, custom_speed=None):
AbstractSprite.__init__(self)
font = ResourceManager.load_font_asset("8bit.ttf", 16)
self.image = font.render(text, True, color)
self.rect = self.image.get_rect()
self._text = text
self.duration = self._DEFAULT_DUR
self.speed = self._DEFAULT_SPD
if custom_duration is not None:
self.cust_dur = custom_duration
if custom_speed is not None:
self.speed = custom_speed
self._dur = 0
self._scroll = scroll
self.set_global_position(position)
self.set_position(self._scroll)
def move_cpu(self):
width, _ = ResourceManager.load_config().get_resolution()
x_pos, y_pos = Farm.get_player()._position
if self._delay >= Torreta.DELAY:
self._delay = 0
if self.rect.left >= -150 and self.rect.right <= width + 150:
dist_x = x_pos - self._position[0]
if dist_x <= 0:
direction_x = Character.LEFT
self._pos_shot = self._position[0] - 20, self._position[1] - 22
else:
direction_x = Character.RIGHT
self._pos_shot = self._position[0] + 50, self._position[1] - 22
if self._last_shot >= Torreta.SHOOT_RATIO:
self._last_shot = 0
Farm.add_enemy(Shot(self._level, self._shot, self._pos_shot, dist_x < 0, self._scroll))
else:
direction_x = Character.STILL
self._last_x = direction_x
Character.move(self, (self._last_x, Character.STILL))
def update(self):
pl_repo = ResourceManager.get_player_repository()
for param_name in pl_repo.updated:
pl_repo.updated.remove(param_name)
self._sprite_groups[param_name]["count"] = pl_repo.get_parameter(param_name)
def update(self, elapsed_time):
step_over = False
self._jump += elapsed_time
self._dash += elapsed_time
res = ResourceManager.load_config().get_resolution()
vel_x, vel_y = self._velocity_x, self._velocity_y
vel_px, vel_py = ResourceManager.load_config().get_pixels(
(vel_x, vel_y))
if self._dash > Character.DASH_DUR and not self._end_dash:
self._end_dash = True
self._velocity = vel_px * elapsed_time * (-1 if self._left else
1), self._velocity[1]
# update horizontal movement
if self._movement_x == Character.LEFT:
self._velocity = (-vel_px * elapsed_time, self._velocity[1])
if self._movement_x == Character.RIGHT:
self._velocity = (vel_px * elapsed_time, self._velocity[1])
if self._movement_x == Character.STILL:
self._velocity = (0, self._velocity[1])
if self._movement_y == Character.UP and self._jump >= Character.JUMPING_DELAY and not self._is_jumping:
self._jump = 0
self._is_jumping = True
self._velocity = (self._velocity[0], -vel_py * 0.018)
if self._dash < Character.DASH_DUR:
direction = -1 if self._left else 1
self._velocity = ((vel_px + 300) * elapsed_time * direction, 0)
self._update_sprite()
# check horizontal collisions
self._increase_position((self._velocity[0], 0))
platform = Farm.platform_collision(self)
if platform != None and platform._collides and self.rect.bottom > platform.rect.top:
dist_l = abs(platform.rect.centerx - self.rect.left)
dist_r = abs(platform.rect.centerx - self.rect.right)
if self.rect.bottom - Character.STEP_OVER < platform.rect.top + 1:
step_over = True
elif self._velocity[0] > 0 or dist_l >= dist_r:
self.set_global_position(
(platform._position[0] - self.rect.width,
self._position[1]))
elif self._velocity[0] < 0 or dist_r > dist_l:
self.set_global_position(
(platform._position[0] + platform.rect.width,
self._position[1]))
# check vertical collisions
self._increase_position((0, self._velocity[1]))
platform = Farm.platform_collision(self)
if platform != None and platform._collides:
if self._velocity[1] > 0 or step_over:
if self._is_jumping and self._velocity[
1] > 0 and self.rect.left - platform.rect.left - platform.rect.height > 10:
self._dash = Character.DASH_CD
self._is_jumping = False
self._velocity = (self._velocity[0], 0)
self.set_global_position(
(self._position[0],
platform._position[1] - platform.rect.height + 1))
elif self._velocity[1] < 0:
self._velocity = (self._velocity[0],
0.04 * vel_py * elapsed_time)
self.set_global_position(
(self._position[0],
platform._position[1] + self.rect.height))
else:
# check y axis boundaries
if self.rect.bottom >= res[1]:
if self._is_jumping and self._velocity[
1] > 0 and self.rect.left > 10:
self._dash = Character.DASH_CD
self._is_jumping = False
self._velocity = (self._velocity[0], 0)
self.set_global_position((self._position[0], res[1]))
else:
self._is_jumping = True
self._jump -= elapsed_time
self._velocity = (self._velocity[0], self._velocity[1] +
0.08 * vel_py * elapsed_time)
def update(self, elapsed_time):
increment = ResourceManager.load_config().get_pixels(self._velocity)
new_x = increment[0] * elapsed_time
new_y = increment[1] * elapsed_time
self._increase_position((new_x, new_y))
def start_scene(self):
if self._song != None:
song_path = ResourceManager.get_song_path(self._song)
pygame.mixer.music.load(song_path)
pygame.mixer.music.play(loops=-1)
def populate_highscores(self):
self._screen_list[1].populate_hs_list(ResourceManager.load_hs())
#!/usr/bin/env python
from game import ResourceManager
from game.scenes import MainMenu
import sys, getopt, os
if __name__ == '__main__':
sys.path.append(os.getcwd())
try:
opts, args = getopt.getopt(sys.argv[1:], "ho:v",
["help", "invulnerable"])
except getopt.GetoptError as err:
# print help information and exit:
print(str(err)) # will print something like "option -a not recognized"
sys.exit(2)
invulnerable = False
verbose = False
for o, a in opts:
if o in ("-h", "--help"):
print("Options: --invulnerable --debug_scene=name")
sys.exit()
if o in ("-i", "--invulnerable"):
invulnerable = True
if o in ("-d", "--debug"):
ResourceManager.enable_debug(a)
director = ResourceManager.load_director()
director.push_scene(MainMenu(invulnerable))
director.execute()
def move_cpu(self):
width, _ = ResourceManager.load_config().get_resolution()
if self.rect.left >= -50 and self.rect.right <= width + 50:
Character.move(self, (Character.LEFT, Character.STILL))
def __init__(self, menu, background, title, text, options):
AbstractScreen.__init__(self,
menu,
"backgrounds/dialog.jpg",
transform=True)
self._text_area = pygame.Rect(
self.rect.centerx - int(DialogScreen.TEXT_AREA_WIDTH / 2),
self.rect.top + DialogScreen.TEXT_AREA_TOP_GAP,
DialogScreen.TEXT_AREA_WIDTH, DialogScreen.TEXT_AREA_HEIGHT)
self.round_rect(self.image, self._text_area, 50,
DialogScreen.TEXT_AREA_COLOR)
self._options_area = pygame.Rect(
self.rect.centerx - int(DialogScreen.OPTIONS_AREA_WIDTH / 2),
self._text_area.centery -
int(DialogScreen.OPTIONS_AREA_HEIGHT / 2) +
DialogScreen.OPTIONS_AREA_TEXT_AREA_GAP,
DialogScreen.OPTIONS_AREA_WIDTH, DialogScreen.OPTIONS_AREA_HEIGHT)
self.round_rect(self.image, self._options_area, 50,
DialogScreen.OPTIONS_AREA_COLOR)
title_font = ResourceManager.load_font_asset(
"8bit.ttf", DialogScreen.TITLE_FONT_SIZE)
text_font = ResourceManager.load_font_asset(
"8bit.ttf", DialogScreen.TEXT_FONT_SIZE)
index = 0
for option in options:
x_offset, y_offset = text_font.size(option.get_text())
bpos = (self._options_area.left + x_offset,
self._options_area.centery)
tpos = (self._options_area.left + x_offset,
self._options_area.centery)
otext = TextGUI(self, text_font, DialogScreen.TEXT_COLOR,
option.get_text(), tpos)
self._gui_elements.append(
OptionButton(self, bpos, x_offset, y_offset,
option.is_valid()))
self._gui_elements.append(otext)
index = index + 1
lines = self.split_text_to_fit(text, DialogScreen.TEXT_FONT_SIZE,
DialogScreen.TEXT_AREA_WIDTH)
title = TextGUI(self, title_font, DialogScreen.TITLE_COLOR, title,
(self._text_area.centerx, self._text_area.top +
DialogScreen.TITLE_TEXT_AREA_GAP))
self._gui_elements.append(title)
background = os.path.join("heads", background)
self._gui_elements.append(
EmptyButton(self,
(self._text_area.left + DialogScreen.HEAD_LEFT_GAP,
self._text_area.centery + DialogScreen.HEAD_TOP_GAP),
100, 100, background))
index = 0
for line in lines:
ltext = TextGUI(self, text_font, DialogScreen.TEXT_COLOR,
"".join(line),
(self._text_area.centerx, self._text_area.top +
DialogScreen.TITLE_TEXT_AREA_GAP +
DialogScreen.TEXT_TITLE_GAP +
(DialogScreen.TEXT_FONT_SIZE * index)))
self._gui_elements.append(ltext)
index = index + 1
