Eauldane/SnowcloakClient
1
0
Fork 1
Code Issues Pull Requests Actions 2 Packages Projects Releases 3 Wiki Activity

Initial

Browse Source
This commit is contained in:
Eauldane
2025-08-22 02:19:48 +01:00
commit a4c82452be
373 changed files with 52044 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
MareSynchronos/PlayerData/Pairs/OnlinePlayerManager.cs Normal file
View File

@@ -0,0 +1,75 @@
using MareSynchronos.API.Data;
using MareSynchronos.PlayerData.Handlers;
using MareSynchronos.Services;
using MareSynchronos.Services.Mediator;
using MareSynchronos.Utils;
using MareSynchronos.WebAPI;
using MareSynchronos.WebAPI.Files;
using Microsoft.Extensions.Logging;
namespace MareSynchronos.PlayerData.Pairs;
public class OnlinePlayerManager : DisposableMediatorSubscriberBase
{
private readonly ApiController _apiController;
private readonly DalamudUtilService _dalamudUtil;
private readonly FileUploadManager _fileTransferManager;
private readonly HashSet<PairHandler> _newVisiblePlayers = [];
private readonly PairManager _pairManager;
private CharacterData? _lastSentData;
public OnlinePlayerManager(ILogger<OnlinePlayerManager> logger, ApiController apiController, DalamudUtilService dalamudUtil,
PairManager pairManager, MareMediator mediator, FileUploadManager fileTransferManager) : base(logger, mediator)
{
_apiController = apiController;
_dalamudUtil = dalamudUtil;
_pairManager = pairManager;
_fileTransferManager = fileTransferManager;
Mediator.Subscribe<PlayerChangedMessage>(this, (_) => PlayerManagerOnPlayerHasChanged());
Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (_) => FrameworkOnUpdate());
Mediator.Subscribe<CharacterDataCreatedMessage>(this, (msg) =>
{
var newData = msg.CharacterData;
if (_lastSentData == null || (!string.Equals(newData.DataHash.Value, _lastSentData.DataHash.Value, StringComparison.Ordinal)))
{
Logger.LogDebug("Pushing data for visible players");
_lastSentData = newData;
PushCharacterData(_pairManager.GetVisibleUsers());
}
else
{
Logger.LogDebug("Not sending data for {hash}", newData.DataHash.Value);
}
});
Mediator.Subscribe<PairHandlerVisibleMessage>(this, (msg) => _newVisiblePlayers.Add(msg.Player));
Mediator.Subscribe<ConnectedMessage>(this, (_) => PushCharacterData(_pairManager.GetVisibleUsers()));
}
private void FrameworkOnUpdate()
{
if (!_dalamudUtil.GetIsPlayerPresent() || !_apiController.IsConnected) return;
if (!_newVisiblePlayers.Any()) return;
var newVisiblePlayers = _newVisiblePlayers.ToList();
_newVisiblePlayers.Clear();
Logger.LogTrace("Has new visible players, pushing character data");
PushCharacterData(newVisiblePlayers.Select(c => c.Pair.UserData).ToList());
}
private void PlayerManagerOnPlayerHasChanged()
{
PushCharacterData(_pairManager.GetVisibleUsers());
}
private void PushCharacterData(List<UserData> visiblePlayers)
{
if (visiblePlayers.Any() && _lastSentData != null)
{
_ = Task.Run(async () =>
{
var dataToSend = await _fileTransferManager.UploadFiles(_lastSentData.DeepClone(), visiblePlayers).ConfigureAwait(false);
await _apiController.PushCharacterData(dataToSend, visiblePlayers).ConfigureAwait(false);
});
}
}
}

10
MareSynchronos/PlayerData/Pairs/OptionalPluginWarning.cs Normal file
View File

@@ -0,0 +1,10 @@
namespace MareSynchronos.PlayerData.Pairs;
public record OptionalPluginWarning
{
public bool ShownHeelsWarning { get; set; } = false;
public bool ShownCustomizePlusWarning { get; set; } = false;
public bool ShownHonorificWarning { get; set; } = false;
public bool ShowPetNicknamesWarning { get; set; } = false;
public bool ShownMoodlesWarning { get; set; } = false;
}

376
MareSynchronos/PlayerData/Pairs/Pair.cs Normal file
View File

@@ -0,0 +1,376 @@
using Dalamud.Game.Gui.ContextMenu;
using Dalamud.Game.Text.SeStringHandling;
using MareSynchronos.API.Data;
using MareSynchronos.API.Data.Comparer;
using MareSynchronos.API.Data.Enum;
using MareSynchronos.API.Data.Extensions;
using MareSynchronos.API.Dto.Group;
using MareSynchronos.API.Dto.User;
using MareSynchronos.MareConfiguration;
using MareSynchronos.PlayerData.Factories;
using MareSynchronos.PlayerData.Handlers;
using MareSynchronos.Services;
using MareSynchronos.Services.Mediator;
using MareSynchronos.Services.ServerConfiguration;
using MareSynchronos.Utils;
using Microsoft.Extensions.Logging;
using System.Collections.Concurrent;
namespace MareSynchronos.PlayerData.Pairs;
public class Pair : DisposableMediatorSubscriberBase
{
private readonly PairHandlerFactory _cachedPlayerFactory;
private readonly SemaphoreSlim _creationSemaphore = new(1);
private readonly ILogger<Pair> _logger;
private readonly MareConfigService _mareConfig;
private readonly ServerConfigurationManager _serverConfigurationManager;
private CancellationTokenSource _applicationCts = new();
private OnlineUserIdentDto? _onlineUserIdentDto = null;
public Pair(ILogger<Pair> logger, UserData userData, PairHandlerFactory cachedPlayerFactory,
MareMediator mediator, MareConfigService mareConfig, ServerConfigurationManager serverConfigurationManager)
: base(logger, mediator)
{
_logger = logger;
_cachedPlayerFactory = cachedPlayerFactory;
_mareConfig = mareConfig;
_serverConfigurationManager = serverConfigurationManager;
UserData = userData;
Mediator.SubscribeKeyed<HoldPairApplicationMessage>(this, UserData.UID, (msg) => HoldApplication(msg.Source));
Mediator.SubscribeKeyed<UnholdPairApplicationMessage>(this, UserData.UID, (msg) => UnholdApplication(msg.Source));
}
public Dictionary<GroupFullInfoDto, GroupPairFullInfoDto> GroupPair { get; set; } = new(GroupDtoComparer.Instance);
public bool HasCachedPlayer => CachedPlayer != null && !string.IsNullOrEmpty(CachedPlayer.PlayerName) && _onlineUserIdentDto != null;
public bool IsOnline => CachedPlayer != null;
public bool IsPaused => UserPair != null && UserPair.OtherPermissions.IsPaired() ? UserPair.OtherPermissions.IsPaused() || UserPair.OwnPermissions.IsPaused()
: GroupPair.All(p => p.Key.GroupUserPermissions.IsPaused() || p.Value.GroupUserPermissions.IsPaused());
// Download locks apply earlier in the process than Application locks
private ConcurrentDictionary<string, int> HoldDownloadLocks { get; set; } = new(StringComparer.Ordinal);
private ConcurrentDictionary<string, int> HoldApplicationLocks { get; set; } = new(StringComparer.Ordinal);
public bool IsDownloadBlocked => HoldDownloadLocks.Any(f => f.Value > 0);
public bool IsApplicationBlocked => HoldApplicationLocks.Any(f => f.Value > 0) || IsDownloadBlocked;
public IEnumerable<string> HoldDownloadReasons => HoldDownloadLocks.Keys;
public IEnumerable<string> HoldApplicationReasons => Enumerable.Concat(HoldDownloadLocks.Keys, HoldApplicationLocks.Keys);
public bool IsVisible => CachedPlayer?.IsVisible ?? false;
public CharacterData? LastReceivedCharacterData { get; set; }
public string? PlayerName => GetPlayerName();
public uint PlayerCharacterId => GetPlayerCharacterId();
public long LastAppliedDataBytes => CachedPlayer?.LastAppliedDataBytes ?? -1;
public long LastAppliedDataTris { get; set; } = -1;
public long LastAppliedApproximateVRAMBytes { get; set; } = -1;
public string Ident => _onlineUserIdentDto?.Ident ?? string.Empty;
public PairAnalyzer? PairAnalyzer => CachedPlayer?.PairAnalyzer;
public UserData UserData { get; init; }
public UserPairDto? UserPair { get; set; }
private PairHandler? CachedPlayer { get; set; }
public void AddContextMenu(IMenuOpenedArgs args)
{
if (CachedPlayer == null || (args.Target is not MenuTargetDefault target) || target.TargetObjectId != CachedPlayer.PlayerCharacterId || IsPaused) return;
void Add(string name, Action<IMenuItemClickedArgs>? action)
{
args.AddMenuItem(new MenuItem()
{
Name = name,
OnClicked = action,
PrefixColor = 559,
PrefixChar = 'L'
});
}
bool isBlocked = IsApplicationBlocked;
bool isBlacklisted = _serverConfigurationManager.IsUidBlacklisted(UserData.UID);
bool isWhitelisted = _serverConfigurationManager.IsUidWhitelisted(UserData.UID);
Add("Open Profile", _ => Mediator.Publish(new ProfileOpenStandaloneMessage(this)));
if (!isBlocked && !isBlacklisted)
Add("Always Block Modded Appearance", _ => {
_serverConfigurationManager.AddBlacklistUid(UserData.UID);
HoldApplication("Blacklist", maxValue: 1);
ApplyLastReceivedData(forced: true);
});
else if (isBlocked && !isWhitelisted)
Add("Always Allow Modded Appearance", _ => {
_serverConfigurationManager.AddWhitelistUid(UserData.UID);
UnholdApplication("Blacklist", skipApplication: true);
ApplyLastReceivedData(forced: true);
});
if (isWhitelisted)
Add("Remove from Whitelist", _ => {
_serverConfigurationManager.RemoveWhitelistUid(UserData.UID);
ApplyLastReceivedData(forced: true);
});
else if (isBlacklisted)
Add("Remove from Blacklist", _ => {
_serverConfigurationManager.RemoveBlacklistUid(UserData.UID);
UnholdApplication("Blacklist", skipApplication: true);
ApplyLastReceivedData(forced: true);
});
Add("Reapply last data", _ => ApplyLastReceivedData(forced: true));
if (UserPair != null)
{
Add("Change Permissions", _ => Mediator.Publish(new OpenPermissionWindow(this)));
Add("Cycle pause state", _ => Mediator.Publish(new CyclePauseMessage(UserData)));
}
}
public void ApplyData(OnlineUserCharaDataDto data)
{
_applicationCts = _applicationCts.CancelRecreate();
LastReceivedCharacterData = data.CharaData;
if (CachedPlayer == null)
{
_logger.LogDebug("Received Data for {uid} but CachedPlayer does not exist, waiting", data.User.UID);
_ = Task.Run(async () =>
{
using var timeoutCts = new CancellationTokenSource();
timeoutCts.CancelAfter(TimeSpan.FromSeconds(120));
var appToken = _applicationCts.Token;
using var combined = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, appToken);
while (CachedPlayer == null && !combined.Token.IsCancellationRequested)
{
await Task.Delay(250, combined.Token).ConfigureAwait(false);
}
if (!combined.IsCancellationRequested)
{
_logger.LogDebug("Applying delayed data for {uid}", data.User.UID);
ApplyLastReceivedData();
}
});
return;
}
ApplyLastReceivedData();
}
public void ApplyLastReceivedData(bool forced = false)
{
if (CachedPlayer == null) return;
if (LastReceivedCharacterData == null) return;
if (IsDownloadBlocked) return;
if (_serverConfigurationManager.IsUidBlacklisted(UserData.UID))
HoldApplication("Blacklist", maxValue: 1);
if (NoSnapService.AnyLoaded)
HoldApplication("NoSnap", maxValue: 1);
else
UnholdApplication("NoSnap", skipApplication: true);
CachedPlayer.ApplyCharacterData(Guid.NewGuid(), RemoveNotSyncedFiles(LastReceivedCharacterData.DeepClone())!, forced);
}
public void CreateCachedPlayer(OnlineUserIdentDto? dto = null)
{
try
{
_creationSemaphore.Wait();
if (CachedPlayer != null) return;
if (dto == null && _onlineUserIdentDto == null)
{
CachedPlayer?.Dispose();
CachedPlayer = null;
return;
}
if (dto != null)
{
_onlineUserIdentDto = dto;
}
CachedPlayer?.Dispose();
CachedPlayer = _cachedPlayerFactory.Create(this);
}
finally
{
_creationSemaphore.Release();
}
}
public string? GetNote()
{
return _serverConfigurationManager.GetNoteForUid(UserData.UID);
}
public string? GetPlayerName()
{
if (CachedPlayer != null && CachedPlayer.PlayerName != null)
return CachedPlayer.PlayerName;
else
return _serverConfigurationManager.GetNameForUid(UserData.UID);
}
public uint GetPlayerCharacterId()
{
if (CachedPlayer != null)
return CachedPlayer.PlayerCharacterId;
return uint.MaxValue;
}
public string? GetNoteOrName()
{
string? note = GetNote();
if (_mareConfig.Current.ShowCharacterNames || IsVisible)
return note ?? GetPlayerName();
else
return note;
}
public string GetPairSortKey()
{
string? noteOrName = GetNoteOrName();
if (noteOrName != null)
return $"0{noteOrName}";
else
return $"9{UserData.AliasOrUID}";
}
public string GetPlayerNameHash()
{
return CachedPlayer?.PlayerNameHash ?? string.Empty;
}
public bool HasAnyConnection()
{
return UserPair != null || GroupPair.Any();
}
public void MarkOffline(bool wait = true)
{
try
{
if (wait)
_creationSemaphore.Wait();
LastReceivedCharacterData = null;
var player = CachedPlayer;
CachedPlayer = null;
player?.Dispose();
_onlineUserIdentDto = null;
}
finally
{
if (wait)
_creationSemaphore.Release();
}
}
public void SetNote(string note)
{
_serverConfigurationManager.SetNoteForUid(UserData.UID, note);
}
internal void SetIsUploading()
{
CachedPlayer?.SetUploading();
}
public void HoldApplication(string source, int maxValue = int.MaxValue)
{
_logger.LogDebug($"Holding {UserData.UID} for reason: {source}");
bool wasHeld = IsApplicationBlocked;
HoldApplicationLocks.AddOrUpdate(source, 1, (k, v) => Math.Min(maxValue, v + 1));
if (!wasHeld)
CachedPlayer?.UndoApplication();
}
public void UnholdApplication(string source, bool skipApplication = false)
{
_logger.LogDebug($"Un-holding {UserData.UID} for reason: {source}");
bool wasHeld = IsApplicationBlocked;
HoldApplicationLocks.AddOrUpdate(source, 0, (k, v) => Math.Max(0, v - 1));
HoldApplicationLocks.TryRemove(new(source, 0));
if (!skipApplication && wasHeld && !IsApplicationBlocked)
ApplyLastReceivedData(forced: true);
}
public void HoldDownloads(string source, int maxValue = int.MaxValue)
{
_logger.LogDebug($"Holding {UserData.UID} for reason: {source}");
bool wasHeld = IsApplicationBlocked;
HoldDownloadLocks.AddOrUpdate(source, 1, (k, v) => Math.Min(maxValue, v + 1));
if (!wasHeld)
CachedPlayer?.UndoApplication();
}
public void UnholdDownloads(string source, bool skipApplication = false)
{
_logger.LogDebug($"Un-holding {UserData.UID} for reason: {source}");
bool wasHeld = IsApplicationBlocked;
HoldDownloadLocks.AddOrUpdate(source, 0, (k, v) => Math.Max(0, v - 1));
HoldDownloadLocks.TryRemove(new(source, 0));
if (!skipApplication && wasHeld && !IsApplicationBlocked)
ApplyLastReceivedData(forced: true);
}
private CharacterData? RemoveNotSyncedFiles(CharacterData? data)
{
_logger.LogTrace("Removing not synced files");
if (data == null)
{
_logger.LogTrace("Nothing to remove");
return data;
}
var ActiveGroupPairs = GroupPair.Where(p => !p.Value.GroupUserPermissions.IsPaused() && !p.Key.GroupUserPermissions.IsPaused()).ToList();
bool disableIndividualAnimations = UserPair != null && (UserPair.OtherPermissions.IsDisableAnimations() || UserPair.OwnPermissions.IsDisableAnimations());
bool disableIndividualVFX = UserPair != null && (UserPair.OtherPermissions.IsDisableVFX() || UserPair.OwnPermissions.IsDisableVFX());
bool disableGroupAnimations = ActiveGroupPairs.All(pair => pair.Value.GroupUserPermissions.IsDisableAnimations() || pair.Key.GroupPermissions.IsDisableAnimations() || pair.Key.GroupUserPermissions.IsDisableAnimations());
bool disableAnimations = (UserPair != null && disableIndividualAnimations) || (UserPair == null && disableGroupAnimations);
bool disableIndividualSounds = UserPair != null && (UserPair.OtherPermissions.IsDisableSounds() || UserPair.OwnPermissions.IsDisableSounds());
bool disableGroupSounds = ActiveGroupPairs.All(pair => pair.Value.GroupUserPermissions.IsDisableSounds() || pair.Key.GroupPermissions.IsDisableSounds() || pair.Key.GroupUserPermissions.IsDisableSounds());
bool disableGroupVFX = ActiveGroupPairs.All(pair => pair.Value.GroupUserPermissions.IsDisableVFX() || pair.Key.GroupPermissions.IsDisableVFX() || pair.Key.GroupUserPermissions.IsDisableVFX());
bool disableSounds = (UserPair != null && disableIndividualSounds) || (UserPair == null && disableGroupSounds);
bool disableVFX = (UserPair != null && disableIndividualVFX) || (UserPair == null && disableGroupVFX);
_logger.LogTrace("Disable: Sounds: {disableSounds}, Anims: {disableAnimations}, VFX: {disableVFX}",
disableSounds, disableAnimations, disableVFX);
if (disableAnimations || disableSounds || disableVFX)
{
_logger.LogTrace("Data cleaned up: Animations disabled: {disableAnimations}, Sounds disabled: {disableSounds}, VFX disabled: {disableVFX}",
disableAnimations, disableSounds, disableVFX);
foreach (var objectKind in data.FileReplacements.Select(k => k.Key))
{
if (disableSounds)
data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
.Where(f => !f.GamePaths.Any(p => p.EndsWith("scd", StringComparison.OrdinalIgnoreCase)))
.ToList();
if (disableAnimations)
data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
.Where(f => !f.GamePaths.Any(p => p.EndsWith("tmb", StringComparison.OrdinalIgnoreCase) || p.EndsWith("pap", StringComparison.OrdinalIgnoreCase)))
.ToList();
if (disableVFX)
data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
.Where(f => !f.GamePaths.Any(p => p.EndsWith("atex", StringComparison.OrdinalIgnoreCase) || p.EndsWith("avfx", StringComparison.OrdinalIgnoreCase)))
.ToList();
}
}
return data;
}
}

403
MareSynchronos/PlayerData/Pairs/PairManager.cs Normal file
View File

@@ -0,0 +1,403 @@
using Dalamud.Plugin.Services;
using MareSynchronos.API.Data;
using MareSynchronos.API.Data.Comparer;
using MareSynchronos.API.Data.Extensions;
using MareSynchronos.API.Dto.Group;
using MareSynchronos.API.Dto.User;
using MareSynchronos.MareConfiguration;
using MareSynchronos.MareConfiguration.Models;
using MareSynchronos.PlayerData.Factories;
using MareSynchronos.Services.Events;
using MareSynchronos.Services.Mediator;
using Microsoft.Extensions.Logging;
using System.Collections.Concurrent;
namespace MareSynchronos.PlayerData.Pairs;
public sealed class PairManager : DisposableMediatorSubscriberBase
{
private readonly ConcurrentDictionary<UserData, Pair> _allClientPairs = new(UserDataComparer.Instance);
private readonly ConcurrentDictionary<GroupData, GroupFullInfoDto> _allGroups = new(GroupDataComparer.Instance);
private readonly MareConfigService _configurationService;
private readonly IContextMenu _dalamudContextMenu;
private readonly PairFactory _pairFactory;
private Lazy<List<Pair>> _directPairsInternal;
private Lazy<Dictionary<GroupFullInfoDto, List<Pair>>> _groupPairsInternal;
public PairManager(ILogger<PairManager> logger, PairFactory pairFactory,
MareConfigService configurationService, MareMediator mediator,
IContextMenu dalamudContextMenu) : base(logger, mediator)
{
_pairFactory = pairFactory;
_configurationService = configurationService;
_dalamudContextMenu = dalamudContextMenu;
Mediator.Subscribe<DisconnectedMessage>(this, (_) => ClearPairs());
Mediator.Subscribe<CutsceneEndMessage>(this, (_) => ReapplyPairData());
_directPairsInternal = DirectPairsLazy();
_groupPairsInternal = GroupPairsLazy();
_dalamudContextMenu.OnMenuOpened += DalamudContextMenuOnOnOpenGameObjectContextMenu;
}
public List<Pair> DirectPairs => _directPairsInternal.Value;
public Dictionary<GroupFullInfoDto, List<Pair>> GroupPairs => _groupPairsInternal.Value;
public Dictionary<GroupData, GroupFullInfoDto> Groups => _allGroups.ToDictionary(k => k.Key, k => k.Value);
public Pair? LastAddedUser { get; internal set; }
public void AddGroup(GroupFullInfoDto dto)
{
_allGroups[dto.Group] = dto;
RecreateLazy();
}
public void AddGroupPair(GroupPairFullInfoDto dto)
{
if (!_allClientPairs.ContainsKey(dto.User))
_allClientPairs[dto.User] = _pairFactory.Create(dto.User);
var group = _allGroups[dto.Group];
_allClientPairs[dto.User].GroupPair[group] = dto;
RecreateLazy();
}
public Pair? GetPairByUID(string uid)
{
var existingPair = _allClientPairs.FirstOrDefault(f => uid.Equals(f.Key.UID, StringComparison.Ordinal));
if (!Equals(existingPair, default(KeyValuePair<UserData, Pair>)))
{
return existingPair.Value;
}
return null;
}
public void AddUserPair(UserPairDto dto, bool addToLastAddedUser = true)
{
if (!_allClientPairs.ContainsKey(dto.User))
{
_allClientPairs[dto.User] = _pairFactory.Create(dto.User);
}
else
{
addToLastAddedUser = false;
}
_allClientPairs[dto.User].UserPair = dto;
if (addToLastAddedUser)
LastAddedUser = _allClientPairs[dto.User];
_allClientPairs[dto.User].ApplyLastReceivedData();
RecreateLazy();
}
public void ClearPairs()
{
Logger.LogDebug("Clearing all Pairs");
DisposePairs();
_allClientPairs.Clear();
_allGroups.Clear();
RecreateLazy();
}
public List<Pair> GetOnlineUserPairs() => _allClientPairs.Where(p => !string.IsNullOrEmpty(p.Value.GetPlayerNameHash())).Select(p => p.Value).ToList();
public int GetVisibleUserCount() => _allClientPairs.Count(p => p.Value.IsVisible);
public List<UserData> GetVisibleUsers() => _allClientPairs.Where(p => p.Value.IsVisible).Select(p => p.Key).ToList();
public void MarkPairOffline(UserData user)
{
if (_allClientPairs.TryGetValue(user, out var pair))
{
Mediator.Publish(new ClearProfileDataMessage(pair.UserData));
pair.MarkOffline();
}
RecreateLazy();
}
public void MarkPairOnline(OnlineUserIdentDto dto, bool sendNotif = true)
{
if (!_allClientPairs.ContainsKey(dto.User)) throw new InvalidOperationException("No user found for " + dto);
Mediator.Publish(new ClearProfileDataMessage(dto.User));
var pair = _allClientPairs[dto.User];
if (pair.HasCachedPlayer)
{
RecreateLazy();
return;
}
if (sendNotif && _configurationService.Current.ShowOnlineNotifications
&& (_configurationService.Current.ShowOnlineNotificationsOnlyForIndividualPairs && pair.UserPair != null
|| !_configurationService.Current.ShowOnlineNotificationsOnlyForIndividualPairs)
&& (_configurationService.Current.ShowOnlineNotificationsOnlyForNamedPairs && !string.IsNullOrEmpty(pair.GetNote())
|| !_configurationService.Current.ShowOnlineNotificationsOnlyForNamedPairs))
{
string? note = pair.GetNoteOrName();
var msg = !string.IsNullOrEmpty(note)
? $"{note} ({pair.UserData.AliasOrUID}) is now online"
: $"{pair.UserData.AliasOrUID} is now online";
Mediator.Publish(new NotificationMessage("User online", msg, NotificationType.Info, TimeSpan.FromSeconds(5)));
}
pair.CreateCachedPlayer(dto);
RecreateLazy();
}
public void ReceiveCharaData(OnlineUserCharaDataDto dto)
{
if (!_allClientPairs.TryGetValue(dto.User, out var pair)) throw new InvalidOperationException("No user found for " + dto.User);
Mediator.Publish(new EventMessage(new Event(pair.UserData, nameof(PairManager), EventSeverity.Informational, "Received Character Data")));
_allClientPairs[dto.User].ApplyData(dto);
}
public void RemoveGroup(GroupData data)
{
_allGroups.TryRemove(data, out _);
foreach (var item in _allClientPairs.ToList())
{
foreach (var grpPair in item.Value.GroupPair.Select(k => k.Key).Where(grpPair => GroupDataComparer.Instance.Equals(grpPair.Group, data)).ToList())
{
_allClientPairs[item.Key].GroupPair.Remove(grpPair);
}
if (!_allClientPairs[item.Key].HasAnyConnection() && _allClientPairs.TryRemove(item.Key, out var pair))
{
pair.MarkOffline();
}
}
RecreateLazy();
}
public void RemoveGroupPair(GroupPairDto dto)
{
if (_allClientPairs.TryGetValue(dto.User, out var pair))
{
var group = _allGroups[dto.Group];
pair.GroupPair.Remove(group);
if (!pair.HasAnyConnection())
{
pair.MarkOffline();
_allClientPairs.TryRemove(dto.User, out _);
}
}
RecreateLazy();
}
public void RemoveUserPair(UserDto dto)
{
if (_allClientPairs.TryGetValue(dto.User, out var pair))
{
pair.UserPair = null;
if (!pair.HasAnyConnection())
{
pair.MarkOffline();
_allClientPairs.TryRemove(dto.User, out _);
}
}
RecreateLazy();
}
public void SetGroupInfo(GroupInfoDto dto)
{
_allGroups[dto.Group].Group = dto.Group;
_allGroups[dto.Group].Owner = dto.Owner;
_allGroups[dto.Group].GroupPermissions = dto.GroupPermissions;
RecreateLazy();
}
public void UpdatePairPermissions(UserPermissionsDto dto)
{
if (!_allClientPairs.TryGetValue(dto.User, out var pair))
{
throw new InvalidOperationException("No such pair for " + dto);
}
if (pair.UserPair == null) throw new InvalidOperationException("No direct pair for " + dto);
if (pair.UserPair.OtherPermissions.IsPaused() != dto.Permissions.IsPaused()
|| pair.UserPair.OtherPermissions.IsPaired() != dto.Permissions.IsPaired())
{
Mediator.Publish(new ClearProfileDataMessage(dto.User));
}
pair.UserPair.OtherPermissions = dto.Permissions;
Logger.LogTrace("Paused: {paused}, Anims: {anims}, Sounds: {sounds}, VFX: {vfx}",
pair.UserPair.OtherPermissions.IsPaused(),
pair.UserPair.OtherPermissions.IsDisableAnimations(),
pair.UserPair.OtherPermissions.IsDisableSounds(),
pair.UserPair.OtherPermissions.IsDisableVFX());
if (!pair.IsPaused)
pair.ApplyLastReceivedData();
RecreateLazy();
}
public void UpdateSelfPairPermissions(UserPermissionsDto dto)
{
if (!_allClientPairs.TryGetValue(dto.User, out var pair))
{
throw new InvalidOperationException("No such pair for " + dto);
}
if (pair.UserPair == null) throw new InvalidOperationException("No direct pair for " + dto);
if (pair.UserPair.OwnPermissions.IsPaused() != dto.Permissions.IsPaused()
|| pair.UserPair.OwnPermissions.IsPaired() != dto.Permissions.IsPaired())
{
Mediator.Publish(new ClearProfileDataMessage(dto.User));
}
pair.UserPair.OwnPermissions = dto.Permissions;
Logger.LogTrace("Paused: {paused}, Anims: {anims}, Sounds: {sounds}, VFX: {vfx}",
pair.UserPair.OwnPermissions.IsPaused(),
pair.UserPair.OwnPermissions.IsDisableAnimations(),
pair.UserPair.OwnPermissions.IsDisableSounds(),
pair.UserPair.OwnPermissions.IsDisableVFX());
if (!pair.IsPaused)
pair.ApplyLastReceivedData();
RecreateLazy();
}
internal void ReceiveUploadStatus(UserDto dto)
{
if (_allClientPairs.TryGetValue(dto.User, out var existingPair) && existingPair.IsVisible)
{
existingPair.SetIsUploading();
}
}
internal void SetGroupPairStatusInfo(GroupPairUserInfoDto dto)
{
var group = _allGroups[dto.Group];
_allClientPairs[dto.User].GroupPair[group].GroupPairStatusInfo = dto.GroupUserInfo;
RecreateLazy();
}
internal void SetGroupPairUserPermissions(GroupPairUserPermissionDto dto)
{
var group = _allGroups[dto.Group];
var prevPermissions = _allClientPairs[dto.User].GroupPair[group].GroupUserPermissions;
_allClientPairs[dto.User].GroupPair[group].GroupUserPermissions = dto.GroupPairPermissions;
if (prevPermissions.IsDisableAnimations() != dto.GroupPairPermissions.IsDisableAnimations()
|| prevPermissions.IsDisableSounds() != dto.GroupPairPermissions.IsDisableSounds()
|| prevPermissions.IsDisableVFX() != dto.GroupPairPermissions.IsDisableVFX())
{
_allClientPairs[dto.User].ApplyLastReceivedData();
}
RecreateLazy();
}
internal void SetGroupPermissions(GroupPermissionDto dto)
{
var prevPermissions = _allGroups[dto.Group].GroupPermissions;
_allGroups[dto.Group].GroupPermissions = dto.Permissions;
if (prevPermissions.IsDisableAnimations() != dto.Permissions.IsDisableAnimations()
|| prevPermissions.IsDisableSounds() != dto.Permissions.IsDisableSounds()
|| prevPermissions.IsDisableVFX() != dto.Permissions.IsDisableVFX())
{
RecreateLazy();
var group = _allGroups[dto.Group];
GroupPairs[group].ForEach(p => p.ApplyLastReceivedData());
}
RecreateLazy();
}
internal void SetGroupStatusInfo(GroupPairUserInfoDto dto)
{
_allGroups[dto.Group].GroupUserInfo = dto.GroupUserInfo;
RecreateLazy();
}
internal void SetGroupUserPermissions(GroupPairUserPermissionDto dto)
{
var prevPermissions = _allGroups[dto.Group].GroupUserPermissions;
_allGroups[dto.Group].GroupUserPermissions = dto.GroupPairPermissions;
if (prevPermissions.IsDisableAnimations() != dto.GroupPairPermissions.IsDisableAnimations()
|| prevPermissions.IsDisableSounds() != dto.GroupPairPermissions.IsDisableSounds()
|| prevPermissions.IsDisableVFX() != dto.GroupPairPermissions.IsDisableVFX())
{
RecreateLazy();
var group = _allGroups[dto.Group];
GroupPairs[group].ForEach(p => p.ApplyLastReceivedData());
}
RecreateLazy();
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
_dalamudContextMenu.OnMenuOpened -= DalamudContextMenuOnOnOpenGameObjectContextMenu;
DisposePairs();
}
private void DalamudContextMenuOnOnOpenGameObjectContextMenu(Dalamud.Game.Gui.ContextMenu.IMenuOpenedArgs args)
{
if (args.MenuType == Dalamud.Game.Gui.ContextMenu.ContextMenuType.Inventory) return;
if (!_configurationService.Current.EnableRightClickMenus) return;
foreach (var pair in _allClientPairs.Where((p => p.Value.IsVisible)))
{
pair.Value.AddContextMenu(args);
}
}
private Lazy<List<Pair>> DirectPairsLazy() => new(() => _allClientPairs.Select(k => k.Value)
.Where(k => k.UserPair != null).ToList());
private void DisposePairs()
{
Logger.LogDebug("Disposing all Pairs");
Parallel.ForEach(_allClientPairs, item =>
{
item.Value.MarkOffline(wait: false);
});
RecreateLazy();
}
private Lazy<Dictionary<GroupFullInfoDto, List<Pair>>> GroupPairsLazy()
{
return new Lazy<Dictionary<GroupFullInfoDto, List<Pair>>>(() =>
{
Dictionary<GroupFullInfoDto, List<Pair>> outDict = new();
foreach (var group in _allGroups)
{
outDict[group.Value] = _allClientPairs.Select(p => p.Value).Where(p => p.GroupPair.Any(g => GroupDataComparer.Instance.Equals(group.Key, g.Key.Group))).ToList();
}
return outDict;
});
}
private void ReapplyPairData()
{
foreach (var pair in _allClientPairs.Select(k => k.Value))
{
pair.ApplyLastReceivedData(forced: true);
}
}
private void RecreateLazy()
{
_directPairsInternal = DirectPairsLazy();
_groupPairsInternal = GroupPairsLazy();
}
}