/*

 *  The Mana World

 *  Copyright (C) 2004  The Mana World Development Team

 *

 *  This file is part of The Mana World.

 *

 *  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, write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include "localplayer.h"

#include "configuration.h"

#include "equipment.h"

#include "flooritem.h"

#include "game.h"

#include "graphics.h"

#include "inventory.h"

#include "item.h"

#include "log.h"

#include "map.h"

#include "monster.h"

#include "particle.h"

#include "simpleanimation.h"

#include "sound.h"

#include "statuseffect.h"

#include "text.h"

#include "gui/gui.h"

#include "gui/ministatus.h"

#include "gui/palette.h"

#include "gui/skilldialog.h"

#include "gui/statuswindow.h"

#include "gui/storagewindow.h"

#include "gui/widgets/chattab.h"

#include "net/inventoryhandler.h"

#include "net/net.h"

#include "net/partyhandler.h"

#include "net/playerhandler.h"

#include "net/specialhandler.h"

#include "net/tradehandler.h"

#include "effectmanager.h"

#ifdef TMWSERV_SUPPORT

#include "guild.h"

//#include "net/tmwserv/gameserver/player.h"

#include "net/tmwserv/chatserver/guild.h"

#endif

#include "resources/animation.h"

#include "resources/imageset.h"

#include "resources/itemdb.h"

#include "resources/iteminfo.h"

#include "resources/resourcemanager.h"

#include "utils/gettext.h"

#include "utils/stringutils.h"

#include <cassert>

#ifdef TMWSERV_SUPPORT

// This is the minimal delay between to permitted

// setDestination() calls using the keyboard.

// TODO: This can fine tuned later on when running is added...

const short walkingKeyboardDelay = 1000;

#endif

LocalPlayer *player_node = NULL;

LocalPlayer::LocalPlayer(int id, int job, Map *map):

    Player(id, job, map),

#ifdef EATHENA_SUPPORT

    mAttackRange(0),

#endif

    mEquipment(new Equipment),

    mInStorage(false),

    mTargetTime(-1),

    mLastTarget(-1),

    mCharacterPoints(0),

    mCorrectionPoints(0),

    mLevel(1),

    mExp(0), mExpNeeded(0),

    mMp(0), mMaxMp(0),

    mMoney(0),

    mTotalWeight(1), mMaxWeight(1),

    mHp(1), mMaxHp(1),

    mSkillPoints(0),

    mTarget(NULL), mPickUpTarget(NULL),

    mTrading(false), mGoingToTarget(false), mKeepAttacking(false),

    mLastAction(-1),

    mWalkingDir(0),

    mPathSetByMouse(false),

    mDestX(0), mDestY(0),

    mInventory(new Inventory(INVENTORY_SIZE)),

#ifdef TMWSERV_SUPPORT

    mLocalWalkTime(-1),

#endif

    mStorage(new Inventory(STORAGE_SIZE)),

    mMessageTime(0)

{

    // Variable to keep the local player from doing certain actions before a map

    // is initialized. e.g. drawing a player's name using the TextManager, since

    // it appears to be dependant upon map coordinates for updating drawing.

    mMapInitialized = false;

    mUpdateName = true;

    mTextColor = &guiPalette->getColor(Palette::PLAYER);

    mNameColor = &guiPalette->getColor(Palette::SELF);

    initTargetCursor();

    config.addListener("showownname", this);

    setShowName(config.getValue("showownname", 1));

}

LocalPlayer::~LocalPlayer()

{

    delete mInventory;

#ifdef EATHENA_SUPPORT

    delete mStorage;

#endif

    config.removeListener("showownname", this);

    for (int i = Being::TC_SMALL; i < Being::NUM_TC; i++)

    {

        delete mTargetCursor[0][i];

        delete mTargetCursor[1][i];

        mTargetCursorImages[0][i]->decRef();

        mTargetCursorImages[1][i]->decRef();

    }

}

void LocalPlayer::logic()

{

    // Actions are allowed once per second

    if (get_elapsed_time(mLastAction) >= 1000)

        mLastAction = -1;

    // Show XP messages

    if (!mMessages.empty())

    {

        if (mMessageTime == 0)

        {

            //const Vector &pos = getPosition();

            MessagePair info = mMessages.front();

            particleEngine->addTextRiseFadeOutEffect(

                    info.first,

                    /*(int) pos.x,

                    (int) pos.y - 48,*/

                    getPixelX(),

                    getPixelY() - 48,

                    &guiPalette->getColor(info.second),

                    gui->getInfoParticleFont(), true);

            mMessages.pop_front();

            mMessageTime = 30;

        }

        mMessageTime--;

    }

    if ((mSpecialRechargeUpdateNeeded%11) == 0)

    {

        mSpecialRechargeUpdateNeeded = 0;

        for (std::map<int, Special>::iterator i = mSpecials.begin();

             i != mSpecials.end();

             i++)

        {

            i->second.currentMana += i->second.recharge;

            if (i->second.currentMana > i->second.neededMana)

            {

                i->second.currentMana = i->second.neededMana;

            }

        }

    }

    mSpecialRechargeUpdateNeeded++;

    // Targeting allowed 4 times a second

    if (get_elapsed_time(mLastTarget) >= 250)

        mLastTarget = -1;

    // Remove target if its been on a being for more than a minute

    if (get_elapsed_time(mTargetTime) >= 60000)

    {

        mTargetTime = -1;

        setTarget(NULL);

        mLastTarget = -1;

    }

    if (mTarget)

    {

        if (mTarget->getType() == Being::NPC)

        {

            // NPCs are always in range

            mTarget->setTargetAnimation(

                mTargetCursor[0][mTarget->getTargetCursorSize()]);

        }

        else

        {

#ifdef TMWSERV_SUPPORT

            // Find whether target is in range

            const int rangeX = abs(mTarget->getPosition().x - getPosition().x);

            const int rangeY = abs(mTarget->getPosition().y - getPosition().y);

#else

            // Find whether target is in range

            const int rangeX = abs(mTarget->getTileX() - getTileX());

            const int rangeY = abs(mTarget->getTileY() - getTileY());

#endif

            const int attackRange = getAttackRange();

            const int inRange = rangeX > attackRange || rangeY > attackRange

                                                                    ? 1 : 0;

            mTarget->setTargetAnimation(

                mTargetCursor[inRange][mTarget->getTargetCursorSize()]);

            if (mTarget->mAction == DEAD)

                stopAttack();

            if (mKeepAttacking && mTarget)

                attack(mTarget, true);

        }

    }

    Player::logic();

}

void LocalPlayer::setAction(Action action, int attackType)

{

    if (action == DEAD)

    {

        mLastTarget = -1;

        setTarget(NULL);

    }

    Player::setAction(action, attackType);

}

void LocalPlayer::setGM(bool gm)

{

    mIsGM = gm;

}

void LocalPlayer::setGMLevel(int level)

{

    mGMLevel = level;

    if (level > 0)

        setGM(true);

}

void LocalPlayer::nextStep(unsigned char dir = 0)

{

#ifdef EATHENA_SUPPORT

    // TODO: Fix picking up when reaching target (this method is obsolete)

    // TODO: Fix holding walking button to keep walking smoothly

    if (mPath.empty())

    {

        if (mPickUpTarget)

            pickUp(mPickUpTarget);

        if (mWalkingDir)

            startWalking(mWalkingDir);

    }

    // TODO: Fix automatically walking within range of target, when wanted

    if (mGoingToTarget && mTarget && withinAttackRange(mTarget))

    {

        mAction = Being::STAND;

        attack(mTarget, true);

        mGoingToTarget = false;

        mPath.clear();

        return;

    }

    else if (mGoingToTarget && !mTarget)

    {

        mGoingToTarget = false;

        mPath.clear();

    }

    Player::nextStep();

#else // TMWSERV_SUPPORT

        if (!mMap || !dir)

        return;

    const Vector &pos = getPosition();

    // Compute where the next step will be set.

    int dx = 0, dy = 0;

    if (dir & UP)

        dy--;

    if (dir & DOWN)

        dy++;

    if (dir & LEFT)

        dx--;

    if (dir & RIGHT)

        dx++;

    // Prevent skipping corners over colliding tiles

    if (dx && !mMap->getWalk(((int) pos.x + dx) / 32,

                             (int) pos.y / 32, getWalkMask()))

        dx = 16 - (int) pos.x % 32;

    if (dy && !mMap->getWalk((int) pos.x / 32,

                             ((int) pos.y + dy) / 32, getWalkMask()))

        dy = 16 - (int) pos.y % 32;

    // Choose a straight direction when diagonal target is blocked

    if (dx && dy && !mMap->getWalk((pos.x + dx) / 32,

                                   (pos.y + dy) / 32, getWalkMask()))

        dx = 16 - (int) pos.x % 32;

    int dScaler; // Distance to walk

    // Checks our path up to 1 tiles, if a blocking tile is found

    // We go to the last good tile, and break out of the loop

    for (dScaler = 1; dScaler <= 32; dScaler++)

    {

        if ( (dx || dy) &&

             !mMap->getWalk( ((int) pos.x + (dx * dScaler)) / 32,

                             ((int) pos.y + (dy * dScaler)) / 32, getWalkMask()) )

        {

            dScaler--;

            break;

        }

    }

    if (dScaler > 0)

    {

        //effectManager->trigger(15, (int) pos.x + (dx * dScaler), (int) pos.y + (dy * dScaler));

        setDestination((int) pos.x + (dx * dScaler), (int) pos.y + (dy * dScaler));

    }

    else if (dir)

    {

        // If the being can't move, just change direction

        Net::getPlayerHandler()->setDirection(dir);

        setDirection(dir);

    }

#endif

}

#ifdef TMWSERV_SUPPORT

bool LocalPlayer::checkInviteRights(const std::string &guildName)

{

    Guild *guild = getGuild(guildName);

    if (guild)

    {

        return guild->getInviteRights();

    }

    return false;

}

void LocalPlayer::inviteToGuild(Being *being)

{

    // TODO: Allow user to choose which guild to invite being to

    // For now, just invite to the first guild you have permissions to invite with

    std::map<int, Guild*>::iterator itr = mGuilds.begin();

    std::map<int, Guild*>::iterator itr_end = mGuilds.end();

    for (; itr != itr_end; ++itr)

    {

        if (checkInviteRights(itr->second->getName()))

        {

            Net::ChatServer::Guild::invitePlayer(being->getName(), itr->second->getId());

            return;

        }

    }

}

void LocalPlayer::clearInventory()

{

    mEquipment->clear();

    mInventory->clear();

}

void LocalPlayer::setInvItem(int index, int id, int amount)

{

    bool equipment = false;

    int itemType = ItemDB::get(id).getType();

    if (itemType != ITEM_UNUSABLE && itemType != ITEM_USABLE)

        equipment = true;

    mInventory->setItem(index, id, amount, equipment);

}

#endif

void LocalPlayer::pickUp(FloorItem *item)

{

    int dx = item->getX() - (int) getPosition().x / 32;

    int dy = item->getY() - (int) getPosition().y / 32;

    if (dx * dx + dy * dy < 4)

    {

        Net::getPlayerHandler()->pickUp(item);

        mPickUpTarget = NULL;

    }

    else

    {

#ifdef TMWSERV_SUPPORT

        setDestination(item->getX() * 32 + 16, item->getY() * 32 + 16);

#else

        setDestination(item->getX(), item->getY());

#endif

        mPickUpTarget = item;

#ifdef EATHENA_SUPPORT

        stopAttack();

#endif

    }

}

Being *LocalPlayer::getTarget() const

{

    return mTarget;

}

void LocalPlayer::setTarget(Being *target)

{

    if (mLastTarget != -1 || target == this)

        return;

    mLastTarget = tick_time;

    if (target == mTarget)

        return;

    if (target || mAction == ATTACK)

    {

        mTargetTime = tick_time;

    }

    else

    {

        mKeepAttacking = false;

        mTargetTime = -1;

    }

    if (mTarget)

        mTarget->untarget();

    if (mTarget && mTarget->getType() == Being::MONSTER)

        static_cast<Monster *>(mTarget)->setShowName(false);

    mTarget = target;

    if (target && target->getType() == Being::MONSTER)

        static_cast<Monster *>(target)->setShowName(true);

}

#ifdef TMWSERV_SUPPORT

void LocalPlayer::setDestination(int x, int y)

#else

void LocalPlayer::setDestination(Uint16 x, Uint16 y)

#endif

{

#ifdef TMWSERV_SUPPORT

    // Check the walkability of the destination

    // If the destination is a wall, don't go there!

    if (!mMap->getWalk(x / 32, y / 32))

        return;

    // check if we're finding a path to the seeked destination

    // If the path is empty... and isn't on the same tile,

    // then, it's an unvalid one.

    Vector playerPosition = getPosition();

    if (((int)(playerPosition.x / 32) != x / 32)

      || (((int)playerPosition.y / 32) != y / 32))

    {

        Path evaluatedPath = mMap->findPath(playerPosition.x / 32,

                                        playerPosition.y / 32,

                                        x / 32, y / 32,

                                        getWalkMask());

        if (evaluatedPath.empty())

            return;

    }

    // Fix coordinates so that the player does not seem to dig into walls.

    const int tx = x / 32;

    const int ty = y / 32;

    int fx = x % 32;

    int fy = y % 32;

    if (fx != 16 && !mMap->getWalk(tx + fx / 16 * 2 - 1, ty, getWalkMask()))

        fx = 16;

    if (fy != 16 && !mMap->getWalk(tx, ty + fy / 16 * 2 - 1, getWalkMask()))

        fy = 16;

    if (fx != 16 && fy != 16 && !mMap->getWalk(tx + fx / 16 * 2 - 1,

                                               ty + fy / 16 * 2 - 1,

                                               getWalkMask()))

        fx = 16;

    x = tx * 32 + fx;

    y = ty * 32 + fy;

#endif

    // Only send a new message to the server when destination changes

    if (x != mDestX || y != mDestY)

    {

        mDestX = x;

        mDestY = y;

        Net::getPlayerHandler()->setDestination(x, y, mDirection);

    }

    mPickUpTarget = NULL;

    mKeepAttacking = false;

    Being::setDestination(x, y);

}

void LocalPlayer::setWalkingDir(int dir)

{

    // This function is called by Game::handleInput()

#ifdef TMWSERV_SUPPORT

        // First if player is pressing key for the direction he is already

        // going, do nothing more...

        // Else if he is pressing a key, and its different from what he has

        // been pressing, stop (do not send this stop to the server) and

        // start in the new direction

        if (dir && (dir != getWalkingDir()))

            player_node->stopWalking(false);

        // Else, he is not pressing a key,

        // and the current path hasn't been sent by mouse,

        // then, stop (sending to server).

        else if (!dir)

        {

            if (!mPathSetByMouse)

                player_node->stopWalking(true);

            return;

        }

        // If the delay to send another walk message to the server hasn't expired,

        // don't do anything or we could get disconnected for spamming the server

        if (get_elapsed_time(mLocalWalkTime) < walkingKeyboardDelay)

            return;

#endif

    mWalkingDir = dir;

    // If we're not already walking, start walking.

    if (mAction != WALK && dir)

    {

        startWalking(dir);

    }

#ifdef TMWSERV_SUPPORT

    else if (mAction == WALK)

    {

        nextStep(dir);

    }

#endif

}

void LocalPlayer::startWalking(unsigned char dir)

{

    // This function is called by setWalkingDir(),

    // but also by nextStep() for eAthena...

    // TODO: Evaluate the implementation of this method for tmwserv

    if (!mMap || !dir)

        return;

#ifdef TMWSERV_SUPPORT

    const Vector &pos = getPosition();

#endif

    if (mAction == WALK && !mPath.empty())

    {

        // Just finish the current action, otherwise we get out of sync

#ifdef TMWSERV_SUPPORT

        Being::setDestination(pos.x, pos.y);

#else

        Being::setDestination(getTileX(), getTileY());

#endif

        return;

    }

    int dx = 0, dy = 0;

    if (dir & UP)

        dy--;

    if (dir & DOWN)

        dy++;

    if (dir & LEFT)

        dx--;

    if (dir & RIGHT)

        dx++;

#ifdef EATHENA_SUPPORT

    // Prevent skipping corners over colliding tiles

    if (dx && !mMap->getWalk(getTileX() + dx, getTileY(), getWalkMask()))

        dx = 0;

    if (dy && !mMap->getWalk(getTileX(), getTileY() + dy, getWalkMask()))

        dy = 0;

    // Choose a straight direction when diagonal target is blocked

    if (dx && dy && !mMap->getWalk(getTileX() + dx, getTileY() + dy, getWalkMask()))

        dx = 0;

    // Walk to where the player can actually go

    if ((dx || dy) && mMap->getWalk(getTileX() + dx, getTileY() + dy, getWalkMask()))

    {

        setDestination(getTileX() + dx, getTileY() + dy);

    }

    else if (dir)

    {

        // If the being can't move, just change direction

        Net::getPlayerHandler()->setDirection(dir);

        setDirection(dir);

    }

#else // TMWSERV_SUPPORT

    nextStep(dir);

#endif

}

void LocalPlayer::stopWalking(bool sendToServer)

{

    if (mAction == WALK && mWalkingDir) {

        mWalkingDir = 0;

#ifdef TMWSERV_SUPPORT

        mLocalWalkTime = 0;

#endif

        Being::setDestination(getPosition().x,getPosition().y);

        if (sendToServer)

             Net::getPlayerHandler()->setDestination(getPosition().x,

                                                     getPosition().y);

        setAction(STAND);

    }

    // No path set anymore, so we reset the path by mouse flag

    mPathSetByMouse = false;

    clearPath();

}

void LocalPlayer::toggleSit()

{

    if (mLastAction != -1)

        return;

    mLastAction = tick_time;

    Being::Action newAction;

    switch (mAction)

    {

        case STAND: newAction = SIT; break;

        case SIT: newAction = STAND; break;

        default: return;

    }

    Net::getPlayerHandler()->changeAction(newAction);

}

void LocalPlayer::emote(Uint8 emotion)

{

    if (mLastAction != -1)

        return;

    mLastAction = tick_time;

    Net::getPlayerHandler()->emote(emotion);

}

#ifdef TMWSERV_SUPPORT

/*

void LocalPlayer::attack()

{

    if (mLastAction != -1)

        return;

    // Can only attack when standing still

    if (mAction != STAND && mAction != ATTACK)

        return;

    //Face direction of the target

    if(mTarget){

        unsigned char dir = 0;

        int x = 0, y = 0;

        Vector plaPos = this->getPosition();

        Vector tarPos = mTarget->getPosition();

        x = plaPos.x - tarPos.x;

        y = plaPos.y - tarPos.y;

        if(abs(x) < abs(y)){

            //Check to see if target is above me or below me

            if(y > 0){

               dir = UP;

            } else {

               dir = DOWN;

            }

        } else {

            //check to see if the target is to the left or right of me

            if(x > 0){

               dir = LEFT;

            } else {

               dir = RIGHT;

            }

        }

        setDirection(dir);

    }

    mLastAction = tick_time;

    setAction(ATTACK);

    if (mEquippedWeapon)

    {

        std::string soundFile = mEquippedWeapon->getSound(EQUIP_EVENT_STRIKE);

        if (soundFile != "") sound.playSfx(soundFile);

    }

    else {

        sound.playSfx("sfx/fist-swish.ogg");

    }

    Net::GameServer::Player::attack(getSpriteDirection());

}

*/

void LocalPlayer::useSpecial(int special)

{

    Net::getSpecialHandler()->use(special);

}

void LocalPlayer::setSpecialStatus(int id, int current, int max, int recharge)

{

    logger->log("SpecialUpdate Skill #%d -- (%d/%d) -> %d", id, current, max, recharge);

    mSpecials[id].currentMana = current;

    mSpecials[id].neededMana = max;

    mSpecials[id].recharge = recharge;

}

#endif

void LocalPlayer::attack(Being *target, bool keep)

{

#ifdef TMWSERV_SUPPORT

    if (mLastAction != -1)

        return;

    // Can only attack when standing still

    if (mAction != STAND && mAction != ATTACK)

        return;

#endif

    mKeepAttacking = keep;

    if (!target || target->getType() == Being::NPC)

        return;

    if (mTarget != target || !mTarget)

    {

        mLastTarget = -1;

        setTarget(target);

    }

#ifdef TMWSERV_SUPPORT

    Vector plaPos = this->getPosition();

    Vector tarPos = mTarget->getPosition();

    int dist_x = plaPos.x - tarPos.x;

    int dist_y = plaPos.y - tarPos.y;

#else

    int dist_x = target->getTileX() - getTileX();

    int dist_y = target->getTileY() - getTileY();

    // Must be standing to attack

    if (mAction != STAND)

        return;

#endif

#ifdef TMWSERV_SUPPORT

    if (abs(dist_y) >= abs(dist_x))

    {

        if (dist_y < 0)

            setDirection(DOWN);

        else

            setDirection(UP);

    }

    else

    {

        if (dist_x < 0)

            setDirection(RIGHT);

        else

            setDirection(LEFT);

    }

#else

    if (abs(dist_y) >= abs(dist_x))

    {

        if (dist_y > 0)

            setDirection(DOWN);

        else

            setDirection(UP);

    }

    else

    {

        if (dist_x > 0)

            setDirection(RIGHT);

        else

            setDirection(LEFT);

    }

#endif

#ifdef TMWSERV_SUPPORT

    mLastAction = tick_time;

#else

    mWalkTime = tick_time;

    mTargetTime = tick_time;

#endif

    setAction(ATTACK);

    if (mEquippedWeapon)

    {

        std::string soundFile = mEquippedWeapon->getSound(EQUIP_EVENT_STRIKE);

        if (!soundFile.empty())

            sound.playSfx(soundFile);

    }

    else

    {

        sound.playSfx("sfx/fist-swish.ogg");

    }

    Net::getPlayerHandler()->attack(target->getId());

#ifdef EATHENA_SUPPORT

    if (!keep)

        stopAttack();

#endif

}

void LocalPlayer::stopAttack()

{

    if (mTarget)

    {

        if (mAction == ATTACK)

            setAction(STAND);

        setTarget(NULL);

    }

    mLastTarget = -1;

}

void LocalPlayer::raiseAttribute(size_t attr)

{

    // we assume that the server allows the change. When not we will undo it later.

    mCharacterPoints--;

    IntMap::iterator it = mAttributeBase.find(attr);

    if (it != mAttributeBase.end())

        (*it).second++;

    Net::getPlayerHandler()->increaseAttribute(attr);

}

void LocalPlayer::lowerAttribute(size_t attr)

{

    // we assume that the server allows the change. When not we will undo it later.

    mCorrectionPoints--;

    mCharacterPoints++;

    IntMap::iterator it = mAttributeBase.find(attr);

    if (it != mAttributeBase.end())

        (*it).second--;

    Net::getPlayerHandler()->decreaseAttribute(attr);

}

void LocalPlayer::setAttributeBase(int num, int value)

{

    int old = mAttributeBase[num];

    mAttributeBase[num] = value;

    if (skillDialog)

    {

        if (skillDialog->update(num).empty() || !(value > old))

            return;

        effectManager->trigger(1, this);

    }

    if (statusWindow)

        statusWindow->update(num);

}

void LocalPlayer::setAttributeEffective(int num, int value)

{

    mAttributeEffective[num] = value;

    if (skillDialog)

        skillDialog->update(num);

    if (statusWindow)

        statusWindow->update(num);

}

void LocalPlayer::setCharacterPoints(int n)

{

    mCharacterPoints = n;

    if (statusWindow)

        statusWindow->update(StatusWindow::CHAR_POINTS);

}

void LocalPlayer::setCorrectionPoints(int n)

{

    mCorrectionPoints = n;

    if (statusWindow)

        statusWindow->update(StatusWindow::CHAR_POINTS);

}

void LocalPlayer::setSkillPoints(int points)

{

    mSkillPoints = points;

    if (skillDialog)

        skillDialog->update();

}

void LocalPlayer::setExperience(int skill, int current, int next)

{

    std::pair<int, int> cur = getExperience(skill);

    int diff = current - cur.first;

    cur = std::pair<int, int>(current, next);

    mSkillExp[skill] = cur;

    std::string name;

    if (skillDialog)

        name = skillDialog->update(skill);

    if (mMap && cur.first != -1 && diff > 0 && !name.empty())

    {

        addMessageToQueue(strprintf("%d %s xp", diff, name.c_str()));

    }

}

std::pair<int, int> LocalPlayer::getExperience(int skill)

{

    return mSkillExp[skill];

}

void LocalPlayer::setHp(int value)

{

    mHp = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::HP);

}

void LocalPlayer::setMaxHp(int value)

{

    mMaxHp = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::HP);

}

void LocalPlayer::setLevel(int value)

{

    mLevel = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::LEVEL);

}

void LocalPlayer::setExp(int value)

{

    if (mMap && value > mExp)

    {

        addMessageToQueue(toString(value - mExp) + " xp");

    }

    mExp = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::EXP);

}

void LocalPlayer::setExpNeeded(int value)

{

    mExpNeeded = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::EXP);

}

void LocalPlayer::setMP(int value)

{

    mMp = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::MP);

}

void LocalPlayer::setMaxMP(int value)

{

    mMaxMp = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::MP);

}

void LocalPlayer::setMoney(int value)

{

    mMoney = value;

    if (statusWindow)

        statusWindow->update(StatusWindow::MONEY);

}

void LocalPlayer::pickedUp(const ItemInfo &itemInfo, int amount)

{

    if (!amount)

    {

        if (config.getValue("showpickupchat", 1))

        {

            localChatTab->chatLog(_("Unable to pick up item."), BY_SERVER);

        }

    }

    else

    {

        if (config.getValue("showpickupchat", 1))

        {

            // TRANSLATORS: This sentence may be translated differently

            // for different grammatical numbers (singular, plural, ...)

            localChatTab->chatLog(strprintf(ngettext("You picked up %d "

                    "[@@%d|%s@@].", "You picked up %d [@@%d|%s@@].", amount),

                    amount, itemInfo.getId(), itemInfo.getName().c_str()),

                    BY_SERVER);

        }

        if (mMap && config.getValue("showpickupparticle", 0))

        {

            // Show pickup notification

            addMessageToQueue(itemInfo.getName(), Palette::PICKUP_INFO);

        }

    }

}

int LocalPlayer::getAttackRange()

{

#ifdef TMWSERV_SUPPORT

    Item *weapon = mEquipment->getEquipment(EQUIP_FIGHT1_SLOT);

    if (weapon)

    {

        const ItemInfo info = weapon->getInfo();

        return info.getAttackRange();

    }

    return 48; // unarmed range

#else

    return mAttackRange;

#endif

}

bool LocalPlayer::withinAttackRange(Being *target)

{

#ifdef TMWSERV_SUPPORT

    const Vector &targetPos = target->getPosition();

    const Vector &pos = getPosition();

    const int dx = abs(targetPos.x - pos.x);

    const int dy = abs(targetPos.y - pos.y);

    const int range = getAttackRange();

    return !(dx > range || dy > range);

#else

    int dist_x = abs(target->getTileX() - getTileY());

    int dist_y = abs(target->getTileY() - getTileX());

    if (dist_x > getAttackRange() || dist_y > getAttackRange())

    {

        return false;

    }

    return true;

#endif

}

void LocalPlayer::setGotoTarget(Being *target)

{

    mLastTarget = -1;

#ifdef TMWSERV_SUPPORT

    mTarget = target;

    mGoingToTarget = true;

    const Vector &targetPos = target->getPosition();

    setDestination(targetPos.x, targetPos.y);

#else

    setTarget(target);

    mGoingToTarget = true;

    setDestination(target->getTileX(), target->getTileY());

#endif

}

extern MiniStatusWindow *miniStatusWindow;

void LocalPlayer::handleStatusEffect(StatusEffect *effect, int effectId)

{

    Being::handleStatusEffect(effect, effectId);

    if (effect)

    {

        effect->deliverMessage();

        effect->playSFX();

        AnimatedSprite *sprite = effect->getIcon();

        if (!sprite) {

            // delete sprite, if necessary

            for (unsigned int i = 0; i < mStatusEffectIcons.size();)

                if (mStatusEffectIcons[i] == effectId) {

                    mStatusEffectIcons.erase(mStatusEffectIcons.begin() + i);

                    miniStatusWindow->eraseIcon(i);

                } else i++;

        } else {

            // replace sprite or append

            bool found = false;

            for (unsigned int i = 0; i < mStatusEffectIcons.size(); i++)

                if (mStatusEffectIcons[i] == effectId) {

                    miniStatusWindow->setIcon(i, sprite);

                    found = true;

                    break;

                }

            if (!found) { // add new

                int offset = mStatusEffectIcons.size();

                miniStatusWindow->setIcon(offset, sprite);

                mStatusEffectIcons.push_back(effectId);

            }

        }

    }

}

void LocalPlayer::initTargetCursor()

{

    // Load target cursors

    loadTargetCursor("graphics/gui/target-cursor-blue-s.png", 44, 35,

                     false, TC_SMALL);

    loadTargetCursor("graphics/gui/target-cursor-red-s.png", 44, 35,

                     true, TC_SMALL);

    loadTargetCursor("graphics/gui/target-cursor-blue-m.png", 62, 44,

                     false, TC_MEDIUM);

    loadTargetCursor("graphics/gui/target-cursor-red-m.png", 62, 44,

                     true, TC_MEDIUM);

    loadTargetCursor("graphics/gui/target-cursor-blue-l.png", 82, 60,

                     false, TC_LARGE);

    loadTargetCursor("graphics/gui/target-cursor-red-l.png", 82, 60,

                     true, TC_LARGE);

}

void LocalPlayer::loadTargetCursor(const std::string &filename,

                                   int width, int height,

                                   bool outRange, TargetCursorSize size)

{

    assert(size > -1);

    assert(size < 3);

    ResourceManager *resman = ResourceManager::getInstance();

    ImageSet *currentImageSet = resman->getImageSet(filename, width, height);

    Animation *anim = new Animation;

    for (unsigned int i = 0; i < currentImageSet->size(); ++i)

    {

        anim->addFrame(currentImageSet->get(i), 75,

                      (16 - (currentImageSet->getWidth() / 2)),

                      (16 - (currentImageSet->getHeight() / 2)));

    }

    SimpleAnimation *currentCursor = new SimpleAnimation(anim);

    const int index = outRange ? 1 : 0;

    mTargetCursorImages[index][size] = currentImageSet;

    mTargetCursor[index][size] = currentCursor;

}

#ifdef EATHENA_SUPPORT

void LocalPlayer::setInStorage(bool inStorage)

{

    mInStorage = inStorage;

    storageWindow->setVisible(inStorage);

}

#endif

void LocalPlayer::addMessageToQueue(const std::string &message,

                                    Palette::ColorType color)

{

    mMessages.push_back(MessagePair(message, color));

}

void LocalPlayer::optionChanged(const std::string &value)

{

    if (value == "showownname")

    {

        setShowName(config.getValue("showownname", 1));

    }

}