fix collumns, start facade and clean shitty code

buildings/geometry/Polygon.py

@@ -6,23 +6,23 @@ from buildings.geometry.Rectangle import Rectangle
 from buildings.geometry.Vertice import Vertice
 
 class Polygon:
-    def __init__(self, position : Point, size: tuple[int,int], vertices : list[Vertice] = []):
+    def __init__(self, position : Point, size: tuple[int,int]):
         self.position = position
         self.size = size
-        self.compressed = {"shape":[], "vertices":[]}
-        self.vertices = vertices
+        self.shape = []
+        self.vertices = []
         
     def fill_polygon(self, editor : Editor, material : str, y : int, y2 : int = None):
         if y2 == None: y2 = y
-        for rect in self.compressed["shape"]:
+        for rect in self.shape:
             rect.fill(editor, material, y, y2)
         
     def fill_vertice(self, editor : Editor, material : str, y : int, y2 : int = None):
         if y2 == None: y2 = y
-        for vertice in self.compressed["vertices"]:
+        for vertice in self.vertices:
             vertice.fill(editor, Block(material), y, y2)
 
-    def compress(self, tiles : list[Tile]):
+    def compress(self, tiles : list[Tile], vertices : list[Vertice]):
         remaining_tiles = tiles.copy()
         while len(remaining_tiles) > 0:
             start = remaining_tiles[0]
@@ -43,31 +43,43 @@ class Polygon:
                 start = neightbor            
             
             # Find northern border
-            north_row = self.find_row_border(row.copy(), DIRECTION.NORTH, remaining_tiles) 
+            north_row = self._find_row_border(row.copy(), DIRECTION.NORTH, remaining_tiles) 
             # Find southern border   
-            south_row = self.find_row_border(row.copy(), DIRECTION.SOUTH, remaining_tiles)
+            south_row = self._find_row_border(row.copy(), DIRECTION.SOUTH, remaining_tiles)
             
             area = Rectangle(north_row[0].north_west, south_row[-1].south_east)    
-            self.compressed["shape"].append(area)    
+            self.shape.append(area)    
         
-        remaining_vertices = self.vertices.copy()
+        remaining_vertices = vertices.copy()
         current = remaining_vertices.pop()
         while len(remaining_vertices) > 0:
             neighbors = current.get_neighbors()
-            has_next1 = self.has_next(neighbors[0], current.facing, remaining_vertices)
-            has_next2 = self.has_next(neighbors[1], current.facing, remaining_vertices)
+            has_next1 = self._has_next(neighbors[0], current.facing, remaining_vertices)
+            has_next2 = self._has_next(neighbors[1], current.facing, remaining_vertices)
             
             if has_next1:
                 current = Vertice(has_next1.point1, current.point2, current.facing)
             elif has_next2:
                 current = Vertice(current.point1, has_next2.point2, current.facing)
             else:
-                self.compressed["vertices"].append(current)
+                self.vertices.append(current)
                 current = remaining_vertices.pop()
             
-            if len(remaining_vertices) == 0: self.compressed["vertices"].append(current)     
+            if len(remaining_vertices) == 0: self.vertices.append(current)     
                     
-    def find_row_border(self, line : list[Tile], direction : str, remaining_tiles : list[Tile]) -> list[Tile]:
+    def set_vertices_and_neighbors(self, tiles : list[Tile], vertices : list[Vertice]):
+        for tile in tiles:
+            targets = tile.get_neighbors_coords()
+            for vertice_num,target in enumerate(targets):
+                has_neighbor = self._has_neighbor(target, tiles)
+                if not has_neighbor:
+                    vertice = tile.get_vertice(vertice_num)
+                    vertices.append(vertice)
+                    tile.set_vertice(DIRECTION(vertice_num), vertice)
+                else :
+                    tile.set_neighbor(vertice_num, has_neighbor)
+    
+    def _find_row_border(self, line : list[Tile], direction : str, remaining_tiles : list[Tile]) -> list[Tile]:
         while True:
             new_line = []
             for tile in line:
@@ -76,24 +88,14 @@ class Polygon:
                 new_line.append(neightbor)
             for tile in new_line: remaining_tiles.remove(tile)
             line = new_line
-
-    def set_vertices_and_neighbors(self, tiles : list[Tile]):
-        for tile in tiles:
-            targets = tile.get_neighbors_coords()
-            for vertice_num,target in enumerate(targets):
-                has_neighbor = self.has_neighbor(target, tiles)
-                if not has_neighbor:
-                    self.vertices.append(tile.get_vertice(vertice_num))
-                else :
-                    tile.set_neighbor(vertice_num, has_neighbor)
     
-    def has_neighbor(self, target : tuple[int], tiles : list[Tile]) -> bool|Tile:
+    def _has_neighbor(self, target : tuple[int], tiles : list[Tile]) -> bool|Tile:
         for tile in tiles:
             if tile.pos.position == target.position:
                 return tile
         return False
     
-    def has_next(self, target : Point, facing : str, remaining_vertices : list[Vertice]) -> bool|Vertice:
+    def _has_next(self, target : Point, facing : str, remaining_vertices : list[Vertice]) -> bool|Vertice:
         for vertice in remaining_vertices:
             if vertice.facing == facing:
                 if vertice.point1.position == target.position or vertice.point2.position == target.position: