maploader.cpp

Go to the documentation of this file.

/***************************************************************************
 *   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          *
 ***************************************************************************/

// Standard C++ library includes
#include <string>
#include <vector>

// 3rd party includes
#include <tinyxml.h>

// 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 "model/model.h"
#include "model/structures/layer.h"
#include "model/structures/instance.h"
#include "model/structures/cell.h"
#include "model/structures/cellcache.h"
#include "model/structures/trigger.h"
#include "model/structures/triggercontroller.h"
#include "model/metamodel/grids/cellgrid.h"
#include "model/metamodel/modelcoords.h"
#include "model/metamodel/action.h"
#include "vfs/fife_boost_filesystem.h"
#include "vfs/vfs.h"
#include "vfs/vfsdirectory.h"
#include "vfs/raw/rawdata.h"
#include "util/base/exception.h"
#include "util/log/logger.h"
#include "util/resource/resource.h"
#include "util/structures/rect.h"
#include "video/imagemanager.h"
#include "video/animationmanager.h"
#include "video/image.h"
#include "video/renderbackend.h"
#include "view/visual.h"
#include "view/camera.h"
#include "view/renderers/instancerenderer.h"
#include "util/base/stringutils.h"

#include "atlasloader.h"
#include "maploader.h"
#include "animationloader.h"
#include "objectloader.h"

namespace FIFE {
    static Logger _log(LM_NATIVE_LOADERS);

    MapLoader::MapLoader(Model* model, VFS* vfs, ImageManager* imageManager, RenderBackend* renderBackend)
    : m_model(model), m_vfs(vfs), m_imageManager(imageManager), m_animationManager(AnimationManager::instance()), m_renderBackend(renderBackend),
      m_loaderName("fife"), m_mapDirectory("") {
        AnimationLoaderPtr animationLoader(new AnimationLoader(m_vfs, m_imageManager, m_animationManager));
        AtlasLoaderPtr atlasLoader(new AtlasLoader(m_model, m_vfs, m_imageManager, m_animationManager));
        m_objectLoader.reset(new ObjectLoader(m_model, m_vfs, m_imageManager, m_animationManager, animationLoader, atlasLoader));
    }

    MapLoader::~MapLoader() {

    }

    Map* MapLoader::load(const std::string& filename) {
        Map* map = NULL;

        // reset percent done listener just in case
        // it has residual data from last load
        m_percentDoneListener.reset();

        bfs::path mapPath(filename);

        if (HasParentPath(mapPath)) {
            if (GetParentPath(mapPath).string() != m_mapDirectory) {
                // save the directory where the map file is located
                m_mapDirectory = GetParentPath(mapPath).string();
            }
        }

        TiXmlDocument mapFile;

        std::string mapFilename = mapPath.string();

        try {
            RawData* data = m_vfs->open(mapFilename);

            if (data) {
                if (data->getDataLength() != 0) {
                    mapFile.Parse(data->readString(data->getDataLength()).c_str());

                    if (mapFile.Error()) {
                        std::ostringstream oss;
                        oss << " Failed to load"
                            << mapFilename
                            << " : " << __FILE__
                            << " [" << __LINE__ << "]"
                            << std::endl;
                        FL_ERR(_log, oss.str());

                        return map;
                    }
                }

                // done with data delete resource
                delete data;
                data = 0;
            }
        }
        catch (NotFound& e)
        {
            FL_ERR(_log, e.what());

            // TODO - should we abort here
            //        or rethrow the exception
            //        or just keep going

            return map;
        }

        // if we get here then everything loaded properly
        // so we can just parse out the contents
        const TiXmlElement* root = mapFile.RootElement();

        if (root) {
            const std::string* loaderName = root->Attribute(std::string("loaderName"));

            if (loaderName) {
                m_loaderName = *loaderName;
            }

            int numElements = 0;
            root->QueryValueAttribute("elements", &numElements);
            m_percentDoneListener.setTotalNumberOfElements(numElements);

            const std::string* mapName = root->Attribute(std::string("id"));

            if (mapName) {
                try {
                    map = m_model->createMap(*mapName);
                }
                catch (NameClash& e) {
                    FL_ERR(_log, e.what());

                    // just rethrow to client
                    throw;
                }

                if (map) {
                    map->setFilename(mapFilename);

                    std::string ns = "";
                    for (const TiXmlElement *importElement = root->FirstChildElement("import"); importElement; importElement = importElement->NextSiblingElement("import")) {
                        const std::string* importDir = importElement->Attribute(std::string("dir"));
                        const std::string* importFile = importElement->Attribute(std::string("file"));

                        std::string directory = "";
                        if (importDir) {
                            directory = *importDir;
                        }

                        std::string file = "";
                        if (importFile) {
                            file = *importFile;
                        }

                        if (importDir && !importFile) {
                            bfs::path fullPath(m_mapDirectory);
                            fullPath /= directory;
                            loadImportDirectory(fullPath.string());
                        }
                        else if (importFile) {
                            bfs::path fullFilePath(file);
                            bfs::path fullDirPath(directory);
                            if (importDir) {
                                fullDirPath = bfs::path(m_mapDirectory);
                                fullDirPath /= directory;
                            }
                            else {
                                fullFilePath = bfs::path(m_mapDirectory);
                                fullFilePath /= file;
                            }
                            loadImportFile(fullFilePath.string(), fullDirPath.string());
                        }
                    }
                    // converts multiobject part id to object pointer
                    std::list<std::string> namespaces = m_model->getNamespaces();
                    std::list<std::string>::iterator name_it = namespaces.begin();
                    for (; name_it != namespaces.end(); ++name_it) {
                        std::list<Object*> objects = m_model->getObjects(*name_it);
                        std::list<Object*>::iterator object_it = objects.begin();
                        for (; object_it != objects.end(); ++object_it) {
                            if ((*object_it)->isMultiObject()) {
                                const std::list<std::string>& multiParts = (*object_it)->getMultiPartIds();
                                std::list<std::string>::const_iterator multi_it = multiParts.begin();
                                for (; multi_it != multiParts.end(); ++multi_it) {
                                    Object* partObj = m_model->getObject(*multi_it, *name_it);
                                    if (partObj) {
                                        partObj->setMultiPart(true);
                                        (*object_it)->addMultiPart(partObj);
                                    }
                                }
                            }
                        }
                    }

                    // iterate over elements looking for layers
                    for (const TiXmlElement* layerElement = root->FirstChildElement("layer"); layerElement; layerElement = layerElement->NextSiblingElement("layer")) {
                        // defaults
                        double xOffset = 0.0;
                        double yOffset = 0.0;
                        double zOffset = 0.0;
                        double xScale = 1.0;
                        double yScale = 1.0;
                        double zScale = 1.0;
                        double rotation = 0.0;

                        int xOffsetRetVal = layerElement->QueryValueAttribute("x_offset", &xOffset);
                        int yOffsetRetVal = layerElement->QueryValueAttribute("y_offset", &yOffset);
                        layerElement->QueryValueAttribute("z_offset", &zOffset);
                        int xScaleRetVal = layerElement->QueryValueAttribute("x_scale", &xScale);
                        int yScaleRetVal = layerElement->QueryValueAttribute("y_scale", &yScale);
                        layerElement->QueryValueAttribute("z_scale", &zScale);
                        int rotationRetVal = layerElement->QueryValueAttribute("rotation", &rotation);

                        const std::string* layerName = layerElement->Attribute(std::string("id"));
                        const std::string* pathing = layerElement->Attribute(std::string("pathing"));
                        const std::string* sorting = layerElement->Attribute(std::string("sorting"));
                        const std::string* gridType = layerElement->Attribute(std::string("grid_type"));
                        const std::string* layerType = layerElement->Attribute(std::string("layer_type"));
                        const std::string* layerTypeName = layerElement->Attribute(std::string("layer_type_id"));

                        if (xOffsetRetVal == TIXML_SUCCESS &&
                            yOffsetRetVal == TIXML_SUCCESS &&
                            xScaleRetVal == TIXML_SUCCESS &&
                            yScaleRetVal == TIXML_SUCCESS &&
                            rotationRetVal == TIXML_SUCCESS &&
                            layerName &&
                            pathing &&
                            gridType) {
                            
                            PathingStrategy pathStrategy = CELL_EDGES_ONLY;
                            if ("cell_edges_and_diagonals" == *pathing) {
                                pathStrategy = CELL_EDGES_AND_DIAGONALS;
                            }

                            SortingStrategy sortStrategy = SORTING_CAMERA;
                            if (sorting) {
                                if (*sorting == "location") {
                                    sortStrategy = SORTING_LOCATION;
                                } else if (*sorting == "camera_and_location") {
                                    sortStrategy = SORTING_CAMERA_AND_LOCATION;
                                }
                            }

                            CellGrid* grid = NULL;
                            if (gridType) {
                                grid = m_model->getCellGrid(*gridType);
                            }
                            else {
                                grid = m_model->getCellGrid("square");
                            }

                            if (grid) {
                                grid->setXShift(xOffset);
                                grid->setXScale(xScale);
                                grid->setYShift(yOffset);
                                grid->setYScale(yScale);
                                grid->setZShift(zOffset);
                                grid->setZScale(zScale);
                                grid->setRotation(rotation);

                                Layer *layer = NULL;
                                try {
                                    layer = map->createLayer(*layerName, grid);
                                }
                                catch (NameClash&) {
                                    // TODO - handle exception
                                    assert(false);
                                }

                                if (layer) {
                                    layer->setPathingStrategy(pathStrategy);
                                    layer->setSortingStrategy(sortStrategy);
                                    if (layerType) {
                                        if (*layerType == "walkable") {
                                            layer->setWalkable(true);
                                        } else if (*layerType == "interact") {
                                            layer->setInteract(true, *layerTypeName);
                                        }
                                    }

                                    double curr_x = 0;
                                    double curr_y = 0;

                                    for (const TiXmlElement* instances = layerElement->FirstChildElement("instances"); instances; instances = instances->NextSiblingElement("instances")) {
                                        for (const TiXmlElement* instance = instances->FirstChildElement("i"); instance; instance = instance->NextSiblingElement("i")) {
                                            double x = 0;
                                            double y = 0;
                                            double z = 0;
                                            int r = 0;
                                            int stackpos = 0;
                                            int cellStack = 0;

                                            const std::string* instanceId = instance->Attribute(std::string("id"));
                                            const std::string* objectId = instance->Attribute(std::string("o"));
                                            const std::string* costId = instance->Attribute(std::string("cost_id"));

                                            if (!objectId) {
                                                objectId = instance->Attribute(std::string("object"));
                                            }

                                            if (!objectId) {
                                                objectId = instance->Attribute(std::string("obj"));
                                            }

                                            const std::string* namespaceId = instance->Attribute(std::string("ns"));

                                            if (!namespaceId) {
                                                namespaceId = instance->Attribute(std::string("namespace"));
                                            }

                                            int xRetVal = instance->QueryValueAttribute("x", &x);
                                            int yRetVal = instance->QueryValueAttribute("y", &y);
                                            instance->QueryValueAttribute("z", &z);
                                            int rRetVal = instance->QueryValueAttribute("r", &r);

                                            if (xRetVal == TIXML_SUCCESS) {
                                                curr_x = x;
                                            }
                                            else {
                                                x = ++curr_x;
                                            }

                                            if (yRetVal == TIXML_SUCCESS) {
                                                curr_y = y;
                                            }
                                            else {
                                                y = curr_y;
                                            }

                                            if (rRetVal != TIXML_SUCCESS) {
                                                rRetVal = instance->QueryValueAttribute("rotation", &r);
                                            }

                                            int stackRetVal = instance->QueryValueAttribute("stackpos", &stackpos);
                                            int cellStackRetVal = instance->QueryValueAttribute("cellstack", &cellStack);

                                            if (objectId) {
                                                if (namespaceId) {
                                                    ns = *namespaceId;
                                                }

                                                Object* object = m_model->getObject(*objectId, ns);

                                                if (object) {
                                                    Instance* inst = NULL;
                                                    if (instanceId) {
                                                        inst = layer->createInstance(object, ExactModelCoordinate(x,y,z), *instanceId);
                                                    }
                                                    else {
                                                        inst = layer->createInstance(object, ExactModelCoordinate(x,y,z));
                                                    }

                                                    if (inst) {
                                                        if (rRetVal != TIXML_SUCCESS) {
                                                            ObjectVisual* objVisual = object->getVisual<ObjectVisual>();
                                                            std::vector<int> angles;
                                                            objVisual->getStaticImageAngles(angles);
                                                            if (!angles.empty()) {
                                                                r = angles[0];
                                                            }
                                                        }

                                                        inst->setRotation(r);

                                                        InstanceVisual* instVisual = InstanceVisual::create(inst);

                                                        if  (instVisual && (stackRetVal == TIXML_SUCCESS)) {
                                                            instVisual->setStackPosition(stackpos);
                                                        }

                                                        if  (cellStackRetVal == TIXML_SUCCESS) {
                                                            inst->setCellStackPosition(cellStack);
                                                        }

                                                        if (costId) {
                                                            double cost = 0;
                                                            int costRetVal = instance->QueryValueAttribute("cost", &cost);
                                                            if (costRetVal == TIXML_SUCCESS) {
                                                                inst->setCost(*costId, cost);
                                                            }
                                                        }

                                                        if (object->getAction("default")) {
                                                            Location target(layer);

                                                            inst->actRepeat("default", target);
                                                        }
                                                    }
                                                    else
                                                    {
                                                        std::ostringstream oss;
                                                        oss << " Failed to create instance of object "
                                                            << *objectId
                                                            << " : " << __FILE__
                                                            << " [" << __LINE__ << "]"
                                                            << std::endl;
                                                        FL_ERR(_log, oss.str());
                                                    }
                                                }
                                            }

                                            // increment % done counter
                                            m_percentDoneListener.incrementCount();
                                        }
                                    }
                                }
                            }
                        }

                        // increment % done counter
                        m_percentDoneListener.incrementCount();
                    }
                    
                    // init CellCaches
                    map->initializeCellCaches();
                    // add Cells from xml File
                    for (const TiXmlElement* cacheElements = root->FirstChildElement("cellcaches"); cacheElements; cacheElements = cacheElements->NextSiblingElement("cellcaches")) {
                        for (const TiXmlElement* cacheElement = cacheElements->FirstChildElement("cellcache"); cacheElement; cacheElement = cacheElement->NextSiblingElement("cellcache")) {
                            double cacheCost = 1.0;
                            double cacheSpeed = 1.0;
                            const std::string* layerId = cacheElement->Attribute(std::string("id"));

                            if (layerId) {
                                cacheElement->QueryDoubleAttribute("default_cost", &cacheCost);
                                cacheElement->QueryDoubleAttribute("default_speed", &cacheSpeed);

                                Layer* layer = map->getLayer(*layerId);
                                if (layer) {
                                    CellCache* cache = layer->getCellCache();
                                    if (cache) {
                                        int searchNarrow = 0;
                                        cacheElement->QueryIntAttribute("search_narrow", &searchNarrow);
                                        cache->setSearchNarrowCells(searchNarrow != 0);
                                        
                                        cache->setDefaultCostMultiplier(cacheCost);
                                        cache->setDefaultSpeedMultiplier(cacheSpeed);
                                        for (const TiXmlElement* cellElement = cacheElement->FirstChildElement("cell"); cellElement; cellElement = cellElement->NextSiblingElement("cell")) {
                                            int cellX = 0;
                                            int cellY = 0;
                                            int success = cellElement->QueryIntAttribute("x", &cellX);
                                            success &= cellElement->QueryIntAttribute("y", &cellY);
                                            if (success == TIXML_SUCCESS) {
                                                ModelCoordinate mc(cellX, cellY);
                                                Cell* cell = cache->createCell(mc);

                                                const std::string* cellBlocker = cellElement->Attribute(std::string("blocker_type"));
                                                if (cellBlocker) {
                                                    if (*cellBlocker == "no_blocker") {
                                                        CellTypeInfo cti = CTYPE_CELL_NO_BLOCKER;
                                                        cell->setCellType(cti);
                                                    } else if (*cellBlocker == "blocker") {
                                                        CellTypeInfo cti = CTYPE_CELL_BLOCKER;
                                                        cell->setCellType(cti);
                                                    }
                                                }

                                                double cellCost = 1.0;
                                                double cellSpeed = 1.0;
                                                success = cellElement->QueryDoubleAttribute("default_cost", &cellCost);
                                                if (success == TIXML_SUCCESS) {
                                                    cell->setCostMultiplier(cellCost);
                                                }
                                                success = cellElement->QueryDoubleAttribute("default_speed", &cellSpeed);
                                                if (success == TIXML_SUCCESS) {
                                                    cell->setSpeedMultiplier(cellSpeed);

                                                }

                                                int isNarrow = 0;
                                                cellElement->QueryIntAttribute("narrow", &isNarrow);
                                                if (isNarrow != 0) {
                                                    cache->addNarrowCell(cell);
                                                }
                                                // add cost with given id to cell
                                                for (const TiXmlElement* costElement = cellElement->FirstChildElement("cost"); costElement; costElement = costElement->NextSiblingElement("cost")) {
                                                    const std::string* costId = costElement->Attribute(std::string("id"));
                                                    double cost = 1.0;
                                                    success = costElement->QueryDoubleAttribute("value", &cost);
                                                    if (costId && success == TIXML_SUCCESS) {
                                                        cache->registerCost(*costId, cost);
                                                        cache->addCellToCost(*costId, cell);
                                                    }
                                                }
                                                // add area to cell
                                                for (const TiXmlElement* areaElement = cellElement->FirstChildElement("area"); areaElement; areaElement = areaElement->NextSiblingElement("area")) {
                                                    const std::string* areaId = areaElement->Attribute(std::string("id"));
                                                    if (areaId) {
                                                        cache->addCellToArea(*areaId, cell);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    // finalize CellCaches
                    map->finalizeCellCaches();
                    // add Transistions
                    for (const TiXmlElement* cacheElements = root->FirstChildElement("cellcaches"); cacheElements; cacheElements = cacheElements->NextSiblingElement("cellcaches")) {
                        for (const TiXmlElement* cacheElement = cacheElements->FirstChildElement("cellcache"); cacheElement; cacheElement = cacheElement->NextSiblingElement("cellcache")) {
                            const std::string* layerId = cacheElement->Attribute(std::string("id"));
                            if (layerId) {
                                Layer* layer = map->getLayer(*layerId);
                                if (layer) {
                                    CellCache* cache = layer->getCellCache();
                                    if (cache) {
                                        for (const TiXmlElement* cellElement = cacheElement->FirstChildElement("cell"); cellElement; cellElement = cellElement->NextSiblingElement("cell")) {
                                            int cellX = 0;
                                            int cellY = 0;
                                            int success = cellElement->QueryIntAttribute("x", &cellX);
                                            success &= cellElement->QueryIntAttribute("y", &cellY);
                                            if (success == TIXML_SUCCESS) {
                                                ModelCoordinate mc(cellX, cellY);
                                                Cell* cell = cache->getCell(mc);
                                                if (!cell) {
                                                    continue;
                                                }
                                                for (const TiXmlElement* transitionElement = cellElement->FirstChildElement("transition"); transitionElement; transitionElement = transitionElement->NextSiblingElement("transition")) {
                                                    int targetX = 0;
                                                    int targetY = 0;
                                                    int targetZ = 0;
                                                    success = transitionElement->QueryIntAttribute("x", &targetX);
                                                    success &= transitionElement->QueryIntAttribute("y", &targetY);
                                                    transitionElement->QueryIntAttribute("z", &targetZ);
                                                    if (success == TIXML_SUCCESS) {
                                                        ModelCoordinate mc(targetX, targetY, targetZ);
                                                        Layer* targetLayer = NULL;
                                                        const std::string* targetLayerId = transitionElement->Attribute(std::string("id"));
                                                        if (targetLayerId) {
                                                            targetLayer = map->getLayer(*targetLayerId);
                                                        }
                                                        if (!targetLayer) {
                                                            targetLayer = layer;
                                                        }

                                                        int immediate = 0;
                                                        transitionElement->QueryIntAttribute("immediate", &immediate);
                                                        cell->createTransition(targetLayer, mc, immediate != 0);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    for (const TiXmlElement* triggerElements = root->FirstChildElement("triggers"); triggerElements; triggerElements = triggerElements->NextSiblingElement("triggers")) {
                        TriggerController* triggerController = map->getTriggerController();
                        for (const TiXmlElement* triggerElement = triggerElements->FirstChildElement("trigger"); triggerElement; triggerElement = triggerElement->NextSiblingElement("trigger")) {
                            const std::string* triggerName = triggerElement->Attribute(std::string("name"));
                            int triggered = 0;
                            int allInstances = 0;
                            triggerElement->QueryIntAttribute("triggered", &triggered);
                            triggerElement->QueryIntAttribute("all_instances", &allInstances);
                            
                            Trigger* trigger = triggerController->createTrigger(*triggerName);
                            if (triggered > 0) {
                                trigger->setTriggered();
                            }
                            if (allInstances > 0) {
                                trigger->enableForAllInstances();
                            }

                            const std::string* instanceId = triggerElement->Attribute(std::string("attached_instance"));
                            const std::string* layerId = triggerElement->Attribute(std::string("attached_layer"));
                            if (instanceId  && layerId) {
                                Layer* layer = map->getLayer(*layerId);
                                if (layer) {
                                    Instance* instance = layer->getInstance(*instanceId);
                                    if (instance) {
                                        trigger->attach(instance);
                                    }
                                }
                            }
                            for (const TiXmlElement* assignElement = triggerElement->FirstChildElement("assign"); assignElement; assignElement = assignElement->NextSiblingElement("assign")) {
                                layerId = assignElement->Attribute(std::string("layer_id"));
                                if (!layerId) {
                                    continue;
                                }
                                int x = 0;
                                int y = 0;
                                assignElement->QueryIntAttribute("x", &x);
                                assignElement->QueryIntAttribute("y", &y);
                                Layer* layer = map->getLayer(*layerId);
                                if (layer) {
                                    trigger->assign(layer, ModelCoordinate(x, y));
                                }
                            }
                            for (const TiXmlElement* enabledElement = triggerElement->FirstChildElement("enabled"); enabledElement; enabledElement = enabledElement->NextSiblingElement("enabled")) {
                                layerId = enabledElement->Attribute(std::string("layer_id"));
                                instanceId = enabledElement->Attribute(std::string("instance_id"));
                                if (!instanceId || !layerId) {
                                    continue;
                                }
                                Layer* layer = map->getLayer(*layerId);
                                if (layer) {
                                    Instance* instance = layer->getInstance(*instanceId);
                                    if (instance) {
                                        trigger->enableForInstance(instance);
                                    }
                                }
                            }
                            for (const TiXmlElement* conditionElement = triggerElement->FirstChildElement("condition"); conditionElement; conditionElement = conditionElement->NextSiblingElement("condition")) {
                                int conditionId = -1;
                                conditionElement->QueryIntAttribute("id", &conditionId);
                                if (conditionId != -1) {
                                    trigger->addTriggerCondition(static_cast<TriggerCondition>(conditionId));
                                }
                            }
                        }
                    }


                    for (const TiXmlElement* cameraElement = root->FirstChildElement("camera"); cameraElement; cameraElement = cameraElement->NextSiblingElement("camera")) {
                        const std::string* cameraId = cameraElement->Attribute(std::string("id"));

                        int refCellWidth = 0;
                        int refCellHeight = 0;
                        int success = cameraElement->QueryIntAttribute("ref_cell_width", &refCellWidth);
                        success &= cameraElement->QueryIntAttribute("ref_cell_height", &refCellHeight);

                        if (cameraId && success == TIXML_SUCCESS) {
                            double tilt = 0.0;
                            double zoom = 1.0;
                            double rotation = 0.0;
                            double zToY = 0.0;
                            cameraElement->QueryDoubleAttribute("tilt", &tilt);
                            cameraElement->QueryDoubleAttribute("zoom", &zoom);
                            cameraElement->QueryDoubleAttribute("rotation", &rotation);
                            success = cameraElement->QueryDoubleAttribute("ztoy", &zToY);

                            const std::string* viewport = cameraElement->Attribute(std::string("viewport"));

                            Camera* cam = NULL;

                            if (viewport) {
                                // parse out the viewport parameters
                                IntVector viewportParameters = tokenize(*viewport, ',');

                                // make sure the right number of viewport parameters were parsed
                                if (viewportParameters.size() == 4) {
                                    Rect rect(viewportParameters[0], viewportParameters[1],
                                                viewportParameters[2], viewportParameters[3]);

                                    try {
                                        cam = map->addCamera(*cameraId, rect);
                                    }
                                    catch (NameClash&) {
                                        // TODO - handle exception
                                        assert(false);
                                    }
                                }
                            } else {
                                Rect rect(0, 0, m_renderBackend->getScreenWidth(), m_renderBackend->getScreenHeight());

                                try {
                                    cam = map->addCamera(*cameraId, rect);
                                }
                                catch (NameClash&) {
                                    // TODO - handle exception
                                    assert(false);
                                }
                            }


                            if (cam) {
                                cam->setCellImageDimensions(refCellWidth, refCellHeight);
                                cam->setRotation(rotation);
                                cam->setTilt(tilt);
                                cam->setZoom(zoom);
                                if (success == TIXML_SUCCESS) {
                                    cam->setZToY(zToY);
                                }

                                // active instance renderer for camera
                                InstanceRenderer* instanceRenderer = InstanceRenderer::getInstance(cam);
                                if (instanceRenderer)
                                {
                                    instanceRenderer->activateAllLayers(map);
                                }
                            }
                        }

                        // increment % done counter
                        m_percentDoneListener.incrementCount();
                    }
                }
            }
        }

        return map;
    }

    void MapLoader::setObjectLoader(const FIFE::ObjectLoaderPtr& objectLoader) {
        assert(objectLoader);

        m_objectLoader = objectLoader;
    }

    FIFE::ObjectLoaderPtr MapLoader::getObjectLoader() {
        return m_objectLoader;
    }

    void MapLoader::setAnimationLoader(const FIFE::AnimationLoaderPtr& animationLoader) {
        assert(animationLoader);

        m_objectLoader->setAnimationLoader(animationLoader);
    }

    FIFE::AnimationLoaderPtr MapLoader::getAnimationLoader() {
        if (m_objectLoader) {
            return m_objectLoader->getAnimationLoader();
        }
        return FIFE::AnimationLoaderPtr();
    }

    void MapLoader::setAtlasLoader(const FIFE::AtlasLoaderPtr& atlasLoader) {
        assert(atlasLoader);

        m_objectLoader->setAtlasLoader(atlasLoader);
    }

    FIFE::AtlasLoaderPtr MapLoader::getAtlasLoader() {
        if (m_objectLoader) {
            return m_objectLoader->getAtlasLoader();
        }
        return FIFE::AtlasLoaderPtr();
    }

    bool MapLoader::isLoadable(const std::string& filename) const {
        bfs::path mapPath(filename);

        TiXmlDocument mapFile;

        std::string mapFilename = mapPath.string();

        try {
            RawData* data = m_vfs->open(mapFilename);

            if (data) {
                if (data->getDataLength() != 0) {
                    mapFile.Parse(data->readString(data->getDataLength()).c_str());

                    if (mapFile.Error()) {
                        return false;
                    }

                    const TiXmlElement* root = mapFile.RootElement();

                    if (root) {
                        const std::string* loaderName = root->Attribute(std::string("loader"));

                        // if the file does not specify a loader but was opened and parsed
                        // correctly then we know we have a compatible extension so we will
                        // attempt to load it, if it does specify a loader then the loader
                        // name will be checked
                        if (!loaderName || (loaderName && *loaderName == getLoaderName())) {
                            return true;
                        }
                    }
                }

                // done with file delete the resource
                delete data;
                data = 0;
            }
        }
        catch (NotFound& e) {
            FL_ERR(_log, e.what());

            return false;
        }

        return false;
    }

    void MapLoader::loadImportFile(const std::string& file, const std::string& directory) {
        if (!file.empty()) {
            bfs::path importFilePath(directory);
            importFilePath /= file;

            std::string importFileString = importFilePath.string();
            if (m_objectLoader && m_objectLoader->getAtlasLoader() && m_objectLoader->getAtlasLoader()->isLoadable(importFileString)) {
                m_objectLoader->getAtlasLoader()->loadMultiple(importFileString);
            }
            if (m_objectLoader && m_objectLoader->getAnimationLoader() && m_objectLoader->getAnimationLoader()->isLoadable(importFileString)) {
                m_objectLoader->getAnimationLoader()->loadMultiple(importFileString);
            }
            if (m_objectLoader && m_objectLoader->isLoadable(importFileString)) {
                m_objectLoader->load(importFileString);
            }
        }
    }

    void MapLoader::loadImportDirectory(const std::string& directory) {
        if (!directory.empty()) {
            bfs::path importDirectory(directory);
            std::string importDirectoryString = importDirectory.string();

            std::set<std::string> files = m_vfs->listFiles(importDirectoryString);

            // load all xml files in the directory
            std::set<std::string>::iterator iter;
            for (iter = files.begin(); iter != files.end(); ++iter) {
                // TODO - vtchill - may need a way to allow clients to load things other
                // than .xml and .zip files
                std::string ext = bfs::extension(*iter);
                if (ext == ".xml" || ext == ".zip") {
                    loadImportFile(*iter, importDirectoryString);
                }
            }

            std::set<std::string> nestedDirectories = m_vfs->listDirectories(importDirectoryString);
            for (iter  = nestedDirectories.begin(); iter != nestedDirectories.end(); ++iter) {
                // do not attempt to load anything from a .svn directory
                if ((*iter).find(".svn") == std::string::npos) {
                    loadImportDirectory(importDirectoryString + "/" + *iter);
                }
            }
        }
    }

    void MapLoader::addPercentDoneListener(PercentDoneListener* listener) {
        m_percentDoneListener.addListener(listener);
    }

    const std::string& MapLoader::getLoaderName() const {
        return m_loaderName;

    }

    MapLoader* createDefaultMapLoader(Model* model, VFS* vfs, ImageManager* imageManager, RenderBackend* renderBackend) {
        return (new MapLoader(model, vfs, imageManager, renderBackend));
    }
}