Documentação da classe fase

renzon · renzon · commit 3f0d4f9f3ac9 · 2014-09-01T10:21:52.000-03:00
diff --git a/README.md b/README.md
@@ -1,6 +1,10 @@
 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 [master](https://github.com/pythonprobr/pythonbirds/tree/master)
+
 Projeto para Ensino de Programação Orientadas a Objetos em Python.
 
 A versão utilizada para desenvolvimento foi Python 3.4
@@ -11,20 +15,20 @@ Um vídeo fala mais que 1000 palavras: [Python Birds](https://www.youtube.com/wa
 
 Instalar [Python 3](https://www.python.org/download/).
 
-Baixar a versão contendo apenas a [estrutura do projeto](https://github.com/pythonprobr/pythonbirds/archive/diversao.zip)
+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 em [Simplificação do Jogo](#simplifica%C3%A7%C3%A3o-do-jogo)
+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.
 
-Após o desenvolvimento é possível emular um jogo que termina em vitória rodando:
+É possível emular um jogo que termina em vitória rodando:
 
     python fase_testes.py
 
@@ -70,27 +74,10 @@ Classe base para todos atores do jogo.
 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 resetar
-
-Método que ao ser executado, seta o valor de _tempo_de_colisão para None
-
-### Método status
-
-O ator possui os status Ativo ou Destruido. Além disso o status deve ser dependente do tempo. Ou seja, se o ator foi 
-destruido no tempo 1, ele deve possuir status Ativo antes desse tempo, como 0.9, e Destruido após esse tempo, como em tempo 1.1.
- 
 ### 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. 
-O ator deve guardar o tempo de colisão para calcular corretamente seu status.
-Além disso, um intervalo é recebido como parâmetro indicando qual a tolerância para considerar um ponto vizinho.
- Por padrão, seu valor é 1.
-
-## Método caracter
-
-O método caracter retorna 'A' quando o ator tem status Ativo e '+' caso contrário. Também é depende do tempo.
-
 
 ## Classe Obstaculo
 
@@ -111,38 +98,31 @@ representação é a o caracter "@".
 
 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 (G) constante e igual a 10 m/s^2.
+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. 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 resetar
-
-O método resetar deve chamar o método resetar de Ator.
-Além disso, deve setar como Nome os parầmetros de tempo de lançamento e ângulo de lançamento
-
 
 ### 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
+### 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çamentomento
+### Lançamento
 
-Se o pássaro ainda não foi lançado, ou se o tempo de jogo é menor que o tempo de lançamento,
-O pássaro deve permanecer na posição inicial.
+Se o pássaro ainda não foi lançado, o pássaro deve permanecer na posição inicial.
   
-Calso tenha sido lançado e seu status esteja ativo, sua posição deve ser calculada de acordo com o lançamento oblíquo.
+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. Para isso, pasta
-calcular o ponto em que o pássaro estava no tempo da colisão.
+Caso contrário, ele deve retornar a posição onde colidiu.
 
 #### Método posicao_horizontal
 
@@ -195,7 +175,8 @@ Recebe o tempo como parâmetro e retorna mensagem com status do jogo.
 
 ### 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.
+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
 
diff --git a/placa_grafica_tkinter.py b/placa_grafica_tkinter.py
@@ -73,7 +73,7 @@ def _animar():
 
             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=u"%d°" % angulo)
+            camada_de_atores.create_text(35, 493, text="%d°" % angulo)
             for ponto in fase.calcular_pontos(tempo):
                 plotar(camada_de_atores, ponto)
             tela.after(passo, _animar)
@@ -88,6 +88,7 @@ def _ouvir_comandos_lancamento(evento):
             fase.lancar(angulo, tempo)
 
     def _replay(event):
+        return
         nonlocal tempo
         nonlocal delta_t
         if fase.acabou(tempo):
@@ -96,6 +97,7 @@ def _replay(event):
 
 
     def _jogar_novamente(event):
+        return
         nonlocal tempo
         nonlocal delta_t
         if fase.acabou(tempo):
diff --git a/testes/fase_testes.py b/testes/fase_testes.py
@@ -2,17 +2,22 @@
 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
 from fase import Fase, Ponto
-import placa_grafica
 
 
 class FaseTestes(TestCase):
@@ -192,19 +197,21 @@ def teste_calcular_pontos(self):
             fase_exemplo.calcular_pontos(i / 100)
         print(fase_exemplo.calcular_pontos(8.5))
 
-
-        expected = [Ponto(32,11,'v'), Ponto(77,0,'a'), Ponto(70,2,'a'), Ponto(31,10,' '), Ponto(78,1,'+'), Ponto(70,1,'+')]
+        expected = [Ponto(32, 11, 'v'), Ponto(77, 0, 'a'), Ponto(70, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '+'),
+                    Ponto(70, 1, '+')]
 
         self.assertListEqual(expected, fase_exemplo.calcular_pontos(8.5))
 
         self.assertTrue(fase_exemplo.acabou())
 
 
-def criar_fase_exemplo():
-    fase_exemplo = Fase()
-    passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)]
-    porcos = [Porco(78, 1), Porco(70, 1)]
-    obstaculos = [Obstaculo(31, 10)]
+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)
@@ -214,4 +221,4 @@ def criar_fase_exemplo():
 
 
 if __name__ == '__main__':
-    placa_grafica.animar(criar_fase_exemplo())
+    rodar_fase(criar_fase_exemplo(10))
