leaflet-city-mapper 0.0.4 → 0.0.6

package/src/traffic/initTraffic.js

@@ -3,7 +3,7 @@ import { speed as sharedSpeed } from '../globals/speed.js';
 import { trafficEmptyOptions } from '../globals/trafficEmptyOptions.js';
 import { vehicles } from '../globals/vehicles.js';
 import { trafficShader } from '../globals/trafficShader.js';
-import { trafficByLayer } from '../globals/trafficByLayer.js';
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
 
 
 /**
@@ -16,9 +16,9 @@ import { trafficByLayer } from '../globals/trafficByLayer.js';
  * in metres, `name`/`description` for the default tooltip. The status line (count and vehicle type) sits under the layer's entry in the layers control.
  * L.Control.Time on the same map drives the time; without one, vehicles run live.
  */
-import { build } from '../geometry/build.js';
+import { build } from '../geometry/buildGeometryParts.js';
 import { init3D } from '../scene/init3D.js';
-import { tooltip } from './tooltip.js';
+import { tooltip } from './trafficTooltip.js';
 
 
 

package/src/traffic/loadedTrafficLanes.js

@@ -1,4 +1,4 @@
-import { toLanes } from './toLanes.js';
+import { toLanes } from './featuresToTrafficLanes.js';
 import { prepareTraffic } from './prepareTraffic.js';
 
 export function loadedTrafficLanes(state, signal, data) {

package/src/traffic/locateTraffic.js

@@ -1,10 +1,10 @@
-import { along } from './along.js';
+import { along } from '../geometry/interpolateRoute.js';
 
-export function locateTraffic(state, trip) {
+export function locateTraffic(state, trip, target) {
   const { points, lengths, length } = trip.lane;
   let distance = trip.distance + state.elapsed * trip.speed;
   distance -= length * Math.floor(distance / length);
-  const position = along(points, lengths, distance);
+  const position = along(points, lengths, distance, target);
   position.x -= position.dz * state.side;
   position.z += position.dx * state.side;
   return position;

package/src/traffic/placeTraffic.js

@@ -4,10 +4,11 @@ export function placeTraffic(state) {
   if (!state.mesh || !state.stale) return;
   state.stale = false;
   const { position, normal } = state.mesh.geometry.attributes;
+  const target = state.position ||= /* alloc */ {};
   let i, trip, cx, y, cz, dx, dz, k, o, lx, lz, nx, nz;
   for (i = 0; i < state.trips.length; i++) {
     trip = state.trips[i];
-    ({ x: cx, y, z: cz, dx, dz } = locateTraffic(state, trip));
+    ({ x: cx, y, z: cz, dx, dz } = locateTraffic(state, trip, target));
     for (k = 0, o = i * state.stride; k < state.stride; k += 3, o += 3) {
       lx = state.template.position[k], lz = state.template.position[k + 2], nx = state.template.normal[k], nz = state.template.normal[k + 2];
       position.data[o] = cx - lx * dz - lz * dx;

package/src/traffic/prepareTraffic.js

@@ -1,6 +1,7 @@
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+
 import { radians } from '../globals/radians.js';
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 import { disposeTrafficObject } from './disposeTrafficObject.js';
@@ -8,8 +9,8 @@ import { groundTraffic } from './groundTraffic.js';
 
 export function prepareTraffic(state) {
   const { layer, lanes } = state;
-  const crs = layer._map.options.crs, origin = crs.project(sceneByLayer.get(layer).location);
-  const metres = Math.cos(sceneByLayer.get(layer).location.lat * radians);
+  const crs = layer._map.options.crs, origin = crs.project(locationByLayer.get(layer));
+  const metres = Math.cos(locationByLayer.get(layer).lat * radians);
   let lane, lat, lng, point, i;
   for (lane of lanes) {
     lane.points = /* alloc */ [];

package/src/traffic/rebaseTraffic.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 
 
 import { destroyTrafficGpu } from './destroyTrafficGpu.js';
@@ -6,7 +7,7 @@ import { trafficStorage } from './trafficStorage.js';
 import { uploadTrafficLanes } from './uploadTrafficLanes.js';
 
 export function rebaseTraffic(state) {
-  const { device } = sceneByLayer.get(state.layer).renderer;
+  const { device } = rendererByLayer.get(state.layer);
   if (state.gpu?.device !== device) {
     destroyTrafficGpu(state);
     const template = /* alloc */ new Float32Array(

package/src/traffic/rebuildTrafficMesh.js

@@ -1,5 +1,5 @@
 import { trafficEmptyOptions } from '../globals/trafficEmptyOptions.js';
-import { build } from '../geometry/build.js';
+import { build } from '../geometry/buildGeometryParts.js';
 import { createTrafficMesh } from './createTrafficMesh.js';
 import { disposeTrafficObject } from './disposeTrafficObject.js';
 import { trafficBounds } from './trafficBounds.js';

package/src/traffic/removeTraffic.js

@@ -1,4 +1,4 @@
-import { trafficByLayer } from '../globals/trafficByLayer.js';
+import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
 
 
 import { disposeTrafficObject } from './disposeTrafficObject.js';

package/src/traffic/startTraffic.js

@@ -1,4 +1,4 @@
-import { underEntry } from '../scene/underEntry.js';
+import { underEntry } from '../layer-controls/underEntry.js';
 
 export function startTraffic(state) {
   state.layer._map.off('simulationtimechange layerremove', state.update).on('simulationtimechange layerremove', state.update);

package/src/traffic/tickTraffic.js

@@ -1,7 +1,8 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
 
 
-import { update as updateScene } from '../scene/update.js';
+
+import { update as updateScene } from '../scene/scheduleSceneUpdate.js';
 import { trafficNow } from './trafficNow.js';
 import { refreshTrafficTrips } from './refreshTrafficTrips.js';
 import { updateTrafficPose } from './updateTrafficPose.js';
@@ -9,7 +10,7 @@ import { updateTrafficPose } from './updateTrafficPose.js';
 export function tickTraffic(state) {
   state.frame = undefined;
   if (!state.ready || !state.layer._map) return;
-  if (!sceneByLayer.get(state.layer).renderer) { state.frame = requestAnimationFrame(state.tick); return; }
+  if (!rendererByLayer.get(state.layer)) { state.frame = requestAnimationFrame(state.tick); return; }
   if (state.mesh && !(state.mesh.geometry.attributes.position.buffer.usage & GPUBufferUsage.STORAGE)) {
     state.tripsKey = null;
     state.nextCheck = -Infinity;

package/src/traffic/trafficNow.js

@@ -1,8 +1,9 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { timeControlByMap } from '../weakmaps/timeControlByMap.js';
+
 
 
 export function trafficNow(state) {
-  const control = cameraByMap.get(state.layer._map)?._timeControl;
+  const control = timeControlByMap.get(state.layer._map);
   const live = control ? control.live : true;
   return /* alloc */ {
     live, time: live ? /* alloc */ new Date() : control.time,

package/src/traffic/updateTraffic.js

@@ -1,10 +1,11 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { controlByLayer } from '../weakmaps/controlByLayer.js';
+
 
 
 import { loadTraffic } from './loadTraffic.js';
 
 export function updateTraffic(state, event) {
-  if (event?.layer && !sceneByLayer.get(event.layer).control?.time) return;
+  if (event?.layer && !controlByLayer.get(event.layer)?.time) return;
   cancelAnimationFrame(state.frame);
   loadTraffic(state);
   state.tick();

package/src/traffic/updateTrafficLights.js

@@ -3,10 +3,12 @@ import { locateTraffic } from './locateTraffic.js';
 export function updateTrafficLights(state) {
   state.litAt = performance.now();
   const lights = /* alloc */ [];
+  const target = state.position ||= /* alloc */ {};
   let trip, x, y, z, dx, dz, lx, ly, lz, light;
   for (trip of state.trips) {
-    ({ x, y, z, dx, dz } = locateTraffic(state, trip));
-    for ({ position: [lx, ly, lz], ...light } of state.lights) {
+    ({ x, y, z, dx, dz } = locateTraffic(state, trip, target));
+    for (light of state.lights) {
+      [lx, ly, lz] = light.position;
       lights.push(/* alloc */ {
         ...light, position: /* alloc */ [x - lx * dz - lz * dx, y + ly, z + lx * dx - lz * dz],
       });

package/src/vehicles/boatBenches.js

@@ -1,4 +1,4 @@
-import { mirror } from './mirror.js';
+import { mirror } from './mirrorVehiclePart.js';
 
 export function boatBenches() {
   const benches = /* alloc */ [];

package/src/vehicles/boatModel.js

@@ -5,7 +5,7 @@ import { glass } from '../globals/glass.js';
 
 import { box } from '../geometry/box.js';
 
-import { mirror } from './mirror.js';
+import { mirror } from './mirrorVehiclePart.js';
 
 import { boatBenches } from './boatBenches.js';
 

package/src/vehicles/busModel.js

@@ -1,5 +1,5 @@
 import { routeColor } from '../traffic/routeColor.js';
-import { carriage } from './carriage.js';
+import { carriage } from './buildCarriage.js';
 
 export function busModel(index, properties) {
   return carriage(0, 12, routeColor(properties));

package/src/vehicles/carModel.js

@@ -7,7 +7,7 @@ import { taillight } from '../globals/taillight.js';
 import { box } from '../geometry/box.js';
 
 
-import { mirror } from './mirror.js';
+import { mirror } from './mirrorVehiclePart.js';
 
 
 

package/src/vehicles/metroModel.js

@@ -1,5 +1,5 @@
 import { routeColor } from '../traffic/routeColor.js';
-import { carriage } from './carriage.js';
+import { carriage } from './buildCarriage.js';
 
 export function metroModel(index, properties) {
   const color = routeColor(properties), parts = /* alloc */ [];

package/src/vehicles/tramModel.js

@@ -1,5 +1,5 @@
 import { routeColor } from '../traffic/routeColor.js';
-import { carriage } from './carriage.js';
+import { carriage } from './buildCarriage.js';
 
 export function tramModel(index, properties) {
   const color = routeColor(properties), parts = /* alloc */ [];

package/src/walk/{step.js → animateWalker.js}

@@ -1,45 +1,41 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
 import { limbs } from '../globals/limbs.js';
 import { parts } from '../globals/parts.js';
 import { moves } from '../globals/moves.js';
 
 
 import * as createMesh from '../rendering/createMesh.js';
-import { build } from '../geometry/build.js';
+import { build } from '../geometry/buildGeometryParts.js';
 
-import { wrap } from '../utils/wrap.js';
-import { local } from './local.js';
-import { place } from './place.js';
-import { land } from './land.js';
-import { moveWalker } from './moveWalker.js';
+import { local } from '../projections/walkerLocalPosition.js';
 import { stepWalkerHeight } from './stepWalkerHeight.js';
-import { updateWalkerView } from './updateWalkerView.js';
+import { resolveWalkerPosition } from './resolveWalkerPosition.js';
+import { updateWalkerFrame } from './updateWalkerFrame.js';
 
 export function step(now) {
   const layer = this.layer;
   this.frame = requestAnimationFrame(this.step);
   const dt = Math.min(0.1, (now - (this.last ?? now)) / 1000);
   this.last = now;
-  if (!sceneByLayer.get(layer).renderer) return;
+  if (!rendererByLayer.get(layer)) return;
   let changed = false;
   let part, key;
+  if (now >= this.nextClearanceCheck) {
+    this.nextClearanceCheck = now + 250;
+    if (resolveWalkerPosition.call(this)) changed = true;
+  }
   if (!this.meshes) {
     this.meshes = /* alloc */ [];
     for ([part] of limbs) this.meshes.push(createMesh.createMesh(layer, build(parts[part])));
     changed = true;
   }
-  const previousY = sceneByLayer.get(layer).root.position[1] +
-    local.call(this, this.local)[1] * sceneByLayer.get(layer).root.scale[1];
+  const previousY = rootByLayer.get(layer).position[1] +
+    local.call(this, this.local)[1] * rootByLayer.get(layer).scale[1];
   if (stepWalkerHeight.call(this, dt)) changed = true;
   let forward = 0, turn = 0;
   for (key of this.keys) { forward += moves[key]?.[0] || 0; turn += moves[key]?.[1] || 0; }
   forward = Math.sign(forward); turn = Math.sign(turn);
-  if (turn) { this.state.heading = wrap(this.state.heading + turn * 2.5 * dt); changed = true; }
-  if (forward) {
-    moveWalker.call(this, forward, dt);
-    changed = true;
-  }
-  if (changed) land.call(this, previousY);
-  if (updateWalkerView.call(this, forward, turn, dt)) changed = true;
-  if (changed) place.call(this);
+  updateWalkerFrame(this, previousY, forward, turn, dt, changed);
 }

package/src/walk/createWalk.js

@@ -1,16 +1,18 @@
+import { typeByLayer } from '../weakmaps/typeByLayer.js';
+import { walkerByLayer } from '../weakmaps/walkerByLayer.js';
+
 import { L } from '../globals/L.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 import { init3D } from '../scene/init3D.js';
-import { onBlur } from './onBlur.js';
-import { onKey } from './onKey.js';
-import { onPointer } from './onPointer.js';
-import { onTerrain } from './onTerrain.js';
-import { start } from './start.js';
-import { step } from './step.js';
-import { stop } from './stop.js';
-import { toggle } from './toggle.js';
+import { onBlur } from './onWalkBlur.js';
+import { onKey } from './onWalkKey.js';
+import { onPointer } from './onWalkPointer.js';
+import { onTerrain } from './onWalkTerrain.js';
+import { start } from './startWalking.js';
+import { step } from './animateWalker.js';
+import { stop } from './stopWalking.js';
+import { toggle } from './toggleWalking.js';
 
 export function createWalk(control, {
   speed,
@@ -18,7 +20,7 @@ export function createWalk(control, {
   ...options
 }) {
   const layer = /* alloc */ new L.Layer();
-  sceneByLayer.get(layer)._type = 'walk';
+  typeByLayer.set(layer, 'walk');
   init3D(layer, options);
   const keys = /* alloc */ new Set();
   const container = L.DomUtil.create('div', 'leaflet-bar leaflet-control');
@@ -46,13 +48,15 @@ export function createWalk(control, {
     meshes: null,
     frame: null,
     last: undefined,
+    nextClearanceCheck: 0,
     swing: 0,
     verticalSpeed: 0,
     saved: null,
     hitData: null,
     local: null,
-    state: control.walker = sceneByLayer.get(layer).walker = /* alloc */ { latlng: null, heading: 0, phase: 0, height: 0 }
+    state: control.walker = /* alloc */ { latlng: null, heading: 0, phase: 0, height: 0 }
   }
+  walkerByLayer.set(layer, context.state);
   context.step = step.bind(context);
   context.onKey = onKey.bind(context);
   context.onBlur = onBlur.bind(context);

package/src/walk/initWalk.js

@@ -1,7 +1,7 @@
 import { L } from '../globals/L.js';
-import { initialize } from './initialize.js';
-import { onAdd } from './onAdd.js';
-import { onRemove } from './onRemove.js';
+import { initialize } from './initializeWalkControl.js';
+import { onAdd } from './onAddWalkControl.js';
+import { onRemove } from './onRemoveWalkControl.js';
 
 /**
  * Third-person walk mode, toggled by a map button (and Esc): a pedestrian at the map centre runs with W/S (or ↑/↓) and
@@ -9,7 +9,7 @@ import { onRemove } from './onRemove.js';
  * (bearing, pitch); the wheel changes the camera distance.
  * The walker follows the terrain, bridges included, and `control.walker` exposes `{ latlng, heading, phase }`.
  * Options: `speed` (m/s, default 70), `distance` (camera distance in metres, default 20), `position` (button corner, default 'bottomright').
- * Visible meshes of the other 3D layers (buildings, trees, models, streetlights) are solid; terrain and traffic are not.
+ * Buildings, trees, models, streetlights and traffic block movement; the walker is moved out of newly loaded obstacles.
  */
 L.Control.Walk = L.Control.extend({
   options: { position: 'bottomright', speed: 70, distance: 20 },

package/src/walk/landWalker.js

@@ -0,0 +1,38 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { raycasterByLayer } from '../weakmaps/raycasterByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
+import { intersectMeshes } from '../collision/intersectMeshes.js';
+import { traverse } from '../scene/traverse.js';
+import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
+import { collectVisibleMesh } from '../picking/collectVisibleMesh.js';
+import { shouldSkipOther } from '../picking/shouldSkipOther.js';
+import { local } from '../projections/walkerLocalPosition.js';
+
+export function land(previousY) {
+  const ray = raycasterByLayer.get(this.layer)
+  const feet = local.call(this, this.local), root = rootByLayer.get(this.layer);
+  const x = root.position[0] + feet[0] * root.scale[0];
+  const y = root.position[1] + feet[1] * root.scale[1];
+  const z = root.position[2] + feet[2] * root.scale[2];
+  if (y > previousY || this.verticalSpeed > 0) return;
+  updateWorldMatrix(sceneByLayer.get(this.layer));
+  ray.origin[0] = x; ray.origin[1] = previousY + 0.01; ray.origin[2] = z;
+  ray.direction[0] = 0; ray.direction[1] = -1; ray.direction[2] = 0;
+  ray.meshes.length = 0;
+  let layer, hit;
+  for (layer of layersByLayer.get(sharedByLayer.get(this.layer))) {
+    if (shouldSkipOther(layer, this.layer) || kindByLayer.get(layer) === 'raster' || layer.options.nightLight) continue;
+    traverse(rootByLayer.get(layer), collectVisibleMesh, ray.meshes);
+  }
+  for (hit of intersectMeshes(ray, ray.meshes)) {
+    if (hit.point[1] < y - 0.001) break;
+    this.state.height += (hit.point[1] - y) / root.scale[1];
+    this.verticalSpeed = 0;
+    break;
+  }
+  ray.meshes.length = 0;
+}

package/src/walk/moveWalker.js

@@ -1,12 +1,13 @@
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
 import { L } from '../globals/L.js';
 import { radians } from '../globals/radians.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { local } from './local.js';
-import { blocked } from './blocked.js';
+import { local } from '../projections/walkerLocalPosition.js';
+import { blocked } from './isWalkBlocked.js';
 
 export function moveWalker(forward, dt) {
   const metres = forward * this.speed * dt, { lat, lng } = this.state.latlng;
-  const { position, scale } = sceneByLayer.get(this.layer).root;
+  const { position, scale } = rootByLayer.get(this.layer);
   let east = Math.sin(this.state.heading) * metres, north = Math.cos(this.state.heading) * metres;
   const feet = local.call(this, this.local);
   let i;

package/src/walk/{onAdd.js → onAddWalkControl.js}

@@ -1,4 +1,4 @@
-import { walkByMap } from '../globals/walkByMap.js';
+import { walkByMap } from '../weakmaps/walkByMap.js';
 
 export function onAdd(map) {
   let state = walkByMap.get(map);
@@ -12,6 +12,8 @@ export function onAdd(map) {
       hitData: /* alloc */ {
         x: 0, y: 0, z: 0, dx: 0, dz: 0, reach: 0, best: 0, found: false,
         seen: /* alloc */ new Set(),
+        intersections: /* alloc */ [],
+        nodes: /* alloc */ [],
         normal: /* alloc */ [0, 0],
       },
       local: /* alloc */ [0, 0, 0],

package/src/walk/{onRemove.js → onRemoveWalkControl.js}

@@ -1,4 +1,4 @@
-import { walkByMap } from '../globals/walkByMap.js';
+import { walkByMap } from '../weakmaps/walkByMap.js';
 
 export function onRemove(map) {
   const state = walkByMap.get(map);

package/src/walk/{onKey.js → onWalkKey.js}

@@ -1,7 +1,7 @@
 import { moves } from '../globals/moves.js';
 
 
-import { stop } from './stop.js';
+import { stop } from './stopWalking.js';
 
 export function onKey(event) {
   if (event.type === 'keyup' && event.code === 'Space') this.keys.delete('Space');

package/src/walk/{onTerrain.js → onWalkTerrain.js}

@@ -1,4 +1,4 @@
-import { place } from './place.js';
+import { place } from './placeWalker.js';
 
 export function onTerrain() {
   if (this.meshes) place.call(this);

package/src/walk/{place.js → placeWalker.js}

@@ -1,8 +1,8 @@
 import { limbs } from '../globals/limbs.js';
 
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
 
-import { local } from './local.js';
+import { local } from '../projections/walkerLocalPosition.js';
 
 export function place() {
   const [x, y, z] = local.call(this, this.local);

package/src/walk/resolveWalkerPosition.js

@@ -0,0 +1,28 @@
+import { L } from '../globals/L.js';
+import { insideWalker } from '../collision/insideWalker.js';
+
+export function resolveWalkerPosition() {
+  if (!this.saved || !insideWalker(this)) return false;
+  const map = this.layer._map;
+  const origin = this.state.latlng;
+  const height = this.state.height;
+  let distance, angle, candidate;
+  for (distance = 0.5; distance <= 20; distance += 0.5) {
+    for (angle = 0; angle < Math.PI * 2; angle += Math.PI / 4) {
+      candidate = /* alloc */ new L.LatLng(
+        origin.lat + Math.cos(angle) * distance / 111320,
+        origin.lng + Math.sin(angle) * distance / (111320 * Math.cos(origin.lat * Math.PI / 180))
+      );
+      this.state.latlng = candidate;
+      this.state.height = 0;
+      if (!insideWalker(this)) {
+        this.verticalSpeed = 0;
+        map.setView(candidate, map.getZoom(), /* alloc */ { animate: false });
+        return true;
+      }
+    }
+  }
+  this.state.latlng = origin;
+  this.state.height = height;
+  return false;
+}

package/src/walk/{start.js → startWalking.js}

@@ -5,11 +5,12 @@ import { sceneWalkHandlers } from '../globals/sceneWalkHandlers.js';
 import { mapGetPitch } from '../camera/mapGetPitch.js';
 import { mapGetBearing } from '../camera/mapGetBearing.js';
 import { mapSetPitch } from '../camera/mapSetPitch.js';
-import { step } from './step.js';
-import { onKey } from './onKey.js';
-import { onBlur } from './onBlur.js';
-import { onPointer } from './onPointer.js';
-import { onTerrain } from './onTerrain.js';
+import { step } from './animateWalker.js';
+import { onKey } from './onWalkKey.js';
+import { onBlur } from './onWalkBlur.js';
+import { onPointer } from './onWalkPointer.js';
+import { onTerrain } from './onWalkTerrain.js';
+import { resolveWalkerPosition } from './resolveWalkerPosition.js';
 
 
 export function start() {
@@ -34,6 +35,7 @@ export function start() {
   this.state.heading = -mapGetBearing(map) * radians;
   map.setView(this.state.latlng, zoom, /* alloc */ { animate: false });
   mapSetPitch(map, 75);
+  resolveWalkerPosition.call(this);
   L.DomEvent.on(document, 'keydown keyup', this.onKey);
   L.DomEvent.on(window, 'blur', this.onBlur);
   L.DomEvent.on(map.getContainer(), 'pointerdown pointermove pointerup pointercancel', this.onPointer);
@@ -42,5 +44,6 @@ export function start() {
   this.button.style.background = '#e4e4e4';
   this.hint.style.display = '';
   this.last = undefined;
+  this.nextClearanceCheck = 0;
   this.frame = requestAnimationFrame(this.step);
 }

package/src/walk/{stop.js → stopWalking.js}

@@ -1,10 +1,10 @@
 import { L } from '../globals/L.js';
 import { mapSetPitch } from '../camera/mapSetPitch.js';
 import * as disposeMesh from '../rendering/disposeMesh.js';
-import { onKey } from './onKey.js';
-import { onBlur } from './onBlur.js';
-import { onPointer } from './onPointer.js';
-import { onTerrain } from './onTerrain.js';
+import { onKey } from './onWalkKey.js';
+import { onBlur } from './onWalkBlur.js';
+import { onPointer } from './onWalkPointer.js';
+import { onTerrain } from './onWalkTerrain.js';
 
 export function stop() {
   const map = this.layer._map;

package/src/walk/{toggle.js → toggleWalking.js}

@@ -1,5 +1,5 @@
-import { start } from './start.js';
-import { stop } from './stop.js';
+import { start } from './startWalking.js';
+import { stop } from './stopWalking.js';
 
 export function toggle() {
   if (this.saved) stop.call(this); else start.call(this);

package/src/walk/updateWalkerFrame.js

@@ -0,0 +1,19 @@
+import { wrap } from '../utils/wrap.js';
+import { place } from './placeWalker.js';
+import { land } from './landWalker.js';
+import { moveWalker } from './moveWalker.js';
+import { updateWalkerView } from './updateWalkerView.js';
+
+export function updateWalkerFrame(walker, previousY, forward, turn, dt, changed) {
+  if (turn) {
+    walker.state.heading = wrap(walker.state.heading + turn * 2.5 * dt);
+    changed = true;
+  }
+  if (forward) {
+    moveWalker.call(walker, forward, dt);
+    changed = true;
+  }
+  if (changed) land.call(walker, previousY);
+  if (updateWalkerView.call(walker, forward, turn, dt)) changed = true;
+  if (changed) place.call(walker);
+}

package/src/weakmaps/addedByLayer.js

@@ -0,0 +1 @@
+export const addedByLayer = new WeakMap();

package/src/weakmaps/archiveHeaderByLayer.js

@@ -0,0 +1 @@
+export const archiveHeaderByLayer = new WeakMap();

package/src/weakmaps/areasByLayer.js

@@ -0,0 +1 @@
+export const areasByLayer = new WeakMap();

package/src/weakmaps/bridgeMeshByLayer.js

@@ -0,0 +1 @@
+export const bridgeMeshByLayer = new WeakMap();

package/src/weakmaps/bridgesByLayer.js

@@ -0,0 +1 @@
+export const bridgesByLayer = new WeakMap();

package/src/weakmaps/cameraAnimationByMap.js

@@ -0,0 +1 @@
+export const cameraAnimationByMap = new WeakMap();

package/src/weakmaps/cameraBearingByMap.js

@@ -0,0 +1 @@
+export const cameraBearingByMap = new WeakMap();

package/src/weakmaps/cameraByLayer.js

@@ -0,0 +1 @@
+export const cameraByLayer = new WeakMap();

package/src/weakmaps/cameraDraggableByMap.js

@@ -0,0 +1 @@
+export const cameraDraggableByMap = new WeakMap();