b-engine-node-map v5.1.4

Road-Map

Example

import { NodeMapTemplateTransformer } from "./NodeMapTemplateTransformer";
import { PathFinding } from "./helper/PathFinding";
import { NodePathModel } from "./helper/model/NodePathModel";

const nodeMapTemplateTransformer = new NodeMapTemplateTransformer();

/// TEMPLATE -- Will add a generator for this soon :)

const template: INodeMapTemplate = {
    nodes: [
        {
            id: 'node1',
            location: {
                x: 100,
                y: 100,
            }
        },
        {
            id: 'node2',
            location: {
                x: 600,
                y: 100,
            }
        },
        {
            id: 'node3',
            location: {
                x: 1000,
                y: 100,
            }
        },
        {
            id: 'node4',
            location: {
                x: 1200,
                y: 100,
            }
        },
    ],
    paths: [
        {
            id: 'node1<->node2',
            bidirectional: true,
            startNodeId: 'node1',
            endNodeId: 'node2',
            distance: 3,
        },
        {
            id: 'node3<->node2',
            bidirectional: false,
            startNodeId: 'node3',
            endNodeId: 'node2',
            distance: 4,
        },
        {
            id: 'node2<->node3',
            bidirectional: false,
            startNodeId: 'node2',
            endNodeId: 'node3',
            distance: 3,
        },
        {
            id: 'node3<->node4',
            bidirectional: true,
            startNodeId: 'node3',
            endNodeId: 'node4',
            distance: 3,
        },
    ]
}

////////////////////////////////////// --- END TEMPLATE

// Get the nodes and paths by processing a template
const { nodeList, pathList } = nodeMapTemplateTransformer.process(template);

// Some code to show you how to get the total cost of a route
const reducer = (accumulator: number, currentValue: number) => accumulator + currentValue;
const calcResultCost = (data: NodePathModel[]) => {
    return data.map(v => ((!v.path) ? 0 : v.path.data.distance)).reduce(reducer);
}

// the route looks like this: --<>- and we will drive both ways

const start = nodeList.find('node1');
const end = nodeList.find('node4');

const result = PathFinding.getShortestPath(start, end);
console.log(calcResultCost(result as any)); // 9

// Different cost because
const resultBack = PathFinding.getShortestPath(end, start);
console.log(calcResultCost(resultBack as any)); // 10