PFManager.h

Go to the documentation of this file.

//    Copyright (C) 2004-2011 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef PFMANAGER_H
#define PFMANAGER_H

#include "../Math_LIB/MPath.h"
#include "../Math_LIB/MInterpolator.h"
#include "../Utils_LIB/UPrecisionTimer.h"

#include "PFAStar.h"
#include "PFQueue.h"
#ifdef PF_USES_WPC
#include "PFWaypointCollection.h"
#endif

namespace OpenSkyNet {
    namespace PF {
        class Manager {
        public:
            enum ALGORITHM { BFS, A_STAR };
        private:
            CD::Grid* _grid;

            const Math::Point<>* _driver;
            const CD::Volume* _drivBoundingVolume;
            Math::Point<int> _prevDrivBin;

            const Math::Point<>* _target;
            const CD::Volume* _targBoundingVolume;
            float _targetRadiusSqrd;
            Math::Point<int> _prevTargBin;

            bool _isDriverPathControlled;
            Math::Path** _drivPath;

            Math::Path _foundPath;

            void createRelativePath(const std::vector<CD::DIRECTION>& pathDirs_);
            void createRelativePath(const std::vector<DirOrPath>& dirsOrPaths_);

            inline void decrementDriverAndTargetBins() {
                Utils::uint i;
                for (i = 1; i < _drivBins.size(); i++) _grid->decrementBin(_drivBins[i]);
                for (i = 1; i < _targBins.size(); i++) _grid->decrementBin(_targBins[i]);
            }

            inline void incrementDriverAndTargetBins() {
                Utils::uint i;
                for (i = 1; i < _drivBins.size(); i++) _grid->incrementBin(_drivBins[i]);
                for (i = 1; i < _targBins.size(); i++) _grid->incrementBin(_targBins[i]);
            }

            double _timeStampIsStuckPrev;
            double _timeStampIsStuckCurr;
            double _numSecsWithSameDrivBin;

            bool _attemptedDirs[CD::POS_X_POS_Y_POS_Z+1];
            inline void clearAttemptedDirs() {
                memset((void*)&_attemptedDirs,0,sizeof(bool)*(CD::POS_X_POS_Y_POS_Z+1));
                _attemptedDirs[CD::NONE] = true;
            }

            Manager::ALGORITHM _algo;

            bool _continuing;
            double _timeStampBegin;

            std::vector<Math::Point<int> > _drivBins, _targBins;
            Math::Point<> _currDriver, _currTarget;

#ifdef PF_USES_WPC
            const std::map<const CD::Volume*, WaypointCollection*>* _volWPCMap;
#endif

            PriorityQueue _prioQ;
            Queue _q;

            RESULT findPathAStar(double secsAllotted_=-1.0);
            RESULT findPathBFS(double secsAllotted_=-1.0);
        public:
            Manager();


            inline void setDriver(const Math::Point<>* driver_, const CD::Volume* drivBoundingVolume_) {
                _driver = driver_;
                _drivBoundingVolume = drivBoundingVolume_;
            }

            inline void setTarget(const Math::Point<>* target_, const CD::Volume* targBoundingVolume_, 
                float targetRadius_=-1.0f) {
                _target = target_;
                _targBoundingVolume = targBoundingVolume_;
                if (targetRadius_ < 0.0f)
                    _targetRadiusSqrd = _targBoundingVolume->getBoundingRadius() * 
                                        _targBoundingVolume->getBoundingRadius();
                else
                    _targetRadiusSqrd = targetRadius_ * targetRadius_;
            }

#ifdef PF_USES_WPC
            inline void setWPCs(const std::map<const CD::Volume*, WaypointCollection*>* volWPCMap_) { _volWPCMap = volWPCMap_; }
#endif


            virtual ~Manager();

            virtual RESULT calcDriverAndTargetBins(std::vector<Math::Point<int> >& drivBins_, std::vector<Math::Point<int> >& targBins_, bool calcPositions_=false, bool useInitialGrid_=false);
            inline RESULT calcDriverAndTargetBins(bool calcPositions_=false, bool useInitialGrid_=false) {
                return calcDriverAndTargetBins(_drivBins,_targBins,calcPositions_,useInitialGrid_);
            }

            inline const std::vector<Math::Point<int> >& getDriverBins() const { return _drivBins; }
            inline const std::vector<Math::Point<int> >& getTargetBins() const { return _targBins; }

            inline const Math::Point<>* getDriver() const { return _driver; }

            inline const Math::Point<>* getTarget() const { return _target; }

            inline const CD::Grid* getGrid() const { return _grid; }

            inline void controlDriverPath(Math::Path*& drivPath_) {
                _drivPath = &drivPath_;
                _isDriverPathControlled = true;
            }
            inline bool controlDriverPath() {
                if (!_drivPath) return false;
                _isDriverPathControlled = true;
                return true;
            }
            inline void releaseDriverPath() { _isDriverPathControlled = false; }
            inline bool isDriverPathControlled() const { return _isDriverPathControlled; }

            inline Math::Path& getFoundPath() { return _foundPath; }

            virtual bool isStuck();

            virtual RESULT findPath(Manager::ALGORITHM algo_=Manager::A_STAR, bool doUpdateMaxCorner_=true, double secsAllotted_=-1.0);

            void resetPathfindingVars();

            bool isDriverBinOutsideGrid() const;

            bool isTargetBinOutsideGrid() const;
        };

        extern Utils::PrecisionTimer g_timer;
    }
}

#endif //PFMANAGER_H