/*************************************************************************** * 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 #include #include // 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; /** Listener interface for changes happening on map */ class MapChangeListener { public: virtual ~MapChangeListener() {}; /** Called when some layer is changed on map. @see LayerChangeListener * Layer is effectively changed, in case some of its instances * is created, deleted or changed during latest update cycle * @param map where change occurred * @param changedLayers list of layers containing some changes * @note Does not report layer creations and deletions */ virtual void onMapChanged(Map* map, std::vector& changedLayers) = 0; /** Called when some layer gets created on the map * @param map where change occurred * @param layer which got created */ virtual void onLayerCreate(Map* map, Layer* layer) = 0; /** Called when some layer gets deleted on map * @param map where change occurred * @param layer which will be deleted * @note right after this call, layer actually gets deleted! */ virtual void onLayerDelete(Map* map, Layer* layer) = 0; }; /** A container of \c Layer(s). * * The actual data is contained in \c Layer objects * @see Layer */ class Map : public FifeClass { public: /** Construct a map * To add map to model, one should call Model::addMap (otherwise * map is not registered with the engine properly) */ Map(const std::string& identifier, RenderBackend* renderbackend, const std::vector& renderers, TimeProvider* tp_master=NULL); /** Destructor */ ~Map(); /** Get the identifier for this map. */ const std::string& getId() const { return m_id; } /** Sets the identifier for this map. */ void setId(const std::string& id) { m_id = id; } /** Add a Layer to this Map. Map owns the returned pointer to the new Layer, so don't delete it! */ Layer* createLayer(const std::string& identifier, CellGrid* grid); /** Delete a layer from the map */ void deleteLayer(Layer*); /** Get the layers on this map. */ const std::list& getLayers() const { return m_layers; } /** Get the layer with the given id. */ Layer* getLayer(const std::string& identifier); /** Get the overall number of layers */ uint32_t getLayerCount() const; /** Delete all layers from the map */ void deleteLayers(); /** Retrieves the minimum/maximum coordinates of instances on the map. * @param min A reference to a ExactModelCoordinate that will hold the minimum coordinate. * @param max A reference to a ExactModelCoordinate that will hold the maximum coordinate. */ void getMinMaxCoordinates(ExactModelCoordinate& min, ExactModelCoordinate& max); /** Called periodically to update events on map * @returns true, if map was changed */ bool update(); /** Sets speed for the map. See Model::setTimeMultiplier. */ void setTimeMultiplier(float multip) { m_timeProvider.setMultiplier(multip); } /** Gets model speed. @see setTimeMultiplier. */ float getTimeMultiplier() const { return m_timeProvider.getMultiplier(); } /** Gets timeprovider used in the map */ TimeProvider* getTimeProvider() { return &m_timeProvider; } /** Adds new change listener * @param listener to add */ void addChangeListener(MapChangeListener* listener); /** Removes associated change listener * @param listener to remove */ void removeChangeListener(MapChangeListener* listener); /** Returns true, if map information was changed during previous update round */ bool isChanged() { return !m_changedLayers.empty(); } /** Returns layers that were changed during previous update round */ std::vector& getChangedLayers() { return m_changedLayers; } /** Adds camera to the map. The Map takes ownership of the camera so don't delete it. */ Camera* addCamera(const std::string& id, const Rect& viewport); /** Removes a camera from the map */ void removeCamera(const std::string& id); /** Get a camera by its identifier. */ Camera* getCamera(const std::string& id); /** Get a list containing all cameras. */ const std::vector& getCameras() const; /** Return the number of enabled cameras in this map. */ uint32_t getActiveCameraCount() const; void setFilename(const std::string& file) { m_filename = file; } const std::string& getFilename() const { return m_filename; } /** Adds instance that is to be transferred to another layer. * @param instance A pointer to the instance that is to be transferred. * @param target A const reference to the target location. */ void addInstanceForTransfer(Instance* instance, const Location& target); /** Removes instance that should be transferred to another layer. * @param instance A pointer to the instance that should be transferred. */ void removeInstanceForTransfer(Instance* instance); /** Creates cellcaches for this map. Called from maploader. */ void initializeCellCaches(); /** Creates cellcaches for this map. Called from maploader. */ void finalizeCellCaches(); /** */ TriggerController* getTriggerController() const { return m_triggerController; }; private: std::string m_id; std::string m_filename; std::list m_layers; TimeProvider m_timeProvider; Map(const Map& map); Map& operator=(const Map& map); //! listeners for map changes std::vector m_changeListeners; //! holds changed layers after each update std::vector m_changedLayers; //! holds the cameras attached to this map std::vector m_cameras; //! pointer to renderbackend RenderBackend* m_renderBackend; //! holds handles to all created renderers std::vector m_renderers; //! true, if something was changed on map during previous update (layer change, creation, deletion) bool m_changed; //! holds instances which should be transferred on the next update std::map m_transferInstances; TriggerController* m_triggerController; }; } #endif