map.cpp

00001 /***************************************************************************
00002  *   Copyright (C) 2005-2008 by the FIFE team                              *
00003  *   http://www.fifengine.de                                               *
00004  *   This file is part of FIFE.                                            *
00005  *                                                                         *
00006  *   FIFE is free software; you can redistribute it and/or                 *
00007  *   modify it under the terms of the GNU Lesser General Public            *
00008  *   License as published by the Free Software Foundation; either          *
00009  *   version 2.1 of the License, or (at your option) any later version.    *
00010  *                                                                         *
00011  *   This library is distributed in the hope that it will be useful,       *
00012  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00013  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00014  *   Lesser General Public License for more details.                       *
00015  *                                                                         *
00016  *   You should have received a copy of the GNU Lesser General Public      *
00017  *   License along with this library; if not, write to the                 *
00018  *   Free Software Foundation, Inc.,                                       *
00019  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
00020  ***************************************************************************/
00021 
00022 // Standard C++ library includes
00023 #include <string>
00024 
00025 // 3rd party library includes
00026 #include <boost/lexical_cast.hpp>
00027 
00028 // FIFE includes
00029 // These includes are split up in two parts, separated by one empty line
00030 // First block: files included from the FIFE root src directory
00031 // Second block: files included from the same folder
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         // remove all cameras
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         // loop over cameras and update if enabled
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         // create new camera and add to list of cameras
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                 // camera has been found delete it
00206                 delete *iter;
00207 
00208                 // now remove it from the vector
00209                 // note this invalidates iterators, but we do not need
00210                 // to worry about it in this case since we are done
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 } //FIFE
00234 
Generated on Wed Nov 23 13:04:43 2011 for FIFE by  doxygen 1.6.3