route.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2019 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE 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.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_ROUTE_H
#define FIFE_ROUTE_H

// Standard C++ library includes
#include <list>

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "util/base/fifeclass.h"

namespace FIFE {

    class Location;
    class Object;

    enum RouteStatus {
        ROUTE_CREATED = 0,
        ROUTE_SEARCHING,
        ROUTE_SEARCHED,
        ROUTE_SOLVED,
        ROUTE_FAILED
    };
    typedef uint8_t RouteStatusInfo;

    typedef std::list<Location> Path;

    class Route : public FifeClass {
    public:
        Route(const Location& start, const Location& end);
        
        ~Route();

        void setRouteStatus(RouteStatusInfo status);

        RouteStatusInfo getRouteStatus();

        void setStartNode(const Location& node);

        const Location& getStartNode();

        void setEndNode(const Location& node);

        const Location& getEndNode();

        const Location& getCurrentNode();

        const Location& getPreviousNode();

        const Location& getNextNode();

        bool walkToNextNode(int32_t step = 1);

        bool reachedEnd();

        void setPath(const Path& path);

        Path getPath();

        void cutPath(uint32_t length = 1);

        void setReplanned(bool replanned);

        bool isReplanned();

        uint32_t getPathLength();

        uint32_t getWalkedLength();

        void setSessionId(int32_t id);

        int32_t getSessionId();

        void setRotation(int32_t rotation);

        int32_t getRotation();

        void setCostId(const std::string& cost);

        const std::string& getCostId();

        bool isMultiCell();

        void setOccupiedArea(const std::vector<ModelCoordinate>& area);

        const std::vector<ModelCoordinate>& getOccupiedArea();

        std::vector<ModelCoordinate> getOccupiedCells(int32_t rotation);

        int32_t getZStepRange();

        bool isAreaLimited();
        const std::list<std::string> getLimitedAreas();

        void setDynamicBlockerIgnored(bool ignore);

        bool isDynamicBlockerIgnored();

        Path getBlockingPathLocations();

        void setObject(Object* obj);

        Object* getObject();

    private:
        typedef Path::iterator PathIterator;

        RouteStatusInfo m_status;

        Location m_startNode;

        Location m_endNode;

        Path m_path;

        PathIterator m_current;

        uint32_t m_walked;

        int32_t m_sessionId;

        int32_t m_rotation;

        bool m_replanned;

        bool m_ignoresBlocker;

        std::string m_costId;

        std::vector<ModelCoordinate> m_area;

        Object* m_object;
    };

} // FIFE

#endif