import rhinoscriptsyntax as rs
import random as ran

# delete everthing and start from scratch
allobjs = rs.AllObjects ()
rs.DeleteObjects (allobjs)

# dom-ino variables
A = 5
B = A/3
thick = 0.2
hgt = 2.7
xcol = 4
ycol = 5
levels = 5
f_height = 0.5
f_size = 0.8                   

# 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)
p_height= (levels-1)*(hgt+thick)

#function to create box at centerpoint
def make_box (insertion= [0,0,0], xsize=10, ysize=10, zsize=10) :
        # 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 box at cornerpoint
def make_podest (insertion= [0,0,0], xsize=10, ysize=10, zsize=10) :
        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)

# 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)

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.AddArc ([rad,0,0], rad-thick,0))
    segs.append (rs.AddArc ([-(rad-thick),0,0], -rad.0,0))
    crv=rs.JoinCurves (seg, delete_input=True)
    path=rs.AddLine ([0,0,0], [0,0,hgt])
    arc=rs.ExtrudeCurve(crv,)
    rs.DeleteObject(crv)
    rs.DeleteObject(path)
    rs.Rotateobject (arc, [0,0,0], orientation)
    rs.MoveObject (arc, insertion)
    return (arc)

def make_terraces (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):
                ori = ran.randint (0,6)
                if ori<4:
                    orientation = ori*90
                    cls.append(make_arc([i*A+A/2,j*A,level], A/2, thick, hgt, orientation))
                return(cls)

#function to create stair
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[-1][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)
    return (hull)

rs.EnableRedraw (False)

# building dom-ino
def make_domino (A=A, B=B, thick=thick, hgt=hgt, levels=levels, xcol=xcol, ycol=ycol, f_height=f_height, f_size=f_size): 
    f_list = []                             # list of foundations 
    c_list = []                             # list of columne
    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))
            if (i%2): 
            c_list.extend (make_columns (A, level, thick, hgt, xcol, ycol))    
        p_list.append(make_box(center_pt, p_width, p_length, thick))
    level = f_height + thick + (levels-1)*(hgt+thick)
    c_list.extend (make_terrace (A, level, thick, hgt, xcol, ycol))
    ################################
    #calculates 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                  # steps size
    s_width=1.2             # s_width = stair width
    pod_w = B               # pod_w = depth of landing
    start = [pod_w,-(s_width*2+f_size/2), f_height+thick]        # startpoint of stair

    #loop to create staircase
    stair_1 = []
    for i in range (levels):
        start [2] = f_height+thick + i*(thick+hgt)          #z-wert bei jeder Interation neu gesetzt
        if i == levels -1:                          # letztes Podest
            stair_1.append (make_podest ([start[0]-pod_w, start[1]+s_width, start[2]-thick], pod_w, s_width, thick)) # Sonderpodest
        else:
            stair_1.append(make_podest ([start[0]-pod_w, start[1], start[2]-thick], pod_w, s_width*2, thick))
            stair_1.append(make_stair (start, th, tt, int(steps/2), thick, s_width))
            stair_1.append(make_podest ([start[0]+(steps/2)*tt, start[1], start[2]+(steps/2)*th-thick], pod_w, s_width*2, thick))
           stair_1.append(make_stair ([start[0]+(steps/2)*tt, start[1]+s_width, start[2]+(steps/2)*th], th, -tt, int (steps/2), thick, width))



    return(f_list, c_list, p_list)

    
(f_list, c_list, p_list) = make_domino()

print f_list
print c_list
print p_list 

rs.AddLayer("foundation") 
rs.LayerColor ("foundation", (60, 60, 60)) 
rs.ObjectLayer (f_list, "foundation")
rs.AddLayer ("columns") 
rs.LayerColor ("columns", (100, 220, 240)) 
rs.ObjectLayer (c_list, "columns")
rs.AddLayer("plates") 
rs.LayerColor ("plates", (110, 30, 90))
rs.ObjectLayer (p_list, "plates") 


# facade one
bsize = 0.2             # side length of box
dist = 0.01             # distance between boxes
offs = bsize + dist     # offset of boxes
num = 30                # number of boxes in one row
numy= int(p_length/offs/2)
numz=int(p_height/offs)

#box
corners = [(0,0,0),(bsize,0,0),(bsize,bsize,0),(0,bsize,0), 
            (0,0,bsize),(bsize,0,bsize),(bsize,bsize,bsize),(0,bsize,bsize)]
                
for j in range(numy):
    for p in range(numz):
        myran = ran.randint(0,12)
        if (myran >= 3):
            if ((j*p)%5) and ((j-p)%5):
                box = rs.AddBox(corners)
                rs.MoveObject(box, (0, j*offs, p*offs))
                rs.MoveObject(box, (-B, p_length/2, f_height))

# facade two
width= 0.2
depth= 13.0
f_length = int((p_length/offs/2)/2)
off = A*(xcol-2.7)+B+depth/2

# facade offset
def make_facade(insertion= [0,0,0] ,depth=0.2, width=0.1, height=(levels-1)*(hgt+thick)+thick, dist=0.4):
    fcd = []
    for i in range(f_length):
        fcd.append(make_box([off,i*dist-f_size/2,f_height], depth, width, height))
    return(fcd)
    
make_facade()

def make_box (insertion= [0,0,0], xsize=10, ysize=10, zsize=10) :
        # 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)