# -*- coding: utf-8 -*-

import rhinoscriptsyntax as rs
import random
import math

# Zeichnen mal ausschalten, damit es schneller läuft
rs.EnableRedraw(0)

# Alles löschen, was schon da is
all_objects = rs.AllObjects()
rs.DeleteObjects(all_objects)

# Macht nen Farbverlauf von Weiß über Rosa zu Lila
def gradient_color(index, total_points):
    ratio = index / float(total_points)
    red = int(255 * (1 - ratio))  # Geht von Weiß zu Lila
    green = int(100 * (1 - ratio))
    blue = int(255 * ratio)
    return [red, green, blue]

# "Knäuel" aus Linien machen, das wie ne Kugel aussieht
sphere_center = [0, 0, 0]  # Mittelpunkt vom Knäuel
sphere_radius = 30  # Groß genug, dass die Würfel drumrum passen
num_curves = 70  # Wie viele Linien ins Knäuel kommen
curve_points_per_curve = 10  # Wie viele Punkte pro Linie

for _ in range(num_curves):
    points = []
    for _ in range(curve_points_per_curve):
        # Zufällige Punkte innerhalb der Kugel
        theta = random.uniform(0, 2 * math.pi)
        phi = random.uniform(0, math.pi)
        r = random.uniform(0.7 * sphere_radius, sphere_radius)  # Radius bisschen zufällig
        x = sphere_center[0] + r * math.sin(phi) * math.cos(theta)
        y = sphere_center[1] + r * math.sin(phi) * math.sin(theta)
        z = sphere_center[2] + r * math.cos(phi)
        points.append([x, y, z])
    # Linie aus den Punkten machen
    curve = rs.AddCurve(points)
    rs.ObjectColor(curve, [0, 0, 0])  # Schwarze Linien

# Würfelgrößen festlegen
cube_sizes = [5.0, 6.0, 7.0, 8.0]  # Jeder Würfel hat ne andere Größe

# Positionen der Würfel rund ums Knäuel, jeder berührt’s von ner anderen Seite
cube_positions = [
    [sphere_radius + cube_sizes[0] / 2, 0, -cube_sizes[0] / 2],   # Auf der X-Achse
    [-(sphere_radius + cube_sizes[1] / 2), 0, -cube_sizes[1] / 2], # Auf der -X-Achse
    [0, sphere_radius + cube_sizes[2] / 2, -cube_sizes[2] / 2],   # Auf der Y-Achse
    [0, -(sphere_radius + cube_sizes[3] / 2), -cube_sizes[3] / 2]  # Auf der -Y-Achse
]

# Würfel generieren, jeder hat Punkte drin und ne gelbe Linie
for size, position in zip(cube_sizes, cube_positions):
    coordinates = []
    x_value = y_value = z_value = size  # Abstand der Punkte hängt von der Würfelgröße ab
    
    # Punkte im Würfel mit bisschen Zufall
    for i in range(5):  # Weniger Punkte für Übersichtlichkeit
        for j in range(5):
            for k in range(5):
                x = position[0] + i * x_value + random.uniform(0.5, x_value)
                y = position[1] + j * y_value + random.uniform(0.5, y_value)
                z = position[2] + k * z_value + random.uniform(0.5, z_value)
                coordinates.append([x, y, z])
    
    # Punkte für den Würfel hinzufügen
    points = rs.AddPoints(coordinates)
    
    # Punkte vom Würfel in nem Farbverlauf
    for idx, point in enumerate(points):
        color = gradient_color(idx, len(points))
        rs.ObjectColor(point, color)

    # Punkte mischen und ne gelbe Linie draus machen
    random.shuffle(coordinates)
    curve = rs.AddCurve(coordinates, 1)
    rs.ObjectColor(curve, [255, 255, 0])  # Gelbe Linie im Würfel

# Zeichnen wieder anschalten
rs.EnableRedraw(1)