Class Network

The function returns the link's distance value, if specified, or the distance between the link's from and to nodes.

You can override this method to account for congestion along links, turning costs, or temporary flow restrictions.

For example, the code below creates a CongestionNetwork class that accounts for congestion by increasing the calculated distance based on the link's current population:

// network with congestion cost
// assumes the simulation adds entities to the link's queue 
// while they move along each link.
class CongestionNetwork extends Network {
    getLinkDistance(link: ILink, prevLink?: ILink): number {

        // regular distance
        let dist = super.getLinkDistance(link, prevLink);

        // add congestion cost
        dist += dist * link.queue.pop * 0.5;

        // add turning cost
        if (prevLink) {
            const
                a1 = this._getLinkAngle(link),
                a2 = this._getLinkAngle(prevLink);
            let angle = Math.abs(a1 - a2); // turn in radians
            distance += someFunction(angle);
        }

        // done
        return dist;
    }
    _getLinkAngle(link: ILink): number {
        return Point.angle(link.from.position, link.to.position, true);
    }
}

This makes it possible for entities to traverse the whole path with a single delay. For example:

// select from/to nodes
const from = sim.network.nodes[0];
const to = sim.network.nodes[10];

// get shortest path
const path = sim.network.shortestPath(from, to);

// merge the path into a list of queues
const [queues, distance] = sim.network.mergePath(path);

// traverse the whole path with a single delay
await this.delay(distance / sim.speed.sample(), {
    queues: queues,
    tension: 0.5
});

The shortestPath method returns an array of ILink objects that represent the shortest path between two network ILink objects.

If a path between the nodes cannot be found, the method returns an empty array.

The example below shows how you to move an Entity between to nodes on a Network:

class Vehicle extends Entity {
    async script() {

        // get a reference to the simulation
        const sim = this.simulation as NetworkIntro;

        // select from/to nodes
        const from = sim.network.nodes[0];
        const to = sim.network.nodes[10];

        // calculate the shortest path
        const path = sim.network.shortestPath(from, to);
        assert(path.length > 0, 'cannot reach destination');

        // move along the path one link at a time
        for (let i = 0; i < path.length; i++) {
            const link = path[i];
            const distance = sim.network.getLinkDistance(link, i > 0 ? path[i - 1] : null);
            const time = distance / sim.serviceVehicleSpeed.sample();
            await this.delay(time, {
                queues: [link.from.queue, link.to.queue] // used in animations
            });
        }
    }
}

You can also use the mergePath method to get a list of queues that make up the path and the total path distance, and use those elements to travel the entire path with a single delay:

// calculate the shortest path
const path = sim.network.shortestPath(from, to);
assert(path.length > 0, 'cannot reach destination');

// merge the path into a list of queues
const [queues, distance] = sim.network.mergePath(path);

// traverse the whole path with a single delay
await this.delay(distance / sim.speed.sample(), {
    queues: queues,
    tension: 0.5
});