import rhinoscriptsyntax as rs
import math
import random  

rs.DeleteObjects(rs.AllObjects())

rs.EnableRedraw(False)

def generate_sphere_points(radius, center, num_points):
    points = []
    for i in range(num_points):
        theta = math.acos(1 - 2 * i / num_points)
        phi = math.sqrt(num_points * math.pi) * theta
        
        x = center[0] + radius * math.sin(theta) * math.cos(phi)
        y = center[1] + radius * math.sin(theta) * math.sin(phi)
        z = center[2] + radius * math.cos(theta)
        
        points.append([x, y, z])
    return points

def generate_cube_points(center, size, cube_density):
    half_size = int(size / 2)
    cube_density = int(cube_density)
    points = []
    for x in range(-half_size, half_size, cube_density):
        for y in range(-half_size, half_size, cube_density):
            for z in range(-half_size, half_size, cube_density):
                point = [center[0] + x, center[1] + y, center[2] + z]
                points.append(point)
    return points

def sphere(radius, center, num_points):
    sphere_points = generate_sphere_points(radius, center, num_points)
    sphere_point_objects = [rs.AddPoint(pt) for pt in sphere_points]
    
    
    sphere_color = (0, 0, 255)  
    for point in sphere_point_objects:
        rs.ObjectColor(point, sphere_color)
    
    
    for i in range(0, len(sphere_points), int(num_points / 100)):
        start = sphere_points[i]
        end = sphere_points[(i + 10) % len(sphere_points)]
        rs.AddCurve([start, end], 1)
        
    return sphere_point_objects

def rubiks_cube(center, cube_size, cube_density, spacing):
    half_size = cube_size / 2
    rubiks_cubes = []
    offsets = [-1, 0, 1]  
    for x_offset in offsets:
        for y_offset in offsets:
            for z_offset in offsets:
                if x_offset == y_offset == z_offset == 0:
                    continue  
                
                cube_center = [
                    center[0] + x_offset * (cube_size + spacing),
                    center[1] + y_offset * (cube_size + spacing),
                    center[2] + z_offset * (cube_size + spacing)]
                
                cube_points = generate_cube_points(cube_center, cube_size, cube_density)
                cube_point_objects = [rs.AddPoint(pt) for pt in cube_points]
                
                
                num_lines = random.randint(15, 30)  
                for _ in range(num_lines):
                    p1 = random.choice(cube_points)  
                    p2 = random.choice(cube_points)
                    rs.AddCurve([p1, p2], 1)  
                
                rubiks_cubes.extend(cube_point_objects)
    
    return rubiks_cubes

cube_size = 15
cube_density = 1 
spacing = 1  
sphere_radius = cube_size / 1.10  
sphere_center = [0, 0, 0]
sphere_point_count = 500  


sphere(sphere_radius, sphere_center, sphere_point_count)


rubiks_cube(sphere_center, cube_size, cube_density, spacing)

rs.EnableRedraw(True)