413 lines
21 KiB
TypeScript
413 lines
21 KiB
TypeScript
// Уровень города: зоны, дороги, контуры зданий, уличные объекты.
|
|
// Интерьеры генерируются отдельно (interior.ts) — в воркерах.
|
|
|
|
import type { OsmElement, BBox } from '../osm/overpass';
|
|
import type { Area, AreaKind, Building, Prop, Ring, Road, RoadKind, Vec, World } from '../types';
|
|
import { Projector } from './project';
|
|
import {
|
|
bboxOf, centroid, cleanRing, dist, distToSegment, minAreaRectAngle,
|
|
pointInRing, pointInRings, ringArea, rotate, signedArea,
|
|
} from '../util/geom';
|
|
import { Rng, hashString } from '../util/rng';
|
|
import { SpatialGrid } from '../util/spatial';
|
|
import { classify, clampLevels, defaultLevels, parseLevels } from './classify';
|
|
import { carShapes, CAR_COLORS, treeProp } from './props';
|
|
|
|
export interface InteriorJob {
|
|
building: Building;
|
|
/** Ближайшие к зданию участки дорог: [a, b, вес]. Вход ставится к дороге. */
|
|
roadSegs: [Vec, Vec, number][];
|
|
}
|
|
|
|
const LANDUSE: Record<string, AreaKind> = {
|
|
residential: 'residential', commercial: 'commercial', retail: 'retail', industrial: 'industrial',
|
|
farmland: 'farmland', farm: 'farmland', farmyard: 'farmyard', grass: 'grass', village_green: 'grass',
|
|
recreation_ground: 'grass', meadow: 'meadow', forest: 'forest', orchard: 'orchard', vineyard: 'vineyard',
|
|
cemetery: 'cemetery', construction: 'construction', brownfield: 'construction', greenfield: 'meadow',
|
|
railway: 'railway', allotments: 'garden', basin: 'water', reservoir: 'water', plant_nursery: 'garden',
|
|
flowerbed: 'garden', garages: 'industrial', religious: 'grass', education: 'school',
|
|
};
|
|
const NATURAL: Record<string, AreaKind> = {
|
|
water: 'water', wood: 'forest', scrub: 'scrub', heath: 'scrub', grassland: 'meadow', wetland: 'wetland',
|
|
beach: 'beach', sand: 'sand', bare_rock: 'sand', scree: 'sand',
|
|
};
|
|
const LEISURE: Record<string, AreaKind> = {
|
|
park: 'park', garden: 'garden', pitch: 'pitch', track: 'pitch', playground: 'playground',
|
|
golf_course: 'grass', swimming_pool: 'water', dog_park: 'grass', common: 'grass',
|
|
};
|
|
const AMENITY_AREA: Record<string, AreaKind> = {
|
|
parking: 'parking', school: 'school', kindergarten: 'school', college: 'school', university: 'school',
|
|
hospital: 'hospital', grave_yard: 'cemetery', marketplace: 'pedestrian', fuel: 'pedestrian',
|
|
};
|
|
|
|
const AREA_TIER: Record<AreaKind, number> = {
|
|
residential: 0, commercial: 0, industrial: 0, retail: 0, farmland: 0, railway: 0, school: 0, hospital: 0, construction: 0,
|
|
farmyard: 1, forest: 1, meadow: 1, grass: 1, park: 1, scrub: 1, orchard: 1, vineyard: 1, cemetery: 1, garden: 1,
|
|
wetland: 1, beach: 1, sand: 1,
|
|
pitch: 2, playground: 2, parking: 2, pedestrian: 2, water: 3,
|
|
};
|
|
|
|
const ROAD_WIDTH: Record<string, number> = {
|
|
motorway: 11, trunk: 10, primary: 9, secondary: 8, tertiary: 7, residential: 6, unclassified: 5.5,
|
|
living_street: 5, service: 3.6, pedestrian: 5, track: 3, footway: 1.8, cycleway: 2, path: 1.2, steps: 2,
|
|
bridleway: 1.5, road: 5,
|
|
};
|
|
const SIDEWALK: Record<string, number> = { primary: 2.2, secondary: 2, tertiary: 1.8, residential: 1.5, living_street: 0, trunk: 0 };
|
|
|
|
function areaKindOf(t: Record<string, string>): AreaKind | null {
|
|
if (t.building) return null;
|
|
if (t.landuse && LANDUSE[t.landuse]) return LANDUSE[t.landuse];
|
|
if (t.natural && NATURAL[t.natural]) return NATURAL[t.natural];
|
|
if (t.waterway === 'riverbank' || t.waterway === 'dock') return 'water';
|
|
if (t.leisure && LEISURE[t.leisure]) return LEISURE[t.leisure];
|
|
if (t.amenity && AMENITY_AREA[t.amenity]) return AMENITY_AREA[t.amenity];
|
|
if (t.place === 'square' || t['area:highway'] || (t.highway === 'pedestrian' && t.area === 'yes')) return 'pedestrian';
|
|
return null;
|
|
}
|
|
|
|
/** Сборка колец мультиполигона из кусков путей. */
|
|
function assembleRings(parts: Vec[][]): Vec[][] {
|
|
const pool = parts.filter((p) => p.length >= 2).map((p) => p.slice());
|
|
const rings: Vec[][] = [];
|
|
const same = (a: Vec, b: Vec) => Math.abs(a[0] - b[0]) < 1e-6 && Math.abs(a[1] - b[1]) < 1e-6;
|
|
while (pool.length) {
|
|
let cur = pool.shift()!;
|
|
let grew = true;
|
|
while (!same(cur[0], cur[cur.length - 1]) && grew) {
|
|
grew = false;
|
|
for (let i = 0; i < pool.length; i++) {
|
|
const p = pool[i];
|
|
const end = cur[cur.length - 1];
|
|
if (same(end, p[0])) cur = cur.concat(p.slice(1));
|
|
else if (same(end, p[p.length - 1])) cur = cur.concat(p.slice(0, -1).reverse());
|
|
else if (same(cur[0], p[p.length - 1])) cur = p.slice(0, -1).concat(cur);
|
|
else if (same(cur[0], p[0])) cur = p.slice(1).reverse().concat(cur);
|
|
else continue;
|
|
pool.splice(i, 1);
|
|
grew = true;
|
|
break;
|
|
}
|
|
}
|
|
if (cur.length >= 4) rings.push(cur);
|
|
}
|
|
return rings;
|
|
}
|
|
|
|
interface Poly {
|
|
outer: Ring;
|
|
holes: Ring[];
|
|
}
|
|
|
|
function polysOfElement(el: OsmElement, proj: Projector): Poly[] {
|
|
if (el.type === 'way' && el.geometry) {
|
|
const g = el.geometry;
|
|
if (g.length < 4) return [];
|
|
const a = g[0], b = g[g.length - 1];
|
|
if (a.lat !== b.lat || a.lon !== b.lon) return [];
|
|
return [{ outer: g.map((p) => proj.toXY(p.lat, p.lon)), holes: [] }];
|
|
}
|
|
if (el.type === 'relation' && el.members) {
|
|
const outers = assembleRings(el.members.filter((m) => m.role !== 'inner' && m.geometry).map((m) => m.geometry!.map((p) => proj.toXY(p.lat, p.lon))));
|
|
const inners = assembleRings(el.members.filter((m) => m.role === 'inner' && m.geometry).map((m) => m.geometry!.map((p) => proj.toXY(p.lat, p.lon))));
|
|
return outers.map((o) => ({ outer: o, holes: inners.filter((h) => pointInRing(h[0], o)) }));
|
|
}
|
|
return [];
|
|
}
|
|
|
|
/** Ориентируем кольца единообразно: внешнее — по часовой (в осях y-вниз), дыры — против. */
|
|
function orient(r: Ring, outer: boolean): Ring {
|
|
const a = signedArea(r);
|
|
return (a > 0) === outer ? r : r.slice().reverse();
|
|
}
|
|
|
|
export function buildCity(elements: OsmElement[], bbox: BBox, name: string, seed: number): { world: World; jobs: InteriorJob[] } {
|
|
const lat0 = (bbox[0] + bbox[2]) / 2, lon0 = (bbox[1] + bbox[3]) / 2;
|
|
const proj = new Projector(lat0, lon0);
|
|
const p0 = proj.toXY(bbox[2], bbox[1]);
|
|
const p1 = proj.toXY(bbox[0], bbox[3]);
|
|
const bounds = { minX: p0[0], minY: p0[1], maxX: p1[0], maxY: p1[1] };
|
|
const inBounds = (p: Vec, m = 0) => p[0] >= bounds.minX - m && p[0] <= bounds.maxX + m && p[1] >= bounds.minY - m && p[1] <= bounds.maxY + m;
|
|
const rng = new Rng(seed);
|
|
|
|
const areas: Area[] = [];
|
|
const roads: Road[] = [];
|
|
const props: Prop[] = [];
|
|
const pois: { p: Vec; tags: Record<string, string> }[] = [];
|
|
const buildingEls: { el: OsmElement; poly: Poly }[] = [];
|
|
|
|
for (const el of elements) {
|
|
const t = el.tags ?? {};
|
|
if (el.type === 'node') {
|
|
if (el.lat == null || el.lon == null) continue;
|
|
const p = proj.toXY(el.lat, el.lon);
|
|
if (!inBounds(p, 5)) continue;
|
|
if (t.natural === 'tree') props.push(treeProp(`t${el.id}`, p, rng, t));
|
|
else if (t.highway === 'street_lamp') props.push({ id: `l${el.id}`, kind: 'lamp', pos: p, rot: 0, w: 0.4, d: 0.4, shapes: [{ t: 'circle', x: 0, y: 0, r: 0.22, s: 'metal' }], blocksMove: true, blocksSight: false });
|
|
else if (t.amenity === 'bench') props.push({ id: `b${el.id}`, kind: 'bench', pos: p, rot: rng.range(0, Math.PI), w: 1.8, d: 0.6, shapes: [{ t: 'rect', x: 0, y: 0, w: 1.8, h: 0.55, s: 'wood' }, { t: 'rect', x: 0, y: -0.22, w: 1.8, h: 0.12, s: 'dark' }], blocksMove: true, blocksSight: false, tags: ['sit'] });
|
|
else if (t.amenity === 'fountain') props.push({ id: `f${el.id}`, kind: 'fountain', pos: p, rot: 0, w: 4, d: 4, shapes: [{ t: 'circle', x: 0, y: 0, r: 2, s: 'base' }, { t: 'circle', x: 0, y: 0, r: 1.7, s: 'water' }], blocksMove: true, blocksSight: false });
|
|
if (t.shop || t.amenity || t.office || t.craft || t.tourism || t.healthcare) pois.push({ p, tags: t });
|
|
continue;
|
|
}
|
|
if (t.building && t.building !== 'no' && t.building !== 'roof' && !t['building:part']) {
|
|
for (const poly of polysOfElement(el, proj)) buildingEls.push({ el, poly });
|
|
continue;
|
|
}
|
|
// Дороги, рельсы, водотоки
|
|
const hw = t.highway, rw = t.railway, ww = t.waterway;
|
|
const isLinear = el.type === 'way' && el.geometry && (hw || rw || ww) && !(t.area === 'yes') && !(ww === 'riverbank');
|
|
if (isLinear && ROAD_WIDTH[hw] !== undefined || (isLinear && (rw || ww))) {
|
|
const pts = el.geometry!.map((g) => proj.toXY(g.lat, g.lon));
|
|
let kind: RoadKind | null = null;
|
|
let width = 0, sidewalk = 0;
|
|
if (hw && ROAD_WIDTH[hw] !== undefined) {
|
|
kind = (['motorway', 'trunk', 'primary', 'secondary', 'tertiary', 'residential', 'unclassified', 'service', 'living_street', 'pedestrian', 'track', 'footway', 'cycleway', 'path', 'steps'] as const).find((k) => hw.startsWith(k)) ?? (hw === 'bridleway' ? 'path' : 'unclassified');
|
|
width = ROAD_WIDTH[hw.replace('_link', '')] ?? 5;
|
|
if (hw.endsWith('_link')) width *= 0.75;
|
|
if (hw === 'service' && (t.service === 'parking_aisle')) width = 5;
|
|
if (hw === 'service' && (t.service === 'driveway')) width = 3;
|
|
const lanes = parseInt(t.lanes);
|
|
if (isFinite(lanes) && lanes > 0 && ROAD_WIDTH[hw] >= 5) width = Math.max(width * 0.6, lanes * 3.2);
|
|
const w = parseFloat(t.width);
|
|
if (isFinite(w) && w > 0.5 && w < 60) width = w;
|
|
sidewalk = SIDEWALK[hw] ?? 0;
|
|
if (t.sidewalk === 'no' || t.sidewalk === 'none' || t.sidewalk === 'separate') sidewalk = 0;
|
|
else if (t.sidewalk && sidewalk === 0 && width >= 5) sidewalk = 1.5;
|
|
} else if (rw) {
|
|
if (rw === 'platform') continue;
|
|
kind = rw === 'tram' ? 'tram' : 'rail';
|
|
width = 1.6;
|
|
} else if (ww) {
|
|
kind = ww === 'river' ? 'river' : ww === 'canal' ? 'canal' : ww === 'stream' ? 'stream' : 'ditch';
|
|
width = { river: 14, canal: 8, stream: 2.5, ditch: 1.2 }[kind as 'river'];
|
|
const w = parseFloat(t.width);
|
|
if (isFinite(w) && w > 0.3 && w < 300) width = w;
|
|
if (t.tunnel === 'culvert') continue;
|
|
}
|
|
if (!kind) continue;
|
|
roads.push({
|
|
id: `r${el.id}`, osmId: `way/${el.id}`, kind, pts, width, sidewalk,
|
|
lanes: parseInt(t.lanes) || 0, oneway: t.oneway === 'yes',
|
|
layer: parseInt(t.layer) || 0, bridge: !!t.bridge && t.bridge !== 'no', tunnel: !!t.tunnel && t.tunnel !== 'no',
|
|
name: t.name,
|
|
});
|
|
continue;
|
|
}
|
|
const ak = areaKindOf(t);
|
|
if (ak) {
|
|
for (const poly of polysOfElement(el, proj)) {
|
|
const bb = bboxOf(poly.outer);
|
|
if (bb[2] < bounds.minX || bb[0] > bounds.maxX || bb[3] < bounds.minY || bb[1] > bounds.maxY) continue;
|
|
areas.push({ id: `a${el.type[0]}${el.id}_${areas.length}`, osmId: `${el.type}/${el.id}`, kind: ak, rings: [orient(cleanRing(poly.outer, 0.01), true), ...poly.holes.map((h) => orient(h, false))], name: t.name });
|
|
}
|
|
}
|
|
if (t.natural === 'tree_row' && el.type === 'way' && el.geometry) {
|
|
const pts = el.geometry.map((g) => proj.toXY(g.lat, g.lon));
|
|
let acc = 0;
|
|
for (let i = 1; i < pts.length; i++) {
|
|
const L = dist(pts[i - 1], pts[i]);
|
|
for (let s = acc; s < L; s += 8) {
|
|
const q: Vec = [pts[i - 1][0] + ((pts[i][0] - pts[i - 1][0]) * s) / L, pts[i - 1][1] + ((pts[i][1] - pts[i - 1][1]) * s) / L];
|
|
if (inBounds(q)) props.push(treeProp(`tr${el.id}_${props.length}`, q, rng, {}));
|
|
}
|
|
acc = (acc - L) % 8;
|
|
if (acc < 0) acc += 8;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Порядок отрисовки зон: крупные подложки → зелень → площадки → вода
|
|
areas.sort((a, b) => AREA_TIER[a.kind] - AREA_TIER[b.kind] || ringArea(b.rings[0]) - ringArea(a.rings[0]));
|
|
|
|
// ---- Индексы для запросов
|
|
const landGrid = new SpatialGrid<Area>(100);
|
|
for (const a of areas) if (AREA_TIER[a.kind] <= 1) landGrid.insert(a, bboxOf(a.rings[0]));
|
|
type Seg = { a: Vec; b: Vec; road: Road };
|
|
const segGrid = new SpatialGrid<Seg>(40);
|
|
for (const r of roads) {
|
|
if (r.tunnel) continue;
|
|
for (let i = 1; i < r.pts.length; i++) {
|
|
const a = r.pts[i - 1], b = r.pts[i];
|
|
const m = r.width / 2 + r.sidewalk + 1;
|
|
segGrid.insert({ a, b, road: r }, [Math.min(a[0], b[0]) - m, Math.min(a[1], b[1]) - m, Math.max(a[0], b[0]) + m, Math.max(a[1], b[1]) + m]);
|
|
}
|
|
}
|
|
const poiGrid = new SpatialGrid<{ p: Vec; tags: Record<string, string> }>(30);
|
|
for (const p of pois) poiGrid.insert(p, [p.p[0], p.p[1], p.p[0], p.p[1]]);
|
|
|
|
// ---- Здания
|
|
const buildings: Building[] = [];
|
|
const bGrid = new SpatialGrid<Building>(40);
|
|
for (const { el, poly } of buildingEls) {
|
|
let outer = cleanRing(poly.outer, 0.08);
|
|
if (outer.length < 3) continue;
|
|
const area = ringArea(outer) - poly.holes.reduce((s, h) => s + ringArea(h), 0);
|
|
if (area < 6 || area > 40000) continue;
|
|
const c = centroid(outer);
|
|
if (!inBounds(c)) continue;
|
|
outer = orient(outer, true);
|
|
const t = el.tags ?? {};
|
|
const id = `b${el.type[0]}${el.id}`;
|
|
const b: Building = {
|
|
id: buildings.some((x) => x.id === id) ? `${id}_${buildings.length}` : id,
|
|
osmId: `${el.type}/${el.id}`,
|
|
kind: 'house', footprint: outer, holes: poly.holes.map((h) => orient(cleanRing(h, 0.08), false)).filter((h) => h.length >= 3),
|
|
area, levels: 1, levelsSource: 'estimate', frame: { origin: [0, 0], angle: minAreaRectAngle(outer) },
|
|
floors: [], units: [], beds: 0, seed: hashString(`${el.type}/${el.id}`) ^ seed,
|
|
name: t.name,
|
|
address: t['addr:street'] ? `${t['addr:street']} ${t['addr:housenumber'] ?? ''}`.trim() : t['addr:housenumber'],
|
|
};
|
|
(b as any)._tags = t;
|
|
buildings.push(b);
|
|
bGrid.insert(b, bboxOf(outer));
|
|
}
|
|
|
|
for (const b of buildings) {
|
|
const t = (b as any)._tags as Record<string, string>;
|
|
const brng = new Rng(b.seed);
|
|
const bb = bboxOf(b.footprint);
|
|
const inside = poiGrid.query(bb).filter((p) => pointInRing(p.p, b.footprint)).map((p) => p.tags);
|
|
const c = centroid(b.footprint);
|
|
let landuse: string | undefined;
|
|
for (const a of landGrid.query([c[0], c[1], c[0], c[1]])) {
|
|
if (AREA_TIER[a.kind] === 0 && pointInRings(c, a.rings)) landuse = a.kind;
|
|
if (a.kind === 'farmyard' && pointInRings(c, a.rings)) landuse = 'farmyard';
|
|
}
|
|
const near = bGrid.query([bb[0] - 15, bb[1] - 15, bb[2] + 15, bb[3] + 15]);
|
|
const nearBigger = near.some((o) => o !== b && o.area > b.area * 2.5 && o.area > 60);
|
|
const cls = classify({ tags: t, pois: inside, area: b.area, landuse, nearBigger }, brng);
|
|
b.kind = cls.kind;
|
|
b.use = cls.use;
|
|
if (!b.name) b.name = inside.find((p) => p.name)?.name;
|
|
const lv = parseLevels(t);
|
|
if (lv) {
|
|
b.levels = lv.levels;
|
|
b.levelsSource = lv.source;
|
|
}
|
|
}
|
|
// Этажность без тегов: медиана соседей с тегами, иначе по виду
|
|
const tagged = buildings.filter((b) => b.levelsSource !== 'estimate');
|
|
const tGrid = new SpatialGrid<Building>(100);
|
|
for (const b of tagged) tGrid.insert(b, bboxOf(b.footprint));
|
|
for (const b of buildings) {
|
|
if (b.levelsSource !== 'estimate') continue;
|
|
const brng = new Rng(b.seed ^ 0x51ed);
|
|
const c = centroid(b.footprint);
|
|
const ns = tGrid.query([c[0] - 120, c[1] - 120, c[0] + 120, c[1] + 120])
|
|
.filter((o) => o.kind === b.kind || (o.kind === 'apartments' && b.kind === 'mixed') || (o.kind === 'mixed' && b.kind === 'apartments'))
|
|
.map((o) => o.levels).sort((x, y) => x - y);
|
|
b.levels = ns.length >= 3 ? clampLevels(b.kind, ns[ns.length >> 1]) : defaultLevels(b.kind, b.area, brng);
|
|
if (b.area < 45) b.levels = Math.min(b.levels, 1);
|
|
}
|
|
for (const b of buildings) delete (b as any)._tags;
|
|
|
|
// ---- Уличные объекты: деревья в лесах/парках, машины на парковках
|
|
const blockedByBuilding = (p: Vec, m: number) =>
|
|
bGrid.query([p[0] - m, p[1] - m, p[0] + m, p[1] + m]).some((b) => pointInRing(p, b.footprint) || distToRing(p, b.footprint) < m);
|
|
const nearRoad = (p: Vec, m: number) =>
|
|
segGrid.query([p[0] - m, p[1] - m, p[0] + m, p[1] + m]).some((s) => distToSegment(p, s.a, s.b) < s.road.width / 2 + s.road.sidewalk + m);
|
|
|
|
let treeBudget = 40000;
|
|
for (const a of areas) {
|
|
const spacing = a.kind === 'forest' ? 6 : a.kind === 'park' ? 14 : a.kind === 'orchard' ? 7 : a.kind === 'cemetery' ? 16 : a.kind === 'scrub' ? 8 : 0;
|
|
if (!spacing) continue;
|
|
const bb = bboxOf(a.rings[0]);
|
|
const x0 = Math.max(bb[0], bounds.minX), x1 = Math.min(bb[2], bounds.maxX);
|
|
const y0 = Math.max(bb[1], bounds.minY), y1 = Math.min(bb[3], bounds.maxY);
|
|
const ar = new Rng(hashString(a.id) ^ seed);
|
|
for (let y = y0; y < y1 && treeBudget > 0; y += spacing)
|
|
for (let x = x0; x < x1 && treeBudget > 0; x += spacing) {
|
|
const p: Vec = [x + ar.range(0, spacing * 0.8), y + ar.range(0, spacing * 0.8)];
|
|
if (a.kind === 'park' && ar.chance(0.35)) continue;
|
|
if (!pointInRings(p, a.rings)) continue;
|
|
if (blockedByBuilding(p, 2) || nearRoad(p, 1.5)) continue;
|
|
props.push(treeProp(`ta${a.id}_${treeBudget}`, p, ar, a.kind === 'scrub' ? { scrub: '1' } : a.kind === 'orchard' ? { orchard: '1' } : {}));
|
|
treeBudget--;
|
|
}
|
|
}
|
|
// Парковки: ряды мест 2.5×5 м с проездами 6 м
|
|
for (const a of areas) {
|
|
if (a.kind !== 'parking') continue;
|
|
const outer = a.rings[0];
|
|
if (ringArea(outer) < 60) continue;
|
|
const ang = minAreaRectAngle(outer);
|
|
const local = outer.map((p) => rotate(p, -ang));
|
|
const lb = bboxOf(local);
|
|
const pr = new Rng(hashString(a.id) ^ seed);
|
|
const fill = pr.range(0.45, 0.85);
|
|
// полоса: ряд машин 5 м, проезд 6 м, ряд 5 м, ...
|
|
let y = lb[1] + 0.5;
|
|
let row = 0;
|
|
while (y + 5 <= lb[3]) {
|
|
for (let x = lb[0] + 0.3; x + 2.5 <= lb[2]; x += 2.5) {
|
|
const corners: Vec[] = [[x, y], [x + 2.5, y], [x + 2.5, y + 5], [x, y + 5]].map((q) => rotate(q as Vec, ang));
|
|
if (!corners.every((q) => pointInRings(q, a.rings))) continue;
|
|
const cc = rotate([x + 1.25, y + 2.5], ang);
|
|
if (!inBounds(cc) || blockedByBuilding(cc, 2)) continue;
|
|
// разметка места рисуем всегда, машину — с вероятностью
|
|
props.push({ id: `ps${a.id}_${props.length}`, kind: 'parking_spot', pos: cc, rot: ang, w: 2.5, d: 5, shapes: [{ t: 'line', x1: -1.25, y1: -2.5, x2: -1.25, y2: 2.5, s: 'line' }, { t: 'line', x1: 1.25, y1: -2.5, x2: 1.25, y2: 2.5, s: 'line' }], blocksMove: false, blocksSight: false });
|
|
if (pr.chance(fill)) {
|
|
const flip = row % 2 === 1 ? Math.PI : 0;
|
|
props.push({ id: `c${a.id}_${props.length}`, kind: 'car', pos: cc, rot: ang + flip + pr.range(-0.04, 0.04), w: 1.8, d: 4.4, shapes: carShapes(), blocksMove: true, blocksSight: false, color: pr.pick(CAR_COLORS), tags: ['vehicle'] });
|
|
}
|
|
}
|
|
y += row % 2 === 0 ? 5 + 6 : 5 + 0.0;
|
|
row++;
|
|
}
|
|
}
|
|
// Машины вдоль жилых улиц (параллельная парковка)
|
|
for (const r of roads) {
|
|
if (!['residential', 'tertiary', 'living_street', 'unclassified'].includes(r.kind) || r.tunnel || r.bridge) continue;
|
|
const rr = new Rng(hashString(r.id) ^ seed);
|
|
if (!rr.chance(0.6)) continue;
|
|
for (let i = 1; i < r.pts.length; i++) {
|
|
const a = r.pts[i - 1], b = r.pts[i];
|
|
const L = dist(a, b);
|
|
if (L < 12) continue;
|
|
const dir: Vec = [(b[0] - a[0]) / L, (b[1] - a[1]) / L];
|
|
const nrm: Vec = [-dir[1], dir[0]];
|
|
for (const side of [1, -1]) {
|
|
for (let s = 6; s < L - 6; s += 6) {
|
|
if (!rr.chance(0.28)) continue;
|
|
const off = r.width / 2 - 1.1;
|
|
const p: Vec = [a[0] + dir[0] * s + nrm[0] * off * side, a[1] + dir[1] * s + nrm[1] * off * side];
|
|
if (!inBounds(p) || blockedByBuilding(p, 1.5)) continue;
|
|
props.push({ id: `cs${r.id}_${props.length}`, kind: 'car', pos: p, rot: Math.atan2(dir[1], dir[0]) + (side > 0 ? Math.PI / 2 : -Math.PI / 2) + rr.range(-0.03, 0.03), w: 1.8, d: 4.4, shapes: carShapes(), blocksMove: true, blocksSight: false, color: rr.pick(CAR_COLORS), tags: ['vehicle'] });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---- Задания на интерьеры: здание + ближайшие дороги
|
|
const jobs: InteriorJob[] = buildings.map((b) => {
|
|
const bb = bboxOf(b.footprint);
|
|
const segs = segGrid.query([bb[0] - 40, bb[1] - 40, bb[2] + 40, bb[3] + 40])
|
|
.filter((s) => !['rail', 'tram', 'river', 'stream', 'canal', 'ditch'].includes(s.road.kind))
|
|
.map((s): [Vec, Vec, number] => [s.a, s.b, s.road.kind === 'footway' || s.road.kind === 'path' || s.road.kind === 'cycleway' ? 0.6 : s.road.kind === 'service' ? 0.8 : 1]);
|
|
return { building: b, roadSegs: segs.slice(0, 200) };
|
|
});
|
|
|
|
const world: World = {
|
|
version: 1,
|
|
id: `w${Date.now().toString(36)}`,
|
|
name,
|
|
createdAt: new Date().toISOString(),
|
|
seed,
|
|
origin: { lat: lat0, lon: lon0 },
|
|
bbox,
|
|
bounds,
|
|
areas,
|
|
roads: roads.filter((r) => r.pts.some((p) => inBounds(p, 200))),
|
|
buildings,
|
|
props: props.filter((p) => inBounds(p.pos, 2)),
|
|
models: {},
|
|
attribution: '© OpenStreetMap contributors (ODbL)',
|
|
};
|
|
return { world, jobs };
|
|
}
|
|
|
|
function distToRing(p: Vec, r: Ring): number {
|
|
let d = Infinity;
|
|
for (let i = 0; i < r.length; i++) d = Math.min(d, distToSegment(p, r[i], r[(i + 1) % r.length]));
|
|
return d;
|
|
}
|