TmwAthena::InventoryRecv Namespace Reference

Functions
void	processPlayerEquipment (Net::MessageIn &msg)
void	processPlayerInventoryAdd (Net::MessageIn &msg)
void	processPlayerInventory (Net::MessageIn &msg)
void	processPlayerStorage (Net::MessageIn &msg)
void	processPlayerEquip (Net::MessageIn &msg)
void	processPlayerUnEquip (Net::MessageIn &msg)
void	processPlayerStorageEquip (Net::MessageIn &msg)
void	processPlayerStorageAdd (Net::MessageIn &msg)
void	processPlayerStorageRemove (Net::MessageIn &msg)
void	processPlayerInventoryRemove (Net::MessageIn &msg)
void	processPlayerInventoryUse (Net::MessageIn &msg)
int	getSlot (const int eAthenaSlot)

Variables
const EquipSlot::Type	EQUIP_POINTS [EquipSlot::VECTOREND]

Function Documentation

getSlot()

int TmwAthena::InventoryRecv::getSlot

(

const int

eAthenaSlot

)

Definition at line 546 of file inventoryrecv.cpp.

{
 if (eAthenaSlot == 0)
 return EquipSlot::VECTOREND;
 
 if ((eAthenaSlot & 0x8000) != 0)
 return inventoryHandler->getProjectileSlot();
 
 unsigned int mask = 1;
 int position = 0;
 while ((eAthenaSlot & mask) == 0U)
 {
 mask <<= 1;
 position++;
 }
 if (position >= EquipSlot::VECTOREND)
 return EquipSlot::VECTOREND;
 return CAST_S32(EQUIP_POINTS[position]);
}

References CAST_S32, EQUIP_POINTS, Net::InventoryHandler::getProjectileSlot(), inventoryHandler, and EquipSlot::VECTOREND.

Referenced by processPlayerEquip(), processPlayerEquipment(), and processPlayerUnEquip().

processPlayerEquip()

void TmwAthena::InventoryRecv::processPlayerEquip

(

Net::MessageIn &

msg

)

Definition at line 379 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerEquip")
 const int index = msg.readInt16("index") - INVENTORY_OFFSET;
 const int equipType = msg.readInt16("equip type");
 const uint8_t flag = msg.readUInt8("flag");
 
 if (flag == 0U)
 {
 NotifyManager::notify(NotifyTypes::EQUIP_FAILED);
 }
 else
 {
 Ea::InventoryRecv::mEquips.setEquipment(
 InventoryRecv::getSlot(equipType),
 index);
 }
 BLOCK_END("InventoryRecv::processPlayerEquip")
}

References BLOCK_END, BLOCK_START, NotifyTypes::EQUIP_FAILED, getSlot(), INVENTORY_OFFSET, Ea::InventoryRecv::mEquips, Actions::msg(), NotifyManager::notify(), and Ea::EquipBackend::setEquipment().

processPlayerEquipment()

void TmwAthena::InventoryRecv::processPlayerEquipment

(

Net::MessageIn &

msg

)

Definition at line 78 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerEquipment")
 Inventory *const inventory = localPlayer != nullptr
 ? PlayerInfo::getInventory() : nullptr;
 
 msg.readInt16("len");
 Equipment *const equipment = PlayerInfo::getEquipment();
 if ((equipment != nullptr) && (equipment->getBackend() == nullptr))
 { // look like SMSG_PLAYER_INVENTORY was not received
 Ea::InventoryRecv::mEquips.clear();
 equipment->setBackend(&Ea::InventoryRecv::mEquips);
 }
 const int number = (msg.getLength() - 4) / 20;
 
 for (int loop = 0; loop < number; loop++)
 {
 const int index = msg.readInt16("index") - INVENTORY_OFFSET;
 const int itemId = msg.readInt16("item id");
 const ItemTypeT itemType = static_cast<ItemTypeT>(
 msg.readUInt8("item type"));
 const uint8_t identified = msg.readUInt8("identify");
 msg.readInt16("equip type?");
 const int equipType = msg.readInt16("equip type");
 msg.readUInt8("attribute");
 const uint8_t refine = msg.readUInt8("refine");
 int cards[maxCards];
 for (int f = 0; f < maxCards; f++)
 cards[f] = msg.readUInt16("card");
 
 if (Ea::InventoryRecv::mDebugInventory)
 {
 logger->log("Index: %d, ID: %d, Type: %d, Identified: %d",
 index, itemId, CAST_S32(itemType), identified);
 }
 
 if (inventory != nullptr)
 {
 inventory->setItem(index,
 itemId,
 itemType,
 1,
 refine,
 ItemColor_one,
 fromBool(identified, Identified),
 Damaged_false,
 Favorite_false,
 Equipm_true,
 Equipped_false);
 inventory->setCards(index, cards, maxCards);
 }
 
 if (equipType != 0)
 {
 Ea::InventoryRecv::mEquips.setEquipment(
 InventoryRecv::getSlot(equipType),
 index);
 }
 }
 BLOCK_END("InventoryRecv::processPlayerEquipment")
}

References BLOCK_END, BLOCK_START, CAST_S32, Ea::EquipBackend::clear(), Damaged_false, Equipm_true, Equipped_false, Favorite_false, fromBool, Equipment::getBackend(), PlayerInfo::getEquipment(), PlayerInfo::getInventory(), getSlot(), INVENTORY_OFFSET, ItemColor_one, localPlayer, Logger::log(), logger, maxCards, Ea::InventoryRecv::mDebugInventory, Ea::InventoryRecv::mEquips, Actions::msg(), Equipment::setBackend(), Inventory::setCards(), Ea::EquipBackend::setEquipment(), and Inventory::setItem().

processPlayerInventory()

void TmwAthena::InventoryRecv::processPlayerInventory

(

Net::MessageIn &

msg

)

Definition at line 270 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerInventory")
 Inventory *const inventory = localPlayer != nullptr
 ? PlayerInfo::getInventory() : nullptr;
 
 if (PlayerInfo::getEquipment() != nullptr)
 {
 // Clear inventory - this will be a complete refresh
 Ea::InventoryRecv::mEquips.clear();
 PlayerInfo::getEquipment()->setBackend(&Ea::InventoryRecv::mEquips);
 }
 
 if (inventory != nullptr)
 inventory->clear();
 
 msg.readInt16("len");
 const int number = (msg.getLength() - 4) / 18;
 
 for (int loop = 0; loop < number; loop++)
 {
 int cards[maxCards];
 const int index = msg.readInt16("index") - INVENTORY_OFFSET;
 const int itemId = msg.readInt16("item id");
 const ItemTypeT itemType = static_cast<ItemTypeT>(
 msg.readUInt8("item type"));
 const uint8_t identified = msg.readUInt8("identified");
 const int amount = msg.readInt16("amount");
 const int arrow = msg.readInt16("arrow");
 for (int i = 0; i < maxCards; i++)
 cards[i] = msg.readUInt16("card");
 
 if (Ea::InventoryRecv::mDebugInventory)
 {
 logger->log("Index: %d, ID: %d, Type: %d, Identified: %d, "
 "Qty: %d, Cards: %d, %d, %d, %d",
 index, itemId, CAST_S32(itemType), identified, amount,
 cards[0], cards[1], cards[2], cards[3]);
 }
 
 // Trick because arrows are not considered equipment
 const bool isEquipment = (arrow & 0x8000) != 0;
 
 if (inventory != nullptr)
 {
 inventory->setItem(index,
 itemId,
 itemType,
 amount,
 0,
 ItemColor_one,
 fromBool(identified, Identified),
 Damaged_false,
 Favorite_false,
 fromBool(isEquipment, Equipm),
 Equipped_false);
 inventory->setCards(index, cards, maxCards);
 }
 }
 BLOCK_END("InventoryRecv::processPlayerInventory")
}

References BLOCK_END, BLOCK_START, CAST_S32, Ea::EquipBackend::clear(), Inventory::clear(), Damaged_false, Equipped_false, Favorite_false, fromBool, PlayerInfo::getEquipment(), PlayerInfo::getInventory(), INVENTORY_OFFSET, ItemColor_one, localPlayer, Logger::log(), logger, maxCards, Ea::InventoryRecv::mDebugInventory, Ea::InventoryRecv::mEquips, Actions::msg(), Equipment::setBackend(), Inventory::setCards(), and Inventory::setItem().

processPlayerInventoryAdd()

void TmwAthena::InventoryRecv::processPlayerInventoryAdd

(

Net::MessageIn &

msg

)

Definition at line 140 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerInventoryAdd")
 Inventory *const inventory = localPlayer != nullptr
 ? PlayerInfo::getInventory() : nullptr;
 
 if ((PlayerInfo::getEquipment() != nullptr)
 && (PlayerInfo::getEquipment()->getBackend() == nullptr))
 { // look like SMSG_PLAYER_INVENTORY was not received
 Ea::InventoryRecv::mEquips.clear();
 PlayerInfo::getEquipment()->setBackend(&Ea::InventoryRecv::mEquips);
 }
 const int index = msg.readInt16("index") - INVENTORY_OFFSET;
 int amount = msg.readInt16("amount");
 const int itemId = msg.readInt16("item id");
 const uint8_t identified = msg.readUInt8("identified");
 msg.readUInt8("attribute");
 const uint8_t refine = msg.readUInt8("refine");
 int cards[maxCards];
 for (int f = 0; f < maxCards; f++)
 cards[f] = msg.readUInt16("card");
 const int equipType = msg.readInt16("equip type");
 const ItemTypeT type = static_cast<ItemTypeT>(msg.readUInt8("item type"));
 const unsigned char err = msg.readUInt8("status");
 BeingId floorId;
 if (Ea::InventoryRecv::mSentPickups.empty())
 {
 floorId = BeingId_zero;
 }
 else
 {
 floorId = Ea::InventoryRecv::mSentPickups.front();
 Ea::InventoryRecv::mSentPickups.pop();
 }
 
 if (err != 0U)
 {
 PickupT pickup;
 switch (err)
 {
 case 1:
 pickup = Pickup::BAD_ITEM;
 break;
 case 2:
 pickup = Pickup::TOO_HEAVY;
 break;
 case 3:
 pickup = Pickup::TOO_FAR;
 break;
 case 4:
 pickup = Pickup::INV_FULL;
 break;
 case 5:
 pickup = Pickup::STACK_FULL;
 break;
 case 6:
 pickup = Pickup::DROP_STEAL;
 break;
 default:
 pickup = Pickup::UNKNOWN;
 UNIMPLEMENTEDPACKETFIELD(err);
 break;
 }
 if (localPlayer != nullptr)
 {
 if (itemId == 0)
 {
 localPlayer->pickedUp(ItemDB::getEmpty(),
 0,
 ItemColor_one,
 floorId,
 pickup);
 }
 else
 {
 localPlayer->pickedUp(ItemDB::get(itemId),
 0,
 ItemColor_one,
 floorId,
 pickup);
 }
 }
 }
 else
 {
 if (localPlayer != nullptr)
 {
 if (itemId == 0)
 {
 localPlayer->pickedUp(ItemDB::getEmpty(),
 amount,
 ItemColor_one,
 floorId,
 Pickup::OKAY);
 }
 else
 {
 localPlayer->pickedUp(ItemDB::get(itemId),
 amount,
 ItemColor_one,
 floorId,
 Pickup::OKAY);
 }
 }
 
 if (inventory != nullptr)
 {
 const Item *const item = inventory->getItem(index);
 
 if ((item != nullptr) && item->getId() == itemId)
 amount += item->getQuantity();
 
 inventory->setItem(index,
 itemId,
 type,
 amount,
 refine,
 ItemColor_one,
 fromBool(identified, Identified),
 Damaged_false,
 Favorite_false,
 fromBool(equipType, Equipm),
 Equipped_false);
 inventory->setCards(index, cards, maxCards);
 }
 ArrowsListener::distributeEvent();
 }
 BLOCK_END("InventoryRecv::processPlayerInventoryAdd")
}

References Pickup::BAD_ITEM, BeingId_zero, BLOCK_END, BLOCK_START, Ea::EquipBackend::clear(), Damaged_false, ArrowsListener::distributeEvent(), Pickup::DROP_STEAL, empty, Equipped_false, Favorite_false, fromBool, ItemDB::get(), ItemDB::getEmpty(), PlayerInfo::getEquipment(), Item::getId(), PlayerInfo::getInventory(), Inventory::getItem(), Item::getQuantity(), Pickup::INV_FULL, INVENTORY_OFFSET, ItemColor_one, localPlayer, maxCards, Ea::InventoryRecv::mEquips, Ea::InventoryRecv::mSentPickups, Actions::msg(), Pickup::OKAY, LocalPlayer::pickedUp(), Actions::pickup(), Equipment::setBackend(), Inventory::setCards(), Inventory::setItem(), Pickup::STACK_FULL, Pickup::TOO_FAR, Pickup::TOO_HEAVY, UNIMPLEMENTEDPACKETFIELD, and Pickup::UNKNOWN.

processPlayerInventoryRemove()

void TmwAthena::InventoryRecv::processPlayerInventoryRemove

(

Net::MessageIn &

msg

)

Definition at line 525 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerInventoryRemove")
 Inventory *const inventory = localPlayer != nullptr
 ? PlayerInfo::getInventory() : nullptr;
 
 const int index = msg.readInt16("index") - INVENTORY_OFFSET;
 const int amount = msg.readInt16("amount");
 if (inventory != nullptr)
 {
 if (Item *const item = inventory->getItem(index))
 {
 item->increaseQuantity(-amount);
 if (item->getQuantity() == 0)
 inventory->removeItemAt(index);
 ArrowsListener::distributeEvent();
 }
 }
 BLOCK_END("InventoryRecv::processPlayerInventoryRemove")
}

References BLOCK_END, BLOCK_START, ArrowsListener::distributeEvent(), PlayerInfo::getInventory(), Inventory::getItem(), INVENTORY_OFFSET, localPlayer, Actions::msg(), and Inventory::removeItemAt().

processPlayerInventoryUse()

void TmwAthena::InventoryRecv::processPlayerInventoryUse

(

Net::MessageIn &

msg

)

Definition at line 566 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerInventoryUse")
 Inventory *const inventory = localPlayer != nullptr
 ? PlayerInfo::getInventory() : nullptr;
 
 const int index = msg.readInt16("index") - INVENTORY_OFFSET;
 msg.readItemId("item id");
 msg.readInt32("id?");
 const int amount = msg.readInt16("amount");
 msg.readUInt8("type");
 
 if (inventory != nullptr)
 {
 if (Item *const item = inventory->getItem(index))
 {
 if (amount != 0)
 item->setQuantity(amount);
 else
 inventory->removeItemAt(index);
 }
 }
 BLOCK_END("InventoryRecv::processPlayerInventoryUse")
}

References BLOCK_END, BLOCK_START, PlayerInfo::getInventory(), Inventory::getItem(), INVENTORY_OFFSET, localPlayer, Actions::msg(), and Inventory::removeItemAt().

processPlayerStorage()

void TmwAthena::InventoryRecv::processPlayerStorage

(

Net::MessageIn &

msg

)

Definition at line 332 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerInventory")
 Ea::InventoryRecv::mStorageItems.clear();
 
 msg.readInt16("len");
 const int number = (msg.getLength() - 4) / 18;
 
 for (int loop = 0; loop < number; loop++)
 {
 int cards[maxCards];
 const int index = msg.readInt16("index") - STORAGE_OFFSET;
 const int itemId = msg.readInt16("item id");
 const ItemTypeT itemType = static_cast<ItemTypeT>(
 msg.readUInt8("item type"));
 const uint8_t identified = msg.readUInt8("identified");
 const int amount = msg.readInt16("amount");
 msg.readInt16("arrow");
 for (int i = 0; i < maxCards; i++)
 cards[i] = msg.readUInt16("card");
 
 if (Ea::InventoryRecv::mDebugInventory)
 {
 logger->log("Index: %d, ID: %d, Type: %d, Identified: %d, "
 "Qty: %d, Cards: %d, %d, %d, %d",
 index, itemId, CAST_S32(itemType), identified, amount,
 cards[0], cards[1], cards[2], cards[3]);
 }
 
 Ea::InventoryRecv::mStorageItems.push_back(Ea::InventoryItem(
 index,
 itemId,
 itemType,
 cards,
 nullptr,
 amount,
 0,
 ItemColor_one,
 fromBool(identified, Identified),
 Damaged_false,
 Favorite_false,
 Equipm_false,
 -1));
 }
 BLOCK_END("InventoryRecv::processPlayerInventory")
}

References BLOCK_END, BLOCK_START, CAST_S32, Damaged_false, Equipm_false, Favorite_false, fromBool, ItemColor_one, Logger::log(), logger, maxCards, Ea::InventoryRecv::mDebugInventory, Actions::msg(), Ea::InventoryRecv::mStorageItems, and STORAGE_OFFSET.

processPlayerStorageAdd()

void TmwAthena::InventoryRecv::processPlayerStorageAdd

(

Net::MessageIn &

msg

)

Definition at line 467 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerStorageAdd")
 // Move an item into storage
 const int index = msg.readInt16("index") - STORAGE_OFFSET;
 const int amount = msg.readInt32("amount");
 const int itemId = msg.readInt16("item id");
 const unsigned char identified = msg.readUInt8("identified");
 msg.readUInt8("attribute");
 const uint8_t refine = msg.readUInt8("refine");
 int cards[maxCards];
 for (int f = 0; f < maxCards; f++)
 cards[f] = msg.readUInt16("card");
 
 if (Item *const item = Ea::InventoryRecv::mStorage->getItem(index))
 {
 item->setId(itemId, ItemColor_one);
 item->increaseQuantity(amount);
 }
 else
 {
 if (Ea::InventoryRecv::mStorage != nullptr)
 {
 Ea::InventoryRecv::mStorage->setItem(index,
 itemId,
 ItemType::Unknown,
 amount,
 refine,
 ItemColor_one,
 fromBool(identified, Identified),
 Damaged_false,
 Favorite_false,
 Equipm_false,
 Equipped_false);
 Ea::InventoryRecv::mStorage->setCards(index, cards, maxCards);
 }
 }
 BLOCK_END("InventoryRecv::processPlayerStorageAdd")
}

References BLOCK_END, BLOCK_START, Damaged_false, Equipm_false, Equipped_false, Favorite_false, fromBool, ItemColor_one, maxCards, Actions::msg(), Ea::InventoryRecv::mStorage, Inventory::setCards(), Inventory::setItem(), STORAGE_OFFSET, and ItemType::Unknown.

processPlayerStorageEquip()

void TmwAthena::InventoryRecv::processPlayerStorageEquip

(

Net::MessageIn &

msg

)

Definition at line 417 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerStorageEquip")
 msg.readInt16("len");
 const int number = (msg.getLength() - 4) / 20;
 
 for (int loop = 0; loop < number; loop++)
 {
 int cards[maxCards];
 const int index = msg.readInt16("index") - STORAGE_OFFSET;
 const int itemId = msg.readInt16("item id");
 const ItemTypeT itemType = static_cast<ItemTypeT>(
 msg.readUInt8("item type"));
 const uint8_t identified = msg.readUInt8("identified");
 const int amount = 1;
 msg.readInt16("equip point?");
 msg.readInt16("another equip point?");
 msg.readUInt8("attribute (broken)");
 const uint8_t refine = msg.readUInt8("refine");
 for (int i = 0; i < maxCards; i++)
 cards[i] = msg.readUInt16("card");
 
 if (Ea::InventoryRecv::mDebugInventory)
 {
 logger->log("Index: %d, ID: %d, Type: %d, Identified: %u, "
 "Qty: %d, Cards: %d, %d, %d, %d, Refine: %u",
 index, itemId, CAST_S32(itemType),
 CAST_U32(identified), amount,
 cards[0], cards[1], cards[2], cards[3],
 CAST_U32(refine));
 }
 
 Ea::InventoryRecv::mStorageItems.push_back(Ea::InventoryItem(
 index,
 itemId,
 itemType,
 cards,
 nullptr,
 amount,
 refine,
 ItemColor_one,
 fromBool(identified, Identified),
 Damaged_false,
 Favorite_false,
 Equipm_false,
 -1));
 }
 BLOCK_END("InventoryRecv::processPlayerStorageEquip")
}

References BLOCK_END, BLOCK_START, CAST_S32, CAST_U32, Damaged_false, Equipm_false, Favorite_false, fromBool, ItemColor_one, Logger::log(), logger, maxCards, Ea::InventoryRecv::mDebugInventory, Actions::msg(), Ea::InventoryRecv::mStorageItems, and STORAGE_OFFSET.

processPlayerStorageRemove()

void TmwAthena::InventoryRecv::processPlayerStorageRemove

(

Net::MessageIn &

msg

)

Definition at line 507 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerStorageRemove")
 // Move an item out of storage
 const int index = msg.readInt16("index") - STORAGE_OFFSET;
 const int amount = msg.readInt32("amount");
 if (Ea::InventoryRecv::mStorage != nullptr)
 {
 if (Item *const item = Ea::InventoryRecv::mStorage->getItem(index))
 {
 item->increaseQuantity(-amount);
 if (item->getQuantity() == 0)
 Ea::InventoryRecv::mStorage->removeItemAt(index);
 }
 }
 BLOCK_END("InventoryRecv::processPlayerStorageRemove")
}

References BLOCK_END, BLOCK_START, Actions::msg(), Ea::InventoryRecv::mStorage, Inventory::removeItemAt(), and STORAGE_OFFSET.

processPlayerUnEquip()

void TmwAthena::InventoryRecv::processPlayerUnEquip

(

Net::MessageIn &

msg

)

Definition at line 399 of file inventoryrecv.cpp.

{
 BLOCK_START("InventoryRecv::processPlayerUnEquip")
 msg.readInt16("index");
 const int equipType = msg.readInt16("equip type");
 const uint8_t flag = msg.readUInt8("flag");
 
 if (flag != 0U)
 {
 Ea::InventoryRecv::mEquips.setEquipment(
 InventoryRecv::getSlot(equipType),
 -1);
 }
 if ((equipType & 0x8000) != 0)
 ArrowsListener::distributeEvent();
 BLOCK_END("InventoryRecv::processPlayerUnEquip")
}

References BLOCK_END, BLOCK_START, ArrowsListener::distributeEvent(), getSlot(), Ea::InventoryRecv::mEquips, Actions::msg(), and Ea::EquipBackend::setEquipment().

Variable Documentation

EQUIP_POINTS

const EquipSlot::Type TmwAthena::InventoryRecv::EQUIP_POINTS[EquipSlot::VECTOREND]

Initial value:

=
 {
 EquipSlot::LEGS_SLOT, 
 EquipSlot::FIGHT1_SLOT, 
 EquipSlot::GLOVES_SLOT, 
 EquipSlot::RING2_SLOT, 
 EquipSlot::RING1_SLOT, 
 EquipSlot::FIGHT2_SLOT, 
 EquipSlot::FEET_SLOT, 
 EquipSlot::NECK_SLOT, 
 EquipSlot::HEAD_SLOT, 
 EquipSlot::TORSO_SLOT, 
 EquipSlot::EVOL_RING1_SLOT, 
 EquipSlot::EVOL_RING2_SLOT, 
 EquipSlot::PROJECTILE_SLOT, 
 EquipSlot::COSTUME_ROBE_SLOT, 
 EquipSlot::MISSING1_SLOT, 
 EquipSlot::MISSING2_SLOT, 
 EquipSlot::SHADOW_ARMOR_SLOT, 
 EquipSlot::SHADOW_WEAPON_SLOT, 
 EquipSlot::SHADOW_SHIELD_SLOT, 
 EquipSlot::SHADOW_SHOES_SLOT, 
 EquipSlot::SHADOW_ACCESSORY2_SLOT, 
 EquipSlot::SHADOW_ACCESSORY1_SLOT, 
 }

Definition at line 51 of file inventoryrecv.cpp.

Referenced by EAthena::InventoryRecv::getSlot(), and getSlot().