Retirada de lógica de componentes a serem implementados

renzon · renzon · commit a6a3ecbf2bc3 · 2014-09-01T10:30:12.000-03:00
diff --git a/atores.py b/atores.py
@@ -35,7 +35,7 @@ def calcular_posicao(self, tempo):
         :param tempo: o tempo do jogo
         :return: posição x, y do ator
         """
-        return self.x, self.y
+        return 1, 1
 
     def colidir(self, outro_ator, intervalo=1):
         """
@@ -47,29 +47,20 @@ def colidir(self, outro_ator, intervalo=1):
 
         :param outro_ator: Ator a ser considerado na colisão
         :param intervalo: Intervalo a ser considerado
-        :return:
         """
-        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
-            self.caracter = self._caracter_destruido
-            outro_ator.caracter = outro_ator._caracter_destruido
-            outro_ator.status = DESTRUIDO
+        pass
 
 
 class Obstaculo(Ator):
-    _caracter_ativo = 'O'
+    pass
 
 
 class Porco(Ator):
-    _caracter_ativo = '@'
-    _caracter_destruido = '+'
+    pass
 
 
 class Passaro(Ator):
-    velocidade_escalar = None
+    velocidade_escalar = 10
 
     def __init__(self, x=0, y=0):
         """
@@ -93,30 +84,15 @@ def foi_lancado(self):
 
         :return: booleano
         """
-        return self._tempo_de_lancamento is not None
+        return True
 
     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
 
         """
-        if self.y <= 0:
-            self.status = DESTRUIDO
-            self.caracter = self._caracter_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)
+        pass
 
     def calcular_posicao(self, tempo):
         """
@@ -132,11 +108,7 @@ def calcular_posicao(self, tempo):
         :param tempo: tempo de jogo a ser calculada a posição
         :return: posição x, y
         """
-        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
+        return 1, 1
 
 
     def lancar(self, angulo, tempo_de_lancamento):
@@ -148,23 +120,12 @@ def lancar(self, angulo, tempo_de_lancamento):
         :param tempo_de_lancamento:
         :return:
         """
-        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
+        pass
 
 
 class PassaroAmarelo(Passaro):
-    velocidade_escalar = 30  # m/s
-    _caracter_ativo = 'A'
-    _caracter_destruido = 'a'
+    pass
 
 
 class PassaroVermelho(Passaro):
-    velocidade_escalar = 20  # m/s
-    _caracter_ativo = 'V'
-    _caracter_destruido = 'v'
+    pass
diff --git a/fase.py b/fase.py
@@ -28,32 +28,30 @@ 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:
         """
-        self._adicionar_ator(self._obstaculos, *obstaculos)
+        pass
 
     def adicionar_porco(self, *porcos):
         """
         Adiciona porcos em uma fase
 
         :param porcos:
         """
-        self._adicionar_ator(self._porcos, *porcos)
+        pass
 
     def adicionar_passaro(self, *passaros):
         """
         Adiciona pássaros em uma fase
 
         :param passaros:
         """
-        self._adicionar_ator(self._passaros, *passaros)
+        pass
 
     def acabou(self):
         """
@@ -66,7 +64,7 @@ def acabou(self):
 
         :return: booleano
         """
-        return not self._existe_porco_ativo() or not self._existe_passaro_ativo()
+        return True
 
     def status(self):
         """
@@ -78,12 +76,8 @@ def status(self):
 
         Se o jogo acabou com vitória (não existe porco ativo), retorna essa mensagem
 
-        :return:
+        :return: Mensagem de status
         """
-        if not self._existe_porco_ativo():
-            return 'Jogo em encerrado. Você ganhou!'
-        if self._existe_passaro_ativo():
-            return 'Jogo em andamento.'
         return 'Jogo em encerrado. Você perdeu!'
 
     def lancar(self, angulo, tempo):
@@ -97,11 +91,7 @@ def lancar(self, angulo, tempo):
         :param angulo: ângulo de lançamento
         :param tempo: Tempo de lançamento
         """
-        for passaro in self._passaros:
-            if not passaro.foi_lancado():
-                passaro.lancar(angulo, tempo)
-                return
-
+        pass
 
     def calcular_pontos(self, tempo):
         """
@@ -112,32 +102,10 @@ def calcular_pontos(self, tempo):
         :param tempo: tempo para o qual devem ser calculados os pontos
         :return: objeto do tipo Ponto
         """
-        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])
+        pontos=[]
+
         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)
