Simplify Prober4

Calculate defections on the fly.
Place the strategy logic in a single function.

Author: margaret

axelrod/strategies/prober.py

@@ -113,7 +113,7 @@ class Prober4(Player):
     name = 'Prober 4'
     classifier = {
         'stochastic': False,
-        'memory_depth': 20,
+        'memory_depth': 1,
         'makes_use_of': set(),
         'long_run_time': False,
         'inspects_source': False,
@@ -124,42 +124,41 @@ class Prober4(Player):
     @init_args
     def __init__(self):
         Player.__init__(self)
-        self.probe_sequence = [C, C, D, C, D, D, D, C, C, D,
-                               C, D, C, C, D, C, D, D, C, D]
-        self.probe_length = len(self.probe_sequence)
-        self.politness_pool = [C, C, C, C, C]
+        self.init_sequence = [C, C, D, C, D, D, D, C, C, D,
+                              C, D, C, C, D, C, D, D, C, D]
+        self.just_Ds = 0
+        self.unjust_Ds = 0
+        self.politeness_pool = [C, C, C, C, C]
         self.is_angry = False
 
     def strategy(self, opponent):
-        turn = len(self.history)
-        if turn <= self.probe_length:
-            return self.probe_sequence[turn - 1]
-        if turn == self.probe_length + 1:
-            self.judge(opponent)
-        if self.is_angry:
-            return D
+        if len(opponent.history) == 0:
+            return C
+        if len(self.history) == 0:
+            return C
         else:
-            # Cooperate for the next 5 turns
-            if self.politness_pool:
-                return self.politness_pool.pop()
-            else:
-                # TFT
-                return D if opponent.history[-1:] == [D] else C
-
-    def judge(self, opponent):
-        just_defect = 0
-        unjust_defect = 0
-        for turn in range(self.probe_length):
-            if opponent.history[turn + 1] == D:
-                if self.history[turn] == C:
-                    unjust_defect += 1
-                if self.history[turn] == D:
-                    just_defect += 1
-        if just_defect - unjust_defect >= 3:
-            self.is_angry = True
+            turn = len(self.history)
+            if turn < len(self.init_sequence):
+                if opponent.history[-1] == D:
+                    if self.history[-1] == D:
+                        self.just_Ds += 1
+                    if self.history[-1] == C:
+                        self.unjust_Ds += 1
+                return self.init_sequence[turn]
+            if turn == len(self.init_sequence):
+                self.is_angry = (self.just_Ds - self.unjust_Ds >= 3)
+            if self.is_angry:
+                return D
+            if not self.is_angry:
+                if self.politeness_pool:
+                    return self.politeness_pool.pop()
+                else:
+                    return D if opponent.history[-1:] == [D] else C
 
     def reset(self):
         Player.reset(self)
+        self.just_Ds = 0
+        self.unjust_Ds = 0
         self.politeness_pool = [C, C, C, C, C]
         self.is_angry = False
 

axelrod/tests/unit/test_prober.py

@@ -99,6 +99,29 @@ def test_strategy(self):
         self.responses_test([D, C, C, D, C], [C, D, C, C], [C])
 
 
+class TestProber4(TestPlayer):
+
+    name = "Prober 4"
+    player = axelrod.Prober4
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_initial_strategy(self):
+        """Starts by playing CCDCDDDCCDCDCCDCDDCD."""
+        self.responses_test([], [], [C, C, D, C, D, D, D, C, C, D,
+                                     C, D, C, C, D, C, D, D, C, D])
+#     def test_strategy(self):
+#         pass
+#
+
+
 class TestHardProber(TestPlayer):
 
     name = "Hard Prober"