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)
Beispiel #3
0
    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)
Beispiel #4
0
 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))
Beispiel #6
0
    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)
Beispiel #8
0
    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)
Beispiel #9
0
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
Beispiel #10
0
 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)
Beispiel #11
0
 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')
Beispiel #12
0
    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)
Beispiel #13
0
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
Beispiel #14
0
 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())
Beispiel #17
0
    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)
Beispiel #19
0
 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')
Beispiel #20
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')
Beispiel #24
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)