Massive Work done to progress the Online portion of the game.

Author: NEUKhoaLe

Big2.py

@@ -295,33 +295,18 @@ def easy_difficulty(self, num_player):
             self.reset_drawn_stat_rect()
             self.clock.tick(self.settings.FPS)
 
+            self.game.game_status()
+
             # Watch for keyboard and mouse events.
             for event in pygame.event.get():
                 if event.type == pygame.QUIT:
                     sys.exit()
                 if event.type == pygame.MOUSEBUTTONDOWN:
                     if event.button == 1:
-                        if self.game.get_turn() == "player":
-                            mouse_x, mouse_y = pygame.mouse.get_pos()
-                            deck_selected = self.game.select(mouse_x, mouse_y)
-
-                            if deck_selected == "player":
-                                self.game.update(o=False, c=True, d=True, s=False, l=False, r=False, gu=False)
-                        elif self.game.get_turn() == "opposite":
-                            mouse_x, mouse_y = pygame.mouse.get_pos()
-                            deck_selected = self.game.select(mouse_x, mouse_y)
-                            if deck_selected == "opposite":
-                                self.game.update(p=False, c=False, d=False, s=False, l=False, r=False, gu=False)
-                        elif self.game.get_turn() == "left":
-                            mouse_x, mouse_y = pygame.mouse.get_pos()
-                            deck_selected = self.game.select(mouse_x, mouse_y)
-                            if deck_selected == "left":
-                                self.game.update(o=False, r=False, p=False, c=False, d=False, s=False, gu=False)
-                        elif self.game.get_turn() == "right":
-                            mouse_x, mouse_y = pygame.mouse.get_pos()
-                            deck_selected = self.game.select(mouse_x, mouse_y)
-                            if deck_selected == "right":
-                                self.game.update(o=False, l=False, p=False, c=False, d=False, s=False, gu=False)
+                        mouse_x, mouse_y = pygame.mouse.get_pos()
+                        deck_selected = self.game.select(mouse_x, mouse_y)
+
+                        self.game.update(c=True, d=True, s=False, l=False, r=False, gu=False)
                     if event.button == 3:
                         self.dragging = True
                 if event.type == pygame.MOUSEBUTTONUP:

Board/AbstractBoard.py

@@ -193,6 +193,9 @@ def shuffle_deck(self):
     def deal(self, last_winner):
         pass
 
+    def check_winner(self):
+        pass
+
     def move_chosen_to_current(self, pile_from):
         pass
 

Board/Board2/Board2.py

@@ -206,12 +206,10 @@ def select_deck(self, mouse_x, mouse_y):
     # and then go through every card in that deck to find the card. Move that card to the chosen
     # If a chosen card is selected, then it is "unchosen" i.e. removed from the chosen pile
     def choose_card(self, mouse_x, mouse_y, cur_player, dragging):
-        if self.select_deck(mouse_x, mouse_y) == "player" and cur_player == "player":
+        if self.select_deck(mouse_x, mouse_y) == "player":
             return self.player_deck.handle_selected(mouse_x, mouse_y, dragging)
-        elif self.select_deck(mouse_x, mouse_y) == "opposite" and cur_player == "opposite":
+        if self.select_deck(mouse_x, mouse_y) == "opposite":
             return self.opposite_deck.handle_selected(mouse_x, mouse_y, dragging)
-        else:
-            return "Not Selected " + cur_player
 
     def rotate_deck(self, order):
         if order == [2, 1]:
@@ -224,6 +222,34 @@ def move_to_discard(self):
         self.discard_deck.transfer_all_cards_to_deck(current_deck)
         self.current_deck.remove_card(current_deck)
 
+    def check_winner(self):
+        player = self.player_deck.get_deck()
+        opposite = self.opposite_deck.get_deck()
+
+        if len(player) == 0:
+            return "player"
+
+        if len(opposite) == 0:
+            return "opposite"
+
+        player_2_count = 0
+        for card in player:
+            if card.get_value() == "2":
+                player_2_count += 1
+
+        if player_2_count == 4:
+            return "player"
+
+        opposite_2_count = 0
+        for card in opposite:
+            if card.get_value() == "2":
+                opposite_2_count += 1
+
+        if opposite_2_count == 4:
+            return "opposite"
+
+        return "none"
+
     def play(self, player, turn):
         operating_deck = None
         if player == "player":
@@ -232,11 +258,10 @@ def play(self, player, turn):
             operating_deck = self.opposite_deck.get_chosen()
 
         if self.valid_move(operating_deck, player, turn):
-            pass
             # If valid move, then move old cards in current to discard
             self.move_to_discard()
             # move chosen to current
-            self.move_chosen_to_current("player")
+            self.move_chosen_to_current(player)
 
             return True
             # return "success" / true
@@ -319,30 +344,30 @@ def valid_move(self, operating_deck, player, turn):
             if self.current_deck.get_length() == 1:
                 if current_deck[0].get_value() == "2":
                     if len(operating_deck) == 1:
-                        if operating_deck[0] != "2":
+                        if operating_deck[0].get_value() != "2":
                             if self.quad_beat_two(operating_deck) or self.triple_beat_two(operating_deck) or \
                                     self.special_beat_two(operating_deck):
                                 return True
 
                             return False
                         else:
-                            if compare_suits(operating_deck[0], current_deck[0]) == "player":
+                            if compare(operating_deck[0], current_deck[0]) == "player":
                                 return True
                             else:
                                 return False
-                    elif len(operating_deck) == 2 or len(operating_deck) == 4:
-                        if operating_deck[0] != "2" or not is_same(operating_deck):
+                    elif len(operating_deck) == 4:
+                        if not is_same(operating_deck):
                             return False
                         else:
                             return True
                     elif len(operating_deck) == 3:
                         return False
                     elif len(operating_deck) % 2 == 0 and len(operating_deck) > 5:
-                        return operating_deck[0] == "2" and self.is_double_consecutive(operating_deck)
+                        return self.is_double_consecutive(operating_deck)
                     else:
                         return False
                 else:
-                    if compare_suits(operating_deck[0], current_deck[0]) == "player":
+                    if compare(operating_deck[0], current_deck[0]) == "player":
                         return True
                     else:
                         return False
@@ -352,7 +377,7 @@ def valid_move(self, operating_deck, player, turn):
                     if len(operating_deck) == 1:
                         return False
                     elif len(operating_deck) == 2:
-                        if operating_deck[0] != "2":
+                        if operating_deck[0].get_value() != "2":
                             if self.quad_beat_two(operating_deck) or self.special_beat_two(operating_deck):
                                 return True
                             else:
@@ -366,12 +391,12 @@ def valid_move(self, operating_deck, player, turn):
                             else:
                                 return False
                     elif len(operating_deck) == 4:
-                        if operating_deck[0] != "2" or not is_same(operating_deck):
+                        if operating_deck[0].get_value() != "2" or not is_same(operating_deck):
                             return False
                         else:
                             return True
                     elif len(operating_deck) % 2 == 0 and len(operating_deck) > 5:
-                        return operating_deck[0] == "2" and self.is_double_consecutive(operating_deck)
+                        return operating_deck[0].get_value() == "2" and self.is_double_consecutive(operating_deck)
                     else:
                         return False
                 else:
@@ -479,12 +504,12 @@ def special_beat_two(self, current_deck):
             return False
 
     def is_consecutive(self, operating_deck):
-        if operating_deck[0] == "2":
+        if operating_deck[-1].get_value() == "2":
             return False
 
         i = 1
         while i < len(operating_deck):
-            if int(operating_deck[i - 1].get_value()) >= int(operating_deck[i].get_value()) + 1:
+            if to_int_value(operating_deck[i - 1].get_value()) >= to_int_value(operating_deck[i].get_value()):
                 return False
 
             i += 1

Bots/EasyBot.py

@@ -1,3 +1,30 @@
+import pygame
+
+from Game.Player import Player
+from Utils.Settings import Settings
+
+
 class EasyBot:
-    def __init__(self):
-        pass
+    def __init__(self, surface, name, deck):
+        self.board = None
+        self.deck = deck
+        self.surface = surface
+        self.name = Player(self.surface, player_type=self.deck)
+        self.name.enter_name(name)
+        self.score = 0
+        self.settings = Settings()
+
+    def add_board(self, board):
+        self.board = board
+
+    def draw_name(self):
+        self.name.draw_name()
+
+    def enter_score(self, score):
+        self.name.enter_score(score)
+
+    def get_score(self):
+        return self.name.get_score()
+
+    def enter_surface(self, surface):
+        self.name.enter_surface(surface)

Cards/Cards.py

@@ -58,6 +58,10 @@ def __init__(self, display, surface, value, suit, front_image, back_image):
         # rect used to calculate the area that is blocked by the card above
         self.rect_blocked = pygame.Rect(0, 0, 0, 0)
 
+    def scale(self, x , y):
+        self.front_image = pygame.transform.scale(self.front_image, (x, y))
+        self.back_image = pygame.transform.scale(self.back_image, (x, y))
+
     # Move the card to a different location
     # If we are moving the card to the shuffle position, we will make it appear
     # instantly. If shuffle is true, then we are moving it to the shuffle

Cards/Deck/Current/CurrentDeck.py

@@ -20,7 +20,7 @@ def __init__(self, x, y, width, display, surface):
         self.full_card = pygame.Surface((self.card_width, self.card_height))
         self.full_card.fill(self.settings.bg_color)
 
-        self.background = pygame.Surface((self.width, self.card_height))
+        self.background = pygame.Surface((self.width + 20, self.card_height))
         self.background.fill(self.settings.bg_color)
 
     def change_pos(self, x, y):

Cards/Deck/Discard/DiscardDeck.py

@@ -10,6 +10,8 @@ def __init__(self, x, y, display, surface):
 
         self.x = x
         self.y = y
+        self.discard_x_size = 60
+        self.discard_y_size = 100
         self.settings = Settings()
 
     def change_pos(self, x, y):
@@ -19,7 +21,8 @@ def change_pos(self, x, y):
     def draw_deck(self, move_from_shuffle=False, game_update=False, draw=True):
         if len(self.deck) != 0:
             for x in self.deck:
-                x.move(self.x, self.y, False)
+                x.scale(self.discard_x_size, self.discard_y_size)
+                x.move(self.x, self.y, True)
                 x.update_vis(False)
 
             card = self.deck[len(self.deck) - 1]

Cards/Deck/PlayDeck/Opposite/OppositeDeck.py

@@ -126,7 +126,7 @@ def handle_selected(self, mouse_x, mouse_y, dragging):
                     self.mouse_y_offset = card_y - mouse_y
 
                     cx, cy = card.cur_pos()
-                    self.surface.blit(self.full_card, (cx + 2, cy))
+                    self.surface.blit(self.full_card, (cx, cy))
 
                     self.draw_previous(i)
                     self.draw_rest_deck(self.deck[max(i - 1, 0)], for_drag=True)

Cards/Deck/PlayDeck/TopBottomDeck.py

@@ -29,8 +29,11 @@ def to_int_value(value):
         return 12
     if value == "K":
         return 13
-    else:
+    elif value == "A":
         return 14
+    else:
+        # Represents 2
+        return 15
 
 
 def compare_suits(player, current):

Cards/Deck/Shuffle/ShuffleDeck.py

@@ -1,3 +1,5 @@
+import random
+
 import pygame
 
 from Cards.Deck.AbstractDeck import AbstractDeck
@@ -42,7 +44,7 @@ def update(self, game_update):
             pygame.display.flip()
 
     def shuffle(self):
-        pass
+        random.shuffle(self.deck)
 
     def card_change_in_play(self, index, boolean):
         self.deck[index].change_in_play(boolean)

Game/Player.py

@@ -38,3 +38,6 @@ def draw_name(self):
             pass
         elif self.player_type == "right":
             pass
+
+    def enter_surface(self, surface):
+        self.surface = surface