def run(self):
"""Execute the game loop
"""
pygame.init()
screen = Screen(self.window_size)
clock = pygame.time.Clock()
world = World()
scheduler = Scheduler()
graphics_system = GraphicsSystem(world, screen)
load_assets(graphics_system)
tile_system = TileSystem(world, 5)
mouse_system = MouseSystem(world)
animation_system = AnimationSystem(world)
light_system = LightSystem(world)
fear_system = FearSystem(world)
clock.tick(self.fps)
playing = [True]
def end_game():
playing[0] = False
create_title_screen(world, scheduler, end_game)
while playing[0]:
for event in pygame.event.get():
if event.type == pygame.QUIT:
playing[0] = False
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_system.on_mouse_down(
event.pos,
to_mouse_button(event.button)
)
elif event.type == pygame.MOUSEMOTION:
mouse_system.on_mouse_motion(event.pos)
clock.tick(self.fps)
time_elapsed = float(clock.get_time()) / 1000.0
scheduler.update(time_elapsed)
animation_system.update(time_elapsed)
tile_system.update_tile_positions()
light_system.update()
fear_system.update()
graphics_system.draw_entities()
pygame.display.set_caption(
"The Family's Treasure Tale --- " + str(clock.get_fps()))
pygame.quit()
def run(self):
"""Execute the game loop
"""
pygame.init()
screen = Screen(self.window_size)
clock = pygame.time.Clock()
world = World()
scheduler = Scheduler()
graphics_system = GraphicsSystem(world, screen)
load_assets(graphics_system)
tile_system = TileSystem(world, 5)
mouse_system = MouseSystem(world)
animation_system = AnimationSystem(world)
light_system = LightSystem(world)
fear_system = FearSystem(world)
clock.tick(self.fps)
playing = [True]
def end_game():
playing[0] = False
create_title_screen(world, scheduler, end_game)
while playing[0]:
for event in pygame.event.get():
if event.type == pygame.QUIT:
playing[0] = False
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_system.on_mouse_down(event.pos,
to_mouse_button(event.button))
elif event.type == pygame.MOUSEMOTION:
mouse_system.on_mouse_motion(event.pos)
clock.tick(self.fps)
time_elapsed = float(clock.get_time()) / 1000.0
scheduler.update(time_elapsed)
animation_system.update(time_elapsed)
tile_system.update_tile_positions()
light_system.update()
fear_system.update()
graphics_system.draw_entities()
pygame.display.set_caption("The Family's Treasure Tale --- " +
str(clock.get_fps()))
pygame.quit()
def main():
"""
Prepare our environment, create a display, and start the program.
"""
os.environ['SDL_VIDEO_CENTERED'] = '1'
pg.init()
pg.display.set_caption(assets.CAPTION)
assets.load_assets()
App().main_loop()
pg.quit()
sys.exit()
def tela_1(window):
'''definição da tela -1, que é a primeira do jogo com instruções, bem-vindo e música'''
pygame.mixer.music.load('Dungeons/musicatela_1.mp3')
pygame.mixer.music.set_volume(0.1)
pygame.mixer.music.play()
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
pygame.mixer.music.play(loops=-1)
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = DONE
return SAIR
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
return TELA0
window.fill((0, 0, 0)) # Preenche com a cor preta
window.blit(assets['Tela_introducao'], (0, 0))
all_sprites.draw(window)
pygame.display.update()
def tela_gameover(window):
''' definição da tela gameover com musica'''
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
pygame.mixer.music.stop()
pygame.mixer.music.load('Dungeons/musicagameover.mp3')
pygame.mixer.music.set_volume(0.1)
pygame.mixer.music.play()
all_sprites = pygame.sprite.Group()
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
pygame.mixer.music.play(loops=-1)
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = DONE
return SAIR
window.fill((0, 0, 0)) # Preenche com a cor preta
window.blit(assets['gameover'], (0, 0))
all_sprites.draw(window)
pygame.display.update()
def tela_pre_boss(window):
''' tela antes do boss que avisa o jogador para o último nível'''
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = DONE
return SAIR
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
return TELA4
window.fill((0, 0, 0)) # Preenche com a cor preta
window.blit(assets['tela_pre_boss'], (0, 0))
all_sprites.draw(window)
pygame.display.update()
def tela_pre_2(window):
''' definição da tela antes da 2 que prepara o jogador para enfrentar o mob do machado'''
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = DONE
return SAIR
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
return TELA2
window.fill((0, 0, 0)) # Preenche com a cor preta
window.blit(assets['tela_pre_2'], (0, 0))
all_sprites.draw(window)
pygame.display.update()
def main(width=800, height=800):
global window, history, background_batch, pieces_batch
window = pyglet.window.Window(width=width, height=height)
pieces_batch = pyglet.graphics.Batch()
background_batch = pyglet.graphics.Batch()
asset_map = assets.load_assets(pyglet)
board_sprite = pyglet.sprite.Sprite(asset_map.board,
batch=background_batch)
for piece, image in asset_map.pieces.items():
piece_sprite = pyglet.sprite.Sprite(image, batch=pieces_batch)
piece_sprites[piece] = piece_sprite
starting_board = board.create_board()
for coords, piece in starting_board.items():
image = asset_map.pieces[piece]
x, y = coords
cell_size = 480 / 8
pyglet.sprite.Sprite(image, batch=pieces_batch)
@window.event
def on_draw(self):
self.clear()
self.background_batch.draw()
self.pieces_batch.draw()
pyglet.app.run()
def game_over(bank):
keys_down = {}
assets = load_assets()
over = True
i = 1
while over:
screen = pygame.display.set_mode([HEIGHT, WIDTH])
screen.fill(BLACK)
OVER = pygame.image.load(path.join(img_dir,
'over.png')).convert_alpha()
OVER = pygame.transform.scale(OVER, (HEIGHT, WIDTH))
screen.blit(OVER, [0, 0])
font = assets[SCORE_FONT]
score = font.render("Score:{}".format(bank[1]), True, [255, 0, 0])
screen.blit(score, (20, 20))
pygame.display.update()
if i == 1:
assets[GAME_OVER].play()
i = 0
for event in pygame.event.get():
if event.type == pygame.QUIT:
over = False
return QUIT
if event.type == pygame.KEYDOWN:
keys_down[event.key] = True
if event.key == pygame.K_TAB:
return GAME
def tela_ante1(window):
''' tela antes da 1, com suspense'''
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
pygame.mixer.music.play(loops=-1)
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = DONE
return SAIR
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
return TELA1
window.fill((0, 0, 0)) # Preenche com a cor preta
window.blit(assets['antes_fase_1'], (0, 0))
all_sprites.draw(window)
pygame.display.update()
def init_screen(window):
# Variável para o ajuste de velocidade
clock = pygame.time.Clock()
# Carrega os asssets
assets = load_assets()
# ===== Loop principal =====
inicio = True
while inicio:
clock.tick(FPS)
# ----- Trata eventos
for event in pygame.event.get():
# ----- Verifica consequências
if event.type == pygame.QUIT:
state = DONE
inicio = False
if event.type == pygame.KEYUP:
state = PLAYING
inicio = False
#atualiza a tela
window.fill(BLACK)
window.blit(assets['inicio'], assets['inicio_rect'])
pygame.display.flip()
return state
def tela_final(TELA, vitoria):
clock = pygame.time.Clock()
assets = assets_file.load_assets()
estado = TELA_FINAL
last_flick = 0 # Press Any Key piscando
while estado != QUIT and estado != GAME:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
estado = QUIT
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
estado = GAME
if estado == TELA_FINAL and vitoria == 1:
TELA.fill(BLACK)
TELA.blit(assets['background'], ORIGEM)
TELA.blit(assets['TelaFinal'], ORIGEM)
TELA.blit(assets['Player1Win'], ORIGEM)
if last_flick < FPS:
TELA.blit(assets['PressSpace'], ORIGEM)
last_flick += 1
elif last_flick == FPS * 2 - 1:
last_flick = 0
else:
last_flick += 1
if estado == TELA_FINAL and vitoria == 2:
TELA.fill(BLACK)
TELA.blit(assets['background'], ORIGEM)
TELA.blit(assets['TelaFinal'], ORIGEM)
TELA.blit(assets['Player2Win'], ORIGEM)
if last_flick < FPS:
TELA.blit(assets['PressSpace'], ORIGEM)
last_flick += 1
elif last_flick == FPS * 2 - 1:
last_flick = 0
else:
last_flick += 1
pygame.display.update()
return estado
def death_screen(janela, score):
#Carregando fontes
assets = load_assets()
gameover_fnt = assets[GAMEOVER_FNT]
result_fnt = assets[RESULT_FNT]
enter_fnt = assets[ENTER_FNT]
#Preenche a janela de preto
janela.fill(BLACK)
#Colocando 'GAMEOVER'
gameover_surface = gameover_fnt.render("GAME OVER", True, RED)
gameover_rect = gameover_surface.get_rect()
gameover_rect.midtop = (WIDTH / 2, HEIGHT / 2 - 50)
#Colocando 'SCORE'
result_surface = result_fnt.render("SCORE: {}".format(score), True, WHITE)
result_rect = result_surface.get_rect()
result_rect.midtop = (WIDTH / 2, HEIGHT / 1.5)
#Colocando indicar
enter_surface = enter_fnt.render("PRESS ENTER TO GO BACK", True, WHITE)
enter_rect = enter_surface.get_rect()
enter_rect.midtop = (WIDTH / 2, HEIGHT - 110)
janela.blit(enter_surface, enter_rect)
#Atualizando janela
janela.blit(gameover_surface, gameover_rect)
janela.blit(result_surface, result_rect)
running = True
while running:
# Processa os eventos (mouse, teclado, botão, etc).
for event in pygame.event.get():
# Verifica se foi fechado.
if event.type == pygame.QUIT:
state = QUIT
running = False
# Verifica se alguma tecla foi apertada:
if event.type == pygame.KEYUP:
key = pygame.key.get_pressed()
# Verifica se return foi apertado
if event.key == pygame.K_RETURN:
state = INIT
running = False
pygame.display.flip()
return state
def load_assets_from_cpp(GPS_coords):
""" returns a 3n x 1 array of asset coordinates in the world. The dimensions
are for simplicity with integration with c++. The list MUST be a numpy array."""
asset_types = ['SNSF', 'MKRF']
asset_list = []
for asset_type in asset_types:
assets = load_assets("A27",
asset_type,
XCOORD=GPS_coords[0],
YCOORD=GPS_coords[1],
max_dist=50)
for (ind, asset) in assets.iterrows():
asset_list.append(
[asset['XCOORD'], asset['HEIGHT'], asset['YCOORD']])
# must return assets a numpy array
return [np.array(asset_list), assets]
def select_size():
RUNNING = 1
QUIT = 0
X_CLICK = False
state = RUNNING
assets = load_assets()
while state != QUIT:
x, y = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = QUIT
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
return False
if event.type == pygame.MOUSEBUTTONDOWN:
if x_btn.collidepoint(x, y):
X_CLICK = True
if event.type == pygame.MOUSEBUTTONUP:
if x_btn.collidepoint(x, y):
return False
else:
X_CLICK = False
x_btn = pygame.draw.rect(window, INSPER_RED, (20, 20, main_menu_btn_h, main_menu_btn_h))
window.blit(assets['background_day'], (0, 0))
if X_CLICK == False:
window.blit(assets['x_img_0'], (20, 20))
else:
window.blit(assets['x_img_1'], (20, 20))
pygame.display.update()
clock.tick(FPS)
pygame.quit()
pygame.mixer.quit()
def main():
asset_types = ['SNSF', 'MKRF']
asset_df = pd.DataFrame(columns=['Easting', 'Northing'])
for asset_type in asset_types:
assets = load_assets("A27", asset_type)
assets['Easting'] = assets['XCOORD']
assets['Northing'] = assets['YCOORD']
# adding lat Lon
bar = Bar("Scraping elevation data for {}...".format(asset_type),
max=len(assets))
assets = add_lat_lon(assets)
elevations = []
for (ind, asset) in assets.iterrows():
# get elevation and add to to height.
elevation = elevation_gmaps(float(asset['lat']),
float(asset['lon']))
asset_df = asset_df.append(
{
'Easting': asset['Easting'],
'Northing': asset['Northing'],
'Elevation': elevation,
'Height': asset['HEIGHT'],
'Type': asset_type
},
ignore_index=True)
bar.next()
bar.finish()
# save
data_dir = "/media/tom/HD#39/Year2/A27/Sequences/2368_0/"
asset_df.to_csv(os.path.join(data_dir, "assets_elevation.txt"),
sep=' ',
header=True,
index=False)
def init_screen(screen):
assets = load_assets()
# Variável para o ajuste de velocidade
clock = pygame.time.Clock()
# Carrega o fundo da tela inicial
background = pygame.image.load(path.join(
IMG_DIR, 'menu-background.jpeg')).convert()
background = pygame.transform.scale(assets['menu_background'],
(WIDTH, HEIGHT))
background_rect = background.get_rect()
running = True
while running:
# Ajusta a velocidade do jogo.
clock.tick(FPS)
# Processa os eventos (mouse, teclado, botão, etc).
for event in pygame.event.get():
# Verifica se foi fechado.
if event.type == pygame.QUIT:
state = QUIT
running = False
if event.type == pygame.KEYUP:
state = GAME
running = False
# A cada loop, redesenha o fundo e os sprites
screen.fill(BLACK)
screen.blit(background, background_rect)
# Depois de desenhar tudo, inverte o display.
pygame.display.flip()
return state
pygame.init()
# Resolução da Tela
TELA = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Space Battle')
lastFlick = 0
QUIT = 0
TELA_INICIAL = 1
INSTRUCOES = 2
GAME = 3
TELA_FINAL = 4
WIN = 1
assets = assets_file.load_assets()
clock = pygame.time.Clock()
game = TELA_FINAL
last_flick = 0 # Press Any Key piscando
while game != QUIT and game != GAME:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
game = QUIT
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
game = GAME
if game == TELA_FINAL and WIN == 1:
def tela3(window):
''' tela em que o jogador enfrentará o arqueiro que atira flechas que descontam 2 vidas do jogador'''
pygame.mixer.music.stop()
pygame.mixer.music.load('Dungeons/musicatela3.mp3')
pygame.mixer.music.set_volume(0.1)
pygame.mixer.music.play()
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
all_arqueiros = pygame.sprite.Group()
all_flechas = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_arqueiros'] = all_arqueiros
groups['all_flechas'] = all_flechas
player = Character(groups, assets)
all_sprites.add(player)
global score
global lives
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
pygame.mixer.music.play(loops=-1)
available_arqueiros = 8
last_arqueiro = pygame.time.get_ticks()
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return SAIR
if state == PLAYING:
if event.type == pygame.KEYDOWN:
keys_down[event.key] = True
if event.key == pygame.K_LEFT:
player.speedx -= 2
if event.key == pygame.K_RIGHT:
player.speedx += 2
if event.key == pygame.K_SPACE or event.key == pygame.K_UP:
player.jump()
if event.key == pygame.K_k:
player.attack()
if event.type == pygame.KEYUP:
if event.key in keys_down and keys_down[event.key]:
if event.key == pygame.K_LEFT:
player.speedx += 2
if event.key == pygame.K_RIGHT:
player.speedx -= 2
if event.key == pygame.K_k:
player.attack()
keys_down[event.key] = False
#Atualiza Jogo
now = pygame.time.get_ticks()
if available_arqueiros > 0 and now - last_arqueiro > 3000:
arqueiro = Arqueiro(assets, groups)
all_sprites.add(arqueiro)
all_arqueiros.add(arqueiro)
available_arqueiros -= 1
last_arqueiro = now
all_sprites.update()
if state == PLAYING:
hits = pygame.sprite.spritecollide(player, all_arqueiros, False, pygame.sprite.collide_mask)
for arqueiro in hits:
if player.attacking:
arqueiro.kill()
score+=100
else:
lives -= 1
if lives <= 0:
return TELA_GAMEOVER
hits = pygame.sprite.spritecollide(player, all_flechas, True, pygame.sprite.collide_mask)
for flechas in hits:
lives -= 2
if lives <= 0:
return TELA_GAMEOVER
if len(all_arqueiros) == 0 and available_arqueiros == 0:
return TELA_PRE_BOSS
window.fill((0, 0, 0)) # Preenche com a cor branca
window.blit(assets['fundotela3'], (0, 0))
all_sprites.draw(window)
text_surface = assets['score_font'].render("{:08d}".format(score), True, (255, 255, 0))
text_rect = text_surface.get_rect()
text_rect.midtop = (WIDTH / 2, 10)
window.blit(text_surface, text_rect)
text_surface = assets['score_font2'].render(chr(9829) * lives, True, (255, 0, 0))
text_rect = text_surface.get_rect()
text_rect.bottomleft = (10, HEIGHT - 10)
window.blit(text_surface, text_rect)
pygame.display.update()
def tela4(window):
''' tela do chefão, que contempla todos os outros inimigos e com a maior dificuldade do jogo'''
pygame.mixer.music.stop()
pygame.mixer.music.load('Dungeons/musicatelaboss_certo.mp3')
pygame.mixer.music.set_volume(0.1)
pygame.mixer.music.play()
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
all_mobs = pygame.sprite.Group()
all_bosses = pygame.sprite.Group()
all_flechas = pygame.sprite.Group()
all_bullets = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_mobs'] = all_mobs
groups['all_bosses'] = all_bosses
groups['all_flechas'] = all_flechas
groups['all_bullets'] = all_bullets
player = Character(groups, assets)
all_sprites.add(player)
for i in range(1):
boss = Boss(assets, groups)
all_sprites.add(boss)
all_bosses.add(boss)
global score
global lives
lives_boss = 5
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
pygame.mixer.music.play(loops=-1)
last_mob = pygame.time.get_ticks()
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return SAIR
if state == PLAYING:
if event.type == pygame.KEYDOWN:
keys_down[event.key] = True
if event.key == pygame.K_LEFT:
player.speedx -= 2
if event.key == pygame.K_RIGHT:
player.speedx += 2
if event.key == pygame.K_SPACE or event.key == pygame.K_UP:
player.jump()
if event.key == pygame.K_k:
player.attack()
if event.type == pygame.KEYUP:
if event.key in keys_down and keys_down[event.key]:
if event.key == pygame.K_LEFT:
player.speedx += 2
if event.key == pygame.K_RIGHT:
player.speedx -= 2
if event.key == pygame.K_k:
player.attack()
keys_down[event.key] = False
#Atualiza Jogo
now = pygame.time.get_ticks()
if boss.alive() and now - last_mob > 500:
classe_mob = random.choice([Mob, Mob2, Arqueiro])
mob = classe_mob(assets, groups)
all_sprites.add(mob)
all_mobs.add(mob)
last_mob = now
all_sprites.update()
if state == PLAYING:
hits = pygame.sprite.spritecollide(player, all_bosses, False, pygame.sprite.collide_mask)
for boss in hits:
if player.attacking:
lives_boss-=1
if lives_boss == 0:
boss.kill()
else:
lives -= 1
if lives == 0:
return TELA_GAMEOVER
hits = pygame.sprite.spritecollide(player, all_bullets, False, pygame.sprite.collide_mask)
for bullet in hits:
lives -= 3
if lives <= 0:
return TELA_GAMEOVER
hits = pygame.sprite.spritecollide(player, all_flechas, False, pygame.sprite.collide_mask)
for flechas in hits:
lives -= 2
if lives <= 0:
return TELA_GAMEOVER
hits = pygame.sprite.spritecollide(player, all_mobs, False, pygame.sprite.collide_mask)
for mob in hits:
if player.attacking:
mob.lives -= 1
if mob.lives <= 0:
mob.kill()
score+=100
if score % 1000 == 0 :
lives += 1
else:
lives -= 1
if lives == 0:
return TELA_GAMEOVER
if len(all_bosses) == 0 and len(all_mobs) == 0:
return TELA_WIN
window.fill((0, 0, 0)) # Preenche com a cor branca
window.blit(assets['fundo_boss'], (0, 0))
all_sprites.draw(window)
text_surface = assets['score_font'].render("{:08d}".format(score), True, (255, 255, 0))
text_rect = text_surface.get_rect()
text_rect.midtop = (WIDTH / 2, 10)
window.blit(text_surface, text_rect)
text_surface = assets['score_font2'].render(chr(9829) * lives, True, (255, 0, 0))
text_rect = text_surface.get_rect()
text_rect.bottomleft = (10, HEIGHT - 10)
window.blit(text_surface, text_rect)
pygame.display.update()
def tela0(window):
''' tela de tutorial para o jogador aprender na prática como será o jogo'''
pygame.mixer.music.stop()
pygame.mixer.music.load('Dungeons/florestacerto.mp3')
pygame.mixer.music.set_volume(0.1)
pygame.mixer.music.play()
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
all_mobs = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_mobs'] = all_mobs
player = Character(groups, assets)
all_sprites.add(player)
for i in range(3):
mob = Mob(assets, groups)
all_sprites.add(mob)
all_mobs.add(mob)
global lives
global score
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
pygame.mixer.music.play(loops=-1)
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = DONE
return SAIR
if event.type == pygame.KEYDOWN:
keys_down[event.key] = True
if event.key == pygame.K_LEFT:
player.speedx -= 2
if event.key == pygame.K_RIGHT:
player.speedx += 2
if event.key == pygame.K_k:
player.attack()
if event.key == pygame.K_SPACE or event.key == pygame.K_UP:
player.jump()
if event.type == pygame.KEYUP:
if event.key in keys_down and keys_down[event.key]:
if event.key == pygame.K_LEFT:
player.speedx += 2
if event.key == pygame.K_RIGHT:
player.speedx -= 2
keys_down[event.key] = False
#Atualiza Jogo
all_sprites.update()
if state == PLAYING:
hits = pygame.sprite.spritecollide(player, all_mobs, False, pygame.sprite.collide_mask)
for mob in hits:
if player.attacking:
mob.kill()
score += 100
print(score)
if score % 1000 == 0:
lives += 1
else:
lives -= 1
if lives == 0:
return TELA_GAMEOVER
if len(all_mobs) == 0 :
return TELA_ANTE1
window.fill((0, 0, 0)) # Preenche com a cor preta
window.blit(assets['telainicio1'], (0, 0))
all_sprites.draw(window)
text_surface = assets['score_font'].render("{:08d}".format(score), True, (255, 255, 0))
text_rect = text_surface.get_rect()
text_rect.midtop = (WIDTH / 2, 10)
window.blit(text_surface, text_rect)
text_surface = assets['score_font2'].render(chr(9829) * lives, True, (255, 0, 0))
text_rect = text_surface.get_rect()
text_rect.bottomleft = (10, HEIGHT - 10)
window.blit(text_surface, text_rect)
pygame.display.update()
def tela2(window):
''' tela que contempla o segundo mob que tem duas vidas e um machado'''
pygame.mixer.music.stop()
pygame.mixer.music.load('Dungeons/tela2.mp3')
pygame.mixer.music.set_volume(0.1)
pygame.mixer.music.play()
clock = pygame.time.Clock()
assets = load_assets()
FPS = 15
all_sprites = pygame.sprite.Group()
all_mobs2 = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_mobs2'] = all_mobs2
player = Character(groups, assets)
all_sprites.add(player)
global score
global lives
DONE = 0
PLAYING = 3
state = PLAYING
keys_down = {}
pygame.mixer.music.play(loops=-1)
available_mobs2 = 12
last_mob2 = pygame.time.get_ticks()
while state != DONE:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return SAIR
if state == PLAYING:
if event.type == pygame.KEYDOWN:
keys_down[event.key] = True
if event.key == pygame.K_LEFT:
player.speedx -= 2
if event.key == pygame.K_RIGHT:
player.speedx += 2
if event.key == pygame.K_SPACE or event.key == pygame.K_UP:
player.jump()
if event.key == pygame.K_k:
player.attack()
if event.type == pygame.KEYUP:
if event.key in keys_down and keys_down[event.key]:
if event.key == pygame.K_LEFT:
player.speedx += 2
if event.key == pygame.K_RIGHT:
player.speedx -= 2
if event.key == pygame.K_k:
player.attack()
keys_down[event.key] = False
#Atualiza Jogo
now = pygame.time.get_ticks()
if available_mobs2 > 0 and now - last_mob2 > 500:
mob2 = Mob2(assets, groups)
all_sprites.add(mob2)
all_mobs2.add(mob2)
available_mobs2 -= 1
last_mob2 = now
all_sprites.update()
if state == PLAYING:
hits = pygame.sprite.spritecollide(player, all_mobs2, False, pygame.sprite.collide_mask)
for mob2 in hits:
if player.attacking:
mob2.lives -=1
if mob2.lives == 0:
mob2.kill()
score += 100
print(score)
if score % 1000 == 0 :
lives += 1
else:
lives -= 1
if lives == 0:
return TELA_GAMEOVER
if len(all_mobs2) == 0 and available_mobs2 == 0:
return TELA_PRE_3
window.fill((0, 0, 0)) # Preenche com a cor branca
window.blit(assets['fundo2'], (0, 0))
all_sprites.draw(window)
text_surface = assets['score_font'].render("{:08d}".format(score), True, (255, 255, 0))
text_rect = text_surface.get_rect()
text_rect.midtop = (WIDTH / 2, 10)
window.blit(text_surface, text_rect)
text_surface = assets['score_font2'].render(chr(9829) * lives, True, (255, 0, 0))
text_rect = text_surface.get_rect()
text_rect.bottomleft = (10, HEIGHT - 10)
window.blit(text_surface, text_rect)
pygame.display.update() # Mostra o novo frame para o jogador
def game_screen(screen):
# Música do jogo
pygame.mixer.music.set_endevent(pygame.USEREVENT)
pygame.mixer.music.load(path.join('audio', 'fill.wav'))
pygame.mixer.music.set_volume(1)
pygame.mixer.music.play()
# Variável para o ajuste do FPS
clock = pygame.time.Clock()
# Carrega assets
assets = load_assets(img_dir)
# Carrega o fundo do jogo
background = assets[BACKGROUND_IMG]
# Redimensiona o fundo
background = pygame.transform.scale(background, (WIDTH, HEIGHT))
background_rect = background.get_rect()
# Carrega spritesheet
player_sheet = pygame.image.load(path.join(img_dir,
'hero.png')).convert_alpha()
# Cria sprite do jogador
player = Player(player_sheet)
# Cria um grupo de todos os sprites e adiciona o jogador
all_sprites = pygame.sprite.Group()
all_sprites.add(player)
# Cria um grupo para guardar somente os sprites do mundo
world_sprites = pygame.sprite.Group()
font = pygame.font.Font(path.join(font_dir, 'fonte.TTF'), 40)
pygame.time.set_timer(
pygame.USEREVENT + 1,
10) # Timer de 100 milisegundos para aumentar a velocidade do jogo
pygame.time.set_timer(pygame.USEREVENT + 2, random.randint(
1000,
2000)) # Timer aleatório de 1 a 2 segundos para criar novos blocos
# Define o score inicial
score = 0
# Define a variável world_speed inicial e a define como como global
global world_speed
world_speed = -13
# Define a variável highscore como global
global highscore
# Game Loop
state = PLAYING
while state == PLAYING:
# Ajusta o FPS
clock.tick(FPS)
# Processa os eventos
for event in pygame.event.get():
if event.type == pygame.USEREVENT + 1:
# Aumenta a velocidade do jogo
world_speed -= 1e-3
# Conta os pontos da partida
score += 1e-1
# Cria novos blocos em função do timer
if event.type == pygame.USEREVENT + 2:
block_x = random.randint(int(WIDTH), int(WIDTH * 1.5))
block_y = (GROUND - 130)
block = Spike(assets[SPIKE_IMG], assets[SNAKE_IMG], block_x,
block_y, world_speed)
world_sprites.add(block)
all_sprites.add(block)
if event.type == pygame.USEREVENT:
pygame.mixer.music.load(path.join('audio', 'song.wav'))
pygame.mixer.music.set_volume(1)
pygame.mixer.music.play(-1)
# Verifica se soltou alguma tecla
if event.type == pygame.KEYDOWN:
# Faz o jogador pular
if event.key == pygame.K_SPACE or event.key == pygame.K_UP:
player.JUMPING()
# Verifica se o jogo foi fechado
if event.type == pygame.QUIT:
state = DONE
hits = pygame.sprite.spritecollide(player, world_sprites, True,
pygame.sprite.collide_mask)
if len(hits) > 0:
state = PLAYAGAIN
death = pygame.mixer.Sound(path.join('audio', 'death.wav'))
death.set_volume(0.4)
death.play()
if score > highscore:
highscore = score
all_sprites.update()
# A cada loop redesenha o fundo e os sprites
screen.fill(BLACK)
all_sprites.draw(screen)
# Atualiza a posição do fundo
background_rect.x += world_speed
# Se o fundo saiu da janela, desenha outro pra direita
if background_rect.right < 0:
background_rect.x += background_rect.width
screen.blit(background, background_rect)
# Desenha a imagem deslocada
background_rect2 = background_rect.copy()
background_rect2.x += background_rect2.width
screen.blit(background, background_rect2)
# Mostra o score da partida atual
score_texto = font.render('score: {0}'.format(int(score)), True,
(WHITE))
screen.blit(score_texto, (30, 70))
# Mostra o highscore
highscore_texto = font.render('highscore: {0}'.format(int(highscore)),
True, (WHITE))
screen.blit(highscore_texto, (30, 25))
# Desenha os sprites
all_sprites.draw(screen)
# Após desenhar inverte o display
pygame.display.flip()
return state, highscore, world_speed
def choose_screen(janela):
# Variável para o ajuste de velocidade
clock = pygame.time.Clock()
#Importanto assets
assets = load_assets()
escolha_fnt = assets[CHOOSE_FNT]
title_choose_fnt = assets[TITLE_CHOOSE_FNT]
#Imagem dos santas para escolher
santa_light = load_spritesheet(assets[SANTALIGHT], 4, 3)
santa_light[7] = pygame.transform.scale(santa_light[7], SANTA_SCREEN)
santa_black = load_spritesheet(assets[SANTABLACK], 4, 3)
santa_black[7] = pygame.transform.scale(santa_black[7], SANTA_SCREEN)
#Colocando tela de fundo
background = pygame.image.load(
os.path.join('Assets', 'Images', 'BG_01.png')).convert()
background = pygame.transform.scale(background, (WIDTH, HEIGHT))
background_rect = background.get_rect()
#Colocando Título
title_choose_surface = title_choose_fnt.render("CHOOSE YOUR CHARACTER",
True, RED)
title_choose_rect = title_choose_surface.get_rect()
title_choose_rect.midtop = (WIDTH / 2, 50)
background.blit(title_choose_surface, title_choose_rect)
#Atualizando santa e gorro
background.blit(santa_light[7], (WIDTH * 1 / 4 - 90, HEIGHT / 2))
background.blit(santa_black[7], (WIDTH * 3 / 4, HEIGHT / 2))
#Colocando texto da escolha
escolha_surface = escolha_fnt.render("PRESS < OR >", True, BLACK)
escolha_rect = escolha_surface.get_rect()
escolha_rect.midtop = (WIDTH / 2, HEIGHT / 2 + 45)
background.blit(escolha_surface, escolha_rect)
running = True
while running:
# Ajusta a velocidade do jogo.
clock.tick(FPS)
# Processa os eventos (mouse, teclado, botão, etc).
for event in pygame.event.get():
# Verifica se foi fechado.
if event.type == pygame.QUIT:
state = QUIT
running = False
# Verifica se alguma tecla foi apertada
if event.type == pygame.KEYUP:
key = pygame.key.get_pressed()
# Verifica se < ou > foi apertado
if event.key == pygame.K_LEFT:
#Para a musica de entrada, define o estado como GAME e chama a sprite do santa light
pygame.mixer.music.stop()
state = GAME
sprite_jogo = SANTALIGHT
running = False
if event.key == pygame.K_RIGHT:
#Para a musica de entrada, define o estado como GAME e chama a sprite do santa black
pygame.mixer.music.stop()
state = GAME
sprite_jogo = SANTABLACK
running = False
# A cada loop, redesenha o fundo e os sprites
janela.blit(background, background_rect)
# Depois de desenhar tudo, inverte o display.
pygame.display.flip()
retornos = [state, sprite_jogo]
return retornos
def tela_jogo(TELA):
assets = assets_file.load_assets()
pygame.mixer.music.load('resources/music/background_music.wav')
pygame.mixer.music.set_volume(1.0)
pygame.mixer.music.play(loops=-1)
if CORONA:
assets['corona_on_sound'].play()
all_sprites = pygame.sprite.Group()
all_asteroids = pygame.sprite.Group()
all_lasers_1 = pygame.sprite.Group()
all_lasers_2 = pygame.sprite.Group()
all_star = pygame.sprite.Group()
all_speed = pygame.sprite.Group()
all_size = pygame.sprite.Group()
all_powerups = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_asteroids'] = all_asteroids
groups['all_lasers_1'] = all_lasers_1
groups['all_lasers_2'] = all_lasers_2
groups['all_star'] = all_star
groups['all_speed'] = all_speed
groups['all_size'] = all_size
groups['all_powerups'] = all_powerups
player_1 = Ship(groups, assets, 'ship1', 0)
player_2 = Ship(groups, assets, 'ship2', WIDTH - SHIP_SIZE)
all_sprites.add(player_1)
all_sprites.add(player_2)
for i in range(NUMERO_ASTEROIDES):
asteroid = Asteroides(assets)
all_sprites.add(asteroid)
all_asteroids.add(asteroid)
lista_Sprites = [all_sprites, all_asteroids, all_lasers_1, all_lasers_2]
estado = GAME
delta_tempo = 0
score_player_1 = 0
score_player_2 = 0
player_1_lives = NUMERO_VIDAS
player_2_lives = NUMERO_VIDAS
star_player_1 = False
star_player_2 = False
player_1_dead = False
player_2_dead = False
clock = pygame.time.Clock()
keys_down = {}
while estado != TELA_FINAL and estado != QUIT:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
estado = QUIT
# Pressiona a tecla
if event.type == pygame.KEYDOWN:
keys_down[event.key] = True
#Player 1
if event.key == pygame.K_w:
player_1.speedy -= SHIP_SPEED
if event.key == pygame.K_s:
player_1.speedy += SHIP_SPEED
if event.key == pygame.K_a:
player_1.speedx -= SHIP_SPEED
if event.key == pygame.K_d:
player_1.speedx += SHIP_SPEED
if event.key == pygame.K_SPACE:
player_1.shoot()
#Player 2
if event.key == pygame.K_UP:
player_2.speedy -= SHIP_SPEED
if event.key == pygame.K_DOWN:
player_2.speedy += SHIP_SPEED
if event.key == pygame.K_LEFT:
player_2.speedx -= SHIP_SPEED
if event.key == pygame.K_RIGHT:
player_2.speedx += SHIP_SPEED
if event.key == pygame.K_RETURN:
player_2.shoot()
# Solta a tecla
if event.type == pygame.KEYUP:
if event.key in keys_down and keys_down[event.key]:
#Player 1
if event.key == pygame.K_w:
player_1.speedy += SHIP_SPEED
if event.key == pygame.K_s:
player_1.speedy -= SHIP_SPEED
if event.key == pygame.K_a:
player_1.speedx += SHIP_SPEED
if event.key == pygame.K_d:
player_1.speedx -= SHIP_SPEED
#Player 2
if event.key == pygame.K_UP:
player_2.speedy += SHIP_SPEED
if event.key == pygame.K_DOWN:
player_2.speedy -= SHIP_SPEED
if event.key == pygame.K_LEFT:
player_2.speedx += SHIP_SPEED
if event.key == pygame.K_RIGHT:
player_2.speedx -= SHIP_SPEED
all_sprites.update()
if estado == GAME:
hits_laser_1_laser_2 = pygame.sprite.groupcollide(
all_lasers_1, all_lasers_2, True, True,
pygame.sprite.collide_mask)
# ======= player 1 ========
# ------ Power Ups ----------
hits_player_1_estrelinha = pygame.sprite.spritecollide(
player_1, all_star, True, pygame.sprite.collide_mask)
if hits_player_1_estrelinha:
assets['powerup_sound'].play()
star_player_1 = True
player_1.star_ship(True)
tick_star_player_1 = pygame.time.get_ticks()
agora = pygame.time.get_ticks()
if star_player_1 and (agora - tick_star_player_1 > STAR_TIME):
star_player_1 = False
player_1.star_ship(False)
hits_player_1_speed = pygame.sprite.spritecollide(
player_1, all_speed, True, pygame.sprite.collide_mask)
if hits_player_1_speed:
assets['powerup_sound'].play()
player_1.speed_multiplier()
hits_player_1_size = pygame.sprite.spritecollide(
player_1, all_size, True, pygame.sprite.collide_mask)
if hits_player_1_size:
assets['powerup_sound'].play()
player_1.size_multiplier()
hits_laser_1_powerups = pygame.sprite.groupcollide(
all_lasers_1, all_powerups, True, True,
pygame.sprite.collide_mask)
#--------- Closisões ----------
hits_asteroid_laser_1 = pygame.sprite.groupcollide(
all_asteroids, all_lasers_1, True, True,
pygame.sprite.collide_mask)
for asteroid in hits_asteroid_laser_1: # colisão entre asteroids e lasers 1
assets['explosion_sound'].play()
novo_asteroid = Asteroides(assets)
all_sprites.add(novo_asteroid)
all_asteroids.add(novo_asteroid)
explode_asteroid = Explode(assets, asteroid.rect.center)
all_sprites.add(explode_asteroid)
score_player_1 += 100
if score_player_1 % 1000 == 0:
POWER_UP = random.randint(1, 3)
if POWER_UP == 1:
estrela = Star(assets, PLAYER_1)
all_sprites.add(estrela)
all_powerups.add(estrela)
all_star.add(estrela)
if POWER_UP == 2:
velocidade = Speed(assets, PLAYER_1)
all_sprites.add(velocidade)
all_powerups.add(velocidade)
all_speed.add(velocidade)
if POWER_UP == 3:
tamanho = Size(assets, PLAYER_1)
all_sprites.add(tamanho)
all_powerups.add(tamanho)
all_size.add(tamanho)
if star_player_1 == True:
hits_player_1_asteroid = pygame.sprite.spritecollide(
player_1, all_asteroids, True, pygame.sprite.collide_mask)
for asteroid in hits_player_1_asteroid: # colisão entre asteroids e player 1 com estrela
assets['explosion_sound'].play()
novo_asteroid = Asteroides(assets)
all_sprites.add(novo_asteroid)
all_asteroids.add(novo_asteroid)
explode_asteroid = Explode(assets, asteroid.rect.center)
all_sprites.add(explode_asteroid)
hits_player_1_laser_2 = pygame.sprite.spritecollide(
player_1, all_lasers_2, True, pygame.sprite.collide_mask)
else:
hits_player_1_asteroid = pygame.sprite.spritecollide(
player_1, all_asteroids, True, pygame.sprite.collide_mask)
if hits_player_1_asteroid: # colisão entre asteroids e player 1
assets['explosion_sound'].play()
explode_player_1 = Explode(assets, player_1.rect.center)
all_sprites.add(explode_player_1)
player_1.kill()
estado = EXPLODING
player_1_dead = True
player_1_lives -= 1
tick_explosao = pygame.time.get_ticks()
hits_player_1_laser_2 = pygame.sprite.spritecollide(
player_1, all_lasers_2, True, pygame.sprite.collide_mask)
if hits_player_1_laser_2: # colisão entre laser 2 e player 1
assets['explosion_sound'].play()
explode_player_1 = Explode(assets, player_1.rect.center)
all_sprites.add(explode_player_1)
player_1.kill()
estado = EXPLODING
player_1_dead = True
player_1_lives -= 1
tick_explosao = pygame.time.get_ticks()
# ======= player 1 ========
# ------ Power Ups ----------
hits_player_2_estrelinha = pygame.sprite.spritecollide(
player_2, all_star, True, pygame.sprite.collide_mask)
if hits_player_2_estrelinha:
assets['powerup_sound'].play()
star_player_2 = True
player_2.star_ship(True)
tick_star_player_2 = pygame.time.get_ticks()
agora = pygame.time.get_ticks()
if star_player_2 and (agora - tick_star_player_2 > STAR_TIME):
star_player_2 = False
player_2.star_ship(False)
hits_player_2_speed = pygame.sprite.spritecollide(
player_2, all_speed, True, pygame.sprite.collide_mask)
if hits_player_2_speed:
assets['powerup_sound'].play()
player_2.speed_multiplier()
hits_player_2_size = pygame.sprite.spritecollide(
player_2, all_size, True, pygame.sprite.collide_mask)
if hits_player_2_size:
assets['powerup_sound'].play()
player_2.size_multiplier()
hits_laser_2_powerups = pygame.sprite.groupcollide(
all_lasers_2, all_powerups, True, True,
pygame.sprite.collide_mask)
# -------- Colisões ------------
hits_asteroid_laser_2 = pygame.sprite.groupcollide(
all_asteroids, all_lasers_2, True, True,
pygame.sprite.collide_mask)
for asteroid in hits_asteroid_laser_2: # colisão entre asteroids e lasers 2
assets['explosion_sound'].play()
novo_asteroid = Asteroides(assets)
all_sprites.add(novo_asteroid)
all_asteroids.add(novo_asteroid)
explode_asteroid = Explode(assets, asteroid.rect.center)
all_sprites.add(explode_asteroid)
score_player_2 += 100
if score_player_2 % 1000 == 0:
POWER_UP = random.randint(1, 3)
if POWER_UP == 1:
estrela = Star(assets, PLAYER_2)
all_sprites.add(estrela)
all_powerups.add(estrela)
all_star.add(estrela)
if POWER_UP == 2:
velocidade = Speed(assets, PLAYER_2)
all_sprites.add(velocidade)
all_powerups.add(velocidade)
all_speed.add(velocidade)
if POWER_UP == 3:
tamanho = Size(assets, PLAYER_2)
all_sprites.add(tamanho)
all_powerups.add(tamanho)
all_size.add(tamanho)
if star_player_2:
hits_player_2_asteroid = pygame.sprite.spritecollide(
player_2, all_asteroids, True, pygame.sprite.collide_mask)
for asteroid in hits_player_2_asteroid: # colisão entre asteroids e player 1 com estrela
assets['explosion_sound'].play()
novo_asteroid = Asteroides(assets)
all_sprites.add(novo_asteroid)
all_asteroids.add(novo_asteroid)
explode_asteroid = Explode(assets, asteroid.rect.center)
all_sprites.add(explode_asteroid)
hits_player_2_laser_2 = pygame.sprite.spritecollide(
player_2, all_lasers_1, True, pygame.sprite.collide_mask)
else:
hits_player_2_asteroid = pygame.sprite.spritecollide(
player_2, all_asteroids, True, pygame.sprite.collide_mask)
if hits_player_2_asteroid: # colisão entre asteroids e player 2
assets['explosion_sound'].play()
explode_player_2 = Explode(assets, player_2.rect.center)
all_sprites.add(explode_player_2)
player_2.kill()
estado = EXPLODING
player_2_dead = True
player_2_lives -= 1
tick_explosao = pygame.time.get_ticks()
hits_player_2_laser_1 = pygame.sprite.spritecollide(
player_2, all_lasers_1, True, pygame.sprite.collide_mask)
if hits_player_2_laser_1: # colisão entre laser 1 e player 2
assets['explosion_sound'].play()
explode_player_2 = Explode(assets, player_2.rect.center)
all_sprites.add(explode_player_2)
player_2.kill()
estado = EXPLODING
player_2_dead = True
player_2_lives -= 1
tick_explosao = pygame.time.get_ticks()
# ---------- rotina de explosão do player
elif estado == EXPLODING:
agora = pygame.time.get_ticks()
if agora - tick_explosao > DURACAO_EXPLOSAO:
if player_1_dead:
if player_1_lives == 0:
estado = TELA_FINAL
vitoria = PLAYER_2
else:
player_2.kill()
player_1 = Ship(groups, assets, 'ship1', 0)
player_2 = Ship(groups, assets, 'ship2',
WIDTH - SHIP_SIZE)
all_sprites.add(player_1)
all_sprites.add(player_2)
keys_down = {}
player_1_dead = False
estado = GAME
if player_2_dead:
if player_2_lives == 0:
estado = TELA_FINAL
vitoria = PLAYER_1
else:
player_1.kill()
player_1 = Ship(groups, assets, 'ship1', 0)
player_2 = Ship(groups, assets, 'ship2',
WIDTH - SHIP_SIZE)
all_sprites.add(player_1)
all_sprites.add(player_2)
keys_down = {}
player_2_dead = False
estado = GAME
else:
estado = TELA_FINAL
TELA.fill(BLACK)
TELA.blit(assets['background'], ORIGEM)
all_sprites.draw(TELA)
# ---------- Vidas dos players -----------
if player_1_lives > 0:
for lives in range(player_1_lives):
TELA.blit(assets['heart'], (20 + 35 * lives, HEIGHT - 50))
if player_2_lives > 0:
for lives in range(player_2_lives):
TELA.blit(assets['heart'],
(WIDTH - 55 - 35 * lives, HEIGHT - 50))
# --------- Score do player 1 -------------
text_surface = assets['font_score'].render(
"{:07d}".format(score_player_1), True, WHITE)
text_rect = text_surface.get_rect()
text_rect.midtop = (WIDTH / 4, 5)
TELA.blit(text_surface, text_rect)
# --------- Score do player 2 -------------
text_surface = assets['font_score'].render(
"{:07d}".format(score_player_2), True, WHITE)
text_rect = text_surface.get_rect()
text_rect.midtop = (3 * WIDTH / 4, 5)
TELA.blit(text_surface, text_rect)
pygame.display.update()
resultado = [estado, vitoria]
return resultado
def screen_game(window):
clock = pygame.time.Clock()
assets = load_assets()
#Grupos
all_sprites = pygame.sprite.Group()
all_poderzin = pygame.sprite.Group()
all_bullets = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_poderzin'] = all_poderzin
groups['all_bullets'] = all_bullets
som_game = assets[SOUND_GAMING]
som_game.play()
som_game.set_volume(0.02)
#Criando o Chefão
chefão = Boss(groups, assets)
all_sprites.add(chefão)
#Criando o jogador
player = Personagem(groups, assets)
all_sprites.add(player)
#Criando os poderes do boss
for i in range(8):
poder = Poderzin(assets, chefão)
all_sprites.add(poder)
all_poderzin.add(poder)
# Possíveis estados do jogador
STILL = 0
JUMPING = 1
FALLING = 2
keys_down = {}
lives_hero = 3
lives_boss = 5
# ======== Loop principal =========
running = True
while running:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
state = QUIT
pygame.quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player.speedx -= SPEEDX
if event.key == pygame.K_RIGHT:
player.speedx += SPEEDX
if event.key == pygame.K_UP:
player.pulo()
som_pulo = assets[SOUND_JUMP]
som_pulo.set_volume(0.2)
som_pulo.play()
if event.key == pygame.K_SPACE:
player.shoot()
if event.key == pygame.K_q:
state = QUIT
pygame.quit()
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
player.speedx += SPEEDX
if event.key == pygame.K_RIGHT:
player.speedx -= SPEEDX
#Colisões entre poder do boss e personagem
hits = pygame.sprite.spritecollide(player, all_poderzin, True, pygame.sprite.collide_mask)
if len(hits) > 0:
som_hit_hero = assets[SOUND_HIT_HERO]
som_hit_hero.set_volume(0.05)
som_hit_hero.play()
lives_hero -= 1
if lives_hero == 0:
som_game.set_volume(0)
som_loses = pygame.mixer.Sound('assets/snd/death.ogg')
som_loses.set_volume(0.03)
som_loses.play()
time.sleep(2.8)
state = LOSE
running = False
#Colisões entre poder do personagem e boss
hits_2 = pygame.sprite.spritecollide(chefão, all_bullets, True, pygame.sprite.collide_mask)
if len(hits_2) > 0:
som_hit_boss = assets[SOUND_HIT_BOSS]
som_hit_boss.set_volume(0.05)
som_hit_boss.play()
lives_boss -= 1
if lives_boss == 0:
som_game.set_volume(0)
som_goal = assets[SOUND_GOAL]
som_goal.set_volume(0.6)
som_goal.play()
time.sleep(7.8)
state = WON
running = False
#atualiza estado do jogo
all_sprites.update()
#gera sáidas
window.fill((46, 139, 87))
window.blit(assets['background'],(0,0))
# Desenhando as vidas do player
text_surface = assets["score_font"].render(chr(9829) * lives_hero, True, (255, 0, 0))
text_rect = text_surface.get_rect()
text_rect.bottomleft = (10, altura_background - 10)
window.blit(text_surface, text_rect)
# Desenhando as vidas do chefão
text_surface = assets["score_font"].render(chr(9829) * lives_boss, True, (104, 34, 139))
text_rect = text_surface.get_rect()
text_rect.topright = (largura_background - 10, 10)
window.blit(text_surface, text_rect)
#desenhando sprites
all_sprites.draw(window)
#mostra o novo frame para o jogador
pygame.display.update()
return state
import pygame
import os
import ctypes
ctypes.windll.user32.SetProcessDPIAware()
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (0, 0)
pygame.init()
from pygame.locals import *
flags = NOFRAME | DOUBLEBUF
#resolution = (value["init.window_width"], value["init.window_height"])
screen = pygame.display.set_mode((0, 0), flags)
print(screen)
from assets import load_assets, load_configs, _systems_path, get_path, texture
load_configs()
load_assets(screen)
print("Passed Configs and Assets")
from weapon import create_bullet_templates
create_bullet_templates()
from entity.powerup import EarthHealPack, HealthPack
earth_pack = EarthHealPack(None, (32, 32), False)
heal_pack = HealthPack(None, (-32, -32), False)
print("Passed Powerup")
from entity.planets import Sun
sun = Sun(None)
print("Passed Planets")
from entity.enemy import Goblin, Bombarder, Hunter
g = Goblin(None, (0, 0), earth)
b = Bombarder(None, (0, 0), earth)
h = Hunter(None, (0, 0), earth)
import pygame
from config import WIDTH, HEIGHT, espaço_da_tela
from assets import load_assets
# Carrega os asssets
assets = load_assets()
class Player(pygame.sprite.Sprite):
def __init__(self, img, player):
# Construtor da classe mãe (Sprite).
pygame.sprite.Sprite.__init__(self)
self.image = img
self.rect = self.image.get_rect()
if player == 1:
self.rect.left = espaço_da_tela
if player == 2:
self.rect.right = WIDTH - espaço_da_tela
self.rect.centery = HEIGHT / 2
self.speedy = 0
def update(self):
# Atualização da posição da nave
self.rect.y += self.speedy
# Mantem dentro da tela
if self.rect.top < 0:
self.rect.top = 0
if self.rect.bottom > HEIGHT:
self.rect.bottom = HEIGHT
with open('save.json','w') as save_json:
save_data = {
"high_score" : 0,
"coins" : 0,
"shoot_speed" : 0,
"difficulty" : 6
}
dic_json = json.dumps(save_data)
save_json.write(dic_json)
# Inicializando o pygame e mixer
pygame.init()
pygame.mixer.init()
window = create_window(SCR_WIDTH,SCR_HEIGHT) # Cria janela
assets = load_assets() # Carrega assets
window.fill((125, 190, 215))
pygame.display.update()
# Inicia timers das nuvens e cria seu sprite group
cloudtimer = 0
cloudtimetocreate = 1
clouds = pygame.sprite.Group()
# Arruma ticks
game_clock = pygame.time.Clock()
global_state = TITLE
def game_screen(window):
# Variável para o ajuste de velocidade
clock = pygame.time.Clock()
assets = load_assets()
# Criando um grupo de meteoros
all_sprites = pygame.sprite.Group()
all_meteors = pygame.sprite.Group()
all_bullets = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_meteors'] = all_meteors
groups['all_bullets'] = all_bullets
# Criando o jogador
player = Ship(groups, assets)
all_sprites.add(player)
# Criando os meteoros
for i in range(8):
meteor = Meteor(assets)
all_sprites.add(meteor)
all_meteors.add(meteor)
DONE = 0
PLAYING = 1
EXPLODING = 2
state = PLAYING
keys_down = {}
score = 0
lives = 3
# ===== Loop principal =====
pygame.mixer.music.play(loops=-1)
while state != DONE:
clock.tick(FPS)
# ----- Trata eventos
for event in pygame.event.get():
# ----- Verifica consequências
if event.type == pygame.QUIT:
state = DONE
# Só verifica o teclado se está no estado de jogo
if state == PLAYING:
# Verifica se apertou alguma tecla.
if event.type == pygame.KEYDOWN:
# Dependendo da tecla, altera a velocidade.
keys_down[event.key] = True
if event.key == pygame.K_LEFT:
player.speedx -= 8
if event.key == pygame.K_RIGHT:
player.speedx += 8
if event.key == pygame.K_SPACE:
player.shoot()
# Verifica se soltou alguma tecla.
if event.type == pygame.KEYUP:
# Dependendo da tecla, altera a velocidade.
if event.key in keys_down and keys_down[event.key]:
if event.key == pygame.K_LEFT:
player.speedx += 8
if event.key == pygame.K_RIGHT:
player.speedx -= 8
# ----- Atualiza estado do jogo
# Atualizando a posição dos meteoros
all_sprites.update()
if state == PLAYING:
# Verifica se houve colisão entre tiro e meteoro
hits = pygame.sprite.groupcollide(all_meteors, all_bullets, True, True, pygame.sprite.collide_mask)
for meteor in hits: # As chaves são os elementos do primeiro grupo (meteoros) que colidiram com alguma bala
# O meteoro e destruido e precisa ser recriado
assets[DESTROY_SOUND].play()
m = Meteor(assets)
all_sprites.add(m)
all_meteors.add(m)
# No lugar do meteoro antigo, adicionar uma explosão.
explosao = Explosion(meteor.rect.center, assets)
all_sprites.add(explosao)
# Ganhou pontos!
score += 100
if score % 1000 == 0:
lives += 1
# Verifica se houve colisão entre nave e meteoro
hits = pygame.sprite.spritecollide(player, all_meteors, True, pygame.sprite.collide_mask)
if len(hits) > 0:
# Toca o som da colisão
assets[BOOM_SOUND].play()
player.kill()
lives -= 1
explosao = Explosion(player.rect.center, assets)
all_sprites.add(explosao)
state = EXPLODING
keys_down = {}
explosion_tick = pygame.time.get_ticks()
explosion_duration = explosao.frame_ticks * len(explosao.explosion_anim) + 400
elif state == EXPLODING:
now = pygame.time.get_ticks()
if now - explosion_tick > explosion_duration:
if lives == 0:
state = DONE
else:
state = PLAYING
player = Ship(groups, assets)
all_sprites.add(player)
# ----- Gera saídas
window.fill(BLACK) # Preenche com a cor branca
window.blit(assets[BACKGROUND], (0, 0))
# Desenhando meteoros
all_sprites.draw(window)
# Desenhando o score
text_surface = assets[SCORE_FONT].render("{:08d}".format(score), True, YELLOW)
text_rect = text_surface.get_rect()
text_rect.midtop = (WIDTH / 2, 10)
window.blit(text_surface, text_rect)
# Desenhando as vidas
text_surface = assets[SCORE_FONT].render(chr(9829) * lives, True, RED)
text_rect = text_surface.get_rect()
text_rect.bottomleft = (10, HEIGHT - 10)
window.blit(text_surface, text_rect)
pygame.display.update() # Mostra o novo frame para o jogador
def game_screen(janela, record, sprite_jogo):
pygame.mixer.music.load('Assets/Sounds/SoundTrack.mp3')
pygame.mixer.music.set_volume(0.1)
game_on = True
pygame.mixer.music.play(loops =-1)
background = Background() # cria o background usando a class Background (está no arquivo "classes")
clock = pygame.time.Clock()
assets = load_assets()
# Criando os grupos de sprites
all_sprites = pygame.sprite.Group()
all_snowballs = pygame.sprite.Group()
all_cookies = pygame.sprite.Group()
all_hats = pygame.sprite.Group()
groups = {}
groups['all_sprites'] = all_sprites
groups['all_snowballs'] = all_snowballs
groups['all_cookies'] = all_cookies
groups['all_hats'] = all_hats
#Carrega o player sheet e cria a sprite do Santa
santa = Santa(assets[sprite_jogo],groups,assets)
all_sprites.add(santa)
#Criando bolas de neve
for i in range(3):
snowball = Snowball(assets)
all_sprites.add(snowball)
all_snowballs.add(snowball)
#Criando cookies
for i in range(2):
cookie = Cookie(assets)
all_sprites.add(cookie)
all_cookies.add(cookie)
#Score inicial
score = 0
# Game Loop
game_on = True
while game_on:
pygame.time.delay(20)
delta_time = clock.tick(FPS) # garante um FPS máximo
#Plano de fundo
background.uptade(delta_time)
background.render(janela,score)
#Desenha todos os sprites
all_sprites.draw(janela)
all_sprites.update()
#Atualizando jogo
pygame.display.flip()
pygame.display.update()
eventos = pygame.event.get()
for evento in eventos:
if evento.type == pygame.QUIT:
pygame.quit()
game_on = False
key = pygame.key.get_pressed()
if evento.type == pygame.KEYDOWN:
# Dependendo da tecla, altera o estado do jogador.
if evento.key == pygame.K_RIGHT:
santa.speedx += 9
elif evento.key == pygame.K_LEFT:
santa.speedx -= 9
elif evento.key == pygame.K_SPACE:
santa.throw()
elif evento.key == pygame.K_UP and santa.rect.centery == 600:
santa.speedy -= 14
assets[JUMP_SOUND].play()
elif evento.key == pygame.K_h:
assets[HOHOHO_SOUND].play()
if evento.type == pygame.KEYUP:
if evento.key == pygame.K_RIGHT:
santa.speedx -= 9
elif evento.key == pygame.K_LEFT:
santa.speedx += 9
#Aumenta o score
score += 1
#Aumentando e limitando a dificuldade do jogo
if len(all_snowballs) < 3 + score/2000 and score <= 10000:
snowball = Snowball(assets)
all_sprites.add(snowball)
all_snowballs.add(snowball)
#Premiando o jogador com mais cookies
if len(all_cookies) < 2 + score/5000 and score <= 10000:
cookie = Cookie(assets)
all_sprites.add(cookie)
all_cookies.add(cookie)
#Colisão santa com cookies
hits_santa_cookies = pygame.sprite.spritecollide(santa,all_cookies , True, pygame.sprite.collide_mask)
#Caso o santa colida com as bolas
for hit in hits_santa_cookies:
assets[EAT_SOUND].play()
cookie = Cookie(assets)
all_sprites.add(cookie)
all_cookies.add(cookie)
score += 200
#Colisão santa com cookies
hits_hats_snowballs = pygame.sprite.groupcollide(all_hats,all_snowballs , True, True, pygame.sprite.collide_mask)
if len(hits_hats_snowballs) > 0:
assets[SNOW_SOUND].play()
for hit in hits_hats_snowballs:
snowball = Snowball(assets)
all_sprites.add(snowball)
all_snowballs.add(snowball)
#Colisão santa com bolas de neve
hits_santa_snowballs = pygame.sprite.spritecollide(santa,all_snowballs, False, pygame.sprite.collide_mask)
if len(hits_santa_snowballs) > 0:
assets[DEATH_SOUND].play()
time.sleep(0.5)
game_on = False
state = DEAD
if record < score:
record = score
pygame.mixer.music.stop()
retornos = [state,score,record]
#Retorna o estado, a pontuação e o recorde atual
return retornos
