More state management.

diff --git a/naja/gameboard.py b/naja/gameboard.py
index fa768dbad5db3481820d1775f277a2e37cb83d1c..123f3be6d6bf059187f4ac97357f306e613cf625 100644 (file)
--- a/naja/gameboard.py
+++ b/naja/gameboard.py
@@ -1,6 +1,8 @@
 from random import choice
 
 from naja.constants import BITS, DIRECTION_BITS, CONDITION_BITS
+from naja.player import Player
+from naja import actions
 
 
 class GameBoard(object):
@@ -8,12 +10,35 @@ class GameBoard(object):
     A representation of the game board.
     """
 
-    def __init__(self, player, health, wins, state=None):
+    def __init__(self, state, player, board_locations):
+        self.max_health = state['max_health']
+        self.wins_required = state['wins_required']
+        self.health = state['health']
+        self.wins = state['wins']
+        self.locations = self.import_locations(state['locations'])
         self.player = player
+        self.board_locations = board_locations
 
-        if state is None:
-            state = self.generate_state(health, wins)
-        self.update_state(state)
+    @classmethod
+    def new_game(cls, max_health, wins_required, locations_definition):
+        state = {
+            'max_health': max_health,
+            'health': max_health,
+            'wins_required': wins_required,
+            'wins': 0,
+            'locations': locations_definition,
+        }
+        player = Player(0x0f, (2, 2))
+        board_locations = cls.generate_board(locations_definition)
+        return cls(state, player, board_locations)
+
+    @classmethod
+    def import_game(cls, definition):
+        state = definition.copy()
+        player = Player.import_player(state.pop('player'))
+        board_locations = cls.import_board_locations(
+            state.pop('board_locations'))
+        return cls(state, player, board_locations)
 
     def export(self):
         return {
@@ -22,38 +47,34 @@ class GameBoard(object):
             'wins_required': self.wins_required,
             'wins': self.wins,
             'locations': self.export_locations(),
+            'player': self.player.export(),
+            'board_locations': self.export_board_locations(),
         }
 
     def export_locations(self):
-        return dict(
-            (position, location.export())
-            for position, location in self.locations)
+        return [location.export() for location in self.locations]
 
     @classmethod
-    def generate_locations(cls):
-        # TODO: Generate some locations.
-        return {}
-
-    def generate_state(self, max_health, wins_required):
-        return {
-            'max_health': max_health,
-            'health': max_health,
-            'wins_required': wins_required,
-            'wins': 0,
-            'locations': self.generate_locations(),
-        }
+    def import_locations(cls, locations_definition):
+        return [
+            LocationCard.import_location(definition)
+            for definition in locations_definition]
 
-    def update_state(self, state):
-        self.max_health = state['max_health']
-        self.wins_required = state['wins_required']
-        self.health = state['health']
-        self.wins = state['wins']
-        self.locations = self.import_locations(state['locations'])
+    def export_board_locations(self):
+        return dict(
+            (position, location.export())
+            for position, location in self.board_locations)
 
-    def import_locations(self, locations):
+    @classmethod
+    def import_board_locations(cls, board_locations_definition):
         return dict(
             (position, LocationCard.import_location(definition))
-            for position, definition in locations.iteritems())
+            for position, definition in board_locations_definition.iteritems())
+
+    @classmethod
+    def generate_board(cls, locations_definition):
+        # TODO: Choose some locations.
+        return {}
 
     def lose_health(self):
         self.health -= 1
@@ -65,20 +86,29 @@ class LocationCard(object):
     A particular set of options available on a location.
     """
 
-    def __init__(self, bitwise_operand, actions):
+    def __init__(self, bitwise_operand, location_actions):
         self.bitwise_operand = bitwise_operand
-        self.actions = actions
+        self.actions = location_actions
 
     @classmethod
     def import_location(cls, state):
         # TODO: Import real locations.
-        return cls(state['bitwise_operand'], [])
+        location_actions = [
+            cls.build_action(definition) for definition in state['actions']]
+        return cls(state['bitwise_operand'], location_actions)
+
+    @classmethod
+    def build_action(cls, definition):
+        action_class = getattr(actions, definition['action_class'])
+        required_bits = definition['required_bits']
+        data = definition.get('data', {})
+        return action_class(required_bits, **data)
 
     @classmethod
     def new_location(cls, definition):
         return cls.import_location({
             'bitwise_operand': cls.generate_bitwise_operand(),
-            'actions': cls.build_actions(definition),
+            'actions': definition['actions'],
         })
 
     def export(self):
@@ -87,10 +117,6 @@ class LocationCard(object):
             'actions': [action.export() for action in self.actions],
         }
 
-    @classmethod
-    def build_actions(cls, definition):
-        raise NotImplementedError("TODO")
-
     @staticmethod
     def generate_bitwise_operand():
         """

diff --git a/naja/player.py b/naja/player.py
index fcfc3301de4ab22bdfed7982b210d4acc73a29e3..c53c6980b5702e5b26f99a66fd09f0689253cc99 100644 (file)
--- a/naja/player.py
+++ b/naja/player.py
@@ -57,3 +57,13 @@ class Player(object):
     def __init__(self, bits, position):
         self.bits = PlayerBits(bits)
         self.position = position
+
+    @classmethod
+    def import_player(cls, definition):
+        return cls(definition['bits'], tuple(definition['position']))
+
+    def export(self):
+        return {
+            'bits': self.bits.bits,
+            'position': list(self.position),
+        }

diff --git a/naja/tests/test_gameboard.py b/naja/tests/test_gameboard.py
index ca973a1dc01b7c7a992594132827e09bd1ee5adf..bd1a16c1c080c3ea95b5a075ed8f1cc2f6345ef2 100644 (file)
--- a/naja/tests/test_gameboard.py
+++ b/naja/tests/test_gameboard.py
@@ -2,21 +2,24 @@ from unittest import TestCase
 
 from naja.constants import BITS
 from naja.gameboard import GameBoard, LocationCard
+from naja import actions
 
 
 class TestGameBoard(TestCase):
     def test_export_new_board(self):
-        board = GameBoard(None, 4, 4)
+        board = GameBoard.new_game(4, 4, [])
         self.assertEqual(board.export(), {
             'max_health': 4,
             'health': 4,
             'wins_required': 4,
             'wins': 0,
-            'locations': {},
+            'locations': [],
+            'board_locations': {},
+            'player': board.player.export(),
         })
 
     def test_lose_health(self):
-        board = GameBoard(None, 4, 4)
+        board = GameBoard.new_game(4, 4, [])
         self.assertEqual(board.health, 4)
         state_1 = board.export()
 
@@ -46,3 +49,15 @@ class TestLocationCard(TestCase):
         self.assertTrue(sizes[3] > 0)
         self.assertTrue(sizes[2] > sizes[3])
         self.assertEqual(bits, set(BITS.values()))
+
+    def test_new_location_no_actions(self):
+        location = LocationCard.new_location({'actions': []})
+        self.assertEqual(location.actions, [])
+
+    def test_new_location_one_action(self):
+        location = LocationCard.new_location({'actions': [
+            {'required_bits': [], 'action_class': 'DoNothing'},
+        ]})
+        [action] = location.actions
+        self.assertEqual(type(action), actions.DoNothing)
+        self.assertEqual(action.required_bits, set())

diff --git a/naja/tests/test_player.py b/naja/tests/test_player.py
index d2b896e402b3983c6b594d5e3c12c24f0304b482..c748c7295827b9e1355c6cb3f0e6182f049585b2 100644 (file)
--- a/naja/tests/test_player.py
+++ b/naja/tests/test_player.py
@@ -1,7 +1,7 @@
 from unittest import TestCase
 
 from naja.constants import BITS
-from naja.player import PlayerBits
+from naja.player import PlayerBits, Player
 
 
 class TestPlayerBits(TestCase):
@@ -84,3 +84,25 @@ class TestPlayerBits(TestCase):
         self.assertEqual(bits._bits, 0x03)
         bits.toggle_bits([BITS.NORTH, BITS.CYAN, BITS.MSB])
         self.assertEqual(bits._bits, 0x92)
+
+
+class TestPlayer(TestCase):
+    def test_new_player(self):
+        player = Player(0x0f, (0, 1))
+        self.assertEqual(player.bits.bits, 0x0f)
+        self.assertEqual(player.position, (0, 1))
+
+    def test_import_player(self):
+        player = Player.import_player({
+            'bits': 0xaa,
+            'position': [1, 2],
+        })
+        self.assertEqual(player.bits.bits, 0xaa)
+        self.assertEqual(player.position, (1, 2))
+
+    def test_export_player(self):
+        player = Player(0xaa, (1, 2))
+        self.assertEqual(player.export(), {
+            'bits': 0xaa,
+            'position': [1, 2],
+        })