layer.h

/***************************************************************************
 *   Copyright (C) 2005-2008 by the FIFE team                              *
 *   http://www.fifengine.de                                               *
 *   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 Selection;
    class CellGrid;
    class Object;
    class InstanceTree;

    enum PathingStrategy {
        CELL_EDGES_ONLY,
        CELL_EDGES_AND_DIAGONALS,
        FREEFORM
    };

    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 { return m_id; }

            void setId(const std::string& id) { m_id = id; }

            Map* getMap() const { return m_map; }

            CellGrid* getCellGrid() const { return m_grid; }

            void setCellGrid(CellGrid* grid) { m_grid = grid; }

            InstanceTree* getInstanceTree(void) const { return m_instanceTree; }

            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 deleteInstance(Instance* object);

            const std::vector<Instance*>& getInstances() const { return m_instances; }

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

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

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

            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;

            bool cellContainsBlockingInstance(const ModelCoordinate& cellCoordinate);

            void toggleInstancesVisible();

            bool areInstancesVisible() const { return m_instances_visibility; }

            bool update();

            void setPathingStrategy(PathingStrategy strategy) { m_pathingstrategy = strategy; }

            PathingStrategy getPathingStrategy() const { return m_pathingstrategy; }

            void addChangeListener(LayerChangeListener* listener);

            void removeChangeListener(LayerChangeListener* listener);

            bool isChanged() { return m_changed; }

            std::vector<Instance*>& getChangedInstances() { return m_changedinstances; }

            void setInstanceActivityStatus(Instance* instance, bool active);

        protected:
            std::string m_id;

            Map* m_map;

            bool m_instances_visibility;

            uint8_t m_transparency;

            // all the instances on this layer
            std::vector<Instance*> m_instances;

            // all the active instances on this layer
            std::set<Instance*> m_active_instances;

            //The instance tree
            InstanceTree* m_instanceTree;

            // layer's cellgrid
            CellGrid* m_grid;

            // pathing strategy for the layer
            PathingStrategy m_pathingstrategy;

            // listeners for layer changes
            std::vector<LayerChangeListener*> m_changelisteners;

            // holds changed instances after each update
            std::vector<Instance*> m_changedinstances;

            // true if layer (or it's instance) information was changed during previous update round
            bool m_changed;
    };

} // FIFE

#endif