layer.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2013 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_LAYER_H
#define FIFE_LAYER_H

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

// 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 "instance.h"

namespace FIFE {

    class Map;
    class CellGrid;
    class Object;
    class InstanceTree;
    class CellCache;
    class Trigger;

    enum PathingStrategy {
        CELL_EDGES_ONLY,
        CELL_EDGES_AND_DIAGONALS
    };

    enum SortingStrategy {
        SORTING_CAMERA,
        SORTING_LOCATION,
        SORTING_CAMERA_AND_LOCATION
    };

    class LayerChangeListener {
    public:
        virtual ~LayerChangeListener() {};

        virtual void onLayerChanged(Layer* layer, std::vector<Instance*>& changedInstances) = 0;

        virtual void onInstanceCreate(Layer* layer, Instance* instance) = 0;

        virtual void onInstanceDelete(Layer* layer, Instance* instance) = 0;
    };


    class Layer : public FifeClass {
        public:
            Layer(const std::string& identifier, Map* map, CellGrid* grid);

            ~Layer();

            const std::string& getId() const;

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

            Map* getMap() const;

            CellGrid* getCellGrid() const;

            void setCellGrid(CellGrid* grid);

            InstanceTree* getInstanceTree(void) const;

            bool hasInstances() const;

            Instance* createInstance(Object* object, const ModelCoordinate& p, const std::string& id="");

            Instance* createInstance(Object* object, const ExactModelCoordinate& p, const std::string& id="");

            bool addInstance(Instance* instance, const ExactModelCoordinate& p);

            void removeInstance(Instance* instance);

            void deleteInstance(Instance* instance);

            const std::vector<Instance*>& getInstances() const;

            std::vector<Instance*> getInstances(const std::string& id);

            std::vector<Instance*> getInstancesAt(Location& loc, bool use_exactcoordinates=false);

            std::list<Instance*> getInstancesIn(Rect& rec);

            std::vector<Instance*> getInstancesInLine(const ModelCoordinate& pt1, const ModelCoordinate& pt2);

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

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

            Instance* getInstance(const std::string& identifier);

            void setInstancesVisible(bool vis);

            void setLayerTransparency(uint8_t transparency);

            uint8_t getLayerTransparency();

            void getMinMaxCoordinates(ModelCoordinate& min, ModelCoordinate& max, const Layer* layer = 0) const;

            float getZOffset() const;

            uint32_t getLayerCount() const;

            bool cellContainsBlockingInstance(const ModelCoordinate& cellCoordinate);

            std::vector<Instance*> getBlockingInstances(const ModelCoordinate& cellCoordinate);

            void toggleInstancesVisible();

            bool areInstancesVisible() const;

            bool update();

            void setPathingStrategy(PathingStrategy strategy);

            PathingStrategy getPathingStrategy() const;

            void setSortingStrategy(SortingStrategy strategy);

            SortingStrategy getSortingStrategy() const;

            void setWalkable(bool walkable);

            bool isWalkable();

            void setInteract(bool interact, const std::string& id);

            bool isInteract();

            const std::string& getWalkableId();

            void addInteractLayer(Layer* layer);

            const std::vector<Layer*>& getInteractLayers();

            void removeInteractLayer(Layer* layer);

            void createCellCache();

            CellCache* getCellCache();

            void destroyCellCache();

            void addChangeListener(LayerChangeListener* listener);

            void removeChangeListener(LayerChangeListener* listener);

            bool isChanged();

            std::vector<Instance*>& getChangedInstances();

            void setInstanceActivityStatus(Instance* instance, bool active);

            void setStatic(bool stati);

            bool isStatic();

        protected:
            std::string m_id;
            Map* m_map;
            bool m_instancesVisibility;
            uint8_t m_transparency;
            std::vector<Instance*> m_instances;
            std::set<Instance*> m_activeInstances;
            InstanceTree* m_instanceTree;
            CellGrid* m_grid;
            PathingStrategy m_pathingStrategy;
            SortingStrategy m_sortingStrategy;
            bool m_walkable;
            bool m_interact;
            std::string m_walkableId;
            std::vector<Layer*> m_interacts;
            CellCache* m_cellCache;
            std::vector<LayerChangeListener*> m_changeListeners;
            std::vector<Instance*> m_changedInstances;
            bool m_changed;
            bool m_static;
    };

} // FIFE

#endif