Commit 3f0d4f9
renzon
Documentação da classe fase
1 parent f67b4c4 commit 3f0d4f9
3 files changed
Lines changed: 34 additions & 44 deletions
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -1,6 +1,10 @@ | |||
| 1 | 1 | Python Birds | |
| 2 | 2 | =========== | |
| 3 | 3 | ||
| 4 | + Essa versão é a mais simples. Ela não contém replay nem reset, de forma que o jogo não pode retroceder. | ||
| 5 | + | ||
| 6 | + Para versão mais complexa, acesse a branch [master](https://github.com/pythonprobr/pythonbirds/tree/master) | ||
| 7 | + | ||
| 4 | 8 | Projeto para Ensino de Programação Orientadas a Objetos em Python. | |
| 5 | 9 | ||
| 6 | 10 | 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 | |||
| 11 | 15 | ||
| 12 | 16 | Instalar [Python 3](https://www.python.org/download/). | |
| 13 | 17 | ||
| 14 | - Baixar a versão contendo apenas a [estrutura do projeto](https://github.com/pythonprobr/pythonbirds/archive/diversao.zip) | ||
| 18 | + Baixar o zip do projeto (botão Download Zip) | ||
| 15 | 19 | ||
| 16 | 20 | Os testes se encontram dentro do pacote "testes" e servem para definir a dinâmica das classes. Para rodar todos testes, execute | |
| 17 | 21 | ||
| 18 | 22 | python executor_de_testes.py | |
| 19 | 23 | ||
| 20 | - Explicação detalhada sobre classes e métodos se encontram em [Simplificação do Jogo](#simplifica%C3%A7%C3%A3o-do-jogo) | ||
| 24 | + Explicação detalhada sobre classes e métodos se encontram nos scripts atores.py e fase.py | ||
| 21 | 25 | ||
| 22 | 26 | ## Ordem de desenvolvimento | |
| 23 | 27 | ||
| 24 | 28 | A ordem preferida é começar pelos atores, seguindo a ordem dos testes presentes no script atores_testes.py. | |
| 25 | 29 | Depois passar para a fase_teste.py, onde é implementada uma fase. | |
| 26 | 30 | ||
| 27 | - Após o desenvolvimento é possível emular um jogo que termina em vitória rodando: | ||
| 31 | + É possível emular um jogo que termina em vitória rodando: | ||
| 28 | 32 | ||
| 29 | 33 | python fase_testes.py | |
| 30 | 34 | ||
@@ -70,27 +74,10 @@ Classe base para todos atores do jogo. | |||
| 70 | 74 | Método que recebe o tempo (float) como parâmetro e retorna uma tupla com 2 elementos, posição horizontal (x) como | |
| 71 | 75 | primeiro elemento e posição vertical (y) como segundo. | |
| 72 | 76 | ||
| 73 | - ### Método resetar | ||
| 74 | - | ||
| 75 | - Método que ao ser executado, seta o valor de _tempo_de_colisão para None | ||
| 76 | - | ||
| 77 | - ### Método status | ||
| 78 | - | ||
| 79 | - O ator possui os status Ativo ou Destruido. Além disso o status deve ser dependente do tempo. Ou seja, se o ator foi | ||
| 80 | - 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. | ||
| 81 | - | ||
| 82 | 77 | ### Método colidir | |
| 83 | 78 | ||
| 84 | 79 | O método colidir executa a lógica de colisão. A colisão só ocorre com atores ativos e que estejam | |
| 85 | 80 | em pontos vizinhos. | |
| 86 | - O ator deve guardar o tempo de colisão para calcular corretamente seu status. | ||
| 87 | - Além disso, um intervalo é recebido como parâmetro indicando qual a tolerância para considerar um ponto vizinho. | ||
| 88 | - Por padrão, seu valor é 1. | ||
| 89 | - | ||
| 90 | - ## Método caracter | ||
| 91 | - | ||
| 92 | - O método caracter retorna 'A' quando o ator tem status Ativo e '+' caso contrário. Também é depende do tempo. | ||
| 93 | - | ||
| 94 | 81 | ||
| 95 | 82 | ## Classe Obstaculo | |
| 96 | 83 | ||
@@ -111,38 +98,31 @@ representação é a o caracter "@". | |||
| 111 | 98 | ||
| 112 | 99 | Classe base de todos os passáros. Cada tipo possui uma velocidade de lançamento (v). No lançamento o jogador escolhe o | |
| 113 | 100 | â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 | |
| 114 | - gravidade (G) constante e igual a 10 m/s^2. | ||
| 101 | + gravidade (GRAVIDADE) constante e igual a 10 m/s^2. | ||
| 115 | 102 | ||
| 116 | 103 | ### Método lancar | |
| 117 | 104 | ||
| 118 | 105 | 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 | |
| 119 | 106 | de lançamento para cálculo de sua posíção. Lembrar que o tempo das fórmulas é delta_t = T_final - T_inicial | |
| 120 | 107 | ||
| 121 | - ### Método de resetar | ||
| 122 | - | ||
| 123 | - O método resetar deve chamar o método resetar de Ator. | ||
| 124 | - Além disso, deve setar como Nome os parầmetros de tempo de lançamento e ângulo de lançamento | ||
| 125 | - | ||
| 126 | 108 | ||
| 127 | 109 | ### Método de colidir_com_chao | |
| 128 | 110 | ||
| 129 | 111 | Todo pássaro que colidir com o chão (y<=0) deve ser destruído. | |
| 130 | 112 | ||
| 131 | - ### Método foi lançado | ||
| 113 | + ### Método foi_lançado | ||
| 132 | 114 | ||
| 133 | 115 | Esse método deve retornar verdadadeiro se o pássaro foi lançado (tempo de lançamento é None). | |
| 134 | 116 | Caso contrário deve retornar falso | |
| 135 | 117 | ||
| 136 | - ### Lançamentomento | ||
| 118 | + ### Lançamento | ||
| 137 | 119 | ||
| 138 | - Se o pássaro ainda não foi lançado, ou se o tempo de jogo é menor que o tempo de lançamento, | ||
| 139 | - O pássaro deve permanecer na posição inicial. | ||
| 120 | + Se o pássaro ainda não foi lançado, o pássaro deve permanecer na posição inicial. | ||
| 140 | 121 | ||
| 141 | - Calso tenha sido lançado e seu status esteja ativo, sua posição deve ser calculada de acordo com o lançamento oblíquo. | ||
| 122 | + Caso tenha sido lançado e seu status esteja ativo, sua posição deve ser calculada de acordo com o lançamento oblíquo. | ||
| 142 | 123 | Nesse caso, delta_t vai ser igual ao tempo do jogo menos o tempo do lançamento. | |
| 143 | 124 | ||
| 144 | - Caso contrário, ele deve retornar a posição onde colidiu. Para isso, pasta | ||
| 145 | - calcular o ponto em que o pássaro estava no tempo da colisão. | ||
| 125 | + Caso contrário, ele deve retornar a posição onde colidiu. | ||
| 146 | 126 | ||
| 147 | 127 | #### Método posicao_horizontal | |
| 148 | 128 | ||
@@ -195,7 +175,8 @@ Recebe o tempo como parâmetro e retorna mensagem com status do jogo. | |||
| 195 | 175 | ||
| 196 | 176 | ### Método lancar | |
| 197 | 177 | ||
| 198 | - Recebe o ângulo e o tempo do lançamento. Deve delegar o lançamento ao primeiro pássaro ativo da lista de pássaros. | ||
| 178 | + 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 | ||
| 179 | + ainda não foi lançado. | ||
| 199 | 180 | ||
| 200 | 181 | ### Método calcular_pontos | |
| 201 | 182 | ||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -73,7 +73,7 @@ def _animar(): | |||
| 73 | 73 | ||
| 74 | 74 | camada_de_atores.create_line(52, 493, 52 + tamanho_seta * math.cos(angulo_rad), | |
| 75 | 75 | 493 + tamanho_seta * math.sin(angulo_rad), width=1.5) | |
| 76 | - camada_de_atores.create_text(35, 493, text=u"%d°" % angulo) | ||
| 76 | + camada_de_atores.create_text(35, 493, text="%d°" % angulo) | ||
| 77 | 77 | for ponto in fase.calcular_pontos(tempo): | |
| 78 | 78 | plotar(camada_de_atores, ponto) | |
| 79 | 79 | tela.after(passo, _animar) | |
@@ -88,6 +88,7 @@ def _ouvir_comandos_lancamento(evento): | |||
| 88 | 88 | fase.lancar(angulo, tempo) | |
| 89 | 89 | ||
| 90 | 90 | def _replay(event): | |
| 91 | + return | ||
| 91 | 92 | nonlocal tempo | |
| 92 | 93 | nonlocal delta_t | |
| 93 | 94 | if fase.acabou(tempo): | |
@@ -96,6 +97,7 @@ def _replay(event): | |||
| 96 | 97 | ||
| 97 | 98 | ||
| 98 | 99 | def _jogar_novamente(event): | |
| 100 | + return | ||
| 99 | 101 | nonlocal tempo | |
| 100 | 102 | nonlocal delta_t | |
| 101 | 103 | if fase.acabou(tempo): | |
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -2,17 +2,22 @@ | |||
| 2 | 2 | from itertools import chain | |
| 3 | 3 | ||
| 4 | 4 | import os | |
| 5 | + from os import path | ||
| 5 | 6 | from unittest.case import TestCase | |
| 6 | 7 | import math | |
| 7 | 8 | import sys | |
| 8 | 9 | ||
| 10 | + project_dir = path.dirname(__file__) | ||
| 11 | + project_dir = path.join('..') | ||
| 12 | + sys.path.append(project_dir) | ||
| 13 | + from placa_grafica_tkinter import rodar_fase | ||
| 14 | + | ||
| 9 | 15 | project_dir = os.path.join(os.path.dirname(__file__), '..') | |
| 10 | 16 | project_dir = os.path.normpath(project_dir) | |
| 11 | 17 | sys.path.append(project_dir) | |
| 12 | 18 | ||
| 13 | 19 | from atores import Obstaculo, Porco, PassaroVermelho, PassaroAmarelo, DESTRUIDO, ATIVO | |
| 14 | 20 | from fase import Fase, Ponto | |
| 15 | - import placa_grafica | ||
| 16 | 21 | ||
| 17 | 22 | ||
| 18 | 23 | class FaseTestes(TestCase): | |
@@ -192,19 +197,21 @@ def teste_calcular_pontos(self): | |||
| 192 | 197 | fase_exemplo.calcular_pontos(i / 100) | |
| 193 | 198 | print(fase_exemplo.calcular_pontos(8.5)) | |
| 194 | 199 | ||
| 195 | - | ||
| 196 | - expected = [Ponto(32,11,'v'), Ponto(77,0,'a'), Ponto(70,2,'a'), Ponto(31,10,' '), Ponto(78,1,'+'), Ponto(70,1,'+')] | ||
| 200 | + expected = [Ponto(32, 11, 'v'), Ponto(77, 0, 'a'), Ponto(70, 2, 'a'), Ponto(31, 10, ' '), Ponto(78, 1, '+'), | ||
| 201 | + Ponto(70, 1, '+')] | ||
| 197 | 202 | ||
| 198 | 203 | self.assertListEqual(expected, fase_exemplo.calcular_pontos(8.5)) | |
| 199 | 204 | ||
| 200 | 205 | self.assertTrue(fase_exemplo.acabou()) | |
| 201 | 206 | ||
| 202 | 207 | ||
| 203 | - def criar_fase_exemplo(): | ||
| 204 | - fase_exemplo = Fase() | ||
| 205 | - passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)] | ||
| 206 | - porcos = [Porco(78, 1), Porco(70, 1)] | ||
| 207 | - obstaculos = [Obstaculo(31, 10)] | ||
| 208 | + def criar_fase_exemplo(multiplicador=1): | ||
| 209 | + fase_exemplo = Fase(1 if multiplicador == 1 else 32) | ||
| 210 | + passaros = [PassaroVermelho(3 * multiplicador, 3 * multiplicador), | ||
| 211 | + PassaroAmarelo(3 * multiplicador, 3 * multiplicador), | ||
| 212 | + PassaroAmarelo(3 * multiplicador, 3 * multiplicador)] | ||
| 213 | + porcos = [Porco(78 * multiplicador, multiplicador), Porco(70 * multiplicador, multiplicador)] | ||
| 214 | + obstaculos = [Obstaculo(31 * multiplicador, 10 * multiplicador)] | ||
| 208 | 215 | ||
| 209 | 216 | fase_exemplo.adicionar_passaro(*passaros) | |
| 210 | 217 | fase_exemplo.adicionar_porco(*porcos) | |
@@ -214,4 +221,4 @@ def criar_fase_exemplo(): | |||
| 214 | 221 | ||
| 215 | 222 | ||
| 216 | 223 | if __name__ == '__main__': | |
| 217 | - placa_grafica.animar(criar_fase_exemplo()) | ||
| 224 | + rodar_fase(criar_fase_exemplo(10)) | ||
0 commit comments