@bendyline/molen-ambient 0.0.12 → 0.0.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -31,7 +31,7 @@ const KIND_SPEED = {
31
31
  function classifyFeature(feature) {
32
32
  const cls = feature.class.toLowerCase();
33
33
  const sub = (feature.subclass ?? "").toLowerCase();
34
- if (cls === "aeroway" || /runway|taxiway|apron/.test(sub)) return sub === "runway" || cls === "runway" ? "runway" : void 0;
34
+ if (/^(aeroway|runway|taxiway|taxilane|parking_position)$/.test(cls) || /^(runway|taxiway|taxilane|apron|parking_position)$/.test(sub)) return sub === "runway" || cls === "runway" ? "runway" : void 0;
35
35
  if (cls === "ferry" || sub === "ferry") return {
36
36
  class: "water",
37
37
  kind: "ferry"
@@ -175,16 +175,38 @@ function roadLanes(feature, width) {
175
175
  if (feature.oneway === true && feature.lanes === void 0) total = dmath.max(1, dmath.min(total, dmath.round(width / 3.3)));
176
176
  return { total: dmath.max(minimum, total) };
177
177
  }
178
- /** Convert a tile's transportation features to clipped world-metre drafts. */
179
- function featureDrafts(input, options) {
178
+ /** Whether a point belongs to a tile part: half-open, so a point on a shared border has one. */
179
+ function inPart(bounds, x, z) {
180
+ return x >= bounds[0] && x < bounds[2] && z >= bounds[1] && z < bounds[3];
181
+ }
182
+ function worldBox(points) {
183
+ const box = [
184
+ Number.POSITIVE_INFINITY,
185
+ Number.POSITIVE_INFINITY,
186
+ Number.NEGATIVE_INFINITY,
187
+ Number.NEGATIVE_INFINITY
188
+ ];
189
+ for (const [x, z] of points) {
190
+ box[0] = dmath.min(box[0], x);
191
+ box[1] = dmath.min(box[1], z);
192
+ box[2] = dmath.max(box[2], x);
193
+ box[3] = dmath.max(box[3], z);
194
+ }
195
+ return box;
196
+ }
197
+ const PART_CELLS = 16;
198
+ /**
199
+ * Joined world lines per features list: a tile registered in parts (AmbientTileInput.bounds)
200
+ * grouped and joined all its lines again for every part, most of a part's drafting time.
201
+ */
202
+ const preparedTiles = /* @__PURE__ */ new WeakMap();
203
+ function prepareTile(input, options) {
180
204
  const { origin, tileSize } = input;
181
- const minX = origin[0];
182
- const minZ = origin[1];
183
- const maxX = origin[0] + tileSize;
184
- const maxZ = origin[1] + tileSize;
185
- const drafts = [];
186
- const runways = [];
205
+ const cached = preparedTiles.get(input.features);
206
+ if (cached !== void 0 && cached.origin[0] === origin[0] && cached.origin[1] === origin[1] && cached.tileSize === tileSize && cached.tunnels === options.tunnels) return cached;
187
207
  const toWorld = (line) => line.map((p) => [origin[0] + p[0] * tileSize, origin[1] + p[1] * tileSize]);
208
+ const features = [];
209
+ const runways = [];
188
210
  for (const feature of groupTransportationFeatures(input.features)) {
189
211
  const classified = classifyFeature(feature);
190
212
  if (classified === void 0) continue;
@@ -202,28 +224,128 @@ function featureDrafts(input, options) {
202
224
  const kind = transportKind(feature);
203
225
  const width = classified.class === "water" ? feature.width ?? 60 : classified.class === "walk" ? dmath.max(1.2, feature.width ?? 2.4) : classified.class === "rail" ? 3 : transportWidth(feature, kind);
204
226
  const lanes = classified.class === "road" ? roadLanes(feature, width).total : 2;
205
- const link = isTransportLink(feature);
206
- for (const line of joinTerrainLines(feature.lines, feature.oneway === true)) for (const piece of clipPolyline(toWorld(line), minX, minZ, maxX, maxZ)) {
207
- const draft = {
208
- class: classified.class,
209
- kind: classified.kind,
210
- points: piece,
211
- width,
212
- lanes,
213
- oneway: feature.oneway === true && (classified.class === "road" || classified.class === "water"),
214
- layer: feature.layer ?? 0,
215
- bridge: feature.bridge === true,
216
- tunnel: feature.tunnel === true,
217
- link,
218
- ...feature.name !== void 0 ? { name: feature.name } : {},
219
- ...feature.deckElevation !== void 0 ? { deckElevation: feature.deckElevation } : {}
220
- };
221
- if (feature.bridgeConnections !== void 0 && feature.bridgeConnections.length > 0) draft.bridgeConnections = feature.bridgeConnections.map((c) => ({
222
- point: [origin[0] + c.point[0] * tileSize, origin[1] + c.point[1] * tileSize],
223
- elevation: c.elevation,
224
- radius: c.radius
225
- }));
226
- drafts.push(draft);
227
+ const draft = {
228
+ class: classified.class,
229
+ kind: classified.kind,
230
+ width,
231
+ lanes,
232
+ oneway: feature.oneway === true && (classified.class === "road" || classified.class === "water"),
233
+ layer: feature.layer ?? 0,
234
+ bridge: feature.bridge === true,
235
+ tunnel: feature.tunnel === true,
236
+ link: isTransportLink(feature),
237
+ ...feature.name !== void 0 ? { name: feature.name } : {},
238
+ ...feature.deckElevation !== void 0 ? { deckElevation: feature.deckElevation } : {}
239
+ };
240
+ if (feature.bridgeConnections !== void 0 && feature.bridgeConnections.length > 0) draft.bridgeConnections = feature.bridgeConnections.map((c) => ({
241
+ point: [origin[0] + c.point[0] * tileSize, origin[1] + c.point[1] * tileSize],
242
+ elevation: c.elevation,
243
+ radius: c.radius
244
+ }));
245
+ if (feature.bridgeApproachProfile?.length) draft.bridgeApproachProfile = feature.bridgeApproachProfile.map((sample) => ({
246
+ ...sample,
247
+ point: [origin[0] + sample.point[0] * tileSize, origin[1] + sample.point[1] * tileSize]
248
+ }));
249
+ features.push({
250
+ draft,
251
+ source: feature
252
+ });
253
+ }
254
+ const prepared = {
255
+ origin,
256
+ tileSize,
257
+ tunnels: options.tunnels,
258
+ features,
259
+ runways
260
+ };
261
+ preparedTiles.set(input.features, prepared);
262
+ return prepared;
263
+ }
264
+ /** World bounds of each of a feature's source lines and of them all (see PreparedFeature). */
265
+ function lineBoxes(feature, origin, tileSize) {
266
+ if (feature.boxes !== void 0) return;
267
+ const source = feature.source.lines;
268
+ const boxes = new Float64Array(source.length * 4);
269
+ const all = [
270
+ Number.POSITIVE_INFINITY,
271
+ Number.POSITIVE_INFINITY,
272
+ Number.NEGATIVE_INFINITY,
273
+ Number.NEGATIVE_INFINITY
274
+ ];
275
+ source.forEach((line, i) => {
276
+ const box = worldBox(line);
277
+ boxes[i * 4] = origin[0] + box[0] * tileSize;
278
+ boxes[i * 4 + 1] = origin[1] + box[1] * tileSize;
279
+ boxes[i * 4 + 2] = origin[0] + box[2] * tileSize;
280
+ boxes[i * 4 + 3] = origin[1] + box[3] * tileSize;
281
+ all[0] = dmath.min(all[0], boxes[i * 4]);
282
+ all[1] = dmath.min(all[1], boxes[i * 4 + 1]);
283
+ all[2] = dmath.max(all[2], boxes[i * 4 + 2]);
284
+ all[3] = dmath.max(all[3], boxes[i * 4 + 3]);
285
+ });
286
+ feature.boxes = boxes;
287
+ feature.box = all;
288
+ }
289
+ /**
290
+ * The prepared features whose boxes may reach a part, in their order (every one for a whole
291
+ * tile), boxes made. Each still checks its own box against the part.
292
+ */
293
+ function partFeatures(prepared, origin, tileSize, bounds) {
294
+ const cell = (value, start) => dmath.clamp(dmath.floor((value - start) / tileSize * PART_CELLS), 0, PART_CELLS - 1);
295
+ if (bounds === void 0) {
296
+ for (const feature of prepared.features) lineBoxes(feature, origin, tileSize);
297
+ return prepared.features;
298
+ }
299
+ let cells = prepared.cells;
300
+ if (cells === void 0) {
301
+ const made = Array.from({ length: PART_CELLS * PART_CELLS }, () => []);
302
+ prepared.features.forEach((feature, index) => {
303
+ lineBoxes(feature, origin, tileSize);
304
+ const [x0, z0, x1, z1] = feature.box;
305
+ for (let row = cell(z0, origin[1]); row <= cell(z1, origin[1]); row++) for (let col = cell(x0, origin[0]); col <= cell(x1, origin[0]); col++) made[row * PART_CELLS + col].push(index);
306
+ });
307
+ prepared.cells = made;
308
+ cells = made;
309
+ }
310
+ const picked = /* @__PURE__ */ new Set();
311
+ for (let row = cell(bounds[1], origin[1]); row <= cell(bounds[3], origin[1]); row++) for (let col = cell(bounds[0], origin[0]); col <= cell(bounds[2], origin[0]); col++) for (const index of cells[row * PART_CELLS + col]) picked.add(index);
312
+ return [...picked].sort((a, b) => a - b).map((index) => prepared.features[index]);
313
+ }
314
+ /** Convert a tile's transportation features to clipped world-metre drafts. */
315
+ function featureDrafts(input, options) {
316
+ const { origin, tileSize, bounds } = input;
317
+ const minX = bounds?.[0] ?? origin[0];
318
+ const minZ = bounds?.[1] ?? origin[1];
319
+ const maxX = bounds?.[2] ?? origin[0] + tileSize;
320
+ const maxZ = bounds?.[3] ?? origin[1] + tileSize;
321
+ const prepared = prepareTile(input, options);
322
+ const drafts = [];
323
+ const runways = prepared.runways.filter(({ a, b }) => !bounds || inPart(bounds, (a[0] + b[0]) / 2, (a[1] + b[1]) / 2)).map(({ a, b }) => ({
324
+ a: [a[0], a[1]],
325
+ b: [b[0], b[1]]
326
+ }));
327
+ for (const feature of partFeatures(prepared, origin, tileSize, bounds)) {
328
+ const source = feature.source.lines;
329
+ const reach = feature.box;
330
+ if (reach[2] < minX || reach[0] > maxX || reach[3] < minZ || reach[1] > maxZ) continue;
331
+ const boxes = feature.boxes;
332
+ const reaching = source.filter((_, i) => !(boxes[i * 4 + 2] < minX || boxes[i * 4] > maxX || boxes[i * 4 + 3] < minZ || boxes[i * 4 + 1] > maxZ));
333
+ if (!reaching.length) continue;
334
+ const draft = feature.draft;
335
+ for (const line of joinTerrainLines(reaching, feature.source.oneway === true)) {
336
+ const points = line.map((p) => [origin[0] + p[0] * tileSize, origin[1] + p[1] * tileSize]);
337
+ for (const piece of clipPolyline(points, minX, minZ, maxX, maxZ)) drafts.push({
338
+ ...draft,
339
+ points: piece.map((p) => [p[0], p[1]]),
340
+ ...draft.bridgeConnections !== void 0 ? { bridgeConnections: draft.bridgeConnections.map((c) => ({
341
+ ...c,
342
+ point: [c.point[0], c.point[1]]
343
+ })) } : {},
344
+ ...draft.bridgeApproachProfile !== void 0 ? { bridgeApproachProfile: draft.bridgeApproachProfile.map((sample) => ({
345
+ ...sample,
346
+ point: [sample.point[0], sample.point[1]]
347
+ })) } : {}
348
+ });
227
349
  }
228
350
  }
229
351
  return {
@@ -243,28 +365,45 @@ const POI_KINDS = new Set([
243
365
  "aerodrome"
244
366
  ]);
245
367
  /** Convert a tile's POIs to world points (only those inside the tile). */
246
- function tilePois(pois, origin, tileSize) {
247
- const result = [];
248
- for (const poi of pois ?? []) {
249
- const kind = (poi.subclass ?? poi.class).toLowerCase();
250
- const matched = POI_KINDS.has(kind) ? kind : POI_KINDS.has(poi.class) ? poi.class : void 0;
251
- if (matched === void 0) continue;
252
- if ([
253
- "traffic_signals",
254
- "stop",
255
- "give_way"
256
- ].includes(matched) && (poi.bridge || poi.tunnel)) continue;
257
- const [u, v] = poi.point;
258
- if (u < 0 || u > 1 || v < 0 || v > 1) continue;
259
- result.push({
260
- kind: matched === "stop" ? "give_way" : matched,
261
- x: origin[0] + u * tileSize,
262
- z: origin[1] + v * tileSize,
263
- ...poi.name !== void 0 ? { name: poi.name } : {},
264
- ...poi.stop === "all" ? { allWay: true } : {},
265
- layer: poi.layer ?? 0
266
- });
368
+ /**
369
+ * A tile's POIs matched and placed once: a tile registered in parts read and matched every one of
370
+ * them again for each part.
371
+ */
372
+ const placedPois = /* @__PURE__ */ new WeakMap();
373
+ function tilePois(pois, origin, tileSize, bounds) {
374
+ if (pois === void 0) return [];
375
+ let placed = placedPois.get(pois);
376
+ if (placed === void 0 || placed.origin[0] !== origin[0] || placed.origin[1] !== origin[1] || placed.tileSize !== tileSize) {
377
+ const all = [];
378
+ for (const poi of pois) {
379
+ const kind = (poi.subclass ?? poi.class).toLowerCase();
380
+ const matched = POI_KINDS.has(kind) ? kind : POI_KINDS.has(poi.class) ? poi.class : void 0;
381
+ if (matched === void 0) continue;
382
+ if ([
383
+ "traffic_signals",
384
+ "stop",
385
+ "give_way"
386
+ ].includes(matched) && (poi.bridge || poi.tunnel)) continue;
387
+ const [u, v] = poi.point;
388
+ if (u < 0 || u > 1 || v < 0 || v > 1) continue;
389
+ all.push({
390
+ kind: matched === "stop" ? "give_way" : matched,
391
+ x: origin[0] + u * tileSize,
392
+ z: origin[1] + v * tileSize,
393
+ ...poi.name !== void 0 ? { name: poi.name } : {},
394
+ ...poi.stop === "all" ? { allWay: true } : {},
395
+ layer: poi.layer ?? 0
396
+ });
397
+ }
398
+ placed = {
399
+ origin: [origin[0], origin[1]],
400
+ tileSize,
401
+ pois: all
402
+ };
403
+ placedPois.set(pois, placed);
267
404
  }
405
+ const result = [];
406
+ for (const poi of placed.pois) if (!bounds || inPart(bounds, poi.x, poi.z)) result.push({ ...poi });
268
407
  return result;
269
408
  }
270
409
  //#endregion
@@ -446,6 +585,7 @@ const ambientAgentSchema = z.strictObject({
446
585
  lane: z.string().describe("Lane id the agent is on (\"\" for aircraft)."),
447
586
  s: num.describe("Metres along the lane; negative while on the connector into it."),
448
587
  speed: num.nonnegative().describe("Speed along the lane in m/s."),
588
+ boosted: z.boolean().optional().describe("Lane speed includes the 4× travel boost."),
449
589
  cruise: num.positive().describe("Vessel cruise limit in m/s.").optional(),
450
590
  prev: z.string().describe("Previous lane (its connector leads onto `lane`).").optional(),
451
591
  next: z.string().describe("Chosen next lane.").optional(),
package/dist/kernel.d.mts CHANGED
@@ -1,4 +1,4 @@
1
- import { a as WildlifeWorld, c as WILDLIFE_FAMILIES, d as WildlifeHabitat, f as WildlifeMotion, i as WildlifeBudget, l as WildlifeChoice, m as wildlifeSpeciesSchema, n as WILDLIFE_TICK_RATE, o as stepWildlife, p as WildlifeSpecies, r as WildlifeAgent, s as wildlifeCandidates, t as WILDLIFE_CELL_METERS, u as WildlifeFamily } from "./wildlife-B4EL0z-N.mjs";
1
+ import { a as WildlifeWorld, c as WILDLIFE_FAMILIES, d as WildlifeHabitat, f as WildlifeMotion, i as WildlifeBudget, l as WildlifeChoice, m as wildlifeSpeciesSchema, n as WILDLIFE_TICK_RATE, o as stepWildlife, p as WildlifeSpecies, r as WildlifeAgent, s as wildlifeCandidates, t as WILDLIFE_CELL_METERS, u as WildlifeFamily } from "./wildlife-CvHzzI9m.mjs";
2
2
  import { Quat } from "@bendyline/molen-kernel/determinism";
3
3
  import { ComponentType, JsonObject, World } from "@bendyline/molen-kernel/world";
4
4
  import { ComponentMap, EntityId, SceneManifest } from "@bendyline/molen-schema";
@@ -20,6 +20,8 @@ interface AmbientAirCorridor extends JsonObject {
20
20
  length: number;
21
21
  }
22
22
  interface AmbientAgentData extends JsonObject {
23
+ /** Kernel-owned: the lane speed includes the world's 4× travel boost. */
24
+ boosted?: boolean;
23
25
  kind: AmbientKind;
24
26
  type: string;
25
27
  color?: string;
@@ -365,6 +367,11 @@ interface EdgeDraft {
365
367
  elevation: number;
366
368
  radius: number;
367
369
  }[];
370
+ bridgeApproachProfile?: {
371
+ point: Point2;
372
+ elevation: number;
373
+ flatness: number;
374
+ }[];
368
375
  }
369
376
  /** Design speeds in m/s by kind. */
370
377
  declare const KIND_SPEED: Readonly<Record<RoadKind, number>>;
@@ -386,6 +393,8 @@ interface TileDraftInput {
386
393
  origin: readonly [number, number];
387
394
  tileSize: number;
388
395
  features: readonly TerrainTransportationFeature[];
396
+ /** World X/Z part of the tile to keep (see AmbientTileInput.bounds); default the whole tile. */
397
+ bounds?: readonly [number, number, number, number];
389
398
  }
390
399
  interface TileDrafts {
391
400
  drafts: EdgeDraft[];
@@ -492,6 +501,12 @@ declare function pseudoAngle(dx: number, dz: number): number;
492
501
  declare const GRID_CELL = 64;
493
502
  interface EdgeSpan {
494
503
  readonly edge: string;
504
+ /**
505
+ * The edge itself and its lanes of each class, as inserted: a spawner weighs every span within
506
+ * reach, and looking both up by id for each was most of a run's few milliseconds.
507
+ */
508
+ readonly ref: TransportEdge;
509
+ readonly lanes: Readonly<Record<TransportClass, number>>;
495
510
  /** Edge-path distances bounding the span. */
496
511
  readonly d0: number;
497
512
  readonly d1: number;
@@ -500,13 +515,26 @@ interface EdgeSpan {
500
515
  readonly z: number;
501
516
  }
502
517
  declare class LaneGrid {
503
- private readonly cells;
518
+ /** Rows by cell z, then cells by cell x: integer keys, no string per probed cell. */
519
+ private readonly rows;
520
+ private cellCount;
504
521
  private readonly edgeCells;
505
522
  /** Bumped on every change; lets callers cache derived sums. */
506
523
  version: number;
507
524
  insert(edge: TransportEdge, laneCounts: Readonly<Record<TransportClass, number>>): void;
508
525
  remove(edgeId: string): void;
509
- /** Visit cells overlapping the disc of radius `r`, in a deterministic order. */
526
+ /**
527
+ * Remove edges together, each touched cell's spans filtered once: a tile's edges share its
528
+ * cells, and filtering a dense city cell again for each of its edges held a frame 5 ms as the
529
+ * tile left.
530
+ */
531
+ removeAll(edgeIds: Iterable<string>): void;
532
+ /**
533
+ * Cells overlapping the disc of radius `r`, in row-major order (z, then x, ascending). A train
534
+ * or boat ring spans thousands of mostly empty cells: probing each one cost a fast flight
535
+ * several milliseconds per spawner run, so a disc larger than the populated grid walks the
536
+ * populated cells instead and sorts the matches into the same order.
537
+ */
510
538
  private cellsNear;
511
539
  /** Lane-metres of a class in cells overlapping the disc. */
512
540
  laneMeters(x: number, z: number, r: number, cls: TransportClass): number;
@@ -534,6 +562,12 @@ interface AmbientTileInput {
534
562
  heightAt?: (x: number, z: number) => number;
535
563
  /** Infer sidewalks along streets without mapped footways (default true). */
536
564
  sidewalks?: boolean;
565
+ /**
566
+ * Build only this world X/Z part of the tile, [minX, minZ, maxX, maxZ] (default: all of it).
567
+ * A large tile registered as parts, each under its own key, costs a tick a part instead of
568
+ * one long tick; edges stitch across part borders as across tile borders.
569
+ */
570
+ bounds?: readonly [number, number, number, number];
537
571
  }
538
572
  interface TransportNetworkOptions {
539
573
  traffic?: "right" | "left";
@@ -572,12 +606,19 @@ declare class TransportNetwork implements GraphStore {
572
606
  readonly grid: LaneGrid;
573
607
  private readonly tunnels;
574
608
  private readonly ground;
609
+ private readonly gradedTiles;
575
610
  private classes;
576
611
  private readonly nodes;
577
612
  private readonly edges;
578
613
  private readonly lanes;
614
+ /** Each edge's lane count per class (see lanesOfClass), kept with its lanes. */
615
+ private readonly classLanes;
579
616
  private readonly junctions;
580
617
  private readonly tiles;
618
+ /**
619
+ * Border nodes by class and layer, then by rounded position (see borderCell): stitching probes
620
+ * the 25 positions around each new border node, and a string key for each was most of it.
621
+ */
581
622
  private readonly borders;
582
623
  private readonly crossings;
583
624
  private readonly crossingsByEdge;
@@ -596,6 +637,11 @@ declare class TransportNetwork implements GraphStore {
596
637
  node(id: string): TransportNode | undefined;
597
638
  edge(id: string): TransportEdge | undefined;
598
639
  lane(id: string): TransportLane | undefined;
640
+ /**
641
+ * How many of an edge's lanes are of `cls`. A city's spawn ring is tens of thousands of spans,
642
+ * and looking up every lane of each one held a spawning tick near 10 ms.
643
+ */
644
+ lanesOfClass(edgeId: string, cls: TransportClass): number;
599
645
  junction(id: string): TransportJunction | undefined;
600
646
  setJunction(junction: TransportJunction): void;
601
647
  deleteJunction(id: string): void;
@@ -643,6 +689,8 @@ declare class TransportNetwork implements GraphStore {
643
689
  s: number;
644
690
  distance: number;
645
691
  } | undefined;
692
+ /** The network's sizes, without the walks `stats()` makes. */
693
+ sizes(): Pick<TransportNetworkStats, "tiles" | "nodes" | "edges" | "lanes" | "junctions">;
646
694
  stats(): TransportNetworkStats;
647
695
  /** Drop everything. */
648
696
  clear(): void;
@@ -658,6 +706,8 @@ interface AmbientSolid {
658
706
  radius: number;
659
707
  }
660
708
  interface AgentEnv {
709
+ /** Internal scale resolved from the world's boost setting by stepAgents. */
710
+ speedScale?: number;
661
711
  net: TransportNetwork;
662
712
  policy: AmbientPolicy;
663
713
  tick: number;
@@ -673,7 +723,7 @@ declare function agentSample(net: TransportNetwork, agent: Readonly<AmbientAgent
673
723
  /** Rotation for an agent facing along a sample (with pitch unless flat). */
674
724
  declare function agentRotation(sample: LaneSample, pitch: boolean): Quat;
675
725
  /** Advance every ambient agent one tick. */
676
- declare function stepAgents(world: World, env: AgentEnv): void;
726
+ declare function stepAgents(world: World, environment: AgentEnv): void;
677
727
  /** Step back `distance` metres from a lane position along the lead's trail. */
678
728
  declare function walkBack(net: TransportNetwork, laneId: string, s: number, prev: string | undefined, trail: readonly string[], distance: number): {
679
729
  lane: string;
@@ -754,6 +804,18 @@ interface AmbientOptions {
754
804
  seed?: string | number;
755
805
  /** Cars yield to vehicles someone is driving (`mounted` riders); default true. */
756
806
  yieldToDriven?: boolean;
807
+ /**
808
+ * Tile registrations a tick applies, in queue order (removals are not counted); default all.
809
+ * A dense tile's network takes tens of milliseconds to build, so a host streaming many tiles
810
+ * (or one tile in parts, see AmbientTileInput.bounds) passes 1 to keep each tick short.
811
+ */
812
+ registrationsPerTick?: number;
813
+ /**
814
+ * Tile removals a tick applies, in queue order; default all. A tile streamed in parts leaves
815
+ * all at once, and removing every part (rebuilding the junctions they were stitched to) in one
816
+ * tick held it 10 ms.
817
+ */
818
+ removalsPerTick?: number;
757
819
  }
758
820
  interface AmbientStats {
759
821
  network: TransportNetworkStats;
@@ -774,7 +836,7 @@ interface AmbientBox {
774
836
  interface AmbientHandle {
775
837
  readonly world: World;
776
838
  readonly network: TransportNetwork;
777
- /** Queue a streamed tile (applied at the next tick, or by `flush()`). */
839
+ /** Queue a streamed tile (applied at a coming tick, see registrationsPerTick, or by `flush()`). */
778
840
  registerTile(tile: AmbientTileInput): void;
779
841
  unregisterTile(key: string): void;
780
842
  /** Apply queued tile changes now (outside a tick). */