Merge remote-tracking branch 'origin/simples' into simples-solucao

renzon · renzon · commit 2237ea38dee8 · 2014-11-12T21:25:45.000-02:00
diff --git a/README.md b/README.md
@@ -3,7 +3,7 @@ Python Birds
 
 Essa versão é a mais simples. Ela não contém replay nem reset, de forma que o jogo não pode retroceder.
 
-Para versão mais complexa, acesse a branch [master](https://github.com/pythonprobr/pythonbirds/tree/master)
+Para versão mais complexa, acesse a branch [diversao](https://github.com/pythonprobr/pythonbirds/tree/diversao)
 
 Projeto para Ensino de Programação Orientadas a Objetos em Python.
 
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 self.x, self.y
+        return 1, 1
 
     def colidir(self, outro_ator, intervalo=1):
         """
@@ -51,25 +51,20 @@ def colidir(self, outro_ator, intervalo=1):
         :param intervalo: Intervalo a ser considerado
         :return:
         """
-        if self.status == DESTRUIDO or outro_ator.status == DESTRUIDO:
-            return
+        pass
 
-        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):
-    _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,29 +88,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
-
-    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):
         """
@@ -131,11 +112,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):
@@ -147,23 +124,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
@@ -2,7 +2,6 @@
 from itertools import chain
 from atores import ATIVO
 
-# Status possíveis do jogo
 
 VITORIA = 'VITORIA'
 DERROTA = 'DERROTA'
@@ -37,45 +36,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)
-
-    # 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
+        pass
 
     def status(self):
         """
@@ -89,11 +73,7 @@ def status(self):
 
         :return:
         """
-        if not self._existe_porco_ativo():
-            return VITORIA
-        if self._existe_passaro_ativo():
-            return EM_ANDAMENTO
-        return DERROTA
+        return EM_ANDAMENTO
 
     def lancar(self, angulo, tempo):
         """
@@ -106,10 +86,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):
@@ -121,32 +98,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)
