PLANK — Board Assembly Language Lenguaje declarativo de construcciones en madera pieza a pieza

¿Qué es PLANK?

PLANK es un DSL declarativo para describir construcciones en madera rectangular. Decides tú mismo dónde va cada panel, con qué orientación y cómo se une a los demás. El sistema genera a partir de tu descripción la vista 3D, la lista de corte, la lista de herrajes y el presupuesto.

A diferencia de MFL, que trabaja a nivel de mueble completo con una estructura paramétrica, PLANK trabaja a nivel de panel: tú controlas exactamente dónde va cada pieza, cómo se orienta y cómo se une a las demás. Esto lo hace válido para cualquier construcción: muebles, pérgolas de jardín, porches de madera, bancadas de trabajo, estanterías a medida…

PLANK v2 elimina las rotaciones. Cada panel se declara con un tag (lateral, frontal o horizontal) que fija cómo sus dimensiones se proyectan sobre los ejes del mundo, y se posiciona con en [x, y, z]. Sin ángulos, sin offsets, sin giros.

¿Cuándo usar cada lenguaje?

MuebleLab ofrece tres lenguajes complementarios. Cada uno tiene su ámbito ideal:

	MFL	PLANK	CLF
Nivel	Alto — paramétrico	Medio — explícito	Plano — 2D
Para qué	Armarios y muebles estándar	Cualquier construcción en madera	Optimización de corte
Ejemplo	Armario 3 puertas en 10 líneas	Pérgola de jardín pieza a pieza	Lista de corte para la sierra
Editor	mfl.html	plank.html	clf.html

Como regla general: usa MFL para muebles de carcasa estándar con distribución de celdas, y usa PLANK cuando tengas formas no estándar, construcciones exteriores, o cuando necesites especificar exactamente dónde va cada tornillo.

Inicio rápido (3 minutos)

El ejemplo más sencillo posible: una estantería con dos laterales, suelo y tapa. Cuatro paneles, cuatro posiciones, una unión.

PLANK — estantería mínima

var _grueso = 19        # grueso del tablero
var _alto   = 720       # alto
var _ancho  = 800       # ancho
var _fondo  = 300       # fondo

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

panel lateral_izquierdo, lateral_derecho
  lateral
  largo = _alto
  ancho = _fondo

panel suelo, tapa
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo

lateral_izquierdo en [0,                0,                   0]
lateral_derecho   en [_ancho - _grueso, 0,                   0]
suelo             en [_grueso,          0,                   0]
tapa              en [_grueso,          _alto - _grueso,  0]

juntar lateral_izquierdo, suelo
  unir confirmat x2

Desglose del ejemplo:

Variables (var) — Definen grueso, alto, ancho y fondo. Empiezan con _ y se reutilizan en toda la definición.
Mueble — Define el bounding box y el grueso por defecto para todos los paneles.
Paneles (panel) — Declaran tableros con su tag de orientación y sus dimensiones. Una sola declaración con coma crea varios paneles idénticos.
Posición (en) — Sitúa la esquina inferior-izquierda-delantera del panel en coordenadas absolutas [X, Y, Z].
Uniones (juntar) — Declaran las conexiones estructurales entre paneles y los herrajes empleados.

Sistema de coordenadas

PLANK usa un sistema de coordenadas cartesiano en 3D. Entenderlo bien es fundamental para posicionar los paneles correctamente:

Y+ (arriba) | | | +------------- X+ (derecha — ancho del mueble) / / Z+ (hacia el fondo)

X+ — hacia la derecha (el ancho del mueble)
Y+ — hacia arriba (el alto del mueble)
Z+ — hacia el fondo (la profundidad del mueble)

Punto ancla de cada panel

El punto [x, y, z] que pasas a en es la esquina inferior-izquierda-delantera del panel. Desde ahí, el panel se extiende hacia X+, Y+ y Z+ según las dimensiones que su tag proyecta sobre cada eje.

No hay rotaciones, no hay offsets tras la orientación: la esquina donde pones el panel es exactamente la esquina que ves en 3D. Para saber cuánto ocupa el panel en cada eje, consulta la tabla de tags más abajo.

Variables

Las variables permiten definir valores numéricos con nombre y reutilizarlos en todas las dimensiones y posiciones. Cuando cambias una variable, todo lo que depende de ella se actualiza automáticamente.

Sintaxis

var _nombre = valor

Reglas importantes:

El nombre siempre empieza con _ (guión bajo)
El valor puede ser un número o una expresión aritmética
Puedes referenciar otras variables ya definidas
Operadores disponibles: + - * /

Token	Descripción	Ejemplo
`var`	Declara una variable numérica	`var _alto = 1900`
Expresiones	Aritmética con variables y números	`largo = _ancho - _grueso * 2`

Usa nombres explícitos. El código PLANK lo leen también carpinteros. Escribe _alto, _ancho, _fondo, _grueso en vez de _h, _a, _p, _g. Para dimensiones de paneles específicos usa sufijos: _grueso_puerta, _alto_zocalo.

Variables y expresiones

var _grueso    = 19             # grueso estándar
var _alto      = 1900           # alto total
var _ancho     = 900            # ancho total
var _fondo     = 350            # fondo
var _centro_x  = _ancho / 2     # centro en X (calculado)

panel suelo
  horizontal
  largo = _ancho - _grueso * 2   # ancho interior (descuenta dos gruesos)
  ancho = _fondo

El bloque mueble

El bloque mueble es opcional pero recomendado. Define el bounding box de la construcción y establece el grueso de tablero por defecto para todos los paneles que no especifiquen el suyo propio.

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

Los tres parámetros entre corchetes son, en orden: alto, ancho y fondo. Sirven para que el editor muestre el cubo envolvente de la construcción y para calcular correctamente la lista de materiales.

Si no incluyes el bloque mueble, PLANK calcula el bounding box automáticamente a partir de las posiciones de los paneles. Para construcciones simples puedes omitirlo sin problema — en ese caso, cada panel necesitará declarar su propio grueso.

Declarar un panel

panel declara una o varias piezas de madera con el mismo tamaño y la misma orientación. Cada pieza recibe un nombre único con el que luego la posicionas con en y la conectas con juntar.

Sintaxis

panel nombre
  lateral                   # tag de orientación — obligatorio
  largo    = valor
  ancho    = valor
  grueso   = valor         # opcional si hay bloque mueble
  material = blanco        # opcional
  rol      = costado       # opcional (interop con CAD)

Si separas varios nombres con coma en la misma declaración, PLANK crea piezas idénticas con esas dimensiones y esa orientación:

panel lateral_izquierdo, lateral_derecho
  lateral
  largo = 1900
  ancho = 350

Esto crea dos tableros idénticos de 1900 × 350 × 19 mm con el tag lateral, llamados lateral_izquierdo y lateral_derecho. Luego los posicionas por separado con en.

Propiedad	Descripción	Notas
`lateral` / `frontal` / `horizontal`	Tag de orientación — proyecta las dimensiones sobre los ejes del mundo	Obligatorio — ver sección Tags de orientación
`largo`	Dimensión principal del tablero (corre con la veta)	Obligatorio
`ancho`	Dimensión secundaria del tablero	Obligatorio
`grueso`	Espesor del tablero	Opcional — hereda del `mueble`; defecto 19 mm
`material`	Tipo o color del material	Opcional
`rol`	Rol semántico del panel para exportación a CAD	Opcional — ver sección Rol

Tags de orientación

En PLANK v2, cada panel lleva un tag que define cómo sus tres dimensiones de tablero (largo, ancho, grueso) se proyectan sobre los ejes del mundo (X, Y, Z). Hay tres tags, y son mutuamente excluyentes.

Tag	`largo` →	`ancho` →	`grueso` →	Veta	Uso típico
`lateral`	Y (alto)	Z (fondo)	X	Y (vertical)	Costados, divisores verticales
`frontal`	Y (alto)	X (ancho del mueble)	Z	Y (vertical)	Puertas, traseras, zócalos
`horizontal`	X (ancho del mueble)	Z (fondo)	Y	X (horizontal)	Suelos, tapas, baldas

Regla clave: la veta siempre corre a lo largo del largo del tablero. Esto es consistente con la industria del mueble y con la optimización de corte: al pedir un panel de 1900 × 350, la fibra va en los 1900 mm. Así, eliges el tag en función de cómo quieres que quede la veta montada.

Por ejemplo, una balda declarada como horizontal con largo = 760 y ancho = 350 ocupa:

X: 760 mm (el largo del tablero, con la veta)
Y: 19 mm (el grueso, canto vertical)
Z: 350 mm (el ancho del tablero, en profundidad)

Ejemplos de uso de cada tag

PLANK — los tres tags

# Costado: de pie, veta vertical, grueso se reparte en X
panel costado_izq
  lateral
  largo = 1900     # ocupa 1900 en Y (alto)
  ancho = 350      # ocupa 350 en Z (fondo)

# Trasera / puerta: de pie, veta vertical, grueso en Z
panel trasera
  frontal
  largo = 1900     # ocupa 1900 en Y (alto)
  ancho = 900      # ocupa 900 en X (ancho del mueble)

# Balda: tumbada, veta horizontal, grueso en Y
panel balda
  horizontal
  largo = 862      # ocupa 862 en X (ancho del mueble)
  ancho = 350      # ocupa 350 en Z (fondo)

Grueso por defecto

Si un panel no declara grueso, su espesor se deduce así, por orden de prioridad:

Si existe un bloque mueble con grueso = valor, hereda ese valor.
Si no hay bloque mueble (o el mueble no especifica grueso), usa 19 mm como defecto.

Por ese orden, basta con declarar el grueso una sola vez en el mueble para que todos los paneles de carcasa lo hereden. Un panel puede sobreescribirlo con su propia propiedad grueso — típico del fondo HDF, más delgado que el resto.

Herencia de grueso

mueble [1900, 900, 350]
  grueso = 19

panel costado
  lateral
  largo = 1900
  ancho = 350
  # grueso = 19 (heredado)

panel trasera_hdf
  frontal
  largo  = 1900
  ancho  = 900
  grueso = 8         # sobreescribe el del mueble

Rol (interop con CAD)

La propiedad opcional rol marca semánticamente qué función cumple el panel dentro de la construcción. PLANK la usa para exportar correctamente hacia programas CAD de carpintería industrial como CabinetVision, PolyBoard y Mozaik, que esperan un rol por panel para aplicar reglas de cantos, herrajes, etiquetado y lista de corte.

Para trabajo puramente en MuebleLab el rol es opcional; solo lo necesitas si vas a exportar la construcción a esos programas externos.

PLANK	CabinetVision	PolyBoard	Mozaik
`costado`	Side	Côté	Side
`tapa`	Top	Dessus	Top
`suelo`	Bottom	Fond bas	Bottom
`trasera`	Back	Fond arrière	Back
`balda`	Shelf	Tablette	Shelf
`puerta`	Door	Façade porte	Door
`cajon_frente`	Drawer Front	Façade tiroir	Drawer Front
`divisor`	Partition	Séparation	Partition

panel costado_izq, costado_der
  lateral
  largo = _alto
  ancho = _fondo
  rol   = costado

Defaults de `largo` y `ancho`

En lateral y horizontal, si no declaras largo o ancho, el compilador los deduce a partir del esqueleto y del mueble. En frontal no se aplica default (sigue avisando con largo = 0).

Tag	Propiedad	Default
`horizontal`	`largo`	(`lateral_dcho.xMin` si existe — si no `cabinet.ancho`) − (`lateral_izq.xMax` si existe — si no `0`)
`lateral`	`largo`	(`tapa.yMin` si existe — si no `cabinet.alto`) − (`suelo.yMax` si existe — si no `0`)
`lateral` / `horizontal`	`ancho`	(`fondo.zMin` si existe — si no `cabinet.fondo`) − `retranqueo`

El default de ancho cubre los dos casos del fondo: si el fondo es superpuesto, fondo.zMin = cabinet.fondo y la pieza llega hasta el final del mueble; si es en ranura, fondo.zMin = cabinet.fondo − grueso_fondo y la pieza queda flush con el interior. Una balda parametrizable estándar puede declararse así:

panel balda
  horizontal

balda en [_grueso, 600, 0]

Retranqueo

Propiedad opcional retranqueo = N en mm. Desplaza la pieza N mm hacia el fondo (Z+) al posicionarla con en [...] — la z del vector se suma con el retranqueo.

Si ancho está declarado, no lo modifica.
Si ancho cae al default automático, este descuenta el retranqueo para que la pieza siga llegando al fondo.

panel balda
  horizontal
  retranqueo = 5     # 5 mm hacia atrás del frente del mueble

balda en [_grueso, 600, 0]

Atajos `puerta`, `balda`, `divisor`

Para piezas con tag y rol estándar, PLANK admite tres keywords paralelos a panel:

Atajo	Tag	Rol
`puerta`	`frontal`	`puerta`
`balda`	`horizontal`	`balda`
`divisor`	`lateral`	`divisor`

puerta puerta_izq
  largo = 800
  ancho = 380

balda b1          # sin propiedades: usa defaults inteligentes

divisor d1
  retranqueo = 10

Tag y rol son implícitos. Si declaras uno distinto en el cuerpo, se ignora con warning.
Aceptan todas las propiedades habituales: largo, ancho, grueso, material, retranqueo.
Sin propiedades, los defaults inteligentes cubren largo y ancho automáticamente para balda y divisor.
puerta activa la validación de gap mínimo (siguiente sección).
balda y divisor aceptan la cláusula entre (más abajo).

Puerta solapada — `en LATERAL`

Atajo para puertas verticales que se montan solapadas sobre la cara frontal del mueble, ancladas con bisagras a un lateral. La puerta cubre toda la altura visible (de suelo a tapa) y el compilador deduce posición y altura.

puerta p_izq en lateral_izquierdo
  ancho = 600

puerta p_dcha en divisor_central
  ancho = 400
  apertura = izquierda     # opcional
  retranqueo = 2           # opcional

Reglas geométricas

Anclaje	xMin / xMax	Apertura por defecto
`lateral_izquierdo`	`xMin = 0`, `xMax = ancho`	`izquierda`
`lateral_derecho`	`xMax = cabinet.ancho`, `xMin = xMax − ancho`	`derecha`
Lateral interior, apertura derecha	`xMax = ref.xMin + ref.grueso/2`, `xMin = xMax − ancho`	(default)
Lateral interior, apertura izquierda	`xMin = ref.xMax − ref.grueso/2`, `xMax = xMin + ancho`	(declarada)

Sobre divisores interiores la puerta cubre media cara del divisor (donde van las bisagras), de modo que dos puertas adyacentes se reparten el divisor central simétricamente.

Altura y profundidad

Altura: yMin = suelo.yMin y yMax = tapa.yMax si suelo y tapa existen; si no, usa los extremos del propio lateral. La puerta cubre toda la altura sobre el zócalo.
Profundidad: por defecto la puerta queda al ras del frente del mueble (zMin = -grueso, zMax = 0). retranqueo = N la mete N mm dentro del mueble.

Reglas y validaciones

ancho es obligatorio.
La ref debe ser un panel lateral (estructural o divisor). Anclar a una balda da error.
Solo en puerta; en panel/balda/divisor da error.
entre y en LATERAL son mutuamente excluyentes.
apertura admite solo izquierda o derecha.
Para puertas horizontales (alacenas que abren hacia arriba/abajo) usa panel ... rol = puerta con tag horizontal.

Cláusula `entre`

Atajo para fittear una pieza entre piezas vecinas con 1 mm de holgura por lado. Dos formas:

Con 2 referencias — `balda`, `divisor`, `puerta`

balda b1 entre lateral_izquierdo y panelv_1
b1.yMoverA = 600

divisor d1 entre suelo y tapa
d1.xMoverA = 900

puerta p1 entre lateral_izquierdo y lateral_derecho
  largo = 1862
p1.yMoverA = 19

En balda → cantos en X.
En divisor → cantos en Y.
En puerta con 2 refs → ajusta el eje según las refs (2 piezas verticales → cantos X; 2 horizontales → cantos Y). Las dos refs tienen que ser del mismo tipo, no se mezclan.

Con 4 referencias — solo `puerta` encastrada

puerta p1 entre lateral_izquierdo, balda1, divisor_centro y suelo

Sintaxis: entre A, B, C y D. El compilador clasifica cada ref por su geometría — vertical (dim Y > dim X) toca un canto en X, horizontal (dim X > dim Y) toca un canto en Y. Luego asigna Min/Max según posición. El orden en que escribas las refs es indiferente. Necesita exactamente 2 verticales y 2 horizontales.

Reglas comunes

Las referencias deben existir y estar posicionadas en el momento de la evaluación (orden lineal del fichero).
En panel genérico no se acepta — error.
Si la pieza no recibe en [...], el constraint la crea automáticamente con coordenadas libres en 0; las completas con xMoverA/yMoverA/zMoverA.
Si dos refs del mismo eje están solapadas (no hay sitio), error de dim ≤ 0.

Gap mínimo en puertas (validación automática)

Toda pieza con rol = puerta debe dejar al menos 1 mm de holgura con sus piezas vecinas en X y en Y para que no roce al cerrar. El compilador lo comprueba automáticamente y avisa si la puerta está pegada o solapando.

El método: se expande el rectángulo de la puerta 1 mm en X y en Y (no en Z) y se mira si cruza con cualquier otra pieza. Si cruza → warning. Las puertas solapadas (con zMin negativo) viven en plano Z disjunto del costado, así que no se confunden con encastradas y no disparan falsos positivos.

Caso	¿Warning?
Puerta encastrada con gap ≥ 1 mm	No
Puerta encastrada al ras (gap = 0)	Sí, uno por cada vecino
Puerta encastrada con solape	Sí, uno por cada vecino
Puerta solapada (zMin negativo)	No
Panel frontal sin `rol = puerta`	No (no es puerta)

Esqueleto — paneles estructurales auto-dimensionados

Para muebles rectangulares estándar, el bloque esqueleto genera los paneles estructurales (laterales, suelo, tapa, fondo) con dimensiones y posiciones calculadas automáticamente a partir del mueble y del tipo de encaje que declares. No tienes que calcular largos ni posiciones.

PLANK — esqueleto básico

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  fondo              superpuesto
    grueso = _grueso_fondo

El compilador genera los 5 paneles con nombres canónicos (lateral_izquierdo, lateral_derecho, suelo, tapa, fondo), con sus tags y posiciones correctas.

Tipos de encaje (`fit`)

Fit	Aplicable a	Efecto
`fit_alto`	laterales	Panel pasante de suelo a techo
`fit_entre_laterales`	suelo, tapa	Encastrado entre laterales
`sobre_laterales`	tapa	Por encima (admite vuelo)
`bajo_laterales`	suelo	Por debajo (admite vuelo)
`superpuesto`	fondo	Tapa entera, pegado al canto posterior
`ranura`	fondo	Encastrado en ranura fresada

Vuelos

Para tapas y suelos en modo sobre_laterales / bajo_laterales, puedes añadir vuelos:

Vuelos por lado

tapa  sobre_laterales
  vuelo_izq    = 20
  vuelo_der    = 20
  vuelo_frente = 30
  vuelo_fondo  = 0

Atajo: vuelo = 20 aplica el mismo vuelo a los 4 lados.

Módulos incompletos

Cada panel es opt-in por declaración. Si lo omites, no existe, y los vecinos extienden hasta el borde del mueble. Ejemplos útiles:

Módulo último de fila (sin lateral derecho):

esqueleto
  lateral_izquierdo  fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  fondo              superpuesto

Mueble suspendido (sin suelo, apoya encima de otro):

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  tapa               fit_entre_laterales
  fondo              superpuesto

Estantería abierta (solo laterales + base):

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales

Combinar con paneles manuales

Los paneles del esqueleto son idénticos a los declarados a mano. Puedes seguir declarando panels interiores (baldas, divisores) y usar los nombres canónicos del esqueleto en juntar:

panel balda_1
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo - _grueso_fondo

balda_1 en [_grueso, 800, 0]

juntar lateral_izquierdo, balda_1
  unir tubillon x4

Situar con `en`

en coloca la esquina inferior-izquierda-delantera del panel en unas coordenadas absolutas del espacio 3D. Es la única instrucción de posicionamiento en PLANK v2 — no hay rotaciones, offsets ni movimientos adicionales.

nombre en [x, y, z]

x — posición en el eje X (izquierda/derecha)
y — posición en el eje Y (abajo/arriba)
z — posición en el eje Z (frente/fondo)

Desde ese punto, el panel se extiende hacia X+, Y+ y Z+ ocupando exactamente lo que marque su tag. Puedes usar variables y expresiones dentro de los corchetes: en [_grueso, _alto - _grueso, 0].

Referencias entre piezas y mutación de cantos

Una vez una pieza está posicionada, puedes leer sus cantos y dimensiones en cualquier expresión, y modificar sus cantos individualmente sin volver a calcular dimensiones a mano.

Lectura: `pieza.campo`

Campos legibles tras posicionar:

Categoría	Campos
Cantos del AABB	`xMin`, `xMax`, `yMin`, `yMax`, `zMin`, `zMax`
Dimensiones del tablero	`largo`, `ancho`, `grueso`

# Pegar la balda al canto derecho del lateral izquierdo
panel balda
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo

balda en [lateral_izquierdo.xMax, 600, 0]

La pieza referenciada debe existir en el momento de evaluar la expresión. El resolver es perezoso: las expresiones de un bloque panel (largo, ancho, grueso) se evalúan cuando la pieza se posiciona con en [...] o se muta, no en su declaración. Basta con que la pieza referenciada aparezca antes en el orden del fichero.

Mutación: `pieza.<canto> = expr`

Mueve solo ese canto. La dimensión del eje se recalcula; el canto opuesto queda intacto.

balda.xMax = 1000     # acorta o alarga la balda dejando xMin igual
balda.xMin = 50       # idem para el otro extremo

Traslación: `pieza.<eje>MoverA = expr`

Mantiene las dimensiones y traslada la pieza fijando su canto Min en el valor dado. Equivale a xMin = expr; xMax = expr + dim_actual.

balda.xMoverA = 0      # mueve manteniendo el largo
balda.yMoverA = 1200   # sube la balda a 1200 mm sin tocar dimensiones

Eje del grueso bloqueado

El canto que define el grueso del tablero no se puede mutar (sería incoherente con la cutlist). El eje bloqueado depende del tag:

Tag	Eje del grueso	Cantos bloqueados	Cantos editables
`lateral`	X	`xMin`, `xMax`	yMin/yMax (largo), zMin/zMax (ancho)
`horizontal`	Y	`yMin`, `yMax`	xMin/xMax (largo), zMin/zMax (ancho)
`frontal`	Z	`zMin`, `zMax`	xMin/xMax (ancho), yMin/yMax (largo)

xMoverA/yMoverA/zMoverA están siempre permitidos: solo trasladan, nunca tocan dimensiones.

Reglas de aplicación

Las mutaciones se aplican en orden del fichero, sobre el estado vigente de la pieza.
Si la pieza está declarada como panel pero no tiene en [...], arranca implícitamente en [0, 0, 0] y se le aplica la mutación encima.
Si el mismo canto se asigna varias veces, gana el último (sin warning).
La cutlist se emite con los largo/ancho finales, tras todas las mutaciones.

Ejemplo: armario

Para un armario de 1800 × 1900 × 350 mm (ancho × alto × fondo) con grueso de carcasa de 19 mm, 2 laterales, suelo y tapa superior, 2 baldas intermedias y trasera HDF de 8 mm, las posiciones y bounds resultantes son:

Panel	Tag	Dims tablero	`en`	Bounds X	Bounds Y	Bounds Z
`lateral_izquierdo`	`lateral`	1900 × 350 × 19	[0, 0, 0]	0 → 19	0 → 1900	0 → 350
`lateral_derecho`	`lateral`	1900 × 350 × 19	[1781, 0, 0]	1781 → 1800	0 → 1900	0 → 350
`suelo`	`horizontal`	1762 × 342 × 19	[19, 0, 0]	19 → 1781	0 → 19	0 → 342
`tapa_superior`	`horizontal`	1762 × 342 × 19	[19, 1881, 0]	19 → 1781	1881 → 1900	0 → 342
`balda_1`	`horizontal`	1762 × 342 × 19	[19, 600, 0]	19 → 1781	600 → 619	0 → 342
`balda_2`	`horizontal`	1762 × 342 × 19	[19, 1200, 0]	19 → 1781	1200 → 1219	0 → 342
`trasera`	`frontal`	1900 × 1800 × 8	[0, 0, 342]	0 → 1800	0 → 1900	342 → 350

Las posiciones se calculan con pura aritmética: el lateral derecho va en x = _ancho - _grueso = 1800 - 19 = 1781. El suelo y la tapa se acortan _grueso_fondo = 8 mm en el fondo para dejar hueco a la trasera HDF, y la trasera se ancla en z = _fondo - _grueso_fondo = 350 - 8 = 342 para quedar pegada al fondo del mueble.

Uniones — `juntar`

juntar declara una unión estructural entre dos paneles. Le dice al sistema qué herrajes hay que comprar, cuántos y cómo colocarlos.

Sintaxis de juntar

juntar panel1, panel2
  unir tipo_herraje xN   # N = cantidad

panel1 — el panel donde se instala el herraje (el que lleva el agujero)
panel2 — el panel donde ancla el herraje (el que recibe)
Puedes incluir varios unir en la misma unión

Unión múltiple — confirmat + tubillón

juntar lateral_izquierdo, suelo
  unir confirmat x2
  unir tubillon  x2

Si una unión no especifica herrajes con unir, hereda automáticamente los definidos en defecto_juntar.

`defecto_juntar`

defecto_juntar define el herraje que se aplica a todas las uniones que no especifiquen los suyos propios. Es útil para no repetir la misma combinación de herrajes en cada juntar.

Herrajes por defecto para toda la carcasa

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

Con esto definido, los bloques juntar que no incluyan unir usarán automáticamente 2 confirmats y 2 tubillones. Si una unión concreta necesita algo distinto, basta con añadir el unir correspondiente y sobreescribe el defecto.

Herrajes disponibles en `unir`

Todos los herrajes que puedes usar dentro de unir:

Nombre	Descripción	Uso habitual
`confirmat`	Tornillo de ensamble tipo euroscrew	Uniones de carcasa principal
`tubillon`	Espigo de madera	Centra y refuerza la unión
`minifix`	Excéntrica desmontable (tipo Rafix)	Uniones desmontables
`tornillo`	Tornillo estándar de madera	Uso general
`escuadra`	Escuadra metálica	Refuerzo de esquinas
`grapa`	Grapa neumática	Fondos HDF / tableros finos
`bisagra_cazoleta`	Bisagra europea 35 mm	Puertas batientes
`bisagra_piano`	Bisagra de piano continua	Puertas largas o pesadas
`push_to_open`	Mecanismo de apertura sin tirador	Puertas modernas
`amortiguador`	Freno hidráulico de cierre suave	Cierre suave de puertas
`corredera`	Guía telescópica	Cajones
`lamello`	Galleta de madera (biscuit)	Uniones de canto a canto

Propiedades de `bisagra_cazoleta`

La bisagra de cazoleta acepta sub-propiedades que el sistema usa para calcular la posición exacta del taladro:

juntar puerta_izquierda, lateral_izquierdo
  unir bisagra_cazoleta x2
    apertura        = 110   # ángulo de apertura en grados
    distancia_borde = 37    # distancia del centro al borde (mm)
  unir amortiguador x1

Componentes — `componente`

Un componente empaqueta un sub-ensamblaje reutilizable (puerta, cajón, balda con corredera…) con sus parámetros, paneles internos y herrajes. Se define una vez, se instancia tantas veces como necesites.

Declarar un componente

PLANK

componente puerta_abatible
  param _alto   = 600            # valor por defecto
  param _ancho  = 400
  param _grueso = 19

  panel tablero              # paneles internos — sintaxis normal
    frontal
    largo  = _alto
    ancho  = _ancho
    grueso = _grueso
    rol    = puerta

  tablero en [0, 0, 0]      # posición LOCAL (origen del componente)

  herraje bisagra_cazoleta x2
    apertura        = 110
    distancia_borde = 37
  herraje push_to_open x1

Elemento	Uso
`param _nombre = valor`	Declara un parámetro con valor por defecto. Al instanciar, se puede sobrescribir.
`panel`	Un panel interno del componente (igual sintaxis que fuera). Se resuelve con el contexto de vars de cada instancia.
`NAME en [x,y,z]`	Posiciona un panel del componente en coordenadas locales (origen del componente). Al instanciar y ubicar con `NAME en [...]`, esas posiciones se trasladan.
`herraje TIPO xN`	Herrajes que viven en el componente (p. ej. tirador en una puerta). Se suman al cómputo global. No incluyas aquí herrajes que conectan dos piezas — esos van en `juntar … unir …`.

Convención importante — dónde van los herrajes. Distinguimos dos tipos:

Herrajes de junta (bisagra, corredera, push_to_open, escuadra, confirmat, tubillon…) — van en juntar … unir … al nivel del proyecto, donde se declara la topología puerta↔lateral, cajón↔lateral, etc.
Herrajes de pieza única (tirador, embellecedor, taco amortiguador autoadhesivo…) — van en herraje dentro del componente porque viven en una sola pieza.

El motivo: una bisagra no pertenece ni a la puerta ni al lateral — es la junta. Si la pones en el componente y en juntar, se cuenta dos veces.

Instanciar — `instancia`

Una vez definido un componente, se instancia tantas veces como hagan falta, sobrescribiendo los parámetros que varíen entre ejemplares.

PLANK

instancia puerta_izq de puerta_abatible
  _alto  = _alto_mueble - 2 * _grueso
  _ancho = (_ancho_mueble - 4) / 2

puerta_izq en [2, _grueso + 2, -_grueso]

La pieza generada se llama puerta_izq_tablero (nombre de la instancia + _ + nombre del panel interno). Si el componente tiene varios paneles internos, se genera una pieza por cada uno con el mismo prefijo.

Varias instancias en una línea: instancia c1, c2, c3 de cajon_simple crea 3 instancias idénticas. Los params se pueden sobrescribir todos a la vez; las posiciones se dan después por separado.

Importar — `importar`

Si guardas tus componentes en un fichero separado (componentes/puertas.plank, componentes/cajones.plank…), los importas con importar:

PLANK

importar puerta_abatible de ./componentes/puertas
importar cajon_simple    de ./componentes/cajones

instancia puerta_izq de puerta_abatible
  _ancho = 450
puerta_izq en [2, 21, -19]

El editor pre-carga los ficheros referenciados antes de compilar y los concatena automáticamente con tu proyecto. No hace falta copiar los componentes a cada proyecto — con tenerlos en una carpeta común y referenciarlos vale.

Abribles en el 3D

El botón 🚪 Abrir del preview 3D detecta las piezas con rol = puerta y rol = cajon_frente. Si esa pieza pertenece a una instancia (por ejemplo, un cajón completo con sus laterales, fondo y trasera), se abre todo el grupo en bloque. Es la ventaja de usar componentes: el cajón sale entero, no solo el frente.

Ejemplos comentados

Galería de siete muebles completos en PLANK, cada uno con su render 3D y el código fuente íntegro. Los ficheros originales están en plank/ejemplos/.

01 · Armario básico con puertas

Armario clásico de dormitorio — 2 puertas abatibles, 3 baldas, fondo superpuesto. Muestra el flujo completo: esqueleto + paneles manuales interiores + puertas frontales.

PLANK · 01-armario-basico.plank

var _grueso        = 19    # grueso de los tableros estructurales
var _grueso_fondo  = 8     # grueso del panel trasero
var _alto          = 2000
var _ancho         = 1200
var _fondo         = 550
var _hueco_puertas = 2     # separación entre puertas y laterales

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

# ── Carcasa ────────────────────────────────────────────────────────

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  fondo              superpuesto
    grueso = _grueso_fondo

# ── Baldas interiores ──────────────────────────────────────────────

panel balda_baja, balda_media, balda_alta
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo - _grueso_fondo

balda_baja  en [_grueso, 500,  0]
balda_media en [_grueso, 1000, 0]
balda_alta  en [_grueso, 1500, 0]

# ── Puertas (frontales con hueco) ─────────────────────────────────

panel puerta_izda, puerta_dcha
  frontal
  largo = _alto - 2 * _hueco_puertas
  ancho = (_ancho - 3 * _hueco_puertas) / 2
  rol   = puerta

puerta_izda en [_hueco_puertas,                                        _hueco_puertas, -_grueso]
puerta_dcha en [_hueco_puertas * 2 + (_ancho - 3 * _hueco_puertas) / 2, _hueco_puertas, -_grueso]

# ── Uniones ────────────────────────────────────────────────────────

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_izquierdo, suelo
juntar lateral_derecho,   suelo
juntar lateral_izquierdo, tapa
juntar lateral_derecho,   tapa

juntar lateral_izquierdo, balda_baja
  unir tubillon x4
juntar lateral_derecho,   balda_baja
  unir tubillon x4
juntar lateral_izquierdo, balda_media
  unir tubillon x4
juntar lateral_derecho,   balda_media
  unir tubillon x4
juntar lateral_izquierdo, balda_alta
  unir tubillon x4
juntar lateral_derecho,   balda_alta
  unir tubillon x4

juntar puerta_izda, lateral_izquierdo
  unir bisagra_cazoleta x3
    apertura        = 110
    distancia_borde = 37
juntar puerta_dcha, lateral_derecho
  unir bisagra_cazoleta x3
    apertura        = 110
    distancia_borde = 37

02 · Librería abierta

Estantería de librería sin puertas ni fondo — solo laterales + base + tapa + 5 baldas a alturas desiguales (libros de distintas alturas). Muestra esqueleto parcial (sin fondo) y múltiples baldas manuales.

PLANK · 02-libreria-abierta.plank

var _grueso = 22    # tableros gruesos para resistir carga
var _alto   = 2200
var _ancho  = 900
var _fondo  = 280

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

# ── Carcasa sin fondo ─────────────────────────────────────────────

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  # sin fondo — estantería abierta por detrás

# ── Baldas a alturas específicas para libros ──────────────────────

panel balda
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo

# Hueco grande abajo para libros de arte / tapa dura grande: 380 mm
# Hueco medio:                                                 300 mm
# Hueco pequeño arriba (bolsillo):                             240 mm

balda en [_grueso, 400,  0]    # primer hueco 400 mm
balda en [_grueso, 780,  0]    # segundo hueco 380 mm
balda en [_grueso, 1100, 0]    # tercer hueco 320 mm
balda en [_grueso, 1420, 0]    # cuarto hueco 320 mm
balda en [_grueso, 1720, 0]    # quinto hueco 300 mm

# ── Uniones ────────────────────────────────────────────────────────

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_izquierdo, suelo
juntar lateral_derecho,   suelo
juntar lateral_izquierdo, tapa
juntar lateral_derecho,   tapa

# Las baldas se unen con pernos de estantería — se puede cargar mucho
juntar lateral_izquierdo, balda
  unir tubillon x4
juntar lateral_derecho,   balda
  unir tubillon x4

03 · Escritorio con vuelo

Escritorio con cajonera a un lado. La tapa sobresale por los 3 lados visibles (izquierda, derecha, frente). No hay tapa en sentido clásico — sobre_laterales sustituye al fit_entre_laterales.

PLANK · 03-escritorio-vuelo.plank

var _grueso        = 25    # tapa robusta
var _grueso_estruc = 19    # laterales y cajonera
var _grueso_fondo  = 8
var _alto          = 760
var _ancho         = 1400
var _fondo         = 600
var _vuelo         = 25    # tapa sale 25 mm por los lados visibles

mueble [_alto, _ancho, _fondo]
  grueso = _grueso_estruc

# ── Carcasa lateral (cajonera a la derecha) ───────────────────────
# La "cajonera" es el bloque estructural a la derecha. El lateral
# izquierdo hace de pata simbólica; podrías cambiarlo por una pata
# metálica real.

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               sobre_laterales
    grueso       = _grueso
    vuelo_izq    = _vuelo
    vuelo_der    = _vuelo
    vuelo_frente = _vuelo
    # vuelo_fondo = 0 (pegado a la pared)
  fondo              superpuesto
    grueso = _grueso_fondo

# ── Divisor central para formar hueco de cajones ──────────────────

panel divisor
  lateral
  largo = _alto - _grueso_estruc - _grueso
  ancho = _fondo - _grueso_fondo

# El divisor separa la zona de piernas (izquierda) de la cajonera (derecha)
divisor en [1000, _grueso_estruc, 0]

# ── Tres frentes de cajón ─────────────────────────────────────────

panel frente_cajon
  frontal
  largo  = 200
  ancho  = _ancho - 1000 - _grueso_estruc * 2 - 4
  rol    = cajon_frente

# Los frentes se apilan verticalmente con 2 mm de hueco entre ellos
# (z = -_grueso_estruc los sitúa delante del mueble)
frente_cajon en [1000 + _grueso_estruc + 2,  50,  -_grueso_estruc]
frente_cajon en [1000 + _grueso_estruc + 2, 260,  -_grueso_estruc]
frente_cajon en [1000 + _grueso_estruc + 2, 470,  -_grueso_estruc]

# ── Uniones ────────────────────────────────────────────────────────

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_izquierdo, suelo
juntar lateral_derecho,   suelo
juntar lateral_izquierdo, tapa
juntar lateral_derecho,   tapa

juntar divisor, suelo
juntar divisor, tapa

# Correderas para los cajones (una por lado del cajón)
juntar frente_cajon, divisor
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30
juntar frente_cajon, lateral_derecho
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30

04 · Mesita de noche

Mueble pequeño: un cajón arriba + hueco abierto abajo. Muestra un módulo compacto con divisor horizontal interior manual (la "balda" que soporta el cajón).

PLANK · 04-mesita-noche.plank

var _grueso       = 19
var _grueso_fondo = 6
var _alto         = 500
var _ancho        = 450
var _fondo        = 400

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

# ── Carcasa completa ──────────────────────────────────────────────

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  fondo              ranura
    grueso = _grueso_fondo

# ── Divisor horizontal: techo del cajón ───────────────────────────
# La balda de separación entre el cajón (arriba) y el hueco abierto (abajo).
# Está a 180 mm del suelo exterior — queda hueco de 161 mm para el cajón.

panel divisor_h
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo - _grueso_fondo

divisor_h en [_grueso, 180, 0]

# ── Frente del cajón ──────────────────────────────────────────────
# Cubre todo el frente desde el divisor hasta el techo, con 2 mm de hueco

var _hueco = 2

panel frente_cajon
  frontal
  largo  = _alto - 180 - _grueso - _hueco * 2
  ancho  = _ancho - _hueco * 2
  rol    = cajon_frente

frente_cajon en [_hueco, 180 + _grueso + _hueco, _fondo]

# ── Uniones ────────────────────────────────────────────────────────

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_izquierdo, suelo
juntar lateral_derecho,   suelo
juntar lateral_izquierdo, tapa
juntar lateral_derecho,   tapa

juntar lateral_izquierdo, divisor_h
  unir tubillon x3
juntar lateral_derecho,   divisor_h
  unir tubillon x3

juntar frente_cajon, lateral_izquierdo
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 20
juntar frente_cajon, lateral_derecho
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 20

juntar frente_cajon, lateral_izquierdo
  unir push_to_open x1

05 · Mueble de TV

Mueble largo y bajo para salón: 3 compartimentos separados por divisores verticales interiores. El compartimento central queda abierto (TV + decodificador); los laterales llevan una puerta abatible cada uno. Muestra el uso de TAG lateral para divisores interiores — no todos los laterales tienen que ser costados del mueble.

PLANK · 05-mueble-tv.plank

var _grueso       = 19
var _grueso_fondo = 8
var _alto         = 500
var _ancho        = 1800
var _fondo        = 420
var _hueco_centro = 900    # ancho del compartimento central (TV)

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

# ── Carcasa completa ──────────────────────────────────────────────

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  fondo              superpuesto
    grueso = _grueso_fondo

# ── Divisores verticales interiores ───────────────────────────────
# Convierten el interior en 3 celdas. Mismo tag `lateral` que los
# costados — carpintería idéntica.

panel divisor_izq, divisor_dcho
  lateral
  largo = _alto - 2 * _grueso
  ancho = _fondo - _grueso_fondo

# Centro: compartimento de _hueco_centro mm.
# Cada compartimento lateral tiene el espacio restante a partes iguales.

divisor_izq  en [(_ancho - _hueco_centro) / 2 - _grueso, _grueso, 0]
divisor_dcho en [(_ancho + _hueco_centro) / 2,           _grueso, 0]

# ── Puertas laterales abatibles ───────────────────────────────────

var _hueco = 2

panel puerta_izda, puerta_dcha
  frontal
  largo = _alto - 2 * _hueco
  ancho = (_ancho - _hueco_centro) / 2 - _grueso - 2 * _hueco
  rol   = puerta

# Izquierda: desde el borde exterior hasta el divisor_izq
puerta_izda en [_hueco,                                           _hueco, -_grueso]
# Derecha: desde el divisor_dcho hasta el borde derecho
puerta_dcha en [(_ancho + _hueco_centro) / 2 + _grueso + _hueco, _hueco, -_grueso]

# ── Uniones ────────────────────────────────────────────────────────

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_izquierdo, suelo
juntar lateral_derecho,   suelo
juntar lateral_izquierdo, tapa
juntar lateral_derecho,   tapa

juntar divisor_izq,  suelo
juntar divisor_izq,  tapa
juntar divisor_dcho, suelo
juntar divisor_dcho, tapa

juntar puerta_izda, lateral_izquierdo
  unir bisagra_cazoleta x2
    apertura        = 110
    distancia_borde = 37
juntar puerta_dcha, lateral_derecho
  unir bisagra_cazoleta x2
    apertura        = 110
    distancia_borde = 37

06 · Módulo cocina fin de fila

Módulo alto de pared de cocina, el último de una fila — comparte su lateral izquierdo con el módulo anterior, así que lo omitimos. No tiene suelo (cuelga de tornillos invisibles). Puerta abatible con apertura push-to-open. Muestra dos casos clave del esqueleto: opt-in por declaración (lateral_izquierdo omitido, suelo omitido) y cómo los vecinos se extienden hasta el envelope del mueble.

PLANK · 06-modulo-cocina-fin-fila.plank

var _grueso       = 19
var _grueso_fondo = 4     # HDF fino para fondo de pared
var _alto         = 720
var _ancho        = 600
var _fondo        = 320

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

# ── Carcasa parcial — sin lateral izquierdo, sin suelo ────────────

esqueleto
  # lateral_izquierdo  (omitido — lo aporta el módulo vecino)
  lateral_derecho    fit_alto
  # suelo            (omitido — módulo suspendido)
  tapa               fit_entre_laterales
  fondo              ranura
    grueso = _grueso_fondo

# ── Tablero inferior cerrando el módulo (donde iría el suelo) ─────
# Cuando omites el suelo del esqueleto pero necesitas cerrar el
# módulo por abajo, puedes poner una balda manual al nivel 0.
# Aquí llega hasta donde llegaría el lateral omitido (x=0).

panel tabla_inferior
  horizontal
  largo = _ancho - _grueso    # hasta el lateral derecho
  ancho = _fondo - _grueso_fondo

tabla_inferior en [0, 0, 0]

# ── Puerta frontal cubriendo todo el hueco ────────────────────────

var _hueco = 2

panel puerta
  frontal
  largo = _alto - 2 * _hueco
  ancho = _ancho - 2 * _hueco
  rol   = puerta

puerta en [_hueco, _hueco, -_grueso]

# ── Uniones ────────────────────────────────────────────────────────

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_derecho, tabla_inferior
juntar lateral_derecho, tapa

# La puerta se une al lateral presente con bisagras
# (si el montaje real comparte bisagras con el módulo vecino,
# puedes reducir a x2 o ajustar)
juntar puerta, lateral_derecho
  unir bisagra_cazoleta x2
    apertura        = 110
    distancia_borde = 37
  unir push_to_open x1

07 · Con componentes importados

Mismo armario que el 01, pero las puertas y los cajones vienen de la librería de componentes. Demuestra importar + instancia — el flujo normal cuando reutilizas diseños entre proyectos.

Render 3D del armario con componentes importados

PLANK · 07-con-componentes-importados.plank

importar puerta_abatible de ./componentes/puertas
importar cajon_simple    de ./componentes/cajones

var _grueso        = 19
var _grueso_fondo  = 8
var _alto          = 2000
var _ancho         = 1200
var _fondo         = 550
var _hueco         = 2

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

# ── Carcasa ────────────────────────────────────────────────────────

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  fondo              superpuesto
    grueso = _grueso_fondo

# ── Balda intermedia (separación cajones / colgadero) ─────────────

panel balda_separacion
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo - _grueso_fondo

balda_separacion en [_grueso, 700, 0]

# ── Dos puertas abatibles cubriendo la parte superior ─────────────

instancia puerta_izq de puerta_abatible
  _alto  = _alto - _grueso - 700 - _hueco
  _ancho = (_ancho - 3 * _hueco) / 2
  _hueco = 0                              # el hueco lo controlamos fuera

instancia puerta_dcha de puerta_abatible
  _alto  = _alto - _grueso - 700 - _hueco
  _ancho = (_ancho - 3 * _hueco) / 2
  _hueco = 0

puerta_izq  en [_hueco,                                     700 + _grueso + _hueco, -_grueso]
puerta_dcha en [_hueco * 2 + (_ancho - 3 * _hueco) / 2,     700 + _grueso + _hueco, -_grueso]

# ── Tres cajones en la parte inferior ─────────────────────────────

instancia cajon_1, cajon_2, cajon_3 de cajon_simple
  _alto         = 220
  _ancho        = _ancho - 2 * _grueso
  _fondo        = _fondo - _grueso_fondo - 20
  _grueso_frente = _grueso

cajon_1 en [_grueso, _grueso,           0]
cajon_2 en [_grueso, _grueso + 225,     0]
cajon_3 en [_grueso, _grueso + 225 * 2, 0]

# ── Conectar carcasa ──────────────────────────────────────────────

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_izquierdo, suelo
juntar lateral_derecho,   suelo
juntar lateral_izquierdo, tapa
juntar lateral_derecho,   tapa
juntar lateral_izquierdo, balda_separacion
  unir tubillon x4
juntar lateral_derecho,   balda_separacion
  unir tubillon x4

# ── Bisagras de las puertas ───────────────────────────────────────
# Cada puerta cuelga de su lateral con 2 bisagras de cazoleta

juntar puerta_izq_tablero, lateral_izquierdo
  unir bisagra_cazoleta x2
    apertura        = 110
    distancia_borde = 37
juntar puerta_dcha_tablero, lateral_derecho
  unir bisagra_cazoleta x2
    apertura        = 110
    distancia_borde = 37

# ── Correderas de los cajones ─────────────────────────────────────
# Cada cajón lleva 2 correderas telescópicas, una por lado

juntar cajon_1_lateral_izq, lateral_izquierdo
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30
juntar cajon_1_lateral_der, lateral_derecho
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30

juntar cajon_2_lateral_izq, lateral_izquierdo
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30
juntar cajon_2_lateral_der, lateral_derecho
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30

juntar cajon_3_lateral_izq, lateral_izquierdo
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30
juntar cajon_3_lateral_der, lateral_derecho
  unir corredera x1
    longitud = _fondo - _grueso_fondo - 30

Referencia rápida — todos los keywords

Keyword	Dónde aparece	Descripción
`var`	Nivel raíz	Declara una variable numérica reutilizable
`mueble`	Nivel raíz	Define bounding box [alto, ancho, fondo] y grueso por defecto
`grueso`	Dentro de `mueble` o `panel`	Espesor del tablero en mm
`panel`	Nivel raíz	Declara uno o varios paneles con sus dimensiones y tag
`lateral`	Tag dentro de `panel`	Panel vertical con veta en Y; largo→Y, ancho→Z, grueso→X
`frontal`	Tag dentro de `panel`	Panel vertical con veta en Y; largo→Y, ancho→X, grueso→Z
`horizontal`	Tag dentro de `panel`	Panel tumbado con veta en X; largo→X, ancho→Z, grueso→Y
`largo`	Dentro de `panel`	Dimensión principal del tablero (siempre con la veta)
`ancho`	Dentro de `panel`	Dimensión secundaria del tablero
`material`	Dentro de `panel`	Tipo o color del material (opcional)
`rol`	Dentro de `panel`	Rol semántico para exportación a CAD (costado, tapa, balda…)
`en`	Nivel raíz (tras declarar el panel)	Sitúa la esquina inferior-izq-delantera del panel en [x, y, z]
`defecto_juntar`	Nivel raíz	Herrajes por defecto para todas las uniones sin `unir` propio
`juntar`	Nivel raíz	Declara una unión estructural entre dos paneles
`unir`	Dentro de `juntar`	Especifica el tipo de herraje y la cantidad (`xN`)
`esqueleto`	Nivel raíz	Bloque que genera paneles estructurales auto-dimensionados
`fit_alto`	Dentro de `esqueleto` (laterales)	Tipo de encaje: panel pasante de suelo a techo
`fit_entre_laterales`	Dentro de `esqueleto` (suelo, tapa)	Tipo de encaje: encastrado entre laterales
`sobre_laterales`	Dentro de `esqueleto` (tapa)	Tipo de encaje: tapa por encima de los laterales (admite vuelo)
`bajo_laterales`	Dentro de `esqueleto` (suelo)	Tipo de encaje: suelo por debajo de los laterales (admite vuelo)
`superpuesto`	Dentro de `esqueleto` (fondo)	Tipo de encaje: fondo pegado al canto posterior
`ranura`	Dentro de `esqueleto` (fondo)	Tipo de encaje: fondo encastrado en ranura fresada
`vuelo`	Dentro de `esqueleto` (tapa/suelo)	Overhang aplicado a los 4 lados
`vuelo_izq`	Dentro de `esqueleto` (tapa/suelo)	Overhang por el lado izquierdo
`vuelo_der`	Dentro de `esqueleto` (tapa/suelo)	Overhang por el lado derecho
`vuelo_frente`	Dentro de `esqueleto` (tapa/suelo)	Overhang por el frente
`vuelo_fondo`	Dentro de `esqueleto` (tapa/suelo)	Overhang por la parte trasera
`profundidad_ranura`	Dentro de `esqueleto` (fondo ranura)	Profundidad de la ranura fresada para `fondo ranura`

Tabla completa de herrajes

Nombre	Descripción	Uso habitual
`confirmat`	Tornillo euroscrew de ensamble	Carcasa principal
`tubillon`	Espigo de madera	Centrado y refuerzo
`minifix`	Excéntrica desmontable	Uniones desmontables
`tornillo`	Tornillo estándar de madera	Uso general
`escuadra`	Escuadra metálica	Refuerzo de esquinas
`grapa`	Grapa neumática	Fondos HDF
`bisagra_cazoleta`	Bisagra europea 35 mm	Puertas batientes
`bisagra_piano`	Bisagra de piano continua	Puertas largas
`push_to_open`	Apertura sin tirador	Puertas modernas
`amortiguador`	Freno hidráulico	Cierre suave
`corredera`	Guía telescópica	Cajones
`lamello`	Galleta de madera (biscuit)	Uniones de canto

Ejemplo completo anotado — Armario con baldas y fondo superpuesto

Un armario de 1800 × 1900 × 350 mm con dos baldas intermedias y fondo superpuesto de 8 mm, generado con esqueleto y con todas las uniones declaradas.

PLANK — armario 1800 × 1900 × 350 mm

# Armario sencillo — 1800×1900×350 mm, dos baldas y fondo superpuesto

var _grueso        = 19    # grueso de los tableros estructurales
var _grueso_fondo  = 8     # grueso del panel trasero (HDF fino)
var _alto          = 1900  # alto total del mueble
var _ancho         = 1800  # ancho total del mueble
var _fondo         = 350   # fondo (profundidad) del mueble

mueble [_alto, _ancho, _fondo]
  grueso = _grueso

esqueleto
  lateral_izquierdo  fit_alto
  lateral_derecho    fit_alto
  suelo              fit_entre_laterales
  tapa               fit_entre_laterales
  fondo              superpuesto
    grueso = _grueso_fondo

panel balda_1, balda_2
  horizontal
  largo = _ancho - 2 * _grueso
  ancho = _fondo - _grueso_fondo

balda_1 en [_grueso, 600,  0]
balda_2 en [_grueso, 1200, 0]

defecto_juntar
  unir confirmat x2
  unir tubillon  x2

juntar lateral_izquierdo, suelo
juntar lateral_derecho,   suelo
juntar lateral_izquierdo, tapa
juntar lateral_derecho,   tapa

juntar lateral_izquierdo, balda_1
  unir tubillon x4
juntar lateral_derecho,   balda_1
  unir tubillon x4
juntar lateral_izquierdo, balda_2
  unir tubillon x4
juntar lateral_derecho,   balda_2
  unir tubillon x4

Notas sobre el ejemplo:

El bloque esqueleto genera automáticamente laterales, suelo, tapa y fondo con las dimensiones correctas a partir del mueble.
Los laterales con fit_alto son pasantes de suelo a techo. El suelo y la tapa con fit_entre_laterales encajan entre ellos.
El fondo superpuesto de 8 mm se pega al canto posterior del mueble.
Las baldas se declaran a mano porque su posición (600 y 1200 mm) no es estructural.
defecto_juntar fija confirmats + tubillones para toda la carcasa; las uniones de baldas sobreescriben con 4 tubillones.

PLANK — Board Assembly Language Lenguaje declarativo de construcciones en madera pieza a pieza

¿Qué es PLANK?

¿Cuándo usar cada lenguaje?

Inicio rápido (3 minutos)

Sistema de coordenadas

Punto ancla de cada panel

Variables

Sintaxis

El bloque mueble

Declarar un panel

Sintaxis

Tags de orientación

Ejemplos de uso de cada tag

Grueso por defecto

Rol (interop con CAD)

Defaults de largo y ancho

Retranqueo

Atajos puerta, balda, divisor

Puerta solapada — en LATERAL

Reglas geométricas

Altura y profundidad

Reglas y validaciones

Cláusula entre

Con 2 referencias — balda, divisor, puerta

Con 4 referencias — solo puerta encastrada

Reglas comunes

Gap mínimo en puertas (validación automática)

Esqueleto — paneles estructurales auto-dimensionados

Tipos de encaje (fit)

Vuelos

Módulos incompletos

Combinar con paneles manuales

Situar con en

Referencias entre piezas y mutación de cantos

Lectura: pieza.campo

Mutación: pieza.<canto> = expr

Traslación: pieza.<eje>MoverA = expr

Eje del grueso bloqueado

Reglas de aplicación

Ejemplo: armario

Uniones — juntar

defecto_juntar

Herrajes disponibles en unir

Propiedades de bisagra_cazoleta

Componentes — componente

Declarar un componente

Instanciar — instancia

Importar — importar

Abribles en el 3D

Ejemplos comentados

01 · Armario básico con puertas

02 · Librería abierta

03 · Escritorio con vuelo

04 · Mesita de noche

05 · Mueble de TV

06 · Módulo cocina fin de fila

07 · Con componentes importados

Referencia rápida — todos los keywords

Tabla completa de herrajes

Ejemplo completo anotado — Armario con baldas y fondo superpuesto

Defaults de `largo` y `ancho`

Atajos `puerta`, `balda`, `divisor`

Puerta solapada — `en LATERAL`

Cláusula `entre`

Con 2 referencias — `balda`, `divisor`, `puerta`

Con 4 referencias — solo `puerta` encastrada

Tipos de encaje (`fit`)

Situar con `en`

Lectura: `pieza.campo`

Mutación: `pieza.<canto> = expr`

Traslación: `pieza.<eje>MoverA = expr`

Uniones — `juntar`

`defecto_juntar`

Herrajes disponibles en `unir`

Propiedades de `bisagra_cazoleta`

Componentes — `componente`

Instanciar — `instancia`

Importar — `importar`