X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=naja%2Fgameboard.py;h=5728d5d0f28535abfeadcbb5ab3f98c3a24b74b7;hb=7ffa20720668ad9e8701d0b5f98a2e3161132423;hp=9c5af7b3554382158c79df337742e605c6b819a7;hpb=18eaa15b16160df3dcd23dd2773603d1f2e179ce;p=naja.git

diff --git a/naja/gameboard.py b/naja/gameboard.py
index 9c5af7b..5728d5d 100644
--- a/naja/gameboard.py
+++ b/naja/gameboard.py
@@ -1,6 +1,9 @@
 from random import choice
 
-from naja.constants import BITS, DIRECTION_BITS, CONDITION_BITS
+from naja.constants import(
+    BITS, DIRECTION_BITS, CONDITION_BITS, PLAYER_DEFAULTS)
+from naja.player import Player
+from naja import actions
 
 
 class GameBoard(object):
@@ -8,32 +11,75 @@ class GameBoard(object):
     A representation of the game board.
     """
 
-    def __init__(self, player, health, wins, locations=None, 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.max_health = health
-        self.wins_required = wins
-
-        if locations is None:
-            locations = self.generate_locations()
-        self.locations = locations
-
-        if state is None:
-            state = self.generate_state()
-        self.update_state(state)
+        self.board_locations = board_locations
 
     @classmethod
-    def generate_locations(cls):
-        raise NotImplementedError("TODO")
+    def new_game(cls, locations_definition,
+                 initial_bits=PLAYER_DEFAULTS.INITIAL_BITS,
+                 initial_pos=PLAYER_DEFAULTS.INITIAL_POS,
+                 max_health=PLAYER_DEFAULTS.MAX_HEALTH,
+                 wins_required=PLAYER_DEFAULTS.WINS_REQUIRED):
+        state = {
+            'max_health': max_health,
+            'health': max_health,
+            'wins_required': wins_required,
+            'wins': 0,
+            'locations': locations_definition,
+        }
+        player = Player(initial_bits, initial_pos)
+        board_locations = cls.generate_board(locations_definition)
+        return cls(state, player, board_locations)
 
-    def generate_state(self):
+    @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 {
-            'health': self.max_health,
-            'wins': 0,
+            'max_health': self.max_health,
+            'health': self.health,
+            'wins_required': self.wins_required,
+            'wins': self.wins,
+            'locations': self.export_locations(),
+            'player': self.player.export(),
+            'board_locations': self.export_board_locations(),
         }
 
-    def update_state(self, state):
-        self.health = state['health']
-        self.wins = state['wins']
+    def export_locations(self):
+        return [location.export() for location in self.locations]
+
+    @classmethod
+    def import_locations(cls, locations_definition):
+        return [
+            LocationCard.import_location(definition)
+            for definition in locations_definition]
+
+    def export_board_locations(self):
+        return dict(
+            (position, location.export())
+            for position, location in self.board_locations)
+
+    @classmethod
+    def import_board_locations(cls, board_locations_definition):
+        return dict(
+            (position, LocationCard.import_location(definition))
+            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
@@ -45,13 +91,36 @@ 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
 
-    @staticmethod
-    def generate_location():
-        raise NotImplementedError("TODO")
+    @classmethod
+    def import_location(cls, state):
+        # TODO: Import real locations.
+        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': definition['actions'],
+        })
+
+    def export(self):
+        return {
+            'bitwise_operand': self.bitwise_operand,
+            'actions': [action.export() for action in self.actions],
+        }
 
     @staticmethod
     def generate_bitwise_operand():
@@ -68,32 +137,3 @@ class LocationCard(object):
         if choice(range(3)) == 0:
             bits.add(choice(BITS.values()))
         return frozenset(bits)
-
-    @staticmethod
-    def generate_location_actions():
-        raise NotImplementedError("TODO")
-
-
-class LocationAction(object):
-    """
-    An action that may be performed on a location.
-    """
-
-    TEXT = None
-
-    def __init__(self, required_bits, **data):
-        self.required_bits = required_bits
-        self.data = data
-
-    def check_available(self, player):
-        return player.bits.check_bits(self.required_bits)
-
-    def perform_action(self, player, board):
-        raise NotImplementedError("TODO")
-
-    def check_and_clear_MSB(self, player):
-        if player.bits.check_bit(BITS.MSB):
-            player.bits.clear_bit(BITS.MSB)
-            return True
-        else:
-            return False