import rhinoscriptsyntax as rs
import random as ran

rs.EnableRedraw(False)

allobjs = rs.AllObjects()
rs.DeleteObjects(allobjs)

##Dom-ino Haus

#Variablen
A = 5
B = A/3
thick = 0.18
hgt = 2.7
xcol = 3
ycol = 4
levels = 5
f_height = 0.5
f_size = 0.8

center_pt = [A*(xcol-1)/2, A*(ycol-1)/2, f_height]
p_width = A*(xcol-1) + 2*B
p_lenght = A*(ycol-1) + f_size

################################################
#alles fuer fassade
#Funktion fuer Stuetzen fuer Fassade
def make_box2(insertion=[0,0,0],xsize=1,ysize=1,zsize=1):
    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,0))
    rs.MoveObject(box, insertion)
    return[box]

def make_fac (insertion=[0,0,0],p_width=p_width, p_lenght=p_lenght, f_height=f_height, levels=levels, hgt=hgt, f_size=f_size, B=B, A=A):
    #unten kurz
    my_line1 = rs.AddLine([insertion[0]-B,insertion[1]-(f_size/2),f_height],[insertion[0]+p_width-B,insertion[1]-(f_size/2),f_height])
    #oben kurz
    my_line2 = rs.AddLine([insertion[0]-B,insertion[1]+p_lenght-(f_size/2),f_height],[insertion[0]+p_width-B,insertion[1]+p_lenght-(f_size/2),f_height])
    #links lang
    my_line3 = rs.AddLine([insertion[0]-B,insertion[1]+p_lenght-f_size/2,f_height],[insertion[0]-B,insertion[1]-f_size/2,f_height])
    #rechts lang
    my_line4 = rs.AddLine([insertion[0]+p_width-B,insertion[1]-f_size/2,f_height],[insertion[0]+p_width-B,insertion[1]+p_lenght-f_size/2,f_height])
    my_lines = (my_line1, my_line2, my_line3, my_line4)
    my_pts1 = rs.DivideCurve(my_line1, 2, False, True)
    my_pts2 = rs.DivideCurve(my_line2, 40, False, True)
    my_pts3 = rs.DivideCurve(my_line3, 18, False, True)
    my_pts4 = rs.DivideCurve(my_line4, 5, False, True)
    xwert = 0.2       #Fassadenplacement
    ywert = 0.2
    zwert = hgt*(levels-1)+f_height+thick*levels-f_height
    facade_boxes = []
    for p in my_pts1:
     make_box2(p, xwert,ywert,zwert)
    for p in my_pts2:
        my_box2 = make_box2(p, xwert,ywert,zwert)
        rs.MoveObjects(my_box2, [0,ywert,0])
    for p in my_pts3:
        my_box3 = make_box2(p, xwert,ywert,zwert)
        rs.MoveObjects(my_box3, [-xwert/2,0,0])
    for p in my_pts4:
        my_box4 = make_box2(p, xwert,ywert,zwert)
        rs.MoveObjects(my_box4, [xwert/2,0,0])
    rs.DeleteObjects(my_lines)
    return (facade_boxes)
    return (zwert)




#####################################################


##Funktion mit Variablen - Box kreieren --> centerpoint
#default Werte, wie xsize=10 --> falls keine anderen Werte angegeben, werden diese genutzt
#insertion punkt --> mit Move wird es dorthin dann verschoben, bei make_box definiert
def make_box(insertion=[0,0,0],xsize=1,ysize=1,zsize=1):
    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]

##Funktion fuer Feld mit Fundamenten
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)

##Funktion fuer Feld mit Stuetzen
def make_columns(A = 5.0, level=0.7, thick=0.2, hgt=3, 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)


################################################

##Domino bauen

##Funktion fuer bogen
def make_arc(insertion, rad, thick, hgt, orientation):
    segs = []
    segs.append( rs.AddArc([0,0,0], rad , 180))
    segs.append( rs.AddArc([0,0,0], rad-thick , 180))
    segs.append( rs.AddLine([rad,0,0],[rad-thick,0,0]))
    segs.append( rs.AddLine([-(rad-thick),0,0],[-rad,0,0]))
    crv = rs.JoinCurves(segs, delete_input=True)
    path = rs.AddLine([0,0,0],[0,0,hgt])
    arc = rs.ExtrudeCurve(crv, path)
    rs.CapPlanarHoles(arc)
    rs.DeleteObject(crv)
    rs.DeleteObject(path)
    rs. RotateObject(arc, [0,0,0],orientation)
    rs.MoveObject(arc, insertion)
    return(arc)

##Funktion fuer terrassen
def make_terrace(A = 5.0, level=0.7, thick=0.2, hgt=3, xcol=2, ycol=3):
    cls = []
    for i in range(xcol-1):
        for j in range(ycol-1):
            ori = ran.randint(0,6)
            if (ori<4):
                orientation = ori*90
                cls.append(make_arc([i*A+A/2,j*A+A/2,level],A/2,thick,hgt,orientation))
    return(cls)

##Funktion fuer stufen
def make_stair(start, th, tt, steps, thick, s_width):
    pointlist = [start]
    for i in range(steps):
        pointlist.append([pointlist[-1][0],pointlist[-1][1], pointlist[-1][2]+th])
        pointlist.append([pointlist[-1][0]+tt,pointlist[-2][1], pointlist[-1][2]])
    pointlist.append([pointlist[-1][0],pointlist[-1][1], pointlist[-1][2]-thick])
    pointlist.append([pointlist[0][0],pointlist[0][1], pointlist[0][2]-thick])
    pointlist.append([pointlist[0][0],pointlist[0][1], pointlist[0][2]])
    s_outline = rs.AddPolyline(pointlist)
    path = rs.AddLine(start,[start[0], start[1]+s_width,start[2]])
    hull = rs.ExtrudeCurve(s_outline,path)
    rs.CapPlanarHoles(hull)
    rs.DeleteObject(s_outline)
    rs.DeleteObject(path)
    return(hull)

##Funktion fuer Podeste --> cornerpoint
def make_podest(insertion=[0,0,0],xsize=1,ysize=1,zsize=1):
    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, insertion)
    return[box]

#Funktion alles in allem
def make_domino(A=A, B=B, levels=levels, thick=thick, hgt=hgt, xcol=xcol, ycol=ycol, f_height=f_height, f_size=f_size):
    f_list = []         #Fundamente
    c_list = []         #Stuetzen
    p_list = []         #Platten
    fac_list = []
    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)      ##Fundamente
        else:
            c_list.extend(make_columns(A, level, thick, hgt, xcol, ycol))   ##Stuetzen
            if(i%2):
                c_list.extend(make_terrace(A, level, thick, hgt, xcol, ycol))
        p_list.append(make_box(center_pt, p_width, p_lenght, thick))         ##Platte
    level = f_height + thick + (levels-1)*(hgt+thick)
    c_list.extend(make_terrace(A, level, thick, hgt, xcol, ycol))
    #####################
    #Fassade
    fac_list = make_fac()
    ##################################
    #calculate stair value
    ##################################
    steps = int((hgt+thick)/0.17)
    if steps%2:
        steps = steps-1
    th = (hgt+thick)/steps
    if (th>0.19):
        steps = steps + 2
        th = (hgt+thick)/steps
    #################################
    #stair parameters
    #################################
    tt = 0.3        #step size
    s_width = 1.2   #stair width
    pod_w = B       #depth of landing
    start = [pod_w,-(s_width*2+f_size/2),f_height+thick]    #startpoint of stair
    #loop fuer stiegenhaus
    stair_l = []
    for i in range(levels):
        start[2] = f_height+thick + i*(thick+hgt)       #z-wert bei jeder Iteration neu gesetzt
        if i==levels-1:                                 #letztes podest
            stair_l.append(make_podest([start[0]- pod_w,start[1]+s_width,start[2]-thick], pod_w, s_width, thick))    #sonderpodest
        else:
            stair_l.append(make_podest([start[0]-pod_w,start[1],start[2]-thick], pod_w, s_width*2, thick))
            stair_l.append(make_stair(start, th, tt, int(steps/2), thick, s_width))
            stair_l.append(make_podest([start[0]+(steps/2)*tt,start[1],start[2]+(steps/2)*th], pod_w, s_width*2, thick))
            stair_l.append(make_stair([start[0]+(steps/2)*tt,start[1]+s_width,start[2]+(steps/2)*th], th, -tt, int(steps/2), thick, s_width))
    return (f_list, c_list, p_list, stair_l, fac_list)
(f_list, c_list, p_list,stair_l, fac_list) = make_domino()



##Layers und Farben
rs.AddLayer("foundation")
rs.LayerColor("foundation",(255,192,203))
rs.ObjectLayer(f_list,"foundation")

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

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




###############
#Feld fuer City
###############
radius = 70
div = 7

plane = rs.WorldXYPlane()
my_c = rs.AddCircle(plane,radius)
my_pts = rs.DivideCurve(my_c, div, False, True)


for p in my_pts:
    levels = ran.randint(2, 7)
    hgt = ran.randint(3, 8)
    insertion = [p.X, p.Y, 0]  #von jedem punkt die x und y werte
    (f_list, c_list, p_list, stair_l, fac_list) = make_domino(levels=levels, hgt=hgt)
    p_width = A * (xcol - 1) + 2 * B
    p_length = A * (ycol - 1) + f_size
    facade_boxes = make_fac(insertion=insertion,p_width=p_width,p_lenght=p_length,f_height=f_height,levels=levels,hgt=hgt,f_size=f_size,B=B,A=A)
    rs.MoveObjects(facade_boxes, insertion)
    rs.MoveObjects(f_list + c_list + p_list + stair_l + fac_list, insertion)

rs.DeleteObject(my_c)