@maniclang/workbench 0.1.11

package/examples/prompt-test-7.manic

@@ -0,0 +1,156 @@
+title("Halving Pizza Circle");
+canvas("16:9");
+
+let r = 220;
+let n = 16;
+
+text(head, (cx, 65), "keep halving the circle");
+display(head);
+color(head, cyan);
+size(head, 34);
+hidden(head);
+
+text(cap, (cx, h - 55), "");
+display(cap);
+color(cap, fg);
+size(cap, 22);
+hidden(cap);
+
+circle(pizza, (cx, cy), r);
+color(pizza, lime);
+stroke(pizza, 4);
+glow(pizza, 7);
+untraced(pizza);
+
+dot(center, (cx, cy), 6);
+color(center, magenta);
+hidden(center);
+
+for i in 0..n {
+sector(slice{i}, (cx, cy), r, tau*i/n, tau*(i+1)/n);
+filled(slice{i});
+hue(slice{i}, 360*i/n, 0.65, 0.55);
+opacity(slice{i}, 0.55);
+outline(slice{i}, fg);
+stroke(slice{i}, 2);
+hidden(slice{i});
+tag(slice{i}, slices);
+}
+
+line(half0, (cx - r, cy), (cx + r, cy));
+line(half1, (cx, cy - r), (cx, cy + r));
+line(half2, (cx - r*cos(pi/4), cy - r*sin(pi/4)), (cx + r*cos(pi/4), cy + r*sin(pi/4)));
+line(half3, (cx - r*cos(pi/4), cy + r*sin(pi/4)), (cx + r*cos(pi/4), cy - r*sin(pi/4)));
+color(half0, fg);
+color(half1, fg);
+color(half2, fg);
+color(half3, fg);
+stroke(half0, 4);
+stroke(half1, 4);
+stroke(half2, 4);
+stroke(half3, 4);
+untraced(half0);
+untraced(half1);
+untraced(half2);
+untraced(half3);
+
+for i in 0..n {
+line(cut{i}, (cx, cy), (cx + r*cos(tau*i/n), cy + r*sin(tau*i/n)));
+color(cut{i}, fg);
+stroke(cut{i}, 2);
+untraced(cut{i});
+tag(cut{i}, finecuts);
+}
+
+text(step1, (cx - 430, 150), "1 cut: 2 halves");
+text(step2, (cx - 430, 195), "2 cuts: 4 quarters");
+text(step3, (cx - 430, 240), "4 cuts: 8 slices");
+text(step4, (cx - 430, 285), "8 cuts: 16 thin slices");
+display(step1);
+display(step2);
+display(step3);
+display(step4);
+color(step1, fg);
+color(step2, fg);
+color(step3, fg);
+color(step4, lime);
+size(step1, 23);
+size(step2, 23);
+size(step3, 23);
+size(step4, 23);
+hidden(step1);
+hidden(step2);
+hidden(step3);
+hidden(step4);
+
+text(done, (cx, cy), "all slices out");
+display(done);
+color(done, magenta);
+size(done, 34);
+hidden(done);
+
+show(head, 0.5);
+show(cap, 0.3);
+say(cap, "Start with one whole circle.", 0.6);
+
+par {
+draw(pizza, 0.8);
+show(center, 0.4);
+}
+say(cap, "Now keep halving it like pizza.", 0.7);
+
+draw(half0, 0.5);
+show(step1, 0.3);
+say(cap, "One cut makes two halves.", 0.6);
+
+draw(half1, 0.5);
+show(step2, 0.3);
+say(cap, "Cut again: four quarters.", 0.6);
+
+par {
+draw(half2, 0.5);
+draw(half3, 0.5);
+}
+show(step3, 0.3);
+say(cap, "Cut the quarters in half: eight slices.", 0.6);
+
+stagger(0.035) {
+for i in 0..n {
+draw(cut{i}, 0.18);
+}
+}
+show(step4, 0.3);
+say(cap, "Keep halving until there are sixteen thin slices.", 0.7);
+
+par {
+fade(pizza, 0.4);
+fade(half0, 0.4);
+fade(half1, 0.4);
+fade(half2, 0.4);
+fade(half3, 0.4);
+fade(finecuts, 0.4);
+}
+
+stagger(0.035) {
+for i in 0..n {
+show(slice{i}, 0.16);
+}
+}
+say(cap, "Now take the slices out one by one.", 0.7);
+
+stagger(0.12) {
+for i in 0..n {
+shift(slice{i}, (110*cos(tau*(i+0.5)/n), 110*sin(tau*(i+0.5)/n)), 0.45, smooth);
+}
+}
+
+stagger(0.08) {
+for i in 0..n {
+fade(slice{i}, 0.25);
+}
+}
+
+show(done, 0.5);
+pulse(done, 0.7);
+say(cap, "The circle was halved again and again, then every slice was removed.", 0.8);
+wait(1.0);

package/examples/prompt-test-8.manic

@@ -0,0 +1,266 @@
+title("Insertion Sort");
+canvas("16:9");
+
+text(head, (cx, 65), "insertion sort");
+display(head);
+color(head, cyan);
+size(head, 38);
+hidden(head);
+
+text(cap, (cx, h - 55), "");
+display(cap);
+color(cap, fg);
+size(cap, 22);
+hidden(cap);
+
+array(a, "5 2 4 6 1 3", (cx, cy), 82, 72);
+hidden(a.cells);
+hidden(a.boxes);
+color(a.cells, fg);
+
+text(pass, (cx, cy - 150), "");
+display(pass);
+color(pass, cyan);
+size(pass, 30);
+hidden(pass);
+
+text(action, (cx, cy + 125), "");
+display(action);
+color(action, fg);
+size(action, 24);
+hidden(action);
+
+text(keybox, (cx, cy - 95), "key = ?");
+display(keybox);
+color(keybox, magenta);
+size(keybox, 28);
+hidden(keybox);
+
+counter(comp, (cx - 250, cy + 205), 0, 0, "comparisons = ", "");
+display(comp);
+color(comp, cyan);
+size(comp, 22);
+hidden(comp);
+
+counter(shifts, (cx + 250, cy + 205), 0, 0, "shifts = ", "");
+display(shifts);
+color(shifts, magenta);
+size(shifts, 22);
+hidden(shifts);
+
+text(prefix1, (cx - 205, cy - 62), "sorted");
+text(prefix2, (cx - 164, cy - 62), "sorted");
+text(prefix3, (cx - 123, cy - 62), "sorted");
+text(prefix4, (cx - 82, cy - 62), "sorted");
+text(prefix5, (cx - 41, cy - 62), "sorted");
+text(prefix6, (cx, cy - 62), "sorted");
+display(prefix1);
+display(prefix2);
+display(prefix3);
+display(prefix4);
+display(prefix5);
+display(prefix6);
+color(prefix1, lime);
+color(prefix2, lime);
+color(prefix3, lime);
+color(prefix4, lime);
+color(prefix5, lime);
+color(prefix6, lime);
+size(prefix1, 18);
+size(prefix2, 18);
+size(prefix3, 18);
+size(prefix4, 18);
+size(prefix5, 18);
+size(prefix6, 18);
+hidden(prefix1);
+hidden(prefix2);
+hidden(prefix3);
+hidden(prefix4);
+hidden(prefix5);
+hidden(prefix6);
+
+text(done, (cx, cy + 285), "sorted array: 1 2 3 4 5 6");
+display(done);
+color(done, lime);
+size(done, 32);
+hidden(done);
+
+show(head, 0.5);
+show(cap, 0.3);
+say(cap, "Insertion sort grows a sorted prefix one item at a time.", 0.8);
+
+par {
+show(a.boxes, 0.5);
+show(a.cells, 0.5);
+show(pass, 0.3);
+show(action, 0.3);
+show(keybox, 0.3);
+show(comp, 0.3);
+show(shifts, 0.3);
+}
+show(prefix1, 0.25);
+say(cap, "The first element is already a sorted prefix.", 0.7);
+
+say(pass, "i = 1", 0.25);
+say(keybox, "key = 2", 0.25);
+flash(a.c1, magenta);
+say(action, "compare key 2 with 5", 0.25);
+par {
+flash(a.c0, cyan);
+flash(a.c1, cyan);
+}
+to(comp, value, 1, 0.25);
+say(action, "5 > 2, shift 5 right", 0.25);
+par {
+flash(a.c0, magenta);
+flash(a.c1, magenta);
+say(a.c1, "5", 0.28);
+}
+to(shifts, value, 1, 0.25);
+say(action, "insert key at slot 0", 0.25);
+say(a.c0, "2", 0.28);
+show(prefix2, 0.25);
+say(cap, "Now 2 5 is sorted.", 0.6);
+
+say(pass, "i = 2", 0.25);
+say(keybox, "key = 4", 0.25);
+flash(a.c2, magenta);
+say(action, "compare key 4 with 5", 0.25);
+par {
+flash(a.c1, cyan);
+flash(a.c2, cyan);
+}
+to(comp, value, 2, 0.25);
+say(action, "5 > 4, shift 5 right", 0.25);
+par {
+flash(a.c1, magenta);
+flash(a.c2, magenta);
+say(a.c2, "5", 0.28);
+}
+to(shifts, value, 2, 0.25);
+say(action, "compare key 4 with 2", 0.25);
+par {
+flash(a.c0, cyan);
+flash(a.c1, cyan);
+}
+to(comp, value, 3, 0.25);
+say(action, "2 <= 4, insert key after 2", 0.25);
+say(a.c1, "4", 0.28);
+show(prefix3, 0.25);
+say(cap, "The sorted prefix becomes 2 4 5.", 0.6);
+
+say(pass, "i = 3", 0.25);
+say(keybox, "key = 6", 0.25);
+flash(a.c3, magenta);
+say(action, "compare key 6 with 5", 0.25);
+par {
+flash(a.c2, cyan);
+flash(a.c3, cyan);
+}
+to(comp, value, 4, 0.25);
+say(action, "5 <= 6, no shift", 0.25);
+show(prefix4, 0.25);
+say(cap, "6 is already in the right place.", 0.6);
+
+say(pass, "i = 4", 0.25);
+say(keybox, "key = 1", 0.25);
+flash(a.c4, magenta);
+say(action, "key 1 moves left through the sorted prefix", 0.25);
+
+say(action, "6 > 1, shift 6 right", 0.25);
+par {
+flash(a.c3, magenta);
+flash(a.c4, magenta);
+say(a.c4, "6", 0.25);
+}
+to(comp, value, 5, 0.2);
+to(shifts, value, 3, 0.2);
+
+say(action, "5 > 1, shift 5 right", 0.25);
+par {
+flash(a.c2, magenta);
+flash(a.c3, magenta);
+say(a.c3, "5", 0.25);
+}
+to(comp, value, 6, 0.2);
+to(shifts, value, 4, 0.2);
+
+say(action, "4 > 1, shift 4 right", 0.25);
+par {
+flash(a.c1, magenta);
+flash(a.c2, magenta);
+say(a.c2, "4", 0.25);
+}
+to(comp, value, 7, 0.2);
+to(shifts, value, 5, 0.2);
+
+say(action, "2 > 1, shift 2 right", 0.25);
+par {
+flash(a.c0, magenta);
+flash(a.c1, magenta);
+say(a.c1, "2", 0.25);
+}
+to(comp, value, 8, 0.2);
+to(shifts, value, 6, 0.2);
+
+say(action, "insert key at the front", 0.25);
+say(a.c0, "1", 0.28);
+show(prefix5, 0.25);
+say(cap, "The sorted prefix is now 1 2 4 5 6.", 0.7);
+
+say(pass, "i = 5", 0.25);
+say(keybox, "key = 3", 0.25);
+flash(a.c5, magenta);
+say(action, "move key 3 left until it fits", 0.25);
+
+say(action, "6 > 3, shift 6 right", 0.25);
+par {
+flash(a.c4, magenta);
+flash(a.c5, magenta);
+say(a.c5, "6", 0.25);
+}
+to(comp, value, 9, 0.2);
+to(shifts, value, 7, 0.2);
+
+say(action, "5 > 3, shift 5 right", 0.25);
+par {
+flash(a.c3, magenta);
+flash(a.c4, magenta);
+say(a.c4, "5", 0.25);
+}
+to(comp, value, 10, 0.2);
+to(shifts, value, 8, 0.2);
+
+say(action, "4 > 3, shift 4 right", 0.25);
+par {
+flash(a.c2, magenta);
+flash(a.c3, magenta);
+say(a.c3, "4", 0.25);
+}
+to(comp, value, 11, 0.2);
+to(shifts, value, 9, 0.2);
+
+say(action, "2 <= 3, insert key after 2", 0.25);
+par {
+flash(a.c1, cyan);
+flash(a.c2, cyan);
+}
+to(comp, value, 12, 0.2);
+say(a.c2, "3", 0.28);
+show(prefix6, 0.25);
+
+say(pass, "done", 0.3);
+say(keybox, "key = none", 0.25);
+say(action, "every prefix is sorted, so the whole array is sorted", 0.35);
+par {
+flash(a.c0, lime);
+flash(a.c1, lime);
+flash(a.c2, lime);
+flash(a.c3, lime);
+flash(a.c4, lime);
+flash(a.c5, lime);
+}
+show(done, 0.5);
+pulse(done, 0.7);
+say(cap, "Insertion sort is complete.", 0.7);
+wait(1.0);

package/examples/prompt-test-9.manic

@@ -0,0 +1,171 @@
+title("Binary Search");
+canvas("16:9");
+
+let cw = 78;
+let ch = 72;
+let x0 = cx - 4*cw;
+let ay = cy + 20;
+
+text(head, (cx, 65), "binary search");
+display(head);
+color(head, cyan);
+size(head, 38);
+hidden(head);
+
+text(cap, (cx, h - 55), "");
+display(cap);
+color(cap, fg);
+size(cap, 22);
+hidden(cap);
+
+text(target, (cx, 125), "target = 13");
+display(target);
+color(target, magenta);
+size(target, 32);
+hidden(target);
+
+array(a, "1 3 5 7 9 11 13 15 17", (cx, ay), cw, ch);
+hidden(a.cells);
+hidden(a.boxes);
+color(a.cells, fg);
+
+rect(range0, (cx, ay), 9*cw, ch + 18);
+outline(range0, cyan);
+stroke(range0, 4);
+hidden(range0);
+
+rect(range1, (x0 + 6.5cw, ay), 4cw, ch + 18);
+outline(range1, cyan);
+stroke(range1, 4);
+hidden(range1);
+
+rect(foundBox, (x0 + 6*cw, ay), cw, ch + 18);
+outline(foundBox, lime);
+stroke(foundBox, 5);
+glow(foundBox, 10);
+hidden(foundBox);
+
+arrow(probe0, (x0 + 4cw, ay - 135), (x0 + 4cw, ay - 55));
+arrow(probe1, (x0 + 6cw, ay - 135), (x0 + 6cw, ay - 55));
+color(probe0, magenta);
+color(probe1, magenta);
+stroke(probe0, 5);
+stroke(probe1, 5);
+glow(probe0, 8);
+glow(probe1, 8);
+untraced(probe0);
+untraced(probe1);
+
+text(mid0, (x0 + 4cw, ay - 165), "mid");
+text(mid1, (x0 + 6cw, ay - 165), "mid");
+display(mid0);
+display(mid1);
+color(mid0, magenta);
+color(mid1, magenta);
+size(mid0, 24);
+size(mid1, 24);
+hidden(mid0);
+hidden(mid1);
+
+text(low0, (x0, ay + 82), "low");
+text(high0, (x0 + 8cw, ay + 82), "high");
+text(low1, (x0 + 5cw, ay + 82), "low");
+text(high1, (x0 + 8*cw, ay + 82), "high");
+display(low0);
+display(high0);
+display(low1);
+display(high1);
+color(low0, cyan);
+color(high0, cyan);
+color(low1, cyan);
+color(high1, cyan);
+size(low0, 20);
+size(high0, 20);
+size(low1, 20);
+size(high1, 20);
+hidden(low0);
+hidden(high0);
+hidden(low1);
+hidden(high1);
+
+text(step, (cx, ay + 150), "");
+display(step);
+color(step, fg);
+size(step, 25);
+hidden(step);
+
+text(done, (cx, ay + 225), "found 13 at index 6");
+display(done);
+color(done, lime);
+size(done, 34);
+hidden(done);
+
+show(head, 0.5);
+show(cap, 0.3);
+say(cap, "Binary search works only on a sorted array.", 0.7);
+
+par {
+show(a.boxes, 0.5);
+show(a.cells, 0.5);
+show(target, 0.5);
+show(step, 0.3);
+}
+say(cap, "We will search for 13.", 0.6);
+
+par {
+show(range0, 0.4);
+show(low0, 0.3);
+show(high0, 0.3);
+}
+say(step, "search range: index 0 to 8", 0.35);
+say(cap, "Start with the whole array.", 0.6);
+
+par {
+draw(probe0, 0.45);
+show(mid0, 0.3);
+flash(a.c4, magenta);
+}
+say(step, "middle value is 9", 0.35);
+say(cap, "The arrow points to the value being checked.", 0.7);
+
+say(step, "9 < 13, so discard the left half", 0.4);
+par {
+fade(range0, 0.35);
+fade(low0, 0.35);
+fade(high0, 0.35);
+fade(probe0, 0.35);
+fade(mid0, 0.35);
+flash(a.c0, dim);
+flash(a.c1, dim);
+flash(a.c2, dim);
+flash(a.c3, dim);
+flash(a.c4, dim);
+}
+say(cap, "Since 9 is too small, the target must be to the right.", 0.8);
+
+par {
+show(range1, 0.4);
+show(low1, 0.3);
+show(high1, 0.3);
+}
+say(step, "new range: index 5 to 8", 0.35);
+
+par {
+draw(probe1, 0.45);
+show(mid1, 0.3);
+flash(a.c6, magenta);
+}
+say(step, "middle value is 13", 0.35);
+say(cap, "Check the middle of the remaining range.", 0.6);
+
+say(step, "13 == 13, target found", 0.4);
+par {
+show(foundBox, 0.4);
+flash(a.c6, lime);
+pulse(a.c6, 0.6);
+}
+show(done, 0.5);
+pulse(done, 0.7);
+say(cap, "Binary search found the target in just two checks.", 0.8);
+
+wait(1.0);