@maniclang/workbench 0.1.11

package/examples/walk.manic

@@ -0,0 +1,154 @@
+title("A Generic Figure Walking Down the Road");
+canvas("16:9");
+
+let groundY = cy + 160;
+let startX = cx - 420;
+let stepDist = 15;
+let swingAmp = 26;
+let bobAmp = 10;
+
+// ================= road =================
+
+rect(road, (0, groundY), w, h - groundY);
+color(road, dim);
+filled(road);
+untraced(road);
+
+line(roadLine, (0, groundY + 40), (w, groundY + 40));
+color(roadLine, panel);
+stroke(roadLine, 2);
+untraced(roadLine);
+
+for i in 0..12 {
+  rect(dash{i}, (i*120 - 40, groundY + 36), 50, 8);
+  color(dash{i}, fg);
+  filled(dash{i});
+  untraced(dash{i});
+}
+
+// ================= stick figure as points + reflowing segments =================
+
+point(neck, (startX, groundY - 118));
+point(hip, (startX, groundY - 10));
+point(handL, (startX - 30, groundY - 40));
+point(handR, (startX + 30, groundY - 40));
+point(footL, (startX - 30, groundY + 100));
+point(footR, (startX + 30, groundY + 100));
+
+hidden(neck);
+hidden(hip);
+hidden(handL);
+hidden(handR);
+hidden(footL);
+hidden(footR);
+
+circle(head, (startX, groundY - 140), 22);
+color(head, fg);
+outlined(head);
+stroke(head, 3);
+untraced(head);
+
+segment(spine, neck, hip);
+segment(armL, neck, handL);
+segment(armR, neck, handR);
+segment(legL, hip, footL);
+segment(legR, hip, footR);
+
+color(spine, fg);
+color(armL, cyan);
+color(armR, cyan);
+color(legL, gold);
+color(legR, gold);
+stroke(spine, 4);
+stroke(armL, 4);
+stroke(armR, 4);
+stroke(legL, 4);
+stroke(legR, 4);
+untraced(spine);
+untraced(armL);
+untraced(armR);
+untraced(legL);
+untraced(legR);
+
+// ================= text =================
+
+text(head_label, (cx, 55), "A Generic Figure Walking Down the Road");
+color(head_label, cyan);
+hidden(head_label);
+
+text(caption, (cx, h - 30), "");
+color(caption, dim);
+hidden(caption);
+
+// ================= script =================
+
+show(head_label, 0.6);
+wait(0.3);
+
+par {
+  draw(road, 0.5);
+  draw(roadLine, 0.5);
+  stagger(0.03) {
+    for i in 0..12 {
+      draw(dash{i}, 0.1);
+    }
+  }
+}
+
+par {
+  show(neck, 0.01); show(hip, 0.01);
+  show(handL, 0.01); show(handR, 0.01);
+  show(footL, 0.01); show(footR, 0.01);
+  draw(head, 0.4);
+  draw(spine, 0.3);
+  draw(armL, 0.3);
+  draw(armR, 0.3);
+  draw(legL, 0.3);
+  draw(legR, 0.3);
+}
+wait(0.3);
+
+show(caption, 0.4);
+say(caption, "Camera pulls back to see the whole road");
+par {
+  cam((cx, cy), 1.0, smooth);
+  zoom(0.85, 1.0, smooth);
+}
+wait(0.3);
+
+// --- walk cycle: phase steps by 90 deg so sin actually alternates ---
+
+for i in 0..28 {
+  let baseX = startX + i*stepDist;
+  let phase = i*90;
+  let swing = swingAmp*sin(phase*pi/180);
+  let legLift = bobAmp*abs(sin(phase*pi/180));
+
+  par {
+    move(neck, (baseX, groundY - 118 - legLift*0.4), 0.15, smooth);
+    move(hip, (baseX, groundY - 10), 0.15, smooth);
+    move(handL, (baseX - swing, groundY - 40), 0.15, smooth);
+    move(handR, (baseX + swing, groundY - 40), 0.15, smooth);
+    move(footL, (baseX + swing, groundY + 100 - legLift), 0.15, smooth);
+    move(footR, (baseX - swing, groundY + 100 - legLift), 0.15, smooth);
+    move(head, (baseX, groundY - 140 - legLift*0.4), 0.15, smooth);
+  }
+}
+
+wait(0.2);
+say(caption, "Camera zooms in as the figure gets close");
+par {
+  cam((startX + 420, groundY - 80), 1.4, smooth);
+  zoom(2.2, 1.4, smooth);
+}
+wait(0.4);
+
+say(caption, "A close-up look, then pulling back out");
+par {
+  cam((cx, cy), 1.2, smooth);
+  zoom(1, 1.2, smooth);
+}
+wait(0.4);
+
+show(caption, 0.3);
+say(caption, "A generic stick figure walking -- no specific person depicted");

package/examples/wheel-duo.manic

@@ -0,0 +1,91 @@
+// wheel-duo — four breathing bursts in a 2x2 grid on black, spinning forever.
+//
+//   top row    : normal spin (inner+outer together) — circle | square
+//   bottom row : COUNTER-spin (outer clockwise, inner counter-clockwise) — circle | square
+//
+// The spokes are `link`s that follow their two dots, so counter-rotation twists them
+// into a spirograph "eye". Each spoke is HUE'd by its angle -> a rainbow wheel; the
+// continuous rotation carries the rainbow around and never stops. Every burst
+// breathes, holds still (the breath-wave fakes rotation), then keeps spinning.
+//
+//   manic examples/wheel-duo.manic
+canvas(1600, 1600);
+template("black");
+
+let n     = 44;
+let rin   = 125;
+let len    = 85;       // outer = rin + len = 210
+let pi     = 3.14159265;
+let lobes   = 4;
+
+// ---- A: circle, top-left (normal spin) ----
+for i in 0..n {
+  let ang = i * 2 * pi / n;
+  let ix = 440 + rin * cos(ang);        let iy = 440 + rin * sin(ang);
+  let ox = 440 + (rin + len) * cos(ang); let oy = 440 + (rin + len) * sin(ang);
+  circle(a_ci{i}, (ix, iy), 5);  stroke(a_ci{i}, 1.8); color(a_ci{i}, #000000); tag(a_ci{i}, a_all);
+  circle(a_co{i}, (ox, oy), 10); stroke(a_co{i}, 2.2); color(a_co{i}, #000000); tag(a_co{i}, a_all);
+  link(a_sp{i}, a_ci{i}, a_co{i}); hue(a_sp{i}, 360 * i / n); stroke(a_sp{i}, 1.3);
+}
+
+// ---- B: square, top-right (normal spin) ----
+for i in 0..n {
+  let ang = i * 2 * pi / n;
+  let c = cos(ang); let s = sin(ang);
+  let m = 0.5 * (abs(c) + abs(s) + abs(abs(c) - abs(s)));   // max(|cos|,|sin|)
+  let ix = 1160 + (rin / m) * c;        let iy = 440 + (rin / m) * s;
+  let ox = 1160 + ((rin + len) / m) * c; let oy = 440 + ((rin + len) / m) * s;
+  rect(b_ci{i}, (ix, iy), 9, 9);   stroke(b_ci{i}, 1.8); color(b_ci{i}, #000000); tag(b_ci{i}, b_all);
+  rect(b_co{i}, (ox, oy), 19, 19); stroke(b_co{i}, 2.2); color(b_co{i}, #000000); tag(b_co{i}, b_all);
+  link(b_sp{i}, b_ci{i}, b_co{i}); hue(b_sp{i}, 360 * i / n); stroke(b_sp{i}, 1.3);
+}
+
+// ---- C: circle, bottom-left (COUNTER: outer cw, inner ccw) ----
+for i in 0..n {
+  let ang = i * 2 * pi / n;
+  let ix = 440 + rin * cos(ang);        let iy = 1160 + rin * sin(ang);
+  let ox = 440 + (rin + len) * cos(ang); let oy = 1160 + (rin + len) * sin(ang);
+  circle(c_ci{i}, (ix, iy), 5);  stroke(c_ci{i}, 1.8); color(c_ci{i}, #000000); tag(c_ci{i}, c_in);
+  circle(c_co{i}, (ox, oy), 10); stroke(c_co{i}, 2.2); color(c_co{i}, #000000); tag(c_co{i}, c_out);
+  link(c_sp{i}, c_ci{i}, c_co{i}); hue(c_sp{i}, 360 * i / n); stroke(c_sp{i}, 1.3);
+}
+
+// ---- D: square, bottom-right (COUNTER: outer cw, inner ccw) ----
+for i in 0..n {
+  let ang = i * 2 * pi / n;
+  let c = cos(ang); let s = sin(ang);
+  let m = 0.5 * (abs(c) + abs(s) + abs(abs(c) - abs(s)));
+  let ix = 1160 + (rin / m) * c;        let iy = 1160 + (rin / m) * s;
+  let ox = 1160 + ((rin + len) / m) * c; let oy = 1160 + ((rin + len) / m) * s;
+  rect(d_ci{i}, (ix, iy), 9, 9);   stroke(d_ci{i}, 1.8); color(d_ci{i}, #000000); tag(d_ci{i}, d_in);
+  rect(d_co{i}, (ox, oy), 19, 19); stroke(d_co{i}, 2.2); color(d_co{i}, #000000); tag(d_co{i}, d_out);
+  link(d_sp{i}, d_ci{i}, d_co{i}); hue(d_sp{i}, 360 * i / n); stroke(d_sp{i}, 1.3);
+}
+
+// labels + centre title
+text(title, (800, 800), "manic"); size(title, 62); color(title, #ff2d95);
+text(la, (440, 720),  "circle");         size(la, 26); color(la, #7f8aa3);
+text(lb, (1160, 720), "square");         size(lb, 26); color(lb, #7f8aa3);
+text(lc, (440, 1500),  "circle counter"); size(lc, 26); color(lc, #7f8aa3);
+text(ld, (1160, 1500), "square counter"); size(ld, 26); color(ld, #7f8aa3);
+
+par {
+  // all four bursts breathe the whole time
+  for i in 0..n {
+    let ph = lobes * i / n;
+    breathe(a_ci{i}, 2.4, 0.85, ph, 38); breathe(a_co{i}, 2.4, 0.92, ph, 38);
+    breathe(b_ci{i}, 2.4, 0.85, ph, 38); breathe(b_co{i}, 2.4, 0.92, ph, 38);
+    breathe(c_ci{i}, 2.4, 0.85, ph, 38); breathe(c_co{i}, 2.4, 0.92, ph, 38);
+    breathe(d_ci{i}, 2.4, 0.85, ph, 38); breathe(d_co{i}, 2.4, 0.92, ph, 38);
+  }
+
+  // hold still, ease in, then spin CONTINUOUSLY (never stops). top: rigid; bottom: counter.
+  seq { wait(5); turn(a_all, (440, 440),   90, 3, in); turn(a_all, (440, 440),   1800, 30, linear); }
+  seq { wait(5); turn(b_all, (1160, 440), -90, 3, in); turn(b_all, (1160, 440), -1800, 30, linear); }
+
+  seq { wait(5); turn(c_out, (440, 1160),  90, 3, in); turn(c_out, (440, 1160),  1800, 30, linear); }
+  seq { wait(5); turn(c_in,  (440, 1160), -90, 3, in); turn(c_in,  (440, 1160), -1800, 30, linear); }
+
+  seq { wait(5); turn(d_out, (1160, 1160),  90, 3, in); turn(d_out, (1160, 1160),  1800, 30, linear); }
+  seq { wait(5); turn(d_in,  (1160, 1160), -90, 3, in); turn(d_in,  (1160, 1160), -1800, 30, linear); }
+}

package/examples/wheel-radial.manic

@@ -0,0 +1,78 @@
+// wheel-radial — a breathing radial burst that also spins with a tempo arc.
+//
+// 60 fixed spokes tipped with HOLLOW rings. Two things happen at once, in a
+// `par { }` block:
+//   1. every ring BREATHES (radius oscillates) with a phase = its position, so
+//      the size-wave travels around the ring (the reference-clip illusion);
+//   2. the whole wheel TURNS about its centre with a steady -> fast -> slow
+//      tempo (three eased `turn`s), and the wordmark cycles through the palette.
+// The breathing period is fixed, so the *speed* change comes from the rotation —
+// `breathe` drives scale, `turn` drives position, so they compose cleanly.
+//
+// Rings are made truly hollow by filling them with the exact paper colour.
+//
+//   manic examples/wheel-radial.manic
+canvas(1080, 1080);
+template("paper");
+
+let n     = 60;
+let cx    = 540;
+let cy    = 540;
+let rin   = 250;      // inner radius
+let len   = 190;      // spoke length -> outer radius = rin + len
+let pi     = 3.14159265;
+let lobes   = 5;       // how many fat arcs travel around at once
+
+// 1) the frame: spokes + hollow rings, all tagged `wheel` so `turn` spins them
+for i in 0..n {
+  let ang = i * 2 * pi / n;
+  let ix = cx + rin * cos(ang);
+  let iy = cy + rin * sin(ang);
+  let ox = cx + (rin + len) * cos(ang);
+  let oy = cy + (rin + len) * sin(ang);
+
+  line(spoke{i}, (ix, iy), (ox, oy));
+  stroke(spoke{i}, 1.2);
+  color(spoke{i}, #3a3a4a);
+  tag(spoke{i}, wheel);
+  tag(spoke{i}, spokes);
+
+  circle(cin{i}, (ix, iy), 5);
+  stroke(cin{i}, 2);
+  color(cin{i}, #f5f2e5);        // hollow: fill matches the paper background
+  tag(cin{i}, wheel);
+
+  circle(cout{i}, (ox, oy), 12);
+  stroke(cout{i}, 2.5);
+  color(cout{i}, #f5f2e5);
+  tag(cout{i}, wheel);
+}
+
+// the centre hub stays still, with the wordmark inside it
+circle(hub, (cx, cy), 150);
+stroke(hub, 2.5);
+color(hub, #f5f2e5);
+text(word, (cx, cy), "manic");
+size(word, 66);
+color(word, #ff2d95);
+
+par {
+  // rings breathe at once, phase = position -> the wave travels
+  for i in 0..n {
+    let ph = lobes * i / n;
+    breathe(cin{i},  2.4, 0.85, ph, 18);
+    breathe(cout{i}, 2.4, 0.92, ph, 18);
+  }
+  // the wheel spins: steady, then fast, then easing to a slow stop
+  seq {
+    turn(wheel, (cx, cy), 100, 6, linear);   // steady
+    turn(wheel, (cx, cy), 320, 4, in);        // accelerate -> fast
+    turn(wheel, (cx, cy), 150, 8, out);       // decelerate -> slow stop
+  }
+  // and the wordmark cycles through the palette on the way
+  seq {
+    wait(6);  recolor(word, #00e6ff, 1.2);  recolor(spokes, #00e6ff, 1.6);
+    wait(4);  recolor(word, #7cff6b, 1.2);
+    wait(3);  recolor(word, #ffd166, 1.2);
+  }
+}

package/examples/wheel-square.manic

@@ -0,0 +1,83 @@
+// wheel-square — the square sibling of wheel-radial: a breathing burst whose rings
+// sit on a SQUARE, on black.
+//
+// The reveal: it starts DEAD STILL — only the rings breathe, and because each ring's
+// phase = its position, the size-wave travels and FAKES a rotation though nothing
+// moves. After ~6s the trick is dropped and the whole burst actually spins
+// COUNTER-CLOCKWISE (steady -> fast -> slow), the wordmark cycling colour.
+//
+// Each spoke's tip is projected onto a square instead of a circle: a ray at angle
+// `ang` hits a square of half-width R at distance R / max(|cos|,|sin|).
+//
+//   manic examples/wheel-square.manic
+canvas(1080, 1080);
+template("mono");
+
+let n     = 64;
+let cx    = 540;
+let cy    = 540;
+let rin   = 195;      // inner square half-width
+let len    = 145;      // spoke length -> outer square half-width = rin + len
+let pi     = 3.14159265;
+let lobes   = 5;
+// sized so the corners (at rout*sqrt(2)) stay inside the frame even when spun
+
+// 1) the frame: spokes + hollow SQUARES on a square, tagged `wheel` so `turn` spins them
+for i in 0..n {
+  let ang = i * 2 * pi / n;
+  let c  = cos(ang);
+  let s  = sin(ang);
+  let ca = abs(c);
+  let sa = abs(s);
+  let m  = 0.5 * (ca + sa + abs(ca - sa));   // = max(|cos|,|sin|): ray -> square edge
+  let ix = cx + (rin / m) * c;
+  let iy = cy + (rin / m) * s;
+  let ox = cx + ((rin + len) / m) * c;
+  let oy = cy + ((rin + len) / m) * s;
+
+  line(spoke{i}, (ix, iy), (ox, oy));
+  stroke(spoke{i}, 1.2);
+  color(spoke{i}, #55607a);
+  tag(spoke{i}, wheel);
+  tag(spoke{i}, spokes);
+
+  rect(cin{i}, (ix, iy), 9, 9);
+  stroke(cin{i}, 2);
+  color(cin{i}, #000000);        // hollow: fill matches the black background
+  tag(cin{i}, wheel);
+
+  rect(cout{i}, (ox, oy), 22, 22);
+  stroke(cout{i}, 2.5);
+  color(cout{i}, #000000);
+  tag(cout{i}, wheel);
+}
+
+// the centre hub stays still, with the wordmark inside it (a square frame too)
+rect(hub, (cx, cy), 300, 300);
+stroke(hub, 2.5);
+color(hub, #000000);
+text(word, (cx, cy), "manic");
+size(word, 66);
+color(word, #ff2d95);
+
+par {
+  // rings breathe the WHOLE time, phase = position -> the wave travels
+  for i in 0..n {
+    let ph = lobes * i / n;
+    breathe(cin{i},  2.4, 0.85, ph, 24);
+    breathe(cout{i}, 2.4, 0.92, ph, 24);
+  }
+  // hold still for the illusion, THEN spin COUNTER-CLOCKWISE: steady -> fast -> slow
+  seq {
+    wait(6);                                   // just the breathing fakes rotation
+    turn(wheel, (cx, cy), -100, 6, linear);    // now it really turns: steady
+    turn(wheel, (cx, cy), -320, 4, in);         // accelerate -> fast
+    turn(wheel, (cx, cy), -150, 8, out);        // decelerate -> slow stop
+  }
+  // the wordmark cycles through the palette once the spin begins
+  seq {
+    wait(6);  recolor(word, #00e6ff, 1.2);  recolor(spokes, #00e6ff, 1.6);
+    wait(5);  recolor(word, #7cff6b, 1.2);
+    wait(4);  recolor(word, #ffd166, 1.2);
+  }
+}

package/examples/wireframe-spheres.manic

@@ -0,0 +1,37 @@
+// wireframe-spheres — a drifting field of triangulated wireframe spheres, each
+// BREATHING (radius oscillating) with a phase tied to its index, so the field
+// pulses like a shoal of soap bubbles. The breathing is the 3-D echo of the 2-D
+// `wheel-radial` wave; `finish3(id, "wire=1")` renders any solid as its bright
+// triangulated wireframe with no filled faces (works on cube/prism/pyramid too).
+//
+//   manic examples/wireframe-spheres.manic
+canvas(1080, 1080);
+template("black");
+camera3((0, -15, 1.5), (0, 0, 0), 56);
+
+let m = 66;
+
+for i in 0..m {
+  let x = 9.5 * sin(i * 2.399 + 0.5);
+  let y = 8.5 * sin(i * 1.13 + 1.7);
+  let z = 6.5 * sin(i * 3.11 + 0.3);
+  let r = 0.5 + 0.85 * sin(i * 1.7) * sin(i * 1.7);
+
+  sphere3(s{i}, (x, y, z), r);
+  finish3(s{i}, "wire=1");
+  hue(s{i}, 360 * i / m);          // a computed rainbow — hue works on 3D now
+}
+
+// every sphere breathes at once, but each with its OWN amplitude, period and
+// phase (deterministic pseudo-random from the index — manic has no rand()), so
+// the bubbles pulse by different amounts instead of in lockstep.
+par {
+  for i in 0..m {
+    let ra = 0.5 + 0.5 * sin(i * 12.9 + 0.5);   // 0..1 pseudo-random
+    let rb = 0.5 + 0.5 * sin(i * 7.7 + 2.3);
+    let rc = 0.5 + 0.5 * sin(i * 5.3 + 4.1);
+    let amp = 0.28 + 0.55 * ra * ra;             // breath size: ~0.28..0.83
+    let per = 2.0 + 2.2 * rb;                     // breath rate: 2.0..4.2 s
+    breathe(s{i}, per, amp, rc, 14);
+  }
+}