[WIP] renamed the client to ManaVerse

removed evol, since its not developed anymore... only leads to confusing players
removed that anoying 'broken nick detected' message (regulare player don't care what crap the server sends)
updated copyright -2020 for manaplus

1 files changed, 1152 insertions, 0 deletions

diff --git a/src/progs/manaverse/gui/viewport.cpp b/src/progs/manaverse/gui/viewport.cpp
new file mode 100644
index 000000000..f96ec8474
--- /dev/null
+++ b/src/progs/manaverse/gui/viewport.cpp
@@ -0,0 +1,1152 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2020  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 "progs/manaverse/gui/viewport.h"
+
+#include "actormanager.h"
+#include "configuration.h"
+#include "game.h"
+#include "settings.h"
+#include "sdlshared.h"
+#include "textmanager.h"
+
+#include "being/flooritem.h"
+#include "being/localplayer.h"
+#include "being/playerinfo.h"
+
+#include "enums/resources/map/blockmask.h"
+#include "enums/resources/map/mapitemtype.h"
+
+#include "gui/gui.h"
+#include "gui/popupmanager.h"
+#include "gui/userpalette.h"
+
+#include "gui/fonts/font.h"
+
+#include "gui/popups/beingpopup.h"
+#include "gui/popups/popupmenu.h"
+#include "gui/popups/textpopup.h"
+
+#include "gui/windows/ministatuswindow.h"
+
+#include "input/inputmanager.h"
+
+#include "utils/checkutils.h"
+#include "utils/foreach.h"
+
+#include "resources/map/map.h"
+#include "resources/map/mapitem.h"
+#include "resources/map/speciallayer.h"
+
+#include "debug.h"
+
+Viewport *viewport = nullptr;
+
+extern volatile int tick_time;
+
+Viewport::Viewport() :
+    WindowContainer(nullptr),
+    MouseListener(),
+    ConfigListener(),
+    mMouseX(0),
+    mMouseY(0),
+    mMap(nullptr),
+    mHoverBeing(nullptr),
+    mHoverItem(nullptr),
+    mHoverSign(nullptr),
+    mScrollRadius(config.getIntValue("ScrollRadius")),
+    mScrollLaziness(config.getIntValue("ScrollLaziness")),
+    mScrollCenterOffsetX(config.getIntValue("ScrollCenterOffsetX")),
+    mScrollCenterOffsetY(config.getIntValue("ScrollCenterOffsetY")),
+    mMousePressX(0),
+    mMousePressY(0),
+    mPixelViewX(0),
+    mPixelViewY(0),
+    mMidTileX(0),
+    mMidTileY(0),
+    mViewXmax(0),
+    mViewYmax(0),
+    mLocalWalkTime(-1),
+    mCameraRelativeX(0),
+    mCameraRelativeY(0),
+    mShowBeingPopup(config.getBoolValue("showBeingPopup")),
+    mSelfMouseHeal(config.getBoolValue("selfMouseHeal")),
+    mEnableLazyScrolling(config.getBoolValue("enableLazyScrolling")),
+    mMouseDirectionMove(config.getBoolValue("mouseDirectionMove")),
+    mLongMouseClick(config.getBoolValue("longmouseclick")),
+    mAllowMoveByMouse(config.getBoolValue("allowMoveByMouse")),
+    mMouseClicked(false),
+    mPlayerFollowMouse(false)
+{
+    setOpaque(Opaque_false);
+    addMouseListener(this);
+
+    config.addListener("ScrollLaziness", this);
+    config.addListener("ScrollRadius", this);
+    config.addListener("showBeingPopup", this);
+    config.addListener("selfMouseHeal", this);
+    config.addListener("enableLazyScrolling", this);
+    config.addListener("mouseDirectionMove", this);
+    config.addListener("longmouseclick", this);
+    config.addListener("allowMoveByMouse", this);
+
+    setFocusable(true);
+    updateMidVars();
+}
+
+Viewport::~Viewport()
+{
+    config.removeListeners(this);
+    CHECKLISTENERS
+}
+
+void Viewport::setMap(Map *const map)
+{
+    if ((mMap != nullptr) && (map != nullptr))
+        map->setDrawLayersFlags(mMap->getDrawLayersFlags());
+    mMap = map;
+    updateMaxVars();
+}
+
+void Viewport::draw(Graphics *const graphics)
+{
+    BLOCK_START("Viewport::draw 1")
+    static int lastTick = tick_time;
+
+    if ((mMap == nullptr) || (localPlayer == nullptr))
+    {
+        graphics->setColor(Color(64, 64, 64, 255));
+        graphics->fillRectangle(
+                Rect(0, 0, getWidth(), getHeight()));
+        BLOCK_END("Viewport::draw 1")
+        return;
+    }
+
+    // Avoid freaking out when tick_time overflows
+    if (tick_time < lastTick)
+        lastTick = tick_time;
+
+    // Calculate viewpoint
+
+    const int player_x = localPlayer->mPixelX - mMidTileX;
+    const int player_y = localPlayer->mPixelY - mMidTileY;
+
+    if (mScrollLaziness < 1)
+        mScrollLaziness = 1;  // Avoids division by zero
+
+    if (mEnableLazyScrolling)
+    {
+        int cnt = 0;
+
+        // Apply lazy scrolling
+        while (lastTick < tick_time && cnt < mapTileSize)
+        {
+            if (player_x > mPixelViewX + mScrollRadius)
+            {
+                mPixelViewX += CAST_S32(
+                    static_cast<float>(player_x
+                    - mPixelViewX - mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            if (player_x < mPixelViewX - mScrollRadius)
+            {
+                mPixelViewX += CAST_S32(
+                    static_cast<float>(player_x
+                    - mPixelViewX + mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            if (player_y > mPixelViewY + mScrollRadius)
+            {
+                mPixelViewY += CAST_S32(
+                    static_cast<float>(player_y
+                    - mPixelViewY - mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            if (player_y < mPixelViewY - mScrollRadius)
+            {
+                mPixelViewY += CAST_S32(
+                    static_cast<float>(player_y
+                    - mPixelViewY + mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            lastTick ++;
+            cnt ++;
+        }
+
+        // Auto center when player is off screen
+        if (cnt > 30 || player_x - mPixelViewX
+            > graphics->mWidth / 2 || mPixelViewX
+            - player_x > graphics->mWidth / 2 || mPixelViewY
+            - player_y > graphics->getHeight() / 2 ||  player_y
+            - mPixelViewY > graphics->getHeight() / 2)
+        {
+            if (player_x <= 0 || player_y <= 0)
+            {
+                logger->log("incorrect player position: %d, %d, %d, %d",
+                    player_x, player_y, mPixelViewX, mPixelViewY);
+                logger->log("tile position: %d, %d",
+                    localPlayer->getTileX(), localPlayer->getTileY());
+            }
+            mPixelViewX = player_x;
+            mPixelViewY = player_y;
+        }
+    }
+    else
+    {
+        mPixelViewX = player_x;
+        mPixelViewY = player_y;
+    }
+
+    if (mPixelViewX < 0)
+        mPixelViewX = 0;
+    if (mPixelViewY < 0)
+        mPixelViewY = 0;
+    if (mPixelViewX > mViewXmax)
+        mPixelViewX = mViewXmax;
+    if (mPixelViewY > mViewYmax)
+        mPixelViewY = mViewYmax;
+
+    // Draw tiles and sprites
+    mMap->draw(graphics, mPixelViewX, mPixelViewY);
+
+    const MapTypeT drawType = settings.mapDrawType;
+    if (drawType != MapType::NORMAL)
+    {
+        if (drawType != MapType::SPECIAL4)
+        {
+            mMap->drawCollision(graphics, mPixelViewX,
+                mPixelViewY, drawType);
+        }
+        if (drawType == MapType::DEBUGTYPE)
+            drawDebugPath(graphics);
+    }
+
+    if (localPlayer->getCheckNameSetting())
+    {
+        localPlayer->setCheckNameSetting(false);
+        localPlayer->setName(localPlayer->getName());
+    }
+
+    // Draw text
+    if (textManager != nullptr)
+        textManager->draw(graphics, mPixelViewX, mPixelViewY);
+
+    // Draw player names, speech, and emotion sprite as needed
+    const ActorSprites &actors = actorManager->getAll();
+    FOR_EACH (ActorSpritesIterator, it, actors)
+    {
+        if ((*it)->getType() == ActorType::FloorItem)
+            continue;
+        Being *const b = static_cast<Being*>(*it);
+        b->drawEmotion(graphics, mPixelViewX, mPixelViewY);
+        b->drawSpeech(mPixelViewX, mPixelViewY);
+    }
+
+    if (miniStatusWindow != nullptr)
+        miniStatusWindow->drawIcons(graphics);
+
+    // Draw contained widgets
+    WindowContainer::draw(graphics);
+    BLOCK_END("Viewport::draw 1")
+}
+
+void Viewport::safeDraw(Graphics *const graphics)
+{
+    Viewport::draw(graphics);
+}
+
+void Viewport::logic()
+{
+    BLOCK_START("Viewport::logic")
+    // Make the player follow the mouse position
+    // if the mouse is dragged elsewhere than in a window.
+    Gui::getMouseState(mMouseX, mMouseY);
+    BLOCK_END("Viewport::logic")
+}
+
+void Viewport::followMouse()
+{
+    if (gui == nullptr)
+        return;
+    const MouseStateType button = Gui::getMouseState(mMouseX, mMouseY);
+    // If the left button is dragged
+    if (mPlayerFollowMouse && ((button & SDL_BUTTON(1)) != 0))
+    {
+        // We create a mouse event and send it to mouseDragged.
+        const MouseEvent event(nullptr,
+            MouseEventType::DRAGGED,
+            MouseButton::LEFT,
+            mMouseX,
+            mMouseY,
+            0);
+
+        walkByMouse(event);
+    }
+}
+
+void Viewport::drawDebugPath(Graphics *const graphics)
+{
+    if (localPlayer == nullptr ||
+        userPalette == nullptr ||
+        actorManager == nullptr ||
+        mMap == nullptr ||
+        gui == nullptr)
+    {
+        return;
+    }
+
+    Gui::getMouseState(mMouseX, mMouseY);
+
+    static Path debugPath;
+    static Vector lastMouseDestination = Vector(0.0F, 0.0F, 0.0F);
+    const int mousePosX = mMouseX + mPixelViewX;
+    const int mousePosY = mMouseY + mPixelViewY;
+    Vector mouseDestination(mousePosX, mousePosY, 0.0F);
+
+    if (mouseDestination.x != lastMouseDestination.x
+        || mouseDestination.y != lastMouseDestination.y)
+    {
+        debugPath = mMap->findPath(
+            CAST_S32(localPlayer->mPixelX - mapTileSize / 2) / mapTileSize,
+            CAST_S32(localPlayer->mPixelY - mapTileSize) / mapTileSize,
+            mousePosX / mapTileSize,
+            mousePosY / mapTileSize,
+            localPlayer->getBlockWalkMask(),
+            500);
+        lastMouseDestination = mouseDestination;
+    }
+    drawPath(graphics, debugPath, userPalette->getColorWithAlpha(
+        UserColorId::ROAD_POINT));
+
+    const ActorSprites &actors = actorManager->getAll();
+    FOR_EACH (ActorSpritesConstIterator, it, actors)
+    {
+        const Being *const being = dynamic_cast<const Being*>(*it);
+        if ((being != nullptr) && being != localPlayer)
+        {
+            const Path &beingPath = being->getPath();
+            drawPath(graphics, beingPath, userPalette->getColorWithAlpha(
+                UserColorId::ROAD_POINT));
+        }
+    }
+}
+
+void Viewport::drawPath(Graphics *const graphics,
+                        const Path &path,
+                        const Color &color) const
+{
+    graphics->setColor(color);
+    Font *const font = getFont();
+
+    int cnt = 1;
+    FOR_EACH (Path::const_iterator, i, path)
+    {
+        const int squareX = i->x * mapTileSize - mPixelViewX + 12;
+        const int squareY = i->y * mapTileSize - mPixelViewY + 12;
+
+        graphics->fillRectangle(Rect(squareX, squareY, 8, 8));
+        if (mMap != nullptr)
+        {
+            const std::string str = toString(cnt);
+            font->drawString(graphics,
+                color, color,
+                str,
+                squareX + 4 - font->getWidth(str) / 2,
+                squareY + 12);
+        }
+        cnt ++;
+    }
+}
+
+bool Viewport::openContextMenu(const MouseEvent &event)
+{
+    mPlayerFollowMouse = false;
+    const int eventX = event.getX();
+    const int eventY = event.getY();
+    if (popupMenu == nullptr)
+        return false;
+    if (mHoverBeing != nullptr)
+    {
+        validateSpeed();
+        if (actorManager != nullptr)
+        {
+            STD_VECTOR<ActorSprite*> beings;
+            const int x = mMouseX + mPixelViewX;
+            const int y = mMouseY + mPixelViewY;
+            actorManager->findBeingsByPixel(beings, x, y, AllPlayers_true);
+            if (beings.size() > 1)
+                popupMenu->showPopup(eventX, eventY, beings);
+            else
+                popupMenu->showPopup(eventX, eventY, mHoverBeing);
+            return true;
+        }
+    }
+    else if (mHoverItem != nullptr)
+    {
+        validateSpeed();
+        popupMenu->showPopup(eventX, eventY, mHoverItem);
+        return true;
+    }
+    else if (mHoverSign != nullptr)
+    {
+        validateSpeed();
+        popupMenu->showPopup(eventX, eventY, mHoverSign);
+        return true;
+    }
+    else if (settings.cameraMode != 0U)
+    {
+        if (mMap == nullptr)
+            return false;
+        popupMenu->showMapPopup(eventX, eventY,
+            (mMouseX + mPixelViewX) / mMap->getTileWidth(),
+            (mMouseY + mPixelViewY) / mMap->getTileHeight(),
+            false);
+        return true;
+    }
+    return false;
+}
+
+bool Viewport::leftMouseAction()
+{
+    const bool stopAttack = inputManager.isActionActive(
+        InputAction::STOP_ATTACK);
+    // Interact with some being
+    if (mHoverBeing != nullptr)
+    {
+        if (!mHoverBeing->isAlive())
+            return true;
+
+        if (mHoverBeing->canTalk())
+        {
+            validateSpeed();
+            mHoverBeing->talkTo();
+            return true;
+        }
+
+        const ActorTypeT type = mHoverBeing->getType();
+        switch (type)
+        {
+            case ActorType::Player:
+                validateSpeed();
+                if (actorManager != nullptr)
+                {
+#ifdef TMWA_SUPPORT
+                    if (localPlayer != mHoverBeing || mSelfMouseHeal)
+                        actorManager->heal(mHoverBeing);
+#endif  // TMWA_SUPPORT
+
+                    if (localPlayer == mHoverBeing &&
+                        mHoverItem != nullptr)
+                    {
+                        localPlayer->pickUp(mHoverItem);
+                    }
+                    return true;
+                }
+                break;
+            case ActorType::Monster:
+            case ActorType::Npc:
+            case ActorType::SkillUnit:
+                if (!stopAttack)
+                {
+                    if (localPlayer->withinAttackRange(mHoverBeing,
+                        false, 0) ||
+                        inputManager.isActionActive(InputAction::ATTACK))
+                    {
+                        validateSpeed();
+                        if (!mStatsReUpdated && localPlayer != mHoverBeing)
+                        {
+                            localPlayer->attack(mHoverBeing,
+                                !inputManager.isActionActive(
+                                InputAction::STOP_ATTACK),
+                                false);
+                            return true;
+                        }
+                    }
+                    else if (!inputManager.isActionActive(
+                             InputAction::ATTACK))
+                    {
+                        validateSpeed();
+                        if (!mStatsReUpdated && localPlayer != mHoverBeing)
+                        {
+                            localPlayer->setGotoTarget(mHoverBeing);
+                            return true;
+                        }
+                    }
+                }
+                break;
+            case ActorType::FloorItem:
+            case ActorType::Portal:
+            case ActorType::Pet:
+            case ActorType::Mercenary:
+            case ActorType::Homunculus:
+            case ActorType::Elemental:
+                break;
+            case ActorType::Unknown:
+            case ActorType::Avatar:
+            default:
+                reportAlways("Left click on unknown actor type: %d",
+                    CAST_S32(type))
+                break;
+        }
+    }
+    // Picks up a item if we clicked on one
+    if (mHoverItem != nullptr)
+    {
+        validateSpeed();
+        localPlayer->pickUp(mHoverItem);
+    }
+    else if (stopAttack)
+    {
+        if (mMap != nullptr)
+        {
+            const int mouseTileX = (mMouseX + mPixelViewX)
+                / mMap->getTileWidth();
+            const int mouseTileY = (mMouseY + mPixelViewY)
+                / mMap->getTileHeight();
+            inputManager.executeChatCommand(InputAction::PET_MOVE,
+                strprintf("%d %d", mouseTileX, mouseTileY),
+                nullptr);
+        }
+        return true;
+    }
+    // Just walk around
+    else if (!inputManager.isActionActive(InputAction::ATTACK) &&
+             localPlayer->canMove())
+    {
+        validateSpeed();
+        localPlayer->stopAttack(false);
+        localPlayer->cancelFollow();
+        mPlayerFollowMouse = mAllowMoveByMouse;
+        if (mPlayerFollowMouse)
+        {
+            // Make the player go to the mouse position
+            followMouse();
+        }
+    }
+    return false;
+}
+
+void Viewport::mousePressed(MouseEvent &event)
+{
+    if (event.getSource() != this || event.isConsumed())
+        return;
+
+    // Check if we are alive and kickin'
+    if ((mMap == nullptr) || (localPlayer == nullptr))
+        return;
+
+    // Check if we are busy
+    // if commented, allow context menu if npc dialog open
+    if (PlayerInfo::isTalking())
+    {
+        mMouseClicked = false;
+        return;
+    }
+
+    mMouseClicked = true;
+
+    mMousePressX = event.getX();
+    mMousePressY = event.getY();
+    const MouseButtonT eventButton = event.getButton();
+
+    // Right click might open a popup
+    if (eventButton == MouseButton::RIGHT)
+    {
+        if (openContextMenu(event))
+            return;
+    }
+
+    // If a popup is active, just remove it
+    if (PopupManager::isPopupMenuVisible())
+    {
+        mPlayerFollowMouse = false;
+        PopupManager::hidePopupMenu();
+        return;
+    }
+
+    // Left click can cause different actions
+    if (!mLongMouseClick && eventButton == MouseButton::LEFT)
+    {
+        if (leftMouseAction())
+        {
+            mPlayerFollowMouse = false;
+            return;
+        }
+    }
+    else if (eventButton == MouseButton::MIDDLE)
+    {
+        mPlayerFollowMouse = false;
+        validateSpeed();
+        // Find the being nearest to the clicked position
+        if (actorManager != nullptr)
+        {
+            const int pixelX = mMousePressX + mPixelViewX;
+            const int pixelY = mMousePressY + mPixelViewY;
+            Being *const target = actorManager->findNearestLivingBeing(
+                pixelX, pixelY, 20, ActorType::Monster, nullptr);
+
+            if (target != nullptr)
+                localPlayer->setTarget(target);
+        }
+    }
+}
+
+void Viewport::getMouseTile(int &destX, int &destY) const
+{
+    getMouseTile(mMouseX, mMouseY, destX, destY);
+}
+
+void Viewport::getMouseTile(const int x, const int y,
+                            int &destX, int &destY) const
+{
+    if (mMap == nullptr)
+        return;
+    const int tw = mMap->getTileWidth();
+    const int th = mMap->getTileHeight();
+    destX = CAST_S32(x + mPixelViewX)
+        / static_cast<float>(tw);
+
+    if (mMap->isHeightsPresent())
+    {
+        const int th2 = th / 2;
+        const int clickY = y + mPixelViewY - th2;
+        destY = y + mPixelViewY;
+        int newDiffY = 1000000;
+        const int heightTiles = mainGraphics->mHeight / th;
+        const int tileViewY = mPixelViewY / th;
+        for (int f = tileViewY; f < tileViewY + heightTiles; f ++)
+        {
+            if (!mMap->getWalk(destX,
+                f,
+                BlockMask::WALL |
+                BlockMask::AIR |
+                BlockMask::WATER |
+                BlockMask::PLAYERWALL))
+            {
+                continue;
+            }
+
+            const int offset = mMap->getHeightOffset(
+                destX, f) * th2;
+            const int pixelF = f * th;
+            const int diff = abs(clickY + offset - pixelF);
+            if (diff < newDiffY)
+            {
+                destY = pixelF;
+                newDiffY = diff;
+            }
+        }
+        destY /= 32;
+    }
+    else
+    {
+        destY = CAST_S32((y + mPixelViewY) / static_cast<float>(th));
+    }
+}
+
+void Viewport::walkByMouse(const MouseEvent &event)
+{
+    if ((mMap == nullptr) || (localPlayer == nullptr))
+        return;
+    if (mPlayerFollowMouse
+        && !inputManager.isActionActive(InputAction::STOP_ATTACK)
+        && !inputManager.isActionActive(InputAction::UNTARGET))
+    {
+        if (!mMouseDirectionMove)
+            mPlayerFollowMouse = false;
+        if (mLocalWalkTime != localPlayer->getActionTime())
+        {
+            mLocalWalkTime = cur_time;
+            localPlayer->unSetPickUpTarget();
+            int playerX = localPlayer->getTileX();
+            int playerY = localPlayer->getTileY();
+            if (mMouseDirectionMove)
+            {
+                const int width = mainGraphics->mWidth / 2;
+                const int height = mainGraphics->mHeight / 2;
+                const float wh = static_cast<float>(width)
+                    / static_cast<float>(height);
+                int x = event.getX() - width;
+                int y = event.getY() - height;
+                if ((x == 0) && (y == 0))
+                    return;
+                const int x2 = abs(x);
+                const int y2 = abs(y);
+                const float diff = 2;
+                int dx = 0;
+                int dy = 0;
+                if (x2 > y2)
+                {
+                    if (y2 != 0 &&
+                        static_cast<float>(x2) / static_cast<float>(y2) /
+                        wh > diff)
+                    {
+                        y = 0;
+                    }
+                }
+                else
+                {
+                    if ((x2 != 0) && y2 * wh / x2 > diff)
+                        x = 0;
+                }
+                if (x > 0)
+                    dx = 1;
+                else if (x < 0)
+                    dx = -1;
+                if (y > 0)
+                    dy = 1;
+                else if (y < 0)
+                    dy = -1;
+
+                if (mMap->getWalk(playerX + dx,
+                    playerY + dy,
+                    BlockMask::WALL |
+                    BlockMask::AIR |
+                    BlockMask::WATER |
+                    BlockMask::PLAYERWALL))
+                {
+                    localPlayer->navigateTo(playerX + dx, playerY + dy);
+                }
+                else
+                {
+                    if ((dx != 0) && (dy != 0))
+                    {
+                        // try avoid diagonal collision
+                        if (x2 > y2)
+                        {
+                            if (mMap->getWalk(playerX + dx,
+                                playerY,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dy = 0;
+                            }
+                            else
+                            {
+                                dx = 0;
+                            }
+                        }
+                        else
+                        {
+                            if (mMap->getWalk(playerX,
+                                playerY + dy,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dx = 0;
+                            }
+                            else
+                            {
+                                dy = 0;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // try avoid vertical or horisontal collision
+                        if (dx == 0)
+                        {
+                            if (mMap->getWalk(playerX + 1,
+                                playerY + dy,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dx = 1;
+                            }
+                            if (mMap->getWalk(playerX - 1,
+                                playerY + dy,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dx = -1;
+                            }
+                        }
+                        if (dy == 0)
+                        {
+                            if (mMap->getWalk(playerX + dx,
+                                playerY + 1,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dy = 1;
+                            }
+                            if (mMap->getWalk(playerX + dx,
+                                playerY - 1,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dy = -1;
+                            }
+                        }
+                    }
+                    localPlayer->navigateTo(playerX + dx, playerY + dy);
+                }
+            }
+            else
+            {
+                int destX;
+                int destY;
+                getMouseTile(event.getX(), event.getY(),
+                    destX, destY);
+                if (playerX != destX || playerY != destY)
+                {
+                    if (!localPlayer->navigateTo(destX, destY))
+                    {
+                        if (playerX > destX)
+                            playerX --;
+                        else if (playerX < destX)
+                            playerX ++;
+                        if (playerY > destY)
+                            playerY --;
+                        else if (playerY < destY)
+                            playerY ++;
+                        if (mMap->getWalk(playerX, playerY, 0))
+                            localPlayer->navigateTo(playerX, playerY);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void Viewport::mouseDragged(MouseEvent &event)
+{
+    if (event.getSource() != this || event.isConsumed())
+    {
+        mPlayerFollowMouse = false;
+        return;
+    }
+    if (mAllowMoveByMouse &&
+        mMouseClicked &&
+        (localPlayer != nullptr) &&
+        localPlayer->canMove())
+    {
+        if (abs(event.getX() - mMousePressX) > 32
+            || abs(event.getY() - mMousePressY) > 32)
+        {
+            mPlayerFollowMouse = true;
+        }
+
+        walkByMouse(event);
+    }
+}
+
+void Viewport::mouseReleased(MouseEvent &event)
+{
+    mPlayerFollowMouse = false;
+    mLocalWalkTime = -1;
+    if (mLongMouseClick && mMouseClicked)
+    {
+        mMouseClicked = false;
+        if (event.getSource() != this || event.isConsumed())
+            return;
+        const MouseButtonT eventButton = event.getButton();
+        if (eventButton == MouseButton::LEFT)
+        {
+            // long button press
+            if ((gui != nullptr) && gui->isLongPress())
+            {
+                if (openContextMenu(event))
+                {
+                    gui->resetClickCount();
+                    return;
+                }
+            }
+            else
+            {
+                if (leftMouseAction())
+                    return;
+            }
+            walkByMouse(event);
+        }
+    }
+}
+
+void Viewport::optionChanged(const std::string &name)
+{
+    if (name == "ScrollLaziness")
+        mScrollLaziness = config.getIntValue("ScrollLaziness");
+    else if (name == "ScrollRadius")
+        mScrollRadius = config.getIntValue("ScrollRadius");
+    else if (name == "showBeingPopup")
+        mShowBeingPopup = config.getBoolValue("showBeingPopup");
+    else if (name == "selfMouseHeal")
+        mSelfMouseHeal = config.getBoolValue("selfMouseHeal");
+    else if (name == "enableLazyScrolling")
+        mEnableLazyScrolling = config.getBoolValue("enableLazyScrolling");
+    else if (name == "mouseDirectionMove")
+        mMouseDirectionMove = config.getBoolValue("mouseDirectionMove");
+    else if (name == "longmouseclick")
+        mLongMouseClick = config.getBoolValue("longmouseclick");
+    else if (name == "allowMoveByMouse")
+        mAllowMoveByMouse = config.getBoolValue("allowMoveByMouse");
+}
+
+void Viewport::mouseMoved(MouseEvent &event)
+{
+    // Check if we are on the map
+    if (mMap == nullptr ||
+        localPlayer == nullptr ||
+        actorManager == nullptr)
+    {
+        return;
+    }
+
+    if (mMouseDirectionMove)
+        mPlayerFollowMouse = false;
+
+    const int x = mMouseX + mPixelViewX;
+    const int y = mMouseY + mPixelViewY;
+
+    ActorTypeT type = ActorType::Unknown;
+    mHoverBeing = actorManager->findBeingByPixel(x, y, AllPlayers_true);
+    if (mHoverBeing != nullptr)
+        type = mHoverBeing->getType();
+    if ((mHoverBeing != nullptr)
+        && (type == ActorType::Player
+        || type == ActorType::Npc
+        || type == ActorType::Homunculus
+        || type == ActorType::Mercenary
+        || type == ActorType::Pet))
+    {
+        PopupManager::hideTextPopup();
+        if (mShowBeingPopup && (beingPopup != nullptr))
+            beingPopup->show(mMouseX, mMouseY, mHoverBeing);
+    }
+    else
+    {
+        PopupManager::hideBeingPopup();
+    }
+
+    mHoverItem = actorManager->findItem(x / mMap->getTileWidth(),
+        y / mMap->getTileHeight());
+
+    if ((mHoverBeing == nullptr) && (mHoverItem == nullptr))
+    {
+        const SpecialLayer *const specialLayer = mMap->getSpecialLayer();
+        if (specialLayer != nullptr)
+        {
+            const int mouseTileX = (mMouseX + mPixelViewX)
+                / mMap->getTileWidth();
+            const int mouseTileY = (mMouseY + mPixelViewY)
+                / mMap->getTileHeight();
+
+            mHoverSign = specialLayer->getTile(mouseTileX, mouseTileY);
+            if (mHoverSign != nullptr &&
+                mHoverSign->getType() != MapItemType::EMPTY)
+            {
+                if (!mHoverSign->getComment().empty())
+                {
+                    PopupManager::hideBeingPopup();
+                    if (textPopup != nullptr)
+                    {
+                        textPopup->show(mMouseX, mMouseY,
+                            mHoverSign->getComment());
+                    }
+                }
+                else
+                {
+                    if (PopupManager::isTextPopupVisible())
+                        PopupManager::hideTextPopup();
+                }
+                gui->setCursorType(Cursor::CURSOR_UP);
+                return;
+            }
+        }
+    }
+    if (!event.isConsumed() &&
+        PopupManager::isTextPopupVisible())
+    {
+        PopupManager::hideTextPopup();
+    }
+
+    if (mHoverBeing != nullptr)
+    {
+        switch (type)
+        {
+            case ActorType::Npc:
+            case ActorType::Monster:
+            case ActorType::Portal:
+            case ActorType::Pet:
+            case ActorType::Mercenary:
+            case ActorType::Homunculus:
+            case ActorType::SkillUnit:
+            case ActorType::Elemental:
+                gui->setCursorType(mHoverBeing->getHoverCursor());
+                break;
+
+            case ActorType::Avatar:
+            case ActorType::FloorItem:
+            case ActorType::Unknown:
+            case ActorType::Player:
+            default:
+                gui->setCursorType(Cursor::CURSOR_POINTER);
+                break;
+        }
+    }
+    // Item mouseover
+    else if (mHoverItem != nullptr)
+    {
+        gui->setCursorType(mHoverItem->getHoverCursor());
+    }
+    else
+    {
+        gui->setCursorType(Cursor::CURSOR_POINTER);
+    }
+}
+
+void Viewport::toggleMapDrawType()
+{
+    settings.mapDrawType = static_cast<MapTypeT>(
+        CAST_S32(settings.mapDrawType) + 1);
+    if (settings.mapDrawType > MapType::BLACKWHITE)
+        settings.mapDrawType = MapType::NORMAL;
+    if (mMap != nullptr)
+        mMap->setDrawLayersFlags(settings.mapDrawType);
+}
+
+void Viewport::toggleCameraMode()
+{
+    settings.cameraMode ++;
+    if (settings.cameraMode > 1)
+        settings.cameraMode = 0;
+    if (settings.cameraMode == 0U)
+    {
+        mCameraRelativeX = 0;
+        mCameraRelativeY = 0;
+        updateMidVars();
+    }
+    UpdateStatusListener::distributeEvent();
+}
+
+void Viewport::clearHover(const ActorSprite *const actor)
+{
+    if (mHoverBeing == actor)
+        mHoverBeing = nullptr;
+
+    if (mHoverItem == actor)
+        mHoverItem = nullptr;
+}
+
+void Viewport::cleanHoverItems()
+{
+    mHoverBeing = nullptr;
+    mHoverItem = nullptr;
+    mHoverSign = nullptr;
+}
+
+void Viewport::moveCamera(const int dx, const int dy)
+{
+    mCameraRelativeX += dx;
+    mCameraRelativeY += dy;
+    updateMidVars();
+}
+
+void Viewport::moveCameraToActor(const BeingId actorId,
+                                 const int x, const int y)
+{
+    if ((localPlayer == nullptr) || (actorManager == nullptr))
+        return;
+
+    const Actor *const actor = actorManager->findBeing(actorId);
+    if (actor == nullptr)
+        return;
+    settings.cameraMode = 1;
+    mCameraRelativeX = actor->mPixelX - localPlayer->mPixelX + x;
+    mCameraRelativeY = actor->mPixelY - localPlayer->mPixelY + y;
+    updateMidVars();
+}
+
+void Viewport::moveCameraToPosition(const int x, const int y)
+{
+    if (localPlayer == nullptr)
+        return;
+
+    settings.cameraMode = 1;
+    mCameraRelativeX = x - localPlayer->mPixelX;
+    mCameraRelativeY = y - localPlayer->mPixelY;
+    updateMidVars();
+}
+
+void Viewport::moveCameraRelative(const int x, const int y)
+{
+    settings.cameraMode = 1;
+    mCameraRelativeX += x;
+    mCameraRelativeY += y;
+    updateMidVars();
+}
+
+void Viewport::returnCamera()
+{
+    settings.cameraMode = 0;
+    mCameraRelativeX = 0;
+    mCameraRelativeY = 0;
+    updateMidVars();
+}
+
+void Viewport::validateSpeed()
+{
+    if (!inputManager.isActionActive(InputAction::TARGET_ATTACK) &&
+        !inputManager.isActionActive(InputAction::ATTACK))
+    {
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+    }
+}
+
+void Viewport::updateMidVars()
+{
+    mMidTileX = (mainGraphics->mWidth + mScrollCenterOffsetX) / 2
+        - mCameraRelativeX;
+    mMidTileY = (mainGraphics->mHeight + mScrollCenterOffsetY) / 2
+        - mCameraRelativeY;
+}
+
+void Viewport::updateMaxVars()
+{
+    if (mMap == nullptr)
+        return;
+    mViewXmax = mMap->getWidth() * mMap->getTileWidth()
+        - mainGraphics->mWidth;
+    mViewYmax = mMap->getHeight() * mMap->getTileHeight()
+        - mainGraphics->mHeight;
+}
+
+void Viewport::videoResized()
+{
+    updateMidVars();
+    updateMaxVars();
+    if (mMap != nullptr)
+        mMap->screenResized();
+}