Finally fixed sprite caching. For now it works only for one map, need to develop mapmanager and have a list of cached sprites for each map.

eb_engine.py

@@ -12,6 +12,10 @@ cell_classes = {"grass_small": eb_terrain_objects.Ground,
 main_dir = os.path.dirname(os.path.abspath(__file__))
 sprites_dir = os.path.join(main_dir, "res", "sprites") 
 
+#class MapManager
+#class Event
+#class EventManager
+
 @dataclass
 class Cell:
     terrain_obj:  any
@@ -23,16 +27,16 @@ class Cell:
 class Map:
     name:             str
     sprites:          dict
-    sprites_refresh:  int    = 60
-    cells:            dict   = field(default_factory = dict)
-    color:            str    = "gray57"
-    target_color:     str    = "gold"
-    size:             int    = 150
-    bord:             int    = 3
-    scale:            float  = 1
-    cam_x:            int    = 0
-    cam_y:            int    = 0
-    cell_dist:        int    = 1
+    sprites_refresh:  int    =   60
+    cells:            dict   =   field(default_factory = dict)
+    color:            str    =   "gray57"
+    target_color:     str    =   "gold"
+    size:             int    =   150
+    bord:             int    =   3
+    scale:            float  =   1
+    cam_x:            int    =   0
+    cam_y:            int    =   0
+    cell_dist:        int    =   1
 
     def __post_init__(self):
         self.cells = {}
@@ -60,8 +64,10 @@ class Map:
                              "screen": screen}
 
                 cell.terrain_obj.draw(dd)
+
                 if cell.item_obj:
                     cell.item_obj.draw(dd)
+                
                 if cell.creature_obj:
                     cell.creature_obj.draw(dd)
 
@@ -70,20 +76,25 @@ class Map:
                 
 @dataclass
 class Engine:
-    sprites:      dict            = field(default_factory = dict)
-    screen:       pygame.Surface  = ((1, 1))
-    width:        int             = 1600
-    height:       int             = 800
-    camera_step:  int             = 10
-    scale_step:   float           = 0.01
+    sprites:         dict             =   field(default_factory = dict)
+    cached_sprites:  dict             =   field(default_factory = dict)
+    screen:          pygame.Surface   =   ((1, 1))
+    width:           int              =   1600
+    height:          int              =   800
+    camera_step:     int              =   10
+    scale_step:      float            =   0.01
+    spr_scale:       float            =   1
     
     def __post_init__(self):
         self.sprites = {}
         pygame.init()
         pygame.display.set_caption('Elvenbane')
         self.screen = pygame.display.set_mode((self.width, self.height), pygame.HWSURFACE | pygame.DOUBLEBUF)
-        self.load_sprites()
         print("The engine has started. Sprites were successfully loaded.\n")
+        self.load_sprites()
+        print("Sprites were successfully loaded.\n")
+        self.cached_sprites = deepcopy(self.sprites)
+        print("Sprites were successfully cached.\n")
 
     def load_sprites(self, folder_path = sprites_dir):
         self.sprites = {}
@@ -104,8 +115,20 @@ class Engine:
                 for num, f in items
             ]
 
+    def scale_image(self, image):
+        orig_size = image.get_size()
+        new_size = (int(orig_size[0] * self.spr_scale), int(orig_size[1] * self.spr_scale))
+        return pygame.transform.smoothscale(image, new_size)
+
+    def scale_sprites(self):
+        for sp_name, sprite_list in self.sprites.items():
+            for i, sprite in enumerate(sprite_list):
+                scaled = self.scale_image(sprite)
+                self.cached_sprites[sp_name][i] = scaled
+
+
     def main_loop(self):                
-        easy_map = Map("def_map.json", self.sprites)
+        easy_map = Map("def_map.json", self.cached_sprites)
         #sp = eb_objects.Sprite(self.sprites, "elf_watching")
         #gr = pygame.image.load(file_path).convert_alpha()
 
@@ -119,16 +142,16 @@ class Engine:
 
         # profiling
 
-        process = psutil.Process(os.getpid())
-        gc.collect()
-        mem_before = process.memory_info().rss / 1024  
+        #process = psutil.Process(os.getpid())
+        #gc.collect()
+        #mem_before = process.memory_info().rss / 1024  
 
         while running:
             #pygame.event.clear()
-            if global_counter % 1000 == 0:
-                gc.collect()
-                mem_after = process.memory_info().rss / 1024 
-                print(f"Leak: {mem_after - mem_before:.1f}  KB per 1000 frames")
+            #if global_counter % 1000 == 0:
+            #    gc.collect()
+            #    mem_after = process.memory_info().rss / 1024 
+            #    print(f"Leak: {mem_after - mem_before:.1f}  KB per 1000 frames")
 
             # poll for events
             # pygame.QUIT event means the user clicked X to close your window
@@ -154,8 +177,12 @@ class Engine:
                     easy_map.cam_x -= self.camera_step
                 if keys[pygame.K_q]:
                     easy_map.scale += self.scale_step
+                    self.spr_scale += self.scale_step
+                    self.scale_sprites()
                 if keys[pygame.K_e] and easy_map.scale >= self.scale_step:
                     easy_map.scale -= self.scale_step
+                    self.spr_scale -= self.scale_step
+                    self.scale_sprites()
                 if keys[pygame.K_ESCAPE]:
                     running = False