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

دمج فرع التتبع عن بعد "المنبع/الرئيسي" في الملف الرئيسي

Browse Source
This commit is contained in:
AKreuzer
2024-06-15 23:01:59 +02:00
parent 74939422e7 8093c0ede4
commit 863f8b1699
25 changed files with 1468 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

925
House.py Normal file
View File

@@ -0,0 +1,925 @@
from time import sleep
from gdpc import Editor, Block, geometry
import numpy as np
import math
import matplotlib.pyplot as plt
class House:
def __init__(self, editor, coordinates_min, coordinates_max, direction, list_block):
self.editor = editor
self.coordinates_min = coordinates_min
self.coordinates_max = coordinates_max
self.skeleton = []
size = [(coordinates_max[i] - coordinates_min[i]) + 10 for i in range(3)]
self.grid3d = np.zeros(size, dtype=[('bool', bool), ('int', int)])
self.nbEtage = (coordinates_max[1] - coordinates_min[1]) // 5
self.direction = direction
self.entranceWall = None
self.blocks = list_block
self.entranceCo = None
self.wall = Block(list_block["wall"])
self.roof = Block(list_block["roof"])
self.roof_slab = Block(list_block["roof_slab"])
self.door = Block(list_block["door"])
self.window = Block(list_block["window"])
self.entrance = Block(list_block["entrance"])
self.stairs = Block(list_block["stairs"])
self.celling = Block(list_block["celling"])
self.floor = Block(list_block["floor"])
self.celling_slab = Block(list_block["celling_slab"])
self.gardenOutline = Block(list_block["garden_outline"])
self.garden_floor = Block(list_block["garden_floor"])
def createHouseSkeleton(self):
self.delete()
x_min, y_min, z_min = self.coordinates_min
x_max, y_max, z_max = self.coordinates_max
perimeter_width = x_max - x_min
perimeter_depth = z_max - z_min
x_min += 1
z_min += 1
x_max -= 1
z_max -= 1
x = np.random.randint(x_min+1 , x_max-1)
z = np.random.randint(z_min+1 , z_max-1 )
width = perimeter_width // 2
depth = perimeter_depth // 2
height = y_max - y_min
if x + width-1 > x_max-1:
x = x_max - width-1
if z + depth-1 > z_max-1:
z = z_max - depth-1
x_plan3d = x - x_min
z_plan3d = z - z_min
for i in range(0, width-1):
for j in range(0, depth-1):
self.editor.placeBlock((x + i, y_min, z + j), self.floor)
self.grid3d[x_plan3d+i,0,z_plan3d+j] = True,1
self.skeleton.append((x, z, width-1, depth-1, height))
print("Coordinates of the corners: ", (x, z), (x, z+depth-1), (x+width-1, z), (x+width-1, z+depth-1))
x_min -= 1
x_max -= 1
z_min += 1
z_max += 1
for _ in range(3):
print("Rectangle n°", _+1, "en cours de création")
for a in range(100000):
new_width = np.random.randint(5, width-2)
new_depth = np.random.randint(5, depth-2)
new_x = np.random.randint(max(x_min+1, x - new_width ), min(x_max-new_width - 1, x + width ))
new_z = np.random.randint(max(z_min+1, z - new_depth), min(z_max-new_depth - 1, z + depth ))
new_x_plan3d = new_x - x_min -1
new_z_plan3d = new_z - z_min +1
adjacent_blocks = 0
for i in range(new_x_plan3d, new_x_plan3d + new_width):
for j in range(new_z_plan3d, new_z_plan3d + new_depth):
if self.grid3d[i-1,0,j]['bool'] and self.grid3d[i-1,0,j]['int']==1 or self.grid3d[i+1,0,j]['bool'] and self.grid3d[i+1,0,j]['int']==1 or self.grid3d[i,0,j-1]['bool'] and self.grid3d[i,0,j-1]['int']==1 or self.grid3d[i,0,j+1]['bool'] and self.grid3d[i,0,j+1]['int']==1:
adjacent_blocks += 1
if adjacent_blocks < 3:
continue
if not np.any(self.grid3d[new_x_plan3d:new_x_plan3d+new_width,0, new_z_plan3d:new_z_plan3d+new_depth]['bool']):
new_x_plan3d = new_x - x_min
new_z_plan3d = new_z - z_min
for i in range(0, new_width):
for j in range(0, new_depth):
self.grid3d[new_x_plan3d + i,0, new_z_plan3d + j] = True,2
if i == 0 or i == new_width-1 or j == 0 or j == new_depth-1:
continue
else:
self.editor.placeBlock((new_x + i, y_min, new_z + j), self.floor)
self.skeleton.append((new_x, new_z, new_width, new_depth, height))
break
else:
print("Failed to place rectangle after 1000 attempts.")
def delete(self):
for x in range(self.coordinates_min[0], self.coordinates_max[0]):
for y in range(self.coordinates_min[1], self.coordinates_max[1]+10):
for z in range(self.coordinates_min[2], self.coordinates_max[2]):
self.editor.placeBlock((x, y, z), Block("air"))
def putWallOnSkeleton(self):
for k in range(len(self.skeleton)):
x, z, width, depth, height = self.skeleton[k]
if k!= 0:
x+=1
z+=1
width-=2
depth-=2
x_plan3d = x - self.coordinates_min[0]
z_plan3d = z - self.coordinates_min[2]
for i in range(-1, width+1):
for j in range(-1, depth+1):
for y in range(0, height):
if i == -1 or i == width or j == -1 or j == depth:
if not (self.grid3d[x_plan3d + i,y, z_plan3d + j]['bool']) and not (self.grid3d[x_plan3d + i,y, z_plan3d + j]['int'] == 1) or (self.grid3d[x_plan3d + i,y, z_plan3d + j]['bool'] and self.grid3d[x_plan3d + i,y, z_plan3d + j]['int'] == 2) or y==0:
self.editor.placeBlock((x + i, self.coordinates_min[1] + y, z + j), self.wall)
self.grid3d[ x_plan3d+i, y, z_plan3d+j] = True
def getAdjacentWalls(self):
main_rect = self.skeleton[0]
x_main, z_main, width_main, depth_main, heigt_main = main_rect
adjacent_walls = []
width_main-=1
depth_main-=1
for k in range(1, len(self.skeleton)):
x, z, width, depth, heigt = self.skeleton[k]
walls = [(x, z, x + width-1, z), (x, z, x, z + depth-1), (x, z + depth-1, x + width-1, z + depth-1), (x + width-1, z, x + width-1, z + depth-1)]
for wall in walls:
x1, z1, x2, z2 = wall
if (x_main <= x1 <= x_main + width_main or x_main <= x2 <= x_main + width_main) and (z_main - 1 == z1 or z_main + depth_main + 1 == z1):
x1 = max(x1, x_main-1)
x2 = min(x2, x_main + width_main+1)
if abs(x2 - x1) > 1:
adjacent_walls.append((x1, z1, x2, z2))
elif (z_main <= z1 <= z_main + depth_main or z_main <= z2 <= z_main + depth_main) and (x_main - 1 == x1 or x_main + width_main + 1 == x1):
z1 = max(z1, z_main-1)
z2 = min(z2, z_main + depth_main+1)
if abs(z2 - z1) > 1:
adjacent_walls.append((x1, z1, x2, z2))
return adjacent_walls
def placeDoor(self):
walls = self.getAdjacentWalls()
for wall in walls:
for i in range(self.nbEtage):
x_min, z_min, x_max, z_max = wall
if x_min == x_max:
width = z_max - z_min
if width % 2 != 0:
door_pos = width // 2
for y in range(self.coordinates_min[1]+1+i*4, self.coordinates_min[1]+3+i*4):
self.editor.placeBlock((x_min, y, z_min + door_pos), Block("air"))
self.editor.placeBlock((x_min, y, z_min + door_pos+1), Block("air"))
else:
door_pos = width // 2
for y in range(self.coordinates_min[1]+1+i*4 , self.coordinates_min[1]+3+i*4):
self.editor.placeBlock((x_min, y, z_min + door_pos), Block("air"))
else:
width = x_max - x_min
if width % 2 != 0:
door_pos = width // 2
for y in range(self.coordinates_min[1]+1+i*4, self.coordinates_min[1]+3+i*4):
self.editor.placeBlock((x_min + door_pos, y, z_min), Block("air"))
self.editor.placeBlock((x_min + door_pos+1, y, z_min), Block("air"))
else:
door_pos = width // 2
for y in range(self.coordinates_min[1]+1+i*4, self.coordinates_min[1]+3+i*4):
self.editor.placeBlock((x_min + door_pos, y, z_min), Block("air"))
def placeRoof(self):
for k in range(len(self.skeleton)-1, -1, -1):
x, z, width, depth, height = self.skeleton[k]
if k!= 0:
x+=1
z+=1
width-=2
depth-=2
if width < depth:
if width <=5:
n = 1
elif width <=10:
n = 2
else:
n = 3
else:
if depth <=5:
n = 1
elif depth <=10:
n = 2
else:
n = 3
else:
if width < depth:
n = width // 4
else:
n = depth // 4
x_plan3d = x - self.coordinates_min[0]
z_plan3d = z - self.coordinates_min[2]
print(width, depth, n)
if width < depth:
if n>1:
for k in range(n-1):
for i in range(-1, depth+1):
for y in range(-1, width//2+1):
self.editor.placeBlock((x + i, self.coordinates_max[1]+k, z+y+k+3), self.roof)
self.editor.placeBlock((x + i, self.coordinates_max[1]+k, z+depth-y-4-k), self.roof)
if width%2 == 0:
for i in range(-1, depth+1):
self.editor.placeBlock((x+width//2+1, self.coordinates_max[1]+n-1, z+i), self.roof)
for i in range(-1,depth+1):
self.editor.placeBlock((x+width//2, self.coordinates_max[1]+n-1, z+i), self.roof)
else:
if n>1:
for k in range(n-1):
for i in range(-1, width+1):
for y in range(-1, depth//2+1):
self.editor.placeBlock((x + i, self.coordinates_max[1]+k, z+y+k+2), self.roof)
self.editor.placeBlock((x + i, self.coordinates_max[1]+k, z+depth-y-3-k), self.roof)
if depth%2 == 0:
for i in range(-1, width+1):
self.editor.placeBlock((x+i, self.coordinates_max[1]+n-1, z+depth//2+1), self.roof)
for i in range(-1,width+1):
self.editor.placeBlock((x+i, self.coordinates_max[1]+n-1, z+depth//2), self.roof)
print('-----------------------------------')
for i in range(-1, width+1):
for j in range(-1, depth+1):
if width<depth:
if width%2 != 0:
if (i == width//2 ):
self.editor.placeBlock((x + i, self.coordinates_max[1]+n, z + j), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.grid3d[ x_plan3d+i, height+n, z_plan3d+j] = True
if j== -1 :
if not self.grid3d[ x_plan3d+i, height+n, z_plan3d+j-1]:
self.editor.placeBlock((x + i, self.coordinates_max[1]+n, z + j-1), Block(self.blocks["celling_slab"],{"type":"bottom"}))
self.grid3d[ x_plan3d+i, height+n, z_plan3d+j-1] = True
if not self.grid3d[ x_plan3d+i, height+n-1, z_plan3d+j-1]:
self.editor.placeBlock((x + i, self.coordinates_max[1]+n-1, z + j-1), Block(self.blocks["celling_slab"],{"type":"top"}))
self.grid3d[ x_plan3d+i, height+n-1, z_plan3d+j-1] = True
elif j == depth:
if not self.grid3d[ x_plan3d+i, height+n, z_plan3d+j+1]:
self.editor.placeBlock((x + i, self.coordinates_max[1]+n, z + j+1), Block(self.blocks["celling_slab"],{"type":"bottom"}))
self.grid3d[ x_plan3d+i, height+n, z_plan3d+j+1] = True
if not self.grid3d[ x_plan3d+i, height+n-1, z_plan3d+j+1]:
self.editor.placeBlock((x + i, self.coordinates_max[1]+n-1, z + j+1), Block(self.blocks["celling_slab"],{"type":"top"}))
self.grid3d[ x_plan3d+i, height+n-1, z_plan3d+j+1] = True
else:
if depth%2 != 0:
if (j == depth//2 ):
self.editor.placeBlock((x + i, self.coordinates_max[1]+n, z + j), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.grid3d[ x_plan3d+i, height+n, z_plan3d+j] = True
if i== -1 :
if not self.grid3d[ x_plan3d+i-1, height+n, z_plan3d+j]:
self.editor.placeBlock((x + i-1, self.coordinates_max[1]+n, z + j), Block(self.blocks["celling_slab"],{"type":"bottom"}))
self.grid3d[ x_plan3d+i-1, height+n, z_plan3d+j] = True
if not self.grid3d[ x_plan3d+i-1, height+n-1, z_plan3d+j]:
self.editor.placeBlock((x + i-1, self.coordinates_max[1]+n-1, z + j), Block(self.blocks["celling_slab"],{"type":"top"}))
self.grid3d[ x_plan3d+i-1, height+n-1, z_plan3d+j] = True
elif i == width:
if not self.grid3d[ x_plan3d+i+1, height+n, z_plan3d+j]:
self.editor.placeBlock((x + i+1, self.coordinates_max[1]+n, z + j), Block(self.blocks["celling_slab"],{"type":"bottom"}))
self.grid3d[ x_plan3d+i+1, height+n, z_plan3d+j] = True
if not self.grid3d[ x_plan3d+i+1, height+n-1, z_plan3d+j]:
self.editor.placeBlock((x + i+1, self.coordinates_max[1]+n-1, z + j), Block(self.blocks["celling_slab"],{"type":"top"}))
self.grid3d[ x_plan3d+i+1, height+n-1, z_plan3d+j] = True
if width<depth:
h = 0
for i in range(-1, width//2):
for j in range(-1, depth+1):
if i != -1:
if h % 1 == 0:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j), Block(self.blocks["roof_slab"],{"type":"top"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j), Block(self.blocks["roof_slab"],{"type":"top"}))
self.grid3d[ x_plan3d+ i, round(height+h), z_plan3d+ j] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h), z_plan3d+ j] = True
if j == -1 :
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j -1), self.celling)
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j -1), self.celling)
self.grid3d[ x_plan3d+ i, round(height+h), z_plan3d+ j-1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h), z_plan3d+ j-1] = True
elif j == depth:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j +1), self.celling)
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j +1), self.celling)
self.grid3d[ x_plan3d+ i, round(height+h), z_plan3d+ j+1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h), z_plan3d+ j+1] = True
else:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.editor.placeBlock((x + i, self.coordinates_max[1]+h-0.5, z + j), self.roof)
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h-0.5, z + j), self.roof)
self.grid3d[ x_plan3d+ i, round(height+h+0.5), z_plan3d+ j] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h+0.5), z_plan3d+ j] = True
self.grid3d[ x_plan3d+ i, round(height+h-0.5), z_plan3d+ j] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h-0.5), z_plan3d+ j] = True
if j == -1 :
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j -1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j -1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + i, self.coordinates_max[1]+h-1, z + j -1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h-1, z + j -1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ x_plan3d+ i, round(height+h-1), z_plan3d+ j-1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h-1), z_plan3d+ j-1] = True
self.grid3d[ x_plan3d+ i, round(height+h), z_plan3d+ j-1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h), z_plan3d+ j-1] = True
elif j == depth:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j +1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j +1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + i, self.coordinates_max[1]+h-1, z + j +1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h-1, z + j +1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ x_plan3d+ i, round(height+h-1), z_plan3d+ j+1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h-1), z_plan3d+ j+1] = True
self.grid3d[ x_plan3d+ i, round(height+h), z_plan3d+ j+1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h), z_plan3d+ j+1] = True
else:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.grid3d[ x_plan3d+ i, round(height+h), z_plan3d+ j] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h), z_plan3d+ j] = True
if j == -1 :
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j -1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j -1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
if not self.grid3d[ x_plan3d+i, height+h-1, z_plan3d+j-1]:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h-1, z + j -1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ x_plan3d+i, height+h-1, z_plan3d+j-1] = True
if not self.grid3d[ x_plan3d+width-1-i, height+h-1, z_plan3d+j-1]:
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h-1, z + j -1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ x_plan3d+width-1-i, height+h-1, z_plan3d+j-1] = True
self.grid3d[ x_plan3d+ i, round(height+h-1), z_plan3d+ j-1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h-1), z_plan3d+ j-1] = True
elif j == depth:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h, z + j +1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h, z + j +1), Block(self.blocks["celling_slab"], {"type": "bottom"}))
if not self.grid3d[ x_plan3d+i, height+h-1, z_plan3d+j+1]:
self.editor.placeBlock((x + i, self.coordinates_max[1]+h-1, z + j +1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ x_plan3d+i, height+h-1, z_plan3d+j+1] = True
if not self.grid3d[ x_plan3d+width-1-i, height+h-1, z_plan3d+j+1]:
self.editor.placeBlock((x + width-1-i, self.coordinates_max[1]+h-1, z + j +1), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ x_plan3d+width-1-i, height+h-1, z_plan3d+j+1] = True
self.grid3d[ x_plan3d+ i, round(height+h-1), z_plan3d+ j+1] = True
self.grid3d[ x_plan3d+ width-1-i, round(height+h-1), z_plan3d+ j+1] = True
if i != -1:
h += 0.5
else:
h = 0
for i in range(-1, depth//2):
for j in range(-1, width+1):
if i != -1:
if h % 1 == 0:
self.editor.placeBlock((x + j, self.coordinates_max[1]+h, z + i), Block(self.blocks["roof_slab"],{"type":"top"}))
self.editor.placeBlock((x + j, self.coordinates_max[1]+h, z + depth-1-i), Block(self.blocks["roof_slab"],{"type":"top"}))
self.grid3d[ x_plan3d+j, round(height+h), z_plan3d+ i] = True
self.grid3d[ x_plan3d+j, round(height+h), z_plan3d+ depth-1-i] = True
if j == -1 :
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h, z + i ), self.celling)
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h, z + depth-1-i ), self.celling)
self.grid3d[ x_plan3d+j-1, round(height+h), z_plan3d+ i] = True
self.grid3d[ x_plan3d+j-1, round(height+h), z_plan3d+ depth-1-i] = True
elif j == width:
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h, z + i ), self.celling)
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h, z + depth-1-i ), self.celling)
self.grid3d[ x_plan3d+j+1, round(height+h), z_plan3d+ i] = True
self.grid3d[ x_plan3d+j+1, round(height+h), z_plan3d+ depth-1-i] = True
else:
self.editor.placeBlock((x + j, self.coordinates_max[1]+h, z + i), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.editor.placeBlock((x + j, self.coordinates_max[1]+h, z + depth-1-i), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.editor.placeBlock((x + j, self.coordinates_max[1]+h-0.5, z + i), self.roof)
self.editor.placeBlock((x + j, self.coordinates_max[1]+h-0.5, z + depth-1-i), self.roof)
self.grid3d[ j, round(height+h+0.5), i] = True
self.grid3d[ j, round(height+h+0.5), depth-1-i] = True
self.grid3d[ j, round(height+h-0.5), i] = True
self.grid3d[ j, round(height+h-0.5), depth-1-i] = True
if j == -1 :
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h, z + i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h-1, z + i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h-1, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ j, round(height+h), i] = True
self.grid3d[ j, round(height+h), depth-1-i] = True
self.grid3d[ j, round(height+h-1), i] = True
self.grid3d[ j, round(height+h-1), depth-1-i] = True
elif j == width:
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h, z + i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h-1, z + i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h-1, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ j, round(height+h), i] = True
self.grid3d[ j, round(height+h), depth-1-i] = True
self.grid3d[ j, round(height+h-1), i] = True
self.grid3d[ j, round(height+h-1), depth-1-i] = True
else:
self.editor.placeBlock((x + j, self.coordinates_max[1]+h, z + i), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.editor.placeBlock((x + j, self.coordinates_max[1]+h, z + depth-1-i), Block(self.blocks["roof_slab"],{"type":"bottom"}))
self.grid3d[ j, round(height+h), i] = True
self.grid3d[ j, round(height+h), depth-1-i] = True
if j == -1 :
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h, z + i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
if not self.grid3d[ j, height+h-1, i]:
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h-1, z + i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ j, height+h-1, i] = True
if not self.grid3d[ j, height+h-1, depth-1-i]:
self.editor.placeBlock((x + j -1, self.coordinates_max[1]+h-1, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ j, height+h-1, depth-1-i] = True
self.grid3d[ j, round(height+h), i] = True
self.grid3d[ j, round(height+h), depth-1-i] = True
elif j == width:
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h, z + i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "bottom"}))
if not self.grid3d[ j, height+h-1, i]:
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h-1, z + i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ j, height+h-1, i] = True
if not self.grid3d[ j, height+h-1, depth-1-i]:
self.editor.placeBlock((x + j +1, self.coordinates_max[1]+h-1, z + depth-1-i ), Block(self.blocks["celling_slab"], {"type": "top"}))
self.grid3d[ j, height+h-1, depth-1-i] = True
self.grid3d[ j, round(height+h), i] = True
self.grid3d[ j, round(height+h), depth-1-i] = True
self.grid3d[ j, round(height+h), i] = True
self.grid3d[ j, round(height+h), depth-1-i] = True
if i != -1:
h += 0.5
QUARTZ_SLAB = Block(self.blocks["celling_slab"], {"type": "top"})
for i in range(-2, width+2):
for j in range(-2, depth+2):
if i == -2 or i == width+1 or j == -2 or j == depth+1:
if not self.grid3d[x_plan3d+i, height-1, z_plan3d+j]['bool']:
if width<depth:
if i == -2 or i == width+1:
self.editor.placeBlock((x + i, self.coordinates_max[1]-1, z + j), QUARTZ_SLAB)
else:
if j == -2 or j == depth+1:
self.editor.placeBlock((x + i, self.coordinates_max[1]-1, z + j), QUARTZ_SLAB)
def putCelling(self):
for k in range(0, len(self.skeleton)):
x, z, width, depth, height = self.skeleton[k]
if k!= 0:
x+=1
z+=1
width-=2
depth-=2
x_plan3d = x - self.coordinates_min[0]
z_plan3d = z - self.coordinates_min[2]
for y in range(1,self.nbEtage+1):
for i in range(0, width):
for j in range(0, depth):
self.editor.placeBlock((x + i, self.coordinates_min[1] +4*y, z + j), self.celling)
self.grid3d[ x_plan3d+i, 4*y, z_plan3d+j] = True
def getAllExterneWalls(self):
walls = []
adjacent_walls = self.getAdjacentWalls()
for k in range(0, len(self.skeleton)):
x, z, width, depth, height = self.skeleton[k]
if k == 0:
x -= 1
z -= 1
width += 2
depth += 2
walls.append((x, z, x + width - 1, z))
walls.append((x, z, x, z + depth - 1))
walls.append((x, z + depth - 1, x + width - 1, z + depth - 1))
walls.append((x + width - 1, z, x + width - 1, z + depth - 1))
walls_to_keep = []
for wall in walls:
remove_wall = False
for adj_wall in adjacent_walls:
if self.isInsideWall(wall, adj_wall):
remove_wall = True
break
if not remove_wall:
walls_to_keep.append(wall)
return walls_to_keep
def isInsideWall(self, big_wall, small_wall):
x1, z1, x2, z2 = big_wall
x3, z3, x4, z4 = small_wall
if x1 == x2 == x3 == x4:
return x1 == x3 and z1 <= z3 and z4 <= z2
elif z1 == z2 == z3 == z4:
return z1 == z3 and x1 <= x3 and x4 <= x2
def placeWindowOnWall(self,wall,axis, is_x):
for l in range(self.nbEtage):
if axis%2==0:
if axis == 4:
if is_x:
self.editor.placeBlock((wall[0]+2, self.coordinates_min[1] + 2+l*4, wall[1]), self.window)
self.editor.placeBlock((wall[0]+3, self.coordinates_min[1] + 2+l*4, wall[1]), self.window)
else:
self.editor.placeBlock((wall[0], self.coordinates_min[1] + 2+l*4, wall[1]+3), self.window)
self.editor.placeBlock((wall[0], self.coordinates_min[1] + 2+l*4, wall[1]+2), self.window)
else:
for i in range(0, math.ceil(axis/4)):
if is_x:
self.editor.placeBlock((wall[0]+1+i*4, self.coordinates_min[1] + 2+l*4, wall[1]), self.window)
self.editor.placeBlock((wall[0]+2+i*4, self.coordinates_min[1] + 2+l*4, wall[1]), self.window)
else:
self.editor.placeBlock((wall[0], self.coordinates_min[1] + 2+l*4, wall[1]+1+i*4), self.window)
self.editor.placeBlock((wall[0], self.coordinates_min[1] + 2+l*4, wall[1]+2+i*4), self.window)
else:
if axis<=5:
for i in range(0, axis):
if is_x:
self.editor.placeBlock((wall[0]+1+i, self.coordinates_min[1] + 2+l*4, wall[1]), self.window)
else:
self.editor.placeBlock((wall[0], self.coordinates_min[1] + 2+l*4, wall[1]+1+i), self.window)
else:
for i in range(0, math.ceil(axis/2)):
if is_x:
self.editor.placeBlock((wall[0]+i*2+1, self.coordinates_min[1] + 2+l*4, wall[1]), self.window)
else:
self.editor.placeBlock((wall[0], self.coordinates_min[1] + 2+l*4, wall[1]+i*2+1), self.window)
def placeWindow(self):
walls = self.getAllExterneWalls()
for wall in walls:
x1, z1, x2, z2 = wall
x = abs(x2-x1) -1
z = abs(z2-z1) -1
if x1 == x2:
self.placeWindowOnWall(wall, z, False)
elif z1 == z2:
self.placeWindowOnWall(wall, x, True)
def placeStairs(self):
x, z, width, depth, height = self.skeleton[0]
x_moy = x + width//2
z_moy = z + depth//2
slab_up = Block(self.blocks["stairs_slab"], { "type": "top"})
slab_down = Block(self.blocks["stairs_slab"], { "type": "bottom"})
for i in range(0, self.nbEtage-1):
for k in range(3):
for l in range(3):
self.editor.placeBlock((x_moy-1+k, self.coordinates_min[1] + 4*(i+1), z_moy-1+l),Block("air"))
for j in range(1, 5):
self.editor.placeBlock((x_moy, self.coordinates_min[1] + 4*i+j, z_moy), self.floor)
self.editor.placeBlock((x_moy-1, self.coordinates_min[1] +1+ 4*i, z_moy-1), slab_down)
self.editor.placeBlock((x_moy, self.coordinates_min[1] +1+ 4*i, z_moy-1), slab_up)
self.editor.placeBlock((x_moy+1, self.coordinates_min[1] +2+ 4*i, z_moy-1), slab_down)
self.editor.placeBlock((x_moy+1, self.coordinates_min[1] +2+ 4*i, z_moy), slab_up)
self.editor.placeBlock((x_moy+1, self.coordinates_min[1] +3+ 4*i, z_moy+1), slab_down)
self.editor.placeBlock((x_moy, self.coordinates_min[1] +3+ 4*i, z_moy+1), slab_up)
self.editor.placeBlock((x_moy-1, self.coordinates_min[1] +4+ 4*i, z_moy+1), slab_down)
self.editor.placeBlock((x_moy-1, self.coordinates_min[1] +4+ 4*i, z_moy), slab_up)
def WallFacingDirection(self):
if self.direction == "N":
closest_wall = min(self.skeleton, key=lambda wall: wall[1])
wall = (closest_wall[0], closest_wall[1], closest_wall[0] + closest_wall[2], closest_wall[1])
elif self.direction == "S":
closest_wall = max(self.skeleton, key=lambda wall: wall[1] + wall[3])
wall = (closest_wall[0], closest_wall[1] + closest_wall[3], closest_wall[0] + closest_wall[2], closest_wall[1] + closest_wall[3])
elif self.direction == "E":
closest_wall = max(self.skeleton, key=lambda wall: wall[0] + wall[2])
wall = (closest_wall[0] + closest_wall[2], closest_wall[1], closest_wall[0] + closest_wall[2], closest_wall[1] + closest_wall[3])
elif self.direction == "W":
closest_wall = min(self.skeleton, key=lambda wall: wall[0])
wall = (closest_wall[0], closest_wall[1], closest_wall[0], closest_wall[1] + closest_wall[3])
else:
return []
if closest_wall != self.skeleton[0]:
if wall[0] == wall[2]:
wall = (wall[0]-1, wall[1]+1, wall[2]-1, wall[3]-2)
elif wall[1] == wall[3]:
wall = (wall[0]+1, wall[1]-1, wall[2]-2, wall[3]-1)
else:
if wall[0] == wall[2]:
if self.direction == "W":
wall = (wall[0]-2, wall[1], wall[2]-2, wall[3])
else:
wall = (wall[0], wall[1]+1, wall[2], wall[3]-2)
elif wall[1] == wall[3]:
if self.direction == "N":
wall = (wall[0]+1, wall[1]-2, wall[2]-2, wall[3]-2)
else:
wall = (wall[0]+1, wall[1], wall[2]-2, wall[3])
return wall
def placeEntrance(self):
wall = self.WallFacingDirection()
print(wall)
self.entranceWall = wall
match self.direction:
case "W":
if (wall[3] - wall[1]) % 2 != 0:
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+1, (wall[1] + wall[3]) // 2 +1), Block("air"))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+2, (wall[1] + wall[3]) // 2 +1), Block("air"))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+1, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+2, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0], self.coordinates_min[1], (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "east"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1], (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "east"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1], (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1], (wall[1] + wall[3]) // 2 +2), Block(self.blocks["stairs"], {"facing": "north"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "east", "half": "top"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "east", "half": "top"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south", "half": "top"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 +2), Block(self.blocks["stairs"], {"facing": "north", "half": "top"}))
self.entranceCo = ((wall[1] + wall[3]) // 2, (wall[1] + wall[3]) // 2 +2, (wall[1] + wall[3]) // 2 +1, (wall[1] + wall[3]) // 2 -1)
else:
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+1, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+2, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0], self.coordinates_min[1], (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "east"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1], (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "north"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1], (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "east", "half": "top"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "north", "half": "top"}))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south", "half": "top"}))
self.entranceCo = ((wall[1] + wall[3] )// 2, (wall[1] + wall[3]) // 2 +1, (wall[1] + wall[3]) // 2 +1, (wall[1] + wall[3]) // 2 -1)
case "N":
if (wall[2] - wall[0]) % 2 != 0:
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+1, wall[1]+1), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+2, wall[1]+1), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+1, wall[1]+1), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+2, wall[1]+1), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1], wall[1]), Block(self.blocks["stairs"], {"facing": "south"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1], wall[1]), Block(self.blocks["stairs"], {"facing": "south"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1], wall[1]), Block(self.blocks["stairs"], {"facing": "east"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +2, self.coordinates_min[1], wall[1]), Block(self.blocks["stairs"], {"facing": "west"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+3, wall[1]), Block(self.blocks["stairs"], {"facing": "south", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+3, wall[1]), Block(self.blocks["stairs"], {"facing": "south", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1]+3, wall[1]), Block(self.blocks["stairs"], {"facing": "east", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +2, self.coordinates_min[1]+3, wall[1]), Block(self.blocks["stairs"], {"facing": "west", "half": "top"}))
self.entranceCo = (wall[0] + (wall[2] - wall[0]) // 2, wall[0] + (wall[2] - wall[0]) // 2 +2, wall[0] + (wall[2] - wall[0]) // 2 +1, wall[0] + (wall[2] - wall[0]) // 2 -1)
else:
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+1, wall[1]+1), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+2, wall[1]+1), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1], wall[1]), Block(self.blocks["stairs"], {"facing": "south"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1], wall[1]), Block(self.blocks["stairs"], {"facing": "west"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1], wall[1]), Block(self.blocks["stairs"], {"facing": "east"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+3, wall[1]), Block(self.blocks["stairs"], {"facing": "south", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+3, wall[1]), Block(self.blocks["stairs"], {"facing": "west", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1]+3, wall[1]), Block(self.blocks["stairs"], {"facing": "east", "half": "top"}))
self.entranceCo = (wall[0] + (wall[2] - wall[0]) // 2, wall[0] + (wall[2] - wall[0]) // 2 +1, wall[0] + (wall[2] - wall[0]) // 2 +1, wall[0] + (wall[2] - wall[0]) // 2 -1)
case "E":
if (wall[3] - wall[1]) % 2 != 0:
self.editor.placeBlock((wall[0], self.coordinates_min[1]+1, (wall[1] + wall[3]) // 2 +1), Block("air"))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+2, (wall[1] + wall[3]) // 2 +1), Block("air"))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+1, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+2, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1], (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "west"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1], (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "west"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1], (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1], (wall[1] + wall[3]) // 2 +2), Block(self.blocks["stairs"], {"facing": "north"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "west", "half": "top"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "west", "half": "top"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south", "half": "top"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 +2), Block(self.blocks["stairs"], {"facing": "north", "half": "top"}))
self.entranceCo = ((wall[1] + wall[3]) // 2, (wall[1] + wall[3]) // 2 +2, (wall[1] + wall[3]) // 2 +1, (wall[1] + wall[3]) // 2 -1)
else:
self.editor.placeBlock((wall[0], self.coordinates_min[1]+1, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0], self.coordinates_min[1]+2, (wall[1] + wall[3]) // 2), Block("air"))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1], (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "west"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1], (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "north"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1], (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 ), Block(self.blocks["stairs"], {"facing": "west", "half": "top"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 +1 ), Block(self.blocks["stairs"], {"facing": "north", "half": "top"}))
self.editor.placeBlock((wall[0]+1, self.coordinates_min[1]+3, (wall[1] + wall[3]) // 2 -1), Block(self.blocks["stairs"], {"facing": "south", "half": "top"}))
self.entranceCo = ((wall[1] + wall[3]) // 2, (wall[1] + wall[3]) // 2 +1, (wall[1] + wall[3]) // 2 +1, (wall[1] + wall[3]) // 2 -1)
case "S":
print(wall)
if (wall[2] - wall[0]) % 2 != 0:
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+1, wall[1]), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+2, wall[1]), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+1, wall[1]), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+2, wall[1]), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1], wall[1]+1), Block(self.blocks["stairs"], {"facing": "north"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1], wall[1]+1), Block(self.blocks["stairs"], {"facing": "north"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1], wall[1]+1), Block(self.blocks["stairs"], {"facing": "east"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +2, self.coordinates_min[1], wall[1]+1), Block(self.blocks["stairs"], {"facing": "west"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+3, wall[1]+1), Block(self.blocks["stairs"], {"facing": "north", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+3, wall[1]+1), Block(self.blocks["stairs"], {"facing": "north", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1]+3, wall[1]+1), Block(self.blocks["stairs"], {"facing": "east", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +2, self.coordinates_min[1]+3, wall[1]+1), Block(self.blocks["stairs"], {"facing": "west", "half": "top"}))
self.entranceCo = (wall[0] + (wall[2] - wall[0]) // 2, wall[0] + (wall[2] - wall[0]) // 2 +2, wall[0] + (wall[2] - wall[0]) // 2 +1, wall[0] + (wall[2] - wall[0]) // 2 -1)
else:
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+1, wall[1]), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+2, wall[1]), Block("air"))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1], wall[1]+1), Block(self.blocks["stairs"], {"facing": "north"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1], wall[1]+1), Block(self.blocks["stairs"], {"facing": "west"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1], wall[1]+1), Block(self.blocks["stairs"], {"facing": "east"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2, self.coordinates_min[1]+3, wall[1]+1), Block(self.blocks["stairs"], {"facing": "north", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 +1, self.coordinates_min[1]+3, wall[1]+1), Block(self.blocks["stairs"], {"facing": "west", "half": "top"}))
self.editor.placeBlock((wall[0] + (wall[2] - wall[0]) // 2 -1, self.coordinates_min[1]+3, wall[1]+1), Block(self.blocks["stairs"], {"facing": "east", "half": "top"}))
self.entranceCo = (wall[0] + (wall[2] - wall[0]) // 2, wall[0] + (wall[2] - wall[0]) // 2 +1, wall[0] + (wall[2] - wall[0]) // 2 +1, wall[0] + (wall[2] - wall[0]) // 2 -1)
case _:
pass
def placeGardenOutline(self):
x_min, y_min, z_min = self.coordinates_min
x_max, y_max, z_max = self.coordinates_max
for i in range (x_min, x_max):
for y in range(z_min, z_max):
if i == x_min or i == x_max - 1 or y == z_min or y == z_max - 1 :
match self.direction:
case "N":
if not (i in self.entranceCo and y == z_min):
self.editor.placeBlock((i, y_min-1, y), Block("oak_log"))
self.editor.placeBlock((i, y_min, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+1, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+2, y), self.gardenOutline)
case "S":
if not (i in self.entranceCo and y == z_max-1):
self.editor.placeBlock((i, y_min-1, y), Block("oak_log"))
self.editor.placeBlock((i, y_min, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+1, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+2, y), self.gardenOutline)
case "E":
if not (i == x_max-1 and y in self.entranceCo):
self.editor.placeBlock((i, y_min-1, y), Block("oak_log"))
self.editor.placeBlock((i, y_min, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+1, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+2, y), self.gardenOutline)
case "W":
if not (i == x_min and y in self.entranceCo):
self.editor.placeBlock((i, y_min-1, y), Block("oak_log"))
self.editor.placeBlock((i, y_min, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+1, y), self.gardenOutline)
self.editor.placeBlock((i, y_min+2, y), self.gardenOutline)
else:
print(i, y)
case _:
self.editor.placeBlock((i, y_min-1, y), self.garden_floor)
else:
self.editor.placeBlock((i, y_min-1, y), self.garden_floor)
def build(self):
house.createHouseSkeleton()
house.putWallOnSkeleton()
house.placeDoor()
house.placeRoof()
house.putCelling()
house.placeWindow()
house.placeEntrance()
house.placeGardenOutline()
if house.nbEtage > 1:
house.placeStairs()
if __name__ == "__main__":
editor = Editor(buffering=True)
buildArea = editor.getBuildArea()
coordinates_min = [min(buildArea.begin[i], buildArea.last[i]) for i in range(3)]
coordinates_max = [max(buildArea.begin[i], buildArea.last[i]) for i in range(3)]
blocks = {
"wall": "blackstone",
"roof": "blackstone",
"roof_slab": "blackstone_slab",
"door": "oak_door",
"window": "glass_pane",
"entrance": "oak_door",
"stairs": "quartz_stairs",
"stairs_slab": "quartz_slab",
"celling": "quartz_block",
"floor": "quartz_block",
"celling_slab": "quartz_slab",
"garden_outline": "oak_leaves",
"garden_floor": "grass_block"
}
for i in range(1):
house = House(editor, coordinates_min, coordinates_max,"W", blocks)
house.build()
new_coordinates_min =(coordinates_max[0] + 10, coordinates_min[1], coordinates_min[2])
new_coordinates_max = (coordinates_max[0] + 10 +24, coordinates_max[1], coordinates_max[2])
coordinates_min = new_coordinates_min
coordinates_max = new_coordinates_max
# delete(editor, coordinates_min, coordinates_max)
editor.flushBuffer()

7
main.py
View File

@@ -1,3 +1,10 @@
from world_maker.world_maker import *
def main():
rectangle_house_mountain, rectangle_building, skeleton_highway, skeleton_mountain = world_maker()
if __name__ == '__main__':
main()
from gdpc import Editor, Block, geometry, Transform
import networks.curve as curve
import numpy as np

101
world_maker/City.py
View File

@@ -1,7 +1,10 @@
from District import District
from Position import Position
from world_maker.District import District, Road
from world_maker.Position import Position
from PIL import Image
import random
from random import randint
from world_maker.data_analysis import handle_import_image, detect_mountain
from typing import Union
import numpy as np
class City:
@@ -25,8 +28,8 @@ class City:
"""
Initialize the maps of the city. It reads the heightmap and watermap images and converts them into 2D lists.
"""
heightmap = Image.open('./data/heightmap.png').convert('L')
watermap = Image.open('./data/watermap.png').convert('L')
heightmap = Image.open('./world_maker/data/heightmap.png').convert('L')
watermap = Image.open('./world_maker/data/watermap.png').convert('L')
width, height = heightmap.size
self.map_data = [[-1 if watermap.getpixel((x, y)) > 0 else 0 for x in range(width)] for y in range(height)]
self.height_map = [[heightmap.getpixel((x, y)) for x in range(width)] for y in range(height)]
@@ -72,7 +75,6 @@ class City:
index_district_chosen = index
else:
self.districts[index].area_expend.remove(point)
self.districts[index_district_chosen].area.append(point)
self.districts[index_district_chosen].area_expend_from_point.append(point)
self.districts[index_district_chosen].area_expend.remove(point)
self.map_data[point.y][point.x] = index_district_chosen + 1
@@ -81,7 +83,6 @@ class City:
"""
Update the expansion points of all districts in the city.
"""
for district in self.districts:
if len(district.area_expend_from_point) > 0:
district.update_expend_points(district.area_expend_from_point[0], self.map_data, self.height_map)
@@ -104,7 +105,7 @@ class City:
"""
width, height = len(self.map_data[0]), len(self.map_data)
img = Image.new('RGB', (width, height))
colors = {id_district: (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
colors = {id_district: (randint(0, 255), randint(0, 255), randint(0, 255))
for id_district in range(1, len(self.districts) + 1)}
for y in range(height):
@@ -114,13 +115,93 @@ class City:
else:
img.putpixel((x, y), colors[self.map_data[y][x]])
img.save('./data/district.png')
img.save('./world_maker/data/district.png')
print("[City] District map created.")
def draw_roads(self, size_road: int = 1) -> Image:
"""
Draw the roads of the city on the image.
:param size:
"""
image = Image.new('RGB', Image.open('./world_maker/data/heightmap.png').size)
for district in self.districts:
district.draw_roads(image, size_road)
return image
def district_generate_road(self) -> list[Road]:
"""
Generate the roads of the city for each district.
:return: The list of roads of the city.
"""
roads = []
for district in self.districts:
if district.type != "mountain":
district.generate_roads(self.map_data)
roads.extend(district.roads)
return roads
def point_in_which_district(self, point: Union[Position, tuple[int, int]]) -> int:
"""
Get the index of the district in which the point is located.
:param point: The point to check.
:return: The index of the district in which the point is located.
"""
if isinstance(point, Position):
point = (point.x, point.y)
return self.map_data[point[1]][point[0]]
def get_district_mountain_map(self) -> Image:
"""
Get the map of a district.
:param district_id: The id of the district.
:return: The map of the district.
"""
district_id = [district.tile_id for district in self.districts if district.type == "mountain"]
array = np.array([[True if self.map_data[y][x] in district_id else False for x in range(len(self.map_data[0]))]
for y in range(len(self.map_data))])
image = Image.fromarray(array)
image.save('./world_maker/data/mountain_map.png')
return image
def generate_district(self):
image = handle_import_image('./world_maker/data/smooth_sobel_watermap.png').convert('L')
array = np.array(image)
mountain_coo = detect_mountain()
self.add_district(Position(mountain_coo[0], mountain_coo[1]), "mountain")
print("[City] District added.")
remove_circle_data(array, mountain_coo)
area = get_area_array(array)
sizeX, sizeY = len(array[0]), len(array)
while area > sizeX * sizeY * 0.1:
x, y = randint(0, sizeX - 1), randint(0, sizeY - 1)
if array[y][x]:
self.add_district(Position(x, y))
remove_circle_data(array, (x, y))
area = get_area_array(array)
print("[City] District added.")
def remove_circle_data(array, center, radius=100):
y_indices, x_indices = np.indices(array.shape)
dist_sq = (y_indices - center[1]) ** 2 + (x_indices - center[0]) ** 2
mask = dist_sq <= radius ** 2
array[mask] = False
def get_area_array(array) -> int:
return np.sum(array)
if __name__ == '__main__':
city = City()
for i in range(10):
city.add_district(Position(random.randint(0, 800), random.randint(0, 800)))
city.add_district(Position(randint(0, 400), randint(0, 400)))
city.loop_expend_district()
city.district_draw_map()
city.district_generate_road()
image = city.draw_roads(Image.new('RGB', (401, 401)), 4)
image.save('./world_maker/data/roadmap.png')

190
world_maker/District.py
View File

@@ -1,8 +1,24 @@
from Position import Position
from world_maker.Position import Position
from typing import Union
from random import randint
from PIL import Image
class Road:
def __init__(self, position: Position, id_height: int, id_width: int, border: bool = False):
self.position: Position = position
self.north: Union[Road, None] = None
self.south: Union[Road, None] = None
self.east: Union[Road, None] = None
self.west: Union[Road, None] = None
self.id_height = id_height
self.id_width = id_width
self.border = border
class District:
"""
The CustomDistrict class represents a district that can be expanded.
The District class represents a district that can be expanded.
Attributes:
center_expend (Position): The center position from which the district expands.
@@ -10,6 +26,7 @@ class District:
area_expend_from_point (list): The list of positions from which the district can expand.
area_expend (list): The list of positions to which the district will maybe expand.
"""
def __init__(self, tile_id: int, center: Position, district_type: str = ""):
"""
The constructor for the District class.
@@ -23,11 +40,13 @@ class District:
self.tile_id = tile_id
self.type = district_type
self.center_expend = center
self.area = [center]
self.area_expend_from_point = [center]
self.area_expend = []
self.roads: list[Road] = []
self.roads_expend = []
def verify_point(self, point: Position, point_new: Position, map_data: list[list[int]], height_map: list[list[int]]):
def verify_point(self, point: Position, point_new: Position, map_data: list[list[int]],
height_map: list[list[int]]):
"""
Verify if a new point can be added to a district extend area list.
@@ -40,9 +59,32 @@ class District:
return (0 <= point_new.x < len(map_data[0]) and
0 <= point_new.y < len(map_data) and
map_data[point_new.y][point_new.x] == 0 and
(self.type == "Mountain" or
(self.type == "mountain" or
abs(height_map[point_new.y][point_new.x] - height_map[point.y][point.x]) < 2))
def is_point_inside(self, point: Position, map_data) -> bool:
"""
Check if a point is inside the district.
:param point: The point to be checked.
:return: True if the point is inside the district, False otherwise.
"""
if not (0 <= point.x < len(map_data[0]) and 0 <= point.y < len(map_data)):
return False
return map_data[point.y][point.x] == self.tile_id
def is_position_in_area_expend(self, position: Position) -> bool:
"""
Check if a position is inside the district.
:param position: The position to be checked.
:return: True if the position is inside the district, False otherwise.
"""
for point in self.area_expend:
if point == position:
return True
return False
def update_expend_points(self, point: Position, map_data: list[list[int]], height_map: list[list[int]]):
"""
Update the points to which the district can expand.
@@ -53,6 +95,142 @@ class District:
"""
for pos in [Position(1, 0), Position(-1, 0), Position(0, 1), Position(0, -1)]:
if self.verify_point(point, point + pos, map_data, height_map):
if point + pos not in self.area_expend:
if not self.is_position_in_area_expend(point + pos):
self.area_expend.append(point + pos)
self.area_expend_from_point.remove(point)
def move_point_to_area(self, point: Position, vector: Position, map_data) -> Position:
while not self.is_point_inside(point + vector, map_data):
point += vector
return point + vector
def get_road_from_point(self, point: Position) -> Union[Road, None]:
"""
Get the road that contains a specific point.
:param point: The point to be checked.
:return: The road that contains the point.
"""
for road in self.roads:
if point == road.position:
return road
return None
def get_road_expend_from_point(self, point: Position) -> Union[Road, None]:
"""
Get the road that contains a specific point.
:param point: The point to be checked.
:return: The road that contains the point.
"""
for road in self.roads_expend:
if point == road.position:
return road
return None
def generate_roads(self, map_data, random_range=(20, 40)):
width = {0: self.center_expend.x}
height = {0: self.center_expend.y}
self.roads_expend = [Road(self.center_expend, 0, 0)]
self.roads = [self.roads_expend[0]]
while len(self.roads_expend) > 0:
road = self.roads_expend.pop(0)
print(road.position)
for id_width in [-1, 1]:
if road.id_width + id_width not in width:
width[road.id_width + id_width] = width[road.id_width] + randint(random_range[0],
random_range[1]) * id_width
road_new = Road(Position(width[road.id_width + id_width], road.position.y),
road.id_height, road.id_width + id_width)
if self.is_point_inside(road_new.position, map_data):
road_search = self.get_road_from_point(road_new.position)
road_expend_search = self.get_road_expend_from_point(road_new.position)
if road_search is not None:
road_new = road_search
if id_width == -1:
road.west = road_new
road_new.east = road
else:
road.east = road_new
road_new.west = road
if road_search is None:
self.roads.append(road_new)
self.roads_expend.append(road_new)
else:
self.roads[self.roads.index(road_search)] = road_new
if road_expend_search is not None:
self.roads_expend[self.roads_expend.index(road_expend_search)] = road_new
else:
point_new = self.move_point_to_area(road_new.position, Position(-id_width, 0), map_data)
road_new = Road(point_new, road.id_height, road.id_width + id_width, True)
if id_width == -1:
road.west = road_new
road_new.east = road
else:
road.east = road_new
road_new.west = road
self.roads.append(road_new)
for id_height in [-1, 1]:
if road.id_height + id_height not in height:
height[road.id_height + id_height] = height[road.id_height] + randint(random_range[0],
random_range[1]) * id_height
road_new = Road(Position(road.position.x, height[road.id_height + id_height]),
road.id_height + id_height, road.id_width)
if self.is_point_inside(road_new.position, map_data):
road_search = self.get_road_from_point(road_new.position)
road_expend_search = self.get_road_expend_from_point(road_new.position)
if road_search is not None:
road_new = road_search
if id_height == -1:
road.north = road_new
road_new.south = road
else:
road.south = road_new
road_new.north = road
if road_search is None:
self.roads.append(road_new)
self.roads_expend.append(road_new)
else:
self.roads[self.roads.index(road_search)] = road_new
if road_expend_search is not None:
self.roads_expend[self.roads_expend.index(road_expend_search)] = road_new
else:
pass
point_new = self.move_point_to_area(road_new.position, Position(0, -id_height), map_data)
road_new = Road(point_new, road.id_height + id_height, road.id_width, True)
if id_height == -1:
road.north = road_new
road_new.south = road
else:
road.south = road_new
road_new.north = road
self.roads.append(road_new)
def draw_roads(self, image: Image, size: int = 1):
for road in self.roads:
image.putpixel((road.position.x, road.position.y), (255, 255, 255))
if road.north is not None:
for y in range(road.position.y, road.north.position.y):
image = draw_square(image, Position(road.position.x, y), size)
if road.south is not None:
for y in range(road.position.y, road.south.position.y):
image = draw_square(image, Position(road.position.x, y), size)
if road.east is not None:
for x in range(road.position.x, road.east.position.x):
image = draw_square(image, Position(x, road.position.y), size)
if road.west is not None:
for x in range(road.position.x, road.west.position.x):
image = draw_square(image, Position(x, road.position.y), size)
def draw_square(image, center: Position, size: int) -> Image:
for x in range(center.x - size, center.x + size):
for y in range(center.y - size, center.y + size):
if 0 <= x < image.width and 0 <= y < image.height:
image.putpixel((x, y), (255, 255, 255))
return image

31
world_maker/Skeleton.py
View File

@@ -3,7 +3,7 @@ import numpy as np
from skimage.morphology import skeletonize
from skan.csr import skeleton_to_csgraph
from collections import Counter
from PIL import Image
from PIL import Image, ImageDraw
import random
@@ -158,7 +158,7 @@ class Skeleton:
# xzDistance = (max(buildRect.end[0], buildRect.begin[0]) - min(buildRect.end[0], buildRect.begin[0]),
# max(buildRect.end[1], buildRect.begin[1]) - min(buildRect.end[1], buildRect.begin[1]))
heightmap = Image.open("data/heightmap.png").convert('RGB')
heightmap = Image.open("./world_maker/data/heightmap.png").convert('RGB')
# roadsArea = Image.new("L", xzDistance, 0)
# width, height = heightmap.size
@@ -213,3 +213,30 @@ class Skeleton:
# )
print("[Skeleton] Mapping completed.")
return heightmap # , roadsArea
def road_area(self, name: str, radius: int = 10) -> Image:
print("[Skeleton] Start mapping the road area...")
heightmap = Image.open("./world_maker/data/heightmap.png")
width, height = heightmap.size
road_area_map = Image.new("L", (width, height), 0)
road_area_map_draw = ImageDraw.Draw(road_area_map)
# Lines
for i in range(len(self.lines)):
for j in range(len(self.lines[i])):
z = self.coordinates[self.lines[i][j]][0]
x = self.coordinates[self.lines[i][j]][2]
circle_coords = (z - radius, x - radius, z + radius, x + radius)
road_area_map_draw.ellipse(circle_coords, fill=255)
# Centers
for i in range(len(self.centers)):
z = self.coordinates[self.centers[i]][0]
x = self.coordinates[self.centers[i]][2]
circle_coords = (z - radius, x - radius, z + radius, x + radius)
road_area_map_draw.ellipse(circle_coords, fill=255)
road_area_map.save("./world_maker/data/"+name)
print("[Skeleton] Road area mapping completed.")
return road_area_map

2
world_maker/World.py
View File

@@ -1,7 +1,7 @@
from gdpc import Editor, geometry, lookup
import numpy as np
from PIL import Image
from Block import Block
from world_maker.Block import Block
waterBiomes = [
"minecraft:ocean",

BIN
world_maker/data/building.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 597 B

BIN
world_maker/data/city_map.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.2 KiB

BIN
world_maker/data/district.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.3 KiB

BIN
world_maker/data/heightmap.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 112 KiB

After

Width:  |  Height:  |  Size: 33 KiB

BIN
world_maker/data/highwaymap.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 8.0 KiB

After

Width:  |  Height:  |  Size: 2.2 KiB

BIN
world_maker/data/mountain_map.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
world_maker/data/negative_sobel_water_map.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 18 KiB

BIN
world_maker/data/roadmap.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.6 KiB

BIN
world_maker/data/skeleton_highway.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 127 KiB

After

Width:  |  Height:  |  Size: 36 KiB

BIN
world_maker/data/skeleton_highway_area.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.4 KiB

BIN
world_maker/data/skeleton_mountain.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 34 KiB

BIN
world_maker/data/skeleton_mountain_area.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
world_maker/data/smooth_sobel_watermap.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.4 KiB

BIN
world_maker/data/sobelmap.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 148 KiB

After

Width:  |  Height:  |  Size: 42 KiB

BIN
world_maker/data/treemap.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 79 KiB

After

Width:  |  Height:  |  Size: 8.7 KiB

BIN
world_maker/data/watermap.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 12 KiB

After

Width:  |  Height:  |  Size: 3.6 KiB

97
world_maker/data_analysis.py
View File

@@ -1,17 +1,19 @@
import World
from world_maker.World import World
from PIL import Image, ImageFilter
import numpy as np
from scipy import ndimage
from Skeleton import Skeleton
from world_maker.Skeleton import Skeleton
from typing import Union
from random import randint
import cv2
def get_data(world: World):
print("[Data Analysis] Generating data...")
heightmap, watermap, treemap = world.getData()
heightmap.save('./data/heightmap.png')
watermap.save('./data/watermap.png')
treemap.save('./data/treemap.png')
heightmap.save('./world_maker/data/heightmap.png')
watermap.save('./world_maker/data/watermap.png')
treemap.save('./world_maker/data/treemap.png')
print("[Data Analysis] Data generated.")
return heightmap, watermap, treemap
@@ -22,13 +24,14 @@ def handle_import_image(image: Union[str, Image]) -> Image:
return image
def filter_negative(image: Image) -> Image:
def filter_negative(image: Union[str, Image]) -> Image:
"""
Invert the colors of an image.
Args:
image (image): image to filter
"""
image = handle_import_image(image)
return Image.fromarray(np.invert(np.array(image)))
@@ -146,8 +149,8 @@ def subtract_map(image: Union[str, Image], substractImage: Union[str, Image]) ->
def group_map(image1: Union[str, Image], image2: Union[str, Image]) -> Image:
image1 = handle_import_image(image1)
image2 = handle_import_image(image2)
image1 = handle_import_image(image1).convert('L')
image2 = handle_import_image(image2).convert('L')
array1 = np.array(image1)
array2 = np.array(image2)
@@ -179,9 +182,9 @@ def filter_remove_details(image: Union[str, Image], n: int = 20) -> Image:
def highway_map() -> Image:
print("[Data Analysis] Generating highway map...")
smooth_sobel = filter_smooth("./data/sobelmap.png", 1)
smooth_sobel = filter_smooth("./world_maker/data/sobelmap.png", 1)
negative_smooth_sobel = filter_negative(smooth_sobel)
negative_smooth_sobel_water = subtract_map(negative_smooth_sobel, './data/watermap.png')
negative_smooth_sobel_water = subtract_map(negative_smooth_sobel, './world_maker/data/watermap.png')
array_sobel_water = np.array(negative_smooth_sobel_water)
array_sobel_water = ndimage.binary_erosion(array_sobel_water, iterations=12)
array_sobel_water = ndimage.binary_dilation(array_sobel_water, iterations=5)
@@ -190,7 +193,7 @@ def highway_map() -> Image:
array_sobel_water = filter_smooth_array(array_sobel_water, 6)
image = Image.fromarray(array_sobel_water)
image_no_details = filter_remove_details(image, 15)
image_no_details.save('./data/highwaymap.png')
image_no_details.save('./world_maker/data/highwaymap.png')
print("[Data Analysis] Highway map generated.")
return image_no_details
@@ -208,16 +211,82 @@ def create_volume(surface: np.ndarray, heightmap: np.ndarray, make_it_flat: bool
def convert_2D_to_3D(image: Union[str, Image], make_it_flat: bool = False) -> np.ndarray:
image = handle_import_image(image)
heightmap = Image.open('./data/heightmap.png').convert('L')
heightmap = Image.open('./world_maker/data/heightmap.png').convert('L')
heightmap = np.array(heightmap)
surface = np.array(image)
volume = create_volume(surface, heightmap, make_it_flat)
return volume
def skeleton_highway_map(image: Union[str, Image] = './data/highwaymap.png'):
def skeleton_highway_map(image: Union[str, Image] = './world_maker/data/highwaymap.png') -> Skeleton:
image_array = convert_2D_to_3D(image, True)
skeleton = Skeleton(image_array)
skeleton.parse_graph(True)
heightmap_skeleton = skeleton.map()
heightmap_skeleton.save('./data/skeleton_highway.png')
heightmap_skeleton.save('./world_maker/data/skeleton_highway.png')
skeleton.road_area('skeleton_highway_area.png', 10)
return skeleton
def skeleton_mountain_map(image: Union[str, Image] = './world_maker/data/mountain_map.png') -> Skeleton:
image_array = convert_2D_to_3D(image, True)
skeleton = Skeleton(image_array)
skeleton.parse_graph()
heightmap_skeleton = skeleton.map()
heightmap_skeleton.save('./world_maker/data/skeleton_mountain.png')
skeleton.road_area('skeleton_mountain_area.png', 3)
return skeleton
def smooth_sobel_water() -> Image:
watermap = handle_import_image("./world_maker/data/watermap.png")
watermap = filter_negative(filter_remove_details(filter_negative(watermap), 5))
sobel = handle_import_image("./world_maker/data/sobelmap.png")
sobel = filter_remove_details(filter_smooth(sobel, 1), 2)
group = group_map(watermap, sobel)
group = filter_negative(group)
group.save('./world_maker/data/smooth_sobel_watermap.png')
return group
def detect_mountain(image: Union[str, Image] = './world_maker/data/sobelmap.png') -> Image:
image = handle_import_image(image)
sobel = np.array(image)
pixels = sobel.reshape((-1, 1))
pixels = np.float32(pixels)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.2)
k = 3
_, labels, centers = cv2.kmeans(pixels, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
centers = np.uint8(centers)
segmented_image = centers[labels.flatten()]
segmented_image = segmented_image.reshape(sobel.shape)
mountain = segmented_image == segmented_image.max()
contours, _ = cv2.findContours(mountain.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
max_contour = max(contours, key=cv2.contourArea)
M = cv2.moments(max_contour)
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
print(f"[Data Analysis] The center of the mountain is at ({cX}, {cY})")
return (cX, cY)
def rectangle_2D_to_3D(rectangle: list[tuple[tuple[int, int], tuple[int, int]]],
height_min: int = 6, height_max: int = 10) \
-> list[tuple[tuple[int, int, int], tuple[int, int, int]]]:
image = handle_import_image('./world_maker/data/heightmap.png').convert('L')
new_rectangle = []
for rect in rectangle:
start, end = rect
avg_height = 0
for x in range(start[0], end[0]):
for y in range(start[1], end[1]):
avg_height += image.getpixel((x, y))
avg_height = int(avg_height / ((end[0] - start[0]) * (end[1] - start[1])))
new_rectangle.append(
((start[0], avg_height, start[1]), (end[0], avg_height + randint(height_min, height_max), end[1])))
return new_rectangle

112
world_maker/pack_rectangle.py Normal file
View File

@@ -0,0 +1,112 @@
from PIL import Image
import numpy as np
from typing import Union
from world_maker.data_analysis import handle_import_image
from random import randint
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
class Bin:
def __init__(self, grid):
self.grid = grid
self.rectangles = []
def place_rectangle(self, rectangle):
best_spot = None
best_spot_empty_area = float('inf')
for i in range(len(self.grid[0]) - rectangle.width + 1):
for j in range(len(self.grid) - rectangle.height + 1):
if self.can_place(rectangle, i, j):
empty_area = self.calculate_empty_area(rectangle, i, j)
if empty_area < best_spot_empty_area:
best_spot = (i, j)
best_spot_empty_area = empty_area
if best_spot is not None:
self.rectangles.append((best_spot, (best_spot[0] + rectangle.width, best_spot[1] + rectangle.height)))
self.update_grid(rectangle, *best_spot)
return True
return False
def calculate_empty_area(self, rectangle, x, y):
empty_area = 0
for rect_x in range(x, x + rectangle.width):
for rect_y in range(y, y + rectangle.height):
if self.grid[rect_y][rect_x]:
empty_area += 1
return empty_area
def can_place(self, rectangle, x, y):
for rect_x in range(x, x + rectangle.width):
for rect_y in range(y, y + rectangle.height):
if not self.grid[rect_y][rect_x]:
return False
return True
def update_grid(self, rectangle, x, y):
for rect_x in range(x, x + rectangle.width):
for rect_y in range(y, y + rectangle.height):
self.grid[rect_y][rect_x] = False
def pack_rectangles(rectangles, grid):
rectangles = sorted(rectangles, key=lambda r: r.width * r.height, reverse=True)
bins = [Bin(grid)]
for rectangle in rectangles:
for bin in bins:
if bin.place_rectangle(rectangle):
break
else:
new_bin = Bin(grid)
if new_bin.place_rectangle(rectangle):
bins.append(new_bin)
else:
return False
return True
def generate_rectangle(min_width: int = 10, max_width: int = 25):
width = randint(min_width, max_width)
height = randint(min_width, max_width)
return Rectangle(width, height)
def pack_rectangles(grid, min_width: int = 10, max_width: int = 25):
bin = Bin(grid)
while True:
rectangle = generate_rectangle(min_width, max_width)
if not bin.place_rectangle(rectangle):
break
print(len(bin.rectangles))
return bin.rectangles
def draw_rectangles(rectangles, grid):
image = Image.new('RGB', (len(grid[0]), len(grid)), (0, 0, 0))
for rectangle in rectangles:
start, end = rectangle
for x in range(start[0], end[0]):
for y in range(start[1], end[1]):
image.putpixel((x, y), (144, 255, 144))
return image
def generate_building(image: Union[str, Image], min_width: int = 10, max_width: int = 25):
image = handle_import_image(image).convert('L')
grid = np.array(image)
rectangles = pack_rectangles(grid, min_width, max_width)
draw_rectangles(rectangles, grid).save('./world_maker/data/building.png')
return rectangles
if __name__ == '__main__':
generate_building()

37
world_maker/world_maker.py
View File

@@ -1,9 +1,34 @@
import World
from world_maker.World import World
from PIL import Image
from data_analysis import get_data, highway_map, filter_sobel, skeleton_highway_map
from world_maker.data_analysis import (get_data,filter_negative, rectangle_2D_to_3D, skeleton_mountain_map, highway_map, filter_sobel, skeleton_highway_map, \
smooth_sobel_water, subtract_map, detect_mountain)
from world_maker.City import City
from world_maker.Position import Position
from random import randint
from world_maker.pack_rectangle import generate_building
if __name__ == '__main__':
world = World.World()
def world_maker():
world = World()
heightmap, watermap, treemap = get_data(world)
filter_sobel("./data/heightmap.png").save('./data/sobelmap.png')
skeleton_highway_map(highway_map())
filter_sobel("./world_maker/data/heightmap.png").save('./world_maker/data/sobelmap.png')
smooth_sobel_water_map = smooth_sobel_water()
skeleton_highway = skeleton_highway_map(highway_map())
city = City()
city.generate_district()
city.loop_expend_district()
city.district_draw_map()
city.district_generate_road()
image_mountain_map = city.get_district_mountain_map()
road = city.draw_roads(4)
road.save('./world_maker/data/roadmap.png')
subtract_map(smooth_sobel_water_map, road).save('./world_maker/data/city_map.png')
subtract_map('./world_maker/data/city_map.png', './world_maker/data/skeleton_highway_area.png').save('./world_maker/data/city_map.png')
subtract_map('./world_maker/data/city_map.png', './world_maker/data/mountain_map.png').save('./world_maker/data/city_map.png')
rectangle_building = generate_building('./world_maker/data/city_map.png')
rectangle_building = rectangle_2D_to_3D(rectangle_building)
skeleton_mountain = skeleton_mountain_map(image_mountain_map)
subtract_map('./world_maker/data/mountain_map.png', './world_maker/data/skeleton_mountain_area.png').save('./world_maker/data/mountain_map.png')
subtract_map(smooth_sobel_water_map, filter_negative('./world_maker/data/mountain_map.png')).save('./world_maker/data/mountain_map.png')
rectangle_mountain = generate_building('./world_maker/data/mountain_map.png')
return rectangle_building, rectangle_mountain, skeleton_highway, skeleton_mountain