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().