`@bendyline/molen-ambient/kernel`

laneCounts

Readonly<Record<TransportClass, number>>

Returns

void

laneMeters()

laneMeters(
   x, 
   z, 
   r, 
   cls
): number;

Lane-metres of a class in cells overlapping the disc.

Parameters

x

number

z

number

r

number

cls

TransportNetworkOptions

Returns

number

remove()

remove(edgeId): void;

Parameters

edgeId

string

Returns

void

spansWithin()

spansWithin(
   x, 
   z, 
   rMin, 
   rMax
): EdgeSpan[];

Spans whose midpoint lies in the annulus [rMin, rMax].

Parameters

x

number

z

number

rMin

number

rMax

number

Returns

EdgeSpan[]

TransportNetwork

Implements

GraphStore

Constructors

Constructor

new TransportNetwork(options?): TransportNetwork;

Parameters

options?

Returns

TransportNetwork

Properties

grid

readonly grid: LaneGrid;

traffic

readonly traffic: "right" | "left";

Implementation of

GraphStore.traffic

version

version: number;

Bumped whenever lanes appear, disappear or change.

Methods

addDocument()

addDocument(doc): void;

Add a transport-network document's ways, stations, signals and aerodromes.

Parameters

doc

TransportNetworkDocument

Returns

void

addPolyline()

addPolyline(line): string | undefined;

Add one polyline (scripts); returns the id of the first edge it produced, if any.

Parameters

line

AmbientPolyline

Returns

string | undefined

aerodromes()

aerodromes(): WorldPoi[];

Aerodrome POIs (and runway midpoints) across registered tiles.

Returns

WorldPoi[]

builds()

builds(cls): boolean;

Whether a lane class is being built.

Parameters

cls

Returns

boolean

clear()

clear(): void;

Drop everything.

Returns

void

crossingsOf()

crossingsOf(edgeId): readonly TransportCrossing[];

Parameters

edgeId

string

Returns

readonly TransportCrossing[]

deleteJunction()

deleteJunction(id): void;

Parameters

id

string

Returns

void

Implementation of

GraphStore.deleteJunction

edge()

edge(id): TransportEdge | undefined;

Parameters

id

string

Returns

TransportEdge | undefined

Implementation of

GraphStore.edge

edgeList()

edgeList(): IterableIterator<TransportEdge>;

Every edge, for export (networkToDocument).

Returns

IterableIterator<TransportEdge>

giveWayNear()

giveWayNear(
   x, 
   z, 
   radius
): readonly WorldPoi[];

Stop and yield signs within radius of a point.

Parameters

x

number

z

number

radius

number

Returns

readonly WorldPoi[]

Implementation of

GraphStore.giveWayNear

hasTile()

hasTile(key): boolean;

Whether a tile key is registered.

Parameters

key

string

Returns

boolean

junction()

junction(id): TransportJunction | undefined;

Parameters

id

string

Returns

TransportJunction | undefined

Implementation of

GraphStore.junction

junctionList()

junctionList(): IterableIterator<TransportJunction>;

Returns

IterableIterator<TransportJunction>

lane()

lane(id): TransportLane | undefined;

Parameters

id

string

Returns

TransportLane | undefined

Implementation of

GraphStore.lane

laneAt()

laneAt(
   x, 
   z, 
   opts?
): 
  | {
  distance: number;
  lane: string;
  s: number;
}
  | undefined;

The nearest lane of a class to a point, with the lane coordinate of the closest point.

Parameters

x

number

z

number

opts?

class?

radius?

number

Returns

| { distance: number; lane: string; s: number; } | undefined

laneIds()

laneIds(): IterableIterator<string>;

Every lane id (registration order).

Returns

IterableIterator<string>

movement()

movement(from, to): LaneMovement | undefined;

The movement from from onto to, if one exists.

Parameters

from

string | undefined

to

string

Returns

LaneMovement | undefined

node()

node(id): TransportNode | undefined;

Parameters

id

string

Returns

TransportNode | undefined

Implementation of

GraphStore.node

registerTile()

registerTile(input): void;

Build and add one map tile (replacing a previous registration under the same key).

Parameters

input

AmbientTileInput

Returns

void

runways()

runways(): TransportRunway[];

Returns

TransportRunway[]

sampleLane()

sampleLane(
   laneId, 
   s, 
   out?
): LaneSample | undefined;

Sample a lane body at s (clamped to the lane).

Parameters

laneId

string

s

number

out?

Returns

LaneSample | undefined

setClasses()

setClasses(classes): void;

Change which lane classes are built (applies to tiles registered afterwards).

Parameters

classes

readonly TransportClass[]

Returns

void

setJunction()

setJunction(junction): void;

Parameters

junction

AmbientOptions.ground

Returns

void

Implementation of

GraphStore.setJunction

signalNear()

signalNear(
   x, 
   z, 
   radius
): boolean;

Whether a mapped traffic-signal point lies within radius of a point.

Parameters

x

number

z

number

radius

number

Returns

boolean

Implementation of

GraphStore.signalNear

stats()

stats(): TransportNetworkStats;

Returns

TransportNetworkStats

tileKeys()

tileKeys(): string[];

Returns

string[]

unregisterTile()

unregisterTile(key): void;

Remove a tile: its edges, lanes and nodes; stitched neighbours become open ends again.

Parameters

key

string

Returns

void

Interfaces

AgentEnv

Properties

dt

dt: number;

net

net: TransportNetwork;

policy

policy: AmbientPolicy;

solids

solids: readonly AmbientSolid[];

Solids cars yield to (queried from the world by the caller).

tick

tick: number;

tickRate

tickRate: number;

AmbientAgentData

Extends

JsonObject

Indexable

[key: string]: JsonValue | undefined

Properties

air?

optional air?: AmbientAirCorridor;

carIndex?

optional carIndex?: number;

color?

optional color?: string;

consist?

optional consist?: string;

hidden?

optional hidden?: boolean;

hops

hops: number;

kind

kind: AmbientKind;

lane

lane: string;

length

length: number;

next?

optional next?: string;

prev?

optional prev?: string;

s

s: number;

seed

seed: number;

served?

optional served?: string;

since

since: number;

spawnedTick

spawnedTick: number;

speed

speed: number;

state

state: "move" | "wait" | "dwell" | "idle";

trail?

optional trail?: string[];

type

type: string;

width

width: number;

AmbientAirCorridor

An aircraft corridor: a straight line flown at linearly varying altitude.

Extends

JsonObject

Indexable

[key: string]: JsonValue | undefined

Properties

dx

dx: number;

dz

dz: number;

length

length: number;

x

x: number;

y0

y0: number;

y1

y1: number;

z

z: number;

AmbientBox

An oriented box on the ground (for host collision queries).

Properties

center

center: readonly [number, number, number];

halfSize

halfSize: readonly [number, number, number];

Half extents: x across, y up, z along.

yaw

yaw: number;

Yaw about +Y (0 = +Z forward).

AmbientBudget

Scale the rings and caps for a density factor and caps from a host budget.

Properties

aircraft?

optional aircraft?: number;

cars?

optional cars?: number;

pedestrianRadius?

optional pedestrianRadius?: number;

Outer spawn radius for pedestrians.

pedestrians?

optional pedestrians?: number;

radius?

optional radius?: number;

Outer spawn radius for cars; trains keep their ratio to it.

trains?

optional trains?: number;

AmbientCapabilityOptions

Extends

Omit<AmbientOptions, "classes" | "seed" | "traffic">

Properties

ground?

optional ground?: (x, z) => number;

Ground height for documents, aircraft and tiles without their own sampler (default 0).

Parameters

x

number

z

number

Returns

number

Inherited from

networks?

optional networks?: Readonly<Record<string, TransportNetworkDocument>>;

Networks for ambient.network paths, keyed by the path as written in the scene.

policy?

optional policy?: DeepPartial<AmbientPolicy>;

Policy overrides (rings, densities, caps, driver parameters).

Inherited from

AmbientOptions.policy

templates?

optional templates?: Partial<Record<AmbientKind, AmbientTemplate | null>>;

Extra components per class; null spawns bare agents (ambientAgent + transform only).

Inherited from

AmbientOptions.templates

tunnels?

optional tunnels?: "hidden" | "skip";

Tunnels: keep them with hidden agents (default) or drop them.

Inherited from

AmbientOptions.tunnels

types?

optional types?: Partial<AmbientTypes>;

Vehicle and pedestrian types per class (default: proxy dimensions).

Inherited from

AmbientOptions.types

yieldToDriven?

optional yieldToDriven?: boolean;

Cars yield to vehicles someone is driving (mounted riders); default true.

Inherited from

AmbientOptions.yieldToDriven

AmbientClassPolicy

Properties

enabled

enabled: boolean;

far

far: number;

Spawn out to this distance (metres).

keep

keep: number;

Remove beyond this distance (metres).

max

max: number;

Hard cap on live agents of the class (consists for trains).

near

near: number;

Never spawn closer than this (metres).

perLaneKm

perLaneKm: number;

Target agents per kilometre of lane within far.

AmbientHandle

Properties

network

readonly network: TransportNetwork;

world

readonly world: World;

Methods

addDocument()

addDocument(doc): void;

Parameters

doc

TransportNetworkDocument

Returns

void

addPolyline()

addPolyline(line): void;

Parameters

line

AmbientPolyline

Returns

void

agentsNear()

agentsNear(
   x, 
   z, 
   radius, 
   kind?
): string[];

Parameters

x

number

z

number

radius

number

kind?

AmbientKind

Returns

string[]

blocks()

blocks(box, except?): boolean;

Whether an ambient car overlaps a box (for a host vehicle solver's canOccupy).

Parameters

box

AmbientBox

except?

string

Returns

boolean

despawnAll()

despawnAll(kind?): void;

Parameters

kind?

AmbientKind

Returns

void

dispose()

dispose(): void;

Returns

void

flush()

flush(): void;

Apply queued tile changes now (outside a tick).

Returns

void

laneAt()

laneAt(
   x, 
   z, 
   opts?
): 
  | {
  distance: number;
  lane: string;
  s: number;
}
  | undefined;

Parameters

x

number

z

number

opts?

class?

radius?

number

Returns

| { distance: number; lane: string; s: number; } | undefined

laneSample()

laneSample(lane, s): LaneSample | undefined;

Parameters

lane

string

s

number

Returns

LaneSample | undefined

policy()

policy(): AmbientPolicy;

Returns

DeepPartial<AmbientPolicy>

registerTile()

registerTile(tile): void;

Queue a streamed tile (applied at the next tick, or by flush()).

Parameters

tile

AmbientTileInput

Returns

void

setBudget()

setBudget(budget): void;

Host budget: caps and ring size (not recorded; hosts reapply after a restore).

Parameters

budget

AmbientBudget

Returns

void

setObserver()

setObserver(observer): void;

Parameters

observer

| { forward?: readonly [number, number]; pos: readonly [number, number, number]; } | { entity: string; } | null

Returns

void

setPolicy()

setPolicy(policy): void;

Persistent policy overrides (recorded in world state).

Parameters

policy

Returns

void

setSolids()

setSolids(solids): void;

Extra solids cars yield to (e.g. the walking player).

Parameters

solids

readonly AmbientSolid[]

Returns

void

stats()

stats(): AmbientStats;

Returns

AmbientStats

unregisterTile()

unregisterTile(key): void;

Parameters

key

string

Returns

void

AmbientObserverData

Extends

JsonObject

Indexable

[key: string]: JsonValue | undefined

Properties

density?

optional density?: number;

despawnRadius?

optional despawnRadius?: number;

radius?

optional radius?: number;

AmbientObserverState

Extends

JsonObject

Indexable

[key: string]: JsonValue | undefined

Properties

entity?

optional entity?: string;

forward?

optional forward?: [number, number];

pos?

optional pos?: [number, number, number];

setAtTick

setAtTick: number;

AmbientOptions

Properties

classes?

optional classes?: readonly AmbientKind[];

Which classes run (default ['car']).

ground?

optional ground?: (x, z) => number;

Ground height for documents, aircraft and tiles without their own sampler (default 0).

Parameters

x

number

z

number

Returns

number

policy?

optional policy?: DeepPartial<AmbientPolicy>;

Policy overrides (rings, densities, caps, driver parameters).

seed?

optional seed?: string | number;

Seed for spawn draws (default: 'ambient').

templates?

optional templates?: Partial<Record<AmbientKind, AmbientTemplate | null>>;

Extra components per class; null spawns bare agents (ambientAgent + transform only).

traffic?

optional traffic?: "right" | "left";

Which side of the road traffic keeps to (default 'right').

tunnels?

optional tunnels?: "hidden" | "skip";

Tunnels: keep them with hidden agents (default) or drop them.

types?

optional types?: Partial<AmbientTypes>;

Vehicle and pedestrian types per class (default: proxy dimensions).

yieldToDriven?

optional yieldToDriven?: boolean;

Cars yield to vehicles someone is driving (mounted riders); default true.

AmbientPedestrianType

Properties

preset

preset: "human.adult" | "human.elder" | "human.child";

weight?

optional weight?: number;

AmbientPolicy

Properties

aircraft

aircraft: AmbientClassPolicy;

car

car: AmbientClassPolicy;

deadlockSeconds

deadlockSeconds: number;

Seconds after which a junction deadlock is broken.

driver

driver: DriverParams;

forwardConeCos

forwardConeCos: number;

Cosine of the half-angle of the view cone spawns avoid near the observer.

forwardConeReach

forwardConeReach: number;

How far ahead (m) the view cone stays free of spawns; beyond it agents fade in.

pedestrian

pedestrian: AmbientClassPolicy;

rail

rail: DriverParams;

spawnBudget

spawnBudget: number;

Spawns per spawner run, across classes.

spawnEveryTicks

spawnEveryTicks: number;

Run the spawner every N ticks.

stuckSeconds

stuckSeconds: number;

Seconds a stuck agent waits before it is removed (out of sight only).

train

train: AmbientClassPolicy;

AmbientPolyline

A script-added polyline.

Properties

class

class: "rail" | "road" | "path";

lanes?

optional lanes?: number;

layer?

optional layer?: number;

oneway?

optional oneway?: boolean;

points

points: ([number, number, number] | [number, number])[];

[x, z] or [x, y, z] points in scene metres.

speed?

optional speed?: number;

subclass?

optional subclass?: string;

width?

optional width?: number;

AmbientRoleData

Extends

JsonObject

Indexable

[key: string]: JsonValue | undefined

Properties

cars?

optional cars?: number;

colors?

optional colors?: string[];

cruise?

optional cruise?: number;

height?

optional height?: number;

length?

optional length?: number;

max?

optional max?: number;

role

role: "car" | "aircraft" | "rail" | "bus";

visual?

optional visual?: AmbientRoleVisual;

weight?

optional weight?: number;

width?

optional width?: number;

AmbientRoleVisual

Extends

JsonObject

Indexable

[key: string]: JsonValue | undefined

Properties

frontWheelNodes?

optional frontWheelNodes?: string[];

gearNodes?

optional gearNodes?: string[];

paintMaterial?

optional paintMaterial?: string;

rotors?

optional rotors?: string[];

wheelbase?

optional wheelbase?: number;

wheelNodes?

optional wheelNodes?: string[];

wheelRadius?

optional wheelRadius?: number;

AmbientSolid

A solid thing agents must not drive into (the player's car, a parked aircraft).

Properties

radius

radius: number;

x

x: number;

z

z: number;

AmbientSpawnInfo

The details a template sees when an agent spawns.

Properties

color?

optional color?: string;

id

id: string;

kind

kind: AmbientKind;

seed

seed: number;

type

type: string;

AmbientStateData

Extends

JsonObject

Indexable

[key: string]: JsonValue | undefined

Properties

despawned

despawned: number;

nextSeq

nextSeq: number;

observer?

optional observer?: AmbientObserverState;

policy?

optional policy?: JsonObject;

spawned

spawned: number;

AmbientStats

Properties

agents

agents: Record<AmbientKind, number>;

despawned

despawned: number;

network

network: TransportNetworkStats;

pendingTiles

pendingTiles: number;

spawned

spawned: number;

waiting

waiting: number;

AmbientTileInput

One streamed map tile's transport data.

Properties

features

features: readonly TerrainTransportationFeature[];

heightAt?

optional heightAt?: (x, z) => number;

Ground height at a world X/Z (default: the network's ground sampler).

Parameters

x

number

z

number

Returns

number

key

key: string;

Unique tile key, e.g. terrainPyramidTileKey(address).

origin

origin: readonly [number, number];

World X/Z of the tile's north-west corner, in metres.

pois?

optional pois?: readonly TerrainPoiFeature[];

sidewalks?

optional sidewalks?: boolean;

Infer sidewalks along streets without mapped footways (default true).

tileSize

tileSize: number;

Tile edge length in metres; feature coordinates are normalized to it.

AmbientTypes

Properties

aircraft

aircraft: AmbientVehicleType[];

car

car: AmbientVehicleType[];

pedestrian

pedestrian: AmbientPedestrianType[];

train

train: AmbientVehicleType[];

AmbientVehicleType

Properties

cars?

optional cars?: number;

Rail: cars per consist.

colors?

optional colors?: string[];

Body colours to pick from (default: a realistic car palette).

cruise?

optional cruise?: number;

Preferred cruise speed in m/s (default: the lane's design speed).

height?

optional height?: number;

id

id: string;

Content type id, or a proxy name.

length

length: number;

max?

optional max?: number;

Top speed in m/s.

weight?

optional weight?: number;

Relative spawn weight within the class (default 1).

width

width: number;

DriverParams

Properties

accel

accel: number;

Maximum acceleration (m/s²).

brake

brake: number;

Comfortable braking (m/s²).

gap

gap: number;

Minimum standstill gap (m).

headway

headway: number;

Time headway (s).

EdgeDraft

A polyline awaiting the planar split, in world metres.

Properties

bridge

bridge: boolean;

bridgeConnections?

optional bridgeConnections?: object[];

elevation

elevation: number;

point

point: Point2;

radius

radius: number;

class

class: TransportClass;

deckElevation?

optional deckElevation?: number;

heights?

optional heights?: number[];

Absolute surface heights per point (documents); otherwise baked from the ground sampler.

kind

kind: RoadKind;

lanes

lanes: number;

Total lanes across both directions (road), ignored for other classes.

layer

layer: number;

link

link: boolean;

name?

optional name?: string;

oneway

oneway: boolean;

points

points: Point2[];

speed?

optional speed?: number;

tunnel

tunnel: boolean;

width

width: number;

EdgeSpan

Properties

d0

readonly d0: number;

Edge-path distances bounding the span.

d1

readonly d1: number;

edge

readonly edge: string;

x

readonly x: number;

Midpoint, for distance tests.

z

readonly z: number;

JunctionArm

Properties

dx

readonly dx: number;

Unit direction pointing away from the junction along the edge.

dz

readonly dz: number;

edge

readonly edge: string;

group

group: number;

Signal phase group this arm belongs to.

kind

readonly kind: RoadKind;

link

readonly link: boolean;

node

readonly node: string;

width

readonly width: number;

yields?

optional yields?: boolean;

A stop or yield sign on this arm: its traffic gives way.

LaneMovement

A way from the end of one lane onto the start of another, through a connector curve.

Properties

crosses?

readonly optional crosses?: readonly number[];

Walk movements: the road arms (by index) whose carriageway this connector crosses.

junction?

readonly optional junction?: string;

Junction whose core this movement crosses (absent at plain through nodes).

key

readonly key: number;

Arm-pair key inArm * armCount + outArm within the junction.

length

readonly length: number;

p0

readonly p0: readonly [number, number, number];

Connector: quadratic Bezier from the lane end, via a control point, to the next lane start.

p1

readonly p1: readonly [number, number, number];

p2

readonly p2: readonly [number, number, number];

to

readonly to: string;

turn

readonly turn: TurnKind;

weight

readonly weight: number;

LaneSample

A lane-level sample: position, surface height and travel direction.

Properties

dx

dx: number;

Unit horizontal travel direction.

dz

dz: number;

grade

grade: number;

Grade (rise per metre travelled).

x

x: number;

y

y: number;

z

z: number;

LaneStop

Properties

d

readonly d: number;

Edge-path distance of the stop (convert with laneCoordinate).

dwell?

readonly optional dwell?: number;

Stations: dwell time in seconds (default: a seeded 20–40 s).

id

readonly id: string;

Station/crossing id, used to remember a served stop.

kind

readonly kind: "bus" | "crossing" | "station" | "level-crossing";

ObserverView

Properties

density

density: number;

Density factor from the observer entity's ambientObserver.

fx?

optional fx?: number;

Unit horizontal view direction, when known.

fz?

optional fz?: number;

keep?

optional keep?: number;

Car despawn radius from the observer entity's ambientObserver.

radius?

optional radius?: number;

Car spawn radius from the observer entity's ambientObserver.

x

x: number;

y

y: number;

z

z: number;

PlanarNode

Properties

class

class: TransportClass;

layer

layer: number;

x

x: number;

z

z: number;

PlanarPiece

Properties

draft

draft: number;

from

from: number;

heights?

optional heights?: number[];

Absolute heights per point when the draft supplied them.

points

points: Point2[];

to

to: number;

PlanarResult

Properties

degraded

degraded: boolean;

True when the comparison budget ran out and some crossings were not detected.

nodes

nodes: PlanarNode[];

pieces

pieces: PlanarPiece[];

SignalTiming

Properties

cycleTicks

cycleTicks: number;

greenTicks

greenTicks: number[];

offsetTicks

offsetTicks: number;

TransportCrossing

A point where a mapped footway crossing or a railway crosses a road edge.

Properties

id

readonly id: string;

kind

readonly kind: "crossing" | "level-crossing";

other

readonly other: string;

The crossing edge (walk crossing or rail) and the distance along it.

otherS

readonly otherS: number;

road

readonly road: string;

roadS

readonly roadS: number;

Distance along the road edge's path.

tile

readonly tile: string;

TransportEdge

A polyline between two nodes. Lanes run along it in either direction.

Properties

bridge

readonly bridge: boolean;

class

readonly class: TransportClass;

from

readonly from: string;

id

readonly id: string;

kind

readonly kind: RoadKind;

lanes

readonly lanes: string[];

layer

readonly layer: number;

link

readonly link: boolean;

name?

readonly optional name?: string;

Source feature name, when mapped.

oneway

readonly oneway: boolean;

path

readonly path: TerrainLinePath;

World metres, [x, z] per vertex, with cumulative distances.

speed

readonly speed: number;

Design speed in m/s before per-agent variation.

tile

readonly tile: string;

to

readonly to: string;

tunnel

readonly tunnel: boolean;

width

readonly width: number;

ys

readonly ys: Float64Array;

Surface height per path vertex (same indexing as path.points).

TransportJunction

Properties

arms

readonly arms: readonly JunctionArm[];

conflicts

readonly conflicts: Uint8Array;

conflicts[a * n² + b] for arm-pair keys a and b.

control

control: JunctionControl;

groups

readonly groups: number;

Number of signal phase groups (≥ 2 when signalised).

id

readonly id: string;

nodes

readonly nodes: readonly string[];

radius

readonly radius: number;

Core radius in metres (lanes are trimmed this far back).

x

readonly x: number;

z

readonly z: number;

TransportLane

A directed lane. s runs from 0 at the lane start to length at its end.

Properties

class

readonly class: TransportClass;

dir

readonly dir: -1 | 1;

1 travels the edge path forward (from → to), -1 backward.

edge

readonly edge: string;

end

readonly end: string;

id

readonly id: string;

index

readonly index: number;

0 = innermost (nearest the centreline for two-way roads, leftmost for one-way).

length

length: number;

lift

readonly lift: number;

Surface lift above the edge's baked heights (sidewalks sit on the kerb).

next: LaneMovement[];

Outgoing movements at the lane end.

offset

readonly offset: number;

Signed lateral offset from the centreline, positive to the right of travel.

start

readonly start: string;

Node the lane starts from and ends at.

stops

stops: LaneStop[];

Stop points along the lane: stations, stops, crossings.

trimEnd

trimEnd: number;

trimStart

trimStart: number;

Edge-path distance trimmed from the start and end (junction cores).

TransportNetworkAerodrome

Properties

at

at: [number, number];

heading?

optional heading?: number;

Runway heading in radians about +Y (0 = +Z).

id

id: string;

length?

optional length?: number;

Runway length in metres (default 2500).

TransportNetworkDocument

Properties

aerodromes?

optional aerodromes?: TransportNetworkAerodrome[];

drivingSide?

optional drivingSide?: "right" | "left";

format

format: "molen/transport-network@1";

name?

optional name?: string;

origin?

optional origin?: 
  | {
  latitude: number;
  longitude: number;
}
  | {
  x: number;
  z: number;
};

sidewalks?

optional sidewalks?: boolean;

Infer sidewalks (walk lanes) along streets without mapped paths (default false).

signals?

optional signals?: TransportNetworkSignal[];

stations?

optional stations?: TransportNetworkStation[];

ways

ways: TransportNetworkWay[];

TransportNetworkOptions

Properties

classes?

optional classes?: readonly TransportClass[];

Lane classes to build (default all); skipping unused classes makes tiles cheaper.

ground?

optional ground?: (x, z) => number;

Ground height used when a tile or document gives none (default 0).

Parameters

x

number

z

number

Returns

number

traffic?

optional traffic?: "right" | "left";

tunnels?

optional tunnels?: "hidden" | "skip";

TransportNetworkSignal

Properties

at

at: [number, number];

kind

kind: "yield" | "stop" | "light";

TransportNetworkStation

Properties

at

at: [number, number];

dwell?

optional dwell?: number;

id

id: string;

kind

kind: "rail" | "bus";

TransportNetworkStats

Properties

degradedTiles

degradedTiles: number;

edges

edges: number;

junctions

junctions: number;

laneKm

laneKm: Record<TransportClass, number>;

Lane-kilometres per class.

lanes

lanes: number;

nodes

nodes: number;

signals

signals: number;

tiles

tiles: number;

TransportNetworkWay

Properties

bridge?

optional bridge?: boolean;

class

class: "rail" | "road" | "air" | "path";

id?

optional id?: string;

lanes?

optional lanes?: number;

layer?

optional layer?: number;

name?

optional name?: string;

oneway?

optional oneway?: boolean;

points

points: TransportNetworkPoint[];

speed?

optional speed?: number;

subclass?

optional subclass?: string;

tunnel?

optional tunnel?: boolean;

width?

optional width?: number;

TransportNode

An endpoint or split point shared by edges.

Properties

border

readonly border: boolean;

True when the node lies on its tile's boundary (a stitching candidate).

class

readonly class: TransportClass;

edges

readonly edges: string[];

Incident edge ids (both directions).

id

readonly id: string;

layer

readonly layer: number;

link?

optional link?: string;

The node in a neighbouring tile this border node is stitched to, if any.

tile

readonly tile: string;

Owning tile key ('*' for documents and polylines).

x

readonly x: number;

z

readonly z: number;

TransportRunway

A mapped runway, kept for aircraft approach corridors.

Properties

ax

readonly ax: number;

az

readonly az: number;

bx

readonly bx: number;

bz

readonly bz: number;

tile

readonly tile: string;

y

readonly y: number;

WorldPoi

POIs in world metres, filtered to the kinds agents care about.

Properties

dwell?

optional dwell?: number;

Stations: dwell time in seconds.

kind

kind: 
  | "crossing"
  | "station"
  | "tram_stop"
  | "bus_stop"
  | "traffic_signals"
  | "give_way"
  | "aerodrome";

name?

optional name?: string;

x

x: number;

z

z: number;

Type Aliases

AmbientKind

type AmbientKind = "car" | "pedestrian" | "train" | "aircraft";

An ambient NPC class.

AmbientTemplate

type AmbientTemplate = (agent) => ComponentMap;

Extra components for a spawned agent (beyond ambientAgent and transform).

Parameters

agent

AmbientSpawnInfo

Returns

ComponentMap

DeepPartial

type DeepPartial<T> = { [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K] };

Type Parameters

T

T

JunctionControl

type JunctionControl = "none" | "yield" | "signal";

RoadKind

type RoadKind = 
  | "motorway"
  | "trunk"
  | "primary"
  | "secondary"
  | "tertiary"
  | "street"
  | "living"
  | "service"
  | "path"
  | "crossing"
  | "rail"
  | "tram";

Finer classification used for speeds, spawn preferences and routing weights.

SignalColor

type SignalColor = "green" | "amber" | "red";

TransportClass

type TransportClass = "road" | "rail" | "walk" | "air";

Which agents a lane serves.

TransportNetworkPoint

type TransportNetworkPoint = [number, number] | [number, number, number];

A way's point: [x, z] or [x, y, z] in scene metres.

TurnKind

type TurnKind = "straight" | "left" | "right" | "uturn" | "merge";

Variables

AMBIENT_AGENT_COMPONENT

const AMBIENT_AGENT_COMPONENT: "ambientAgent";

AMBIENT_ENTITY

const AMBIENT_ENTITY: "$ambient";

The singleton entity holding ambient bookkeeping.

AMBIENT_KINDS

const AMBIENT_KINDS: readonly AmbientKind[];

AMBIENT_OBSERVER_COMPONENT

const AMBIENT_OBSERVER_COMPONENT: "ambientObserver";

AMBIENT_ROLE_COMPONENT

const AMBIENT_ROLE_COMPONENT: "ambientRole";

AMBIENT_STATE_COMPONENT

const AMBIENT_STATE_COMPONENT: "ambientState";

AmbientAgent

const AmbientAgent: ComponentType<AmbientAgentData>;

AmbientObserver

const AmbientObserver: ComponentType<AmbientObserverData>;

AmbientRole

const AmbientRole: ComponentType<AmbientRoleData>;

AmbientState

const AmbientState: ComponentType<AmbientStateData>;

CAR_COLORS

const CAR_COLORS: readonly string[];

Common real-world car body colours, weighted by repetition.

DEFAULT_POLICY

const DEFAULT_POLICY: AmbientPolicy;

DEFAULT_TEMPLATES

const DEFAULT_TEMPLATES: Readonly<Record<AmbientKind, AmbientTemplate>>;

Built-in templates: vehicles render through ambient-vehicle, pedestrians as figures.

DEFAULT_TYPES

const DEFAULT_TYPES: AmbientTypes;

GRID_CELL

const GRID_CELL: 64 = 64;

KIND_SPEED

const KIND_SPEED: Readonly<Record<RoadKind, number>>;

Design speeds in m/s by kind.

TRANSPORT_NETWORK_EXAMPLE

const TRANSPORT_NETWORK_EXAMPLE: TransportNetworkDocument;

TRANSPORT_NETWORK_FORMAT

const TRANSPORT_NETWORK_FORMAT: "molen/transport-network@1";

Functions

agentRotation()

function agentRotation(sample, pitch): Quat;

Rotation for an agent facing along a sample (with pitch unless flat).

Parameters

sample

pitch

boolean

Returns

Quat

agentSample()

function agentSample(
   net, 
   agent, 
   out
): LaneSample | undefined;

Where an agent is: its lane body, or the connector curve into its lane.

Parameters

Returns

LaneSample | undefined

allRed()

function allRed(
   junction, 
   tick, 
   tickRate, 
   timing?
): boolean;

Whether every group is red at tick (the all-red clearance interval).

Parameters

junction

AmbientCapabilityOptions

tick

number

tickRate

number

timing?

SignalTiming

Returns

boolean

ambientCapability()

function ambientCapability(opts?): (world, manifest) => Record<string, object> | undefined;

Build-world capability hook: buildWorld(scene, setup, { capabilities: [ambientCapability()] }).

Parameters

opts?

Returns

(world, manifest) => Record<string, object> | undefined

ambientOf()

function ambientOf(world): AmbientHandle | undefined;

The ambient handle installed on a world, if any.

Parameters

world

World

Returns

AmbientHandle | undefined

ambientScriptApi()

function ambientScriptApi(handle): object;

The script-api namespace for ambient life (molen.ambient.*); pass via buildWorld capabilities.

Parameters

handle

AmbientHandle

Returns

object

chooseNext()

function chooseNext(
   lane, 
   seed, 
   hops
): string | undefined;

Pick the next lane at a lane's end (seeded by the agent and its hop count).

Parameters

lane

seed

number

hops

number

Returns

string | undefined

classifyFeature()

function classifyFeature(feature): 
  | {
  class: TransportClass;
  kind: RoadKind;
}
  | "runway"
  | undefined;

Classify a mapped feature; undefined for features no agent uses.

Parameters

feature

TerrainTransportationFeature

Returns

| { class: TransportClass; kind: RoadKind; } | "runway" | undefined

clipPolyline()

function clipPolyline(
   points, 
   minX, 
   minZ, 
   maxX, 
   maxZ
): Point2[][];

Clip a polyline to an axis-aligned rectangle, returning the visible pieces (a line that leaves and re-enters the tile yields several pieces).

Parameters

points

readonly Point2[]

minX

number

minZ

number

maxX

number

maxZ

number

Returns

Point2[][]

edgeHeight()

function edgeHeight(edge, d): number;

Height of the edge surface at an edge-path distance.

Parameters

edge

d

number

Returns

number

featureDrafts()

function featureDrafts(input, options): TileDrafts;

Convert a tile's transportation features to clipped world-metre drafts.

Parameters

input

TileDraftInput

options

FeatureDraftOptions

Returns

TileDrafts

fmix32()

function fmix32(x): number;

murmur3 finalizer: a full-avalanche 32-bit mix.

Parameters

x

number

Returns

number

idmAcceleration()

function idmAcceleration(
   v, 
   v0, 
   gap, 
   dv, 
   p
): number;

IDM acceleration. gap is the bumper-to-bumper distance to the leader (Infinity when free), dv the closing speed (own speed minus the leader's).

Parameters

v

number

v0

number

gap

number

dv

number

p

DriverParams

Returns

number

installAmbient()

function installAmbient(world, options?): AmbientHandle;

Install the ambient systems (idempotent per world) and return the handle.

Parameters

world

World

options?

AmbientOptions

Returns

AmbientHandle

laneCoordinate()

function laneCoordinate(
   lane, 
   edge, 
   d
): number;

Lane coordinate of edge-path distance d.

Parameters

lane

edge

d

number

Returns

number

laneEdgeDistance()

function laneEdgeDistance(
   lane, 
   edge, 
   s
): number;

Edge-path distance of lane coordinate s (clamped to the lane).

Parameters

lane

edge

s

number

Returns

number

laneSample()

function laneSample(): LaneSample;

A fresh sample record.

Returns

mergePolicy()

function mergePolicy(base, ...overrides): AmbientPolicy;

Merge overrides into a policy (plain objects merge; other values replace).

Parameters

base

overrides

...( | JsonObject | DeepPartial<AmbientPolicy> | undefined)[]

Returns

TransportNetworkDocument

networkToDocument()

function networkToDocument(
   network, 
   meta?, 
   options?
): TransportNetworkDocument;

Every road, rail and path edge as a way (with surface heights), plus stations and signals.

Parameters

network

TransportNetwork

meta?

Pick<TransportNetworkDocument, "name" | "origin">

options?

heights?

boolean

Returns

pickWeighted()

function pickWeighted<T>(list, u): T | undefined;

Weighted pick from a list using a stateless draw.

Type Parameters

T

T extends object

Parameters

list

readonly T[]

u

number

Returns

T | undefined

planarSplit()

function planarSplit(drafts, options?): PlanarResult;

Split drafts into pieces between nodes. Drafts only connect within their class.

Parameters

drafts

readonly EdgeDraft[]

options?

PlanarOptions

Returns

PlanarResult

policyForBudget()

function policyForBudget(policy, budget): AmbientPolicy;

A policy with a host budget's caps and ring sizes applied.

Parameters

policy

budget

AmbientBudget

Returns

pseudoAngle()

function pseudoAngle(dx, dz): number;

Monotone stand-in for atan2 in [0, 4): orders directions without transcendental math.

Parameters

dx

number

dz

number

Returns

number

registerAmbientSchema()

function registerAmbientSchema(): void;

Returns

void

sampleConnector()

function sampleConnector(
   move, 
   t, 
   out
): LaneSample;

Point and tangent on a movement's connector at arc-length fraction t in [0, 1].

Parameters

move

LaneMovement

t

number

out

Returns

sampleLaneBody()

function sampleLaneBody(
   lane, 
   edge, 
   s, 
   out
): LaneSample;

Sample a lane at s within [0, length], writing into out.

Parameters

lane

edge

s

number

out

Returns

signalColor()

function signalColor(
   junction, 
   group, 
   tick, 
   tickRate, 
   timing?
): SignalColor;

The colour shown to arms of phase group group at tick.

Parameters

junction

group

number

tick

number

tickRate

number

timing?

SignalTiming

Returns

SignalColor

signalTiming()

function signalTiming(junction, tickRate): SignalTiming;

Timing for a signalised junction: 18–30 s green per phase group, seeded by the junction id.

Parameters

junction