import rhinoscriptsyntax as rs
import random as ran

#allobj= rs.AllObjects()
allobj=rs.AllObjects()
rs.DeleteObjects(allobj)

#domino variables
A=5               #distance btw columns
B=A/3             #distance of columns to end of plate
thick=0.2         #thickness of all slabs
hgt=2.7           #height of room
xcol=2            #columns in x direction
ycol=3            #columns in y direction
levels=3          #number of floor plates
f_height=0.5      #foundation height
f_size=0.8        #foundation edge size

#derived values
center_pt=[A*(xcol-1)/2,A*(ycol-1)/2,f_height]    #insertion point of floor plate
p_width=A*(xcol-1)+2*B                     #width of floor plate (x)
p_length=A*(ycol-1)+f_size                 #length of floor plate (y)

def make_box(insertion=[0,0,0],xsize=10,ysize=10,zsize=10):

    #jeweils die Laengen
    
    #create a box
    corners = [[0,0,0],[xsize,0,0] ,[xsize,ysize,0] ,[0,ysize,0],
              [0,0,zsize],[xsize,0,zsize],[xsize,ysize,zsize],[0,ysize,zsize]]

    box=rs.AddBox(corners)
    rs.MoveObject(box, (-xsize/2,-ysize/2,0))
    rs.MoveObject(box, insertion)
    return(box)

#function to create a field of foundations
def make_foundations(A=5.0,f_size=0.8,f_height=0.5, xcol=2, ycol=3):
    fns=[]
    for i in range (xcol):
        for j in range (ycol):
            fns.append(make_box([i*A,j*A,0],f_size,f_size,f_height))
    return(fns)

#function to create a field of columns
def make_columns(A=5.0, level=0.7,thick=0.2, hgt=3.0, xcol=2, ycol=3):
    cls=[]
    for i in range (xcol):
        for j in range (ycol):
             cls.append(make_box([i*A,j*A,level],thick,thick,hgt))
    return(cls)

 #building dom-ino
f_list=[]      #list of founations
c_list=[]       #list of columns
p_list=[]      #list of plates

for i in range (levels):
    center_pt[2] = f_height + i*(thick + hgt)
    level=f_height+thick+(i-1)*(hgt+thick)
    if i==0:
        f_list=make_foundations(A,f_size,f_height,xcol,ycol)
    else:
        c_list.extend(make_columns(A,level,thick,hgt,xcol,ycol))
    p_list.append(make_box(center_pt, p_width, p_length, thick))
    

rs.AddLayer("foundation")
rs.LayerColor("foundation", (220,60,60))
rs.ObjectLayer(f_list,"foundation")

rs.AddLayer("columns")
rs.LayerColor("columns", (60,220,60))
rs.ObjectLayer(c_list,"columns")

rs.AddLayer("plates")
rs.LayerColor("plates", (60,60,220))
rs.ObjectLayer(p_list,"plates")



##########################################Fassade
# Masse fuer die Laenge und Breite des Dom-Ino Haus
total_length = 10.78  
width_length = 5.4  

xf = 0.2  # Breite der Boxen
yf = 0.05  # Hoehe der Boxen
f_pcs = 45  # Anzahl der Boxen Laengsseiten
f_pcs_width = 20  # Anzahl der Boxen Breitenseiten

# Abstands zwischen den Boxen auf der Laengsseite
dis_length = total_length / f_pcs
# Abstands zwischen den Boxen auf der Breitenseite
dis_width = width_length / f_pcs_width

# Aussparung auf den Laengsseiten
gap_start = int(f_pcs / 3)  
gap_end = gap_start + 10  

# Berechnung des Versatzes fuer die Laengsseiten (rechte Fassade)
off_length_right = A * (xcol - 1) + B + xf / 2

# Berechnung des Versatzes fuer die Laengsseiten (linke Fassade)
off_length_left = A * (xcol - 2.7) + B + xf / 2

# Berechnung des Versatzes fuer die Breitenseiten (rechte und linke Seite)
off_breadth = A * (xcol - 1) + B + xf / 2
off_breadth_left = A * (xcol - 2.7) + B + xf / 2

# Erstellen der Fassade Laengsseite
def make_facade_length(insertion=[0, 0, 0], xf=0.2, yf=0.05, zf=(hgt + thick)*(levels-1), dis_length=dis_length, off=off_length_right):
    fcd = []
    for i in range(f_pcs):
        # Aussparung ueberspringen
        if gap_start <= i < gap_end:
            continue
        # Boxen entlang der Y-Achse verteilen (Laengsseite)
        fcd.append(make_box([off, i * dis_length - f_size / 2, f_height], xf, yf, zf))
    return fcd

# Erstellen der Fassade entlang der Breitenseite
def make_facade_breadth(insertion=[0, 0, 0], xf=0.2, yf=0.05, zf=(hgt + thick)*(levels-1), dis_width=dis_width, off=off_breadth):
    fcd = []
    for i in range(f_pcs_width):
        fcd.append(make_box([i * dis_width - f_size / 2, off, f_height], xf, yf, zf))
    return fcd

# rechte Laengsseite
make_facade_length()

# linke Laengsseite
make_facade_length(off=off_length_left)

# rechte Breitenseite
make_facade_breadth(off=0)  # Positioniert die Breitenseite an der unteren Kante der Laengsseite

# linke Breitenseite
make_facade_breadth(off=10.78)  # Positioniert die Breitenseite an der oberen Kante der Laengsseite