Solitaire update (#141)

* fixed issue with card not added to the controls list

* fixed issue with card update

* fixed card update in solitaire-game-rules

* game-rules example fixed

* click method for card

* fixed card update in final part

Author: InesaFitsner

python/tutorials/solitaire/solitaire-fanned-piles/card.py

@@ -5,87 +5,90 @@
 
 import flet as ft
 
+
 class Card(ft.GestureDetector):
     def __init__(self, solitaire, color):
         super().__init__()
-        self.mouse_cursor=ft.MouseCursor.MOVE
-        self.drag_interval=5
-        self.on_pan_start=self.start_drag
-        self.on_pan_update=self.drag
-        self.on_pan_end=self.drop
-        self.left=None
-        self.top=None
+        self.mouse_cursor = ft.MouseCursor.MOVE
+        self.drag_interval = 5
+        self.on_pan_start = self.start_drag
+        self.on_pan_update = self.drag
+        self.on_pan_end = self.drop
+        self.left = None
+        self.top = None
         self.solitaire = solitaire
         self.slot = None
         self.card_offset = CARD_OFFSET
         self.color = color
-        self.content=ft.Container(bgcolor=self.color, width=CARD_WIDTH, height=CARD_HEIGTH)
+        self.content = ft.Container(
+            bgcolor=self.color, width=CARD_WIDTH, height=CARD_HEIGTH
+        )
+        self.draggable_pile = [self]
 
     def move_on_top(self):
         """Brings draggable card pile to the top of the stack"""
 
-        for card in self.get_draggable_pile():
+        # for card in self.get_draggable_pile():
+        for card in self.draggable_pile:
             self.solitaire.controls.remove(card)
             self.solitaire.controls.append(card)
         self.solitaire.update()
 
     def bounce_back(self):
         """Returns draggable pile to its original position"""
-        draggable_pile = self.get_draggable_pile()
-        for card in draggable_pile:
+        for card in self.draggable_pile:
             card.top = card.slot.top + card.slot.pile.index(card) * CARD_OFFSET
             card.left = card.slot.left
         self.solitaire.update()
 
     def place(self, slot):
         """Place draggable pile to the slot"""
-        
-        draggable_pile = self.get_draggable_pile()
-
-        for card in draggable_pile:
+        for card in self.draggable_pile:
             card.top = slot.top + len(slot.pile) * CARD_OFFSET
             card.left = slot.left
 
-            # remove card from it's original slot, if exists
+            # remove card from it's original slot, if it exists
             if card.slot is not None:
                 card.slot.pile.remove(card)
-        
+
             # change card's slot to a new slot
             card.slot = slot
 
             # add card to the new slot's pile
             slot.pile.append(card)
-        
+
         self.solitaire.update()
 
     def get_draggable_pile(self):
         """returns list of cards that will be dragged together, starting with the current card"""
         if self.slot is not None:
-            return self.slot.pile[self.slot.pile.index(self):]
-        return [self]
+            self.draggable_pile = self.slot.pile[self.slot.pile.index(self) :]
+        else:  # slot == None when the cards are dealed and need to be place in slot for the first time
+            self.draggable_pile = [self]
 
     def start_drag(self, e: ft.DragStartEvent):
+        self.get_draggable_pile()
         self.move_on_top()
-        self.update()
+        self.solitaire.update()
 
-    
     def drag(self, e: ft.DragUpdateEvent):
-        draggable_pile = self.get_draggable_pile()
-        for card in draggable_pile:
-            card.top = max(0, self.top + e.delta_y) + draggable_pile.index(card) * CARD_OFFSET
+        for card in self.draggable_pile:
+            card.top = (
+                max(0, self.top + e.delta_y)
+                + self.draggable_pile.index(card) * CARD_OFFSET
+            )
             card.left = max(0, self.left + e.delta_x)
-            card.update()
-
+            self.solitaire.update()
 
     def drop(self, e: ft.DragEndEvent):
         for slot in self.solitaire.slots:
             if (
-                abs(self.top - (slot.top + len(slot.pile) * CARD_OFFSET))< DROP_PROXIMITY
-            and abs(self.left - slot.left) < DROP_PROXIMITY
-          ):
+                abs(self.top - (slot.top + len(slot.pile) * CARD_OFFSET))
+                < DROP_PROXIMITY
+                and abs(self.left - slot.left) < DROP_PROXIMITY
+            ):
                 self.place(slot)
-                self.update()
+                self.solitaire.update()
                 return
-           
+
         self.bounce_back()
-        self.update()

python/tutorials/solitaire/solitaire-fanned-piles/solitaire.py

@@ -1,19 +1,20 @@
-#CARD_OFFSET = 20
+# CARD_OFFSET = 20
 SOLITAIRE_WIDTH = 1000
 SOLITAIRE_HEIGHT = 500
 
 import flet as ft
-from slot import Slot
 from card import Card
+from slot import Slot
+
 
 class Solitaire(ft.Stack):
     def __init__(self):
         super().__init__()
-        #self.start_top = 0
-        #self.start_left = 0
+        # self.start_top = 0
+        # self.start_left = 0
         self.controls = []
         self.slots = []
-        #self.card_offset = CARD_OFFSET
+        # self.card_offset = CARD_OFFSET
         self.width = SOLITAIRE_WIDTH
         self.height = SOLITAIRE_HEIGHT
 
@@ -26,7 +27,8 @@ def create_card_deck(self):
         card1 = Card(self, color="GREEN")
         card2 = Card(self, color="YELLOW")
         card3 = Card(self, color="RED")
-        self.cards = [card1, card2, card3]
+        card4 = Card(self, color="BLUE")
+        self.cards = [card1, card2, card3, card4]
 
     def create_slots(self):
         self.slots.append(Slot(top=0, left=0))
@@ -37,6 +39,7 @@ def create_slots(self):
 
     def deal_cards(self):
         self.controls.extend(self.cards)
+
         for card in self.cards:
             card.place(self.slots[0])
-        self.update()
+        self.update()

python/tutorials/solitaire/solitaire-final-part1/card.py

@@ -29,31 +29,31 @@ def __init__(self, solitaire, suite, rank):
             border_radius=ft.border_radius.all(6),
             content=ft.Image(src="/images/card_back.png"),
         )
+        self.draggable_pile = [self]
 
     def turn_face_up(self):
         """Reveals card"""
         self.face_up = True
         self.content.content.src = f"/images/{self.rank.name}_{self.suite.name}.svg"
-        self.update()
+        self.solitaire.update()
 
     def turn_face_down(self):
         """Hides card"""
         self.face_up = False
         self.content.content.src = "/images/card_back.png"
-        self.update()
+        self.solitaire.update()
 
     def move_on_top(self):
         """Brings draggable card pile to the top of the stack"""
 
-        for card in self.get_draggable_pile():
+        for card in self.draggable_pile:
             self.solitaire.controls.remove(card)
             self.solitaire.controls.append(card)
         self.solitaire.update()
 
     def bounce_back(self):
         """Returns draggable pile to its original position"""
-        draggable_pile = self.get_draggable_pile()
-        for card in draggable_pile:
+        for card in self.draggable_pile:
             if card.slot in self.solitaire.tableau:
                 card.top = card.slot.top + card.slot.pile.index(card) * CARD_OFFSET
             else:
@@ -64,9 +64,7 @@ def bounce_back(self):
     def place(self, slot):
         """Place draggable pile to the slot"""
 
-        draggable_pile = self.get_draggable_pile()
-
-        for card in draggable_pile:
+        for card in self.draggable_pile:
             if slot in self.solitaire.tableau:
                 card.top = slot.top + len(slot.pile) * CARD_OFFSET
             else:
@@ -90,29 +88,30 @@ def place(self, slot):
 
     def get_draggable_pile(self):
         """returns list of cards that will be dragged together, starting with the current card"""
+
         if (
             self.slot is not None
             and self.slot != self.solitaire.stock
             and self.slot != self.solitaire.waste
         ):
-            return self.slot.pile[self.slot.pile.index(self) :]
-        return [self]
+            self.draggable_pile = self.slot.pile[self.slot.pile.index(self) :]
+        else:  # slot == None when the cards are dealed and need to be place in slot for the first time
+            self.draggable_pile = [self]
 
     def start_drag(self, e: ft.DragStartEvent):
         if self.face_up:
+            self.get_draggable_pile()
             self.move_on_top()
-            self.update()
 
     def drag(self, e: ft.DragUpdateEvent):
         if self.face_up:
-            draggable_pile = self.get_draggable_pile()
-            for card in draggable_pile:
+            for card in self.draggable_pile:
                 card.top = (
                     max(0, self.top + e.delta_y)
-                    + draggable_pile.index(card) * CARD_OFFSET
+                    + self.draggable_pile.index(card) * CARD_OFFSET
                 )
                 card.left = max(0, self.left + e.delta_x)
-                card.update()
+                self.solitaire.update()
 
     def drop(self, e: ft.DragEndEvent):
         if self.face_up:
@@ -123,38 +122,35 @@ def drop(self, e: ft.DragEndEvent):
                     and abs(self.left - slot.left) < DROP_PROXIMITY
                 ) and self.solitaire.check_tableau_rules(self, slot):
                     self.place(slot)
-                    self.update()
                     return
 
-            if len(self.get_draggable_pile()) == 1:
+            if len(self.draggable_pile) == 1:
                 for slot in self.solitaire.foundations:
                     if (
                         abs(self.top - slot.top) < DROP_PROXIMITY
                         and abs(self.left - slot.left) < DROP_PROXIMITY
                     ) and self.solitaire.check_foundations_rules(self, slot):
                         self.place(slot)
-                        self.update()
                         return
 
             self.bounce_back()
-            self.update()
 
     def click(self, e):
+
+        self.get_draggable_pile()
         if self.slot in self.solitaire.tableau:
-            if not self.face_up and self == self.slot.get_top_card():
+            if not self.face_up and len(self.draggable_pile) == 1:
                 self.turn_face_up()
-                self.update()
         elif self.slot == self.solitaire.stock:
             self.move_on_top()
             self.place(self.solitaire.waste)
             self.turn_face_up()
-            self.solitaire.update()
 
     def doubleclick(self, e):
-        if self.face_up:
+        self.get_draggable_pile()
+        if self.face_up and len(self.draggable_pile) == 1:
             self.move_on_top()
             for slot in self.solitaire.foundations:
                 if self.solitaire.check_foundations_rules(self, slot):
                     self.place(slot)
-                    self.page.update()
                     return