added vegetables collection function, you cant run over rocks anymore

field.py

@@ -1,60 +1,60 @@
 import random
+from enum import Enum
 
 import pygame
+
 pygame.init()
 BLACK = (0, 0, 0)
 WHITE = (200, 200, 200)
 BLUE = (46, 34, 240)
-WINDOW_HEIGHT = 600
-WINDOW_WIDTH = 600
-BLOCK_SIZE = 40
+WINDOW_DIMENSIONS = 800
+BLOCK_SIZE = 80
 ROCKS_NUMBER = 10
 VEGETABLES_NUMBER = 20
 VEGETABLES = ('Potato', 'Broccoli', 'Carrot', 'Onion')
-
-
+BOARD_SIZE = int(WINDOW_DIMENSIONS / BLOCK_SIZE)
 
 
 def generate_locations(number, flag=False, rocks=[]):
     locations = []
     if flag:
         for i in range(number):
-            x = random.randrange(0, WINDOW_WIDTH, BLOCK_SIZE)
-            y = random.randrange(0, WINDOW_HEIGHT, BLOCK_SIZE)
-            if (x, y) not in rocks and (x, y) not in locations:
+            x = random.randrange(0, BOARD_SIZE)
+            y = random.randrange(0, BOARD_SIZE)
+            if (x, y) not in rocks and (x, y, 'Potato') not in locations and (x, y, 'Broccoli') not in locations and (
+            x, y, 'Carrot') not in locations and (x, y, 'Onion') not in locations:
                 locations.append((x, y, VEGETABLES[random.randrange(0, len(VEGETABLES))]))
             else:
                 i -= 1
         return locations
     else:
         for i in range(number):
-            x = random.randrange(0, WINDOW_WIDTH, BLOCK_SIZE)
-            y = random.randrange(0, WINDOW_HEIGHT, BLOCK_SIZE)
-            if (x, y) not in locations:
+            x = random.randrange(0, BOARD_SIZE - 1)
+            y = random.randrange(0, BOARD_SIZE - 1)
+            if (x, y) not in locations and (x, y) != (0, 0):
                 locations.append((x, y))
             else:
                 i -= 1
         return locations
 
 
-
 def draw_grid():
-    #Set the size of the grid block
-    wei = pygame.image.load("images/wet_earth_tile.jpg")
-    dei = pygame.image.load("images/dry_earth_tile.jpg")
-    for x in range(0, WINDOW_WIDTH, BLOCK_SIZE):
-        for y in range(0, WINDOW_HEIGHT, BLOCK_SIZE):
+    # Set the size of the grid block
+    wei = pygame.transform.scale(pygame.image.load("images/wet_earth_tile.jpg"), (BLOCK_SIZE, BLOCK_SIZE))
+    dei = pygame.transform.scale(pygame.image.load("images/dry_earth_tile.jpg"), (BLOCK_SIZE, BLOCK_SIZE))
+    for x in range(0, BOARD_SIZE):
+        for y in range(0, BOARD_SIZE):
             if (x, y) in wet_tiles_coordinates:
-                sc.blit(wei, (x, y))
+                sc.blit(wei, (x * BLOCK_SIZE, y * BLOCK_SIZE))
             else:
-                sc.blit(dei, (x, y))
-            rect = pygame.Rect(x, y, BLOCK_SIZE, BLOCK_SIZE)
+                sc.blit(dei, (x * BLOCK_SIZE, y * BLOCK_SIZE))
+            rect = pygame.Rect(x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE)
             pygame.draw.rect(sc, WHITE, rect, 1)
 
 
 def draw_interface():
     global sc
-    sc = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
+    sc = pygame.display.set_mode((WINDOW_DIMENSIONS, WINDOW_DIMENSIONS))
     pygame.display.set_caption("Pole i ciągnik")
     pygame.display.set_icon(pygame.image.load("images/icon.png"))
 
@@ -62,63 +62,128 @@ def draw_interface():
     sc.fill(BLACK)
     FPS = 60
 
-    #region Images import
-    bg = pygame.image.load("images/field_image.jpg")
-    tractor_image = pygame.image.load("images/tractor_image.png")
-    rock_image = pygame.image.load("images/rock_image.png")
-    potato_image = pygame.image.load("images/potato.png")
-    carrot_image = pygame.image.load("images/carrot.png")
-    broccoli_image = pygame.image.load("images/broccoli.png")
-    onion_image = pygame.image.load("images/onion.png")
-    #endregion
+    # region Images import
+    # bg = pygame.image.load("images/field_image.jpg")
+    tractor_image= pygame.transform.scale(pygame.image.load("images/tractor_image.png"), (BLOCK_SIZE, BLOCK_SIZE))
+    rock_image = pygame.transform.scale(pygame.image.load("images/rock_image.png"), (BLOCK_SIZE, BLOCK_SIZE))
+    potato_image = pygame.transform.scale(pygame.image.load("images/potato.png"), (BLOCK_SIZE, BLOCK_SIZE))
+    carrot_image = pygame.transform.scale(pygame.image.load("images/carrot.png"), (BLOCK_SIZE, BLOCK_SIZE))
+    broccoli_image = pygame.transform.scale(pygame.image.load("images/broccoli.png"), (BLOCK_SIZE, BLOCK_SIZE))
+    onion_image = pygame.transform.scale(pygame.image.load("images/onion.png"), (BLOCK_SIZE, BLOCK_SIZE))
+    font = pygame.font.Font('freesansbold.ttf', BLOCK_SIZE // 2)
+    # endregion
 
-    x = BLOCK_SIZE / 4
-    y = BLOCK_SIZE / 4
+    x = 0
+    y = 0
 
     rocks = generate_locations(ROCKS_NUMBER)
     vegetables = generate_locations(VEGETABLES_NUMBER, flag=True, rocks=rocks)
+    collected_vegetables = [0, 0, 0, 0]
     global wet_tiles_coordinates
     wet_tiles_coordinates = []
 
-    flRunning = True
-    while flRunning:
-        #sc.fill(BLACK)
-        sc.blit(bg, (0, 0))
+    fl_running = True
+    while fl_running:
         draw_grid()
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 pygame.quit()
-                flRunning = False
+                fl_running = False
             elif event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_LEFT:
-                    if x > BLOCK_SIZE/2:
-                        x -= BLOCK_SIZE
+                    if x > 0:
+                        if (x - 1, y) not in rocks:
+                            x -= 1
+                        else:
+                            print("Rock")
                 elif event.key == pygame.K_RIGHT:
-                    if x < WINDOW_WIDTH - BLOCK_SIZE/2:
-                        x += BLOCK_SIZE
+                    if x < BOARD_SIZE - 1:
+                        if (x + 1, y) not in rocks:
+                            x += 1
+                        else:
+                            print("Rock")
                 elif event.key == pygame.K_DOWN:
-                    if y < WINDOW_HEIGHT - BLOCK_SIZE/2:
-                        y += BLOCK_SIZE
+                    if y < BOARD_SIZE - 1:
+                        if (x, y + 1) not in rocks:
+                            y += 1
+                        else:
+                            print("Rock")
                 elif event.key == pygame.K_UP:
-                    if y > BLOCK_SIZE/2:
-                        y -= BLOCK_SIZE
+                    if y > 0:
+                        if (x, y - 1) not in rocks:
+                            y -= 1
+                        else:
+                            print("Rock")
                 elif event.key == pygame.K_SPACE:
-                    wet_tiles_coordinates.append((x-BLOCK_SIZE/4, y-BLOCK_SIZE/4))
-
-        #pygame.draw.rect(sc, BLUE, (x, y, BLOCK_SIZE / 2, BLOCK_SIZE / 2))
+                    wet_tiles_coordinates.append((x, y))
+                elif event.key == pygame.K_RETURN:
+                    for vegetable in vegetables:
+                        if vegetable[0] == x and vegetable[1] == y:
+                            if vegetable[2] == 'Potato':
+                                print("Potato collected")
+                                collected_vegetables[0] += 1
+                            elif vegetable[2] == 'Broccoli':
+                                print("Broccoli collected")
+                                collected_vegetables[1] += 1
+                            elif vegetable[2] == 'Carrot':
+                                print("Carrot collected")
+                                collected_vegetables[2] += 1
+                            elif vegetable[2] == 'Onion':
+                                print("Onion collected")
+                                collected_vegetables[3] += 1
+                            vegetables.remove(vegetable)
+                            break
+                        else:
+                            print("No vegetable here")
 
         for rock in rocks:
-            sc.blit(rock_image, (rock[0], rock[1]))
+            sc.blit(rock_image, (rock[0] * BLOCK_SIZE, rock[1] * BLOCK_SIZE))
         for vegetable in vegetables:
             if vegetable[2] == 'Potato':
-                sc.blit(potato_image, (vegetable[0], vegetable[1]))
+                sc.blit(potato_image, (vegetable[0] * BLOCK_SIZE + 5, vegetable[1] * BLOCK_SIZE + 5))
             elif vegetable[2] == 'Carrot':
-                sc.blit(carrot_image, (vegetable[0], vegetable[1]))
+                sc.blit(carrot_image, (vegetable[0] * BLOCK_SIZE + 5, vegetable[1] * BLOCK_SIZE + 5))
             elif vegetable[2] == 'Broccoli':
-                sc.blit(broccoli_image, (vegetable[0], vegetable[1]))
+                sc.blit(broccoli_image, (vegetable[0] * BLOCK_SIZE + 5, vegetable[1] * BLOCK_SIZE + 5))
             elif vegetable[2] == 'Onion':
-                sc.blit(onion_image, (vegetable[0], vegetable[1]))
-        sc.blit(tractor_image, (x - 5, y - 5))
+                sc.blit(onion_image, (vegetable[0] * BLOCK_SIZE + 5, vegetable[1] * BLOCK_SIZE + 5))
+        vegetables_text = font.render('Potato: ' + str(collected_vegetables[0]) + ' Broccoli: ' + str(
+            collected_vegetables[1]) + ' Carrot: ' + str(collected_vegetables[2]) + ' Onion: ' + str(
+            collected_vegetables[3]), True, WHITE, BLACK)
+        vegetables_textRect = vegetables_text.get_rect()
+        vegetables_textRect.center = (WINDOW_DIMENSIONS // 2, WINDOW_DIMENSIONS - 30)
+        sc.blit(vegetables_text, vegetables_textRect)
+        sc.blit(tractor_image, (x * BLOCK_SIZE + 5, y * BLOCK_SIZE + 5))
         pygame.display.update()
 
-        clock.tick(FPS)
+        clock.tick(FPS)
+
+
+class types(Enum):
+    EMPTY = 0
+    ROCK = 1
+    TRACTOR = 2
+    POTATO = 3
+    BROCCOLI = 4
+    CARROT = 5
+    ONION = 6
+
+
+class objectOnField:
+    def __init__(self, x, y, type):
+        self.x = x
+        self.y = y
+        self.type = type
+
+
+class Grid:
+    def __init__(self, width, height, block_size):
+        self.width = width
+        self.height = height
+        self.block_size = block_size
+        self.grid = []
+        self.vegetables = []
+        self.rocks = []
+        self.tractor = None
+        self.wet_tiles = []
+        self.generate_grid()