import rhinoscriptsyntax as rs
import random as ran
import math

# Alle Objekte aus der Szene loeschen
rs.DeleteObjects(rs.AllObjects())

# Box-Dimensionen definieren
width = 10
depth = 10
height = 10

# Ursprungspunkt definieren
origin = (0, 0, 0)

# Stuetzen-Einstellungen
double_supports = True  # Falls True, werden die Stuetzen mehrfach dupliziert
support_copies = 0  # Wie oft die Stuetzen kopiert werden sollen (Original + Kopien)

# Individuelle Offset-Werte fuer die Kopien der Stuetzen
support_shift_x = 0.0  # Verschiebt die Stuetzen nach rechts/links
support_shift_y = 5.0  # Verschiebt die Stuetzen nach vorne/hinten
support_shift_z = 0.0  # Verschiebt die Stuetzen nach oben/unten

# Funktion zum Erstellen einer Box
def create_box(origin, width, depth, height):
    corners = [
        (origin[0], origin[1], origin[2]),
        (origin[0] + width, origin[1], origin[2]),
        (origin[0] + width, origin[1] + depth, origin[2]),
        (origin[0], origin[1] + depth, origin[2]),
        (origin[0], origin[1], origin[2] + height),
        (origin[0] + width, origin[1], origin[2] + height),
        (origin[0] + width, origin[1] + depth, origin[2] + height),
        (origin[0], origin[1] + depth, origin[2] + height)
    ]
    return rs.AddBox(corners)

# Hauptbox erstellen
tower = create_box(origin, width, depth, height)

# Select the box for further operations
rs.SelectObject(tower)

# Create contour lines in Z-direction and extrude them (floor plates)
rs.Command("Contour 0,0,0 0,0,1 3.0 _Enter")
rs.Command("_ExtrudeCrv Solid=Yes 0.3 _Enter")

# Create contour lines in X-direction and use the pipe command (vertical support)
rs.SelectObject(tower)
rs.Command("Contour 0,0,0 1,0,0 2.0 _Enter")
rs.Command("Pipe 0.2 _Enter")


# Funktion zum Erstellen gestufter Stuetzen
def create_stepped_supports(origin, box_width, box_depth, box_height, num_steps=10):
    supports = []
    step_decrease_factor = 0.5  # Faktor zur Verkleinerung der Stuetzen mit jeder Stufe
    initial_support_width = 2  # Anfangsbreite der Stuetzen
    initial_support_depth = 3  # Anfangstiefe der Stuetzen
    support_height_factor = 1  # Verhaeltnis der Stuetzenhoehe zur Boxhoehe
    
    for i in range(num_steps):
        # Berechnung der Stuetzenhoehe
        support_height = box_height * (support_height_factor / num_steps)
        # Stuetzen mit jedem Schritt kleiner machen
        support_width = initial_support_width * (step_decrease_factor ** i)
        support_depth = initial_support_depth * (step_decrease_factor ** i)
        
        # Original-Stuetzenpositionen
        right_support_origin = (origin[0] + box_width, origin[1], origin[2] + support_height * i)
        left_support_origin = (origin[0] - support_width, origin[1], origin[2] + support_height * i)
        
        # Originale Stuetzen erstellen
        supports.append(create_box(right_support_origin, support_width, support_depth, support_height))
        supports.append(create_box(left_support_origin, support_width, support_depth, support_height))
        
        # Falls doppelte Stuetzen aktiviert sind, erstelle Kopien
        if double_supports:
            for j in range(1, support_copies + 1):
                right_support_offset = (
                    right_support_origin[0] + j * support_shift_x,
                    right_support_origin[1] + j * support_shift_y,
                    right_support_origin[2] + j * support_shift_z
                )
                left_support_offset = (
                    left_support_origin[0] - j * support_shift_x,
                    left_support_origin[1] + j * support_shift_y,
                    left_support_origin[2] + j * support_shift_z
                )

                supports.append(create_box(right_support_offset, support_width, support_depth, support_height))
                supports.append(create_box(left_support_offset, support_width, support_depth, support_height))
    
    return supports

# Funktion zum Erstellen der treppenartigen Pyramide
def create_stepped_pyramid(origin, width, depth, height, pyramid_height, pyramid_levels, step_depth):
    step_height = pyramid_height / pyramid_levels  # Hoehe jeder Stufe
    
    for i in range(pyramid_levels):
        # Berechnung der neuen Dimensionen jeder Stufe
        new_width = width - (i * step_depth * 2)
        new_depth = depth - (i * step_depth * 2)
        
        # Sicherstellen, dass die Breite und Tiefe nicht negativ werden
        if new_width <= 0 or new_depth <= 0:
            break
        
        # Berechnung der neuen Position jeder Stufe
        new_origin = (
            origin[0] + (i * step_depth),
            origin[1] + (i * step_depth),
            origin[2] + height + (i * step_height)
        )

        # Stufe erstellen
        create_box(new_origin, new_width, new_depth, step_height)

# Parameter fuer die Pyramide definieren
pyramid_height = 2  # Gesamthoehe der Pyramide
pyramid_levels = 10  # Anzahl der Stufen
step_depth = 0.8  # Wie tief die Stufen sind

# Treppenartige Pyramide auf die Box setzen
create_stepped_pyramid(origin, width, depth, height, pyramid_height, pyramid_levels, step_depth)

# Stepped Supports mit Verdoppelungs-, Verschiebungs- und Multiplikationsoptionen hinzufuegen
stepped_supports = create_stepped_supports(origin, width, depth, height)

# Neuzeichnen aktivieren
rs.EnableRedraw(True)