semi-final update: desing + win logic

domino.py

@@ -5,11 +5,9 @@ import settings as s
 from screens import Empty_domino
 
 pygame.font.init()
-my_font = pygame.font.SysFont('Calibri (Body)', 50)
+my_font = pygame.font.SysFont('Calibri (Body)', 37)
 
 
-# Define a Player object by extending pygame.sprite.Sprite
-# The surface drawn on the screen is now an attribute of 'player'
 class Domino(pygame.sprite.Sprite):
     def __init__(self, x, y, values, index):
         super().__init__()
@@ -33,6 +31,7 @@ class Domino(pygame.sprite.Sprite):
 
         movement = self.w + 10
         i = 0
+        # передвигаем домино влево, если есть пустые места
         for domino in dominos:
             if i == 0:
 
@@ -45,16 +44,20 @@ class Domino(pygame.sprite.Sprite):
 
             i += 1
 
-
+        # блит домино с текстом
         screen.blit(self.surf, self.rect)
 
-        v_up = my_font.render(f"{self.values[0]}", True, (255, 255, 255))
+        v_up = my_font.render(f"{self.values[0][1]}", True, (255, 255, 255))
-        v_down = my_font.render(f"{self.values[1]}", True, (255, 255, 255))
+        v_down = my_font.render(f"{self.values[1][1]}", True, (255, 255, 255))
+        # screen.blit(v_up,
+        #             (self.rect.x + (self.w / 2), self.rect.y + (self.h / 4)))
+
         screen.blit(v_up,
-                    (self.rect.x + (self.w / 2) - v_up.get_width(), self.rect.y + (self.h / 4) - v_up.get_height()))
+                    (self.rect.x + (self.w / 2) - v_up.get_width()/2, self.rect.y + (self.h / 4) - v_up.get_height()/2))
+
         # print(self.rect.x + (self.w / 2) - v_up.get_width(), self.rect.y + (self.h / 4) - v_up.get_height())
         screen.blit(v_down, (
-            self.rect.x + (self.w / 2) - v_down.get_width(), self.rect.y + (self.h / 4) * 3 - v_down.get_height()))
+            self.rect.x + (self.w / 2) - v_down.get_width()/2, self.rect.y + (self.h / 4) * 3 - v_down.get_height()/2))
         # screen.blit(v_up,
         #             (310, 16))
 
@@ -66,6 +69,7 @@ class Domino(pygame.sprite.Sprite):
             self.surf.fill(self.color)
 
     def update_rotation(self, mouse_x, mouse_y, r_click_time):
+        # если клинкули правым кликом - переворачиваем домино
         if self.rect.x <= mouse_x <= self.rect.x + self.w and self.rect.y <= mouse_y <= self.rect.y + self.h:
             # pygame.transform.rotate(self.surf, 90)
             self.values = self.values[::-1]
@@ -77,6 +81,7 @@ class Domino(pygame.sprite.Sprite):
         # check if mouse colide with domino
         if self.rect.x <= mouse_new_x <= self.rect.x + self.w and self.rect.y <= mouse_new_y <= self.rect.y + self.h:
 
+            # передвижение вместе с мышью
             self.rect.x -= mouse_x
             self.rect.y -= mouse_y
 
@@ -87,6 +92,7 @@ class Domino(pygame.sprite.Sprite):
 
 
         elif self.type_pos == "hand":
+            # проверяем, не находится ли домино за пределами руки (выложили ли домино на стол по правилам?)
             self.update_type_pos(hand, group_hand, game, dominos)
             # if self.type_pos == "hand":
             #     self.rect.x = self.start_pos[0]
@@ -96,24 +102,26 @@ class Domino(pygame.sprite.Sprite):
     def update_type_pos(self, hand, group_hand, game, dominos):
         if self.type_pos == "hand":
 
+            # если домино за пределами руки
             if not hand.rect.colliderect(self.rect):
                 move = False
-                for empty in game.empty_group:
 
+                # проверяем колизию с пустышками (красными), чтобы на их место поставить домино
+                for empty in game.empty_group:
+                    # ставим
                     if empty.rect.colliderect(self.rect):
                         if empty.pos == "up":
-                            if not game.value_up or game.value_up == self.values[1]:
+                            if not game.value_up or game.value_up == self.values[1][0]:
                                 move = True
 
                         elif empty.pos == "down":
-                            if not game.value_down or game.value_down == self.values[0]:
+                            if not game.value_down or game.value_down == self.values[0][0]:
                                 move = True
 
                         elif empty.pos == "both":
                             move = True
 
-
+                        # ставим домино на место пустышки, и добавляем в группу объектов игрового стола
-
                         if move:
                             self.surf.fill(self.color)
                             self.type_pos == "game"
@@ -125,20 +133,22 @@ class Domino(pygame.sprite.Sprite):
                             self.rect.y = empty.rect.y
 
                             if empty.pos == "up":
-                                game.value_up = self.values[0]
+                                game.value_up = self.values[0][0]
                                 game.empty_up.rect.y -= game.empty_up.h + 10
                             elif empty.pos == "down":
-                                game.value_down = self.values[1]
+                                game.value_down = self.values[1][0]
                                 game.empty_down.rect.y += game.empty_down.h + 10
                             elif empty.pos == "both":
-                                game.value_up = self.values[0]
+                                game.value_up = self.values[0][0]
-                                game.value_down = self.values[1]
+                                game.value_down = self.values[1][0]
 
-                                game.empty_up = Empty_domino(empty.rect.x, empty.rect.y - (s.DOMINO_W * 1.1 * 2 + 10), "up")
+                                game.empty_up = Empty_domino(empty.rect.x, empty.rect.y - (s.DOMINO_W * 1.1 * 2 + 10),
+                                                             "up")
                                 game.group.add(game.empty_up)
                                 game.empty_group.add(game.empty_up)
 
-                                game.empty_down = Empty_domino(empty.rect.x, empty.rect.y + (s.DOMINO_W * 1.1 * 2 + 10), "down")
+                                game.empty_down = Empty_domino(empty.rect.x, empty.rect.y + (s.DOMINO_W * 1.1 * 2 + 10),
+                                                               "down")
                                 game.group.add(game.empty_down)
                                 game.empty_group.add(game.empty_down)
 
@@ -146,6 +156,7 @@ class Domino(pygame.sprite.Sprite):
 
 
 
+            # если домино не за пределами руки - возвращаем её на место
             else:
                 self.rect.x = self.start_pos[0]
                 self.rect.y = self.start_pos[1]

main.py

@@ -14,6 +14,8 @@ from pygame.locals import (
 )
 
 pygame.init()
+
+#  инициализируем настроки экрана и домино
 SCREEN_WIDTH = s.SCREEN_WIDTH
 SCREEN_HEIGHT = s.SCREEN_HEIGHT
 DOMINO_W = s.DOMINO_W
@@ -21,28 +23,28 @@ DOMINO_H = s.DOMINO_H
 # screen = pygame.display.set_mode((0,0),pygame.FULLSCREEN)
 screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
 
-all_sprites = pygame.sprite.Group()
+# создаем группы руки и игры
+
 dominos = pygame.sprite.Group()
 group_hand_screen = pygame.sprite.Group()
 group_game_screen = pygame.sprite.Group()
 
 game_screen = Game_screen()
-all_sprites.add(game_screen)
+
 group_game_screen.add(game_screen)
 
 hand_screen = Hand_screen()
 group_hand_screen.add(hand_screen)
-all_sprites.add(hand_screen)
+
 
 get_button = Button()
 group_hand_screen.add(get_button)
-all_sprites.add(get_button)
+
 
 x = 100
 y = SCREEN_HEIGHT - DOMINO_H / 2 - 25
 
-# print(len(all_sprites))
+# стартовая рука
-
 for i in range(6):
     values = choice(s.DOMINOS)
     domino = Domino(x, y, values, i)
@@ -51,7 +53,7 @@ for i in range(6):
 
     dominos.add(domino)
     group_hand_screen.add(domino)
-    all_sprites.add(domino)
+
 
 pygame.display.flip()
 run = True
@@ -61,6 +63,7 @@ mouse_down = False
 mouse_old_pos = [pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1]]
 r_click_cd = 0.2
 r_click_time = 0
+
 while run:
 
     for event in pygame.event.get():
@@ -87,22 +90,28 @@ while run:
     if mouse_down:
         move = False
 
+        # получаем координаты мыши, и её parvietojums
         mouse_new_pos = pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1]
         mouse_move = [mouse_old_pos[0] - mouse_new_pos[0], mouse_old_pos[1] - mouse_new_pos[1]]
 
         for domino in group_hand_screen:
             if domino.type == "domino":
+                # если мы навели на домино: меняем её цвет
                 domino.update_color(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1])
 
+                # передвигаем домино, если кликнули и зажали
                 if mouse_down == "left":
                     move = domino.update_pos(move, mouse_move[0], mouse_move[1], mouse_new_pos[0], mouse_new_pos[1],
                                              hand_screen, group_hand_screen, game_screen, dominos)
 
+                # если правый клик - переворачиваем домино (переворачиваем ее значения)
                 elif mouse_down == "right" and time() - r_click_time >= r_click_cd:
                     r_click_time = domino.update_rotation(mouse_new_pos[0], mouse_new_pos[1], r_click_time)
 
+        # если мы кликнули на кнопку, добовляем в руку новые домино
         if not move and mouse_down == "left":
             values = False
+
             if time() - r_click_time >= r_click_cd and len(dominos) != 0:
                 r_click_time, values, coor = get_button.active_button(mouse_new_pos[0], mouse_new_pos[1], r_click_time, dominos)
             if values:
@@ -112,6 +121,7 @@ while run:
             else:
                 game_screen.update_pos(mouse_move[0], mouse_move[1], mouse_new_pos[0], mouse_new_pos[1])
 
+    # если мы кликнули на "стол", передвигаем его
     else:
         for domino in group_hand_screen:
             if domino.type == "domino":
@@ -121,6 +131,7 @@ while run:
     screen.fill((230, 230, 230))
 
     def blit_group(group):
+        """блит группы"""
         for entity in group:
             if entity.type == "domino":
                 entity.blit_domino(screen, dominos)
@@ -137,4 +148,31 @@ while run:
 
     mouse_old_pos = [pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1]]
 
+    # print(len(dominos), len(s.DOMINOS))
+    # если у игрока на руке не осталось фишек, и в колоде тоже, то он побеждает, и программа выходит из while
+    if len(dominos) <= 0 and len(s.DOMINOS) <= 0:
+        break
+
+    pygame.display.flip()
+
+# экран победы
+run = True
+while run:
+    for event in pygame.event.get():
+        # Did the user hit a key?
+        if event.type == KEYDOWN:
+            # Was it the Escape key? If so, stop the loop.
+            if event.key == K_ESCAPE:
+                run = False
+
+
+        elif event.type == MOUSEBUTTONDOWN:
+            run = False
+
+    surf = pygame.Surface((500, 200))
+    color = (255, 50, 50)
+    surf.fill(color)
+    rect = surf.get_rect(center=(s.SCREEN_WIDTH/2, s.SCREEN_HEIGHT/2))
+    screen.blit(surf, rect)
+                
     pygame.display.flip()

screens.py

@@ -2,6 +2,7 @@ import pygame
 import settings as s
 from time import time
 from random import choice
+from json import dumps
 # from domino import Domino
 
 
@@ -9,6 +10,7 @@ pygame.font.init()
 my_font = pygame.font.SysFont('Calibri (Body)', 50)
 
 class Hand_screen(pygame.sprite.Sprite):
+    """рука игрока"""
     def __init__(self):
         super().__init__()
         self.type = "hand_screen"
@@ -22,6 +24,7 @@ class Hand_screen(pygame.sprite.Sprite):
 
 
 class Button(pygame.sprite.Sprite):
+
     def __init__(self):
         super().__init__()
         self.type = "button"
@@ -36,7 +39,7 @@ class Button(pygame.sprite.Sprite):
 
 
     def blit_button(self, screen):
-
+        # блит кнопки
         screen.blit(self.surf, self.rect)
 
         text = my_font.render(f"{self.text}", True, (255, 255, 255))
@@ -46,6 +49,7 @@ class Button(pygame.sprite.Sprite):
 
 
     def active_button(self, mouse_x, mouse_y, r_click_time, dominos):
+        # если нажали на кнопку, добавляем домино в руку
         if self.rect.x <= mouse_x <= self.rect.x + self.w and self.rect.y <= mouse_y <= self.rect.y + self.h:
             # pygame.transform.rotate(self.surf, 90)
             x = 110 * len(dominos) - 1
@@ -58,6 +62,7 @@ class Button(pygame.sprite.Sprite):
         return r_click_time, False, False
 
 class Empty_domino(pygame.sprite.Sprite):
+    """пустышка"""
     def __init__(self, x, y, pos):
         super().__init__()
         self.type = "empty domino"

settings.py

@@ -1,4 +1,4 @@
-# Define constants for the screen width and height
+# Define constants for the screen, dominos
 from random import choice
 
 SCREEN_WIDTH = 1200
@@ -9,12 +9,36 @@ DOMINO_H = 200
 DOMINOS = []
 
 values = range(7)
-for v_up in values:
+# for v_up in values:
-    for v_down in values:
+    # for v_down in values:
-        if not [v_up, v_down] in DOMINOS and not [v_down, v_up] in DOMINOS:
+    #     if not [v_up, v_down] in DOMINOS and not [v_down, v_up] in DOMINOS:
-            DOMINOS.append([v_up, v_down])
+    #         DOMINOS.append([v_up, v_down])
+
+for _ in range(10):
+    DOMINOS.append([[1, '1'], [1, '1']])
+
+print(DOMINOS)
+
+# в каждом по 8
+str_values = {
+    0: ["32*0", "2^2-4", "7-3.5*2", "-5+2.5*2", "0-0+0", "0/43", "False", "[1, 0][1]", "8*(3-3)", "not 3", "6+6-6+6-6-6"],
+    1: ["0^0", "24/24", "True", "23>4", "1 or 0", "10-1*9", "sqrt(1)", "5^1/5", "7-6", "1!", "36/6^2", "-2+3", "if 'str'", "bool(-3)"],
+    2: ["2!", "8^0.34", "int(e)", "True+True", "14/7", "sqrt(4)", "sqrt(4)^2", "int('2')", "(1<3)*2", "3-1", "1+1"],
+    3: ["2!*1.5", "9/3", "round(pi)", "sqrt(9)", "(18/2)^0.5", "True*3", "5-2", "6/2", "3+0^1", "0^0*3", "round(3)"],
+    4: ["2*2", "3+1*1", "0+4", "int(e)*2", "8/2", "6-3+1", "(8+4)/3", "int('5')-1", "int(float(str(4.9)))", "sqrt(16)"],
+    5: ["10/2", "25^0.5", "2*5/2", "4!-19", "True*10/2", "3+2", "100/20", "4*1.25", "int(5.839)", "5+5-5+5-5", "2.5*2"],
+    6: ["3!", "2+2*2", "round(pi)*2", "(if 6>1)*6", "10-4", "24/4", "sqrt(12*3)", "3^2-3", "2*(4-1)", "{1,3,6}[2]"]
+}
+
+# for i in range(len(DOMINOS)):
+#     v_up = choice(str_values[DOMINOS[i][0]])
+#     str_values[DOMINOS[i][0]].remove(v_up)
+#     v_down = choice(str_values[DOMINOS[i][1]])
+#     str_values[DOMINOS[i][1]].remove(v_down)
+#
+#     DOMINOS[i] = [[DOMINOS[i][0], v_up], [DOMINOS[i][1], v_down]]
+
+
+print(DOMINOS)
 
-# for _ in range(10):
-#     DOMINOS.append([1, 1])
 
-# print(DOMINOS)