Card Game Trump

constants.py

SPADES = "SPADES"
DIAMONDS = "DIAMONDS"
HEARTS = "HEARTS"
CLUBS = "CLUBS"

CARD_SUITES_SET = [SPADES,DIAMONDS,HEARTS,CLUBS]

CARD_FACES_MAP = {
    14:"ACE",
    13:"KING",
    12: "QUEEN",
    11:"JACK",
    10: "10",
    9:"9",
    7:"7",
    6: "6",
    5: "5",
    4:"4",
    3: "3",
    2: "2"
}

core.py

import random
from domain.constants import *
from heapq import *
from collections import OrderedDict
TOTAL_CARD_COUNT = 52

class Card:
    def __init__(self,suite,face):
        self.suite = suite
        self.face = face

    def get_suite(self):
        return self.suite

    def get_face(self):
        return self.face

    def __lt__(self,card):
        if card is None:
            raise ValueError

        if self.face < card.get_face():
            return True
        else:
            return False

    def __str__(self):
       return "{}:{}".format(self.suite,self.face)

    def __repr__(self):
        return self.__str__()

class Deck:
    def __init__(self):
        self.deck_cards = []
        for suite_val in CARD_SUITES_SET:
            for face_val in CARD_FACES_MAP:
                card = Card(suite=suite_val, face=face_val)
                self.deck_cards.append(card)
    def shuffle(self):
        random.shuffle(self.deck_cards)

    def get_card(self):
        if not self.deck_cards:
            return None
        else:
            current_card = self.deck_cards[0]
            self.deck_cards = self.deck_cards[1:]
            return current_card

class Player:
    def __init__(self,name):
        self.name = name
        self.cards_map = {
            SPADES:[],
            CLUBS:[],
            HEARTS:[],
            DIAMONDS:[]
        }

    def set_card_in_hand(self,card):
        if card is not None:
            #self.cards_map[card.face] = heappush(self.cards_map[card.face],card)
            self.cards_map[card.suite].append(card)

    def __str__(self):
        str_val = "Player Name: {}\n".format(self.name)
        for suite,cards in self.cards_map.items():
            str_val += str("{} {}\n".format(suite,cards))

        return str_val

    def print_cards(self):
        str_val = ""
        for suite,cards in self.cards_map.items():
            str_val += str("{} {}\n".format(suite,cards))

        return str_val

    def max_value_card_in_suite(self,input_suite):
        cards_in_suite = self.cards_map[input_suite]
        if not cards_in_suite:
            return None

        sorted_cards = sorted(cards_in_suite,key=lambda x:x.get_face())
        return sorted_cards[-1]


    def min_value_in_suite(self,input_suite):
        cards_in_suite = self.cards_map[input_suite]
        if not cards_in_suite:
            return None

        sorted_cards = sorted(cards_in_suite, key=lambda x: x.get_face())
        return sorted_cards[0]


    def trump_card_played(self,current_cards_played,trump_suite):
        current_cards_played_suites = [c.get_suite() for c in current_cards_played]
        if trump_suite in current_cards_played_suites:
            return True
        else:
            return False

    def remove_card(self,card_obj):
        if card_obj in self.cards_map[card_obj.suite]:
            self.cards_map[card_obj.suite].remove(card_obj)

    def get_smallest_other_card(self,trump_suite):
        other_suites = [suite for suite in CARD_SUITES_SET if suite!=trump_suite]
        min_card = None
        for s in other_suites:
            curr_card = self.min_value_in_suite(s)
            if not min_card:
                min_card = curr_card
            else:
                if min_card.get_face() > curr_card.get_face():
                    min_card = curr_card

        if min_card:
            return min_card

        smallest_card = self.min_value_in_suite(trump_suite)

        return smallest_card


    def get_largest_card(self):
        largest_card = None
        for suite in self.cards_map:
            for card in self.cards_map[suite]:
                if not largest_card:
                    largest_card = card
                else:
                    if card.get_face() > largest_card.get_face():
                        largest_card = card

        return largest_card

    def play_card(self,current_cards_played,trump_suite):
        if current_cards_played:
            first_suite = current_cards_played[0].get_suite()

            max_value_current_played_suite = sorted(current_cards_played,key=lambda x:x.get_face())[-1]
            if self.cards_map[first_suite]:
                max_value_in_player_suite = self.max_value_card_in_suite(first_suite)
                if max_value_current_played_suite > max_value_in_player_suite:
                    min_value_card = self.min_value_in_suite(first_suite)
                    self.remove_card(min_value_card)
                    return min_value_card

            elif self.trump_card_played(current_cards_played,trump_suite):
                if self.cards_map[trump_suite]:
                    max_value_trump_in_player_suite = self.max_value_card_in_suite(trump_suite)
                    trump_played_cards = [c for c in current_cards_played if c.get_suite() == trump_suite]
                    max_value_current_played_suite = sorted(trump_played_cards, lambda x: x.get_face() )[-1]
                    if max_value_current_played_suite > max_value_trump_in_player_suite:
                        max_value_card = self.max_value_in_suite(trump_suite)
                        self.remove_card(max_value_card)
                        return max_value_card

            curr_card = self.get_smallest_other_card(trump_suite)
            self.remove_card(curr_card)
            return curr_card

        else:
            largest_card = self.get_largest_card()
            self.remove_card(largest_card)

            return largest_card

game.py

from domain.core import *

class Game:
    def __init__(self, num_players):

        if num_players < 2:
            raise ValueError("Please enter atleast 2 players")

        self.deck = Deck()
        self.deck.shuffle()
        self.player_map = OrderedDict()
        self.player_score_map = dict()
        self.num_players = num_players

        for i in range(num_players):
            self.player_map[i] = Player(str(i))
            self.player_score_map[i] = 0

        for i in range(TOTAL_CARD_COUNT):
            self.player_map[i%num_players].set_card_in_hand(self.deck.get_card())

        self.current_player_index = random.randint(0,num_players -1 )
        self.current_player = self.player_map[self.current_player_index]

    def print_player_map(self):
        for i in self.player_map:
            print(self.player_map[i].print_cards())


    def get_next_player(self):
        next_player_index = (self.current_player_index + 1) % self.num_players
        next_player = self.player_map[next_player_index]
        self.current_player_index = next_player_index
        return next_player


    def play(self):
        current_cards_played = []
        trump_suite = SPADES
        for i in range(52):
            if i % self.num_players == 0:
                current_cards_played = []
            player = self.get_next_player()
            current_card = player.play_card(current_cards_played,trump_suite)
            current_cards_played.append(current_card)

            
if __name__ == '__main__':
    game = Game(4)
    game.print_player_map()
    game.play()