map.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_MAP_MAP_H
#define FIFE_MAP_MAP_H

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

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

#include "location.h"

namespace FIFE {

    class RendererBase;
    class RenderBackend;
    class Layer;
    class CellGrid;
    class Map;
    class Camera;
    class Instance;
    class TriggerController;

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

        virtual void onMapChanged(Map* map, std::vector<Layer*>& changedLayers) = 0;

        virtual void onLayerCreate(Map* map, Layer* layer) = 0;

        virtual void onLayerDelete(Map* map, Layer* layer) = 0;
    };

    class Map : public FifeClass {
        public:

            Map(const std::string& identifier, RenderBackend* renderbackend,
                const std::vector<RendererBase*>& renderers, TimeProvider* tp_master=NULL);

            ~Map();

            const std::string& getId() const { return m_id; }

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

            Layer* createLayer(const std::string& identifier, CellGrid* grid);

            void deleteLayer(Layer*);

            const std::list<Layer*>& getLayers() const { return m_layers; }

            Layer* getLayer(const std::string& identifier);

            uint32_t getLayerCount() const;

            void deleteLayers();

            void getMinMaxCoordinates(ExactModelCoordinate& min, ExactModelCoordinate& max);

            bool update();

            void setTimeMultiplier(float multip) { m_timeProvider.setMultiplier(multip); }

            float getTimeMultiplier() const { return m_timeProvider.getMultiplier(); }

            TimeProvider* getTimeProvider() { return &m_timeProvider; }

            void addChangeListener(MapChangeListener* listener);

            void removeChangeListener(MapChangeListener* listener);

            bool isChanged() { return !m_changedLayers.empty(); }

            std::vector<Layer*>& getChangedLayers() { return m_changedLayers; }

            Camera* addCamera(const std::string& id, const Rect& viewport);

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

            Camera* getCamera(const std::string& id);

            const std::vector<Camera*>& getCameras() const;

            uint32_t getActiveCameraCount() const;

            void setFilename(const std::string& file) { m_filename = file; }
            const std::string& getFilename() const { return m_filename; }

            void addInstanceForTransfer(Instance* instance, const Location& target);

            void removeInstanceForTransfer(Instance* instance);

            void initializeCellCaches();

            void finalizeCellCaches();

            TriggerController* getTriggerController() const { return m_triggerController; };

        private:
            std::string m_id;
            std::string m_filename;

            std::list<Layer*> m_layers;
            TimeProvider m_timeProvider;

            Map(const Map& map);
            Map& operator=(const Map& map);

            std::vector<MapChangeListener*> m_changeListeners;

            std::vector<Layer*> m_changedLayers;

            std::vector<Camera*> m_cameras;

            RenderBackend* m_renderBackend;

            std::vector<RendererBase*> m_renderers;

            bool m_changed;

            std::map<Instance*, Location> m_transferInstances;

            TriggerController* m_triggerController;
    };

}

#endif