cellcache.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_CELLCACHE_H
#define FIFE_CELLCACHE_H

// Standard C++ library includes
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <stack>

// 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"
#include "util/structures/rect.h"
#include "model/metamodel/modelcoords.h"
#include "model/metamodel/object.h"

#include "layer.h"
#include "cell.h"

namespace FIFE {

    class Zone {
    public:
        Zone(uint32_t id);
        
        ~Zone();

        void addCell(Cell* cell);

        void removeCell(Cell* cell);

        void mergeZone(Zone* zone);

        const std::set<Cell*>& getCells() const;

        void resetCells();

        uint32_t getId() const;

        uint32_t getCellCount() const;

        std::vector<Cell*> getTransitionCells(Layer* layer = NULL);

    private:
        uint32_t m_id;
        std::set<Cell*> m_cells;
    };

    class CellCache : public FifeClass {
        public:
            CellCache(Layer* layer);

            ~CellCache();

            void reset();

            void resize();

            void resize(const Rect& rec);

            void createCells();

            void forceUpdate();

            void addCell(Cell* cell);

            Cell* createCell(const ModelCoordinate& mc);

            Cell* getCell(const ModelCoordinate& mc);

            const std::vector<std::vector<Cell*> >& getCells();

            void removeCell(Cell* cell);

            void addInteractOnRuntime(Layer* interact);

            void removeInteractOnRuntime(Layer* interact);

            LayerChangeListener* getCellCacheChangeListener();

            Layer* getLayer();

            const Rect& getSize();

            void setSize(const Rect& rec);

            uint32_t getWidth();

            uint32_t getHeight();

            bool isInCellCache(const Location& location) const;

            int32_t convertCoordToInt(const ModelCoordinate& coord) const;
            
            ModelCoordinate convertIntToCoord(const int32_t cell) const;

            int32_t getMaxIndex() const;

            void setMaxNeighborZ(int32_t z);

            int32_t getMaxNeighborZ();

            std::vector<Cell*> getCellsInLine(const ModelCoordinate& pt1, const ModelCoordinate& pt2, bool blocker = false);

            std::vector<Cell*> getCellsInRect(const Rect& rec);

            std::vector<Cell*> getBlockingCellsInRect(const Rect& rec);

            std::vector<Cell*> getCellsInCircle(const ModelCoordinate& center, uint16_t radius);

            std::vector<Cell*> getCellsInCircleSegment(const ModelCoordinate& center, uint16_t radius, int32_t sangle, int32_t eangle);

            void registerCost(const std::string& costId, double cost);

            void unregisterCost(const std::string& costId);

            double getCost(const std::string& costId);

            bool existsCost(const std::string& costId);

            std::list<std::string> getCosts();

            void unregisterAllCosts();

            void addCellToCost(const std::string& costId, Cell* cell);

            void addCellsToCost(const std::string& costId, const std::vector<Cell*>& cells);

            void removeCellFromCost(Cell* cell);

            void removeCellFromCost(const std::string& costId, Cell* cell);

            void removeCellsFromCost(const std::string& costId, const std::vector<Cell*>& cells);

            std::vector<Cell*> getCostCells(const std::string& costId);

            std::vector<std::string> getCellCosts(Cell* cell);

            bool existsCostForCell(const std::string& costId, Cell* cell);

            double getAdjacentCost(const ModelCoordinate& adjacent, const ModelCoordinate& next);

            double getAdjacentCost(const ModelCoordinate& adjacent, const ModelCoordinate& next, const std::string& costId);

            bool getCellSpeedMultiplier(const ModelCoordinate& cell, double& multiplier);

            void setDefaultCostMultiplier(double multi);

            double getDefaultCostMultiplier();

            void setDefaultSpeedMultiplier(double multi);

            double getDefaultSpeedMultiplier();

            bool isDefaultCost(Cell* cell);

            void setCostMultiplier(Cell* cell, double multi);

            double getCostMultiplier(Cell* cell);

            void resetCostMultiplier(Cell* cell);

            bool isDefaultSpeed(Cell* cell);

            void setSpeedMultiplier(Cell* cell, double multi);

            double getSpeedMultiplier(Cell* cell);

            void resetSpeedMultiplier(Cell* cell);

            void addTransition(Cell* cell);

            void removeTransition(Cell* cell);

            std::vector<Cell*> getTransitionCells(Layer* layer = NULL);

            const std::vector<Zone*>& getZones();

            Zone* getZone(uint32_t id);

            Zone* createZone();

            void removeZone(Zone* zone);

            void splitZone(Cell* cell);

            void mergeZones(Zone* zone1, Zone* zone2);

            void addNarrowCell(Cell* cell);

            const std::set<Cell*>& getNarrowCells();

            void removeNarrowCell(Cell* cell);

            void resetNarrowCells();

            bool isSearchNarrowCells();

            void setSearchNarrowCells(bool search);

            void addCellToArea(const std::string& id, Cell* cell);

            void addCellsToArea(const std::string& id, const std::vector<Cell*>& cells);

            void removeCellFromArea(Cell* cell);

            void removeCellFromArea(const std::string& id, Cell* cell);

            void removeCellsFromArea(const std::string& id, const std::vector<Cell*>& cells);

            void removeArea(const std::string& id);

            bool existsArea(const std::string& id);

            std::vector<std::string> getAreas();

            std::vector<std::string> getCellAreas(Cell* cell);

            std::vector<Cell*> getAreaCells(const std::string& id);

            bool isCellInArea(const std::string& id, Cell* cell);

            void setStaticSize(bool staticSize);

            bool isStaticSize();

            void setBlockingUpdate(bool update);
            void setSizeUpdate(bool update);
            void update();
        private:
            typedef std::multimap<std::string, Cell*> StringCellMultimap;
            typedef StringCellMultimap::iterator StringCellIterator;
            typedef std::pair<StringCellIterator, StringCellIterator> StringCellPair;

            Rect calculateCurrentSize();
            
            Layer* m_layer;

            double m_defaultCostMulti;

            double m_defaultSpeedMulti;

            LayerChangeListener* m_cellListener;

            // cells on this cache
            std::vector<std::vector<Cell*> > m_cells;

            Rect m_size;
            
            uint32_t m_width;

            uint32_t m_height;

            int32_t m_neighborZ;

            bool m_blockingUpdate;

            bool m_sizeUpdate;

            bool m_searchNarrow;

            bool m_staticSize;

            std::vector<Cell*> m_transitions;

            std::vector<Zone*> m_zones;

            std::set<Cell*> m_narrowCells;

            StringCellMultimap m_cellAreas;

            CellChangeListener* m_cellZoneListener;

            std::map<std::string, double> m_costsTable;

            StringCellMultimap m_costsToCells;

            std::map<Cell*, double> m_costMultipliers;

            std::map<Cell*, double> m_speedMultipliers;
    };

} // FIFE

#endif