Merge pull request #289 from Axelrod-Python/286

Creates tournament attributes dictionary for players

Author: marcharper

axelrod/player.py

@@ -33,7 +33,7 @@ def __init__(self):
         """Initiates an empty history and 0 score for a player."""
         self.history = []
         self.stochastic = "random" in inspect.getsource(self.__class__)
-        self.tournament_length = -1
+        self.tournament_attributes = {'length': -1, 'game': None}
         if self.name == "Player":
             self.stochastic = False
         self.cooperations = 0

axelrod/round_robin.py

@@ -87,7 +87,7 @@ def _pair_of_players(self, player1_index, player2_index):
                 player2 = copy.deepcopy(player1)
             else:
                 player2 = class1()
-                player2.tournament_length = self.turns
+                player2.tournament_attributes = player1.tournament_attributes
             class2 = class1
         else:
             player2 = self.players[player2_index]

axelrod/strategies/axelrod_tournaments.py

@@ -161,7 +161,7 @@ class Champion(Player):
 
     def strategy(self, opponent):
         current_round = len(self.history)
-        expected_length = self.tournament_length
+        expected_length = self.tournament_attributes['length']
         # Cooperate for the first 1/20-th of the game
         if current_round == 0:
             return 'C'

axelrod/strategies/backstabber.py

@@ -14,7 +14,7 @@ class BackStabber(Player):
     def strategy(self, opponent):
         if not opponent.history:
             return 'C'
-        if len(opponent.history) > (self.tournament_length - 3):
+        if len(opponent.history) > (self.tournament_attributes['length'] - 3):
             return 'D'
         if opponent.defections > 3:
             return 'D'
@@ -38,7 +38,7 @@ def strategy(self, opponent):
 
         if not opponent.history:
             return 'C'
-        if len(opponent.history) > (self.tournament_length - 3):
+        if len(opponent.history) > (self.tournament_attributes['length'] - 3):
             return 'D'
         if len(opponent.history) < 180:
             if len(opponent.history) > cutoff:

axelrod/tests/unit/test_player.py

@@ -98,7 +98,8 @@ def test_initialisation(self):
         """Test that the player initiates correctly."""
         self.assertEqual(self.player().history, [])
         self.assertEqual(self.player().stochastic, self.stochastic)
-        self.assertEqual(self.player().tournament_length, -1)
+        self.assertEqual(self.player().tournament_attributes,
+            {'length': -1, 'game': None})
         self.assertEqual(self.player().cooperations, 0)
         self.assertEqual(self.player().defections, 0)
 
@@ -149,9 +150,9 @@ def responses_test(self, history_1, history_2, responses,
         subsequent moves by player one to test.
         """
         P1 = self.player()
-        P1.tournament_length = tournament_length
+        P1.tournament_attributes['length'] = tournament_length
         P2 = Player()
-        P2.tournament_length = tournament_length
+        P2.tournament_attributes['length'] = tournament_length
         test_responses(
             self, P1, P2, history_1, history_2, responses,
             random_seed=random_seed)

axelrod/tests/unit/test_tournament.py

@@ -26,6 +26,7 @@ def setUpClass(cls):
             axelrod.GoByMajority()]
         cls.test_name = 'test'
         cls.test_repetitions = 5
+        cls.test_turns = 100
 
         cls.expected_payoff = [
             [600, 600, 0, 600, 600],
@@ -46,12 +47,19 @@ def test_init(self):
             name=self.test_name,
             players=self.players,
             game=self.game,
+            turns=self.test_turns,
             processes=4,
             noise=0.2)
         self.assertEqual(len(tournament.players), len(self.players))
-        self.assertEqual(tournament.players[0].tournament_length, 200)
+        self.assertEqual(
+            tournament.players[0].tournament_attributes['length'],
+            self.test_turns
+        )
+        self.assertIsInstance(
+            tournament.players[0].tournament_attributes['game'], axelrod.Game
+        )
         self.assertEqual(tournament.game.score(('C', 'C')), (3, 3))
-        self.assertEqual(tournament.turns, 200)
+        self.assertEqual(tournament.turns, self.test_turns)
         self.assertEqual(tournament.repetitions, 10)
         self.assertEqual(tournament.name, 'test')
         self.assertEqual(tournament._processes, 4)

axelrod/tournament.py

@@ -38,7 +38,9 @@ def players(self):
     def players(self, players):
         newplayers = []
         for player in players:
-            player.tournament_length = self.turns
+            player.tournament_attributes = {
+                'length': self.turns,
+                'game': self.game}
             newplayers.append(player)
         self._players = newplayers