mapreader.cpp File Reference

(986a3bf)

#include "resources/mapreader.h"
#include "configuration.h"
#include "graphicsmanager.h"
#include "main.h"
#include "const/resources/map/map.h"
#include "enums/resources/map/collisiontype.h"
#include "enums/resources/map/mapitemtype.h"
#include "fs/virtfs/fs.h"
#include "resources/map/map.h"
#include "resources/map/mapheights.h"
#include "resources/map/maplayer.h"
#include "resources/map/tileset.h"
#include "resources/beingcommon.h"
#include "resources/animation/animation.h"
#include "resources/image/image.h"
#include "resources/db/mapdb.h"
#include "resources/loaders/atlasloader.h"
#include "resources/loaders/emptyatlasloader.h"
#include "resources/map/tileanimation.h"
#include "resources/loaders/imageloader.h"
#include "resources/loaders/walklayerloader.h"
#include "utils/base64.h"
#include "utils/checkutils.h"
#include "utils/delete2.h"
#include "utils/stringmap.h"
#include "utils/translation/podict.h"
#include <zlib.h>
#include "debug.h"

Go to the source code of this file.

Namespaces
	anonymous_namespace{mapreader.cpp}

Typedefs
typedef std::map< std::string, xmlNodePtr >::iterator	LayerInfoIterator
typedef std::set< XML::Document * >::iterator	DocIterator

Functions
static int	inflateMemory (unsigned char *in, unsigned int inLength, unsigned char *&out, unsigned int &outLength)
static int	inflateMemory (unsigned char *in, unsigned int inLength, unsigned char *&out)
static std::string	resolveRelativePath (std::string base, std::string relative)
static void	loadReplaceLayer (LayerInfoIterator &it, Map *map)
static void	setTile (Map *map, MapLayer *layer, MapLayerTypeT &layerType, MapHeights *heights, int x, int y, int gid)

Variables
std::map< std::string, xmlNodePtr >	anonymous_namespace{mapreader.cpp}::mKnownLayers
std::set< XML::Document * >	anonymous_namespace{mapreader.cpp}::mKnownDocs

Typedef Documentation

DocIterator

typedef std::set<XML::Document*>::iterator DocIterator

Definition at line 73 of file mapreader.cpp.

LayerInfoIterator

typedef std::map<std::string, xmlNodePtr >::iterator LayerInfoIterator

Definition at line 72 of file mapreader.cpp.

Function Documentation

inflateMemory() [1/2]

int inflateMemory ( unsigned char *  in, unsigned int  inLength, unsigned char *&  out  )

static

Definition at line 196 of file mapreader.cpp.

{
    unsigned int outLength = 0;
    const int ret = inflateMemory(in, inLength, out, outLength);
 
    if (ret != Z_OK || (out == nullptr))
    {
        if (ret == Z_MEM_ERROR)
        {
            reportAlways("Error: Out of memory while decompressing map data!")
        }
        else if (ret == Z_VERSION_ERROR)
        {
            reportAlways("Error: Incompatible zlib version!")
        }
        else if (ret == Z_DATA_ERROR)
        {
            reportAlways("Error: Incorrect zlib compressed data!")
        }
        else
        {
            reportAlways("Error: Unknown error while decompressing map data!")
        }
 
        free(out);
        out = nullptr;
        outLength = 0;
    }
 
    return outLength;
}

References inflateMemory(), and reportAlways.

inflateMemory() [2/2]

int inflateMemory ( unsigned char *  in, unsigned int  inLength, unsigned char *&  out, unsigned int &  outLength  )

static

Inflates either zlib or gzip deflated memory. The inflated memory is expected to be freed by the caller.

Definition at line 124 of file mapreader.cpp.

{
    int bufferSize = 256 * 1024;
    out = static_cast<unsigned char*>(calloc(bufferSize, 1));
 
    z_stream strm;
    strm.zalloc = nullptr;
    strm.zfree = nullptr;
    strm.opaque = nullptr;
    strm.next_in = in;
    strm.avail_in = inLength;
    strm.next_out = out;
    strm.avail_out = bufferSize;
 
PRAGMACLANG6GCC(GCC diagnostic push)
PRAGMACLANG6GCC(GCC diagnostic ignored "-Wold-style-cast")
    int ret = inflateInit2(&strm, 15 + 32);
PRAGMACLANG6GCC(GCC diagnostic pop)
 
    if (ret != Z_OK)
        return ret;
 
    do
    {
        if (strm.next_out == nullptr)
        {
            inflateEnd(&strm);
            return Z_MEM_ERROR;
        }
 
        ret = inflate(&strm, Z_NO_FLUSH);
        if (ret == Z_STREAM_ERROR)
            return ret;
 
        switch (ret)
        {
            case Z_NEED_DICT:
                ret = Z_DATA_ERROR;
                A_FALLTHROUGH
            case Z_DATA_ERROR:
            case Z_MEM_ERROR:
                (void) inflateEnd(&strm);
                return ret;
            default:
                break;
        }
 
        if (ret != Z_STREAM_END)
        {
            out = static_cast<unsigned char*>(realloc(out, bufferSize * 2));
 
            if (out == nullptr)
            {
                inflateEnd(&strm);
                return Z_MEM_ERROR;
            }
 
            strm.next_out = out + CAST_SIZE(bufferSize);
            strm.avail_out = bufferSize;
            bufferSize *= 2;
        }
    }
    while (ret != Z_STREAM_END);
 
    outLength = bufferSize - strm.avail_out;
    (void) inflateEnd(&strm);
    return Z_OK;
}

References A_FALLTHROUGH, CAST_SIZE, and PRAGMACLANG6GCC.

Referenced by inflateMemory(), and MapReader::readBase64Layer().

loadReplaceLayer()

static void loadReplaceLayer ( LayerInfoIterator &  it, Map *  map  )

static

Definition at line 324 of file mapreader.cpp.

{
    MapReader::readLayer((*it).second, map);
}

References MapReader::readLayer().

resolveRelativePath()

static std::string resolveRelativePath ( std::string  base, std::string  relative  )

static

Definition at line 94 of file mapreader.cpp.

{
    // Remove trailing "/", if present
    size_t i = base.length();
    if (base.at(i - 1) == '/')
        base.erase(i - 1, i);
 
    while (relative.substr(0, 3) == "../")
    {
        relative.erase(0, 3);  // Remove "../"
        if (!base.empty())  // If base is already empty, we can't trim anymore
        {
            i = base.find_last_of('/');
            if (i == std::string::npos)
                i = 0;
            base.erase(i, base.length());  // Remove deepest folder in base
        }
    }
 
    // Re-add trailing slash, if needed
    if (!base.empty() && base[base.length() - 1] != '/')
        base.append("/");
 
    return base + relative;
}

References anonymous_namespace{stringutils.cpp}::base.

Referenced by MapReader::readTileset().

setTile()

static void setTile ( Map *  map, MapLayer *  layer, MapLayerTypeT &  layerType, MapHeights *  heights, int  x, int  y, int  gid  )

inlinestatic

Definition at line 559 of file mapreader.cpp.

{
    const Tileset * const set = map->getTilesetWithGid(gid);
    switch (layerType)
    {
        case MapLayerType::TILES:
        {
            if (layer == nullptr)
                break;
            if (set != nullptr &&
                !set->isEmpty())
            {
                Image *const img = set->get(gid - set->getFirstGid());
                layer->setTile(x, y, img);
            }
            else
            {
                layer->setTile(x, y, nullptr);
            }
            break;
        }
 
        case MapLayerType::COLLISION:
        {
            if (set != nullptr)
            {
                if (map->getVersion() >= 1)
                {
                    const int collisionId = gid - set->getFirstGid();
                    CollisionTypeT type;
                    if (collisionId < 0 ||
                        collisionId >= CAST_S32(CollisionType::COLLISION_MAX))
                    {
                        type = CollisionType::COLLISION_EMPTY;
                    }
                    else
                    {
                        type = static_cast<CollisionTypeT>(collisionId);
                    }
                    switch (type)
                    {
                        case CollisionType::COLLISION_EMPTY:
                            map->addBlockMask(x, y, BlockType::GROUND);
                            break;
                        case CollisionType::COLLISION_WALL:
                            map->addBlockMask(x, y, BlockType::WALL);
                            break;
                        case CollisionType::COLLISION_AIR:
                            map->addBlockMask(x, y, BlockType::AIR);
                            break;
                        case CollisionType::COLLISION_WATER:
                            map->addBlockMask(x, y, BlockType::WATER);
                            break;
                        case CollisionType::COLLISION_GROUNDTOP:
                            map->addBlockMask(x, y, BlockType::GROUNDTOP);
                            break;
                        case CollisionType::COLLISION_PLAYER_WALL:
                            map->addBlockMask(x, y, BlockType::PLAYERWALL);
                            break;
                        case CollisionType::COLLISION_MONSTER_WALL:
                            map->addBlockMask(x, y, BlockType::MONSTERWALL);
                            break;
                        case CollisionType::COLLISION_MAX:
                        default:
                            break;
                    }
                }
                else
                {
                    if (gid - set->getFirstGid() != 0)
                        map->addBlockMask(x, y, BlockType::WALL);
                }
            }
            break;
        }
 
        case MapLayerType::HEIGHTS:
        {
            if (set == nullptr || heights == nullptr)
                break;
            if (map->getVersion() >= 2)
            {
                heights->setHeight(x, y, CAST_U8(
                    gid - set->getFirstGid() + 1));
            }
            else
            {
                Image *const img = set->get(gid - set->getFirstGid());
                if (layer != nullptr)
                    layer->setTile(x, y, img);
            }
            break;
        }
 
        default:
        case MapLayerType::ACTIONS:
            break;
    }
}

References MapLayerType::ACTIONS, Map::addBlockMask(), BlockType::AIR, CAST_S32, CAST_U8, MapLayerType::COLLISION, CollisionType::COLLISION_AIR, CollisionType::COLLISION_EMPTY, CollisionType::COLLISION_GROUNDTOP, CollisionType::COLLISION_MAX, CollisionType::COLLISION_MONSTER_WALL, CollisionType::COLLISION_PLAYER_WALL, CollisionType::COLLISION_WALL, CollisionType::COLLISION_WATER, ImageSet::get(), Tileset::getFirstGid(), Map::getTilesetWithGid(), Map::getVersion(), BlockType::GROUND, BlockType::GROUNDTOP, MapLayerType::HEIGHTS, Tileset::isEmpty(), BlockType::MONSTERWALL, BlockType::PLAYERWALL, MapHeights::setHeight(), MapLayer::setTile(), MapLayerType::TILES, BlockType::WALL, BlockType::WATER, x, and y.

Referenced by MapReader::readBase64Layer(), MapReader::readCsvLayer(), and MapReader::readLayer().