X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=naja%2Ftests%2Ftest_gameboard.py;h=cccd9aae88be92758b1ab658292423fdf2a532b9;hb=2bc3952e185343ae2ff75f3f8ed738561858f61b;hp=ca031a33bee7c9e9b1a305e5f1a92c2ab2f4d859;hpb=db97008646152ce2d93949e0266635fdd89a0b91;p=naja.git diff --git a/naja/tests/test_gameboard.py b/naja/tests/test_gameboard.py index ca031a3..cccd9aa 100644 --- a/naja/tests/test_gameboard.py +++ b/naja/tests/test_gameboard.py @@ -12,7 +12,7 @@ class TestGameBoard(TestCase): def make_deck(self, cards=None): if cards is None: - cards = [{'actions': []}] + cards = [{'card_name': 'card', 'actions': []}] return {'cards': cards} def assert_state(self, state1, state2, exclude=(), player_exclude=()): @@ -30,23 +30,25 @@ class TestGameBoard(TestCase): self.assertEqual(state1, state2) def test_export_new_board(self): - board = GameBoard.new_game({'cards': [{'actions': [ - { - 'action_class': 'LoseHealthOrMSB', - 'required_bits': [], - }, { - 'action_class': 'GainHealth', - 'required_bits': [BITS.RED], - }, - ]}]}) + board = GameBoard.new_game({'cards': [ + {'card_name': 'card1', 'actions': [ + { + 'action_class': 'LoseHealthOrMSB', + 'required_bits': [], + }, { + 'action_class': 'GainHealth', + 'required_bits': [BITS.RED], + }, + ]}]}) exported_state = board.export() board_locations = exported_state.pop('board_locations') self.assertEqual(exported_state, { + 'clock_count': 0, 'max_health': 4, 'health': 4, 'wins_required': 4, 'wins': 0, - 'locations': [{'actions': [ + 'locations': [{'card_name': 'card1', 'actions': [ { 'action_class': 'LoseHealthOrMSB', 'required_bits': [], @@ -58,12 +60,14 @@ class TestGameBoard(TestCase): 'player': board.player.export(), 'puzzle': False, 'player_mode': EXAMINE, + 'replacement_params': None, }) positions = [] for position, location_state in board_locations: positions.append(position) - self.assertEqual( - sorted(location_state.keys()), ['actions', 'bitwise_operand']) + self.assertEqual(sorted(location_state.keys()), [ + 'actions', 'bitwise_operand', 'card_name', 'max_number', + 'replacement_time']) self.assertEqual(location_state['actions'], [ { 'action_class': 'LoseHealthOrMSB', @@ -79,6 +83,89 @@ class TestGameBoard(TestCase): self.assertEqual( positions, sorted((x, y) for x in range(5) for y in range(5))) + def test_max_number(self): + def _check_counts(board): + counts = {} + exported_state = board.export() + board_locations = exported_state.pop('board_locations') + for _position, location_state in board_locations: + counts.setdefault( + location_state['actions'][0]['action_class'], 0) + counts[location_state['actions'][0]['action_class']] += 1 + self.assertTrue(counts.get('LoseHealthOrMSB', 0) <= 5) + + board = GameBoard.new_game({'cards': [ + {'card_name': 'card1', 'actions': [{ + 'action_class': 'LoseHealthOrMSB', + 'required_bits': [], }], + 'max_number': 5}, + {'card_name': 'card2', 'actions': [{ + 'action_class': 'DoNothing', + 'required_bits': [], }], + 'max_number': 25}]}) + # check creation constraints + _check_counts(board) + # Check replacement + # Replace center card 12 times and assert invariant still holds + for x in range(12): + board.replace_card((2, 2)) + _check_counts(board) + # replace a diagonal of cards + for x in range(5): + board.replace_card((x, x)) + _check_counts(board) + + def test_max_number_complex(self): + def _check_counts(board): + counts = {} + exported_state = board.export() + board_locations = exported_state.pop('board_locations') + for _position, location_state in board_locations: + counts.setdefault( + location_state['actions'][0]['action_class'], 0) + counts[location_state['actions'][0]['action_class']] += 1 + self.assertTrue(counts.get('LoseHealthOrMSB', 0) <= 5) + self.assertTrue(counts.get('DoNothing', 0) <= 3) + self.assertTrue(counts.get('AcquireWinToken', 0) <= 4) + self.assertTrue(counts.get('GainHealth', 0) <= 3) + + board = GameBoard.new_game({'cards': [ + {'card_name': 'card1', 'actions': [{ + 'action_class': 'LoseHealthOrMSB', + 'required_bits': [], }], + 'max_number': 5}, + {'card_name': 'card2', 'actions': [{ + 'action_class': 'AcquireWinToken', + 'required_bits': [], }], + 'max_number': 4}, + {'card_name': 'card3', 'actions': [{ + 'action_class': 'GainHealth', + 'required_bits': [], }], + 'max_number': 3}, + {'card_name': 'card4', 'actions': [{ + 'action_class': 'RotateLocations', + 'required_bits': [], }], + 'max_number': 25}, + {'card_name': 'card5', 'actions': [{ + 'action_class': 'AllowChessMove', + 'required_bits': [], }], + 'max_number': 25}, + {'card_name': 'card6', 'actions': [{ + 'action_class': 'DoNothing', + 'required_bits': [], }], + 'max_number': 3}]}) + # check creation constraints + _check_counts(board) + # Check replacement + # Replace center card 12 times and assert invariant still holds + for x in range(12): + board.replace_card((2, 2)) + _check_counts(board) + # replace a diagonal of cards + for x in range(5): + board.replace_card((x, x)) + _check_counts(board) + def test_lose_health(self): board = GameBoard.new_game(self.make_deck()) self.assertEqual(board.health, 4) @@ -152,54 +239,64 @@ class TestGameBoard(TestCase): (0, 2): '12', (1, 2): '32', (3, 2): '42', (4, 2): '02', })) - def test_rotate_locations_clockwise(self): + def test_rotate_locations_anticlockwise(self): board = GameBoard.new_game(self.make_deck()) board.board_locations = self.generate_locations() - board.rotate_locations('CLOCKWISE') + board.rotate_locations('ANTICLOCKWISE') self.assertEqual(board.board_locations, self.generate_locations({ (1, 1): '21', (2, 1): '31', (3, 1): '32', (1, 2): '11', (3, 2): '33', (1, 3): '12', (2, 3): '13', (3, 3): '23', })) - def test_rotate_locations_clockwise_top(self): + def test_rotate_locations_anticlockwise_top(self): board = GameBoard.new_game(self.make_deck(), initial_pos=(2, 0)) board.board_locations = self.generate_locations() - board.rotate_locations('CLOCKWISE') + board.rotate_locations('ANTICLOCKWISE') self.assertEqual(board.board_locations, self.generate_locations({ (1, 0): '30', (3, 0): '31', (1, 1): '10', (2, 1): '11', (3, 1): '21', })) - def test_rotate_locations_clockwise_right(self): + def test_rotate_locations_anticlockwise_right(self): board = GameBoard.new_game(self.make_deck(), initial_pos=(0, 2)) board.board_locations = self.generate_locations() - board.rotate_locations('CLOCKWISE') + board.rotate_locations('ANTICLOCKWISE') self.assertEqual(board.board_locations, self.generate_locations({ (0, 1): '11', (1, 1): '12', (1, 2): '13', (0, 3): '01', (1, 3): '03', })) - def test_rotate_locations_clockwise_corner(self): + def test_rotate_locations_anticlockwise_corner(self): board = GameBoard.new_game(self.make_deck(), initial_pos=(0, 4)) board.board_locations = self.generate_locations() - board.rotate_locations('CLOCKWISE') + board.rotate_locations('ANTICLOCKWISE') self.assertEqual(board.board_locations, self.generate_locations({ (0, 3): '13', (1, 3): '14', (1, 4): '03', })) - def test_rotate_locations_anticlockwise(self): + def test_rotate_locations_clockwise(self): board = GameBoard.new_game(self.make_deck()) board.board_locations = self.generate_locations() - board.rotate_locations('ANTICLOCKWISE') + board.rotate_locations('CLOCKWISE') self.assertEqual(board.board_locations, self.generate_locations({ (1, 1): '12', (2, 1): '11', (3, 1): '21', (1, 2): '13', (3, 2): '31', (1, 3): '23', (2, 3): '33', (3, 3): '32', })) + def test_rotate_locations_clockwise_1_3(self): + board = GameBoard.new_game(self.make_deck(), initial_pos=(1, 3)) + board.board_locations = self.generate_locations() + board.rotate_locations('CLOCKWISE') + self.assertEqual(board.board_locations, self.generate_locations({ + (0, 2): '03', (1, 2): '02', (2, 2): '12', + (0, 3): '04', (2, 3): '22', + (0, 4): '14', (1, 4): '24', (2, 4): '23', + })) + def test_allow_chess_move_knight(self): board = GameBoard.new_game(self.make_deck()) board.allow_chess_move(MOVES.KNIGHT) @@ -234,26 +331,29 @@ class TestLocationCard(TestCase): self.assertEqual(bits, set(BITS.values())) def test_new_location_no_actions(self): - location = LocationCard.new_location({'actions': []}) + location = LocationCard.new_location( + {'card_name': 'card', 'actions': []}, None) [action] = location.actions self.assertEqual(type(action), actions.DoNothing) self.assertEqual(action.required_bits, set()) + self.assertEqual(location.replacement_time, None) - def test_new_location_one_action(self): - location = LocationCard.new_location({'actions': [ - {'required_bits': [], 'action_class': 'DoNothing'}, - ]}) + def test_new_location_replacement_params(self): + location = LocationCard.new_location( + {'card_name': 'card', 'actions': []}, + {'chance': 1, 'min': 2, 'max': 2}) [action] = location.actions self.assertEqual(type(action), actions.DoNothing) self.assertEqual(action.required_bits, set()) + self.assertEqual(location.replacement_time, 2) - def test_parse_bits(self): - self.assertEqual( - LocationCard.parse_bits([]), frozenset([])) - self.assertEqual( - LocationCard.parse_bits(['RED']), frozenset([BITS.RED])) - self.assertEqual( - LocationCard.parse_bits([BITS.BLUE]), frozenset([BITS.BLUE])) - self.assertEqual( - LocationCard.parse_bits([BITS.NORTH, 'MSB']), - frozenset([BITS.NORTH, BITS.MSB])) + def test_new_location_one_action(self): + location = LocationCard.new_location({ + 'card_name': 'card1', + 'actions': [ + {'required_bits': [], 'action_class': 'DoNothing'}, + ]}, None) + [action] = location.actions + self.assertEqual(type(action), actions.DoNothing) + self.assertEqual(action.required_bits, set()) + self.assertEqual(location.replacement_time, None)