// Расстановка мебели по правилам для каждого типа комнаты.
// Работает в сетке здания: предмет занимает клетки, «спинкой» встаёт к стене,
// не перекрывает двери (зона открывания) и высокими предметами не закрывает окна.

import type { Building, Prop, Vec } from '../types';
import type { DoorL, FloorG, Grid, WindowL } from './interior';
import { C } from './interior';
import * as K from './catalog';
import type { Def } from './catalog';
import { Rng } from '../util/rng';
import { distToSegment } from '../util/geom';
import { CAR_COLORS } from './props';

export interface PropL {
  prop: Prop;
  pos: Vec;
  rot: number;
  room: number;
}

interface Ctx {
  g: Grid;
  F: FloorG;
  doors: DoorL[];
  windows: WindowL[];
  building: Building;
  rng: Rng;
}

type Dir = 'N' | 'E' | 'S' | 'W';
const ROT: Record<Dir, number> = { N: 0, S: Math.PI, W: -Math.PI / 2, E: Math.PI / 2 };

export function furnishFloor(ctx: Ctx): PropL[] {
  const { g, F, rng } = ctx;
  const n = g.gw * g.gh;
  const occ = new Uint8Array(n); // 0 свободно, 1 занято, 2 держать свободным
  const win = new Uint8Array(n);
  const out: PropL[] = [];
  const cellsOf = new Map<number, number[]>();
  for (let i = 0; i < n; i++) {
    const r = F.labels[i];
    if (r < 0 || !g.mask[i]) continue;
    if (!cellsOf.has(r)) cellsOf.set(r, []);
    cellsOf.get(r)!.push(i);
  }
  const cc = (i: number): Vec => [((i % g.gw) + 0.5) * C, (((i / g.gw) | 0) + 0.5) * C];
  // зоны дверей и окон
  const around = (a: Vec, b: Vec, r: number, fn: (i: number, p: Vec) => void) => {
    const x0 = Math.max(0, Math.floor((Math.min(a[0], b[0]) - r) / C)), x1 = Math.min(g.gw - 1, Math.floor((Math.max(a[0], b[0]) + r) / C));
    const y0 = Math.max(0, Math.floor((Math.min(a[1], b[1]) - r) / C)), y1 = Math.min(g.gh - 1, Math.floor((Math.max(a[1], b[1]) + r) / C));
    for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) { const i = y * g.gw + x; if (F.labels[i] >= 0) fn(i, cc(i)); }
  };
  for (const d of ctx.doors) {
    const m: Vec = [(d.a[0] + d.b[0]) / 2, (d.a[1] + d.b[1]) / 2];
    const half = Math.hypot(d.b[0] - d.a[0], d.b[1] - d.a[1]) / 2;
    around(d.a, d.b, half + 0.7, (i, p) => {
      if (distToSegment(p, d.a, d.b) < 0.95 || Math.hypot(p[0] - m[0], p[1] - m[1]) < half + 0.6) occ[i] = 2;
    });
  }
  for (const w of ctx.windows) around(w.a, w.b, 0.6, (i, p) => { if (distToSegment(p, w.a, w.b) < 0.6) win[i] = 1; });
  // лестницы — вне мебели
  for (const s of F.stairs) for (let y = s.block.y0; y < s.block.y1; y++) for (let x = s.block.x0; x < s.block.x1; x++) occ[y * g.gw + x] = 1;

  const lab = (x: number, y: number) => (x < 0 || y < 0 || x >= g.gw || y >= g.gh ? -1 : F.labels[y * g.gw + x]);
  const free = (x: number, y: number, room: number, tall?: boolean) => {
    if (x < 0 || y < 0 || x >= g.gw || y >= g.gh) return false;
    const i = y * g.gw + x;
    return F.labels[i] === room && g.mask[i] === 1 && occ[i] === 0 && !(tall && win[i]);
  };

  const emit = (def: Def, pos: Vec, rot: number, room: number, cells: number[], frontCells: number[], color?: string) => {
    for (const i of cells) occ[i] = 1;
    for (const i of frontCells) if (occ[i] === 0) occ[i] = 2;
    out.push({
      pos, rot, room,
      prop: {
        id: '', kind: def.kind, pos: [0, 0], rot: 0, w: def.w, d: def.d, shapes: def.shapes,
        blocksMove: def.blocksMove ?? true, blocksSight: !!def.tall, tags: def.tags, color,
      },
    });
    return true;
  };

  /** Поставить предмет спинкой к стене. */
  const atWall = (room: number, def: Def, opt: { corner?: boolean; window?: boolean; tries?: number } = {}): boolean => {
    const cells = cellsOf.get(room);
    if (!cells) return false;
    const A = Math.max(1, Math.ceil(def.w / C - 1e-6)), D = Math.max(1, Math.ceil(def.d / C - 1e-6));
    const FD = Math.ceil((def.front ?? 0) / C - 1e-6);
    let best: { s: number; dir: Dir; x0: number; y0: number; x1: number; y1: number } | null = null;
    for (const i of cells) {
      const cx = i % g.gw, cy = (i / g.gw) | 0;
      for (const dir of ['N', 'E', 'S', 'W'] as Dir[]) {
        let x0: number, y0: number, x1: number, y1: number;
        if (dir === 'N') { x0 = cx; y0 = cy; x1 = cx + A; y1 = cy + D; }
        else if (dir === 'S') { x0 = cx; y0 = cy - D + 1; x1 = cx + A; y1 = cy + 1; }
        else if (dir === 'W') { x0 = cx; y0 = cy; x1 = cx + D; y1 = cy + A; }
        else { x0 = cx - D + 1; y0 = cy; x1 = cx + 1; y1 = cy + A; }
        let ok = true;
        for (let y = y0; y < y1 && ok; y++) for (let x = x0; x < x1 && ok; x++) if (!free(x, y, room, def.tall)) ok = false;
        if (!ok) continue;
        // сзади должна быть стена по всей длине
        let wallOk = true;
        if (dir === 'N') for (let x = x0; x < x1; x++) wallOk &&= lab(x, y0 - 1) !== room;
        if (dir === 'S') for (let x = x0; x < x1; x++) wallOk &&= lab(x, y1) !== room;
        if (dir === 'W') for (let y = y0; y < y1; y++) wallOk &&= lab(x0 - 1, y) !== room;
        if (dir === 'E') for (let y = y0; y < y1; y++) wallOk &&= lab(x1, y) !== room;
        if (!wallOk) continue;
        // перед предметом — проход
        let frontOk = true;
        for (let k = 1; k <= FD && frontOk; k++) {
          if (dir === 'N') for (let x = x0; x < x1; x++) frontOk &&= lab(x, y1 - 1 + k) === room && occ[(y1 - 1 + k) * g.gw + x] !== 1;
          if (dir === 'S') for (let x = x0; x < x1; x++) frontOk &&= lab(x, y0 - k) === room && occ[(y0 - k) * g.gw + x] !== 1;
          if (dir === 'W') for (let y = y0; y < y1; y++) frontOk &&= lab(x1 - 1 + k, y) === room && occ[y * g.gw + x1 - 1 + k] !== 1;
          if (dir === 'E') for (let y = y0; y < y1; y++) frontOk &&= lab(x0 - k, y) === room && occ[y * g.gw + x0 - k] !== 1;
        }
        if (!frontOk) continue;
        let s = rng.next();
        if (opt.corner) {
          const sideA = dir === 'N' || dir === 'S' ? lab(x0 - 1, dir === 'N' ? y0 : y1 - 1) !== room : lab(dir === 'W' ? x0 : x1 - 1, y0 - 1) !== room;
          const sideB = dir === 'N' || dir === 'S' ? lab(x1, dir === 'N' ? y0 : y1 - 1) !== room : lab(dir === 'W' ? x0 : x1 - 1, y1) !== room;
          s += (sideA ? 2 : 0) + (sideB ? 2 : 0);
        }
        if (opt.window) {
          let wn = 0;
          for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) wn += win[y * g.gw + x];
          s += wn ? 3 : 0;
        }
        if (!best || s > best.s) best = { s, dir, x0, y0, x1, y1 };
      }
    }
    if (!best) return false;
    const { dir, x0, y0, x1, y1 } = best;
    const inset = 0.07 + def.d / 2;
    let pos: Vec;
    if (dir === 'N') pos = [((x0 + x1) / 2) * C, y0 * C + inset];
    else if (dir === 'S') pos = [((x0 + x1) / 2) * C, y1 * C - inset];
    else if (dir === 'W') pos = [x0 * C + inset, ((y0 + y1) / 2) * C];
    else pos = [x1 * C - inset, ((y0 + y1) / 2) * C];
    const used: number[] = [];
    for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) used.push(y * g.gw + x);
    const front: number[] = [];
    for (let k = 1; k <= FD; k++) {
      if (dir === 'N') for (let x = x0; x < x1; x++) front.push((y1 - 1 + k) * g.gw + x);
      if (dir === 'S') for (let x = x0; x < x1; x++) front.push((y0 - k) * g.gw + x);
      if (dir === 'W') for (let y = y0; y < y1; y++) front.push(y * g.gw + x1 - 1 + k);
      if (dir === 'E') for (let y = y0; y < y1; y++) front.push(y * g.gw + x0 - k);
    }
    return emit(def, pos, ROT[dir], room, used, front.filter((i) => i >= 0 && i < n));
  };

  /** Поставить предмет отдельно (стол, кластер), с отступом margin клеток, ближе к центру комнаты. */
  const inMiddle = (room: number, def: Def, margin = 1, center?: Vec, color?: string): boolean => {
    const cells = cellsOf.get(room);
    if (!cells) return false;
    const c = center ?? roomPole(room);
    let best: { s: number; x0: number; y0: number; x1: number; y1: number; rot: boolean } | null = null;
    for (const rotd of [false, true]) {
      const A = Math.max(1, Math.ceil((rotd ? def.d : def.w) / C - 1e-6)), D = Math.max(1, Math.ceil((rotd ? def.w : def.d) / C - 1e-6));
      for (const i of cells) {
        const x0 = i % g.gw, y0 = (i / g.gw) | 0;
        let ok = true;
        for (let y = y0 - margin; y < y0 + D + margin && ok; y++)
          for (let x = x0 - margin; x < x0 + A + margin && ok; x++) {
            const inner = x >= x0 && x < x0 + A && y >= y0 && y < y0 + D;
            if (inner) ok = free(x, y, room);
            else ok = lab(x, y) === room && occ[y * g.gw + x] !== 1;
          }
        if (!ok) continue;
        const s = -Math.hypot((x0 + A / 2) * C - c[0], (y0 + D / 2) * C - c[1]) + rng.next() * 0.3;
        if (!best || s > best.s) best = { s, x0, y0, x1: x0 + A, y1: y0 + D, rot: rotd };
      }
    }
    if (!best) return false;
    const used: number[] = [];
    for (let y = best.y0; y < best.y1; y++) for (let x = best.x0; x < best.x1; x++) used.push(y * g.gw + x);
    return emit(def, [((best.x0 + best.x1) / 2) * C, ((best.y0 + best.y1) / 2) * C], best.rot ? Math.PI / 2 : rng.chance(0.5) ? 0 : Math.PI, room, used, [], color);
  };

  /** Сетка одинаковых предметов (столики, парты, станки). */
  const lattice = (room: number, make: () => Def, gapX: number, gapY: number, margin: number, alongLong = true, max = 400, faceRot?: number): number => {
    const cells = cellsOf.get(room);
    if (!cells) return 0;
    const bb = roomBox(room);
    const longX = bb[2] - bb[0] >= bb[3] - bb[1];
    const def0 = make();
    const rotd = alongLong ? !longX : longX;
    const A = Math.ceil((rotd ? def0.d : def0.w) / C - 1e-6), D = Math.ceil((rotd ? def0.w : def0.d) / C - 1e-6);
    const sx = A + Math.round(gapX / C), sy = D + Math.round(gapY / C);
    let placed = 0;
    for (let y = bb[1] + margin; y + D <= bb[3] - margin && placed < max; y += sy)
      for (let x = bb[0] + margin; x + A <= bb[2] - margin && placed < max; x += sx) {
        let ok = true;
        for (let yy = y - 1; yy < y + D + 1 && ok; yy++)
          for (let xx = x - 1; xx < x + A + 1 && ok; xx++) {
            const inner = xx >= x && xx < x + A && yy >= y && yy < y + D;
            ok = inner ? free(xx, yy, room) : lab(xx, yy) === room && occ[yy * g.gw + xx] !== 1;
          }
        if (!ok) continue;
        const used: number[] = [];
        for (let yy = y; yy < y + D; yy++) for (let xx = x; xx < x + A; xx++) used.push(yy * g.gw + xx);
        emit(make(), [(x + A / 2) * C, (y + D / 2) * C], faceRot ?? (rotd ? Math.PI / 2 : 0), room, used, []);
        placed++;
      }
    return placed;
  };

  /** Ряды стеллажей вдоль длинной стороны комнаты с проходами. */
  const rows = (room: number, make: (L: number) => Def, depth: number, aisle: number, margin: number, maxLen = 12) => {
    const bb = roomBox(room);
    const longX = bb[2] - bb[0] >= bb[3] - bb[1];
    const D = Math.ceil(depth / C), step = D + Math.round(aisle / C);
    const [a0, a1, b0, b1] = longX ? [bb[1], bb[3], bb[0], bb[2]] : [bb[0], bb[2], bb[1], bb[3]];
    for (let a = a0 + margin; a + D <= a1 - margin; a += step) {
      let runStart = -1;
      const flush = (end: number) => {
        let s = runStart;
        while (end - s >= 4) {
          const len = Math.min(end - s, Math.round(maxLen / C));
          const L = len * C - 0.1;
          const used: number[] = [];
          for (let k = s; k < s + len; k++) for (let dd = a; dd < a + D; dd++) used.push(longX ? dd * g.gw + k : k * g.gw + dd);
          const pos: Vec = longX ? [((s + s + len) / 2) * C, (a + D / 2) * C] : [(a + D / 2) * C, ((s + s + len) / 2) * C];
          emit(make(L), pos, longX ? 0 : Math.PI / 2, room, used, []);
          s += len + 3;
        }
        runStart = -1;
      };
      for (let k = b0 + margin; k <= b1 - margin; k++) {
        let ok = k < b1 - margin;
        for (let dd = a - 1; dd < a + D + 1 && ok; dd++) {
          const x = longX ? k : dd, y = longX ? dd : k;
          const inner = dd >= a && dd < a + D;
          ok = inner ? free(x, y, room, true) : lab(x, y) === room && occ[y * g.gw + x] !== 1;
        }
        if (ok && runStart < 0) runStart = k;
        if (!ok && runStart >= 0) flush(k);
      }
    }
  };

  const roomBox = (room: number): [number, number, number, number] => {
    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
    for (const i of cellsOf.get(room) ?? []) {
      const x = i % g.gw, y = (i / g.gw) | 0;
      x0 = Math.min(x0, x); y0 = Math.min(y0, y); x1 = Math.max(x1, x + 1); y1 = Math.max(y1, y + 1);
    }
    return [x0, y0, x1, y1];
  };
  const roomPole = (room: number): Vec => {
    const bb = roomBox(room);
    return [((bb[0] + bb[2]) / 2) * C, ((bb[1] + bb[3]) / 2) * C];
  };
  const areaOf = (room: number) => (cellsOf.get(room)?.length ?? 0) * C * C;
  const shortSide = (room: number) => { const bb = roomBox(room); return Math.min(bb[2] - bb[0], bb[3] - bb[1]) * C; };

  const use = ctx.building.use ?? '';
  for (const [room, cells] of cellsOf) {
    const R = F.rooms[room];
    if (R.dead || !cells.length) continue;
    const a = areaOf(room);
    switch (R.kind) {
      case 'bedroom': {
        if (a >= 10 && shortSide(room) >= 2.8) {
          if (!atWall(room, K.bedWithNightstands())) atWall(room, K.bed(true));
        } else if (!atWall(room, K.bed(a >= 9), { corner: true })) atWall(room, K.bed(false), { corner: true });
        atWall(room, K.wardrobe(a > 12 ? 1.8 : 1.2), { corner: true });
        if (a > 11) atWall(room, K.desk(1.2), { window: true });
        if (a > 14 && rng.chance(0.5)) atWall(room, K.armchair(), { corner: true });
        if (rng.chance(0.3)) atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'living': {
        const studio = a < 30 && !F.rooms.some((r) => r.unit === R.unit && r.kind === 'bedroom' && !r.dead);
        if (studio) {
          atWall(room, K.bed(true), { corner: true });
          if (!F.rooms.some((r) => r.unit === R.unit && r.kind === 'kitchen' && !r.dead)) atWall(room, K.kitchenLine(1.8));
        }
        if (!atWall(room, K.sofaSet())) atWall(room, K.sofa(1.8));
        atWall(room, K.tvStand());
        if (a > 16) atWall(room, K.armchair(), { corner: true });
        atWall(room, K.bookshelf(rng.pick([0.8, 1.0, 1.6])));
        if (a > 20 && !studio) inMiddle(room, K.diningTable(a > 26 ? 6 : 4), 1);
        atWall(room, K.plant(), { corner: true });
        if (rng.chance(0.5)) atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'kitchen': {
        let placed = false;
        for (const L of [3.6, 3.0, 2.4, 1.8, 1.2]) if (atWall(room, K.kitchenLine(L))) { placed = true; break; }
        if (!placed) inMiddle(room, K.kitchenLine(1.2), 0);
        atWall(room, K.fridge(), { corner: true });
        if (a >= 8) inMiddle(room, K.diningTable(4), 1);
        break;
      }
      case 'bath': {
        if (a >= 4.2 && shortSide(room) >= 1.7) { if (!atWall(room, K.bathtub(), { corner: true })) atWall(room, K.shower(), { corner: true }); }
        else atWall(room, K.shower(), { corner: true });
        atWall(room, K.toilet());
        atWall(room, K.basin());
        if (a > 6) atWall(room, K.washer());
        break;
      }
      case 'wc': {
        const n = ctx.building.kind === 'house' || a < 5 ? 1 : Math.min(4, Math.floor(a / 2.5));
        for (let k = 0; k < n; k++) atWall(room, K.toilet(), { corner: k === 0 });
        atWall(room, K.basin());
        if (n > 1) atWall(room, K.basin());
        break;
      }
      case 'hall': {
        atWall(room, K.coatRack());
        if (a > 5) atWall(room, K.shoeCabinet());
        if (a > 9) atWall(room, K.plant(), { corner: true });
        if (ctx.building.kind === 'civic' && a > 20) { atWall(room, K.counter(2.4)); atWall(room, K.sofa(2.0)); }
        break;
      }
      case 'landing':
        if (F.level === 0) atWall(room, K.mailboxes());
        break;
      case 'lobby': {
        atWall(room, K.mailboxes());
        atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'corridor': {
        if (rng.chance(0.4)) atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'utility': {
        atWall(room, K.washer());
        atWall(room, K.boiler(), { corner: true });
        atWall(room, K.shelf(1.0));
        break;
      }
      case 'storage':
      case 'backroom': {
        for (let k = 0; k < 8; k++) if (!atWall(room, K.shelf(rng.pick([1.0, 1.2, 1.8])))) break;
        for (let k = 0; k < (a > 15 ? 3 : 1); k++) inMiddle(room, K.crate(), 1);
        break;
      }
      case 'sales': {
        if (['clothes', 'shoes', 'boutique', 'fashion'].includes(use)) {
          lattice(room, K.clothesRack, 1.0, 1.2, 2);
          atWall(room, K.counter(1.6));
          for (let k = 0; k < 6; k++) if (!atWall(room, K.wallShelf(2.0))) break;
        } else if (['bakery', 'cafe', 'butcher', 'pastry', 'deli', 'confectionery'].includes(use) || a < 25) {
          if (!atWall(room, K.counter(Math.min(3.0, Math.max(1.2, shortSide(room) - 1))))) inMiddle(room, K.counter(1.2), 1);
          for (let k = 0; k < 3; k++) if (!atWall(room, K.wallShelf(1.6))) break;
        } else {
          // супермаркет / обычный магазин: кассы у входа, стеллажи рядами, холодильники у стен
          const ent = ctx.doors.find((d) => d.r2 === -1 && d.r1 === room);
          const nCheck = a > 400 ? 4 : a > 120 ? 2 : 1;
          for (let k = 0; k < nCheck; k++) inMiddle(room, K.checkout(), 1, ent ? [(ent.a[0] + ent.b[0]) / 2, (ent.a[1] + ent.b[1]) / 2] : undefined);
          if (use === 'supermarket' || a > 150) for (let k = 0; k < 4; k++) if (!atWall(room, K.fridgeDisplay(2.4))) break;
          for (let k = 0; k < 10; k++) if (!atWall(room, K.wallShelf(rng.pick([1.8, 2.4])))) break;
          rows(room, K.gondola, 1.0, 1.6, 2, 10);
        }
        if (a > 20) atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'dining': {
        atWall(room, K.counter(Math.min(3.0, Math.max(1.4, shortSide(room) * 0.6))));
        if (lattice(room, a > 30 && rng.chance(0.5) ? K.cafeTable : () => K.diningTable(4), 0.8, 0.9, 1) === 0) inMiddle(room, K.cafeTable(), 1);
        atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'prokitchen': {
        for (const L of [2.4, 1.8, 1.2]) if (atWall(room, K.prepTable(L))) break;
        atWall(room, K.proStove());
        atWall(room, K.fridge(), { corner: true });
        atWall(room, K.fridge(), { corner: true });
        if (a > 14) inMiddle(room, K.prepTable(1.6), 1);
        atWall(room, K.shelf(1.2));
        break;
      }
      case 'office': {
        atWall(room, K.desk(1.4), { window: true });
        if (a > 12) atWall(room, K.desk(1.4), { window: true });
        atWall(room, K.filing(), { corner: true });
        atWall(room, K.bookshelf(1.0));
        if (rng.chance(0.6)) atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'openoffice': {
        lattice(room, K.officeCluster, 1.4, 1.2, 2);
        for (let k = 0; k < 3; k++) atWall(room, K.filing(), { corner: true });
        atWall(room, K.plant(), { corner: true });
        atWall(room, K.plant(), { corner: true });
        break;
      }
      case 'meeting': {
        const bb = roomBox(room);
        const L = Math.max(1.6, Math.min(6, (Math.max(bb[2] - bb[0], bb[3] - bb[1]) * C) - 2.2));
        if (!inMiddle(room, K.meetingTable(L), 1)) inMiddle(room, K.meetingTable(1.6), 1);
        atWall(room, K.board(2.0));
        break;
      }
      case 'staff': {
        inMiddle(room, K.diningTable(4), 1);
        atWall(room, K.kitchenLine(1.8));
        atWall(room, K.sofa(1.8));
        break;
      }
      case 'classroom': {
        atWall(room, K.board(3.0));
        inMiddle(room, K.teacherDesk(), 1);
        lattice(room, K.studentDesk, 0.7, 0.5, 2);
        atWall(room, K.bookshelf(1.6));
        break;
      }
      case 'ward': {
        for (let k = 0; k < Math.max(1, Math.min(4, Math.floor(a / 8))); k++) if (!atWall(room, K.hospitalBed())) break;
        atWall(room, K.nightstand());
        atWall(room, K.armchair(), { corner: true });
        break;
      }
      case 'guestroom': {
        if (!atWall(room, K.bedWithNightstands())) if (!atWall(room, K.bed(true))) atWall(room, K.bed(false));
        atWall(room, K.desk(1.2), { window: true });
        atWall(room, K.wardrobe(1.0), { corner: true });
        atWall(room, K.armchair(), { corner: true });
        break;
      }
      case 'workshop': {
        for (let k = 0; k < 3; k++) atWall(room, K.workbench(rng.pick([1.6, 2.0])));
        for (let k = 0; k < 4; k++) atWall(room, K.shelf(1.2));
        inMiddle(room, K.machine(), 1);
        break;
      }
      case 'hall_ind': {
        const kindB = ctx.building.kind;
        if (kindB === 'warehouse' && !['sports_hall', 'sports_centre'].includes(use)) {
          rows(room, K.palletRack, 1.1, 3.2, 3, 16);
          lattice(room, K.pallet, 2.0, 2.0, 2, true, 6);
        } else if (kindB === 'farm') {
          lattice(room, K.pallet, 2.5, 2.5, 2, true, 8);
          for (let k = 0; k < 4; k++) atWall(room, K.shelf(1.8));
        } else if (['sports_hall', 'sports_centre'].includes(use)) {
          atWall(room, K.bookshelf(2.0));
        } else {
          lattice(room, K.machine, 2.4, 2.6, 3, true, 40);
          for (let k = 0; k < 4; k++) atWall(room, K.workbench(2.0));
          for (let k = 0; k < 6; k++) atWall(room, K.shelf(1.8));
        }
        break;
      }
      case 'nave': {
        // алтарь у дальней от входа стены, скамьи рядами поперёк
        const ent = ctx.doors.find((d) => d.r2 === -1);
        const bb = roomBox(room);
        const longX = bb[2] - bb[0] >= bb[3] - bb[1];
        const cMid: Vec = [((bb[0] + bb[2]) / 2) * C, ((bb[1] + bb[3]) / 2) * C];
        let far: Vec = cMid;
        if (ent) {
          const em: Vec = [(ent.a[0] + ent.b[0]) / 2, (ent.a[1] + ent.b[1]) / 2];
          far = longX ? [em[0] < cMid[0] ? (bb[2] - 3) * C : (bb[0] + 3) * C, cMid[1]] : [cMid[0], em[1] < cMid[1] ? (bb[3] - 3) * C : (bb[1] + 3) * C];
        }
        inMiddle(room, K.altar(), 1, far);
        const width = (longX ? bb[3] - bb[1] : bb[2] - bb[0]) * C;
        const L = Math.max(1.5, Math.min(5, (width - 2.4) / 2));
        lattice(room, () => K.pew(L), 1.6, 0.5, 2, false, 60, longX ? Math.PI / 2 : 0);
        break;
      }
      case 'garage': {
        if (a > 14 && shortSide(room) >= 2.6) inMiddle(room, K.carDef(), 0, undefined, rng.pick(CAR_COLORS));
        atWall(room, K.workbench(1.6));
        atWall(room, K.shelf(1.2));
        break;
      }
      default:
        break;
    }
  }
  return out;
}