Persson-dev/GDMC-2024
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix collumns, start facade and clean shitty code

Browse Source
This commit is contained in:
KAymeric
2024-05-11 11:21:24 +02:00
parent 1da68576f4
commit 235d9be35d
10 changed files with 231 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
buildings/geometry/Polygon.py
View File

@@ -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:

60
buildings/geometry/Tile.py
View File

@@ -7,17 +7,26 @@ class Tile:
def __init__(self, size : int, position : tuple[int, int]):
self.size = size
x,z = position
self.pos = Point(x = x, z = z)
leng = self.size-1
self.pos = Point(x = x, z = z)
self.has_vertice = False
self.north_west = self.pos
self.north_east = Point(x = self.pos.x + leng, z =self.pos.z)
self.south_west = Point(x = self.pos.x, z = self.pos.z + leng)
self.south_east = Point(x = self.pos.x + leng, z = self.pos.z + leng)
self.west_neighbor = None
self.east_neighbor = None
self.north_neighbor = None
self.south_neighbor = None
self.west_vertice = None
self.east_vertice = None
self.north_vertice = None
self.south_vertice = None
def fill(self, editor : Editor, material : str, y : int, y2 : int = None) -> list[Point]:
if y2 == None: y2 = y
geometry.placeCuboid(editor, (self.pos.x, y, self.pos.z), (self.pos.x+self.size-1, y2, self.pos.z+self.size-1), Block(material))
@@ -28,18 +37,6 @@ class Tile:
Point(x = self.pos.x, z = self.pos.z - self.size), # north
Point(x = self.pos.x, z = self.pos.z + self.size)] # south
def get_vertice(self,vertice : int) -> Vertice:
# gives the corresponding vertice :
# 0 = west, 1 = east, 2 = north, 3 = south
match(vertice):
case 0 :
return Vertice(self.north_west, self.south_west, DIRECTION.WEST)
case 1 :
return Vertice(self.north_east, self.south_east, DIRECTION.EAST)
case 2 :
return Vertice(self.north_west, self.north_east, DIRECTION.NORTH)
case 3 :
return Vertice(self.south_west, self.south_east, DIRECTION.SOUTH)
def get_neighbor(self, direction) -> Point:
match(direction):
@@ -52,7 +49,7 @@ class Tile:
case DIRECTION.SOUTH:
return self.south_neighbor
def set_neighbor(self, direction, neighbor : Point):
def set_neighbor(self, direction, neighbor : 'Tile'):
match(direction):
case DIRECTION.WEST:
self.west_neighbor = neighbor
@@ -61,4 +58,37 @@ class Tile:
case DIRECTION.NORTH:
self.north_neighbor = neighbor
case DIRECTION.SOUTH:
self.south_neighbor = neighbor
self.south_neighbor = neighbor
def get_vertice(self,vertice : int|DIRECTION) -> Vertice:
# gives the corresponding vertice :
# 0 = west, 1 = east, 2 = north, 3 = south
match(vertice):
case 0 :
return Vertice(self.north_west, self.south_west, DIRECTION.WEST)
case 1 :
return Vertice(self.north_east, self.south_east, DIRECTION.EAST)
case 2 :
return Vertice(self.north_west, self.north_east, DIRECTION.NORTH)
case 3 :
return Vertice(self.south_west, self.south_east, DIRECTION.SOUTH)
case DIRECTION.WEST :
return self.west_vertice
case DIRECTION.EAST :
return self.east_vertice
case DIRECTION.NORTH :
return self.north_vertice
case DIRECTION.SOUTH :
return self.south_vertice
def set_vertice(self, direction : DIRECTION, vertice : Vertice):
self.has_vertice = True
match(direction):
case DIRECTION.WEST :
self.west_vertice = vertice
case DIRECTION.EAST :
self.east_vertice = vertice
case DIRECTION.NORTH :
self.north_vertice = vertice
case DIRECTION.SOUTH :
self.south_vertice = vertice

3
buildings/geometry/Vertice.py
View File

@@ -15,4 +15,7 @@ class Vertice(Rectangle):
case DIRECTION.EAST | DIRECTION.WEST:
return [Point(x = self.point1.x, z = self.point1.z - 1),
Point(x = self.point2.x, z = self.point2.z + 1)]
def get_size(self):
return self.point2.x - self.point1.x + self.point2.z - self.point1.z