diff --git a/atores.py b/atores.py
index cfc2ef5ea..e33ec964c 100644
--- a/atores.py
+++ b/atores.py
@@ -9,7 +9,7 @@
 GRAVIDADE = 10  # m/s^2
 
 
-class Ator():
+class Ator:
     """
     Classe que representa um ator. Ele representa um ponto cartesiano na tela.
     """
@@ -38,7 +38,8 @@ 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,17 +53,23 @@ 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):
     pass
@@ -93,7 +100,8 @@ def foi_lancado(self):
 
         :return: booleano
         """
-        return True
+        return not self._tempo_de_lancamento is None
+
 
     def colidir_com_chao(self):
         """
@@ -101,7 +109,8 @@ def colidir_com_chao(self):
         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 +126,12 @@ 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() and self.status == ATIVO:
+            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 +143,29 @@ 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*math.sin(angulo_radianos)*delta_t
+        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*math.cos(angulo_radianos)*delta_t
+        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..c5d0ab81f 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,13 @@ 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 +92,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 +107,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 +119,16 @@ 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/__init__.py b/oo/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/oo/carro.py b/oo/carro.py
new file mode 100644
index 000000000..e48576995
--- /dev/null
+++ b/oo/carro.py
@@ -0,0 +1,147 @@
+"""
+Você deve criar uma classe carro que vai possuir
+dois atributos compostos por outras duas classes:
+
+ 1. Motor
+ 2. Direção
+O Motor terá a responsabilidade de controlar a velocidade.
+Ele oferece os seguintes atributos:
+
+ 1. Atributo de dado velocidade
+ 2. Método acelerar, que deverá incremetar a velocidade de uma unidade
+ 3. Método frear que deverá decrementar a velocidade em duas unidades
+
+A Direção terá a responsabilidade de controlar a direção. Ela oferece
+os seguintes atributos:
+
+1. Valor de diração com valores possíveis: Norte, Sul, Leste, Oeste.
+2. Método girar_a_direita
+3. Método girar_a_esquerda
+
+       N
+    O     L
+       S
+
+Exemplo:
+    >>> # Testando motor
+    >>> motor = Motor()
+    >>> motor.velocidade
+    0
+    >>> motor.acelerar()
+    >>> motor.velocidade
+    1
+    >>> motor.acelerar()
+    >>> motor.velocidade
+    2
+    >>> motor.acelerar()
+    >>> motor.velocidade
+    3
+    >>> motor.frear()
+    >>> motor.velocidade
+    1
+    >>> motor.frear()
+    >>> motor.velocidade
+    0
+    >>> # Testando Direcao
+    >>> direcao = Direcao()
+    >>> direcao.valor
+    'Norte'
+    >>> direcao.girar_a_direita()
+    >>> direcao.valor
+    'Leste'
+    >>> direcao.girar_a_direita()
+    >>> direcao.valor
+    'Sul'
+    >>> direcao.girar_a_direita()
+    >>> direcao.valor
+    'Oeste'
+    >>> direcao.girar_a_direita()
+    >>> direcao.valor
+    'Norte'
+    >>> direcao.girar_a_esquerda()
+    >>> direcao.valor
+    'Oeste'
+    >>> direcao.girar_a_esquerda()
+    >>> direcao.valor
+    'Sul'
+    >>> direcao.girar_a_esquerda()
+    >>> direcao.valor
+    'Leste'
+    >>> direcao.girar_a_esquerda()
+    >>> direcao.valor
+    'Norte'
+    >>> carro = Carro(direcao, motor)
+    >>> carro.calcular_velocidade()
+    0
+    >>> carro.acelerar()
+    >>> carro.calcular_velocidade()
+    1
+    >>> carro.acelerar()
+    >>> carro.calcular_velocidade()
+    2
+    >>> carro.frear()
+    >>> carro.calcular_velocidade()
+    0
+    >>> carro.calcular_direcao()
+    'Norte'
+    >>> carro.girar_a_direita()
+    >>> carro.calcular_direcao()
+    'Leste'
+    >>> carro.girar_a_esquerda()
+    >>> carro.calcular_direcao()
+    'Norte'
+    >>> carro.girar_a_esquerda()
+    >>> carro.calcular_direcao()
+    'Oeste'
+
+"""
+
+
+class Motor:
+
+    def __init__(self, velocidade=0):
+        self.velocidade = velocidade
+
+    def acelerar(self):
+        self.velocidade += 1
+
+    def frear(self):
+        self.velocidade -= 2
+        self.velocidade = max(0,self.velocidade)
+
+class Direcao:
+    DIRECAO = ['Norte', 'Leste', 'Sul', 'Oeste']
+
+    def __init__(self):
+        self.valor = self.DIRECAO[0]
+        self.__direcao = 0
+
+    def girar_a_direita(self):
+        self.__direcao = (self.__direcao + 1) % len(self.DIRECAO)
+        self.valor = self.DIRECAO[self.__direcao]
+
+    def girar_a_esquerda(self):
+        self.__direcao = (self.__direcao - 1) % len(self.DIRECAO)
+        self.valor = self.DIRECAO[self.__direcao]
+
+
+class Carro:
+
+    def __init__(self, direcao, motor):
+        self.motor = Motor()
+        self.direcao = Direcao()
+
+    def calcular_velocidade(self):
+        return self.motor.velocidade
+
+    def acelerar(self):
+        self.motor.acelerar()
+    def frear(self):
+        self.motor.frear()
+    def girar_a_direita(self):
+        self.direcao.girar_a_direita()
+    def girar_a_esquerda(self):
+        self.direcao.girar_a_esquerda()
+    def calcular_direcao(self):
+        return self.direcao.valor
+
diff --git a/oo/pessoa.py b/oo/pessoa.py
new file mode 100644
index 000000000..79ceb44bc
--- /dev/null
+++ b/oo/pessoa.py
@@ -0,0 +1,59 @@
+class Pessoa:
+    olhos = 2
+
+    def __init__(self, *filhos, nome=None, idade=35):
+        self.nome = nome
+        self.idade = idade
+        self.filhos = list(filhos)
+
+    def cumprimentar(self):
+        return f'Olá, meu nome é {self.nome}'
+
+    @staticmethod
+    def metodo_estatico():
+        return 42
+
+    @classmethod
+    def nome_e_atributos_de_classe(cls):
+        return f'{cls} - olhos {cls.olhos}'
+
+
+class Homem(Pessoa):
+    def cumprimentar(self):
+        cumprimentar_da_classe_pai = super().cumprimentar()
+        return f'{cumprimentar_da_classe_pai}. Aperto de mão'
+
+class Mutante(Pessoa):
+    olhos = 3
+
+
+if __name__ == '__main__':
+    renzo = Mutante(nome='Renzo')
+    luciano = Homem(renzo, nome='Luciano')
+    print(Pessoa.cumprimentar(luciano))
+    print(id(luciano))
+    print(luciano.cumprimentar())
+    print(luciano.nome)
+    print(luciano.idade)
+    print(luciano.filhos)
+    for filho in luciano.filhos:
+        print(filho.nome)
+    luciano.sobrenome = 'Ramalho'
+    del luciano.filhos
+    luciano.olhos = 1
+    del luciano.olhos
+    print(luciano.__dict__)
+    print(renzo.__dict__)
+
+    print(Pessoa.olhos)
+    print(luciano.olhos)
+    print(renzo.olhos)
+    print(id(Pessoa.olhos), id(luciano.olhos), id(renzo.olhos))
+    print(Pessoa.metodo_estatico(), luciano.metodo_estatico())
+    print(Pessoa.nome_e_atributos_de_classe(), luciano.nome_e_atributos_de_classe())
+    pessoa = Pessoa('Anonimo')
+    print(isinstance(pessoa, Pessoa))
+    print(isinstance(pessoa, Homem))
+    print(isinstance(renzo, Homem))
+    print(luciano.cumprimentar())
+    print(renzo.cumprimentar())
diff --git a/oo/teste_carro.py b/oo/teste_carro.py
new file mode 100644
index 000000000..0c507cbfb
--- /dev/null
+++ b/oo/teste_carro.py
@@ -0,0 +1,14 @@
+from unittest import TestCase
+
+from oo.carro import Motor
+
+
+class CarroTestCase(TestCase):
+    def teste_velocidade_inicial(self):
+        motor = Motor()
+        self.assertEqual(0, motor.velocidade)
+
+    def teste_acelerar(self):
+        motor = Motor()
+        motor.acelerar()
+        self.assertEqual(1, motor.velocidade)
\ No newline at end of file
diff --git a/testes/atores_testes.py b/testes/testes_atores.py
similarity index 99%
rename from testes/atores_testes.py
rename to testes/testes_atores.py
index f4254f29e..7adbccb42 100644
--- a/testes/atores_testes.py
+++ b/testes/testes_atores.py
@@ -38,7 +38,7 @@ def teste_ator_posicao(self):
         self.assertEqual(0, y)
 
         ator = Ator(0.3, 0.5)
-        x, y = ator.calcular_posicao(10)
+        x, y = ator.calcular_posicao(10) #ator generico não se move na tela
         self.assertEqual(0.3, x)
         self.assertEqual(0.5, y)
 
diff --git a/testes/fase_testes.py b/testes/testes_fase.py
similarity index 100%
rename from testes/fase_testes.py
rename to testes/testes_fase.py
diff --git a/testes/integracao.py b/testes/testes_integracao.py
similarity index 100%
rename from testes/integracao.py
rename to testes/testes_integracao.py