From cfede1d7d50541cf64b191844d537cb55880ce09 Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sat, 30 Jul 2011 21:36:51 +0300 Subject: Extract shared logic from inventoryhandler netcode to ea namespace. --- src/net/ea/eaprotocol.h | 3 + src/net/ea/inventoryhandler.cpp | 624 ++++++++++++++++++++++++++++++++++++++++ src/net/ea/inventoryhandler.h | 204 +++++++++++++ src/net/ea/partyhandler.cpp | 2 +- 4 files changed, 832 insertions(+), 1 deletion(-) create mode 100644 src/net/ea/inventoryhandler.cpp create mode 100644 src/net/ea/inventoryhandler.h (limited to 'src/net/ea') 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 . + */ + +#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 . + */ + +#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 +#include + +#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 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 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 -- cgit v1.2.3-70-g09d2