import rhinoscriptsyntax as rs
import Rhino.Geometry as rg
import random as r


def draw_castle(o, l, w, h, t, f_fort, f_towers):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    draw_fort_floors(o, l, w, h, t, f_fort)
    
    draw_tower_a_floors(o + vz*h*f_fort, l, w, h, t, f_towers[0])
    draw_tower_b_floors(o + vz*h*f_fort, l, w, h, t, f_towers[1])
    draw_tower_c_floors(o + vz*h*f_fort, l, w, h, t, f_towers[2])
    draw_tower_d_floors(o + vz*h*f_fort, l, w, h, t, f_towers[3])


def draw_fort_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        draw_fort(o + vz*h*n, l, w, h, t)
        draw_fort_vert(o + vz*h*n, l, w, h, t)
        if n == f-1: draw_fort(o + vz*h*(n+1), l, w, h, t)


def draw_tower_a_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_a(o + vz*h*n, l, w, h, t, [0,0,1,1])
        else: draw_tower_a(o + vz*h*n, l, w, h, t)
        draw_tower_a_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_a(o + vz*h*(n+1), l, w, h, t)
            draw_tower_a_cap(o + vz*h*(n+1), l, w, h, t)


def draw_tower_b_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_b(o + vz*h*n, l, w, h, t, [0,1,0,1])
        else: draw_tower_b(o + vz*h*n, l, w, h, t)
        draw_tower_b_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_b(o + vz*h*(n+1), l, w, h, t)
            draw_tower_b_cap(o + vz*h*(n+1), l, w, h, t)


def draw_tower_c_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_c(o + vz*h*n, l, w, h, t, [1,0,1,0])
        else: draw_tower_c(o + vz*h*n, l, w, h, t)
        draw_tower_c_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_c(o + vz*h*(n+1), l, w, h, t)
            draw_tower_c_cap(o + vz*h*(n+1), l, w, h, t)


def draw_tower_d_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_d(o + vz*h*n, l, w, h, t, [1,1,0,0])
        else: draw_tower_d(o + vz*h*n, l, w, h, t)
        draw_tower_d_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_d(o + vz*h*(n+1), l, w, h, t)
            draw_tower_d_cap(o + vz*h*(n+1), l, w, h, t)


def draw_fort(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vx*l)
    rs.AddLine(o, o + vy*w)
    rs.AddLine(o + vx*l, o + vx*l + vy*w)
    rs.AddLine(o + vy*w, o + vx*l + vy*w)
    
    rs.AddLine(o + vx*t + vy*t, o + vx*(l-t) + vy*t)
    rs.AddLine(o + vx*t + vy*t, o + vx*t + vy*(w-t))
    rs.AddLine(o + vx*(l-t) + vy*t, o + vx*(l-t)+ vy*(w-t))
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*(l-t)+ vy*(w-t))


def draw_fort_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vy*w, o + vy*w + vz*h)
    rs.AddLine(o + vx*l, o + vx*l + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)
    
    rs.AddLine(o + vx*t + vy*t, o + vx*t + vy*t + vz*h)
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*t + vy*(w-t) + vz*h)
    rs.AddLine(o + vx*(l-t) + vy*t, o + vx*(l-t) + vy*t + vz*h)
    rs.AddLine(o + vx*(l-t)+ vy*(w-t), o + vx*(l-t)+ vy*(w-t) + vz*h)


def draw_tower_a(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o, o + vx*t)
    if elements[1]: rs.AddLine(o, o + vy*t)
    if elements[2]: rs.AddLine(o + vx*t, o + vx*t + vy*t)
    if elements[3]: rs.AddLine(o + vy*t, o + vx*t + vy*t)


def draw_tower_b(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vx*(l-t), o + vx*l)
    if elements[1]: rs.AddLine(o + vx*(l-t), o + vy*t + vx*(l-t))
    if elements[2]: rs.AddLine(o + vx*l, o + vx*l + vy*t)
    if elements[3]: rs.AddLine(o + vy*t + vx*(l-t), o + vx*l + vy*t)


def draw_tower_c(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vy*(w-t), o + vx*t + vy*(w-t))
    if elements[1]: rs.AddLine(o + vy*(w-t), o + vy*w)
    if elements[2]: rs.AddLine(o + vx*t + vy*(w-t), o + vx*t + vy*w)
    if elements[3]: rs.AddLine(o + vy*w, o + vx*t + vy*w)


def draw_tower_d(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vx*l + vy*(w-t))
    if elements[1]: rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vy*w + vx*(l-t))
    if elements[2]: rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*w)
    if elements[3]: rs.AddLine(o + vy*w + vx*(l-t), o + vx*l + vy*w)


def draw_tower_a_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vy*t, o + vy*t + vz*h)
    rs.AddLine(o + vx*t, o + vx*t + vz*h)
    rs.AddLine(o + vx*t + vy*t, o + vx*t + vy*t + vz*h)


def draw_tower_b_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vx*(l-t), o + vx*(l-t) + vz*h)
    rs.AddLine(o + vy*t + vx*(l-t), o + vy*t + vx*(l-t) + vz*h)
    rs.AddLine(o + vx*l, o + vx*l + vz*h)
    rs.AddLine(o + vx*l + vy*t, o + vx*l + vy*t + vz*h)


def draw_tower_c_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t), o + vy*(w-t) + vz*h)
    rs.AddLine(o + vy*w, o + vy*w + vz*h)
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*t + vy*(w-t) + vz*h)
    rs.AddLine(o + vx*t + vy*w, o + vx*t + vy*w + vz*h)


def draw_tower_d_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vy*(w-t) + vx*(l-t) + vz*h)
    rs.AddLine(o + vy*w + vx*(l-t), o + vy*w + vx*(l-t) + vz*h)
    rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*(w-t) + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)


def draw_tower_a_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vy*t, o + vz*h)
    rs.AddLine(o + vx*t, o + vz*h)
    rs.AddLine(o + vx*t + vy*t, o + vz*h)


def draw_tower_b_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vx*(l-t), o + vx*l + vz*h)
    rs.AddLine(o + vy*t + vx*(l-t), o + vx*l + vz*h)
    rs.AddLine(o + vx*l, o + vx*l + vz*h)
    rs.AddLine(o + vx*l + vy*t, o + vx*l + vz*h)


def draw_tower_c_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t), o + vy*w + vz*h)
    rs.AddLine(o + vy*w, o + vy*w + vz*h)
    rs.AddLine(o + vx*t + vy*(w-t), o + vy*w + vz*h)
    rs.AddLine(o + vx*t + vy*w, o + vy*w + vz*h)


def draw_tower_d_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vy*w + vx*(l-t), o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)




rs.EnableRedraw(False)
objects = rs.ObjectsByLayer("Default")
rs.DeleteObjects(objects)



grid_size_x = 20
grid_size_y = 20
grid_spacing = 20

for i in range(grid_size_x):
    for j in range(grid_size_x):
        
        o = rg.Point3d(i*grid_spacing, j*grid_spacing, 0)
        #l, w, h, t = 6, 4, 1, 1
        
        l = r.randint(5,15)
        w = r.randint(5,15)
        h = r.randint(1,5)
        t = r.randint(1,5)
        
        if t*2 >= l: t = int(l/2) - 1
        if t*2 >= w: t = int(w/2) - 1
        
        f_fort = 2
        f_towers = [2,1,3,5]
        
        draw_castle(o, l, w, h, t, f_fort, f_towers)



"""
o = rg.Point3d(0,0,0)
l, w, h, t = 6, 4, 1, 1
f_fort = 2
f_towers = [2,1,3,5]

draw_castle(o, l, w, h, t, f_fort, f_towers)
"""