Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2026-10-02 19:03:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
ee23d80815486174d93cb6326fe0967036669cc2
DarkflameServer/dGame/dGameMessages/InventoryMessages.cpp
Aaron Kimbrell a1ee18fce7 feat(inventory): items can carry where they came from to the client 
Live servers put _Metric_ keys in AddItemToInventoryClientSync's extra info,
after the item's own config, saying where the items came from: the source
object's LOT (_Metric_Souce_LOT_Int, misspelt as live had it), the mission,
activity, coins paid, mail or trade. LootMetrics holds them and writes them
with the key names and name value types live used (the mail ID as type 8,
the trade ID as type 9). AddItem, ReceiveItem (its options), the new item
constructor and Item::SetCount pass them through to the message; the item
does not keep them.

RemoveItem and Item::SetCount can also say what took items away
(ItemRemovalSource), filling RemoveItemFromInventory's loot source and
source object instead of none.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 07:45:50 -05:00

572 lines
23 KiB
C++
Raw Blame History

#include "InventoryMessages.h"
#include "BitStreamUtils.h"
#include "TeamManager.h"
#include "EntityManager.h"
#include "Game.h"
#include "Entity.h"
#include "GeneralUtils.h"
#include "Inventory.h"
#include "InventoryComponent.h"
#include "Item.h"
#include "LootMetrics.h"
#include "BrickByBrick.h"
#include <ranges>
namespace {
// Name value text (the client's LwoNameValue on the wire): u32 length, the characters, then a null character
// only if the text is not empty.
void WriteNameValue(RakNet::BitStream& bitStream, const std::u16string& text) {
BitStreamUtils::WriteLengthPrefixed<uint32_t>(bitStream, text);
if (!text.empty()) bitStream.Write<uint16_t>(0x00);
}
bool ReadNameValue(RakNet::BitStream& bitStream, std::u16string& text) {
if (!BitStreamUtils::ReadLengthPrefixed<uint32_t>(bitStream, text)) return false;
uint16_t nullTerminator{};
return text.empty() || bitStream.Read(nullTerminator);
}
// Writes the flag and value of an optional field whose flag DLU always sets.
template<typename T>
void WriteAlways(RakNet::BitStream& bitStream, const T& value) {
bitStream.Write1();
bitStream.Write(value);
}
}
namespace GameMessages {
void AddItemToInventoryClientSync::SetItem(const Item& item) {
bBound = item.GetBound();
bIsBOE = item.GetInfo().isBOE;
bIsBOP = item.GetInfo().isBOP;
extraInfo.clear();
for (const auto& data : item.GetConfig().values | std::views::values) {
extraInfo += GeneralUtils::ASCIIToUTF16(data->GetString()) + u",";
}
if (extraInfo.length() > 0) extraInfo.pop_back(); // remove the last comma
iObjTemplate = item.GetLot();
invType = item.GetInventory()->GetType();
itemsTotal = item.GetCount();
slotID = item.GetSlot();
}
void AddItemToInventoryClientSync::AddMetrics(const LootMetrics& metrics) {
const auto text = metrics.ToExtraInfo();
if (text.empty()) return;
if (!extraInfo.empty()) extraInfo += u',';
extraInfo += text;
}
void AddItemToInventoryClientSync::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bBound);
bitStream.Write(bIsBOE);
bitStream.Write(bIsBOP);
BitStreamUtils::WriteOptional(bitStream, eLootTypeSource, eLootSourceType::NONE);
WriteNameValue(bitStream, extraInfo);
bitStream.Write(iObjTemplate);
BitStreamUtils::WriteOptional(bitStream, iSubkey, LWOOBJID_EMPTY);
BitStreamUtils::WriteOptional(bitStream, invType, eInventoryType::ITEMS);
BitStreamUtils::WriteOptional(bitStream, itemCount, 1);
BitStreamUtils::WriteOptional<uint32_t>(bitStream, itemsTotal, 0);
bitStream.Write(newObjID);
bitStream.Write(ni3FlyingLootPosit.x);
bitStream.Write(ni3FlyingLootPosit.y);
bitStream.Write(ni3FlyingLootPosit.z);
bitStream.Write(showFlyingLoot);
bitStream.Write(slotID);
}
bool AddItemToInventoryClientSync::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bBound));
VALIDATE_READ(bitStream.Read(bIsBOE));
VALIDATE_READ(bitStream.Read(bIsBOP));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, eLootTypeSource, eLootSourceType::NONE));
VALIDATE_READ(ReadNameValue(bitStream, extraInfo));
VALIDATE_READ(bitStream.Read(iObjTemplate));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iSubkey, LWOOBJID_EMPTY));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, invType, eInventoryType::ITEMS));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, itemCount, 1));
VALIDATE_READ(BitStreamUtils::ReadOptional<uint32_t>(bitStream, itemsTotal, 0));
VALIDATE_READ(bitStream.Read(newObjID));
VALIDATE_READ(bitStream.Read(ni3FlyingLootPosit.x));
VALIDATE_READ(bitStream.Read(ni3FlyingLootPosit.y));
VALIDATE_READ(bitStream.Read(ni3FlyingLootPosit.z));
VALIDATE_READ(bitStream.Read(showFlyingLoot));
VALIDATE_READ(bitStream.Read(slotID));
return true;
}
void SetInventorySize::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(inventoryType);
bitStream.Write(size);
}
bool SetInventorySize::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(inventoryType));
VALIDATE_READ(bitStream.Read(size));
return true;
}
void RemoveItemFromInventory::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bConfirmed);
bitStream.Write(bDeleteItem);
bitStream.Write(bOutSuccess);
WriteAlways(bitStream, eInvType);
WriteAlways(bitStream, eLootTypeSource);
WriteNameValue(bitStream, extraInfo);
bitStream.Write(forceDeletion);
BitStreamUtils::WriteOptional(bitStream, iLootTypeSource, LWOOBJID_EMPTY);
WriteAlways(bitStream, iObjID);
WriteAlways(bitStream, iObjTemplate);
BitStreamUtils::WriteOptional(bitStream, iRequestingObjID, LWOOBJID_EMPTY);
WriteAlways(bitStream, iStackCount);
WriteAlways(bitStream, iStackRemaining);
BitStreamUtils::WriteOptional(bitStream, iSubkey, LWOOBJID_EMPTY);
BitStreamUtils::WriteOptional(bitStream, iTradeID, LWOOBJID_EMPTY);
}
bool RemoveItemFromInventory::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bConfirmed));
VALIDATE_READ(bitStream.Read(bDeleteItem));
VALIDATE_READ(bitStream.Read(bOutSuccess));
VALIDATE_READ(BitStreamUtils::ReadOptional<int32_t>(bitStream, eInvType, INVENTORY_MAX));
VALIDATE_READ(BitStreamUtils::ReadOptional<int32_t>(bitStream, eLootTypeSource, LOOTTYPE_NONE));
VALIDATE_READ(ReadNameValue(bitStream, extraInfo));
VALIDATE_READ(bitStream.Read(forceDeletion));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iLootTypeSource, LWOOBJID_EMPTY));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iObjID, LWOOBJID_EMPTY));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iObjTemplate, LOT_NULL));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iRequestingObjID, LWOOBJID_EMPTY));
VALIDATE_READ(BitStreamUtils::ReadOptional<uint32_t>(bitStream, iStackCount, 1));
VALIDATE_READ(BitStreamUtils::ReadOptional<uint32_t>(bitStream, iStackRemaining, 0));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iSubkey, LWOOBJID_EMPTY));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iTradeID, LWOOBJID_EMPTY));
return true;
}
void RemoveItemFromInventory::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnRemoveItemFromInventory(*this);
}
void EquipInventory::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bIgnoreCooldown);
bitStream.Write(bOutSuccess);
bitStream.Write(itemToEquip);
}
bool EquipInventory::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bIgnoreCooldown));
VALIDATE_READ(bitStream.Read(bOutSuccess));
VALIDATE_READ(bitStream.Read(itemToEquip));
return true;
}
void EquipInventory::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnEquipInventory(*this);
}
void UnEquipInventory::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bEvenIfDead);
bitStream.Write(bIgnoreCooldown);
bitStream.Write(bOutSuccess);
bitStream.Write(itemToUnequip);
BitStreamUtils::WriteOptional(bitStream, replacementObjectID, LWOOBJID_EMPTY);
}
bool UnEquipInventory::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bEvenIfDead));
VALIDATE_READ(bitStream.Read(bIgnoreCooldown));
VALIDATE_READ(bitStream.Read(bOutSuccess));
VALIDATE_READ(bitStream.Read(itemToUnequip));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, replacementObjectID, LWOOBJID_EMPTY));
return true;
}
void UnEquipInventory::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnUnEquipInventory(*this);
}
void MoveItemInInventory::Serialize(RakNet::BitStream& bitStream) const {
BitStreamUtils::WriteOptional<int32_t>(bitStream, destInvType, eInventoryType::INVALID);
bitStream.Write(iObjID);
bitStream.Write(inventoryType);
bitStream.Write(responseCode);
bitStream.Write(slot);
}
bool MoveItemInInventory::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(BitStreamUtils::ReadOptional<int32_t>(bitStream, destInvType, eInventoryType::INVALID));
VALIDATE_READ(bitStream.Read(iObjID));
VALIDATE_READ(bitStream.Read(inventoryType));
VALIDATE_READ(bitStream.Read(responseCode));
VALIDATE_READ(bitStream.Read(slot));
return true;
}
void MoveItemInInventory::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnMoveItemInInventory(*this);
}
void MoveItemBetweenInventoryTypes::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(inventoryTypeA);
bitStream.Write(inventoryTypeB);
bitStream.Write(objectID);
bitStream.Write(showFlyingLoot);
BitStreamUtils::WriteOptional<uint32_t>(bitStream, stackCount, 1);
BitStreamUtils::WriteOptional(bitStream, templateID, LOT_NULL);
}
bool MoveItemBetweenInventoryTypes::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(inventoryTypeA));
VALIDATE_READ(bitStream.Read(inventoryTypeB));
VALIDATE_READ(bitStream.Read(objectID));
VALIDATE_READ(bitStream.Read(showFlyingLoot));
VALIDATE_READ(BitStreamUtils::ReadOptional<uint32_t>(bitStream, stackCount, 1));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, templateID, LOT_NULL));
return true;
}
void MoveItemBetweenInventoryTypes::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnMoveItemBetweenInventoryTypes(*this);
}
void RequestMoveItemBetweenInventoryTypes::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bAllowPartial);
BitStreamUtils::WriteOptional(bitStream, destSlot, -1);
BitStreamUtils::WriteOptional(bitStream, iStackCount, 1);
BitStreamUtils::WriteOptional(bitStream, invTypeDst, eInventoryType::ITEMS);
BitStreamUtils::WriteOptional(bitStream, invTypeSrc, eInventoryType::ITEMS);
BitStreamUtils::WriteOptional(bitStream, itemID, LWOOBJID_EMPTY);
bitStream.Write(showFlyingLoot);
BitStreamUtils::WriteOptional(bitStream, subkey, LWOOBJID_EMPTY);
BitStreamUtils::WriteOptional(bitStream, itemLOT, LOT_NULL);
}
bool RequestMoveItemBetweenInventoryTypes::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bAllowPartial));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, destSlot, -1));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iStackCount, 1));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, invTypeDst, eInventoryType::ITEMS));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, invTypeSrc, eInventoryType::ITEMS));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, itemID, LWOOBJID_EMPTY));
VALIDATE_READ(bitStream.Read(showFlyingLoot));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, subkey, LWOOBJID_EMPTY));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, itemLOT, LOT_NULL));
return true;
}
void RequestMoveItemBetweenInventoryTypes::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (invTypeDst != invTypeSrc && inventoryComponent) {
inventoryComponent->OnRequestMoveItemBetweenInventoryTypes(*this, sysAddr);
return;
}
ResponseMoveItemBetweenInventoryTypes response;
response.target = entity.GetObjectID();
response.inventoryTypeDestination = invTypeDst;
response.inventoryTypeSource = invTypeSrc;
response.response = eReponseMoveItemBetweenInventoryTypeCode::FAIL_GENERIC;
response.SendToClient(sysAddr);
}
void ResponseMoveItemBetweenInventoryTypes::Serialize(RakNet::BitStream& bitStream) const {
BitStreamUtils::WriteOptional(bitStream, inventoryTypeDestination, eInventoryType::ITEMS);
BitStreamUtils::WriteOptional(bitStream, inventoryTypeSource, eInventoryType::ITEMS);
BitStreamUtils::WriteOptional(bitStream, response, eReponseMoveItemBetweenInventoryTypeCode::FAIL_GENERIC);
}
bool ResponseMoveItemBetweenInventoryTypes::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, inventoryTypeDestination, eInventoryType::ITEMS));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, inventoryTypeSource, eInventoryType::ITEMS));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, response, eReponseMoveItemBetweenInventoryTypeCode::FAIL_GENERIC));
return true;
}
void MoveInventoryBatch::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bAllowPartial);
bitStream.Write(bOutSuccess);
BitStreamUtils::WriteOptional<uint32_t>(bitStream, count, 1);
BitStreamUtils::WriteOptional(bitStream, dstBag, eInventoryType::ITEMS);
BitStreamUtils::WriteOptional(bitStream, moveLOT, LOT_NULL);
BitStreamUtils::WriteOptional(bitStream, moveSubkey, LWOOBJID_EMPTY);
bitStream.Write(showFlyingLoot);
BitStreamUtils::WriteOptional(bitStream, srcBag, eInventoryType::ITEMS);
BitStreamUtils::WriteOptional(bitStream, startObjectID, LWOOBJID_EMPTY);
}
bool MoveInventoryBatch::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bAllowPartial));
VALIDATE_READ(bitStream.Read(bOutSuccess));
VALIDATE_READ(BitStreamUtils::ReadOptional<uint32_t>(bitStream, count, 1));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, dstBag, eInventoryType::ITEMS));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, moveLOT, LOT_NULL));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, moveSubkey, LWOOBJID_EMPTY));
VALIDATE_READ(bitStream.Read(showFlyingLoot));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, srcBag, eInventoryType::ITEMS));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, startObjectID, LWOOBJID_EMPTY));
return true;
}
void MoveInventoryBatch::Handle(Entity& entity, const SystemAddress& sysAddr) {
BrickByBrick::MoveBricks(entity, *this);
}
void NotifyNotEnoughInvSpace::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(freeSlotsNeeded);
BitStreamUtils::WriteOptional(bitStream, inventoryType, eInventoryType::ITEMS);
}
bool NotifyNotEnoughInvSpace::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(freeSlotsNeeded));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, inventoryType, eInventoryType::ITEMS));
return true;
}
void MarkInventoryItemAsActive::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bActive);
BitStreamUtils::WriteOptional(bitStream, iType, eUnequippableActiveType::INVALID);
BitStreamUtils::WriteOptional(bitStream, itemID, LWOOBJID_EMPTY);
}
bool MarkInventoryItemAsActive::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bActive));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, iType, eUnequippableActiveType::INVALID));
VALIDATE_READ(BitStreamUtils::ReadOptional(bitStream, itemID, LWOOBJID_EMPTY));
return true;
}
void ConsumeClientItem::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(bSuccess);
bitStream.Write(item);
}
bool ConsumeClientItem::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(bSuccess));
VALIDATE_READ(bitStream.Read(item));
return true;
}
void ClientItemConsumed::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(item);
}
bool ClientItemConsumed::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(item));
return true;
}
void ClientItemConsumed::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnClientItemConsumed(*this);
}
void UseNonEquipmentItem::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(itemToUse);
}
bool UseNonEquipmentItem::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(itemToUse));
return true;
}
void UseNonEquipmentItem::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnUseNonEquipmentItem(*this);
}
void UseItemResult::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(itemTemplateID);
bitStream.Write(useItemResult);
}
bool UseItemResult::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(itemTemplateID));
VALIDATE_READ(bitStream.Read(useItemResult));
return true;
}
void UseItemRequirementsResponse::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(eUseResponse);
}
bool UseItemRequirementsResponse::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(eUseResponse));
return true;
}
void SetConsumableItem::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(itemTemplateID);
}
bool SetConsumableItem::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(itemTemplateID));
return true;
}
void SetConsumableItem::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->SetConsumable(itemTemplateID);
}
void PushEquippedItemsState::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->PushEquippedItems();
}
void PopEquippedItemsState::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (!inventoryComponent) return;
inventoryComponent->PopEquippedItems();
Game::entityManager->SerializeEntity(&entity); // so it updates on client side
}
void ResyncEquipment::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* const inventoryComponent = entity.GetComponent<InventoryComponent>();
if (!inventoryComponent) return;
inventoryComponent->ResyncEquipment();
Game::entityManager->SerializeEntity(&entity);
}
void UpdateInventoryGroup::Serialize(RakNet::BitStream& bitStream) const {
BitStreamUtils::WriteLengthPrefixed<uint32_t>(bitStream, action);
BitStreamUtils::WriteLengthPrefixed<uint32_t>(bitStream, groupID);
BitStreamUtils::WriteLengthPrefixed<uint32_t>(bitStream, groupName);
bitStream.Write(inventoryType);
bitStream.Write(locked);
}
bool UpdateInventoryGroup::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(BitStreamUtils::ReadLengthPrefixed<uint32_t>(bitStream, action));
VALIDATE_READ(BitStreamUtils::ReadLengthPrefixed<uint32_t>(bitStream, groupID));
VALIDATE_READ(BitStreamUtils::ReadLengthPrefixed<uint32_t>(bitStream, groupName, MAX_MESSAGE_LENGTH / 2));
VALIDATE_READ(bitStream.Read(inventoryType));
VALIDATE_READ(bitStream.Read(locked));
return true;
}
void UpdateInventoryGroup::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnUpdateInventoryGroup(*this);
}
void UpdateInventoryGroupContents::Serialize(RakNet::BitStream& bitStream) const {
BitStreamUtils::WriteLengthPrefixed<uint32_t>(bitStream, action);
BitStreamUtils::WriteLengthPrefixed<uint32_t>(bitStream, groupID);
bitStream.Write(inventoryType);
bitStream.Write(lot);
}
bool UpdateInventoryGroupContents::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(BitStreamUtils::ReadLengthPrefixed<uint32_t>(bitStream, action));
VALIDATE_READ(BitStreamUtils::ReadLengthPrefixed<uint32_t>(bitStream, groupID));
VALIDATE_READ(bitStream.Read(inventoryType));
VALIDATE_READ(bitStream.Read(lot));
return true;
}
void UpdateInventoryGroupContents::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* inventoryComponent = entity.GetComponent<InventoryComponent>();
if (inventoryComponent) inventoryComponent->OnUpdateInventoryGroupContents(*this);
}
void UseItemOnClient::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(itemLOT);
bitStream.Write(itemToUse);
bitStream.Write(itemType);
bitStream.Write(playerId);
bitStream.Write(targetPosition.x);
bitStream.Write(targetPosition.y);
bitStream.Write(targetPosition.z);
}
void DropClientLoot::Serialize(RakNet::BitStream& stream) const {
stream.Write(bUsePosition);
stream.Write(finalPosition != NiPoint3Constant::ZERO);
if (finalPosition != NiPoint3Constant::ZERO) stream.Write(finalPosition);
stream.Write(currency);
stream.Write(item);
stream.Write(lootID);
stream.Write(ownerID);
stream.Write(sourceID);
stream.Write(spawnPos != NiPoint3Constant::ZERO);
if (spawnPos != NiPoint3Constant::ZERO) stream.Write(spawnPos);
}
bool PickupItem::Deserialize(RakNet::BitStream& stream) {
if (!stream.Read(lootID)) return false;
if (!stream.Read(lootOwnerID)) return false;
return true;
}
void PickupItem::Handle(Entity& entity, const SystemAddress& sysAddr) {
auto* team = TeamManager::Instance()->GetTeam(entity.GetObjectID());
LOG("Has team %i picking up %llu:%llu", team != nullptr, lootID, lootOwnerID);
if (team) {
for (const auto memberId : team->members) {
PickupItemEvent event(*this);
event.Send(memberId);
TeamPickupItem teamPickupMsg{};
teamPickupMsg.target = lootID;
teamPickupMsg.lootID = lootID;
teamPickupMsg.lootOwnerID = lootOwnerID;
const auto* const memberEntity = Game::entityManager->GetEntity(memberId);
if (memberEntity) teamPickupMsg.Send(memberEntity->GetSystemAddress());
}
} else {
entity.PickupItem(lootID);
}
}
void TeamPickupItem::Serialize(RakNet::BitStream& stream) const {
stream.Write(lootID);
stream.Write(lootOwnerID);
}
bool UseItemOnClient::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(itemLOT));
VALIDATE_READ(bitStream.Read(itemToUse));
VALIDATE_READ(bitStream.Read(itemType));
VALIDATE_READ(bitStream.Read(playerId));
VALIDATE_READ(bitStream.Read(targetPosition.x));
VALIDATE_READ(bitStream.Read(targetPosition.y));
VALIDATE_READ(bitStream.Read(targetPosition.z));
return true;
}
bool DropClientLoot::Deserialize(RakNet::BitStream& stream) {
VALIDATE_READ(stream.Read(bUsePosition));
VALIDATE_READ(BitStreamUtils::ReadOptional(stream, finalPosition, NiPoint3Constant::ZERO));
VALIDATE_READ(stream.Read(currency));
VALIDATE_READ(stream.Read(item));
VALIDATE_READ(stream.Read(lootID));
VALIDATE_READ(stream.Read(ownerID));
VALIDATE_READ(stream.Read(sourceID));
VALIDATE_READ(BitStreamUtils::ReadOptional(stream, spawnPos, NiPoint3Constant::ZERO));
return true;
}
void PickupItem::Serialize(RakNet::BitStream& stream) const {
stream.Write(lootID);
stream.Write(lootOwnerID);
}
bool TeamPickupItem::Deserialize(RakNet::BitStream& stream) {
VALIDATE_READ(stream.Read(lootID));
VALIDATE_READ(stream.Read(lootOwnerID));
return true;
}
}
Reference in New Issue View Git Blame Copy Permalink