diff --git a/atores.py b/atores.py index cfc2ef5ea..7620d478d 100644 --- a/atores.py +++ b/atores.py @@ -52,16 +52,17 @@ def colidir(self, outro_ator, intervalo=1): :param intervalo: Intervalo a ser considerado :return: """ - pass + if (self.x, self.y) == (outro_ator.x, outro_ator.y): + self.status = DESTRUIDO class Obstaculo(Ator): - pass + _caracter_ativo = 'O' class Porco(Ator): - pass + _caracter_ativo = '@' class DuploLancamentoExcecao(Exception): @@ -133,8 +134,8 @@ def lancar(self, angulo, tempo_de_lancamento): class PassaroAmarelo(Passaro): - pass + _caracter_ativo = 'A' class PassaroVermelho(Passaro): - pass \ No newline at end of file + _caracter_ativo = 'V' \ No newline at end of file diff --git a/fase.py b/fase.py index 3385175c6..eb131da00 100644 --- a/fase.py +++ b/fase.py @@ -43,7 +43,7 @@ def adicionar_obstaculo(self, *obstaculos): :param obstaculos: """ - pass + self._obstaculos.extend(obstaculos) def adicionar_porco(self, *porcos): """ @@ -51,7 +51,7 @@ def adicionar_porco(self, *porcos): :param porcos: """ - pass + self._porcos.extend(porcos) def adicionar_passaro(self, *passaros): """ @@ -59,7 +59,7 @@ def adicionar_passaro(self, *passaros): :param passaros: """ - pass + self._passaros.extend(passaros) def status(self): """ @@ -73,7 +73,12 @@ def status(self): :return: """ - return EM_ANDAMENTO + if not self._possui_porco_ativo(): + return VITORIA + elif self._possui_passaros_ativos(): + return EM_ANDAMENTO + else: + return DERROTA def lancar(self, angulo, tempo): """ @@ -105,3 +110,15 @@ def calcular_pontos(self, tempo): def _transformar_em_ponto(self, ator): return Ponto(ator.x, ator.y, ator.caracter()) + def _possui_porco_ativo(self): + for porco in self._porcos: + if porco.status == ATIVO: + return True + return False + + def _possui_passaros_ativos(self): + for passaro in self._passaros: + if passaro.status == ATIVO: + return True + return False + diff --git a/oo/__init__.py b/oo/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/oo/exercicio.py b/oo/exercicio.py new file mode 100644 index 000000000..735dc54ae --- /dev/null +++ b/oo/exercicio.py @@ -0,0 +1,159 @@ +''' +Exemplo: + >>> # Testando motor + >>> motor = Motor() + >>> motor.velocidade + 0 + >>> motor.acelerar() + >>> motor.velocidade + 1 + >>> motor.acelerar() + >>> motor.velocidade + 2 + >>> motor.acelerar() + >>> motor.velocidade + 3 + >>> motor.frear() + >>> motor.velocidade + 1 + >>> motor.frear() + >>> motor.velocidade + 0 + >>> # Testando Direcao + >>> Dir = Direcao() + >>> Dir.direcao + 'Norte' + >>> Dir.girar_a_direita() + >>> Dir.direcao + 'Leste' + >>> Dir.girar_a_direita() + >>> Dir.direcao + 'Sul' + >>> Dir.girar_a_direita() + >>> Dir.direcao + 'Oeste' + >>> Dir.girar_a_direita() + >>> Dir.direcao + 'Norte' + >>> Dir.girar_a_esquerda() + >>> Dir.direcao + 'Oeste' + >>> Dir.girar_a_esquerda() + >>> Dir.direcao + 'Sul' + >>> Dir.girar_a_esquerda() + >>> Dir.direcao + 'Leste' + >>> Dir.girar_a_esquerda() + >>> Dir.direcao + 'Norte' + >>> carro = Carro(motor, Dir) + >>> carro.calcular_velocidade() + 0 + >>> carro.acelerar() + >>> carro.calcular_velocidade() + 1 + >>> carro.acelerar() + >>> carro.calcular_velocidade() + 2 + >>> carro.frear() + >>> carro.calcular_velocidade() + 0 + >>> carro.calcular_direcao() + 'Norte' + >>> carro.girar_a_direita() + >>> carro.calcular_direcao() + 'Leste' + >>> carro.girar_a_esquerda() + >>> carro.calcular_direcao() + 'Norte' + >>> carro.girar_a_esquerda() + >>> carro.calcular_direcao() + 'Oeste' + +''' + +class Carro: + + def __init__(self, motor, Dir): + self.Dir = Dir + self.motor = motor + + def calcular_velocidade(self): + return self.motor.velocidade + + def acelerar(self): + self.motor.acelerar() + + def frear(self): + self.motor.frear() + + def calcular_direcao(self): + return self.Dir.direcao + + def girar_a_direita(self): + self.Dir.girar_a_direita() + + def girar_a_esquerda(self): + self.Dir.girar_a_esquerda() + +class Motor: + + def __init__(self, velocidade = 0): + self.velocidade = velocidade + + def acelerar(self): + self.velocidade += 1 + return self.velocidade + + def frear(self): + if self.velocidade >= 2: + self.velocidade -= 2 + else: + self.velocidade = 0 + return self.velocidade + +class Direcao: + direcoes = ['Norte', 'Leste', 'Sul', 'Oeste'] + contador = 0 + + def __init__(self, direcao = 'Norte'): + self.direcao = direcao + + def girar_a_direita(self): + self.contador += 1 + if self.contador > 3: + self.contador = 0 + self.direcao = self.direcoes[self.contador] + return self.direcoes[self.contador] + + def girar_a_esquerda(self): + self.contador -= 1 + if self.contador < 0: + self.contador = 3 + self.direcao = self.direcoes[self.contador] + return self.direcoes[self.contador] + + +if __name__ == '__main__': + motor = Motor() + print(motor.velocidade) + print(motor.acelerar()) + print(motor.acelerar()) + print(motor.acelerar()) + print(motor.frear()) + print(motor.frear()) + + Dir = Direcao() + print(Dir.direcao) + print(Dir.girar_a_direita()) + print(Dir.girar_a_direita()) + print(Dir.girar_a_direita()) + print(Dir.girar_a_direita()) + print(Dir.girar_a_esquerda()) + print(Dir.girar_a_esquerda()) + print(Dir.girar_a_esquerda()) + print(Dir.girar_a_esquerda()) +''' +Rodar doctest via linha de comando: python -m doctest exercicio.py +''' diff --git a/oo/pessoa.py b/oo/pessoa.py new file mode 100644 index 000000000..c964720ee --- /dev/null +++ b/oo/pessoa.py @@ -0,0 +1,58 @@ +class Pessoa: + olhos = 2 + def __init__(self, *filhos, nome = None, idade = 35): + self.idade = idade + self.nome = nome + self.filhos = list(filhos) + + def cumprimentar(self): + return f'Olá, meu nome é {self.nome}' + + @staticmethod + def metodo_estatico(): + return 42 + + @classmethod + def nome_e_atributos_de_classe(cls): + return f'{cls} - olhos {cls.olhos}' + +class Homem(Pessoa): + def cumprimentar(self): + # cumprimentar_da_classe_pai = Pessoa.cumprimentar(self) #OU + cumprimentar_da_classe_pai = super().cumprimentar() + return f'{cumprimentar_da_classe_pai}. Aperto de mão' + +class Mutante(Pessoa): + olhos = 3 # sobrescrita de atributos + +if __name__ == '__main__': + renzo = Mutante(nome='Renzo') + luciano = Homem(renzo, nome='Luciano') + print(Pessoa.cumprimentar(luciano)) + print(luciano.cumprimentar()) + print(luciano.nome) + print(luciano.idade) + for filho in luciano.filhos: + print(filho.nome) + luciano.sobrenome = 'Ramalho' + del luciano.filhos + luciano.olhos = 1 + del luciano.olhos + print(renzo.__dict__) + print(luciano.__dict__) + print(Pessoa.olhos) + print(luciano.olhos) + print(renzo.olhos) + print(id(Pessoa.olhos), id(luciano.olhos), id(renzo.olhos)) + print(Pessoa.metodo_estatico(), luciano.metodo_estatico()) + print(Pessoa.nome_e_atributos_de_classe(), luciano.nome_e_atributos_de_classe()) + pessoa = Pessoa('Anonimo') + print(isinstance(pessoa, Pessoa)) + print(isinstance(pessoa, Homem)) + print(isinstance(renzo, Pessoa)) + print(isinstance(renzo, Homem)) + print(renzo.olhos) + print(luciano.cumprimentar()) + print(renzo.cumprimentar()) + + diff --git a/testes/teste_exercicio.py b/testes/teste_exercicio.py new file mode 100644 index 000000000..192419af6 --- /dev/null +++ b/testes/teste_exercicio.py @@ -0,0 +1,17 @@ +from unittest import TestCase + +from oo.exercicio import Motor + +class CarroTestCase(TestCase): + def teste_velocidade_inicial(self): + motor = Motor() + self.assertEqual(0, motor.velocidade) + + def teste_acelerar(self): + motor = Motor() + motor.acelerar() + self.assertEqual(1, motor.velocidade) + + +# herdar da classe TestCase +# o nome do código e o método precisa ter o prefixo test \ No newline at end of file diff --git a/testes/testes_atores.py b/testes/testes_atores.py new file mode 100644 index 000000000..f4254f29e --- /dev/null +++ b/testes/testes_atores.py @@ -0,0 +1,764 @@ +# -*- coding: utf-8 -*- + +from __future__ import unicode_literals +from os import path +import sys + +project_dir = path.dirname(__file__) +project_dir = path.join('..') +sys.path.append(project_dir) + +import unittest +from unittest.case import TestCase +from atores import Ator, DESTRUIDO, ATIVO, Obstaculo, Porco, PassaroAmarelo, PassaroVermelho + + +class AtorTestes(TestCase): + def teste_valores_padrao(self): + 'Testa valores iniciais padrão de um Ator' + ator = Ator() + self.assertEqual(0, ator.x) + self.assertEqual(0, ator.y) + self.assertEqual(ATIVO, ator.status) + self.assertEqual('A', ator.caracter()) + + def teste_valores_passados_por_parametro(self): + 'Testa se valores passados no inicializador são armazenados no objeto' + ator = Ator(1, 2) + self.assertEqual(1, ator.x) + self.assertEqual(2, ator.y) + self.assertEqual(ATIVO, ator.status) + self.assertEqual('A', ator.caracter()) + + def teste_ator_posicao(self): + 'Teste que verifica que o ator comum não deve se mover independente do tempo do jogo' + ator = Ator() + x, y = ator.calcular_posicao(0) + self.assertEqual(0, x) + self.assertEqual(0, y) + + ator = Ator(0.3, 0.5) + x, y = ator.calcular_posicao(10) + self.assertEqual(0.3, x) + self.assertEqual(0.5, y) + + + def teste_colisao_entre_atores_ativos(self): + """ + Teste de colisão entre dois atores + Inicialmente atores possuem status ATIVO. Ao se chocarem, ele muda para DESTRUIDO + A função assert_colisao_atores_ativos testa justamente se dois atore ativos se chocam quando estão em posições + vizinhas. + """ + ator = Ator(2, 2) # Ator recém criado deve ter status ativo + ator2 = Ator(2, 2) + self.assert_colisao_atores_ativos(ator, ator2) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(2, 3)) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(3, 3)) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(3, 2)) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(3, 1)) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(2, 1)) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(1, 1)) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(1, 2)) + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(1, 3)) + + def teste_colisao_entre_atores_ativos_com_intervalo(self): + # Com intervalo 2, diferente do padrão 1, essa colisão deveria acontecer + self.assert_colisao_atores_ativos(Ator(2, 2), Ator(2, 4), 2) + + def teste_nao_colisao_entre_atores_distantes(self): + 'Teste de que não há colisão entre atores distantes' + self.assert_nao_colisao(Ator(2, 2), Ator(2, 4)) + self.assert_nao_colisao(Ator(2, 2), Ator(3, 4)) + self.assert_nao_colisao(Ator(2, 2), Ator(4, 2)) + self.assert_nao_colisao(Ator(2, 2), Ator(3, 0)) + self.assert_nao_colisao(Ator(2, 2), Ator(2, 0)) + self.assert_nao_colisao(Ator(2, 2), Ator(0, 1)) + self.assert_nao_colisao(Ator(2, 2), Ator(0, 2)) + self.assert_nao_colisao(Ator(2, 2), Ator(0, 4)) + + def teste_colisao_somente_um_ator_destruido(self): + 'Teste de que um ator destruído não pode colidir com nenhum outro, mesmo que estejam próximos' + ator = Ator(2, 2) + ator.colidir(ator, 0) # colidindo ator com ele mesmo para alterar seu status para destruido + ator2 = Ator(2, 2) + self.assert_nao_colisao(ator, ator2) + self.assert_nao_colisao(Ator(2, 3), ator) + self.assert_nao_colisao(Ator(3, 3), ator) + self.assert_nao_colisao(Ator(3, 2), ator) + self.assert_nao_colisao(Ator(3, 1), ator) + self.assert_nao_colisao(Ator(2, 1), ator) + self.assert_nao_colisao(Ator(1, 1), ator) + self.assert_nao_colisao(Ator(1, 2), ator) + self.assert_nao_colisao(Ator(1, 3), ator) + self.assert_nao_colisao(ator2, ator) + self.assert_nao_colisao(Ator(2, 3), ator) + self.assert_nao_colisao(Ator(3, 3), ator) + self.assert_nao_colisao(Ator(3, 2), ator) + self.assert_nao_colisao(Ator(3, 1), ator) + self.assert_nao_colisao(Ator(2, 1), ator) + self.assert_nao_colisao(Ator(1, 1), ator) + self.assert_nao_colisao(Ator(1, 2), ator) + self.assert_nao_colisao(Ator(1, 3), ator) + + def test_caracter(self): + 'Teste de caracter para status ATIVO e DESTRUIDO' + ator = Ator() + self.assertEqual('A', ator.caracter()) + outro_ator_na_mesma_posicao = Ator() + ator.colidir(outro_ator_na_mesma_posicao) + self.assertEqual(' ', ator.caracter()) + + + def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1): + """ + Se certifica que há colisão entre atores ativos + Atenção: Esse não é método de teste porque nao se inicia com prefixo "text". + Ele serve apenas para encapsular toda lógica de teste de colisão entre dois atores ativos + """ + # Conferindo status dos dois atores antes da colisão + self.assertEqual(ator.status, ATIVO, 'Status deveria ser ativo antes da colisão') + self.assertEqual(ator2.status, ATIVO, 'Status deveria ser ativo antes da colisão') + ator.colidir(ator2, intervalo) + # Conferindo status dos dois atores depois da colisão + self.assertEqual(ator2.status, DESTRUIDO, 'Status deveria ser destruido depois da colisão') + self.assertEqual(ator.status, DESTRUIDO, 'Status deveria ser destruido depois da colisão') + + def assert_nao_colisao(self, ator, ator2): + """ + Se certifica que não colisão entre dois atores + Atenção: Esse não é método de teste porque nao se inicia com prefixo "text". + Ele apenas encapsula a lógica de não colisão entre dois atores. + So seja, eles deve manter seus respectivos status mesmo depois da chamada do metodo colidir + """ + # Armazenando status antes da colisão + status_inicial_ator = ator.status + status_inicial_ator_2 = ator2.status + + ator.colidir(ator2) + + # Conferindo se status ficaram inalterados + self.assertEqual(status_inicial_ator, ator.status, 'Status de ator não deveria mudar') + self.assertEqual(status_inicial_ator_2, ator2.status, 'Status de ator2 não deveria mudar') + + +class ObstaculoTestes(TestCase): + """ + Esperado '0' como caracter de obstáculo ativo e ' ' como caracter de obstáculo destruído + """ + def teste_status(self): + obstaculo = Obstaculo() + self.assertEqual('O', obstaculo.caracter()) + outro_ator_na_mesma_posicao = Ator() + obstaculo.colidir(outro_ator_na_mesma_posicao) + self.assertEqual(' ', obstaculo.caracter()) + + +class PorcoTestes(TestCase): + """ + Esperado '@' como caracter de porco ativo e '+' como caracter de porco destruido + """ + def teste_status(self): + porco = Porco() + self.assertEqual('@', porco.caracter()) + outro_ator_na_mesma_posicao = Ator() + porco.colidir(outro_ator_na_mesma_posicao) + self.assertEqual('+', porco.caracter()) + + +class PassaroBaseTests(TestCase): + """ + Classe base para teste de passaros. + Essa classe não contèm nenhum teste, serve apenas para encapsular a lógica de asserção de posição de passaros + vermelhos e também dos amarelos. + + """ + + def assert_passaro_posicao(self, x_esperado, y_esperado, status_esperado, passaro, tempo): + """ + Método que se testa posição do pássaro. + Atenção: Esse não é um método de teste porque não se inicia com prefixo "test". + :param x_esperado: posição x esperada do passaro + :param y_esperado: posição y esperada do passaro + :param status_esperado: status esperado do passaro + :param passaro: passaro alvo do teste + :param tempo: tempo do jogo + """ + x_calculado, y_calculado = passaro.calcular_posicao(tempo) + self.assertEqual(x_esperado, round(x_calculado), 'valor real de x = %s' % x_calculado) + self.assertEqual(y_esperado, round(y_calculado), 'valor real de y = %s' % y_calculado) + self.assertEqual(status_esperado, passaro.status, '(x = %s, y = %s)' % (x_calculado, y_calculado)) + + +class PassaroVermelhoTests(PassaroBaseTests): + """ + Classe de teste e Passaro Vermelho + """ + + def teste_status(self): + passaro_vermelho = PassaroVermelho(1, 1) + self.assertEqual('V', passaro_vermelho.caracter()) + outro_ator_na_mesma_posicao = Ator() + passaro_vermelho.colidir(outro_ator_na_mesma_posicao) + self.assertEqual('v', passaro_vermelho.caracter()) + + + def teste_velocidade_escalar(self): + self.assertEqual(20, PassaroVermelho.velocidade_escalar) + + + def teste_foi_lancado(self): + """ + Teste de lançamento. Enquanto o método lançar do passaro não for chamado, o méotodo 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_colisao_com_chao(self): + """ + Testando que o passáro colide 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') + + +class PassaroAmareloTests(PassaroBaseTests): + """ + Classe de Tests para passaros amarelos + """ + + def teste_status(self): + passaro_amarelo = PassaroAmarelo(1, 1) + self.assertEqual('A', passaro_amarelo.caracter()) + outro_ator_na_mesma_posicao = Ator() + passaro_amarelo.colidir(outro_ator_na_mesma_posicao) + self.assertEqual('a', passaro_amarelo.caracter()) + + def teste_velocidade_escalar(self): + self.assertEqual(30, PassaroAmarelo.velocidade_escalar) + + def teste_lacamento_vertical(self): + """ + Tests de lançamento vertical. Nele, o passaro só se move verticalmente e sua posição y se matém contanstante + :return: + """ + passaro_amarelo = PassaroAmarelo(1, 1) + passaro_amarelo.lancar(90, 2) # passaro lancado a 90 graus no tempo 2 segundos + + + + # subindo + + self.assert_posicao_vertical(1, 2.0, passaro_amarelo) + self.assert_posicao_vertical(1, 2.01, passaro_amarelo) + self.assert_posicao_vertical(2, 2.02, passaro_amarelo) + self.assert_posicao_vertical(2, 2.03, passaro_amarelo) + self.assert_posicao_vertical(2, 2.04, passaro_amarelo) + self.assert_posicao_vertical(2, 2.05, passaro_amarelo) + + # descendo + + self.assert_posicao_vertical(46, 5.26, passaro_amarelo) + self.assert_posicao_vertical(46, 5.27, passaro_amarelo) + self.assert_posicao_vertical(46, 5.279999999999999, passaro_amarelo) + self.assert_posicao_vertical(46, 5.29, passaro_amarelo) + self.assert_posicao_vertical(46, 5.3, passaro_amarelo) + self.assert_posicao_vertical(46, 5.3100000000000005, passaro_amarelo) + self.assert_posicao_vertical(45, 5.32, passaro_amarelo) + self.assert_posicao_vertical(45, 5.33, passaro_amarelo) + self.assert_posicao_vertical(45, 5.34, passaro_amarelo) + self.assert_posicao_vertical(45, 5.35, passaro_amarelo) + self.assert_posicao_vertical(45, 5.359999999999999, passaro_amarelo) + self.assert_posicao_vertical(45, 5.37, passaro_amarelo) + self.assert_posicao_vertical(45, 5.38, passaro_amarelo) + self.assert_posicao_vertical(45, 5.390000000000001, passaro_amarelo) + self.assert_posicao_vertical(45, 5.4, passaro_amarelo) + self.assert_posicao_vertical(45, 5.41, passaro_amarelo) + self.assert_posicao_vertical(45, 5.42, passaro_amarelo) + self.assert_posicao_vertical(45, 5.43, passaro_amarelo) + self.assert_posicao_vertical(45, 5.4399999999999995, passaro_amarelo) + self.assert_posicao_vertical(45, 5.45, passaro_amarelo) + self.assert_posicao_vertical(45, 5.46, passaro_amarelo) + self.assert_posicao_vertical(45, 5.470000000000001, passaro_amarelo) + self.assert_posicao_vertical(45, 5.48, passaro_amarelo) + + # preparando para impacto no chão + self.assert_posicao_vertical(1, 8.0, passaro_amarelo) + self.assert_posicao_vertical(1, 8.01, passaro_amarelo) + + # colisão + self.assert_posicao_vertical(0, 8.04, passaro_amarelo) + passaro_amarelo.colidir_com_chao() + self.assertEqual(DESTRUIDO, passaro_amarelo.status) + + def test_lancamento_45_graus(self): + passaro_amarelo = PassaroAmarelo(1, 1) + passaro_amarelo.lancar(45, 2) # passaro lancado a 45 graus no tempo 2 segundos + self.assert_passaro_posicao(1, 1, ATIVO, passaro_amarelo, 2.0) + self.assert_passaro_posicao(1, 1, ATIVO, passaro_amarelo, 2.01) + self.assert_passaro_posicao(1, 1, ATIVO, passaro_amarelo, 2.02) + self.assert_passaro_posicao(2, 2, ATIVO, passaro_amarelo, 2.03) + self.assert_passaro_posicao(2, 2, ATIVO, passaro_amarelo, 2.04) + self.assert_passaro_posicao(2, 2, ATIVO, passaro_amarelo, 2.05) + self.assert_passaro_posicao(2, 2, ATIVO, passaro_amarelo, 2.06) + self.assert_passaro_posicao(2, 2, ATIVO, passaro_amarelo, 2.07) + self.assert_passaro_posicao(3, 3, ATIVO, passaro_amarelo, 2.08) + self.assert_passaro_posicao(3, 3, ATIVO, passaro_amarelo, 2.09) + self.assert_passaro_posicao(3, 3, ATIVO, passaro_amarelo, 2.1) + self.assert_passaro_posicao(3, 3, ATIVO, passaro_amarelo, 2.11) + self.assert_passaro_posicao(4, 3, ATIVO, passaro_amarelo, 2.12) + self.assert_passaro_posicao(4, 4, ATIVO, passaro_amarelo, 2.13) + self.assert_passaro_posicao(4, 4, ATIVO, passaro_amarelo, 2.14) + self.assert_passaro_posicao(4, 4, ATIVO, passaro_amarelo, 2.15) + self.assert_passaro_posicao(4, 4, ATIVO, passaro_amarelo, 2.16) + self.assert_passaro_posicao(5, 4, ATIVO, passaro_amarelo, 2.17) + self.assert_passaro_posicao(5, 5, ATIVO, passaro_amarelo, 2.18) + self.assert_passaro_posicao(5, 5, ATIVO, passaro_amarelo, 2.19) + self.assert_passaro_posicao(5, 5, ATIVO, passaro_amarelo, 2.2) + self.assert_passaro_posicao(5, 5, ATIVO, passaro_amarelo, 2.21) + self.assert_passaro_posicao(6, 5, ATIVO, passaro_amarelo, 2.22) + self.assert_passaro_posicao(6, 6, ATIVO, passaro_amarelo, 2.23) + self.assert_passaro_posicao(6, 6, ATIVO, passaro_amarelo, 2.24) + self.assert_passaro_posicao(6, 6, ATIVO, passaro_amarelo, 2.25) + self.assert_passaro_posicao(7, 6, ATIVO, passaro_amarelo, 2.26) + self.assert_passaro_posicao(7, 6, ATIVO, passaro_amarelo, 2.27) + self.assert_passaro_posicao(7, 7, ATIVO, passaro_amarelo, 2.2800000000000002) + self.assert_passaro_posicao(7, 7, ATIVO, passaro_amarelo, 2.29) + self.assert_passaro_posicao(7, 7, ATIVO, passaro_amarelo, 2.3) + self.assert_passaro_posicao(8, 7, ATIVO, passaro_amarelo, 2.31) + self.assert_passaro_posicao(8, 7, ATIVO, passaro_amarelo, 2.32) + self.assert_passaro_posicao(8, 7, ATIVO, passaro_amarelo, 2.33) + self.assert_passaro_posicao(8, 8, ATIVO, passaro_amarelo, 2.34) + self.assert_passaro_posicao(8, 8, ATIVO, passaro_amarelo, 2.35) + self.assert_passaro_posicao(9, 8, ATIVO, passaro_amarelo, 2.36) + self.assert_passaro_posicao(9, 8, ATIVO, passaro_amarelo, 2.37) + self.assert_passaro_posicao(9, 8, ATIVO, passaro_amarelo, 2.38) + self.assert_passaro_posicao(9, 9, ATIVO, passaro_amarelo, 2.39) + self.assert_passaro_posicao(9, 9, ATIVO, passaro_amarelo, 2.4) + self.assert_passaro_posicao(10, 9, ATIVO, passaro_amarelo, 2.41) + self.assert_passaro_posicao(10, 9, ATIVO, passaro_amarelo, 2.42) + self.assert_passaro_posicao(10, 9, ATIVO, passaro_amarelo, 2.43) + self.assert_passaro_posicao(10, 9, ATIVO, passaro_amarelo, 2.44) + self.assert_passaro_posicao(11, 10, ATIVO, passaro_amarelo, 2.45) + self.assert_passaro_posicao(11, 10, ATIVO, passaro_amarelo, 2.46) + self.assert_passaro_posicao(11, 10, ATIVO, passaro_amarelo, 2.4699999999999998) + self.assert_passaro_posicao(11, 10, ATIVO, passaro_amarelo, 2.48) + self.assert_passaro_posicao(11, 10, ATIVO, passaro_amarelo, 2.49) + self.assert_passaro_posicao(12, 10, ATIVO, passaro_amarelo, 2.5) + self.assert_passaro_posicao(12, 11, ATIVO, passaro_amarelo, 2.51) + self.assert_passaro_posicao(12, 11, ATIVO, passaro_amarelo, 2.52) + self.assert_passaro_posicao(12, 11, ATIVO, passaro_amarelo, 2.5300000000000002) + self.assert_passaro_posicao(12, 11, ATIVO, passaro_amarelo, 2.54) + self.assert_passaro_posicao(13, 11, ATIVO, passaro_amarelo, 2.55) + self.assert_passaro_posicao(13, 11, ATIVO, passaro_amarelo, 2.56) + self.assert_passaro_posicao(13, 11, ATIVO, passaro_amarelo, 2.57) + self.assert_passaro_posicao(13, 12, ATIVO, passaro_amarelo, 2.58) + self.assert_passaro_posicao(14, 12, ATIVO, passaro_amarelo, 2.59) + self.assert_passaro_posicao(14, 12, ATIVO, passaro_amarelo, 2.6) + self.assert_passaro_posicao(14, 12, ATIVO, passaro_amarelo, 2.61) + self.assert_passaro_posicao(14, 12, ATIVO, passaro_amarelo, 2.62) + self.assert_passaro_posicao(14, 12, ATIVO, passaro_amarelo, 2.63) + self.assert_passaro_posicao(15, 13, ATIVO, passaro_amarelo, 2.64) + self.assert_passaro_posicao(15, 13, ATIVO, passaro_amarelo, 2.65) + self.assert_passaro_posicao(15, 13, ATIVO, passaro_amarelo, 2.66) + self.assert_passaro_posicao(15, 13, ATIVO, passaro_amarelo, 2.67) + self.assert_passaro_posicao(15, 13, ATIVO, passaro_amarelo, 2.68) + self.assert_passaro_posicao(16, 13, ATIVO, passaro_amarelo, 2.69) + self.assert_passaro_posicao(16, 13, ATIVO, passaro_amarelo, 2.7) + self.assert_passaro_posicao(16, 14, ATIVO, passaro_amarelo, 2.71) + self.assert_passaro_posicao(16, 14, ATIVO, passaro_amarelo, 2.7199999999999998) + self.assert_passaro_posicao(16, 14, ATIVO, passaro_amarelo, 2.73) + self.assert_passaro_posicao(17, 14, ATIVO, passaro_amarelo, 2.74) + self.assert_passaro_posicao(17, 14, ATIVO, passaro_amarelo, 2.75) + self.assert_passaro_posicao(17, 14, ATIVO, passaro_amarelo, 2.76) + self.assert_passaro_posicao(17, 14, ATIVO, passaro_amarelo, 2.77) + self.assert_passaro_posicao(18, 15, ATIVO, passaro_amarelo, 2.7800000000000002) + self.assert_passaro_posicao(18, 15, ATIVO, passaro_amarelo, 2.79) + self.assert_passaro_posicao(18, 15, ATIVO, passaro_amarelo, 2.8) + self.assert_passaro_posicao(18, 15, ATIVO, passaro_amarelo, 2.81) + self.assert_passaro_posicao(18, 15, ATIVO, passaro_amarelo, 2.82) + self.assert_passaro_posicao(19, 15, ATIVO, passaro_amarelo, 2.83) + self.assert_passaro_posicao(19, 15, ATIVO, passaro_amarelo, 2.84) + self.assert_passaro_posicao(19, 15, ATIVO, passaro_amarelo, 2.85) + self.assert_passaro_posicao(19, 16, ATIVO, passaro_amarelo, 2.86) + self.assert_passaro_posicao(19, 16, ATIVO, passaro_amarelo, 2.87) + self.assert_passaro_posicao(20, 16, ATIVO, passaro_amarelo, 2.88) + self.assert_passaro_posicao(20, 16, ATIVO, passaro_amarelo, 2.89) + self.assert_passaro_posicao(20, 16, ATIVO, passaro_amarelo, 2.9) + self.assert_passaro_posicao(20, 16, ATIVO, passaro_amarelo, 2.91) + self.assert_passaro_posicao(21, 16, ATIVO, passaro_amarelo, 2.92) + self.assert_passaro_posicao(21, 16, ATIVO, passaro_amarelo, 2.93) + self.assert_passaro_posicao(21, 17, ATIVO, passaro_amarelo, 2.94) + self.assert_passaro_posicao(21, 17, ATIVO, passaro_amarelo, 2.95) + self.assert_passaro_posicao(21, 17, ATIVO, passaro_amarelo, 2.96) + self.assert_passaro_posicao(22, 17, ATIVO, passaro_amarelo, 2.9699999999999998) + self.assert_passaro_posicao(22, 17, ATIVO, passaro_amarelo, 2.98) + self.assert_passaro_posicao(22, 17, ATIVO, passaro_amarelo, 2.99) + self.assert_passaro_posicao(22, 17, ATIVO, passaro_amarelo, 3.0) + self.assert_passaro_posicao(22, 17, ATIVO, passaro_amarelo, 3.01) + self.assert_passaro_posicao(23, 17, ATIVO, passaro_amarelo, 3.02) + self.assert_passaro_posicao(23, 18, ATIVO, passaro_amarelo, 3.0300000000000002) + self.assert_passaro_posicao(23, 18, ATIVO, passaro_amarelo, 3.04) + self.assert_passaro_posicao(23, 18, ATIVO, passaro_amarelo, 3.05) + self.assert_passaro_posicao(23, 18, ATIVO, passaro_amarelo, 3.06) + self.assert_passaro_posicao(24, 18, ATIVO, passaro_amarelo, 3.0700000000000003) + self.assert_passaro_posicao(24, 18, ATIVO, passaro_amarelo, 3.08) + self.assert_passaro_posicao(24, 18, ATIVO, passaro_amarelo, 3.09) + self.assert_passaro_posicao(24, 18, ATIVO, passaro_amarelo, 3.1) + self.assert_passaro_posicao(25, 18, ATIVO, passaro_amarelo, 3.1100000000000003) + self.assert_passaro_posicao(25, 18, ATIVO, passaro_amarelo, 3.12) + self.assert_passaro_posicao(25, 19, ATIVO, passaro_amarelo, 3.13) + self.assert_passaro_posicao(25, 19, ATIVO, passaro_amarelo, 3.1399999999999997) + self.assert_passaro_posicao(25, 19, ATIVO, passaro_amarelo, 3.15) + self.assert_passaro_posicao(26, 19, ATIVO, passaro_amarelo, 3.16) + self.assert_passaro_posicao(26, 19, ATIVO, passaro_amarelo, 3.17) + self.assert_passaro_posicao(26, 19, ATIVO, passaro_amarelo, 3.1799999999999997) + self.assert_passaro_posicao(26, 19, ATIVO, passaro_amarelo, 3.19) + self.assert_passaro_posicao(26, 19, ATIVO, passaro_amarelo, 3.2) + self.assert_passaro_posicao(27, 19, ATIVO, passaro_amarelo, 3.21) + self.assert_passaro_posicao(27, 19, ATIVO, passaro_amarelo, 3.2199999999999998) + self.assert_passaro_posicao(27, 20, ATIVO, passaro_amarelo, 3.23) + self.assert_passaro_posicao(27, 20, ATIVO, passaro_amarelo, 3.24) + self.assert_passaro_posicao(28, 20, ATIVO, passaro_amarelo, 3.25) + self.assert_passaro_posicao(28, 20, ATIVO, passaro_amarelo, 3.26) + self.assert_passaro_posicao(28, 20, ATIVO, passaro_amarelo, 3.27) + self.assert_passaro_posicao(28, 20, ATIVO, passaro_amarelo, 3.2800000000000002) + self.assert_passaro_posicao(28, 20, ATIVO, passaro_amarelo, 3.29) + self.assert_passaro_posicao(29, 20, ATIVO, passaro_amarelo, 3.3) + self.assert_passaro_posicao(29, 20, ATIVO, passaro_amarelo, 3.31) + self.assert_passaro_posicao(29, 20, ATIVO, passaro_amarelo, 3.3200000000000003) + self.assert_passaro_posicao(29, 20, ATIVO, passaro_amarelo, 3.33) + self.assert_passaro_posicao(29, 20, ATIVO, passaro_amarelo, 3.34) + self.assert_passaro_posicao(30, 21, ATIVO, passaro_amarelo, 3.35) + self.assert_passaro_posicao(30, 21, ATIVO, passaro_amarelo, 3.3600000000000003) + self.assert_passaro_posicao(30, 21, ATIVO, passaro_amarelo, 3.37) + self.assert_passaro_posicao(30, 21, ATIVO, passaro_amarelo, 3.38) + self.assert_passaro_posicao(30, 21, ATIVO, passaro_amarelo, 3.3899999999999997) + self.assert_passaro_posicao(31, 21, ATIVO, passaro_amarelo, 3.4) + self.assert_passaro_posicao(31, 21, ATIVO, passaro_amarelo, 3.41) + self.assert_passaro_posicao(31, 21, ATIVO, passaro_amarelo, 3.42) + self.assert_passaro_posicao(31, 21, ATIVO, passaro_amarelo, 3.4299999999999997) + self.assert_passaro_posicao(32, 21, ATIVO, passaro_amarelo, 3.44) + self.assert_passaro_posicao(32, 21, ATIVO, passaro_amarelo, 3.45) + self.assert_passaro_posicao(32, 21, ATIVO, passaro_amarelo, 3.46) + self.assert_passaro_posicao(32, 21, ATIVO, passaro_amarelo, 3.4699999999999998) + self.assert_passaro_posicao(32, 21, ATIVO, passaro_amarelo, 3.48) + self.assert_passaro_posicao(33, 22, ATIVO, passaro_amarelo, 3.49) + self.assert_passaro_posicao(33, 22, ATIVO, passaro_amarelo, 3.5) + self.assert_passaro_posicao(33, 22, ATIVO, passaro_amarelo, 3.51) + self.assert_passaro_posicao(33, 22, ATIVO, passaro_amarelo, 3.52) + self.assert_passaro_posicao(33, 22, ATIVO, passaro_amarelo, 3.5300000000000002) + self.assert_passaro_posicao(34, 22, ATIVO, passaro_amarelo, 3.54) + self.assert_passaro_posicao(34, 22, ATIVO, passaro_amarelo, 3.55) + self.assert_passaro_posicao(34, 22, ATIVO, passaro_amarelo, 3.56) + self.assert_passaro_posicao(34, 22, ATIVO, passaro_amarelo, 3.5700000000000003) + self.assert_passaro_posicao(35, 22, ATIVO, passaro_amarelo, 3.58) + self.assert_passaro_posicao(35, 22, ATIVO, passaro_amarelo, 3.59) + self.assert_passaro_posicao(35, 22, ATIVO, passaro_amarelo, 3.6) + self.assert_passaro_posicao(35, 22, ATIVO, passaro_amarelo, 3.6100000000000003) + self.assert_passaro_posicao(35, 22, ATIVO, passaro_amarelo, 3.62) + self.assert_passaro_posicao(36, 22, ATIVO, passaro_amarelo, 3.63) + self.assert_passaro_posicao(36, 22, ATIVO, passaro_amarelo, 3.6399999999999997) + self.assert_passaro_posicao(36, 22, ATIVO, passaro_amarelo, 3.65) + self.assert_passaro_posicao(36, 22, ATIVO, passaro_amarelo, 3.66) + self.assert_passaro_posicao(36, 22, ATIVO, passaro_amarelo, 3.67) + self.assert_passaro_posicao(37, 23, ATIVO, passaro_amarelo, 3.6799999999999997) + self.assert_passaro_posicao(37, 23, ATIVO, passaro_amarelo, 3.69) + self.assert_passaro_posicao(37, 23, ATIVO, passaro_amarelo, 3.7) + self.assert_passaro_posicao(37, 23, ATIVO, passaro_amarelo, 3.71) + self.assert_passaro_posicao(37, 23, ATIVO, passaro_amarelo, 3.7199999999999998) + self.assert_passaro_posicao(38, 23, ATIVO, passaro_amarelo, 3.73) + self.assert_passaro_posicao(38, 23, ATIVO, passaro_amarelo, 3.74) + self.assert_passaro_posicao(38, 23, ATIVO, passaro_amarelo, 3.75) + self.assert_passaro_posicao(38, 23, ATIVO, passaro_amarelo, 3.76) + self.assert_passaro_posicao(39, 23, ATIVO, passaro_amarelo, 3.77) + self.assert_passaro_posicao(39, 23, ATIVO, passaro_amarelo, 3.7800000000000002) + self.assert_passaro_posicao(39, 23, ATIVO, passaro_amarelo, 3.79) + self.assert_passaro_posicao(39, 23, ATIVO, passaro_amarelo, 3.8) + self.assert_passaro_posicao(39, 23, ATIVO, passaro_amarelo, 3.81) + self.assert_passaro_posicao(40, 23, ATIVO, passaro_amarelo, 3.8200000000000003) + self.assert_passaro_posicao(40, 23, ATIVO, passaro_amarelo, 3.83) + self.assert_passaro_posicao(40, 23, ATIVO, passaro_amarelo, 3.84) + self.assert_passaro_posicao(40, 23, ATIVO, passaro_amarelo, 3.85) + self.assert_passaro_posicao(40, 23, ATIVO, passaro_amarelo, 3.8600000000000003) + self.assert_passaro_posicao(41, 23, ATIVO, passaro_amarelo, 3.87) + self.assert_passaro_posicao(41, 23, ATIVO, passaro_amarelo, 3.88) + self.assert_passaro_posicao(41, 23, ATIVO, passaro_amarelo, 3.8899999999999997) + self.assert_passaro_posicao(41, 23, ATIVO, passaro_amarelo, 3.9) + self.assert_passaro_posicao(42, 23, ATIVO, passaro_amarelo, 3.91) + self.assert_passaro_posicao(42, 23, ATIVO, passaro_amarelo, 3.92) + self.assert_passaro_posicao(42, 23, ATIVO, passaro_amarelo, 3.9299999999999997) + self.assert_passaro_posicao(42, 23, ATIVO, passaro_amarelo, 3.94) + self.assert_passaro_posicao(42, 23, ATIVO, passaro_amarelo, 3.95) + self.assert_passaro_posicao(43, 23, ATIVO, passaro_amarelo, 3.96) + self.assert_passaro_posicao(43, 23, ATIVO, passaro_amarelo, 3.9699999999999998) + self.assert_passaro_posicao(43, 23, ATIVO, passaro_amarelo, 3.98) + self.assert_passaro_posicao(43, 23, ATIVO, passaro_amarelo, 3.99) + self.assert_passaro_posicao(43, 23, ATIVO, passaro_amarelo, 4.0) + self.assert_passaro_posicao(44, 23, ATIVO, passaro_amarelo, 4.01) + self.assert_passaro_posicao(44, 23, ATIVO, passaro_amarelo, 4.02) + self.assert_passaro_posicao(44, 23, ATIVO, passaro_amarelo, 4.029999999999999) + self.assert_passaro_posicao(44, 23, ATIVO, passaro_amarelo, 4.04) + self.assert_passaro_posicao(44, 23, ATIVO, passaro_amarelo, 4.05) + self.assert_passaro_posicao(45, 23, ATIVO, passaro_amarelo, 4.0600000000000005) + self.assert_passaro_posicao(45, 23, ATIVO, passaro_amarelo, 4.07) + self.assert_passaro_posicao(45, 23, ATIVO, passaro_amarelo, 4.08) + self.assert_passaro_posicao(45, 23, ATIVO, passaro_amarelo, 4.09) + self.assert_passaro_posicao(46, 23, ATIVO, passaro_amarelo, 4.1) + self.assert_passaro_posicao(46, 23, ATIVO, passaro_amarelo, 4.109999999999999) + self.assert_passaro_posicao(46, 23, ATIVO, passaro_amarelo, 4.12) + self.assert_passaro_posicao(46, 23, ATIVO, passaro_amarelo, 4.13) + self.assert_passaro_posicao(46, 23, ATIVO, passaro_amarelo, 4.140000000000001) + self.assert_passaro_posicao(47, 23, ATIVO, passaro_amarelo, 4.15) + self.assert_passaro_posicao(47, 23, ATIVO, passaro_amarelo, 4.16) + self.assert_passaro_posicao(47, 23, ATIVO, passaro_amarelo, 4.17) + self.assert_passaro_posicao(47, 23, ATIVO, passaro_amarelo, 4.18) + self.assert_passaro_posicao(47, 23, ATIVO, passaro_amarelo, 4.1899999999999995) + self.assert_passaro_posicao(48, 23, ATIVO, passaro_amarelo, 4.2) + self.assert_passaro_posicao(48, 23, ATIVO, passaro_amarelo, 4.21) + self.assert_passaro_posicao(48, 23, ATIVO, passaro_amarelo, 4.220000000000001) + self.assert_passaro_posicao(48, 23, ATIVO, passaro_amarelo, 4.23) + self.assert_passaro_posicao(49, 23, ATIVO, passaro_amarelo, 4.24) + self.assert_passaro_posicao(49, 23, ATIVO, passaro_amarelo, 4.25) + self.assert_passaro_posicao(49, 23, ATIVO, passaro_amarelo, 4.26) + self.assert_passaro_posicao(49, 23, ATIVO, passaro_amarelo, 4.27) + self.assert_passaro_posicao(49, 23, ATIVO, passaro_amarelo, 4.279999999999999) + self.assert_passaro_posicao(50, 23, ATIVO, passaro_amarelo, 4.29) + self.assert_passaro_posicao(50, 23, ATIVO, passaro_amarelo, 4.3) + self.assert_passaro_posicao(50, 23, ATIVO, passaro_amarelo, 4.3100000000000005) + self.assert_passaro_posicao(50, 23, ATIVO, passaro_amarelo, 4.32) + self.assert_passaro_posicao(50, 23, ATIVO, passaro_amarelo, 4.33) + self.assert_passaro_posicao(51, 23, ATIVO, passaro_amarelo, 4.34) + self.assert_passaro_posicao(51, 23, ATIVO, passaro_amarelo, 4.35) + self.assert_passaro_posicao(51, 23, ATIVO, passaro_amarelo, 4.359999999999999) + self.assert_passaro_posicao(51, 23, ATIVO, passaro_amarelo, 4.37) + self.assert_passaro_posicao(51, 23, ATIVO, passaro_amarelo, 4.38) + self.assert_passaro_posicao(52, 23, ATIVO, passaro_amarelo, 4.390000000000001) + self.assert_passaro_posicao(52, 23, ATIVO, passaro_amarelo, 4.4) + self.assert_passaro_posicao(52, 23, ATIVO, passaro_amarelo, 4.41) + self.assert_passaro_posicao(52, 23, ATIVO, passaro_amarelo, 4.42) + self.assert_passaro_posicao(53, 23, ATIVO, passaro_amarelo, 4.43) + self.assert_passaro_posicao(53, 23, ATIVO, passaro_amarelo, 4.4399999999999995) + self.assert_passaro_posicao(53, 23, ATIVO, passaro_amarelo, 4.45) + self.assert_passaro_posicao(53, 23, ATIVO, passaro_amarelo, 4.46) + self.assert_passaro_posicao(53, 23, ATIVO, passaro_amarelo, 4.470000000000001) + self.assert_passaro_posicao(54, 23, ATIVO, passaro_amarelo, 4.48) + self.assert_passaro_posicao(54, 23, ATIVO, passaro_amarelo, 4.49) + self.assert_passaro_posicao(54, 23, ATIVO, passaro_amarelo, 4.5) + self.assert_passaro_posicao(54, 23, ATIVO, passaro_amarelo, 4.51) + self.assert_passaro_posicao(54, 23, ATIVO, passaro_amarelo, 4.52) + self.assert_passaro_posicao(55, 23, ATIVO, passaro_amarelo, 4.529999999999999) + self.assert_passaro_posicao(55, 23, ATIVO, passaro_amarelo, 4.54) + self.assert_passaro_posicao(55, 23, ATIVO, passaro_amarelo, 4.55) + self.assert_passaro_posicao(55, 23, ATIVO, passaro_amarelo, 4.5600000000000005) + self.assert_passaro_posicao(56, 22, ATIVO, passaro_amarelo, 4.57) + self.assert_passaro_posicao(56, 22, ATIVO, passaro_amarelo, 4.58) + self.assert_passaro_posicao(56, 22, ATIVO, passaro_amarelo, 4.59) + self.assert_passaro_posicao(56, 22, ATIVO, passaro_amarelo, 4.6) + self.assert_passaro_posicao(56, 22, ATIVO, passaro_amarelo, 4.609999999999999) + self.assert_passaro_posicao(57, 22, ATIVO, passaro_amarelo, 4.62) + self.assert_passaro_posicao(57, 22, ATIVO, passaro_amarelo, 4.63) + self.assert_passaro_posicao(57, 22, ATIVO, passaro_amarelo, 4.640000000000001) + self.assert_passaro_posicao(57, 22, ATIVO, passaro_amarelo, 4.65) + self.assert_passaro_posicao(57, 22, ATIVO, passaro_amarelo, 4.66) + self.assert_passaro_posicao(58, 22, ATIVO, passaro_amarelo, 4.67) + self.assert_passaro_posicao(58, 22, ATIVO, passaro_amarelo, 4.68) + self.assert_passaro_posicao(58, 22, ATIVO, passaro_amarelo, 4.6899999999999995) + self.assert_passaro_posicao(58, 22, ATIVO, passaro_amarelo, 4.7) + self.assert_passaro_posicao(58, 22, ATIVO, passaro_amarelo, 4.71) + self.assert_passaro_posicao(59, 22, ATIVO, passaro_amarelo, 4.720000000000001) + self.assert_passaro_posicao(59, 22, ATIVO, passaro_amarelo, 4.73) + self.assert_passaro_posicao(59, 22, ATIVO, passaro_amarelo, 4.74) + self.assert_passaro_posicao(59, 22, ATIVO, passaro_amarelo, 4.75) + self.assert_passaro_posicao(60, 21, ATIVO, passaro_amarelo, 4.76) + self.assert_passaro_posicao(60, 21, ATIVO, passaro_amarelo, 4.77) + self.assert_passaro_posicao(60, 21, ATIVO, passaro_amarelo, 4.779999999999999) + self.assert_passaro_posicao(60, 21, ATIVO, passaro_amarelo, 4.79) + self.assert_passaro_posicao(60, 21, ATIVO, passaro_amarelo, 4.8) + self.assert_passaro_posicao(61, 21, ATIVO, passaro_amarelo, 4.8100000000000005) + self.assert_passaro_posicao(61, 21, ATIVO, passaro_amarelo, 4.82) + self.assert_passaro_posicao(61, 21, ATIVO, passaro_amarelo, 4.83) + self.assert_passaro_posicao(61, 21, ATIVO, passaro_amarelo, 4.84) + self.assert_passaro_posicao(61, 21, ATIVO, passaro_amarelo, 4.85) + self.assert_passaro_posicao(62, 21, ATIVO, passaro_amarelo, 4.859999999999999) + self.assert_passaro_posicao(62, 21, ATIVO, passaro_amarelo, 4.87) + self.assert_passaro_posicao(62, 21, ATIVO, passaro_amarelo, 4.88) + self.assert_passaro_posicao(62, 21, ATIVO, passaro_amarelo, 4.890000000000001) + self.assert_passaro_posicao(63, 20, ATIVO, passaro_amarelo, 4.9) + self.assert_passaro_posicao(63, 20, ATIVO, passaro_amarelo, 4.91) + self.assert_passaro_posicao(63, 20, ATIVO, passaro_amarelo, 4.92) + self.assert_passaro_posicao(63, 20, ATIVO, passaro_amarelo, 4.93) + self.assert_passaro_posicao(63, 20, ATIVO, passaro_amarelo, 4.9399999999999995) + self.assert_passaro_posicao(64, 20, ATIVO, passaro_amarelo, 4.95) + self.assert_passaro_posicao(64, 20, ATIVO, passaro_amarelo, 4.96) + self.assert_passaro_posicao(64, 20, ATIVO, passaro_amarelo, 4.970000000000001) + self.assert_passaro_posicao(64, 20, ATIVO, passaro_amarelo, 4.98) + self.assert_passaro_posicao(64, 20, ATIVO, passaro_amarelo, 4.99) + self.assert_passaro_posicao(65, 20, ATIVO, passaro_amarelo, 5.0) + self.assert_passaro_posicao(65, 20, ATIVO, passaro_amarelo, 5.01) + self.assert_passaro_posicao(65, 19, ATIVO, passaro_amarelo, 5.02) + self.assert_passaro_posicao(65, 19, ATIVO, passaro_amarelo, 5.029999999999999) + self.assert_passaro_posicao(65, 19, ATIVO, passaro_amarelo, 5.04) + self.assert_passaro_posicao(66, 19, ATIVO, passaro_amarelo, 5.05) + self.assert_passaro_posicao(66, 19, ATIVO, passaro_amarelo, 5.0600000000000005) + self.assert_passaro_posicao(66, 19, ATIVO, passaro_amarelo, 5.07) + self.assert_passaro_posicao(66, 19, ATIVO, passaro_amarelo, 5.08) + self.assert_passaro_posicao(67, 19, ATIVO, passaro_amarelo, 5.09) + self.assert_passaro_posicao(67, 19, ATIVO, passaro_amarelo, 5.1) + self.assert_passaro_posicao(67, 19, ATIVO, passaro_amarelo, 5.109999999999999) + self.assert_passaro_posicao(67, 19, ATIVO, passaro_amarelo, 5.12) + self.assert_passaro_posicao(67, 18, ATIVO, passaro_amarelo, 5.13) + self.assert_passaro_posicao(68, 18, ATIVO, passaro_amarelo, 5.140000000000001) + self.assert_passaro_posicao(68, 18, ATIVO, passaro_amarelo, 5.15) + self.assert_passaro_posicao(68, 18, ATIVO, passaro_amarelo, 5.16) + self.assert_passaro_posicao(68, 18, ATIVO, passaro_amarelo, 5.17) + self.assert_passaro_posicao(68, 18, ATIVO, passaro_amarelo, 5.18) + self.assert_passaro_posicao(69, 18, ATIVO, passaro_amarelo, 5.1899999999999995) + self.assert_passaro_posicao(69, 18, ATIVO, passaro_amarelo, 5.2) + self.assert_passaro_posicao(69, 18, ATIVO, passaro_amarelo, 5.21) + self.assert_passaro_posicao(69, 17, ATIVO, passaro_amarelo, 5.220000000000001) + self.assert_passaro_posicao(70, 17, ATIVO, passaro_amarelo, 5.23) + self.assert_passaro_posicao(70, 17, ATIVO, passaro_amarelo, 5.24) + self.assert_passaro_posicao(70, 17, ATIVO, passaro_amarelo, 5.25) + self.assert_passaro_posicao(70, 17, ATIVO, passaro_amarelo, 5.26) + self.assert_passaro_posicao(70, 17, ATIVO, passaro_amarelo, 5.27) + self.assert_passaro_posicao(71, 17, ATIVO, passaro_amarelo, 5.279999999999999) + self.assert_passaro_posicao(71, 17, ATIVO, passaro_amarelo, 5.29) + self.assert_passaro_posicao(71, 17, ATIVO, passaro_amarelo, 5.3) + self.assert_passaro_posicao(71, 16, ATIVO, passaro_amarelo, 5.3100000000000005) + self.assert_passaro_posicao(71, 16, ATIVO, passaro_amarelo, 5.32) + self.assert_passaro_posicao(72, 16, ATIVO, passaro_amarelo, 5.33) + self.assert_passaro_posicao(72, 16, ATIVO, passaro_amarelo, 5.34) + self.assert_passaro_posicao(72, 16, ATIVO, passaro_amarelo, 5.35) + self.assert_passaro_posicao(72, 16, ATIVO, passaro_amarelo, 5.359999999999999) + self.assert_passaro_posicao(72, 16, ATIVO, passaro_amarelo, 5.37) + self.assert_passaro_posicao(73, 16, ATIVO, passaro_amarelo, 5.38) + self.assert_passaro_posicao(73, 15, ATIVO, passaro_amarelo, 5.390000000000001) + self.assert_passaro_posicao(73, 15, ATIVO, passaro_amarelo, 5.4) + self.assert_passaro_posicao(73, 15, ATIVO, passaro_amarelo, 5.41) + self.assert_passaro_posicao(74, 15, ATIVO, passaro_amarelo, 5.42) + self.assert_passaro_posicao(74, 15, ATIVO, passaro_amarelo, 5.43) + self.assert_passaro_posicao(74, 15, ATIVO, passaro_amarelo, 5.4399999999999995) + self.assert_passaro_posicao(74, 15, ATIVO, passaro_amarelo, 5.45) + self.assert_passaro_posicao(74, 15, ATIVO, passaro_amarelo, 5.46) + self.assert_passaro_posicao(75, 14, ATIVO, passaro_amarelo, 5.470000000000001) + self.assert_passaro_posicao(75, 14, ATIVO, passaro_amarelo, 5.48) + self.assert_passaro_posicao(75, 14, ATIVO, passaro_amarelo, 5.49) + self.assert_passaro_posicao(75, 14, ATIVO, passaro_amarelo, 5.5) + self.assert_passaro_posicao(75, 14, ATIVO, passaro_amarelo, 5.51) + self.assert_passaro_posicao(76, 14, ATIVO, passaro_amarelo, 5.52) + self.assert_passaro_posicao(76, 14, ATIVO, passaro_amarelo, 5.529999999999999) + self.assert_passaro_posicao(76, 13, ATIVO, passaro_amarelo, 5.54) + self.assert_passaro_posicao(76, 13, ATIVO, passaro_amarelo, 5.55) + self.assert_passaro_posicao(77, 13, ATIVO, passaro_amarelo, 5.5600000000000005) + self.assert_passaro_posicao(77, 13, ATIVO, passaro_amarelo, 5.57) + self.assert_passaro_posicao(77, 13, ATIVO, passaro_amarelo, 5.58) + self.assert_passaro_posicao(77, 13, ATIVO, passaro_amarelo, 5.59) + self.assert_passaro_posicao(77, 13, ATIVO, passaro_amarelo, 5.6) + self.assert_passaro_posicao(78, 12, ATIVO, passaro_amarelo, 5.609999999999999) + self.assert_passaro_posicao(78, 12, ATIVO, passaro_amarelo, 5.62) + self.assert_passaro_posicao(78, 12, ATIVO, passaro_amarelo, 5.63) + self.assert_passaro_posicao(78, 12, ATIVO, passaro_amarelo, 5.640000000000001) + self.assert_passaro_posicao(78, 12, ATIVO, passaro_amarelo, 5.65) + self.assert_passaro_posicao(79, 12, ATIVO, passaro_amarelo, 5.66) + self.assert_passaro_posicao(79, 12, ATIVO, passaro_amarelo, 5.67) + self.assert_passaro_posicao(79, 11, ATIVO, passaro_amarelo, 5.68) + self.assert_passaro_posicao(79, 11, ATIVO, passaro_amarelo, 5.6899999999999995) + self.assert_passaro_posicao(79, 11, ATIVO, passaro_amarelo, 5.7) + self.assert_passaro_posicao(80, 11, ATIVO, passaro_amarelo, 5.71) + self.assert_passaro_posicao(80, 11, ATIVO, passaro_amarelo, 5.720000000000001) + self.assert_passaro_posicao(80, 11, ATIVO, passaro_amarelo, 5.73) + self.assert_passaro_posicao(80, 10, ATIVO, passaro_amarelo, 5.74) + self.assert_passaro_posicao(81, 10, ATIVO, passaro_amarelo, 5.75) + self.assert_passaro_posicao(81, 10, ATIVO, passaro_amarelo, 5.76) + self.assert_passaro_posicao(81, 10, ATIVO, passaro_amarelo, 5.77) + self.assert_passaro_posicao(81, 10, ATIVO, passaro_amarelo, 5.779999999999999) + self.assert_passaro_posicao(81, 10, ATIVO, passaro_amarelo, 5.79) + self.assert_passaro_posicao(82, 9, ATIVO, passaro_amarelo, 5.8) + self.assert_passaro_posicao(82, 9, ATIVO, passaro_amarelo, 5.8100000000000005) + self.assert_passaro_posicao(82, 9, ATIVO, passaro_amarelo, 5.82) + self.assert_passaro_posicao(82, 9, ATIVO, passaro_amarelo, 5.83) + self.assert_passaro_posicao(82, 9, ATIVO, passaro_amarelo, 5.84) + self.assert_passaro_posicao(83, 9, ATIVO, passaro_amarelo, 5.85) + self.assert_passaro_posicao(83, 8, ATIVO, passaro_amarelo, 5.859999999999999) + self.assert_passaro_posicao(83, 8, ATIVO, passaro_amarelo, 5.87) + self.assert_passaro_posicao(83, 8, ATIVO, passaro_amarelo, 5.88) + self.assert_passaro_posicao(84, 8, ATIVO, passaro_amarelo, 5.890000000000001) + self.assert_passaro_posicao(84, 8, ATIVO, passaro_amarelo, 5.9) + self.assert_passaro_posicao(84, 8, ATIVO, passaro_amarelo, 5.91) + self.assert_passaro_posicao(84, 7, ATIVO, passaro_amarelo, 5.92) + self.assert_passaro_posicao(84, 7, ATIVO, passaro_amarelo, 5.93) + self.assert_passaro_posicao(85, 7, ATIVO, passaro_amarelo, 5.9399999999999995) + self.assert_passaro_posicao(85, 7, ATIVO, passaro_amarelo, 5.95) + self.assert_passaro_posicao(85, 7, ATIVO, passaro_amarelo, 5.96) + self.assert_passaro_posicao(85, 6, ATIVO, passaro_amarelo, 5.970000000000001) + self.assert_passaro_posicao(85, 6, ATIVO, passaro_amarelo, 5.98) + self.assert_passaro_posicao(86, 6, ATIVO, passaro_amarelo, 5.99) + self.assert_passaro_posicao(86, 6, ATIVO, passaro_amarelo, 6.0) + self.assert_passaro_posicao(86, 6, ATIVO, passaro_amarelo, 6.01) + self.assert_passaro_posicao(86, 5, ATIVO, passaro_amarelo, 6.02) + self.assert_passaro_posicao(86, 5, ATIVO, passaro_amarelo, 6.03) + self.assert_passaro_posicao(87, 5, ATIVO, passaro_amarelo, 6.04) + self.assert_passaro_posicao(87, 5, ATIVO, passaro_amarelo, 6.05) + self.assert_passaro_posicao(87, 5, ATIVO, passaro_amarelo, 6.06) + self.assert_passaro_posicao(87, 5, ATIVO, passaro_amarelo, 6.07) + self.assert_passaro_posicao(88, 4, ATIVO, passaro_amarelo, 6.08) + self.assert_passaro_posicao(88, 4, ATIVO, passaro_amarelo, 6.09) + self.assert_passaro_posicao(88, 4, ATIVO, passaro_amarelo, 6.1) + self.assert_passaro_posicao(88, 4, ATIVO, passaro_amarelo, 6.11) + self.assert_passaro_posicao(88, 4, ATIVO, passaro_amarelo, 6.12) + self.assert_passaro_posicao(89, 3, ATIVO, passaro_amarelo, 6.13) + self.assert_passaro_posicao(89, 3, ATIVO, passaro_amarelo, 6.14) + self.assert_passaro_posicao(89, 3, ATIVO, passaro_amarelo, 6.15) + self.assert_passaro_posicao(89, 3, ATIVO, passaro_amarelo, 6.16) + self.assert_passaro_posicao(89, 3, ATIVO, passaro_amarelo, 6.17) + self.assert_passaro_posicao(90, 2, ATIVO, passaro_amarelo, 6.18) + self.assert_passaro_posicao(90, 2, ATIVO, passaro_amarelo, 6.19) + self.assert_passaro_posicao(90, 2, ATIVO, passaro_amarelo, 6.2) + self.assert_passaro_posicao(90, 2, ATIVO, passaro_amarelo, 6.21) + self.assert_passaro_posicao(91, 1, ATIVO, passaro_amarelo, 6.22) + self.assert_passaro_posicao(91, 1, ATIVO, passaro_amarelo, 6.23) + self.assert_passaro_posicao(91, 1, ATIVO, passaro_amarelo, 6.24) + self.assert_passaro_posicao(91, 1, ATIVO, passaro_amarelo, 6.25) + self.assert_passaro_posicao(91, 1, ATIVO, passaro_amarelo, 6.26) + self.assert_passaro_posicao(92, 0, ATIVO, passaro_amarelo, 6.29) + passaro_amarelo.colidir_com_chao() + self.assertEqual(DESTRUIDO, passaro_amarelo.status) + # Código de geração de testes + + # for delta_t in range(0, 550): + # t = 2 + (delta_t / 100) + # x, y = passaro_amarelo.calcular_posicao(t) + # print(' self.assert_passaro_posicao(%s, %s, ATIVO, passaro_amarelo, %s)' % (x, y, t)) + + def assert_posicao_vertical(self, y, tempo, passaro): + """ + Método auxiliar que mantém x fixo com valor 1, status Ativo, variando apenas o tempo e a posição y + Atenção, esse não é um teste porque não começa com prefixo "test" + """ + self.assert_passaro_posicao(1, y, ATIVO, passaro, tempo) + + +if __name__=='__main__': + teste= AtorTestes() + teste.teste_colisao_entre_atores_ativos() diff --git a/testes/testes_fase.py b/testes/testes_fase.py new file mode 100644 index 000000000..8158a43f5 --- /dev/null +++ b/testes/testes_fase.py @@ -0,0 +1,212 @@ +# -*- coding: utf-8 -*- + +import os +import sys +from os import path +from unittest.case import TestCase + +project_dir = path.dirname(__file__) +project_dir = path.join('..') +sys.path.append(project_dir) +from placa_grafica_tkinter import rodar_fase + +project_dir = os.path.join(os.path.dirname(__file__), '..') +project_dir = os.path.normpath(project_dir) +sys.path.append(project_dir) + +from atores import (Obstaculo, Porco, PassaroVermelho, PassaroAmarelo, + DESTRUIDO, ATIVO, DuploLancamentoExcecao) +from fase import Fase, Ponto, EM_ANDAMENTO, VITORIA, DERROTA + + +class AtorFake: + def __init__(self, x=0, y=0): + self.y = y + self.x = x + self.status = ATIVO + self.colidir_executado = False + self.calcular_posicao_executado = False + self.intervalo_colisao = None + + def calcular_posicao(self, tempo): + self.calcular_posicao_executado = True + + def colidir(self, outro_ator, intervalo): + self.colidir_executado = outro_ator.colidir_executado = True + self.intervalo_colisao = outro_ator.intervalo_colisao = intervalo + + def caracter(self): + return ' ' + + +class ObstaculoFake(AtorFake): + pass + + +class PorcoFake(AtorFake): + pass + + +class PassaroFake(AtorFake): + def __init__(self, x=0, y=0): + super().__init__(x, y) + self._lancado = False + self.colidir_com_chao_executado = False + + def foi_lancado(self): + return self._lancado + + def lancar(self, angulo, tempo): + if self._lancado: + raise DuploLancamentoExcecao() + self._lancado = True + + def colidir_com_chao(self): + self.colidir_com_chao_executado = True + + +class FaseTestes(TestCase): + def teste_adicionar_obstaculo(self): + fase = Fase() + self.assertListEqual([], fase._obstaculos) + obstaculo = ObstaculoFake() + fase.adicionar_obstaculo(obstaculo) + self.assertListEqual([obstaculo], fase._obstaculos) + + obstaculo1, obstaculo2 = ObstaculoFake(), ObstaculoFake() + fase.adicionar_obstaculo(obstaculo1, obstaculo2) + self.assertListEqual([obstaculo, obstaculo1, obstaculo2], + fase._obstaculos) + + def teste_adicionar_porco(self): + fase = Fase() + self.assertListEqual([], fase._porcos) + porco = PorcoFake() + fase.adicionar_porco(porco) + self.assertListEqual([porco], fase._porcos) + + porco1, porco2 = PorcoFake(), PorcoFake() + fase.adicionar_porco(porco1, porco2) + self.assertListEqual([porco, porco1, porco2], fase._porcos) + + def teste_adicionar_passaro(self): + fase = Fase() + self.assertListEqual([], fase._passaros) + passaro = PassaroFake() + fase.adicionar_passaro(passaro) + self.assertListEqual([passaro], fase._passaros) + + passaro1, passaro2 = PassaroFake(), PassaroFake() + fase.adicionar_passaro(passaro1, passaro2) + self.assertListEqual([passaro, passaro1, passaro2], fase._passaros) + + def teste_acabou_sem_porcos(self): + fase = Fase() + self.assertEqual(VITORIA, fase.status()) + + 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 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') + + 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 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 = 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_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) diff --git a/testes/testes_integracao.py b/testes/testes_integracao.py new file mode 100644 index 000000000..11f2f0178 --- /dev/null +++ b/testes/testes_integracao.py @@ -0,0 +1,188 @@ +# -*- coding: utf-8 -*- +from itertools import chain + +import os +from os import path +from unittest.case import TestCase +import math +import sys + +project_dir = path.dirname(__file__) +project_dir = path.join('..') +sys.path.append(project_dir) +from placa_grafica_tkinter import rodar_fase + +project_dir = os.path.join(os.path.dirname(__file__), '..') +project_dir = os.path.normpath(project_dir) +sys.path.append(project_dir) + +from atores import Obstaculo, Porco, PassaroVermelho, PassaroAmarelo, DESTRUIDO, ATIVO, \ + Ator, Passaro +from fase import Fase, Ponto, EM_ANDAMENTO, VITORIA, DERROTA + +class FaseTestes(TestCase): + 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_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 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_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_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_calcular_pontos(self): + fase_exemplo = criar_fase_exemplo() + expected = set([Ponto(3, 3, 'A'), Ponto(3, 3, 'A'), Ponto(31, 10, 'O'), Ponto(78, 1, '@'), + Ponto(70, 1, '@'), Ponto(3, 3, 'V')]) + self.assertSetEqual(expected, set(fase_exemplo.calcular_pontos(0))) + + fase_exemplo.lancar(45, 1) + + # i variando de 1 até 2.9 + for i in range(100, 300, 1): + fase_exemplo.calcular_pontos(i / 100) + + fase_exemplo.lancar(63, 3) + + # i variando de 3 até 3.9 + for i in range(300, 400, 1): + fase_exemplo.calcular_pontos(i / 100) + + fase_exemplo.lancar(23, 4) + + expected = set([Ponto(32, 11, 'v'), Ponto(17, 25, 'A'), Ponto(3, 3, 'A'), Ponto(31, 10, ' '), Ponto(78, 1, '@'), + Ponto(70, 1, '@')]) + + self.assertSetEqual(expected, set(fase_exemplo.calcular_pontos(4))) + + # i variando de 4 até 6.9 + for i in range(400, 700, 1): + fase_exemplo.calcular_pontos(i / 100) + + expected = set( + [Ponto(32, 11, 'v'), Ponto(57, 30, 'A'), Ponto(70, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '@'), + Ponto(70, 1, '+')]) + + self.assertSetEqual(expected, set(fase_exemplo.calcular_pontos(7))) + + # i variando de 7 até 8.49 + for i in range(700, 849, 1): + fase_exemplo.calcular_pontos(i / 100) + print(fase_exemplo.calcular_pontos(8.5)) + + expected = set([Ponto(32, 11, 'v'), Ponto(77, 0, 'a'), Ponto(70, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '+'), + Ponto(70, 1, '+')]) + + self.assertSetEqual(expected, set(fase_exemplo.calcular_pontos(8.5))) + + self.assertEqual(VITORIA, fase_exemplo.status()) + + +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 + + +if __name__ == '__main__': + rodar_fase(criar_fase_exemplo(10))