Remove ea/guildhandler and ea/guildrecv. Because guilds not works in legacy server anymore.

7 files changed, 592 insertions, 48 deletions

diff --git a/src/net/eathena/generalhandler.cpp b/src/net/eathena/generalhandler.cpp
index 36cac3d1d..8663cec06 100644
--- a/src/net/eathena/generalhandler.cpp
+++ b/src/net/eathena/generalhandler.cpp
@@ -198,7 +198,7 @@ void GeneralHandler::gameEnded() const
 {
     if (socialWindow)
     {
-        socialWindow->removeTab(Ea::taGuild);
+        socialWindow->removeTab(taGuild);
         socialWindow->removeTab(Ea::taParty);
     }
 
diff --git a/src/net/eathena/guildhandler.cpp b/src/net/eathena/guildhandler.cpp
index 42c0bd951..56a661da1 100644
--- a/src/net/eathena/guildhandler.cpp
+++ b/src/net/eathena/guildhandler.cpp
@@ -26,13 +26,18 @@
 #include "being/localplayer.h"
 #include "being/playerinfo.h"
 
-#include "net/ea/guildrecv.h"
+#include "gui/widgets/tabs/chat/guildtab.h"
 
+#include "net/eathena/guildrecv.h"
 #include "net/eathena/messageout.h"
 #include "net/eathena/protocolout.h"
 
+#include "utils/delete2.h"
+
 #include "debug.h"
 
+GuildTab *guildTab = nullptr;
+
 extern Net::GuildHandler *guildHandler;
 extern int packetVersion;
 
@@ -40,13 +45,25 @@ namespace EAthena
 {
 
 GuildHandler::GuildHandler() :
-    Ea::GuildHandler()
+    Net::GuildHandler()
 {
     guildHandler = this;
+    GuildRecv::showBasicInfo = false;
 }
 
 GuildHandler::~GuildHandler()
 {
+    delete2(guildTab);
+}
+
+void GuildHandler::clear() const
+{
+    taGuild = nullptr;
+}
+
+ChatTab *GuildHandler::getTab() const
+{
+    return guildTab;
 }
 
 void GuildHandler::create(const std::string &name) const
@@ -164,7 +181,7 @@ void GuildHandler::info() const
     // 3 = skill info
     // 4 = expulsion list
 
-    Ea::GuildRecv::showBasicInfo = true;
+    GuildRecv::showBasicInfo = true;
     createOutPacket(CMSG_GUILD_REQUEST_INFO);
     outMsg.writeInt32(0, "action");  // Request basic info
 }
diff --git a/src/net/eathena/guildhandler.h b/src/net/eathena/guildhandler.h
index 3ff9d5042..1a5248517 100644
--- a/src/net/eathena/guildhandler.h
+++ b/src/net/eathena/guildhandler.h
@@ -22,12 +22,14 @@
 #ifndef NET_EATHENA_GUILDHANDLER_H
 #define NET_EATHENA_GUILDHANDLER_H
 
-#include "net/ea/guildhandler.h"
+#include "net/guildhandler.h"
+
+class GuildTab;
 
 namespace EAthena
 {
 
-class GuildHandler final : public Ea::GuildHandler
+class GuildHandler final : public Net::GuildHandler
 {
     public:
         GuildHandler();
@@ -36,6 +38,10 @@ class GuildHandler final : public Ea::GuildHandler
 
         ~GuildHandler();
 
+        void clear() const override final;
+
+        ChatTab *getTab() const override final;
+
         void create(const std::string &name) const override final;
 
         void invite(const std::string &name) const override final;
@@ -89,11 +95,10 @@ class GuildHandler final : public Ea::GuildHandler
         void requestEmblem(const int guildId) const override final;
 };
 
+extern Guild *taGuild;
+
 }  // namespace EAthena
 
-namespace Ea
-{
-    extern Guild *taGuild;
-}
+extern GuildTab *guildTab;
 
 #endif  // NET_EATHENA_GUILDHANDLER_H
diff --git a/src/net/eathena/guildrecv.cpp b/src/net/eathena/guildrecv.cpp
index ec446edf5..2180f798f 100644
--- a/src/net/eathena/guildrecv.cpp
+++ b/src/net/eathena/guildrecv.cpp
@@ -21,35 +21,535 @@
 
 #include "net/eathena/guildrecv.h"
 
+#include "actormanager.h"
 #include "configuration.h"
+#include "notifymanager.h"
 
 #include "being/localplayer.h"
 #include "being/playerinfo.h"
 
+#include "enums/resources/notifytypes.h"
+
 #include "gui/windows/chatwindow.h"
+#include "gui/windows/skilldialog.h"
 #include "gui/windows/socialwindow.h"
 
 #include "gui/widgets/tabs/chat/guildtab.h"
 
-#include "net/ea/guildrecv.h"
-
 #include "net/messagein.h"
 
 #include "net/eathena/guildhandler.h"
 
+#include "utils/delete2.h"
+#include "utils/gettext.h"
+
 #include "debug.h"
 
 namespace EAthena
 {
 
+Guild *taGuild = nullptr;
+
+namespace GuildRecv
+{
+    bool showBasicInfo = false;
+}  // namespace GuildRecv
+
+void GuildRecv::processGuildCreateResponse(Net::MessageIn &msg)
+{
+    const uint8_t flag = msg.readUInt8("flag");
+
+    switch (flag)
+    {
+        case 0:
+            // Success
+            NotifyManager::notify(NotifyTypes::GUILD_CREATED);
+            break;
+
+        case 1:
+            // Already in a guild
+            NotifyManager::notify(NotifyTypes::GUILD_ALREADY);
+            break;
+
+        case 2:
+            // Unable to make (likely name already in use)
+            NotifyManager::notify(NotifyTypes::GUILD_ALREADY);
+            break;
+
+        case 3:
+            // Emperium check failed
+            NotifyManager::notify(NotifyTypes::GUILD_EMPERIUM_CHECK_FAILED);
+            break;
+
+        default:
+            // Unknown response
+            NotifyManager::notify(NotifyTypes::GUILD_ERROR);
+            break;
+    }
+}
+
+void GuildRecv::processGuildMasterOrMember(Net::MessageIn &msg)
+{
+    msg.readInt32("type");  // Type (0x57 for member, 0xd7 for master)
+}
+
+void GuildRecv::processGuildBasicInfo(Net::MessageIn &msg)
+{
+    const int guildId = msg.readInt32("guild id");
+    const int level = msg.readInt32("guild level");
+    const int members = msg.readInt32("connect member");
+    const int maxMembers = msg.readInt32("max member");
+    const int avgLevel = msg.readInt32("average level");
+    const int exp = msg.readInt32("exp");
+    const int nextExp = msg.readInt32("next exp");
+    msg.skip(12, "unused");
+    const int emblem = msg.readInt32("emblem id");
+    std::string name = msg.readString(24, "guild name");
+    std::string master = msg.readString(24, "master name");
+    std::string castle = msg.readString(16, "castles");
+    msg.readInt32("unused");
+
+    if (guildTab && showBasicInfo)
+    {
+        showBasicInfo = false;
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Guild name: %s"),
+            name.c_str()), ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Guild master: %s"),
+            master.c_str()), ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Guild level: %d"), level),
+            ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Online members: %d"),
+            members), ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Max members: %d"),
+            maxMembers), ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Average level: %d"),
+            avgLevel), ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Guild exp: %d"), exp),
+            ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Guild next exp: %d"),
+            nextExp), ChatMsgType::BY_SERVER);
+        // TRANSLATORS: guild info message
+        guildTab->chatLog(strprintf(_("Guild castle: %s"),
+            castle.c_str()), ChatMsgType::BY_SERVER);
+    }
+
+    Guild *const g = Guild::getGuild(CAST_S16(guildId));
+    if (!g)
+        return;
+    g->setName(name);
+    g->setEmblemId(emblem);
+}
+
+void GuildRecv::processGuildAlianceInfo(Net::MessageIn &msg)
+{
+    const int length = msg.readInt16("len");
+    if (length < 4)
+        return;
+    const int count = (length - 4) / 32;
+
+    for (int i = 0; i < count; i++)
+    {
+        msg.readInt32("opposition");
+        msg.readInt32("guild id");
+        msg.readString(24, "guild name");
+    }
+}
+
+void GuildRecv::processGuildMemberList(Net::MessageIn &msg)
+{
+    const int length = msg.readInt16("len");
+    if (length < 4)
+        return;
+    const int count = (length - 4) / 104;
+    if (!taGuild)
+    {
+        logger->log1("!taGuild");
+        return;
+    }
+
+    taGuild->clearMembers();
+
+    int onlineNum = 0;
+    int totalNum = 0;
+    for (int i = 0; i < count; i++)
+    {
+        const BeingId id = msg.readBeingId("account id");
+        const int charId = msg.readInt32("char id");
+        msg.readInt16("hair");
+        msg.readInt16("hair color");
+        const int gender = msg.readInt16("gender");
+        const int race = msg.readInt16("class");
+        const int level = msg.readInt16("level");
+        const int exp = msg.readInt32("exp");
+        const int online = msg.readInt32("online");
+        const int pos = msg.readInt32("position");
+        msg.skip(50, "unused");
+        std::string name = msg.readString(24, "name");
+
+        GuildMember *const m = taGuild->addMember(id, charId, name);
+        if (m)
+        {
+            m->setOnline(online);
+            m->setID(id);
+            m->setCharId(charId);
+            m->setGender(Being::intToGender(CAST_U8(gender)));
+            m->setLevel(level);
+            m->setExp(exp);
+            m->setPos(pos);
+            m->setRace(race);
+            if (actorManager)
+            {
+                Being *const being = actorManager->findBeingByName(
+                    name, ActorType::Player);
+                if (being)
+                {
+                    being->setGuildName(taGuild->getName());
+                    if (being->getLevel() != level)
+                    {
+                        being->setLevel(level);
+                        being->updateName();
+                    }
+                }
+            }
+            if (online)
+                onlineNum ++;
+            totalNum ++;
+        }
+    }
+    taGuild->sort();
+    if (actorManager)
+    {
+        actorManager->updatePlayerGuild();
+        actorManager->updatePlayerColors();
+    }
+    if (socialWindow)
+        socialWindow->updateGuildCounter(onlineNum, totalNum);
+}
+
+void GuildRecv::processGuildPosNameList(Net::MessageIn &msg)
+{
+    if (!taGuild)
+    {
+        logger->log1("!taGuild");
+        return;
+    }
+
+    const int length = msg.readInt16("len");
+    if (length < 4)
+        return;
+    const int count = (length - 4) / 28;
+
+    for (int i = 0; i < count; i++)
+    {
+        const int id = msg.readInt32("position id");
+        const std::string name = msg.readString(24, "position name");
+        taGuild->addPos(id, name);
+    }
+}
+
+void GuildRecv::processGuildPosInfoList(Net::MessageIn &msg)
+{
+    const int length = msg.readInt16("len");
+    if (length < 4)
+        return;
+    const int count = (length - 4) / 16;
+
+    for (int i = 0; i < count; i++)
+    {
+        msg.readInt32("id");
+        msg.readInt32("mode");
+        msg.readInt32("same id");
+        msg.readInt32("exp mode");
+    }
+}
+
+void GuildRecv::processGuildPositionChanged(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    msg.readInt16("len");
+    msg.readInt32("id");
+    msg.readInt32("mode");
+    msg.readInt32("same ip");
+    msg.readInt32("exp mode");
+    msg.readString(24, "name");
+}
+
+void GuildRecv::processGuildMemberPosChange(Net::MessageIn &msg)
+{
+    msg.readInt16("len");
+    const BeingId accountId = msg.readBeingId("account id");
+    const int charId = msg.readInt32("char id");
+    const int pos = msg.readInt32("position");
+    if (taGuild)
+    {
+        GuildMember *const m = taGuild->getMember(accountId, charId);
+        if (m)
+            m->setPos(pos);
+    }
+}
+
+void GuildRecv::processGuildEmblemData(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    const int length = msg.readInt16("len");
+
+    msg.readInt32("guild id");
+    msg.readInt32("emblem id");
+    if (length < 12)
+        return;
+    msg.skip(length - 12, "emblem data");
+}
+
+void GuildRecv::processGuildSkillInfo(Net::MessageIn &msg)
+{
+    const int count = (msg.readInt16("len") - 6) / 37;
+    msg.readInt16("skill points");
+
+    if (skillDialog)
+        skillDialog->hideSkills(SkillOwner::Guild);
+    for (int i = 0; i < count; i++)
+    {
+        const int skillId = msg.readInt16("skill id");
+        const SkillType::SkillType inf = static_cast<SkillType::SkillType>(
+            msg.readInt32("inf"));
+        const int level = msg.readInt16("skill level");
+        const int sp = msg.readInt16("sp");
+        const int range = msg.readInt16("range");
+        const std::string name = msg.readString(24, "skill name");
+        const Modifiable up = fromBool(msg.readUInt8("up flag"), Modifiable);
+        PlayerInfo::setSkillLevel(skillId, level);
+        if (skillDialog)
+        {
+            if (!skillDialog->updateSkill(skillId, range, up, inf, sp))
+            {
+                skillDialog->addSkill(SkillOwner::Guild,
+                    skillId, name, level, range, up, inf, sp);
+            }
+        }
+    }
+    if (skillDialog)
+        skillDialog->updateModels();
+}
+
+void GuildRecv::processGuildNotice(Net::MessageIn &msg)
+{
+    const std::string msg1 = msg.readString(60, "msg1");
+    const std::string msg2 = msg.readString(120, "msg2");
+    if (guildTab)
+    {
+        guildTab->chatLog(msg1, ChatMsgType::BY_SERVER);
+        guildTab->chatLog(msg2, ChatMsgType::BY_SERVER);
+    }
+}
+
+void GuildRecv::processGuildInvite(Net::MessageIn &msg)
+{
+    const int guildId = msg.readInt32("guild id");
+    const std::string guildName = msg.readString(24, "guild name");
+
+    if (socialWindow)
+        socialWindow->showGuildInvite(guildName, guildId, "");
+}
+
+void GuildRecv::processGuildInviteAck(Net::MessageIn &msg)
+{
+    const uint8_t flag = msg.readUInt8("flag");
+    if (!guildTab)
+        return;
+
+    switch (flag)
+    {
+        case 0:
+            NotifyManager::notify(NotifyTypes::GUILD_INVITE_FAILED);
+            break;
+
+        case 1:
+            NotifyManager::notify(NotifyTypes::GUILD_INVITE_REJECTED);
+            break;
+
+        case 2:
+            NotifyManager::notify(NotifyTypes::GUILD_INVITE_JOINED);
+            break;
+
+        case 3:
+            NotifyManager::notify(NotifyTypes::GUILD_INVITE_FULL);
+            break;
+
+        default:
+            NotifyManager::notify(NotifyTypes::GUILD_INVITE_ERROR);
+            break;
+    }
+}
+
+void GuildRecv::processGuildLeave(Net::MessageIn &msg)
+{
+    const std::string nick = msg.readString(24, "nick");
+    msg.readString(40, "message");
+
+    if (taGuild)
+        taGuild->removeMember(nick);
+
+    if (!localPlayer)
+        return;
+
+    if (nick == localPlayer->getName())
+    {
+        if (taGuild)
+        {
+            taGuild->removeFromMembers();
+            taGuild->clearMembers();
+            localPlayer->removeGuild(taGuild->getId());
+        }
+        NotifyManager::notify(NotifyTypes::GUILD_LEFT);
+        delete2(guildTab)
+
+        if (socialWindow && taGuild)
+            socialWindow->removeTab(taGuild);
+        if (actorManager)
+            actorManager->updatePlayerColors();
+    }
+    else
+    {
+        NotifyManager::notify(NotifyTypes::GUILD_USER_LEFT, nick);
+        if (actorManager)
+        {
+            Being *const b = actorManager->findBeingByName(
+                nick, ActorType::Player);
+
+            if (b)
+                b->clearGuilds();
+            if (taGuild)
+                taGuild->removeMember(nick);
+        }
+    }
+}
+
+void GuildRecv::processGuildMessage(Net::MessageIn &msg)
+{
+    const int msgLength = msg.readInt16("len") - 4;
+
+    if (msgLength <= 0)
+        return;
+    if (guildTab)
+    {
+        std::string chatMsg = msg.readString(msgLength, "message");
+        const size_t pos = chatMsg.find(" : ", 0);
+        if (pos != std::string::npos)
+        {
+            const std::string sender_name = chatMsg.substr(0, pos);
+            chatMsg.erase(0, pos + 3);
+            trim(chatMsg);
+            guildTab->chatLog(sender_name, chatMsg);
+        }
+        else
+        {
+            guildTab->chatLog(chatMsg, ChatMsgType::BY_SERVER);
+        }
+    }
+    else
+    {
+        DEBUGLOGSTR("invisible guild?");
+        msg.readString(msgLength, "message");
+    }
+}
+
+void GuildRecv::processGuildSkillUp(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    msg.readInt16("skill id");
+    msg.readInt16("level");
+    msg.readInt16("sp");
+    msg.readInt16("range");
+    msg.readUInt8("unused?");
+}
+
+void GuildRecv::processGuildReqAlliance(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    msg.readInt32("id");
+    msg.readString(24, "name");
+}
+
+void GuildRecv::processGuildReqAllianceAck(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    msg.readInt32("flag");
+}
+
+void GuildRecv::processGuildDelAlliance(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    msg.readInt32("guild id");
+    msg.readInt32("flag");
+}
+
+void GuildRecv::processGuildOppositionAck(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    msg.readUInt8("flag");
+}
+
+void GuildRecv::processGuildBroken(Net::MessageIn &msg)
+{
+    UNIMPLIMENTEDPACKET;
+    msg.readInt32("flag");
+}
+
+void GuildRecv::processGuildExpulsionContinue(const std::string &nick)
+{
+    if (taGuild)
+        taGuild->removeMember(nick);
+
+    if (!localPlayer)
+        return;
+
+    if (nick == localPlayer->getName())
+    {
+        if (taGuild)
+        {
+            taGuild->removeFromMembers();
+            taGuild->clearMembers();
+        }
+        NotifyManager::notify(NotifyTypes::GUILD_KICKED);
+        delete2(guildTab)
+
+        if (socialWindow && taGuild)
+            socialWindow->removeTab(taGuild);
+        if (actorManager)
+            actorManager->updatePlayerColors();
+    }
+    else
+    {
+        NotifyManager::notify(NotifyTypes::GUILD_USER_KICKED, nick);
+        if (actorManager)
+        {
+            Being *const b = actorManager->findBeingByName(
+                nick, ActorType::Player);
+
+            if (b)
+                b->clearGuilds();
+            if (taGuild)
+                taGuild->removeMember(nick);
+        }
+    }
+}
+
 void GuildRecv::processGuildUpdateCoords(Net::MessageIn &msg)
 {
     const BeingId id = msg.readBeingId("account id");
     const int x = msg.readInt16("x");
     const int y = msg.readInt16("y");
-    if (Ea::taGuild)
+    if (taGuild)
     {
-        GuildMember *const m = Ea::taGuild->getMember(id);
+        GuildMember *const m = taGuild->getMember(id);
         if (m)
         {
             m->setX(x);
@@ -74,15 +574,15 @@ void GuildRecv::processGuildPositionInfo(Net::MessageIn &msg)
 
     g->setName(guildName);
     g->setEmblemId(emblem);
-    if (!Ea::taGuild)
-        Ea::taGuild = g;
+    if (!taGuild)
+        taGuild = g;
     if (!guildTab && chatWindow)
     {
         guildTab = new GuildTab(chatWindow);
         if (config.getBoolValue("showChatHistory"))
             guildTab->loadFromLogFile("#Guild");
         if (localPlayer)
-            localPlayer->addGuild(Ea::taGuild);
+            localPlayer->addGuild(taGuild);
         guildHandler->memberList();
     }
 
@@ -102,9 +602,9 @@ void GuildRecv::processGuildMemberLogin(Net::MessageIn &msg)
         msg.readInt16("sex")));
     msg.readInt16("hair");
     msg.readInt16("hair color");
-    if (Ea::taGuild)
+    if (taGuild)
     {
-        GuildMember *const m = Ea::taGuild->getMember(accountId, charId);
+        GuildMember *const m = taGuild->getMember(accountId, charId);
         if (m)
         {
             m->setOnline(online);
@@ -123,7 +623,7 @@ void GuildRecv::processGuildExpulsion(Net::MessageIn &msg)
     const std::string nick = msg.readString(24, "name");
     msg.readString(40, "message");
 
-    Ea::GuildRecv::processGuildExpulsionContinue(nick);
+    GuildRecv::processGuildExpulsionContinue(nick);
 }
 
 void GuildRecv::processGuildExpulsionList(Net::MessageIn &msg)
diff --git a/src/net/eathena/guildrecv.h b/src/net/eathena/guildrecv.h
index 408b494c6..6bec88f54 100644
--- a/src/net/eathena/guildrecv.h
+++ b/src/net/eathena/guildrecv.h
@@ -22,6 +22,8 @@
 #ifndef NET_EATHENA_GUILDRECV_H
 #define NET_EATHENA_GUILDRECV_H
 
+#include <string>
+
 namespace Net
 {
     class MessageIn;
@@ -34,6 +36,31 @@ namespace EAthena
 {
     namespace GuildRecv
     {
+        extern bool showBasicInfo;
+
+        void processGuildCreateResponse(Net::MessageIn &msg);
+        void processGuildMasterOrMember(Net::MessageIn &msg);
+        void processGuildBasicInfo(Net::MessageIn &msg);
+        void processGuildAlianceInfo(Net::MessageIn &msg);
+        void processGuildMemberList(Net::MessageIn &msg);
+        void processGuildPosNameList(Net::MessageIn &msg);
+        void processGuildPosInfoList(Net::MessageIn &msg);
+        void processGuildPositionChanged(Net::MessageIn &msg);
+        void processGuildMemberPosChange(Net::MessageIn &msg);
+        void processGuildEmblemData(Net::MessageIn &msg);
+        void processGuildSkillInfo(Net::MessageIn &msg);
+        void processGuildNotice(Net::MessageIn &msg);
+        void processGuildInvite(Net::MessageIn &msg);
+        void processGuildInviteAck(Net::MessageIn &msg);
+        void processGuildLeave(Net::MessageIn &msg);
+        void processGuildMessage(Net::MessageIn &msg);
+        void processGuildSkillUp(Net::MessageIn &msg);
+        void processGuildReqAlliance(Net::MessageIn &msg);
+        void processGuildReqAllianceAck(Net::MessageIn &msg);
+        void processGuildDelAlliance(Net::MessageIn &msg);
+        void processGuildOppositionAck(Net::MessageIn &msg);
+        void processGuildBroken(Net::MessageIn &msg);
+        void processGuildExpulsionContinue(const std::string &nick);
         void processGuildUpdateCoords(Net::MessageIn &msg);
         void processGuildPositionInfo(Net::MessageIn &msg);
         void processGuildMemberLogin(Net::MessageIn &msg);
@@ -42,12 +69,8 @@ namespace EAthena
         void processGuildEmblem(Net::MessageIn &msg);
         void processOnlineInfo(Net::MessageIn &msg);
     }  // namespace GuildRecv
-}  // namespace EAthena
-
-namespace Ea
-{
     extern Guild *taGuild;
-}
+}  // namespace EAthena
 
 extern GuildTab *guildTab;
 
diff --git a/src/net/eathena/network.cpp b/src/net/eathena/network.cpp
index 9361c4723..d75d7fc6d 100644
--- a/src/net/eathena/network.cpp
+++ b/src/net/eathena/network.cpp
@@ -30,7 +30,6 @@
 #include "net/ea/charserverrecv.h"
 #include "net/ea/chatrecv.h"
 #include "net/ea/gamerecv.h"
-#include "net/ea/guildrecv.h"
 #include "net/ea/inventoryrecv.h"
 #include "net/ea/itemrecv.h"
 #include "net/ea/loginrecv.h"
diff --git a/src/net/eathena/packetsin.inc b/src/net/eathena/packetsin.inc
index 3c7003831..d180a84a4 100644
--- a/src/net/eathena/packetsin.inc
+++ b/src/net/eathena/packetsin.inc
@@ -141,33 +141,33 @@ packet(SMSG_FRIENDS_REQUEST_ACK,           0x0209,  36, &FriendsRecv::processReq
 packet(SMSG_GM_CHAT,                       0x009a,  -1, &ChatRecv::processGmChat,                       0);
 packet(SMSG_GM_CHAT2,                      0x01c3,  -1, &ChatRecv::processGmChat2,                      0);
 packet(SMSG_GRAFFITI_VISIBLE,              0x01c9,  97, &BeingRecv::processGraffiti,                    0);
-packet(SMSG_GUILD_ALIANCE_INFO,            0x014c,  -1, &Ea::GuildRecv::processGuildAlianceInfo,        0);
+packet(SMSG_GUILD_ALIANCE_INFO,            0x014c,  -1, &GuildRecv::processGuildAlianceInfo,        0);
 packet(SMSG_GUILD_ALLIANCE_ADDED_DISABLED, 0x0185,  34, nullptr,                                        0);
-packet(SMSG_GUILD_BASIC_INFO,              0x01b6, 114, &Ea::GuildRecv::processGuildBasicInfo,          0);
-packet(SMSG_GUILD_BROKEN,                  0x015e,   6, &Ea::GuildRecv::processGuildBroken,             0);
-packet(SMSG_GUILD_CREATE_RESPONSE,         0x0167,   3, &Ea::GuildRecv::processGuildCreateResponse,     0);
-packet(SMSG_GUILD_DEL_ALLIANCE,            0x0184,  10, &Ea::GuildRecv::processGuildDelAlliance,        0);
+packet(SMSG_GUILD_BASIC_INFO,              0x01b6, 114, &GuildRecv::processGuildBasicInfo,          0);
+packet(SMSG_GUILD_BROKEN,                  0x015e,   6, &GuildRecv::processGuildBroken,             0);
+packet(SMSG_GUILD_CREATE_RESPONSE,         0x0167,   3, &GuildRecv::processGuildCreateResponse,     0);
+packet(SMSG_GUILD_DEL_ALLIANCE,            0x0184,  10, &GuildRecv::processGuildDelAlliance,        0);
 packet(SMSG_GUILD_EMBLEM,                  0x01b4,  12, &GuildRecv::processGuildEmblem,                 0);
-packet(SMSG_GUILD_EMBLEM_DATA,             0x0152,  -1, &Ea::GuildRecv::processGuildEmblemData,         0);
+packet(SMSG_GUILD_EMBLEM_DATA,             0x0152,  -1, &GuildRecv::processGuildEmblemData,         0);
 packet(SMSG_GUILD_EXPULSION_LIST,          0x0163,  -1, &GuildRecv::processGuildExpulsionList,          0);
-packet(SMSG_GUILD_INVITE,                  0x016a,  30, &Ea::GuildRecv::processGuildInvite,             0);
-packet(SMSG_GUILD_INVITE_ACK,              0x0169,   3, &Ea::GuildRecv::processGuildInviteAck,          0);
-packet(SMSG_GUILD_LEAVE,                   0x015a,  66, &Ea::GuildRecv::processGuildLeave,              0);
-packet(SMSG_GUILD_MASTER_OR_MEMBER,        0x014e,   6, &Ea::GuildRecv::processGuildMasterOrMember,     0);
-packet(SMSG_GUILD_MEMBER_LIST,             0x0154,  -1, &Ea::GuildRecv::processGuildMemberList,         0);
+packet(SMSG_GUILD_INVITE,                  0x016a,  30, &GuildRecv::processGuildInvite,             0);
+packet(SMSG_GUILD_INVITE_ACK,              0x0169,   3, &GuildRecv::processGuildInviteAck,          0);
+packet(SMSG_GUILD_LEAVE,                   0x015a,  66, &GuildRecv::processGuildLeave,              0);
+packet(SMSG_GUILD_MASTER_OR_MEMBER,        0x014e,   6, &GuildRecv::processGuildMasterOrMember,     0);
+packet(SMSG_GUILD_MEMBER_LIST,             0x0154,  -1, &GuildRecv::processGuildMemberList,         0);
 packet(SMSG_GUILD_MEMBER_LOGIN,            0x01f2,  20, &GuildRecv::processGuildMemberLogin,            0);
-packet(SMSG_GUILD_MEMBER_POS_CHANGE,       0x0156,  -1, &Ea::GuildRecv::processGuildMemberPosChange,    0);
-packet(SMSG_GUILD_MESSAGE,                 0x017f,  -1, &Ea::GuildRecv::processGuildMessage,            0);
-packet(SMSG_GUILD_NOTICE,                  0x016f, 182, &Ea::GuildRecv::processGuildNotice,             0);
-packet(SMSG_GUILD_OPPOSITION_ACK,          0x0181,   3, &Ea::GuildRecv::processGuildOppositionAck,      0);
-packet(SMSG_GUILD_POSITION_CHANGED,        0x0174,  -1, &Ea::GuildRecv::processGuildPositionChanged,    0);
+packet(SMSG_GUILD_MEMBER_POS_CHANGE,       0x0156,  -1, &GuildRecv::processGuildMemberPosChange,    0);
+packet(SMSG_GUILD_MESSAGE,                 0x017f,  -1, &GuildRecv::processGuildMessage,            0);
+packet(SMSG_GUILD_NOTICE,                  0x016f, 182, &GuildRecv::processGuildNotice,             0);
+packet(SMSG_GUILD_OPPOSITION_ACK,          0x0181,   3, &GuildRecv::processGuildOppositionAck,      0);
+packet(SMSG_GUILD_POSITION_CHANGED,        0x0174,  -1, &GuildRecv::processGuildPositionChanged,    0);
 packet(SMSG_GUILD_POSITION_INFO,           0x016c,  43, &GuildRecv::processGuildPositionInfo,           0);
-packet(SMSG_GUILD_POS_INFO_LIST,           0x0160,  -1, &Ea::GuildRecv::processGuildPosInfoList,        0);
-packet(SMSG_GUILD_POS_NAME_LIST,           0x0166,  -1, &Ea::GuildRecv::processGuildPosNameList,        0);
-packet(SMSG_GUILD_REQ_ALLIANCE,            0x0171,  30, &Ea::GuildRecv::processGuildReqAlliance,        0);
-packet(SMSG_GUILD_REQ_ALLIANCE_ACK,        0x0173,   3, &Ea::GuildRecv::processGuildReqAllianceAck,     0);
-packet(SMSG_GUILD_SKILL_INFO,              0x0162,  -1, &Ea::GuildRecv::processGuildSkillInfo,          0);
-packet(SMSG_GUILD_SKILL_UP,                0x010e,  11, &Ea::GuildRecv::processGuildSkillUp,            0);
+packet(SMSG_GUILD_POS_INFO_LIST,           0x0160,  -1, &GuildRecv::processGuildPosInfoList,        0);
+packet(SMSG_GUILD_POS_NAME_LIST,           0x0166,  -1, &GuildRecv::processGuildPosNameList,        0);
+packet(SMSG_GUILD_REQ_ALLIANCE,            0x0171,  30, &GuildRecv::processGuildReqAlliance,        0);
+packet(SMSG_GUILD_REQ_ALLIANCE_ACK,        0x0173,   3, &GuildRecv::processGuildReqAllianceAck,     0);
+packet(SMSG_GUILD_SKILL_INFO,              0x0162,  -1, &GuildRecv::processGuildSkillInfo,          0);
+packet(SMSG_GUILD_SKILL_UP,                0x010e,  11, &GuildRecv::processGuildSkillUp,            0);
 packet(SMSG_GUILD_UPDATE_COORDS,           0x01eb,  10, &GuildRecv::processGuildUpdateCoords,           0);
 packet(SMSG_IGNORE_ALL_RESPONSE,           0x00d2,   4, &Ea::ChatRecv::processIgnoreAllResponse,        0);
 packet(SMSG_IGNORE_NICK_ACK,               0x00d1,   4, &ChatRecv::processIgnoreNickAck,                0);