Refactoring para tornar objetos stateles, todos dependentes de tempo

renzon · renzon · commit 4bdc9f089ee0 · 2014-07-16T16:55:37.000-03:00
diff --git a/README.md b/README.md
@@ -17,18 +17,18 @@ Classe base para todos os atores do jogo.
 
 ### Método calcular_posicao
 
-Método que recebe o tempo (float) como parâmetro e retorna uma tupla com 3 elementos, posição horizontal (x), posição
-vertical (y) e sinal a ser exibido em tela (caracter).
+Método que recebe o tempo (float) como parâmetro e retorna uma tupla com 2 elementos, posição horizontal (x) como 
+primeiro elemento e posição vertical (y) como segundo
 
-x e y devem ser números inteiros. Devem ser aproximados utilizando lógica de arredondamento.
+### Método Status
 
-### Status
+O ator possui os status Ativo e Destruido. Além disso o status deve ser dependente do tempo. Ou seja, se o ator foi 
+destruido no tempo t, ele deve possuir status ativo antes desse tempo e Destruido após esse tempo.
+ 
 
-O ator possui os status Ativo e Destruido. Quando destruido, o caracter the apresentação quando for calculada a posição 
-deve ser "✝".
+## Método sinal
 
-Além disso o status deve ser dependente do tempo. Ou seja, se o ator foi destruido no tempo t, ele deve possuir status
-ativo antes desse tempo e Destruido após esse tempo.
+O método sinal retorna 'A' quando o ator tem status Ativo e '✝' caso contrário.
 
 ### Método colidir
 
diff --git a/atores.py b/atores.py
@@ -7,44 +7,49 @@
 
 
 class Ator():
-    caracter = 'A'
+    _tempo_de_colisao = None
+    _caracter_ativo = 'A'
+    _caracter_destruido = '✝'
+
+    def caracter(self, tempo):
+        if self.status(tempo) == ATIVO:
+            return self._caracter_ativo
+        else:
+            return self._caracter_destruido
 
     def __init__(self, x=0, y=0):
         self.y = y
         self.x = x
-        self.status = ATIVO
 
-    def ponto_cartesiano_inteiro(self):
-        return round(self.x), round(self.y)
+    def status(self, tempo):
+        if self._tempo_de_colisao is None or self._tempo_de_colisao > tempo:
+            return ATIVO
+        return DESTRUIDO
 
     def calcular_posicao(self, tempo):
-        caracter = self.caracter if self.status == ATIVO else '✝'
-        x, y = self.ponto_cartesiano_inteiro()
-        return x, y, caracter
+        return self.arredondar_posicao()
+
+    def arredondar_posicao(self):
+        return round(self.x), round(self.y)
 
-    def colidir(self, outro_ator):
-        if self.status == DESTRUIDO or outro_ator.status == DESTRUIDO:
-            return False
-        x1, y1 = self.ponto_cartesiano_inteiro()
-        x2, y2 = outro_ator.ponto_cartesiano_inteiro()
+    def colidir(self, outro_ator, tempo):
+        if self.status(tempo) == DESTRUIDO or outro_ator.status(tempo) == DESTRUIDO:
+            return
+        x1, y1 = self.arredondar_posicao()
+        x2, y2 = outro_ator.arredondar_posicao()
 
         def esta_no_intervalo(coordenada1, coordenada2, intervalo=1):
             coordenadas = sorted([coordenada1, coordenada2])
             return coordenadas[1] - intervalo <= coordenadas[0]
 
         if esta_no_intervalo(x1, x2) and esta_no_intervalo(y1, y2):
-            self.status = DESTRUIDO
-            outro_ator.status = DESTRUIDO
-            return True
-        return False
+            self._tempo_de_colisao = tempo
+            outro_ator._tempo_de_colisao = tempo
 
 
 class Obstaculo(Ator):
-    caracter = 'O'
-
-    def calcular_posicao(self, tempo):
-        x, y, caracter = super().calcular_posicao(tempo)
-        return x, y, ' ' if self.status == DESTRUIDO else caracter
+    _caracter_ativo = 'O'
+    _caracter_destruido = ' '
 
 
 
diff --git a/testes/atores_testes.py b/testes/atores_testes.py
@@ -5,6 +5,18 @@
 from atores import Ator, DESTRUIDO, ATIVO, Obstaculo
 
 
+def assert_ator_status(test_case, ator, caracter_status_ativo, carater_status_destruido):
+    test_case.assertEqual(ATIVO, ator.status(0))
+    test_case.assertEqual(caracter_status_ativo, ator.caracter(0))
+    ator.colidir(ator, 3.2)
+    test_case.assertEqual(ATIVO, ator.status(3.1))
+    test_case.assertEqual(caracter_status_ativo, ator.caracter(3.1))
+    test_case.assertEqual(DESTRUIDO, ator.status(3.2))
+    test_case.assertEqual(carater_status_destruido, ator.caracter(3.2))
+    test_case.assertEqual(DESTRUIDO, ator.status(4))
+    test_case.assertEqual(carater_status_destruido, ator.caracter(4))
+
+
 class AtorTestes(TestCase):
     def teste_ator_posicao(self):
         ator = Ator()
@@ -14,25 +26,19 @@ def teste_ator_posicao(self):
         ator = Ator(0.6, 2.1)
         self.assertTupleEqual((1, 2), ator.calcular_posicao(3.14))
 
-    def teste_status(self):
-        ator = Ator()
-        self.assertEqual(ATIVO, ator.status)
-        self.assertEqual('A', ator.calcular_posicao(0)[2])
-        ator.status = DESTRUIDO
-        self.assertEqual('✝', ator.calcular_posicao(0)[2])
-        self.assertEqual(ATIVO, Ator().status)
-
     def assert_colisao_atores_ativos(self, ator, ator2):
-        self.assertEqual(ator.status, ATIVO)
-        self.assertEqual(ator2.status, ATIVO)
-        self.assertTrue(ator.colidir(ator2))
-        self.assertEqual(ator2.status, DESTRUIDO)
-        self.assertEqual(ator.status, DESTRUIDO)
+        tempo_da_colisao = 2
+        self.assertEqual(ator.status(tempo_da_colisao), ATIVO)
+        self.assertEqual(ator2.status(tempo_da_colisao), ATIVO)
+        ator.colidir(ator2, tempo_da_colisao)
+        self.assertEqual(ator2.status(tempo_da_colisao), DESTRUIDO)
+        self.assertEqual(ator.status(tempo_da_colisao), DESTRUIDO)
 
     def assert_nao_colisao(self, ator, ator2):
-        status_iniciais = [ator.status, ator2.status]
-        self.assertFalse(ator.colidir(ator2))
-        self.assertListEqual(status_iniciais, [ator.status, ator2.status])
+        tempo_da_colisao = 2
+        status_iniciais = [ator.status(tempo_da_colisao), ator2.status(tempo_da_colisao)]
+        ator.colidir(ator2, tempo_da_colisao)
+        self.assertListEqual(status_iniciais, [ator.status(tempo_da_colisao), ator2.status(tempo_da_colisao)])
 
     def teste_colisao_entre_atores_ativos(self):
         ator = Ator(2, 2)
@@ -59,7 +65,7 @@ def teste_nao_colisao_entre_atores_ativos(self):
 
     def teste_colisao_somente_um_ator_destruido(self):
         ator = Ator(2, 2)
-        ator.status = DESTRUIDO
+        ator.colidir(ator,0)
         ator2 = Ator(2, 2)
         self.assert_nao_colisao(ator, ator2)
         self.assert_nao_colisao(Ator(2, 3), ator)
@@ -80,28 +86,23 @@ def teste_colisao_somente_um_ator_destruido(self):
         self.assert_nao_colisao(Ator(1, 2), ator)
         self.assert_nao_colisao(Ator(1, 3), ator)
 
-    def teste_status_dependete_de_tempo(self):
+    def teste_status(self):
         ator = Ator()
-        ator2 = Ator()
-
-        self.assertEqual(ATIVO, ator.status)
-        ator.colidir(ator2, 3.2)
-        self.assertEqual('A', ator.calcular_posicao(0)[2])
-        self.assertEqual(ATIVO,ator.status)
-        self.assertEqual('A', ator.calcular_posicao(3.1)[2])
-        self.assertEqual(ATIVO,ator.status)
-        self.assertEqual('✝', ator.calcular_posicao(3.2)[2])
-        self.assertEqual(ATIVO, Ator().status)
+        assert_ator_status(self, ator, 'A', '✝')
 
 
 class ObstaculoTestes(TestCase):
     def teste_status(self):
         obstaculo = Obstaculo()
-        self.assertEqual(ATIVO, obstaculo.status)
-        self.assertEqual('O', obstaculo.calcular_posicao(0)[2])
-        obstaculo.status = DESTRUIDO
-        self.assertEqual(' ', obstaculo.calcular_posicao(0)[2])
-        self.assertEqual(ATIVO, Ator().status)
+        self.assertEqual(ATIVO, obstaculo.status(0))
+        self.assertEqual('O', obstaculo.caracter(0))
+        obstaculo.colidir(obstaculo, 3.2)
+        self.assertEqual(ATIVO, obstaculo.status(3.1))
+        self.assertEqual('O', obstaculo.caracter(3.1))
+        self.assertEqual(DESTRUIDO, obstaculo.status(3.2))
+        self.assertEqual(' ', obstaculo.caracter(3.2))
+        self.assertEqual(DESTRUIDO, obstaculo.status(4))
+        self.assertEqual(' ', obstaculo.caracter(4))
 
 
 
