Move receive code from beinghandler into separate file.

4 files changed, 536 insertions, 455 deletions

diff --git a/src/net/ea/beinghandler.cpp b/src/net/ea/beinghandler.cpp
index 85e04efbc..49e8b4720 100644
--- a/src/net/ea/beinghandler.cpp
+++ b/src/net/ea/beinghandler.cpp
@@ -40,434 +40,17 @@
 
 #include "net/serverfeatures.h"
 
+#include "net/ea/beingnet.h"
+
 #include "debug.h"
 
 namespace Ea
 {
-BeingId BeingHandler::mSpawnId = BeingId_zero;
-bool BeingHandler::mSync = false;
 
 BeingHandler::BeingHandler(const bool enableSync)
 {
-    mSync = enableSync;
-    mSpawnId = BeingId_zero;
-}
-
-Being *BeingHandler::createBeing(const BeingId id,
-                                 const int job)
-{
-    if (!actorManager)
-        return nullptr;
-
-    ActorTypeT type = ActorType::Unknown;
-    if (job <= 25 || (job >= 4001 && job <= 4049))
-        type = ActorType::Player;
-    else if (job >= 46 && job <= 1000)
-        type = ActorType::Npc;
-    else if (job > 1000 && job <= 2000)
-        type = ActorType::Monster;
-    else if (job == 45)
-        type = ActorType::Portal;
-
-    Being *const being = actorManager->createBeing(
-        id, type, fromInt(job, BeingTypeId));
-    return being;
-}
-
-void BeingHandler::setSprite(Being *const being, const unsigned int slot,
-                             const int id, const std::string &color,
-                             const ItemColor colorId,
-                             const bool isWeapon,
-                             const bool isTempSprite)
-{
-    if (!being)
-        return;
-    being->updateSprite(slot, id, color, colorId, isWeapon, isTempSprite);
-}
-
-void BeingHandler::processBeingRemove(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processBeingRemove")
-    if (!actorManager || !localPlayer)
-    {
-        BLOCK_END("BeingHandler::processBeingRemove")
-        return;
-    }
-
-    // A being should be removed or has died
-
-    const BeingId id = msg.readBeingId("being id");
-    Being *const dstBeing = actorManager->findBeing(id);
-    if (!dstBeing)
-    {
-        msg.readUInt8("dead flag?");
-        BLOCK_END("BeingHandler::processBeingRemove")
-        return;
-    }
-
-    localPlayer->followMoveTo(dstBeing, localPlayer->getNextDestX(),
-        localPlayer->getNextDestY());
-
-    // If this is player's current target, clear it.
-    if (dstBeing == localPlayer->getTarget())
-        localPlayer->stopAttack(true);
-
-    if (msg.readUInt8("dead flag?") == 1U)
-    {
-        if (dstBeing->getCurrentAction() != BeingAction::DEAD)
-        {
-            dstBeing->setAction(BeingAction::DEAD, 0);
-            dstBeing->recalcSpritesOrder();
-        }
-    }
-    else
-    {
-        if (dstBeing->getType() == ActorType::Player)
-        {
-            if (socialWindow)
-                socialWindow->updateActiveList();
-        }
-        actorManager->destroy(dstBeing);
-    }
-    BLOCK_END("BeingHandler::processBeingRemove")
-}
-
-void BeingHandler::processSkillDamage(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processSkillDamage")
-    if (!actorManager)
-    {
-        BLOCK_END("BeingHandler::processSkillDamage")
-        return;
-    }
-
-    const int id = msg.readInt16("skill id");
-    Being *const srcBeing = actorManager->findBeing(
-        msg.readBeingId("src being id"));
-    Being *const dstBeing = actorManager->findBeing(
-        msg.readBeingId("dst being id"));
-    msg.readInt32("tick");
-    msg.readInt32("src speed");
-    msg.readInt32("dst speed");
-    const int param1 = msg.readInt32("damage");
-    const int level = msg.readInt16("skill level");
-    msg.readInt16("div");
-    msg.readUInt8("skill hit/type?");
-    if (srcBeing)
-        srcBeing->handleSkill(dstBeing, param1, id, level);
-    if (dstBeing)
-        dstBeing->takeDamage(srcBeing, param1, AttackType::SKILL, id, level);
-    BLOCK_END("BeingHandler::processSkillDamage")
-}
-
-void BeingHandler::processBeingAction(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processBeingAction")
-    if (!actorManager)
-    {
-        BLOCK_END("BeingHandler::processBeingAction")
-        return;
-    }
-
-    Being *const srcBeing = actorManager->findBeing(
-        msg.readBeingId("src being id"));
-    Being *const dstBeing = actorManager->findBeing(
-        msg.readBeingId("dst being id"));
-
-    msg.readInt32("tick");
-    const int srcSpeed = msg.readInt32("src speed");
-    msg.readInt32("dst speed");
-    const int param1 = msg.readInt16("param1");
-    msg.readInt16("param 2");
-    const AttackTypeT type = static_cast<AttackTypeT>(
-        msg.readUInt8("type"));
-    msg.readInt16("param 3");
-
-    switch (type)
-    {
-        case AttackType::HIT:  // Damage
-        case AttackType::CRITICAL:  // Critical Damage
-        case AttackType::MULTI:  // Critical Damage
-        case AttackType::REFLECT:  // Reflected Damage
-        case AttackType::FLEE:  // Lucky Dodge
-            if (srcBeing)
-            {
-                if (srcSpeed && srcBeing->getType() == ActorType::Player)
-                    srcBeing->setAttackDelay(srcSpeed);
-                // attackid=1, type
-                srcBeing->handleAttack(dstBeing, param1, 1);
-                if (srcBeing->getType() == ActorType::Player)
-                    srcBeing->setAttackTime();
-            }
-            if (dstBeing)
-            {
-                // level not present, using 1
-                dstBeing->takeDamage(srcBeing, param1,
-                    static_cast<AttackTypeT>(type), 1);
-            }
-            break;
-
-        case AttackType::PICKUP:
-            break;
-            // tmw server can send here garbage?
-//            if (srcBeing)
-//                srcBeing->setAction(BeingAction::DEAD, 0);
-
-        case AttackType::SIT:
-            if (srcBeing)
-            {
-                srcBeing->setAction(BeingAction::SIT, 0);
-                if (srcBeing->getType() == ActorType::Player)
-                {
-                    srcBeing->setMoveTime();
-                    if (localPlayer)
-                        localPlayer->imitateAction(srcBeing, BeingAction::SIT);
-                }
-            }
-            break;
-
-        case AttackType::STAND:
-            if (srcBeing)
-            {
-                srcBeing->setAction(BeingAction::STAND, 0);
-                if (srcBeing->getType() == ActorType::Player)
-                {
-                    srcBeing->setMoveTime();
-                    if (localPlayer)
-                    {
-                        localPlayer->imitateAction(srcBeing,
-                            BeingAction::STAND);
-                    }
-                }
-            }
-            break;
-        default:
-        case AttackType::SPLASH:
-        case AttackType::SKILL:
-        case AttackType::REPEATE:
-        case AttackType::MULTI_REFLECT:
-        case AttackType::TOUCH_SKILL:
-        case AttackType::MISS:
-        case AttackType::SKILLMISS:
-            UNIMPLIMENTEDPACKET;
-            break;
-    }
-    BLOCK_END("BeingHandler::processBeingAction")
-}
-
-void BeingHandler::processBeingEmotion(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processBeingEmotion")
-    if (!localPlayer || !actorManager)
-    {
-        BLOCK_END("BeingHandler::processBeingEmotion")
-        return;
-    }
-
-    Being *const dstBeing = actorManager->findBeing(
-        msg.readBeingId("being id"));
-    if (!dstBeing)
-    {
-        BLOCK_END("BeingHandler::processBeingEmotion")
-        return;
-    }
-
-    if (player_relations.hasPermission(dstBeing, PlayerRelation::EMOTE))
-    {
-        const uint8_t emote = msg.readUInt8("emote");
-        if (emote)
-        {
-            dstBeing->setEmote(emote, 0);
-            localPlayer->imitateEmote(dstBeing, emote);
-        }
-    }
-    if (dstBeing->getType() == ActorType::Player)
-        dstBeing->setOtherTime();
-    BLOCK_END("BeingHandler::processBeingEmotion")
-}
-
-void BeingHandler::processNameResponse(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processNameResponse")
-    if (!localPlayer || !actorManager)
-    {
-        BLOCK_END("BeingHandler::processNameResponse")
-        return;
-    }
-
-    const BeingId beingId = msg.readBeingId("being id");
-    Being *const dstBeing = actorManager->findBeing(beingId);
-
-    if (dstBeing)
-    {
-        if (beingId == localPlayer->getId())
-        {
-            localPlayer->pingResponse();
-        }
-        else
-        {
-            const std::string name = msg.readString(24, "name");
-            if (dstBeing->getType() != ActorType::Portal)
-            {
-                dstBeing->setName(name);
-            }
-            else if (viewport)
-            {
-                Map *const map = viewport->getMap();
-                if (map)
-                {
-                    map->addPortalTile(name, MapItemType::PORTAL,
-                        dstBeing->getTileX(), dstBeing->getTileY());
-                }
-            }
-            dstBeing->updateGuild();
-            dstBeing->addToCache();
-
-            if (dstBeing->getType() == ActorType::Player)
-                dstBeing->updateColors();
-
-            if (localPlayer)
-            {
-                const Party *const party = localPlayer->getParty();
-                if (party && party->isMember(dstBeing->getId()))
-                {
-                    PartyMember *const member = party->getMember(
-                        dstBeing->getId());
-
-                    if (member)
-                        member->setName(dstBeing->getName());
-                }
-                localPlayer->checkNewName(dstBeing);
-            }
-            BLOCK_END("BeingHandler::processNameResponse")
-            return;
-        }
-    }
-    msg.readString(24, "name");
-    BLOCK_END("BeingHandler::processNameResponse")
-}
-
-void BeingHandler::processPlayerStop(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processPlayerStop")
-    if (!actorManager || !localPlayer)
-    {
-        BLOCK_END("BeingHandler::processPlayerStop")
-        return;
-    }
-
-    const BeingId id = msg.readBeingId("account id");
-
-    if (mSync || id != localPlayer->getId())
-    {
-        Being *const dstBeing = actorManager->findBeing(id);
-        if (dstBeing)
-        {
-            const uint16_t x = msg.readInt16("x");
-            const uint16_t y = msg.readInt16("y");
-            dstBeing->setTileCoords(x, y);
-            if (dstBeing->getCurrentAction() == BeingAction::MOVE)
-                dstBeing->setAction(BeingAction::STAND, 0);
-            BLOCK_END("BeingHandler::processPlayerStop")
-            return;
-        }
-    }
-    msg.readInt16("x");
-    msg.readInt16("y");
-    BLOCK_END("BeingHandler::processPlayerStop")
-}
-
-void BeingHandler::processPlayerMoveToAttack(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processPlayerStop")
-    msg.readInt32("target id");
-    msg.readInt16("target x");
-    msg.readInt16("target y");
-    msg.readInt16("x");
-    msg.readInt16("y");
-    msg.readInt16("attack range");
-
-    if (localPlayer)
-        localPlayer->fixAttackTarget();
-    BLOCK_END("BeingHandler::processPlayerStop")
-}
-
-void BeingHandler::processSkillNoDamage(Net::MessageIn &msg)
-{
-    const int id = msg.readInt16("skill id");
-    const int heal = msg.readInt16("heal");
-    Being *const dstBeing = actorManager->findBeing(
-        msg.readBeingId("dst being id"));
-    Being *const srcBeing = actorManager->findBeing(
-        msg.readBeingId("src being id"));
-    const int flag = msg.readUInt8("fail");
-
-    if (srcBeing)
-        srcBeing->handleSkill(dstBeing, heal, id, 1);
-}
-
-void BeingHandler::processPvpMapMode(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processPvpMapMode")
-    const Game *const game = Game::instance();
-    if (!game)
-    {
-        BLOCK_END("BeingHandler::processPvpMapMode")
-        return;
-    }
-
-    Map *const map = game->getCurrentMap();
-    if (map)
-        map->setPvpMode(msg.readInt16("pvp mode"));
-    BLOCK_END("BeingHandler::processPvpMapMode")
-}
-
-void BeingHandler::processBeingMove3(Net::MessageIn &msg)
-{
-    BLOCK_START("BeingHandler::processBeingMove3")
-    if (!actorManager || !serverFeatures->haveMove3())
-    {
-        BLOCK_END("BeingHandler::processBeingMove3")
-        return;
-    }
-
-    static const int16_t dirx[8] = {0, -1, -1, -1,  0,  1, 1, 1};
-    static const int16_t diry[8] = {1,  1,  0, -1, -1, -1, 0, 1};
-
-    const int len = msg.readInt16("len") - 14;
-    Being *const dstBeing = actorManager->findBeing(
-        msg.readBeingId("being id"));
-    if (!dstBeing)
-    {
-        BLOCK_END("BeingHandler::processBeingMove3")
-        return;
-    }
-    const int16_t speed = msg.readInt16("speed");
-    dstBeing->setWalkSpeed(Vector(speed, speed, 0));
-    int16_t x = msg.readInt16("x");
-    int16_t y = msg.readInt16("y");
-    const unsigned char *moves = msg.readBytes(len, "moving path");
-    Path path;
-    if (moves)
-    {
-        for (int f = 0; f < len; f ++)
-        {
-            const unsigned char dir = moves[f];
-            if (dir <= 7)
-            {
-                x += dirx[dir];
-                y += diry[dir];
-                path.push_back(Position(x, y));
-            }
-            else
-            {
-                logger->log("bad move packet: %d", dir);
-            }
-        }
-        delete [] moves;
-    }
-    dstBeing->setPath(path);
-    BLOCK_END("BeingHandler::processBeingMove3")
+    BeingNet::mSync = enableSync;
+    BeingNet::mSpawnId = BeingId_zero;
 }
 
 }  // namespace Ea
diff --git a/src/net/ea/beinghandler.h b/src/net/ea/beinghandler.h
index 6c372ce1f..660f93f8e 100644
--- a/src/net/ea/beinghandler.h
+++ b/src/net/ea/beinghandler.h
@@ -35,40 +35,6 @@ class BeingHandler notfinal : public Net::BeingHandler
 
     protected:
         explicit BeingHandler(const bool enableSync);
-
-        static Being *createBeing(const BeingId id,
-                                  const int job) A_WARN_UNUSED;
-
-        static void setSprite(Being *const being, const unsigned int slot,
-                              const int id,
-                              const std::string &color = "",
-                              const ItemColor colorId = ItemColor_one,
-                              const bool isWeapon = false,
-                              const bool isTempSprite = false);
-
-        static void processBeingRemove(Net::MessageIn &msg);
-
-        static void processSkillDamage(Net::MessageIn &msg);
-
-        static void processBeingAction(Net::MessageIn &msg);
-
-        static void processBeingEmotion(Net::MessageIn &msg);
-
-        static void processNameResponse(Net::MessageIn &msg);
-
-        static void processPlayerStop(Net::MessageIn &msg);
-
-        static void processPlayerMoveToAttack(Net::MessageIn &msg);
-
-        static void processSkillNoDamage(Net::MessageIn &msg);
-
-        static void processPvpMapMode(Net::MessageIn &msg);
-
-        static void processBeingMove3(Net::MessageIn &msg);
-
-        // Should we honor server "Stop Walking" packets
-        static BeingId mSpawnId;
-        static bool mSync;
 };
 
 }  // namespace Ea
diff --git a/src/net/ea/beingnet.cpp b/src/net/ea/beingnet.cpp
new file mode 100644
index 000000000..c7f64aa66
--- /dev/null
+++ b/src/net/ea/beingnet.cpp
@@ -0,0 +1,473 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2015  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 "net/ea/beingnet.h"
+
+#include "actormanager.h"
+#include "game.h"
+#include "party.h"
+
+#include "being/localplayer.h"
+#include "being/playerrelation.h"
+#include "being/playerrelations.h"
+
+#include "enums/resources/map/mapitemtype.h"
+
+#include "gui/viewport.h"
+
+#include "gui/windows/socialwindow.h"
+
+#include "resources/map/map.h"
+
+#include "net/serverfeatures.h"
+
+#include "debug.h"
+
+namespace Ea
+{
+
+namespace BeingNet
+{
+    bool mSync = false;
+    BeingId mSpawnId = BeingId_zero;
+}  // namespace BeingNet
+
+void BeingNet::processBeingRemove(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processBeingRemove")
+    if (!actorManager || !localPlayer)
+    {
+        BLOCK_END("BeingNet::processBeingRemove")
+        return;
+    }
+
+    // A being should be removed or has died
+
+    const BeingId id = msg.readBeingId("being id");
+    Being *const dstBeing = actorManager->findBeing(id);
+    if (!dstBeing)
+    {
+        msg.readUInt8("dead flag?");
+        BLOCK_END("BeingNet::processBeingRemove")
+        return;
+    }
+
+    localPlayer->followMoveTo(dstBeing, localPlayer->getNextDestX(),
+        localPlayer->getNextDestY());
+
+    // If this is player's current target, clear it.
+    if (dstBeing == localPlayer->getTarget())
+        localPlayer->stopAttack(true);
+
+    if (msg.readUInt8("dead flag?") == 1U)
+    {
+        if (dstBeing->getCurrentAction() != BeingAction::DEAD)
+        {
+            dstBeing->setAction(BeingAction::DEAD, 0);
+            dstBeing->recalcSpritesOrder();
+        }
+    }
+    else
+    {
+        if (dstBeing->getType() == ActorType::Player)
+        {
+            if (socialWindow)
+                socialWindow->updateActiveList();
+        }
+        actorManager->destroy(dstBeing);
+    }
+    BLOCK_END("BeingNet::processBeingRemove")
+}
+
+void BeingNet::processSkillDamage(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processSkillDamage")
+    if (!actorManager)
+    {
+        BLOCK_END("BeingNet::processSkillDamage")
+        return;
+    }
+
+    const int id = msg.readInt16("skill id");
+    Being *const srcBeing = actorManager->findBeing(
+        msg.readBeingId("src being id"));
+    Being *const dstBeing = actorManager->findBeing(
+        msg.readBeingId("dst being id"));
+    msg.readInt32("tick");
+    msg.readInt32("src speed");
+    msg.readInt32("dst speed");
+    const int param1 = msg.readInt32("damage");
+    const int level = msg.readInt16("skill level");
+    msg.readInt16("div");
+    msg.readUInt8("skill hit/type?");
+    if (srcBeing)
+        srcBeing->handleSkill(dstBeing, param1, id, level);
+    if (dstBeing)
+        dstBeing->takeDamage(srcBeing, param1, AttackType::SKILL, id, level);
+    BLOCK_END("BeingNet::processSkillDamage")
+}
+
+void BeingNet::processBeingAction(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processBeingAction")
+    if (!actorManager)
+    {
+        BLOCK_END("BeingNet::processBeingAction")
+        return;
+    }
+
+    Being *const srcBeing = actorManager->findBeing(
+        msg.readBeingId("src being id"));
+    Being *const dstBeing = actorManager->findBeing(
+        msg.readBeingId("dst being id"));
+
+    msg.readInt32("tick");
+    const int srcSpeed = msg.readInt32("src speed");
+    msg.readInt32("dst speed");
+    const int param1 = msg.readInt16("param1");
+    msg.readInt16("param 2");
+    const AttackTypeT type = static_cast<AttackTypeT>(
+        msg.readUInt8("type"));
+    msg.readInt16("param 3");
+
+    switch (type)
+    {
+        case AttackType::HIT:  // Damage
+        case AttackType::CRITICAL:  // Critical Damage
+        case AttackType::MULTI:  // Critical Damage
+        case AttackType::REFLECT:  // Reflected Damage
+        case AttackType::FLEE:  // Lucky Dodge
+            if (srcBeing)
+            {
+                if (srcSpeed && srcBeing->getType() == ActorType::Player)
+                    srcBeing->setAttackDelay(srcSpeed);
+                // attackid=1, type
+                srcBeing->handleAttack(dstBeing, param1, 1);
+                if (srcBeing->getType() == ActorType::Player)
+                    srcBeing->setAttackTime();
+            }
+            if (dstBeing)
+            {
+                // level not present, using 1
+                dstBeing->takeDamage(srcBeing, param1,
+                    static_cast<AttackTypeT>(type), 1);
+            }
+            break;
+
+        case AttackType::PICKUP:
+            break;
+            // tmw server can send here garbage?
+//            if (srcBeing)
+//                srcBeing->setAction(BeingAction::DEAD, 0);
+
+        case AttackType::SIT:
+            if (srcBeing)
+            {
+                srcBeing->setAction(BeingAction::SIT, 0);
+                if (srcBeing->getType() == ActorType::Player)
+                {
+                    srcBeing->setMoveTime();
+                    if (localPlayer)
+                        localPlayer->imitateAction(srcBeing, BeingAction::SIT);
+                }
+            }
+            break;
+
+        case AttackType::STAND:
+            if (srcBeing)
+            {
+                srcBeing->setAction(BeingAction::STAND, 0);
+                if (srcBeing->getType() == ActorType::Player)
+                {
+                    srcBeing->setMoveTime();
+                    if (localPlayer)
+                    {
+                        localPlayer->imitateAction(srcBeing,
+                            BeingAction::STAND);
+                    }
+                }
+            }
+            break;
+        default:
+        case AttackType::SPLASH:
+        case AttackType::SKILL:
+        case AttackType::REPEATE:
+        case AttackType::MULTI_REFLECT:
+        case AttackType::TOUCH_SKILL:
+        case AttackType::MISS:
+        case AttackType::SKILLMISS:
+            UNIMPLIMENTEDPACKET;
+            break;
+    }
+    BLOCK_END("BeingNet::processBeingAction")
+}
+
+void BeingNet::processBeingEmotion(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processBeingEmotion")
+    if (!localPlayer || !actorManager)
+    {
+        BLOCK_END("BeingNet::processBeingEmotion")
+        return;
+    }
+
+    Being *const dstBeing = actorManager->findBeing(
+        msg.readBeingId("being id"));
+    if (!dstBeing)
+    {
+        BLOCK_END("BeingNet::processBeingEmotion")
+        return;
+    }
+
+    if (player_relations.hasPermission(dstBeing, PlayerRelation::EMOTE))
+    {
+        const uint8_t emote = msg.readUInt8("emote");
+        if (emote)
+        {
+            dstBeing->setEmote(emote, 0);
+            localPlayer->imitateEmote(dstBeing, emote);
+        }
+    }
+    if (dstBeing->getType() == ActorType::Player)
+        dstBeing->setOtherTime();
+    BLOCK_END("BeingNet::processBeingEmotion")
+}
+
+void BeingNet::processNameResponse(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processNameResponse")
+    if (!localPlayer || !actorManager)
+    {
+        BLOCK_END("BeingNet::processNameResponse")
+        return;
+    }
+
+    const BeingId beingId = msg.readBeingId("being id");
+    Being *const dstBeing = actorManager->findBeing(beingId);
+
+    if (dstBeing)
+    {
+        if (beingId == localPlayer->getId())
+        {
+            localPlayer->pingResponse();
+        }
+        else
+        {
+            const std::string name = msg.readString(24, "name");
+            if (dstBeing->getType() != ActorType::Portal)
+            {
+                dstBeing->setName(name);
+            }
+            else if (viewport)
+            {
+                Map *const map = viewport->getMap();
+                if (map)
+                {
+                    map->addPortalTile(name, MapItemType::PORTAL,
+                        dstBeing->getTileX(), dstBeing->getTileY());
+                }
+            }
+            dstBeing->updateGuild();
+            dstBeing->addToCache();
+
+            if (dstBeing->getType() == ActorType::Player)
+                dstBeing->updateColors();
+
+            if (localPlayer)
+            {
+                const Party *const party = localPlayer->getParty();
+                if (party && party->isMember(dstBeing->getId()))
+                {
+                    PartyMember *const member = party->getMember(
+                        dstBeing->getId());
+
+                    if (member)
+                        member->setName(dstBeing->getName());
+                }
+                localPlayer->checkNewName(dstBeing);
+            }
+            BLOCK_END("BeingNet::processNameResponse")
+            return;
+        }
+    }
+    msg.readString(24, "name");
+    BLOCK_END("BeingNet::processNameResponse")
+}
+
+void BeingNet::processPlayerStop(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processPlayerStop")
+    if (!actorManager || !localPlayer)
+    {
+        BLOCK_END("BeingNet::processPlayerStop")
+        return;
+    }
+
+    const BeingId id = msg.readBeingId("account id");
+
+    if (mSync || id != localPlayer->getId())
+    {
+        Being *const dstBeing = actorManager->findBeing(id);
+        if (dstBeing)
+        {
+            const uint16_t x = msg.readInt16("x");
+            const uint16_t y = msg.readInt16("y");
+            dstBeing->setTileCoords(x, y);
+            if (dstBeing->getCurrentAction() == BeingAction::MOVE)
+                dstBeing->setAction(BeingAction::STAND, 0);
+            BLOCK_END("BeingNet::processPlayerStop")
+            return;
+        }
+    }
+    msg.readInt16("x");
+    msg.readInt16("y");
+    BLOCK_END("BeingNet::processPlayerStop")
+}
+
+void BeingNet::processPlayerMoveToAttack(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processPlayerStop")
+    msg.readInt32("target id");
+    msg.readInt16("target x");
+    msg.readInt16("target y");
+    msg.readInt16("x");
+    msg.readInt16("y");
+    msg.readInt16("attack range");
+
+    if (localPlayer)
+        localPlayer->fixAttackTarget();
+    BLOCK_END("BeingNet::processPlayerStop")
+}
+
+void BeingNet::processSkillNoDamage(Net::MessageIn &msg)
+{
+    const int id = msg.readInt16("skill id");
+    const int heal = msg.readInt16("heal");
+    Being *const dstBeing = actorManager->findBeing(
+        msg.readBeingId("dst being id"));
+    Being *const srcBeing = actorManager->findBeing(
+        msg.readBeingId("src being id"));
+    const int flag = msg.readUInt8("fail");
+
+    if (srcBeing)
+        srcBeing->handleSkill(dstBeing, heal, id, 1);
+}
+
+void BeingNet::processPvpMapMode(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processPvpMapMode")
+    const Game *const game = Game::instance();
+    if (!game)
+    {
+        BLOCK_END("BeingNet::processPvpMapMode")
+        return;
+    }
+
+    Map *const map = game->getCurrentMap();
+    if (map)
+        map->setPvpMode(msg.readInt16("pvp mode"));
+    BLOCK_END("BeingNet::processPvpMapMode")
+}
+
+void BeingNet::processBeingMove3(Net::MessageIn &msg)
+{
+    BLOCK_START("BeingNet::processBeingMove3")
+    if (!actorManager || !serverFeatures->haveMove3())
+    {
+        BLOCK_END("BeingNet::processBeingMove3")
+        return;
+    }
+
+    static const int16_t dirx[8] = {0, -1, -1, -1,  0,  1, 1, 1};
+    static const int16_t diry[8] = {1,  1,  0, -1, -1, -1, 0, 1};
+
+    const int len = msg.readInt16("len") - 14;
+    Being *const dstBeing = actorManager->findBeing(
+        msg.readBeingId("being id"));
+    if (!dstBeing)
+    {
+        BLOCK_END("BeingNet::processBeingMove3")
+        return;
+    }
+    const int16_t speed = msg.readInt16("speed");
+    dstBeing->setWalkSpeed(Vector(speed, speed, 0));
+    int16_t x = msg.readInt16("x");
+    int16_t y = msg.readInt16("y");
+    const unsigned char *moves = msg.readBytes(len, "moving path");
+    Path path;
+    if (moves)
+    {
+        for (int f = 0; f < len; f ++)
+        {
+            const unsigned char dir = moves[f];
+            if (dir <= 7)
+            {
+                x += dirx[dir];
+                y += diry[dir];
+                path.push_back(Position(x, y));
+            }
+            else
+            {
+                logger->log("bad move packet: %d", dir);
+            }
+        }
+        delete [] moves;
+    }
+    dstBeing->setPath(path);
+    BLOCK_END("BeingNet::processBeingMove3")
+}
+
+Being *BeingNet::createBeing(const BeingId id,
+                             const int job)
+{
+    if (!actorManager)
+        return nullptr;
+
+    ActorTypeT type = ActorType::Unknown;
+    if (job <= 25 || (job >= 4001 && job <= 4049))
+        type = ActorType::Player;
+    else if (job >= 46 && job <= 1000)
+        type = ActorType::Npc;
+    else if (job > 1000 && job <= 2000)
+        type = ActorType::Monster;
+    else if (job == 45)
+        type = ActorType::Portal;
+
+    Being *const being = actorManager->createBeing(
+        id, type, fromInt(job, BeingTypeId));
+    return being;
+}
+
+void BeingNet::setSprite(Being *const being,
+                         const unsigned int slot,
+                         const int id,
+                         const std::string &color,
+                         const ItemColor colorId,
+                         const bool isWeapon,
+                         const bool isTempSprite)
+{
+    if (!being)
+        return;
+    being->updateSprite(slot, id, color, colorId, isWeapon, isTempSprite);
+}
+
+}  // namespace Ea
diff --git a/src/net/ea/beingnet.h b/src/net/ea/beingnet.h
new file mode 100644
index 000000000..c32a49b9f
--- /dev/null
+++ b/src/net/ea/beingnet.h
@@ -0,0 +1,59 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-2015  The ManaPlus Developers
+ *
+ *  This file is part of The ManaPlus Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NET_EA_BEING_H
+#define NET_EA_BEING_H
+
+#include "net/beinghandler.h"
+
+namespace Ea
+{
+    namespace BeingNet
+    {
+        extern bool mSync;
+        extern BeingId mSpawnId;
+
+        void processBeingRemove(Net::MessageIn &msg);
+        void processSkillDamage(Net::MessageIn &msg);
+        void processBeingAction(Net::MessageIn &msg);
+        void processBeingEmotion(Net::MessageIn &msg);
+        void processNameResponse(Net::MessageIn &msg);
+        void processPlayerStop(Net::MessageIn &msg);
+        void processPlayerMoveToAttack(Net::MessageIn &msg);
+        void processSkillNoDamage(Net::MessageIn &msg);
+        void processPvpMapMode(Net::MessageIn &msg);
+        void processBeingMove3(Net::MessageIn &msg);
+        Being *createBeing(const BeingId id,
+                           const int job);
+        void setSprite(Being *const being, const unsigned int slot,
+                       const int id,
+                       const std::string &color = "",
+                       const ItemColor colorId = ItemColor_one,
+                       const bool isWeapon = false,
+                       const bool isTempSprite = false);
+    }  // namespace Being
+
+}  // namespace Ea
+
+//extern bool Ea::BeingNet::mSync;
+
+#endif  // NET_EA_BEING_H