330 lines
9.9 KiB
JavaScript
330 lines
9.9 KiB
JavaScript
import axios from "axios";
|
||
import turfAlong from "@turf/along";
|
||
import * as turfProjection from "@turf/projection";
|
||
import * as routing from "./routing.js";
|
||
import network from "./network.json";
|
||
|
||
const server = "http://localhost:4321";
|
||
|
||
// Time to stay at each stop (milliseconds)
|
||
const stopTime = 10000;
|
||
|
||
// Step used to compute the vehicle bearing (meters)
|
||
const angleStep = 10;
|
||
|
||
// Maximum speed of a vehicle (meters per millisecond)
|
||
const maxSpeed = 60 / 3600;
|
||
|
||
// Minimum speed of a vehicle (meters per millisecond)
|
||
const minSpeed = 10 / 3600;
|
||
|
||
// Normal speed of a vehicle
|
||
const normSpeed = (2 * maxSpeed + minSpeed) / 3;
|
||
|
||
/** Simulate the evolution of a vehicle course in the network. */
|
||
class Course {
|
||
constructor(id) {
|
||
// Unique identifier of this course
|
||
this.id = id;
|
||
|
||
// Line on which this vehicle operates
|
||
this.line = null;
|
||
|
||
// Line direction of this course
|
||
this.direction = null;
|
||
|
||
// Stop to which this course is headed
|
||
this.finalStop = null;
|
||
|
||
// Previous stops that this course left (stop id/timestamp pairs)
|
||
this.prevPassings = [];
|
||
|
||
// Next stops that this course will leave (stop id/timestamp pairs)
|
||
this.nextPassings = [];
|
||
|
||
// Stop that this course just left or will leave
|
||
this.departureStop = null;
|
||
|
||
// Time at which the last stop was left or will be left (timestamp)
|
||
this.departureTime = 0;
|
||
|
||
// Next stop that this course will reach
|
||
this.arrivalStop = null;
|
||
|
||
// Time at which the next stop will be left (timestamp)
|
||
this.arrivalTime = 0;
|
||
|
||
// Route between the current departure and arrival stops
|
||
this.segment = null;
|
||
|
||
// Distance already travelled between the two stops (meters)
|
||
this.traveledDistance = 0;
|
||
|
||
// Current vehicle speed (meters per millisecond)
|
||
this.speed = 0;
|
||
|
||
// Current vehicle latitude and longitude
|
||
this.position = [0, 0];
|
||
|
||
// Current vehicle bearing (clockwise degrees from north)
|
||
this.angle = 0;
|
||
}
|
||
|
||
/** Find a route between the current departure and arrival stops. */
|
||
updateSegment() {
|
||
if (this.departureStop === null || this.arrivalStop === null) {
|
||
this.segment = null;
|
||
return;
|
||
}
|
||
|
||
const name = `${this.departureStop}-${this.arrivalStop}`;
|
||
|
||
// Use predefined segment if it exists
|
||
if (name in network.segments) {
|
||
this.segment = network.segments[name];
|
||
return;
|
||
}
|
||
|
||
if (!(this.departureStop in network.stops)) {
|
||
console.warn(`Unknown stop: ${this.departureStop}`);
|
||
this.segment = null;
|
||
return;
|
||
}
|
||
|
||
if (!(this.arrivalStop in network.stops)) {
|
||
console.warn(`Unknown stop: ${this.arrivalStop}`);
|
||
this.segment = null;
|
||
return;
|
||
}
|
||
|
||
// Compute a custom route between two stops
|
||
this.segment = routing.findSegment(this.departureStop, this.arrivalStop);
|
||
|
||
if (this.segment === null) {
|
||
console.warn(`No route from ${this.departureStop} \
|
||
to ${this.arrivalStop}`);
|
||
}
|
||
}
|
||
|
||
/** Merge passings data received from the server. */
|
||
receiveData(data) {
|
||
this.line = data.line;
|
||
this.direction = data.direction;
|
||
this.finalStop = data.finalStopId;
|
||
|
||
const passings = Object.assign(
|
||
Object.fromEntries(this.nextPassings),
|
||
Object.fromEntries(data.passings),
|
||
);
|
||
|
||
// Remove older passings from next passings
|
||
for (let [stop, _] of this.prevPassings) {
|
||
delete passings[stop];
|
||
}
|
||
|
||
// Update departure time if still announced
|
||
if (this.departureStop !== null) {
|
||
if (this.departureStop in passings) {
|
||
this.departureTime = passings[this.departureStop];
|
||
delete passings[this.departureStop];
|
||
}
|
||
}
|
||
|
||
// Update arrival time
|
||
if (this.arrivalStop !== null) {
|
||
if (this.arrivalStop in passings) {
|
||
// Use announced time if available
|
||
this.arrivalTime = passings[this.arrivalStop];
|
||
delete passings[this.arrivalStop];
|
||
} else {
|
||
// Otherwise, arrive using a normal speed from current position
|
||
const segment = this.segment;
|
||
const distance = segment.properties.length - this.traveledDistance;
|
||
const time = Math.floor(distance / normSpeed);
|
||
this.arrivalTime = Date.now() + time;
|
||
}
|
||
}
|
||
|
||
this.nextPassings = Object.entries(passings).sort(
|
||
([, time1], [, time2]) => time1 - time2
|
||
);
|
||
}
|
||
|
||
/** Update the vehicle state. */
|
||
update() {
|
||
const now = Date.now();
|
||
|
||
// When initializing, use the first available passing as start
|
||
if (this.departureStop === null) {
|
||
if (this.nextPassings.length > 0) {
|
||
const [stopId, time] = this.nextPassings.shift();
|
||
this.departureStop = stopId;
|
||
this.departureTime = time;
|
||
this.updateSegment();
|
||
}
|
||
}
|
||
|
||
// …and the second one as the arrival
|
||
if (this.arrivalStop === null) {
|
||
if (this.nextPassings.length > 0) {
|
||
const [stopId, time] = this.nextPassings.shift();
|
||
this.arrivalStop = stopId;
|
||
this.arrivalTime = time;
|
||
this.updateSegment();
|
||
}
|
||
}
|
||
|
||
if (this.segment !== null) {
|
||
const segment = this.segment;
|
||
const distance = segment.properties.length - this.traveledDistance;
|
||
const duration = this.arrivalTime - stopTime - now;
|
||
|
||
// Arrive to the next stop
|
||
if (distance === 0) {
|
||
this.prevPassings.push([this.departureStop, this.departureTime]);
|
||
this.departureStop = this.arrivalStop;
|
||
this.departureTime = this.arrivalTime;
|
||
|
||
if (this.nextPassings.length > 0) {
|
||
const [stopId, time] = this.nextPassings.shift();
|
||
this.arrivalStop = stopId;
|
||
this.arrivalTime = time;
|
||
} else {
|
||
this.arrivalStop = null;
|
||
this.arrivalTime = 0;
|
||
}
|
||
|
||
this.traveledDistance = 0;
|
||
this.updateSegment();
|
||
}
|
||
|
||
if (this.departureTime > now) {
|
||
// Wait for departure
|
||
this.speed = 0;
|
||
} else {
|
||
if (this.traveledDistance === 0 && this.speed === 0) {
|
||
// We’re late, record the actual departure time
|
||
this.departureTime = now;
|
||
}
|
||
|
||
// Update current speed to arrive on time if possible
|
||
this.speed = Course.computeSpeed(distance, duration);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/** Integrate the current vehicle speed and update distance. */
|
||
move(time) {
|
||
if (this.segment === null) {
|
||
return;
|
||
}
|
||
|
||
if (this.speed > 0) {
|
||
this.traveledDistance = Math.min(
|
||
this.traveledDistance + this.speed * time,
|
||
this.segment.properties.length,
|
||
);
|
||
}
|
||
|
||
// Compute updated position and angle based on a small step
|
||
let positionBehind;
|
||
let positionInFront;
|
||
|
||
if (this.traveledDistance < angleStep / 2) {
|
||
positionBehind = this.traveledDistance;
|
||
positionInFront = angleStep;
|
||
} else {
|
||
positionBehind = this.traveledDistance - angleStep / 2;
|
||
positionInFront = this.traveledDistance + angleStep / 2;
|
||
}
|
||
|
||
const positions = [
|
||
positionBehind,
|
||
this.traveledDistance,
|
||
positionInFront,
|
||
].map(distance => turfProjection.toMercator(turfAlong(
|
||
this.segment,
|
||
distance / 1000
|
||
)).geometry.coordinates);
|
||
|
||
this.angle = Math.atan2(
|
||
positions[0][1] - positions[2][1],
|
||
positions[2][0] - positions[0][0]
|
||
);
|
||
|
||
this.position = positions[1];
|
||
}
|
||
|
||
/**
|
||
* Compute the optimal speed to arrive on time.
|
||
* @param {number} distance Distance to cover (meters)
|
||
* @param {number} duration Remaining time (seconds)
|
||
* @return {number} Optimal speed (meters per second)
|
||
*/
|
||
static computeSpeed(distance, duration) {
|
||
if (duration <= 0) {
|
||
// Late: go to maximum speed
|
||
return maxSpeed;
|
||
}
|
||
|
||
const speed = distance / duration;
|
||
|
||
if (speed < minSpeed) {
|
||
// Too slow: pause until speed is sufficient
|
||
return 0;
|
||
}
|
||
|
||
return Math.min(maxSpeed, speed);
|
||
}
|
||
}
|
||
|
||
/** Fetch passing data from the server and update simulation. */
|
||
const updateData = async courses => {
|
||
const dataset = (await axios.get(`${server}/courses`)).data;
|
||
|
||
// Update or create new courses
|
||
for (const [id, data] of Object.entries(dataset)) {
|
||
if (id in courses) {
|
||
courses[id].receiveData(data);
|
||
} else {
|
||
const newCourse = new Course(data.id);
|
||
newCourse.receiveData(data);
|
||
courses[id] = newCourse;
|
||
}
|
||
}
|
||
|
||
// Remove stale courses
|
||
for (const id of Object.keys(courses)) {
|
||
if (courses[id].departureStop === courses[id].finalStop) {
|
||
delete courses[id];
|
||
}
|
||
}
|
||
};
|
||
|
||
export const start = () => {
|
||
const courses = {};
|
||
let lastFrame = null;
|
||
let lastUpdate = null;
|
||
|
||
const update = () => {
|
||
const now = Date.now();
|
||
|
||
if (lastUpdate === null || lastUpdate + 5000 <= now) {
|
||
lastUpdate = now;
|
||
updateData(courses);
|
||
}
|
||
|
||
const time = lastFrame === null ? 0 : now - lastFrame;
|
||
lastFrame = now;
|
||
|
||
for (const course of Object.values(courses)) {
|
||
course.update();
|
||
course.move(time);
|
||
}
|
||
};
|
||
|
||
return { courses, update };
|
||
};
|