Commit 79a2f7d
renzon
Adicionando documentação para atores
1 parent a76670a commit 79a2f7d
1 file changed
Lines changed: 70 additions & 3 deletions
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
@@ -9,19 +9,46 @@ | |||
| 9 | 9 | ||
| 10 | 10 | ||
| 11 | 11 | class Ator(): | |
| 12 | + """ | ||
| 13 | + Classe que representa um ator. Ele representa um ponto cartesiano na tela. | ||
| 14 | + """ | ||
| 12 | 15 | _caracter_ativo = 'A' | |
| 13 | 16 | _caracter_destruido = ' ' | |
| 14 | 17 | ||
| 15 | 18 | def __init__(self, x=0, y=0): | |
| 19 | + """ | ||
| 20 | + Método de inicialização da classe. Deve inicializar os parâmetros x, y, caracter e status | ||
| 21 | + | ||
| 22 | + :param x: Posição horizontal inicial do ator | ||
| 23 | + :param y: Posição vertical inicial do ator | ||
| 24 | + """ | ||
| 16 | 25 | self.y = y | |
| 17 | 26 | self.x = x | |
| 18 | 27 | self.caracter = self._caracter_ativo | |
| 19 | 28 | self.status = ATIVO | |
| 20 | 29 | ||
| 21 | 30 | def calcular_posicao(self, tempo): | |
| 31 | + """ | ||
| 32 | + Método que calcula a posição do ator em determinado tempo. | ||
| 33 | + Deve-se imaginar que o tempo começa em 0 e avança de 0,01 segundos | ||
| 34 | + | ||
| 35 | + :param tempo: o tempo do jogo | ||
| 36 | + :return: posição x, y do ator | ||
| 37 | + """ | ||
| 22 | 38 | return self.x, self.y | |
| 23 | 39 | ||
| 24 | 40 | def colidir(self, outro_ator, intervalo=1): | |
| 41 | + """ | ||
| 42 | + Método que executa lógica de colisão entre dois atores. | ||
| 43 | + Só deve haver colisão se os dois atores tiverem seus status ativos. | ||
| 44 | + Para colisão, é considerado um quadrado, com lado igual ao parâmetro intervalo, em volta do ponto onde se | ||
| 45 | + encontra o ator. Se os atores estiverem dentro desse mesmo quadrado, seus status devem ser alterados para | ||
| 46 | + destruido, seus caracteres para destruido também. | ||
| 47 | + | ||
| 48 | + :param outro_ator: Ator a ser considerado na colisão | ||
| 49 | + :param intervalo: Intervalo a ser considerado | ||
| 50 | + :return: | ||
| 51 | + """ | ||
| 25 | 52 | if self.status == DESTRUIDO or outro_ator.status == DESTRUIDO: | |
| 26 | 53 | return | |
| 27 | 54 | ||
@@ -45,19 +72,38 @@ class Passaro(Ator): | |||
| 45 | 72 | velocidade_escalar = None | |
| 46 | 73 | ||
| 47 | 74 | def __init__(self, x=0, y=0): | |
| 75 | + """ | ||
| 76 | + Método de inicialização de pássaro. | ||
| 77 | + | ||
| 78 | + Deve chamar a inicialização de ator. Além disso, deve armazenar a posição inicial e incializar o tempo de | ||
| 79 | + lançamento e angulo de lançamento | ||
| 80 | + | ||
| 81 | + :param x: | ||
| 82 | + :param y: | ||
| 83 | + """ | ||
| 48 | 84 | super().__init__(x, y) | |
| 49 | 85 | self._x_inicial = x | |
| 50 | 86 | self._y_inicial = y | |
| 51 | 87 | self._tempo_de_lancamento = None | |
| 52 | 88 | self._angulo_de_lancamento = None # radianos | |
| 53 | 89 | ||
| 54 | 90 | def foi_lancado(self): | |
| 91 | + """ | ||
| 92 | + Método que retorna verdaeira se o pássaro já foi lançado e falso caso contrário | ||
| 93 | + | ||
| 94 | + :return: booleano | ||
| 95 | + """ | ||
| 55 | 96 | return self._tempo_de_lancamento is not None | |
| 56 | 97 | ||
| 57 | 98 | def colidir_com_chao(self): | |
| 99 | + """ | ||
| 100 | + Método que executa lógica de colisão com o chão. Toda vez que y for menor ou igual a 0, | ||
| 101 | + o status dos Passaro deve ser alterado para destruido, bem como o seu caracter | ||
| 102 | + | ||
| 103 | + """ | ||
| 58 | 104 | if self.y <= 0: | |
| 59 | 105 | self.status = DESTRUIDO | |
| 60 | - self.caracter=self._caracter_destruido | ||
| 106 | + self.caracter = self._caracter_destruido | ||
| 61 | 107 | ||
| 62 | 108 | def _calcular_posicao_horizontal(self, delta_t): | |
| 63 | 109 | self.x = self._x_inicial + self.velocidade_escalar * delta_t * math.cos(self._angulo_de_lancamento) | |
@@ -73,15 +119,36 @@ def _calcular_posicao(self, tempo): | |||
| 73 | 119 | self._calcular_posicao_horizontal(delta_t) | |
| 74 | 120 | ||
| 75 | 121 | def calcular_posicao(self, tempo): | |
| 122 | + """ | ||
| 123 | + Método que cálcula a posição do passaro de acordo com o tempo. | ||
| 124 | + | ||
| 125 | + Antes do lançamento o pássaro deve retornar o valor de sua posição inicial | ||
| 126 | + | ||
| 127 | + Depois do lançamento o pássaro deve calcular de acordo com sua posição inicial, velocidade escalar, | ||
| 128 | + ângulo de lancamento, gravidade (constante GRAVIDADE) e o tempo do jogo. | ||
| 129 | + | ||
| 130 | + Após a colisão, ou seja, ter seus status destruido, o pássaro deve apenas retornar a última posição calculada. | ||
| 131 | + | ||
| 132 | + :param tempo: tempo de jogo a ser calculada a posição | ||
| 133 | + :return: posição x, y | ||
| 134 | + """ | ||
| 76 | 135 | if self._tempo_de_lancamento is None: | |
| 77 | 136 | return self._x_inicial, self._y_inicial | |
| 78 | 137 | if self.status == ATIVO: | |
| 79 | 138 | self._calcular_posicao(tempo) | |
| 80 | 139 | return self.x, self.y | |
| 81 | 140 | ||
| 82 | 141 | ||
| 83 | - def lancar(self, angulo, tempo): | ||
| 84 | - self._tempo_de_lancamento = tempo | ||
| 142 | + def lancar(self, angulo, tempo_de_lancamento): | ||
| 143 | + """ | ||
| 144 | + Lógica que lança o pássaro. Deve armazenar o ângulo e o tempo de lançamento para posteriores cálculo. | ||
| 145 | + O ângulo é passado em graus e deve ser transformado em radianos | ||
| 146 | + | ||
| 147 | + :param angulo: | ||
| 148 | + :param tempo_de_lancamento: | ||
| 149 | + :return: | ||
| 150 | + """ | ||
| 151 | + self._tempo_de_lancamento = tempo_de_lancamento | ||
| 85 | 152 | self._angulo_de_lancamento = math.radians(angulo) | |
| 86 | 153 | ||
| 87 | 154 | def _aguardando_lancamento(self, tempo): | |
0 commit comments