redscript-mc 1.2.26 → 1.2.28

package/dist/optimizer/commands.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setOptimizerObjective = setOptimizerObjective;
 exports.createEmptyOptimizationStats = createEmptyOptimizationStats;
 exports.mergeOptimizationStats = mergeOptimizationStats;
 exports.applyLICM = applyLICM;
 exports.applyCSE = applyCSE;
 exports.batchSetblocks = batchSetblocks;
 exports.optimizeCommandFunctions = optimizeCommandFunctions;
-const SCOREBOARD_READ_RE = /^execute store result score (\$[A-Za-z0-9_]+) rs run scoreboard players get (\S+) (\S+)$/;
+// Matches scoreboard reads for LICM/CSE — objective is captured in group 2
+// so the optimizer can reconstruct the command with the same objective.
+let _OBJ_PATTERN = 'rs';
+function setOptimizerObjective(obj) { _OBJ_PATTERN = obj; }
+function scoreboardReadRe() {
+    return new RegExp(`^execute store result score (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} run scoreboard players get (\\S+) (\\S+)$`);
+}
 const SCOREBOARD_WRITE_RE = /^(?:scoreboard players (?:set|add|remove|reset)\s+(\S+)\s+(\S+)|scoreboard players operation\s+(\S+)\s+(\S+)\s+[+\-*/%]?= )/;
 const EXECUTE_STORE_SCORE_RE = /^execute store result score (\S+) (\S+) run /;
 const FUNCTION_CALL_RE = /^execute as (.+) run function ([^:]+):(.+)$/;
@@ -95,7 +102,7 @@ function applyLICMInternal(functions) {
             const readInfo = new Map();
             const scoreboardWrites = new Set();
             for (const inner of loopFn.commands) {
-                const readMatch = inner.cmd.match(SCOREBOARD_READ_RE);
+                const readMatch = inner.cmd.match(scoreboardReadRe());
                 if (readMatch) {
                     const [, temp, player, objective] = readMatch;
                     const key = `${player} ${objective}`;
@@ -110,7 +117,7 @@ function applyLICMInternal(functions) {
                 for (const info of readInfo.values()) {
                     const matches = inner.cmd.match(TEMP_RE) ?? [];
                     const usageCount = matches.filter(name => name === info.temp).length;
-                    const isDef = inner.cmd.startsWith(`execute store result score ${info.temp} rs run scoreboard players get `);
+                    const isDef = inner.cmd.startsWith(`execute store result score ${info.temp} ${_OBJ_PATTERN} run scoreboard players get `);
                     if (!isDef) {
                         info.uses += usageCount;
                     }
@@ -134,7 +141,7 @@ function applyLICMInternal(functions) {
             const hoistedTemps = new Set(hoistable.map(item => item.temp));
             const rewrittenLoopCommands = [];
             for (const inner of loopFn.commands) {
-                const readMatch = inner.cmd.match(SCOREBOARD_READ_RE);
+                const readMatch = inner.cmd.match(scoreboardReadRe());
                 if (readMatch && hoistedTemps.has(readMatch[1])) {
                     continue;
                 }
@@ -142,7 +149,7 @@ function applyLICMInternal(functions) {
             }
             loopFn.commands = rewrittenLoopCommands;
             nextCommands.push(...hoistable.map(item => ({
-                cmd: `execute store result score ${item.temp} rs run scoreboard players get ${item.player} ${item.objective}`,
+                cmd: `execute store result score ${item.temp} ${_OBJ_PATTERN} run scoreboard players get ${item.player} ${item.objective}`,
             })), command);
             stats.licmHoists = (stats.licmHoists ?? 0) + hoistable.length;
             stats.licmLoopBodies = (stats.licmLoopBodies ?? 0) + 1;
@@ -152,9 +159,9 @@ function applyLICMInternal(functions) {
     return stats;
 }
 function extractArithmeticExpression(commands, index) {
-    const assign = commands[index]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs = (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/) ??
-        commands[index]?.cmd.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs (-?\d+)$/);
-    const op = commands[index + 1]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs ([+\-*/%]=) (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/);
+    const assign = commands[index]?.cmd.match(new RegExp(`^scoreboard players operation (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} = (\\$[A-Za-z0-9_]+|\\$const_-?\\d+) ${_OBJ_PATTERN}$`)) ??
+        commands[index]?.cmd.match(new RegExp(`^scoreboard players set (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} (-?\\d+)$`));
+    const op = commands[index + 1]?.cmd.match(new RegExp(`^scoreboard players operation (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} ([+\\-*/%]=) (\\$[A-Za-z0-9_]+|\\$const_-?\\d+) ${_OBJ_PATTERN}$`));
     if (!assign || !op || assign[1] !== op[1]) {
         return null;
     }
@@ -184,14 +191,14 @@ function applyCSEInternal(functions) {
         }
         for (let i = 0; i < commands.length; i++) {
             const command = commands[i];
-            const readMatch = command.cmd.match(SCOREBOARD_READ_RE);
+            const readMatch = command.cmd.match(scoreboardReadRe());
             if (readMatch) {
                 const [, dst, player, objective] = readMatch;
                 const key = `${player} ${objective}`;
                 const cached = readCache.get(key);
                 if (cached) {
                     stats.cseRedundantReads = (stats.cseRedundantReads ?? 0) + 1;
-                    rewritten.push({ ...command, cmd: `scoreboard players operation ${dst} rs = ${cached} rs` });
+                    rewritten.push({ ...command, cmd: `scoreboard players operation ${dst} ${_OBJ_PATTERN} = ${cached} ${_OBJ_PATTERN}` });
                 }
                 else {
                     readCache.set(key, dst);
@@ -205,7 +212,7 @@ function applyCSEInternal(functions) {
             if (expr) {
                 const cached = exprCache.get(expr.key);
                 if (cached) {
-                    rewritten.push({ ...commands[i], cmd: `scoreboard players operation ${expr.dst} rs = ${cached} rs` });
+                    rewritten.push({ ...commands[i], cmd: `scoreboard players operation ${expr.dst} ${_OBJ_PATTERN} = ${cached} ${_OBJ_PATTERN}` });
                     stats.cseArithmetic = (stats.cseArithmetic ?? 0) + 1;
                     i += 1;
                 }

package/dist/optimizer/structure.d.ts

@@ -1,5 +1,6 @@
 import type { IRCommand, IRFunction } from '../ir/types';
 import { type OptimizationStats } from './commands';
+export declare function setStructureObjective(obj: string): void;
 export declare function optimizeFunctionForStructure(fn: IRFunction, functions: Map<string, IRFunction>, namespace: string): IRCommand[];
 export declare function optimizeForStructure(functions: IRFunction[], namespace?: string): IRFunction[];
 export declare function optimizeForStructureWithStats(functions: IRFunction[], namespace?: string): {

package/dist/optimizer/structure.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setStructureObjective = setStructureObjective;
 exports.optimizeFunctionForStructure = optimizeFunctionForStructure;
 exports.optimizeForStructure = optimizeForStructure;
 exports.optimizeForStructureWithStats = optimizeForStructureWithStats;
 const commands_1 = require("./commands");
-const OBJ = 'rs';
+let OBJ = 'rs';
+function setStructureObjective(obj) {
+    OBJ = obj;
+    (0, commands_1.setOptimizerObjective)(obj);
+}
 const INLINE_THRESHOLD = 8;
 const BOP_OP = {
     '+': '+=',

package/dist/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 26,
+    "description": "mypack datapack — compiled by redscript"
+  }
+}

package/dist/reqtest.map.json

@@ -0,0 +1,4 @@
+{
+  "$a": "const:42",
+  "$b": "internal:ret"
+}

package/dist/reqtest2.map.json

@@ -0,0 +1,4 @@
+{
+  "$a": "const:42",
+  "$b": "internal:ret"
+}

package/dist/runtime/index.js

@@ -647,17 +647,27 @@ class MCRuntime {
                 condition = condition && entities.length === 0;
                 continue;
             }
-            // Handle 'store result storage <ns:path> <field> <type> <scale>'
+            // Handle 'store result storage <ns:path> <field>[<idx>] <type> <scale>'  (array element)
             if (rest.startsWith('store result storage ')) {
-                rest = rest.slice(21);
-                // format: <ns:path> <field> <type> <scale> <run-cmd>
-                const storageParts = rest.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/);
+                const sliced = rest.slice(21);
+                // Try array-index form first: <ns:path> <field>[<idx>] <type> <scale> <run-cmd>
+                // Use [^\[\s]+ for field (no brackets or spaces) so that \[ matches correctly.
+                const arrParts = sliced.match(/^(\S+)\s+([^\[\s]+)\[(\d+)\]\s+(\S+)\s+([\d.]+)\s+(.*)$/);
+                if (arrParts) {
+                    const [, storagePath, field, indexStr, , , remaining] = arrParts;
+                    storeTarget = { storagePath, field: `${field}[${indexStr}]`, type: 'result' };
+                    rest = remaining.trim();
+                    continue;
+                }
+                // Plain form: <ns:path> <field> <type> <scale> <run-cmd>
+                const storageParts = sliced.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/);
                 if (storageParts) {
                     const [, storagePath, field, , , remaining] = storageParts;
                     storeTarget = { storagePath, field, type: 'result' };
                     rest = remaining.trim();
                     continue;
                 }
+                rest = sliced;
             }
             // Handle 'store result score <player> <obj>'
             if (rest.startsWith('store result score ')) {
@@ -771,8 +781,19 @@ class MCRuntime {
             }
             return true;
         }
+        // data modify storage <ns:path> <field>[<index>] set value <val>  (array element write)
+        const setArrMatch = cmd.match(/^data modify storage (\S+) ([^\[\s]+)\[(\d+)\] set value (.+)$/);
+        if (setArrMatch) {
+            const [, storagePath, field, indexStr, valueStr] = setArrMatch;
+            const arr = this.getStorageField(storagePath, field);
+            const idx = parseInt(indexStr, 10);
+            if (Array.isArray(arr) && idx >= 0 && idx < arr.length) {
+                arr[idx] = this.parseDataValue(valueStr);
+            }
+            return true;
+        }
         // data get storage <ns:path> <field>[<index>] [scale]  (array element access)
-        const getArrMatch = cmd.match(/^data get storage (\S+) (\S+)\[(\d+)\](?:\s+[\d.]+)?$/);
+        const getArrMatch = cmd.match(/^data get storage (\S+) ([^\[\s]+)\[(\d+)\](?:\s+[\d.]+)?$/);
         if (getArrMatch) {
             const [, storagePath, field, indexStr] = getArrMatch;
             const arr = this.getStorageField(storagePath, field);

package/dist/runtime.map.json

@@ -0,0 +1,7 @@
+{
+  "$d": "ticks",
+  "$a": "const:0",
+  "$b": "const:1",
+  "$c": "const:100",
+  "$i": "internal:ret"
+}

package/dist/swap_test.map.json

@@ -0,0 +1,14 @@
+{
+  "$b": "a",
+  "$d": "b",
+  "$f": "p0",
+  "$g": "p1",
+  "$h": "x",
+  "$i": "y",
+  "$k": "tmp",
+  "$n": "m",
+  "$a": "const:0",
+  "$c": "internal:p0",
+  "$e": "internal:p1",
+  "$m": "internal:ret"
+}

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.0.28",
+  "version": "1.0.35",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.0.28",
+      "version": "1.0.35",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"
@@ -23,7 +23,7 @@
     },
     "../..": {
       "name": "redscript-mc",
-      "version": "1.2.26",
+      "version": "1.2.27",
       "license": "MIT",
       "bin": {
         "redscript": "dist/cli.js",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.0.28",
+  "version": "1.0.35",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/examples/math-showcase.mcrs

@@ -0,0 +1,146 @@
+// math-showcase.mcrs — Fancy math examples for README / demo
+// Run each fn individually:  /function mathshow:<name>
+//
+// Compile:  node dist/cli.js compile examples/math-showcase.mcrs -o <dp> --namespace mathshow
+
+import "../src/stdlib/math.mcrs"
+import "../src/stdlib/vec.mcrs"
+import "../src/stdlib/advanced.mcrs"
+import "../src/stdlib/bigint.mcrs"
+
+// ─── 1. Trig table — print sin & cos for 0°, 15°, 30° … 90° ────────────────
+// NOTE: sin_fixed/cos_fixed return values in ×1000 space (sin(30°) = 500, not 0.5).
+//       s*s + c*c ≈ 1000000 because (sin×1000)²+(cos×1000)² = 10⁶×(sin²+cos²) = 10⁶.
+//       Requires __load to have run (initializes the sin table).
+fn trig_table() {
+    say("§e=== Trig Table (×1000 fixed-point, needs __load) ===");
+    let deg: int = 0;
+    while (deg <= 90) {
+        let s: int = sin_fixed(deg);
+        let c: int = cos_fixed(deg);
+        say(f"  {deg}°  sin={s}  cos={c}  s²+c²={s*s + c*c}  (expect ~1000000)");
+        deg = deg + 15;
+    }
+}
+
+// ─── 2. Newton–Raphson sqrt — compare isqrt vs sqrt_fixed ──────────────────
+// isqrt(n)      → floor(sqrt(n)), raw integer
+// sqrt_fixed(x) → sqrt of x/1000 expressed in ×1000 format
+//                 e.g. sqrt_fixed(2000) = sqrt(2.0)×1000 = 1414
+//                 Input must be in ×1000 space. Max input ≈ 2147000 (before overflow).
+// NOTE: Each isqrt call runs a convergence loop (bits+guess+Newton).
+//       Large values = more loop iterations = more MC commands.
+//       Keep inputs moderate to stay under Paper's maxCommandChainLength (65536).
+fn sqrt_showcase() {
+    say("§e=== Integer Square Root (isqrt) ===");
+    say(f"  isqrt(2)       = {isqrt(2)}    (exact: 1)");
+    say(f"  isqrt(144)     = {isqrt(144)}  (exact: 12)");
+    say(f"  isqrt(10000)   = {isqrt(10000)} (exact: 100)");
+    say(f"  isqrt(1000000) = {isqrt(1000000)} (exact: 1000)");
+
+    say("§e=== Fixed-Point sqrt (input&output in ×1000) ===");
+    say(f"  sqrt_fixed(1000) = {sqrt_fixed(1000)} (sqrt(1.0) = 1.000)");
+    say(f"  sqrt_fixed(2000) = {sqrt_fixed(2000)} (sqrt(2.0) ≈ 1.414)");
+    say(f"  sqrt_fixed(4000) = {sqrt_fixed(4000)} (sqrt(4.0) = 2.000)");
+    say(f"  sqrt_fixed(9000) = {sqrt_fixed(9000)} (sqrt(9.0) = 3.000)");
+}
+
+// ─── 3. 2D vector geometry ──────────────────────────────────────────────────
+fn vector_showcase() {
+    say("§e=== 2D Vector Geometry ===");
+    // 3-4-5 right triangle
+    let d345: int = distance2d_fixed(0, 0, 300, 400);
+    say(f"  dist((0,0)→(300,400))  = {d345}  (expect 500)");
+    // unit circle
+    let d_unit: int = length2d_fixed(1000, 0);
+    say(f"  length(1000, 0)        = {d_unit}  (expect 1000)");
+    // atan2
+    say(f"  atan2(1000, 0)         = {atan2_fixed(1000, 0)}°  (expect 90)");
+    say(f"  atan2(1000, 1000)      = {atan2_fixed(1000, 1000)}°  (expect 45)");
+    say(f"  atan2(-1, 0)           = {atan2_fixed(-1, 0)}°  (expect 270)");
+    // dot product: orthogonal vectors → 0
+    say(f"  dot2d(1000,0, 0,1000)  = {dot2d(1000, 0, 0, 1000)}  (expect 0, orthogonal)");
+    say(f"  dot2d(1000,0, 1000,0)  = {dot2d(1000, 0, 1000, 0)}  (expect 1000000, parallel)");
+}
+
+// ─── 4. Number theory ───────────────────────────────────────────────────────
+fn number_theory() {
+    say("§e=== Number Theory ===");
+    say(f"  gcd(360, 252)         = {gcd(360, 252)}      (expect 36)");
+    say(f"  lcm(12, 18)           = {lcm(12, 18)}        (expect 36)");
+    say(f"  is_prime(97)          = {is_prime(97)}       (expect 1)");
+    say(f"  is_prime(100)         = {is_prime(100)}      (expect 0)");
+    say(f"  fib(20)               = {fib(20)}            (expect 6765)");
+    say(f"  collatz_steps(27)     = {collatz_steps(27)}  (expect 111)");
+    say(f"  digit_sum(123456789)  = {digit_sum(123456789)} (expect 45)");
+    say(f"  mod_pow(2, 10, 1000)  = {mod_pow(2, 10, 1000)} (expect 24)");
+    say(f"  mod_pow(7, 5, 13)     = {mod_pow(7, 5, 13)}    (expect 11)");
+}
+
+// ─── 5. Fixed-point interpolation & easing ──────────────────────────────────
+fn easing_showcase() {
+    say("§e=== Easing & Interpolation (t = 0..1000) ===");
+    let t: int = 0;
+    while (t <= 1000) {
+        let lin: int = lerp(0, 1000, t);
+        let sm:  int = smoothstep(0, 1000, t);
+        let smr: int = smootherstep(0, 1000, t);
+        say(f"  t={t}  lerp={lin}  smooth={sm}  smoother={smr}");
+        t = t + 250;
+    }
+}
+
+// ─── 6. Hash & noise ────────────────────────────────────────────────────────
+fn hash_showcase() {
+    say("§e=== Hash & Procedural Noise ===");
+    say(f"  hash_int(0)           = {hash_int(0)}");
+    say(f"  hash_int(1)           = {hash_int(1)}");
+    say(f"  hash_int(42)          = {hash_int(42)}");
+    say(f"  noise1d(0)            = {noise1d(0)}   (0..1000)");
+    say(f"  noise1d(100)          = {noise1d(100)}");
+    say(f"  noise1d(200)          = {noise1d(200)}");
+    say(f"  noise1d(300)          = {noise1d(300)}");
+}
+
+// ─── 7. BigInt Fibonacci — numbers beyond INT32 ─────────────────────────────
+fn bigint_showcase() {
+    say("§e=== BigInt — Arbitrary Precision (base 10000, 8 limbs) ===");
+    bigint_fib(50);
+    let l0: int = bigint_get_a(0);
+    let l1: int = bigint_get_a(1);
+    let l2: int = bigint_get_a(2);
+    say(f"  fib(50)  limbs: [{l2}][{l1}][{l0}]");
+    say(f"           = {l2}×10⁸ + {l1}×10⁴ + {l0}");
+    say(f"           = 12,586,269,025  (verify: l0=9025 l1=8626 l2=125)");
+
+    bigint_fib(70);
+    let m0: int = bigint_get_a(0);
+    let m1: int = bigint_get_a(1);
+    let m2: int = bigint_get_a(2);
+    let m3: int = bigint_get_a(3);
+    say(f"  fib(70)  limbs: [{m3}][{m2}][{m1}][{m0}]");
+    say(f"           = 190,392,490,709,135");
+}
+
+// ─── 8. Mandelbrot / Julia — fractals in integer arithmetic ─────────────────
+fn fractal_showcase() {
+    say("§e=== Mandelbrot & Julia (fixed-point, scale=1000) ===");
+    // Mandelbrot: does (cr, ci) escape in <max_iter> steps?
+    say(f"  mandelbrot_iter(0, 0, 64)         = {mandelbrot_iter(0, 0, 64)}  (inside, expect 64)");
+    say(f"  mandelbrot_iter(2000, 0, 64)      = {mandelbrot_iter(2000, 0, 64)}  (outside, < 64)");
+    say(f"  mandelbrot_iter(-500, 500, 64)    = {mandelbrot_iter(-500, 500, 64)}");
+    say(f"  julia_iter(0, 0, -500, 250, 64)  = {julia_iter(0, 0, -500, 250, 64)}");
+    say(f"  julia_iter(500, 0, -500, 250, 64)= {julia_iter(500, 0, -500, 250, 64)}");
+}
+
+// ─── 9. Run everything ──────────────────────────────────────────────────────
+fn run_all() {
+    trig_table();
+    sqrt_showcase();
+    vector_showcase();
+    number_theory();
+    easing_showcase();
+    hash_showcase();
+    bigint_showcase();
+    fractal_showcase();
+}

package/examples/readme-demo.mcrs

@@ -0,0 +1,92 @@
+// readme-demo.mcrs — RedScript v1.2.27 README visual showcase
+// What 55 lines of RedScript can do on a vanilla Minecraft server.
+//
+// Compile:  node dist/cli.js compile examples/readme-demo.mcrs -o <datapack> --namespace rsdemo
+// In-game:  /function rsdemo:start   (then record your gif)
+//           /function rsdemo:stop
+
+import "../src/stdlib/math.mcrs"
+
+let t:     int = 0;     // 0..359 degrees, 4° per tick = full cycle every 1.5 s
+let frame: int = 0;
+let on:    bool = false;
+
+@load fn _init() {
+    t = 0;
+    frame = 0;
+}
+
+@tick fn _wave_tick() {
+    if (!on) { return; }
+
+    t = (t + 4) % 360;
+    frame = frame + 1;
+
+    let s:   int = sin_fixed(t);        // -1000 .. 1000
+    let c:   int = cos_fixed(t);        // -1000 .. 1000
+    let mag: int = abs(s);              // 0 .. 1000
+
+    // ── Particle rings: spread values scale with sin(t) ─────────────────
+    // Inner ring — always visible, small tight shimmer
+    foreach (p in @a) at @s {
+        particle("minecraft:end_rod", ~0, ~1, ~0, 0.25, 0.08, 0.25, 0.02, 6);
+    }
+
+    // Mid ring — appears when sin > 0 (upper half of cycle)
+    if (s > 0) {
+        foreach (p in @a) at @s {
+            particle("minecraft:end_rod", ~0, ~1, ~0, 0.9, 0.25, 0.9, 0.02, 12);
+        }
+    }
+
+    // Outer ring + soul fire — sin > 600
+    if (s > 600) {
+        foreach (p in @a) at @s {
+            particle("minecraft:end_rod", ~0, ~1, ~0, 1.8, 0.4, 1.8, 0.02, 18);
+            particle("minecraft:soul_fire_flame", ~0, ~2, ~0, 0.9, 0.3, 0.9, 0.03, 8);
+        }
+    }
+
+    // Peak flash — fires ~4 ticks per cycle
+    if (s > 940) {
+        foreach (p in @a) at @s {
+            particle("minecraft:flash", ~0, ~3, ~0, 0.4, 0.3, 0.4, 0.1, 3);
+        }
+    }
+
+    // Negative trough — ground portal swirl
+    if (s < -700) {
+        foreach (p in @a) at @s {
+            particle("minecraft:portal", ~0, ~0.5, ~0, 1.2, 0.4, 1.2, 0.05, 12);
+        }
+    }
+
+    // ── Actionbar: live math rotating every 3 s ──────────────────────────
+    let seg: int = (frame / 45) % 4;
+    if (seg == 0) {
+        actionbar(@a, f"§3⚡ §bsin({t}°) = §e{s}‰   cos({t}°) = §e{c}‰");
+    }
+    if (seg == 1) {
+        actionbar(@a, f"§3⚡ §bsmoothstep(|sin|) = §e{smoothstep(0, 1000, mag)}‰   isqrt({frame}) = §e{isqrt(frame)}");
+    }
+    if (seg == 2) {
+        actionbar(@a, f"§3⚡ §bgcd(360, {t + 1}) = §e{gcd(360, t + 1)}   log2({mag + 1}) = §e{log2_int(mag + 1)}");
+    }
+    if (seg == 3) {
+        actionbar(@a, f"§3⚡ §bpow(2, {(frame / 30) % 10 + 1}) = §e{pow_int(2, (frame / 30) % 10 + 1)}   clamp(sin) = §e{clamp(s, -500, 500)}");
+    }
+}
+
+fn start() {
+    on = true;
+    t = 0;
+    frame = 0;
+    title(@a, f"§e✦ §bRedScript§e ✦", f"§7trig-driven particle rings");
+    say("§a▶ readme-demo started  — /function rsdemo:stop to end");
+}
+
+fn stop() {
+    on = false;
+    actionbar(@a, f"§7[ demo stopped ]");
+    say("§c■ readme-demo stopped");
+}