Sort passings, improve simulation

* use DFS to find path when passings are missing
* give passings sorted by increasing time

src/tam/network.js

@@ -88,7 +88,8 @@ a “ref” tag`);
                             stop.lat
                         ], {
                             name: stop.tags.name,
-                            routes: [[lineRef, routeRef]]
+                            routes: [[lineRef, routeRef]],
+                            successors: [],
                         });
                     } else {
                         stops[stop.tags.ref].properties.routes.push([
@@ -223,6 +224,7 @@ different sequence of nodes in two or more lines.`);
                         routes: [[lineRef, routeRef]]
                     });
 
+                    stops[begin].properties.successors.push(end);
                     segments[id].properties.length = (
                         1000 * turfLength(segments[id]));
                 }

src/tam/realtime.js

@@ -13,8 +13,9 @@ let currentCourses = null;
  * @property {string} id Unique identifier for this course.
  * @property {string} line Transport line number.
  * @property {string} finalStop Final stop to which the course is headed.
- * @property {Object.<string,number>} nextPassings Next stations to which
+ * @property {Array.<Array>} nextPassings Next stations to which
- * the vehicle will stop, associated to the passing timestamp.
+ * the vehicle will stop, associated to the passing timestamp, ordered by
+ * increasing passing timestamp.
  */
 
 /**
@@ -52,10 +53,10 @@ const fetch = async() => {
                     id,
                     line,
                     finalStop,
-                    nextPassings: { [stopId]: arrivalTime }
+                    nextPassings: [[stopId, arrivalTime]]
                 };
             } else {
-                courses[id].nextPassings[stopId] = arrivalTime;
+                courses[id].nextPassings.push([stopId, arrivalTime]);
             }
         }
 
@@ -66,7 +67,7 @@ const fetch = async() => {
             if (!(course.line in network.lines)) {
                 delete courses[courseId];
             } else {
-                for (const stopId of Object.keys(course.nextPassings)) {
+                for (const [stopId,] of course.nextPassings) {
                     if (!(stopId in network.stops)) {
                         delete courses[courseId];
                         break;
@@ -75,6 +76,13 @@ const fetch = async() => {
             }
         }
 
+        // Order next passings by increasing passing time
+        for (const courseId of Object.keys(courses)) {
+            courses[courseId].nextPassings.sort(
+                ([, time1], [, time2]) => time1 - time2
+            );
+        }
+
         currentCourses = courses;
     }
 

src/tam/simulation.js

@@ -5,14 +5,38 @@ const network = require("./network.json");
 
 const server = "http://localhost:4321";
 
+const stops = Object.keys(network.stops);
+
+const findRoute = (from, to) => {
+    const queue = [[from, []]];
+
+    while (queue.length) {
+        const [head, path] = queue.shift();
+
+        for (const successor of network.stops[head].properties.successors) {
+            if (successor === to) {
+                return path.concat([head, successor]);
+            }
+
+            if (!path.includes(successor)) {
+                queue.push([successor, path.concat([head])]);
+            }
+        }
+    }
+
+    return null;
+};
+
 class Course {
     constructor(data) {
         this.id = data.id;
-        this.passings = {};
+        this.prevPassings = [];
+        this.nextPassings = [];
         this.state = null;
 
         // Attributes for the `stopped` state
         this.currentStop = null;
+        this.departureTime = 0;
 
         // Attributes for the `moving` state
         this.departureStop = null;
@@ -38,76 +62,118 @@ class Course {
     updateData(data) {
         this.line = data.line;
         this.finalStop = data.finalStop;
-        Object.assign(this.passings, data.nextPassings);
+        this.nextPassings = data.nextPassings;
 
         const now = Date.now();
 
-        // Make sure we’re on the right `stopped`/`moving` state
         if (this.state === null) {
-            let previousStop = null;
+            // Initialize the course on the first available segment
-            let departureTime = 0;
+            const index = this.nextPassings.findIndex(
+                ([, time]) => time >= now
+            );
 
-            let nextStop = null;
+            if (index === -1) {
-            let arrivalTime = Infinity;
-
-            for (const [stopId, time] of Object.entries(this.passings)) {
-                if (time > now && time < arrivalTime) {
-                    nextStop = stopId;
-                    arrivalTime = time;
-                }
-
-                if (time < now && time > departureTime) {
-                    previousStop = stopId;
-                    departureTime = time;
-                }
-            }
-
-            if (nextStop === null) {
                 return false;
             }
 
-            if (previousStop === null) {
+            if (index === 0) {
-                // Teleport to the first known stop
+                this.arriveToStop(this.nextPassings[index][0]);
-                this.arriveToStop(nextStop);
             } else {
-
+                this.arriveToStop(this.nextPassings[index - 1][0]);
-                // Teleport to the first known segment
+                this.moveToStop(...this.nextPassings[index]);
-                this.arriveToStop(previousStop);
-                this.moveToStop(nextStop, arrivalTime);
             }
         } else if (this.state === "moving") {
-            if (this.passings[this.arrivalStop] <= now) {
+            const index = this.nextPassings.findIndex(
-                // Should already be at the next stop
+                ([stop, ]) => stop === this.arrivalStop
-                this.arriveToStop(this.arrivalStop);
+            );
+
+            if (index === -1 || this.nextPassings[index][1] <= now) {
+                // Next stop is not announced or in the past,
+                // move towards it as fast as possible
+                this.arrivalTime = now;
             } else {
                 // On the right track, update the arrival time
-                this.arrivalTime = this.passings[this.arrivalStop];
+                this.arrivalTime = this.nextPassings[index][1];
             }
         } else {
             // (this.state === 'stopped')
             // Try moving to the next stop
-            let nextStop = null;
+            const index = this.nextPassings.findIndex(
-            let arrivalTime = Infinity;
+                ([stop, ]) => stop === this.currentStop
+            );
 
-            for (const [stopId, time] of Object.entries(this.passings)) {
+            if (index !== -1) {
-                if (time > now && time < arrivalTime) {
+                if (this.nextPassings[index][1] <= now) {
-                    nextStop = stopId;
+                    // Current stop is still announced but in the past
-                    arrivalTime = time;
+                    if (index + 1 < this.nextPassings.length) {
-                }
+                        // Move to next stop
-            }
+                        this.moveToStop(...this.nextPassings[index + 1]);
-
+                    } else {
-            if (nextStop === null) {
+                        // No next stop announced, end of course
-                // This course is finished
                         return false;
                     }
+                } else {
+                    // Cannot move yet, departure is in the future
+                    this.departureTime = this.nextPassings[index][1];
+                }
+            } else {
+                // Current stop is not announced, find the first stop
+                // announced in the future to which is connection is
+                // possible
+                let found = false;
 
-            if (nextStop !== this.currentStop) {
+                for (
-                this.moveToStop(nextStop, arrivalTime);
+                    let index = 0;
+                    index < this.nextPassings.length;
+                    ++index
+                ) {
+                    const [stop, arrivalTime] = this.nextPassings[index];
+
+                    if (arrivalTime > now) {
+                        const route = findRoute(this.currentStop, stop);
+
+                        if (route !== null) {
+                            // Move to the first intermediate stop, guess the
+                            // arrival time based on the final arrival time and
+                            // the relative distance of the stops
+                            const midDistance = network.segments[
+                                `${route[0]}-${route[1]}`
+                            ].properties.length;
+
+                            let totalDistance = midDistance;
+
+                            for (
+                                let midIndex = 1;
+                                midIndex + 1 < route.length;
+                                ++midIndex
+                            ) {
+                                totalDistance += network.segments[
+                                    `${route[midIndex]}-${route[midIndex + 1]}`
+                                ].properties.length;
+                            }
+
+                            const midTime = now + (arrivalTime - now) *
+                                midDistance / totalDistance;
+
+                            this.moveToStop(route[1], midTime);
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (!found) {
+                    // No valid next stop available
+                    return false;
+                }
             }
         }
 
         if (this.state === "moving") {
-            this.speed = this.computeTheoreticalSpeed();
+            const segment = this.currentSegment;
+            const distance = segment.properties.length - this.traveledDistance;
+            const duration = this.arrivalTime - Date.now();
+            this.speed = this.computeSpeed(distance, duration);
         }
 
         return true;
@@ -115,7 +181,6 @@ class Course {
 
     tick(time) {
         if (this.state === "moving") {
-
             // Integrate current speed in travelled distance
             this.traveledDistance += this.speed * time;
             const segment = this.currentSegment;
@@ -155,10 +220,12 @@ class Course {
     arriveToStop(stop) {
         this.state = "stopped";
         this.currentStop = stop;
+        this.departureTime = Date.now();
+        this.prevPassings.push([stop, Date.now()]);
         this.position = (
             turfProjection.toMercator(network.stops[stop])
-                .geometry.coordinates);
+                .geometry.coordinates
-        this.history.push(["arriveToStop", stop]);
+        );
     }
 
     /**
@@ -168,49 +235,43 @@ class Course {
      * @returns {undefined}
      */
     moveToStop(stop, arrivalTime) {
-        if (!(`${this.currentStop}-${stop}` in network.segments)) {
+        const segmentId = `${this.currentStop}-${stop}`;
+
+        if (!(segmentId in network.segments)) {
             console.warn(`Course ${this.id} cannot go from stop
 ${this.currentStop} to stop ${stop}. Teleporting to ${stop}`);
             this.arriveToStop(stop);
             return;
         }
 
+        const distance = network.segments[segmentId].properties.length;
+        const duration = arrivalTime - Date.now();
+
+        if (this.computeSpeed(distance, duration) === 0) {
+            // Speed would be too low, better wait for some time
+            return;
+        }
+
         this.state = "moving";
         this.departureStop = this.currentStop;
         this.arrivalStop = stop;
         this.arrivalTime = arrivalTime;
         this.traveledDistance = 0;
         this.speed = 0;
-        this.history.push(["moveToStop", stop, arrivalTime]);
-
-        console.info(`Course ${this.id} leaving stop ${this.currentStop} \
-with initial speed ${this.computeTheoreticalSpeed() * 3600} km/h`);
     }
 
-    /**
+    computeSpeed(distance, duration) {
-     * Compute the speed that needs to be maintained to arrive on time.
+        if (duration <= 0) {
-     * @returns {number} Speed in meters per millisecond.
+            // Late: go to maximum speed
-     */
+            return 50 / 3600;
-    computeTheoreticalSpeed() {
+        }
-        if (this.state !== "moving") {
+
+        if (distance / duration <= 10 / 3600) {
+            // Too slow: pause until speed is sufficient
             return 0;
         }
 
-        const segment = this.currentSegment;
+        return distance / duration;
-        const remainingTime = this.arrivalTime - Date.now();
-        const remainingDistance = (
-            segment.properties.length - this.traveledDistance
-        );
-
-        if (remainingDistance <= 0) {
-            return 0;
-        }
-        if (remainingTime <= 0) {
-            // We’re late, go to maximum speed
-            return 50 / 3600; // 50 km/h
-        }
-
-        return remainingDistance / remainingTime;
     }
 }
 
@@ -221,16 +282,12 @@ const updateData = async courses => {
     for (const [id, data] of Object.entries(dataset)) {
         if (id in courses) {
             if (!courses[id].updateData(data)) {
-                console.info(`Course ${id} is finished.`);
                 delete courses[id];
             }
         } else {
             const newCourse = new Course(data);
 
-            if (!newCourse.updateData(data)) {
+            if (newCourse.updateData(data)) {
-                console.info(`Ignoring course ${id} which is outdated.`);
-            } else {
-                console.info(`Course ${id} starting.`);
                 courses[id] = newCourse;
             }
         }