import rhinoscriptsyntax as rs
import random as ran

# Delete all objects and start from scratch
rs.DeleteObjects(rs.AllObjects())

# Disable redraw for faster execution
rs.EnableRedraw(False)

#Domino variables

A           = 5                     # A = Module size (distance between columns)
B           = A/3                   # B = Distance of columns to end of plate
thick       = 0.18                  # thicknes 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                   # f_height = foundation height
f_size       = 0.8                   # f_size = 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                     # lenght of floor plate (y)

def make_box(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, (-xsize/2,-ysize/2,0))
    rs.MoveObject(box, insertion)
    return(box)

#make_box([10,-3,0],6,9,10)

#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.5, 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)


f_list=[]               # list of foundations
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("column")
rs.LayerColor("column"), (220,60,60)
rs.ObjectLayer(f_list,"column")
rs.AddLayer("plate")
rs.LayerColor("plate"), (220,60,60)
rs.ObjectLayer(f_list,"plate")

print f_list
print c_list
print p_list

# Size and number of boxes
xbsize = thick            
zbsize = (2 * hgt + 3 * thick) / 14
ybsize = (2 * A + f_size) / 14
ynum = 12   # Number of rows in the y-direction (1 row)
xnum = 1  # Number of boxes in the x-direction (wide)
znum = 14  # Number of boxes in the z-direction (depth)

# Create base box corners
corners = [(0, 0, 0), (xbsize, 0, 0), (xbsize, ybsize, 0), (0, ybsize, 0),
           (0, 0, zbsize), (xbsize, 0, zbsize), (xbsize, ybsize, zbsize), (0, ybsize, zbsize)]

# Create and move boxes randomly with color
for i in range(ynum):     # Loop for X-axis
    for j in range(znum): # Loop for Z-axis (filling the area in one layer)
        my_ran = ran.randint(0, 9)
        if my_ran >= 3:  # Only create box if random condition is met (like in the original)
            box = rs.AddBox(corners)  # Create the box
            
            # Move box based on X-Z grid structure, all boxes remain in the same Y-plane (flat)
            rs.MoveObject(box, (i * ybsize, 0, j * zbsize))
            rs.MoveObject(box, ((-B - xbsize), (-f_size / 2), (f_height)))
            
            # Assign random color to the box
            color = (ran.randint(0, 255), ran.randint(0, 255), ran.randint(0, 255))
            rs.ObjectColor(box, color)

# Enable redraw to update the view
rs.EnableRedraw(True)