From fb4da31f3a481772fa0fc2e3db15d472b122cd5a Mon Sep 17 00:00:00 2001
From: jonatasilva <jonatas.iw@gmail.com>
Date: Tue, 21 Apr 2020 16:19:46 -0300
Subject: [PATCH 1/7] Criada classe pessoa

---
 oo/__init__.py | 0
 oo/pessoa.py   | 2 ++
 2 files changed, 2 insertions(+)
 create mode 100644 oo/__init__.py
 create mode 100644 oo/pessoa.py

diff --git a/oo/__init__.py b/oo/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/oo/pessoa.py b/oo/pessoa.py
new file mode 100644
index 000000000..e1da50e22
--- /dev/null
+++ b/oo/pessoa.py
@@ -0,0 +1,2 @@
+class Pessoa:
+    pass
\ No newline at end of file

From 728964dfc86ffea1d960f4000aeed4d630bf35a9 Mon Sep 17 00:00:00 2001
From: jonatasilva <jonatas.iw@gmail.com>
Date: Tue, 21 Apr 2020 18:29:30 -0300
Subject: [PATCH 2/7] Enviar atributos de instancia Pessoa

---
 oo/pessoa.py | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/oo/pessoa.py b/oo/pessoa.py
index e1da50e22..71f2b4675 100644
--- a/oo/pessoa.py
+++ b/oo/pessoa.py
@@ -1,2 +1,16 @@
 class Pessoa:
-    pass
\ No newline at end of file
+    def __init__(self, nome = None, idade=33):
+        self.idade = idade
+        self.nome = nome
+
+    def cumprimentar(self):
+        return f'Olá {id(self)}'
+
+if __name__ == '__main__':
+    p = Pessoa('Silva')
+    print(p.cumprimentar())
+    print(id(p))
+    print(p.nome)
+    p.nome = "Jonatas"
+    print(p.nome)
+    print(p.idade)

From 254a1d5a3a2f1e5d64eacb0451dda55f561d145f Mon Sep 17 00:00:00 2001
From: jonatasilva <jonatas.iw@gmail.com>
Date: Tue, 21 Apr 2020 19:31:35 -0300
Subject: [PATCH 3/7] Criar atributo complexo filhos

---
 oo/pessoa.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/oo/pessoa.py b/oo/pessoa.py
index 71f2b4675..835401974 100644
--- a/oo/pessoa.py
+++ b/oo/pessoa.py
@@ -1,16 +1,18 @@
 class Pessoa:
-    def __init__(self, nome = None, idade=33):
+    def __init__(self, *filhos, nome = None, idade=33):
         self.idade = idade
         self.nome = nome
+        self.filhos = list(filhos)
 
     def cumprimentar(self):
         return f'Olá {id(self)}'
 
 if __name__ == '__main__':
-    p = Pessoa('Silva')
-    print(p.cumprimentar())
-    print(id(p))
-    print(p.nome)
-    p.nome = "Jonatas"
-    print(p.nome)
-    print(p.idade)
+    jonatas = Pessoa(nome='Jonatas')
+    silva = Pessoa(jonatas,nome='Silva')
+    print(silva.cumprimentar())
+    print(id(silva))
+    print(silva.nome)
+    print(silva.idade)
+    for filho in silva.filhos:
+        print(filho.nome)

From 8a396576c57d02a0ac9a7299b804df1dbcd5465b Mon Sep 17 00:00:00 2001
From: jonatasilva <jonatas.iw@gmail.com>
Date: Tue, 21 Apr 2020 19:37:47 -0300
Subject: [PATCH 4/7] Criar e remover atribuito dinamico de objeto pessoa

---
 oo/pessoa.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/oo/pessoa.py b/oo/pessoa.py
index 835401974..cfc0c40f9 100644
--- a/oo/pessoa.py
+++ b/oo/pessoa.py
@@ -16,3 +16,7 @@ def cumprimentar(self):
     print(silva.idade)
     for filho in silva.filhos:
         print(filho.nome)
+    jonatas.sobrenome = 'oliveira'
+    del jonatas.filhos
+    print(silva.__dict__)
+    print(jonatas.__dict__)
\ No newline at end of file

From 0ac2493a8ef83c94a87ef144a862a93d47bf5cc4 Mon Sep 17 00:00:00 2001
From: jonatasilva <jonatas.iw@gmail.com>
Date: Tue, 21 Apr 2020 20:06:03 -0300
Subject: [PATCH 5/7] Criado atributo de classe olhos

---
 oo/pessoa.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/oo/pessoa.py b/oo/pessoa.py
index cfc0c40f9..8ce1b6640 100644
--- a/oo/pessoa.py
+++ b/oo/pessoa.py
@@ -1,4 +1,6 @@
 class Pessoa:
+    olhos = 2 #atributo de classe, ou atributo default
+
     def __init__(self, *filhos, nome = None, idade=33):
         self.idade = idade
         self.nome = nome
@@ -19,4 +21,8 @@ def cumprimentar(self):
     jonatas.sobrenome = 'oliveira'
     del jonatas.filhos
     print(silva.__dict__)
-    print(jonatas.__dict__)
\ No newline at end of file
+    print(jonatas.__dict__)
+    print(Pessoa.olhos)
+    print(jonatas.olhos)
+    print(silva.olhos)
+    print(id(silva.olhos), id(jonatas.olhos))
\ No newline at end of file

From 3fb9ba8183889f1e07bc50ddf0bc3e0e055c071e Mon Sep 17 00:00:00 2001
From: jonatasilva <jonatas.iw@gmail.com>
Date: Tue, 21 Apr 2020 22:10:24 -0300
Subject: [PATCH 6/7] Implementecao Carro Completo

---
 oo/carro.py   | 61 +++++++++++++++++++++++++++++++++++++++++++++++++++
 oo/direcao.py | 25 +++++++++++++++++++++
 oo/motor.py   | 32 +++++++++++++++++++++++++++
 oo/pessoa.py  | 12 +++++++++-
 4 files changed, 129 insertions(+), 1 deletion(-)
 create mode 100644 oo/carro.py
 create mode 100644 oo/direcao.py
 create mode 100644 oo/motor.py

diff --git a/oo/carro.py b/oo/carro.py
new file mode 100644
index 000000000..fe0879c7c
--- /dev/null
+++ b/oo/carro.py
@@ -0,0 +1,61 @@
+"""
+>>> c = Carro(Motor(), Direcao())
+>>> c.direcao.valor
+'norte'
+>>> c.calcular_velocidade()
+"""
+
+from oo.direcao import Direcao
+from oo.motor import Motor
+
+
+class Carro:
+
+    def __init__(self, motor =  Motor(), direcao = Direcao()):
+        self.direcao = direcao
+        self.motor = motor
+
+    def calcular_velocidade(self):
+        return self.motor.velocidade
+
+    def frear(self):
+        self.motor.frear()
+
+    def acelerar(self):
+        self.motor.acelerar()
+
+    def calcular_direcao(self):
+        return self.direcao.valor
+
+    def girar_direita(self):
+        self.direcao.girar_direita()
+
+    def girar_esquerda(self):
+        self.direcao.girar_esquerda()
+
+
+
+
+if __name__ == '__main__':
+    c = Carro(Motor(), Direcao())
+    c2 = Carro(Motor(), Direcao())
+
+    print(c.direcao.valor)
+    print(c.calcular_velocidade())
+
+    c.acelerar()
+    print(c.calcular_velocidade())
+
+    c.acelerar()
+    print(c.calcular_velocidade())
+
+    print(c2.calcular_velocidade())
+    c2.acelerar()
+    print(c2.calcular_velocidade())
+
+    c.girar_direita()
+    print(c.calcular_direcao())
+
+    # c2.girar_direita()
+    print(c2.calcular_direcao())
+
diff --git a/oo/direcao.py b/oo/direcao.py
new file mode 100644
index 000000000..03b264bc1
--- /dev/null
+++ b/oo/direcao.py
@@ -0,0 +1,25 @@
+NORTE = 'norte'
+LESTE = 'leste'
+SUL = 'sul'
+OESTE = 'oeste'
+
+class Direcao:
+    rotacao_direita_dic = {NORTE:LESTE, LESTE:SUL, OESTE:LESTE, LESTE:NORTE}
+    rotacao_esquerda_dic = {NORTE:OESTE, OESTE:SUL, SUL:LESTE, LESTE:NORTE}
+
+    def __init__(self):
+        self.valor = 'norte';
+
+    def girar_esquerda(self):
+        self.valor = self.rotacao_esquerda_dic[self.valor]
+
+    def girar_direita(self):
+        self.valor = self.rotacao_direita_dic[self.valor]
+
+if __name__ == '__main__':
+    d = Direcao()
+    print(d.valor)
+    d.girar_direita()
+    print(d.valor)
+    d.girar_esquerda()
+    print(d.valor)
\ No newline at end of file
diff --git a/oo/motor.py b/oo/motor.py
new file mode 100644
index 000000000..0a1b8afcb
--- /dev/null
+++ b/oo/motor.py
@@ -0,0 +1,32 @@
+class Motor:
+
+    def __init__(self, velocidade = 0):
+        self.velocidade = velocidade
+
+    def acelerar(self):
+        self.velocidade += 1;
+
+    def frear(self):
+
+        if(self.velocidade > 1):
+            self.velocidade -= 2;
+        else:
+            self.velocidade = 0
+
+if __name__ == '__main__':
+    m = Motor()
+
+    m.acelerar()
+    print(m.velocidade)
+
+    m.acelerar()
+    print(m.velocidade)
+
+    m.acelerar()
+    print(m.velocidade)
+
+    m.frear()
+    print(m.velocidade)
+
+    m.frear()
+    print(m.velocidade)
\ No newline at end of file
diff --git a/oo/pessoa.py b/oo/pessoa.py
index 8ce1b6640..981ae36f8 100644
--- a/oo/pessoa.py
+++ b/oo/pessoa.py
@@ -9,6 +9,14 @@ def __init__(self, *filhos, nome = None, idade=33):
     def cumprimentar(self):
         return f'Olá {id(self)}'
 
+    @staticmethod
+    def metodo_estatico():
+        return 33
+
+    @classmethod
+    def nome_e_atributos_de_classe(cls):
+        return f'{cls} - olhos {cls.olhos}'
+
 if __name__ == '__main__':
     jonatas = Pessoa(nome='Jonatas')
     silva = Pessoa(jonatas,nome='Silva')
@@ -25,4 +33,6 @@ def cumprimentar(self):
     print(Pessoa.olhos)
     print(jonatas.olhos)
     print(silva.olhos)
-    print(id(silva.olhos), id(jonatas.olhos))
\ No newline at end of file
+    print(id(silva.olhos), id(jonatas.olhos))
+    print(Pessoa.metodo_estatico(), jonatas.metodo_estatico())
+    print(Pessoa.nome_e_atributos_de_classe())
\ No newline at end of file

From b40f8ab4cef8d9b3f3f8874cb882b0fa7e3776f5 Mon Sep 17 00:00:00 2001
From: jonatasilva <jonatas.iw@gmail.com>
Date: Wed, 22 Apr 2020 16:04:17 -0300
Subject: [PATCH 7/7] testes completados e implementacao movimentacao e colisao

---
 atores.py               | 47 ++++++++++++++++++++++++++++++++---------
 fase.py                 | 35 +++++++++++++++++++++++++-----
 oo/pessoa.py            | 26 +++++++++++++++++++----
 oo/test_carro.py        | 21 ++++++++++++++++++
 testes/atores_testes.py | 16 +++++++-------
 testes/fase_testes.py   |  2 +-
 6 files changed, 119 insertions(+), 28 deletions(-)
 create mode 100644 oo/test_carro.py

diff --git a/atores.py b/atores.py
index cfc2ef5ea..35d695787 100644
--- a/atores.py
+++ b/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,7 +97,8 @@ def foi_lancado(self):
 
         :return: booleano
         """
-        return True
+        return not self._tempo_de_lancamento is None
+
 
     def colidir_com_chao(self):
         """
@@ -117,7 +122,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.foi_lancado():
+            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 +138,30 @@ def lancar(self, angulo, tempo_de_lancamento):
         :param tempo_de_lancamento:
         :return:
         """
-        pass
+        self._angulo_de_lancamento = angulo
+        self._tempo_de_lancamento = tempo_de_lancamento
+
+    def _calcular_posicao_vertical(self, delta_t):
+        y_atual = self._y_inicial
+        angulo_radianos=math.radians(self._angulo_de_lancamento)
+        y_atual += self.velocidade_escalar*delta_t * math.sin(angulo_radianos)
+        y_atual -= (GRAVIDADE/2) * delta_t**2
+        self.y=y_atual
+
+    def _calcular_posicao_horizontal(self, delta_t):
+        x_atual = self._x_inicial
+        angulo_radianos=math.radians(self._angulo_de_lancamento)
+        x_atual += self.velocidade_escalar * delta_t*math.cos(angulo_radianos)
+        self.x = x_atual
 
 
 class PassaroAmarelo(Passaro):
-    pass
+    _caracter_ativo = 'A'
+    _caracter_destruido = 'a'
+    velocidade_escalar = 30
 
 
 class PassaroVermelho(Passaro):
-    pass
\ No newline at end of file
+    _caracter_ativo = 'V'
+    _caracter_destruido = 'v'
+    velocidade_escalar = 20
\ No newline at end of file
diff --git a/fase.py b/fase.py
index 3385175c6..5cb00a0cb 100644
--- a/fase.py
+++ b/fase.py
@@ -43,7 +43,7 @@ def adicionar_obstaculo(self, *obstaculos):
 
         :param obstaculos:
         """
-        pass
+        self._obstaculos.extend(obstaculos)
 
     def adicionar_porco(self, *porcos):
         """
@@ -51,7 +51,7 @@ def adicionar_porco(self, *porcos):
 
         :param porcos:
         """
-        pass
+        self._porcos.extend(porcos)
 
     def adicionar_passaro(self, *passaros):
         """
@@ -59,7 +59,7 @@ def adicionar_passaro(self, *passaros):
 
         :param passaros:
         """
-        pass
+        self._passaros.extend(passaros)
 
     def status(self):
         """
@@ -73,7 +73,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,7 +91,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,6 +106,11 @@ def calcular_pontos(self, tempo):
         :param tempo: tempo para o qual devem ser calculados os pontos
         :return: objeto do tipo Ponto
         """
+        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
@@ -105,3 +118,15 @@ def calcular_pontos(self, tempo):
     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
+
diff --git a/oo/pessoa.py b/oo/pessoa.py
index 981ae36f8..8834ad24e 100644
--- a/oo/pessoa.py
+++ b/oo/pessoa.py
@@ -7,7 +7,7 @@ def __init__(self, *filhos, nome = None, idade=33):
         self.filhos = list(filhos)
 
     def cumprimentar(self):
-        return f'Olá {id(self)}'
+        return f'Olá {self.nome}'
 
     @staticmethod
     def metodo_estatico():
@@ -17,9 +17,18 @@ def metodo_estatico():
     def nome_e_atributos_de_classe(cls):
         return f'{cls} - olhos {cls.olhos}'
 
+
+class Homem(Pessoa):
+    def cumprimentar(self):
+        cumprimentar_classe=super().cumprimentar()
+        return f"{cumprimentar_classe} Aperto de mao"
+
+class Mutante(Pessoa):
+    olhos = 3
+
 if __name__ == '__main__':
-    jonatas = Pessoa(nome='Jonatas')
-    silva = Pessoa(jonatas,nome='Silva')
+    jonatas = Mutante(nome='Jonatas')
+    silva = Homem(jonatas,nome='Silva')
     print(silva.cumprimentar())
     print(id(silva))
     print(silva.nome)
@@ -35,4 +44,13 @@ def nome_e_atributos_de_classe(cls):
     print(silva.olhos)
     print(id(silva.olhos), id(jonatas.olhos))
     print(Pessoa.metodo_estatico(), jonatas.metodo_estatico())
-    print(Pessoa.nome_e_atributos_de_classe())
\ No newline at end of file
+    print(Pessoa.nome_e_atributos_de_classe())
+    pessoa = Pessoa('Anonimo')
+    print(isinstance(pessoa, Pessoa))
+    print(isinstance(pessoa, Homem))
+
+    print(isinstance(jonatas, Homem))
+    print(isinstance(jonatas, Pessoa))
+    print(jonatas.olhos)
+    print(silva.cumprimentar())
+    print(jonatas.cumprimentar())
\ No newline at end of file
diff --git a/oo/test_carro.py b/oo/test_carro.py
new file mode 100644
index 000000000..314b9023e
--- /dev/null
+++ b/oo/test_carro.py
@@ -0,0 +1,21 @@
+from unittest import TestCase
+
+from oo.motor import Motor
+
+
+class CarroTestCase(TestCase):
+    def test_velocidade_inicial(self):
+        motor=Motor()
+        self.assertEqual(0,motor.velocidade)
+
+    def test_acelerar(self):
+        motor=Motor()
+        motor.acelerar()
+        self.assertEqual(1,motor.velocidade)
+
+    def test_frear(self):
+        motor=Motor()
+        motor.acelerar()
+        motor.acelerar()
+        motor.frear()
+        self.assertEqual(0,motor.velocidade)
\ No newline at end of file
diff --git a/testes/atores_testes.py b/testes/atores_testes.py
index f4254f29e..b3718dfde 100644
--- a/testes/atores_testes.py
+++ b/testes/atores_testes.py
@@ -14,7 +14,7 @@
 
 
 class AtorTestes(TestCase):
-    def teste_valores_padrao(self):
+    def test_valores_padrao(self):
         'Testa valores iniciais padrão de um Ator'
         ator = Ator()
         self.assertEqual(0, ator.x)
@@ -22,7 +22,7 @@ def teste_valores_padrao(self):
         self.assertEqual(ATIVO, ator.status)
         self.assertEqual('A', ator.caracter())
 
-    def teste_valores_passados_por_parametro(self):
+    def test_valores_passados_por_parametro(self):
         'Testa se valores passados no inicializador são armazenados no objeto'
         ator = Ator(1, 2)
         self.assertEqual(1, ator.x)
@@ -30,7 +30,7 @@ def teste_valores_passados_por_parametro(self):
         self.assertEqual(ATIVO, ator.status)
         self.assertEqual('A', ator.caracter())
 
-    def teste_ator_posicao(self):
+    def test_ator_posicao(self):
         'Teste que verifica que o ator comum não deve se mover independente do tempo do jogo'
         ator = Ator()
         x, y = ator.calcular_posicao(0)
@@ -43,7 +43,7 @@ def teste_ator_posicao(self):
         self.assertEqual(0.5, y)
 
 
-    def teste_colisao_entre_atores_ativos(self):
+    def test_colisao_entre_atores_ativos(self):
         """
         Teste de colisão entre dois atores
         Inicialmente atores possuem status ATIVO. Ao se chocarem, ele muda para DESTRUIDO
@@ -62,11 +62,11 @@ def teste_colisao_entre_atores_ativos(self):
         self.assert_colisao_atores_ativos(Ator(2, 2), Ator(1, 2))
         self.assert_colisao_atores_ativos(Ator(2, 2), Ator(1, 3))
 
-    def teste_colisao_entre_atores_ativos_com_intervalo(self):
+    def test_colisao_entre_atores_ativos_com_intervalo(self):
         # Com intervalo 2, diferente do padrão 1, essa colisão deveria acontecer
         self.assert_colisao_atores_ativos(Ator(2, 2), Ator(2, 4), 2)
 
-    def teste_nao_colisao_entre_atores_distantes(self):
+    def test_nao_colisao_entre_atores_distantes(self):
         'Teste de que não há colisão entre atores distantes'
         self.assert_nao_colisao(Ator(2, 2), Ator(2, 4))
         self.assert_nao_colisao(Ator(2, 2), Ator(3, 4))
@@ -77,7 +77,7 @@ def teste_nao_colisao_entre_atores_distantes(self):
         self.assert_nao_colisao(Ator(2, 2), Ator(0, 2))
         self.assert_nao_colisao(Ator(2, 2), Ator(0, 4))
 
-    def teste_colisao_somente_um_ator_destruido(self):
+    def test_colisao_somente_um_ator_destruido(self):
         'Teste de que um ator destruído não pode colidir com nenhum outro, mesmo que estejam próximos'
         ator = Ator(2, 2)
         ator.colidir(ator, 0)  # colidindo ator com ele mesmo para alterar seu status para destruido
@@ -113,7 +113,7 @@ def test_caracter(self):
     def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1):
         """
         Se certifica que há colisão entre atores ativos
-        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 serve apenas para encapsular toda lógica de teste de colisão entre dois atores ativos
         """
         # Conferindo status dos dois atores antes da colisão
diff --git a/testes/fase_testes.py b/testes/fase_testes.py
index 8158a43f5..dc0dcfbd3 100644
--- a/testes/fase_testes.py
+++ b/testes/fase_testes.py
@@ -179,7 +179,7 @@ def teste_lancar_passaro_sem_erro_quando_nao_existe_passaro(self):
         self.assertTrue(passaros[0].foi_lancado())
         self.assertTrue(passaros[1].foi_lancado())
 
-    def teste_intervalo_de_colisao_padrão(self):
+    def teste_intervalo_de_colisao_padrao(self):
         '''
         Método que testa se o intervalo de colisão da Fase é repassado aos
         atores. Padrão de intervalo é 1