model.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 
00024 // 3rd party library includes
00025 
00026 // FIFE includes
00027 // These includes are split up in two parts, separated by one empty line
00028 // First block: files included from the FIFE root src directory
00029 // Second block: files included from the same folder
00030 #include "util/structures/purge.h"
00031 #include "model/metamodel/abstractpather.h"
00032 #include "model/metamodel/object.h"
00033 #include "model/metamodel/grids/cellgrid.h"
00034 #include "structures/map.h"
00035 #include "structures/layer.h"
00036 #include "structures/instance.h"
00037 #include "util/base/exception.h"
00038 #include "view/rendererbase.h"
00039 #include "video/renderbackend.h"
00040 #include "video/imagepool.h"
00041 #include "video/animationpool.h"
00042 
00043 #include "model.h"
00044 
00045 namespace FIFE {
00046 
00047     Model::Model(RenderBackend* renderbackend, const std::vector<RendererBase*>& renderers,
00048                     ImagePool* imagepool, AnimationPool* animpool): 
00049         FifeClass(),
00050         m_last_namespace(NULL),
00051         m_renderbackend(renderbackend),
00052         m_renderers(renderers),
00053         m_imagepool(imagepool),
00054         m_animpool(animpool),
00055         m_timeprovider(NULL) {
00056 
00057         }
00058 
00059     Model::~Model() {
00060         purge(m_maps);
00061         for(std::list<namespace_t>::iterator nspace = m_namespaces.begin(); nspace != m_namespaces.end(); ++nspace)
00062             purge_map(nspace->second);
00063         purge(m_pathers);
00064         purge(m_created_grids);
00065         purge(m_adopted_grids);
00066     }
00067 
00068     Map* Model::createMap(const std::string& identifier) {
00069         std::list<Map*>::const_iterator it = m_maps.begin();
00070         for(; it != m_maps.end(); ++it) {
00071             if(identifier == (*it)->getId()) {
00072                 throw NameClash(identifier);
00073             }
00074         }
00075 
00076         Map* map = new Map(identifier, m_renderbackend, m_renderers, m_imagepool, m_animpool, &m_timeprovider);
00077         m_maps.push_back(map);
00078         return map;
00079     }
00080 
00081     void Model::adoptPather(AbstractPather* pather) {
00082         m_pathers.push_back(pather);
00083     }
00084     
00085     AbstractPather* Model::getPather(const std::string& pathername) {
00086         std::vector<AbstractPather*>::const_iterator it = m_pathers.begin();
00087         for(; it != m_pathers.end(); ++it) {
00088             if ((*it)->getName() == pathername) {
00089                 return *it;
00090             }
00091         }
00092         return NULL;
00093     }
00094 
00095     void Model::adoptCellGrid(CellGrid* grid) {
00096         m_adopted_grids.push_back(grid);
00097     }
00098 
00099     CellGrid* Model::getCellGrid(const std::string& gridtype) {
00100         std::vector<CellGrid*>::const_iterator it = m_adopted_grids.begin();
00101         for(; it != m_adopted_grids.end(); ++it) {
00102             if ((*it)->getType() == gridtype) {
00103                 CellGrid* newcg = (*it)->clone();
00104                 m_created_grids.push_back(newcg);
00105                 return newcg;
00106             }
00107         }
00108         return NULL;
00109     }
00110 
00111     
00112     Map* Model::getMap(const std::string& identifier) const {
00113         std::list<Map*>::const_iterator it = m_maps.begin();
00114         for(; it != m_maps.end(); ++it) {
00115             if((*it)->getId() == identifier)
00116                 return *it;
00117         }
00118 
00119         throw NotFound(std::string("Tried to get non-existent map: ") + identifier + ".");
00120     }
00121 
00122     void Model::deleteMap(Map* map) {
00123         std::list<Map*>::iterator it = m_maps.begin();
00124         for(; it != m_maps.end(); ++it) {
00125             if(*it == map) {
00126                 delete *it;
00127                 m_maps.erase(it);
00128                 return ;
00129             }
00130         }
00131     }
00132 
00133     size_t Model::getNumMaps() const {
00134         return m_maps.size();
00135     }
00136 
00137     void Model::deleteMaps() {
00138         purge(m_maps);
00139         m_maps.clear();
00140     }
00141 
00142     std::list<std::string> Model::getNamespaces() const {
00143         std::list<std::string> namespace_list;
00144         std::list<namespace_t>::const_iterator nspace = m_namespaces.begin();
00145         for(; nspace != m_namespaces.end(); ++nspace) {
00146             namespace_list.push_back(nspace->first);
00147         }
00148         return namespace_list;
00149     }
00150 
00151     Object* Model::createObject(const std::string& identifier, const std::string& name_space, Object* parent) {
00152         // Find or create namespace
00153         namespace_t* nspace = selectNamespace(name_space);
00154         if(!nspace) {
00155             m_namespaces.push_back(namespace_t(name_space,objectmap_t()));
00156             nspace = selectNamespace(name_space);
00157         }
00158 
00159         // Check for nameclashes
00160         objectmap_t::const_iterator it = nspace->second.find(identifier);
00161         if( it != nspace->second.end() ) {
00162             throw NameClash(identifier);
00163         }
00164 
00165         // Finally insert & create
00166         Object* object = new Object(identifier, name_space, parent);
00167         nspace->second[identifier] = object;
00168         return object;
00169     }
00170 
00171     bool Model::deleteObject(Object* object) {
00172         // WARNING: This code has obviously not been tested (thoroughly).
00173 
00174         // Check if any instances exist. If yes - bail out.
00175         std::list<Layer*>::const_iterator jt;
00176         std::vector<Instance*>::const_iterator kt;
00177         for(std::list<Map*>::iterator it = m_maps.begin(); it != m_maps.end(); ++it) {
00178             for(jt = (*it)->getLayers().begin(); jt != (*it)->getLayers().end(); ++jt) {
00179                 for(kt = (*jt)->getInstances().begin(); kt != (*jt)->getInstances().end(); ++kt) {
00180                     Object* o = (*kt)->getObject();
00181                     if(o == object) {
00182                         return false;
00183                     }
00184                 }
00185             }
00186         }
00187 
00188         // Check if the namespace exists
00189         namespace_t* nspace = selectNamespace(object->getNamespace());
00190         if(!nspace)
00191             return true;
00192 
00193         // If yes - delete+erase object.
00194         objectmap_t::iterator it = nspace->second.find(object->getId());
00195         if( it != nspace->second.end()) {
00196             delete it->second;
00197             nspace->second.erase(it);
00198         }
00199 
00200         return true;
00201     }
00202 
00203     bool Model::deleteObjects() {
00204         // If we have layers with instances - bail out.
00205         std::list<Layer*>::const_iterator jt;
00206         for(std::list<Map*>::iterator it = m_maps.begin(); it != m_maps.end(); ++it) {
00207             for(jt = (*it)->getLayers().begin(); jt != (*it)->getLayers().end(); ++jt) {
00208                 if((*jt)->hasInstances())
00209                     return false;
00210             }
00211         }
00212 
00213         // Otherwise delete every object in every namespace
00214         std::list<namespace_t>::iterator nspace = m_namespaces.begin();
00215         while(nspace != m_namespaces.end()) {
00216             objectmap_t::iterator it = nspace->second.begin();
00217             for(; it != nspace->second.end(); ++it) {
00218                 delete it->second;
00219             }
00220             nspace = m_namespaces.erase(nspace);
00221         }
00222         m_last_namespace = 0;
00223         return true;
00224     }
00225 
00226     Object* Model::getObject(const std::string& id, const std::string& name_space) {
00227         namespace_t* nspace = selectNamespace(name_space);
00228         if(nspace) {
00229             objectmap_t::iterator it = nspace->second.find(id);
00230             if( it !=  nspace->second.end() )
00231                 return it->second;
00232         }
00233         return 0;
00234     }
00235 
00236     std::list<Object*> Model::getObjects(const std::string& name_space) const {
00237         std::list<Object*> object_list;
00238         const namespace_t* nspace = selectNamespace(name_space);
00239         if(nspace) {
00240             objectmap_t::const_iterator it = nspace->second.begin();
00241             for(; it != nspace->second.end(); ++it )
00242                 object_list.push_back(it->second);
00243             return object_list;
00244         }
00245         throw NotFound(name_space);
00246     }
00247 
00248     const Model::namespace_t* Model::selectNamespace(const std::string& name_space) const {
00249         std::list<namespace_t>::const_iterator nspace = m_namespaces.begin();
00250         for(; nspace != m_namespaces.end(); ++nspace) {
00251             if( nspace->first == name_space ) {
00252                 return &(*nspace);
00253             }
00254         }
00255         return 0;
00256     }
00257 
00258     Model::namespace_t* Model::selectNamespace(const std::string& name_space) {
00259         if( m_last_namespace && m_last_namespace->first == name_space )
00260             return m_last_namespace;
00261         std::list<namespace_t>::iterator nspace = m_namespaces.begin();
00262         for(; nspace != m_namespaces.end(); ++nspace) {
00263             if( nspace->first == name_space ) {
00264                 m_last_namespace = &(*nspace);
00265                 return m_last_namespace;
00266             }
00267         }
00268         m_last_namespace = 0;
00269         return 0;
00270     }
00271 
00272     void Model::update() {
00273         std::list<Map*>::iterator it = m_maps.begin();
00274         for(; it != m_maps.end(); ++it) {
00275             (*it)->update();
00276         }
00277         std::vector<AbstractPather*>::iterator jt = m_pathers.begin();
00278         for(; jt != m_pathers.end(); ++jt) {
00279             (*jt)->update();
00280         }
00281     }
00282 
00283 } //FIFE
00284