Initial commit.

This code based on mana client http://www.gitorious.org/mana/mana
and my private repository.

1 files changed, 1654 insertions, 0 deletions

diff --git a/src/map.cpp b/src/map.cpp
new file mode 100644
index 000000000..5dd933f0b
--- /dev/null
+++ b/src/map.cpp
@@ -0,0 +1,1654 @@
+/*
+ *  The Mana Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *
+ *  This file is part of The Mana 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 "map.h"
+
+#include "actorspritemanager.h"
+#include "client.h"
+#include "configuration.h"
+#include "graphics.h"
+#include "log.h"
+#include "particle.h"
+#include "simpleanimation.h"
+#include "tileset.h"
+#include "localplayer.h"
+
+#include "resources/ambientlayer.h"
+#include "resources/image.h"
+#include "resources/resourcemanager.h"
+
+#include "gui/gui.h"
+#include "gui/palette.h"
+#include "gui/truetypefont.h"
+
+#include "gui/widgets/chattab.h"
+
+#include "utils/dtor.h"
+#include "utils/mkdir.h"
+#include "utils/stringutils.h"
+
+#include <queue>
+
+#include <sys/stat.h>
+
+bool actorCompare(const Actor *a, const Actor *b);
+
+/**
+ * A location on a tile map. Used for pathfinding, open list.
+ */
+struct Location
+{
+    /**
+     * Constructor.
+     */
+    Location(int px, int py, MetaTile *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;
+};
+
+TileAnimation::TileAnimation(Animation *ani):
+    mLastImage(NULL)
+{
+    mAnimation = new SimpleAnimation(ani);
+}
+
+TileAnimation::~TileAnimation()
+{
+    delete mAnimation;
+    mAnimation = 0;
+}
+
+void TileAnimation::update(int ticks)
+{
+    if (!mAnimation)
+        return;
+
+    // update animation
+    mAnimation->update(ticks);
+
+    // exchange images
+    Image *img = mAnimation->getCurrentImage();
+    if (img != mLastImage)
+    {
+        for (std::list<std::pair<MapLayer*, int> >::iterator i =
+             mAffected.begin(); i != mAffected.end(); i++)
+        {
+            i->first->setTile(i->second, img);
+        }
+        mLastImage = img;
+    }
+}
+
+MapLayer::MapLayer(int x, int y, int width, int height, bool isFringeLayer):
+    mX(x), mY(y),
+    mWidth(width), mHeight(height),
+    mIsFringeLayer(isFringeLayer),
+    mHighlightAttackRange(config.getBoolValue("highlightAttackRange"))
+{
+    const int size = mWidth * mHeight;
+    mTiles = new Image*[size];
+
+    std::fill_n(mTiles, size, (Image*) 0);
+
+    config.addListener("highlightAttackRange", this);
+}
+
+MapLayer::~MapLayer()
+{
+    config.removeListener("highlightAttackRange", this);
+    delete[] mTiles;
+}
+
+void MapLayer::optionChanged(const std::string &value)
+{
+    if (value == "highlightAttackRange")
+    {
+        mHighlightAttackRange =
+            config.getBoolValue("highlightAttackRange");
+    }
+}
+
+void MapLayer::setTile(int x, int y, Image *img)
+{
+    setTile(x + y * mWidth, img);
+}
+
+Image* MapLayer::getTile(int x, int y) const
+{
+    return mTiles[x + y * mWidth];
+}
+
+void MapLayer::draw(Graphics *graphics, int startX, int startY,
+                    int endX, int endY, int scrollX, int scrollY,
+                    const Actors &actors, int debugFlags) const
+{
+    if (!player_node)
+        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;
+
+    Actors::const_iterator ai = actors.begin();
+
+    const int dx = (mX * 32) - scrollX;
+    const int dy = (mY * 32) - scrollY + 32;
+
+    int specialWidth = 0;
+    int specialHeight = 0;
+
+    const bool extraDraw =
+        mIsFringeLayer && mSpecialLayer && mTempLayer;
+
+    if (mIsFringeLayer)
+    {
+        if (mSpecialLayer)
+        {
+            specialWidth = mSpecialLayer->mWidth;
+            specialHeight = mSpecialLayer->mHeight;
+        }
+    }
+
+    for (int y = startY; y < endY; y++)
+    {
+        const int y32 = y * 32;
+        const int yWidth = y * mWidth;
+
+        // If drawing the fringe layer, make sure all actors above this row of
+        // tiles have been drawn
+        if (mIsFringeLayer)
+        {
+            while (ai != actors.end() && (*ai)->getPixelY() <= y32)
+            {
+                (*ai)->draw(graphics, -scrollX, -scrollY);
+                ai++;
+            }
+        }
+
+        if (debugFlags == Map::MAP_SPECIAL3
+            || debugFlags == Map::MAP_BLACKWHITE)
+        {
+            if (extraDraw && y < specialHeight)
+            {
+                //x + y * mWidth
+                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 * 32 - scrollX;
+
+                    MapItem *item = mSpecialLayer->mTiles[ptr + x];
+                    if (item)
+                        item->draw(graphics, px1, py1, 32, 32);
+
+                    item = mTempLayer->mTiles[ptr + x];
+                    if (item)
+                        item->draw(graphics, px1, py1, 32, 32);
+                }
+            }
+        }
+        else
+        {
+            const int py0 = y32 + dy;
+            const int py1 = y32 - scrollY;
+
+            for (int x = startX; x < endX; x++)
+            {
+                const int px1 = x * 32 - scrollX;
+                const int tilePtr = x + yWidth;
+                int c = 0;
+                Image *img = mTiles[tilePtr];
+                if (img)
+                {
+                    const int px = (x * 32) + dx;
+                    const int py = py0 - img->getHeight();
+                    if ((debugFlags != Map::MAP_SPECIAL
+                        && debugFlags != Map::MAP_SPECIAL2)
+                        || img->getHeight() <= 32)
+                    {
+                        int width = 0;
+                        c = getTileDrawWidth(tilePtr, endX - x, width);
+
+                        if (!c)
+                        {
+                            graphics->drawImage(img, px, py);
+                        }
+                        else
+                        {
+                            graphics->drawImagePattern(img, px, py,
+                                width, img->getHeight());
+                        }
+                    }
+                }
+
+                if (extraDraw && y < specialHeight)
+                {
+                    int c1 = c;
+                    if (c1 + x + 1 > specialWidth)
+                        c1 = specialWidth - x - 1;
+                    if (c1 < 0)
+                        c1 = 0;
+
+                    int ptr = y * specialWidth + x;
+
+                    for (int x1 = 0; x1 < c1 + 1; x1 ++)
+                    {
+                        MapItem *item1 = mSpecialLayer->mTiles[ptr + x1];
+                        MapItem *item2 = mTempLayer->mTiles[ptr + x1];
+                        if (item1 || item2)
+                        {
+                            const int px2 = px1 + (x1 * 32);
+                            if (item1 && item1->mType != MapItem::EMPTY)
+                                item1->draw(graphics, px2, py1, 32, 32);
+
+                            if (item2 && item2->mType != MapItem::EMPTY)
+                                item2->draw(graphics, px2, py1, 32, 32);
+                        }
+                    }
+                }
+                x += c;
+            }
+        }
+    }
+
+    // Draw any remaining actors
+    if (mIsFringeLayer && debugFlags != Map::MAP_SPECIAL3)
+    {
+        while (ai != actors.end())
+        {
+            (*ai)->draw(graphics, -scrollX, -scrollY);
+            ai++;
+        }
+        if (mHighlightAttackRange && player_node)
+        {
+            const int px = player_node->getPixelX() - scrollX - 16;
+            const int py = player_node->getPixelY() - scrollY - 32;
+            const int attackRange = player_node->getAttackRange() * 32;
+
+            int x = px - attackRange;
+            int y = py - attackRange;
+            int w = 2 * attackRange + 32;
+            int h = w;
+            if (attackRange <= 32)
+            {
+                x -= 16;
+                y -= 16;
+                w += 32;
+                h += 32;
+            }
+
+            if (userPalette)
+            {
+                graphics->setColor(userPalette->getColorWithAlpha(
+                    UserPalette::ATTACK_RANGE));
+
+                graphics->fillRectangle(gcn::Rectangle(
+                                                       x, y,
+                                                       w, h));
+
+                graphics->setColor(userPalette->getColorWithAlpha(
+                    UserPalette::ATTACK_RANGE_BORDER));
+
+                graphics->drawRectangle(gcn::Rectangle(
+                                                       x, y,
+                                                       w, h));
+            }
+        }
+    }
+}
+
+int MapLayer::getTileDrawWidth(int tilePtr, int endX, int &width) const
+{
+    Image *img1 = mTiles[tilePtr];
+    int c = 0;
+    if (!img1)
+    {
+        width = 0;
+        return c;
+    }
+    width = img1->getWidth();
+    for (int x = 1; x < endX; x++)
+    {
+        tilePtr ++;
+        Image *img = mTiles[tilePtr];
+        if (img != img1)
+            break;
+        c ++;
+        if (img)
+            width += img->getWidth();
+    }
+    return c;
+}
+
+Map::Map(int width, int height, int tileWidth, int tileHeight):
+    mWidth(width), mHeight(height),
+    mTileWidth(tileWidth), mTileHeight(tileHeight),
+    mMaxTileHeight(height),
+    mHasWarps(false),
+    mDebugFlags(MAP_NORMAL),
+    mOnClosedList(1), mOnOpenList(2),
+    mLastScrollX(0.0f), mLastScrollY(0.0f),
+    mOverlayDetail(config.getIntValue("OverlayDetail")),
+    mOpacity(config.getFloatValue("guialpha")),
+    mPvp(0)
+//    mSpritesUpdated(true)
+{
+    const int size = mWidth * mHeight;
+
+    mDebugFlags = 0;
+    mMetaTiles = new MetaTile[size];
+    for (int i = 0; i < NB_BLOCKTYPES; i++)
+    {
+        mOccupation[i] = new int[size];
+        memset(mOccupation[i], 0, size * sizeof(int));
+    }
+    mSpecialLayer = new SpecialLayer(width, height);
+    mTempLayer = new SpecialLayer(width, height, true);
+    config.addListener("OverlayDetail", this);
+    config.addListener("guialpha", this);
+
+#ifdef USE_OPENGL
+    mOpenGL = config.getIntValue("opengl");
+#else
+    mOpenGL = 0;
+#endif
+}
+
+Map::~Map()
+{
+    config.removeListener("OverlayDetail", this);
+    config.removeListener("guialpha", this);
+
+    // delete metadata, layers, tilesets and overlays
+    delete[] mMetaTiles;
+    for (int i = 0; i < NB_BLOCKTYPES; i++)
+        delete[] mOccupation[i];
+
+    delete_all(mLayers);
+    delete_all(mTilesets);
+    delete_all(mForegrounds);
+    delete_all(mBackgrounds);
+    delete_all(mTileAnimations);
+    delete mSpecialLayer;
+    mSpecialLayer = 0;
+    delete mTempLayer;
+    mTempLayer = 0;
+    delete_all(mMapPortals);
+}
+
+void Map::optionChanged(const std::string &value)
+{
+    if (value == "OverlayDetail")
+        mOverlayDetail = config.getIntValue("OverlayDetail");
+    else if (value == "guialpha")
+        mOpacity = config.getFloatValue("guialpha");
+}
+
+void Map::initializeAmbientLayers()
+{
+    ResourceManager *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("foreground" + toString(i) + "image"))
+            name = "foreground" + toString(i);
+        else if (hasProperty("overlay" + toString(i) + "image"))
+            name = "overlay" + toString(i);
+        else
+            break; // the FOR loop
+
+        Image *img = resman->getImage(getProperty(name + "image"));
+        const float speedX = getFloatProperty(name + "scrollX");
+        const float speedY = getFloatProperty(name + "scrollY");
+        const float parallax = getFloatProperty(name + "parallax");
+        const bool keepRatio = getBoolProperty(name + "keepratio");
+
+        if (img)
+        {
+            mForegrounds.push_back(
+                new AmbientLayer(img, parallax, speedX, speedY, keepRatio));
+
+            // The AmbientLayer takes control over the image.
+            img->decRef();
+        }
+    }
+
+
+    // search for "background*" in map properties
+    for (int i = 0;
+         hasProperty("background" + toString(i) + "image");
+         i++)
+    {
+        const std::string name = "background" + toString(i);
+
+        Image *img = resman->getImage(getProperty(name + "image"));
+        const float speedX = getFloatProperty(name + "scrollX");
+        const float speedY = getFloatProperty(name + "scrollY");
+        const float parallax = getFloatProperty(name + "parallax");
+        const bool keepRatio = getBoolProperty(name + "keepratio");
+
+        if (img)
+        {
+            mBackgrounds.push_back(
+                new AmbientLayer(img, parallax, speedX, speedY, keepRatio));
+
+            // The AmbientLayer takes control over the image.
+            img->decRef();
+        }
+    }
+}
+
+void Map::addLayer(MapLayer *layer)
+{
+    mLayers.push_back(layer);
+}
+
+void Map::addTileset(Tileset *tileset)
+{
+    if (!tileset)
+        return;
+
+    mTilesets.push_back(tileset);
+
+    if (tileset->getHeight() > mMaxTileHeight)
+        mMaxTileHeight = tileset->getHeight();
+}
+
+bool actorCompare(const Actor *a, const Actor *b)
+{
+    if (!a || !b)
+        return false;
+
+    return a->getPixelY() < b->getPixelY();
+}
+
+void Map::update(int ticks)
+{
+    // Update animated tiles
+    for (std::map<int, TileAnimation*>::iterator
+         iAni = mTileAnimations.begin();
+         iAni != mTileAnimations.end(); iAni++)
+    {
+        iAni->second->update(ticks);
+    }
+}
+
+void Map::draw(Graphics *graphics, int scrollX, int scrollY)
+{
+    // Calculate range of tiles which are on-screen
+    int endPixelY = graphics->getHeight() + scrollY + mTileHeight - 1;
+    endPixelY += mMaxTileHeight - mTileHeight;
+    int startX = scrollX / mTileWidth;
+    int startY = scrollY / mTileHeight;
+    int endX = (graphics->getWidth() + scrollX + mTileWidth - 1) / mTileWidth;
+    int endY = endPixelY / mTileHeight;
+
+    // Make sure actors are sorted ascending by Y-coordinate
+    // so that they overlap correctly
+//    if (mSpritesUpdated)
+//    {
+        mActors.sort(actorCompare);
+//        mSpritesUpdated = false;
+//    }
+
+    // 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)
+    {
+        graphics->setColor(userPalette->getColorWithAlpha(
+            UserPalette::WALKABLE_HIGHLIGHT));
+
+        graphics->fillRectangle(gcn::Rectangle(0, 0,
+            graphics->getWidth(), graphics->getHeight()));
+    }
+
+    // draw the game world
+    Layers::const_iterator layeri = mLayers.begin();
+
+    bool overFringe = false;
+
+    if (mDebugFlags == MAP_SPECIAL3 || mDebugFlags == MAP_BLACKWHITE)
+    {
+        for (; layeri != mLayers.end(); ++layeri)
+        {
+            if ((*layeri)->isFringeLayer())
+            {
+                (*layeri)->setSpecialLayer(mSpecialLayer);
+                (*layeri)->setTempLayer(mTempLayer);
+                (*layeri)->draw(graphics,
+                                startX, startY, endX, endY,
+                                scrollX, scrollY,
+                                mActors, mDebugFlags);
+                break;
+            }
+        }
+    }
+    else
+    {
+        for (; layeri != mLayers.end() && !overFringe; ++layeri)
+        {
+            if ((*layeri)->isFringeLayer())
+            {
+                (*layeri)->setSpecialLayer(mSpecialLayer);
+                (*layeri)->setTempLayer(mTempLayer);
+                if (mDebugFlags == MAP_SPECIAL2)
+                    overFringe = true;
+            }
+
+            (*layeri)->draw(graphics,
+                            startX, startY, endX, endY,
+                            scrollX, scrollY,
+                            mActors, mDebugFlags);
+        }
+    }
+
+    // Dont draw if gui opacity == 1
+    if (mOpacity != 1.0f)
+    {
+        // Draws beings with a lower opacity to make them visible
+        // even when covered by a wall or some other elements...
+        Actors::const_iterator ai = mActors.begin();
+        while (ai != mActors.end())
+        {
+            if (Actor *actor = *ai)
+            {
+                if (!mOpenGL && (actor->getTileX() < startX
+                    || actor->getTileX() > endX || actor->getTileY() < startY
+                    || actor->getTileY() > 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);
+}
+
+void Map::drawCollision(Graphics *graphics, int scrollX, int scrollY,
+                        int debugFlags)
+{
+    int endPixelY = graphics->getHeight() + scrollY + mTileHeight - 1;
+    int startX = scrollX / mTileWidth;
+    int startY = scrollY / mTileHeight;
+    int endX = (graphics->getWidth() + 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(gcn::Color(0, 0, 0, 64));
+        graphics->drawNet(
+            startX * mTileWidth - scrollX,
+            startY * mTileHeight - scrollY,
+            endX * mTileWidth - scrollX,
+            endY * mTileHeight - scrollY,
+            32, 32);
+    }
+
+    for (int y = startY; y < endY; y++)
+    {
+        for (int x = startX; x < endX; x++)
+        {
+            int width = 0;
+            int x0 = x;
+
+            if (!getWalk(x, y, BLOCKMASK_WALL))
+            {
+                width = 32;
+                for (int x2 = x + 1; x < endX; x2 ++)
+                {
+                    if (getWalk(x2, y, BLOCKMASK_WALL))
+                        break;
+                    width += 32;
+                    x ++;
+                }
+            }
+
+            if (width && userPalette)
+            {
+                graphics->setColor(userPalette->getColorWithAlpha(
+                    UserPalette::COLLISION_HIGHLIGHT));
+
+                graphics->fillRectangle(gcn::Rectangle(
+                    x0 * mTileWidth - scrollX,
+                    y * mTileHeight - scrollY,
+                    width, 32));
+            }
+        }
+    }
+}
+
+void Map::updateAmbientLayers(float scrollX, float scrollY)
+{
+    static int lastTick = tick_time; // static = only initialized at first call
+
+    if (mLastScrollX == 0.0f && mLastScrollY == 0.0f)
+    {
+        // First call - initialisation
+        mLastScrollX = scrollX;
+        mLastScrollY = scrollY;
+    }
+
+    // Update Overlays
+    float dx = scrollX - mLastScrollX;
+    float dy = scrollY - mLastScrollY;
+    int timePassed = get_elapsed_time(lastTick);
+
+    std::list<AmbientLayer*>::iterator i;
+    for (i = mBackgrounds.begin(); i != mBackgrounds.end(); i++)
+        (*i)->update(timePassed, dx, dy);
+
+    for (i = mForegrounds.begin(); i != mForegrounds.end(); i++)
+        (*i)->update(timePassed, dx, dy);
+
+    mLastScrollX = scrollX;
+    mLastScrollY = scrollY;
+    lastTick = tick_time;
+}
+
+void Map::drawAmbientLayers(Graphics *graphics, LayerType type,
+                            int detail)
+{
+    // Detail 0 = no ambient effects except background image
+    if (detail <= 0 && type != BACKGROUND_LAYERS)
+        return;
+
+    // find out which layer list to draw
+    std::list<AmbientLayer*> *layers;
+    switch (type)
+    {
+        case FOREGROUND_LAYERS:
+            layers = &mForegrounds;
+            break;
+        case BACKGROUND_LAYERS:
+            layers = &mBackgrounds;
+            break;
+        default:
+            // New type of ambient layers added here without adding it
+            // to Map::drawAmbientLayers.
+            assert(false);
+            break;
+    }
+
+    // Draw overlays
+    for (std::list<AmbientLayer*>::iterator i = layers->begin();
+         i != layers->end(); i++)
+    {
+        (*i)->draw(graphics, graphics->getWidth(), graphics->getHeight());
+
+        // Detail 1: only one overlay, higher: all overlays
+        if (detail == 1)
+            break;
+    }
+}
+
+Tileset *Map::getTilesetWithGid(int gid) const
+{
+    Tileset *s = NULL;
+    for (Tilesets::const_iterator it = mTilesets.begin(),
+         it_end = mTilesets.end(); it < it_end && (*it)->getFirstGid() <= gid;
+         it++)
+    {
+        s = *it;
+    }
+
+    return s;
+}
+
+void Map::blockTile(int x, int y, BlockType type)
+{
+    if (type == BLOCKTYPE_NONE || !contains(x, y))
+        return;
+
+    const int tileNum = x + y * mWidth;
+
+    if ((++mOccupation[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;
+            default:
+                // Do nothing.
+                break;
+        }
+    }
+}
+
+bool Map::getWalk(int x, int y, unsigned char walkmask) const
+{
+    // You can't walk outside of the map
+    if (!contains(x, y))
+        return false;
+
+    // Check if the tile is walkable
+    return !(mMetaTiles[x + y * mWidth].blockmask & walkmask);
+}
+
+bool Map::occupied(int x, int y) const
+{
+    const ActorSprites &actors = actorSpriteManager->getAll();
+    ActorSpritesConstIterator it, it_end;
+    for (it = actors.begin(), it_end = actors.end(); it != it_end; it++)
+    {
+        const ActorSprite *actor = *it;
+
+//+++        if (actor->getTileX() == x && actor->getTileY() == y
+//            && being->getSubType() != 45)
+        if (actor->getTileX() == x && actor->getTileY() == y &&
+            actor->getType() != ActorSprite::FLOOR_ITEM)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool Map::contains(int x, int y) const
+{
+    return x >= 0 && y >= 0 && x < mWidth && y < mHeight;
+}
+
+MetaTile *Map::getMetaTile(int x, int y) const
+{
+    return &mMetaTiles[x + y * mWidth];
+}
+
+Actors::iterator Map::addActor(Actor *actor)
+{
+    mActors.push_front(actor);
+//    mSpritesUpdated = true;
+    return mActors.begin();
+}
+
+void Map::removeActor(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
+{
+    std::string fileName = getProperty("_filename");
+    int lastSlash = static_cast<int>(fileName.rfind("/")) + 1;
+    int lastDot = static_cast<int>(fileName.rfind("."));
+
+    return fileName.substr(lastSlash, lastDot - lastSlash);
+}
+
+Position Map::checkNodeOffsets(int radius, unsigned char walkMask,
+                               const Position &position) const
+{
+    // Pre-computing character's position in tiles
+    const int tx = position.x / 32;
+    const int ty = position.y / 32;
+
+    // Pre-computing character's position offsets.
+    int fx = position.x % 32;
+    int fy = position.y % 32;
+
+    // Compute the being radius:
+    // FIXME: Hande beings with more than 1/2 tile radius by not letting them
+    // go or spawn in too narrow places. The server will have to be aware
+    // of being's radius value (in tiles) to handle this gracefully.
+    if (radius > 32 / 2)
+        radius = 32 / 2;
+    // set a default value if no value returned.
+    if (radius < 1)
+        radius = 32 / 3;
+
+    // We check diagonal first as they are more restrictive.
+    // Top-left border check
+    if (!getWalk(tx - 1, ty - 1, walkMask)
+        && fy < radius && fx < radius)
+    {
+        fx = radius;
+        fy = radius;
+    }
+    // Top-right border check
+    if (!getWalk(tx + 1, ty - 1, walkMask)
+        && (fy < radius) && fx > (32 - radius))
+    {
+        fx = 32 - radius;
+        fy = radius;
+    }
+    // Bottom-left border check
+    if (!getWalk(tx - 1, ty + 1, walkMask)
+        && fy > (32 - radius) && fx < radius)
+    {
+        fx = radius;
+        fy = 32 - radius;
+    }
+    // Bottom-right border check
+    if (!getWalk(tx + 1, ty + 1, walkMask)
+        && fy > (32 - radius) && fx > (32 - radius))
+    {
+        fx = 32 - radius;
+        fy = fx;
+    }
+
+    // Fix coordinates so that the player does not seem to dig into walls.
+    if (fx > (32 - radius) && !getWalk(tx + 1, ty, walkMask))
+        fx = 32 - radius;
+    else if (fx < radius && !getWalk(tx - 1, ty, walkMask))
+        fx = radius;
+    else if (fy > (32 - radius) && !getWalk(tx, ty + 1, walkMask))
+        fy = 32 - radius;
+    else if (fy < radius && !getWalk(tx, ty - 1, walkMask))
+        fy = radius;
+
+    return Position(tx * 32 + fx, ty * 32 + fy);
+}
+
+Path Map::findPixelPath(int startPixelX, int startPixelY, int endPixelX,
+                        int endPixelY,
+                        int radius, unsigned char walkMask, int maxCost)
+{
+    Path myPath = findPath(startPixelX / 32, startPixelY / 32,
+                           endPixelX / 32, endPixelY / 32, walkMask, maxCost);
+
+    // Don't compute empty coordinates.
+    if (myPath.empty())
+        return myPath;
+
+    // Find the starting offset
+    float startOffsetX = static_cast<float>(startPixelX % 32);
+    float startOffsetY = static_cast<float>(startPixelY % 32);
+
+    // Find the ending offset
+    float endOffsetX = static_cast<float>(endPixelX % 32);
+    float endOffsetY = static_cast<float>(endPixelY % 32);
+
+    // Find the distance, and divide it by the number of steps
+    int changeX = (int)((endOffsetX - startOffsetX)
+                  / static_cast<float>(myPath.size()));
+    int changeY = (int)((endOffsetY - startOffsetY)
+                  / static_cast<float>(myPath.size()));
+
+    // Convert the map path to pixels over tiles
+    // And add interpolation between the starting and ending offsets
+    Path::iterator it = myPath.begin();
+    int i = 0;
+    while (it != myPath.end())
+    {
+        // A position that is valid on the start and end tile is not
+        // necessarily valid on all the tiles in between, so check the offsets.
+        *it = checkNodeOffsets(radius, walkMask,
+            it->x * 32 + startOffsetX + static_cast<float>(changeX * i),
+            it->y * 32 + startOffsetY + static_cast<float>(changeY * i));
+        i++;
+        it++;
+    }
+
+    // Remove the last path node, as it's more clever to go to the destination.
+    // It also permit to avoid zigzag at the end of the path,
+    // especially with mouse.
+    Position destination = checkNodeOffsets(radius, walkMask,
+                                            endPixelX, endPixelY);
+    myPath.pop_back();
+    myPath.push_back(destination);
+
+    return myPath;
+}
+
+Path Map::findPath(int startX, int startY, int destX, int destY,
+                   unsigned char walkmask, int maxCost)
+{
+    static int const basicCost = 100;
+
+    // Path to be built up (empty by default)
+    Path path;
+
+    // Declare open list, a list with open tiles sorted on F cost
+    std::priority_queue<Location> openList;
+
+    // Return when destination not walkable
+    if (!getWalk(destX, destY, walkmask))
+        return path;
+
+    // Reset starting tile's G cost to 0
+    MetaTile *startTile = getMetaTile(startX, startY);
+    startTile->Gcost = 0;
+
+    // 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.
+        Location curr = openList.top();
+        openList.pop();
+
+        // 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 (curr.tile->whichList == mOnClosedList)
+            continue;
+
+        // Put the current tile on the closed list
+        curr.tile->whichList = mOnClosedList;
+
+        // Check the adjacent tiles
+        for (int dy = -1; dy <= 1; dy++)
+        {
+            for (int dx = -1; dx <= 1; dx++)
+            {
+                // Calculate location of tile to check
+                const int x = curr.x + dx;
+                const int y = curr.y + dy;
+
+                // 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) || !contains(x, y))
+                    continue;
+
+                MetaTile *newTile = getMetaTile(x, y);
+
+                // Skip if the tile is on the closed list or is not walkable
+                // unless its the destination tile
+                if (!newTile || 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)
+                {
+                    MetaTile *t1 = getMetaTile(curr.x, curr.y + dy);
+                    MetaTile *t2 = getMetaTile(curr.x + dx, curr.y);
+
+                    if (!t1 || !t2 || ((t1->blockmask | t2->blockmask)
+                        & BLOCKMASK_WALL))
+                    {
+                        continue;
+                    }
+                }
+
+                // Calculate G cost for this route, ~sqrt(2) for moving diagonal
+                int Gcost = curr.tile->Gcost +
+                    (dx == 0 || dy == 0 ? basicCost : basicCost * 362 / 256);
+
+                /* 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. */
+                    int dx = std::abs(x - destX), dy = std::abs(y - destY);
+                    newTile->Hcost = std::abs(dx - dy) * basicCost +
+                        std::min(dx, dy) * (basicCost * 362 / 256);
+
+                    // 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.
+    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
+            MetaTile *tile = getMetaTile(pathX, pathY);
+            pathX = tile->parentX;
+            pathY = tile->parentY;
+        }
+    }
+
+    return path;
+}
+
+void Map::addParticleEffect(const std::string &effectFile,
+                            int x, int y, int w, int h)
+{
+    ParticleEffectData newEffect;
+    newEffect.file = effectFile;
+    newEffect.x = x;
+    newEffect.y = y;
+    newEffect.w = w;
+    newEffect.h = h;
+    particleEffects.push_back(newEffect);
+}
+
+void Map::initializeParticleEffects(Particle *particleEngine)
+{
+    if (!particleEngine)
+        return;
+
+    Particle *p;
+
+    if (config.getBoolValue("particleeffects"))
+    {
+        for (std::list<ParticleEffectData>::iterator
+             i = particleEffects.begin();
+             i != particleEffects.end(); i++)
+        {
+            p = particleEngine->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;
+    }
+    std::string mapFileName = getUserMapDirectory() + "/extralayer.txt";
+    logger->log("try load 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);
+        char line[201];
+        std::string buf;
+        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;
+                std::vector<int> tokens;
+                ss >> comment;
+                while (ss >> buf)
+                    comment += " " + buf;
+
+                int type = atoi(type1.c_str());
+/*
+                MapItem *item = new MapItem(atoi(type.c_str()), comment);
+                int x1 = atoi(x.c_str());
+                int y1 = atoi(y.c_str());
+                mSpecialLayer->setTile(x1, y1, item);
+*/
+                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()
+{
+    if (!mSpecialLayer)
+    {
+        logger->log1("No special layer");
+        return;
+    }
+    std::string mapFileName = getUserMapDirectory() + "/extralayer.txt";
+    logger->log("try save 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;
+    }
+
+    int width = mSpecialLayer->mWidth;
+    int height = mSpecialLayer->mHeight;
+
+    for (int x = 0; x < width; x ++)
+    {
+        for (int y = 0; y < height; y ++)
+        {
+            MapItem *item = mSpecialLayer->getTile(x, y);
+            if (item && item->mType != MapItem::EMPTY
+                && item->mType != MapItem::HOME)
+            {
+                mapFile << x << " " << y << " " << (int)item->mType
+                        << " " << item->mComment << std::endl;
+            }
+        }
+    }
+    mapFile.close();
+}
+
+std::string Map::getUserMapDirectory() const
+{
+    return Client::getServerConfigDirectory() + "/" + getProperty("_filename");
+}
+
+void Map::addPortal(const std::string &name, int type,
+                    int x, int y, int dx, int dy)
+{
+    addPortalTile(name, type, (x / 32) + (dx / 64), (y / 32) + (dy / 64));
+}
+
+void Map::addPortalTile(const std::string &name, int type, int x, int y)
+{
+    MapItem *item = new MapItem(type, name, x, y);
+    if (mSpecialLayer)
+        mSpecialLayer->setTile(x, y, item);
+
+    item = new MapItem(type, name, x, y);
+    mMapPortals.push_back(item);
+}
+
+void Map::updatePortalTile(const std::string &name, int type,
+                           int x, int y, 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(int x, int y)
+{
+    std::list<MapItem*>::iterator it;
+    std::list<MapItem*>::iterator it_end;
+
+    for (it = mMapPortals.begin(), it_end = mMapPortals.end();
+         it != it_end; it++)
+    {
+        MapItem *item = *it;
+        if (item->mX == x && item->mY == y)
+            return item;
+    }
+    return 0;
+}
+
+TileAnimation *Map::getAnimationForGid(int gid) const
+{
+    std::map<int, TileAnimation*>::const_iterator
+        i = mTileAnimations.find(gid);
+    return (i == mTileAnimations.end()) ? NULL : i->second;
+}
+
+void Map::setPvpMode(int mode)
+{
+    int oldMode = mPvp;
+
+    if (!mode)
+        mPvp = 0;
+    else
+        mPvp |= mode;
+
+    if (mPvp != oldMode && player_node)
+    {
+        switch (mPvp)
+        {
+            case 0:
+                player_node->setSpeech("pvp off, gvg off", SPEECH_TIME);
+                break;
+            case 1:
+                player_node->setSpeech("pvp on", SPEECH_TIME);
+                break;
+            case 2:
+                player_node->setSpeech("gvg on", SPEECH_TIME);
+                break;
+            case 3:
+                player_node->setSpeech("pvp on, gvg on", SPEECH_TIME);
+                break;
+            default:
+                player_node->setSpeech("unknown pvp", SPEECH_TIME);
+                break;
+        }
+    }
+}
+
+SpecialLayer::SpecialLayer(int width, int height, bool drawSprites):
+    mWidth(width), mHeight(height)
+{
+    const int size = mWidth * mHeight;
+    mTiles = new MapItem*[size];
+    std::fill_n(mTiles, size, (MapItem*) 0);
+    mDrawSprites = drawSprites;
+}
+
+SpecialLayer::~SpecialLayer()
+{
+    for (int f = 0; f < mWidth * mHeight; f ++)
+    {
+        delete mTiles[f];
+        mTiles[f] = 0;
+    }
+    delete[] mTiles;
+}
+
+MapItem* SpecialLayer::getTile(int x, int y) const
+{
+    if (x < 0 || x >= mWidth ||
+        y < 0 || y >= mHeight)
+    {
+        return 0;
+    }
+    return mTiles[x + y * mWidth];
+}
+
+void SpecialLayer::setTile(int x, int y, MapItem *item)
+{
+    if (x < 0 || x >= mWidth ||
+        y < 0 || y >= mHeight)
+    {
+        return;
+    }
+
+    int idx = x + y * mWidth;
+    delete mTiles[idx];
+    if (item)
+        item->setPos(x, y);
+    mTiles[idx] = item;
+}
+
+void SpecialLayer::setTile(int x, int y, int type)
+{
+    if (x < 0 || x >= mWidth ||
+        y < 0 || y >= mHeight)
+    {
+        return;
+    }
+
+    int idx = x + y * mWidth;
+    if (mTiles[idx])
+    {
+        mTiles[idx]->setType(type);
+    }
+    else
+    {
+        delete mTiles[idx];
+        mTiles[idx] = new MapItem(type);
+    }
+    mTiles[idx]->setPos(x, y);
+}
+
+void SpecialLayer::addRoad(Path road)
+{
+    for (Path::const_iterator i = road.begin(), i_end = road.end();
+         i != i_end; ++i)
+    {
+        Position pos = (*i);
+        MapItem *item = getTile(pos.x, pos.y);
+        if (!item)
+        {
+            item = new MapItem(MapItem::ROAD);
+            setTile(pos.x, pos.y, item);
+        }
+        else
+        {
+            item->setType(MapItem::ROAD);
+        }
+    }
+}
+
+void SpecialLayer::clean()
+{
+    for (int f = 0; f < mWidth * mHeight; f ++)
+    {
+        MapItem *item = mTiles[f];
+        if (item)
+            item->setType(MapItem::EMPTY);
+    }
+}
+
+void SpecialLayer::draw(Graphics *graphics, int startX, int startY,
+                        int endX, int endY, int scrollX, int scrollY)
+{
+    if (startX < 0)
+        startX = 0;
+    if (startY < 0)
+        startY = 0;
+    if (endX > mWidth)
+        endX = mWidth;
+    if (endY > mHeight)
+        endY = mHeight;
+
+//    MapSprites::const_iterator si = sprites.begin();
+
+    for (int y = startY; y < endY; y++)
+    {
+        for (int x = startX; x < endX; x++)
+            itemDraw(graphics, x, y, scrollX, scrollY);
+    }
+}
+
+void SpecialLayer::itemDraw(Graphics *graphics, int x, int y,
+                            int scrollX, int scrollY)
+{
+    MapItem *item = getTile(x, y);
+    if (item)
+    {
+        const int px = x * 32 - scrollX;
+        const int py = y * 32 - scrollY;
+        item->draw(graphics, px, py, 32, 32);
+    }
+}
+
+
+MapItem::MapItem():
+    mImage(0), mComment(""), mName(""), mX(-1), mY(-1)
+{
+    setType(EMPTY);
+}
+
+MapItem::MapItem(int type):
+    mImage(0), mComment(""), mName(""), mX(-1), mY(-1)
+{
+    setType(type);
+}
+
+MapItem::MapItem(int type, std::string comment):
+    mImage(0), mComment(comment), mName(""), mX(-1), mY(-1)
+{
+    setType(type);
+}
+
+MapItem::MapItem(int type, std::string comment, int x, int y):
+    mImage(0), mComment(comment), mName(""), mX(x), mY(y)
+{
+    setType(type);
+}
+
+MapItem::~MapItem()
+{
+    if (mImage)
+        mImage->decRef();
+}
+
+void MapItem::setType(int type)
+{
+    std::string name = "";
+    mType = type;
+    if (mImage)
+        mImage->decRef();
+
+    switch (type)
+    {
+        case ARROW_UP:
+            name = "graphics/sprites/arrow_up.gif";
+            break;
+        case ARROW_DOWN:
+            name = "graphics/sprites/arrow_down.gif";
+            break;
+        case ARROW_LEFT:
+            name = "graphics/sprites/arrow_left.gif";
+            break;
+        case ARROW_RIGHT:
+            name = "graphics/sprites/arrow_right.gif";
+            break;
+        default:
+            break;
+    }
+
+    if (name != "")
+    {
+        ResourceManager *resman = ResourceManager::getInstance();
+        mImage = resman->getImage(name);
+    }
+    else
+    {
+        mImage = 0;
+    }
+}
+
+void MapItem::setPos(int x, int y)
+{
+    mX = x;
+    mY = y;
+}
+
+void MapItem::draw(Graphics *graphics, int x, int y, int dx, int dy)
+{
+    if (mImage)
+        graphics->drawImage(mImage, x, y);
+
+    switch(mType)
+    {
+        case ROAD:
+        case CROSS:
+            graphics->setColor(userPalette->getColorWithAlpha(
+                               UserPalette::ROAD_POINT));
+            graphics->fillRectangle(gcn::Rectangle(x + dx / 3, y + dy / 3,
+                                    dx / 3, dy / 3));
+            break;
+        case HOME:
+        {
+            graphics->setColor(userPalette->getColorWithAlpha(
+                               UserPalette::HOME_PLACE));
+            graphics->fillRectangle(gcn::Rectangle(
+                                                   x, y,
+                                                   dx, dy));
+            graphics->setColor(userPalette->getColorWithAlpha(
+                               UserPalette::HOME_PLACE_BORDER));
+            graphics->drawRectangle(gcn::Rectangle(
+                                                   x, y,
+                                                   dx, dy));
+            break;
+        }
+        default:
+            break;
+    }
+    if (!mName.empty() && mType != PORTAL && mType != EMPTY)
+    {
+        gcn::Font *font = gui->getFont();
+        if (font)
+        {
+            graphics->setColor(userPalette->getColor(UserPalette::BEING));
+            font->drawString(graphics, mName, x, y);
+        }
+    }
+}
+