MapReader Class Reference

#include <mapreader.h>

Static Public Member Functions
static Map *	readMap (const std::string &filename, const std::string &realFilename)
static Map *	readMap (xmlNode *const node, const std::string &path)
static Map *	createEmptyMap (const std::string &filename, const std::string &realFilename)
static void	readLayer (const xmlNodePtr node, Map *const map)
static void	loadEmptyAtlas ()
static void	unloadEmptyAtlas ()

Static Private Member Functions
static void	readProperties (const xmlNode *const node, Properties *const props)
static bool	readBase64Layer (const xmlNode *const childNode, Map *const map, MapLayer *const layer, const MapLayerTypeT &layerType, MapHeights *const heights, const std::string &compression, int &x, int &y, const int w, const int h)
static bool	readCsvLayer (const xmlNode *const childNode, Map *const map, MapLayer *const layer, const MapLayerTypeT &layerType, MapHeights *const heights, int &x, int &y, const int w, const int h)
static Tileset *	readTileset (xmlNodePtr node, const std::string &path, Map *const map)
static void	updateMusic (Map *const map)
static void	addLayerToList (const std::string &fileName, const SkipError skipError)
static void	loadLayers (const std::string &path)
static void	unloadTempLayers ()

Static Private Attributes
static Resource *	mEmptyAtlas = 0

Detailed Description

Reader for XML map files (*.tmx)

Definition at line 41 of file mapreader.h.

Member Function Documentation

addLayerToList()

void MapReader::addLayerToList ( const std::string &  fileName, const SkipError  skipError  )

staticprivate

Definition at line 230 of file mapreader.cpp.

{
    XML::Document *doc = new XML::Document(fileName,
        UseVirtFs_true,
        skipError);
    XmlNodePtrConst node = doc->rootNode();
    if (node == nullptr)
    {
        delete doc;
        return;
    }
 
    int cnt = 0;
    for_each_xml_child_node(childNode, node)
    {
        if (!xmlNameEqual(childNode, "layer"))
            continue;
        std::string name = XML::getProperty(childNode, "name", "");
        if (name.empty())
            continue;
        name = toLower(name);
        logger->log("found patch layer: " + name);
        mKnownLayers[name] = childNode;
        mKnownDocs.insert(doc);
        cnt ++;
    }
    if (cnt == 0)
        delete doc;
}

References fileName, for_each_xml_child_node, XML::getProperty(), Logger::log(), logger, anonymous_namespace{mapreader.cpp}::mKnownDocs, anonymous_namespace{mapreader.cpp}::mKnownLayers, XML::Document::rootNode(), Catch::toLower(), and UseVirtFs_true.

Referenced by loadLayers().

createEmptyMap()

Map * MapReader::createEmptyMap ( const std::string &  filename, const std::string &  realFilename  )

static

Definition at line 1275 of file mapreader.cpp.

{
    logger->log1("Creating empty map");
    Map *const map = new Map("empty map",
        300, 300,
        mapTileSize, mapTileSize);
    map->setProperty("_filename", realFilename);
    map->setProperty("_realfilename", filename);
    updateMusic(map);
    map->setCustom(true);
    MapLayer *layer = new MapLayer("nolayer",
        0, 0,
        300, 300,
        false,
        1,
        -1);
    map->addLayer(layer);
    layer = new MapLayer("nolayer",
        0, 0,
        300, 300,
        true,
        1,
        -1);
    map->addLayer(layer);
    map->updateDrawLayersList();
    map->updateConditionLayers();
    map->preCacheLayers();
 
    return map;
}

References Map::addLayer(), Logger::log1(), logger, mapTileSize, Map::preCacheLayers(), Map::setCustom(), Properties::setProperty(), Map::updateConditionLayers(), Map::updateDrawLayersList(), and updateMusic().

loadEmptyAtlas()

void MapReader::loadEmptyAtlas ( )

static

Definition at line 1319 of file mapreader.cpp.

{
    if (!graphicsManager.getUseAtlases())
        return;
 
    const MapInfo *const info = MapDB::getAtlas(
        paths.getStringValue("emptyAtlasName"));
    if (info != nullptr)
    {
        mEmptyAtlas = Loader::getEmptyAtlas(
            info->atlas,
            *info->files);
        delete info;
    }
}

References MapDB::getAtlas(), Loader::getEmptyAtlas(), Configuration::getStringValue(), GraphicsManager::getUseAtlases(), graphicsManager, Actions::info(), mEmptyAtlas, and paths.

Referenced by Game::Game().

loadLayers()

void MapReader::loadLayers ( const std::string &  path )

staticprivate

Definition at line 307 of file mapreader.cpp.

{
    BLOCK_START("MapReader::loadLayers")
    loadXmlDir2(path, addLayerToList, ".tmx", SkipError_false)
    BLOCK_END("MapReader::loadLayers")
}

References addLayerToList(), BLOCK_END, BLOCK_START, loadXmlDir2, and SkipError_false.

readBase64Layer()

bool MapReader::readBase64Layer ( const xmlNode *const  childNode, Map *const  map, MapLayer *const  layer, const MapLayerTypeT &  layerType, MapHeights *const  heights, const std::string &  compression, int &  x, int &  y, const int  w, const int  h  )

staticprivate

Definition at line 664 of file mapreader.cpp.

{
    if (childNode == nullptr)
        return false;
 
    if (!compression.empty() && compression != "gzip"
        && compression != "zlib")
    {
        reportAlways("Warning: only gzip and zlib layer"
            " compression supported!")
        return false;
    }
 
    // Read base64 encoded map file
    if (!XmlHaveChildContent(childNode))
        return true;
 
    const size_t len = strlen(XmlChildContent(childNode)) + 1;
    unsigned char *charData = new unsigned char[len + 1];
    const char *const xmlChars = XmlChildContent(childNode);
    const char *charStart = reinterpret_cast<const char*>(xmlChars);
    if (charStart == nullptr)
    {
        delete [] charData;
        return false;
    }
 
    unsigned char *charIndex = charData;
 
    while (*charStart != 0)
    {
        if (*charStart != ' ' &&
            *charStart != '\t' &&
            *charStart != '\n')
        {
            *charIndex = *charStart;
            charIndex++;
        }
        charStart++;
    }
    *charIndex = '\0';
 
    int binLen;
    unsigned char *binData = php3_base64_decode(charData,
        CAST_S32(strlen(reinterpret_cast<char*>(
        charData))), &binLen);
 
    delete [] charData;
//    XmlFree(const_cast<char*>(xmlChars));
 
    if (binData != nullptr)
    {
        if (compression == "gzip" || compression == "zlib")
        {
            // Inflate the gzipped layer data
            unsigned char *inflated = nullptr;
            const unsigned int inflatedSize =
                inflateMemory(binData, binLen, inflated);
 
            free(binData);
            binData = inflated;
            binLen = inflatedSize;
 
            if (inflated == nullptr)
            {
                reportAlways("Error: Could not decompress layer!")
                return false;
            }
        }
 
        const std::map<int, TileAnimation*> &tileAnimations
            = map->getTileAnimations();
 
        const bool hasAnimations = !tileAnimations.empty();
        if (hasAnimations)
        {
            for (int i = 0; i < binLen - 3; i += 4)
            {
                const int gid = binData[i] |
                    binData[i + 1] << 8 |
                    binData[i + 2] << 16 |
                    binData[i + 3] << 24;
 
                setTile(map, layer, layerType, heights, x, y, gid);
                TileAnimationMapCIter it = tileAnimations.find(gid);
                if (it != tileAnimations.end())
                {
                    TileAnimation *const ani = it->second;
                    if (ani != nullptr)
                        ani->addAffectedTile(layer, x + y * w);
                }
 
                x++;
                if (x == w)
                {
                    x = 0; y++;
 
                    // When we're done, don't crash on too much data
                    if (y == h)
                        break;
                }
            }
        }
        else
        {
            for (int i = 0; i < binLen - 3; i += 4)
            {
                const int gid = binData[i] |
                    binData[i + 1] << 8 |
                    binData[i + 2] << 16 |
                    binData[i + 3] << 24;
 
                setTile(map, layer, layerType, heights, x, y, gid);
 
                x++;
                if (x == w)
                {
                    x = 0; y++;
 
                    // When we're done, don't crash on too much data
                    if (y == h)
                        break;
                }
            }
        }
        free(binData);
    }
    return true;
}

References TileAnimation::addAffectedTile(), CAST_S32, Map::getTileAnimations(), inflateMemory(), php3_base64_decode(), reportAlways, setTile(), x, and y.

Referenced by readLayer().

readCsvLayer()

bool MapReader::readCsvLayer ( const xmlNode *const  childNode, Map *const  map, MapLayer *const  layer, const MapLayerTypeT &  layerType, MapHeights *const  heights, int &  x, int &  y, const int  w, const int  h  )

staticprivate

Definition at line 801 of file mapreader.cpp.

{
    if (childNode == nullptr)
        return false;
 
    if (!XmlHaveChildContent(childNode))
        return true;
 
    const char *const xmlChars = XmlChildContent(childNode);
    const char *const data = reinterpret_cast<const char*>(xmlChars);
    if (data == nullptr)
        return false;
 
    std::string csv(data);
    size_t oldPos = 0;
 
    const std::map<int, TileAnimation*> &tileAnimations
        = map->getTileAnimations();
    const bool hasAnimations = !tileAnimations.empty();
 
    if (hasAnimations)
    {
        while (oldPos != std::string::npos)
        {
            const size_t pos = csv.find_first_of(',', oldPos);
            if (pos == std::string::npos)
                return false;
 
            const int gid = atoi(csv.substr(oldPos, pos - oldPos).c_str());
            setTile(map, layer, layerType, heights, x, y, gid);
            TileAnimationMapCIter it = tileAnimations.find(gid);
            if (it != tileAnimations.end())
            {
                TileAnimation *const ani = it->second;
                if (ani != nullptr)
                    ani->addAffectedTile(layer, x + y * w);
            }
 
            x++;
            if (x == w)
            {
                x = 0; y++;
 
                // When we're done, don't crash on too much data
                if (y == h)
                    return false;
            }
            oldPos = pos + 1;
        }
    }
    else
    {
        while (oldPos != std::string::npos)
        {
            const size_t pos = csv.find_first_of(',', oldPos);
            if (pos == std::string::npos)
                return false;
 
            const int gid = atoi(csv.substr(oldPos, pos - oldPos).c_str());
            setTile(map, layer, layerType, heights, x, y, gid);
 
            x++;
            if (x == w)
            {
                x = 0; y++;
 
                // When we're done, don't crash on too much data
                if (y == h)
                    return false;
            }
            oldPos = pos + 1;
        }
    }
    return true;
}

References TileAnimation::addAffectedTile(), data, Map::getTileAnimations(), setTile(), x, and y.

Referenced by readLayer().

readLayer()

void MapReader::readLayer ( const xmlNodePtr  node, Map *const  map  )

static

Reads a map layer and adds it to the given map.

Definition at line 883 of file mapreader.cpp.

{
    if (node == nullptr)
        return;
 
    // Layers are not necessarily the same size as the map
    const int w = XML::getProperty(node, "width", map->getWidth());
    const int h = XML::getProperty(node, "height", map->getHeight());
    const int offsetX = XML::getProperty(node, "x", 0);
    const int offsetY = XML::getProperty(node, "y", 0);
    std::string name = XML::getProperty(node, "name", "");
    name = toLower(name);
 
    const bool isFringeLayer = (name.substr(0, 6) == "fringe");
    const bool isCollisionLayer = (name.substr(0, 9) == "collision");
    const bool isHeightLayer = (name.substr(0, 7) == "heights");
    const bool isActionsLayer = (name.substr(0, 7) == "actions");
    int mask = 1;
    int tileCondition = -1;
    int conditionLayer = 0;
 
    MapLayerTypeT layerType = MapLayerType::TILES;
    if (isCollisionLayer)
        layerType = MapLayerType::COLLISION;
    else if (isHeightLayer)
        layerType = MapLayerType::HEIGHTS;
    else if (isActionsLayer)
        layerType = MapLayerType::ACTIONS;
 
    map->indexTilesets();
 
    MapLayer *layer = nullptr;
    MapHeights *heights = nullptr;
 
    logger->log("- Loading layer \"%s\"", name.c_str());
    int x = 0;
    int y = 0;
 
    // Load the tile data
    for_each_xml_child_node(childNode, node)
    {
        if (xmlNameEqual(childNode, "properties"))
        {
            for_each_xml_child_node(prop, childNode)
            {
                if (!xmlNameEqual(prop, "property"))
                    continue;
                const std::string pname = XML::getProperty(prop, "name", "");
                const std::string value = XML::getProperty(prop, "value", "");
                // ignoring any layer if property Hidden is 1
                if (pname == "Hidden")
                {
                    if (value == "1")
                        return;
                }
                else if (pname == "Version")
                {
                    if (value > CHECK_VERSION)
                        return;
                }
                else if (pname == "NotVersion")
                {
                    if (value <= CHECK_VERSION)
                        return;
                }
                else if (pname == "Mask")
                {
                    mask = atoi(value.c_str());
                }
                else if (pname == "TileCondition")
                {
                    tileCondition = atoi(value.c_str());
                }
                else if (pname == "ConditionLayer")
                {
                    conditionLayer = atoi(value.c_str());
                }
                else if (pname == "SideView")
                {
                    if (value != "down")
                        return;
                }
            }
        }
 
        if (!xmlNameEqual(childNode, "data"))
            continue;
 
        // Disable for future usage "TileCondition" attribute
        // if already set ConditionLayer to non zero
        if (conditionLayer != 0)
            tileCondition = -1;
 
        switch (layerType)
        {
            case MapLayerType::TILES:
            {
                layer = new MapLayer(name,
                    offsetX, offsetY,
                    w, h,
                    isFringeLayer,
                    mask,
                    tileCondition);
                map->addLayer(layer);
                break;
            }
            case MapLayerType::HEIGHTS:
            {
                heights = new MapHeights(w, h);
                map->addHeights(heights);
                break;
            }
            default:
            case MapLayerType::ACTIONS:
            case MapLayerType::COLLISION:
                break;
        }
 
        const std::string encoding =
            XML::getProperty(childNode, "encoding", "");
        const std::string compression =
            XML::getProperty(childNode, "compression", "");
 
        if (encoding == "base64")
        {
            if (readBase64Layer(childNode, map, layer, layerType,
                heights, compression, x, y, w, h))
            {
                continue;
            }
            else
            {
                return;
            }
        }
        else if (encoding == "csv")
        {
            if (readCsvLayer(childNode, map, layer, layerType,
                heights, x, y, w, h))
            {
                continue;
            }
            else
            {
                return;
            }
        }
        else
        {
            const std::map<int, TileAnimation*> &tileAnimations
                = map->getTileAnimations();
            const bool hasAnimations = !tileAnimations.empty();
 
            // Read plain XML map file
            for_each_xml_child_node(childNode2, childNode)
            {
                if (!xmlNameEqual(childNode2, "tile"))
                    continue;
 
                const int gid = XML::getProperty(childNode2, "gid", -1);
                setTile(map, layer, layerType, heights, x, y, gid);
                if (hasAnimations)
                {
                    TileAnimationMapCIter it = tileAnimations.find(gid);
                    if (it != tileAnimations.end())
                    {
                        TileAnimation *const ani = it->second;
                        if (ani != nullptr)
                            ani->addAffectedTile(layer, x + y * w);
                    }
                }
 
                x++;
                if (x == w)
                {
                    x = 0; y++;
                    if (y >= h)
                        break;
                }
            }
        }
 
        if (y < h)
            std::cerr << "TOO SMALL!\n";
        if (x != 0)
            std::cerr << "TOO SMALL!\n";
 
        // There can be only one data element
        break;
    }
}

References MapLayerType::ACTIONS, TileAnimation::addAffectedTile(), Map::addHeights(), Map::addLayer(), CHECK_VERSION, MapLayerType::COLLISION, for_each_xml_child_node, Map::getHeight(), XML::getProperty(), Map::getTileAnimations(), Map::getWidth(), MapLayerType::HEIGHTS, Map::indexTilesets(), Logger::log(), logger, readBase64Layer(), readCsvLayer(), setTile(), MapLayerType::TILES, Catch::toLower(), x, and y.

Referenced by loadReplaceLayer().

readMap() [1/2]

static Map* MapReader::readMap ( const std::string &  filename, const std::string &  realFilename  )

static

Read an XML map from a file.

Referenced by Game::changeMap().

readMap() [2/2]

static Map* MapReader::readMap ( xmlNode *const  node, const std::string &  path  )

static

Read an XML map from a parsed XML tree. The path is used to find the location of referenced tileset images.

readProperties()

void MapReader::readProperties ( const xmlNode *const  node, Properties *const  props  )

staticprivate

Reads the properties element.

Parameters

node	The properties element.
props	The Properties instance to which the properties will be assigned.

Definition at line 522 of file mapreader.cpp.

{
    BLOCK_START("MapReader::readProperties")
    if (node == nullptr)
    {
        BLOCK_END("MapReader::readProperties")
        return;
    }
 
    for_each_xml_child_node(childNode, node)
    {
        if (!xmlNameEqual(childNode, "property"))
            continue;
 
        // Example: <property name="name" value="value"/>
        const std::string name = XML::getProperty(childNode, "name", "");
        const std::string value = XML::getProperty(childNode, "value", "");
 
        if (!name.empty() && !value.empty())
        {
            if (name == "name")
                props->setProperty(name, translator->getStr(value));
            else
                props->setProperty(name, value);
        }
    }
    BLOCK_END("MapReader::readProperties")
}

References BLOCK_END, BLOCK_START, for_each_xml_child_node, XML::getProperty(), PoDict::getStr(), and translator.

readTileset()

Tileset * MapReader::readTileset ( xmlNodePtr  node, const std::string &  path, Map *const  map  )

staticprivate

Reads a tile set.

Definition at line 1075 of file mapreader.cpp.

{
    BLOCK_START("MapReader::readTileset")
    if (node == nullptr)
    {
        BLOCK_END("MapReader::readTileset")
        return nullptr;
    }
 
    const int firstGid = XML::getProperty(node, "firstgid", 0);
    const int margin = XML::getProperty(node, "margin", 0);
    const int spacing = XML::getProperty(node, "spacing", 0);
    XML::Document* doc = nullptr;
    Tileset *set = nullptr;
    std::string pathDir(path);
    std::map<std::string, std::string> props;
 
    if (XmlHasProp(node, "source"))
    {
        std::string filename = XML::getProperty(node, "source", "");
        filename = resolveRelativePath(path, filename);
 
        doc = new XML::Document(filename, UseVirtFs_true, SkipError_false);
        node = doc->rootNode();
        if (node == nullptr)
        {
            delete doc;
            BLOCK_END("MapReader::readTileset")
            return nullptr;
        }
 
        // Reset path to be realtive to the tsx file
        pathDir = filename.substr(0, filename.rfind('/') + 1);
    }
 
    const int tw = XML::getProperty(node, "tilewidth", map->getTileWidth());
    const int th = XML::getProperty(node, "tileheight", map->getTileHeight());
 
    for_each_xml_child_node(childNode, node)
    {
        if (xmlNameEqual(childNode, "image"))
        {
            // ignore second other <image> tags in tileset
            if (set != nullptr)
                continue;
 
            const std::string source = XML::getProperty(
                childNode, "source", "");
 
            if (!source.empty())
            {
                const std::string sourceResolved = resolveRelativePath(pathDir,
                    source);
 
                Image *const tilebmp = Loader::getImage(sourceResolved);
 
                if (tilebmp != nullptr)
                {
                    set = new Tileset(tilebmp,
                        tw, th,
                        firstGid,
                        margin,
                        spacing);
                    tilebmp->decRef();
#ifdef USE_OPENGL
                    if (MapDB::isEmptyTileset(sourceResolved))
                        set->setEmpty(true);
                    if (tilebmp->getType() == ImageType::Image &&
                        map->haveAtlas() == true &&
                        graphicsManager.getUseAtlases())
                    {
                        reportAlways("Error: image '%s' not present in atlas",
                            source.c_str())
                    }
#endif  // USE_OPENGL
                }
                else
                {
                    reportAlways("Error: Failed to load tileset (%s)",
                        source.c_str())
                }
            }
        }
        else if (xmlNameEqual(childNode, "properties"))
        {
            for_each_xml_child_node(propertyNode, childNode)
            {
                if (!xmlNameEqual(propertyNode, "property"))
                    continue;
                const std::string name = XML::getProperty(
                    propertyNode, "name", "");
                if (!name.empty())
                    props[name] = XML::getProperty(propertyNode, "value", "");
            }
        }
        else if (xmlNameEqual(childNode, "tile"))
        {
            bool haveAnimation(false);
 
            for_each_xml_child_node(tileNode, childNode)
            {
                const bool isProps = xmlNameEqual(tileNode, "properties");
                const bool isAnim = xmlNameEqual(tileNode, "animation");
                if (!isProps && !isAnim)
                    continue;
 
                const int tileGID = firstGid + XML::getProperty(
                    childNode, "id", 0);
 
                Animation *ani = new Animation("from map");
 
                if (isProps)
                {
                    // read tile properties to a map for simpler handling
                    StringIntMap tileProperties;
                    for_each_xml_child_node(propertyNode, tileNode)
                    {
                        if (!xmlNameEqual(propertyNode, "property"))
                            continue;
 
                        haveAnimation = true;
                        const std::string name = XML::getProperty(
                            propertyNode, "name", "");
                        if (!name.empty())
                        {
                            const int value = XML::getProperty(
                                propertyNode, "value", 0);
                            tileProperties[name] = value;
                            logger->log("Tile Prop of %d \"%s\" = \"%d\"",
                                tileGID, name.c_str(), value);
                        }
                    }
 
                    // create animation
                    if (set == nullptr ||
                        !config.getBoolValue("playMapAnimations"))
                    {
                        delete ani;
                        continue;
                    }
 
                    for (int i = 0; ; i++)
                    {
                        const std::string iStr(toString(i));
                        StringIntMapCIter iFrame
                            = tileProperties.find("animation-frame" + iStr);
                        StringIntMapCIter iDelay
                            = tileProperties.find("animation-delay" + iStr);
                        // possible need add random attribute?
                        if (iFrame != tileProperties.end()
                            && iDelay != tileProperties.end())
                        {
                            ani->addFrame(set->get(iFrame->second),
                                iDelay->second, 0, 0, 100);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
                else if (isAnim && !haveAnimation)
                {
                    for_each_xml_child_node(frameNode, tileNode)
                    {
                        if (!xmlNameEqual(frameNode, "frame"))
                            continue;
 
                        if (set != nullptr)
                        {
                            const int tileId = XML::getProperty(
                                frameNode, "tileid", 0);
                            const int duration = XML::getProperty(
                                frameNode, "duration", 0) /  10;
 
                            ani->addFrame(set->get(tileId),
                                duration,
                                0, 0, 100);
                        }
                    }
                }
 
                if (ani->getLength() > 0)
                    map->addAnimation(tileGID, new TileAnimation(ani));
                else
                    delete2(ani)
            }
        }
    }
 
    delete doc;
 
    if (set != nullptr)
        set->setProperties(props);
    BLOCK_END("MapReader::readTileset")
    return set;
}

References Map::addAnimation(), Animation::addFrame(), ParticleType::Animation, BLOCK_END, BLOCK_START, config, delete2, for_each_xml_child_node, ImageSet::get(), Configuration::getBoolValue(), Loader::getImage(), Animation::getLength(), XML::getProperty(), Map::getTileHeight(), Map::getTileWidth(), GraphicsManager::getUseAtlases(), graphicsManager, Map::haveAtlas(), ImageType::Image, MapDB::isEmptyTileset(), Logger::log(), logger, reportAlways, resolveRelativePath(), XML::Document::rootNode(), Tileset::setEmpty(), Tileset::setProperties(), SkipError_false, Catch::toString(), and UseVirtFs_true.

unloadEmptyAtlas()

void MapReader::unloadEmptyAtlas ( )

static

Definition at line 1335 of file mapreader.cpp.

{
    if (mEmptyAtlas != nullptr)
        mEmptyAtlas->decRef();
}

References Resource::decRef(), and mEmptyAtlas.

Referenced by Game::~Game().

unloadTempLayers()

void MapReader::unloadTempLayers ( )

staticprivate

Definition at line 314 of file mapreader.cpp.

{
    FOR_EACH (DocIterator, it, mKnownDocs)
        delete (*it);
    mKnownLayers.clear();
    mKnownDocs.clear();
}

References FOR_EACH, anonymous_namespace{mapreader.cpp}::mKnownDocs, and anonymous_namespace{mapreader.cpp}::mKnownLayers.

updateMusic()

void MapReader::updateMusic ( Map *const  map )

staticprivate

Definition at line 1307 of file mapreader.cpp.

{
    std::string name = map->getProperty("shortName", std::string());
    const size_t p = name.rfind('.');
    if (p != std::string::npos)
        name = name.substr(0, p);
    name.append(".ogg");
    if (VirtFs::exists(pathJoin(paths.getStringValue("music"), name)))
        map->setProperty("music", name);
}

References VirtFs::exists(), Properties::getProperty(), Configuration::getStringValue(), pathJoin(), paths, and Properties::setProperty().

Referenced by createEmptyMap().

Field Documentation

mEmptyAtlas

Resource * MapReader::mEmptyAtlas = 0

staticprivate

Definition at line 120 of file mapreader.h.

Referenced by loadEmptyAtlas(), and unloadEmptyAtlas().

---

The documentation for this class was generated from the following files:

• src/resources/mapreader.h (986a3bf)
• src/resources/mapreader.cpp (986a3bf)