KINDLE

HOW TO PLAY

A cold field of drifting light. You carry the only fire — move your cursor and it kindles the cloud around you; your warmth lingers a moment where you have passed. Everyone here carries a flame, and it is warmer where you gather. No goal. Just be here, and bring a little heat into the cold.

visual · sparks

fn visual_sparks(uv: vec2f, sdf: f32, color: vec4f, time: f32, params: vec4f, behind: vec4f) -> vec4f {
  var col = vec3f(0.0);
  let n = popCount();
  for (var i = 0; i < n; i++) {
    let e = pop(i);
    let pos = vec2f(e.x, e.y);
    let hue = e.z;
    let age = e.w;            // 0..1 lifetime
    let d = uv - pos;
    let dist = length(d);
    // bounds-reject before any heavier math
    if (dist > 0.5) { continue; }
    let fade = smoothstep(1.0, 0.0, age);
    let base = hsv2rgb(vec3f(hue, 0.65, 1.0));
    // bright core
    col += base * exp(-dist*dist*900.0) * fade * 1.6;
    // soft bloom halo
    col += base * exp(-dist*dist*90.0) * fade * 0.5;
    // as it ages it blooms into a little flower of petals
    let bloom = smoothstep(0.35, 0.9, age);
    if (bloom > 0.001) {
      let ang = atan2(d.y, d.x);
      let petals = 0.5 + 0.5 * cos(ang * 6.0 - hue * 20.0);
      let ring = exp(-pow((dist - 0.05 - age*0.06)*22.0, 2.0));
      col += base * ring * petals * bloom * fade * 1.2;
    }
    // a faint drifting trail beneath the spark
    let tr = exp(-dist*dist*160.0) * exp(-max(0.0, d.y)*10.0);
    col += base * tr * fade * 0.3;
  }
  col = col / (1.0 + col*0.2);
  let a = clamp(max(col.r, max(col.g, col.b)) * 1.3, 0.0, 1.0);
  return vec4f(col, a);
}

visual · dream

fn visual_dream(uv: vec2f, sdf: f32, color: vec4f, time: f32, params: vec4f, behind: vec4f) -> vec4f {
  let t = time * 0.12;
  let cur = vec2f(uni(0), uni(1));
  let energy = uni(2);
  var p = uv * 1.35;
  let toC = cur - uv;
  let pull = toC * (0.35 / (0.15 + dot(toC, toC)));
  p += pull * (0.18 + 0.12 * energy);
  let q = vec2f(fbm(p + vec2f(0.0, t), 5), fbm(p + vec2f(4.3, -t*0.7), 5));
  let r = vec2f(fbm(p + 2.4*q + vec2f(1.7, 9.2), 4), fbm(p + 2.4*q + vec2f(8.3, 2.8) - t*0.5, 4));
  let nz = fbm(p + 2.6*r, 5);
  var col = palette(nz + t*0.5 + length(uv)*0.25,
                    vec3f(0.10, 0.09, 0.18),
                    vec3f(0.45, 0.40, 0.55),
                    vec3f(1.0, 1.05, 0.85),
                    vec3f(0.15, 0.45, 0.75));
  let vig = smoothstep(1.7, 0.2, length(uv));
  col *= 0.35 + 0.75 * vig;
  let ribbon = smoothstep(0.55, 0.75, r.x) * smoothstep(0.75, 0.55, r.y);
  col += vec3f(0.4, 0.7, 1.0) * ribbon * (0.35 + 0.4*energy);
  let dc = length(uv - cur);
  col += vec3f(0.9, 0.6, 1.0) * exp(-dc*dc*3.5) * (0.15 + 0.5*energy);
  let sp = uv * 8.0;
  let sc = floor(sp);
  let sh = hash21(sc);
  if (sh > 0.86) {
    let star = fract(sp) - 0.5;
    let tw = 0.5 + 0.5 * sin(time*2.0 + sh*40.0);
    col += vec3f(0.8, 0.85, 1.0) * exp(-dot(star,star)*90.0) * tw * (1.0-vig)*0.9;
  }
  col = col / (1.0 + col*0.25);
  return vec4f(clamp(col, vec3f(0.0), vec3f(2.0)), 1.0);
}

visual · kindle

fn art_hash(p: vec2f) -> f32 { return fract(sin(dot(p, vec2f(127.1, 311.7))) * 43758.5453); }
fn art_noise(p: vec2f) -> f32 {
  let i = floor(p); let f = fract(p); let u = f*f*(3.0-2.0*f);
  return mix(mix(art_hash(i), art_hash(i+vec2f(1.,0.)), u.x),
             mix(art_hash(i+vec2f(0.,1.)), art_hash(i+vec2f(1.,1.)), u.x), u.y);
}
fn art_fbm(p: vec2f) -> f32 { var v=0.0; var a=0.5; var q=p; for (var i=0;i<6;i=i+1){ v=v+a*art_noise(q); q=q*2.03; a=a*0.5; } return v; }
fn visual_kindle(uv: vec2f, sdf: f32, color: vec4f, time: f32, params: vec4f, behind: vec4f) -> vec4f {
  let t = time * 0.15;
  let p = uv * 1.7;
  let w = vec2f(art_fbm(p + vec2f(0.0, t)), art_fbm(p + vec2f(5.2, -t)));
  let f = art_fbm(p * 1.4 + w * 2.2 + vec2f(t*0.3, -t*0.2));
  // EVERY fire in the world — you, your fading trail, and everyone else — fed by the hook
  var kindle = 0.0;
  let F = min(i32(uni(2)), 24);
  for (var i = 0; i < F; i = i + 1) {
    let fp = vec2f(uni(3 + i*3), uni(4 + i*3));
    let intensity = uni(5 + i*3);
    let dc = uv - fp;
    kindle = kindle + exp(-dot(dc, dc) * 4.4) * intensity;
  }
  kindle = min(kindle, 1.1);
  let ribbon = pow(smoothstep(0.28, 0.90, f), 1.8);
  var col = vec3f(0.02, 0.03, 0.07);                 // deep field, always cold
  col += vec3f(0.06, 0.16, 0.34) * ribbon;           // dim teal drift
  col += vec3f(0.20, 0.10, 0.32) * pow(ribbon, 2.5) * 0.7;  // violet folds
  // flame licks the CLOUD you're standing in — an effect, not a radial. Fine animated
  // detail decides WHERE the cold catches fire; your kindle only says how near it can.
  let flick = art_fbm(p * 3.1 + vec2f(t * 2.6, -t * 3.4));
  let caught = smoothstep(0.40, 0.74, f * 0.6 + flick * 0.55);   // the cloud igniting
  let fire = kindle * (caught + 0.10);               // a faint floor so your presence still glimmers
  col += vec3f(1.0, 0.48, 0.15) * pow(fire, 1.4) * 2.1;   // textured embers
  col += vec3f(1.0, 0.86, 0.60) * pow(fire, 3.4) * 2.0;   // white-hot tongues where warmth gathers
  col *= 1.0 - 0.26 * dot(uv, uv);
  return vec4f(col, 1.0);
}

hook · kindle_fire

const wd = sim.worldData;
const nx = (v) => (v - 256) / 256;
const mx = (wd.mouse_x == null ? 256 : wd.mouse_x), my = (wd.mouse_y == null ? 256 : wd.mouse_y);
const cx = nx(mx), cy = nx(my);
const fires = [[cx, cy, 1.0]];               // YOU
// fading trail — __trail so the sandbox writes it back (single _ keys are dropped)
const trail = Array.isArray(wd.__trail) ? wd.__trail : [];
trail.push([cx, cy]);
while (trail.length > 9) trail.shift();
wd.__trail = trail;
for (let i = 0; i < trail.length - 1; i++) { const age = (i + 1) / trail.length; fires.push([trail[i][0], trail[i][1], 0.4 * age]); }
// other players, when the host exposes them to hooks
const others = Array.isArray(wd.players) ? wd.players : [];
for (const o of others) { if (o && o.x != null && o.y != null) fires.push([nx(o.x), nx(o.y), 1.0]); }
const capped = fires.slice(0, 24);
const u = [cx, cy, capped.length];
for (const fr of capped) u.push(fr[0], fr[1], fr[2]);
wd.gpuUniforms = u;