Retornando com solução que tinha sido removida pelo merge

renzon · renzon · commit e26869ee1bc1 · 2014-11-16T11:06:56.000-02:00
diff --git a/.gitignore b/.gitignore
@@ -43,10 +43,6 @@ coverage.xml
 .pydevproject
 .idea
 
-# Floobits
-
-.floorc.json
-
 # Rope
 .ropeproject
 
diff --git a/atores.py b/atores.py
@@ -37,7 +37,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):
         """
@@ -51,20 +51,25 @@ def colidir(self, outro_ator, intervalo=1):
         :param intervalo: Intervalo a ser considerado
         :return:
         """
-        pass
+        if self.status == DESTRUIDO or outro_ator.status == DESTRUIDO:
+            return
 
+        if self.x - intervalo <= outro_ator.x <= self.x + intervalo and self.y - intervalo <= outro_ator.y <= self.y + intervalo:
+            self.status = DESTRUIDO
+            outro_ator.status = DESTRUIDO
 
 
 class Obstaculo(Ator):
-    pass
+    _caracter_ativo = 'O'
 
 
 class Porco(Ator):
-    pass
+    _caracter_ativo = '@'
+    _caracter_destruido = '+'
 
 
 class Passaro(Ator):
-    velocidade_escalar = 10
+    velocidade_escalar = None
 
     def __init__(self, x=0, y=0):
         """
@@ -88,15 +93,29 @@ def foi_lancado(self):
 
         :return: booleano
         """
-        return True
+        return self._tempo_de_lancamento is not 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_horizontal(self, delta_t):
+        self.x = self._x_inicial + self.velocidade_escalar * delta_t * math.cos(self._angulo_de_lancamento)
+
+    def _calcular_posicao_vertical(self, delta_t):
+        self.y = (self._y_inicial +
+                  self.velocidade_escalar * delta_t * math.sin(self._angulo_de_lancamento) -
+                  (GRAVIDADE / 2) * delta_t ** 2)
+
+    def _calcular_posicao(self, tempo):
+        delta_t = tempo - self._tempo_de_lancamento
+        self._calcular_posicao_vertical(delta_t)
+        self._calcular_posicao_horizontal(delta_t)
 
     def calcular_posicao(self, tempo):
         """
@@ -112,7 +131,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._tempo_de_lancamento is None:
+            return self._x_inicial, self._y_inicial
+        if self.status == ATIVO:
+            self._calcular_posicao(tempo)
+        return self.x, self.y
 
 
     def lancar(self, angulo, tempo_de_lancamento):
@@ -124,12 +147,23 @@ def lancar(self, angulo, tempo_de_lancamento):
         :param tempo_de_lancamento:
         :return:
         """
-        pass
+        self._tempo_de_lancamento = tempo_de_lancamento
+        self._angulo_de_lancamento = math.radians(angulo)
+
+    def _aguardando_lancamento(self, tempo):
+        return not self.foi_lancado() or tempo < self._tempo_de_lancamento
+
+    def _ja_colidiu(self):
+        return self.foi_lancado() and self.status() == DESTRUIDO
 
 
 class PassaroAmarelo(Passaro):
-    pass
+    velocidade_escalar = 30  # m/s
+    _caracter_ativo = 'A'
+    _caracter_destruido = 'a'
 
 
 class PassaroVermelho(Passaro):
-    pass
+    velocidade_escalar = 20  # m/s
+    _caracter_ativo = 'V'
+    _caracter_destruido = 'v'
diff --git a/fase.py b/fase.py
@@ -2,6 +2,7 @@
 from itertools import chain
 from atores import ATIVO
 
+# Status possíveis do jogo
 
 VITORIA = 'VITORIA'
 DERROTA = 'DERROTA'
@@ -36,30 +37,45 @@ def __init__(self, intervalo_de_colisao=1):
         self._porcos = []
         self._obstaculos = []
 
+    def _adicionar_ator(self, lista, *atores):
+        lista.extend(atores)
 
     def adicionar_obstaculo(self, *obstaculos):
         """
         Adiciona obstáculos em uma fase
 
         :param obstaculos:
         """
-        pass
+        self._adicionar_ator(self._obstaculos, *obstaculos)
 
     def adicionar_porco(self, *porcos):
         """
         Adiciona porcos em uma fase
 
         :param porcos:
         """
-        pass
+        self._adicionar_ator(self._porcos, *porcos)
 
     def adicionar_passaro(self, *passaros):
         """
         Adiciona pássaros em uma fase
 
         :param passaros:
         """
-        pass
+        self._adicionar_ator(self._passaros, *passaros)
+
+    # def acabou(self):
+    # """
+    #     Método que retorna verdadeiro se o jogo acabou e falso caso contrário
+    #
+    #     O jogo pode acabar por dois motivos:
+    #
+    #     1. Não existem mais porcos ativos no jogo
+    #     2. Não existem mais pássaros ativos no jogo
+    #
+    #     :return: booleano
+    #     """
+    #     return self.status() != EM_ANDAMENTO
 
     def status(self):
         """
@@ -73,7 +89,11 @@ def status(self):
 
         :return:
         """
-        return EM_ANDAMENTO
+        if not self._existe_porco_ativo():
+            return VITORIA
+        if self._existe_passaro_ativo():
+            return EM_ANDAMENTO
+        return DERROTA
 
     def lancar(self, angulo, tempo):
         """
@@ -86,7 +106,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)
+                return
 
 
     def calcular_pontos(self, tempo):
@@ -98,10 +121,32 @@ def calcular_pontos(self, tempo):
         :param tempo: tempo para o qual devem ser calculados os pontos
         :return: objeto do tipo Ponto
         """
-        pontos=[]
-
+        pontos = [self._calcular_ponto_de_passaro(p, tempo) for p in self._passaros]
+        obstaculos_e_porcos = chain(self._obstaculos, self._porcos)
+        pontos.extend([self._transformar_em_ponto(ator) for ator in obstaculos_e_porcos])
         return pontos
 
     def _transformar_em_ponto(self, ator):
         return Ponto(ator.x, ator.y, ator.caracter())
 
+    def _calcular_ponto_de_passaro(self, passaro, tempo, ):
+        passaro.calcular_posicao(tempo)
+        for ator in chain(self._obstaculos, self._porcos):
+            if ATIVO == passaro.status:
+                passaro.colidir(ator, self.intervalo_de_colisao)
+                passaro.colidir_com_chao()
+            else:
+                break
+        return self._transformar_em_ponto(passaro)
+
+    def _existe_porco_ativo(self):
+        return self._verificar_se_existe_ator_ativo(self._porcos)
+
+    def _verificar_se_existe_ator_ativo(self, atores):
+        for a in atores:
+            if a.status == ATIVO:
+                return True
+        return False
+
+    def _existe_passaro_ativo(self):
+        return self._verificar_se_existe_ator_ativo(self._passaros)
