Initial commit

2020-03-26 16:37:01 +01:00
commit 38bf52c867
3 changed files with 481 additions and 0 deletions
@@ -0,0 +1,255 @@
+from enum import Enum
+from random import shuffle
+
+class BridzikException(Exception):
+    pass
+
+class RuleException(Exception):
+    pass
+
+class Card_colors(Enum):
+    HEARTS = 'červeň'
+    LEAVES = 'zeleň'
+    ACORNS = 'žaluď'
+    BELLS = 'guľa'
+
+    def __eq__(self, other):
+        if self.__class__ is other.__class__:
+            return self.name == other.name
+        return NotImplemented
+
+
+class Card_values(Enum):
+    C7 = 1
+    C8 = 2
+    C9 = 3
+    C10 = 4
+    LOWER = 5
+    UPPER = 6
+    KING = 7
+    ACE = 8
+    
+    def __ge__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value >= other.value
+        return NotImplemented
+    def __gt__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value > other.value
+        return NotImplemented
+    def __le__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value <= other.value
+        return NotImplemented
+    def __lt__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value < other.value
+        return NotImplemented
+    def __eq__(self, other):
+        if self.__class__ is other.__class__:
+            return self.name == other.name
+        return NotImplemented
+
+
+class Card():
+    def __init__(self, color: Card_colors, value: Card_values):
+        self.color = color
+        self.value = value
+
+    def __eq__(self, other):
+        if self.__class__ is other.__class__:
+            return self.color == other.color \
+                and self.value == other.value
+        return NotImplemented
+
+    def __str__(self):
+        return '{}_{}'.format(self.color.name, self.value.name)
+
+cards = [Card(color, value) for value in Card_values for color in Card_colors]
+
+# for series_number in range(4): # 4 hry
+    
+#     for round_number in range(8): # v kazdej hre 8 serii
+#         for player_number in range(4):
+#             rozdaj_karty_na_kolo(series_number, player_number)
+
+#         for player_number in range(4):
+#             vezmi_tip(series_number, player_number)
+#             over_ci_je_mozny
+#             pridaj_tip_do_zoznamu_tipov
+        
+#         for game_number in range(series_number+1): # v kazdej serii 
+    
+#             for turn_number in range(4):
+#                 kopka.pridaj_kartu(hrac, karta)
+#             vyherca = kopka.vyhodnot_kopku
+#             hraci[vyherca].pridaj_ziskanu_kopku()
+
+class Bridzik():
+    # self.series = []
+    pass
+
+class Series():
+    # self.rounds = []
+    pass
+
+class Round():
+    def __init__(self, round_number: int, first_player: int, cards: [], shuffler = shuffle): 
+        # vyrob kopku pre toto kolo a priprav prazdne objekty
+        if not 0 <= round_number < 8:
+            raise BridzikException('Round number has to be between 0 and 7.')
+        self.round_number = round_number
+        self.first_player = first_player
+        self.deal_starting_cards(cards, shuffler)
+        self.guesses = {}
+        self.stashes = []
+
+    def add_player_guess(self, player: int, guess: int):
+        if player not in [0, 1, 2, 3]:
+            raise BridzikException('Cislo hraca musi byt 0, 1, 2 alebo 3.')
+        if player in self.guesses:
+            raise BridzikException('Pre tohto hraca uz bol zadany tip.')
+        if player != self.get_active_player():
+            raise BridzikException('Nie je mozne pridat tip mimo poradia.')
+        if len(self.guesses) < 3:
+            self.guesses[player] = guess
+        elif 8 - self.round_number != guess + sum([self.guesses[player] for player in self.guesses]):
+            self.guesses[player] = guess
+            self.start_new_stash()
+        else:
+            raise BridzikException('Nie je mozne zadat tip. Sucet sa rovna poctu kopok v hre.')
+
+    def play_card(self, player, card: Card):
+        if self.is_completed():
+            raise BridzikException('Kolo je ukoncene.')
+        if not self.is_guessing_completed():
+            raise BridzikException('Tipovanie nie je ukoncene.')
+        if self.get_last_stash().get_active_player() != player:
+            raise BridzikException('Hrac nie je na tahu.')
+        if card not in self.player_cards[player]:
+            raise BridzikException('Hrac nema tuto kartu na ruke.')
+        if self.get_last_stash().get_first_card():
+            if [c for c in self.player_cards[player] if c.color == \
+                            self.get_last_stash().get_first_card().color] == []: # nema farbu
+                if [c for c in self.player_cards[player] if c.color == \
+                                                Card_colors['HEARTS']] == []: # nema cerven
+                    pass
+                elif card.color != Card_colors['HEARTS']: # ma cerven ale nezahral
+                    raise BridzikException('Musi zahrat cerven, ktory ma.')
+            elif card.color != self.get_last_stash().get_first_card().color: # ma farbu ale nezahral
+                raise BridzikException('Musi zahrat farbu.')            
+
+        self.player_cards[player] = [c for c in self.player_cards[player] if c != card]
+        self.get_last_stash().add_card(card, player)
+        if self.get_last_stash().is_completed() and not self.is_completed():
+            self.start_new_stash()
+
+    def get_highest_guessing_player(self) -> int:
+        if not self.is_guessing_completed():
+            raise BridzikException('Tipovanie nebolo skoncene.')
+        round_highest_guessing_player = self.first_player
+        for i in range(1, 4):
+            if self.guesses[round_highest_guessing_player] < self.guesses[(i+self.first_player) % 4]:
+                round_highest_guessing_player = (i+self.first_player) % 4
+        return round_highest_guessing_player
+
+    def get_active_player(self):
+        if not self.is_completed():
+            if not self.is_guessing_completed():
+                return (self.first_player + len(self.guesses)) % 4
+            return self.get_last_stash().get_active_player()
+        raise BridzikException('Kolo je uzavrete')
+
+    def is_completed(self):
+        """Round completion status"""
+        return len(self.stashes) == 8 - self.round_number \
+                and self.get_last_stash().is_completed()
+    
+    def is_guessing_completed(self):
+        return len(self.guesses) == 4
+
+    def get_last_stash(self):
+        return self.stashes[-1] if len(self.stashes) > 0 else None
+
+    def deal_starting_cards(self, cards: [], shuffler = shuffle):
+        self.round_cards = cards.copy()
+        shuffler(self.round_cards)
+        self.round_cards = self.round_cards[(4*self.round_number):]
+        self.player_cards = {}
+        for player_number in range(4):
+            self.player_cards[player_number] = self.round_cards[
+                player_number * (8-self.round_number) : 
+                (player_number + 1) * (8-self.round_number)
+                ]
+        self.player_starting_cards = self.player_cards.copy()
+
+    def start_new_stash(self):
+        if self.is_completed():
+            raise BridzikException('Kolo je ukoncene.')
+        if len(self.stashes) == 0:
+            self.stashes.append(Stash(self.get_highest_guessing_player()))
+        elif not self.get_last_stash().is_completed():
+            raise BridzikException('Predchadzajuca kopka nie je ukoncena.')
+        else:
+            self.stashes.append(Stash(self.get_last_stash().get_winner()))
+
+
+class Stash():
+    def __init__(self, first_player: int):
+        if first_player not in [0, 1, 2, 3]:
+            raise BridzikException('Cislo hraca musi byt 0, 1, 2 alebo 3.')
+        self._cards = {}
+        self.first_player = first_player
+    
+    def add_card(self, card: Card, player: int):
+        if player not in [0, 1, 2, 3]:
+            raise BridzikException('Cislo hraca musi byt 0, 1, 2 alebo 3.')
+        if player in self._cards:
+            raise BridzikException('Pre tohto hraca uz bola pridana karta')
+        self._cards[player] = card
+
+    def get_first_card(self) -> Card:
+        """Return copy of first card in stash"""
+        return Card(
+            self._cards[self.first_player].color,
+            self._cards[self.first_player].value
+        ) if len(self._cards) > 0 else None
+
+    def get_winner(self) -> int:
+        if not self.is_completed():
+            raise BridzikException('Nie je mozne urcit vitaza, kopka nie je dohrana.')
+        winner = None
+        winning_card = self.get_first_card()
+        for player_number in range(4):
+            if self._cards[player_number].color == self.get_first_card().color \
+                    or self._cards[player_number].color == Card_colors['HEARTS']:
+                if self._cards[player_number].color == winning_card.color \
+                        and self._cards[player_number].value >= winning_card.value:
+                    winning_card = self._cards[player_number]
+                    winner = player_number
+                elif self._cards[player_number].color == Card_colors['HEARTS']:
+                    winning_card = self._cards[player_number]
+                    winner = player_number
+        return winner
+
+    def get_active_player(self) -> int:
+        if not self.is_completed():
+            return (self.first_player + len(self._cards)) % 4
+        else:
+            raise BridzikException('Kopka je ukoncena.')
+
+    def get_cards(self) -> {}:
+        return self._cards.copy()
+
+    def is_completed(self) -> bool:
+        return len(self._cards) == 4
+
+        
+        
+        # pozbieraj tipy
+        # urci prveho
+        # zahraj n kopok:
+        #     pozbieraj karty do kopky
+        #     vyhodnot kopku
+        #     pridaj tuto kopku vitazovy
+        # vyhodnot toto kolo podla tipov a ziskanych kopok