def teste_foi_lancado(self):
passaro_vermelho = PassaroVermelho(1, 1)
self.assertFalse(passaro_vermelho.foi_lancado(),
'Se o método lançar ainda não foi executado, deve retornar falso')
passaro_vermelho.lancar(0, 0)
self.assertTrue(passaro_vermelho.foi_lancado(),
'Se o método lançar foi executado, deve retornar verdadeiro')
def teste_posicao_antes_do_lancamento(self):
passaro_vermelho = PassaroVermelho(1, 1)
passaro_vermelho.lancar(90, 2) # passaro lancado a 90 graus no tempo 2 segundos
#
for t in range(20):
t /= 10
self.assertEqual((1, 1), passaro_vermelho.calcular_posicao(t),
'Não deveria se mover no tempo %s < 2 segundtos' % t)
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 teste_posicao_antes_do_lancamento(self):
'Método que testa que o pássaro fica parado antes do tempo de lançamento'
passaro_vermelho = PassaroVermelho(1, 1)
passaro_vermelho.lancar(
90, 2) # passaro lancado a 90 graus no tempo 2 segundos
#
for t in range(20):
t /= 10
self.assertEqual(
(1, 1), passaro_vermelho.calcular_posicao(t),
'Não deveria se mover no tempo %s < 2 segundtos' % t)
def teste_colisao(self):
passaro_vermelho = PassaroVermelho(1, 1)
passaro_vermelho.lancar(45, 2) # passaro lancado a 45 graus no tempo 2 segundos
# Código de geração de testes
porco = Porco(14, 10)
passaro_vermelho.calcular_posicao(2.89) # tempo exato quanto o passário chega em 14,10
passaro_vermelho.colidir(porco, 2.89)
self.assertEqual(DESTRUIDO, passaro_vermelho.status(2.89))
# Deve ficar parado onde colidiu para qualquer tempo maior que o de colisão
self.assertTupleEqual((14, 10), passaro_vermelho.calcular_posicao(2.9))
self.assertTupleEqual((14, 10), passaro_vermelho.calcular_posicao(1000))
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_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_colisao(self):
passaro_vermelho = PassaroVermelho(1, 1)
passaro_vermelho.lancar(
45, 2) # passaro lancado a 45 graus no tempo 2 segundos
porco = Porco(14, 10)
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(2.89)
self.assertEqual(14, x_calculado)
self.assertEqual(10, y_calculado)
passaro_vermelho.colidir(porco, 2.89)
self.assertEqual(DESTRUIDO, passaro_vermelho.status(2.89))
# Deve ficar parado onde colidiu para qualquer tempo maior ou igual que o de colisão
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(2.89)
self.assertEqual(14, x_calculado)
self.assertEqual(10, y_calculado)
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(4)
self.assertEqual(14, x_calculado)
self.assertEqual(10, y_calculado)
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_resetar(self):
passaro = PassaroVermelho()
self.assertIsNone(passaro._tempo_de_colisao)
self.assertIsNone(passaro._tempo_de_lancamento)
self.assertIsNone(passaro._angulo_de_lancamento)
passaro._tempo_de_colisao = 1
passaro._tempo_de_lancamento = 2
passaro._angulo_de_lancamento = 90
passaro.resetar()
self.assertIsNone(passaro._tempo_de_colisao)
self.assertIsNone(passaro._tempo_de_lancamento)
self.assertIsNone(passaro._angulo_de_lancamento)
def teste_foi_lancado(self):
passaro_vermelho = PassaroVermelho(1, 1)
self.assertFalse(
passaro_vermelho.foi_lancado(),
'Se o método lançar ainda não foi executado, deve retornar falso')
passaro_vermelho.lancar(0, 0)
self.assertTrue(
passaro_vermelho.foi_lancado(),
'Se o método lançar foi executado, deve retornar verdadeiro')
def teste_colisao(self):
passaro_vermelho = PassaroVermelho(1, 1)
passaro_vermelho.lancar(45, 2) # passaro lancado a 45 graus no tempo 2 segundos
porco = Porco(14, 10)
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(2.89)
self.assertEqual(14, x_calculado)
self.assertEqual(10, y_calculado)
passaro_vermelho.colidir(porco, 2.89)
self.assertEqual(DESTRUIDO, passaro_vermelho.status(2.89))
# Deve ficar parado onde colidiu para qualquer tempo maior ou igual que o de colisão
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(2.89)
self.assertEqual(14, x_calculado)
self.assertEqual(10, y_calculado)
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(4)
self.assertEqual(14, x_calculado)
self.assertEqual(10, y_calculado)
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
def teste_resetar(self):
passaro = PassaroVermelho()
self.assertIsNone(passaro._tempo_de_colisao)
self.assertIsNone(passaro._tempo_de_lancamento)
self.assertIsNone(passaro._angulo_de_lancamento)
passaro._tempo_de_colisao = 1
passaro._tempo_de_lancamento = 2
passaro._angulo_de_lancamento = 90
passaro.resetar()
self.assertIsNone(passaro._tempo_de_colisao)
self.assertIsNone(passaro._tempo_de_lancamento)
self.assertIsNone(passaro._angulo_de_lancamento)
def teste_foi_lancado(self):
"""
Teste de lançamento. Enquanto o método lançar do passaro não for chamado, o méotod foi_lancado deve retornar
Falso
:return:
"""
passaro_vermelho = PassaroVermelho(1, 1)
self.assertFalse(
passaro_vermelho.foi_lancado(),
'Se o método lançar ainda não foi executado, deve retornar falso')
passaro_vermelho.lancar(0, 0)
self.assertTrue(
passaro_vermelho.foi_lancado(),
'Se o método lançar foi executado, deve retornar verdadeiro')
def teste_foi_lancado(self):
passaro_vermelho = PassaroVermelho(1, 1)
self.assertFalse(passaro_vermelho.foi_lancado())
passaro_vermelho.lancar(0, 0)
self.assertTrue(passaro_vermelho.foi_lancado())
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)
# -*- 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=32)
# 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 teste_colisao_com_chao(self):
for i in range(30):
passaro = PassaroVermelho(i, 0)
passaro.colidir_com_chao(3)
self.assertEqual(DESTRUIDO, passaro.status(3),
'Deve colidir com chão sempre que y=0')
def teste_status(self):
passaro_amarelo = PassaroVermelho(1, 1)
self.assert_ator_caracteres(passaro_amarelo, 'V', 'v')
def teste_status(self):
passaro_amarelo = PassaroVermelho(1, 1)
self.assertEqual('V', passaro_amarelo.caracter())
outro_ator_na_mesma_posicao = Ator()
passaro_amarelo.colidir(outro_ator_na_mesma_posicao)
self.assertEqual('v', passaro_amarelo.caracter())
def teste_colisao_com_chao(self):
for i in range(30):
passaro = PassaroVermelho(i, 0)
passaro.colidir_com_chao(3)
self.assertEqual(DESTRUIDO, passaro.status(3), 'Deve colidir com chão sempre que y=0')
def teste_colisao_com_chao(self):
"""
Testando que o passáro colido quando sua posição y é menor ou igual a 0
:return:
"""
passaro = PassaroVermelho(0, 0)
passaro.colidir_com_chao()
self.assertEqual(DESTRUIDO, passaro.status,
'Deve colidir com chão sempre que y<=0')
passaro = PassaroVermelho(1, 0)
passaro.colidir_com_chao()
self.assertEqual(DESTRUIDO, passaro.status,
'Deve colidir com chão sempre que y<=0')
passaro = PassaroVermelho(2, 0)
passaro.colidir_com_chao()
self.assertEqual(DESTRUIDO, passaro.status,
'Deve colidir com chão sempre que y<=0')
passaro = PassaroVermelho(2, -0.1)
passaro.colidir_com_chao()
self.assertEqual(DESTRUIDO, passaro.status,
'Deve colidir com chão sempre que y<=0')
passaro = PassaroVermelho(2, -5)
passaro.colidir_com_chao()
self.assertEqual(DESTRUIDO, passaro.status,
'Deve colidir com chão sempre que y<=0')
# -*- 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)