update to use per pixel update only

Author: Emprario

Diff for: CONSTS.py

@@ -15,4 +15,4 @@ class OnLoadMapError(Exception):
 
 coordinate = tuple[int, int]
 DEFAULT_DENSITY = 20
-MAX_THREAD_BY_CALC = 58
+MAX_THREAD_BY_CALC = 1

Diff for: debug_utils.py

@@ -1,17 +1,53 @@
 """
 Outil de debug divers
 """
+from time import time
+from typing import Callable
 
-def test_get_full_line():
+total_time = 0
+
+
+def get_time(function: Callable) -> Callable:
+    def wrapper(*args, **kwargs):
+        t1 = time()
+        result = function(*args, **kwargs)
+        t2 = time()
+        print(f'Elapsed time of {function}: {t2 - t1}')
+        return result
+
+    return wrapper
+
+
+def add_time_incache(function: Callable) -> Callable:
+    global total_time
 
+    def wrapper(*args, **kwargs):
+        global total_time
+        t1 = time()
+        result = function(*args, **kwargs)
+        t2 = time()
+        total_time += t2 - t1
+        return result
+
+    return wrapper
+
+
+def get_time_incache() -> int:
+    print(f"Total time: {total_time}")
+    return total_time
+
+
+def test_get_full_line():
     from utils import get_full_line
 
     assert get_full_line((10, 30), (-20, 69)) == [(-20, 69), (-19, 68), (-18, 67), (-18, 66), (-17, 65), (-16, 64),
-                                              (-15, 63), (-15, 62), (-14, 61), (-13, 60), (-12, 59), (-12, 58),
-                                              (-11, 57), (-10, 56), (-9, 55), (-8, 54), (-8, 53), (-7, 52), (-6, 51),
-                                              (-5, 50), (-5, 49), (-4, 48), (-3, 47), (-2, 46), (-2, 45), (-1, 44),
-                                              (0, 43), (1, 42), (2, 41), (2, 40), (3, 39), (4, 38), (5, 37), (5, 36),
-                                              (6, 35), (7, 34), (8, 33), (8, 32), (9, 31), (10, 30)]
+                                                  (-15, 63), (-15, 62), (-14, 61), (-13, 60), (-12, 59), (-12, 58),
+                                                  (-11, 57), (-10, 56), (-9, 55), (-8, 54), (-8, 53), (-7, 52),
+                                                  (-6, 51),
+                                                  (-5, 50), (-5, 49), (-4, 48), (-3, 47), (-2, 46), (-2, 45), (-1, 44),
+                                                  (0, 43), (1, 42), (2, 41), (2, 40), (3, 39), (4, 38), (5, 37),
+                                                  (5, 36),
+                                                  (6, 35), (7, 34), (8, 33), (8, 32), (9, 31), (10, 30)]
 
 
 def have_duplicated_obj_in_list(master: list[list]) -> bool:

Diff for: main.py

@@ -3,11 +3,13 @@
 Ce module devra également contenir
     - Les instructions pour lancer la boucle principale (dans game_engine.MaitreDuJeu)
 """
+from threading import Thread
 
 import pygame
 
 from map import TileMap
 from debug_pygame import show_point, get_point_from_idx
+from debug_utils import get_time_incache
 
 pygame.init()
 
@@ -22,7 +24,11 @@
 
 run = True
 debug_switch = False
+
+map.blit_texture(SCREEN, all_pxs=True)
+
 while run:
+    destruction = ()
     if debug_switch:
         map.print_map(SCREEN)
     else:
@@ -32,13 +38,19 @@
         if event.type == pygame.KEYDOWN:
             if event.key == pygame.K_s:
                 debug_switch = not debug_switch
-            # if event.key == pygame.K_d:
+                map.blit_texture(SCREEN, all_pxs=True)
+            if event.key == pygame.K_d:
+                get_time_incache()
             elif event.key == pygame.K_ESCAPE:
                 run = False
         elif event.type == pygame.MOUSEBUTTONDOWN:
             print("Mouse point @", pygame.mouse.get_pos())
-            map.destroy_map(pygame.mouse.get_pos(), 50.0)
+            destruction = (pygame.mouse.get_pos(), 50.0)
         elif event.type == pygame.QUIT:
             pygame.quit()
             exit(1)
-    # Oclock.tick(60)
+
+    if destruction != ():
+        Thread(group=None, target=map.destroy_map, name=None, args=destruction).start()
+
+    Oclock.tick(60)

Diff for: map.py

@@ -5,14 +5,14 @@
     - Comment représenter dans le programme de la matière
 """
 
-from debug_pygame import show_point
+from functools import reduce
 from sys import setrecursionlimit
 from threading import Thread
-from functools import reduce
 
 import pygame
 
-from CONSTS import coordinate, OnLoadMapError, DEFAULT_DENSITY, MAX_THREAD_BY_CALC
+from CONSTS import coordinate, OnLoadMapError, DEFAULT_DENSITY
+from debug_pygame import get_point_from_idx
 from utils import get_full_line, get_circle
 
 setrecursionlimit(9000000)
@@ -35,12 +35,15 @@ def gen_segmented_map(vectmap: list[list[coordinate]]) -> list[list[coordinate]]
 
 
 def algo_peinture(segmap: list[list[coordinate]], fmap: list[list[bool]], centers: list[coordinate],
-                  base: bool = False):
+                  dim: list[int], base: bool = False):
     def fill_neighbours(point: coordinate, segform: set[coordinate]):
         # print(segform)
         fmap[point[0]][point[1]] = not base
         for (x, y) in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
-            if (point not in segform) and fmap[point[0] + x][point[1] + y] == base:
+            if (
+                    0 <= point[0] + x < dim[0] and 0 < point[1] + y <= dim[1] and
+                    (point not in segform) and fmap[point[0] + x][point[1] + y] == base
+            ):
                 fill_neighbours((point[0] + x, point[1] + y), segform)
 
     # print(centers)
@@ -58,10 +61,11 @@ def __init__(self, mappath: str):
         """
         self.map: list[list[bool]] = []  # [x][y]
         self.texture: list[int] | None = None  # Invalid texture is None - debug // list[int] is bytes to print img
-        self.fond: pygame.Surface | None = None
+        self.fond: list[int] | None = None
         self.dimensions: list[int] = [0, 0]
         self.form_borders: list[list[coordinate]] = []
-
+        self.reset_ONMAP_thread: Thread | None = None
+        self.px_update_list: list[int] = []
         # Step 1: Extract vectorial map
 
         """
@@ -154,7 +158,7 @@ def __init__(self, mappath: str):
                             else:
                                 if sp[0] == "empty":
                                     print("load fond")
-                                    self.fond = pygame.image.load(sp[1])
+                                    self.fond = list(pygame.image.tobytes(pygame.image.load(sp[1]), 'ARGB'))
                                 elif sp[0] == "full":
                                     print("load front")
                                     # pygame.image.tobytes returns [y] then [x]
@@ -167,6 +171,7 @@ def __init__(self, mappath: str):
         # print(vectmap)
 
         ### INTERLUDE ###
+        self.TRUEMAP = [[True for y in range(self.dimensions[1])] for x in range(self.dimensions[0])]
         Thread(group=None, target=self.__reset_ONMAP, name=None).start()
         ###           ###
 
@@ -305,7 +310,7 @@ def __init__(self, mappath: str):
                         elif x not in Hdict[y]:
                             self.map[x][y] = inside
 
-        self.__filter_image(0, len(self.texture))
+        self.__filter_image(0, len(self.texture), arbitrary=True)
 
     def clear_map(self):
         """
@@ -328,15 +333,28 @@ def print_map(self, screen):
                 else:
                     screen.set_at((x, y), "black")
 
-    def blit_texture(self, screen):
+    def blit_texture(self, screen, *, all_pxs: bool = False):
         """
         Affiche la map dans le screen
         Utilise les textures internes
         :param screen: Le screen qu'on doit blit dessus
         """
-        screen.blit(self.fond, (0, 0))
-        screen.blit(pygame.image.frombytes(bytes(self.texture), self.dimensions, 'ARGB'), (0, 0))
+        if all_pxs:
+            screen.blit(pygame.image.frombytes(bytes(self.fond), self.dimensions, 'ARGB'), (0, 0))
+            screen.blit(pygame.image.frombytes(bytes(self.texture), self.dimensions, 'ARGB'), (0, 0))
+        else:
+            while len(self.px_update_list) > 0:
+                self.update_px(self.px_update_list.pop(), screen)
+
+    def update_px(self, idx: int, screen) -> None:
+        """
+        Blit the pixel given on screen
+        :param idx: Pixel index in self.texture (should point on Alpha channel)
+        :param screen: The screen to update
+        """
+        screen.set_at(get_point_from_idx(idx), self.fond[idx + 1:idx + 4])
 
+    # @get_time
     def destroy_map(self, impact: coordinate, power: float):
         """
         Destoy the map using an impact point and the power of the weapon
@@ -357,50 +375,78 @@ def destroy_map(self, impact: coordinate, power: float):
         #     show_point(point, does_stop=False, one_pixel=True)
         # show_point(impact, color=(0,0,255))
 
-        algo_peinture(seg_circle, self.ONMAP, [impact], base=True)
+        algo_peinture(seg_circle, self.ONMAP, [impact], self.dimensions, base=True)
 
-        self.map = [
-            [self.map[x][y] and self.ONMAP[x][y] for y in range(len(self.map[x]))] for x in range(len(self.map))
-        ]
+        for x in range(len(self.map)):
+            for y in range(len(self.map[x])):
+                self.map[x][y] = self.map[x][y] and self.ONMAP[x][y]
 
         head = (xmini, ymini)
-        queue = (xmaxi, ymaxi)
-        starter = (head[0]+head[1]*self.dimensions[0])*4
-        goal = (queue[0]+queue[1]*self.dimensions[0])*4
+        # queue = (xmaxi, ymaxi)
+        starter = (head[0] + head[1] * self.dimensions[0]) * 4
+        # goal = (queue[0] + queue[1] * self.dimensions[0]) * 4
         # show_point(head, does_stop=False)
         # show_point(queue)
 
+        while self.reset_ONMAP_thread:
+            pass
+
         Thread(group=None, target=self.__reset_ONMAP, name=None).start()
+
         # self.tt = 0
-        parter = (goal-starter) // MAX_THREAD_BY_CALC
-        print(parter, goal, starter)
-        for i in range(MAX_THREAD_BY_CALC):
-            Thread(group=None, target=self.__filter_image, name=None,
-                   kwargs={'_from': starter + parter * i, '_to': starter + parter * (i + 1)}
-                   ).start()
-
-    def __filter_image(self, _from: int, _to: int):
+        parter = (xmaxi - xmini) * 4
+        # print(parter, goal, starter)
+        launch_dicts = [{'_from': starter + self.dimensions[0] * i * 4,
+                         '_to': starter + parter + self.dimensions[0] * (i + 1) * 4}
+                        for i in range(ymaxi - ymini)]
+        Thread(group=None, target=self.__start_filter_image, name=None, args=launch_dicts).start()
+        # for dlign in launch_dicts:
+        #     self.__filter_image(**dlign)
+
+    # @add_time_incache
+    def __start_filter_image(self, *launch_dict: dict[str, int]) -> None:
+        for dict in launch_dict:
+            self.__filter_image(**dict)
+
+    def __filter_image(self, _from: int, _to: int, *, arbitrary: bool = False) -> None:
         """
         Filter the image to set alpha channel of hidden pixel to 0 and the other pixel to 1
         :param _from: Start processing at px _from (included)
         :param _to: Ends processing at px _to (excluded)
         """
-        print("go from",_from, "to", _to)
+        # print("go from", _from, "to", _to)
         # t1 = time()
         # Make sure we are interacting with images
         assert self.texture != None
+        if arbitrary:
+            for idx in range(_from, _to, 4):  # Catch only alpha channels
+                # print((idx // 4) // self.dimensions[0], (idx // 4) // self.dimensions[1])
+                if self.map[(idx // 4) % self.dimensions[0]][(idx // 4) // self.dimensions[0]]:
+                    self.texture[idx] = 255
+                else:
+                    self.texture[idx] = 0
+        else:
+            for idx in range(_from, _to, 4):  # Catch only alpha channels
+                if (
+                        self.map[(idx // 4) % self.dimensions[0]][(idx // 4) // self.dimensions[0]]
+                        and self.texture[idx] != 255
+                ):
+                    self.texture[idx] = 255
+                    self.px_update_list.append(idx)
+                elif (
+                        not self.map[(idx // 4) % self.dimensions[0]][(idx // 4) // self.dimensions[0]]
+                        and self.texture[idx] != 0
+                ):
+                    self.texture[idx] = 0
+                    self.px_update_list.append(idx)
 
-        for idx in range(_from, _to, 4):  # Catch only alpha channels
-        # print((idx // 4) // self.dimensions[0], (idx // 4) // self.dimensions[1])
-            if self.map[(idx // 4) % self.dimensions[0]][(idx // 4) // self.dimensions[0]]:
-                self.texture[idx] = 255
-            else:
-                self.texture[idx] = 0
         # t2 = time()
         # self.tt += t2 - t1
 
     def __reset_ONMAP(self):
-        self.ONMAP = [[True for y in range(self.dimensions[1])] for x in range(self.dimensions[0])]
+        self.reset_ONMAP_thread = True
+        self.ONMAP = self.TRUEMAP.copy()
+        self.reset_ONMAP_thread = False
 
 
 if __name__ == "__main__":