restructured

agent.py

@@ -0,0 +1,43 @@
+import pygame
+import settings
+
+
+class Instance:
+    def __init__(self):
+        size = settings.Field.size
+        self.rect = pygame.Rect(0, 0, size(), size())
+        self.action = ''
+
+    def current_field_pos(self):
+        return {
+            'x': self.x(),
+            'y': self.y()
+        }
+
+    def x(self):
+        return int(self.rect.x / settings.Field.size())
+
+    def y(self):
+        return int(self.rect.y / settings.Field.size())
+
+    def move(self):
+        key_pressed = pygame.key.get_pressed()
+        height = settings.Pygame.height()
+        width = settings.Pygame.width()
+        tile_size = settings.Field.size()
+
+        if key_pressed[pygame.K_LEFT] and self.rect.x > 0:
+            self.rect.x -= tile_size
+            return False
+        elif key_pressed[pygame.K_RIGHT] and self.rect.x < width - tile_size:
+            self.rect.x += tile_size
+            return False
+        elif key_pressed[pygame.K_UP] and self.rect.y > 0:
+            self.rect.y -= tile_size
+            return False
+        elif key_pressed[pygame.K_DOWN] and self.rect.y < height - tile_size:
+            self.rect.y += tile_size
+            return False
+        elif key_pressed[pygame.K_SPACE]:
+            return False
+        return True

common.py

@@ -0,0 +1,9 @@
+class Instance:
+    def __init__(self):
+        self.vars = {}
+
+    def set(self, key: str, value):
+        self.vars[key] = value
+
+    def get(self, key: str):
+        return self.vars[key]

field.py

@@ -0,0 +1,90 @@
+from enum import Enum
+
+import pygame
+
+import settings
+
+
+class Type(Enum):
+    DEFAULT = 0
+    PLANT = 1
+    SPECIAL = 2
+
+    @staticmethod
+    def get_string(_type):
+        return {
+            Type.DEFAULT: 'default',
+            Type.PLANT: 'plant',
+            Type.SPECIAL: 'special',
+        }[_type]
+
+
+class Object:
+    height = width = 0
+    name = 'default'
+    type = Type.DEFAULT
+
+    def create(self):
+        field_string = Type.get_string(self.type)
+
+        print("assets/fields/" + field_string + "/" + self.name + ".jpg")
+        img = pygame.image.load("./assets/fields/" + field_string + "/" + self.name + ".jpg")
+        print(img)
+        return pygame.transform.scale(img, (self.width, self.height))
+
+
+class Tile(Object) :
+    def __init__(self, name: str, _type: Type):
+        self.name = name
+        self.type = _type
+        self.width = self.height = settings.Field.size()
+        self.object = self.create()
+
+
+class Block(Object) :
+    def __init__(self, name: str, _type: Type):
+        self.name = name
+        self.type = _type
+        self.width = settings.Pygame.width()
+        self.height = settings.Pygame.height()
+        self.object = self.create()
+
+
+class Field:
+    type = Type.DEFAULT
+    name = 'default'
+    
+    def __init__(self):
+        self.tile = Tile(self.name, self.type)
+        self.block = Block(self.name + "_block", self.type)
+
+
+class Dirt(Field):
+    type = Type.PLANT
+    name = 'dirt'
+
+    def __init__(self):
+        super(Dirt, self).__init__()
+        
+        
+class Cobble:
+    type = Type.SPECIAL
+    name = 'cobble'
+
+    def __init__(self):
+        self.tile = Tile(self.name, self.type)
+        self.block = Block(self.name + "_block", self.type)
+        
+        
+class Grass:
+    type = Type.DEFAULT
+    name = 'grass'
+
+    def __init__(self):
+        self.tile = Tile(self.name, self.type)
+        self.block = Block(self.name + "_block", self.type)
+
+# DIRT_IMG = pygame.image.load("assets/fields/plant/dirt.jpg")
+# DIRT = pygame.transform.scale(DIRT_IMG, (50, 50))
+# DIRT_BLOCK_IMG = pygame.image.load("assets/fields/plant/dirt_block.jpg")
+# DIRT_BLOCK = pygame.transform.scale(DIRT_BLOCK_IMG, (800, 800))

main.py

@@ -1,32 +1,45 @@
 import pygame
 import random
 
-WIDTH, HEIGHT = 800, 800
-WIN = pygame.display.set_mode((WIDTH, HEIGHT))
-pygame.display.set_caption("Sztuczna Inteligencja")
-FPS = 30
+import field
+import settings
+import common
+import agent
+
 AGENT_IMG = pygame.image.load("dot-22-433567.png")
 AGENT = pygame.transform.scale(AGENT_IMG, (50, 50))
-DIRT_IMG = pygame.image.load("dirt.jpg")
-DIRT = pygame.transform.scale(DIRT_IMG, (50, 50))
-GRASS_IMG = pygame.image.load("grass.png")
+
+DIRT_IMG = pygame.image.load("assets/fields/plant/dirt.jpg")
+# DIRT = pygame.transform.scale(DIRT_IMG, (50, 50))
+# DIRT_BLOCK_IMG = pygame.image.load("assets/fields/plant/dirt_block.jpg")
+# DIRT_BLOCK = pygame.transform.scale(DIRT_BLOCK_IMG, (800, 800))
+
+DIRT = field.Dirt().tile.object
+DIRT_BLOCK = field.Dirt().block.object
+
+GRASS_IMG = pygame.image.load("assets/fields/default/grass.png")
 GRASS = pygame.transform.scale(GRASS_IMG, (50, 50))
+GRASS_BLOCK_IMG = pygame.image.load("assets/fields/default/grass_block.jpeg")
+GRASS_BLOCK = pygame.transform.scale(GRASS_BLOCK_IMG, (800, 800))
+
 SAND_IMG = pygame.image.load("sand.jpeg")
 SAND = pygame.transform.scale(SAND_IMG, (50, 50))
-COBBLE_IMG = pygame.image.load("cobble.jpeg")
-COBBLE = pygame.transform.scale(COBBLE_IMG, (50, 50))
-DIRT_BLOCK_IMG = pygame.image.load("dirt_block.jpg")
-DIRT_BLOCK = pygame.transform.scale(DIRT_BLOCK_IMG, (800, 800))
-GRASS_BLOCK_IMG = pygame.image.load("grass_block.jpeg")
-GRASS_BLOCK = pygame.transform.scale(GRASS_BLOCK_IMG, (800, 800))
 SAND_BLOCK_IMG = pygame.image.load("sand_block.jpg")
 SAND_BLOCK = pygame.transform.scale(SAND_BLOCK_IMG, (800, 800))
-COBBLE_BLOCK_IMG = pygame.image.load("cobble_block.jpeg")
+
+COBBLE_IMG = pygame.image.load("assets/fields/special/cobble.jpg")
+COBBLE = pygame.transform.scale(COBBLE_IMG, (50, 50))
+COBBLE_BLOCK_IMG = pygame.image.load("assets/fields/special/cobble_block.jpg")
 COBBLE_BLOCK = pygame.transform.scale(COBBLE_BLOCK_IMG, (800, 800))
 
 
 def randomize_map():
-    possible_fields = [DIRT, GRASS, SAND, COBBLE]
+    possible_fields = [
+        field.Dirt().tile.object,
+        GRASS,
+        SAND,
+        COBBLE
+    ]
     field_array_big = []
     field_array_small = []
     for i in range(16):
@@ -38,63 +51,64 @@ def randomize_map():
 
 
 def read_img(agent, fields):
-    if fields[int(agent.x / 50)][int(agent.y / 50)] == GRASS:
-        WIN.blit(GRASS_BLOCK, (0, 0))
-    elif fields[int(agent.x / 50)][int(agent.y / 50)] == DIRT:
-        WIN.blit(DIRT_BLOCK, (0, 0))
-    elif fields[int(agent.x / 50)][int(agent.y / 50)] == SAND:
-        WIN.blit(SAND_BLOCK, (0, 0))
-    elif fields[int(agent.x / 50)][int(agent.y / 50)] == COBBLE:
-        WIN.blit(COBBLE_BLOCK, (0, 0))
+    window = common.get('window')
+    coords = agent.current_field_pos()
+    current_field = fields[coords['x']][coords['y']]
+
+    if current_field == GRASS:
+        window.blit(GRASS_BLOCK, (0, 0))
+    elif current_field == field.Dirt().tile.object:
+        window.blit(DIRT_BLOCK, (0, 0))
+    elif current_field == SAND:
+        window.blit(SAND_BLOCK, (0, 0))
+    elif current_field == COBBLE:
+        window.blit(COBBLE_BLOCK, (0, 0))
     pygame.display.update()
     pygame.time.delay(2000)
 
 
-def draw_window(agent, fields, image_shown):
-    if image_shown:
-        for i in range(16):
-            for j in range(16):
-                WIN.blit(fields[i][j], (i * 50, j * 50))
-        WIN.blit(AGENT, (agent.x, agent.y))
-        pygame.display.update()
-    else:
-        read_img(agent, fields)
+def draw_window(agent, fields):
+    window = common.get('window')
+    rect = agent.rect
+    for i in range(16):
+        for j in range(16):
+            window.blit(fields[i][j], (i * settings.Field.size(), j * settings.Field.size()))
+    window.blit(AGENT, (rect.x, rect.y))
+    pygame.display.update()
 
 
-def agent_movement(keys_pressed, agent):
-    if keys_pressed[pygame.K_LEFT] and agent.x > 0:
-        agent.x -= 50
-        return False
-    elif keys_pressed[pygame.K_RIGHT] and agent.x < 750:
-        agent.x += 50
-        return False
-    elif keys_pressed[pygame.K_UP] and agent.y > 0:
-        agent.y -= 50
-        return False
-    elif keys_pressed[pygame.K_DOWN] and agent.y < 750:
-        agent.y += 50
-        return False
-    else:
-        return True
+common = common.Instance()
+agent = agent.Instance()
 
 
 def main():
-    clock = pygame.time.Clock()
-    run = True
-    agent = pygame.Rect(0, 0, 50, 50)
+    common.set('game_running', True)
+    common.set('state_imgShown', True)
+    common.set(
+        'window',
+        pygame.display.set_mode((
+            settings.Pygame.width(),
+            settings.Pygame.height())))
+
+    pygame.display.set_caption(settings.Pygame.display_name())
+
     fields = randomize_map()
-    image_shown = True
-    while run:
-        clock.tick(FPS)
+
+    while common.get('game_running'):
+        pygame.time.Clock().tick(settings.Pygame.fps())
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
-                run = False
-        keys_pressed = pygame.key.get_pressed()
-        draw_window(agent, fields, image_shown)
-        image_shown = agent_movement(keys_pressed, agent)
+                common.set('game_running', False)
+
+        if not common.get('state_imgShown'):
+            read_img(agent, fields)
+        else:
+            draw_window(agent, fields)
+
+        agent.move()
 
     pygame.quit()
 
 
 if __name__ == "__main__":
-    main()
+    main()

settings.py

@@ -0,0 +1,36 @@
+class Field:
+    @staticmethod
+    def size():
+        return 50
+
+    @staticmethod
+    def horizontal_count():
+        return 16
+
+    @staticmethod
+    def vertical_count():
+        return 16
+
+
+class Pygame:
+    @staticmethod
+    def display_name():
+        return 'Szybcior Sztucznie Inteligentny Traktor'
+
+    @staticmethod
+    def fps():
+        return 10
+
+    @staticmethod
+    def height():
+        return Field.vertical_count() * Field.size()
+
+    @staticmethod
+    def width():
+        return Field.horizontal_count() * Field.size()
+
+
+class Setting:
+    def __init__(self, key, default_value):
+        self.key = key
+        self.default_value = default_value