insert_or_assign instead of [] because nanoseconds matter.

Author: DeltaGW2

src/SquadMgr/SquadMgr.cpp

@@ -1003,6 +1003,7 @@ void CSquadMgr::OnGroupMemberUpdate(RTAPI::GroupMember* aGroupMember)
 	const std::lock_guard<std::mutex> lock(this->Mutex);
 
 	auto& player = this->Players[aGroupMember->AccountName];
+
 	player.Member = *aGroupMember;
 	player.HasLeft = 0; /* Reset in case the player rejoined without removal. */
 
@@ -1015,36 +1016,36 @@ void CSquadMgr::OnAgentJoin(AgentUpdate* aAgentUpdate)
 
 	const std::lock_guard<std::mutex> lock(this->CacheMutex);
 
-	this->CachedAgentsArc[&aAgentUpdate->AccountName[1]] = *aAgentUpdate;
+	auto [agIt, inserted] = this->CachedAgents.insert_or_assign(&aAgentUpdate->AccountName[1], *aAgentUpdate);
 
 	/* Is in party according to arc, else it'd give the display sub. */
 	if (aAgentUpdate->Subgroup == 0)
 	{
-		this->CachedAgentsArc[&aAgentUpdate->AccountName[1]].Subgroup++;
+		agIt->second.Subgroup++;
 	}
 
 	RTAPI::GroupMember member{};
-	strcpy_s(&member.AccountName[0], sizeof(member.AccountName), &aAgentUpdate->AccountName[1]);
-	strcpy_s(&member.CharacterName[0], sizeof(member.CharacterName), &aAgentUpdate->CharacterName[0]);
-	member.Profession = aAgentUpdate->Prof;
+	strcpy_s(&member.AccountName[0],   sizeof(aAgentUpdate->AccountName)   - 1, &aAgentUpdate->AccountName[1]);
+	strcpy_s(&member.CharacterName[0], sizeof(aAgentUpdate->CharacterName) - 1, &aAgentUpdate->CharacterName[0]);
+	member.Profession          = aAgentUpdate->Prof;
 	member.EliteSpecialization = aAgentUpdate->Elite;
-	member.IsSelf = aAgentUpdate->Self;
-	member.IsInInstance = true; // arc only reports in instance players
+	member.IsSelf              = aAgentUpdate->Self;
+	member.IsInInstance        = true; // arc only reports in instance players
 
-	auto ue = this->CachedAgentsUE.find(member.AccountName);
+	auto ue = this->CachedUsers.find(member.AccountName);
 
-	if (ue != this->CachedAgentsUE.end())
+	if (ue != this->CachedUsers.end())
 	{
-		member.Subgroup = ue->second.Subgroup;
-		member.IsCommander = ue->second.Role == UserRole::SquadLeader;
+		member.Subgroup     = ue->second.Subgroup;
+		member.IsCommander  = ue->second.Role == UserRole::SquadLeader;
 		member.IsLieutenant = ue->second.Role == UserRole::Lieutenant;
 	}
 	else
 	{
 		member.Subgroup = aAgentUpdate->Subgroup;
 	}
 
-	if (G::RTAPI) { return; }
+	if (G::RTAPI) { return; } /* Do not process. */
 	this->OnGroupMemberUpdate(&member);
 }
 void CSquadMgr::OnAgentLeave(AgentUpdate* aAgentUpdate)
@@ -1055,58 +1056,56 @@ void CSquadMgr::OnAgentLeave(AgentUpdate* aAgentUpdate)
 	RTAPI::GroupMember member{};
 
 	/* Minimal data needed here. */
-	strcpy_s(&member.AccountName[0], sizeof(member.AccountName), &aAgentUpdate->AccountName[1]);
+	strcpy_s(&member.AccountName[0], sizeof(aAgentUpdate->AccountName) - 1, &aAgentUpdate->AccountName[1]);
 	member.IsSelf = aAgentUpdate->Self;
 
-	if (G::RTAPI) { return; }
+	if (G::RTAPI) { return; } /* Do not process. */
 	this->OnGroupMemberLeave(&member);
 }
 void CSquadMgr::OnSquadUpdate(SquadUpdate* aSquadUpdate)
 {
 	G::IsUEEnabled = true;
 
-	if (G::RTAPI) { return; } /* Prefer RTAPI updates over UE. */
-
 	for (size_t i = 0; i < aSquadUpdate->UsersCount; i++)
 	{
 		const std::lock_guard<std::mutex> lock(this->CacheMutex);
 
-		UserInfo& user = aSquadUpdate->UserInfo[i];
 		RTAPI::GroupMember member{};
-		AgentUpdate& agent = this->CachedAgentsArc[&user.AccountName[1]];
 
-		this->CachedAgentsUE[&user.AccountName[1]] = user;
-		this->CachedAgentsUE[&user.AccountName[1]].Subgroup++;
+		auto [usrIt, inserted] = this->CachedUsers.insert_or_assign(&aSquadUpdate->UserInfo[i].AccountName[1], aSquadUpdate->UserInfo[i]);
 
-		strcpy_s(&member.AccountName[0], sizeof(member.AccountName), &user.AccountName[1]);
-		strcpy_s(&member.CharacterName[0], sizeof(member.CharacterName), &agent.CharacterName[0]);
-		member.Subgroup = user.Subgroup;
-		/* UE reports 0 based subgroup instead of display value. */
-		if (user.Role != UserRole::Invited && user.Role != UserRole::Applied)
+		strcpy_s(&member.AccountName[0], sizeof(member.AccountName) - 1, usrIt->first.c_str());
+		member.Subgroup     = usrIt->second.Subgroup;
+		/* UE reports 0 based subgroup instead of display value. So we increment it manually. */
+		member.Subgroup    += (usrIt->second.Role != UserRole::Invited && usrIt->second.Role != UserRole::Applied) ? 1 : 0;
+		member.IsCommander  = usrIt->second.Role == UserRole::SquadLeader;
+		member.IsLieutenant = usrIt->second.Role == UserRole::Lieutenant;
+
+		auto agIt = this->CachedAgents.find(usrIt->first);
+
+		if (agIt != this->CachedAgents.end())
 		{
-			member.Subgroup++;
+			strcpy_s(&member.CharacterName[0], sizeof(member.CharacterName) - 1, agIt->first.c_str());
+			member.Profession          = agIt->second.Prof;
+			member.EliteSpecialization = agIt->second.Elite;
+			member.IsInInstance        = agIt->second.ID > 0;
+			member.IsSelf              = agIt->second.Self;
 		}
-		member.Profession = agent.Prof;
-		member.EliteSpecialization = agent.Elite;
-		member.IsInInstance = agent.ID > 0;
-		member.IsSelf = agent.Self;
-		member.IsCommander  = user.Role == UserRole::SquadLeader;
-		member.IsLieutenant = user.Role == UserRole::Lieutenant;
-
-		if (user.Role == UserRole::None)
+
+		if (usrIt->second.Role == UserRole::None)
 		{
-			this->CachedAgentsUE.erase(&user.AccountName[1]);
-			if (!this->CachedAgentsArc[&user.AccountName[1]].Self)
+			this->CachedUsers.erase(usrIt);
+			if (agIt != this->CachedAgents.end() && !agIt->second.Self)
 			{
-				this->CachedAgentsArc.erase(&user.AccountName[1]);
+				this->CachedAgents.erase(agIt);
 			}
 
-			if (G::RTAPI) { return; }
+			if (G::RTAPI) { continue; } /* Do not process. */
 			this->OnGroupMemberLeave(&member);
 		}
 		else
 		{
-			if (G::RTAPI) { return; }
+			if (G::RTAPI) { continue; } /* Do not process. */
 			this->OnGroupMemberUpdate(&member);
 		}
 	}

src/SquadMgr/SquadMgr.h

@@ -60,8 +60,8 @@ class CSquadMgr
 	std::unordered_map<std::string, PlayerInfo_t> Players;
 
 	std::mutex                                    CacheMutex;
-	std::unordered_map<std::string, AgentUpdate>  CachedAgentsArc;
-	std::unordered_map<std::string, UserInfo>     CachedAgentsUE;
+	std::unordered_map<std::string, AgentUpdate>  CachedAgents; /* From Arc */
+	std::unordered_map<std::string, UserInfo>     CachedUsers;  /* From UE */
 
 	std::mutex                                    KPMutex;
 	std::unordered_map<std::string, KPMEInfo_t*>  KPData;