map.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <string>
00024
00025
00026 #include <boost/lexical_cast.hpp>
00027
00028
00029
00030
00031
00032 #include "util/base/exception.h"
00033 #include "util/structures/purge.h"
00034 #include "util/structures/rect.h"
00035 #include "view/camera.h"
00036 #include "view/rendererbase.h"
00037 #include "video/renderbackend.h"
00038 #include "video/imagepool.h"
00039 #include "video/animationpool.h"
00040
00041 #include "map.h"
00042 #include "layer.h"
00043
00044 namespace FIFE {
00045
00046 Map::Map(const std::string& identifier, RenderBackend* renderBackend,
00047 const std::vector<RendererBase*>& renderers, ImagePool* imagePool,
00048 AnimationPool* animPool, TimeProvider* tp_master):
00049 m_id(identifier),
00050 m_timeprovider(tp_master),
00051 m_changelisteners(),
00052 m_changedlayers(),
00053 m_renderbackend(renderBackend),
00054 m_imagepool(imagePool),
00055 m_animpool(animPool),
00056 m_renderers(renderers),
00057 m_changed(false){
00058 }
00059
00060 Map::~Map() {
00061
00062 std::vector<Camera*>::iterator iter = m_cameras.begin();
00063 for ( ; iter != m_cameras.end(); ++iter) {
00064 delete *iter;
00065 }
00066 m_cameras.clear();
00067
00068 deleteLayers();
00069 }
00070
00071 Layer* Map::getLayer(const std::string& id) {
00072 std::list<Layer*>::const_iterator it = m_layers.begin();
00073 for(; it != m_layers.end(); ++it) {
00074 if((*it)->getId() == id)
00075 return *it;
00076 }
00077
00078 throw NotFound(id);
00079 }
00080
00081 uint32_t Map::getNumLayers() const {
00082 return m_layers.size();
00083 }
00084
00085 Layer* Map::createLayer(const std::string& identifier, CellGrid* grid) {
00086 std::list<Layer*>::const_iterator it = m_layers.begin();
00087 for(; it != m_layers.end(); ++it) {
00088 if(identifier == (*it)->getId())
00089 throw NameClash(identifier);
00090 }
00091
00092 Layer* layer = new Layer(identifier, this, grid);
00093 m_layers.push_back(layer);
00094 m_changed = true;
00095 std::vector<MapChangeListener*>::iterator i = m_changelisteners.begin();
00096 while (i != m_changelisteners.end()) {
00097 (*i)->onLayerCreate(this, layer);
00098 ++i;
00099 }
00100
00101 return layer;
00102 }
00103
00104 void Map::deleteLayer(Layer* layer) {
00105 std::list<Layer*>::iterator it = m_layers.begin();
00106 for(; it != m_layers.end(); ++it) {
00107 if((*it) == layer) {
00108 std::vector<MapChangeListener*>::iterator i = m_changelisteners.begin();
00109 while (i != m_changelisteners.end()) {
00110 (*i)->onLayerDelete(this, layer);
00111 ++i;
00112 }
00113 delete layer;
00114 m_layers.erase(it);
00115 return ;
00116 }
00117 }
00118 m_changed = true;
00119 }
00120
00121 void Map::deleteLayers() {
00122 std::list<Layer*>::iterator it = m_layers.begin();
00123 for(; it != m_layers.end(); ++it) {
00124 std::vector<MapChangeListener*>::iterator i = m_changelisteners.begin();
00125 while (i != m_changelisteners.end()) {
00126 (*i)->onLayerDelete(this, *it);
00127 ++i;
00128 }
00129 }
00130 purge(m_layers);
00131 m_layers.clear();
00132 }
00133
00134 bool Map::update() {
00135 m_changedlayers.clear();
00136 std::list<Layer*>::iterator it = m_layers.begin();
00137 for(; it != m_layers.end(); ++it) {
00138 if ((*it)->update()) {
00139 m_changedlayers.push_back(*it);
00140 }
00141 }
00142 if (!m_changedlayers.empty()) {
00143 std::vector<MapChangeListener*>::iterator i = m_changelisteners.begin();
00144 while (i != m_changelisteners.end()) {
00145 (*i)->onMapChanged(this, m_changedlayers);
00146 ++i;
00147 }
00148 }
00149
00150
00151 std::vector<Camera*>::iterator camIter = m_cameras.begin();
00152 for ( ; camIter != m_cameras.end(); ++camIter) {
00153 if ((*camIter)->isEnabled()) {
00154 (*camIter)->update();
00155 (*camIter)->render();
00156 }
00157 }
00158
00159 bool retval = m_changed;
00160 m_changed = false;
00161 return retval;
00162 }
00163
00164 void Map::addChangeListener(MapChangeListener* listener) {
00165 m_changelisteners.push_back(listener);
00166 }
00167
00168 void Map::removeChangeListener(MapChangeListener* listener) {
00169 std::vector<MapChangeListener*>::iterator i = m_changelisteners.begin();
00170 while (i != m_changelisteners.end()) {
00171 if ((*i) == listener) {
00172 m_changelisteners.erase(i);
00173 return;
00174 }
00175 ++i;
00176 }
00177 }
00178
00179 Camera* Map::addCamera(const std::string &id, Layer *layer, const Rect& viewport) {
00180 if (layer == NULL) {
00181 throw NotSupported("Must have valid layer for camera");
00182 }
00183
00184 if (getCamera(id)) {
00185 std::string errorStr = "Camera: " + id + " already exists";
00186 throw NameClash(errorStr);
00187 }
00188
00189
00190 Camera* camera = new Camera(id, layer, viewport, m_renderbackend, m_imagepool, m_animpool);
00191 m_cameras.push_back(camera);
00192
00193 std::vector<RendererBase*>::iterator iter = m_renderers.begin();
00194 for ( ; iter != m_renderers.end(); ++iter) {
00195 camera->addRenderer((*iter)->clone());
00196 }
00197
00198 return camera;
00199 }
00200
00201 void Map::removeCamera(const std::string &id) {
00202 std::vector<Camera*>::iterator iter = m_cameras.begin();
00203 for ( ; iter != m_cameras.end(); ++iter) {
00204 if ((*iter)->getId() == id) {
00205
00206 delete *iter;
00207
00208
00209
00210
00211 m_cameras.erase(iter);
00212
00213 break;
00214 }
00215 }
00216 }
00217
00218 Camera* Map::getCamera(const std::string &id) {
00219 std::vector<Camera*>::iterator iter = m_cameras.begin();
00220 for ( ; iter != m_cameras.end(); ++iter) {
00221 if ((*iter)->getId() == id) {
00222 return *iter;
00223 }
00224 }
00225
00226 return NULL;
00227 }
00228
00229 std::vector<Camera*>& Map::getCameras() {
00230 return m_cameras;
00231 }
00232
00233 }
00234