summaryrefslogtreecommitdiff
path: root/src/net/ea
diff options
context:
space:
mode:
Diffstat (limited to 'src/net/ea')
-rw-r--r--src/net/ea/eaprotocol.h3
-rw-r--r--src/net/ea/inventoryhandler.cpp624
-rw-r--r--src/net/ea/inventoryhandler.h204
-rw-r--r--src/net/ea/partyhandler.cpp2
4 files changed, 832 insertions, 1 deletions
diff --git a/src/net/ea/eaprotocol.h b/src/net/ea/eaprotocol.h
index 11cc0180d..fae3651a8 100644
--- a/src/net/ea/eaprotocol.h
+++ b/src/net/ea/eaprotocol.h
@@ -42,4 +42,7 @@ enum
EA_SPRITE_VECTOREND
};
+static const int INVENTORY_OFFSET = 2;
+static const int STORAGE_OFFSET = 1;
+
#endif
diff --git a/src/net/ea/inventoryhandler.cpp b/src/net/ea/inventoryhandler.cpp
new file mode 100644
index 000000000..1b13b1121
--- /dev/null
+++ b/src/net/ea/inventoryhandler.cpp
@@ -0,0 +1,624 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2004-2009 The Mana World Development Team
+ * Copyright (C) 2009-2010 The Mana Developers
+ * Copyright (C) 2011 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/inventoryhandler.h"
+
+#include "inventory.h"
+#include "localplayer.h"
+#include "log.h"
+
+#include "gui/ministatus.h"
+
+#include "net/messagein.h"
+
+#include "net/ea/eaprotocol.h"
+
+#include "utils/gettext.h"
+
+#include "debug.h"
+
+const Equipment::Slot EQUIP_POINTS[Equipment::EQUIP_VECTOREND] =
+{
+ Equipment::EQUIP_LEGS_SLOT,
+ Equipment::EQUIP_FIGHT1_SLOT,
+ Equipment::EQUIP_GLOVES_SLOT,
+ Equipment::EQUIP_RING2_SLOT,
+ Equipment::EQUIP_RING1_SLOT,
+ Equipment::EQUIP_FIGHT2_SLOT,
+ Equipment::EQUIP_FEET_SLOT,
+ Equipment::EQUIP_NECK_SLOT,
+ Equipment::EQUIP_HEAD_SLOT,
+ Equipment::EQUIP_TORSO_SLOT,
+ Equipment::EQUIP_EVOL_RING1_SLOT,
+ Equipment::EQUIP_EVOL_RING2_SLOT,
+ Equipment::EQUIP_PROJECTILE_SLOT,
+};
+
+// missing EQUIP_RING1_SLOT
+const Equipment::Slot EQUIP_CONVERT[] =
+{
+ Equipment::EQUIP_PROJECTILE_SLOT, // 0
+ Equipment::EQUIP_FEET_SLOT, // SPRITE_SHOE
+ Equipment::EQUIP_LEGS_SLOT, // SPRITE_BOTTOMCLOTHES
+ Equipment::EQUIP_TORSO_SLOT, // SPRITE_TOPCLOTHES
+ Equipment::EQUIP_PROJECTILE_SLOT, // 0
+ Equipment::EQUIP_NECK_SLOT, // SPRITE_RING
+ Equipment::EQUIP_PROJECTILE_SLOT, // 0
+ Equipment::EQUIP_HEAD_SLOT, // SPRITE_HAT
+ Equipment::EQUIP_RING2_SLOT, // 0
+ Equipment::EQUIP_GLOVES_SLOT, // SPRITE_GLOVES
+ Equipment::EQUIP_FIGHT1_SLOT, // SPRITE_WEAPON
+ Equipment::EQUIP_FIGHT2_SLOT, // SPRITE_SHIELD
+ Equipment::EQUIP_EVOL_RING1_SLOT, // SPRITE_EVOL1
+ Equipment::EQUIP_EVOL_RING2_SLOT, // SPRITE_EVOL2
+ Equipment::EQUIP_PROJECTILE_SLOT, // 0
+};
+
+namespace Ea
+{
+
+InventoryHandler::InventoryHandler()
+{
+ mStorage = 0;
+ mStorageWindow = 0;
+ mDebugInventory = true;
+}
+
+InventoryHandler::~InventoryHandler()
+{
+ if (mStorageWindow)
+ {
+ mStorageWindow->close();
+ mStorageWindow = 0;
+ }
+
+ delete mStorage;
+ mStorage = 0;
+}
+
+bool InventoryHandler::canSplit(const Item *item A_UNUSED) const
+{
+ return false;
+}
+
+void InventoryHandler::splitItem(const Item *item A_UNUSED,
+ int amount A_UNUSED)
+{
+ // Not implemented for eAthena (possible?)
+}
+
+void InventoryHandler::moveItem(int oldIndex A_UNUSED, int newIndex A_UNUSED)
+{
+ // Not implemented for eAthena (possible?)
+}
+
+void InventoryHandler::openStorage(int type A_UNUSED)
+{
+ // Doesn't apply to eAthena, since opening happens through NPCs?
+}
+
+size_t InventoryHandler::getSize(int type) const
+{
+ switch (type)
+ {
+ case Inventory::INVENTORY:
+ return 100;
+ case Inventory::STORAGE:
+ return 0; // Comes from server after items
+ case Inventory::TRADE:
+ return 12;
+ case GUILD_STORAGE:
+ return 0; // Comes from server after items
+ default:
+ return 0;
+ }
+}
+int InventoryHandler::convertFromServerSlot(int serverSlot) const
+{
+ if (serverSlot < 0 || serverSlot > 13)
+ return 0;
+
+ return EQUIP_CONVERT[serverSlot];
+}
+
+int InventoryHandler::getSlot(int eAthenaSlot)
+{
+ if (eAthenaSlot == 0)
+ return Equipment::EQUIP_VECTOREND;
+
+ if (eAthenaSlot & 0x8000)
+ return Equipment::EQUIP_PROJECTILE_SLOT;
+
+ int mask = 1;
+ int position = 0;
+ while (!(eAthenaSlot & mask))
+ {
+ mask <<= 1;
+ position++;
+ }
+ return EQUIP_POINTS[position];
+}
+
+void InventoryHandler::processPlayerInventory(Net::MessageIn &msg, bool playerInvintory)
+{
+ int index, amount, itemId, arrow;
+ int cards[4], itemType;
+ unsigned char identified;
+ Inventory *inventory = 0;
+
+ if (player_node)
+ inventory = PlayerInfo::getInventory();
+
+ if (playerInvintory)
+ {
+ if (PlayerInfo::getEquipment())
+ {
+ // Clear inventory - this will be a complete refresh
+ mEquips.clear();
+ PlayerInfo::getEquipment()->setBackend(&mEquips);
+ }
+
+ if (inventory)
+ inventory->clear();
+ }
+ else
+ {
+ mInventoryItems.clear();
+ }
+
+ msg.readInt16(); // length
+ int number = (msg.getLength() - 4) / 18;
+
+ for (int loop = 0; loop < number; loop++)
+ {
+ index = msg.readInt16();
+ itemId = msg.readInt16();
+ itemType = msg.readInt8();
+ identified = msg.readInt8();
+ amount = msg.readInt16();
+ arrow = msg.readInt16();
+ for (int i = 0; i < 4; i++)
+ cards[i] = msg.readInt16();
+
+ index -= ((msg.getId() == playerInvintory) ?
+ INVENTORY_OFFSET : STORAGE_OFFSET);
+
+ if (mDebugInventory)
+ {
+ logger->log("Index: %d, ID: %d, Type: %d, Identified: %d, "
+ "Qty: %d, Cards: %d, %d, %d, %d",
+ index, itemId, itemType, identified, amount,
+ cards[0], cards[1], cards[2], cards[3]);
+ }
+
+ if (serverVersion < 1 && identified > 1)
+ identified = 1;
+
+ if (playerInvintory)
+ {
+ // Trick because arrows are not considered equipment
+ bool isEquipment = arrow & 0x8000;
+
+ if (inventory)
+ {
+ inventory->setItem(index, itemId, amount,
+ 0, identified, isEquipment);
+ }
+ }
+ else
+ {
+ mInventoryItems.push_back(Ea::InventoryItem(index, itemId,
+ amount, 0, identified, false));
+ }
+ }
+}
+
+void InventoryHandler::processPlayerStorageEquip(Net::MessageIn &msg)
+{
+ int index, amount, itemId, refine;
+ int cards[4], itemType;
+ unsigned char identified;
+
+ msg.readInt16(); // length
+ int number = (msg.getLength() - 4) / 20;
+
+ for (int loop = 0; loop < number; loop++)
+ {
+ index = msg.readInt16() - STORAGE_OFFSET;
+ itemId = msg.readInt16();
+ itemType = msg.readInt8();
+ identified = msg.readInt8();
+ amount = 1;
+ msg.readInt16(); // Equip Point?
+ msg.readInt16(); // Another Equip Point?
+ msg.readInt8(); // Attribute (broken)
+ refine = msg.readInt8();
+ for (int i = 0; i < 4; i++)
+ cards[i] = msg.readInt16();
+
+ if (mDebugInventory)
+ {
+ logger->log("Index: %d, ID: %d, Type: %d, Identified: %d, "
+ "Qty: %d, Cards: %d, %d, %d, %d, Refine: %d",
+ index, itemId, itemType, identified, amount,
+ cards[0], cards[1], cards[2], cards[3],
+ refine);
+ }
+
+ if (serverVersion < 1 && identified > 1)
+ identified = 1;
+
+ mInventoryItems.push_back(Ea::InventoryItem(index,
+ itemId, amount, refine, identified, false));
+ }
+}
+
+void InventoryHandler::processPlayerInventoryAdd(Net::MessageIn &msg)
+{
+ int index, amount, itemId, equipType, refine;
+ int cards[4], itemType;
+ unsigned char identified;
+ int floorId;
+
+ Inventory *inventory = 0;
+ if (player_node)
+ inventory = PlayerInfo::getInventory();
+
+ if (PlayerInfo::getEquipment()
+ && !PlayerInfo::getEquipment()->getBackend())
+ { // look like SMSG_PLAYER_INVENTORY was not received
+ mEquips.clear();
+ PlayerInfo::getEquipment()->setBackend(&mEquips);
+ }
+ index = msg.readInt16() - INVENTORY_OFFSET;
+ amount = msg.readInt16();
+ itemId = msg.readInt16();
+ identified = msg.readInt8();
+ msg.readInt8(); // attribute
+ refine = msg.readInt8();
+ for (int i = 0; i < 4; i++)
+ cards[i] = msg.readInt16();
+ equipType = msg.readInt16();
+ itemType = msg.readInt8();
+
+ const ItemInfo &itemInfo = ItemDB::get(itemId);
+
+ unsigned char err = msg.readInt8();
+ if (mSentPickups.empty())
+ {
+ floorId = 0;
+ }
+ else
+ {
+ floorId = mSentPickups.front();
+ mSentPickups.pop();
+ }
+
+ if (err)
+ {
+ if (player_node)
+ {
+ player_node->pickedUp(itemInfo, 0, identified,
+ floorId, err);
+ }
+ }
+ else
+ {
+ if (player_node)
+ {
+ player_node->pickedUp(itemInfo, amount,
+ identified, floorId, PICKUP_OKAY);
+ }
+
+ if (inventory)
+ {
+ Item *item = inventory->getItem(index);
+
+ if (item && item->getId() == itemId)
+ amount += inventory->getItem(index)->getQuantity();
+
+ if (serverVersion < 1 && identified > 1)
+ identified = 1;
+
+ inventory->setItem(index, itemId, amount, refine,
+ identified, equipType != 0);
+ }
+ }
+}
+
+void InventoryHandler::processPlayerInventoryRemove(Net::MessageIn &msg)
+{
+ int index, amount;
+ Inventory *inventory = 0;
+ if (player_node)
+ inventory = PlayerInfo::getInventory();
+
+ index = msg.readInt16() - INVENTORY_OFFSET;
+ amount = msg.readInt16();
+ if (inventory)
+ {
+ if (Item *item = inventory->getItem(index))
+ {
+ item->increaseQuantity(-amount);
+ if (item->getQuantity() == 0)
+ inventory->removeItemAt(index);
+ if (miniStatusWindow)
+ miniStatusWindow->updateArrows();
+ }
+ }
+}
+
+void InventoryHandler::processPlayerInventoryUse(Net::MessageIn &msg)
+{
+ int index, amount;
+ Inventory *inventory = 0;
+ if (player_node)
+ inventory = PlayerInfo::getInventory();
+
+ index = msg.readInt16() - INVENTORY_OFFSET;
+ msg.readInt16(); // item id
+ msg.readInt32(); // id
+ amount = msg.readInt16();
+ msg.readInt8(); // type
+
+ if (inventory)
+ {
+ if (Item *item = inventory->getItem(index))
+ {
+ if (amount)
+ item->setQuantity(amount);
+ else
+ inventory->removeItemAt(index);
+ }
+ }
+}
+
+void InventoryHandler::processItemUseResponse(Net::MessageIn &msg)
+{
+ int index, amount;
+ Inventory *inventory = 0;
+ if (player_node)
+ inventory = PlayerInfo::getInventory();
+
+ index = msg.readInt16() - INVENTORY_OFFSET;
+ amount = msg.readInt16();
+
+ if (msg.readInt8() == 0)
+ {
+ SERVER_NOTICE(_("Failed to use item."))
+ }
+ else
+ {
+ if (inventory)
+ {
+ if (Item *item = inventory->getItem(index))
+ {
+ if (amount)
+ item->setQuantity(amount);
+ else
+ inventory->removeItemAt(index);
+ }
+ }
+ }
+}
+
+void InventoryHandler::processPlayerStorageStatus(Net::MessageIn &msg)
+{
+ /*
+ * This is the closest we get to an "Open Storage" packet from the
+ * server. It always comes after the two SMSG_PLAYER_STORAGE_...
+ * packets that update storage contents.
+ */
+ msg.readInt16(); // Used count
+ int size = msg.readInt16(); // Max size
+
+ if (!mStorage)
+ mStorage = new Inventory(Inventory::STORAGE, size);
+
+ Ea::InventoryItems::iterator it = mInventoryItems.begin();
+ Ea::InventoryItems::iterator it_end = mInventoryItems.end();
+ for (; it != it_end; ++it)
+ {
+ mStorage->setItem((*it).slot, (*it).id, (*it).quantity,
+ (*it).refine, (*it).color, (*it).equip);
+ }
+ mInventoryItems.clear();
+
+ if (!mStorageWindow)
+ mStorageWindow = new InventoryWindow(mStorage);
+}
+
+void InventoryHandler::processPlayerStorageAdd(Net::MessageIn &msg)
+{
+ int index, amount, itemId, refine;
+ unsigned char identified;
+ int cards[4];
+
+ // Move an item into storage
+ index = msg.readInt16() - STORAGE_OFFSET;
+ amount = msg.readInt32();
+ itemId = msg.readInt16();
+ identified = msg.readInt8();
+ msg.readInt8(); // attribute
+ refine = msg.readInt8();
+ for (int i = 0; i < 4; i++)
+ cards[i] = msg.readInt16();
+
+ if (Item *item = mStorage->getItem(index))
+ {
+ item->setId(itemId, identified);
+ item->increaseQuantity(amount);
+ }
+ else
+ {
+ if (mStorage)
+ {
+ if (serverVersion < 1 && identified > 1)
+ identified = 1;
+
+ mStorage->setItem(index, itemId, amount, refine,
+ identified, false);
+ }
+ }
+}
+
+void InventoryHandler::processPlayerStorageRemove(Net::MessageIn &msg)
+{
+ int index, amount;
+
+ // Move an item out of storage
+ index = msg.readInt16() - STORAGE_OFFSET;
+ amount = msg.readInt16();
+ if (mStorage)
+ {
+ if (Item *item = mStorage->getItem(index))
+ {
+ item->increaseQuantity(-amount);
+ if (item->getQuantity() == 0)
+ mStorage->removeItemAt(index);
+ }
+ }
+}
+
+void InventoryHandler::processPlayerStorageClose(Net::MessageIn &msg A_UNUSED)
+{
+ // Storage access has been closed
+
+ // Storage window deletes itself
+ mStorageWindow = 0;
+
+ if (mStorage)
+ mStorage->clear();
+
+ delete mStorage;
+ mStorage = 0;
+}
+
+void InventoryHandler::processPlayerEquipment(Net::MessageIn &msg)
+{
+ int index, itemId, equipType, refine;
+ int number;
+ unsigned char identified;
+
+ Inventory *inventory = 0;
+ if (player_node)
+ inventory = PlayerInfo::getInventory();
+
+ msg.readInt16(); // length
+ if (PlayerInfo::getEquipment()
+ && !PlayerInfo::getEquipment()->getBackend())
+ { // look like SMSG_PLAYER_INVENTORY was not received
+ mEquips.clear();
+ PlayerInfo::getEquipment()->setBackend(&mEquips);
+ }
+ number = (msg.getLength() - 4) / 20;
+
+ for (int loop = 0; loop < number; loop++)
+ {
+ index = msg.readInt16() - INVENTORY_OFFSET;
+ itemId = msg.readInt16();
+ int itemType = msg.readInt8(); // type
+ identified = msg.readInt8(); // identify flag
+
+ msg.readInt16(); // equip type
+ equipType = msg.readInt16();
+ msg.readInt8(); // attribute
+ refine = msg.readInt8();
+ msg.skip(8); // card
+
+
+ if (mDebugInventory)
+ {
+ logger->log("Index: %d, ID: %d, Type: %d, Identified: %d",
+ index, itemId, itemType, identified);
+ }
+
+ if (serverVersion < 1 && identified > 1)
+ identified = 1;
+
+ if (inventory)
+ {
+ inventory->setItem(index, itemId, 1, refine,
+ identified, true);
+ }
+
+ if (equipType)
+ mEquips.setEquipment(getSlot(equipType), index);
+
+ }
+}
+
+void InventoryHandler::processPlayerEquip(Net::MessageIn &msg)
+{
+ int index, equipType;
+ int flag;
+
+ index = msg.readInt16() - INVENTORY_OFFSET;
+ equipType = msg.readInt16();
+ flag = msg.readInt8();
+
+ if (!flag)
+ SERVER_NOTICE(_("Unable to equip."))
+ else
+ mEquips.setEquipment(getSlot(equipType), index);
+}
+
+void InventoryHandler::processPlayerUnEquip(Net::MessageIn &msg)
+{
+ int index, equipType;
+ int flag;
+
+ index = msg.readInt16() - INVENTORY_OFFSET;
+ equipType = msg.readInt16();
+ flag = msg.readInt8();
+
+ if (flag)
+ mEquips.setEquipment(getSlot(equipType), -1);
+ if (miniStatusWindow && equipType & 0x8000)
+ miniStatusWindow->updateArrows();
+}
+
+void InventoryHandler::processPlayerAttackRange(Net::MessageIn &msg)
+{
+ int range = msg.readInt16();
+ if (player_node)
+ player_node->setAttackRange(range);
+ PlayerInfo::setStatBase(ATTACK_RANGE, range);
+ PlayerInfo::setStatMod(ATTACK_RANGE, 0);
+}
+
+void InventoryHandler::processPlayerArrowEquip(Net::MessageIn &msg)
+{
+ int index = msg.readInt16();
+
+ if (index <= 1)
+ return;
+
+ index -= INVENTORY_OFFSET;
+
+ mEquips.setEquipment(Equipment::EQUIP_PROJECTILE_SLOT, index);
+
+ if (miniStatusWindow)
+ miniStatusWindow->updateArrows();
+}
+
+} // namespace Ea
diff --git a/src/net/ea/inventoryhandler.h b/src/net/ea/inventoryhandler.h
new file mode 100644
index 000000000..1f1f8d296
--- /dev/null
+++ b/src/net/ea/inventoryhandler.h
@@ -0,0 +1,204 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2004-2009 The Mana World Development Team
+ * Copyright (C) 2009-2010 The Mana Developers
+ * Copyright (C) 2011 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_INVENTORYHANDLER_H
+#define NET_EA_INVENTORYHANDLER_H
+
+#include "equipment.h"
+#include "inventory.h"
+#include "log.h"
+#include "playerinfo.h"
+
+#include "gui/inventorywindow.h"
+
+#include "net/inventoryhandler.h"
+#include "net/messagein.h"
+#include "net/net.h"
+
+#include <vector>
+#include <queue>
+
+#ifdef __GNUC__
+#define A_UNUSED __attribute__ ((unused))
+#else
+#define A_UNUSED
+#endif
+
+namespace Ea
+{
+
+class EquipBackend : public Equipment::Backend
+{
+ public:
+ EquipBackend()
+ {
+ memset(mEquipment, -1, sizeof(mEquipment));
+ }
+
+ Item *getEquipment(int index) const
+ {
+ int invyIndex = mEquipment[index];
+ if (invyIndex == -1)
+ return NULL;
+
+ return PlayerInfo::getInventory()->getItem(invyIndex);
+ }
+
+ void clear()
+ {
+ for (int i = 0; i < EQUIPMENT_SIZE; i++)
+ {
+ if (mEquipment[i] != -1)
+ {
+ Item* item = PlayerInfo::getInventory()->getItem(i);
+ if (item)
+ item->setEquipped(false);
+ }
+
+ mEquipment[i] = -1;
+ }
+ }
+
+ void setEquipment(int index, int inventoryIndex)
+ {
+ // Unequip existing item
+ Item* item = PlayerInfo::getInventory()
+ ->getItem(mEquipment[index]);
+
+ if (item)
+ item->setEquipped(false);
+
+ mEquipment[index] = inventoryIndex;
+
+ item = PlayerInfo::getInventory()->getItem(inventoryIndex);
+ if (item)
+ item->setEquipped(true);
+
+ if (inventoryWindow)
+ inventoryWindow->updateButtons();
+ }
+
+ private:
+ int mEquipment[EQUIPMENT_SIZE];
+};
+
+/**
+ * Used to cache storage data until we get size data for it.
+ */
+class InventoryItem
+{
+ public:
+ int slot;
+ int id;
+ int quantity;
+ unsigned char color;
+ int refine;
+ bool equip;
+
+ InventoryItem(int slot, int id, int quantity, int refine,
+ unsigned char color, bool equip)
+ {
+ this->slot = slot;
+ this->id = id;
+ this->quantity = quantity;
+ this->refine = refine;
+ this->color = color;
+ this->equip = equip;
+ }
+};
+
+typedef std::vector<InventoryItem> InventoryItems;
+
+class InventoryHandler : public Net::InventoryHandler
+{
+ public:
+ enum
+ {
+ GUILD_STORAGE = Inventory::TYPE_END,
+ CART
+ };
+
+ InventoryHandler();
+
+ ~InventoryHandler();
+
+ bool canSplit(const Item *item) const;
+
+ void splitItem(const Item *item, int amount);
+
+ void moveItem(int oldIndex, int newIndex);
+
+ void openStorage(int type);
+
+ size_t getSize(int type) const;
+
+ int convertFromServerSlot(int serverSlot) const;
+
+ void pushPickup(int floorId)
+ { mSentPickups.push(floorId); }
+
+ int getSlot(int eAthenaSlot);
+
+ void processPlayerInventory(Net::MessageIn &msg, bool playerInvintory);
+
+ void processPlayerStorageEquip(Net::MessageIn &msg);
+
+ void processPlayerInventoryAdd(Net::MessageIn &msg);
+
+ void processPlayerInventoryRemove(Net::MessageIn &msg);
+
+ void processPlayerInventoryUse(Net::MessageIn &msg);
+
+ void processItemUseResponse(Net::MessageIn &msg);
+
+ void processPlayerStorageStatus(Net::MessageIn &msg);
+
+ void processPlayerStorageAdd(Net::MessageIn &msg);
+
+ void processPlayerStorageRemove(Net::MessageIn &msg);
+
+ void processPlayerStorageClose(Net::MessageIn &msg);
+
+ void processPlayerEquipment(Net::MessageIn &msg);
+
+ void processPlayerEquip(Net::MessageIn &msg);
+
+ void processPlayerUnEquip(Net::MessageIn &msg);
+
+ void processPlayerAttackRange(Net::MessageIn &msg);
+
+ void processPlayerArrowEquip(Net::MessageIn &msg);
+
+ protected:
+ EquipBackend mEquips;
+ InventoryItems mInventoryItems;
+ Inventory *mStorage;
+ InventoryWindow *mStorageWindow;
+ bool mDebugInventory;
+
+ typedef std::queue<int> PickupQueue;
+ PickupQueue mSentPickups;
+};
+
+} // namespace Ea
+
+#endif // NET_EA_INVENTORYHANDLER_H
diff --git a/src/net/ea/partyhandler.cpp b/src/net/ea/partyhandler.cpp
index 1878bb567..f720f9f96 100644
--- a/src/net/ea/partyhandler.cpp
+++ b/src/net/ea/partyhandler.cpp
@@ -448,4 +448,4 @@ void PartyHandler::processPartyMessage(Net::MessageIn &msg)
}
}
-} // namespace TmwAthena
+} // namespace Ea
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-11-01 05:30:34 +0000