map.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_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 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 getMatchingCoordinates(const ModelCoordinate& coord_to_map, const Layer* from_layer,
                const Layer* to_layer, std::vector<ModelCoordinate>& matching_coords) const;

            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, Layer *layer, const Rect& viewport);

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

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

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

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

        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);

            // listeners for map changes
            std::vector<MapChangeListener*> m_changelisteners;

            // holds changed layers after each update
            std::vector<Layer*> m_changedlayers;

            // holds the cameras attached to this map
            std::vector<Camera*> m_cameras;

            RenderBackend* m_renderbackend;

            // holds handles to all created renderers
            std::vector<RendererBase*> m_renderers;

            // true, if something was changed on map during previous update (layer change, creation, deletion)
            bool m_changed;
    };

} //FIFE

#endif
/* vim: set noexpandtab: set shiftwidth=2: set tabstop=2: */