// The vacuum, blowing grains out, grains in flight (flyers), and the flame tool.
// Material the vacuum would start on at the cursor: a bar, else the nearest loose grain.
function vacuumTargetAt(cx, cy, r) {
  for (const e of entsInCircle(cx, cy, Math.max(1, r))) return e.m;
  let best = 0, bd = 1e9;
  forBrush(cx, cy, Math.max(1, r), (x, y, i) => {
    const m = mat[i], ph = PH[m];
    if (ph === PH_POWDER || (ph === PH_LIQUID && player.flask)) { const d = (x - cx) * (x - cx) + (y - cy) * (y - cy); if (d < bd) { bd = d; best = m; } }
  });
  return best;
}
// Vacuum: picks up loose grains, liquids (with the Flask) and bars for which pick(m) is true.
function toolVacuum(cx, cy, r, pick) {
  let got = 0, full = false, budget = 48;
  for (const e of entsInCircle(cx, cy, r)) {
    if (!pick(e.m) || !inReach(e.ix + 2, e.iy + 1)) continue;
    if (bagTotal >= bagCap()) { full = true; break; }
    bagAdd(e.m, 1); removeEnt(e); got++;
    emit({ t: 'suck', x: e.ix + 2, y: e.iy + 1, m: e.m });
  }
  if (!full) forBrush(cx, cy, r, (x, y, i) => {
    const m = mat[i], ph = PH[m];
    if (!(ph === PH_POWDER || (ph === PH_LIQUID && player.flask))) return;
    if (!pick(m)) return;
    if (part[i] >= P_TU && part[i] <= P_TR) return;
    if (bagTotal >= bagCap()) { full = true; return false; }
    bagAdd(m, 1); setCell(i, EMPTY, AMB[y], 0); got++;
    if (got & 1) emit({ t: 'suck', x, y, m });
    if (--budget <= 0) return false;
  });
  return { got, full, status: full ? 'Bag full; blow material out or cast a bigger tank.' : '' };
}
// Blow: grains leave the bot's nozzle and fly to the cursor, where they drop.
// Liquids need the Flask. Bars are thrown, one at a time.
function nozzle(tx, ty) {
  const cx = bot.x + bot.w / 2, cy = bot.y + bot.h / 2;
  let dx = tx - cx, dy = ty - cy; const d = Math.hypot(dx, dy) || 1;
  const reach = Math.min(d, REACH - 1);
  dx /= d; dy /= d;
  return { ox: cx + dx * 3, oy: cy + dy * 3, dx, dy, dist: Math.max(1, reach - 3) };
}
// mix: optional list of materials blown out in turn, one grain each (an even mix).
let blowRR = 0;
function toolBlow(cx, cy, r, m, mix) {
  let pickM = null;
  if (mix && mix.length) {
    const avail = mix.filter(k => bag[k] > 0 && PH[k] !== PH_ITEM && (PH[k] !== PH_LIQUID || player.flask));
    if (!avail.length) return { placed: 0, status: 'Tick materials in your bag to mix.' };
    pickM = () => { for (let k = 0; k < avail.length; k++) { const c = avail[(blowRR++) % avail.length]; if (bag[c] > 0) return c; } return 0; };
    m = avail[0];
  }
  if (!m) return { placed: 0, status: 'Pick what to blow out: Q/E, or click it in your bag.' };
  if (bag[m] <= 0) return { placed: 0, status: `No ${MD[m].name.toLowerCase()} left.` };
  const ph = PH[m];
  if (ph === PH_LIQUID && !player.flask) return { placed: 0, status: 'You need the Flask to carry liquids.' };
  const nz = nozzle(cx + 0.5, cy + 0.5);
  if (ph === PH_ITEM) {
    if (tick % 10 !== 0) return { placed: 0, status: '' };
    // a short lob: aim so the bar lands near the cursor
    const T = Math.max(10, Math.min(34, nz.dist / 2.2));
    const tx = nz.ox + nz.dx * nz.dist, ty = nz.oy + nz.dy * nz.dist;
    let e = null;
    for (let k = 0; k < 6 && !e; k++) { const sx = nz.ox + nz.dx * k * 2 - 2, sy = nz.oy + nz.dy * k * 2 - 1; if (entFreeAt(Math.round(sx), Math.round(sy))) e = spawnBar(m, sx, sy, (tx - sx - 2) / T, (ty - sy - 1) / T - 0.5 * 0.07 * T); }
    if (!e) return { placed: 0, status: 'No room to throw a bar from here.' };
    bagTake(m, 1); return { placed: 1, status: '' };
  }
  if (flyers.length > 3000) return { placed: 0, status: '' };
  // nozzle 0 is a trickle for careful work, the widest a torrent
  const rate = 1 + r + ((r * r) >> 1);
  const n = pickM ? rate : Math.min(bag[m], rate);
  let placed = 0;
  for (let k = 0; k < n; k++) {
    const gm = pickM ? pickM() : m;
    if (!gm) break;
    // aim each grain at a spot in the brush around the cursor, on an arc that passes
    // through it; past that point gravity carries it on until it hits something
    const a = rnd() * Math.PI * 2, rr = Math.sqrt(rnd()) * (r + 0.5);
    const tx = cx + 0.5 + Math.cos(a) * rr, ty = cy + 0.5 + Math.sin(a) * rr;
    const ox = nz.ox + (rnd() - 0.5), oy = nz.oy + (rnd() - 0.5);
    const dx = tx - ox, dy = ty - oy, d = Math.hypot(dx, dy) || 1;
    // air drag (FLY_Q) and gravity (FLY_G) act every tick; pick the launch speed that
    // reaches the target after T ticks
    const T = Math.max(3, Math.min(60, Math.round(d / (2.0 + rnd() * 0.4)))), S = (1 - FLY_Q ** T) / (1 - FLY_Q), G = FLY_G * (T - S) / (1 - FLY_Q);
    flyers.push({ x: ox, y: oy, vx: dx / S, vy: (dy - G) / S, age: 0, m: gm, T: bagTemp(gm), free: false, run: 0, bag: true });
    bagTake(gm, 1); placed++;
  }
  return { placed, status: '' };
}
const FLY_G = 0.06, FLY_Q = 0.93;
// Can a flying grain of m be in cell j?
function flyOpen(m, j) {
  if (occ[j] || mach[j] && mat[j] === HULL) return false;
  const p = part[j];
  if (p === P_GRATE && PH[m] === PH_POWDER) return false;
  if (p === P_INTAKE) return false;
  if (p === P_FILTER && PH[m] === PH_POWDER && !filterPassAt(m, j)) return false;
  const t = mat[j];
  return t === EMPTY || PH[t] === PH_GAS;
}
// Put a grain into the nearest open cell around (x, y), at or above where it stopped. It never
// jumps down: below could be the far side of a floor, a grate or a filter (into a mold, say).
function depositNear(m, T, x, y, skip) {
  x = Math.max(0, Math.min(W - 1, x)); y = Math.max(0, Math.min(H - 1, y));
  for (let r = 0; r <= 24; r++) {
    for (let dy = -r; dy <= 0; dy++) for (let dx = -r; dx <= r; dx++) {
      if (Math.max(Math.abs(dx), Math.abs(dy)) !== r) continue;
      const xx = x + dx, yy = y + dy;
      if (xx < 0 || yy < 0 || xx >= W || yy >= H) continue;
      const j = yy * W + xx;
      if (j !== skip && flyOpen(m, j)) { setCell(j, m, T, 0); return true; }
    }
  }
  return false;
}
// What comes out of the bag is at room temperature, except what would melt at it: snow stays frozen,
// and molten things come out hot enough to pour.
function bagTemp(m) { return PH[m] === PH_LIQUID ? Math.max(LIQT[m], 20) : MELT[m] !== 0 && MELT[m] < 20 ? MELT[m] - 6 : 20; }
function landFlyer(f, x, y) {
  // settle into the nearest open cell at or above where it stopped
  for (let k = 0; k < 8; k++) {
    const yy = y - k; if (yy < 0) break;
    const j = yy * W + x;
    if (flyOpen(f.m, j)) { setCell(j, f.m, f.T, 0); return; }
  }
  if (!depositNear(f.m, f.T, x, y)) { if (f.rain) absorbSteam(x); else bagAdd(f.m, 1, true); } // nowhere to go: back into the bag (rain: back into the clouds)
}
function flyTick() {
  for (let k = flyers.length - 1; k >= 0; k--) {
    const f = flyers[k];
    const steps = Math.max(1, Math.ceil(Math.max(Math.abs(f.vx), Math.abs(f.vy))));
    const sx = f.vx / steps, sy = f.vy / steps;
    let px = Math.floor(f.x), py = Math.floor(f.y), done = false;
    for (let s = 0; s < steps; s++) {
      const nx = f.x + sx, ny = f.y + sy, cx = Math.floor(nx), cy = Math.floor(ny);
      if (cx < 0 || cx >= W) { f.vx = 0; continue; } // the world's edge stops it; it drops from there
      if (cy >= H) { landFlyer(f, px, H - 1); done = true; break; }
      if (cy < 0) { f.x = nx; f.y = ny; continue; }
      const open = flyOpen(f.m, cy * W + cx);
      if (!f.free) {
        // still inside whatever the bot is flying through: pass until the first open cell
        // a blocked nozzle spills: the grain backs up into the nearest open space
        if (open) f.free = true; else if (++f.run > 14) { if (!depositNear(f.m, f.T, cx, cy)) bagAdd(f.m, 1, true); done = true; break; }
      } else if (!open) { landFlyer(f, px, py); done = true; break; }
      f.x = nx; f.y = ny; px = cx; py = cy;
    }
    if (done) { flyers[k] = flyers[flyers.length - 1]; flyers.pop(); continue; }
    f.vx *= FLY_Q; f.vy = f.vy * FLY_Q + FLY_G;
    if (++f.age > 900) { landFlyer(f, Math.max(0, Math.min(W - 1, px)), Math.max(0, py)); flyers[k] = flyers[flyers.length - 1]; flyers.pop(); }
  }
}
// The flame heats what it touches, and licks a few grains into a loose pile, so fuel
// buried just under ore still catches if air reaches it (through a grate, say).
// Returns { any: anything got hotter, fuel: there is fuel within the flame's reach }.
function toolIgnite(cx, cy) {
  let any = false, fuel = false;
  forBrush(cx, cy, 4, (x, y, i) => {
    const dx = x - cx, dy = y - cy, near = dx * dx + dy * dy <= 2.5;
    if (IGN[mat[i]]) fuel = true;
    if (!near && !(IGN[mat[i]] && dy >= 0)) return;
    const top = near ? 640 : 520;
    if (temp[i] < top) { temp[i] = Math.min(top, temp[i] + (near ? 26 : 12)); any = true; }
    wakeHeatXY(x, y);
  });
  return { any, fuel };
}