@cocacola-lover/knight_path_finder/dist/searchAlgorithms.js

Iterative path finding Algorithms for knight on a chessboard

import ChessPointer from "./chess_pointer.js";
import { SearchResult } from "./interfaces.js";
import OrderedLinkedList from "./ordered_linked_list.js";
var BasicPointer = ChessPointer.BasicPointer;
var PathFindingIterators;
(function (PathFindingIterators) {
    function baseSearchIterator({ start, end, orderFunction }) {
        start.at().distanceFromStart = 0;
        let queue = new OrderedLinkedList(orderFunction, [start]);
        const explored = new Set();
        const iterate = () => {
            if (queue.isEmpty())
                return { result: SearchResult.TargetNotFound };
            let pointer;
            while (true) {
                if (queue.pickIn() === undefined)
                    return { result: SearchResult.TargetNotFound };
                if (BasicPointer.areSame(queue.pickIn(), end))
                    return { result: SearchResult.TargetFound };
                pointer = queue.shift();
                if (explored.has(pointer.toString())) {
                    continue;
                }
                else {
                    break;
                }
            }
            explored.add(pointer.toString());
            const neighbours = pointer.getPassableNeighbours();
            for (let i = 0; i < neighbours.length; i++) {
                const neighbour = neighbours[i];
                if (neighbour.at().distanceFromStart !== undefined &&
                    neighbour.at().distanceFromStart < (pointer.at().distanceFromStart + 1))
                    continue;
                neighbour.at().distanceFromStart = pointer.at().distanceFromStart + 1;
                neighbour.at().shortestPath = pointer;
            }
            let checkIfEndFound = false;
            (neighbours.filter((neighbour) => !explored.has(neighbour.toString())))
                .forEach((neighbour) => {
                if (BasicPointer.areSame(neighbour, end)) {
                    queue = new OrderedLinkedList(orderFunction, [end]);
                    checkIfEndFound = true;
                }
                if (!checkIfEndFound)
                    queue.add(neighbour);
            });
            return { result: SearchResult.SearchContinues, from: pointer.at().shortestPath, to: pointer };
        };
        return iterate;
    }
    function deepFirstSearchIterator(start, end) {
        return baseSearchIterator({ start, end, orderFunction: (a, b) => {
                return -1;
            } });
    }
    PathFindingIterators.deepFirstSearchIterator = deepFirstSearchIterator;
    function dijkstraSearchIterator(start, end) {
        return baseSearchIterator({ start, end, orderFunction: (a, b) => {
                const aweight = a.at().weight;
                const bweight = b.at().weight;
                if (bweight === aweight)
                    return 1;
                return aweight - bweight;
            } });
    }
    PathFindingIterators.dijkstraSearchIterator = dijkstraSearchIterator;
    function greedySearchIterator(start, end) {
        return baseSearchIterator({ start, end, orderFunction: (a, b) => {
                const getDistanse = (a, b) => {
                    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
                };
                return getDistanse(a, end) - getDistanse(b, end);
            } });
    }
    PathFindingIterators.greedySearchIterator = greedySearchIterator;
    function aStarSearchIterator(start, end) {
        return baseSearchIterator({ start, end, orderFunction: (a, b) => {
                const getDistanse = (a, b) => {
                    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
                };
                return (getDistanse(a, end) + getDistanse(a, start)) - (getDistanse(b, end) + getDistanse(b, start));
            } });
    }
    PathFindingIterators.aStarSearchIterator = aStarSearchIterator;
})(PathFindingIterators || (PathFindingIterators = {}));
export default PathFindingIterators;
//# sourceMappingURL=searchAlgorithms.js.map