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")])
