@songsid/agend 2.3.2-beta.9 → 2.3.3-beta.1

package/dist/ui/fleet-office-zones.js

@@ -42,33 +42,62 @@ export function overflowSpots(area, need = 0) {
  * slot }). Someone still in the same area keeps their slot; the others take the first free seat, in the area's order,
  * then an overflow spot (slot -1, -2, …). No two share one. Whoever finds neither is counted in `crowd` (area → n).
  * Returns { seats: Map name → { area, slot, x, y }, crowd: Map }.
+ *
+ * #2691: a seat may be reserved (its `for`). Whoever it is for, wanting its area, takes a free seat reserved for them
+ * before anything else (the one they sat on last time, else their first in the area's order) — owners are seated
+ * before anyone keeps a slot, so a borrower on an owner's seat moves off when the owner comes. Everyone else keeps
+ * their slot or takes the first free seat not reserved for someone else: a plain one, else a reserved one that says
+ * `lend` (one no owner of it took). A reserved seat not lent, none of whose owners wants the area, is unavailable:
+ * the area's overflow spots and `over` count without it. Seats without `for` work as before.
  */
 export function assignSeats(pack, wants, prev = new Map()) {
-  const seats = new Map(), crowd = new Map(), taken = new Map(), spill = new Map(), demand = new Map();
+  const seats = new Map(), crowd = new Map(), taken = new Map(), spill = new Map(), demand = new Map(), wanting = new Map();
   const areaOf = (a) => own(pack.areas, a);
-  for (const w of wants) demand.set(w.area, (demand.get(w.area) || 0) + 1);
+  for (const w of wants) {
+    demand.set(w.area, (demand.get(w.area) || 0) + 1);
+    if (!wanting.has(w.area)) wanting.set(w.area, new Set());
+    wanting.get(w.area).add(w.name);
+  }
+  const mine = (s, name) => !!s.for && s.for.includes(name);
+  const lent = (s) => !!s.for && s.lend === true;
+  // The seats someone wanting the area may end up on: plain, lent, or reserved for someone who wants it.
+  const usable = (area) => areaOf(area).seats.filter((s) => !s.for || s.lend === true || s.for.some((n) => wanting.get(area).has(n))).length;
   const spotsOf = (area) => {
-    if (!spill.has(area)) spill.set(area, overflowSpots(areaOf(area), Math.max(0, (demand.get(area) || 0) - areaOf(area).seats.length)));
+    if (!spill.has(area)) spill.set(area, overflowSpots(areaOf(area), Math.max(0, (demand.get(area) || 0) - usable(area))));
     return spill.get(area);
   };
   const pos = (area, slot) => (slot >= 0 ? areaOf(area).seats[slot] : spotsOf(area)[-slot - 1]);
   const usedIn = (area) => { if (!taken.has(area)) taken.set(area, new Set()); return taken.get(area); };
   const give = (name, area, slot) => { const p = pos(area, slot); usedIn(area).add(slot); seats.set(name, { area, slot, x: p.x, y: p.y }); };
+  const free = (w) => !seats.has(w.name) && !!areaOf(w.area);
+  // Owners first: their own seat from last time, then their first free one.
+  for (const w of wants) {
+    const p = prev.get(w.name), s = p && p.area === w.area && p.slot >= 0 && areaOf(w.area) ? areaOf(w.area).seats[p.slot] : null;
+    if (s && mine(s, w.name) && !usedIn(w.area).has(p.slot)) give(w.name, w.area, p.slot);
+  }
+  for (const w of wants) {
+    if (!free(w)) continue;
+    const used = usedIn(w.area), slot = areaOf(w.area).seats.findIndex((s, i) => mine(s, w.name) && !used.has(i));
+    if (slot >= 0) give(w.name, w.area, slot);
+  }
   for (const w of wants) {
     const p = prev.get(w.name);
-    if (!p || p.area !== w.area || !areaOf(w.area) || !pos(w.area, p.slot) || usedIn(w.area).has(p.slot)) continue;
+    if (!free(w) || !p || p.area !== w.area || !pos(w.area, p.slot) || usedIn(w.area).has(p.slot)) continue;
+    const s = p.slot >= 0 ? areaOf(w.area).seats[p.slot] : null;
+    if (s && s.for && !lent(s)) continue;                       // reserved for someone else (theirs would be taken above)
     give(w.name, w.area, p.slot);
   }
   for (const w of wants) {
-    if (seats.has(w.name) || !areaOf(w.area)) continue;
+    if (!free(w)) continue;
     const used = usedIn(w.area), area = areaOf(w.area);
-    let slot = area.seats.findIndex((_, i) => !used.has(i));
+    let slot = area.seats.findIndex((s, i) => !s.for && !used.has(i));
+    if (slot < 0) slot = area.seats.findIndex((s, i) => lent(s) && !used.has(i));
     if (slot < 0) { const j = spotsOf(w.area).findIndex((_, i) => !used.has(-i - 1)); slot = j < 0 ? null : -j - 1; }
     if (slot === null) crowd.set(w.area, (crowd.get(w.area) || 0) + 1);
     else give(w.name, w.area, slot);
   }
-  // Over capacity: more people want the area than it has seats (their bubbles and tags are thinned, fleet-office.js).
-  const over = new Set([...demand].filter(([a, n]) => areaOf(a) && n > areaOf(a).seats.length).map(([a]) => a));
+  // Over capacity: more people want the area than it has seats for them (their bubbles and tags are thinned, fleet-office.js).
+  const over = new Set([...demand].filter(([a, n]) => areaOf(a) && n > usable(a)).map(([a]) => a));
   return { seats, crowd, over };
 }
 
@@ -79,17 +108,39 @@ export function assignSeats(pack, wants, prev = new Map()) {
  */
 export function zonesLayout(pack, nodes, prev = new Map(), { night = false } = {}) {
   // At night (#2568) the idle go to bed: the area asleep people go to while it has a free seat; the rest doze where they are.
-  const bed = zoneOf(pack, "paused"), beds = (own(pack.areas, bed)?.seats || []).length, sleepers = new Set(), inBed = new Set();
-  let used = nodes.filter((n) => n.state !== "idle" && zoneOf(pack, n.state) === bed).length;
-  if (night) for (const n of nodes) if (n.state === "idle") { sleepers.add(n.name); if (used < beds) { used++; inBed.add(n.name); } }
-  const wants = nodes.filter((n) => n.state !== "missing").map((n) => ({ name: n.name, area: inBed.has(n.name) ? bed : zoneOf(pack, n.state) }));
-  const { seats, crowd, over } = assignSeats(pack, wants, prev);
+  const bed = zoneOf(pack, "paused"), bedSeats = own(pack.areas, bed)?.seats || [], sleepers = new Set(), inBed = new Set();
+  const wantsOf = (beds) => nodes.filter((n) => n.state !== "missing").map((n) => ({ name: n.name, area: beds.has(n.name) ? bed : zoneOf(pack, n.state) }));
+  let placed = assignSeats(pack, wantsOf(inBed), prev);
+  if (night) {
+    // #2691 review: who goes to bed is decided by the seat assignment itself (assignSeats' reservation rules), one
+    // sleeper at a time — whoever has a bed of their own there first, then the rest in the fleet's order. A sleeper
+    // goes to bed only if it gives them a bed (never an overflow spot) without taking one from anyone already in one
+    // (the awake first, then the sleepers admitted before), unless it is a bed reserved for them: an owner comes first,
+    // as by day. Everyone else dozes where they are.
+    const inABed = (r) => new Set([...r.seats].filter(([, s]) => s.area === bed && s.slot >= 0).map(([name]) => name));
+    const idle = nodes.filter((n) => n.state === "idle");
+    const hasBed = (n) => bedSeats.some((s) => s.for && s.for.includes(n.name));
+    for (const n of idle) sleepers.add(n.name);
+    for (const n of [...idle.filter(hasBed), ...idle.filter((n) => !hasBed(n))]) {
+      const trial = assignSeats(pack, wantsOf(new Set([...inBed, n.name])), prev), s = trial.seats.get(n.name);
+      if (!s || s.area !== bed || s.slot < 0) {
+        if (!hasBed(n)) break;                                  // no bed free for anyone without one: none for the rest either
+        continue;
+      }
+      const before = inABed(placed), after = inABed(trial);
+      const theirs = !!bedSeats[s.slot].for && bedSeats[s.slot].for.includes(n.name);
+      if (!theirs && [...before].some((m) => !after.has(m))) continue;
+      inBed.add(n.name);
+      placed = trial;
+    }
+  }
+  const { seats, crowd, over } = placed;
   const desks = nodes.filter((n) => seats.has(n.name)).map((n) => {
     const s = seats.get(n.name);
     return { key: `zone/${n.name}`, node: n, x: s.x - 24, y: s.y - 52, w: 48, h: 66, seat: { x: s.x, y: s.y }, wp: null, area: s.area, slot: s.slot, night: sleepers.has(n.name) };
   });
   return { mode: "zones", rooms: [{ key: "\u0000zones", name: null, lobby: false, x: 0, y: 0, w: LOGICAL.w, h: LOGICAL.h, desks }], areas: pack.areas,
-    waypoints: pack.waypoints || [], edges: pack.edges || [], straight: pack.straight === true, door: pack.door, width: LOGICAL.w, height: LOGICAL.h, seats, crowd, over };
+    waypoints: pack.waypoints || [], edges: pack.edges || [], straight: pack.straight === true, door: pack.door, mailDrop: pack.mailDrop || null, width: LOGICAL.w, height: LOGICAL.h, seats, crowd, over };
 }
 
 // ── Walking ──
@@ -176,7 +227,9 @@ export function walkTargets(desks, graph, t, wander = true, furniture = [], nigh
  */
 export const MAIL = { MAX_WAIT: 60000, GAP: 16, SEARCH: 320, ASLEEP: new Set(["paused", "stopped"]), MAX: 20 };
 /**
- * Where the `n`th waiting letter lands: `n` GAPs along from the waypoint nearest the room's middle — the nearest whose
+ * Where the `n`th waiting letter lands. #2736: the layout's `mailDrop` when it has one — the `n`th of the slots GAP
+ * apart rightwards from it that no seat is on (never beyond the room's right edge); fewer than that, today's rule. Otherwise `n`
+ * GAPs along from the waypoint nearest the room's middle — the nearest whose
  * spot (offset included) no seat of the office is on, taken or free (someone may sit there any moment; #2561 likewise);
  * with none, the nearest point round the middle (rings GAP·2 apart, inside the room) that no seat is on; with none of
  * those either, null — the letter is not delivered here (never on a seat).
@@ -185,6 +238,12 @@ export function dropPoint(L, n = 0) {
   const mid = { x: L.width / 2, y: L.height * 0.55 }, d = (p, q) => Math.hypot(p.x - q.x, p.y - q.y);
   const seats = [...Object.values(L.areas || {}).flatMap((a) => a.seats || []), ...desksIn(L).map((q) => q.seat)];
   const onSeat = (p) => seats.some((q) => d(p, q) < 4);
+  // #2751 review: the nth off-seat slot (slots GAP apart from the mailDrop), so two letters never share one.
+  const md = L.mailDrop;
+  if (md) for (let i = 0, free = 0; md.x + i * MAIL.GAP <= L.width; i++) {
+    const p = { x: Math.round(md.x + i * MAIL.GAP), y: Math.round(md.y) };
+    if (!onSeat(p) && free++ === n) return p;
+  }
   const spots = (L.waypoints || []).map((w) => ({ x: Math.round(w.x + n * MAIL.GAP), y: Math.round(w.y), from: w }))
     .filter((p) => !onSeat(p.from) && !onSeat(p)).sort((p, q) => d(p.from, mid) - d(q.from, mid));
   if (spots.length) return { x: spots[0].x, y: spots[0].y };
@@ -386,14 +445,38 @@ export function linesFor(state, lang, pack, defaults) {
 
 // ── Furniture ──
 
-/** The furniture active now: an item whose `activeWhen` names a state someone shown is in. */
-export function activeFurniture(pack, states, byName = new Map()) {
+/**
+ * The people an item with `activeFor` is active for now (#2570): those of them shown in an `activeWhen` state — with
+ * "activeOn": "seated" (#2698), only those `posture(name)` says are "seated" (at the seat zones gave them, not walking).
+ * `posture` null: no walkers, everyone at their seat.
+ */
+function activeForNow(f, byName, posture) {
+  const seated = (n) => f.activeOn !== "seated" || !posture || posture(n) === "seated";
+  return (f.activeFor || [...byName.keys()]).filter((n) => byName.has(n) && f.activeWhen.includes(byName.get(n)) && seated(n));
+}
+/**
+ * The furniture active now: an item whose `activeWhen` names a state someone shown is in. With activeFor (#2570),
+ * only those people's states count; with "activeOn": "seated" (#2698), only once one of them is seated (`posture`,
+ * name → "walking" | "seated" | "standing"; null: everyone seated) — it turns back as they walk off.
+ */
+export function activeFurniture(pack, states, byName = new Map(), posture = null) {
   const on = new Set();
   for (const f of (pack && pack.furniture) || []) {
     if (!f.activeWhen) continue;
-    // activeFor (#2570): only those people's states count; else anyone's shown.
-    const hit = f.activeFor ? f.activeFor.some((n) => byName.has(n) && f.activeWhen.includes(byName.get(n))) : f.activeWhen.some((s) => states.has(s));
+    const hit = f.activeFor || f.activeOn === "seated" ? activeForNow(f, byName, posture).length > 0 : f.activeWhen.some((s) => states.has(s));
     if (hit) on.add(f.id);
   }
   return on;
 }
+/**
+ * #2698: who is drawn on an item instead of themselves (name → the item's id): for each `active` item with "hides",
+ * the people it is active for (activeFor's order) who are not walking — someone walking is always drawn. One item each.
+ */
+export function hiddenBy(pack, active, byName = new Map(), posture = null) {
+  const out = new Map();
+  for (const f of (pack && pack.furniture) || []) {
+    if (!f.hides || !f.activeWhen || !active.has(f.id)) continue;
+    for (const n of activeForNow(f, byName, posture)) if (!out.has(n) && (!posture || posture(n) !== "walking")) out.set(n, f.id);
+  }
+  return out;
+}