Debian Codegraph @

engine/core/model/structures/map.h

raw
1 /***************************************************************************
2 * Copyright (C) 2005-2019 by the FIFE team *
3 * http://www.fifengine.net *
4 * This file is part of FIFE. *
5 * *
6 * FIFE is free software; you can redistribute it and/or *
7 * modify it under the terms of the GNU Lesser General Public *
8 * License as published by the Free Software Foundation; either *
9 * version 2.1 of the License, or (at your option) any later version. *
10 * *
11 * This library is distributed in the hope that it will be useful, *
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14 * Lesser General Public License for more details. *
15 * *
16 * You should have received a copy of the GNU Lesser General Public *
17 * License along with this library; if not, write to the *
18 * Free Software Foundation, Inc., *
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
20 ***************************************************************************/
21
22 #ifndef FIFE_MAP_MAP_H
23 #define FIFE_MAP_MAP_H
24
25 // Standard C++ library includes
26 #include <list>
27 #include <string>
28 #include <vector>
29
30 // 3rd party library includes
31
32 // FIFE includes
33 // These includes are split up in two parts, separated by one empty line
34 // First block: files included from the FIFE root src directory
35 // Second block: files included from the same folder
36 #include "util/base/fifeclass.h"
37 #include "util/resource/resource.h"
38 #include "model/metamodel/timeprovider.h"
39 #include "util/structures/rect.h"
40
41 #include "location.h"
42
43 namespace FIFE {
44
45 class RendererBase;
46 class RenderBackend;
47 class Layer;
48 class CellGrid;
49 class Map;
50 class Camera;
51 class Instance;
52 class TriggerController;
53
54 /** Listener interface for changes happening on map
55 */
56 class MapChangeListener {
57 public:
58 virtual ~MapChangeListener() {};
59
60 /** Called when some layer is changed on map. @see LayerChangeListener
61 * Layer is effectively changed, in case some of its instances
62 * is created, deleted or changed during latest update cycle
63 * @param map where change occurred
64 * @param changedLayers list of layers containing some changes
65 * @note Does not report layer creations and deletions
66 */
67 virtual void onMapChanged(Map* map, std::vector<Layer*>& changedLayers) = 0;
68
69 /** Called when some layer gets created on the map
70 * @param map where change occurred
71 * @param layer which got created
72 */
73 virtual void onLayerCreate(Map* map, Layer* layer) = 0;
74
75 /** Called when some layer gets deleted on map
76 * @param map where change occurred
77 * @param layer which will be deleted
78 * @note right after this call, layer actually gets deleted!
79 */
80 virtual void onLayerDelete(Map* map, Layer* layer) = 0;
81 };
82
83 /** A container of \c Layer(s).
84 *
85 * The actual data is contained in \c Layer objects
86 * @see Layer
87 */
88 class Map : public FifeClass {
89 public:
90
91 /** Construct a map
92 * To add map to model, one should call Model::addMap (otherwise
93 * map is not registered with the engine properly)
94 */
95 Map(const std::string& identifier, RenderBackend* renderbackend,
96 const std::vector<RendererBase*>& renderers, TimeProvider* tp_master=NULL);
97
98 /** Destructor
99 */
100 ~Map();
101
102 /** Get the identifier for this map.
103 */
104 const std::string& getId() const { return m_id; }
105
106 /** Sets the identifier for this map.
107 */
108 void setId(const std::string& id) { m_id = id; }
109
110 /** Add a Layer to this Map. Map owns the returned pointer to the new Layer, so don't delete it!
111 */
112 Layer* createLayer(const std::string& identifier, CellGrid* grid);
113
114 /** Delete a layer from the map
115 */
116 void deleteLayer(Layer*);
117
118 /** Get the layers on this map.
119 */
120 const std::list<Layer*>& getLayers() const { return m_layers; }
121
122 /** Get the layer with the given id.
123 */
124 Layer* getLayer(const std::string& identifier);
125
126 /** Get the overall number of layers
127 */
128 uint32_t getLayerCount() const;
129
130 /** Delete all layers from the map
131 */
132 void deleteLayers();
133
134 /** Retrieves the minimum/maximum coordinates of instances on the map.
135 * @param min A reference to a ExactModelCoordinate that will hold the minimum coordinate.
136 * @param max A reference to a ExactModelCoordinate that will hold the maximum coordinate.
137 */
138 void getMinMaxCoordinates(ExactModelCoordinate& min, ExactModelCoordinate& max);
139
140 /** Called periodically to update events on map
141 * @returns true, if map was changed
142 */
143 bool update();
144
145 /** Sets speed for the map. See Model::setTimeMultiplier.
146 */
147 void setTimeMultiplier(float multip) { m_timeProvider.setMultiplier(multip); }
148
149 /** Gets model speed. @see setTimeMultiplier.
150 */
151 float getTimeMultiplier() const { return m_timeProvider.getMultiplier(); }
152
153 /** Gets timeprovider used in the map
154 */
155 TimeProvider* getTimeProvider() { return &m_timeProvider; }
156
157 /** Adds new change listener
158 * @param listener to add
159 */
160 void addChangeListener(MapChangeListener* listener);
161
162 /** Removes associated change listener
163 * @param listener to remove
164 */
165 void removeChangeListener(MapChangeListener* listener);
166
167 /** Returns true, if map information was changed during previous update round
168 */
169 bool isChanged() { return !m_changedLayers.empty(); }
170
171 /** Returns layers that were changed during previous update round
172 */
173 std::vector<Layer*>& getChangedLayers() { return m_changedLayers; }
174
175 /** Adds camera to the map. The Map takes ownership of the camera
176 so don't delete it.
177 */
178 Camera* addCamera(const std::string& id, const Rect& viewport);
179
180 /** Removes a camera from the map
181 */
182 void removeCamera(const std::string& id);
183
184 /** Get a camera by its identifier.
185 */
186 Camera* getCamera(const std::string& id);
187
188 /** Get a list containing all cameras.
189 */
190 const std::vector<Camera*>& getCameras() const;
191
192 /** Return the number of enabled cameras in this map.
193 */
194 uint32_t getActiveCameraCount() const;
195
196 void setFilename(const std::string& file) { m_filename = file; }
197 const std::string& getFilename() const { return m_filename; }
198
199 /** Adds instance that is to be transferred to another layer.
200 * @param instance A pointer to the instance that is to be transferred.
201 * @param target A const reference to the target location.
202 */
203 void addInstanceForTransfer(Instance* instance, const Location& target);
204
205 /** Removes instance that should be transferred to another layer.
206 * @param instance A pointer to the instance that should be transferred.
207 */
208 void removeInstanceForTransfer(Instance* instance);
209
210 /** Creates cellcaches for this map. Called from maploader.
211 */
212 void initializeCellCaches();
213
214 /** Creates cellcaches for this map. Called from maploader.
215 */
216 void finalizeCellCaches();
217
218 /**
219 */
220 TriggerController* getTriggerController() const { return m_triggerController; };
221
222 private:
223 std::string m_id;
224 std::string m_filename;
225
226 std::list<Layer*> m_layers;
227 TimeProvider m_timeProvider;
228
229 Map(const Map& map);
230 Map& operator=(const Map& map);
231
232 //! listeners for map changes
233 std::vector<MapChangeListener*> m_changeListeners;
234
235 //! holds changed layers after each update
236 std::vector<Layer*> m_changedLayers;
237
238 //! holds the cameras attached to this map
239 std::vector<Camera*> m_cameras;
240
241 //! pointer to renderbackend
242 RenderBackend* m_renderBackend;
243
244 //! holds handles to all created renderers
245 std::vector<RendererBase*> m_renderers;
246
247 //! true, if something was changed on map during previous update (layer change, creation, deletion)
248 bool m_changed;
249
250 //! holds instances which should be transferred on the next update
251 std::map<Instance*, Location> m_transferInstances;
252
253 TriggerController* m_triggerController;
254 };
255
256 }
257
258 #endif