def __init__(self):
self.__fase_atual = Fase(-1, None, self.DUMMY_FUNDO, [], [], [], [],
"no_img")
self.__fs = FabricaFases()
self.__ge = GerenciadorEntidade(self, self.__fs, self.__fase_atual)
self.__lista_fases = []
self.__lista_fases_original = []
def novo_jogo(self, data=None):
if self.mapa_atual+1 > len(self.mapas):
print("Nao a proxima fase")
self.statusBar.place_forget()
self.mapa.place_forget()
self['bg'] = CORES['bg']
self.status = "zerou"
self.ativar_popUp(1)
else:
self.status = "jogando"
self.menu_ops.place_forget()
self.fase = Fase(self.mapas[self.mapa_atual], self, data)
self.configurar_partida()
self.render(self.fase.mapa)
self.fase.getItens()
self.label_player = self.sprites.criar_player(self.mapa)
self.posi_obj_dinamicos()
def teste_intervalo_de_colisao_padrão(self):
'''
Método que testa se o intervalo de colisão da Fase é repassado aos atores. Padrão de intervalo é 1
'''
fase = Fase()
passaro = PassaroAmarelo(1, 1)
fase.adicionar_passaro(passaro)
porco = Porco(2, 2)
fase.adicionar_porco(porco)
fase.calcular_pontos(0)
self.assertEqual(DESTRUIDO, passaro.status)
self.assertEqual(DESTRUIDO, porco.status)
def teste_lancar_passaro_sem_erro_quando_nao_existe_passaro(self):
passaros = [PassaroFake(1, 1) for _ in range(2)]
fase = Fase()
fase.adicionar_passaro(*passaros)
self.assertFalse(passaros[0].foi_lancado())
self.assertFalse(passaros[1].foi_lancado())
fase.lancar(90, 1)
fase.lancar(45, 3)
fase.lancar(31, 5) # testando que lançar passaros depios de todos lançados não causa erro
self.assertTrue(passaros[0].foi_lancado())
self.assertTrue(passaros[1].foi_lancado())
def criar_fase_exemplo(multiplicador=1):
fase_exemplo = Fase(1 if multiplicador == 1 else 32)
passaros = [PassaroVermelho(3 * multiplicador, 3 * multiplicador),
PassaroAmarelo(3 * multiplicador, 3 * multiplicador),
PassaroAmarelo(3 * multiplicador, 3 * multiplicador)]
porcos = [Porco(78 * multiplicador, multiplicador), Porco(70 * multiplicador, multiplicador)]
obstaculos = [Obstaculo(31 * multiplicador, 10 * multiplicador)]
fase_exemplo.adicionar_passaro(*passaros)
fase_exemplo.adicionar_porco(*porcos)
fase_exemplo.adicionar_obstaculo(*obstaculos)
return fase_exemplo
def teste_intervalo_de_colisao_nao_padrao(self):
'''
Método que testa se o intervalo de colisão da Fase é repassado aos
atores. valor testado: 31
'''
fase = Fase(30)
passaro = PassaroFake(1, 1)
fase.adicionar_passaro(passaro)
porco = PorcoFake(31, 31)
fase.adicionar_porco(porco)
fase.calcular_pontos(0)
self.assertEqual(30, passaro.intervalo_colisao)
self.assertEqual(30, porco.intervalo_colisao)
def teste_intervalo_de_colisao_nao_padrao(self):
'''
Método que testa se o intervalo de colisão da Fase é repassado aos atores. valor testado: 31
'''
fase = Fase(30)
passaro = PassaroAmarelo(1, 1)
fase.adicionar_passaro(passaro)
porco = Porco(31, 31)
fase.adicionar_porco(porco)
fase.calcular_pontos(0)
self.assertEqual(DESTRUIDO, passaro.status)
self.assertEqual(DESTRUIDO, porco.status)
def teste_lancar_passaro_sem_erro_quando_nao_existe_passaro(self):
passaros = [PassaroFake(1, 1) for _ in range(2)] # cria os passaros
fase = Fase()
fase.adicionar_passaro(*passaros)
# certifica-se de que o método .foi_lancado() retorna False
self.assertFalse(passaros[0].foi_lancado())
self.assertFalse(passaros[1].foi_lancado())
fase.lancar(90, 1) # lança o primeiro passaro
fase.lancar(45, 3) # lança o segundo passaro
fase.lancar(
31, 5) # testando que lançar passaros depois de todos (2 passaros)
# lançados não causa erro
# verifica se o método .foi_lancado() retorna True
self.assertTrue(passaros[0].foi_lancado())
self.assertTrue(passaros[1].foi_lancado())
def criar_fase_exemplo(multiplicador=1):
fase_exemplo = Fase(1 if multiplicador == 1 else 32)
passaros = [PassaroVermelho(3 * multiplicador, 3 * multiplicador),
PassaroAmarelo(3 * multiplicador, 3 * multiplicador),
PassaroAmarelo(3 * multiplicador, 3 * multiplicador)]
porcos = [Porco(78 * multiplicador, multiplicador), Porco(70 * multiplicador, multiplicador)]
obstaculos = [Obstaculo(31 * multiplicador, 10 * multiplicador)]
fase_exemplo.adicionar_passaro(*passaros)
fase_exemplo.adicionar_porco(*porcos)
fase_exemplo.adicionar_obstaculo(*obstaculos)
return fase_exemplo
def teste_lancar_passaro_sem_erro_quando_nao_existe_passaro(self):
passaro_vermelho, passaro_amarelo = PassaroVermelho(1, 1), PassaroAmarelo(1, 1)
fase = Fase()
fase.adicionar_passaro(passaro_vermelho, passaro_amarelo)
self.assertFalse(passaro_vermelho.foi_lancado())
self.assertFalse(passaro_amarelo.foi_lancado())
fase.lancar(90, 1)
fase.lancar(45, 3)
fase.lancar(31, 5) # testando que lançar passaros depios de todos lançados não causa erro
self.assertTrue(passaro_vermelho.foi_lancado())
self.assertEqual(math.radians(90), passaro_vermelho._angulo_de_lancamento)
self.assertEqual(1, passaro_vermelho._tempo_de_lancamento)
self.assertTrue(passaro_amarelo.foi_lancado())
self.assertEqual(math.radians(45), passaro_amarelo._angulo_de_lancamento)
self.assertEqual(3, passaro_amarelo._tempo_de_lancamento)
def teste_intervalo_de_colisao_padrao(self):
'''
Método que testa se o intervalo de colisão da Fase é repassado aos
atores. Padrão de intervalo é 1
'''
fase = Fase()
passaro = PassaroFake(1, 1)
fase.adicionar_passaro(passaro)
porco = PorcoFake(2, 2)
fase.adicionar_porco(porco)
fase.calcular_pontos(0)
self.assertTrue(passaro.colidir_executado)
self.assertTrue(porco.colidir_executado)
self.assertTrue(passaro.calcular_posicao_executado)
self.assertTrue(passaro.colidir_com_chao_executado)
self.assertEqual(1, passaro.intervalo_colisao)
self.assertEqual(1, porco.intervalo_colisao)
def teste_adicionar_obstaculo(self):
fase = Fase()
self.assertListEqual([], fase._obstaculos)
obstaculo = Obstaculo()
fase.adicionar_obstaculo(obstaculo)
self.assertListEqual([obstaculo], fase._obstaculos)
obstaculo1, obstaculo2 = Obstaculo(), Obstaculo()
fase.adicionar_obstaculo(obstaculo1, obstaculo2)
self.assertListEqual([obstaculo, obstaculo1, obstaculo2], fase._obstaculos)
def teste_adicionar_porco(self):
fase = Fase()
self.assertListEqual([], fase._porcos)
porco = Porco()
fase.adicionar_porco(porco)
self.assertListEqual([porco], fase._porcos)
porco1, porco2 = Porco(), Porco()
fase.adicionar_porco(porco1, porco2)
self.assertListEqual([porco, porco1, porco2], fase._porcos)
def teste_adicionar_passaro(self):
fase = Fase()
self.assertListEqual([], fase._passaros)
passaro = PassaroVermelho()
fase.adicionar_passaro(passaro)
self.assertListEqual([passaro], fase._passaros)
passaro1, passaro2 = PassaroVermelho(), PassaroAmarelo()
fase.adicionar_passaro(passaro1, passaro2)
self.assertListEqual([passaro, passaro1, passaro2], fase._passaros)
def __init__(self):
self.__pontuacao = PontuacaoController()
self.__tela = Tela()
# Fase 1
self.__bg_1 = pygame.image.load("Materials/AnimatedStreet.png").convert(self.__tela.display)
self.__linha_img = pygame.image.load("Materials/AnimatedStreet_Element.png").convert(self.__tela.display)
self.__linha1 = BGElement([115, -53], [self.__linha_img])
self.__linha2 = BGElement([230, -53], [self.__linha_img])
self.__linha3 = BGElement([115, 292], [self.__linha_img])
self.__linha4 = BGElement([230, 292], [self.__linha_img])
self.__fase1 = Fase(self.__bg_1, [self.__linha1, self.__linha2, self.__linha3, self.__linha4])
self.__fases = [self.__fase1]
self.__fase = 0
self.__fase_atual = self.__fases[self.__fase]
def teste_lancar_passaro_sem_erro_quando_nao_existe_passaro(self):
passaro_vermelho, passaro_amarelo = PassaroVermelho(1, 1), PassaroAmarelo(1, 1)
fase = Fase()
fase.adicionar_passaro(passaro_vermelho, passaro_amarelo)
self.assertFalse(passaro_vermelho.foi_lancado())
self.assertFalse(passaro_amarelo.foi_lancado())
fase.lancar(90, 1)
fase.lancar(45, 3)
fase.lancar(31, 5) # testando que lançar passaros depios de todos lançados não causa erro
self.assertTrue(passaro_vermelho.foi_lancado())
self.assertEqual(math.radians(90), passaro_vermelho._angulo_de_lancamento)
self.assertEqual(1, passaro_vermelho._tempo_de_lancamento)
self.assertTrue(passaro_amarelo.foi_lancado())
self.assertEqual(math.radians(45), passaro_amarelo._angulo_de_lancamento)
self.assertEqual(3, passaro_amarelo._tempo_de_lancamento)
tela.after(passo, _animar)
def rodar_fase(fase):
root.title("Python Birds")
root.geometry("800x600")
root.resizable(0, 0)
stage = Canvas(root, width=800, height=ALTURA_DA_TELA)
multiplicador = 10
PassaroAmarelo.velocidade_escalar *= multiplicador
PassaroVermelho.velocidade_escalar *= multiplicador
atores.GRAVIDADE = 100
animar(root, stage, fase)
if __name__ == '__main__':
fase = Fase(intervalo_de_colisao=32)
passaros = [
PassaroVermelho(30, 30),
PassaroAmarelo(30, 30),
PassaroAmarelo(30, 30)
]
porcos = [Porco(750, 1), Porco(700, 1)]
obstaculos = [Obstaculo(310, 100)]
fase.adicionar_obstaculo(*obstaculos)
fase.adicionar_passaro(*passaros)
fase.adicionar_porco(*porcos)
rodar_fase(fase)
def teste_status(self):
fase = Fase()
porcos = [Porco(1, 1) for i in range(2)]
passaros = [PassaroAmarelo(1, 1) for i in range(2)]
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertEqual(EM_ANDAMENTO, fase.status())
for passaro, porco in zip(passaros, porcos):
passaro.colidir(porco, 3)
self.assertEqual(VITORIA, fase.status(),
'Sem porcos ativos o jogo deveria terminar com vitória')
fase.adicionar_obstaculo(Obstaculo())
self.assertEqual(VITORIA, fase.status(),
'Obstáculo não interfere para definir vitória')
porco = Porco()
fase.adicionar_porco(porco)
self.assertEqual(DERROTA, fase.status(),
'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar em derrota')
fase.adicionar_passaro(PassaroAmarelo())
self.assertEqual(EM_ANDAMENTO, fase.status(),
'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')
porco.colidir(porco, 3)
self.assertEqual(VITORIA, fase.status(),
'Sem porco ativo, o jogo deveria acabar com vitória')
# -*- coding: utf-8 -*-
from os import path
import sys
project_dir = path.dirname(__file__)
project_dir = path.join('..')
sys.path.append(project_dir)
from atores import PassaroAmarelo, PassaroVermelho, Obstaculo, Porco
from fase import Fase
from placa_grafica_tkinter import rodar_fase
if __name__ == '__main__':
fase = Fase(intervalo_de_colisao=10)
# Adicionar Pássaros Vermelhos
for i in range(5):
fase.adicionar_passaro(PassaroVermelho(30, 30))
# Adicionar Pássaros Amarelos
for i in range(30):
fase.adicionar_passaro(PassaroAmarelo(30, 30))
# Obstaculos
for i in range(30, 480, 32):
fase.adicionar_obstaculo(Obstaculo(300, i))
# Porcos
for i in range(30, 300, 32):
fase.adicionar_porco(Porco(600, i))
def teste_acabou_sem_porcos(self):
fase = Fase()
self.assertEqual(VITORIA, fase.status())
def teste_acabou_com_porcos_e_passaros(self):
fase = Fase()
porcos = [Porco(1, 1) for i in range(2)] # criando 2 porcos
passaros = [PassaroAmarelo(1, 1) for i in range(2)] # criando 2 pássaros
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertEqual(EM_ANDAMENTO, fase.status())
# colidindo cada passaro com um porco no tempo 3
for passaro, porco in zip(passaros, porcos):
passaro.colidir(porco, 3)
self.assertEqual(VITORIA, fase.status())
fase.adicionar_obstaculo(Obstaculo())
self.assertEqual(VITORIA, fase.status(), 'Obstáculo não interfere no fim do jogo')
fase.adicionar_porco(Porco())
self.assertEqual(DERROTA, fase.status(), 'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar')
fase.adicionar_passaro(PassaroAmarelo())
self.assertEqual(EM_ANDAMENTO, fase.status(),
'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')
def teste_acabou_com_porcos_e_passaros(self):
fase = Fase()
porcos = [Porco(1, 1) for i in range(2)] # criando 2 porcos
passaros = [PassaroAmarelo(1, 1) for i in range(2)] # criando 2 pássaros
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertFalse(fase.acabou(0))
self.assertFalse(fase.acabou(2.9))
self.assertFalse(fase.acabou(3))
# colidingo cada passaro com um porco no tempo 3
for passaro, porco in zip(passaros, porcos):
passaro.colidir(porco, 3)
self.assertFalse(fase.acabou(0))
self.assertFalse(fase.acabou(2.9))
self.assertTrue(fase.acabou(3))
fase.adicionar_obstaculo(Obstaculo())
self.assertTrue(fase.acabou(3), 'Obstáculo não interfere no fim do jogo')
fase.adicionar_porco(Porco())
self.assertTrue(fase.acabou(3), 'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar')
fase.adicionar_passaro(PassaroAmarelo())
self.assertFalse(fase.acabou(3), 'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')
def teste_acabou_com_porcos_e_passaros(self):
fase = Fase()
porcos = [PorcoFake(1, 1) for _ in range(2)] # criando 2 porcos
passaros = [PassaroFake(1, 1) for _ in range(2)] # criando 2 pássaros
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertEqual(EM_ANDAMENTO, fase.status())
for ator in porcos + passaros:
ator.status = DESTRUIDO
self.assertEqual(VITORIA, fase.status())
fase.adicionar_obstaculo(Obstaculo())
self.assertEqual(VITORIA, fase.status(),
'Obstáculo não interfere no fim do jogo')
fase.adicionar_porco(PorcoFake())
self.assertEqual(
DERROTA, fase.status(),
'Com Porco ativo e sem pássaro para lançar, o jogo '
'deveria acabar')
fase.adicionar_passaro(PassaroFake())
self.assertEqual(
EM_ANDAMENTO, fase.status(),
'Com Porco ativo e com pássaro para lançar, o jogo '
'não deveria acabar')
def criar_fase_exemplo():
fase_exemplo = Fase()
passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)]
porcos = [Porco(78, 1), Porco(70, 1)]
obstaculos = [Obstaculo(31, 10)]
fase_exemplo.adicionar_passaro(*passaros)
fase_exemplo.adicionar_porco(*porcos)
fase_exemplo.adicionar_obstaculo(*obstaculos)
fase_exemplo.lancar(45, 1)
fase_exemplo.lancar(63, 3)
fase_exemplo.lancar(23, 4)
for i in range(86):
fase_exemplo.calcular_pontos(i / 10)
return fase_exemplo
Ponto(70, 1, '@')]
self.assertListEqual(expected, fase_exemplo.calcular_pontos(4))
expected = [Ponto(31, 11, 'v'), Ponto(57, 30, 'A'), Ponto(69, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '@'),
Ponto(70, 1, '+')]
self.assertListEqual(expected, fase_exemplo.calcular_pontos(7))
expected = [Ponto(31, 11, 'v'), Ponto(77, 2, 'a'), Ponto(69, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '+'),
Ponto(70, 1, '+')]
self.assertListEqual(expected, fase_exemplo.calcular_pontos(8.5))
self.assertFalse(fase_exemplo.acabou(8.3))
self.assertTrue(fase_exemplo.acabou(8.5))
fase_exemplo = Fase()
passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)]
porcos = [Porco(78, 1), Porco(70, 1)]
obstaculos = [Obstaculo(31, 10)]
fase_exemplo.adicionar_passaro(*passaros)
fase_exemplo.adicionar_porco(*porcos)
fase_exemplo.adicionar_obstaculo(*obstaculos)
fase_exemplo.lancar(45, 1)
fase_exemplo.lancar(63, 3)
fase_exemplo.lancar(23, 4)
for i in range(86):
fase_exemplo.calcular_pontos(i / 10)
def teste_acabou_com_porcos_e_passaros(self):
fase = Fase()
porcos = [Porco(1, 1) for i in range(2)] # criando 2 porcos
passaros = [PassaroAmarelo(1, 1) for i in range(2)] # criando 2 pássaros
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertEqual(EM_ANDAMENTO, fase.status())
# colidindo cada passaro com um porco no tempo 3
for passaro, porco in zip(passaros, porcos):
passaro.colidir(porco, 3)
self.assertEqual(VITORIA, fase.status())
fase.adicionar_obstaculo(Obstaculo())
self.assertEqual(VITORIA, fase.status(), 'Obstáculo não interfere no fim do jogo')
fase.adicionar_porco(Porco())
self.assertEqual(DERROTA, fase.status(), 'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar')
fase.adicionar_passaro(PassaroAmarelo())
self.assertEqual(EM_ANDAMENTO, fase.status(),
'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')
def teste_acabou_sem_porcos(self):
fase = Fase()
self.assertTrue(fase.acabou(0))
# -*- coding: utf-8 -*-
from os import path
import sys
project_dir = path.dirname(__file__)
project_dir = path.join('..')
sys.path.append(project_dir)
from atores import PassaroAmarelo, PassaroVermelho, Obstaculo, Porco
from fase import Fase
from placa_grafica_tkinter import rodar_fase
if __name__ == '__main__':
fase = Fase(intervalo_de_colisao=10)
# Adicionar Pássaros Vermelhos
for i in range(5):
fase.adicionar_passaro(PassaroVermelho(30, 30))
# Adicionar Pássaros Amarelos
for i in range(30):
fase.adicionar_passaro(PassaroAmarelo(30, 30))
# Obstaculos
for i in range(30, 480, 32):
fase.adicionar_obstaculo(Obstaculo(300, i))
# Porcos
for i in range(30, 300, 32):
fase.adicionar_porco(Porco(600, i))
rodar_fase(fase)
def criar_fase(self, linha):
plataformas = []
moedas = []
energias = []
inimigos = []
cor = (65, 65, 65)
fundo = pygame.Surface((800, 600))
fundo.fill(cor)
jogador = None
_id = 0
for i in linha:
i = i.split(":")
if i[0] == "plataforma":
i = i[1].split("|")
print(i)
plataformas.append(
Plataforma(float(i[0]), float(i[1]), float(i[2]),
float(i[3]), float(i[4]), float(i[5]),
float(i[6]), parse_tuple(i[7]), i[8]))
elif i[0] == "plataforma_andante":
i = i[1].split("|")
print(i)
plataformas.append(
PlataformaAndante(float(i[0]), float(i[1]), float(i[2]),
float(i[3]), float(i[4]), float(i[5]),
float(i[6]), parse_tuple(i[7]),
parse_tuple(i[8]), float(i[9]),
parse_tuple(i[10]), i[11]))
elif i[0] == "energia":
i = i[1].split("|")
print(i)
energias.append(
Energia(float(i[0]), float(i[1]), float(i[2]), float(i[3]),
float(i[4]), float(i[5]), float(i[6]),
parse_bool(i[7]), parse_tuple(i[8]), i[9]))
elif i[0] == "inimigo":
i = i[1].split("|")
print(i)
inimigos.append(
Inimigo(float(i[0]), float(i[1]), float(i[2]), float(i[3]),
float(i[4]), float(i[5]), float(i[6]),
parse_bool(i[7]), float(i[8]), parse_bool(i[9]),
parse_tuple(i[10]), i[11], i[12]))
elif i[0] == "jogador":
i = i[1].split("|")
jogador = Jogador(float(i[0]), float(i[1]), float(i[2]),
float(i[3]), float(i[4]), float(i[5]),
float(i[6]), parse_tuple(i[7]), i[8])
elif i[0] == "moeda":
i = i[1].split("|")
moedas.append(
Moeda(float(i[0]), float(i[1]), float(i[2]), float(i[3]),
float(i[4]), float(i[5]), float(i[6]),
parse_tuple(i[7]), i[8]))
elif i[0] == "cor":
cor = parse_tuple(i[1])
fundo.fill(cor)
elif i[0] == "fundo":
caminho_fundo = i[1]
elif i[0] == "fase_indice":
_id = int(i[1])
if caminho_fundo != "no_img":
fundo = pygame.image.load("../Imagens/" +
caminho_fundo).convert_alpha()
return Fase(_id, jogador, fundo, plataformas, moedas, energias,
inimigos, cor)
# -*- coding: utf-8 -*-
from os import path
import sys
import math
project_dir = path.dirname(__file__)
project_dir = path.join('..')
sys.path.append(project_dir)
from atores import PassaroAmarelo, PassaroVermelho, Obstaculo, Porco
from fase import Fase
from placa_grafica_tkinter import rodar_fase
from random import randint
if __name__ == '__main__':
fase = Fase(intervalo_de_colisao=32)
# Adicionar Pássaros Amarelos
for i in range(80):
fase.adicionar_passaro(PassaroAmarelo(30, 30))
# Obstaculos
theta = 270
h = 12
k = 7
step = 32
r = 50
while theta < 480:
# -*- coding: utf-8 -*-
from os import path
import sys
import math
project_dir = path.dirname(__file__)
project_dir = path.join('..')
sys.path.append(project_dir)
from atores import PassaroAmarelo, PassaroVermelho, Obstaculo, Porco
from fase import Fase
from placa_grafica_tkinter import rodar_fase
from random import randint
if __name__ == '__main__':
fase = Fase(intervalo_de_colisao=32)
# Adicionar Pássaros Amarelos
for i in range(80):
fase.adicionar_passaro(PassaroAmarelo(30, 30))
# Obstaculos
theta = 270
h = 12
k = 7
step = 32
r = 50
while theta < 480:
tela.bind_all('3', _finalizar)
tela.bind_all('<Escape>', _finalizar)
tela.mainloop()
tela.after(passo, _animar)
def rodar_fase(fase):
root.title("Python Birds")
root.geometry("800x600")
root.resizable(0, 0)
stage = Canvas(root, width=800, height=ALTURA_DA_TELA)
multiplicador = 10
PassaroAmarelo.velocidade_escalar *= multiplicador
PassaroVermelho.velocidade_escalar *= multiplicador
atores.GRAVIDADE = 100
animar(root, stage, fase)
if __name__ == '__main__':
fase = Fase(intervalo_de_colisao=32)
passaros = [PassaroVermelho(30, 30), PassaroAmarelo(30, 30), PassaroAmarelo(30, 30)]
porcos = [Porco(750, 1), Porco(700, 1)]
obstaculos = [Obstaculo(310, 100)]
fase.adicionar_obstaculo(*obstaculos)
fase.adicionar_passaro(*passaros)
fase.adicionar_porco(*porcos)
rodar_fase(fase)
__author__ = 'jmorais'
try:
from fase import Fase
except Exception as e:
print('require module exception: %s' % e)
exit(0)
"""
Starting Fase(...).execute() make possible the communication between the micro services.
simple: python core.py
"""
Fase(sender_endpoint='ipc:///tmp/sender', receiver_endpoint='ipc:///tmp/receiver').execute()
def teste_status(self):
fase = Fase()
porcos = [Porco(1, 1) for i in range(2)]
passaros = [PassaroAmarelo(1, 1) for i in range(2)]
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertEqual('Jogo em andamento.', fase.status(0))
self.assertEqual('Jogo em andamento.', fase.status(2.9))
self.assertEqual('Jogo em andamento.', fase.status(3))
for passaro, porco in zip(passaros, porcos):
passaro.colidir(porco, 3)
self.assertEqual('Jogo em andamento.', fase.status(0))
self.assertEqual('Jogo em andamento.', fase.status(2.9))
self.assertEqual('Jogo em encerrado. Você ganhou!', fase.status(3),
'Sem porcos ativos o jogo deveria terminar com vitória')
fase.adicionar_obstaculo(Obstaculo())
self.assertEqual('Jogo em encerrado. Você ganhou!', fase.status(3),
'Obstáculo não interfere para definir vitória')
porco = Porco()
fase.adicionar_porco(porco)
self.assertEqual('Jogo em encerrado. Você perdeu!', fase.status(3),
'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar em derrota')
fase.adicionar_passaro(PassaroAmarelo())
self.assertEqual('Jogo em andamento.', fase.status(3),
'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')
porco.colidir(porco, 3)
self.assertEqual('Jogo em encerrado. Você ganhou!', fase.status(3),
'Sem porco ativo, o jogo deveria acabar com vitória')
def teste_status(self):
fase = Fase()
porcos = [Porco(1, 1) for i in range(2)]
passaros = [PassaroAmarelo(1, 1) for i in range(2)]
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertEqual(EM_ANDAMENTO, fase.status())
for passaro, porco in zip(passaros, porcos):
passaro.colidir(porco, 3)
self.assertEqual(VITORIA, fase.status(),
'Sem porcos ativos o jogo deveria terminar com vitória')
fase.adicionar_obstaculo(Obstaculo())
self.assertEqual(VITORIA, fase.status(),
'Obstáculo não interfere para definir vitória')
porco = Porco()
fase.adicionar_porco(porco)
self.assertEqual(DERROTA, fase.status(),
'Com Porco ativo e sem pássaro para lançar, o jogo deveria acabar em derrota')
fase.adicionar_passaro(PassaroAmarelo())
self.assertEqual(EM_ANDAMENTO, fase.status(),
'Com Porco ativo e com pássaro para lançar, o jogo não deveria acabar')
porco.colidir(porco, 3)
self.assertEqual(VITORIA, fase.status(),
'Sem porco ativo, o jogo deveria acabar com vitória')
def eventos(self, e):
if e.type == pygame.MOUSEBUTTONUP and e.button == 1:
self.arrastando_entidade = False
if e.type == pygame.MOUSEBUTTONDOWN and e.button == 2:
self.camera_mov_x += self.pos[0]
self.camera_mov_y += self.pos[1]
if e.type == pygame.MOUSEBUTTONUP and e.button == 2:
self.camera_mov_x -= self.pos[0]
self.camera_mov_y -= self.pos[1]
if e.type == pygame.MOUSEBUTTONUP and e.button == 3:
entidade = self.pegar_entidade_cursor()
if entidade:
nomes = entidade.get_nomes()
param = multenterbox(msg=entidade.__class__.__name__,
title='Editor de atributos',
fields=(nomes))
if param:
entidade.setar_atributos(param)
else:
nomes = ["ID", "Cor", "Imagem Fundo"]
param = multenterbox(msg="Fase",
title='Editor de atributos',
fields=(nomes))
if param:
self.fase.setar_atributos(param)
if e.type == pygame.KEYDOWN:
if e.key == pygame.K_DELETE:
entidade = self.pegar_entidade_cursor()
if entidade:
self.entidades.remove(entidade)
self.fase.remover(entidade)
mods = pygame.key.get_mods()
if mods & pygame.KMOD_CTRL: # get_mods para poder pegar o evento de duas teclas pressionadas (e.g CTRL + NUMPAD1/2/3/4)
if mods & pygame.KMOD_SHIFT and e.key == pygame.K_s:
if self.arquivo_atual:
self.ff.salvar_arquivo("Fases/" + self.arquivo_atual,
self.fase)
print("Salvo!")
else:
msgbox("Nenhum arquivo foi aberto!", "Erro")
elif e.key == pygame.K_s:
if self.fase.get_id() == -1:
_id = enterbox("Digite o id da fase!")
if _id:
self.fase.set_id(_id)
else:
return
arquivo = enterbox("Digite o nome do arquivo a ser salvo!")
if arquivo:
self.arquivo_atual = arquivo
self.ff.salvar_arquivo("Fases/" + self.arquivo_atual,
self.fase)
if e.key == pygame.K_1:
jogador = Jogador(400, 420, 30, 30, 0.0, 0.0, 2.3,
(0, 25, 125), "no_img")
self.entidades.append(jogador)
self.fase.set_jogador(jogador)
elif e.key == pygame.K_2:
plataforma = Plataforma(0, 570, 800, 30, 0.0, 0.0, 0.0,
(10, 10, 15), "no_img")
self.entidades.append(plataforma)
self.fase.adicionar_plataforma(plataforma)
elif e.key == pygame.K_3:
plataforma = PlataformaAndante(400, 300, 100, 30, 0, 0,
0.5, (100, 200), (0, 0),
0.0, (200, 0, 150),
"no_img")
self.entidades.append(plataforma)
self.fase.adicionar_plataforma(plataforma)
elif e.key == pygame.K_4:
energia = Energia(400, 240, 20, 30, 0, 0, 0.0, True,
(255, 255, 125), "no_img")
self.entidades.append(energia)
self.fase.adicionar_energia(energia)
elif e.key == pygame.K_5:
moeda = Moeda(300, 510, 10, 10, 0, 0, 0.0, (255, 100, 10),
"no_img")
self.entidades.append(moeda)
self.fase.adicionar_moeda(moeda)
elif e.key == pygame.K_6:
inimigo = Inimigo(170, 540, 30, 30, 0, 0, 2.0, True, 25.0,
False, (0, 25, 125), "canon.png",
"gold_bullet.png")
self.entidades.append(inimigo)
self.fase.adicionar_inimigo(inimigo)
elif e.key == pygame.K_l:
arquivo = enterbox(
"Digite o nome do arquivo a ser carregado!")
if arquivo:
self.arquivo_atual = arquivo
ret = self.gf.iniciar(self.arquivo_atual)
if ret:
ret = ret[:]
self.entidades = ret[0]
self.fase = ret[1]
else:
msgbox("Arquivo não existente ou corrompido!",
"Erro")
elif e.key == pygame.K_c:
entidade = self.pegar_entidade_cursor()
if entidade:
self.entidade_copia = self.copiar_entidade(entidade)
elif e.key == pygame.K_v:
if self.entidade_copia:
self.entidade_copia.x = self.pos[
0] - self.camera.x - self.entidade_copia.w / 2
self.entidade_copia.y = self.pos[
1] - self.camera.y - self.entidade_copia.h / 2
clone = self.copiar_entidade(self.entidade_copia)
self.entidades.append(clone)
self.fase.adicionar(clone)
elif mods & pygame.KMOD_SHIFT and e.key == pygame.K_f:
if self.arquivo_atual:
copy2("Fases/" + self.arquivo_atual,
"../Projeto/Fases")
print("Arquivo enviado!")
else:
msgbox("Nenhum arquivo para ser enviado!", "Erro")
elif e.key == pygame.K_f:
nome = enterbox("Digite o nome do arquivo a enviado!")
if nome:
copy2("Fases/" + nome, "../Projeto/Fases")
elif mods & pygame.KMOD_SHIFT and e.key == pygame.K_b:
if self.arquivo_atual:
self.ff.salvar_arquivo("Fases/" + self.arquivo_atual,
self.fase)
print("Salvo!")
copy2("Fases/" + self.arquivo_atual,
"../Projeto/Fases")
print("Arquivo enviado!")
Popen("python jogo.py",
cwd="../Projeto/Codigo/",
shell=True)
else:
msgbox("Nenhum arquivo aberto ou salvo!", "Erro")
elif e.key == pygame.K_b:
Popen("python jogo.py",
cwd="../Projeto/Codigo/",
shell=True)
elif e.key == pygame.K_n:
self.entidades = []
self.fase = Fase(-1, None, self.dummy_fundo, [], [], [],
[], "no_img")
self.arquivo_atual = ""
class Jogo(Tk):
def __init__(self):
super().__init__()
#variaveis
self.mapas = ['fase1', 'fase2', 'fase3']
self.label_itens = []
self.labels = []
self.porta = []
self.mapa_atual = 0
self.status = "jogando"
#fonte
self.fonte = ('Fixedsys', 14)
#propriedades da janela
self.geometry("496x527+248+0")
self.minsize(496, 527)
self.maxsize(496, 527)
#widgets
#/frames
self.menu = Frame(self, width=496, height=527, bg="#212222")
self.statusBar = Frame(self, width=496, height=31, bg="#000612")
self.mapa = Frame(self, width=496, height= 496)
#/labes
self.player_name = Label(self.statusBar, fg="white", bg="#000612", font=self.fonte)
self.player_vidas = Label(self.statusBar, fg="white", bg="#000612", font=self.fonte)
self.player_itens = Label(self.statusBar, fg="white", bg="#000612", font=self.fonte)
#labes/sprites
self.sprites = sprites.Sprites()
self.sprites.criar_menu(self.menu)
#places
self.menu.place(x=0, y=0)
self.player_name.place(x=10, y=5)
self.player_vidas.place(x=400, y=5)
self.player_itens.place(x=210, y=5)
#binds
self.menu.bind('<Return>', self.iniciar_menu)
self.menu.focus_force()
self.mapa.bind('<Key>', self.ler_teclado)
self.mapa.bind('<Escape>', self.menu_partida)
self.mainloop()
def menu_partida(self, event):
menu = MenuPartida(self)
menu.exibir(100, 80)
def ativar_popUp(self, ev):
pop_up = popUp.popUp(self, self.status)
pop_up.exibir()
def proxima_fase(self):
self.sair_partida()
self.mapa_atual+=1
def carregar_jogo(self):
with open('save/save.json', 'r') as save:
try:
data = json.load(save)
if len(data) == 0:
raise execoes.SaveVazio
else:
print(data)
self.mapa_atual = data['fase_atual']
self.novo_jogo(data=data)
except execoes.SaveVazio as error:
print(f"Erro: {error}")
finally:
save.close()
def sair_partida(self):
if self.status == "jogando" or self.status == "perdeu":
print("fase inicial zero")
self.mapa_atual = 0
self.fase.parar()
self.fase.clear()
print(f" threads: {self.fase.threads}")
print("Partida finalizada")
def iniciar_menu(self, event):
self.menu.place_forget()
self.menu_ops = Menu(self)
self.menu_ops.place(x=0, y=0)
def novo_jogo(self, data=None):
if self.mapa_atual+1 > len(self.mapas):
print("Nao a proxima fase")
self.statusBar.place_forget()
self.mapa.place_forget()
self['bg'] = CORES['bg']
self.status = "zerou"
self.ativar_popUp(1)
else:
self.status = "jogando"
self.menu_ops.place_forget()
self.fase = Fase(self.mapas[self.mapa_atual], self, data)
self.configurar_partida()
self.render(self.fase.mapa)
self.fase.getItens()
self.label_player = self.sprites.criar_player(self.mapa)
self.posi_obj_dinamicos()
def ler_teclado(self, event):
key = str(event.char)
eventos.colide_mapa(self.fase.player, key, self.fase.mapa)
eventos.coletarItem(self, self.fase.player, self.fase)
eventos.verificar(self, self.fase.player, self.fase)
self.atualizar_player()
def posi_obj_dinamicos(self):
self.atualizar_player()
self.criar_enemigos(self.fase.enemigos)
def atualizar_player(self):
posGhfX = self.fase.player.posx*31
posGhfY = self.fase.player.posy*31
self.label_player.place(x=posGhfX, y=posGhfY)
def configurar_partida(self):
self.menu.place_forget()
self.statusBar.place(x=0, y=0)
self.atualizar_status_bar(self.fase.player)
self.mapa.place(x=0, y=31)
self.mapa.focus_force()
def atualizar_status_bar(self, player):
self.player_name['text'] = "Player: "+player.nome
self.player_itens['text'] = "itens: "+str(len(player.itens))+"/"+str(len(self.fase.itens))
self.player_vidas['text'] = "Vidas: "+str(player.vidas)
def retirar_item(self, pos):
self.label_itens[pos]['image'] = self.sprites.img_chao
def abrir_porta(self):
self.porta[0]['image'] = self.sprites.img_chao
def ganhou(self):
self.status = "ganhou"
self.label_player['image'] = self.sprites.img_player_portal
self.fase.parar_loop = True
self.ativar_popUp("event")
def criar_enemigos(self, *enemigos):
print("criando objetos")
self.enemigos4 = []
objts = {}
for enemigo in enemigos[0]:
enemigoGUI = self.sprites.criar_enemigo(self.mapa)
posx = enemigo.posx*31
posy = enemigo.posy*31
enemigoGUI.place(x=posx, y=posy)
objts['logico'] = enemigo
objts['grafico'] = enemigoGUI
self.enemigos4.append(objts.copy())
objts.clear()
self.fase.mover_enemigos(self.enemigos4)
def limpar_mapa(self):
#self.mapa.destroy()
self.porta.clear()
self.limpar_player()
for label in self.labels:
label.destroy()
self.label_itens.clear()
if self.status == "jogando" or self.status == "perdeu":
self.menu_ops.place(x=0, y=0)
self.menu_ops.focus_force()
elif self.status == "ganhou":
self.novo_jogo()
def limpar_player(self):
self.label_player.destroy()
def limpar_enemigos(self):
for enem in self.enemigos4:
enem['grafico'].destroy()
enem.clear()
def render(self, mapa):
posx = 0
posy = 0
for linha in mapa:
for coluna in linha:
if coluna == 0:
bloco = self.sprites.criar_chao(self.mapa, posx, posy)
elif coluna == 1:
bloco = self.sprites.criar_parede(self.mapa, posx, posy)
elif coluna == 2:
bloco = self.sprites.criar_item(self.mapa, posx, posy)
self.label_itens.append(bloco)
elif coluna == 3:
bloco = self.sprites.criar_porta(self.mapa, posx, posy)
self.porta.append(bloco)
self.porta.append(posx)
self.porta.append(posy)
elif coluna == 4:
bloco = self.sprites.criar_portal(self.mapa, posx, posy)
posx+=31
self.labels.append(bloco)
posy+=31
posx = 0
def sair(self):
self.quit()
def teste_status(self):
fase = Fase()
porcos = [PorcoFake(1, 1) for _ in range(2)]
passaros = [PassaroFake(1, 1) for _ in range(2)]
fase.adicionar_porco(*porcos)
fase.adicionar_passaro(*passaros)
self.assertEqual(EM_ANDAMENTO, fase.status())
for ator in porcos + passaros:
ator.status = DESTRUIDO
self.assertEqual(
VITORIA, fase.status(),
'Sem porcos ativos o jogo deveria terminar com '
'vitória')
fase.adicionar_obstaculo(ObstaculoFake())
self.assertEqual(VITORIA, fase.status(),
'Obstáculo não interfere para definir vitória')
porco = PorcoFake()
fase.adicionar_porco(porco)
self.assertEqual(
DERROTA, fase.status(),
'Com Porco ativo e sem pássaro para lançar, o jogo '
'deveria acabar em derrota')
fase.adicionar_passaro(PassaroFake())
self.assertEqual(
EM_ANDAMENTO, fase.status(),
'Com Porco ativo e com pássaro para lançar, o jogo '
'não deveria acabar')
porco.status = DESTRUIDO
self.assertEqual(VITORIA, fase.status(),
'Sem porco ativo, o jogo deveria acabar com vitória')
class GerenciadorFase(object):
DUMMY_FUNDO = pygame.Surface((800, 600))
DUMMY_FUNDO.fill((65, 65, 65))
def __init__(self):
self.__fase_atual = Fase(-1, None, self.DUMMY_FUNDO, [], [], [], [],
"no_img")
self.__fs = FabricaFases()
self.__ge = GerenciadorEntidade(self, self.__fs, self.__fase_atual)
self.__lista_fases = []
self.__lista_fases_original = []
def iniciar(self, nome):
self.__carregar_fases(nome)
self.__ge.iniciar(self.__fase_atual)
entidades = []
if self.__fase_atual:
for plat in self.get_plataformas():
entidades.append(plat)
for ini in self.get_inimigos():
entidades.append(ini)
for ene in self.get_energias():
entidades.append(ene)
for moe in self.get_moedas():
entidades.append(moe)
p = self.get_jogador_ref()
if p:
entidades.append(p)
return entidades, self.__fase_atual
return None
def __adicionar_fase(self, fase):
self.__lista_fases_original.append(fase.clonar())
def __carregar_fases(self, nome):
arquivos = glob.glob("./Fases/*.gload")
print(arquivos)
for arquivo in arquivos:
if "Fases" in arquivo and nome in arquivo:
fase = self.__fs.criar_fase(
self.__fs.carregar_arquivo(arquivo))
self.__adicionar_fase(fase)
self.__set_fase_atual(fase)
break
def desenhar_fundo(self, tela):
if not self.__fase_atual: return
tela.blit(self.__fase_atual.get_fundo(), (0, 0))
def __set_fase_atual(self, fase):
self.__fase_atual = fase
def get_gerenciador_entidades(self):
return self.__ge
def get_fabrica_fases(self):
return self.__fs
def get_fase_atual(self):
return self.__fase_atual
def get_id(self):
return self.__fase_atual.get_id()
def get_fundo(self):
return self.__fase_atual.get_fundo()
def get_fases(self):
return self.__lista_fases
def get_jogador_ref(self):
return self.__fase_atual.get_jogador_ref()
def get_jogador(self):
return self.__fase_atual.get_jogador()
def get_plataformas_ref(self):
return self.__fase_atual.get_plataformas_ref()
def get_plataformas(self):
return self.__fase_atual.get_plataformas()
def get_energias_ref(self):
return self.__fase_atual.get_energias_ref()
def get_energias(self):
return self.__fase_atual.get_energias()
def get_inimigos_ref(self):
return self.__fase_atual.get_inimigos_ref()
def get_inimigos(self):
return self.__fase_atual.get_inimigos()
def get_moedas_ref(self):
return self.__fase_atual.get_moedas_ref()
def get_moedas(self):
return self.__fase_atual.get_moedas()
# -*- coding: utf-8 -*-
from atores import PassaroVermelho, PassaroAmarelo, Porco, Obstaculo
from fase import Fase
import placa_grafica
fase_exemplo = Fase()
passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)]
porcos = [Porco(78, 1), Porco(70, 1)]
obstaculos = [Obstaculo(31, 10)]
fase_exemplo.adicionar_passaro(*passaros)
fase_exemplo.adicionar_porco(*porcos)
fase_exemplo.adicionar_obstaculo(*obstaculos)
# Solução para ganhar
# fase_exemplo.lancar(45, 1)
# fase_exemplo.lancar(63, 3)
# fase_exemplo.lancar(23, 4)
if __name__ == '__main__':
placa_grafica.animar(fase_exemplo)