def test_game_complete(self): # [36, 45, 14, 5, 25, 20, 46, 48, 1, 46, 48, 13, 35, 45, 15, 18, 7, 2, # 30, 46, 47, 36, 43, 27, 5, 46, 48, 6, 2, 22, 46, 47, 35, 44, 29, 8, 46, # 48, 18, 21, 27, 26, 14, 11, 9, 46, 48, 17, 34, 43, 10, 1, 46, 47, 41, # 42, 24, 17, 46, 48, 0, 14, 3, 29, 46, 48, 41, 45, 19, 8, 30, 24, 20, # 16, 34, 46, 47, 39, 44, 16, 30, 18, 46, 48, 21, 46, 47, 39, 43, 24, # 26, 14, 22, 29, 6, 5, 7] game = WattenGame() world = WorldWatten() world.init_world_to_state(1, -1, 0, 0, [25, 9, 1, 32, 14], [5, 13, 7, 10, 20], [], 0, 0, 2, False, False, None, 16, 28, None, None) game.trueboard = world cur_player = game.get_cur_player() self.assertEqual(cur_player, 0) moves = game.get_valid_moves_no_zeros() self.assertEqual(moves, [33, 34, 35, 36, 37, 38, 39, 40, 41, 46]) self.assertEqual(game.make_move(36), (0.0, 1)) cur_player = game.get_cur_player() self.assertEqual(cur_player, 1) moves = game.get_valid_moves_no_zeros() self.assertEqual(moves, [42, 43, 44, 45, 46])
def test_observe(self): world = WorldWatten() world.current_game_prize = 15 result = world.observe(1) print(result)
def test_get_valid_moves_last_move_accepted_raise(self): world = WorldWatten() world.is_last_move_accepted_raise = True valid_moves = world.get_valid_moves() # after an accepted raise a player can't raise again self.assertNotIn(46, valid_moves)
def test_get_valid_moves_declare_rank(self): world = WorldWatten() world.refresh() # opponent player declare the rank # valid moves: ALL RANKS + RAISE POINTS valid_moves = world.get_valid_moves() self.assertEqual([33, 34, 35, 36, 37, 38, 39, 40, 41, 46], valid_moves)
def test_get_valid_moves_last_move_raise(self): world = WorldWatten() world.is_last_move_raise = True valid_moves = world.get_valid_moves() # after a raise a player can only accept it or fold self.assertEqual([47, 48], valid_moves)
def test_get_valid_moves_last_move_raise_last_hand(self): world = WorldWatten() world.is_last_move_raise = True world.is_last_hand_raise_valid = True valid_moves = world.get_valid_moves() # after a raise in last hand a player can only accept, fold, or fold and verify conditions for raise in last hand self.assertEqual([47, 48, 49], valid_moves)
def test_get_valid_moves_declare_suit(self): world = WorldWatten() world.rank = 5 # rank already chosen # current player declare the suit valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [42, 43, 44, 45, 46]) world.suit = 3 valid_moves = world.get_valid_moves() self.assertEqual(len(valid_moves), 6) # no suit played - every move is allowed world.played_cards.append(watten.get_id(7, 2)) world.current_player = 1 world.player_A_hand = [ watten.get_id(3, 2), watten.get_id(6, 3), watten.get_id(3, 0), watten.get_id(2, 0), watten.get_id(4, 1) ] valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [19, 30, 3, 2, 12, 46])
def test_act_pick_suit_2(self): world = WorldWatten() world.current_player = -1 world.rank = 3 result, next_player = world.act(42) self.assertEqual(result, "continue") self.assertEqual(next_player, 1) self.assertEqual(world.suit, 0) self.assertEqual(world.is_last_move_raise, False) self.assertEqual(world.is_last_move_accepted_raise, False)
def test_last_hand_raise_valid_error(self): world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4] world.rank = 3 world.suit = 2 world.current_player = 1 world.player_B_hand = [watten.get_id(4, 1)] world.player_A_hand = [watten.get_id(5, 0)] self.assertRaises(InconsistentStateError, world._last_hand_raise_valid)
def test_is_blinde(self): world = WorldWatten() world.rank = 6 world.suit = 2 self.assertTrue(world.is_blinde(6)) self.assertFalse(world.is_blinde(3)) self.assertFalse(world.is_blinde(1)) self.assertFalse(world.is_blinde(7))
def test_act_fold_hand_and_show_valid_raise(self): world = WorldWatten() world.player_A_score = 4 world.player_B_score = 7 world.current_game_prize = 3 world.current_player = 1 world.distributing_cards_player = -1 world.is_last_move_raise = True world.is_last_hand_raise_valid = False result, next_player = world.act( watten.moves["fold_hand_and_show_valid_raise"]) self.assertEqual("end", result) self.assertEqual(7, world.player_B_score) self.assertEqual(4 + 2, world.player_A_score) self.assertEqual(-1, world.current_player) self.assertEqual(-1, next_player)
def test_get_valid_moves_declare_suit_rank_weli(self): world = WorldWatten() world.refresh() # when the chosen rank is weli, suit is automatically world.rank = 8 world.suit = 3 # opponent player declare the rank valid_moves = world.get_valid_moves() # if picked rank is weli, then it doesn't matter to declare a suit self.assertEqual(len(valid_moves), 6)
def test_act_pick_suit_1(self): world = WorldWatten() world.current_player = 1 world.rank = 3 world.is_last_move_accepted_raise = True world.is_last_move_raise = False result, next_player = world.act(45) self.assertEqual(result, "continue") self.assertEqual(next_player, -1) self.assertEqual(world.suit, 3) self.assertEqual(world.is_last_move_raise, False) self.assertEqual(world.is_last_move_accepted_raise, False)
def test_act_raise_points(self): world = WorldWatten() world.current_player = -1 world.current_game_prize = 4 world.is_last_move_raise = False world.is_last_move_accepted_raise = False result, next_player = world.act(46) self.assertEqual(result, "continue") self.assertEqual(next_player, 1) self.assertEqual(world.current_player, 1) self.assertEqual(world.current_game_prize, 5) self.assertEqual(world.is_last_move_raise, True) self.assertEqual(world.is_last_move_accepted_raise, False)
def test_get_valid_moves_played_suit_only_rechte(self): world = WorldWatten() # suit has been played world.played_cards = [] world.rank = 4 world.suit = 3 world.played_cards.append(watten.get_id(3, 3)) world.current_player = 1 world.player_A_hand = [ watten.get_id(1, 2), watten.get_id(1, 0), watten.get_id(3, 0), watten.get_id(4, 3), watten.get_id(2, 2) ] valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [17, 1, 3, 28, 18, 46])
def test_act_accept_raise(self): world = WorldWatten() world.current_player = 1 world.is_last_move_accepted_raise = False world.is_last_move_raise = True result, next_player = world.act(48) self.assertEqual(result, "continue") self.assertEqual(next_player, -1) self.assertEqual(world.is_last_move_raise, False) self.assertEqual(world.is_last_move_accepted_raise, True)
def test_game_no_raise_player_B_starts(self): world = WorldWatten() world.LOG.setLevel(DEBUG) world.init_world_to_state(-1, 1, 0, 0, [3, 31, 27, 10, 29], [0, 9, 30, 25, 26], [], 0, 0, 2, False, False, None, 15, 20, None, None) # [30, 29, 37, 45, 7, 10, 21, 19, 25, 24, # 33, 42, 8, 20, 32, 31, 24, 10, 0, 9, 36, 43, 23, 28, 12, 8, 31, 30, 34, # 43, 21, 23, 12, 17, 22, 24, 0, 4, 11, 25, 35, 44, 12, 1, 21, 17, 10, # 32, 34, 42, 19, 16, 3, 2, 20, 7, 13, 22, 11, 29, 37, 42, 8, 2, 3, 9, 5, # 4, 31, 16, 15, 32, 38, 44, 7, 24, 6, 22, 2, 23, 27, 9, 33, 42, 6, 16, # 17, 9, 13, 22, 34, 43, 19, 1, 5, 20, 10, 12, 17, 31, 22, 18, 35, 44, # 23, 20, 10, 25, 15, 14, 34, 43, 13, 12, 22, 10, 2, 1, 29, 18, 41, 45, # 5, 2, 14, 16, 27, 25] world_copy = world.deepcopy() ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [33, 34, 35, 36, 37, 38, 39, 40, 41, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(37) self.assertEqual(outcome, "continue") self.assertEqual(next_player, 1) world_copy.rank = 4 world_copy.current_player = 1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [42, 43, 44, 45, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(45) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.suit = 3 world_copy.current_player = -1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [0, 9, 30, 25, 26, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(0) self.assertEqual(outcome, "continue") self.assertEqual(next_player, 1) world_copy.player_B_hand = [9, 30, 25, 26] world_copy.played_cards = [0] world_copy.current_player = 1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [3, 31, 27, 10, 29, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(10) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.player_A_hand = [3, 31, 27, 29] world_copy.played_cards = [0, 10] world_copy.current_game_player_B_score = 1 world_copy.current_player = -1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [9, 30, 25, 26, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(25) self.assertEqual(outcome, "continue") self.assertEqual(next_player, 1) world_copy.player_B_hand = [9, 30, 26] world_copy.played_cards = [0, 10, 25] world_copy.current_player = 1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [31, 27, 29, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(31) self.assertEqual(outcome, "continue") self.assertEqual(next_player, 1) world_copy.player_A_hand = [3, 27, 29] world_copy.played_cards = [0, 10, 25, 31] world_copy.current_player = 1 world_copy.current_game_player_A_score = 1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [3, 27, 29, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(3) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.player_A_hand = [27, 29] world_copy.played_cards = [0, 10, 25, 31, 3] world_copy.current_player = -1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [9, 30, 26, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(26) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.player_B_hand = [9, 30] world_copy.played_cards = [0, 10, 25, 31, 3, 26] world_copy.current_game_player_B_score = 2 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [9, 30, 46]) self._compare_worlds(world, world_copy)
def test_game_no_raise_player_A_starts(self): world = WorldWatten() world.LOG.setLevel(DEBUG) world.init_world_to_state(1, -1, 0, 0, [14, 30, 2, 28, 11], [4, 23, 31, 7, 22], [], 0, 0, 2, False, False, None, 21, 26, None, None) # [40, 45, 29, 12, 28, 13, 26, 0, 33, 45, # 3, 25, 6, 16, 30, 14, 13, 1, 38, 43, 13, 5, 32, 3, 21, 27, 33, 42, 0, # 4, 30, 31, 23, 7, 29, 1, 25, 9, 33, 42, 9, 30, 14, 32, 7, 25, 34, 42, # 29, 7, 15, 19, 11, 17, 20, 27, 0, 2, 35, 44, 31, 4, 28, 1, 12, 3, 33, # 45, 24, 25, 7, 11, 14, 18, 37, 45, 2, 27, 3, 0, 8, 10, 6, 26, 33, 43, # 21, 22, 6, 10, 24, 14, 8, 16, 33, 42, 3, 0, 29, 17, 13, 31] world_copy = world.deepcopy() ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [33, 34, 35, 36, 37, 38, 39, 40, 41, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(36) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.rank = 3 world_copy.current_player = -1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [42, 43, 44, 45, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(45) self.assertEqual(outcome, "continue") self.assertEqual(next_player, 1) world_copy.suit = 3 world_copy.current_player = 1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [14, 30, 2, 28, 11, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(30) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.player_A_hand = [14, 2, 28, 11] world_copy.played_cards = [30] world_copy.current_player = -1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [31, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(31) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.current_game_player_B_score = 1 world_copy.player_B_hand = [4, 23, 7, 22] world_copy.played_cards = [30, 31] self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [4, 23, 7, 22, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(22) self.assertEqual(outcome, "continue") self.assertEqual(next_player, 1) world_copy.player_B_hand = [4, 23, 7] world_copy.played_cards = [30, 31, 22] world_copy.current_player = 1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [14, 2, 28, 11, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(2) self.assertEqual(outcome, "continue") self.assertEqual(next_player, -1) world_copy.player_A_hand = [14, 28, 11] world_copy.current_game_player_B_score = 2 world_copy.played_cards = [30, 31, 22, 2] world_copy.current_player = -1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [4, 23, 7, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(23) self.assertEqual(outcome, "continue") self.assertEqual(next_player, 1) world_copy.player_B_hand = [4, 7] world_copy.played_cards = [30, 31, 22, 2, 23] world_copy.current_player = 1 self._compare_worlds(world, world_copy) ######## MOVE ######## valid_moves = world.get_valid_moves() self.assertEqual(valid_moves, [14, 28, 11, 46]) self._compare_worlds(world, world_copy) outcome, next_player = world.act(14) self.assertEqual(outcome, "end") self.assertEqual(next_player, -1) world.player_A_hand = [20, 21, 22, 23, 24] world.player_B_hand = [25, 26, 27, 28, 29] world.first_card_deck = 4 world.last_card_deck = 5 world.deck = [8, 9, 10] world_copy.player_A_hand = [20, 21, 22, 23, 24] world_copy.player_B_hand = [25, 26, 27, 28, 29] world_copy.first_card_deck = 4 world_copy.last_card_deck = 5 world_copy.deck = [8, 9, 10] world_copy.current_player = -1 world_copy.distributing_cards_player = 1 world_copy.player_B_score = 2 world_copy.played_cards = [] world_copy.current_game_player_A_score = 0 world_copy.current_game_player_B_score = 0 world_copy.rank = None world_copy.suit = None self._compare_worlds(world, world_copy)
def test_assign_points_fold(self): # player -1 fold world = WorldWatten() world.current_player = -1 world.current_game_prize = 5 world.player_A_score = 3 world.player_B_score = 8 world.is_last_hand_raise_valid = None world._assign_points_fold() self.assertEqual(world.player_A_score, 7) self.assertEqual(world.player_B_score, 8) # player 1 fold world = WorldWatten() world.current_player = 1 world.current_game_prize = 5 world.player_A_score = 3 world.player_B_score = 8 world.is_last_hand_raise_valid = None world._assign_points_fold() self.assertEqual(world.player_A_score, 3) self.assertEqual(world.player_B_score, 12) # player 1 fold is last hand raise not valid world = WorldWatten() world.current_player = 1 world.current_game_prize = 5 world.player_A_score = 3 world.player_B_score = 8 world.is_last_hand_raise_valid = False world._assign_points_fold() self.assertEqual(world.player_A_score, 7) self.assertEqual(world.player_B_score, 8) # player 1 fold is last hand raise valid world = WorldWatten() world.current_player = 1 world.current_game_prize = 5 world.player_A_score = 3 world.player_B_score = 8 world.is_last_hand_raise_valid = True world._assign_points_fold() self.assertEqual(world.player_A_score, 3) self.assertEqual(world.player_B_score, 12) # player -1 fold is last hand raise not valid world = WorldWatten() world.current_player = -1 world.current_game_prize = 5 world.player_A_score = 3 world.player_B_score = 8 world.is_last_hand_raise_valid = False world._assign_points_fold() self.assertEqual(world.player_A_score, 3) self.assertEqual(world.player_B_score, 12) # player -1 fold is last hand raise valid world = WorldWatten() world.current_player = -1 world.current_game_prize = 5 world.player_A_score = 3 world.player_B_score = 8 world.is_last_hand_raise_valid = True world._assign_points_fold() self.assertEqual(world.player_A_score, 7) self.assertEqual(world.player_B_score, 8)
def test_is_rank_higher(self): world = WorldWatten() world.refresh() # weli played self.assertFalse(world.is_rank_higher(8, 0)) self.assertFalse(world.is_rank_higher(8, 1)) self.assertFalse(world.is_rank_higher(8, 2)) self.assertFalse(world.is_rank_higher(8, 3)) self.assertFalse(world.is_rank_higher(8, 4)) self.assertFalse(world.is_rank_higher(8, 5)) self.assertFalse(world.is_rank_higher(8, 6)) self.assertFalse(world.is_rank_higher(8, 7)) self.assertTrue(world.is_rank_higher(0, 8)) self.assertTrue(world.is_rank_higher(1, 8)) self.assertTrue(world.is_rank_higher(2, 8)) self.assertTrue(world.is_rank_higher(3, 8)) self.assertTrue(world.is_rank_higher(4, 8)) self.assertTrue(world.is_rank_higher(5, 8)) self.assertTrue(world.is_rank_higher(6, 8)) self.assertTrue(world.is_rank_higher(7, 8)) self.assertTrue(world.is_rank_higher(3, 8)) # not weli self.assertTrue(world.is_rank_higher(6, 5)) self.assertTrue(world.is_rank_higher(7, 1)) self.assertFalse(world.is_rank_higher(1, 4)) self.assertFalse(world.is_rank_higher(3, 6)) self.assertFalse(world.is_rank_higher(4, 6)) self.assertFalse(world.is_rank_higher(5, 6))
def test_assign_points_single_hand_ended(self): # current player: 1 world = WorldWatten() world.current_player = 1 world.current_game_player_A_score = 1 world.current_game_player_B_score = 2 world._assign_points_move(True) self.assertEqual(world.current_game_player_A_score, 2) self.assertEqual(world.current_game_player_B_score, 2) world = WorldWatten() world.current_player = 1 world.current_game_player_A_score = 1 world.current_game_player_B_score = 2 world._assign_points_move(False) self.assertEqual(world.current_game_player_A_score, 1) self.assertEqual(world.current_game_player_B_score, 3) # current player: 2 world = WorldWatten() world.current_player = -1 world.current_game_player_A_score = 1 world.current_game_player_B_score = 2 world._assign_points_move(True) self.assertEqual(world.current_game_player_A_score, 1) self.assertEqual(world.current_game_player_B_score, 3) world = WorldWatten() world.current_player = -1 world.current_game_player_A_score = 1 world.current_game_player_B_score = 2 world._assign_points_move(False) self.assertEqual(world.current_game_player_A_score, 2) self.assertEqual(world.current_game_player_B_score, 2)
def test_get_opponent_hand(self): world = WorldWatten() world.player_A_hand = [1, 2, 3] world.player_B_hand = [4, 5, 6] world.current_player = 1 result = world._get_opponent_hand() self.assertEqual(result, [4, 5, 6]) world = WorldWatten() world.player_A_hand = [1, 2, 3] world.player_B_hand = [4, 5, 6] world.current_player = -1 result = world._get_opponent_hand() self.assertEqual(result, [1, 2, 3])
def test_remove_card_from_hand(self): world = WorldWatten() world.player_A_hand = [0, 1, 2, 3, 4] world.player_B_hand = [5, 6, 7, 8, 9] world._remove_card_from_hand(3, 1) self.assertTrue(world.player_A_hand, [0, 1, 2, 4]) world._remove_card_from_hand(5, -1) self.assertTrue(world.player_A_hand, [6, 7, 8, 9]) world._remove_card_from_hand(4, 1) self.assertTrue(world.player_A_hand, [0, 1, 2]) world._remove_card_from_hand(8, -1) self.assertTrue(world.player_A_hand, [6, 7, 9])
def test_is_game_end(self): world = WorldWatten() world.refresh() result = world.is_game_end() self.assertFalse(result) world.player_A_score = 15 result = world.is_game_end() self.assertTrue(result) world.refresh() world.player_B_score = 13 result = world.is_game_end() self.assertFalse(result) world.refresh() world.player_B_score = 18 result = world.is_game_end() self.assertTrue(result)
def test_last_hand_raise_valid_9_cards(self): # trumpf # player -1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, 8] world.rank = 3 world.suit = 2 world.current_player = -1 world.player_B_hand = [watten.get_id(4, 2)] world.player_A_hand = [watten.get_id(5, 0)] result = world._last_hand_raise_valid() self.assertTrue(result) # player 1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, 8] world.rank = 3 world.suit = 2 world.current_player = 1 world.player_B_hand = [watten.get_id(4, 2)] world.player_A_hand = [watten.get_id(5, 2)] result = world._last_hand_raise_valid() self.assertTrue(result) # same suit # player 1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, watten.get_id(1, 0)] world.rank = 3 world.suit = 2 world.current_player = 1 world.player_B_hand = [] world.player_A_hand = [watten.get_id(4, 0)] result = world._last_hand_raise_valid() self.assertTrue(result) # player -1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, watten.get_id(1, 0)] world.rank = 3 world.suit = 2 world.current_player = -1 world.player_B_hand = [watten.get_id(4, 0)] world.player_A_hand = [] result = world._last_hand_raise_valid() self.assertTrue(result) # card beats the played one # player 1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, watten.get_id(1, 0)] world.rank = 3 world.suit = 2 world.current_player = 1 world.player_B_hand = [] world.player_A_hand = [watten.get_id(3, 2)] result = world._last_hand_raise_valid() self.assertTrue(result) # player -1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, watten.get_id(1, 0)] world.rank = 3 world.suit = 2 world.current_player = -1 world.player_B_hand = [watten.get_id(3, 2)] world.player_A_hand = [] result = world._last_hand_raise_valid() self.assertTrue(result) # raise was not legal # player 1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, watten.get_id(6, 3)] world.rank = 3 world.suit = 2 world.current_player = 1 world.player_B_hand = [] world.player_A_hand = [watten.get_id(1, 0)] result = world._last_hand_raise_valid() self.assertFalse(result) # player -1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7, watten.get_id(6, 3)] world.rank = 3 world.suit = 2 world.current_player = -1 world.player_B_hand = [watten.get_id(1, 0)] world.player_A_hand = [] result = world._last_hand_raise_valid() self.assertFalse(result)
def test_is_won(self): world = WorldWatten() world.refresh() world.player_A_score = 15 result = world.is_won(-1) self.assertTrue(result) world.refresh() world.player_A_score = 15 world.player_B_score = 15 self.assertRaises(InconsistentStateError, world.is_won, 1) world.refresh() world.player_B_score = 15 result = world.is_won(-1) self.assertFalse(result) world.refresh() world.player_B_score = 15 result = world.is_won(1) self.assertTrue(result)
def test_last_hand_raise_valid_8_cards(self): # player -1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7] world.rank = 3 world.suit = 2 world.current_player = -1 world.player_B_hand = [watten.get_id(4, 1)] world.player_A_hand = [watten.get_id(5, 0)] result = world._last_hand_raise_valid() self.assertFalse(result) world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7] world.rank = 3 world.suit = 2 world.current_player = -1 world.player_B_hand = [watten.get_id(4, 2)] world.player_A_hand = [watten.get_id(5, 0)] result = world._last_hand_raise_valid() self.assertTrue(result) # player 1 raised world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7] world.rank = 3 world.suit = 2 world.current_player = 1 world.player_B_hand = [watten.get_id(4, 1)] world.player_A_hand = [watten.get_id(5, 0)] result = world._last_hand_raise_valid() self.assertFalse(result) world = WorldWatten() world.played_cards = [0, 1, 2, 3, 4, 5, 6, 7] world.rank = 3 world.suit = 2 world.current_player = 1 world.player_B_hand = [watten.get_id(4, 2)] world.player_A_hand = [watten.get_id(5, 2)] result = world._last_hand_raise_valid() self.assertTrue(result)
def test_act_unknown_move(self): world = WorldWatten() self.assertRaises(InvalidActionError, world.act, 49)
def test_observe(self): world = WorldWatten() world.first_card_deck = 32 world.last_card_deck = 32 world.player_A_hand = [0, 1, 2, 3, 4] world.player_B_hand = [31, 30, 29, 28, 27] world.rank = 8 world.suit = 0 world.played_cards = [10, 11, 12, 13, 14] world.current_game_player_A_score = 1 world.current_game_player_B_score = 2 world.player_A_score = 14 world.player_B_score = 1 world.is_last_move_raise = True world.is_last_move_accepted_raise = True world.is_last_hand_raise_valid = False world.current_game_prize = 15 expected_player_A = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 9 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 19 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 29 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, # 39 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 49 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 59 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, # 69 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 89 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 99 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, # 109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 119 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, # 129 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 149 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, # 159 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 169 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, # 179 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, # 189 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, # 199 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 209 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, # 219 0, 0, 0, 0, 0, 1 ] # 225 expected_player_B = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 9 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 19 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 29 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, # 39 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 49 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 59 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, # 69 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 89 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, # 99 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, # 109 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 119 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, # 129 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 149 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, # 159 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 169 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, # 179 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, # 189 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 199 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, # 209 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, # 219 0, 0, 0, 0, 0, 1 ] # 225 observation_player_A = world.observe(1) observation_player_B = world.observe(-1) np.testing.assert_array_equal( observation_player_A, np.array(expected_player_A).reshape((226, 1))) np.testing.assert_array_equal( observation_player_B, np.array(expected_player_B).reshape((226, 1)))
def test_get_last_played_card(self): world = WorldWatten() world.played_cards = [4, 3, 2] last_played_card = world._get_last_played_card() self.assertEqual(last_played_card, 2) world = WorldWatten() world.played_cards = [] last_played_card = world._get_last_played_card() self.assertEqual(last_played_card, None) world = WorldWatten() world.played_cards = [123] last_played_card = world._get_last_played_card() self.assertEqual(last_played_card, 123) world = WorldWatten() world.played_cards = [2, 8] last_played_card = world._get_last_played_card() self.assertEqual(last_played_card, 8)