Merge pull request #865 from souravsingh/add-strategy

[MRG] Add Resurrection Strategy

Author: meatballs

axelrod/strategies/_strategies.py

@@ -63,6 +63,7 @@
 from .qlearner import (
     RiskyQLearner, ArrogantQLearner, HesitantQLearner, CautiousQLearner)
 from .rand import Random
+from .resurrection import Resurrection
 from .retaliate import (
     Retaliate, Retaliate2, Retaliate3, LimitedRetaliate, LimitedRetaliate2,
     LimitedRetaliate3)
@@ -206,6 +207,7 @@
     Random,
     RandomHunter,
     RemorsefulProber,
+    Resurrection,
     Retaliate,
     Retaliate2,
     Retaliate3,

axelrod/strategies/resurrection.py

@@ -0,0 +1,36 @@
+from axelrod.actions import Actions, Action
+from axelrod.player import Player
+
+C, D = Actions.C, Actions.D
+
+
+class Resurrection(Player):
+    """
+    A player starts by cooperating and defects if the number of rounds 
+    played by the player is greater than five and the last five rounds are defections.
+    Otherwise, the strategy plays like Tit-for-tat.
+    
+    Names:
+    - Resurrection: Name from CoopSim https://github.com/jecki/CoopSim     
+    """
+
+    # These are various properties for the strategy
+    name = 'Resurrection'
+    classifier = {
+        'memory_depth': 1,  
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def strategy(self, opponent: Player) -> Action:
+        if len(self.history) == 0:
+            return C
+        if len(self.history) >= 5 and self.history[-5:] == [D, D, D, D, D]:
+            return D
+        else:
+            return opponent.history[-1]
+

axelrod/tests/unit/test_resurrection.py

@@ -0,0 +1,35 @@
+"""Test for the Resurrection strategy."""
+
+import axelrod
+from .test_player import TestPlayer
+
+C, D = axelrod.Actions.C, axelrod.Actions.D
+class Resurrection(TestPlayer):
+
+    name = "Resurrection"
+    player = axelrod.Resurrection
+    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_strategy(self):
+        # Starts by Cooperating
+        self.first_play_test(C)
+        
+        # Check if the turns played are greater than 5 
+        self.responses_test([D], [D, C, C, D, D, D, D, D] , [C] * 8)
+        
+        #Check if turns played are less than 5.
+        self.responses_test([C], [D, C, D, C], [C] * 4)
+        
+        # Check for TFT behavior after 5 rounds
+        self.responses_test([C], [C] * 5, [C, C, C, C, C, D])
+        
+        # Check for four defections and a cooperation by opponent
+        self.responses_test([D], [C] * 5, [D, D, D, D, D, C])

docs/reference/all_strategies.rst

@@ -126,6 +126,9 @@ Here are the docstrings of all the strategies in the library.
 .. automodule:: axelrod.strategies.rand
    :members:
    :undoc-members:
+.. automodule:: axelrod.strategies.resurrection
+   :members:
+   :undoc-members:
 .. automodule:: axelrod.strategies.retaliate
    :members:
    :undoc-members:

docs/tutorials/advanced/classification_of_strategies.rst

@@ -57,7 +57,7 @@ make a decision::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    27
+    28
 
 Multiple filters can be specified within the filterset dictionary. To specify a
 range of memory_depth values, we can use the 'min_memory_depth' and
@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    48
+    49
 
 We can also identify strategies that make use of particular properties of the
 tournament. For example, here is the number of strategies that  make use of the