move examples into subfolder, added wasm4 skip_ahead

examples/microw8/plasma.cwa

@@ -0,0 +1,16 @@
+import "env.memory" memory(4);
+import "math.sin" fn sin(f32) -> f32;
+import "math.cos" fn cos(f32) -> f32;
+
+export fn tic(time: i32) {
+    let i: i32;
+    loop screen {
+        let defer x = (i % 320) as f32 / 48 as f32;
+        let defer y = (i / 320) as f32 / 48 as f32;
+        let defer t = time as f32 / 200 as f32;
+
+        i?120 = ((sin(x + sin(y - t / 4 as f32) * 3 as f32 + t / 5 as f32) + sin(y + sin(x - t / 3 as f32) + t / 6 as f32)) * 63 as f32) as i32 + 128;
+
+        branch_if (i := i + 1) < 320*256: screen
+    }
+}

examples/microw8/random.cwa

@@ -0,0 +1,35 @@
+import "env.memory" memory(4);
+
+global mut randomState: i64 = 37i64;
+
+fn random() -> i32 {
+    (random64() >> 32i64) as i32
+}
+
+fn random64() -> i64 {
+    let state: i64;
+    randomState = (state := (
+                          state := randomState ^ (randomState >> 12i64)
+                      ) ^ (state << 25i64)
+                  ) ^ (state >> 27i64);
+    randomState * 2685821657736338717i64
+}
+
+fn randomf() -> f32 {
+    f32.reinterpret_i32(1065353216 | (random() >> 9)) - 1 as f32
+}
+
+fn seed(s: i32) {
+    randomState = (s as i64 << 32i64) ^ ((63 - s) as i64);
+    randomState = random64();
+    randomState = random64();
+}
+
+export fn tic(time: i32) {
+    let i: i32;
+    loop pixels {
+        seed(i + (time / 100) * 320);
+        i?120 = (randomf() * 256 as f32 + time as f32 / 10 as f32) as i32;
+        branch_if (i := i + 1) < 320*256: pixels
+    }
+}

examples/microw8/technotunnel.cwa

@@ -0,0 +1,25 @@
+import "env.memory" memory(4);
+import "env.sin" fn sin(f32) -> f32;
+import "env.atan2" fn atan2(f32, f32) -> f32;
+
+export fn tic(time: i32) {
+    let i: i32;
+    loop screen {
+        let defer t = time as f32 / 2000 as f32;
+        let defer o = sin(t) * 0.8;
+        let defer q = (i % 320) as f32 - 160.1;
+        let defer w = (i / 320 - 128) as f32;
+        let defer r = sqrt(q*q + w*w);
+        let defer z = q / r;
+        let defer s = z * o + sqrt(z * z * o * o + 1 as f32 - o * o);
+        let defer q2 = (z * s - o) * 10 as f32 + t;
+        let defer w2 = w / r * s * 10 as f32 + t;
+        let defer s2 = s * 50 as f32 / r;
+        i?120 = max(
+            0 as f32, 
+            ((q2 as i32 ^ w2 as i32 & ((s2 + t) * 20 as f32) as i32) & 5) as f32 *
+                (2 as f32 - s2) * 22 as f32
+            ) as i32;
+        branch_if (i := i + 1) < 320*256: screen
+    }
+}

examples/microw8/trainride.cwa

@@ -0,0 +1,25 @@
+import "env.memory" memory(2);
+
+export fn tic(time: i32) {
+  let i: i32;
+  let defer t = time as f32 / 1000 as f32;
+  loop pixels {
+    let defer x = (i % 320 - 160) as f32;
+    let defer y = (i / 320) as f32 - 128.5;
+    let defer z = t + 20 as f32 / sqrt(x*x + y*y);
+    let defer z_int = z as i32;
+    let defer q = select(z_int % 9 >= 6, z, (z_int - z_int % 9 + 6) as f32);
+    let defer w = 9 as f32 / y + t;
+    let defer s = q - t;
+    let defer m = x * s / 50 as f32;
+
+    i?120 = select(y > 0 as f32 & w < q,
+              select(abs(x * (w - t)) < 9 as f32, 15, 7) - w as i32 % 2,
+              select(y * s > -99 as f32 / (m * m + 1 as f32),
+                select(q == z, z_int % 2, 3),
+                12 + (y / 23 as f32) as i32
+              )
+            ) * 16;
+    branch_if (i := i + 1) < 320*256: pixels;
+  }
+}

examples/microw8/tunnel.cwa

@@ -0,0 +1,14 @@
+import "env.memory" memory(4);
+import "env.atan2" fn atan2(f32, f32) -> f32;
+
+export fn tic(time: i32) {
+    let i: i32;
+    loop screen {
+        let defer t = time as f32 / 10 as f32;
+        let defer x = (i % 320) as f32 - 160.1;
+        let defer y = (i / 320 - 128) as f32;
+
+        i?120 = ((20000 as f32 / sqrt(x * x + y * y) + t) as i32 ^ (atan2(x, y) * 512 as f32 / 3.141 + t) as i32);
+        branch_if (i := i + 1) < 320*256: screen
+    }
+}

examples/microw8/warptunnel.cwa

@@ -0,0 +1,15 @@
+import "env.memory" memory(2);
+
+export fn tic(time: i32) {
+    let i: i32;
+    loop pixels {
+        let defer x = (i % 320) as f32 - 160.1;
+        let defer y = (i / 320 - 128) as f32;
+        let defer dist = 10000.0 / (x*x + y*y);
+        let defer t = time as f32 / 20 as f32;
+
+        i?120 = (x * dist + t) as i32 ^ (y * dist + t) as i32;
+
+        branch_if (i := i + 1) < 320*256: pixels
+    }
+}

examples/microw8/xorscroll.cwa

@@ -0,0 +1,9 @@
+import "env.memory" memory(2);
+
+export fn tic(time: i32) {
+  let i: i32;
+  loop frame {
+    i?120 = (i % 320 + time / 10) ^ (i / 320);
+    branch_if (i := i + 1) < 320*256: frame;
+  }
+}

examples/wasm4/skipahead.cwa

@@ -0,0 +1,62 @@
+import "env.memory" memory(1);
+
+import "env.rect" fn rect(i32, i32, i32, i32);
+import "env.oval" fn oval(i32, i32, i32, i32);
+
+global mut pz: f32 = 0.0;
+global mut px: f32 = 2.0;
+global mut py: f32 = 0.0;
+global mut s: f32 = 0.0;
+global mut f: f32 = 0.0;
+
+fn xorshift(state: i32) -> i32 {
+    100902443 * (
+                    (state :=
+                        (state := state ^ (state << 13))
+                        ^ (state >> 17))
+                    ^ (state << 5)
+                )
+}
+
+export fn update() {
+    let y: i32;
+    loop lines {
+        let z = (200 as f32 / (y := y + 1) as f32 + pz) as i32;
+        let x = (xorshift(xorshift(xorshift(z))) & 3) as f32 / 2 as f32 - px;
+        let w = 6 as f32 / sqrt(z as f32);
+        let rx = 80 + (y as f32 * x) as i32;
+        let rw = (y as f32 * w) as i32;
+        
+        let defer c = ((z & 1) + 2) * 17;
+        ?20 = c;
+        rect(rx, y, rw, y / 9);
+        ?20 = c + 17;
+        rect(rx, y + 1, rw, y / 9);
+
+        if y == 120 & py > 0.0 {
+            if x+w < 0.0 | x > 0.0 {
+                return;
+            }
+            py = 0.0;
+            s = 0.0;
+            f = 0.8;
+        }
+
+        branch_if y < 160: lines;
+    };
+
+    ?20 = 50;
+    oval(80 - 11, 114 - 11 + py as i32, 22, 22);
+    ?20 = 17;
+    oval(80 - 6, 114 - 6 + py as i32, 6, 6);
+    let defer pad = ?22;
+    let defer control_speed = 0.03;
+    px = px + (((pad >> 5) & 1) - ((pad >> 4) & 1)) as f32 * control_speed;
+    if pad & 1 {
+        s = s - f - control_speed;
+    }
+    s = s + 0.1;
+    py = py + s;
+    pz = pz + 0.05;
+    f = f * 0.7;
+}