feat: loot highlight effect (#500)

apply this fix
opentibiabr/canary@5bdb379

Author: omarcopires

src/creatures/creature.cpp

@@ -723,6 +723,8 @@ bool Creature::dropCorpse(const std::shared_ptr<Creature> &lastHitCreature, cons
 					},
 					                        "Game::playerQuickLootCorpse");
 				}
+
+				corpse->sendUpdateToClient(player);
 			}
 		}
 

src/creatures/players/player.hpp

@@ -1483,7 +1483,7 @@ class Player final : public Creature, public Cylinder, public Bankable {
 	void sendPlayerTyping(const std::shared_ptr<Creature> &creature, uint8_t typing) const;
 
 	void resetOldCharms();
-	bool isFirstOnStack() const;
+	[[nodiscard]] bool isFirstOnStack() const;
 
 	/*******************************************************************************
 	 * Deflect Condition
@@ -1529,6 +1529,11 @@ class Player final : public Creature, public Cylinder, public Bankable {
 
 	std::unordered_map<uint16_t, uint8_t> spellActivedAimMap;
 
+	using ManagedContainerMap = std::map<ObjectCategory_t, std::pair<std::shared_ptr<Container>, std::shared_ptr<Container>>>;
+	[[nodiscard]] const ManagedContainerMap &getManagedContainers() const {
+		return m_managedContainers;
+	}
+
 private:
 	friend class PlayerLock;
 	std::mutex mutex;
@@ -1614,7 +1619,7 @@ class Player final : public Creature, public Cylinder, public Bankable {
 
 	std::map<uint64_t, std::shared_ptr<Reward>> rewardMap;
 
-	std::map<ObjectCategory_t, std::pair<std::shared_ptr<Container>, std::shared_ptr<Container>>> m_managedContainers;
+	ManagedContainerMap m_managedContainers;
 	std::vector<ForgeHistory> forgeHistoryVector;
 
 	std::vector<uint16_t> quickLootListItemIds;

src/enums/container_type.hpp

@@ -0,0 +1,32 @@
+////////////////////////////////////////////////////////////////////////
+// Crystal Server - an opensource roleplaying game
+////////////////////////////////////////////////////////////////////////
+// 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 3 of the License, or
+// (at your option) 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/>.
+////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#ifndef USE_PRECOMPILED_HEADERS
+	#include <cstdint>
+#endif
+
+enum class ContainerSpecial_t : uint8_t {
+	None = 0,
+	LootContainer = 1,
+	ContentCounter = 2,
+	LootHighlight = 4,
+	Obtain = 8,
+	Manager = 9,
+	QuiverLoot = 11,
+};

src/game/game.cpp

@@ -3067,6 +3067,26 @@ void Game::playerQuickLootCorpse(const std::shared_ptr<Player> &player, const st
 		}
 	}
 
+	bool hasLootavaible = false;
+	for (ContainerIterator it = corpse->iterator(); it.hasNext(); it.advance()) {
+		const auto &corpseItem = *it;
+		if (!corpseItem) {
+			continue;
+		}
+
+		const bool listed = player->isQuickLootListedItem(corpseItem);
+		if ((listed && ignoreListItems) || (!listed && !ignoreListItems)) {
+			continue;
+		}
+
+		hasLootavaible = true;
+		break;
+	}
+
+	if (!hasLootavaible) {
+		corpse->clearLootHighlight(player);
+	}
+
 	std::stringstream ss;
 	if (totalLootedGold != 0 || missedAnyGold || totalLootedItems != 0 || missedAnyItem) {
 		bool lootedAllGold = totalLootedGold != 0 && !missedAnyGold;
@@ -3141,6 +3161,8 @@ void Game::playerQuickLootCorpse(const std::shared_ptr<Player> &player, const st
 		player->sendTextMessage(MESSAGE_EVENT_ADVANCE, ss.str());
 	}
 
+	corpse->sendUpdateToClient(player);
+
 	player->lastQuickLootNotification = OTSYS_TIME();
 }
 
@@ -5783,6 +5805,8 @@ void Game::handleCorpseLoot(const std::shared_ptr<Player> &player, const std::sh
 	} else {
 		playerLootAllCorpses(player, pos, lootAll);
 	}
+
+	corpse->sendUpdateToClient(player);
 }
 
 void Game::sendLootMessageWithCooldown(const std::shared_ptr<Player> &player, const std::string &message) {

src/items/containers/container.cpp

@@ -831,6 +831,10 @@ void Container::removeThing(const std::shared_ptr<Thing> &thing, uint32_t count)
 
 		item->resetParent();
 		itemlist.erase(itemlist.begin() + index);
+
+		if (isCorpse() && empty()) {
+			clearLootHighlight();
+		}
 	}
 }
 
@@ -970,8 +974,24 @@ void Container::removeItem(const std::shared_ptr<Thing> &thing, bool sendUpdateT
 
 		itemlist.erase(it);
 		itemToRemove->resetParent();
+
+		if (isCorpse() && empty()) {
+			clearLootHighlight();
+		}
 	}
 }
+void Container::clearLootHighlight(const std::shared_ptr<Player> &player) {
+	if (!isCorpse()) {
+		return;
+	}
+
+	if (!m_lootHighlightActive) {
+		return;
+	}
+
+	m_lootHighlightActive = false;
+	sendUpdateToClient(player);
+}
 
 uint32_t Container::getOwnerId() const {
 	uint32_t ownerId = Item::getOwnerId();
@@ -1095,3 +1115,62 @@ size_t ContainerIterator::getCurrentIndex() const {
 	const auto &top = states.back();
 	return top.index;
 }
+
+ContainerSpecial_t Container::getSpecialCategory(const std::shared_ptr<Player> &player) {
+	const auto &holdingPlayer = getHoldingPlayer();
+	using enum ContainerSpecial_t;
+
+	if (isCorpse() && hasLootHighlight() && !isRewardCorpse() && !empty() && (getCorpseOwner() == static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) || (getCorpseOwner() == 0 || player->canOpenCorpse(getCorpseOwner())))) {
+		return LootHighlight;
+	}
+
+	if (holdingPlayer == player) {
+		if (isQuiver() && getSlotPosition() & SLOTP_RIGHT) {
+			return QuiverLoot;
+		}
+
+		auto [lootFlags, obtainFlags] = getObjectCategoryFlags(player);
+		if (lootFlags != 0 || obtainFlags != 0) {
+			return Manager;
+		}
+	}
+
+	return None;
+}
+
+std::pair<uint32_t, uint32_t> Container::getObjectCategoryFlags(const std::shared_ptr<Player> &player) const {
+	uint32_t lootFlags = 0;
+	uint32_t obtainFlags = 0;
+	// Cycle through all containers managed by the player
+	for (const auto &[category, containerPair] : player->getManagedContainers()) {
+		// Check if the category is valid before continuing
+		if (!isValidObjectCategory(category)) {
+			continue;
+		}
+
+		// containerPair.first refers to loot containers
+		if (containerPair.first == static_self_cast<Container>()) {
+			lootFlags |= 1 << category;
+		}
+
+		// containerPair.second refers to the obtain containers
+		if (containerPair.second == static_self_cast<Container>()) {
+			obtainFlags |= 1 << category;
+		}
+	}
+
+	return { lootFlags, obtainFlags };
+}
+
+uint32_t Container::getAmmoAmount(const std::shared_ptr<Player> &player) const {
+	uint32_t ammoTotal = 0;
+	if (isQuiver()) {
+		for (const auto &listItem : getItemList()) {
+			if (player->getLevel() >= Item::items[listItem->getID()].minReqLevel) {
+				ammoTotal += listItem->getItemAmount();
+			}
+		}
+	}
+
+	return ammoTotal;
+}

src/items/containers/container.hpp

@@ -21,6 +21,8 @@
 #include "items/item.hpp"
 #include "items/tile.hpp"
 
+#include "enums/container_type.hpp"
+
 class Container;
 class DepotChest;
 class DepotLocker;
@@ -293,6 +295,14 @@ class Container : public Item, public Cylinder {
 	bool isBrowseFieldAndHoldsRewardChest();
 	bool isInsideContainerWithId(uint16_t id);
 
+	ContainerSpecial_t getSpecialCategory(const std::shared_ptr<Player> &player);
+	std::pair<uint32_t, uint32_t> getObjectCategoryFlags(const std::shared_ptr<Player> &player) const;
+	uint32_t getAmmoAmount(const std::shared_ptr<Player> &player) const;
+	void clearLootHighlight(const std::shared_ptr<Player> &player = nullptr);
+	[[nodiscard]] bool hasLootHighlight() const {
+		return m_lootHighlightActive;
+	}
+
 protected:
 	uint32_t m_maxItems {};
 	uint32_t maxSize {};
@@ -302,6 +312,7 @@ class Container : public Item, public Cylinder {
 
 	bool unlocked {};
 	bool pagination {};
+	bool m_lootHighlightActive { true };
 
 	friend class MapCache;
 

src/items/item.cpp

@@ -35,6 +35,8 @@
 #include "items/trashholder.hpp"
 #include "lua/creature/actions.hpp"
 #include "map/house/house.hpp"
+#include "map/spectators.hpp"
+#include "creatures/players/grouping/party.hpp"
 
 #define ITEM_IMBUEMENT_SLOT 500
 
@@ -3565,3 +3567,33 @@ std::string ItemProperties::getShader() const {
 	const CustomAttribute* shader = getCustomAttribute("shader");
 	return shader ? shader->getString() : "";
 }
+
+void Item::sendUpdateToClient(const std::shared_ptr<Player> &player /* = nullptr */) {
+	const auto &tile = getTile();
+	if (!tile) {
+		return;
+	}
+
+	auto selfItem = getItem();
+
+	auto sendUpdateTo = [&](const std::shared_ptr<Player> &target) {
+		if (target) {
+			target->sendUpdateTileItem(tile, getPosition(), selfItem);
+		}
+	};
+
+	if (player) {
+		if (auto party = player->getParty()) {
+			for (const auto &participant : party->getPlayers()) {
+				sendUpdateTo(participant);
+			}
+		} else {
+			sendUpdateTo(player);
+		}
+		return;
+	}
+
+	for (const auto &spectator : Spectators().find<Creature>(getPosition(), true)) {
+		sendUpdateTo(spectator->getPlayer());
+	}
+}

src/items/item.hpp

@@ -637,6 +637,19 @@ class Item : virtual public Thing, public ItemProperties, public SharedObject {
 	virtual void startDecaying();
 	virtual void stopDecaying();
 
+	/**
+	 * @brief Send "AddItem" update to the specified player or to all nearby players if none specified.
+	 *
+	 * This function sends updates about the item's state to a client. If a specific player is provided,
+	 * the update is directed to that player and possibly their party members depending on the game logic.
+	 * If no player is specified, the update is broadcast to all nearby players who are capable of viewing
+	 * the item update, such as spectators around the item's location.
+	 *
+	 * @param player Optional shared pointer to a Player object. If provided, the update is directed to this player
+	 * and their associated viewers or party members. If nullptr, the update goes to all nearby spectators.
+	 */
+	void sendUpdateToClient(const std::shared_ptr<Player> &player = nullptr);
+
 	std::shared_ptr<Item> transform(uint16_t itemId, uint16_t itemCount = -1);
 
 	bool isLoadedFromMap() const {

src/lua/creature/actions.cpp

@@ -381,6 +381,7 @@ ReturnValue Actions::internalUseItem(const std::shared_ptr<Player> &player, cons
 			player->onCloseContainer(openContainer);
 			player->closeContainer(oldContainerId);
 		} else {
+			container->clearLootHighlight();
 			player->addContainer(index, openContainer);
 			player->onSendContainer(openContainer);
 		}