// 事故が起きたら誰の責任？ — 交差点の計算（試作 v0）
// 単位：m・秒。上から見て x が東、z が南（three.js と同じ向き）。
export const DEFAULTS = { mode: 'l2', sensor: 'normal', speed: 10, guide: true, route: 'short', rest: true };

export const PARAMS = {
  daysPerYear: 300, passesPerDay: 40, dt: 0.1, passTime: 75,
  pedRatePerPass: 0.8, phoneRate: 0.2, fromBehindHedge: 0.4, walk: [1.0, 1.5],
  // 歩く人の型（割合）：ふつう / 連れ立って / ゆっくり / 急いで / 渡るか迷う / 横断歩道の外を斜めに
  pedTypes: [['normal', 0.45], ['group', 0.15], ['slow', 0.12], ['hurry', 0.1], ['hesitate', 0.1], ['diagonal', 0.08]],
  slowWalk: [0.6, 0.9], hurryWalk: [2.0, 2.8], ambient: [1, 3],
  guideClear: 0.7, operatorTrustGuide: 0.4, missRest: 0.05, missNoRest: 0.10,
  reaction: 0.9, decel: 2.5, emergencyDecel: 3.0, operatorReaction: 1.2,
  // バスの動き：ゆるやかな加速・減速。加速度の変わり方（ジャーク）にも上限をつけ、曲がる前は横Gが大きくならない速さに落とす
  cruise: 35 / 3.6, zoneBefore: 14, zoneAfter: 4, // 交差点の外は時速35kmで走り（20人前後のミニバス。最高は時速40km前後）、交差点の手前14mから抜けて4mまでは設定の速さ
  accel: 1.0, comfortDecel: 1.3, trackDecel: 2.0, jerk: 1.8, latAcc: 3.0,
  predictNormal: 1.0, predictWide: 2.0, predictOp: 1.2, // 人の何秒先の位置まで読むか
  sensorNormal: { range: 10, half: 95 }, sensorWide: { range: 14, half: 150 },
  eveningRange: 0.7, detourSec: 0, remoteReaction: 2.0, nearMiss: 1.0, pedR: 0.25,
  cost: { base: 100, sensorWide: 30, guide: 40, detour: 10, rest: 15, onboard: 20, remote1: 12, remote3: 4 }
};

// 再現できる乱数
export function rng(seed) {
  let a = seed >>> 0;
  return () => { a |= 0; a = (a + 0x6D2B79F5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
}

// 植え込み（近道のときだけある）：[xmin, xmax, zmin, zmax]
export const HEDGES = [[3.4, 9.0, -5.0, -3.6]];
// 横断歩道（脇道の入口）
export const CROSS = { xmin: -3.2, xmax: 3.2, zmin: -6.5, zmax: -3.5 };
export const PED_Z = -5.8;

// バスの道：4通り。直線 → 90度曲がる → 直線。h は向き（0で東・π/2で北）
// 左側通行：東へ向かう車線は z=-1.75、西へは z=+1.75、北へ向かう脇道の車線は x=-1.5、南へは x=+1.5
const leftOf = (h) => ({ x: -Math.sin(h), z: -Math.cos(h) });
function makeRoute(name, label, x0, z0, h0, len1, turn, R) {
  const L2 = Math.PI / 2 * R, L3 = 45;
  const p1 = { x: x0 + Math.cos(h0) * len1, z: z0 - Math.sin(h0) * len1 };
  const lv = leftOf(h0), C = { x: p1.x + turn * R * lv.x, z: p1.z + turn * R * lv.z };
  const h2 = h0 + turn * Math.PI / 2, lv2 = leftOf(h2), p2 = { x: C.x - turn * R * lv2.x, z: C.z - turn * R * lv2.z };
  const pose = (s) => {
    if (s <= len1) return { x: x0 + Math.cos(h0) * s, z: z0 - Math.sin(h0) * s, h: h0 };
    if (s <= len1 + L2) { const h = h0 + turn * (s - len1) / R, l = leftOf(h); return { x: C.x - turn * R * l.x, z: C.z - turn * R * l.z, h }; }
    const t = s - len1 - L2; return { x: p2.x + Math.cos(h2) * t, z: p2.z - Math.sin(h2) * t, h: h2 };
  };
  const pts = []; for (let q = 0; q <= len1 + L2 + L3 + 12; q += 0.1) pts.push(pose(q));
  const fast = (q) => pts[Math.max(0, Math.min(pts.length - 1, Math.round(q * 10)))]; // 速く引くための、0.1m刻みの表
  const r = { name, label, turn, R, pose, fast, arcStart: len1, arcEnd: len1 + L2, total: len1 + L2 + L3, stopS: 0, enters: name === 'wl' || name === 'er' };
  for (let s = 0; s < r.total; s += 0.02) { const p = pose(s), fx = p.x + Math.cos(p.h) * BUS_L / 2, fz = p.z - Math.sin(p.h) * BUS_L / 2;
    if (fx > CROSS.xmin - 0.3 && fx < CROSS.xmax + 0.3 && fz > CROSS.zmin - (r.enters ? 0.3 : 1.2) && fz < CROSS.zmax + 0.3) { r.stopS = s; break; } }
  return r;
}
const BUS_L = 5.2, BUS_W = 2.2;
export const ROUTES = {
  wl: makeRoute('wl', '西から来て左折', -75, -1.75, 0, 70, 1, 3.5),
  er: makeRoute('er', '東から来て右折', 75, 1.75, Math.PI, 71.5, -1, 5),
  nl: makeRoute('nl', '脇道から出て左折', 1.5, -75, -Math.PI / 2, 69.75, 1, 3.5),
  nr: makeRoute('nr', '脇道から出て右折', 1.5, -75, -Math.PI / 2, 71.75, -1, 5),
};
export const ROUTE_SHARE = [['wl', 0.4], ['er', 0.25], ['nl', 0.2], ['nr', 0.15]];
export const STOP_S = ROUTES.wl.stopS;
export function busPose(s, route = 'wl') { return ROUTES[route].pose(s); }
// バスの車体（中心＝pose、向き h：0で東向き）と点の距離
function distToBus(p, px, pz) {
  const c = Math.cos(p.h), s = Math.sin(p.h);
  const dx = px - p.x, dz = pz - p.z;
  const u = dx * c - dz * s;      // 進む向き
  const w = dx * s + dz * c;      // 横
  const du = Math.max(Math.abs(u) - BUS_L / 2, 0), dw = Math.max(Math.abs(w) - BUS_W / 2, 0);
  return Math.hypot(du, dw);
}
// 車体のすぐ前（前4m・左右1.8m）に人がいるか
function inFront(p, px, pz) {
  const c = Math.cos(p.h), s = Math.sin(p.h), dx = px - p.x, dz = pz - p.z;
  const u = dx * c - dz * s, w = dx * s + dz * c;
  return u > BUS_L / 2 - 0.2 && u < BUS_L / 2 + 4 && Math.abs(w) < 1.8;
}
function frontHalf(p, px, pz) { const c = Math.cos(p.h), s = Math.sin(p.h); return (px - p.x) * c - (pz - p.z) * s > 0; }
function segHitsRect(x1, z1, x2, z2, r) {
  // 線分が長方形を通るか（簡単な刻みで判定）
  for (let i = 1; i < 20; i++) { const t = i / 20, x = x1 + (x2 - x1) * t, z = z1 + (z2 - z1) * t; if (x > r[0] && x < r[1] && z > r[2] && z < r[3]) return true; }
  return false;
}
function blocked(cfg, x1, z1, x2, z2) {
  if (cfg.route !== 'short') return false;
  return HEDGES.some((h) => segHitsRect(x1, z1, x2, z2, h));
}
function inCross(px, pz, pad = 0) { return px > CROSS.xmin - pad && px < CROSS.xmax + pad && pz > CROSS.zmin && pz < CROSS.zmax; }

// 脇道の車道（横断歩道から北）。歩く人が車道に入る直前かを見るのに使う
const inSideRoad = (x, z) => Math.abs(x) < 3.2 && z < -3.5 && z > -40;
const pick = (rand, table) => { let u = rand(), acc = 0; for (const [k, w] of table) { acc += w; if (u < acc) return k; } return table.at(-1)[0]; };
const EMPTY_CACHE = new Map();
// 場面を選んで確かめるための場面（道・歩く人・誘導員の合図を決め打ちにしたもの）。arrive はバスが交差点に来るころに合わせてある
export const SCENES = [
  { id: 'miss', title: '見ている人の見落とし', note: 'スマホを見ている人が、バスの発進のころに横断歩道へ入る', route: 'wl', peds: [{ type: 'normal', fromEast: false, phone: true, sp: 1.2, arrive: 15.5, missRoll: 0.07 }], guideClear: false, trustGuide: false },
  { id: 'guide', requires: { guide: true }, title: '誘導員の合図を当てにした発進', note: '誘導員の合図はあいまい。運転する側は「止めてくれる」と読む', route: 'wl', peds: [{ type: 'normal', fromEast: false, phone: true, sp: 1.3, arrive: 16.75, missRoll: 0.5 }], guideClear: false, trustGuide: true },
  { id: 'right', title: '右折中の横断歩道', note: '東から来たバスが、対向車線を横切って横断歩道へ向かう', route: 'er', peds: [{ type: 'normal', fromEast: false, phone: true, sp: 1.3, arrive: 17.75, missRoll: 0.5 }], guideClear: false, trustGuide: false },
  { id: 'exit', title: '脇道から出るバスの前へ', note: '本道へ出るバスの前を、人が横断歩道で渡る', route: 'nl', peds: [{ type: 'normal', fromEast: true, phone: true, sp: 1.3, arrive: 16.0, missRoll: 0.5 }], guideClear: false, trustGuide: false },
  { id: 'diagonal', title: '横断歩道の外を斜めに渡る人', note: '脇道に入ったバスの前を、横断歩道の先で斜めに渡る', route: 'wl', peds: [{ type: 'diagonal', fromEast: false, phone: false, sp: 1.3, arrive: 17.25, missRoll: 0.5 }], guideClear: true, trustGuide: false },
];
// 場面のバスの向きを変える。歩く人が車道に着く時刻を、その向きでバスが横断歩道に着く時刻に合わせてずらす（場面の「ぶつかりそうな間合い」を保つ）
const ARR = new Map();
function busArrive(cfg, route) {
  const k = route + JSON.stringify(cfg); if (ARR.has(k)) return ARR.get(k);
  const r = simulatePass(cfg, rng(1), { record: true, scene: { route, peds: [], guideClear: true, trustGuide: false } });
  const S = ROUTES[route].stopS; const f = r.frames.find((x) => x.bus.s >= S - 1) || r.frames[r.frames.length - 1];
  ARR.set(k, f.t); return f.t;
}
// 向きを変えたときの、歩く人の時刻のずらし（秒）と、渡ってくる側を逆にするか。各向きで場面の間合いが保たれるよう、設定を総当たりして選んだ値
export const SCENE_DIRS = {
  miss: { er: [0.75, false], nl: [1, true], nr: [1, true] },
  guide: { er: [0, false], nl: [-0.25, true], nr: [0, true] },
  right: { wl: [0, false], nl: [-0.25, true], nr: [0, true] },
  exit: { wl: [0, true], er: [0, true], nr: [0, false] },
  diagonal: { er: [0, false] }, // 斜めに渡る人は脇道の奥を歩くので、脇道から出るバスとは交わらない
};
export function sceneFor(sc, dir, cfg) {
  if (!dir || dir === sc.route) return sc;
  const adj = (SCENE_DIRS[sc.id] || {})[dir]; if (!adj) return sc;
  const dt = busArrive(cfg, dir) - busArrive(cfg, sc.route) + adj[0];
  return { ...sc, route: dir, peds: sc.peds.map((p) => ({ ...p, arrive: Math.max(1, p.arrive + dt), ...(adj[1] ? { fromEast: !p.fromEast } : {}) })) };
}
export const PED_LABEL = { normal: 'ふつうに渡る人', group: '連れ立って渡る人', slow: 'ゆっくり渡る人', hurry: '急いで渡る人', hesitate: '渡るか迷っていた人', diagonal: '横断歩道の外を斜めに渡る人' };

// 1回の通過を計算する。record=true なら0.5秒ごとの記録を残す
export function simulatePass(cfg, rand, opts = {}) {
  const P = PARAMS;
  const evening = (opts.scene && opts.scene.evening) || opts.evening || false;
  const SC = opts.scene || null; // 場面を選んで確かめるとき：道・歩く人・誘導員の合図などを決め打ちにする
  const RT = ROUTES[(SC && SC.route) || opts.route || pick(rand, ROUTE_SHARE)];
  const pose = (s) => RT.pose(s);
  const STOP = RT.stopS;
  const vmax = cfg.speed / 3.6;
  const sens = cfg.sensor === 'wide' ? P.sensorWide : P.sensorNormal;
  const range = sens.range * (evening ? P.eveningRange : 1);
  // 運行の形：l2＝レベル2・運転士が乗る（発進は運転士）／l4in＝レベル4・車内に主任者／l4r1・l4r3＝レベル4・遠くで1人が1台／3台を見る
  const MODE = cfg.mode || 'l2', humanStart = MODE === 'l2', onboard = MODE === 'l2' || MODE === 'l4in', remote = MODE === 'l4r1' || MODE === 'l4r3';
  // 見落とし：休憩なしで増える。レベル2は「任せて見ているだけ」の監視疲れで少し増える。遠くで3台を見ると大きく増える
  const missP = (cfg.rest ? P.missRest : P.missNoRest) * (MODE === 'l2' ? 1.5 : MODE === 'l4r3' ? 2.5 : 1);
  // 歩く人（脇道を渡る人）
  const peds = [];
  let n = 0; if (SC) n = SC.peds.length; else { let l = Math.exp(-P.pedRatePerPass), k = 0, p = 1; do { k++; p *= rand(); } while (p > l); n = k - 1; }
  let S = {};
  // 見落としは「くじ」の値と見落としの割合で決まる。場面ではくじの値を固定するので、休憩や運行の形を変えると結果が変わる
  const mk = (o) => { const p = { id: peds.length, phone: false, missed: (S.missRoll ?? rand()) < missP, hes: 0, hit: false, minD: 99, ...o }; peds.push(p); return p; };
  for (let i = 0; i < n; i++) {
    S = SC ? SC.peds[i] : {};
    const type = S.type ?? pick(rand, P.pedTypes);
    const fromEast = S.fromEast ?? rand() < P.fromBehindHedge;
    const dir = fromEast ? -1 : 1;
    let sp = P.walk[0] + rand() * (P.walk[1] - P.walk[0]);
    if (type === 'slow') sp = P.slowWalk[0] + rand() * (P.slowWalk[1] - P.slowWalk[0]);
    if (type === 'hurry') sp = P.hurryWalk[0] + rand() * (P.hurryWalk[1] - P.hurryWalk[0]);
    if (S.sp) sp = S.sp;
    const arrive = S.arrive ?? 4 + rand() * 18; // 車道の端に着く時刻（通過の始まりから）
    const phone = S.phone ?? ((type === 'normal' || type === 'group') && rand() < P.phoneRate);
    if (type === 'diagonal') {
      // 脇道の歩道を北から歩いてきて、角の手前から横断歩道の外を斜めに渡り、反対側の角へ向かう
      const sx = fromEast ? 1 : -1, zA = -9.2 - rand() * 1.6, zB = -6.9 - rand() * 0.4;
      const A = { x: sx * 4.6, z: zA }, B = { x: -sx * 4.6, z: zB }, C = { x: -sx * 30, z: -6.8 };
      const L = Math.hypot(B.x - A.x, B.z - A.z), ux = (B.x - A.x) / L, uz = (B.z - A.z) / L;
      const k = (4.6 - 3.2) / Math.abs(ux); // 角から車道の端までの距離
      const D = sp * arrive;
      let x, z, path;
      if (D <= k) { x = A.x + ux * (k - D); z = A.z + uz * (k - D); path = [B, C]; }
      else { x = A.x; z = A.z - (D - k); path = [A, B, C]; }
      const p = mk({ type, fromEast, hedge: false, sp, x, z, ux: 0, uz: 1, path, phone: rand() < P.phoneRate });
      const t0 = path[0], d0 = Math.hypot(t0.x - x, t0.z - z) || 1; p.ux = (t0.x - x) / d0; p.uz = (t0.z - z) / d0;
      continue;
    }
    const edgeX = fromEast ? CROSS.xmax : CROSS.xmin;
    const base = { type, fromEast, hedge: fromEast, sp, ux: dir, uz: 0, phone };
    if (type === 'group') {
      const m = 2 + (rand() < 0.4 ? 1 : 0), offs = [[0, 0], [0.7, 0.45], [1.3, -0.45]];
      for (let j = 0; j < m; j++) mk({ ...base, phone: j === 0 ? phone : false, x: edgeX - dir * sp * (arrive + offs[j][0]), z: PED_Z + offs[j][1] });
    } else {
      mk({ ...base, hes: type === 'hesitate' ? (S.hes ?? 1 + rand() * 3) : 0, x: edgeX - dir * sp * arrive, z: PED_Z });
    }
  }
  // 歩道を通り過ぎるだけの人（交差点は渡らない。見た目の人通り）
  const amb = [];
  { const na = P.ambient[0] + Math.floor(rand() * (P.ambient[1] - P.ambient[0] + 1));
    for (let i = 0; i < na; i++) {
      const sp = P.walk[0] + rand() * (P.walk[1] - P.walk[0]), kind = rand();
      if (kind < 0.6) { const d = rand() < 0.5 ? 1 : -1; amb.push({ id: 100 + i, x: -28 + rand() * 56, z: 5.0 + rand() * 0.8, ux: d, uz: 0, sp }); }
      else { const side = rand() < 0.5 ? -1 : 1; amb.push({ id: 100 + i, x: side * (4.3 + rand() * 0.6), z: -9 - rand() * 18, ux: 0, uz: -1, sp }); }
    } }
  const guideClear = SC && SC.guideClear !== undefined ? SC.guideClear : rand() < P.guideClear;
  const trustGuide = SC && SC.trustGuide !== undefined ? SC.trustGuide : rand() < P.operatorTrustGuide;
  // 渡る人がいない通過は、結果がいつも同じ。仕組み・道・夕方ごとに一度だけ計算して使い回す（1年を速く回すため）
  const ck = !peds.length && !opts.record ? JSON.stringify(cfg) + RT.name + evening : null;
  if (ck && EMPTY_CACHE.has(ck)) return EMPTY_CACHE.get(ck);
  const bus = { s: 0, v: Math.max(vmax, P.cruise), a: 0, state: 'approach', stopT: 0, brakeAt: null };
  const ev = []; const frames = [];
  let startedBy = null, guideRaised = false, hitCtx = null;
  const log = (t, k, text, extra) => ev.push({ t, k, text, ...(extra || {}) });
  log(0, 'route', `バスは${RT.label}${RT.name === 'er' ? '（対向車線を横切る）' : ''}`);
  let detectedLogged = false;
  const T = P.passTime;
  const blinkAt = (s) => (s > RT.arcStart - 15 && s < RT.arcEnd ? (RT.turn > 0 ? 'L' : 'R') : '');
  for (let step = 0; step * P.dt < T; step++) {
    const t = step * P.dt;
    const ps = pose(bus.s);
    const fx = ps.x + Math.cos(ps.h) * BUS_L / 2, fz = ps.z - Math.sin(ps.h) * BUS_L / 2;
    // センサー：前の範囲で、植え込みの陰でない人
    const sees = (p) => {
      const dx = p.x - fx, dz = p.z - fz, d = Math.hypot(dx, dz);
      if (d > range) return false;
      const ang = Math.atan2(-dz, dx) - ps.h; const a = Math.abs(Math.atan2(Math.sin(ang), Math.cos(ang))) * 180 / Math.PI;
      if (a > sens.half) return false;
      if (cfg.sensor !== 'wide' && blocked(cfg, fx, fz, p.x, p.z)) return false;
      return true;
    };
    // オペレーターの目（車内の前）
    const opSees = (p) => Math.hypot(p.x - fx, p.z - fz) < 25 && !blocked(cfg, fx, fz, p.x, p.z);
    // 発進の前に気にする場所：横断歩道と、その先の脇道（斜めに渡る人）
    const conflict = (p, pad) => !p.waitBus && (inCross(p.x, p.z, pad) || (Math.abs(p.x) < 3.2 + pad && p.z < -3.5 && p.z > -11)); // 下がってバスを待っている人は、バスに道をゆずっている
    const live = peds.filter((p) => !p.gone);
    const sensed = live.filter(sees);
    // これから通る道の上（車体の幅＋余裕）に人がいるか。いれば、前の端からその場所までの道のりを返す
    const look = 2 + bus.v * 3;
    // horizon 秒先の、歩いている人の位置も見る（先読み）
    const onPath = (p, horizon = 0) => {
      const far = look + 3 + horizon * 1.5; if (Math.abs(p.x - fx) > far || Math.abs(p.z - fz) > far) return null;
      if (!pathPts) { pathPts = []; for (let q = -0.3; q <= look; q += 0.8) { const pp = RT.fast(bus.s + BUS_L / 2 + q); pathPts.push(pp.x, pp.z, q); } }
      const key = p.id * 10 + horizon; if (memo.has(key)) return memo.get(key);
      const r2 = (BUS_W / 2 + (p.waitBus ? 0.2 : 0.5)) ** 2, n = horizon > 0 && p.moving !== false ? 2 : 1;
      for (let i = 0; i < pathPts.length; i += 3) for (let k = 0; k < n; k++) {
        const x = p.x + p.ux * p.sp * horizon * k, z = p.z + p.uz * p.sp * horizon * k, dx = x - pathPts[i], dz = z - pathPts[i + 1];
        if (dx * dx + dz * dz < r2) { const v = Math.max(0, pathPts[i + 2]); memo.set(key, v); return v; }
      }
      memo.set(key, null); return null;
    };
    let pathPts = null; const memo = new Map();
    const senseH = cfg.sensor === 'wide' ? P.predictWide : P.predictNormal;
    if (bus.state === 'approach' || bus.state === 'go') {
      const reach = bus.v * P.reaction + bus.v * bus.v / (2 * P.emergencyDecel) + 1.0;
      const danger = bus.v > 0.2 && sensed.find((p) => { const q = onPath(p, senseH); return q !== null && q < reach; });
      const opDanger = onboard && bus.v > 0.2 && live.find((p) => { if (!opSees(p) || p.missed) return false; const q = onPath(p, P.predictOp); return q !== null && q < reach + 0.5; });
      if (danger) danger.reacted = true; if (opDanger) opDanger.reacted = true;
      if (danger && (bus.brakeAt === null || bus.brakeAt > t + P.reaction)) { bus.brakeAt = t + P.reaction; log(t, 'sensed', 'センサーが歩行者を感知し、自動ブレーキ'); }
      if (opDanger && bus.brakeAt === null) { bus.brakeAt = t + P.operatorReaction; log(t, 'opbrake', MODE === 'l2' ? '運転士が非常ブレーキ' : '車内の主任者が非常停止'); }
      // オペレーターが乗らないとき：遠くの担当が、バスのカメラの映像で気づいて止める（通信と気づくまでの分だけ遅れる）
      const remoteDanger = remote && bus.v > 0.2 && sensed.find((p) => { if (p.missed) return false; const q = onPath(p, P.predictOp); return q !== null && q < reach + 1.5; });
      if (remoteDanger) remoteDanger.reacted = true;
      if (remoteDanger && bus.brakeAt === null) { bus.brakeAt = t + P.remoteReaction * (MODE === 'l4r3' ? 1.5 : 1); /* 3台を見ていると、気づいて指示を出すまでが遅れる */ log(t, 'remote', '遠隔監視者が映像で気づき、停止を指示'); }
      // 止まったあと、道の前が空いたらブレーキを解く
      // （近くの人が2秒先までに道に入らないことを確かめ、止まってから1秒は待つ）
      if (bus.v === 0 && bus.brakeAt !== null && t >= bus.brakeAt) { bus.heldT = (bus.heldT || 0) + P.dt; if (bus.heldT > 1.0 && !live.some((p) => { const q = onPath(p, 2.0); return q !== null && q < 4; })) { bus.brakeAt = null; bus.heldT = 0; } }
    }
    const braking = bus.brakeAt !== null && t >= bus.brakeAt;
    if (bus.state === 'approach') {
      if (sensed.some((p) => conflict(p, 3)) && !detectedLogged) { log(t, 'sensor', 'センサーが横断歩道のまわりに人を感知'); detectedLogged = true; }
    } else if (bus.state === 'stopped') {
      let clear;
      if (!humanStart) clear = !sensed.some((p) => conflict(p, cfg.sensor === 'wide' ? 3 : 1)); // ふつうのセンサーは、横断歩道に向かってくる人を先読みしない
      else {
        const seen = live.filter(opSees);
        const pad = cfg.guide && trustGuide ? 0.5 : 3;
        clear = !seen.some((p) => conflict(p, pad) && !p.missed);
      }
      if (clear && t - bus.stopT > 1.5) {
        bus.state = 'go'; startedBy = humanStart ? 'human' : 'bus';
        log(t, 'start', !humanStart ? 'バスが自分で「渡る人はいない」と判断して発進' : '運転士が発進させる');
        if (cfg.guide) { guideRaised = true; log(t, 'guide', guideClear ? '誘導員が歩行者に「止まれ」の合図（はっきり伝わる）' : '誘導員が手を水平に上げる（どちらへの合図か、あいまい）'); }
        if (humanStart && cfg.guide && trustGuide) log(t, 'trust', '運転士は「誘導員が歩行者を止めてくれる」と読んだ');
      }
    }
    // 速さの目標：設定の速さ → 曲がる前の減速 → 横断歩道の手前で止まる
    const zs = STOP - P.zoneBefore, ze = RT.arcEnd + P.zoneAfter, cruise = Math.max(vmax, P.cruise);
    let vT = bus.s < zs ? Math.min(cruise, Math.sqrt(vmax * vmax + 2 * P.comfortDecel * (zs - bus.s))) : bus.s > ze ? cruise : vmax;
    const vC = Math.sqrt(P.latAcc * RT.R);
    if (bus.s < RT.arcEnd) vT = Math.min(vT, Math.sqrt(vC * vC + 2 * P.comfortDecel * Math.max(0, RT.arcStart - bus.s)));
    if (bus.state === 'approach') vT = Math.min(vT, Math.sqrt(2 * P.comfortDecel * Math.max(0, STOP - bus.s - 0.02)));
    if (bus.state === 'stopped' || bus.state === 'after') vT = 0;
    let aWant, J = P.jerk;
    if (braking) { aWant = -P.emergencyDecel; J = 25; }
    else if (bus.brakeAt !== null) aWant = Math.min(bus.a, 0); // 気づいてからブレーキが効くまで
    else aWant = Math.max(-P.trackDecel, Math.min(P.accel, (vT - bus.v) / 0.7));
    bus.a = Math.max(bus.a - J * P.dt, Math.min(bus.a + J * P.dt, aWant));
    bus.v = Math.max(0, bus.v + bus.a * P.dt);
    if (bus.v === 0 && bus.a < 0) bus.a = 0;
    if (bus.state === 'approach' && STOP - bus.s < 0.06 && bus.v < 0.25) { bus.v = 0; bus.a = 0; bus.brakeAt = null; bus.state = 'stopped'; bus.stopT = t; log(t, 'stop', '横断歩道の手前で一時停止'); }
    bus.s += bus.v * P.dt;
    if (bus.state === 'approach' && bus.s > STOP) bus.s = STOP;
    // 歩く人
    const ps2 = pose(bus.s);
    for (const p of peds) {
      if (p.gone || p.hit) continue;
      const nx = p.x + p.ux * 1.2, nz = p.z + p.uz * 1.2; // 車道の縁から少し下がったところで待つ
      const atEdge = !inSideRoad(p.x, p.z) && inSideRoad(nx, nz);
      const dBus = Math.hypot(ps2.x - p.x, ps2.z - p.z);
      const busMovingNear = bus.v > 0.3 && dBus < 7;
      let stop = false;
      if (atEdge) {
        if (p.hes > 0) { stop = true; p.hes -= P.dt; } // 渡るか迷って、端で立ち止まる
        else if (p.type === 'hurry') { if (bus.v > 0.3 && dBus < 3.5) stop = true; } // 急いでいる人は、すぐそばに来るまで止まらない
        else if (!p.phone && busMovingNear) stop = true;
        if (guideRaised && guideClear && bus.state === 'go' && busMovingNear) { stop = true; p.stoppedByGuide = true; }
      }
      // 目の前にバスの車体があれば、スマホを見ていても止まる（自分から車体にぶつかりには行かない）
      const blockedAhead = distToBus(ps2, p.x + p.ux * 1.0, p.z + p.uz * 1.0) < 0.9; // 車体との間を1mより詰めない
      if (!stop && blockedAhead) {
        stop = true;
        // 止まったバスに道をふさがれたままなら、少し下がってバスから離れる（引き返しはしない）
        if (bus.v < 0.1) { p.blockT = (p.blockT || 0) + P.dt; if (p.blockT > 1.5 && !p.backed) { p.back = 3; p.backed = true; } }
      }
      // 動いているバスがすぐ近くに来たら、その場から少し離れる
      if (bus.v > 0.3 && distToBus(ps2, p.x, p.z) < (p.phone ? 0.9 : 2.0) && !(p.back > 0) && !p.waitBus) { p.back = 2.0; p.reacted = distToBus(ps2, p.x, p.z) < 1.2; } // スマホを見ていない人は、2m以内に来たら早めに離れる
      if (p.back > 0) {
        // バスの進む向きに対して横へ、車体の通り道の外まで下がる（最大3m）
        const c = Math.cos(ps2.h), sn = Math.sin(ps2.h), w = (p.x - ps2.x) * sn + (p.z - ps2.z) * c, sg = w >= 0 ? 1 : -1;
        if (Math.abs(w) < BUS_W / 2 + 0.6 && p.back > 0) { const step = 1.0 * P.dt; p.x += sn * sg * step; p.z += c * sg * step; p.back -= step; }
        else p.back = 0;
        stop = true;
        if (p.back <= 0) p.waitBus = true;
      }
      // 下がったあとは、進もうとしていた方向の先がバスで空くまで待ち、空いたら元の向きに渡る
      // お互いに待ってしまったら、人のほうが来た道を少し戻って歩道まで下がり、バスを先に通す（向きは変えない）
      if (p.waitBus && bus.v < 0.1) { p.waitT = (p.waitT || 0) + P.dt; if (p.waitT > 3 && !p.retreated) { p.retreat = 2.5; p.retreated = true; } }
      if (p.retreat > 0) { const step = Math.min(p.retreat, 1.0 * P.dt); p.retreat -= step; p.x -= p.ux * step; p.z -= p.uz * step; stop = true; }
      else if (p.waitBus) { if (distToBus(ps2, p.x + p.ux * 2.0, p.z + p.uz * 2.0) < 1.0 || (bus.v > 0.3 && distToBus(ps2, p.x, p.z) < 3)) stop = true; else { p.waitBus = false; p.blockT = 0; p.backed = false; p.waitT = 0; p.retreated = false; } }
      p.moving = !stop;
      if (!stop) {
        p.x += p.ux * p.sp * P.dt; p.z += p.uz * p.sp * P.dt;
        // 曲がり角（道筋の点）に着いたら、次の点へ向きを変える
        if (p.path && p.path.length) { const w = p.path[0]; if ((w.x - p.x) * p.ux + (w.z - p.z) * p.uz <= 0) { p.path.shift(); const nw = p.path[0]; if (nw) { const d = Math.hypot(nw.x - p.x, nw.z - p.z) || 1; p.ux = (nw.x - p.x) / d; p.uz = (nw.z - p.z) / d; } } }
      }
      if (Math.abs(p.x) > 30 || p.z < -40 || p.z > 30) p.gone = true;
      const d = distToBus(ps2, p.x, p.z) - P.pedR;
      // ひやりは、動いているバスに1mより近づいたときだけ数える。そのときの様子を残す（原因を示すため）
      if (bus.v > 1.0 && d < p.minD) { p.minD = d; p.ctx = { state: bus.state, kmh: Math.round(bus.v * 3.6), blocked: blocked(cfg, fx, fz, p.x, p.z) || !!p.hedgeHidden }; }
      if (d <= 0 && !p.hit && bus.v > 0.3) { p.hit = true; hitCtx = { state: bus.state, kmh: Math.round(bus.v * 3.6), blocked: blocked(cfg, fx, fz, p.x, p.z) }; log(t, 'hit', `止まりきる前に、バスと歩行者が接触（バスは時速${(bus.v * 3.6).toFixed(0)}km）`, { x: p.x, z: p.z, kmh: Math.round(bus.v * 3.6) }); bus.v = 0; bus.state = 'after'; }
    }
    if (opts.record) for (const a of amb) { a.x += a.ux * a.sp * P.dt; a.z += a.uz * a.sp * P.dt; }
    if (opts.record && step % 5 === 0) frames.push({ t: +t.toFixed(1), bus: { ...ps2, s: bus.s, v: bus.v, blink: blinkAt(bus.s) },
      peds: peds.filter((p) => !p.gone).map((p) => ({ id: p.id, x: p.x, z: p.z, phone: p.phone, type: p.type })).concat(amb.filter((a) => Math.abs(a.x) < 32 && a.z > -42).map((a) => ({ id: a.id, x: a.x, z: a.z, type: 'ambient' }))), guide: guideRaised });
    if (bus.state === 'after') { if (!opts.record || t > (ev.find((x) => x.k === 'hit') || { t: 0 }).t + 4) break; }
    if (bus.s > STOP + 40) break; // 交差点の先まで走り切ったら終わり
  }
  const hit = peds.some((p) => p.hit);
  // ひやり：動いているバスと1mより近づき、しかも急ブレーキか、人が飛びのくかした
  const nearPeds = peds.filter((p) => p.minD < P.nearMiss && p.reacted);
  const near = !hit && nearPeds.length > 0;
  const np = near ? nearPeds.reduce((a, b) => (b.minD < a.minD ? b : a)) : null;
  const hitPed = peds.find((p) => p.hit);
  const wait = ev.find((e) => e.k === 'start') && ev.find((e) => e.k === 'stop') ? ev.find((e) => e.k === 'start').t - ev.find((e) => e.k === 'stop').t : 0;
  if (ck) { const res = { hit: false, near: false, wait: Math.max(0, wait), events: [], frames: [], route: RT.name, nearFacts: null, facts: null }; EMPTY_CACHE.set(ck, res); return res; }
  return {
    hit, near, wait: Math.max(0, wait), events: ev, frames, route: RT.name,
    nearFacts: np ? { mode: MODE, id: np.id, dist: Math.max(0, np.minD), evening, pedType: np.type, phone: np.phone, missed: np.missed, hedge: np.hedge && RT.enters, ...np.ctx, startedBy, guideRaised, guideClear, trustGuide, route: RT.name } : null,
    facts: hit ? { ...hitCtx, hedge: hitPed.hedge && RT.enters, guideRaised, missed: hitPed.missed, phone: hitPed.phone, pedType: hitPed.type, fromBehindHedge: hitPed.hedge && RT.enters, guideClear, trustGuide, startedBy, evening, route: RT.name, mode: MODE } : null
  };
}

export function cost(cfg) {
  const c = PARAMS.cost; let v = c.base;
  if (cfg.sensor === 'wide') v += c.sensorWide;
  if (cfg.guide) v += c.guide;
  if (cfg.route === 'long') v += c.detour;
  const m = cfg.mode || 'l2'; v += m === 'l2' || m === 'l4in' ? c.onboard : m === 'l4r1' ? c.remote1 : c.remote3;
  if (cfg.rest) v += c.rest;
  return v;
}

// 1年を回す。事故の通過は seed を残し、あとで記録つきで再計算する
export function simulateYear(cfg, seed = 1) {
  const P = PARAMS, out = { accidents: [], near: 0, waitSum: 0, passes: 0, daily: [] };
  let k = 0;
  for (let d = 0; d < P.daysPerYear; d++) {
    let acc = 0, nr = 0;
    for (let i = 0; i < P.passesPerDay; i++) {
      const passSeed = (seed * 1000003 + k++) >>> 0;
      const evening = i >= 34 && i < 37;
      const r = simulatePass(cfg, rng(passSeed), { evening });
      out.passes++; out.waitSum += r.wait + (cfg.route === 'long' ? P.detourSec : 0);
      if (r.hit) { acc++; out.accidents.push({ day: d, pass: i, seed: passSeed, evening, facts: r.facts }); }
      if (r.near) { nr++; out.near++; }
    }
    out.daily.push({ acc, near: nr });
  }
  out.delayAvgMin = out.waitSum / out.passes / 60;
  out.cost = cost(cfg);
  return out;
}
