diff --git a/.gitignore b/.gitignore
index 6220a9500..999174f74 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,6 +18,7 @@ lib64/
 parts/
 sdist/
 var/
+.vscode
 *.egg-info/
 .installed.cfg
 *.egg
diff --git a/atores.py b/atores.py
index cfc2ef5ea..5866f61ab 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,22 @@ 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"
+    _caracter_destruido = " "
 
 
 class Porco(Ator):
-    pass
+    _caracter_ativo = "@"
+    _caracter_destruido = "+"
 
 
 class DuploLancamentoExcecao(Exception):
@@ -93,7 +99,7 @@ def foi_lancado(self):
 
         :return: booleano
         """
-        return True
+        return not self._tempo_de_lancamento is None
 
     def colidir_com_chao(self):
         """
@@ -101,7 +107,9 @@ 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 +125,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() 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 +141,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
+
 
 
 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
diff --git a/fase.py b/fase.py
index 3385175c6..564676866 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_passaro_ativo():
+            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,12 @@ 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_passaro_ativo(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..b53963c80
--- /dev/null
+++ b/oo/carro.py
@@ -0,0 +1,197 @@
+"""
+Você deve criar uma classe carro que vai possuir
+butos compostos por outras duas classes:
+
+Motor
+Direção
+O Motor terá a responsabilidade de controlar a velocidade.
+Ele oferece os seguintes atributos:
+
+Atributo de dado velocidade
+Método acelerar, que deverá incremetar a velocidade de uma unidade
+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:
+
+Valor de diração com valores possíveis: Norte, Sul, Leste, Oeste.
+Método girar_a_direita
+Método girar_a_esquerda
+
+        N
+    O       L
+        S
+
+IMPORTANTE:
+Para rodar o doctest, no terminal:
+python -m doctest <nome_do_arquivo>.py      # rodar todos os testes de uma só vez.
+python -m doctest -f <nome_do_arquivo>.py   # rodar testes e para na primeira falha.
+
+>>> # 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 Direcao:
+
+    def __init__(self, valor="Norte"):
+        self.valor = valor
+    
+    def girar_a_direita(self):
+        if self.valor == "Norte":
+            self.valor = "Leste"
+        elif self.valor == "Leste":
+            self.valor = "Sul"
+        elif self.valor == "Sul":
+            self.valor = "Oeste"
+        else:
+            self.valor = "Norte"
+    
+    def girar_a_esquerda(self):
+        if self.valor == "Norte":
+            self.valor = "Oeste"
+        elif self.valor == "Oeste":
+            self.valor = "Sul"
+        elif self.valor == "Sul":
+            self.valor = "Leste"
+        else:
+            self.valor = "Norte"
+
+
+class Motor:
+
+    def __init__(self, velocidade=0):
+        self.velocidade = velocidade
+
+    def acelerar(self):
+        self.velocidade += 1
+            
+    def frear(self):
+        if self.velocidade-2 < 0:
+            self.velocidade = 0
+        else:
+            self.velocidade -= 2
+
+
+class Carro:
+    ## Se eu tivesse deixado as classes Motor e Direcao em arquivos separados do
+    ## carro.py, as chamadas de impoortação deveriam ser colocadas.
+    # from direcao import Direcao
+    # from motor import Motor
+
+    def __init__(self, direcao=Direcao(), motor=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 calcular_direcao(self):
+        return self.direcao.valor
+    
+    def girar_a_direita(self):
+        self.direcao.girar_a_direita()
+    
+    def girar_a_esquerda(self):
+        self.direcao.girar_a_esquerda()
+
+
+# if __name__ == "__main__":
+#     from direcao import Direcao
+#     from motor import Motor
+#     carro = Carro(Direcao("Sul"), Motor(10))
+#     print(carro.calcular_velocidade())
+#     print(0)
+#     carro.acelerar()
+#     print(carro.calcular_velocidade())
+#     print(1)
+#     carro.acelerar()
+#     print(carro.calcular_velocidade())
+#     print(2)
+#     carro.frear()
+#     print(carro.calcular_velocidade())
+#     print(0)
+#     print(carro.calcular_direcao())
+#     print('Norte')
+#     carro.girar_a_direita()
+#     print(carro.calcular_direcao())
+#     print('Leste')
+#     carro.girar_a_esquerda()
+#     print(carro.calcular_direcao())
+#     print('Norte')
+#     carro.girar_a_esquerda()
+#     print(carro.calcular_direcao())
+#     print('Oeste')
diff --git a/oo/direcao.py b/oo/direcao.py
new file mode 100644
index 000000000..d7bc5be65
--- /dev/null
+++ b/oo/direcao.py
@@ -0,0 +1,57 @@
+class Direcao:
+
+    def __init__(self, valor="Norte"):
+        self.valor = valor
+    
+    def girar_a_direita(self):
+        if self.valor == "Norte":
+            self.valor = "Leste"
+        elif self.valor == "Leste":
+            self.valor = "Sul"
+        elif self.valor == "Sul":
+            self.valor = "Oeste"
+        else:
+            self.valor = "Norte"
+
+    
+    def girar_a_esquerda(self):
+        if self.valor == "Norte":
+            self.valor = "Oeste"
+        elif self.valor == "Oeste":
+            self.valor = "Sul"
+        elif self.valor == "Sul":
+            self.valor = "Leste"
+        else:
+            self.valor = "Norte"
+
+
+if __name__ == "__main__":
+    # Testando Direcao
+    direcao = Direcao()
+    print(direcao.valor)
+    print('Norte')
+    direcao.girar_a_direita()
+    print(direcao.valor)
+    print('Leste')
+    direcao.girar_a_direita()
+    print(direcao.valor)
+    print('Sul')
+    direcao.girar_a_direita()
+    print(direcao.valor)
+    print('Oeste')
+    direcao.girar_a_direita()
+    print(direcao.valor)
+    print('Norte')
+    direcao.girar_a_esquerda()
+    print(direcao.valor)
+    print('Oeste')
+    direcao.girar_a_esquerda()
+    print(direcao.valor)
+    print('Sul')
+    direcao.girar_a_esquerda()
+    print(direcao.valor)
+    print('Leste')
+    direcao.girar_a_esquerda()
+    print(direcao.valor)
+    print('Norte')
+
diff --git a/oo/motor.py b/oo/motor.py
new file mode 100644
index 000000000..2d0ba05cc
--- /dev/null
+++ b/oo/motor.py
@@ -0,0 +1,41 @@
+class Motor:
+
+    def __init__(self, velocidade=0):
+        self.velocidade = velocidade
+
+    def acelerar(self):
+        self.velocidade += 1
+    
+    def frear(self):
+        if self.velocidade-2 < 0:
+            self.velocidade = 0
+        else:
+            self.velocidade -= 2
+
+        
+
+if __name__ == "__main__":
+    motor = Motor()
+    motor.velocidade
+    print(motor.velocidade)
+    print(0)
+    motor.acelerar()
+    motor.velocidade
+    print(motor.velocidade)
+    print(1)
+    motor.acelerar()
+    motor.velocidade
+    print(motor.velocidade)
+    print(2)
+    motor.acelerar()
+    motor.velocidade
+    print(motor.velocidade)
+    print(3)
+    motor.frear()
+    motor.velocidade
+    print(motor.velocidade)
+    print(1)
+    motor.frear()
+    motor.velocidade
+    print(motor.velocidade)
+    print(0)
diff --git a/oo/pessoa.py b/oo/pessoa.py
new file mode 100644
index 000000000..16a3db7eb
--- /dev/null
+++ b/oo/pessoa.py
@@ -0,0 +1,60 @@
+class Pessoa:
+    # Atributo de classe. Deve ser usado quando todas as instâncias tiverem o mesmo valor.
+    olhos = 2
+    ser = "Pessoa"
+
+    # Atributos de dado ou apenas atributos
+    def __init__(self, *filhos, nome=None, idade=35): 
+        self.nome = nome
+        self.idade = idade
+        self.filhos = list(filhos)
+    
+    # Método
+    def cumprimentar(self):
+        return f"Olá {id(self)}"
+
+    # Método de classe: Método que independe do objeto que está sendo executado
+    # Pode-se fazer isso usando decorators
+    @staticmethod
+    def metodo_estatico():
+        return "método estático"
+
+    # Método de classe com decorator @classmethod.
+    # Com esse é possível acessar a classe que está executando esse método.
+    # No caso, o parâmetro cls representa a palavra class; porém, como class é uma palavra reservada, usamos o cls.
+    @classmethod
+    def nome_e_atributos_de_classe(cls):
+        return f"{cls} - olhos {cls.olhos}"
+
+class Homem(Pessoa):
+    pass
+
+class Mutante(Pessoa):
+    olhos = 3
+
+if __name__ == "__main__":
+    gustavo = Mutante(nome="Gustavo")
+    jose = Pessoa(gustavo, nome="José", idade=66)
+    print(jose.nome)
+    print(id(jose))
+    print(jose.cumprimentar())
+    for filho in jose.filhos:
+        print(f"Um dos filhos de {jose.nome} chama {filho.nome}.")
+    gustavo.olhos = 1
+
+    # Criando um atributo dinâmico
+    gustavo.sobrenome = "Suto"
+
+    # Acessando todos os atributos de um objeto, mesmo os atributos dinâmicos.
+    print(gustavo.__dict__)
+    print(jose.__dict__)
+
+    print(f"{gustavo.nome} tem {gustavo.olhos} olhos.")
+    print(f"Pessoa tem {Pessoa.olhos} olhos.")
+
+    # Usando o método de classe sob o decorator @staticmethod:
+    print(f"{Pessoa.ser}: {Pessoa.metodo_estatico()}, {gustavo.nome}: {gustavo.metodo_estatico()}")
+
+    # Usando o método de classe sob o decorator @classmethod:
+    print(f"""{Pessoa.ser}: {Pessoa.nome_e_atributos_de_classe()}
+{gustavo.nome}: {gustavo.nome_e_atributos_de_classe()}""")
\ No newline at end of file
diff --git a/oo/teste_carro.py b/oo/teste_carro.py
new file mode 100644
index 000000000..456ebcaba
--- /dev/null
+++ b/oo/teste_carro.py
@@ -0,0 +1,78 @@
+from unittest import TestCase
+
+from oo.carro import Motor
+from oo.carro import Direcao
+from oo.carro import Carro
+
+class CarroTestCase(TestCase):
+    def teste_velocidade(self):
+        motor = Motor()
+        self.assertEqual(0, motor.velocidade)
+
+    def teste_aceleracao(self):
+        motor = Motor()
+        motor.acelerar()
+        self.assertEqual(1, motor.velocidade)
+        motor.acelerar()
+        self.assertEqual(2, motor.velocidade)
+        motor.acelerar()
+        self.assertEqual(3, motor.velocidade)
+    
+    def teste_frenagem(self):
+        motor = Motor(3)
+        motor.frear()
+        self.assertEqual(1, motor.velocidade)
+        motor.frear()
+        self.assertEqual(0, motor.velocidade)
+
+    def teste_direcao(self):
+        direcao = Direcao()
+        self.assertEqual("Norte", direcao.valor)
+
+    def teste_girar_a_direita(self):
+        direcao = Direcao()
+        direcao.girar_a_direita()
+        self.assertEqual("Leste", direcao.valor)
+        direcao.girar_a_direita()
+        self.assertEqual("Sul", direcao.valor)
+        direcao.girar_a_direita()
+        self.assertEqual("Oeste", direcao.valor)
+
+    def teste_girar_a_esquerda(self):
+        direcao = Direcao()
+        direcao.girar_a_esquerda()
+        self.assertEqual("Oeste", direcao.valor)
+        direcao.girar_a_esquerda()
+        self.assertEqual("Sul", direcao.valor)
+        direcao.girar_a_esquerda()
+        self.assertEqual("Leste", direcao.valor)
+
+    def teste_carro(self):
+        carro = Carro()
+        self.assertEqual(0, carro.calcular_velocidade())
+
+
+
+# >>> 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'
\ No newline at end of file
diff --git a/oo_old/__init__.py b/oo_old/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/oo_old/carro.py b/oo_old/carro.py
new file mode 100644
index 000000000..cca647eea
--- /dev/null
+++ b/oo_old/carro.py
@@ -0,0 +1,147 @@
+"""
+    >>> 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 Carro:
+    def __init__(self, direcao, motor):
+        self.motor = motor
+        self.direcao = direcao
+
+    def calcular_velocidade(self):
+        return self.motor.velocidade
+
+    def acelerar(self):
+        return self.motor.acelerar()
+
+    def frear(self):
+        return self.motor.frear()
+
+    def calcular_direcao(self):
+        return self.direcao.valor
+
+    def girar_a_direita(self):
+        return self.direcao.girar_a_direita()
+
+    def girar_a_esquerda(self):
+        return self.direcao.girar_a_esquerda()
+
+
+
+class Motor:
+    def __init__(self, velocidade=0):
+        self.velocidade = velocidade
+
+    def acelerar(self):
+        self.velocidade += 1
+
+    def frear(self):
+        if self.velocidade - 2 <= 0:
+            self.velocidade = 0
+        else:
+            self.velocidade -= 2
+
+
+
+class Direcao():
+
+    def __init__(self, valor="Norte"):
+        self.valor = valor
+
+    def girar_a_direita(self):
+        if self.valor == "Norte":
+            self.valor = "Leste"
+        elif self.valor == "Leste":
+            self.valor = "Sul"
+        elif self.valor == "Sul":
+            self.valor = "Oeste"
+        else:
+            self.valor = "Norte"
+
+    def girar_a_esquerda(self):
+        if self.valor == "Norte":
+            self.valor = "Oeste"
+        elif self.valor == "Oeste":
+            self.valor = "Sul"
+        elif self.valor == "Sul":
+            self.valor = "Leste"
+        else:
+            self.valor = "Norte"
+
+if __name__ == "__main__":
+    carro = Carro(direcao, motor)
+    print(carro.calcular_velocidade())
+    print(0)
+    carro.acelerar()
+    print(carro.calcular_velocidade())
+    print(1)
+    carro.acelerar()
+    print(carro.calcular_velocidade())
+    print(2)
\ No newline at end of file
diff --git a/oo_old/pessoa.py b/oo_old/pessoa.py
new file mode 100644
index 000000000..e503d8c10
--- /dev/null
+++ b/oo_old/pessoa.py
@@ -0,0 +1,57 @@
+class Pessoa:
+    # Atributos de classe ou atributo default
+    olhos = 2
+
+    # Atributos de instância
+    def __init__(self, *filhos, nome="Gustavo", idade=35):
+        self.idade = idade
+        self.nome = nome
+        self.filhos = list(filhos)
+
+    # Método de instância
+    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} - quantidade de 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__':
+    filho01 = Mutante(nome="Gu", idade=34)
+    filho02 = Homem(nome="Gui", idade=32)
+    pai = Pessoa(filho01, filho02, nome="José", idade=64)
+    print(pai.cumprimentar())
+    print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.")
+
+    for i, filho in enumerate(pai.filhos):
+        print(f"O {i + 1}º chama {filho.nome}.")
+
+    pai.sobrenome = "Souza"  # Atributo criado dinamicamente
+    print(pai.nome, pai.__dict__)
+    print(filho01.nome, filho01.__dict__)
+
+    print(Pessoa.metodo_estatico(), pai.metodo_estatico())
+    print(Pessoa.nome_e_atributos_de_classe(), pai.nome_e_atributos_de_classe())
+
+    pessoa = Homem("Anônimo")
+    print(isinstance(pessoa, Pessoa))
+
+    print(filho01.olhos)
+
+    print(pai.cumprimentar())
+    print(filho02.cumprimentar())
diff --git a/oo_old/teste_carro.py b/oo_old/teste_carro.py
new file mode 100644
index 000000000..49837c5c8
--- /dev/null
+++ b/oo_old/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)
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..e833eb43a 100644
--- a/testes/atores_testes.py
+++ b/testes/testes_atores.py
@@ -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/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