Move map related files into resources/map.

10 files changed, 3664 insertions, 0 deletions

diff --git a/src/resources/map/map.cpp b/src/resources/map/map.cpp
new file mode 100644
index 000000000..c753b0202
--- /dev/null
+++ b/src/resources/map/map.cpp
@@ -0,0 +1,1509 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "resources/map/map.h"
+
+#include "client.h"
+#include "configuration.h"
+#include "render/graphics.h"
+#include "notifications.h"
+#include "notifymanager.h"
+#include "simpleanimation.h"
+
+#include "resources/map/mapheights.h"
+#include "resources/map/maplayer.h"
+#include "resources/map/tileset.h"
+#include "resources/map/walklayer.h"
+
+#include "being/localplayer.h"
+
+#include "particle/particle.h"
+
+#include "resources/ambientlayer.h"
+#include "resources/image.h"
+#include "resources/resourcemanager.h"
+#include "resources/subimage.h"
+
+#include "utils/delete2.h"
+#include "utils/dtor.h"
+#include "utils/mkdir.h"
+#include "utils/physfstools.h"
+#include "utils/timer.h"
+
+#include <climits>
+#include <queue>
+
+#include <sys/stat.h>
+
+#include "debug.h"
+
+/**
+ * A location on a tile map. Used for pathfinding, open list.
+ */
+struct Location final
+{
+    /**
+     * Constructor.
+     */
+    Location(const int px, const int py, MetaTile *const ptile):
+        x(px), y(py), tile(ptile)
+    {}
+
+    /**
+     * Comparison operator.
+     */
+    bool operator< (const Location &loc) const
+    {
+        return tile->Fcost > loc.tile->Fcost;
+    }
+
+    int x, y;
+    MetaTile *tile;
+};
+
+class ActorFunctuator final
+{
+    public:
+        bool operator()(const Actor *const a, const Actor *const b) const
+        {
+            if (!a || !b)
+                return false;
+            return a->getSortPixelY() < b->getSortPixelY();
+        }
+} actorCompare;
+
+TileAnimation::TileAnimation(Animation *const ani):
+    mAffected(),
+    mAnimation(new SimpleAnimation(ani)),
+    mLastImage(nullptr)
+{
+}
+
+TileAnimation::~TileAnimation()
+{
+    delete2(mAnimation);
+}
+
+bool TileAnimation::update(const int ticks)
+{
+    if (!mAnimation)
+        return false;
+
+    // update animation
+    if (!mAnimation->update(ticks))
+        return false;
+
+    // exchange images
+    Image *const img = mAnimation->getCurrentImage();
+    if (img != mLastImage)
+    {
+        FOR_EACH (TilePairVectorCIter, i, mAffected)
+        {
+            if (i->first)
+                i->first->setTile(i->second, img);
+        }
+        mLastImage = img;
+    }
+    return true;
+}
+
+Map::Map(const int width, const int height,
+         const int tileWidth, const int tileHeight) :
+    Properties(),
+    mWidth(width), mHeight(height),
+    mTileWidth(tileWidth), mTileHeight(tileHeight),
+    mMaxTileHeight(height),
+    mMetaTiles(new MetaTile[mWidth * mHeight]),
+    mWalkLayer(nullptr),
+    mLayers(),
+    mTilesets(),
+    mActors(),
+    mHasWarps(false),
+    mDebugFlags(MAP_NORMAL),
+    mOnClosedList(1),
+    mOnOpenList(2),
+    mBackgrounds(),
+    mForegrounds(),
+    mLastAScrollX(0.0F),
+    mLastAScrollY(0.0F),
+    mParticleEffects(),
+    mMapPortals(),
+    mTileAnimations(),
+    mOverlayDetail(config.getIntValue("OverlayDetail")),
+    mOpacity(config.getFloatValue("guialpha")),
+#ifdef USE_OPENGL
+    mOpenGL(intToRenderType(config.getIntValue("opengl"))),
+#else
+    mOpenGL(RENDER_SOFTWARE),
+#endif
+    mPvp(0),
+    mTilesetsIndexed(false),
+    mIndexedTilesets(nullptr),
+    mIndexedTilesetsSize(0),
+    mActorFixX(0),
+    mActorFixY(0),
+    mVersion(0),
+    mSpecialLayer(new SpecialLayer(width, height)),
+    mTempLayer(new SpecialLayer(width, height)),
+    mObjects(new ObjectsLayer(width, height)),
+    mFringeLayer(nullptr),
+    mLastX(-1),
+    mLastY(-1),
+    mLastScrollX(-1),
+    mLastScrollY(-1),
+    mDrawX(-1),
+    mDrawY(-1),
+    mDrawScrollX(-1),
+    mDrawScrollY(-1),
+    mMask(1),
+    mAtlas(nullptr),
+    mHeights(nullptr),
+    mRedrawMap(true),
+    mBeingOpacity(false),
+    mCustom(false)
+{
+    const int size = mWidth * mHeight;
+    for (int i = 0; i < NB_BLOCKTYPES; i++)
+    {
+        mOccupation[i] = new unsigned[static_cast<size_t>(size)];
+        memset(mOccupation[i], 0, static_cast<size_t>(size)
+            * sizeof(unsigned));
+    }
+
+    config.addListener("OverlayDetail", this);
+    config.addListener("guialpha", this);
+    config.addListener("beingopacity", this);
+
+    if (mOpacity != 1.0F)
+        mBeingOpacity = config.getBoolValue("beingopacity");
+    else
+        mBeingOpacity = false;
+}
+
+Map::~Map()
+{
+    config.removeListeners(this);
+    CHECKLISTENERS
+
+    delete [] mMetaTiles;
+    for (int i = 0; i < NB_BLOCKTYPES; i++)
+        delete [] mOccupation[i];
+
+    if (mWalkLayer)
+    {
+        mWalkLayer->decRef();
+        mWalkLayer = nullptr;
+    }
+    mFringeLayer = nullptr;
+    delete_all(mLayers);
+    delete_all(mTilesets);
+    delete_all(mForegrounds);
+    delete_all(mBackgrounds);
+    delete_all(mTileAnimations);
+    delete2(mSpecialLayer);
+    delete2(mTempLayer);
+    delete2(mObjects);
+    delete_all(mMapPortals);
+    if (mAtlas)
+    {
+        mAtlas->decRef();
+        mAtlas = nullptr;
+    }
+    delete2(mHeights);
+}
+
+void Map::optionChanged(const std::string &value)
+{
+    if (value == "OverlayDetail")
+    {
+        mOverlayDetail = config.getIntValue("OverlayDetail");
+    }
+    else if (value == "guialpha")
+    {
+        mOpacity = config.getFloatValue("guialpha");
+        if (mOpacity != 1.0F)
+            mBeingOpacity = config.getBoolValue("beingopacity");
+        else
+            mBeingOpacity = false;
+    }
+    else if (value == "beingopacity")
+    {
+        if (mOpacity != 1.0F)
+            mBeingOpacity = config.getBoolValue("beingopacity");
+        else
+            mBeingOpacity = false;
+    }
+}
+
+void Map::initializeAmbientLayers()
+{
+    ResourceManager *const resman = ResourceManager::getInstance();
+
+    // search for "foreground*" or "overlay*" (old term) in map properties
+    for (int i = 0; /* terminated by a break */; i++)
+    {
+        std::string name;
+        if (hasProperty(std::string("foreground").append(
+            toString(i)).append("image")))
+        {
+            name = "foreground" + toString(i);
+        }
+        else if (hasProperty(std::string("overlay").append(
+                 toString(i)).append("image")))
+        {
+            name = "overlay" + toString(i);
+        }
+        else
+        {
+            break;  // the FOR loop
+        }
+
+        Image *const img = resman->getImage(getProperty(name + "image"));
+        if (img)
+        {
+            int mask = atoi(getProperty(name + "mask").c_str());
+            if (!mask)
+                mask = 1;
+            const float parallax = getFloatProperty(name + "parallax");
+            mForegrounds.push_back(new AmbientLayer(img,
+                getFloatProperty(name + "parallaxX", parallax),
+                getFloatProperty(name + "parallaxY", parallax),
+                getFloatProperty(name + "posX"),
+                getFloatProperty(name + "posY"),
+                getFloatProperty(name + "scrollX"),
+                getFloatProperty(name + "scrollY"),
+                getBoolProperty(name + "keepratio"),
+                mask));
+
+            // The AmbientLayer takes control over the image.
+            img->decRef();
+        }
+    }
+
+    // search for "background*" in map properties
+    for (int i = 0; hasProperty(std::string("background").append(
+         toString(i)).append("image")); i ++)
+    {
+        const std::string name("background" + toString(i));
+        Image *const img = resman->getImage(getProperty(name + "image"));
+
+        if (img)
+        {
+            int mask = atoi(getProperty(name + "mask").c_str());
+            if (!mask)
+                mask = 1;
+
+            const float parallax = getFloatProperty(name + "parallax");
+            mForegrounds.push_back(new AmbientLayer(img,
+                getFloatProperty(name + "parallaxX", parallax),
+                getFloatProperty(name + "parallaxY", parallax),
+                getFloatProperty(name + "posX"),
+                getFloatProperty(name + "posY"),
+                getFloatProperty(name + "scrollX"),
+                getFloatProperty(name + "scrollY"),
+                getBoolProperty(name + "keepratio"),
+                mask));
+
+            // The AmbientLayer takes control over the image.
+            img->decRef();
+        }
+    }
+}
+
+void Map::addLayer(MapLayer *const layer)
+{
+    if (layer)
+    {
+        mLayers.push_back(layer);
+        if (layer->isFringeLayer() && !mFringeLayer)
+            mFringeLayer = layer;
+    }
+}
+
+void Map::addTileset(Tileset *const tileset)
+{
+    if (!tileset)
+        return;
+
+    mTilesets.push_back(tileset);
+    const int height = tileset->getHeight();
+    if (height > mMaxTileHeight)
+        mMaxTileHeight = height;
+}
+
+void Map::update(const int ticks)
+{
+    // Update animated tiles
+    FOR_EACH (TileAnimationMapCIter, iAni, mTileAnimations)
+    {
+        TileAnimation *const tileAni = iAni->second;
+        if (tileAni && tileAni->update(ticks))
+            mRedrawMap = true;
+    }
+}
+
+void Map::draw(Graphics *const graphics, int scrollX, int scrollY)
+{
+    if (!player_node)
+        return;
+
+    BLOCK_START("Map::draw")
+    // Calculate range of tiles which are on-screen
+    const int endPixelY = graphics->mHeight + scrollY + mTileHeight - 1
+        + mMaxTileHeight - mTileHeight;
+    const int startX = scrollX / mTileWidth - 2;
+    const int startY = scrollY / mTileHeight;
+    const int endX = (graphics->mWidth + scrollX + mTileWidth - 1)
+        / mTileWidth + 1;
+    const int endY = endPixelY / mTileHeight + 1;
+
+    // Make sure actors are sorted ascending by Y-coordinate
+    // so that they overlap correctly
+    BLOCK_START("Map::draw sort")
+        mActors.sort(actorCompare);
+    BLOCK_END("Map::draw sort")
+
+    // update scrolling of all ambient layers
+    updateAmbientLayers(static_cast<float>(scrollX),
+                        static_cast<float>(scrollY));
+
+    // Draw backgrounds
+    drawAmbientLayers(graphics, BACKGROUND_LAYERS, mOverlayDetail);
+
+    if (mDebugFlags == MAP_BLACKWHITE && userPalette)
+    {
+        graphics->setColor(userPalette->getColorWithAlpha(
+            UserPalette::WALKABLE_HIGHLIGHT));
+
+        graphics->fillRectangle(Rect(0, 0,
+            graphics->mWidth, graphics->mHeight));
+    }
+
+#ifdef USE_OPENGL
+    int updateFlag = 0;
+
+    if (mOpenGL == RENDER_NORMAL_OPENGL || mOpenGL == RENDER_GLES_OPENGL)
+    {
+        if (mLastX != startX || mLastY != startY || mLastScrollX != scrollX
+            || mLastScrollY != scrollY)
+        {   // player moving
+            mLastX = startX;
+            mLastY = startY;
+            mLastScrollX = scrollX;
+            mLastScrollY = scrollY;
+            updateFlag = 2;
+        }
+        else if (mRedrawMap || startX != mDrawX || startY != mDrawY ||
+                 scrollX != mDrawScrollX || scrollY != mDrawScrollY)
+        {   // player mode to new position
+            mRedrawMap = false;
+            mDrawX = startX;
+            mDrawY = startY;
+            mDrawScrollX = scrollX;
+            mDrawScrollY = scrollY;
+            updateFlag = 1;
+        }
+    }
+#endif
+
+    if (mDebugFlags == MAP_SPECIAL3 || mDebugFlags == MAP_BLACKWHITE)
+    {
+        if (mFringeLayer)
+        {
+            mFringeLayer->setSpecialLayer(mSpecialLayer);
+            mFringeLayer->setTempLayer(mTempLayer);
+            mFringeLayer->drawFringe(graphics, startX, startY, endX, endY,
+                scrollX, scrollY, &mActors, mDebugFlags, mActorFixY);
+        }
+    }
+    else
+    {
+        bool overFringe = false;
+
+        for (LayersCIter layeri = mLayers.begin(), layeri_end = mLayers.end();
+             layeri != layeri_end && !overFringe; ++ layeri)
+        {
+            MapLayer *const layer = *layeri;
+            if (!(layer->mMask & mMask))
+                continue;
+
+            if (layer->isFringeLayer())
+            {
+                layer->setSpecialLayer(mSpecialLayer);
+                layer->setTempLayer(mTempLayer);
+                if (mDebugFlags == MAP_SPECIAL2)
+                    overFringe = true;
+
+                layer->drawFringe(graphics, startX, startY, endX, endY,
+                    scrollX, scrollY, &mActors, mDebugFlags, mActorFixY);
+            }
+            else
+            {
+#ifdef USE_OPENGL
+                if (mOpenGL == RENDER_NORMAL_OPENGL
+                    || mOpenGL == RENDER_GLES_OPENGL)
+                {
+                    if (updateFlag)
+                    {
+                        layer->updateOGL(graphics, startX, startY,
+                            endX, endY, scrollX, scrollY, mDebugFlags);
+                    }
+
+                    layer->drawOGL(graphics);
+                }
+                else
+#endif
+                {
+                    layer->draw(graphics, startX, startY, endX, endY,
+                        scrollX, scrollY, mDebugFlags);
+                }
+            }
+        }
+    }
+
+    // Don't draw if gui opacity == 1
+    if (mBeingOpacity && mOpacity != 1.0F)
+    {
+        // Draws beings with a lower opacity to make them visible
+        // even when covered by a wall or some other elements...
+        ActorsCIter ai = mActors.begin();
+        const ActorsCIter ai_end = mActors.end();
+        while (ai != ai_end)
+        {
+            if (Actor *const actor = *ai)
+            {
+                if (mOpenGL == RENDER_SOFTWARE)
+                {
+                    const int x = actor->getTileX();
+                    const int y = actor->getTileY();
+                    if (x < startX || x > endX || y < startY || y > endY)
+                    {
+                        ++ai;
+                        continue;
+                    }
+                }
+                // For now, just draw actors with only one layer.
+                if (actor->getNumberOfLayers() == 1)
+                {
+                    actor->setAlpha(0.3F);
+                    actor->draw(graphics, -scrollX, -scrollY);
+                    actor->setAlpha(1.0F);
+                }
+            }
+            ++ai;
+        }
+    }
+
+    drawAmbientLayers(graphics, FOREGROUND_LAYERS, mOverlayDetail);
+    BLOCK_END("Map::draw")
+}
+
+#define fillCollision(collision, color) \
+    if (x < endX && mMetaTiles[tilePtr].blockmask & collision)\
+    {\
+        width = mapTileSize;\
+        for (int x2 = tilePtr + 1; x < endX; x2 ++)\
+        {\
+            if (!(mMetaTiles[x2].blockmask & collision))\
+                break;\
+            width += mapTileSize;\
+            x ++;\
+            tilePtr ++;\
+        }\
+        if (width && userPalette)\
+        {\
+            graphics->setColor(userPalette->getColorWithAlpha(\
+                UserPalette::color));\
+            graphics->fillRectangle(Rect(\
+                x0 * mTileWidth - scrollX, \
+                y * mTileHeight - scrollY, \
+                width, mapTileSize));\
+        }\
+    }\
+
+void Map::drawCollision(Graphics *const graphics,
+                        const int scrollX, const int scrollY,
+                        const int debugFlags) const
+{
+    const int endPixelY = graphics->mHeight + scrollY + mTileHeight - 1;
+    int startX = scrollX / mTileWidth;
+    int startY = scrollY / mTileHeight;
+    int endX = (graphics->mWidth + scrollX + mTileWidth - 1) / mTileWidth;
+    int endY = endPixelY / mTileHeight;
+
+    if (startX < 0)
+        startX = 0;
+    if (startY < 0)
+        startY = 0;
+    if (endX > mWidth)
+        endX = mWidth;
+    if (endY > mHeight)
+        endY = mHeight;
+
+    if (debugFlags < MAP_SPECIAL)
+    {
+        graphics->setColor(userPalette->getColorWithAlpha(UserPalette::NET));
+        graphics->drawNet(
+            startX * mTileWidth - scrollX,
+            startY * mTileHeight - scrollY,
+            endX * mTileWidth - scrollX,
+            endY * mTileHeight - scrollY,
+            mapTileSize, mapTileSize);
+    }
+
+    for (int y = startY; y < endY; y++)
+    {
+        const int yWidth = y * mWidth;
+        int tilePtr = startX + yWidth;
+        for (int x = startX; x < endX; x++, tilePtr++)
+        {
+            int width = 0;
+            const int x0 = x;
+
+            fillCollision(BLOCKMASK_WALL, COLLISION_HIGHLIGHT);
+            fillCollision(BLOCKMASK_AIR, AIR_COLLISION_HIGHLIGHT);
+            fillCollision(BLOCKMASK_WATER, WATER_COLLISION_HIGHLIGHT);
+            fillCollision(BLOCKMASK_GROUNDTOP, GROUNDTOP_COLLISION_HIGHLIGHT);
+        }
+    }
+}
+
+void Map::updateAmbientLayers(const float scrollX, const float scrollY)
+{
+    BLOCK_START("Map::updateAmbientLayers")
+    static int lastTick = tick_time;
+
+    if (mLastAScrollX == 0.0F && mLastAScrollY == 0.0F)
+    {
+        // First call - initialisation
+        mLastAScrollX = scrollX;
+        mLastAScrollY = scrollY;
+    }
+
+    // Update Overlays
+    const float dx = scrollX - mLastAScrollX;
+    const float dy = scrollY - mLastAScrollY;
+    const int timePassed = get_elapsed_time(lastTick);
+
+    // need check mask to update or not to update
+
+    FOR_EACH (AmbientLayerVectorIter, i, mBackgrounds)
+    {
+        AmbientLayer *const layer = *i;
+        if (layer && (layer->mMask & mMask))
+            layer->update(timePassed, dx, dy);
+    }
+
+    FOR_EACH (AmbientLayerVectorIter, i, mForegrounds)
+    {
+        AmbientLayer *const layer = *i;
+        if (layer && (layer->mMask & mMask))
+            layer->update(timePassed, dx, dy);
+    }
+
+    mLastAScrollX = scrollX;
+    mLastAScrollY = scrollY;
+    lastTick = tick_time;
+    BLOCK_END("Map::updateAmbientLayers")
+}
+
+void Map::drawAmbientLayers(Graphics *const graphics, const LayerType type,
+                            const int detail)
+{
+    BLOCK_START("Map::drawAmbientLayers")
+    // Detail 0 = no ambient effects except background image
+    if (detail <= 0 && type != BACKGROUND_LAYERS)
+    {
+        BLOCK_END("Map::drawAmbientLayers")
+        return;
+    }
+
+    // find out which layer list to draw
+    AmbientLayerVector *layers = nullptr;
+    switch (type)
+    {
+        case FOREGROUND_LAYERS:
+            layers = &mForegrounds;
+            break;
+        case BACKGROUND_LAYERS:
+            layers = &mBackgrounds;
+            break;
+        default:
+            return;
+    }
+
+    // Draw overlays
+    FOR_EACHP (AmbientLayerVectorCIter, i, layers)
+    {
+        const AmbientLayer *const layer = *i;
+        // need check mask to draw or not to draw
+        if (layer && (layer->mMask & mMask))
+            (layer)->draw(graphics, graphics->mWidth, graphics->mHeight);
+
+        // Detail 1: only one overlay, higher: all overlays
+        if (detail == 1)
+            break;
+    }
+    BLOCK_END("Map::drawAmbientLayers")
+}
+
+const Tileset *Map::getTilesetWithGid(const int gid) const
+{
+    if (gid >= 0 && gid < mIndexedTilesetsSize)
+        return mIndexedTilesets[gid];
+    else
+        return nullptr;
+}
+
+void Map::blockTile(const int x, const int y, const BlockType type)
+{
+    if (type == BLOCKTYPE_NONE || !contains(x, y))
+        return;
+
+    const int tileNum = x + y * mWidth;
+
+    if (mOccupation[static_cast<size_t>(type)][tileNum] < UINT_MAX &&
+        (++mOccupation[static_cast<size_t>(type)][tileNum]) > 0)
+    {
+        switch (type)
+        {
+            case BLOCKTYPE_WALL:
+                mMetaTiles[tileNum].blockmask |= BLOCKMASK_WALL;
+                break;
+            case BLOCKTYPE_CHARACTER:
+                mMetaTiles[tileNum].blockmask |= BLOCKMASK_CHARACTER;
+                break;
+            case BLOCKTYPE_MONSTER:
+                mMetaTiles[tileNum].blockmask |= BLOCKMASK_MONSTER;
+                break;
+            case BLOCKTYPE_AIR:
+                mMetaTiles[tileNum].blockmask |= BLOCKMASK_AIR;
+                break;
+            case BLOCKTYPE_WATER:
+                mMetaTiles[tileNum].blockmask |= BLOCKMASK_WATER;
+                break;
+            case BLOCKTYPE_GROUND:
+                mMetaTiles[tileNum].blockmask |= BLOCKMASK_GROUND;
+                break;
+            case BLOCKTYPE_GROUNDTOP:
+                mMetaTiles[tileNum].blockmask |= BLOCKMASK_GROUNDTOP;
+                break;
+            default:
+            case BLOCKTYPE_NONE:
+            case NB_BLOCKTYPES:
+                // Do nothing.
+                break;
+        }
+    }
+}
+
+bool Map::getWalk(const int x, const int y, const unsigned char walkmask) const
+{
+    // You can't walk outside of the map
+    if (x < 0 || y < 0 || x >= mWidth || y >= mHeight)
+        return false;
+
+    // Check if the tile is walkable
+    return !(mMetaTiles[x + y * mWidth].blockmask & walkmask);
+}
+
+unsigned char Map::getBlockMask(const int x, const int y) const
+{
+    // You can't walk outside of the map
+    if (x < 0 || y < 0 || x >= mWidth || y >= mHeight)
+        return 0;
+
+    // Check if the tile is walkable
+    return mMetaTiles[x + y * mWidth].blockmask;
+}
+
+void Map::setWalk(const int x, const int y, const bool walkable A_UNUSED)
+{
+    blockTile(x, y, Map::BLOCKTYPE_GROUNDTOP);
+}
+
+bool Map::contains(const int x, const int y) const
+{
+    return x >= 0 && y >= 0 && x < mWidth && y < mHeight;
+}
+
+const MetaTile *Map::getMetaTile(const int x, const int y) const
+{
+    return &mMetaTiles[x + y * mWidth];
+}
+
+Actors::iterator Map::addActor(Actor *const actor)
+{
+    mActors.push_front(actor);
+//    mSpritesUpdated = true;
+    return mActors.begin();
+}
+
+void Map::removeActor(const Actors::iterator &iterator)
+{
+    mActors.erase(iterator);
+//    mSpritesUpdated = true;
+}
+
+const std::string Map::getMusicFile() const
+{
+    return getProperty("music");
+}
+
+const std::string Map::getName() const
+{
+    if (hasProperty("name"))
+        return getProperty("name");
+
+    return getProperty("mapname");
+}
+
+const std::string Map::getFilename() const
+{
+    const std::string fileName = getProperty("_filename");
+    const size_t lastSlash = fileName.rfind("/") + 1;
+    return fileName.substr(lastSlash, fileName.rfind(".") - lastSlash);
+}
+
+Path Map::findPath(const int startX, const int startY,
+                   const int destX, const int destY,
+                   const unsigned char walkmask, const int maxCost)
+{
+    // The basic walking cost of a tile.
+    static const int basicCost = 100;
+    const int basicCost2 = 100 * 362 / 256;
+    const float basicCostF = 100.0 * 362 / 256;
+
+    // Path to be built up (empty by default)
+    Path path;
+
+    if (startX >= mWidth || startY >= mHeight || startX < 0 || startY < 0)
+        return path;
+
+    // Return when destination not walkable
+    if (!getWalk(destX, destY, walkmask))
+        return path;
+
+    // Reset starting tile's G cost to 0
+    MetaTile *const startTile = &mMetaTiles[startX + startY * mWidth];
+    if (!startTile)
+        return path;
+
+    startTile->Gcost = 0;
+
+    // Declare open list, a list with open tiles sorted on F cost
+    std::priority_queue<Location> openList;
+
+    // Add the start point to the open list
+    openList.push(Location(startX, startY, startTile));
+
+    bool foundPath = false;
+
+    // Keep trying new open tiles until no more tiles to try or target found
+    while (!openList.empty() && !foundPath)
+    {
+        // Take the location with the lowest F cost from the open list.
+        const Location curr = openList.top();
+        openList.pop();
+
+        const MetaTile *const tile = curr.tile;
+
+        // If the tile is already on the closed list, this means it has already
+        // been processed with a shorter path to the start point (lower G cost)
+        if (tile->whichList == mOnClosedList)
+            continue;
+
+        // Put the current tile on the closed list
+        curr.tile->whichList = mOnClosedList;
+
+        const int curWidth = curr.y * mWidth;
+        const int tileGcost = tile->Gcost;
+
+        // Check the adjacent tiles
+        for (int dy = -1; dy <= 1; dy++)
+        {
+            const int y = curr.y + dy;
+            if (y < 0 || y >= mHeight)
+                continue;
+
+            const int yWidth = y * mWidth;
+            const int dy1 = std::abs(y - destY);
+
+            for (int dx = -1; dx <= 1; dx++)
+            {
+                // Calculate location of tile to check
+                const int x = curr.x + dx;
+
+                // Skip if if we're checking the same tile we're leaving from,
+                // or if the new location falls outside of the map boundaries
+                if ((dx == 0 && dy == 0) || x < 0 || x >= mWidth)
+                    continue;
+
+                MetaTile *const newTile = &mMetaTiles[x + yWidth];
+
+                // Skip if the tile is on the closed list or is not walkable
+                // unless its the destination tile
+                // +++ here need check block must depend on player abilities.
+                if (newTile->whichList == mOnClosedList ||
+                    ((newTile->blockmask & walkmask)
+                    && !(x == destX && y == destY))
+                    || (newTile->blockmask & BLOCKMASK_WALL))
+                {
+                    continue;
+                }
+
+                // When taking a diagonal step, verify that we can skip the
+                // corner.
+                if (dx != 0 && dy != 0)
+                {
+                    const MetaTile *const t1 = &mMetaTiles[curr.x +
+                        (curr.y + dy) * mWidth];
+                    const MetaTile *const t2 = &mMetaTiles[curr.x +
+                        dx + curWidth];
+
+                    // +++ here need check block must depend
+                    // on player abilities.
+                    if (((t1->blockmask | t2->blockmask) & BLOCKMASK_WALL))
+                        continue;
+                }
+
+                // Calculate G cost for this route, ~sqrt(2) for moving diagonal
+                int Gcost = tileGcost + (dx == 0 || dy == 0
+                    ? basicCost : basicCost2);
+
+                /* Demote an arbitrary direction to speed pathfinding by
+                   adding a defect (TODO: change depending on the desired
+                   visual effect, e.g. a cross-product defect toward
+                   destination).
+                   Important: as long as the total defect along any path is
+                   less than the basicCost, the pathfinder will still find one
+                   of the shortest paths! */
+                if (dx == 0 || dy == 0)
+                {
+                    // Demote horizontal and vertical directions, so that two
+                    // consecutive directions cannot have the same Fcost.
+                    ++Gcost;
+                }
+
+                // It costs extra to walk through a being (needs to be enough
+                // to make it more attractive to walk around).
+//                if (occupied(x, y))
+//                {
+//                    Gcost += 3 * basicCost;
+//                }
+
+                // Skip if Gcost becomes too much
+                // Warning: probably not entirely accurate
+                if (maxCost > 0 && Gcost > maxCost * basicCost)
+                    continue;
+
+                if (newTile->whichList != mOnOpenList)
+                {
+                    // Found a new tile (not on open nor on closed list)
+
+                    /* Update Hcost of the new tile. The pathfinder does not
+                       work reliably if the heuristic cost is higher than the
+                       real cost. In particular, using Manhattan distance is
+                       forbidden here. */
+                    const int dx1 = std::abs(x - destX);
+                    newTile->Hcost = std::abs(dx1 - dy1) * basicCost +
+                        std::min(dx1, dy1) * (basicCostF);
+
+                    // Set the current tile as the parent of the new tile
+                    newTile->parentX = curr.x;
+                    newTile->parentY = curr.y;
+
+                    // Update Gcost and Fcost of new tile
+                    newTile->Gcost = Gcost;
+                    newTile->Fcost = Gcost + newTile->Hcost;
+
+                    if (x != destX || y != destY)
+                    {
+                        // Add this tile to the open list
+                        newTile->whichList = mOnOpenList;
+                        openList.push(Location(x, y, newTile));
+                    }
+                    else
+                    {
+                        // Target location was found
+                        foundPath = true;
+                    }
+                }
+                else if (Gcost < newTile->Gcost)
+                {
+                    // Found a shorter route.
+                    // Update Gcost and Fcost of the new tile
+                    newTile->Gcost = Gcost;
+                    newTile->Fcost = Gcost + newTile->Hcost;
+
+                    // Set the current tile as the parent of the new tile
+                    newTile->parentX = curr.x;
+                    newTile->parentY = curr.y;
+
+                    // Add this tile to the open list (it's already
+                    // there, but this instance has a lower F score)
+                    openList.push(Location(x, y, newTile));
+                }
+            }
+        }
+    }
+
+    // Two new values to indicate whether a tile is on the open or closed list,
+    // this way we don't have to clear all the values between each pathfinding.
+    if (mOnOpenList > UINT_MAX - 2)
+    {
+        // We reset the list memebers value.
+        mOnClosedList = 1;
+        mOnOpenList = 2;
+
+        // Clean up the metaTiles
+        const int size = mWidth * mHeight;
+        for (int i = 0; i < size; ++i)
+            mMetaTiles[i].whichList = 0;
+    }
+    else
+    {
+        mOnClosedList += 2;
+        mOnOpenList += 2;
+    }
+
+    // If a path has been found, iterate backwards using the parent locations
+    // to extract it.
+    if (foundPath)
+    {
+        int pathX = destX;
+        int pathY = destY;
+
+        while (pathX != startX || pathY != startY)
+        {
+            // Add the new path node to the start of the path list
+            path.push_front(Position(pathX, pathY));
+
+            // Find out the next parent
+            const MetaTile *const tile = &mMetaTiles[pathX + pathY * mWidth];
+            pathX = tile->parentX;
+            pathY = tile->parentY;
+        }
+    }
+
+    return path;
+}
+
+void Map::addParticleEffect(const std::string &effectFile,
+                            const int x, const int y, const int w, const int h)
+{
+    ParticleEffectData newEffect;
+    newEffect.file = effectFile;
+    newEffect.x = x;
+    newEffect.y = y;
+    newEffect.w = w;
+    newEffect.h = h;
+    mParticleEffects.push_back(newEffect);
+}
+
+void Map::initializeParticleEffects(Particle *const engine)
+{
+    if (!engine)
+        return;
+
+    if (config.getBoolValue("particleeffects"))
+    {
+        for (std::vector<ParticleEffectData>::const_iterator
+             i = mParticleEffects.begin();
+             i != mParticleEffects.end(); ++i)
+        {
+            Particle *const p = engine->addEffect(i->file, i->x, i->y);
+            if (p && i->w > 0 && i->h > 0)
+                p->adjustEmitterSize(i->w, i->h);
+        }
+    }
+}
+
+void Map::addExtraLayer()
+{
+    if (!mSpecialLayer)
+    {
+        logger->log1("No special layer");
+        return;
+    }
+    const std::string mapFileName = getUserMapDirectory().append(
+        "/extralayer.txt");
+    logger->log("loading extra layer: " + mapFileName);
+    struct stat statbuf;
+    if (!stat(mapFileName.c_str(), &statbuf) && S_ISREG(statbuf.st_mode))
+    {
+        std::ifstream mapFile;
+        mapFile.open(mapFileName.c_str(), std::ios::in);
+        if (!mapFile.is_open())
+        {
+            mapFile.close();
+            return;
+        }
+        char line[201];
+
+        while (mapFile.getline(line, 200))
+        {
+            std::string buf;
+            std::string str = line;
+            if (!str.empty())
+            {
+                std::string x;
+                std::string y;
+                std::string type1;
+                std::string comment;
+                std::stringstream ss(str);
+                ss >> x;
+                ss >> y;
+                ss >> type1;
+                ss >> comment;
+                while (ss >> buf)
+                    comment.append(" ").append(buf);
+
+                const int type = atoi(type1.c_str());
+
+                if (comment.empty())
+                {
+                    if (type < MapItem::ARROW_UP
+                        || type > MapItem::ARROW_RIGHT)
+                    {
+                        comment = "unknown";
+                    }
+                }
+                if (type == MapItem::PORTAL)
+                {
+                    updatePortalTile(comment, type, atoi(x.c_str()),
+                                     atoi(y.c_str()), false);
+                }
+                else if (type == MapItem::HOME)
+                {
+                    updatePortalTile(comment, type, atoi(x.c_str()),
+                                     atoi(y.c_str()));
+                }
+                else
+                {
+                    addPortalTile(comment, type, atoi(x.c_str()),
+                                  atoi(y.c_str()));
+                }
+            }
+        }
+        mapFile.close();
+    }
+}
+
+void Map::saveExtraLayer() const
+{
+    if (!mSpecialLayer)
+    {
+        logger->log1("No special layer");
+        return;
+    }
+    const std::string mapFileName = getUserMapDirectory().append(
+        "/extralayer.txt");
+    logger->log("saving extra layer: " + mapFileName);
+
+    if (mkdir_r(getUserMapDirectory().c_str()))
+    {
+        logger->log(strprintf("%s doesn't exist and can't be created! "
+                              "Exiting.", getUserMapDirectory().c_str()));
+        return;
+    }
+
+    std::ofstream mapFile;
+    mapFile.open(mapFileName.c_str(), std::ios::binary);
+    if (!mapFile.is_open())
+    {
+        logger->log1("Unable to open extralayer.txt for writing");
+        return;
+    }
+
+    const int width = mSpecialLayer->mWidth;
+    const int height = mSpecialLayer->mHeight;
+
+    for (int x = 0; x < width; x ++)
+    {
+        for (int y = 0; y < height; y ++)
+        {
+            const MapItem *const item = mSpecialLayer->getTile(x, y);
+            if (item && item->mType != MapItem::EMPTY
+                && item->mType != MapItem::HOME)
+            {
+                mapFile << x << " " << y << " "
+                    << static_cast<int>(item->mType) << " "
+                    << item->mComment << std::endl;
+            }
+        }
+    }
+    mapFile.close();
+}
+
+std::string Map::getUserMapDirectory() const
+{
+    return client->getServerConfigDirectory() +
+        dirSeparator + getProperty("_realfilename");
+}
+
+void Map::addRange(const std::string &name, const int type,
+                   const int x, const int y, const int dx, const int dy)
+{
+    if (!mObjects)
+        return;
+
+    mObjects->addObject(name, type, x / mapTileSize, y / mapTileSize,
+        dx / mapTileSize, dy / mapTileSize);
+}
+
+void Map::addPortal(const std::string &name, const int type,
+                    const int x, const int y, const int dx, const int dy)
+{
+    addPortalTile(name, type, (x / mapTileSize) + (dx / mapTileSize / 2),
+        (y / mapTileSize) + (dy / mapTileSize / 2));
+}
+
+void Map::addPortalTile(const std::string &name, const int type,
+                        const int x, const int y)
+{
+    if (mSpecialLayer)
+        mSpecialLayer->setTile(x, y, new MapItem(type, name, x, y));
+
+    mMapPortals.push_back(new MapItem(type, name, x, y));
+}
+
+void Map::updatePortalTile(const std::string &name, const int type,
+                           const int x, const int y, const bool addNew)
+{
+    MapItem *item = findPortalXY(x, y);
+    if (item)
+    {
+        item->mComment = name;
+        item->setType(type);
+        item->mX = x;
+        item->mY = y;
+        if (mSpecialLayer)
+        {
+            item = new MapItem(type, name, x, y);
+            mSpecialLayer->setTile(x, y, item);
+        }
+    }
+    else if (addNew)
+    {
+        addPortalTile(name, type, x, y);
+    }
+}
+
+MapItem *Map::findPortalXY(const int x, const int y) const
+{
+    FOR_EACH (std::vector<MapItem*>::const_iterator, it, mMapPortals)
+    {
+        if (!*it)
+            continue;
+
+        MapItem *const item = *it;
+        if (item->mX == x && item->mY == y)
+            return item;
+    }
+    return nullptr;
+}
+
+const TileAnimation *Map::getAnimationForGid(const int gid) const
+{
+    if (mTileAnimations.empty())
+        return nullptr;
+
+    TileAnimationMapCIter i = mTileAnimations.find(gid);
+    return (i == mTileAnimations.end()) ? nullptr : i->second;
+}
+
+void Map::setPvpMode(const int mode)
+{
+    const int oldMode = mPvp;
+
+    if (!mode)
+        mPvp = 0;
+    else
+        mPvp |= mode;
+
+    if (mPvp != oldMode && player_node)
+    {
+        switch (mPvp)
+        {
+            case 0:
+                NotifyManager::notify(NotifyManager::PVP_OFF_GVG_OFF);
+                break;
+            case 1:
+                NotifyManager::notify(NotifyManager::PVP_ON);
+                break;
+            case 2:
+                NotifyManager::notify(NotifyManager::GVG_ON);
+                break;
+            case 3:
+                NotifyManager::notify(NotifyManager::PVP_ON_GVG_ON);
+                break;
+            default:
+                NotifyManager::notify(NotifyManager::PVP_UNKNOWN);
+                break;
+        }
+    }
+}
+
+std::string Map::getObjectData(const unsigned x, const unsigned y,
+                               const int type) const
+{
+    if (!mObjects)
+        return "";
+
+    MapObjectList *const list = mObjects->getAt(x, y);
+    if (!list)
+        return "";
+
+    std::vector<MapObject>::const_iterator it = list->objects.begin();
+    const std::vector<MapObject>::const_iterator it_end = list->objects.end();
+    while (it != it_end)
+    {
+        if ((*it).type == type)
+            return (*it).data;
+        ++ it;
+    }
+
+    return "";
+}
+
+void Map::indexTilesets()
+{
+    if (mTilesetsIndexed)
+        return;
+
+    mTilesetsIndexed = true;
+
+    const Tileset *s = nullptr;
+    size_t sSz = 0;
+    FOR_EACH (Tilesets::const_iterator, it, mTilesets)
+    {
+        const size_t sz = (*it)->size();
+        if (!s || static_cast<size_t>(s->getFirstGid()) + sSz
+            < static_cast<size_t>((*it)->getFirstGid()) + sz)
+        {
+            s = *it;
+            sSz = sz;
+        }
+    }
+    if (!s)
+    {
+        mIndexedTilesetsSize = 0;
+        mIndexedTilesets = nullptr;
+        return;
+    }
+
+    const int size = static_cast<int>(s->getFirstGid())
+        + static_cast<int>(s->size());
+    mIndexedTilesetsSize = size;
+    mIndexedTilesets = new Tileset*[static_cast<size_t>(size)];
+    std::fill_n(mIndexedTilesets, size, static_cast<Tileset*>(nullptr));
+
+    FOR_EACH (Tilesets::const_iterator, it, mTilesets)
+    {
+        Tileset *const s2 = *it;
+        if (s2)
+        {
+            const int start = s2->getFirstGid();
+            const int end = start + static_cast<int>(s2->size());
+            for (int f = start; f < end; f ++)
+            {
+                if (f < size)
+                    mIndexedTilesets[f] = s2;
+            }
+        }
+    }
+}
+
+void Map::clearIndexedTilesets()
+{
+    if (!mTilesetsIndexed)
+        return;
+
+    mTilesetsIndexed = false;
+    delete [] mIndexedTilesets;
+    mIndexedTilesetsSize = 0;
+}
+
+void Map::reduce()
+{
+#ifdef USE_SDL2
+    return;
+#else
+    if (!mFringeLayer || mOpenGL != RENDER_SOFTWARE ||
+        !config.getBoolValue("enableMapReduce"))
+    {
+        return;
+    }
+
+    int cnt = 0;
+    for (int x = 0; x < mWidth; x ++)
+    {
+        for (int y = 0; y < mHeight; y ++)
+        {
+            bool correct(true);
+            bool dontHaveAlpha(false);
+
+            FOR_EACH (LayersCIter, layeri, mLayers)
+            {
+                const MapLayer *const layer = *layeri;
+                if (x >= layer->mWidth || y >= layer->mHeight)
+                    continue;
+
+                Image *const img = layer->mTiles[x + y * layer->mWidth];
+                if (img)
+                {
+                    if (img->hasAlphaChannel() && img->isAlphaCalculated())
+                    {
+                        if (!img->isAlphaVisible())
+                        {
+                            dontHaveAlpha = true;
+                            img->setAlphaVisible(false);
+                        }
+                    }
+                    else if (img->mBounds.w > mapTileSize
+                             || img->mBounds.h > mapTileSize)
+                    {
+                        correct = false;
+                        img->setAlphaVisible(true);
+                        break;
+                    }
+                    else if (!img->isHasAlphaChannel())
+                    {
+                        dontHaveAlpha = true;
+                        img->setAlphaVisible(false);
+                    }
+                    else if (img->hasAlphaChannel())
+                    {
+                        const uint8_t *const arr = img->SDLgetAlphaChannel();
+                        if (!arr)
+                            continue;
+
+                        bool bad(false);
+                        bool stop(false);
+                        int width;
+                        const SubImage *const subImg
+                            = dynamic_cast<SubImage*>(img);
+                        if (subImg)
+                            width = subImg->mInternalBounds.w;
+                        else
+                            width = img->mBounds.w;
+
+                        for (int f = img->mBounds.x;
+                             f < img->mBounds.x + img->mBounds.w; f ++)
+                        {
+                            for (int d = img->mBounds.y;
+                                 d < img->mBounds.y + img->mBounds.h; d ++)
+                            {
+                                const uint8_t chan = arr[f + d * width];
+                                if (chan != 255)
+                                {
+                                    bad = true;
+                                    stop = true;
+                                    break;
+                                }
+                            }
+                            if (stop)
+                                break;
+                        }
+                        if (!bad)
+                        {
+                            dontHaveAlpha = true;
+                            img->setAlphaVisible(false);
+                        }
+                        else
+                        {
+                            img->setAlphaVisible(true);
+                        }
+                    }
+                    img->setAlphaCalculated(true);
+                }
+            }
+            if (!correct || !dontHaveAlpha)
+                continue;
+
+            Layers::reverse_iterator ri = mLayers.rbegin();
+            while (ri != mLayers.rend())
+            {
+                const MapLayer *const layer = *ri;
+                if (x >= layer->mWidth || y >= layer->mHeight)
+                {
+                    ++ ri;
+                    continue;
+                }
+
+                const Image *img = layer->mTiles[x + y * layer->mWidth];
+                if (img && !img->isAlphaVisible())
+                {   // removing all down tiles
+                    ++ ri;
+                    while (ri != mLayers.rend())
+                    {
+                        MapLayer *const layer2 = *ri;
+                        const size_t pos = static_cast<size_t>(
+                            x + y * layer2->mWidth);
+                        img = layer2->mTiles[pos];
+                        if (img)
+                        {
+                            layer2->mTiles[pos] = nullptr;
+                            cnt ++;
+                        }
+                        ++ ri;
+                    }
+                    break;
+                }
+                ++ ri;
+            }
+        }
+    }
+    logger->log("tiles reduced: %d", cnt);
+#endif
+}
+
+void Map::redrawMap()
+{
+    mRedrawMap = true;
+}
+
+void Map::addHeights(MapHeights *const heights)
+{
+    delete mHeights;
+    mHeights = heights;
+}
+
+uint8_t Map::getHeightOffset(const int x, const int y) const
+{
+    if (!mHeights)
+        return 0;
+    return mHeights->getHeight(x, y);
+}
+
+void Map::setMask(const int mask)
+{
+    if (mask != mMask)
+        mRedrawMap = true;
+    mMask = mask;
+}
+
+void Map::setMusicFile(const std::string &file)
+{
+    setProperty("music", file);
+}
diff --git a/src/resources/map/map.h b/src/resources/map/map.h
new file mode 100644
index 000000000..f0712be76
--- /dev/null
+++ b/src/resources/map/map.h
@@ -0,0 +1,540 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RESOURCES_MAP_MAP_H
+#define RESOURCES_MAP_MAP_H
+
+#include "position.h"
+
+#include "being/actor.h"
+
+#include "resources/map/properties.h"
+
+#include "listeners/configlistener.h"
+
+#include "render/renderers.h"
+
+#include <string>
+#include <vector>
+
+class Animation;
+class AmbientLayer;
+class Image;
+class MapHeights;
+class MapItem;
+class MapLayer;
+class ObjectsLayer;
+class Particle;
+class Resource;
+class SimpleAnimation;
+class SpecialLayer;
+class Tileset;
+class WalkLayer;
+
+typedef std::vector<Tileset*> Tilesets;
+typedef std::vector<MapLayer*> Layers;
+typedef Layers::const_iterator LayersCIter;
+
+typedef std::vector<std::pair<MapLayer*, int> > TilePairVector;
+typedef TilePairVector::const_iterator TilePairVectorCIter;
+
+typedef std::vector<AmbientLayer*> AmbientLayerVector;
+typedef AmbientLayerVector::const_iterator AmbientLayerVectorCIter;
+typedef AmbientLayerVector::iterator AmbientLayerVectorIter;
+
+static const int mapTileSize = 32;
+
+/**
+ * A meta tile stores additional information about a location on a tile map.
+ * This is information that doesn't need to be repeated for each tile in each
+ * layer of the map.
+ */
+struct MetaTile final
+{
+    /**
+     * Constructor.
+     */
+    MetaTile() : Fcost(0), Gcost(0), Hcost(0), whichList(0),
+        parentX(0), parentY(0), blockmask(0)
+    {}
+
+    A_DELETE_COPY(MetaTile)
+
+    // Pathfinding members
+    int Fcost;               /**< Estimation of total path cost */
+    int Gcost;               /**< Cost from start to this location */
+    int Hcost;               /**< Estimated cost to goal */
+    unsigned whichList;      /**< No list, open list or closed list */
+    int parentX;             /**< X coordinate of parent tile */
+    int parentY;             /**< Y coordinate of parent tile */
+    unsigned char blockmask; /**< Blocking properties of this tile */
+};
+
+/**
+ * Animation cycle of a tile image which changes the map accordingly.
+ */
+class TileAnimation final
+{
+    public:
+        explicit TileAnimation(Animation *const ani);
+
+        ~TileAnimation();
+
+        A_DELETE_COPY(TileAnimation)
+
+        bool update(const int ticks = 1);
+
+        void addAffectedTile(MapLayer *const layer, const int index)
+        { mAffected.push_back(std::make_pair(layer, index)); }
+
+    private:
+        TilePairVector mAffected;
+        SimpleAnimation *mAnimation;
+        Image *mLastImage;
+};
+
+typedef std::map<int, TileAnimation*> TileAnimationMap;
+typedef TileAnimationMap::const_iterator TileAnimationMapCIter;
+
+/**
+ * A tile map.
+ */
+class Map final : public Properties, public ConfigListener
+{
+    public:
+        enum BlockType
+        {
+            BLOCKTYPE_NONE = -1,
+            BLOCKTYPE_WALL,
+            BLOCKTYPE_CHARACTER,
+            BLOCKTYPE_MONSTER,
+            BLOCKTYPE_AIR,
+            BLOCKTYPE_WATER,
+            BLOCKTYPE_GROUND,
+            BLOCKTYPE_GROUNDTOP,
+            NB_BLOCKTYPES
+        };
+
+        enum CollisionTypes
+        {
+            COLLISION_EMPTY = 0,        // no collision
+            COLLISION_WALL = 1,         // full collison
+            COLLISION_AIR = 2,          // air units can walk
+            COLLISION_WATER = 3,        // water units can walk
+            COLLISION_GROUNDTOP = 4,    // no collision (chair, bed, etc)
+            COLLISION_MAX = 5           // count index
+        };
+
+        enum BlockMask
+        {
+            BLOCKMASK_WALL      = 0x80,  // 1000 0000
+            BLOCKMASK_CHARACTER = 0x01,  // 0000 0001
+            BLOCKMASK_MONSTER   = 0x02,  // 0000 0010
+            BLOCKMASK_AIR       = 0x04,  // 0000 0100
+            BLOCKMASK_WATER     = 0x08,  // 0000 1000
+            BLOCKMASK_GROUND    = 0x10,  // 0001 0000
+            BLOCKMASK_GROUNDTOP = 0x20   // 0010 0000
+        };
+
+        enum DebugType
+        {
+            MAP_NORMAL  = 0,
+            MAP_DEBUG   = 1,
+            MAP_SPECIAL = 2,
+            MAP_SPECIAL2 = 3,
+            MAP_SPECIAL3 = 4,
+            MAP_BLACKWHITE = 5
+        };
+
+        /**
+         * Constructor, taking map and tile size as parameters.
+         */
+        Map(const int width, const int height,
+            const int tileWidth, const int tileHeight);
+
+        A_DELETE_COPY(Map)
+
+        /**
+         * Destructor.
+         */
+        ~Map();
+
+        /**
+         * Initialize ambient layers. Has to be called after all the properties
+         * are set.
+         */
+        void initializeAmbientLayers();
+
+        /**
+         * Updates animations. Called as needed.
+         */
+        void update(const int ticks = 1);
+
+        /**
+         * Draws the map to the given graphics output. This method draws all
+         * layers, actors and overlay effects.
+         *
+         * TODO: For efficiency reasons, this method could take into account
+         * the clipping rectangle set on the Graphics object. However,
+         * currently the map is always drawn full-screen.
+         */
+        void draw(Graphics *const graphics, int scrollX, int scrollY);
+
+        /**
+         * Visualizes collision layer for debugging
+         */
+        void drawCollision(Graphics *const graphics,
+                           const int scrollX, const int scrollY,
+                           const int debugFlags) const;
+
+        /**
+         * Adds a layer to this map. The map takes ownership of the layer.
+         */
+        void addLayer(MapLayer *const layer);
+
+        /**
+         * Adds a tileset to this map. The map takes ownership of the tileset.
+         */
+        void addTileset(Tileset *const tileset);
+
+        /**
+         * Finds the tile set that a tile with the given global id is part of.
+         */
+        const Tileset *getTilesetWithGid(const int gid) const A_WARN_UNUSED;
+
+        /**
+         * Get tile reference.
+         */
+        const MetaTile *getMetaTile(const int x,
+                                    const int y) const A_WARN_UNUSED;
+
+        /**
+         * Marks a tile as occupied.
+         */
+        void blockTile(const int x, const int y, const BlockType type);
+
+        /**
+         * Gets walkability for a tile with a blocking bitmask. When called
+         * without walkmask, only blocks against colliding tiles.
+         */
+        bool getWalk(const int x, const int y,
+                     const unsigned char walkmask = BLOCKMASK_WALL
+                     | BLOCKMASK_AIR | BLOCKMASK_WATER) const A_WARN_UNUSED;
+
+        void setWalk(const int x, const int y, const bool walkable);
+
+        unsigned char getBlockMask(const int x, const int y) const;
+
+        /**
+         * Returns the width of this map in tiles.
+         */
+        int getWidth() const A_WARN_UNUSED
+        { return mWidth; }
+
+        /**
+         * Returns the height of this map in tiles.
+         */
+        int getHeight() const A_WARN_UNUSED
+        { return mHeight; }
+
+        /**
+         * Returns the tile width of this map.
+         */
+        int getTileWidth() const A_WARN_UNUSED
+        { return mTileWidth; }
+
+        /**
+         * Returns the tile height used by this map.
+         */
+        int getTileHeight() const A_WARN_UNUSED
+        { return mTileHeight; }
+
+        const std::string getMusicFile() const A_WARN_UNUSED;
+
+        void setMusicFile(const std::string &file);
+
+        const std::string getName() const A_WARN_UNUSED;
+
+        /**
+         * Gives the map id based on filepath (ex: 009-1)
+         */
+        const std::string getFilename() const A_WARN_UNUSED;
+
+        /**
+         * Find a path from one location to the next.
+         */
+        Path findPath(const int startX, const int startY,
+                      const int destX, const int destY,
+                      const unsigned char walkmask,
+                      const int maxCost = 20) A_WARN_UNUSED;
+
+        /**
+         * Adds a particle effect
+         */
+        void addParticleEffect(const std::string &effectFile,
+                               const int x, const int y,
+                               const int w = 0, const int h = 0);
+
+        /**
+         * Initializes all added particle effects
+         */
+        void initializeParticleEffects(Particle *const particleEngine);
+
+        /**
+         * Adds a tile animation to the map
+         */
+        void addAnimation(const int gid, TileAnimation *const animation)
+        { mTileAnimations[gid] = animation; }
+
+        void setDebugFlags(const int n)
+        { mDebugFlags = n; }
+
+        int getDebugFlags() const A_WARN_UNUSED
+        { return mDebugFlags; }
+
+        void addExtraLayer();
+
+        void saveExtraLayer() const;
+
+        SpecialLayer *getTempLayer() const A_WARN_UNUSED
+        { return mTempLayer; }
+
+        SpecialLayer *getSpecialLayer() const A_WARN_UNUSED
+        { return mSpecialLayer; }
+
+        void setHasWarps(const bool n)
+        { mHasWarps = n; }
+
+        bool getHasWarps() const A_WARN_UNUSED
+        { return mHasWarps; }
+
+        std::string getUserMapDirectory() const A_WARN_UNUSED;
+
+        void addPortal(const std::string &name, const int type,
+                       const int x, const int y, const int dx, const int dy);
+
+        void addRange(const std::string &name, const int type,
+                      const int x, const int y, const int dx, const int dy);
+
+        void addPortalTile(const std::string &name, const int type,
+                           const int x, const int y);
+
+        void updatePortalTile(const std::string &name, const int type,
+                              const int x, const int y,
+                              const bool addNew = true);
+
+        const std::vector<MapItem*> &getPortals() const A_WARN_UNUSED
+        { return mMapPortals; }
+
+        /**
+         * Gets the tile animation for a specific gid
+         */
+        const TileAnimation *getAnimationForGid(const int gid)
+                                                const A_WARN_UNUSED;
+
+        void optionChanged(const std::string &value) override final;
+
+        MapItem *findPortalXY(const int x, const int y) const A_WARN_UNUSED;
+
+        int getActorsCount() const A_WARN_UNUSED
+        { return static_cast<int>(mActors.size()); }
+
+        void setPvpMode(const int mode);
+
+        const ObjectsLayer* getObjectsLayer() const A_WARN_UNUSED
+        { return mObjects; }
+
+        std::string getObjectData(const unsigned x, const unsigned y,
+                                  const int type) const A_WARN_UNUSED;
+
+        void indexTilesets();
+
+        void clearIndexedTilesets();
+
+        void setActorsFix(const int x, const int y)
+        { mActorFixX = x; mActorFixY = y; }
+
+        int getVersion() const A_WARN_UNUSED
+        { return mVersion; }
+
+        void setVersion(const int n)
+        { mVersion = n; }
+
+        void reduce();
+
+        void redrawMap();
+
+        bool empty() const A_WARN_UNUSED
+        { return mLayers.empty(); }
+
+        void setCustom(const bool b)
+        { mCustom = b; }
+
+        bool isCustom() const A_WARN_UNUSED
+        { return mCustom; }
+
+        const std::map<int, TileAnimation*> &getTileAnimations()
+                                            const A_WARN_UNUSED
+        { return mTileAnimations; }
+
+        void setAtlas(Resource *const atlas)
+        { mAtlas = atlas; }
+
+        const MetaTile *getMetaTiles() const
+        { return mMetaTiles; }
+
+        WalkLayer *getWalkLayer()
+        { return mWalkLayer; }
+
+        void setWalkLayer(WalkLayer *const layer)
+        { mWalkLayer = layer; }
+
+        void addHeights(MapHeights *const heights);
+
+        uint8_t getHeightOffset(const int x, const int y) const;
+
+        void setMask(const int mask);
+
+    protected:
+        friend class Actor;
+        friend class Minimap;
+
+        /**
+         * Adds an actor to the map.
+         */
+        Actors::iterator addActor(Actor *const actor);
+
+        /**
+         * Removes an actor from the map.
+         */
+        void removeActor(const Actors::iterator &iterator);
+
+    private:
+        enum LayerType
+        {
+            FOREGROUND_LAYERS = 0,
+            BACKGROUND_LAYERS
+        };
+
+        /**
+         * Updates scrolling of ambient layers. Has to be called each game tick.
+         */
+        void updateAmbientLayers(const float scrollX, const float scrollY);
+
+        /**
+         * Draws the foreground or background layers to the given graphics output.
+         */
+        void drawAmbientLayers(Graphics *const graphics, const LayerType type,
+                               const int detail);
+
+        /**
+         * Tells whether the given coordinates fall within the map boundaries.
+         */
+        bool contains(const int x, const int y) const A_WARN_UNUSED;
+
+        /**
+         * Blockmasks for different entities
+         */
+        unsigned *mOccupation[NB_BLOCKTYPES];
+
+        int mWidth;
+        int mHeight;
+        int mTileWidth, mTileHeight;
+        int mMaxTileHeight;
+        MetaTile *mMetaTiles;
+        WalkLayer *mWalkLayer;
+        Layers mLayers;
+        Tilesets mTilesets;
+        Actors mActors;
+        bool mHasWarps;
+
+        // debug flags
+        int mDebugFlags;
+
+        // Pathfinding members
+        unsigned int mOnClosedList;
+        unsigned int mOnOpenList;
+
+        // Overlay data
+        AmbientLayerVector mBackgrounds;
+        AmbientLayerVector mForegrounds;
+        float mLastAScrollX;
+        float mLastAScrollY;
+
+        // Particle effect data
+        struct ParticleEffectData
+        {
+            ParticleEffectData() :
+                file(),
+                x(0),
+                y(0),
+                w(0),
+                h(0)
+            {
+            }
+
+            std::string file;
+            int x;
+            int y;
+            int w;
+            int h;
+        };
+        std::vector<ParticleEffectData> mParticleEffects;
+
+        std::vector<MapItem*> mMapPortals;
+
+        std::map<int, TileAnimation*> mTileAnimations;
+
+        int mOverlayDetail;
+        float mOpacity;
+        RenderType mOpenGL;
+        int mPvp;
+        bool mTilesetsIndexed;
+        Tileset** mIndexedTilesets;
+        int mIndexedTilesetsSize;
+        int mActorFixX;
+        int mActorFixY;
+        int mVersion;
+
+        SpecialLayer *mSpecialLayer;
+        SpecialLayer *mTempLayer;
+        ObjectsLayer *mObjects;
+        MapLayer *mFringeLayer;
+
+        int mLastX;
+        int mLastY;
+        int mLastScrollX;
+        int mLastScrollY;
+
+        int mDrawX;
+        int mDrawY;
+        int mDrawScrollX;
+        int mDrawScrollY;
+        int mMask;
+        Resource *mAtlas;
+        MapHeights *mHeights;
+        bool mRedrawMap;
+        bool mBeingOpacity;
+        bool mCustom;
+};
+
+#endif  // RESOURCES_MAP_MAP_H
diff --git a/src/resources/map/mapheights.cpp b/src/resources/map/mapheights.cpp
new file mode 100644
index 000000000..1f93a0a84
--- /dev/null
+++ b/src/resources/map/mapheights.cpp
@@ -0,0 +1,41 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2013-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "resources/map/mapheights.h"
+
+#include "debug.h"
+
+MapHeights::MapHeights(const int width, const int height) :
+    mWidth(width),
+    mHeight(height),
+    mTiles(new uint8_t[mWidth * mHeight])
+{
+    memset(mTiles, 0, mWidth * mHeight);
+}
+
+MapHeights::~MapHeights()
+{
+    delete [] mTiles;
+}
+
+void MapHeights::setHeight(const int x, const int y, const uint8_t height)
+{
+    mTiles[x + y * mWidth] = height;
+}
diff --git a/src/resources/map/mapheights.h b/src/resources/map/mapheights.h
new file mode 100644
index 000000000..89fc6a5c2
--- /dev/null
+++ b/src/resources/map/mapheights.h
@@ -0,0 +1,48 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2013-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RESOURCES_MAP_MAPHEIGHTS_H
+#define RESOURCES_MAP_MAPHEIGHTS_H
+
+#include "localconsts.h"
+
+class MapHeights final
+{
+    public:
+        friend class Map;
+
+        MapHeights(const int width, const int height);
+
+        A_DELETE_COPY(MapHeights)
+
+        ~MapHeights();
+
+        void setHeight(const int x, const int y, const uint8_t height);
+
+        uint8_t getHeight(const int x, const int y) const
+        { return mTiles[x + y * mWidth]; }
+
+    private:
+        int mWidth;
+        int mHeight;
+        uint8_t *mTiles;
+};
+
+#endif  // RESOURCES_MAP_MAPHEIGHTS_H
diff --git a/src/resources/map/maplayer.cpp b/src/resources/map/maplayer.cpp
new file mode 100644
index 000000000..dae071565
--- /dev/null
+++ b/src/resources/map/maplayer.cpp
@@ -0,0 +1,892 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "resources/map/maplayer.h"
+
+#include "configuration.h"
+#include "graphicsvertexes.h"
+
+#ifndef USE_OPENGL
+#include "render/graphics.h"
+#endif
+
+#include "being/localplayer.h"
+
+#include "render/graphics.h"
+
+#include "resources/image.h"
+#include "resources/resourcemanager.h"
+
+#include "gui/font.h"
+#include "gui/gui.h"
+
+#include "utils/delete2.h"
+#include "utils/dtor.h"
+
+#include "debug.h"
+
+MapLayer::MapLayer(const int x, const int y, const int width, const int height,
+                   const bool fringeLayer, const int mask):
+    mX(x),
+    mY(y),
+    mWidth(width),
+    mHeight(height),
+    mTiles(new Image*[mWidth * mHeight]),
+    mSpecialLayer(nullptr),
+    mTempLayer(nullptr),
+    mTempRows(),
+    mMask(mask),
+    mIsFringeLayer(fringeLayer),
+    mHighlightAttackRange(config.getBoolValue("highlightAttackRange"))
+{
+    std::fill_n(mTiles, mWidth * mHeight, static_cast<Image*>(nullptr));
+
+    config.addListener("highlightAttackRange", this);
+}
+
+MapLayer::~MapLayer()
+{
+    config.removeListener("highlightAttackRange", this);
+    CHECKLISTENERS
+    delete [] mTiles;
+    delete_all(mTempRows);
+    mTempRows.clear();
+}
+
+void MapLayer::optionChanged(const std::string &value)
+{
+    if (value == "highlightAttackRange")
+    {
+        mHighlightAttackRange =
+            config.getBoolValue("highlightAttackRange");
+    }
+}
+
+void MapLayer::setTile(const int x, const int y, Image *const img)
+{
+    mTiles[x + y * mWidth] = img;
+}
+
+void MapLayer::draw(Graphics *const graphics,
+                    int startX, int startY, int endX, int endY,
+                    const int scrollX, const int scrollY,
+                    const int debugFlags) const
+{
+    if (!player_node)
+        return;
+
+    BLOCK_START("MapLayer::draw")
+    startX -= mX;
+    startY -= mY;
+    endX -= mX;
+    endY -= mY;
+
+    if (startX < 0)
+        startX = 0;
+    if (startY < 0)
+        startY = 0;
+    if (endX > mWidth)
+        endX = mWidth;
+    if (endY > mHeight)
+        endY = mHeight;
+
+    const int dx = (mX * mapTileSize) - scrollX;
+    const int dy = (mY * mapTileSize) - scrollY + mapTileSize;
+    const bool flag = (debugFlags != Map::MAP_SPECIAL
+        && debugFlags != Map::MAP_SPECIAL2);
+
+    for (int y = startY; y < endY; y++)
+    {
+        const int y32 = y * mapTileSize;
+        const int yWidth = y * mWidth;
+
+        const int py0 = y32 + dy;
+
+        Image **tilePtr = mTiles + static_cast<size_t>(startX + yWidth);
+
+        for (int x = startX; x < endX; x++, tilePtr++)
+        {
+            const int x32 = x * mapTileSize;
+
+            int c = 0;
+            const Image *const img = *tilePtr;
+            if (img)
+            {
+                const int px = x32 + dx;
+                const int py = py0 - img->mBounds.h;
+                if (flag || img->mBounds.h <= mapTileSize)
+                {
+                    int width = 0;
+                    // here need not draw over player position
+                    c = getTileDrawWidth(img, endX - x, width);
+
+                    if (!c)
+                    {
+                        graphics->drawImage(img, px, py);
+                    }
+                    else
+                    {
+                        graphics->drawPattern(img, px, py,
+                            width, img->mBounds.h);
+                    }
+                }
+            }
+
+            x += c;
+        }
+    }
+    BLOCK_END("MapLayer::draw")
+}
+
+void MapLayer::drawSDL(Graphics *const graphics)
+{
+    BLOCK_START("MapLayer::drawSDL")
+    MapRows::const_iterator rit = mTempRows.begin();
+    const MapRows::const_iterator rit_end = mTempRows.end();
+    while (rit != rit_end)
+    {
+        MepRowImages *const images = &(*rit)->images;
+        MepRowImages::const_iterator iit = images->begin();
+        const MepRowImages::const_iterator iit_end = images->end();
+        while (iit != iit_end)
+        {
+            graphics->drawTileVertexes(*iit);
+            ++ iit;
+        }
+        ++ rit;
+    }
+    BLOCK_END("MapLayer::drawSDL")
+}
+
+#ifdef USE_OPENGL
+void MapLayer::updateSDL(const Graphics *const graphics,
+                         int startX, int startY,
+                         int endX, int endY,
+                         const int scrollX, const int scrollY,
+                         const int debugFlags)
+{
+    BLOCK_START("MapLayer::updateSDL")
+    delete_all(mTempRows);
+    mTempRows.clear();
+
+    startX -= mX;
+    startY -= mY;
+    endX -= mX;
+    endY -= mY;
+
+    if (startX < 0)
+        startX = 0;
+    if (startY < 0)
+        startY = 0;
+    if (endX > mWidth)
+        endX = mWidth;
+    if (endY > mHeight)
+        endY = mHeight;
+
+    const int dx = (mX * mapTileSize) - scrollX;
+    const int dy = (mY * mapTileSize) - scrollY + mapTileSize;
+    const bool flag = (debugFlags != Map::MAP_SPECIAL
+        && debugFlags != Map::MAP_SPECIAL2);
+
+    for (int y = startY; y < endY; y++)
+    {
+        MapRowVertexes *const row = new MapRowVertexes();
+        mTempRows.push_back(row);
+
+        const Image *lastImage = nullptr;
+        ImageVertexes *imgVert = nullptr;
+
+        const int yWidth = y * mWidth;
+        const int py0 = y * mapTileSize + dy;
+        Image **tilePtr = mTiles + static_cast<size_t>(startX + yWidth);
+
+        for (int x = startX; x < endX; x++, tilePtr++)
+        {
+            Image *const img = *tilePtr;
+            if (img)
+            {
+                const int px = x * mapTileSize + dx;
+                const int py = py0 - img->mBounds.h;
+                if (flag || img->mBounds.h <= mapTileSize)
+                {
+                    if (lastImage != img)
+                    {
+                        imgVert = new ImageVertexes();
+                        imgVert->image = img;
+                        row->images.push_back(imgVert);
+                        lastImage = img;
+                    }
+                    graphics->calcTileSDL(imgVert, px, py);
+                }
+            }
+        }
+    }
+    BLOCK_END("MapLayer::updateSDL")
+}
+
+void MapLayer::updateOGL(const Graphics *const graphics,
+                         int startX, int startY,
+                         int endX, int endY,
+                         const int scrollX, const int scrollY,
+                         const int debugFlags)
+{
+    BLOCK_START("MapLayer::updateOGL")
+    delete_all(mTempRows);
+    mTempRows.clear();
+
+    startX -= mX;
+    startY -= mY;
+    endX -= mX;
+    endY -= mY;
+
+    if (startX < 0)
+        startX = 0;
+    if (startY < 0)
+        startY = 0;
+    if (endX > mWidth)
+        endX = mWidth;
+    if (endY > mHeight)
+        endY = mHeight;
+
+    const int dx = (mX * mapTileSize) - scrollX;
+    const int dy = (mY * mapTileSize) - scrollY + mapTileSize;
+    const bool flag = (debugFlags != Map::MAP_SPECIAL
+        && debugFlags != Map::MAP_SPECIAL2);
+
+    MapRowVertexes *const row = new MapRowVertexes();
+    mTempRows.push_back(row);
+    Image *lastImage = nullptr;
+    ImageVertexes *imgVert = nullptr;
+    std::map<int, ImageVertexes*> imgSet;
+
+    for (int y = startY; y < endY; y++)
+    {
+        const int yWidth = y * mWidth;
+        const int py0 = y * mapTileSize + dy;
+        Image **tilePtr = mTiles + static_cast<size_t>(startX + yWidth);
+        for (int x = startX; x < endX; x++, tilePtr++)
+        {
+            Image *const img = *tilePtr;
+            if (img)
+            {
+                const int px = x * mapTileSize + dx;
+                const int py = py0 - img->mBounds.h;
+                const GLuint imgGlImage = img->mGLImage;
+                if (flag || img->mBounds.h <= mapTileSize)
+                {
+                    if (!lastImage || lastImage->mGLImage != imgGlImage)
+                    {
+                        if (img->mBounds.w > mapTileSize)
+                            imgSet.clear();
+
+                        if (imgSet.find(imgGlImage) != imgSet.end())
+                        {
+                            imgVert = imgSet[imgGlImage];
+                        }
+                        else
+                        {
+                            if (lastImage)
+                                imgSet[lastImage->mGLImage] = imgVert;
+                            imgVert = new ImageVertexes();
+                            imgVert->ogl.init();
+                            imgVert->image = img;
+                            row->images.push_back(imgVert);
+                        }
+                    }
+                    lastImage = img;
+//                    if (imgVert->image->mGLImage != lastImage->mGLImage)
+//                        logger->log("wrong image draw");
+                    graphics->calcTileVertexes(imgVert, lastImage, px, py);
+                }
+            }
+        }
+    }
+    BLOCK_END("MapLayer::updateOGL")
+}
+
+void MapLayer::drawOGL(Graphics *const graphics)
+{
+    BLOCK_START("MapLayer::drawOGL")
+    MapRows::const_iterator rit = mTempRows.begin();
+    const MapRows::const_iterator rit_end = mTempRows.end();
+//    int k = 0;
+    while (rit != rit_end)
+    {
+        const MepRowImages *const images = &(*rit)->images;
+        MepRowImages::const_iterator iit = images->begin();
+        const MepRowImages::const_iterator iit_end = images->end();
+        while (iit != iit_end)
+        {
+            graphics->drawTileVertexes(*iit);
+            ++ iit;
+//            k ++;
+        }
+        ++ rit;
+    }
+    BLOCK_END("MapLayer::drawOGL")
+//    logger->log("draws: %d", k);
+}
+#endif
+
+void MapLayer::drawFringe(Graphics *const graphics, int startX, int startY,
+                          int endX, int endY,
+                          const int scrollX, const int scrollY,
+                          const Actors *const actors,
+                          const int debugFlags, const int yFix) const
+{
+    BLOCK_START("MapLayer::drawFringe")
+    if (!player_node || !mSpecialLayer || !mTempLayer)
+    {
+        BLOCK_END("MapLayer::drawFringe")
+        return;
+    }
+
+    startX -= mX;
+    startY -= mY;
+    endX -= mX;
+    endY -= mY;
+
+    if (startX < 0)
+        startX = 0;
+    if (startY < 0)
+        startY = 0;
+    if (endX > mWidth)
+        endX = mWidth;
+    if (endY > mHeight)
+        endY = mHeight;
+
+    ActorsCIter ai = actors->begin();
+    const ActorsCIter ai_end = actors->end();
+
+    const int dx = (mX * mapTileSize) - scrollX;
+    const int dy = (mY * mapTileSize) - scrollY + mapTileSize;
+
+    const int specialWidth = mSpecialLayer->mWidth;
+    const int specialHeight = mSpecialLayer->mHeight;
+
+    for (int y = startY; y < endY; y++)
+    {
+        const int y32 = y * mapTileSize;
+        const int y32s = (y + yFix) * mapTileSize;
+        const int yWidth = y * mWidth;
+
+        BLOCK_START("MapLayer::drawFringe drawmobs")
+        // If drawing the fringe layer, make sure all actors above this row of
+        // tiles have been drawn
+        while (ai != ai_end && (*ai)->getSortPixelY() <= y32s)
+        {
+            (*ai)->draw(graphics, -scrollX, -scrollY);
+            ++ ai;
+        }
+        BLOCK_END("MapLayer::drawFringe drawmobs")
+
+        if (debugFlags == Map::MAP_SPECIAL3
+            || debugFlags == Map::MAP_BLACKWHITE)
+        {
+            if (y < specialHeight)
+            {
+                const int ptr = y * specialWidth;
+                const int py1 = y32 - scrollY;
+                int endX1 = endX;
+                if (endX1 > specialWidth)
+                    endX1 = specialWidth;
+                if (endX1 < 0)
+                    endX1 = 0;
+
+                for (int x = startX; x < endX1; x++)
+                {
+                    const int px1 = x * mapTileSize - scrollX;
+
+                    const MapItem *item = mSpecialLayer->mTiles[ptr + x];
+                    if (item)
+                    {
+                        item->draw(graphics, px1, py1,
+                            mapTileSize, mapTileSize);
+                    }
+
+                    item = mTempLayer->mTiles[ptr + x];
+                    if (item)
+                    {
+                        item->draw(graphics, px1, py1,
+                            mapTileSize, mapTileSize);
+                    }
+                }
+            }
+        }
+        else
+        {
+            const int py0 = y32 + dy;
+            const int py1 = y32 - scrollY;
+
+            Image **tilePtr = mTiles + static_cast<size_t>(startX + yWidth);
+            for (int x = startX; x < endX; x++, tilePtr++)
+            {
+                const int x32 = x * mapTileSize;
+
+                const int px1 = x32 - scrollX;
+                int c = 0;
+                const Image *const img = *tilePtr;
+                if (img)
+                {
+                    const int px = x32 + dx;
+                    const int py = py0 - img->mBounds.h;
+                    if ((debugFlags != Map::MAP_SPECIAL
+                        && debugFlags != Map::MAP_SPECIAL2)
+                        || img->mBounds.h <= mapTileSize)
+                    {
+                        int width = 0;
+                        // here need not draw over player position
+                        c = getTileDrawWidth(img, endX - x, width);
+
+                        if (!c)
+                        {
+                            graphics->drawImage(img, px, py);
+                        }
+                        else
+                        {
+                            graphics->drawPattern(img, px, py,
+                                width, img->mBounds.h);
+                        }
+                    }
+                }
+
+                if (y < specialHeight)
+                {
+                    int c1 = c;
+                    if (c1 + x + 1 > specialWidth)
+                        c1 = specialWidth - x - 1;
+                    if (c1 < 0)
+                        c1 = 0;
+
+                    const int ptr = y * specialWidth + x;
+
+                    for (int x1 = 0; x1 < c1 + 1; x1 ++)
+                    {
+                        const MapItem *const item1
+                            = mSpecialLayer->mTiles[ptr + x1];
+                        const MapItem *const item2
+                            = mTempLayer->mTiles[ptr + x1];
+                        if (item1 || item2)
+                        {
+                            const int px2 = px1 + (x1 * mapTileSize);
+                            if (item1 && item1->mType != MapItem::EMPTY)
+                            {
+                                item1->draw(graphics, px2, py1,
+                                    mapTileSize, mapTileSize);
+                            }
+
+                            if (item2 && item2->mType != MapItem::EMPTY)
+                            {
+                                item2->draw(graphics, px2, py1,
+                                    mapTileSize, mapTileSize);
+                            }
+                        }
+                    }
+                }
+                x += c;
+            }
+        }
+    }
+
+    // Draw any remaining actors
+    if (debugFlags != Map::MAP_SPECIAL3)
+    {
+        BLOCK_START("MapLayer::drawFringe drawmobs")
+        while (ai != ai_end)
+        {
+            (*ai)->draw(graphics, -scrollX, -scrollY);
+            ++ai;
+        }
+        BLOCK_END("MapLayer::drawFringe drawmobs")
+        if (mHighlightAttackRange && player_node)
+        {
+            const int px = player_node->getPixelX()
+                - scrollX - mapTileSize / 2;
+            const int py = player_node->getPixelY() - scrollY - mapTileSize;
+            const int attackRange = player_node->getAttackRange()
+                * mapTileSize;
+
+            int x = px - attackRange;
+            int y = py - attackRange;
+            int w = 2 * attackRange + mapTileSize;
+            int h = w;
+            if (attackRange <= mapTileSize)
+            {
+                x -= mapTileSize / 2;
+                y -= mapTileSize / 2;
+                w += mapTileSize;
+                h += mapTileSize;
+            }
+
+            if (userPalette)
+            {
+                graphics->setColor(userPalette->getColorWithAlpha(
+                    UserPalette::ATTACK_RANGE));
+                graphics->fillRectangle(Rect(x, y, w, h));
+                graphics->setColor(userPalette->getColorWithAlpha(
+                    UserPalette::ATTACK_RANGE_BORDER));
+                graphics->drawRectangle(Rect(x, y, w, h));
+            }
+        }
+    }
+    BLOCK_END("MapLayer::drawFringe")
+}
+
+int MapLayer::getTileDrawWidth(const Image *img,
+                               const int endX,
+                               int &width)
+{
+    BLOCK_START("MapLayer::getTileDrawWidth")
+    const Image *const img1 = img;
+    int c = 0;
+    if (!img1)
+    {
+        width = 0;
+        BLOCK_END("MapLayer::getTileDrawWidth")
+        return c;
+    }
+    width = img1->mBounds.w;
+    for (int x = 1; x < endX; x++)
+    {
+        img ++;
+        if (img != img1)
+            break;
+        c ++;
+        if (img)
+            width += img->mBounds.w;
+    }
+    BLOCK_END("MapLayer::getTileDrawWidth")
+    return c;
+}
+
+SpecialLayer::SpecialLayer(const int width, const int height) :
+    mWidth(width),
+    mHeight(height),
+    mTiles(new MapItem*[mWidth * mHeight])
+{
+    std::fill_n(mTiles, mWidth * mHeight, static_cast<MapItem*>(nullptr));
+}
+
+SpecialLayer::~SpecialLayer()
+{
+    for (int f = 0; f < mWidth * mHeight; f ++)
+        delete2(mTiles[f])
+    delete [] mTiles;
+}
+
+MapItem* SpecialLayer::getTile(const int x, const int y) const
+{
+    if (x < 0 || x >= mWidth ||
+        y < 0 || y >= mHeight)
+    {
+        return nullptr;
+    }
+    return mTiles[x + y * mWidth];
+}
+
+void SpecialLayer::setTile(const int x, const int y, MapItem *const item)
+{
+    if (x < 0 || x >= mWidth ||
+        y < 0 || y >= mHeight)
+    {
+        return;
+    }
+
+    const int idx = x + y * mWidth;
+    delete mTiles[idx];
+    if (item)
+        item->setPos(x, y);
+    mTiles[idx] = item;
+}
+
+void SpecialLayer::setTile(const int x, const int y, const int type)
+{
+    if (x < 0 || x >= mWidth ||
+        y < 0 || y >= mHeight)
+    {
+        return;
+    }
+
+    const int idx = x + y * mWidth;
+    MapItem *const tile = mTiles[idx];
+    if (tile)
+    {
+        tile->setType(type);
+        tile->setPos(x, y);
+    }
+    else
+    {
+        mTiles[idx] = new MapItem(type);
+        mTiles[idx]->setPos(x, y);
+    }
+}
+
+void SpecialLayer::addRoad(const Path &road)
+{
+    FOR_EACH (Path::const_iterator, i, road)
+    {
+        const Position &pos = (*i);
+        MapItem *const item = getTile(pos.x, pos.y);
+        if (!item)
+            setTile(pos.x, pos.y, new MapItem(MapItem::ROAD));
+        else
+            item->setType(MapItem::ROAD);
+    }
+}
+
+void SpecialLayer::clean() const
+{
+    if (!mTiles)
+        return;
+
+    for (int f = 0; f < mWidth * mHeight; f ++)
+    {
+        MapItem *const item = mTiles[f];
+        if (item)
+            item->setType(MapItem::EMPTY);
+    }
+}
+
+void SpecialLayer::draw(Graphics *const graphics, int startX, int startY,
+                        int endX, int endY,
+                        const int scrollX, const int scrollY) const
+{
+    BLOCK_START("SpecialLayer::draw")
+    if (startX < 0)
+        startX = 0;
+    if (startY < 0)
+        startY = 0;
+    if (endX > mWidth)
+        endX = mWidth;
+    if (endY > mHeight)
+        endY = mHeight;
+
+    for (int y = startY; y < endY; y ++)
+    {
+        const int py = y * mapTileSize - scrollY;
+        const int y2 = y * mWidth;
+        for (int x = startX; x < endX; x ++)
+        {
+            const MapItem *const item = mTiles[x + y2];
+            if (item)
+            {
+                item->draw(graphics, x * mapTileSize - scrollX, py,
+                    mapTileSize, mapTileSize);
+            }
+        }
+    }
+    BLOCK_END("SpecialLayer::draw")
+}
+
+MapItem::MapItem():
+    mImage(nullptr),
+    mComment(),
+    mName(),
+    mType(EMPTY),
+    mX(-1),
+    mY(-1)
+{
+    setType(EMPTY);
+}
+
+MapItem::MapItem(const int type):
+    mImage(nullptr),
+    mComment(),
+    mName(),
+    mType(type),
+    mX(-1),
+    mY(-1)
+{
+    setType(type);
+}
+
+MapItem::MapItem(const int type, std::string comment):
+    mImage(nullptr),
+    mComment(comment),
+    mName(),
+    mType(type),
+    mX(-1),
+    mY(-1)
+{
+    setType(type);
+}
+
+MapItem::MapItem(const int type, std::string comment,
+                 const int x, const int y):
+    mImage(nullptr),
+    mComment(comment),
+    mName(),
+    mType(type),
+    mX(x),
+    mY(y)
+{
+    setType(type);
+}
+
+MapItem::~MapItem()
+{
+    if (mImage)
+    {
+        mImage->decRef();
+        mImage = nullptr;
+    }
+}
+
+void MapItem::setType(const int type)
+{
+    std::string name;
+    mType = type;
+    if (mImage)
+        mImage->decRef();
+
+    switch (type)
+    {
+        case ARROW_UP:
+            name = "graphics/sprites/arrow_up.png";
+            break;
+        case ARROW_DOWN:
+            name = "graphics/sprites/arrow_down.png";
+            break;
+        case ARROW_LEFT:
+            name = "graphics/sprites/arrow_left.png";
+            break;
+        case ARROW_RIGHT:
+            name = "graphics/sprites/arrow_right.png";
+            break;
+        default:
+            break;
+    }
+
+    if (!name.empty())
+    {
+        ResourceManager *const resman = ResourceManager::getInstance();
+        mImage = resman->getImage(name);
+    }
+    else
+    {
+        mImage = nullptr;
+    }
+}
+
+void MapItem::setPos(const int x, const int y)
+{
+    mX = x;
+    mY = y;
+}
+
+void MapItem::draw(Graphics *const graphics, const int x, const int y,
+                   const int dx, const int dy) const
+{
+    BLOCK_START("MapItem::draw")
+    if (mImage)
+        graphics->drawImage(mImage, x, y);
+
+    switch (mType)
+    {
+        case ROAD:
+        case CROSS:
+            graphics->setColor(userPalette->getColorWithAlpha(
+                               UserPalette::ROAD_POINT));
+            graphics->fillRectangle(Rect(x + dx / 3, y + dy / 3,
+                                    dx / 3, dy / 3));
+            break;
+        case HOME:
+        {
+            graphics->setColor(userPalette->getColorWithAlpha(
+                               UserPalette::HOME_PLACE));
+            graphics->fillRectangle(Rect(x, y, dx, dy));
+            graphics->setColor(userPalette->getColorWithAlpha(
+                               UserPalette::HOME_PLACE_BORDER));
+            graphics->drawRectangle(Rect(x, y, dx, dy));
+            break;
+        }
+        default:
+            break;
+    }
+    if (!mName.empty() && mType != PORTAL && mType != EMPTY)
+    {
+        Font *const font = gui->getFont();
+        if (font)
+        {
+            graphics->setColor(userPalette->getColor(UserPalette::BEING));
+            font->drawString(graphics, mName, x, y);
+        }
+    }
+    BLOCK_END("MapItem::draw")
+}
+
+ObjectsLayer::ObjectsLayer(const unsigned width, const unsigned height) :
+    mTiles(new MapObjectList*[width * height]),
+    mWidth(width),
+    mHeight(height)
+{
+    std::fill_n(mTiles, width * height, static_cast<MapObjectList*>(nullptr));
+}
+
+ObjectsLayer::~ObjectsLayer()
+{
+    const unsigned size = mWidth * mHeight;
+    for (unsigned f = 0; f < size; f ++)
+        delete mTiles[f];
+
+    delete [] mTiles;
+    mTiles = nullptr;
+}
+
+void ObjectsLayer::addObject(const std::string &name, const int type,
+                             const unsigned x, const unsigned y,
+                             unsigned dx, unsigned dy)
+{
+    if (!mTiles)
+        return;
+
+    if (x + dx > mWidth)
+        dx = mWidth - x;
+    if (y + dy > mHeight)
+        dy = mHeight - y;
+
+    for (unsigned y1 = y; y1 < y + dy; y1 ++)
+    {
+        const unsigned idx1 = x + y1 * mWidth;
+        const unsigned idx2 = idx1 + dx;
+
+        for (unsigned i = idx1; i < idx2; i ++)
+        {
+            if (!mTiles[i])
+                mTiles[i] = new MapObjectList();
+            mTiles[i]->objects.push_back(MapObject(type, name));
+        }
+    }
+}
+
+MapObjectList *ObjectsLayer::getAt(const unsigned x, const unsigned y) const
+{
+    if (x >= mWidth || y >= mHeight)
+        return nullptr;
+    return mTiles[x + y * mWidth];
+}
+
+MapRowVertexes::~MapRowVertexes()
+{
+    delete_all(images);
+    images.clear();
+}
diff --git a/src/resources/map/maplayer.h b/src/resources/map/maplayer.h
new file mode 100644
index 000000000..2c3fc23f1
--- /dev/null
+++ b/src/resources/map/maplayer.h
@@ -0,0 +1,328 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RESOURCES_MAP_MAPLAYER_H
+#define RESOURCES_MAP_MAPLAYER_H
+
+#include "position.h"
+#include "main.h"
+
+#include "listeners/configlistener.h"
+
+#include "being/actor.h"
+
+#include <string>
+#include <vector>
+
+class Image;
+class MapItem;
+class SpecialLayer;
+class ImageVertexes;
+
+typedef std::vector<ImageVertexes*> MepRowImages;
+
+class MapRowVertexes final
+{
+    public:
+        MapRowVertexes() :
+            images()
+        {
+            images.reserve(30);
+        }
+
+        A_DELETE_COPY(MapRowVertexes)
+
+        ~MapRowVertexes();
+
+        MepRowImages images;
+};
+
+class MapObject final
+{
+    public:
+        MapObject(const int type0, const std::string &data0) :
+            type(type0), data(data0)
+        {
+        }
+
+        int type;
+        std::string data;
+};
+
+class MapObjectList final
+{
+    public:
+        MapObjectList() :
+            objects()
+        {
+        }
+
+        A_DELETE_COPY(MapObjectList)
+
+        std::vector<MapObject> objects;
+};
+
+/**
+ * A map layer. Stores a grid of tiles and their offset, and implements layer
+ * rendering.
+ */
+class MapLayer final: public ConfigListener
+{
+    public:
+        enum Type
+        {
+            TILES = 0,
+            COLLISION,
+            HEIGHTS
+        };
+
+        friend class Map;
+
+        /**
+         * Constructor, taking layer origin, size and whether this layer is the
+         * fringe layer. The fringe layer is the layer that draws the actors.
+         * There can be only one fringe layer per map.
+         */
+        MapLayer(const int x, const int y, const int width, const int height,
+                 const bool isFringeLayer, const int mask);
+
+        A_DELETE_COPY(MapLayer)
+
+        /**
+         * Destructor.
+         */
+        ~MapLayer();
+
+        /**
+         * Set tile image, with x and y in layer coordinates.
+         */
+        void setTile(const int x, const int y, Image *const img);
+
+        /**
+         * Set tile image with x + y * width already known.
+         */
+        void setTile(const int index, Image *const img)
+        { mTiles[index] = img; }
+
+        /**
+         * Draws this layer to the given graphics context. The coordinates are
+         * expected to be in map range and will be translated to local layer
+         * coordinates and clipped to the layer's dimensions.
+         *
+         * The given actors are only drawn when this layer is the fringe
+         * layer.
+         */
+        void draw(Graphics *const graphics,
+                  int startX, int startY, int endX, int endY,
+                  const int scrollX, const int scrollY,
+                  const int mDebugFlags) const;
+
+        void drawSDL(Graphics *const graphics);
+
+#ifdef USE_OPENGL
+        void drawOGL(Graphics *const graphics);
+
+        void updateOGL(const Graphics *const graphics,
+                       int startX, int startY,
+                       int endX, int endY,
+                       const int scrollX, const int scrollY,
+                       const int mDebugFlags);
+#endif
+
+        void updateSDL(const Graphics *const graphics,
+                       int startX, int startY,
+                       int endX, int endY,
+                       const int scrollX, const int scrollY,
+                       const int mDebugFlags);
+
+        void drawFringe(Graphics *const graphics,
+                        int startX, int startY,
+                        int endX, int endY,
+                        const int scrollX, const int scrollY,
+                        const Actors *const actors,
+                        const int mDebugFlags, const int yFix) const;
+
+        bool isFringeLayer() const A_WARN_UNUSED
+        { return mIsFringeLayer; }
+
+        void setSpecialLayer(SpecialLayer *const val)
+        { mSpecialLayer = val; }
+
+        void setTempLayer(SpecialLayer *const val)
+        { mTempLayer = val; }
+
+        int getWidth() const A_WARN_UNUSED
+        { return mWidth; }
+
+        int getHeight() const A_WARN_UNUSED
+        { return mHeight; }
+
+        void optionChanged(const std::string &value) override final;
+
+        static int getTileDrawWidth(const Image *img,
+                                    const int endX,
+                                    int &width) A_WARN_UNUSED;
+
+    private:
+        int mX;
+        int mY;
+        int mWidth;
+        int mHeight;
+        Image **mTiles;
+        SpecialLayer *mSpecialLayer;
+        SpecialLayer *mTempLayer;
+        typedef std::vector<MapRowVertexes*> MapRows;
+        MapRows mTempRows;
+        int mMask;
+        bool mIsFringeLayer;    /**< Whether the actors are drawn. */
+        bool mHighlightAttackRange;
+};
+
+class SpecialLayer final
+{
+    public:
+        friend class Map;
+        friend class MapLayer;
+
+        SpecialLayer(const int width, const int height);
+
+        A_DELETE_COPY(SpecialLayer)
+
+        ~SpecialLayer();
+
+        void draw(Graphics *const graphics, int startX, int startY,
+                  int endX, int endY,
+                  const int scrollX, const int scrollY) const;
+
+        MapItem* getTile(const int x, const int y) const A_WARN_UNUSED;
+
+        void setTile(const int x, const int y, MapItem *const item);
+
+        void setTile(const int x, const int y, const int type);
+
+        void addRoad(const Path &road);
+
+        void clean() const;
+
+    private:
+        int mWidth;
+        int mHeight;
+        MapItem **mTiles;
+};
+
+class MapItem final
+{
+    public:
+        friend class Map;
+        friend class MapLayer;
+
+        enum ItemType
+        {
+            EMPTY = 0,
+            HOME = 1,
+            ROAD = 2,
+            CROSS = 3,
+            ARROW_UP = 4,
+            ARROW_DOWN = 5,
+            ARROW_LEFT = 6,
+            ARROW_RIGHT = 7,
+            PORTAL = 8,
+            MUSIC = 9,
+            ATTACK = 10,
+            PRIORITY = 11,
+            IGNORE_ = 12,
+            PICKUP = 13,
+            NOPICKUP = 14,
+            SEPARATOR = 15
+        };
+
+        MapItem();
+
+        explicit MapItem(const int type);
+
+        MapItem(const int type, std::string comment);
+
+        MapItem(const int type, std::string comment, const int x, const int y);
+
+        A_DELETE_COPY(MapItem)
+
+        ~MapItem();
+
+        int getType() const A_WARN_UNUSED
+        { return mType; }
+
+        void setType(const int type);
+
+        void setPos(const int x, const int y);
+
+        int getX() const A_WARN_UNUSED
+        { return mX; }
+
+        int getY() const A_WARN_UNUSED
+        { return mY; }
+
+        const std::string &getComment() const A_WARN_UNUSED
+        { return mComment; }
+
+        void setComment(const std::string &comment)
+        { mComment = comment; }
+
+        const std::string &getName() const A_WARN_UNUSED
+        { return mName; }
+
+        void setName(const std::string &name)
+        { mName = name; }
+
+        void draw(Graphics *const graphics, const int x, const int y,
+                  const int dx, const int dy) const;
+
+    private:
+        Image *mImage;
+        std::string mComment;
+        std::string mName;
+        int mType;
+        int mX;
+        int mY;
+};
+
+class ObjectsLayer final
+{
+    public:
+        ObjectsLayer(const unsigned width, const unsigned height);
+
+        A_DELETE_COPY(ObjectsLayer)
+
+        ~ObjectsLayer();
+
+        void addObject(const std::string &name, const int type,
+                       const unsigned x, const unsigned y,
+                       unsigned dx, unsigned dy);
+
+        MapObjectList *getAt(const unsigned x,
+                             const unsigned y) const A_WARN_UNUSED;
+    private:
+        MapObjectList **mTiles;
+        unsigned mWidth;
+        unsigned mHeight;
+};
+
+#endif  // RESOURCES_MAP_MAPLAYER_H
diff --git a/src/resources/map/properties.h b/src/resources/map/properties.h
new file mode 100644
index 000000000..7d3ff6ebf
--- /dev/null
+++ b/src/resources/map/properties.h
@@ -0,0 +1,135 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RESOURCES_MAP_PROPERTIES_H
+#define RESOURCES_MAP_PROPERTIES_H
+
+#include "localconsts.h"
+
+#include <map>
+#include <sstream>
+#include <string>
+
+/**
+ * A class holding a set of properties.
+ */
+class Properties
+{
+    public:
+        Properties() :
+            mProperties()
+        {
+        }
+
+        /**
+         * Destructor.
+         */
+        virtual ~Properties()
+        { }
+
+        /**
+         * Get a map property.
+         *
+         * @param name The name of the property.
+         * @param def  Default value, empty string by default.
+         * @return the value of the given property or the given default when it
+         *         doesn't exist.
+         */
+        const std::string getProperty(const std::string &name,
+                                      const std::string &def = "")
+                                      const A_WARN_UNUSED
+        {
+            const PropertyMap::const_iterator i = mProperties.find(name);
+            return (i != mProperties.end()) ? i->second : def;
+        }
+
+        /**
+         * Gets a map property as a float.
+         *
+         * @param name The name of the property.
+         * @param def  Default value, 0.0F by default.
+         * @return the value of the given property or the given default when it
+         *         doesn't exist.
+         */
+        float getFloatProperty(const std::string &name,
+                               const float def = 0.0F) const A_WARN_UNUSED
+        {
+            const PropertyMap::const_iterator i = mProperties.find(name);
+            float ret = def;
+            if (i != mProperties.end())
+            {
+                std::stringstream ss;
+                ss.str(i->second);
+                ss >> ret;
+            }
+            return ret;
+        }
+
+        /**
+         * Gets a map property as a boolean.
+         *
+         * @param name The name of the property.
+         * @param def  Default value, false by default.
+         * @return the value of the given property or the given default when it
+         *         doesn't exist.
+         */
+        bool getBoolProperty(const std::string &name,
+                             const bool def = false) const A_WARN_UNUSED
+        {
+            const PropertyMap::const_iterator i = mProperties.find(name);
+            bool ret = def;
+            if (i != mProperties.end())
+            {
+                if (i->second == "true")
+                    ret = true;
+                if (i->second == "false")
+                    ret = false;
+            }
+            return ret;
+        }
+
+        /**
+         * Returns whether a certain property is available.
+         *
+         * @param name The name of the property.
+         * @return <code>true</code> when a property is defined,
+         *         <code>false</code> otherwise.
+         */
+        bool hasProperty(const std::string &name) const A_WARN_UNUSED
+        { return (mProperties.find(name) != mProperties.end()); }
+
+        /**
+         * Set a map property.
+         *
+         * @param name  The name of the property.
+         * @param value The value of the property.
+         */
+        void setProperty(const std::string &name, const std::string &value)
+        { mProperties[name] = value; }
+
+
+    private:
+        typedef std::map<std::string, std::string> PropertyMap;
+        PropertyMap mProperties;
+};
+
+#endif  // RESOURCES_MAP_PROPERTIES_H
diff --git a/src/resources/map/tileset.h b/src/resources/map/tileset.h
new file mode 100644
index 000000000..312896c62
--- /dev/null
+++ b/src/resources/map/tileset.h
@@ -0,0 +1,79 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RESOURCES_MAP_TILESET_H
+#define RESOURCES_MAP_TILESET_H
+
+#include "resources/imageset.h"
+
+#include <map>
+
+/**
+ * A tileset, which is basically just an image set but it stores a firstgid.
+ */
+class Tileset final : public ImageSet
+{
+    public:
+        /**
+         * Constructor.
+         */
+        Tileset(Image *const img, const int w, const int h, const int firstGid,
+                const int margin, const int spacing):
+            ImageSet(img, w, h, margin, spacing),
+            mFirstGid(firstGid),
+            mProperties()
+        {
+        }
+
+        A_DELETE_COPY(Tileset)
+
+        /**
+         * Returns the first gid.
+         */
+        int getFirstGid() const A_WARN_UNUSED
+        { return mFirstGid; }
+
+        /**
+         * Set tileset property.
+         */
+        void setProperties(const std::map<std::string, std::string> &props)
+        { mProperties = props; }
+
+        /**
+         * Returns property value.
+         */
+        std::string getProperty(const std::string &name) A_WARN_UNUSED
+        {
+            const std::map<std::string, std::string>::const_iterator
+                it = mProperties.find(name);
+            if (it == mProperties.end())
+                return "";
+            return mProperties[name];
+        }
+
+    private:
+        int mFirstGid;
+
+        std::map<std::string, std::string> mProperties;
+};
+
+#endif  // RESOURCES_MAP_TILESET_H
diff --git a/src/resources/map/walklayer.cpp b/src/resources/map/walklayer.cpp
new file mode 100644
index 000000000..88f2fe8ef
--- /dev/null
+++ b/src/resources/map/walklayer.cpp
@@ -0,0 +1,44 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2013-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "resources/map/walklayer.h"
+
+#include "debug.h"
+
+WalkLayer::WalkLayer(const int width, const int height) :
+    Resource(),
+    mWidth(width),
+    mHeight(height),
+    mTiles(new int[width * height])
+{
+    std::fill_n(mTiles, width * height, 0);
+}
+
+WalkLayer::~WalkLayer()
+{
+    delete [] mTiles;
+}
+
+int WalkLayer::getDataAt(const int x, const int y) const
+{
+    if (x < 0 || x >= mWidth || y < 0 || y >= mHeight)
+        return 0;
+    return mTiles[x + y * mWidth];
+}
diff --git a/src/resources/map/walklayer.h b/src/resources/map/walklayer.h
new file mode 100644
index 000000000..a55cab434
--- /dev/null
+++ b/src/resources/map/walklayer.h
@@ -0,0 +1,48 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2013-2014  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RESOURCES_MAP_WALKLAYER_H
+#define RESOURCES_MAP_WALKLAYER_H
+
+#include "resources/resource.h"
+
+#include "localconsts.h"
+
+class WalkLayer final : public Resource
+{
+    public:
+        WalkLayer(const int width, const int height);
+
+        A_DELETE_COPY(WalkLayer)
+
+        ~WalkLayer();
+
+        int *getData()
+        { return mTiles; }
+
+        int getDataAt(const int x, const int y) const;
+
+    private:
+        int mWidth;
+        int mHeight;
+        int *mTiles;
+};
+
+#endif  // RESOURCES_MAP_WALKLAYER_H