path: root/blender/bloques.py

# -*- coding: utf-8 -*-
"""BLOQUES - la pila armonica que sobresale de la mesa sin limite.

Blender disena (mesa, piso, bloques de madera) y exporta a glTF; Godot (Jolt)
decide que se sostiene y que se cae. Hay tres experimentos, cada uno en su
propio carril de la mesa (Y distinta) para que no se toquen; al renderizar se
trae al frente el que toca y se ocultan los otros.

  A: la escalera "obvia", cada bloque corrido medio largo  -> se cae
  B: 5 bloques armonicos (1/2, 1/4, 1/6, 1/8, 1/10)        -> se sostiene
  C: 16 bloques armonicos; en el beat 8 se le apoya uno mas -> se cae todo

Los corrimientos armonicos se escalan por C_SEG = 0,95: asi el centro de masa
de cada subpila queda (1-C)/2 = 2,5 % de largo adentro del borde que la
sostiene, en todos los pisos. Sin ese margen, el solver decide al azar.
"""
import math, os, sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import bpy
from base import *

NOMBRE = "bloques"
L, H, P = 1.0, 0.16, 0.50        # largo, alto, profundidad del bloque
C_SEG = 0.95
C_TORRE = float(os.environ.get("T_C", C_SEG))   # la torre alta necesita mas margen con el solver
Z_PISO = -3.5                    # mesa de 70 cm con bloques de 20 cm
GRAV = 49.0                      # 9,81 / 0,2: bloques de 20 cm de verdad
CARRIL = {"a": 0.0, "b": 3.0, "c": 6.0, "x": 6.0}
N_B, N_C = 5, 16
DX_EXTRA = float(os.environ.get("T_DX", -0.45))   # donde se apoya el bloque de mas


def pila(n, c=C_SEG):
    """Centros x de una pila armonica de n bloques (indice 0 = el de arriba)."""
    xs = [0.0] * n
    x = -L / 2                                  # la mesa hace de bloque n+1
    for k in range(n, 0, -1):
        x += c * L / (2 * k)
        xs[k - 1] = x
    return xs


def z_de(n, k):
    """Altura del centro del bloque k (0 = arriba) en una pila de n."""
    return (n - 1 - k) * H + H / 2


def construir():
    escena(muestras=int(os.environ.get("MUESTRAS", 24)))
    mundo_estudio(fuerza=0.55)
    M = {
        "bloque": madera("bloque", claro="#E2B880", oscuro="#B07A45", escala=5.0, rug=0.5),
        "arriba": material("arriba", "ambar", rug=0.35),
        "mesa": madera("mesa", claro="#6B4426", oscuro="#2E1A0C", escala=2.5, rug=0.35,
                       veta=(0.4, 1, 1)),
        "piso": madera("piso", claro="#3A3F4B", oscuro="#1E222B", escala=1.5, rug=0.6,
                       veta=(0.3, 1, 1)),
        "invisible": material("inv", "gris"),
    }
    fis = []
    mesa = caja("caja_mesa", (6.0, 9.0, 0.3), (-3.0, 3.0, -0.15), M["invisible"])
    piso = caja("caja_piso", (30.0, 30.0, 0.2), (0.0, 3.0, Z_PISO - 0.1), M["invisible"])
    mesa.hide_render = piso.hide_render = True
    fis += [mesa, piso]
    # lo que se ve de la mesa y el piso: solo el carril del frente
    caja("mesa_v", (6.0, 2.4, 0.3), (-3.0, 0.4, -0.15), M["mesa"])
    m_pata = metal("pata", "#2A2F3A", rug=0.4)
    caja("pata", (0.14, 0.14, -Z_PISO - 0.3), (-0.35, -0.55, (Z_PISO - 0.3) / 2), m_pata)
    caja("pata2", (0.14, 0.14, -Z_PISO - 0.3), (-0.35, 1.3, (Z_PISO - 0.3) / 2), m_pata)
    caja("piso_v", (14.0, 5.0, 0.2), (1.0, 1.0, Z_PISO - 0.1), M["piso"])

    bl = {}
    # A: escalera "obvia"
    for k in range(5):
        x = -0.25 + 0.5 * (4 - k)
        bl[f"a{k}"] = caja(f"bloque_a{k}", (L, P, H), (x, CARRIL["a"], z_de(5, k)), M["bloque"])
    # B: armonica de 5
    for k, x in enumerate(pila(N_B)):
        bl[f"b{k}"] = caja(f"bloque_b{k}", (L, P, H), (x, CARRIL["b"], z_de(N_B, k)),
                           M["arriba"] if k == 0 else M["bloque"])
    # C: armonica de 16 y el bloque de mas, esperando arriba
    xc = pila(N_C, C_TORRE)
    for k, x in enumerate(xc):
        bl[f"c{k:02d}"] = caja(f"bloque_c{k:02d}", (L, P, H), (x, CARRIL["c"], z_de(N_C, k)),
                               M["arriba"] if k == 0 else M["bloque"])
    bl["x"] = caja("bloque_x", (L, P, H), (xc[0] + DX_EXTRA, CARRIL["x"], z_de(N_C, 0) + H + 0.005),
                   M["bloque"])
    fis += list(bl.values())
    return dict(fis=fis, bl=bl, M=M)


def eventos(T):
    t = lambda f: (f - 1) / FPS
    fa = T.rango(1)[0] + int(0.55 * (T.rango(1)[1] - T.rango(1)[0]))
    fx = T.rango(8)[0] + int(0.70 * (T.rango(8)[1] - T.rango(8)[0]))
    return {"a": fa, "b": T.rango(4)[0], "c": T.rango(7)[0], "x": fx}, [
        {"t": t(fa), "accion": "soltar", "prefijo": "bloque_a"},
        {"t": t(T.rango(4)[0]), "accion": "soltar", "prefijo": "bloque_b"},
        {"t": t(T.rango(7)[0]), "accion": "soltar", "prefijo": "bloque_c"},
        {"t": t(fx), "accion": "soltar", "prefijo": "bloque_x"},
    ]


def simular(T, obj):
    _, ev = eventos(T)
    cfg = {
        "duracion": T.n_frames / FPS + 0.2,
        "gravedad": GRAV,
        "escala": float(os.environ.get("T_ESC", 5.0)),
        "hz": int(os.environ.get("T_HZ", 1920)),
        "congelados": ["bloque_"],
        "reglas": {
            "bloque_": {"friccion": 0.55, "rebote": 0.08, "densidad": 600},
            "caja_": {"friccion": 0.6, "rebote": 0.05},
        },
        "eventos": ev,
    }
    correr_godot(exportar_fisica(NOMBRE, obj["fis"], cfg))


def main():
    T = Tiempo(NOMBRE)
    obj = construir()
    if os.environ.get("MODO") == "sim":
        simular(T, obj)
        return
    idx, D = cargar_sim(NOMBRE)
    bl, M = obj["bl"], obj["M"]
    suelta, _ = eventos(T)
    xc = pila(N_C, C_TORRE)

    # reporte: que quedo en pie
    for g, n in (("a", 5), ("b", N_B), ("c", N_C)):
        nom = [k for k in bl if k.startswith(g) and k != "x"]
        zmin = min(D[-1, idx[bl[k].name], 2] for k in nom)
        zmin_antes = min(D[min(len(D) - 1, suelta["x"] - 5), idx[bl[k].name], 2] for k in nom)
        print(f"[{NOMBRE}] pila {g}: z minima al final {zmin:+.2f}  "
              f"(antes del bloque extra {zmin_antes:+.2f})")
    print(f"[{NOMBRE}] B: el de arriba arranca en x={pila(N_B)[0] - L / 2:+.3f} "
          f"(sobresale {pila(N_B)[0] + L / 2:.3f});  C sobresale {xc[0] + L / 2:.3f}")

    # --- dibujos -------------------------------------------------------------
    m_borde = material("borde", "celeste", emis=2.5)
    borde = curva_poly("borde", [[(0, -0.30, z0), (0, -0.30, z0 + 0.09)]
                                 for z0 in [0.02 + 0.16 * i for i in range(18)]],
                       grosor=0.012, mat=m_borde)
    etiquetas = []
    xb = pila(N_B)
    for k in range(N_B):
        num = texto(f"1/{2 * (k + 1)}", tam=0.15, color="ambar")
        # el corrimiento de este bloque respecto del de abajo, a su derecha
        num.location = (xb[k] + L / 2 + 0.16, -0.30, z_de(N_B, k))
        etiquetas.append(num)
    aire = curva_poly("aire", [[(0, -0.3, 0.9), (xb[0] - L / 2, -0.3, 0.9)]],
                      grosor=0.02, mat=material("aire", "rosa", emis=3.0))
    aire_t = texto("en el aire", tam=0.16, color="rosa")
    aire_t.location = (0.45, -0.3, 1.08)
    # centros de masa de cada subpila, sobre el borde que la sostiene
    cms = []
    for k in range(1, N_B + 1):
        x_cm = sum(xb[:k]) / k
        e = esfera(f"cm{k}", 0.045, material(f"mcm{k}", "ambar", emis=3.0))
        e.location = (x_cm, -0.30, z_de(N_B, k - 1) - H / 2)
        cms.append(e)
    cuenta = texto("16 bloques", tam=0.22, color="blanco")
    sobre = texto("sobresale 1,6 bloques", tam=0.18, color="ambar")
    regla = curva_poly("regla", [[(0, -0.3, 2.78), (xc[0] + L / 2, -0.3, 2.78)]],
                       grosor=0.018, mat=material("regla", "ambar", emis=3.0))

    lente = 50.0
    cam = camara((0, -8, 1), (0, 0, 0), lente=lente)
    cam.data.sensor_fit = 'VERTICAL'
    cam.data.sensor_height = 36.0
    luz("key", 'AREA', (-3.0, -4.0, 5.0), 1400, "blanco", tam=4.0, mira=(0.5, 0, 0.8))
    luz("fill", 'AREA', (4.0, -3.0, 0.5), 350, "blanco", tam=4.0, mira=(0.5, 0, 0.5))
    luz("rim", 'AREA', (1.0, 4.0,