def draw(self):
ScreenGUI.draw(self)
font = pg.font.Font(assets.path_to('fonts', 'yukari.ttf'), 78)
title = font.render('VICTORY!!', True, (255, 255, 255))
font = pg.font.Font(assets.path_to('fonts', 'Purisa Bold.ttf'), 40)
subtitle = font.render('Anything is paw-sible for you', True,
(255, 255, 255))
image_points = self.get_points_sprite("characters", "enemy",
"enemy_full.png")
image_hearts = self.get_heart_sprite("player", "Corazon-Sheet.png")
image_cookie = assets.load_image("treat.png")
image_cookie = pg.transform.scale(image_cookie, (48, 48))
player = self.menu.director.player
punctuation = player.punctuation
n_hearts = player.hearts
n_cookies = player.cookies
text_points = font.render(str(punctuation), True, (0, 0, 0))
text_hearts = font.render(str(n_hearts), True, (0, 0, 0))
text_cookies = font.render(str(n_cookies), True, (0, 0, 0))
self.screen.blit(title, (270, 80))
self.screen.blit(subtitle, (50, 200))
self.screen.blit(text_points, (470, 300))
self.screen.blit(text_hearts, (470, 400))
self.screen.blit(text_cookies, (470, 500))
self.screen.blit(image_points, (290, 300))
self.screen.blit(image_hearts, (300, 400))
self.screen.blit(image_cookie, (300, 500))
def __init__(self, game):
try:
with open(assets.path_to(game)) as f:
game_config = json.load(f)
self.fps = game_config["fps"]
self.cursor = game_config["cursor"]
self.screen_height = game_config["screen_height"]
self.screen_width = game_config["screen_width"]
self.levels = list(map(lambda x: LevelDTO(x), game_config["levels"]))
with open(assets.path_to(game_config["characters"])) as f2:
characters = json.load(f2)
self.characters = dict(
map(lambda k, v: (k, CharacterDTO(v)), characters.keys(), characters.values()))
with open(assets.path_to(game_config["sounds"])) as f3:
profiles = json.load(f3)
sounds = profiles["sounds"]
self.sounds = dict(
map(lambda k, v: (k, SoundDTO(v)), sounds.keys(), sounds.values()))
self.music = profiles["music"]
except IOError as ex:
print("Game data loading error", ex)
def __init__(self, level_name):
try:
self.level_name = level_name
with open(assets.path_to('levels', level_name, level_name + '_config.json')) as f:
level_config = json.load(f)
if level_config is not None:
self.path = level_config["path"]
self.bg = level_config["background"]
self.sounds = level_config["sounds_profile"]
self.music = level_config["music_profile"]
tiles = level_config["tiles"]
entities = level_config["entities"]
events = level_config['events']
self.tiles_image = tiles['image']
self.layers_id = tiles["layers_id"]
with open(assets.path_to('levels', level_name, level_config["gaps"])) as f:
self.gaps = GapsDTO(json.load(f))
with open(assets.path_to('levels', level_name, tiles['config'])) as f:
tiles_config = json.load(f)
if tiles_config is not None:
self.tile_size = tiles_config["tile_size"]
self.map_width = tiles_config["map_width"]
self.map_height = tiles_config["map_height"]
layers = tiles_config["layers"]
self.layers = []
for layer in layers:
self.layers.append(LayerDTO(layer))
with open(assets.path_to('levels', level_name, entities)) as f:
entities_config = json.load(f)
self.hero = EntityDTO(entities_config['hero'])
self.enemies = []
for entity in entities_config["enemies"]:
enemy_aux = dict()
enemy_aux["name"] = entity["name"]
enemy_aux["scale"] = entity["scale"]
for pos in entity["positions"]:
enemy_aux["x"] = pos["x"]
enemy_aux["y"] = pos["y"]
self.enemies.append(EntityDTO(enemy_aux))
with open(assets.path_to('levels', level_name, events)) as f:
entities_config = json.load(f)
self.events = []
for event in entities_config['events']:
self.events.append(EventDTO(event))
except IOError as e:
print("Level data loading error > ", e)
def __init__(self, container, entity, character, *groups):
super().__init__(*groups)
sheet_path = assets.path_to("characters", character.name,
character.sheet)
sheet = container.image_from_path(sheet_path)
sheet = SpriteStripAnim(sheet,
(0, 0, character.height, character.width),
character.rows,
rows=4,
scale=(character.rescale_x,
character.rescale_y))
self.layer = character.layer
self.scroll = pg.Vector2(0, 0)
self.sheet = sheet
self.image = self.sheet.images[0][0]
self.mask = self.sheet.masks[0][0]
self.rect = self.image.get_rect()
self.rect.bottomleft = entity.pos
self.movement = None
self.direction = None
self.onGround = False
self.getting_damage = False
self.falling_mode = False
self.y_movement = False
self.gravity_value = pg.Vector2((0, 3.8))
self.vel = pg.Vector2((0, 0))
self.speed = 8
self.jump_strength = 28
self.num_jumps = 0
self.damage_time = 0
self.falling_velocity = 0
self.mixer = container.get_object('mixer')
def __init__(self, container, level_dto):
self.container = container
self.events = level_dto.events
path = assets.path_to('levels', level_dto.level_name,
level_dto.tiles_image)
sheet = container.image_from_path(path)
self.sheet = SpriteSheet(sheet)
def __init__(self, container, n_hearts, player):
path = assets.path_to("player", "Corazon-Sheet.png")
sheet = container.image_from_path(path)
sheet = pg.transform.scale(sheet, (Heart.SIZE * 21, Heart.SIZE))
self.sheet = SpriteSheet(sheet)
self.hearts = []
self.player = player
pos = ceil(self.player.life / 2) - 1
# Full hearts
for i in range(pos):
heart = Heart(self.sheet, 0)
self.heart_pos(heart, i)
self.hearts.append(heart)
# Half hearts
heart = Heart(self.sheet, self.player.life % 2)
self.heart_pos(heart, pos)
self.hearts.append(heart)
# Empty hearts
for i in range(pos + 1, n_hearts):
heart = Heart(self.sheet, 2)
self.heart_pos(heart, i)
self.hearts.append(heart)
self.queue = []
super().__init__(self.hearts)
def load_background(self, n=6):
self.bg = px.ParallaxSurface(
(self.dto.map_width * self.dto.tile_size,
self.dto.map_height * self.dto.tile_size), pg.RLEACCEL)
for i in range(1, n):
self.bg.add(
assets.path_to('levels', self.dto.level_name, self.dto.bg,
f"{i}.png"), (n - i))
def __init__(self, container, entity, character, *groups):
path = assets.path_to('projectiles', character.projectile)
image = container.image_from_path(path)
self.projectile = pg.transform.scale(image, (32, 32))
ActiveEntity.__init__(self, container, entity, character, *groups)
self.maniac_time = 10
self.maniac_init = time.time()
self.maniac = False
def __init__(self, menu, image):
self.menu = menu
self.element_click = None
self.bg = assets.load_image(image)
self.font = pg.font.Font(assets.path_to('fonts', 'Purisa Bold.ttf'),
26)
self.screen = pg.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
# list of elementGUI
self.elementGUI = []
def get_heart_sprite(self, *parts):
container = self.menu.director.container
path = assets.path_to(*parts)
sheet = container.image_from_path(path)
sheet = pg.transform.scale(sheet, (50 * 21, 50))
sheet = SpriteSheet(sheet)
return sheet.image_at((0, 0, 50, 50))
def get_points_sprite(self, *parts):
container = self.menu.director.container
path = assets.path_to(*parts)
sheet = container.image_from_path(path)
sheet = SpriteStripAnim(sheet, (0, 0, 32, 32), 8, rows=4)
sheet[3].set_frames_skip(2)
image = sheet[3].next(0)
return pg.transform.scale(image, (64, 64))
def __init__(self, container, mouse_pos):
super().__init__()
game = container.get_object('game')
path = assets.path_to("cursor", game.cursor)
sheet = container.image_from_path(path)
self.sheet = SpriteSheet(sheet)
self.image = pg.transform.scale(self.sheet.image_at((64, 0, 16, 16)),
(16, 16))
self.rect = self.image.get_rect()
self.rect.center = mouse_pos
def load_music(self, music):
if music != self.music:
mixer.music.stop()
self.playing = False
mixer.music.unload()
mixer.music.load(assets.path_to("sounds", music))
if not mixer.get_busy():
mixer.music.play(-1)
mixer.music.set_volume(self.current_music_volume)
self.playing = True
self.music = music
def __init__(self, container, player, point_y):
super().__init__()
self.font = pg.font.Font(assets.path_to('fonts', 'Purisa Bold.ttf'),
48)
self.player = player
self.image = self.font.render(f'x{player.punctuation}', True,
(0, 0, 0))
self.rect = self.image.get_rect()
game = container.get_object('game')
self.base_offset = game.screen_width - 3 * 64
self.rect.x = self.base_offset - 24 * (math.log10(
max(1, self.player.punctuation)))
self.rect.y = point_y + 8
self.increasing = False
def __init__(self, container, point_y):
super().__init__()
path = assets.path_to("characters", "enemy", "enemy_full.png")
sheet = container.image_from_path(path)
self.sheet = SpriteStripAnim(sheet, (0, 0, 32, 32), 8, rows=4)
self.sheet[3].set_frames_skip(2)
self.image = self.sheet[3].next(0)
self.image = pg.transform.scale(self.image, (64, 64))
self.rect = self.image.get_rect()
game = container.get_object('game')
self.rect.x = game.screen_width - 2* 64 - 4
self.rect.y = point_y
self.running = False
self.begin = False
def __init__(self, screen, color, text, position):
font = pg.font.Font(assets.path_to('fonts', 'Purisa Bold.ttf'), 26)
self.image = font.render(text, True, color)
ElementGUI.__init__(self, screen, self.image.get_rect())
self.set_position(position)
def draw(self):
ScreenGUI.draw(self)
font = pg.font.Font(assets.path_to('fonts', 'yukari.ttf'), 78)
title = font.render('5Gatos', True, (255, 255, 255))
self.screen.blit(title, (280, 60))
def load_sound(sound_file):
return mixer.Sound(assets.path_to("sounds", sound_file)) if sound_file else None
def __init__(self, screen, image, position, width, height):
self.image = pg.image.load(assets.path_to(image))
self.image = pg.transform.scale(self.image, (width, height))
ElementGUI.__init__(self, screen, self.image.get_rect())
self.set_position(position)
def image_from_parts(self, *parts: str):
path = assets.path_to(*parts)
return self.image_from_path(path)
def draw(self):
ScreenGUI.draw(self)
font = pg.font.Font(assets.path_to('fonts', 'yukari.ttf'), 78)
title = font.render('Game Over :(', True, (255, 255, 255))
self.screen.blit(title, (215, 80))