feat: activity component debug stuff and fix issues with duplicates in debug ui (#1850)

Tested that duplicate data in ui is no longer hidden and that activity debug stuff is shown

dGame/dComponents/ActivityComponent.cpp

@@ -28,8 +28,11 @@
 #include "CDActivitiesTable.h"
 #include "LeaderboardManager.h"
 #include "CharacterComponent.h"
+#include "Amf3.h"
 
 ActivityComponent::ActivityComponent(Entity* parent, int32_t activityID) : Component(parent) {
+	using namespace GameMessages;
+	RegisterMsg<GetObjectReportInfo>(this, &ActivityComponent::OnGetObjectReportInfo);
 	/*
 	* This is precisely what the client does functionally
 	* Use the component id as the default activity id and load its data from the database
@@ -354,8 +357,7 @@ bool ActivityComponent::TakeCost(Entity* player) const{
 	if (CheckCost(player)) {
 		inventoryComponent->RemoveItem(m_ActivityInfo.optionalCostLOT, m_ActivityInfo.optionalCostCount);
 		return true;
-	}
+	} else return false;
-	else return false;
 }
 
 void ActivityComponent::PlayerReady(Entity* player, bool bReady) {
@@ -618,3 +620,91 @@ void ActivityInstance::SetScore(uint32_t score) {
 Entity* LobbyPlayer::GetEntity() const {
 	return Game::entityManager->GetEntity(entityID);
 }
+
+bool ActivityComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
+	auto& reportInfo = static_cast<GameMessages::GetObjectReportInfo&>(msg);
+
+	auto& activityInfo = reportInfo.info->PushDebug("Activity");
+
+	auto& instances = activityInfo.PushDebug("Instances: " + std::to_string(m_Instances.size()));
+	size_t i = 0;
+	for (const auto& activityInstance : m_Instances) {
+		if (!activityInstance) continue;
+		auto& instance = instances.PushDebug("Instance " + std::to_string(i++));
+		instance.PushDebug<AMFIntValue>("Score") = activityInstance->GetScore();
+		instance.PushDebug<AMFIntValue>("Next Zone Clone ID") = activityInstance->GetNextZoneCloneID();
+
+		{
+			auto& activityInfo = instance.PushDebug("Activity Info");
+			const auto& instanceActInfo = activityInstance->GetActivityInfo();
+			activityInfo.PushDebug<AMFIntValue>("ActivityID") = instanceActInfo.ActivityID;
+			activityInfo.PushDebug<AMFIntValue>("locStatus") = instanceActInfo.locStatus;
+			activityInfo.PushDebug<AMFIntValue>("instanceMapID") = instanceActInfo.instanceMapID;
+			activityInfo.PushDebug<AMFIntValue>("minTeams") = instanceActInfo.minTeams;
+			activityInfo.PushDebug<AMFIntValue>("maxTeams") = instanceActInfo.maxTeams;
+			activityInfo.PushDebug<AMFIntValue>("minTeamSize") = instanceActInfo.minTeamSize;
+			activityInfo.PushDebug<AMFIntValue>("maxTeamSize") = instanceActInfo.maxTeamSize;
+			activityInfo.PushDebug<AMFIntValue>("waitTime") = instanceActInfo.waitTime;
+			activityInfo.PushDebug<AMFIntValue>("startDelay") = instanceActInfo.startDelay;
+			activityInfo.PushDebug<AMFBoolValue>("requiresUniqueData") = instanceActInfo.requiresUniqueData;
+			activityInfo.PushDebug<AMFIntValue>("leaderboardType") = instanceActInfo.leaderboardType;
+			activityInfo.PushDebug<AMFBoolValue>("localize") = instanceActInfo.localize;
+			activityInfo.PushDebug<AMFIntValue>("optionalCostLOT") = instanceActInfo.optionalCostLOT;
+			activityInfo.PushDebug<AMFIntValue>("optionalCostCount") = instanceActInfo.optionalCostCount;
+			activityInfo.PushDebug<AMFBoolValue>("showUIRewards") = instanceActInfo.showUIRewards;
+			activityInfo.PushDebug<AMFIntValue>("CommunityActivityFlagID") = instanceActInfo.CommunityActivityFlagID;
+			activityInfo.PushDebug<AMFStringValue>("gate_version") = instanceActInfo.gate_version;
+			activityInfo.PushDebug<AMFBoolValue>("noTeamLootOnDeath") = instanceActInfo.noTeamLootOnDeath;
+			activityInfo.PushDebug<AMFDoubleValue>("optionalPercentage") = instanceActInfo.optionalPercentage;
+		}
+
+		auto& participants = instance.PushDebug("Participants");
+		for (const auto* participant : activityInstance->GetParticipants()) {
+			if (!participant) continue;
+			auto* character = participant->GetCharacter();
+			if (!character) continue;
+			participants.PushDebug<AMFStringValue>(std::to_string(participant->GetObjectID()) + ": " + character->GetName()) = "";
+		}
+	}
+
+	auto& queue = activityInfo.PushDebug("Queue");
+	i = 0;
+	for (const auto& lobbyQueue : m_Queue) {
+		auto& lobby = queue.PushDebug("Lobby " + std::to_string(i++));
+		lobby.PushDebug<AMFDoubleValue>("Timer") = lobbyQueue->timer;
+
+		auto& players = lobby.PushDebug("Players");
+		for (const auto* player : lobbyQueue->players) {
+			if (!player) continue;
+			auto* playerEntity = player->GetEntity();
+			if (!playerEntity) continue;
+			auto* character = playerEntity->GetCharacter();
+			if (!character) continue;
+
+			players.PushDebug<AMFStringValue>(std::to_string(playerEntity->GetObjectID()) + ": " + character->GetName()) = player->ready ? "Ready" : "Not Ready";
+		}
+	}
+
+	auto& activityPlayers = activityInfo.PushDebug("Activity Players");
+	for (const auto* activityPlayer : m_ActivityPlayers) {
+		if (!activityPlayer) continue;
+		auto* const activityPlayerEntity = Game::entityManager->GetEntity(activityPlayer->playerID);
+		if (!activityPlayerEntity) continue;
+		auto* character = activityPlayerEntity->GetCharacter();
+		if (!character) continue;
+
+		auto& playerData = activityPlayers.PushDebug(std::to_string(activityPlayer->playerID) + " " + character->GetName());
+
+		auto& scores = playerData.PushDebug("Scores");
+		for (size_t i = 0; i < 10; ++i) {
+			scores.PushDebug<AMFDoubleValue>(std::to_string(i)) = activityPlayer->values[i];
+		}
+	}
+	
+	auto& lootMatrices = activityInfo.PushDebug("Loot Matrices");
+	for (const auto& [activityRating, lootMatrixID] : m_ActivityLootMatrices) {
+		lootMatrices.PushDebug<AMFIntValue>("Loot Matrix " + std::to_string(activityRating)) = lootMatrixID;
+	}
+	activityInfo.PushDebug<AMFIntValue>("ActivityID") = m_ActivityID;
+	return true;
+}

dGame/dComponents/ActivityComponent.h

@@ -9,6 +9,10 @@
 
 #include "CDActivitiesTable.h"
 
+namespace GameMessages {
+	class GameMsg;
+};
+
  /**
   * Represents an instance of an activity, having participants and score
   */
@@ -60,6 +64,10 @@ public:
 	 * Currently unused
 	 */
 	void SetScore(uint32_t score);
+
+	[[nodiscard]] uint32_t GetNextZoneCloneID() const noexcept { return m_NextZoneCloneID; }
+
+	const CDActivities& GetActivityInfo() const noexcept { return m_ActivityInfo; }
 private:
 
 	/**
@@ -75,12 +83,12 @@ private:
 	/**
 	 * The database information for this activity
 	 */
-	CDActivities m_ActivityInfo;
+	CDActivities m_ActivityInfo{};
 
 	/**
 	 * The entity that owns this activity (the entity that has the ScriptedActivityComponent)
 	 */
-	Entity* m_Parent;
+	Entity* m_Parent{};
 
 	/**
 	 * All the participants of this activity
@@ -341,6 +349,7 @@ public:
 	uint32_t GetLootMatrixForTeamSize(uint32_t teamSize) { return m_ActivityLootMatrices[teamSize]; }
 private:
 
+	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
 	/**
 	 * The database information for this activity
 	 */

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -385,16 +385,19 @@ bool ControllablePhysicsComponent::OnGetObjectReportInfo(GameMessages::GameMsg&
 	info.PushDebug<AMFBoolValue>("Is Static") = m_Static;
 
 	auto& pickupRadii = info.PushDebug("Active Pickup Radius Scales");
+
+	size_t i = 0;
 	for (const auto& scale : m_ActivePickupRadiusScales) {
-		pickupRadii.PushDebug<AMFStringValue>(std::to_string(scale)) = "";
+		pickupRadii.PushDebug<AMFStringValue>(std::to_string(i++) + " " + std::to_string(scale)) = "";
 	}
 
 	info.PushDebug<AMFDoubleValue>("Largest Pickup Radius") = m_PickupRadius;
 	info.PushDebug<AMFBoolValue>("Is Teleporting") = m_IsTeleporting;
 
 	auto& activeSpeedBoosts = info.PushDebug("Active Speed Boosts");
+	i = 0;
 	for (const auto& boost : m_ActiveSpeedBoosts) {
-		activeSpeedBoosts.PushDebug<AMFStringValue>(std::to_string(boost)) = "";
+		activeSpeedBoosts.PushDebug<AMFStringValue>(std::to_string(i++) + " " + std::to_string(boost)) = "";
 	}
 
 	info.PushDebug<AMFDoubleValue>("Speed Boost") = m_SpeedBoost;

dGame/dComponents/DestroyableComponent.cpp

@@ -1052,12 +1052,14 @@ bool DestroyableComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
 	destroyableInfo.PushDebug<AMFIntValue>("Attacks To Block") = m_AttacksToBlock;
 	destroyableInfo.PushDebug<AMFIntValue>("Damage Reduction") = m_DamageReduction;
 	auto& factions = destroyableInfo.PushDebug("Factions");
+	size_t i = 0;
 	for (const auto factionID : m_FactionIDs) {
-		factions.PushDebug<AMFStringValue>(std::to_string(factionID)) = "";
+		factions.PushDebug<AMFStringValue>(std::to_string(i++) + " " + std::to_string(factionID)) = "";
 	}
 	auto& enemyFactions = destroyableInfo.PushDebug("Enemy Factions");
+	i = 0;
 	for (const auto enemyFactionID : m_EnemyFactionIDs) {
-		enemyFactions.PushDebug<AMFStringValue>(std::to_string(enemyFactionID)) = "";
+		enemyFactions.PushDebug<AMFStringValue>(std::to_string(i++) + " " + std::to_string(enemyFactionID)) = "";
 	}
 	destroyableInfo.PushDebug<AMFBoolValue>("Is Smashable") = m_IsSmashable;
 	destroyableInfo.PushDebug<AMFBoolValue>("Is Dead") = m_IsDead;