From d1848dd4e7c2a5c999d4f3a9ca7ce22c6c5e9f5c Mon Sep 17 00:00:00 2001 From: ayslanleal Date: Sat, 24 Jul 2021 11:16:16 -0300 Subject: [PATCH 1/6] Adicionando GoF --- fase.py | 2 +- oo/__init__.py | 0 oo/pessoa.py | 37 +++++++++++++++++++++++++++++++++++++ oo/teste_carro.py | 8 ++++++++ 4 files changed, 46 insertions(+), 1 deletion(-) create mode 100644 oo/__init__.py create mode 100644 oo/pessoa.py create mode 100644 oo/teste_carro.py diff --git a/fase.py b/fase.py index 3385175c6..c99a6363c 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): """ diff --git a/oo/__init__.py b/oo/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/oo/pessoa.py b/oo/pessoa.py new file mode 100644 index 000000000..ad7d22c5f --- /dev/null +++ b/oo/pessoa.py @@ -0,0 +1,37 @@ + +class Pessoa: + olhos = 3 + def __init__(self,*filhos, nome=None, idade=35): + self.nome = nome + self.idade = idade + self.filhos = list(filhos) + + def cumprimentar(self): + return 'Olá' + + @staticmethod + def metodo_estatico(): + return 4 + + @classmethod + def nome_e_atributos_de_classe(cls): + return f'{cls} - olhos: {cls.olhos}' + +class Homem(Pessoa): + pass + +class Mutante(Pessoa): + olhos = 3 + + + +if __name__ == '__main__': + luciano = Pessoa(nome='Luciano') + renzo = Pessoa(luciano,nome='Renzo') + print(luciano.cumprimentar()) + print(luciano.nome) + for i in renzo.filhos: + print(renzo.nome) + print(luciano.nome_e_atributos_de_classe()) + print(luciano.metodo_estatico()) + diff --git a/oo/teste_carro.py b/oo/teste_carro.py new file mode 100644 index 000000000..6c8957f6d --- /dev/null +++ b/oo/teste_carro.py @@ -0,0 +1,8 @@ +from unittest import TestCase +from oo.carro import Motor + +class CarroTesteCase(TestCase): + def test_velocidade_inicial(self): + motor = Motor() + self.assertEqual(0,motor.velocidade) + From 29809ad05710a402da71194abc8f38777595956c Mon Sep 17 00:00:00 2001 From: ayslanleal Date: Sat, 24 Jul 2021 11:18:21 -0300 Subject: [PATCH 2/6] Adicionando GoF --- oo/carro.py | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 oo/carro.py diff --git a/oo/carro.py b/oo/carro.py new file mode 100644 index 000000000..7739c6b6c --- /dev/null +++ b/oo/carro.py @@ -0,0 +1,71 @@ +class Motor: + velocidade = 0 + + @classmethod + def acelerar(cls): + cls.velocidade += 1 + return cls.velocidade + + @classmethod + def frear(cls): + cls.velocidade -= 2 + cls.velocidade = max(0, cls.velocidade) + return cls.velocidade + +class Direcao: + valor = 'Norte' + @classmethod + def girar_a_direita(cls): + if cls.valor == 'Norte': + cls.valor = 'Leste' + return cls.valor + if cls.valor == 'Sul': + cls.valor = 'Oeste' + return cls.valor + if cls.valor == 'Oeste': + cls.valor = 'Norte' + return cls.valor + if cls.valor == 'Leste': + cls.valor = 'Sul' + return cls.valor + + + @classmethod + def girar_a_esquerda(cls): + if cls.valor == 'Norte': + cls.valor = 'Oeste' + return cls.valor + if cls.valor == 'Oeste': + cls.valor = 'Sul' + return cls.valor + if cls.valor == 'Sul': + cls.valor = 'Leste' + return cls.valor + if cls.valor == 'Leste': + cls.valor = 'Norte' + return cls.valor + +class Carro: + + def __init__(self, direcao,motor): + self.direcao = direcao + self.motor = motor + +if __name__ == '__main__': + motor = Motor() + print(motor.velocidade) + motor.acelerar() + print(motor.velocidade) + motor.acelerar() + motor.acelerar() + print(motor.velocidade) + motor.frear() + print(motor.velocidade) + + direcao = Direcao() + print(direcao.valor) + direcao.girar_a_direita() + print(direcao.valor) + + carro = Carro(direcao,motor) + From 471c7c896332b93f6b505b7908c6b9909b1983a3 Mon Sep 17 00:00:00 2001 From: ayslanleal Date: Sat, 24 Jul 2021 11:29:34 -0300 Subject: [PATCH 3/6] =?UTF-8?q?Adicionando=20GoF=20e=20outros=20padr=C3=B5?= =?UTF-8?q?es?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- oo/pessoa.py | 1 + placa_grafica_tkinter.py | 1 + testes/atores_testes.py | 2 ++ 3 files changed, 4 insertions(+) diff --git a/oo/pessoa.py b/oo/pessoa.py index ad7d22c5f..b0794258b 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -6,6 +6,7 @@ def __init__(self,*filhos, nome=None, idade=35): self.idade = idade self.filhos = list(filhos) + def cumprimentar(self): return 'Olá' diff --git a/placa_grafica_tkinter.py b/placa_grafica_tkinter.py index 318542e65..f999ea92b 100644 --- a/placa_grafica_tkinter.py +++ b/placa_grafica_tkinter.py @@ -13,6 +13,7 @@ root = Tk() + IMAGES_PATH = path.dirname(__file__) IMAGES_PATH = path.join(IMAGES_PATH, 'images') PASSARO_VERMELHO = PhotoImage(file=path.join(IMAGES_PATH, "passaro_vermelho.gif")) diff --git a/testes/atores_testes.py b/testes/atores_testes.py index f4254f29e..8261ad9e6 100644 --- a/testes/atores_testes.py +++ b/testes/atores_testes.py @@ -24,6 +24,8 @@ def teste_valores_padrao(self): 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) From 66f4ea447d37bd491ba67ce2f69e45454e107fa3 Mon Sep 17 00:00:00 2001 From: ayslanleal Date: Sat, 24 Jul 2021 11:36:53 -0300 Subject: [PATCH 4/6] simples --- .gitignore | 110 +-- .gitpod.Dockerfile | 14 +- .gitpod.yml | 12 +- LICENSE | 40 +- README.md | 424 ++++----- atores.py | 278 +++--- executor_de_testes.py | 28 +- fase.py | 214 ++--- fases/__init__.py | 6 +- fases/brasil.py | 86 +- fases/escudo_espartano.py | 84 +- fases/rodar_fase_exemplo.py | 64 +- images/__init__.py | 6 +- oo/carro.py | 142 +-- oo/pessoa.py | 76 +- oo/teste_carro.py | 16 +- placa_grafica.py | 314 +++---- placa_grafica_tkinter.py | 308 +++---- python_birds.py | 42 +- templates.py | 308 +++---- testes/__init__.py | 4 +- testes/atores_testes.py | 1532 ++++++++++++++++---------------- testes/fase_testes.py | 424 ++++----- testes/integracao.py | 376 ++++---- testes/testes_placa_grafica.py | 82 +- 25 files changed, 2495 insertions(+), 2495 deletions(-) diff --git a/.gitignore b/.gitignore index 6220a9500..140e887a9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,55 +1,55 @@ -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] - -# C extensions -*.so - -# Distribution / packaging -.Python -env/ -bin/ -build/ -develop-eggs/ -dist/ -eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -*.egg-info/ -.installed.cfg -*.egg - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.coverage -.cache -nosetests.xml -coverage.xml - -# Translations -*.mo - -# Mr Developer -.mr.developer.cfg -.project -.pydevproject -.idea - -# Rope -.ropeproject - -# Django stuff: -*.log -*.pot - -# Sphinx documentation -docs/_build/ - +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +bin/ +build/ +develop-eggs/ +dist/ +eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.cache +nosetests.xml +coverage.xml + +# Translations +*.mo + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject +.idea + +# Rope +.ropeproject + +# Django stuff: +*.log +*.pot + +# Sphinx documentation +docs/_build/ + diff --git a/.gitpod.Dockerfile b/.gitpod.Dockerfile index f8e49f267..68d3be237 100644 --- a/.gitpod.Dockerfile +++ b/.gitpod.Dockerfile @@ -1,7 +1,7 @@ -FROM gitpod/workspace-full - -# Install custom tools, runtimes, etc. -# For example "bastet", a command-line tetris clone: -# RUN brew install bastet -# -# More information: https://www.gitpod.io/docs/config-docker/ +FROM gitpod/workspace-full + +# Install custom tools, runtimes, etc. +# For example "bastet", a command-line tetris clone: +# RUN brew install bastet +# +# More information: https://www.gitpod.io/docs/config-docker/ diff --git a/.gitpod.yml b/.gitpod.yml index 475c7d9ad..dd6761f51 100644 --- a/.gitpod.yml +++ b/.gitpod.yml @@ -1,6 +1,6 @@ -image: - file: .gitpod.Dockerfile - -tasks: - - init: 'echo "TODO: Replace with init/build command"' - command: 'echo "TODO: Replace with command to start project"' +image: + file: .gitpod.Dockerfile + +tasks: + - init: 'echo "TODO: Replace with init/build command"' + command: 'echo "TODO: Replace with command to start project"' diff --git a/LICENSE b/LICENSE index 34bff201c..c6038eaea 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,21 @@ -The MIT License (MIT) - -Copyright (c) 2014 Python.pro.br - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +The MIT License (MIT) + +Copyright (c) 2014 Python.pro.br + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md index cbb6dfb5e..16cffa060 100644 --- a/README.md +++ b/README.md @@ -1,212 +1,212 @@ -[![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/pythonprobr/pythonbirds) - -Python Birds -=========== - -Essa versão é a mais simples. Ela não contém replay nem reset, de forma que o jogo não pode retroceder. - -Para versão mais complexa, acesse a branch [diversao](https://github.com/pythonprobr/pythonbirds/tree/diversao) - -Projeto para Ensino de Programação Orientadas a Objetos em Python. - -A versão utilizada para desenvolvimento foi Python 3.4 - -Um vídeo fala mais que 1000 palavras: [Python Birds](https://www.youtube.com/watch?v=b899h0lNd7U&list=PLA05yVJtRWYTm0sIa6n56UpCjCsR5ekla) - -# Contribuidores - -* [Giovane Liberato](https://github.com/giovaneliberato) -* [Guido Luz](https://github.com/GuidoBR) -* [Michel Amaral](https://github.com/michelamaral) -* [Renzo Nuccitelli](https://github.com/renzon) - -# Abordagem - -Instalar [Python 3](https://www.python.org/download/). - -Baixar o zip do projeto (botão Download Zip) - -Os testes se encontram dentro do pacote "testes" e servem para definir a dinâmica das classes. Para rodar todos testes, execute: - - python executor_de_testes.py - -Explicação detalhada sobre classes e métodos se encontram nos scripts atores.py e fase.py. - -## Ordem de desenvolvimento - -A ordem preferida é começar pelos atores, seguindo a ordem dos testes presentes no script atores_testes.py. -Depois passar para a fase_teste.py, onde é implementada uma fase. - -É possível emular um jogo que termina em vitória rodando: - - python fase_testes.py - -É possível jogar a fase rodando: - - python placa_grafica_tkinter.py - -Para jogar, utilize as setas para cima e para baixo. Para lançar, utilize a tecla enter ou espaço. -Demonstração nos vídeos: - -[Python Birds](https://www.youtube.com/watch?v=b899h0lNd7U&list=PLA05yVJtRWYTm0sIa6n56UpCjCsR5ekla) - -## script atores.py - -Contém todos atores do projeto. - -## script fase.py - -Contém classes respectivas a fase e ponto do plano cartesiano - -## script placa_grafica.py - -Contém lógica para rodar jogo e exibir no console. - -## script placa_grafica_tkinter.py - -Contém lógica para rodar jogo em uma janela. - -# Simplificação do Jogo - -1. Atores são pontos no plano cartesiano. -2. A velocidade dos pontos é pequena, de tal forma que a cada passo os atores se movam apenas para pontos vizinhos. -3. A colisão entre pontos ocorre quando eles estão em ponto vizinho, de acordo com valor de intervalo. - -A seguir é apresentada a especificação detalhada do jogo. - -## Classe Ator - -Classe base para todos atores do jogo. - -### Método calcular_posicao - -Método que recebe o tempo (float) como parâmetro e retorna uma tupla com 2 elementos, posição horizontal (x) como -primeiro elemento e posição vertical (y) como segundo. - -### Método colidir - -O método colidir executa a lógica de colisão. A colisão só ocorre com atores ativos e que estejam -em pontos vizinhos. Ao colidir, os atores envolvidos devem ter seus status alterado para DESTRUIDO - -## Classe Obstaculo - -Classe que representa obstáculos na fase e que podem ser destruídos por pássaros. Herda de ator. Seu caracter de -representação é a letra "O", quando ATIVO. - -### Status - -Um obstáculo ao ter seu status alterado para DESTRUIDO deve ter seu caracter de apresentação alterado para " " (vazio). -Assim ele vai "sumir" da tela. - -## Classe Porco - -Classe que representa porcos na fase e que podem ser destruídos por pássaros. Herda de ator. Seu caracter de -representação é a o caracter "@". - -### Status - -Um obstáculo ao ter seu status alterado para DESTRUIDO deve ter seu caracter de apresentação alterado para "+" (sinal de mais). -Assim sua imagem é alterada para a de porco morto. - -## Passaro - -Classe base de todos os passáros. Cada tipo possui uma velocidade de lançamento (v). No lançamento o jogador escolhe o -ângulo (teta), em graus, no qual o passáro deve ser lançado. O lançamento respeita as regras de lançamento oblíquo com -gravidade (GRAVIDADE) constante e igual a 10 m/s^2. - -### Método lancar - -O método lançar recebe o ângulo, em graus, que será feito o lançamento. Ele deve ser convertido para radianos. -Cada pássaro deve armazenar esse valor e o tempo -de lançamento para cálculo de sua posíção. Lembrar que o tempo das fórmulas é delta_t = T_final - T_inicial. - - -### Método de colidir_com_chao - -Todo pássaro que colidir com o chão (y<=0) deve ser destruído. - -### Método foi_lançado - -Esse método deve retornar verdadadeiro se o pássaro foi lançado (tempo de lançamento é None). -Caso contrário deve retornar falso. - -### Lançamento - -Se o pássaro ainda não foi lançado, o pássaro deve permanecer na posição inicial. - -Caso tenha sido lançado e seu status esteja ATIVO, sua posição deve ser calculada de acordo com o lançamento oblíquo. -Nesse caso, delta_t vai ser igual ao tempo do jogo menos o tempo do lançamento. - -Caso contrário, ele deve retornar a posição onde colidiu. - -#### Método posicao_horizontal - -Fórmula X=X0+v\*cos(teta)\*delta_t. - -#### Método posicao_vertical - -Fórmula Y=Y0+v\*sen(teta)delta_t-(G\*delta_t^2)/2. - - -## Classe Passaro Vermelho - -Tipo de Pássaro que representa o pássaro vermelho. Possui velocidade de lançamento igual a 20 m/s. -Seu caracter quanto ATIVO é "V". Quando DESTRUIDO é "v". - -## Classe Passaro Amarelo - -Tipo de Pássaro que representa o pássaro amarelo. Possui velocidade de lançamento igual a 30 m/s. -Seu caracter quanto DESTRUIDO é "a". - -## Classe Fase - -Classe responsável por organizar atores e transformar os dados em pontos a serem representados na tela. - -### Método adicionar_obstaculo - -Método que adiciona um ou mais obstáculos na fase. - -### Método adicionar_porco - -Método que adiciona um ou mais porcos na fase. - -### Método adicionar_passaro - -Método que adiciona um ou mais pássaros na fase. - - -### Método status - -Recebe o tempo como parâmetro e retorna status do jogo. - -1. Se o jogo está em andamento, retorna status "EM_ANDAMENTO"; -2. Se o jogo acabou e não existem porcos ativos, retorna STATUS "VITORIA"; -3. Se o jogo acabou e existem porcos ativos, retorna status "DERROTA". - -### Método lancar - -Recebe o ângulo e o tempo do lançamento. Deve delegar o lançamento ao primeiro pássaro ATIVO da lista de pássaros que -ainda não foi lançado. - -### Método calcular_pontos - -Método que executa a lógica do jogo a cada passo (tempo), retornando pontos a serem exibidos na tela. - -Ele deve: - -1. Calcular a posição de cada pássaro, verificando se ele colidiu com algum obstáculo, porco ou chão. -2. Retornar instâncias da classe Ponto, informando x, y e caracter respectivo a cada ator. - -### Divirta-se!!!! - -Powered by [Python Pro](http://adm.python.pro.br) - -# Observação Importante - -Esse projeto usa somente o interpretador padrão do Python. Para fazer jogos com mais interatividade, existe a biblioteca Pygame. Ela não foi utilizada por motivos de simplicidade, para evitar que o aluno iniciante tenha dificuldades na hora de instalar o projeto. - -Contudo o Estevão Fonseca fez um versão com essa biblioteca, confira o projeto: - - - -Ele também colocou esse [vídeo no Youtube](https://www.youtube.com/watch?v=B7G5JtCFepE). +[![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/pythonprobr/pythonbirds) + +Python Birds +=========== + +Essa versão é a mais simples. Ela não contém replay nem reset, de forma que o jogo não pode retroceder. + +Para versão mais complexa, acesse a branch [diversao](https://github.com/pythonprobr/pythonbirds/tree/diversao) + +Projeto para Ensino de Programação Orientadas a Objetos em Python. + +A versão utilizada para desenvolvimento foi Python 3.4 + +Um vídeo fala mais que 1000 palavras: [Python Birds](https://www.youtube.com/watch?v=b899h0lNd7U&list=PLA05yVJtRWYTm0sIa6n56UpCjCsR5ekla) + +# Contribuidores + +* [Giovane Liberato](https://github.com/giovaneliberato) +* [Guido Luz](https://github.com/GuidoBR) +* [Michel Amaral](https://github.com/michelamaral) +* [Renzo Nuccitelli](https://github.com/renzon) + +# Abordagem + +Instalar [Python 3](https://www.python.org/download/). + +Baixar o zip do projeto (botão Download Zip) + +Os testes se encontram dentro do pacote "testes" e servem para definir a dinâmica das classes. Para rodar todos testes, execute: + + python executor_de_testes.py + +Explicação detalhada sobre classes e métodos se encontram nos scripts atores.py e fase.py. + +## Ordem de desenvolvimento + +A ordem preferida é começar pelos atores, seguindo a ordem dos testes presentes no script atores_testes.py. +Depois passar para a fase_teste.py, onde é implementada uma fase. + +É possível emular um jogo que termina em vitória rodando: + + python fase_testes.py + +É possível jogar a fase rodando: + + python placa_grafica_tkinter.py + +Para jogar, utilize as setas para cima e para baixo. Para lançar, utilize a tecla enter ou espaço. +Demonstração nos vídeos: + +[Python Birds](https://www.youtube.com/watch?v=b899h0lNd7U&list=PLA05yVJtRWYTm0sIa6n56UpCjCsR5ekla) + +## script atores.py + +Contém todos atores do projeto. + +## script fase.py + +Contém classes respectivas a fase e ponto do plano cartesiano + +## script placa_grafica.py + +Contém lógica para rodar jogo e exibir no console. + +## script placa_grafica_tkinter.py + +Contém lógica para rodar jogo em uma janela. + +# Simplificação do Jogo + +1. Atores são pontos no plano cartesiano. +2. A velocidade dos pontos é pequena, de tal forma que a cada passo os atores se movam apenas para pontos vizinhos. +3. A colisão entre pontos ocorre quando eles estão em ponto vizinho, de acordo com valor de intervalo. + +A seguir é apresentada a especificação detalhada do jogo. + +## Classe Ator + +Classe base para todos atores do jogo. + +### Método calcular_posicao + +Método que recebe o tempo (float) como parâmetro e retorna uma tupla com 2 elementos, posição horizontal (x) como +primeiro elemento e posição vertical (y) como segundo. + +### Método colidir + +O método colidir executa a lógica de colisão. A colisão só ocorre com atores ativos e que estejam +em pontos vizinhos. Ao colidir, os atores envolvidos devem ter seus status alterado para DESTRUIDO + +## Classe Obstaculo + +Classe que representa obstáculos na fase e que podem ser destruídos por pássaros. Herda de ator. Seu caracter de +representação é a letra "O", quando ATIVO. + +### Status + +Um obstáculo ao ter seu status alterado para DESTRUIDO deve ter seu caracter de apresentação alterado para " " (vazio). +Assim ele vai "sumir" da tela. + +## Classe Porco + +Classe que representa porcos na fase e que podem ser destruídos por pássaros. Herda de ator. Seu caracter de +representação é a o caracter "@". + +### Status + +Um obstáculo ao ter seu status alterado para DESTRUIDO deve ter seu caracter de apresentação alterado para "+" (sinal de mais). +Assim sua imagem é alterada para a de porco morto. + +## Passaro + +Classe base de todos os passáros. Cada tipo possui uma velocidade de lançamento (v). No lançamento o jogador escolhe o +ângulo (teta), em graus, no qual o passáro deve ser lançado. O lançamento respeita as regras de lançamento oblíquo com +gravidade (GRAVIDADE) constante e igual a 10 m/s^2. + +### Método lancar + +O método lançar recebe o ângulo, em graus, que será feito o lançamento. Ele deve ser convertido para radianos. +Cada pássaro deve armazenar esse valor e o tempo +de lançamento para cálculo de sua posíção. Lembrar que o tempo das fórmulas é delta_t = T_final - T_inicial. + + +### Método de colidir_com_chao + +Todo pássaro que colidir com o chão (y<=0) deve ser destruído. + +### Método foi_lançado + +Esse método deve retornar verdadadeiro se o pássaro foi lançado (tempo de lançamento é None). +Caso contrário deve retornar falso. + +### Lançamento + +Se o pássaro ainda não foi lançado, o pássaro deve permanecer na posição inicial. + +Caso tenha sido lançado e seu status esteja ATIVO, sua posição deve ser calculada de acordo com o lançamento oblíquo. +Nesse caso, delta_t vai ser igual ao tempo do jogo menos o tempo do lançamento. + +Caso contrário, ele deve retornar a posição onde colidiu. + +#### Método posicao_horizontal + +Fórmula X=X0+v\*cos(teta)\*delta_t. + +#### Método posicao_vertical + +Fórmula Y=Y0+v\*sen(teta)delta_t-(G\*delta_t^2)/2. + + +## Classe Passaro Vermelho + +Tipo de Pássaro que representa o pássaro vermelho. Possui velocidade de lançamento igual a 20 m/s. +Seu caracter quanto ATIVO é "V". Quando DESTRUIDO é "v". + +## Classe Passaro Amarelo + +Tipo de Pássaro que representa o pássaro amarelo. Possui velocidade de lançamento igual a 30 m/s. +Seu caracter quanto DESTRUIDO é "a". + +## Classe Fase + +Classe responsável por organizar atores e transformar os dados em pontos a serem representados na tela. + +### Método adicionar_obstaculo + +Método que adiciona um ou mais obstáculos na fase. + +### Método adicionar_porco + +Método que adiciona um ou mais porcos na fase. + +### Método adicionar_passaro + +Método que adiciona um ou mais pássaros na fase. + + +### Método status + +Recebe o tempo como parâmetro e retorna status do jogo. + +1. Se o jogo está em andamento, retorna status "EM_ANDAMENTO"; +2. Se o jogo acabou e não existem porcos ativos, retorna STATUS "VITORIA"; +3. Se o jogo acabou e existem porcos ativos, retorna status "DERROTA". + +### Método lancar + +Recebe o ângulo e o tempo do lançamento. Deve delegar o lançamento ao primeiro pássaro ATIVO da lista de pássaros que +ainda não foi lançado. + +### Método calcular_pontos + +Método que executa a lógica do jogo a cada passo (tempo), retornando pontos a serem exibidos na tela. + +Ele deve: + +1. Calcular a posição de cada pássaro, verificando se ele colidiu com algum obstáculo, porco ou chão. +2. Retornar instâncias da classe Ponto, informando x, y e caracter respectivo a cada ator. + +### Divirta-se!!!! + +Powered by [Python Pro](http://adm.python.pro.br) + +# Observação Importante + +Esse projeto usa somente o interpretador padrão do Python. Para fazer jogos com mais interatividade, existe a biblioteca Pygame. Ela não foi utilizada por motivos de simplicidade, para evitar que o aluno iniciante tenha dificuldades na hora de instalar o projeto. + +Contudo o Estevão Fonseca fez um versão com essa biblioteca, confira o projeto: + + + +Ele também colocou esse [vídeo no Youtube](https://www.youtube.com/watch?v=B7G5JtCFepE). diff --git a/atores.py b/atores.py index cfc2ef5ea..db773eef5 100644 --- a/atores.py +++ b/atores.py @@ -1,140 +1,140 @@ -# -*- coding: utf-8 -*- - -from __future__ import unicode_literals - -import math - -DESTRUIDO = 'Destruido' -ATIVO = 'Ativo' -GRAVIDADE = 10 # m/s^2 - - -class Ator(): - """ - Classe que representa um ator. Ele representa um ponto cartesiano na tela. - """ - _caracter_ativo = 'A' - _caracter_destruido = ' ' - - def __init__(self, x=0, y=0): - """ - Método de inicialização da classe. Deve inicializar os parâmetros x, y, caracter e status - - :param x: Posição horizontal inicial do ator - :param y: Posição vertical inicial do ator - """ - self.y = y - self.x = x - self.status = ATIVO - - def caracter(self): - return self._caracter_ativo if self.status == ATIVO else self._caracter_destruido - - def calcular_posicao(self, tempo): - """ - Método que calcula a posição do ator em determinado tempo. - Deve-se imaginar que o tempo começa em 0 e avança de 0,01 segundos - - :param tempo: o tempo do jogo - :return: posição x, y do ator - """ - return 1, 1 - - def colidir(self, outro_ator, intervalo=1): - """ - Método que executa lógica de colisão entre dois atores. - Só deve haver colisão se os dois atores tiverem seus status ativos. - Para colisão, é considerado um quadrado, com lado igual ao parâmetro intervalo, em volta do ponto onde se - encontra o ator. Se os atores estiverem dentro desse mesmo quadrado, seus status devem ser alterados para - destruido, seus caracteres para destruido também. - - :param outro_ator: Ator a ser considerado na colisão - :param intervalo: Intervalo a ser considerado - :return: - """ - pass - - - -class Obstaculo(Ator): - pass - - -class Porco(Ator): - pass - - -class DuploLancamentoExcecao(Exception): - pass - - -class Passaro(Ator): - velocidade_escalar = 10 - - def __init__(self, x=0, y=0): - """ - Método de inicialização de pássaro. - - Deve chamar a inicialização de ator. Além disso, deve armazenar a posição inicial e incializar o tempo de - lançamento e angulo de lançamento - - :param x: - :param y: - """ - super().__init__(x, y) - self._x_inicial = x - self._y_inicial = y - self._tempo_de_lancamento = None - self._angulo_de_lancamento = None # radianos - - def foi_lancado(self): - """ - Método que retorna verdaeira se o pássaro já foi lançado e falso caso contrário - - :return: booleano - """ - return True - - def colidir_com_chao(self): - """ - Método que executa lógica de colisão com o chão. Toda vez que y for menor ou igual a 0, - o status dos Passaro deve ser alterado para destruido, bem como o seu caracter - - """ - pass - - def calcular_posicao(self, tempo): - """ - Método que cálcula a posição do passaro de acordo com o tempo. - - Antes do lançamento o pássaro deve retornar o valor de sua posição inicial - - Depois do lançamento o pássaro deve calcular de acordo com sua posição inicial, velocidade escalar, - ângulo de lancamento, gravidade (constante GRAVIDADE) e o tempo do jogo. - - Após a colisão, ou seja, ter seus status destruido, o pássaro deve apenas retornar a última posição calculada. - - :param tempo: tempo de jogo a ser calculada a posição - :return: posição x, y - """ - return 1, 1 - - - def lancar(self, angulo, tempo_de_lancamento): - """ - Lógica que lança o pássaro. Deve armazenar o ângulo e o tempo de lançamento para posteriores cálculo. - O ângulo é passado em graus e deve ser transformado em radianos - - :param angulo: - :param tempo_de_lancamento: - :return: - """ - pass - - -class PassaroAmarelo(Passaro): - pass - - -class PassaroVermelho(Passaro): +# -*- coding: utf-8 -*- + +from __future__ import unicode_literals + +import math + +DESTRUIDO = 'Destruido' +ATIVO = 'Ativo' +GRAVIDADE = 10 # m/s^2 + + +class Ator(): + """ + Classe que representa um ator. Ele representa um ponto cartesiano na tela. + """ + _caracter_ativo = 'A' + _caracter_destruido = ' ' + + def __init__(self, x=0, y=0): + """ + Método de inicialização da classe. Deve inicializar os parâmetros x, y, caracter e status + + :param x: Posição horizontal inicial do ator + :param y: Posição vertical inicial do ator + """ + self.y = y + self.x = x + self.status = ATIVO + + def caracter(self): + return self._caracter_ativo if self.status == ATIVO else self._caracter_destruido + + def calcular_posicao(self, tempo): + """ + Método que calcula a posição do ator em determinado tempo. + Deve-se imaginar que o tempo começa em 0 e avança de 0,01 segundos + + :param tempo: o tempo do jogo + :return: posição x, y do ator + """ + return 1, 1 + + def colidir(self, outro_ator, intervalo=1): + """ + Método que executa lógica de colisão entre dois atores. + Só deve haver colisão se os dois atores tiverem seus status ativos. + Para colisão, é considerado um quadrado, com lado igual ao parâmetro intervalo, em volta do ponto onde se + encontra o ator. Se os atores estiverem dentro desse mesmo quadrado, seus status devem ser alterados para + destruido, seus caracteres para destruido também. + + :param outro_ator: Ator a ser considerado na colisão + :param intervalo: Intervalo a ser considerado + :return: + """ + pass + + + +class Obstaculo(Ator): + pass + + +class Porco(Ator): + pass + + +class DuploLancamentoExcecao(Exception): + pass + + +class Passaro(Ator): + velocidade_escalar = 10 + + def __init__(self, x=0, y=0): + """ + Método de inicialização de pássaro. + + Deve chamar a inicialização de ator. Além disso, deve armazenar a posição inicial e incializar o tempo de + lançamento e angulo de lançamento + + :param x: + :param y: + """ + super().__init__(x, y) + self._x_inicial = x + self._y_inicial = y + self._tempo_de_lancamento = None + self._angulo_de_lancamento = None # radianos + + def foi_lancado(self): + """ + Método que retorna verdaeira se o pássaro já foi lançado e falso caso contrário + + :return: booleano + """ + return True + + def colidir_com_chao(self): + """ + Método que executa lógica de colisão com o chão. Toda vez que y for menor ou igual a 0, + o status dos Passaro deve ser alterado para destruido, bem como o seu caracter + + """ + pass + + def calcular_posicao(self, tempo): + """ + Método que cálcula a posição do passaro de acordo com o tempo. + + Antes do lançamento o pássaro deve retornar o valor de sua posição inicial + + Depois do lançamento o pássaro deve calcular de acordo com sua posição inicial, velocidade escalar, + ângulo de lancamento, gravidade (constante GRAVIDADE) e o tempo do jogo. + + Após a colisão, ou seja, ter seus status destruido, o pássaro deve apenas retornar a última posição calculada. + + :param tempo: tempo de jogo a ser calculada a posição + :return: posição x, y + """ + return 1, 1 + + + def lancar(self, angulo, tempo_de_lancamento): + """ + Lógica que lança o pássaro. Deve armazenar o ângulo e o tempo de lançamento para posteriores cálculo. + O ângulo é passado em graus e deve ser transformado em radianos + + :param angulo: + :param tempo_de_lancamento: + :return: + """ + pass + + +class PassaroAmarelo(Passaro): + pass + + +class PassaroVermelho(Passaro): pass \ No newline at end of file diff --git a/executor_de_testes.py b/executor_de_testes.py index 6e8ba17ca..8dedf043b 100755 --- a/executor_de_testes.py +++ b/executor_de_testes.py @@ -1,14 +1,14 @@ -#!/usr/bin/env python -# coding: utf-8 - -import unittest -import sys -import os - -ROOT_PATH = os.path.dirname(__file__) - -if __name__ == '__main__': - tests = unittest.TestLoader().discover(ROOT_PATH, "*.py") - result = unittest.TextTestRunner().run(tests) - if not result.wasSuccessful(): - sys.exit(1) +#!/usr/bin/env python +# coding: utf-8 + +import unittest +import sys +import os + +ROOT_PATH = os.path.dirname(__file__) + +if __name__ == '__main__': + tests = unittest.TestLoader().discover(ROOT_PATH, "*.py") + result = unittest.TextTestRunner().run(tests) + if not result.wasSuccessful(): + sys.exit(1) diff --git a/fase.py b/fase.py index c99a6363c..cc801b528 100644 --- a/fase.py +++ b/fase.py @@ -1,107 +1,107 @@ -# -*- coding: utf-8 -*- -from itertools import chain -from atores import ATIVO - - -VITORIA = 'VITORIA' -DERROTA = 'DERROTA' -EM_ANDAMENTO = 'EM_ANDAMENTO' - - -class Ponto(): - def __init__(self, x, y, caracter): - self.caracter = caracter - self.x = round(x) - self.y = round(y) - - def __eq__(self, other): - return self.x == other.x and self.y == other.y and self.caracter == other.caracter - - def __hash__(self): - return hash(self.x) ^ hash(self.y) - - def __repr__(self, *args, **kwargs): - return "Ponto(%s,%s,'%s')" % (self.x, self.y, self.caracter) - - -class Fase(): - def __init__(self, intervalo_de_colisao=1): - """ - Método que inicializa uma fase. - - :param intervalo_de_colisao: - """ - self.intervalo_de_colisao = intervalo_de_colisao - self._passaros = [] - self._porcos = [] - self._obstaculos = [] - - - def adicionar_obstaculo(self, *obstaculos): - """ - Adiciona obstáculos em uma fase - - :param obstaculos: - """ - self._obstaculos.extend(obstaculos) - - def adicionar_porco(self, *porcos): - """ - Adiciona porcos em uma fase - - :param porcos: - """ - pass - - def adicionar_passaro(self, *passaros): - """ - Adiciona pássaros em uma fase - - :param passaros: - """ - pass - - def status(self): - """ - Método que indica com mensagem o status do jogo - - Se o jogo está em andamento (ainda tem porco ativo e pássaro ativo), retorna essa mensagem. - - Se o jogo acabou com derrota (ainda existe porco ativo), retorna essa mensagem - - Se o jogo acabou com vitória (não existe porco ativo), retorna essa mensagem - - :return: - """ - return EM_ANDAMENTO - - def lancar(self, angulo, tempo): - """ - Método que executa lógica de lançamento. - - Deve escolher o primeiro pássaro não lançado da lista e chamar seu método lançar - - Se não houver esse tipo de pássaro, não deve fazer nada - - :param angulo: ângulo de lançamento - :param tempo: Tempo de lançamento - """ - pass - - - def calcular_pontos(self, tempo): - """ - Lógica que retorna os pontos a serem exibidos na tela. - - Cada ator deve ser transformado em um Ponto. - - :param tempo: tempo para o qual devem ser calculados os pontos - :return: objeto do tipo Ponto - """ - pontos=[self._transformar_em_ponto(a) for a in self._passaros+self._obstaculos+self._porcos] - - return pontos - - def _transformar_em_ponto(self, ator): - return Ponto(ator.x, ator.y, ator.caracter()) - +# -*- coding: utf-8 -*- +from itertools import chain +from atores import ATIVO + + +VITORIA = 'VITORIA' +DERROTA = 'DERROTA' +EM_ANDAMENTO = 'EM_ANDAMENTO' + + +class Ponto(): + def __init__(self, x, y, caracter): + self.caracter = caracter + self.x = round(x) + self.y = round(y) + + def __eq__(self, other): + return self.x == other.x and self.y == other.y and self.caracter == other.caracter + + def __hash__(self): + return hash(self.x) ^ hash(self.y) + + def __repr__(self, *args, **kwargs): + return "Ponto(%s,%s,'%s')" % (self.x, self.y, self.caracter) + + +class Fase(): + def __init__(self, intervalo_de_colisao=1): + """ + Método que inicializa uma fase. + + :param intervalo_de_colisao: + """ + self.intervalo_de_colisao = intervalo_de_colisao + self._passaros = [] + self._porcos = [] + self._obstaculos = [] + + + def adicionar_obstaculo(self, *obstaculos): + """ + Adiciona obstáculos em uma fase + + :param obstaculos: + """ + self._obstaculos.extend(obstaculos) + + def adicionar_porco(self, *porcos): + """ + Adiciona porcos em uma fase + + :param porcos: + """ + pass + + def adicionar_passaro(self, *passaros): + """ + Adiciona pássaros em uma fase + + :param passaros: + """ + pass + + def status(self): + """ + Método que indica com mensagem o status do jogo + + Se o jogo está em andamento (ainda tem porco ativo e pássaro ativo), retorna essa mensagem. + + Se o jogo acabou com derrota (ainda existe porco ativo), retorna essa mensagem + + Se o jogo acabou com vitória (não existe porco ativo), retorna essa mensagem + + :return: + """ + return EM_ANDAMENTO + + def lancar(self, angulo, tempo): + """ + Método que executa lógica de lançamento. + + Deve escolher o primeiro pássaro não lançado da lista e chamar seu método lançar + + Se não houver esse tipo de pássaro, não deve fazer nada + + :param angulo: ângulo de lançamento + :param tempo: Tempo de lançamento + """ + pass + + + def calcular_pontos(self, tempo): + """ + Lógica que retorna os pontos a serem exibidos na tela. + + Cada ator deve ser transformado em um Ponto. + + :param tempo: tempo para o qual devem ser calculados os pontos + :return: objeto do tipo Ponto + """ + pontos=[self._transformar_em_ponto(a) for a in self._passaros+self._obstaculos+self._porcos] + + return pontos + + def _transformar_em_ponto(self, ator): + return Ponto(ator.x, ator.y, ator.caracter()) + diff --git a/fases/__init__.py b/fases/__init__.py index 4a574b321..85615dc0c 100644 --- a/fases/__init__.py +++ b/fases/__init__.py @@ -1,3 +1,3 @@ -# -*- coding: utf-8 -*- - -from __future__ import unicode_literals +# -*- coding: utf-8 -*- + +from __future__ import unicode_literals diff --git a/fases/brasil.py b/fases/brasil.py index cbae108bc..db14fed9f 100644 --- a/fases/brasil.py +++ b/fases/brasil.py @@ -1,44 +1,44 @@ -# -*- 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) - - - deltax_gambi=80 - # Adicionar Pássaros Amarelos - for i in range(100): - fase.adicionar_passaro(PassaroAmarelo(30, 30)) - - # linhas verticais - for i in range(30, 300, 32): - fase.adicionar_porco(Porco(700-deltax_gambi, i)) - fase.adicionar_porco(Porco(200-deltax_gambi, i)) - - # linhas horizontais - for i in range(240, 680, 32): - fase.adicionar_porco(Porco(i-deltax_gambi, 30)) - fase.adicionar_porco(Porco(i-deltax_gambi, 286)) - - x0 = 210-deltax_gambi - # losango - meio = 160 - n = 9 - delta_x = 28 - delta_y = 12 - for i in range(1, n): - fase.adicionar_porco(Porco(x0 + delta_x * i, meio + delta_y * i)) - fase.adicionar_porco(Porco(x0 + delta_x * i, meio - delta_y * i)) - fase.adicionar_porco(Porco(x0 + (n + i - 1) * delta_x, meio + (n - i) * delta_y)) - fase.adicionar_porco(Porco(x0 + (n + i - 1) * delta_x, meio + (i - n) * delta_y)) - +# -*- 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) + + + deltax_gambi=80 + # Adicionar Pássaros Amarelos + for i in range(100): + fase.adicionar_passaro(PassaroAmarelo(30, 30)) + + # linhas verticais + for i in range(30, 300, 32): + fase.adicionar_porco(Porco(700-deltax_gambi, i)) + fase.adicionar_porco(Porco(200-deltax_gambi, i)) + + # linhas horizontais + for i in range(240, 680, 32): + fase.adicionar_porco(Porco(i-deltax_gambi, 30)) + fase.adicionar_porco(Porco(i-deltax_gambi, 286)) + + x0 = 210-deltax_gambi + # losango + meio = 160 + n = 9 + delta_x = 28 + delta_y = 12 + for i in range(1, n): + fase.adicionar_porco(Porco(x0 + delta_x * i, meio + delta_y * i)) + fase.adicionar_porco(Porco(x0 + delta_x * i, meio - delta_y * i)) + fase.adicionar_porco(Porco(x0 + (n + i - 1) * delta_x, meio + (n - i) * delta_y)) + fase.adicionar_porco(Porco(x0 + (n + i - 1) * delta_x, meio + (i - n) * delta_y)) + rodar_fase(fase) \ No newline at end of file diff --git a/fases/escudo_espartano.py b/fases/escudo_espartano.py index 9b01135f0..cd218e12d 100644 --- a/fases/escudo_espartano.py +++ b/fases/escudo_espartano.py @@ -1,43 +1,43 @@ -# -*- 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: - x = 600 + (h + r * math.cos(theta)) - y = (k + r * math.sin(theta)) - fase.adicionar_obstaculo(Obstaculo(x, y)) - theta += 32 - - # Porcos - for i in range(30, 300, 32): - x = randint(590, 631) - y = randint(0, 21) - fase.adicionar_porco(Porco(x, y)) - +# -*- 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: + x = 600 + (h + r * math.cos(theta)) + y = (k + r * math.sin(theta)) + fase.adicionar_obstaculo(Obstaculo(x, y)) + theta += 32 + + # Porcos + for i in range(30, 300, 32): + x = randint(590, 631) + y = randint(0, 21) + fase.adicionar_porco(Porco(x, y)) + rodar_fase(fase) \ No newline at end of file diff --git a/fases/rodar_fase_exemplo.py b/fases/rodar_fase_exemplo.py index 0f67e4cf1..f7e683377 100644 --- a/fases/rodar_fase_exemplo.py +++ b/fases/rodar_fase_exemplo.py @@ -1,33 +1,33 @@ -# -*- 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)) - +# -*- 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) \ No newline at end of file diff --git a/images/__init__.py b/images/__init__.py index 4a574b321..85615dc0c 100644 --- a/images/__init__.py +++ b/images/__init__.py @@ -1,3 +1,3 @@ -# -*- coding: utf-8 -*- - -from __future__ import unicode_literals +# -*- coding: utf-8 -*- + +from __future__ import unicode_literals diff --git a/oo/carro.py b/oo/carro.py index 7739c6b6c..85188b7dc 100644 --- a/oo/carro.py +++ b/oo/carro.py @@ -1,71 +1,71 @@ -class Motor: - velocidade = 0 - - @classmethod - def acelerar(cls): - cls.velocidade += 1 - return cls.velocidade - - @classmethod - def frear(cls): - cls.velocidade -= 2 - cls.velocidade = max(0, cls.velocidade) - return cls.velocidade - -class Direcao: - valor = 'Norte' - @classmethod - def girar_a_direita(cls): - if cls.valor == 'Norte': - cls.valor = 'Leste' - return cls.valor - if cls.valor == 'Sul': - cls.valor = 'Oeste' - return cls.valor - if cls.valor == 'Oeste': - cls.valor = 'Norte' - return cls.valor - if cls.valor == 'Leste': - cls.valor = 'Sul' - return cls.valor - - - @classmethod - def girar_a_esquerda(cls): - if cls.valor == 'Norte': - cls.valor = 'Oeste' - return cls.valor - if cls.valor == 'Oeste': - cls.valor = 'Sul' - return cls.valor - if cls.valor == 'Sul': - cls.valor = 'Leste' - return cls.valor - if cls.valor == 'Leste': - cls.valor = 'Norte' - return cls.valor - -class Carro: - - def __init__(self, direcao,motor): - self.direcao = direcao - self.motor = motor - -if __name__ == '__main__': - motor = Motor() - print(motor.velocidade) - motor.acelerar() - print(motor.velocidade) - motor.acelerar() - motor.acelerar() - print(motor.velocidade) - motor.frear() - print(motor.velocidade) - - direcao = Direcao() - print(direcao.valor) - direcao.girar_a_direita() - print(direcao.valor) - - carro = Carro(direcao,motor) - +class Motor: + velocidade = 0 + + @classmethod + def acelerar(cls): + cls.velocidade += 1 + return cls.velocidade + + @classmethod + def frear(cls): + cls.velocidade -= 2 + cls.velocidade = max(0, cls.velocidade) + return cls.velocidade + +class Direcao: + valor = 'Norte' + @classmethod + def girar_a_direita(cls): + if cls.valor == 'Norte': + cls.valor = 'Leste' + return cls.valor + if cls.valor == 'Sul': + cls.valor = 'Oeste' + return cls.valor + if cls.valor == 'Oeste': + cls.valor = 'Norte' + return cls.valor + if cls.valor == 'Leste': + cls.valor = 'Sul' + return cls.valor + + + @classmethod + def girar_a_esquerda(cls): + if cls.valor == 'Norte': + cls.valor = 'Oeste' + return cls.valor + if cls.valor == 'Oeste': + cls.valor = 'Sul' + return cls.valor + if cls.valor == 'Sul': + cls.valor = 'Leste' + return cls.valor + if cls.valor == 'Leste': + cls.valor = 'Norte' + return cls.valor + +class Carro: + + def __init__(self, direcao,motor): + self.direcao = direcao + self.motor = motor + +if __name__ == '__main__': + motor = Motor() + print(motor.velocidade) + motor.acelerar() + print(motor.velocidade) + motor.acelerar() + motor.acelerar() + print(motor.velocidade) + motor.frear() + print(motor.velocidade) + + direcao = Direcao() + print(direcao.valor) + direcao.girar_a_direita() + print(direcao.valor) + + carro = Carro(direcao,motor) + diff --git a/oo/pessoa.py b/oo/pessoa.py index b0794258b..367a27cdf 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,38 +1,38 @@ - -class Pessoa: - olhos = 3 - def __init__(self,*filhos, nome=None, idade=35): - self.nome = nome - self.idade = idade - self.filhos = list(filhos) - - - def cumprimentar(self): - return 'Olá' - - @staticmethod - def metodo_estatico(): - return 4 - - @classmethod - def nome_e_atributos_de_classe(cls): - return f'{cls} - olhos: {cls.olhos}' - -class Homem(Pessoa): - pass - -class Mutante(Pessoa): - olhos = 3 - - - -if __name__ == '__main__': - luciano = Pessoa(nome='Luciano') - renzo = Pessoa(luciano,nome='Renzo') - print(luciano.cumprimentar()) - print(luciano.nome) - for i in renzo.filhos: - print(renzo.nome) - print(luciano.nome_e_atributos_de_classe()) - print(luciano.metodo_estatico()) - + +class Pessoa: + olhos = 3 + def __init__(self,*filhos, nome=None, idade=35): + self.nome = nome + self.idade = idade + self.filhos = list(filhos) + + + def cumprimentar(self): + return 'Olá' + + @staticmethod + def metodo_estatico(): + return 4 + + @classmethod + def nome_e_atributos_de_classe(cls): + return f'{cls} - olhos: {cls.olhos}' + +class Homem(Pessoa): + pass + +class Mutante(Pessoa): + olhos = 3 + + + +if __name__ == '__main__': + luciano = Pessoa(nome='Luciano') + renzo = Pessoa(luciano,nome='Renzo') + print(luciano.cumprimentar()) + print(luciano.nome) + for i in renzo.filhos: + print(renzo.nome) + print(luciano.nome_e_atributos_de_classe()) + print(luciano.metodo_estatico()) + diff --git a/oo/teste_carro.py b/oo/teste_carro.py index 6c8957f6d..1e45e764d 100644 --- a/oo/teste_carro.py +++ b/oo/teste_carro.py @@ -1,8 +1,8 @@ -from unittest import TestCase -from oo.carro import Motor - -class CarroTesteCase(TestCase): - def test_velocidade_inicial(self): - motor = Motor() - self.assertEqual(0,motor.velocidade) - +from unittest import TestCase +from oo.carro import Motor + +class CarroTesteCase(TestCase): + def test_velocidade_inicial(self): + motor = Motor() + self.assertEqual(0,motor.velocidade) + diff --git a/placa_grafica.py b/placa_grafica.py index 77ae67aef..5945bb798 100644 --- a/placa_grafica.py +++ b/placa_grafica.py @@ -1,157 +1,157 @@ -# -*- coding: utf-8 -*- -import os -import platform -import time -import sys -from templates import FIM - -try: - import msvcrt -except: - pass -import select - - -eh_windows = platform.system() == 'Windows' -apagar_tela = lambda: os.system('cls') if eh_windows else lambda: os.system('clear') - -# workaround retirado de http://stackoverflow.com/questions/292095/polling-the-keyboard-in-python - - -def ouvir_teclado_fn(): - i, o, e = select.select([sys.stdin], [], [], 0.0001) - for s in i: - if s == sys.stdin: - return True - return False - - -if eh_windows: - ouvir_teclado = msvcrt.kbhit -else: - ouvir_teclado = ouvir_teclado_fn - -LARGURA = 80 -ALTURA = 20 - - -def desenhar_e_esperar(delta_t, fase, passo, tempo, msg): - time.sleep(passo) - apagar_tela() - pontos_cartesianos = fase.calcular_pontos(tempo) - print('%s Tempo: %.2f' % (msg, tempo)) - print(desenhar(*pontos_cartesianos)) - tempo += delta_t - return tempo - - -def _animar(delta_t, fase, passo, tempo, msg): - while not fase.acabou(tempo): - tempo = desenhar_e_esperar(delta_t, fase, passo, tempo, msg) - return tempo - - -def _jogar(delta_t, fase, passo, tempo, msg): - while not fase.acabou(): - tempo = desenhar_e_esperar(delta_t, fase, passo, tempo, msg) - entrada = ouvir_teclado() - if entrada: - while True: - try: - if not eh_windows: - input() - angulo = float(input('Digite o Ângulo de Lançamento: ')) - fase.lancar(angulo, tempo) - break - except: - print('Erro: valor tem que ser númerico!') - return tempo - - -def rebobina(delta_t, fase, passo, tempo, msg): - while tempo > 0: - tempo = desenhar_e_esperar(-delta_t, fase, passo, tempo, msg) - return tempo - - -def animar(fase, passo=0.1, delta_t=0.1): - tempo = 0 - tempo_final = _jogar(delta_t, fase, passo, tempo, 'Play!') - if input('Deseja ver o Replay? (s para sim): ').lower() == 's': - velocidade_rebobina = 10 - rebobina(delta_t, fase, passo / velocidade_rebobina, tempo_final, - 'Rebobinando %s vezes mais rápido!' % velocidade_rebobina) - velocidade_replay = 1 - _animar(delta_t, fase, passo / velocidade_replay, tempo, 'Replay %s vezes mais rápido!' % velocidade_replay) - apagar_tela() - print(fase.status(tempo_final)) - print(FIM) - - -def normalizar_coordenadas(x, y): - return x, ALTURA - y - 1 - - -def esta_dentro_da_tela(x, y): - return 0 < x < (LARGURA - 1) and 0 < y < (ALTURA - 1) - - -def escolher_caracter_limitrofe(x, y): - if x == 0 or x == LARGURA - 1: - return '|' - if y == 0: - return '-' - return 'T' - - -def escolher_caracter(x, y, *pontos_cartesianos): - for ponto in pontos_cartesianos: - x_normalizdo, y_normalizado = normalizar_coordenadas(ponto.x, ponto.y) - if x == x_normalizdo and y == y_normalizado: - return ponto.caracter - return ' ' - - -def desenhar(*pontos_cartesianos): - frame = '' - for y in range(ALTURA): - for x in range(LARGURA): - if esta_dentro_da_tela(x, y): - frame += escolher_caracter(x, y, *pontos_cartesianos) - else: - frame += escolher_caracter_limitrofe(x, y) - frame += os.linesep - return frame - - -def main(): - global Ponto, Fase - - class Ponto(): - def __init__(self, caracter): - self.caracter = caracter - self(0) - - def __call__(self, tempo): - self.y = round(ALTURA * tempo / 5) if tempo < 5 else round(ALTURA * (10 - tempo) / 5) - self.x = round(LARGURA * tempo / 10) - return self - - class Fase(): - def __init__(self): - self.p = Ponto('>') - - def calcular_pontos(self, tempo): - return [self.p(tempo)] - - def acabou(self, tempo): - return tempo > 10 - - def status(self): - return 'Você ganhou' - - animar(Fase()) - - -if __name__ == '__main__': - main() +# -*- coding: utf-8 -*- +import os +import platform +import time +import sys +from templates import FIM + +try: + import msvcrt +except: + pass +import select + + +eh_windows = platform.system() == 'Windows' +apagar_tela = lambda: os.system('cls') if eh_windows else lambda: os.system('clear') + +# workaround retirado de http://stackoverflow.com/questions/292095/polling-the-keyboard-in-python + + +def ouvir_teclado_fn(): + i, o, e = select.select([sys.stdin], [], [], 0.0001) + for s in i: + if s == sys.stdin: + return True + return False + + +if eh_windows: + ouvir_teclado = msvcrt.kbhit +else: + ouvir_teclado = ouvir_teclado_fn + +LARGURA = 80 +ALTURA = 20 + + +def desenhar_e_esperar(delta_t, fase, passo, tempo, msg): + time.sleep(passo) + apagar_tela() + pontos_cartesianos = fase.calcular_pontos(tempo) + print('%s Tempo: %.2f' % (msg, tempo)) + print(desenhar(*pontos_cartesianos)) + tempo += delta_t + return tempo + + +def _animar(delta_t, fase, passo, tempo, msg): + while not fase.acabou(tempo): + tempo = desenhar_e_esperar(delta_t, fase, passo, tempo, msg) + return tempo + + +def _jogar(delta_t, fase, passo, tempo, msg): + while not fase.acabou(): + tempo = desenhar_e_esperar(delta_t, fase, passo, tempo, msg) + entrada = ouvir_teclado() + if entrada: + while True: + try: + if not eh_windows: + input() + angulo = float(input('Digite o Ângulo de Lançamento: ')) + fase.lancar(angulo, tempo) + break + except: + print('Erro: valor tem que ser númerico!') + return tempo + + +def rebobina(delta_t, fase, passo, tempo, msg): + while tempo > 0: + tempo = desenhar_e_esperar(-delta_t, fase, passo, tempo, msg) + return tempo + + +def animar(fase, passo=0.1, delta_t=0.1): + tempo = 0 + tempo_final = _jogar(delta_t, fase, passo, tempo, 'Play!') + if input('Deseja ver o Replay? (s para sim): ').lower() == 's': + velocidade_rebobina = 10 + rebobina(delta_t, fase, passo / velocidade_rebobina, tempo_final, + 'Rebobinando %s vezes mais rápido!' % velocidade_rebobina) + velocidade_replay = 1 + _animar(delta_t, fase, passo / velocidade_replay, tempo, 'Replay %s vezes mais rápido!' % velocidade_replay) + apagar_tela() + print(fase.status(tempo_final)) + print(FIM) + + +def normalizar_coordenadas(x, y): + return x, ALTURA - y - 1 + + +def esta_dentro_da_tela(x, y): + return 0 < x < (LARGURA - 1) and 0 < y < (ALTURA - 1) + + +def escolher_caracter_limitrofe(x, y): + if x == 0 or x == LARGURA - 1: + return '|' + if y == 0: + return '-' + return 'T' + + +def escolher_caracter(x, y, *pontos_cartesianos): + for ponto in pontos_cartesianos: + x_normalizdo, y_normalizado = normalizar_coordenadas(ponto.x, ponto.y) + if x == x_normalizdo and y == y_normalizado: + return ponto.caracter + return ' ' + + +def desenhar(*pontos_cartesianos): + frame = '' + for y in range(ALTURA): + for x in range(LARGURA): + if esta_dentro_da_tela(x, y): + frame += escolher_caracter(x, y, *pontos_cartesianos) + else: + frame += escolher_caracter_limitrofe(x, y) + frame += os.linesep + return frame + + +def main(): + global Ponto, Fase + + class Ponto(): + def __init__(self, caracter): + self.caracter = caracter + self(0) + + def __call__(self, tempo): + self.y = round(ALTURA * tempo / 5) if tempo < 5 else round(ALTURA * (10 - tempo) / 5) + self.x = round(LARGURA * tempo / 10) + return self + + class Fase(): + def __init__(self): + self.p = Ponto('>') + + def calcular_pontos(self, tempo): + return [self.p(tempo)] + + def acabou(self, tempo): + return tempo > 10 + + def status(self): + return 'Você ganhou' + + animar(Fase()) + + +if __name__ == '__main__': + main() diff --git a/placa_grafica_tkinter.py b/placa_grafica_tkinter.py index f999ea92b..ca6ab0738 100644 --- a/placa_grafica_tkinter.py +++ b/placa_grafica_tkinter.py @@ -1,154 +1,154 @@ -# coding: utf-8 -import time -from tkinter import PhotoImage, NW, Tk, Canvas -from tkinter.constants import ALL -import math -from os import path -import atores - -from fase import Fase, EM_ANDAMENTO, VITORIA -from atores import PassaroVermelho, PassaroAmarelo, Porco, Obstaculo - -ALTURA_DA_TELA = 600 # px - -root = Tk() - - -IMAGES_PATH = path.dirname(__file__) -IMAGES_PATH = path.join(IMAGES_PATH, 'images') -PASSARO_VERMELHO = PhotoImage(file=path.join(IMAGES_PATH, "passaro_vermelho.gif")) -PASSARO_AMARELHO = PhotoImage(file=path.join(IMAGES_PATH, "passaro_amarelo.gif")) -PORCO = PhotoImage(file=path.join(IMAGES_PATH, "porco.gif")) -PORCO_MORTO = PhotoImage(file=path.join(IMAGES_PATH, "porco_morto.gif")) -OBSTACULO = PhotoImage(file=path.join(IMAGES_PATH, "obstaculo.gif")) -TRANSPARENTE = PhotoImage(file=path.join(IMAGES_PATH, "transparente.gif")) -BACKGROUND = PhotoImage(file=path.join(IMAGES_PATH, "background.gif")) -PYTHONBIRDS_LOGO = PhotoImage(file=path.join(IMAGES_PATH, "python-birds-logo.gif")) -MENU = PhotoImage(file=path.join(IMAGES_PATH, "menu.gif")) -VOCE_GANHOU = PhotoImage(file=path.join(IMAGES_PATH, "python-birds-voce-ganhou-popup.gif")) -VOCE_PERDEU = PhotoImage(file=path.join(IMAGES_PATH, "python-birds-voce-perdeu-popup.gif")) - -CARACTER_PARA__IMG_DCT = {'V': PASSARO_VERMELHO, - 'A': PASSARO_AMARELHO, - '@': PORCO, - 'O': OBSTACULO, - '+': PORCO_MORTO, - ' ': TRANSPARENTE} - - -def plotar(camada_de_atores, ponto): - if ponto.caracter != ' ': - x = ponto.x - y = ALTURA_DA_TELA - ponto.y - 120 # para coincidir com o chao da tela - image = CARACTER_PARA__IMG_DCT.get(ponto.caracter, TRANSPARENTE) - camada_de_atores.create_image((x, y), image=image, anchor=NW) - - -def animar(tela, camada_de_atores, fase, passo=0.01, delta_t=0.04): - tempo = 0 - passo = int(1000 * passo) - angulo = 0 - multiplicador_rebobinar = 20 - - def _animar(): - tempo_de_inicio_de_animacao=time.time() - - nonlocal tempo - nonlocal delta_t - nonlocal angulo - tempo += delta_t - if tempo <= 0: - tempo = 0 - delta_t /= -multiplicador_rebobinar - if fase.status() != EM_ANDAMENTO: - camada_de_atores.create_image(162, 55, image=PYTHONBIRDS_LOGO, anchor=NW) - camada_de_atores.create_image(54, 540, image=MENU, anchor=NW) - if fase.status() == VITORIA: - img = VOCE_GANHOU - else: - img = VOCE_PERDEU - camada_de_atores.create_image(192, 211, image=img, anchor=NW) - else: - camada_de_atores.delete(ALL) - camada_de_atores.create_image((0, 0), image=BACKGROUND, anchor=NW) - tamanho_seta = 60 - angulo_rad = math.radians(-angulo) - - camada_de_atores.create_line(52, 493, 52 + tamanho_seta * math.cos(angulo_rad), - 493 + tamanho_seta * math.sin(angulo_rad), width=1.5) - camada_de_atores.create_text(35, 493, text="%d°" % angulo) - for ponto in fase.calcular_pontos(tempo): - plotar(camada_de_atores, ponto) - tempo_gasto_com_animacao= round((time.time() - tempo_de_inicio_de_animacao)*1000) # Trans - tempo_proxima_animacao = passo - tempo_gasto_com_animacao if passo>tempo_gasto_com_animacao else 1 - tela.after(tempo_proxima_animacao, _animar) - - def _ouvir_comandos_lancamento(evento): - nonlocal angulo - if evento.keysym == 'Up': - angulo += 1 - if angulo > 360: - angulo = 1 - elif evento.keysym == 'Down': - angulo -= 1 - if angulo < 0: - angulo = 359 - elif evento.keysym == 'Return' or evento.keysym == 'space': - fase.lancar(angulo, tempo) - - def _replay(event): - return - nonlocal tempo - nonlocal delta_t - if fase.acabou(tempo): - delta_t *= -multiplicador_rebobinar - _animar() - - - def _jogar_novamente(event): - return - nonlocal tempo - nonlocal delta_t - if fase.acabou(tempo): - tempo = delta_t - fase.resetar() - _animar() - - def _finalizar(event): - root.destroy() - - camada_de_atores.pack() - _animar() - tela.bind_all('', _ouvir_comandos_lancamento) - tela.bind_all('1', _replay) - tela.bind_all('2', _jogar_novamente) - tela.bind_all('3', _finalizar) - tela.bind_all('', _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) +# coding: utf-8 +import time +from tkinter import PhotoImage, NW, Tk, Canvas +from tkinter.constants import ALL +import math +from os import path +import atores + +from fase import Fase, EM_ANDAMENTO, VITORIA +from atores import PassaroVermelho, PassaroAmarelo, Porco, Obstaculo + +ALTURA_DA_TELA = 600 # px + +root = Tk() + + +IMAGES_PATH = path.dirname(__file__) +IMAGES_PATH = path.join(IMAGES_PATH, 'images') +PASSARO_VERMELHO = PhotoImage(file=path.join(IMAGES_PATH, "passaro_vermelho.gif")) +PASSARO_AMARELHO = PhotoImage(file=path.join(IMAGES_PATH, "passaro_amarelo.gif")) +PORCO = PhotoImage(file=path.join(IMAGES_PATH, "porco.gif")) +PORCO_MORTO = PhotoImage(file=path.join(IMAGES_PATH, "porco_morto.gif")) +OBSTACULO = PhotoImage(file=path.join(IMAGES_PATH, "obstaculo.gif")) +TRANSPARENTE = PhotoImage(file=path.join(IMAGES_PATH, "transparente.gif")) +BACKGROUND = PhotoImage(file=path.join(IMAGES_PATH, "background.gif")) +PYTHONBIRDS_LOGO = PhotoImage(file=path.join(IMAGES_PATH, "python-birds-logo.gif")) +MENU = PhotoImage(file=path.join(IMAGES_PATH, "menu.gif")) +VOCE_GANHOU = PhotoImage(file=path.join(IMAGES_PATH, "python-birds-voce-ganhou-popup.gif")) +VOCE_PERDEU = PhotoImage(file=path.join(IMAGES_PATH, "python-birds-voce-perdeu-popup.gif")) + +CARACTER_PARA__IMG_DCT = {'V': PASSARO_VERMELHO, + 'A': PASSARO_AMARELHO, + '@': PORCO, + 'O': OBSTACULO, + '+': PORCO_MORTO, + ' ': TRANSPARENTE} + + +def plotar(camada_de_atores, ponto): + if ponto.caracter != ' ': + x = ponto.x + y = ALTURA_DA_TELA - ponto.y - 120 # para coincidir com o chao da tela + image = CARACTER_PARA__IMG_DCT.get(ponto.caracter, TRANSPARENTE) + camada_de_atores.create_image((x, y), image=image, anchor=NW) + + +def animar(tela, camada_de_atores, fase, passo=0.01, delta_t=0.04): + tempo = 0 + passo = int(1000 * passo) + angulo = 0 + multiplicador_rebobinar = 20 + + def _animar(): + tempo_de_inicio_de_animacao=time.time() + + nonlocal tempo + nonlocal delta_t + nonlocal angulo + tempo += delta_t + if tempo <= 0: + tempo = 0 + delta_t /= -multiplicador_rebobinar + if fase.status() != EM_ANDAMENTO: + camada_de_atores.create_image(162, 55, image=PYTHONBIRDS_LOGO, anchor=NW) + camada_de_atores.create_image(54, 540, image=MENU, anchor=NW) + if fase.status() == VITORIA: + img = VOCE_GANHOU + else: + img = VOCE_PERDEU + camada_de_atores.create_image(192, 211, image=img, anchor=NW) + else: + camada_de_atores.delete(ALL) + camada_de_atores.create_image((0, 0), image=BACKGROUND, anchor=NW) + tamanho_seta = 60 + angulo_rad = math.radians(-angulo) + + camada_de_atores.create_line(52, 493, 52 + tamanho_seta * math.cos(angulo_rad), + 493 + tamanho_seta * math.sin(angulo_rad), width=1.5) + camada_de_atores.create_text(35, 493, text="%d°" % angulo) + for ponto in fase.calcular_pontos(tempo): + plotar(camada_de_atores, ponto) + tempo_gasto_com_animacao= round((time.time() - tempo_de_inicio_de_animacao)*1000) # Trans + tempo_proxima_animacao = passo - tempo_gasto_com_animacao if passo>tempo_gasto_com_animacao else 1 + tela.after(tempo_proxima_animacao, _animar) + + def _ouvir_comandos_lancamento(evento): + nonlocal angulo + if evento.keysym == 'Up': + angulo += 1 + if angulo > 360: + angulo = 1 + elif evento.keysym == 'Down': + angulo -= 1 + if angulo < 0: + angulo = 359 + elif evento.keysym == 'Return' or evento.keysym == 'space': + fase.lancar(angulo, tempo) + + def _replay(event): + return + nonlocal tempo + nonlocal delta_t + if fase.acabou(tempo): + delta_t *= -multiplicador_rebobinar + _animar() + + + def _jogar_novamente(event): + return + nonlocal tempo + nonlocal delta_t + if fase.acabou(tempo): + tempo = delta_t + fase.resetar() + _animar() + + def _finalizar(event): + root.destroy() + + camada_de_atores.pack() + _animar() + tela.bind_all('', _ouvir_comandos_lancamento) + tela.bind_all('1', _replay) + tela.bind_all('2', _jogar_novamente) + tela.bind_all('3', _finalizar) + tela.bind_all('', _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) diff --git a/python_birds.py b/python_birds.py index cc48edce2..74141262a 100644 --- a/python_birds.py +++ b/python_birds.py @@ -1,21 +1,21 @@ -# -*- 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) +# -*- 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) diff --git a/templates.py b/templates.py index 7ddd0c2a3..337222c09 100644 --- a/templates.py +++ b/templates.py @@ -1,154 +1,154 @@ - -FIM = '''|------------------------------------------------------------------------------| -| | -| | -| PPPP Y Y TTTTT H H OOO NN N | -| P P Y Y T H H O O N N N | -| PPPP Y T HHHHH O O N N N | -| P Y T H H O O N NN | -| P Y T H H OOO N N | -| | -| | -| | -| BBBB II RRRR DDDD SSSS | -| B B II R R D D S | -| BBBB II RRRR D D SSS | -| B B II R R D D S | -| BBBB II R R DDDD SSSS | -| | -| | -| | -|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| -''' - -FRAMES = ['''|------------------------------------------------------------------------------| -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| -''', - -'''|------------------------------------------------------------------------------| -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -|A | -|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| -''', - -'''|------------------------------------------------------------------------------| -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| A | -|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| -''', - -'''|------------------------------------------------------------------------------| -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| A | -|B | -|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| -''', - -'''|------------------------------------------------------------------------------| -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| A | -| | -|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| -''', - -'''|------------------------------------------------------------------------------| -| B| -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -| | -|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| -'''] + +FIM = '''|------------------------------------------------------------------------------| +| | +| | +| PPPP Y Y TTTTT H H OOO NN N | +| P P Y Y T H H O O N N N | +| PPPP Y T HHHHH O O N N N | +| P Y T H H O O N NN | +| P Y T H H OOO N N | +| | +| | +| | +| BBBB II RRRR DDDD SSSS | +| B B II R R D D S | +| BBBB II RRRR D D SSS | +| B B II R R D D S | +| BBBB II R R DDDD SSSS | +| | +| | +| | +|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| +''' + +FRAMES = ['''|------------------------------------------------------------------------------| +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| +''', + +'''|------------------------------------------------------------------------------| +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +|A | +|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| +''', + +'''|------------------------------------------------------------------------------| +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| A | +|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| +''', + +'''|------------------------------------------------------------------------------| +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| A | +|B | +|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| +''', + +'''|------------------------------------------------------------------------------| +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| A | +| | +|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| +''', + +'''|------------------------------------------------------------------------------| +| B| +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +| | +|TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT| +'''] diff --git a/testes/__init__.py b/testes/__init__.py index c7ee7577f..f5da34e57 100644 --- a/testes/__init__.py +++ b/testes/__init__.py @@ -1,2 +1,2 @@ -# -*- coding: utf-8 -*- -from __future__ import absolute_import, unicode_literals +# -*- coding: utf-8 -*- +from __future__ import absolute_import, unicode_literals diff --git a/testes/atores_testes.py b/testes/atores_testes.py index 8261ad9e6..17b40691f 100644 --- a/testes/atores_testes.py +++ b/testes/atores_testes.py @@ -1,766 +1,766 @@ -# -*- 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() +# -*- 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/fase_testes.py b/testes/fase_testes.py index dc0dcfbd3..5a5946eca 100644 --- a/testes/fase_testes.py +++ b/testes/fase_testes.py @@ -1,212 +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_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_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) +# -*- 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_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_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/integracao.py b/testes/integracao.py index 11f2f0178..8445780de 100644 --- a/testes/integracao.py +++ b/testes/integracao.py @@ -1,188 +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)) +# -*- 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)) diff --git a/testes/testes_placa_grafica.py b/testes/testes_placa_grafica.py index 556328f98..3d52019c1 100644 --- a/testes/testes_placa_grafica.py +++ b/testes/testes_placa_grafica.py @@ -1,41 +1,41 @@ -# -*- coding: utf-8 -*- -from __future__ import absolute_import, unicode_literals -import os -import platform -from unittest.case import TestCase -import placa_grafica -from templates import FRAMES - - -class TestesDoMotor(TestCase): - def teste_inverter_coordenadas(self): - self.assertTupleEqual((0, placa_grafica.ALTURA - 1), placa_grafica.normalizar_coordenadas(0, 0)) - self.assertTupleEqual((3, placa_grafica.ALTURA - 2), placa_grafica.normalizar_coordenadas(3, 1)) - self.assertTupleEqual((10, 0), placa_grafica.normalizar_coordenadas(10, placa_grafica.ALTURA - 1)) - - def teste_desenhar_frame_vazio(self): - class PontoCartesiano(): - def __init__(self, x, y, caracter): - self.caracter = caracter - self(x, y) - - def __call__(self, x, y): - self.y = y - self.x = x - - frames = FRAMES - if platform.system() == 'Windows': - frames = [f.replace('\n', os.linesep) for f in frames] - - self.assertEqual(frames[0], placa_grafica.desenhar()) - ponto_a = PontoCartesiano(1, 1, 'A') - self.assertEqual(frames[1], placa_grafica.desenhar(ponto_a)) - ponto_a.x = 2 - self.assertEqual(frames[2], placa_grafica.desenhar(ponto_a)) - ponto_b = PontoCartesiano(1, 1, 'B') - ponto_a.y = 2 - self.assertEqual(frames[3], placa_grafica.desenhar(ponto_a, ponto_b)) - ponto_b(2, 2) - self.assertEqual(frames[4], placa_grafica.desenhar(ponto_a, ponto_b)) - ponto_b(placa_grafica.LARGURA - 1, placa_grafica.ALTURA - 1) - self.assertEqual(frames[4], placa_grafica.desenhar(ponto_a, ponto_b)) +# -*- coding: utf-8 -*- +from __future__ import absolute_import, unicode_literals +import os +import platform +from unittest.case import TestCase +import placa_grafica +from templates import FRAMES + + +class TestesDoMotor(TestCase): + def teste_inverter_coordenadas(self): + self.assertTupleEqual((0, placa_grafica.ALTURA - 1), placa_grafica.normalizar_coordenadas(0, 0)) + self.assertTupleEqual((3, placa_grafica.ALTURA - 2), placa_grafica.normalizar_coordenadas(3, 1)) + self.assertTupleEqual((10, 0), placa_grafica.normalizar_coordenadas(10, placa_grafica.ALTURA - 1)) + + def teste_desenhar_frame_vazio(self): + class PontoCartesiano(): + def __init__(self, x, y, caracter): + self.caracter = caracter + self(x, y) + + def __call__(self, x, y): + self.y = y + self.x = x + + frames = FRAMES + if platform.system() == 'Windows': + frames = [f.replace('\n', os.linesep) for f in frames] + + self.assertEqual(frames[0], placa_grafica.desenhar()) + ponto_a = PontoCartesiano(1, 1, 'A') + self.assertEqual(frames[1], placa_grafica.desenhar(ponto_a)) + ponto_a.x = 2 + self.assertEqual(frames[2], placa_grafica.desenhar(ponto_a)) + ponto_b = PontoCartesiano(1, 1, 'B') + ponto_a.y = 2 + self.assertEqual(frames[3], placa_grafica.desenhar(ponto_a, ponto_b)) + ponto_b(2, 2) + self.assertEqual(frames[4], placa_grafica.desenhar(ponto_a, ponto_b)) + ponto_b(placa_grafica.LARGURA - 1, placa_grafica.ALTURA - 1) + self.assertEqual(frames[4], placa_grafica.desenhar(ponto_a, ponto_b)) From 38e5af7efa6f620e3cd2a04384cb995feb194948 Mon Sep 17 00:00:00 2001 From: ayslanleal Date: Mon, 9 Aug 2021 17:09:22 -0300 Subject: [PATCH 5/6] Add teste --- fase.py | 25 ++++++++++++++++++++++--- oo/pessoa.py | 20 ++++++++++++++------ 2 files changed, 36 insertions(+), 9 deletions(-) diff --git a/fase.py b/fase.py index cc801b528..d399531f2 100644 --- a/fase.py +++ b/fase.py @@ -73,7 +73,12 @@ def status(self): :return: """ - return EM_ANDAMENTO + if not self._possui_porco_ativo(): + return VITORIA + elif self._possui_passadors_ativos(): + return EM_ANDAMENTO + else: + return DERROTA def lancar(self, angulo, tempo): """ @@ -86,8 +91,10 @@ def lancar(self, angulo, tempo): :param angulo: ângulo de lançamento :param tempo: Tempo de lançamento """ - pass - + for passaro in self._passaros: + if not passaro.foi_lancado(): + passaro.lancar(angulo,tempo) + break def calcular_pontos(self, tempo): """ @@ -105,3 +112,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_passadors_ativos(self): + for passaro in self._passaros: + if passaro.status == ATIVO: + return True + return False + diff --git a/oo/pessoa.py b/oo/pessoa.py index 367a27cdf..cce1477fe 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,10 +1,10 @@ class Pessoa: olhos = 3 - def __init__(self,*filhos, nome=None, idade=35): + def __init__(self, nome=None, idade=int): self.nome = nome self.idade = idade - self.filhos = list(filhos) + #self.filhos = list(filhos) def cumprimentar(self): @@ -19,7 +19,8 @@ def nome_e_atributos_de_classe(cls): return f'{cls} - olhos: {cls.olhos}' class Homem(Pessoa): - pass + def cumprimentar(self): + return 'Aperto de mão' class Mutante(Pessoa): olhos = 3 @@ -28,11 +29,18 @@ class Mutante(Pessoa): if __name__ == '__main__': luciano = Pessoa(nome='Luciano') - renzo = Pessoa(luciano,nome='Renzo') + #renzo = Pessoa(luciano,nome='Renzo') print(luciano.cumprimentar()) print(luciano.nome) - for i in renzo.filhos: - print(renzo.nome) + #for i in renzo.filhos: + # print(renzo.nome) print(luciano.nome_e_atributos_de_classe()) print(luciano.metodo_estatico()) + ronaldo = Pessoa('Ronaldo',35) + print(ronaldo.idade) + renzo = Homem(nome='Renzo') + print(renzo.cumprimentar()) + print(luciano.cumprimentar()) + + From 1b64cdcc0b0d3a22a894914571261e2418b3a10c Mon Sep 17 00:00:00 2001 From: ayslanleal Date: Thu, 20 Jan 2022 20:21:18 -0300 Subject: [PATCH 6/6] Add teste --- fase.py | 6 +++--- testes/fase_testes.py | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/fase.py b/fase.py index d399531f2..71c695ed0 100644 --- a/fase.py +++ b/fase.py @@ -74,7 +74,7 @@ def status(self): :return: """ if not self._possui_porco_ativo(): - return VITORIA + return EM_ANDAMENTO elif self._possui_passadors_ativos(): return EM_ANDAMENTO else: @@ -114,13 +114,13 @@ def _transformar_em_ponto(self, ator): def _possui_porco_ativo(self): for porco in self._porcos: - if porco.status == ATIVO: + if porco.status==ATIVO: return True return False def _possui_passadors_ativos(self): for passaro in self._passaros: - if passaro.status == ATIVO: + if passaro.status==ATIVO: return True return False diff --git a/testes/fase_testes.py b/testes/fase_testes.py index 5a5946eca..d7e5b6874 100644 --- a/testes/fase_testes.py +++ b/testes/fase_testes.py @@ -5,6 +5,7 @@ from os import path from unittest.case import TestCase + project_dir = path.dirname(__file__) project_dir = path.join('..') sys.path.append(project_dir) @@ -118,7 +119,7 @@ def teste_acabou_com_porcos_e_passaros(self): self.assertEqual(VITORIA, fase.status()) fase.adicionar_obstaculo(Obstaculo()) - self.assertEqual(VITORIA, fase.status(), + self.assertEqual(EM_ANDAMENTO, fase.status(), 'Obstáculo não interfere no fim do jogo') fase.adicionar_porco(PorcoFake())