People movement and travel distance

/** The grid of one room: free[i] = 1 where the cell's centre is inside the outline and outside the holes. */
function makeGrid(room, cell0) {
  const xs = room.poly.map((p) => p[0]), ys = room.poly.map((p) => p[1]);
  const x0 = Math.min(...xs), y0 = Math.min(...ys), x1 = Math.max(...xs), y1 = Math.max(...ys);
  let cell = cell0;
  while (((x1 - x0) / cell + 1) * ((y1 - y0) / cell + 1) > 60000) cell *= 1.5;   // very big rooms: coarser
  const nx = Math.max(1, Math.ceil((x1 - x0) / cell)), ny = Math.max(1, Math.ceil((y1 - y0) / cell));
  const free = new Uint8Array(nx * ny);
  for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
    const x = x0 + (i + 0.5) * cell, y = y0 + (j + 0.5) * cell;
    if (inRing(room.poly, x, y) && !(room.holes || []).some((h) => inRing(h, x, y))) free[j * nx + i] = 1;
  }
  return { x0, y0, nx, ny, cell, free, fields: new Map() };
}

/** Distance field (mm) from a cell over the free cells: 16 neighbours with true lengths, within about 2.5 % of the straight-line truth. */
function field(g, src) {
  const d = new Float64Array(g.nx * g.ny).fill(Infinity), h = new Heap(), nx = g.nx, ny = g.ny, free = g.free, cell = g.cell;
  d[src] = 0; h.push(0, src);
  while (h.size) {
    const [dd, c] = h.pop();
    if (dd > d[c]) continue;
    const ci = c % nx, cj = (c - ci) / nx;
    for (const [di, dj] of NB) {
      const i = ci + di, j = cj + dj;
      if (i < 0 || j < 0 || i >= nx || j >= ny || !free[j * nx + i]) continue;
      if (Math.abs(di) + Math.abs(dj) === 2 && (!free[cj * nx + i] || !free[j * nx + ci])) continue;   // no cutting a corner
      if (Math.abs(di) === 2 && (!free[cj * nx + ci + di / 2] || !free[j * nx + ci + di / 2])) continue;   // knight move: both middle cells free
      if (Math.abs(dj) === 2 && (!free[(cj + dj / 2) * nx + ci] || !free[(cj + dj / 2) * nx + i])) continue;
      const n = j * nx + i, nd = dd + Math.hypot(di, dj) * cell;
      if (nd < d[n]) { d[n] = nd; h.push(nd, n); }
    }
  }
  return d;
}

/** Distance in metres between two standing places of one room, and the walked route. */
function inRoomRoute(scene, room, p, q, needPath) {
  const g = scene.rooms[room].g;
  if (los(g, p, q)) return { d: Math.hypot(q[0] - p[0], q[1] - p[1]) / 1000, path: needPath ? [p, q] : null };
  const cq = nearFree(g, q[0], q[1]), cp = nearFree(g, p[0], p[1]);
  if (cq < 0 || cp < 0) return { d: Infinity, path: null };
  const f = fieldOf(g, cq), d = f[cp];
  if (!Number.isFinite(d)) return { d: Infinity, path: null };
  if (!needPath) return { d: d / 1000, path: null };
  // walk down the field, then string-pull: from each vertex jump to the farthest one it can see
  const raw = [p];
  let c = cp;
  for (let guard = 0; guard < 100000 && f[c] > 0; guard++) {
    const ci = c % g.nx, cj = (c - ci) / g.nx;
    let best = c, bv = f[c];
    for (const [di, dj] of NB.slice(0, 8)) {
      const i = ci + di, j = cj + dj;
      if (i < 0 || j < 0 || i >= g.nx || j >= g.ny) continue;
      const n = j * g.nx + i;
      if (f[n] < bv) { bv = f[n]; best = n; }
    }
    if (best === c) break;
    c = best; raw.push(centre(g, c));
  }
  raw.push(q);
  const path = [raw[0]];
  let at = 0;
  while (at < raw.length - 1) {
    let far = at + 1;
    for (let k = raw.length - 1; k > at + 1; k--) if (los(g, raw[at], raw[k])) { far = k; break; }
    path.push(raw[far]); at = far;
  }
  let len = 0;
  for (let i = 1; i < path.length; i++) len += Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]);
  return { d: len / 1000, path };
}

/**
 * Cost (m) to a goal from every standing place, counted from standing at the place to the goal: crossing its opening (a stair's length)
 * and everything after. goal { exit: true }: an exit's inside place costs 0 (the door itself takes no length). goal { room }: crossing
 * into that room is the end. Shut openings are not used.
 */
function costToGoal(scene, goal, shut, exitSet) {
  const E = scene.ends, dist = new Float64Array(E.length).fill(Infinity), h = new Heap();
  const seed = (i, d) => { if (d < dist[i]) { dist[i] = d; h.push(d, i); } };
  E.forEach((e, i) => {
    const o = scene.openings[e.o];
    if (shut.has(o.id)) return;
    if (goal.exit) { if (exitSet.has(o.id) && o.end[1 - e.side].room < 0) seed(i, 0); }
    else if (e.room === goal.room && scene.far[i] >= 0) seed(scene.far[i], o.len);   // the place on the other side of j crosses into the room
  });
  while (h.size) {
    const [dd, i] = h.pop();
    if (dd > dist[i]) continue;
    const e = E[i];
    for (const j of scene.inRoom[e.room]) {   // arriving at j (by crossing its opening from its far side), then walking to i
      if (j === i) continue;
      const oj = scene.openings[E[j].o];
      if (shut.has(oj.id)) continue;
      const far = scene.far[j];
      if (far < 0) continue;
      const walk = inRoomRoute(scene, e.room, E[j].p, e.p, false).d;
      if (!Number.isFinite(walk)) continue;
      const nd = dd + walk + oj.len;
      if (nd < dist[far]) { dist[far] = nd; h.push(nd, far); }
    }
  }
  return dist;
}

/** The farthest point of every room from an exit, walked (m), with the opening that way leads through. */
export function travelDistances(scene, o = {}) {
  const shut = shutSet(o), dist = costToGoal(scene, { exit: true }, shut, exitsOf(scene, o));
  return scene.rooms.map((r) => {
    const ends = scene.inRoom[r.index].filter((i) => Number.isFinite(dist[i]) && !shut.has(scene.openings[scene.ends[i].o].id));
    const res = { room: r.index, id: r.id, name: r.name || '', maxM: null, at: null, via: null, reachable: false };
    if (!ends.length) return res;
    const fields = ends.map((i) => fieldOf(r.g, scene.ends[i].cellId));
    const g = r.g;
    let worst = -1;
    const consider = (v, at) => { if (v > worst) { worst = v; res.at = at.map(Math.round); } };
    // from a place to the nearest way out: straight when it can see the opening, else along the room's distance field
    const toExit = (c, pt, extra) => {
      let best = Infinity, via = -1;
      for (let k = 0; k < ends.length; k++) {
        const e = scene.ends[ends[k]], straight = los(g, pt, e.p) ? Math.hypot(pt[0] - e.p[0], pt[1] - e.p[1]) : fields[k][c];
        const v = straight / 1000 + dist[ends[k]];
        if (v < best) { best = v; via = k; }
      }
      return [best + extra / 1000, via];
    };
    let viaAt = null;
    for (let c = 0; c < g.free.length; c++) {
      if (!g.free[c]) continue;
      const pt = centre(g, c), [v, via] = toExit(c, pt, 0);
      if (v > worst) { consider(v, pt); viaAt = via; }
    }
    // the corners themselves (the cell centres stop half a cell short of the wall): a corner is its nearest cell plus the step to it
    for (const ring of [r.poly, ...(r.holes || [])]) for (const vx of ring) {
      const c = nearFree(g, vx[0], vx[1]);
      if (c < 0) continue;
      const pt = centre(g, c), [v, via] = toExit(c, pt, Math.hypot(vx[0] - pt[0], vx[1] - pt[1]));
      if (v > worst) { consider(v, vx); viaAt = via; }
    }
    if (worst >= 0) res.via = scene.openings[scene.ends[ends[viaAt]].o].id;
    if (worst >= 0) { res.maxM = Math.round(worst * 100) / 100; res.reachable = true; }
    return res;
  });
}

const dens = (count, area, minF) => { const D = count / Math.max(area, 0.5); return D <= D_FREE ? 1 : Math.max(minF, (1 - A * D) / (1 - A * D_FREE)); };

const rate = OP.map((x) => (x.kind === 'stair' ? o.flow.stair : o.flow.door) * Math.max(0.2, x.w / 1000 - 2 * o.boundary));
const ostat = OP.map((x) => ({ id: x.id, kind: x.kind, passed: 0, switches: 0, lastDir: null, lastPassT: -Infinity, peakQueue: 0, totalWait: 0, maxWait: 0, first: null, last: null, capacity: 0 }));
ostat.forEach((s, i) => { s.capacity = Math.round(rate[i] * 100) / 100; });

const f = dens(inRoomCount[a.room], Rm[a.room].area_m2, o.minDensityFactor), ds = a.v0 * f * o.dt;
a.s += ds; a.travel += Math.min(ds, Math.max(0, a.leg.len - (a.s - ds)));

const a = q.shift(), base = Math.max(nextFree[oi], a.qT, t);
// counter-flow (0.8 EG.48): a pass in the other direction from the last one, close behind it, costs the opening part of its rate
const dir = a.cross.from >= 0 ? E[a.cross.from].side : 1 - E[a.cross.to].side, sw = S.lastDir !== null && S.lastDir !== dir && base - S.lastPassT <= o.counterWindow;
const passT = base + (sw ? 1 / (rate[oi] * o.counterFlow) - 1 / rate[oi] : 0);
if (sw) S.switches++;
S.lastDir = dir; S.lastPassT = passT;
nextFree[oi] = passT + 1 / rate[oi];
const wait = passT - a.qT;

const pct = (p) => (times.length ? Math.round(times[Math.max(0, Math.ceil(times.length * p) - 1)] * 10) / 10 : null);
const roomRes = Rm.map((r, ri) => {
  const mine = P.filter((a) => exchange ? a.home === ri && a.destRoom === null : (a.home === ri && !arrive || arrive && a.destRoom === ri));
  const left = mine.filter((a) => a.exitT !== null);
  return { id: r.id, name: r.name || '', people: mine.length, stuck: mine.filter((a) => a.st === ST.stuck).length,
    clearT: left.length === mine.length && mine.length ? Math.round(Math.max(...left.map((a) => a.exitT)) * 10) / 10 : null,
    maxWalked: mine.length ? Math.round(Math.max(...mine.map((a) => a.travel)) * 100) / 100 : 0 };
});
const bottleneck = ostat.filter((s) => s.totalWait > 0).sort((x, y) => y.totalWait - x.totalWait)[0] || null;
const results = {
  scenario: o.scenario, people: N, finished: done.length, stuck: stuck.length, unfinished: still.length,
  totalTime: times.length ? Math.round(times[times.length - 1] * 10) / 10 : null, t50: pct(0.5), t90: pct(0.9),
  meanWalked: N ? Math.round(P.reduce((s, a) => s + a.travel, 0) / N * 100) / 100 : 0, maxWalked: N ? Math.round(Math.max(...P.map((a) => a.travel)) * 100) / 100 : 0,
  meanWait: N ? Math.round(P.reduce((s, a) => s + a.waited, 0) / N * 10) / 10 : 0,

let plan = 0;
for (let i = 1; i < lay.walk.length; i++) plan += Math.hypot(lay.walk[i][0] - lay.walk[i - 1][0], lay.walk[i][1] - lay.walk[i - 1][1]);
stairs.push({ id: st.guid, a: { room: ra.id, x: a[0], y: a[1] }, b: { room: rb.id, x: b[0], y: b[1] }, length: Math.hypot(plan, height), w: st.width, landings: (lay.pieces || []).filter((pc) => pc.kind === 'landing').length });

/**
 * 0.8 EG.48 (bim-sim_PART_3): the people each room holds before a run, so the person can set a count per room.
 *   roomCounts(ed, { m2PerPerson, loads }) → [{ id, name, level, levelName, area_m2, occupied, auto, count }]     auto = the count the factor gives (0 for a corridor, stair, lobby …);
 *   count = the person's number when `loads` has the room, else auto. The same `loads` map goes to simulate().
 */
export function roomCounts(ed, { m2PerPerson = 10, loads = {} } = {}) {
  const { rooms } = namedRooms(ed);
  return rooms.map((r) => { const auto = r.occupied ? Math.floor(r.area_m2 / m2PerPerson) : 0, own = loads[r.id]; return { id: r.id, name: r.name, level: r.level, levelName: r.levelName, area_m2: Math.round(r.area_m2 * 10) / 10, occupied: r.occupied, auto, count: own !== undefined && own !== '' && own !== null ? Math.max(0, Math.floor(Number(own)) || 0) : auto }; });
}