From b3db4400695249420f5f941744c2a2692a1bad98 Mon Sep 17 00:00:00 2001 From: Jeremy Thurgood Date: Sun, 11 May 2014 19:13:42 +0200 Subject: [PATCH] More state management. --- naja/gameboard.py | 96 +++++++++++++++++++++++------------- naja/player.py | 10 ++++ naja/tests/test_gameboard.py | 21 ++++++-- naja/tests/test_player.py | 24 ++++++++- 4 files changed, 112 insertions(+), 39 deletions(-) diff --git a/naja/gameboard.py b/naja/gameboard.py index fa768db..123f3be 100644 --- 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 fcfc330..c53c698 100644 --- 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 ca973a1..bd1a16c 100644 --- 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 d2b896e..c748c72 100644 --- 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], + }) -- 2.34.1