1

README.md

@@ -1,7 +1,7 @@
 [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/pythonprobr/pythonbirds)
 
 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.
 

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,20 @@ 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):
-    pass
+    _caracter_ativo = 'O'
 
 
 class Porco(Ator):
-    pass
+    _caracter_ativo = '@'
+    _caracter_destruido = '+'
 
 
 class DuploLancamentoExcecao(Exception):
@@ -93,15 +97,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 +123,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._esta_voando():
+            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 +139,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
+
+    def _esta_voando(self):
+        return self.foi_lancado() and self.status == ATIVO
 
 
 class PassaroAmarelo(Passaro):
-    pass
+    _caracter_ativo = 'A'
+    _caracter_destruido = 'a'
+    velocidade_escalar = 30
 
 
 class PassaroVermelho(Passaro):
-    pass
+    _caracter_ativo = 'V'
+    _caracter_destruido = 'v'
+    velocidade_escalar = 20

fase.py

@@ -2,7 +2,6 @@
 from itertools import chain
 from atores import ATIVO
 
-
 VITORIA = 'VITORIA'
 DERROTA = 'DERROTA'
 EM_ANDAMENTO = 'EM_ANDAMENTO'
@@ -36,30 +35,29 @@ def __init__(self, intervalo_de_colisao=1):
         self._porcos = []
         self._obstaculos = []
 
-
     def adicionar_obstaculo(self, *obstaculos):
         """
         Adiciona obstáculos em uma fase
 
         :param obstaculos:
         """
-        pass
+        self._obstaculos.extend(obstaculos)
 
     def adicionar_porco(self, *porcos):
         """
         Adiciona porcos em uma fase
 
         :param porcos:
         """
-        pass
+        self._porcos.extend(porcos)
 
     def adicionar_passaro(self, *passaros):
         """
         Adiciona pássaros em uma fase
 
         :param passaros:
         """
-        pass
+        self._passaros.extend(passaros)
 
     def status(self):
         """
@@ -73,7 +71,12 @@ def status(self):
 
         :return:
         """
-        return EM_ANDAMENTO
+        if not self._possui_porco_ativo():
+            return VITORIA
+        elif self._possui_passaros_ativos():
+            return EM_ANDAMENTO
+        else:
+            return DERROTA
 
     def lancar(self, angulo, tempo):
         """
@@ -86,8 +89,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)
+                break
 
     def calcular_pontos(self, tempo):
         """
@@ -98,10 +103,26 @@ def calcular_pontos(self, tempo):
         :param tempo: tempo para o qual devem ser calculados os pontos
         :return: objeto do tipo Ponto
         """
-        pontos=[self._transformar_em_ponto(a) for a in self._passaros+self._obstaculos+self._porcos]
+        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
 
     def _transformar_em_ponto(self, ator):
         return Ponto(ator.x, ator.y, ator.caracter())
 
+    def _possui_porco_ativo(self):
+        for porco in self._porcos:
+            if porco.status == ATIVO:
+                return True
+        return False
+
+    def _possui_passaros_ativos(self):
+        for passaro in self._passaros:
+            if passaro.status == ATIVO:
+                return True
+        return False

oo/pessoa.py

@@ -0,0 +1,40 @@
+class Pessoa:
+    olhos = 2
+    def __init__(self, *filhos, nome=None, idade=38):
+        self.idade = idade
+        self.nome = nome
+        self.filhos = list(filhos)
+
+    def cumprimentar(self):
+        return f'Ola {id(self)}'
+
+    @staticmethod
+    def metodo_estatico():
+        return 42
+
+    @classmethod
+    def nome_e_aributos_de_classe(cls):
+        return f'{cls} - olhos {cls.olhos}'
+
+if __name__ == '__main__':
+    fabio = Pessoa(nome='Fabio')
+    luis = Pessoa(fabio, nome='Luis')
+    print(Pessoa.cumprimentar(luis))
+    print(id(luis))
+    print(luis.cumprimentar())
+    print(luis.nome)
+    print(luis.idade)
+    for filho in luis.filhos:
+        print(filho.nome)
+    luis.sobrenome = 'Santos da Silva'
+    del luis.filhos
+    luis.olhos = 1
+    del luis.olhos
+    print(luis.__dict__)
+    print(fabio.__dict__)
+    print(Pessoa.olhos)
+    print(luis.olhos)
+    print(fabio.olhos)
+    print(id(Pessoa.olhos), id(luis.olhos), id(fabio.olhos))
+    print(Pessoa.metodo_estatico(), luis.metodo_estatico())
+    print(Pessoa.nome_e_aributos_de_classe(), luis.nome_e_aributos_de_classe())

testes/atores_testes.py → testes/test_atores.py

@@ -127,7 +127,7 @@ def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1):
     def assert_nao_colisao(self, ator, ator2):
         """
         Se certifica que não colisão entre dois atores
-        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 apenas encapsula a lógica de não colisão entre dois atores.
         So seja, eles deve manter seus respectivos status mesmo depois da chamada do metodo colidir
         """
@@ -266,7 +266,6 @@ def teste_lacamento_vertical(self):
         passaro_amarelo.lancar(90, 2)  # passaro lancado a 90 graus no tempo 2 segundos
 
 
-
         # subindo
 
         self.assert_posicao_vertical(1, 2.0, passaro_amarelo)