X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=naja%2Ftests%2Ftest_gameboard.py;h=cccd9aae88be92758b1ab658292423fdf2a532b9;hb=2bc3952e185343ae2ff75f3f8ed738561858f61b;hp=d843c7e9fc86e2cee5e913551c08946f3f9f8d31;hpb=ee2a1f7e16272d19eb5a2dc03355ce8b851a441e;p=naja.git diff --git a/naja/tests/test_gameboard.py b/naja/tests/test_gameboard.py index d843c7e..cccd9aa 100644 --- a/naja/tests/test_gameboard.py +++ b/naja/tests/test_gameboard.py @@ -1,11 +1,20 @@ from unittest import TestCase -from naja.constants import BITS, MOVES +from naja.constants import BITS, MOVES, EXAMINE from naja.gameboard import GameBoard, LocationCard +from naja.options import parse_args from naja import actions class TestGameBoard(TestCase): + def setUp(self): + parse_args([]) + + def make_deck(self, cards=None): + if cards is None: + cards = [{'card_name': 'card', 'actions': []}] + return {'cards': cards} + def assert_state(self, state1, state2, exclude=(), player_exclude=()): def filter_dict(source, exclude_keys): return dict((k, v) for k, v in source.items() @@ -21,38 +30,144 @@ class TestGameBoard(TestCase): self.assertEqual(state1, state2) def test_export_new_board(self): - board = GameBoard.new_game([{'actions': [{ - 'action_class': 'LoseHealthOrMSB', - 'required_bits': [], - }]}]) + 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': [{ - 'action_class': 'LoseHealthOrMSB', - 'required_bits': [], - }]}], + 'locations': [{'card_name': 'card1', 'actions': [ + { + 'action_class': 'LoseHealthOrMSB', + 'required_bits': [], + }, { + 'action_class': 'GainHealth', + 'required_bits': [BITS.RED], + }, + ]}], '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', 'card_name', 'max_number', + 'replacement_time']) + self.assertEqual(location_state['actions'], [ + { + 'action_class': 'LoseHealthOrMSB', + 'required_bits': [], + 'data': {}, + }, { + 'action_class': 'GainHealth', + 'required_bits': [BITS.RED], + 'data': {}, + }, + ]) + self.assertTrue(2 <= len(location_state['bitwise_operand']) <= 3) self.assertEqual( - set(board_locations.keys()), - set((x, y) for x in range(5) for y in range(5))) - for location_state in board_locations.values(): - self.assertEqual( - sorted(location_state.keys()), ['actions', 'bitwise_operand']) - self.assertEqual(location_state['actions'], [{ + 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': [], - 'data': {}, - }]) - self.assertTrue(2 <= len(location_state['bitwise_operand']) <= 3) + '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([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) self.assertEqual(board.health, 4) state_1 = board.export() @@ -63,7 +178,7 @@ class TestGameBoard(TestCase): self.assert_state(state_1, state_2, exclude=['health']) def test_gain_health(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.health = 2 self.assertEqual(board.health, 2) state_1 = board.export() @@ -75,7 +190,7 @@ class TestGameBoard(TestCase): self.assert_state(state_1, state_2, exclude=['health']) def test_gain_health_at_max(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) self.assertEqual(board.health, 4) state_1 = board.export() @@ -93,7 +208,7 @@ class TestGameBoard(TestCase): return locations_dict def test_shift_locations_north(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.board_locations = self.generate_locations() board.shift_locations('NORTH') self.assertEqual(board.board_locations, self.generate_locations({ @@ -101,7 +216,7 @@ class TestGameBoard(TestCase): })) def test_shift_locations_south(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.board_locations = self.generate_locations() board.shift_locations('SOUTH') self.assertEqual(board.board_locations, self.generate_locations({ @@ -109,7 +224,7 @@ class TestGameBoard(TestCase): })) def test_shift_locations_east(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.board_locations = self.generate_locations() board.shift_locations('EAST') self.assertEqual(board.board_locations, self.generate_locations({ @@ -117,73 +232,83 @@ class TestGameBoard(TestCase): })) def test_shift_locations_west(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.board_locations = self.generate_locations() board.shift_locations('WEST') self.assertEqual(board.board_locations, self.generate_locations({ (0, 2): '12', (1, 2): '32', (3, 2): '42', (4, 2): '02', })) - def test_rotate_locations_clockwise(self): - board = GameBoard.new_game([{'actions': []}]) + 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): - board = GameBoard.new_game([{'actions': []}], initial_pos=(2, 0)) + 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): - board = GameBoard.new_game([{'actions': []}], initial_pos=(0, 2)) + 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): - board = GameBoard.new_game([{'actions': []}], initial_pos=(0, 4)) + 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): - board = GameBoard.new_game([{'actions': []}]) + 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([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.allow_chess_move(MOVES.KNIGHT) self.assertEqual(board.player.movement_mode, MOVES.KNIGHT) def test_allow_chess_move_bishop(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.allow_chess_move(MOVES.BISHOP) self.assertEqual(board.player.movement_mode, MOVES.BISHOP) def test_allow_chess_move_castle(self): - board = GameBoard.new_game([{'actions': []}]) + board = GameBoard.new_game(self.make_deck()) board.allow_chess_move(MOVES.CASTLE) self.assertEqual(board.player.movement_mode, MOVES.CASTLE) @@ -206,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)