Optional sanity check for actions.

[naja.git] / naja / gameboard.py

diff --git a/naja/gameboard.py b/naja/gameboard.py
index ad692e716e8ee414371c72152f04ea0672233403..689c3fd15fcf324d9110763331a6a0eeb93023d2 100644 (file)
--- a/naja/gameboard.py
+++ b/naja/gameboard.py
@@ -7,6 +7,7 @@ from naja.options import options
 from naja.player import Player
 from naja import actions
 from naja.sound import sound
+from naja.utils import parse_bits
 import random
 
 
@@ -30,13 +31,37 @@ class GameBoard(object):
         self.replacement_params = state.get('replacement_params', None)
 
     @classmethod
-    def new_game(cls, deck,
-                 initial_bits=PLAYER_DEFAULTS.INITIAL_BITS,
-                 initial_pos=PLAYER_DEFAULTS.INITIAL_POS,
-                 max_health=PLAYER_DEFAULTS.MAX_HEALTH,
-                 wins_required=PLAYER_DEFAULTS.WINS_REQUIRED):
+    def new_game(cls, deck, initial_bits=None, initial_pos=None,
+                 max_health=None, wins_required=None):
+
+        defaults = {
+            'initial_bits': PLAYER_DEFAULTS.INITIAL_BITS,
+            'initial_pos': PLAYER_DEFAULTS.INITIAL_POS,
+            'max_health': PLAYER_DEFAULTS.MAX_HEALTH,
+            'wins_required': PLAYER_DEFAULTS.WINS_REQUIRED,
+        }
+
+        deck_defaults = deck.get('defaults', {})
+        for k, v in deck_defaults.iteritems():
+            if isinstance(v, list):
+                deck_defaults[k] = tuple(v)
+        defaults.update(deck_defaults)
+
+        if initial_bits is None:
+            initial_bits = defaults['initial_bits']
+        if initial_pos is None:
+            initial_pos = defaults['initial_pos']
+        if max_health is None:
+            max_health = defaults['max_health']
+        if wins_required is None:
+            wins_required = defaults['wins_required']
+
+        assert wins_required + max_health == 8
+
+        # Overriden by command line
         if options.initial_bits:
             initial_bits = options.initial_bits
+
         state = {
             'max_health': max_health,
             'health': max_health,
@@ -50,7 +75,9 @@ class GameBoard(object):
         player = Player(initial_bits, initial_pos)
         board_locations = cls.import_board_locations(
             cls.generate_board(deck))
-        return cls(state, player, board_locations)
+        board = cls(state, player, board_locations)
+        player.set_gameboard(board)
+        return board
 
     @classmethod
     def import_game(cls, definition):
@@ -58,7 +85,9 @@ class GameBoard(object):
         player = Player.import_player(state.pop('player'))
         board_locations = cls.import_board_locations(
             state.pop('board_locations'))
-        return cls(state, player, board_locations)
+        board = cls(state, player, board_locations)
+        player.set_gameboard(board)
+        return board
 
     def export(self):
         data = {
@@ -74,6 +103,8 @@ class GameBoard(object):
             'clock_count': self.clock_count,
             'replacement_params': self.replacement_params,
         }
+        if options.cheat_enabled:
+            self.has_cheated = True
         if self.has_cheated:
             data['cheater'] = True
         return data
@@ -109,7 +140,7 @@ class GameBoard(object):
         board_locations = [
             [(i % 5, i // 5),
              LocationCard.new_location(
-                 card.copy(), replacement_params).export()]
+                 card.copy(), replacement_params, puzzle=True).export()]
             for i, card in enumerate(deck['cards'])
         ]
         return board_locations
@@ -222,7 +253,8 @@ class GameBoard(object):
         if ROTATION[direction] == ROTATION.CLOCKWISE:
             new_positions = locations_to_rotate[1:] + [locations_to_rotate[0]]
         elif ROTATION[direction] == ROTATION.ANTICLOCKWISE:
-            new_positions = ([locations_to_rotate[-1]] + locations_to_rotate[:-1])
+            new_positions = (
+                [locations_to_rotate[-1]] + locations_to_rotate[:-1])
 
         for old, new in zip(locations_to_rotate, new_positions):
             rotated_locations[new] = self.board_locations[old]
@@ -267,13 +299,15 @@ class LocationCard(object):
     """
 
     def __init__(self, card_name, bitwise_operand, location_actions,
-                 replacement_time, max_number=25):
+                 replacement_time=None, max_number=25):
         self.card_name = card_name
         self.bitwise_operand = bitwise_operand
         self.actions = location_actions
         self.max_number = max_number
-        self.check_actions()
         self.replacement_time = replacement_time
+        if options.debug:
+            for action in self.actions:
+                action.sanity_check(self)
 
     @classmethod
     def import_location(cls, state):
@@ -286,14 +320,14 @@ class LocationCard(object):
     @classmethod
     def build_action(cls, definition):
         action_class = getattr(actions, definition['action_class'])
-        required_bits = cls.parse_bits(definition['required_bits'])
+        required_bits = parse_bits(definition['required_bits'])
         data = definition.get('data', {})
         return action_class(required_bits, **data)
 
     @classmethod
-    def new_location(cls, definition, replacement_params):
+    def new_location(cls, definition, replacement_params=None, puzzle=False):
         if 'bits' in definition:
-            bits = cls.parse_bits(definition['bits'])
+            bits = parse_bits(definition['bits'])
         else:
             bits = cls.generate_bitwise_operand()
 
@@ -305,18 +339,16 @@ class LocationCard(object):
 
         max_number = definition.get('max_number', 25)
         card_name = definition['card_name']
-        return cls.import_location({
+        location = cls.import_location({
             'bitwise_operand': bits,
             'actions': definition['actions'],
             'max_number': max_number,
             'card_name': card_name,
             'replacement_time': replacement_time,
         })
-
-    @classmethod
-    def parse_bits(self, bit_list):
-        # Convert names to numbers if applicable.
-        return frozenset(BITS.get(bit, bit) for bit in bit_list)
+        if not puzzle:
+            location.check_actions()
+        return location
 
     def export(self):
         return {
@@ -361,11 +393,14 @@ class LocationCard(object):
         if replacement_params is None:
             return None
         else:
-            return random.randint(replacement_params[0], replacement_params[1])
+            if replacement_params['chance'] > random.random():
+                return random.randint(replacement_params['min'],
+                                      replacement_params['max'])
+            else:
+                return None
 
     def timer_action(self, position, board):
         if self.replacement_time is not None:
             self.replacement_time -= 1
             if self.replacement_time <= 0:
                 board.replace_card(position)
-