class PlayerTestCase(unittest.TestCase): def setUp(self): self.player = Player() self.cards = [Card('red', 1), Card('green', 3)] self.deck = Deck(self.cards) self.emptyDeck = Deck([]) self.player_with_cards = Player(self.cards) def test_init_value(self): self.assertEqual(0, self.player.num_cards) self.assertEqual(0, len(self.player.cards)) def test_get_card_from_non_empty_deck(self): self.player.get_card(self.deck) self.assertEqual('green', self.player.cards[0].color) self.assertEqual(3, self.player.cards[0].number) self.assertEqual(1, len(self.deck.cards)) self.assertEqual('red', self.deck.cards[0].color) self.assertEqual(1, self.deck.cards[0].number) def test_get_card_from_empty_deck(self): self.assertRaises(ValueError, self.player.get_card, self.emptyDeck) def test_get_score(self): self.assertEqual(6, self.player_with_cards.get_score())
def test_deal_cards(self): players = [Player('Player 1', []), Player('Player 2', [])] cards = [Card(1, 1), Card(2, 2), Card(3, 3), Card(4, 4)] dealer = Dealer(cards) dealer.deal_to(players) self.assertEqual(players[0].cards, [Card(1, 1), Card(3, 3)]) self.assertEqual(players[1].cards, [Card(2, 2), Card(4, 4)])
def test_1000_random_tactic_executions(self): cards = CardGenerator.generate([1, 2], [1, 2, 3, 4, 5]) player1 = Player('Player 1', cards=[], tactic=tactic_play_random_card) player2 = Player('Player 2', cards=[], tactic=tactic_play_random_card) tactics_analyser = TacticsAnalyser(cards, [player1, player2]) results = tactics_analyser.run(1000) self.assertEqual(len(results), 2)
def __init__(self, sid, names): self.player = Player(names[0], auto=True) self.opponent_names = names[1:] self.sid = sid # session id from socketio self.round_number = 0 self.trick_number = 0 self.state = STATE_READY
def test_compare_cards_when_equal_cards(self): player = Player(0) cards = [[Card(0, 'A')]] player._check_count = MagicMock() player._check_sequence = MagicMock() self.assertEqual(player._compare_cards(cards, cards), 0) player._check_count.assert_not_called() player._check_sequence.assert_not_called()
class PlayerTests(unittest.TestCase): """Tests decks""" def setUp(self): self.player = Player() # test get winining value def testGetWininingValue(self): self.player.add_card(Card(suit=0, rank=2)) self.player.add_card(Card(suit=2, rank=5)) self.player.add_card(Card(suit=3, rank=8)) self.player.add_card(Card(suit=2, rank=6)) self.assertTrue(self.player.get_winining_value() ==38)
def test_compare_cards_when_cards_not_equal(self): player = Player(0) cards1 = [[Card(0, 'A')], []] cards2 = [[], [Card(1, 'K')]] mock = Mock(return_value=0) player._check_count = mock player._check_sequence = mock self.assertEqual(player._compare_cards(cards1, cards2), 1) card_param1 = [['A'], []] card_param2 = [[], ['K']] calls = [call(card_param1, card_param2, 3), call( card_param1, card_param2), call(card_param1, card_param2, 2)] mock.assert_has_calls(calls)
def test_has_better_cards(self): player1 = Player(0) player2 = Player(0) card = Card(0, 'A') player1.add_card(card) player1._compare_cards = MagicMock() player1.has_better_cards(player2) player1._compare_cards.assert_called_with([[card], [], [], [], [], [], [], [], [ ], [], [], []], [[], [], [], [], [], [], [], [], [], [], [], []])
def test_get_winning_player(self): self.player1 = Player('Player 1', [Card(1, 4), Card(1, 3)]) self.player2 = Player('Player 2', [Card(1, 2), Card(1, 1)]) self.game.round_start() self.game.apply_action(Action(self.player1, Card(1, 4))) self.game.apply_action(Action(self.player2, Card(1, 2))) self.game.round_end() self.assertEqual(self.game.get_winner(), self.player1) self.game.round_start() self.game.apply_action(Action(self.player1, Card(1, 3))) self.game.apply_action(Action(self.player2, Card(1, 1))) self.game.round_end() self.assertEqual(self.game.get_winner(), self.player1)
def test_apply_action_with_different_types(self): self.player1 = Player('Player 1', [Card(2, 1), Card(1, 3)]) self.player2 = Player('Player 2', [Card(2, 2), Card(1, 4)]) self.game.round_start() self.game.apply_action(Action(self.player1, Card(2, 1))) self.game.apply_action(Action(self.player2, Card(1, 4))) self.game.round_end() completed_round = self.game.completed_rounds[0] self.assertEqual(completed_round.winning_action, Action(self.player1, Card(2, 1))) self.game.round_start() self.game.apply_action(Action(self.player1, Card(1, 3))) self.game.apply_action(Action(self.player2, Card(2, 2))) self.game.round_end() completed_round = self.game.completed_rounds[1] self.assertEqual(completed_round.winning_action, Action(self.player2, Card(2, 2))) self.assertEqual(self.player1.cards, []) self.assertEqual(self.player2.cards, [])
def test_init(self): """Test Player initial instance variables. """ player = Player(0) self.assertEqual(player.get_id(), 0) self.assertIsInstance(player.get_cards(), list)
def test_remove_player(self): card_game = CardGame([0, 1]) card_game._remove_player(Player(1)) self.assertTrue(1 not in card_game._available_players)
def setUp(self): self.player = Player()
def setUp(self): self.player = Player() self.cards = [Card('red', 1), Card('green', 3)] self.deck = Deck(self.cards) self.emptyDeck = Deck([]) self.player_with_cards = Player(self.cards)
def setUp(self): self.player1 = Player('Player 1') self.player2 = Player('Player 2') self.game = MultiValCardGame([self.player1, self.player2])
def test_check_count_when_two_triplet(self): player = Player(0) self.assertEqual(player._check_count( [[], ['K', 'K', 'K']], [['A', 'A', 'A'], []], 3), -1)
def test_reset_card(self): player = Player(0) init_cards = player.get_cards() player.add_card(Card(0, 'A')) player.reset_card() self.assertEqual(player.get_cards(), init_cards)
def test_add_card(self): player = Player(0) init_count = len(player.get_cards()[0]) player.add_card(Card(0, 'A')) self.assertEqual(len(player.get_cards()[0]), init_count + 1)
def test_show_cards(self): player = Player(0) try: player.show_cards() except Exception: self.fail("show_cards() raised Exception unexpectedly!")
return total # Loop that runs to start a new hand. while True: # Initialize and shuffle new deck. deck = Deck() deck.shuffle() # Initialize player and dealer then deals cards to them. Set values to determine if beginning of hand and if player # chose to stand or not. player = Player() dealer = Player() player.draw(deck) dealer.draw(deck) player.draw(deck) dealer.draw(deck) first_hand = True player_stand = False # Loop that runs while player is playing current hand. Once player stands the dealer will finish drawing cards as # needed, calculate hands and determine whether it was a win loss or draw for the player. while True:
def test_check_count_when_triplet_and_sequence(self): player = Player(0) self.assertEqual(player._check_count( [[], ['K', 'K', 'K']], [['A'], ['K'], ['Q']], 3), 1)
def test_check_sequence_when_sequece_and_pair(self): player = Player(0) self.assertEqual(player._check_sequence( [['A'], ['K'], ['Q']], [['A'], ['K', 'K']]), 1)
class Game_Player(): def __init__(self, sid, names): self.player = Player(names[0], auto=True) self.opponent_names = names[1:] self.sid = sid # session id from socketio self.round_number = 0 self.trick_number = 0 self.state = STATE_READY def restart(self): self.player.score = 0 self.player.tricksWon = [] def log_state(self, received): #states = ['NEGOTIATION', 'DH', 'ROTATION','CONNECT', 'OPEN', 'DATA', 'CLOSE'] #logger.info("State: {}".format(states[self.state])) logger.info("Received: {}".format(received)) def on_frame(self, frame: str) -> None: """ Processes a frame (JSON Object) :param frame: The JSON Object to process :return: """ #logger.debug("Frame: {}".format(frame)) try: message = json.loads(frame) except: logger.exception("Could not decode the JSON message") return mtype = message.get('type', None) self.log_state(mtype) if mtype == 'ROUND_UPDATE': logger.debug('ROUND_UPDATE') self.round_number = message['parameters']['round_number'] logger.info('Current round: {}'.format(self.round_number)) if self.state == STATE_READY: logger.debug('Starting first round') elif self.state == STATE_GAME: self.restart() logger.debug('Starting new round') self.state = STATE_NEW_ROUND message = {'type': 'OK'} #self._send(message) return elif mtype == 'SHUFFLE_REQUEST': logger.debug('SHUFFLE_REQUEST') deck = message['parameters']['deck'] new_deck, cipher = self.process_shuffle_response(deck) message = { 'type': 'SHUFFLE_RESPONSE', 'parameters': { 'deck': new_deck, 'encryption_key': cipher } } #self._send(message) self.state = STATE_GAME return elif mtype == 'PICK_OR_PASS_REQUEST': logger.debug('PICK_OR_PASS_REQUEST') deck = message['parameters']['deck'] new_deck = self.process_pick_or_pass_response(deck) message = { 'type': 'PICK_OR_PASS_RESPONSE', 'parameters': { 'deck': new_deck } } #self._send(message) return elif mtype == 'DISTRIBUTE_ENCRYPTION_KEYS': logger.debug('DISTRIBUTE_ENCRYPTION_KEYS') encryption_keys = message['parameters']['encryption_keys'] self.decrypt_hand(encryption_keys) message = {'type': 'OK'} #self._send(message) return elif mtype == 'PASS_CARD_REQUEST' or mtype == 'PASS_CARD_REQUEST_ERROR': logger.debug('PASS_CARD_REQUEST') pass_card = self.process_pass_card_request() if pass_card is not None: self.player.removeCard(pass_card) message = { 'type': 'PASS_CARD_RESPONSE', 'parameters': { 'card': pass_card } } #self._send(message) return elif mtype == 'DISTRIBUTE_PASSED_CARDS': logger.debug('DISTRIBUTE_PASSED_CARDS') cards = message['parameters']['cards'] for card in cards: self.player.addCard(card) message = {'type': 'OK'} #self._send(message) return elif mtype == 'BIT_COMMITMENT_REQUEST': logger.debug('BIT_COMMITMENT_REQUEST') bit_commitment = self.process_bit_commitment_request() message = { 'type': 'BIT_COMMITMENT_RESPONSE', 'parameters': { 'bit_commitment': bit_commitment } } #self._send(message) return elif mtype == 'DISTRIBUTE_BIT_COMMITMENTS': logger.debug('DISTRIBUTE_BIT_COMMITMENTS') bit_commitments = message['parameters']['all_bit_commitments'] #for name,commit in bit_commitments: #self.save_bit_commitments(name, commit) self.process_bit_commitments() return elif mtype == 'STARTER_REQUEST': logger.debug('STARTER_REQUEST') flag = self.check_starter_request() message = { 'type': 'STARTER_RESPONSE', 'parameters': { 'value': flag } } #self._send(message) return elif mtype == 'PLAY_CARD_REQUEST' or mtype == 'PLAY_CARD_REQUEST_ERROR': logger.debug('PLAY_CARD_REQUEST') play_card = self.process_play_card_request() if play_card is not None: self.player.removeCard(play_card) message = { 'type': 'PLAY_CARD_RESPONSE', 'parameters': { 'card': play_card } } #self._send(message) return elif mtype == 'TRICK_UPDATE': logger.debug('TRICK_UPDATE') trick = message['parameters']['current_trick'] self.trick_number = message['parameters']['trick_number'] winner = message['parameters']['trick_winner'] #if winner == self.sid: # self.player.trickWon(trick) logger.info(trick) message = {'type': 'OK'} #self._send(message) return elif mtype == 'COMMITMENT_REVEAL_REQUEST': logger.debug('COMMITMENT_REVEAL_REQUEST') commitment_reveal = self.process_commitment_reveal_request() message = { 'type': 'COMMITMENT_REVEAL_RESPONSE', 'parameters': { 'commitment_reveal': commitment_reveal } } #self._send(message) return elif mtype == 'DISTRIBUTE_COMMITMENT_REVEALS': logger.debug('DISTRIBUTE_COMMITMENT_REVEALS') commitment_reveals = message['parameters'][ 'all_commitment_reveals'] #for name, commit in commitment_reveals: #self.save_commitment_reveals(name, commit) self.process_commitment_reveals() return elif mtype == 'MISMATCH_VERIFICATION': logger.debug('MISMATCH_VERIFICATION') message = {'type': 'OK'} #self._send(message) return elif mtype == 'DISPLAY_SCORE': logger.debug('DISPLAY_SCORE') scores = message['parameters']['scores'] message = {'type': 'OK'} self.player.discardTricks() #self._send(message) return elif mtype == 'DISPLAY_WINNER': logger.debug('DISPLAY_WINNER') winner = message['parameters']['winner'] message = {'type': 'OK'} #self._send(message) self.state = STATE_CLOSE return elif mtype == 'OK': logger.warning("Ignoring message from server") return elif mtype == 'ERROR': logger.warning("Got error from server: {}".format( message.get('data', None))) else: logger.warning("Invalid message type") logger.debug('Closing') def process_shuffle_response(self, deck): new_deck, encryption_key = self.player.shuffle_deck(deck) return (new_deck, encryption_key) def process_pick_or_pass_response(self, deck): return self.player.pick_or_pass(deck) def decrypt_hand(self, keys_list): self.player.decrypt_hand(keys_list) def process_bit_commitment_request(self): self.player.perform_bit_commitment() return self.player.crypto.bit_commitment def save_bit_commitments(self, bit_commit_dic): for name, bit_commit in bit_commit_dic: if name != self.player.name: self.player.crypto.players_bit_commitments[name] = bit_commit def process_bit_commitments(self): names = [] for name, bit_commit in self.player.crypto.players_bit_commitments: if self.player.verify_bit_commitment_signature(bit_commit): names.append(name) logger.warning('SIGNATURE_MISMATCH: {}'.format(names)) message = { 'type': 'OK' } if len(names) == 0 else { 'type': 'SIGNATURE_MISMATCH', 'player': names } #self._send(message) def process_pass_card_request(self): return self.player.play(option='pass') def check_starter_request(self): return self.player.hand.contains2ofclubs def process_play_card_request(self, card=None): if card != None: card = self.player.play(option='play', c=card) else: card = self.player.play(option='play') self.player.removeCard(card) return card def process_commitment_reveal_request(self): return self.player.crypto.commitment_reveal def save_commitment_reveals(self, commit_reveal_dic): for name, commit_reveal in commit_reveal_dic: if name != self.player.name: self.player.crypto.other_commitments_reveal[ name] = commit_reveal def process_commitment_reveals(self): names = [] #for name, commit_reveal in self.player.crypto.other_commitments_reveal: #if self.player.verify_commitment(commit_reveal): #names.append(name) logger.warning('MISMATCH_ERROR: {}'.format(names)) message = { 'type': 'OK' } if len(names) == 0 else { 'type': 'MISMATCH_ERROR', 'parameters': { 'players': names } } #self._send(message)
def test_check_sequence_when_two_sequece(self): player = Player(0) self.assertEqual(player._check_sequence( [['A'], ['K'], ['Q'], []], [[], ['K'], ['Q'], ['10']]), 1)
def setUp(self): self.player1 = Player('Player 1', [Card(4, 1), Card(2, 1)]) self.player2 = Player('Player 2', [Card(1, 1), Card(3, 1)]) self.players = [self.player1, self.player2] self.game = MultiValCardGame(self.players)
def main(): hearts = Hearts([Player("ID1","A"), Player("ID2","B"), Player("ID3","C"), Player("ID4","D")])