one_direction_sync_path_finder.h

#pragma once
 
#include <memory>
#include <unordered_map>
#include <set>
#include <utility>
#include <unordered_set>
#include <base/grid_path_finder.h>
#include <future>
#include <solid_collider.h>
#include "solid_sync_collider.h"
#include "scene.h"
#include "one_direction_path_finder.h"
 
namespace bmpf {
    class OneDirectionSyncPathFinder : public OneDirectionPathFinder {
    public:
        OneDirectionSyncPathFinder(const std::shared_ptr<bmpf::Scene> &scene,
                                   bool showTrace,
                                   unsigned int maxOpenSetSize,
                                   int gridSize,
                                   unsigned int maxNodeCnt,
                                   unsigned int kG = 1,
                                   unsigned int kD = 0,
                                   int threadCnt = 1)
                : OneDirectionPathFinder(scene, showTrace, maxOpenSetSize, gridSize, maxNodeCnt, kG, kD, threadCnt) {
 
            // инициализируем многопоточный коллайдер
            _collider = std::make_shared<bmpf::SolidSyncCollider>(threadCnt);
            _collider->init(scene->getGroupedModelPaths(), false);
 
            // разбиваем смещения по пакетам
            std::vector<std::vector<int>> group;
            int cnt = 0;
            for (auto &offset: _offsetList) {
                group.emplace_back(offset);
                cnt++;
                if (cnt >= threadCnt) {
                    _groupedOffsetList.emplace_back(group);
                    group.clear();
                    cnt = 0;
                }
 
            }
        };
 
    protected:
 
        std::shared_ptr<PathNode> _forEachNeighbor(
                std::shared_ptr<PathNode> currentNode,
                std::vector<int> &endCoords
        ) override;
 
        std::vector<std::vector<std::vector<int>>> _groupedOffsetList;
    };
 
}