[feat] Python birds finalizado.

guyrux · guyrux · commit dabb16b4f0dc · 2020-09-20T15:29:11.000-03:00
diff --git a/atores.py b/atores.py
@@ -38,7 +38,7 @@ def calcular_posicao(self, tempo):
         :param tempo: o tempo do jogo
         :return: posição x, y do ator
         """
-        return 1, 1
+        return self.x, self.y
 
     def colidir(self, outro_ator, intervalo=1):
         """
@@ -52,16 +52,22 @@ def colidir(self, outro_ator, intervalo=1):
         :param intervalo: Intervalo a ser considerado
         :return:
         """
-        pass
+        if self.status == ATIVO and outro_ator.status == ATIVO:
+            delta_x=abs(self.x - outro_ator.x)
+            delta_y=abs(self.y - outro_ator.y)
+            if delta_x <= intervalo and delta_y <= intervalo:
+                self.status = outro_ator.status = DESTRUIDO 
 
 
 
 class Obstaculo(Ator):
     _caracter_ativo = "O"
+    _caracter_destruido = " "
 
 
 class Porco(Ator):
     _caracter_ativo = "@"
+    _caracter_destruido = "+"
 
 
 class DuploLancamentoExcecao(Exception):
@@ -93,15 +99,17 @@ def foi_lancado(self):
 
         :return: booleano
         """
-        return True
+        return not self._tempo_de_lancamento is None
 
     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
+        if self.y <= 0:
+            self.status = DESTRUIDO
+
 
     def calcular_posicao(self, tempo):
         """
@@ -117,7 +125,11 @@ def calcular_posicao(self, tempo):
         :param tempo: tempo de jogo a ser calculada a posição
         :return: posição x, y
         """
-        return 1, 1
+        if self.foi_lancado() and self.status == ATIVO:
+            delta_t = tempo - self._tempo_de_lancamento
+            self._calcular_posicao_vertical(delta_t)
+            self._calcular_posicao_horizontal(delta_t)
+        return super().calcular_posicao(tempo)
 
 
     def lancar(self, angulo, tempo_de_lancamento):
@@ -129,12 +141,33 @@ def lancar(self, angulo, tempo_de_lancamento):
         :param tempo_de_lancamento:
         :return:
         """
-        pass
+        self._angulo_de_lancamento = math.radians(angulo)
+        self._tempo_de_lancamento = tempo_de_lancamento
+
+    
+    def _calcular_posicao_vertical(self, delta_t):
+        y_atual = self._y_inicial
+        angulo_radianos = self._angulo_de_lancamento
+        y_atual += self.velocidade_escalar*delta_t*math.sin(angulo_radianos)
+        y_atual -= (GRAVIDADE*(delta_t**2))/2
+        self.y = y_atual
+
+    
+    def _calcular_posicao_horizontal(self, delta_t):
+        x_atual = self._x_inicial
+        angulo_radianos = self._angulo_de_lancamento
+        x_atual += self.velocidade_escalar*delta_t*math.cos(angulo_radianos)
+        self.x = x_atual
+
 
 
 class PassaroAmarelo(Passaro):
     _caracter_ativo = "A"
+    _caracter_destruido = "a"
+    velocidade_escalar = 30
 
 
 class PassaroVermelho(Passaro):
-    _caracter_ativo = "V"
+    _caracter_ativo = "V"
+    _caracter_destruido = "v"
+    velocidade_escalar = 20
diff --git a/fase.py b/fase.py
@@ -106,6 +106,12 @@ def calcular_pontos(self, tempo):
         :param tempo: tempo para o qual devem ser calculados os pontos
         :return: objeto do tipo Ponto
         """
+        for passaro in self._passaros:
+            passaro.calcular_posicao(tempo)
+            for alvo in self._obstaculos+self._porcos:
+                passaro.colidir(alvo, self.intervalo_de_colisao)
+            passaro.colidir_com_chao()
+
         pontos=[self._transformar_em_ponto(a) for a in self._passaros+self._obstaculos+self._porcos]
 
         return pontos
diff --git a/testes/testes_atores.py b/testes/testes_atores.py
@@ -113,7 +113,7 @@ def test_caracter(self):
     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".
+        Atenção: Esse não é método de teste porque nao se inicia com prefixo "test".
         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
