melhora em lógica de colisao

renzon · renzon · commit a94bdc838509 · 2016-12-06T17:21:36.000-02:00
método lançar gerando excecao se executado mais de uma vez
diff --git a/atores.py b/atores.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from __future__ import unicode_literals
+
 import math
 
 DESTRUIDO = 'Destruido'
@@ -17,7 +18,8 @@ class Ator():
 
     def __init__(self, x=0, y=0):
         """
-        Método de inicialização da classe. Deve inicializar os parâmetros x, y, caracter e status
+        Método de inicialização da classe. Deve inicializar os parâmetros x,
+        y, caracter e status
 
         :param x: Posição horizontal inicial do ator
         :param y: Posição vertical inicial do ator
@@ -27,7 +29,8 @@ def __init__(self, x=0, y=0):
         self.status = ATIVO
 
     def caracter(self):
-        return self._caracter_ativo if self.status == ATIVO else self._caracter_destruido
+        return self._caracter_ativo if self.status == ATIVO else \
+            self._caracter_destruido
 
     def calcular_posicao(self, tempo):
         """
@@ -43,8 +46,10 @@ def colidir(self, outro_ator, intervalo=1):
         """
         Método que executa lógica de colisão entre dois atores.
         Só deve haver colisão se os dois atores tiverem seus status ativos.
-        Para colisão, é considerado um quadrado, com lado igual ao parâmetro intervalo, em volta do ponto onde se
-        encontra o ator. Se os atores estiverem dentro desse mesmo quadrado, seus status devem ser alterados para
+        Para colisão, é considerado um quadrado, com lado igual ao parâmetro
+        intervalo, em volta do ponto onde se
+        encontra o ator. Se os atores estiverem dentro desse mesmo quadrado,
+        seus status devem ser alterados para
         destruido, seus caracteres para destruido também.
 
         :param outro_ator: Ator a ser considerado na colisão
@@ -54,7 +59,8 @@ def colidir(self, outro_ator, intervalo=1):
         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:
+        if abs(self.x - outro_ator.x) <= intervalo and abs(
+                        self.y - outro_ator.y) <= intervalo:
             self.status = DESTRUIDO
             outro_ator.status = DESTRUIDO
 
@@ -68,14 +74,19 @@ class Porco(Ator):
     _caracter_destruido = '+'
 
 
+class DuploLancamentoExcecao(Exception):
+    pass
+
+
 class Passaro(Ator):
     velocidade_escalar = None
 
     def __init__(self, x=0, y=0):
         """
         Método de inicialização de pássaro.
 
-        Deve chamar a inicialização de ator. Além disso, deve armazenar a posição inicial e incializar o tempo de
+        Deve chamar a inicialização de ator. Além disso, deve armazenar a
+        posição inicial e incializar o tempo de
         lançamento e angulo de lançamento
 
         :param x:
@@ -89,27 +100,33 @@ def __init__(self, x=0, y=0):
 
     def foi_lancado(self):
         """
-        Método que retorna verdaeira se o pássaro já foi lançado e falso caso contrário
+        Método que retorna verdadeiro se o pássaro já foi lançado e falso
+        caso contrário
 
         :return: booleano
         """
         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
+        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
 
         """
         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)
+        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) -
+                  self.velocidade_escalar * delta_t * math.sin(
+                      self._angulo_de_lancamento) -
                   (GRAVIDADE / 2) * delta_t ** 2)
 
     def _calcular_posicao(self, tempo):
@@ -121,12 +138,16 @@ def calcular_posicao(self, tempo):
         """
         Método que cálcula a posição do passaro de acordo com o tempo.
 
-        Antes do lançamento o pássaro deve retornar o valor de sua posição inicial
+        Antes do lançamento o pássaro deve retornar o valor de sua posição
+        inicial
 
-        Depois do lançamento o pássaro deve calcular de acordo com sua posição inicial, velocidade escalar,
-        ângulo de lancamento, gravidade (constante GRAVIDADE) e o tempo do jogo.
+        Depois do lançamento o pássaro deve calcular de acordo com sua
+        posição inicial, velocidade escalar,
+        ângulo de lancamento, gravidade (constante GRAVIDADE) e o tempo do
+        jogo.
 
-        Após a colisão, ou seja, ter seus status destruido, o pássaro deve apenas retornar a última posição calculada.
+        Após a colisão, ou seja, ter seus status destruido, o pássaro deve
+        apenas retornar a última posição calculada.
 
         :param tempo: tempo de jogo a ser calculada a posição
         :return: posição x, y
@@ -137,16 +158,18 @@ def calcular_posicao(self, tempo):
             self._calcular_posicao(tempo)
         return self.x, self.y
 
-
     def lancar(self, angulo, tempo_de_lancamento):
         """
-        Lógica que lança o pássaro. Deve armazenar o ângulo e o tempo de lançamento para posteriores cálculo.
+        Lógica que lança o pássaro. Deve armazenar o ângulo e o tempo de
+        lançamento para posteriores cálculo.
         O ângulo é passado em graus e deve ser transformado em radianos
 
         :param angulo:
         :param tempo_de_lancamento:
         :return:
         """
+        if self.foi_lancado():
+            raise DuploLancamentoExcecao('Pássaro já foi lançado')
         self._tempo_de_lancamento = tempo_de_lancamento
         self._angulo_de_lancamento = math.radians(angulo)
 
diff --git a/fase.py b/fase.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 from itertools import chain
-from atores import ATIVO
+from atores import ATIVO, DuploLancamentoExcecao
 
 # Status possíveis do jogo
 
@@ -104,11 +104,14 @@ def lancar(self, angulo, tempo):
         Se não houver esse tipo de pássaro, não deve fazer nada
 
         :param angulo: ângulo de lançamento
-        :param tempo: Tempo de lançamento
+        :param tempo: tempo de lançamento
         """
         for passaro in self._passaros:
-            if not passaro.foi_lancado():
+            try:
                 passaro.lancar(angulo, tempo)
+            except DuploLancamentoExcecao:
+                continue
+            else:
                 return
 
 
diff --git a/testes/atores_testes.py b/testes/atores_testes.py
@@ -2,7 +2,8 @@
 
 from __future__ import unicode_literals
 from unittest.case import TestCase
-from atores import Ator, DESTRUIDO, ATIVO, Obstaculo, Porco, PassaroAmarelo, PassaroVermelho
+from atores import Ator, DESTRUIDO, ATIVO, Obstaculo, Porco, PassaroAmarelo, PassaroVermelho, \
+    DuploLancamentoExcecao
 
 
 class AtorTestes(TestCase):
@@ -206,6 +207,15 @@ def teste_foi_lancado(self):
         self.assertTrue(passaro_vermelho.foi_lancado(),
                         'Se o método lançar foi executado, deve retornar verdadeiro')
 
+    def test_excecao_ao_lancar_passaro_pela_segunda_vez(self):
+        """Se certifica que pássaro só pode ser lançado uma vez"""
+        passaro = PassaroVermelho(0,0)
+        passaro.lancar(0,0)
+        with self.assertRaises(DuploLancamentoExcecao):
+            passaro.lancar(1,1)
+        self.assertEqual(passaro._angulo_de_lancamento,0,'Deveria continuar com angulo passado no primeiro lançamento')
+        self.assertEqual(passaro._tempo_de_lancamento,0,'Deveria continuar com tempo passado no primeiro lançamento')
+
     def teste_colisao_com_chao(self):
         """
         Testando que o passáro colido quando sua posição y é menor ou igual a 0
@@ -229,6 +239,7 @@ def teste_colisao_com_chao(self):
 
 
 class PassaroAmareloTests(PassaroBaseTests):
+
     """
     Classe de Tests para passaros amarelos
     """
@@ -243,9 +254,10 @@ def teste_status(self):
     def teste_velocidade_escalar(self):
         self.assertEqual(30, PassaroAmarelo.velocidade_escalar)
 
+
     def teste_lacamento_vertical(self):
         """
-        Tests de lançamento vertical. Nele, o passaro só se move verticalmente e sua posição y se matém contanstante
+        Testes de lançamento vertical. Nele, o passaro só se move verticalmente e sua posição y se matém contanstante
         :return:
         """
         passaro_amarelo = PassaroAmarelo(1, 1)
