From 98c3a2c7f8e67ca61daf84144216c4cf9902ce70 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Fri, 10 Oct 2025 06:42:59 +0200 Subject: [PATCH 01/64] Added syncshell profile related items. --- LightlessSync/PlayerData/Pairs/PairManager.cs | 8 +-- .../Services/LightlessGroupProfileData.cs | 6 ++ .../Services/LightlessProfileManager.cs | 67 ++++++++++++++----- ...ileData.cs => LightlessUserProfileData.cs} | 2 +- LightlessSync/Services/Mediator/Messages.cs | 3 +- LightlessSync/Services/UiFactory.cs | 2 +- LightlessSync/UI/EditProfileUi.cs | 8 +-- LightlessSync/UI/PopoutProfileUi.cs | 2 +- LightlessSync/UI/SettingsUi.cs | 4 +- LightlessSync/UI/StandaloneProfileUi.cs | 2 +- .../ApiController.Functions.Callbacks.cs | 8 ++- .../SignalR/ApiController.Functions.Groups.cs | 11 +++ LightlessSync/WebAPI/SignalR/ApiController.cs | 10 --- 13 files changed, 91 insertions(+), 42 deletions(-) create mode 100644 LightlessSync/Services/LightlessGroupProfileData.cs rename LightlessSync/Services/{LightlessProfileData.cs => LightlessUserProfileData.cs} (68%) diff --git a/LightlessSync/PlayerData/Pairs/PairManager.cs b/LightlessSync/PlayerData/Pairs/PairManager.cs index 512c7ad..2044db0 100644 --- a/LightlessSync/PlayerData/Pairs/PairManager.cs +++ b/LightlessSync/PlayerData/Pairs/PairManager.cs @@ -138,7 +138,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase { if (_allClientPairs.TryGetValue(user, out var pair)) { - Mediator.Publish(new ClearProfileDataMessage(pair.UserData)); + Mediator.Publish(new ClearProfileUserDataMessage(pair.UserData)); pair.MarkOffline(); } @@ -149,7 +149,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase { if (!_allClientPairs.ContainsKey(dto.User)) throw new InvalidOperationException("No user found for " + dto); - Mediator.Publish(new ClearProfileDataMessage(dto.User)); + Mediator.Publish(new ClearProfileUserDataMessage(dto.User)); var pair = _allClientPairs[dto.User]; if (pair.HasCachedPlayer) @@ -254,7 +254,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase if (pair.UserPair.OtherPermissions.IsPaused() != dto.Permissions.IsPaused()) { - Mediator.Publish(new ClearProfileDataMessage(dto.User)); + Mediator.Publish(new ClearProfileUserDataMessage(dto.User)); } pair.UserPair.OtherPermissions = dto.Permissions; @@ -280,7 +280,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase if (pair.UserPair.OwnPermissions.IsPaused() != dto.Permissions.IsPaused()) { - Mediator.Publish(new ClearProfileDataMessage(dto.User)); + Mediator.Publish(new ClearProfileUserDataMessage(dto.User)); } pair.UserPair.OwnPermissions = dto.Permissions; diff --git a/LightlessSync/Services/LightlessGroupProfileData.cs b/LightlessSync/Services/LightlessGroupProfileData.cs new file mode 100644 index 0000000..5a4c01a --- /dev/null +++ b/LightlessSync/Services/LightlessGroupProfileData.cs @@ -0,0 +1,6 @@ +namespace LightlessSync.Services; + +public record LightlessGroupProfileData(string Base64ProfilePicture, string Description, string Tags) +{ + public Lazy ImageData { get; } = new Lazy(Convert.FromBase64String(Base64ProfilePicture)); +} diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index f880a6a..8da01b4 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -18,11 +18,14 @@ public class LightlessProfileManager : MediatorSubscriberBase private const string _nsfw = "Profile not displayed - NSFW"; private readonly ApiController _apiController; private readonly LightlessConfigService _lightlessConfigService; - private readonly ConcurrentDictionary _lightlessProfiles = new(UserDataComparer.Instance); + private readonly ConcurrentDictionary _lightlessUserProfiles = new(UserDataComparer.Instance); + private readonly ConcurrentDictionary _lightlessGroupProfiles = new(GroupDataComparer.Instance); - private readonly LightlessProfileData _defaultProfileData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noDescription); - private readonly LightlessProfileData _loadingProfileData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, "Loading Data from server..."); - private readonly LightlessProfileData _nsfwProfileData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfw); + private readonly LightlessUserProfileData _defaultProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noDescription); + private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, "Loading User Profile Data from server..."); + private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Group Profile Data from server...", string.Empty); + private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noDescription, string.Empty); + private readonly LightlessUserProfileData _nsfwProfileData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfw); public LightlessProfileManager(ILogger logger, LightlessConfigService lightlessConfigService, LightlessMediator mediator, ApiController apiController) : base(logger, mediator) @@ -30,22 +33,33 @@ public class LightlessProfileManager : MediatorSubscriberBase _lightlessConfigService = lightlessConfigService; _apiController = apiController; - Mediator.Subscribe(this, (msg) => + Mediator.Subscribe(this, (msg) => { if (msg.UserData != null) - _lightlessProfiles.Remove(msg.UserData, out _); + _lightlessUserProfiles.Remove(msg.UserData, out _); else - _lightlessProfiles.Clear(); + _lightlessUserProfiles.Clear(); }); - Mediator.Subscribe(this, (_) => _lightlessProfiles.Clear()); + Mediator.Subscribe(this, (_) => _lightlessUserProfiles.Clear()); } - public LightlessProfileData GetLightlessProfile(UserData data) + public LightlessUserProfileData GetLightlessUserProfile(UserData data) { - if (!_lightlessProfiles.TryGetValue(data, out var profile)) + if (!_lightlessUserProfiles.TryGetValue(data, out var profile)) { _ = Task.Run(() => GetLightlessProfileFromService(data)); - return (_loadingProfileData); + return (_loadingProfileUserData); + } + + return (profile); + } + + public LightlessGroupProfileData GetLightlessGroupProfile(GroupData data) + { + if (!_lightlessGroupProfiles.TryGetValue(data, out var profile)) + { + _ = Task.Run(() => GetLightlessProfileFromService(data)); + return (_loadingProfileGroupData); } return (profile); @@ -55,26 +69,47 @@ public class LightlessProfileManager : MediatorSubscriberBase { try { - _lightlessProfiles[data] = _loadingProfileData; + _lightlessUserProfiles[data] = _loadingProfileUserData; var profile = await _apiController.UserGetProfile(new API.Dto.User.UserDto(data)).ConfigureAwait(false); - LightlessProfileData profileData = new(profile.Disabled, profile.IsNSFW ?? false, + LightlessUserProfileData profileData = new(profile.Disabled, profile.IsNSFW ?? false, string.IsNullOrEmpty(profile.ProfilePictureBase64) ? _lightlessLogo : profile.ProfilePictureBase64, !string.IsNullOrEmpty(data.Alias) && !string.Equals(data.Alias, data.UID, StringComparison.Ordinal) ? _lightlessSupporter : string.Empty, string.IsNullOrEmpty(profile.Description) ? _noDescription : profile.Description); if (profileData.IsNSFW && !_lightlessConfigService.Current.ProfilesAllowNsfw && !string.Equals(_apiController.UID, data.UID, StringComparison.Ordinal)) { - _lightlessProfiles[data] = _nsfwProfileData; + _lightlessUserProfiles[data] = _nsfwProfileData; } else { - _lightlessProfiles[data] = profileData; + _lightlessUserProfiles[data] = profileData; } } catch (Exception ex) { // if fails save DefaultProfileData to dict Logger.LogWarning(ex, "Failed to get Profile from service for user {user}", data); - _lightlessProfiles[data] = _defaultProfileData; + _lightlessUserProfiles[data] = _defaultProfileUserData; + } + } + + private async Task GetLightlessProfileFromService(GroupData data) + { + try + { + _lightlessGroupProfiles[data] = _loadingProfileGroupData; + var profile = await _apiController.GroupGetProfile(new API.Dto.Group.GroupDto(data)).ConfigureAwait(false); + LightlessGroupProfileData profileData = new( + string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, + !string.IsNullOrEmpty(data.Alias) && !string.Equals(data.Alias, data.GID, StringComparison.Ordinal) ? _lightlessSupporter : string.Empty, + string.IsNullOrEmpty(profile.Description) ? _noDescription : profile.Description); + + _lightlessGroupProfiles[data] = profileData; + } + catch (Exception ex) + { + // if fails save DefaultProfileData to dict + Logger.LogWarning(ex, "Failed to get Profile from service for group {group}", data); + _lightlessGroupProfiles[data] = _defaultProfileGroupData; } } } \ No newline at end of file diff --git a/LightlessSync/Services/LightlessProfileData.cs b/LightlessSync/Services/LightlessUserProfileData.cs similarity index 68% rename from LightlessSync/Services/LightlessProfileData.cs rename to LightlessSync/Services/LightlessUserProfileData.cs index a6f0053..3319043 100644 --- a/LightlessSync/Services/LightlessProfileData.cs +++ b/LightlessSync/Services/LightlessUserProfileData.cs @@ -1,6 +1,6 @@ namespace LightlessSync.Services; -public record LightlessProfileData(bool IsFlagged, bool IsNSFW, string Base64ProfilePicture, string Base64SupporterPicture, string Description) +public record LightlessUserProfileData(bool IsFlagged, bool IsNSFW, string Base64ProfilePicture, string Base64SupporterPicture, string Description) { public Lazy ImageData { get; } = new Lazy(Convert.FromBase64String(Base64ProfilePicture)); public Lazy SupporterImageData { get; } = new Lazy(string.IsNullOrEmpty(Base64SupporterPicture) ? [] : Convert.FromBase64String(Base64SupporterPicture)); diff --git a/LightlessSync/Services/Mediator/Messages.cs b/LightlessSync/Services/Mediator/Messages.cs index 963bcbf..064e6fb 100644 --- a/LightlessSync/Services/Mediator/Messages.cs +++ b/LightlessSync/Services/Mediator/Messages.cs @@ -64,7 +64,8 @@ public record DownloadStartedMessage(GameObjectHandler DownloadId, Dictionary(), _lightlessMediator, - _apiController, _uiSharedService, _pairManager, dto, _performanceCollectorService); + _apiController, _uiSharedService, _pairManager, dto, _performanceCollectorService, _lightlessProfileManager); } public StandaloneProfileUi CreateStandaloneProfileUi(Pair pair) diff --git a/LightlessSync/UI/EditProfileUi.cs b/LightlessSync/UI/EditProfileUi.cs index 72e8d33..d9db33b 100644 --- a/LightlessSync/UI/EditProfileUi.cs +++ b/LightlessSync/UI/EditProfileUi.cs @@ -25,8 +25,8 @@ public class EditProfileUi : WindowMediatorSubscriberBase private readonly FileDialogManager _fileDialogManager; private readonly LightlessProfileManager _lightlessProfileManager; private readonly UiSharedService _uiSharedService; - private bool _adjustedForScollBarsLocalProfile = false; - private bool _adjustedForScollBarsOnlineProfile = false; + private bool _adjustedForScollBarsLocalProfile = false; + private bool _adjustedForScollBarsOnlineProfile = false; private string _descriptionText = string.Empty; private IDalamudTextureWrap? _pfpTextureWrap; private string _profileDescription = string.Empty; @@ -63,7 +63,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase Mediator.Subscribe(this, (_) => { _wasOpen = IsOpen; IsOpen = false; }); Mediator.Subscribe(this, (_) => IsOpen = _wasOpen); Mediator.Subscribe(this, (_) => IsOpen = false); - Mediator.Subscribe(this, (msg) => + Mediator.Subscribe(this, (msg) => { if (msg.UserData == null || string.Equals(msg.UserData.UID, _apiController.UID, StringComparison.Ordinal)) { @@ -108,7 +108,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase ImGui.Dummy(new Vector2(3)); - var profile = _lightlessProfileManager.GetLightlessProfile(new UserData(_apiController.UID)); + var profile = _lightlessProfileManager.GetLightlessUserProfile(new UserData(_apiController.UID)); if (ImGui.BeginTabBar("##EditProfileTabs")) { diff --git a/LightlessSync/UI/PopoutProfileUi.cs b/LightlessSync/UI/PopoutProfileUi.cs index 5a6557c..1737214 100644 --- a/LightlessSync/UI/PopoutProfileUi.cs +++ b/LightlessSync/UI/PopoutProfileUi.cs @@ -85,7 +85,7 @@ public class PopoutProfileUi : WindowMediatorSubscriberBase { var spacing = ImGui.GetStyle().ItemSpacing; - var lightlessProfile = _lightlessProfileManager.GetLightlessProfile(_pair.UserData); + var lightlessProfile = _lightlessProfileManager.GetLightlessUserProfile(_pair.UserData); if (_textureWrap == null || !lightlessProfile.ImageData.Value.SequenceEqual(_lastProfilePicture)) { diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index 84e4e94..bb851ed 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -1599,7 +1599,7 @@ public class SettingsUi : WindowMediatorSubscriberBase { if (ImGui.Checkbox("Show Lightless Profiles on Hover", ref showProfiles)) { - Mediator.Publish(new ClearProfileDataMessage()); + Mediator.Publish(new ClearProfileUserDataMessage()); _configService.Current.ProfilesShow = showProfiles; _configService.Save(); } @@ -1623,7 +1623,7 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.Unindent(); if (ImGui.Checkbox("Show profiles marked as NSFW", ref showNsfwProfiles)) { - Mediator.Publish(new ClearProfileDataMessage()); + Mediator.Publish(new ClearProfileUserDataMessage()); _configService.Current.ProfilesAllowNsfw = showNsfwProfiles; _configService.Save(); } diff --git a/LightlessSync/UI/StandaloneProfileUi.cs b/LightlessSync/UI/StandaloneProfileUi.cs index ca7d779..6ef21d5 100644 --- a/LightlessSync/UI/StandaloneProfileUi.cs +++ b/LightlessSync/UI/StandaloneProfileUi.cs @@ -51,7 +51,7 @@ public class StandaloneProfileUi : WindowMediatorSubscriberBase { var spacing = ImGui.GetStyle().ItemSpacing; - var lightlessProfile = _lightlessProfileManager.GetLightlessProfile(Pair.UserData); + var lightlessProfile = _lightlessProfileManager.GetLightlessUserProfile(Pair.UserData); if (_textureWrap == null || !lightlessProfile.ImageData.Value.SequenceEqual(_lastProfilePicture)) { diff --git a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs index 263c87a..6f71ee9 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs @@ -192,7 +192,7 @@ public partial class ApiController public Task Client_UserUpdateProfile(UserDto dto) { Logger.LogDebug("Client_UserUpdateProfile: {dto}", dto); - ExecuteSafely(() => Mediator.Publish(new ClearProfileDataMessage(dto.User))); + ExecuteSafely(() => Mediator.Publish(new ClearProfileUserDataMessage(dto.User))); return Task.CompletedTask; } @@ -377,6 +377,12 @@ public partial class ApiController _lightlessHub!.On(nameof(Client_UserUpdateProfile), act); } + public void ClientGroupSendProfile(Action act) + { + if (_initialized) return; + _lightlessHub!.On(nameof(Client_GroupSendProfile), act); + } + public void OnUserUpdateSelfPairPermissions(Action act) { if (_initialized) return; diff --git a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs index c7581d1..79de11e 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs @@ -115,6 +115,17 @@ public partial class ApiController CheckConnection(); return await _lightlessHub!.InvokeAsync(nameof(GroupPrune), group, days, execute).ConfigureAwait(false); } + public async Task GroupGetProfile(GroupDto dto) + { + if (!IsConnected) return new GroupProfileDto(Group: dto.Group, Description: null, Tags: null, PictureBase64: null); + return await _lightlessHub!.InvokeAsync(nameof(GroupGetProfile), dto).ConfigureAwait(false); + } + + public async Task GroupSetProfile(GroupProfileDto dto) + { + if (!IsConnected) return; + await _lightlessHub!.InvokeAsync(nameof(GroupSetProfile), dto).ConfigureAwait(false); + } public async Task> GroupsGetAll() { diff --git a/LightlessSync/WebAPI/SignalR/ApiController.cs b/LightlessSync/WebAPI/SignalR/ApiController.cs index 90be67f..d9b8001 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.cs @@ -610,15 +610,5 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL { throw new NotImplementedException(); } - - public Task GroupGetProfile(GroupDto dto) - { - throw new NotImplementedException(); - } - - public Task GroupSetProfile(GroupProfileDto dto) - { - throw new NotImplementedException(); - } } #pragma warning restore MA0040 \ No newline at end of file From a8a01b303473cb6539ade7e3213c15fea02babda Mon Sep 17 00:00:00 2001 From: choco Date: Sun, 12 Oct 2025 18:00:49 +0200 Subject: [PATCH 02/64] added more customization to the notifs, settings improvemnts, left and right notifs, animations for sliding in and out --- .../Configurations/LightlessConfig.cs | 2 + .../Models/NotificationLocation.cs | 6 + LightlessSync/Services/Mediator/Messages.cs | 3 +- LightlessSync/UI/LightlessNotificationUI.cs | 153 ++++++-- LightlessSync/UI/SettingsUi.cs | 332 +++++++++++------- 5 files changed, 335 insertions(+), 161 deletions(-) diff --git a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs index 4d82529..bee94fd 100644 --- a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs +++ b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs @@ -95,6 +95,7 @@ public class LightlessConfig : ILightlessConfiguration public bool ShowNotificationTimestamp { get; set; } = false; // Position & Layout + public NotificationCorner NotificationCorner { get; set; } = NotificationCorner.Right; public int NotificationOffsetY { get; set; } = 50; public int NotificationOffsetX { get; set; } = 0; public float NotificationWidth { get; set; } = 350f; @@ -102,6 +103,7 @@ public class LightlessConfig : ILightlessConfiguration // Animation & Effects public float NotificationAnimationSpeed { get; set; } = 10f; + public float NotificationSlideSpeed { get; set; } = 10f; public float NotificationAccentBarWidth { get; set; } = 3f; // Duration per Type diff --git a/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs b/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs index 2815986..73637ee 100644 --- a/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs +++ b/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs @@ -18,4 +18,10 @@ public enum NotificationType Error, PairRequest, Download +} + +public enum NotificationCorner +{ + Right, + Left } \ No newline at end of file diff --git a/LightlessSync/Services/Mediator/Messages.cs b/LightlessSync/Services/Mediator/Messages.cs index 1524dbd..3396027 100644 --- a/LightlessSync/Services/Mediator/Messages.cs +++ b/LightlessSync/Services/Mediator/Messages.cs @@ -48,7 +48,6 @@ public record PetNamesMessage(string PetNicknamesData) : MessageBase; public record HonorificReadyMessage : MessageBase; public record TransientResourceChangedMessage(IntPtr Address) : MessageBase; public record HaltScanMessage(string Source) : MessageBase; -public record ResumeScanMessage(string Source) : MessageBase; public record NotificationMessage (string Title, string Message, NotificationType Type, TimeSpan? TimeShownOnScreen = null) : MessageBase; public record CreateCacheForObjectMessage(GameObjectHandler ObjectToCreateFor) : SameThreadMessage; @@ -56,12 +55,14 @@ public record ClearCacheForObjectMessage(GameObjectHandler ObjectToCreateFor) : public record CharacterDataCreatedMessage(CharacterData CharacterData) : SameThreadMessage; public record LightlessNotificationMessage(LightlessSync.UI.Models.LightlessNotification Notification) : MessageBase; public record LightlessNotificationDismissMessage(string NotificationId) : MessageBase; +public record ClearAllNotificationsMessage : MessageBase; public record CharacterDataAnalyzedMessage : MessageBase; public record PenumbraStartRedrawMessage(IntPtr Address) : MessageBase; public record PenumbraEndRedrawMessage(IntPtr Address) : MessageBase; public record HubReconnectingMessage(Exception? Exception) : SameThreadMessage; public record HubReconnectedMessage(string? Arg) : SameThreadMessage; public record HubClosedMessage(Exception? Exception) : SameThreadMessage; +public record ResumeScanMessage(string Source) : MessageBase; public record DownloadReadyMessage(Guid RequestId) : MessageBase; public record DownloadStartedMessage(GameObjectHandler DownloadId, Dictionary DownloadStatus) : MessageBase; public record DownloadFinishedMessage(GameObjectHandler DownloadId) : MessageBase; diff --git a/LightlessSync/UI/LightlessNotificationUI.cs b/LightlessSync/UI/LightlessNotificationUI.cs index c0d5b01..36fa508 100644 --- a/LightlessSync/UI/LightlessNotificationUI.cs +++ b/LightlessSync/UI/LightlessNotificationUI.cs @@ -26,6 +26,8 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private readonly List _notifications = new(); private readonly object _notificationLock = new(); private readonly LightlessConfigService _configService; + private readonly Dictionary _notificationYOffsets = new(); + private readonly Dictionary _notificationTargetYOffsets = new(); public LightlessNotificationUI(ILogger logger, LightlessMediator mediator, PerformanceCollectorService performanceCollector, LightlessConfigService configService) : base(logger, mediator, "Lightless Notifications##LightlessNotifications", performanceCollector) @@ -49,12 +51,11 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase Mediator.Subscribe(this, HandleNotificationMessage); Mediator.Subscribe(this, HandleNotificationDismissMessage); + Mediator.Subscribe(this, HandleClearAllNotifications); } - private void HandleNotificationMessage(LightlessNotificationMessage message) => - AddNotification(message.Notification); - - private void HandleNotificationDismissMessage(LightlessNotificationDismissMessage message) => - RemoveNotification(message.NotificationId); + private void HandleNotificationMessage(LightlessNotificationMessage message) => AddNotification(message.Notification); + private void HandleNotificationDismissMessage(LightlessNotificationDismissMessage message) => RemoveNotification(message.NotificationId); + private void HandleClearAllNotifications(ClearAllNotificationsMessage message) => ClearAllNotifications(); public void AddNotification(LightlessNotification notification) { @@ -96,20 +97,34 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase } } + public void ClearAllNotifications() + { + lock (_notificationLock) + { + foreach (var notification in _notifications) + { + StartOutAnimation(notification); + } + } + } + private void StartOutAnimation(LightlessNotification notification) { notification.IsAnimatingOut = true; notification.IsAnimatingIn = false; } + + private bool ShouldRemoveNotification(LightlessNotification notification) => + notification.IsAnimatingOut && notification.AnimationProgress <= 0.01f; protected override void DrawInternal() { ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, Vector2.Zero); - + lock (_notificationLock) { UpdateNotifications(); - + if (_notifications.Count == 0) { ImGui.PopStyleVar(); @@ -118,33 +133,49 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase } var viewport = ImGui.GetMainViewport(); + + // Set window to full viewport height + var width = _configService.Current.NotificationWidth; + Size = new Vector2(width, viewport.WorkSize.Y); + SizeCondition = ImGuiCond.Always; + Position = CalculateWindowPosition(viewport); + PositionCondition = ImGuiCond.Always; + DrawAllNotifications(); } - + ImGui.PopStyleVar(); } private Vector2 CalculateWindowPosition(ImGuiViewportPtr viewport) { - var x = viewport.WorkPos.X + viewport.WorkSize.X - - _configService.Current.NotificationWidth - - _configService.Current.NotificationOffsetX - - WindowPaddingOffset; - var y = viewport.WorkPos.Y + _configService.Current.NotificationOffsetY; - return new Vector2(x, y); + var corner = _configService.Current.NotificationCorner; + var offsetX = _configService.Current.NotificationOffsetX; + var width = _configService.Current.NotificationWidth; + + float posX = corner == NotificationCorner.Left + ? viewport.WorkPos.X + offsetX - WindowPaddingOffset + : viewport.WorkPos.X + viewport.WorkSize.X - width - offsetX - WindowPaddingOffset; + + return new Vector2(posX, viewport.WorkPos.Y); } private void DrawAllNotifications() { + var offsetY = _configService.Current.NotificationOffsetY; + var startY = ImGui.GetCursorPosY() + offsetY; + for (int i = 0; i < _notifications.Count; i++) { - DrawNotification(_notifications[i], i); + var notification = _notifications[i]; - if (i < _notifications.Count - 1) + if (_notificationYOffsets.TryGetValue(notification.Id, out var yOffset)) { - ImGui.Dummy(new Vector2(0, _configService.Current.NotificationSpacing)); + ImGui.SetCursorPosY(startY + yOffset); } + + DrawNotification(notification, i); } } @@ -174,18 +205,65 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private void UpdateAnimationsAndRemoveExpired(float deltaTime) { + UpdateTargetYPositions(); + for (int i = _notifications.Count - 1; i >= 0; i--) { var notification = _notifications[i]; UpdateNotificationAnimation(notification, deltaTime); + UpdateNotificationYOffset(notification, deltaTime); if (ShouldRemoveNotification(notification)) { _notifications.RemoveAt(i); + _notificationYOffsets.Remove(notification.Id); + _notificationTargetYOffsets.Remove(notification.Id); } } } + private void UpdateTargetYPositions() + { + float currentY = 0f; + + for (int i = 0; i < _notifications.Count; i++) + { + var notification = _notifications[i]; + + if (!_notificationTargetYOffsets.ContainsKey(notification.Id)) + { + _notificationTargetYOffsets[notification.Id] = currentY; + _notificationYOffsets[notification.Id] = currentY; + } + else + { + _notificationTargetYOffsets[notification.Id] = currentY; + } + + currentY += CalculateNotificationHeight(notification) + _configService.Current.NotificationSpacing; + } + } + + private void UpdateNotificationYOffset(LightlessNotification notification, float deltaTime) + { + if (!_notificationYOffsets.ContainsKey(notification.Id) || !_notificationTargetYOffsets.ContainsKey(notification.Id)) + return; + + var current = _notificationYOffsets[notification.Id]; + var target = _notificationTargetYOffsets[notification.Id]; + var diff = target - current; + + if (Math.Abs(diff) < 0.5f) + { + _notificationYOffsets[notification.Id] = target; + } + else + { + var speed = _configService.Current.NotificationSlideSpeed; + _notificationYOffsets[notification.Id] = current + (diff * deltaTime * speed); + } + } + private void UpdateNotificationAnimation(LightlessNotification notification, float deltaTime) { if (notification.IsAnimatingIn && notification.AnimationProgress < 1f) @@ -209,20 +287,24 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase } } - private bool ShouldRemoveNotification(LightlessNotification notification) => - notification.IsAnimatingOut && notification.AnimationProgress <= 0.01f; + private Vector2 CalculateSlideOffset(float alpha) + { + var distance = (1f - alpha) * SlideAnimationDistance; + var corner = _configService.Current.NotificationCorner; + return corner == NotificationCorner.Left ? new Vector2(-distance, 0) : new Vector2(distance, 0); + } private void DrawNotification(LightlessNotification notification, int index) { var alpha = notification.AnimationProgress; if (alpha <= 0f) return; - var slideOffset = (1f - alpha) * SlideAnimationDistance; + var slideOffset = CalculateSlideOffset(alpha); var originalCursorPos = ImGui.GetCursorPos(); - ImGui.SetCursorPosX(originalCursorPos.X + slideOffset); + ImGui.SetCursorPos(originalCursorPos + slideOffset); var notificationHeight = CalculateNotificationHeight(notification); - var notificationWidth = _configService.Current.NotificationWidth - slideOffset; + var notificationWidth = _configService.Current.NotificationWidth - Math.Abs(slideOffset.X); ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, Vector2.Zero); @@ -308,15 +390,28 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private void DrawAccentBar(ImDrawListPtr drawList, Vector2 windowPos, Vector2 windowSize, Vector4 accentColor) { var accentWidth = _configService.Current.NotificationAccentBarWidth; - if (accentWidth > 0f) + if (accentWidth <= 0f) return; + + var corner = _configService.Current.NotificationCorner; + Vector2 accentStart, accentEnd; + + if (corner == NotificationCorner.Left) { - drawList.AddRectFilled( - windowPos, - windowPos + new Vector2(accentWidth, windowSize.Y), - ImGui.ColorConvertFloat4ToU32(accentColor), - 3f - ); + accentStart = windowPos + new Vector2(windowSize.X - accentWidth, 0); + accentEnd = windowPos + windowSize; } + else + { + accentStart = windowPos; + accentEnd = windowPos + new Vector2(accentWidth, windowSize.Y); + } + + drawList.AddRectFilled( + accentStart, + accentEnd, + ImGui.ColorConvertFloat4ToU32(accentColor), + 3f + ); } private void DrawDurationProgressBar(LightlessNotification notification, float alpha, Vector2 windowPos, Vector2 windowSize, ImDrawListPtr drawList) diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index 6c2fd6e..4f57f2e 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -3493,69 +3493,162 @@ public class SettingsUi : WindowMediatorSubscriberBase if (useLightlessNotifications) { // Lightless notification locations - ImGui.Indent(); - var lightlessLocations = GetLightlessNotificationLocations(); - - ImGui.AlignTextToFramePadding(); - ImGui.TextUnformatted("Info Notifications:"); - ImGui.SameLine(); - ImGui.SetNextItemWidth(200 * ImGuiHelpers.GlobalScale); - _uiShared.DrawCombo("###enhanced_info", lightlessLocations, GetNotificationLocationLabel, (location) => - { - _configService.Current.LightlessInfoNotification = location; - _configService.Save(); - }, _configService.Current.LightlessInfoNotification); - - ImGui.AlignTextToFramePadding(); - ImGui.TextUnformatted("Warning Notifications:"); - ImGui.SameLine(); - ImGui.SetNextItemWidth(200 * ImGuiHelpers.GlobalScale); - _uiShared.DrawCombo("###enhanced_warning", lightlessLocations, GetNotificationLocationLabel, - (location) => - { - _configService.Current.LightlessWarningNotification = location; - _configService.Save(); - }, _configService.Current.LightlessWarningNotification); - - ImGui.AlignTextToFramePadding(); - ImGui.TextUnformatted("Error Notifications:"); - ImGui.SameLine(); - ImGui.SetNextItemWidth(200 * ImGuiHelpers.GlobalScale); - _uiShared.DrawCombo("###enhanced_error", lightlessLocations, GetNotificationLocationLabel, (location) => - { - _configService.Current.LightlessErrorNotification = location; - _configService.Save(); - }, _configService.Current.LightlessErrorNotification); - - ImGuiHelpers.ScaledDummy(3); - _uiShared.DrawHelpText("Special notification types:"); - - ImGui.AlignTextToFramePadding(); - ImGui.TextUnformatted("Pair Request Notifications:"); - ImGui.SameLine(); - ImGui.SetNextItemWidth(200 * ImGuiHelpers.GlobalScale); - _uiShared.DrawCombo("###enhanced_pairrequest", lightlessLocations, GetNotificationLocationLabel, - (location) => - { - _configService.Current.LightlessPairRequestNotification = location; - _configService.Save(); - }, _configService.Current.LightlessPairRequestNotification); - - ImGui.AlignTextToFramePadding(); - ImGui.TextUnformatted("Download Progress Notifications:"); - ImGui.SameLine(); - ImGui.SetNextItemWidth(200 * ImGuiHelpers.GlobalScale); var downloadLocations = GetDownloadNotificationLocations(); - _uiShared.DrawCombo("###enhanced_download", downloadLocations, GetNotificationLocationLabel, - (location) => + + if (ImGui.BeginTable("##NotificationLocationTable", 3, ImGuiTableFlags.Borders | ImGuiTableFlags.RowBg | ImGuiTableFlags.SizingFixedFit)) + { + ImGui.TableSetupColumn("Notification Type", ImGuiTableColumnFlags.WidthFixed, 200f * ImGuiHelpers.GlobalScale); + ImGui.TableSetupColumn("Location", ImGuiTableColumnFlags.WidthStretch); + ImGui.TableSetupColumn("Actions", ImGuiTableColumnFlags.WidthFixed, 40f * ImGuiHelpers.GlobalScale); + ImGui.TableHeadersRow(); + + ImGui.TableNextRow(); + ImGui.TableSetColumnIndex(0); + ImGui.AlignTextToFramePadding(); + ImGui.TextUnformatted("Info Notifications"); + ImGui.TableSetColumnIndex(1); + ImGui.SetNextItemWidth(-1); + _uiShared.DrawCombo("###enhanced_info", lightlessLocations, GetNotificationLocationLabel, (location) => { - _configService.Current.LightlessDownloadNotification = location; + _configService.Current.LightlessInfoNotification = location; _configService.Save(); - }, _configService.Current.LightlessDownloadNotification); + }, _configService.Current.LightlessInfoNotification); + ImGui.TableSetColumnIndex(2); + var availableWidth = ImGui.GetContentRegionAvail().X; + using (ImRaii.PushFont(UiBuilder.IconFont)) + { + if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_info", new Vector2(availableWidth, 0))) + { + Mediator.Publish(new NotificationMessage("Test Info", + "This is a test info notification to let you know Chocola is cute :3", NotificationType.Info)); + } + } + UiSharedService.AttachToolTip("Test info notification"); + ImGui.TableNextRow(); + ImGui.TableSetColumnIndex(0); + ImGui.AlignTextToFramePadding(); + ImGui.TextUnformatted("Warning Notifications"); + ImGui.TableSetColumnIndex(1); + ImGui.SetNextItemWidth(-1); + _uiShared.DrawCombo("###enhanced_warning", lightlessLocations, GetNotificationLocationLabel, + (location) => + { + _configService.Current.LightlessWarningNotification = location; + _configService.Save(); + }, _configService.Current.LightlessWarningNotification); + ImGui.TableSetColumnIndex(2); + availableWidth = ImGui.GetContentRegionAvail().X; + using (ImRaii.PushFont(UiBuilder.IconFont)) + { + if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_warning", new Vector2(availableWidth, 0))) + { + Mediator.Publish(new NotificationMessage("Test Warning", "This is a test warning notification!", + NotificationType.Warning)); + } + } + UiSharedService.AttachToolTip("Test warning notification"); - ImGui.Unindent(); + ImGui.TableNextRow(); + ImGui.TableSetColumnIndex(0); + ImGui.AlignTextToFramePadding(); + ImGui.TextUnformatted("Error Notifications"); + ImGui.TableSetColumnIndex(1); + ImGui.SetNextItemWidth(-1); + _uiShared.DrawCombo("###enhanced_error", lightlessLocations, GetNotificationLocationLabel, (location) => + { + _configService.Current.LightlessErrorNotification = location; + _configService.Save(); + }, _configService.Current.LightlessErrorNotification); + ImGui.TableSetColumnIndex(2); + availableWidth = ImGui.GetContentRegionAvail().X; + using (ImRaii.PushFont(UiBuilder.IconFont)) + { + if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_error", new Vector2(availableWidth, 0))) + { + Mediator.Publish(new NotificationMessage("Test Error", "This is a test error notification!", + NotificationType.Error)); + } + } + UiSharedService.AttachToolTip("Test error notification"); + + ImGui.TableNextRow(); + ImGui.TableSetColumnIndex(0); + ImGui.AlignTextToFramePadding(); + ImGui.TextUnformatted("Pair Request Notifications"); + ImGui.TableSetColumnIndex(1); + ImGui.SetNextItemWidth(-1); + _uiShared.DrawCombo("###enhanced_pairrequest", lightlessLocations, GetNotificationLocationLabel, + (location) => + { + _configService.Current.LightlessPairRequestNotification = location; + _configService.Save(); + }, _configService.Current.LightlessPairRequestNotification); + ImGui.TableSetColumnIndex(2); + availableWidth = ImGui.GetContentRegionAvail().X; + using (ImRaii.PushFont(UiBuilder.IconFont)) + { + if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_pair", new Vector2(availableWidth, 0))) + { + _lightlessNotificationService.ShowPairRequestNotification( + "Test User", + "test-uid-123", + () => + { + Mediator.Publish(new NotificationMessage("Accepted", "You accepted the test pair request.", + NotificationType.Info)); + }, + () => + { + Mediator.Publish(new NotificationMessage("Declined", "You declined the test pair request.", + NotificationType.Info)); + } + ); + } + } + UiSharedService.AttachToolTip("Test pair request notification"); + + ImGui.TableNextRow(); + ImGui.TableSetColumnIndex(0); + ImGui.AlignTextToFramePadding(); + ImGui.TextUnformatted("Download Progress Notifications"); + ImGui.TableSetColumnIndex(1); + ImGui.SetNextItemWidth(-1); + _uiShared.DrawCombo("###enhanced_download", downloadLocations, GetNotificationLocationLabel, + (location) => + { + _configService.Current.LightlessDownloadNotification = location; + _configService.Save(); + }, _configService.Current.LightlessDownloadNotification); + ImGui.TableSetColumnIndex(2); + availableWidth = ImGui.GetContentRegionAvail().X; + using (ImRaii.PushFont(UiBuilder.IconFont)) + { + if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_download", new Vector2(availableWidth, 0))) + { + _lightlessNotificationService.ShowPairDownloadNotification( + new List<(string playerName, float progress, string status)> + { + ("Player One", 0.35f, "downloading"), + ("Player Two", 0.75f, "downloading"), + ("Player Three", 1.0f, "downloading") + }, + queueWaiting: 2 + ); + } + } + UiSharedService.AttachToolTip("Test download progress notification"); + + ImGui.EndTable(); + } + + ImGuiHelpers.ScaledDummy(5); + if (_uiShared.IconTextButton(FontAwesomeIcon.Trash, "Clear All Notifications")) + { + Mediator.Publish(new ClearAllNotificationsMessage()); + } + _uiShared.DrawHelpText("Dismiss all active notifications immediately."); } else { @@ -3602,73 +3695,6 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.Separator(); if (useLightlessNotifications) { - if (_uiShared.MediumTreeNode("Test Notifications", UIColors.Get("LightlessPurple"))) - { - ImGui.Indent(); - - // Test notification buttons - if (_uiShared.IconTextButton(FontAwesomeIcon.Bell, "Test Info")) - { - Mediator.Publish(new NotificationMessage("Test Info", - "This is a test info notification to let you know Chocola is cute :3", NotificationType.Info)); - } - - ImGui.SameLine(); - if (_uiShared.IconTextButton(FontAwesomeIcon.ExclamationTriangle, "Test Warning")) - { - Mediator.Publish(new NotificationMessage("Test Warning", "This is a test warning notification!", - NotificationType.Warning)); - } - - ImGui.SameLine(); - if (_uiShared.IconTextButton(FontAwesomeIcon.ExclamationCircle, "Test Error")) - { - Mediator.Publish(new NotificationMessage("Test Error", "This is a test error notification!", - NotificationType.Error)); - } - - ImGuiHelpers.ScaledDummy(3); - if (_uiShared.IconTextButton(FontAwesomeIcon.UserPlus, "Test Pair Request")) - { - _lightlessNotificationService.ShowPairRequestNotification( - "Test User", - "test-uid-123", - () => - { - Mediator.Publish(new NotificationMessage("Accepted", "You accepted the test pair request.", - NotificationType.Info)); - }, - () => - { - Mediator.Publish(new NotificationMessage("Declined", "You declined the test pair request.", - NotificationType.Info)); - } - ); - } - - ImGui.SameLine(); - if (_uiShared.IconTextButton(FontAwesomeIcon.Download, "Test Download Progress")) - { - _lightlessNotificationService.ShowPairDownloadNotification( - new List<(string playerName, float progress, string status)> - { - ("Player One", 0.35f, "downloading"), - ("Player Two", 0.75f, "downloading"), - ("Player Three", 1.0f, "downloading") - }, - queueWaiting: 2 - ); - } - - _uiShared.DrawHelpText("Preview how notifications will appear with your current settings."); - - ImGui.Unindent(); - - _uiShared.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); - ImGui.TreePop(); - } - - ImGui.Separator(); if (_uiShared.MediumTreeNode("Basic Settings", UIColors.Get("LightlessPurple"))) { int maxNotifications = _configService.Current.MaxSimultaneousNotifications; @@ -3768,10 +3794,28 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.Spacing(); ImGui.TextUnformatted("Position"); - int offsetY = _configService.Current.NotificationOffsetY; - if (ImGui.SliderInt("Vertical Offset", ref offsetY, 0, 500)) + var currentCorner = _configService.Current.NotificationCorner; + if (ImGui.BeginCombo("Notification Position", GetNotificationCornerLabel(currentCorner))) { - _configService.Current.NotificationOffsetY = Math.Clamp(offsetY, 0, 500); + foreach (NotificationCorner corner in Enum.GetValues(typeof(NotificationCorner))) + { + bool isSelected = currentCorner == corner; + if (ImGui.Selectable(GetNotificationCornerLabel(corner), isSelected)) + { + _configService.Current.NotificationCorner = corner; + _configService.Save(); + } + if (isSelected) + ImGui.SetItemDefaultFocus(); + } + ImGui.EndCombo(); + } + _uiShared.DrawHelpText("Choose which corner of the screen notifications appear in."); + + int offsetY = _configService.Current.NotificationOffsetY; + if (ImGui.SliderInt("Vertical Offset", ref offsetY, 0, 1000)) + { + _configService.Current.NotificationOffsetY = Math.Clamp(offsetY, 0, 1000); _configService.Save(); } if (ImGui.IsItemClicked(ImGuiMouseButton.Right)) @@ -3781,7 +3825,7 @@ public class SettingsUi : WindowMediatorSubscriberBase } if (ImGui.IsItemHovered()) ImGui.SetTooltip("Right click to reset to default (50)."); - _uiShared.DrawHelpText("Move notifications down from the top-right corner."); + _uiShared.DrawHelpText("Distance from the top edge of the screen."); int offsetX = _configService.Current.NotificationOffsetX; if (ImGui.SliderInt("Horizontal Offset", ref offsetX, 0, 500)) @@ -3802,9 +3846,9 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.TextUnformatted("Animation Settings"); float animSpeed = _configService.Current.NotificationAnimationSpeed; - if (ImGui.SliderFloat("Animation Speed", ref animSpeed, 1f, 30f, "%.1f")) + if (ImGui.SliderFloat("Animation Speed", ref animSpeed, 1f, 20f, "%.1f")) { - _configService.Current.NotificationAnimationSpeed = Math.Clamp(animSpeed, 1f, 30f); + _configService.Current.NotificationAnimationSpeed = Math.Clamp(animSpeed, 1f, 20f); _configService.Save(); } if (ImGui.IsItemClicked(ImGuiMouseButton.Right)) @@ -3816,6 +3860,21 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.SetTooltip("Right click to reset to default (10)."); _uiShared.DrawHelpText("How fast notifications slide in/out. Higher = faster."); + float slideSpeed = _configService.Current.NotificationSlideSpeed; + if (ImGui.SliderFloat("Slide Speed", ref slideSpeed, 1f, 20f, "%.1f")) + { + _configService.Current.NotificationSlideSpeed = Math.Clamp(slideSpeed, 1f, 20f); + _configService.Save(); + } + if (ImGui.IsItemClicked(ImGuiMouseButton.Right)) + { + _configService.Current.NotificationSlideSpeed = 10f; + _configService.Save(); + } + if (ImGui.IsItemHovered()) + ImGui.SetTooltip("Right click to reset to default (10)."); + _uiShared.DrawHelpText("How fast notifications slide into position when others disappear. Higher = faster."); + ImGui.Spacing(); ImGui.TextUnformatted("Visual Effects"); @@ -3999,6 +4058,7 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.Separator(); // Location descriptions removed - information is now inline with each setting + } } @@ -4043,6 +4103,16 @@ public class SettingsUi : WindowMediatorSubscriberBase }; } + private string GetNotificationCornerLabel(NotificationCorner corner) + { + return corner switch + { + NotificationCorner.Right => "Right", + NotificationCorner.Left => "Left", + _ => corner.ToString() + }; + } + private void DrawSoundTable() { var soundEffects = new[] @@ -4087,7 +4157,7 @@ public class SettingsUi : WindowMediatorSubscriberBase var currentIndex = Array.FindIndex(soundEffects, s => s.Item1 == currentSoundId); if (currentIndex == -1) currentIndex = 1; - ImGui.SetNextItemWidth(200 * ImGuiHelpers.GlobalScale); + ImGui.SetNextItemWidth(-1); if (ImGui.Combo($"##sound_{typeIndex}", ref currentIndex, soundEffects.Select(s => s.Item2).ToArray(), soundEffects.Length)) { From 02c384603109203924ffb9913cdcdcbddcab74b9 Mon Sep 17 00:00:00 2001 From: choco Date: Sun, 12 Oct 2025 18:02:53 +0200 Subject: [PATCH 03/64] column rename for better UX c: --- LightlessSync/UI/SettingsUi.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index 4f57f2e..87df967 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -3500,7 +3500,7 @@ public class SettingsUi : WindowMediatorSubscriberBase { ImGui.TableSetupColumn("Notification Type", ImGuiTableColumnFlags.WidthFixed, 200f * ImGuiHelpers.GlobalScale); ImGui.TableSetupColumn("Location", ImGuiTableColumnFlags.WidthStretch); - ImGui.TableSetupColumn("Actions", ImGuiTableColumnFlags.WidthFixed, 40f * ImGuiHelpers.GlobalScale); + ImGui.TableSetupColumn("Test", ImGuiTableColumnFlags.WidthFixed, 40f * ImGuiHelpers.GlobalScale); ImGui.TableHeadersRow(); ImGui.TableNextRow(); From 4b4e587a8927533a83cd08787dadb7283ae5c3d5 Mon Sep 17 00:00:00 2001 From: defnotken Date: Sun, 12 Oct 2025 11:07:24 -0500 Subject: [PATCH 04/64] 1.12.3 initial --- LightlessSync/LightlessSync.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessSync/LightlessSync.csproj b/LightlessSync/LightlessSync.csproj index 4bab148..5b31c88 100644 --- a/LightlessSync/LightlessSync.csproj +++ b/LightlessSync/LightlessSync.csproj @@ -3,7 +3,7 @@ - 1.12.2 + 1.12.3 https://github.com/Light-Public-Syncshells/LightlessClient From 0635caab6545be60081155d237457fe4413b1fca Mon Sep 17 00:00:00 2001 From: defnotken Date: Sun, 12 Oct 2025 12:09:06 -0500 Subject: [PATCH 05/64] Safety checks for NullDrawObject --- .../PlayerData/Factories/PlayerDataFactory.cs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/LightlessSync/PlayerData/Factories/PlayerDataFactory.cs b/LightlessSync/PlayerData/Factories/PlayerDataFactory.cs index 6e21ad2..f752051 100644 --- a/LightlessSync/PlayerData/Factories/PlayerDataFactory.cs +++ b/LightlessSync/PlayerData/Factories/PlayerDataFactory.cs @@ -98,7 +98,19 @@ public class PlayerDataFactory private unsafe bool CheckForNullDrawObjectUnsafe(IntPtr playerPointer) { - return ((Character*)playerPointer)->GameObject.DrawObject == null; + if (playerPointer == IntPtr.Zero) + return true; + + var character = (Character*)playerPointer; + + if (character == null) + return true; + + var gameObject = &character->GameObject; + if (gameObject == null) + return true; + + return gameObject->DrawObject == null; } private async Task CreateCharacterData(GameObjectHandler playerRelatedObject, CancellationToken ct) From be847c16b818be0a4d0dd3bb87ccbb59cbf4fd9f Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 12 Oct 2025 20:04:09 +0200 Subject: [PATCH 06/64] Added profile settings for Syncshells. --- LightlessSync/Services/UiFactory.cs | 9 +- LightlessSync/UI/EditProfileUi.cs | 4 +- LightlessSync/UI/SyncshellAdminUI.cs | 177 ++++++++++++++++++++++++++- 3 files changed, 182 insertions(+), 8 deletions(-) diff --git a/LightlessSync/Services/UiFactory.cs b/LightlessSync/Services/UiFactory.cs index b8ce902..248eae0 100644 --- a/LightlessSync/Services/UiFactory.cs +++ b/LightlessSync/Services/UiFactory.cs @@ -1,4 +1,5 @@ -using LightlessSync.API.Dto.Group; +using Dalamud.Interface.ImGuiFileDialog; +using LightlessSync.API.Dto.Group; using LightlessSync.PlayerData.Pairs; using LightlessSync.Services.Mediator; using LightlessSync.Services.ServerConfiguration; @@ -18,10 +19,11 @@ public class UiFactory private readonly ServerConfigurationManager _serverConfigManager; private readonly LightlessProfileManager _lightlessProfileManager; private readonly PerformanceCollectorService _performanceCollectorService; + private readonly FileDialogManager _fileDialogManager; public UiFactory(ILoggerFactory loggerFactory, LightlessMediator lightlessMediator, ApiController apiController, UiSharedService uiSharedService, PairManager pairManager, ServerConfigurationManager serverConfigManager, - LightlessProfileManager lightlessProfileManager, PerformanceCollectorService performanceCollectorService) + LightlessProfileManager lightlessProfileManager, PerformanceCollectorService performanceCollectorService, FileDialogManager fileDialogManager) { _loggerFactory = loggerFactory; _lightlessMediator = lightlessMediator; @@ -31,12 +33,13 @@ public class UiFactory _serverConfigManager = serverConfigManager; _lightlessProfileManager = lightlessProfileManager; _performanceCollectorService = performanceCollectorService; + _fileDialogManager = fileDialogManager; } public SyncshellAdminUI CreateSyncshellAdminUi(GroupFullInfoDto dto) { return new SyncshellAdminUI(_loggerFactory.CreateLogger(), _lightlessMediator, - _apiController, _uiSharedService, _pairManager, dto, _performanceCollectorService, _lightlessProfileManager); + _apiController, _uiSharedService, _pairManager, dto, _performanceCollectorService, _lightlessProfileManager, _fileDialogManager); } public StandaloneProfileUi CreateStandaloneProfileUi(Pair pair) diff --git a/LightlessSync/UI/EditProfileUi.cs b/LightlessSync/UI/EditProfileUi.cs index d9db33b..8c84571 100644 --- a/LightlessSync/UI/EditProfileUi.cs +++ b/LightlessSync/UI/EditProfileUi.cs @@ -25,8 +25,8 @@ public class EditProfileUi : WindowMediatorSubscriberBase private readonly FileDialogManager _fileDialogManager; private readonly LightlessProfileManager _lightlessProfileManager; private readonly UiSharedService _uiSharedService; - private bool _adjustedForScollBarsLocalProfile = false; - private bool _adjustedForScollBarsOnlineProfile = false; + private bool _adjustedForScollBarsLocalProfile = false; + private bool _adjustedForScollBarsOnlineProfile = false; private string _descriptionText = string.Empty; private IDalamudTextureWrap? _pfpTextureWrap; private string _profileDescription = string.Empty; diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index fb30067..2904d3d 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -1,17 +1,24 @@ using Dalamud.Bindings.ImGui; using Dalamud.Interface; using Dalamud.Interface.Colors; +using Dalamud.Interface.ImGuiFileDialog; +using Dalamud.Interface.Textures.TextureWraps; using Dalamud.Interface.Utility; using Dalamud.Interface.Utility.Raii; +using LightlessSync.API.Data; using LightlessSync.API.Data.Enum; using LightlessSync.API.Data.Extensions; using LightlessSync.API.Dto.Group; +using LightlessSync.API.Dto.User; using LightlessSync.PlayerData.Pairs; using LightlessSync.Services; using LightlessSync.Services.Mediator; using LightlessSync.WebAPI; using Microsoft.Extensions.Logging; +using SixLabors.ImageSharp; +using SixLabors.ImageSharp.PixelFormats; using System.Globalization; +using System.Numerics; namespace LightlessSync.UI; @@ -22,8 +29,17 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private readonly bool _isOwner = false; private readonly List _oneTimeInvites = []; private readonly PairManager _pairManager; + private readonly LightlessProfileManager _lightlessProfileManager; + private readonly FileDialogManager _fileDialogManager; private readonly UiSharedService _uiSharedService; private List _bannedUsers = []; + private bool _adjustedForScollBarsLocalProfile = false; + private bool _adjustedForScollBarsOnlineProfile = false; + private string _descriptionText = string.Empty; + private IDalamudTextureWrap? _pfpTextureWrap; + private string _profileDescription = string.Empty; + private byte[] _profileImage = []; + private bool _showFileDialogError = false; private int _multiInvites; private string _newPassword; private bool _pwChangeSuccess; @@ -32,13 +48,16 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private int _pruneDays = 14; public SyncshellAdminUI(ILogger logger, LightlessMediator mediator, ApiController apiController, - UiSharedService uiSharedService, PairManager pairManager, GroupFullInfoDto groupFullInfo, PerformanceCollectorService performanceCollectorService) + UiSharedService uiSharedService, PairManager pairManager, GroupFullInfoDto groupFullInfo, PerformanceCollectorService performanceCollectorService, LightlessProfileManager lightlessProfileManager, FileDialogManager fileDialogManager) : base(logger, mediator, "Syncshell Admin Panel (" + groupFullInfo.GroupAliasOrGID + ")", performanceCollectorService) { GroupFullInfo = groupFullInfo; _apiController = apiController; _uiSharedService = uiSharedService; _pairManager = pairManager; + _lightlessProfileManager = lightlessProfileManager; + _fileDialogManager = fileDialogManager; + _isOwner = string.Equals(GroupFullInfo.OwnerUID, _apiController.UID, StringComparison.Ordinal); _isModerator = GroupFullInfo.GroupUserInfo.IsModerator(); _newPassword = string.Empty; @@ -76,7 +95,9 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase DrawManagement(); - DrawPermission(perm); + DrawPermission(perm); + + DrawProfile(); } } @@ -176,6 +197,157 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase ownerTab.Dispose(); } } + private void DrawProfile() + { + var profile = _lightlessProfileManager.GetLightlessGroupProfile(new GroupData(GroupFullInfo.Group.GID)); + var profileTab = ImRaii.TabItem("Profile"); + + if (profileTab) + { + _uiSharedService.MediumText("Current Profile (as saved on server)", UIColors.Get("LightlessPurple")); + ImGui.Dummy(new Vector2(5)); + + if (!_profileImage.SequenceEqual(profile.ImageData.Value)) + { + _profileImage = profile.ImageData.Value; + _pfpTextureWrap?.Dispose(); + _pfpTextureWrap = _uiSharedService.LoadImage(_profileImage); + } + + if (!string.Equals(_profileDescription, profile.Description, StringComparison.OrdinalIgnoreCase)) + { + _profileDescription = profile.Description; + _descriptionText = _profileDescription; + } + + if (_pfpTextureWrap != null) + { + ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height)); + } + + var spacing = ImGui.GetStyle().ItemSpacing.X; + ImGuiHelpers.ScaledRelativeSameLine(256, spacing); + using (_uiSharedService.GameFont.Push()) + { + var descriptionTextSize = ImGui.CalcTextSize(profile.Description, wrapWidth: 256f); + var childFrame = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 256); + if (descriptionTextSize.Y > childFrame.Y) + { + _adjustedForScollBarsOnlineProfile = true; + } + else + { + _adjustedForScollBarsOnlineProfile = false; + } + childFrame = childFrame with + { + X = childFrame.X + (_adjustedForScollBarsOnlineProfile ? ImGui.GetStyle().ScrollbarSize : 0), + }; + if (ImGui.BeginChildFrame(101, childFrame)) + { + UiSharedService.TextWrapped(profile.Description); + } + ImGui.EndChildFrame(); + } + _uiSharedService.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); + ImGui.EndTabItem(); + } + + if (ImGui.BeginTabItem("Profile Settings")) + { + _uiSharedService.MediumText("Profile Settings", UIColors.Get("LightlessPurple")); + ImGui.Dummy(new Vector2(5)); + + if (_uiSharedService.IconTextButton(FontAwesomeIcon.FileUpload, "Upload new profile picture")) + { + _fileDialogManager.OpenFileDialog("Select new Profile picture", ".png", (success, file) => + { + if (!success) return; + _ = Task.Run(async () => + { + var fileContent = File.ReadAllBytes(file); + using MemoryStream ms = new(fileContent); + var format = await Image.DetectFormatAsync(ms).ConfigureAwait(false); + if (!format.FileExtensions.Contains("png", StringComparer.OrdinalIgnoreCase)) + { + _showFileDialogError = true; + return; + } + using var image = Image.Load(fileContent); + + if (image.Width > 256 || image.Height > 256 || (fileContent.Length > 250 * 1024)) + { + _showFileDialogError = true; + return; + } + + _showFileDialogError = false; + await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) + .ConfigureAwait(false); + }); + }); + } + UiSharedService.AttachToolTip("Select and upload a new profile picture"); + ImGui.SameLine(); + if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) + { + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); + } + UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); + if (_showFileDialogError) + { + UiSharedService.ColorTextWrapped("The profile picture must be a PNG file with a maximum height and width of 256px and 250KiB size", ImGuiColors.DalamudRed); + } + + _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); + var widthTextBox = 400; + var posX = ImGui.GetCursorPosX(); + ImGui.TextUnformatted($"Description {_descriptionText.Length}/1500"); + ImGui.SetCursorPosX(posX); + ImGuiHelpers.ScaledRelativeSameLine(widthTextBox, ImGui.GetStyle().ItemSpacing.X); + ImGui.TextUnformatted("Preview (approximate)"); + using (_uiSharedService.GameFont.Push()) + ImGui.InputTextMultiline("##description", ref _descriptionText, 1500, ImGuiHelpers.ScaledVector2(widthTextBox, 200)); + + ImGui.SameLine(); + + using (_uiSharedService.GameFont.Push()) + { + var descriptionTextSizeLocal = ImGui.CalcTextSize(_descriptionText, wrapWidth: 256f); + var childFrameLocal = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 200); + if (descriptionTextSizeLocal.Y > childFrameLocal.Y) + { + _adjustedForScollBarsLocalProfile = true; + } + else + { + _adjustedForScollBarsLocalProfile = false; + } + childFrameLocal = childFrameLocal with + { + X = childFrameLocal.X + (_adjustedForScollBarsLocalProfile ? ImGui.GetStyle().ScrollbarSize : 0), + }; + if (ImGui.BeginChildFrame(102, childFrameLocal)) + { + UiSharedService.TextWrapped(_descriptionText); + } + ImGui.EndChildFrame(); + } + + if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) + { + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: _descriptionText, Tags: null, PictureBase64: null)); + } + UiSharedService.AttachToolTip("Sets your profile description text"); + ImGui.SameLine(); + if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) + { + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); + } + UiSharedService.AttachToolTip("Clears your profile description text"); + } + profileTab.Dispose(); + } private void DrawManagement() { @@ -474,7 +646,6 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase ImGui.Separator(); } mgmtTab.Dispose(); - } private void DrawInvites(GroupPermissions perm) From 6c0d00dc390667621263154a267f8e02c210338c Mon Sep 17 00:00:00 2001 From: choco Date: Sun, 12 Oct 2025 21:07:32 +0200 Subject: [PATCH 07/64] update intervall prevent spam better performance --- LightlessSync/UI/DownloadUi.cs | 68 ++++++++++++++++++++++++++-------- 1 file changed, 52 insertions(+), 16 deletions(-) diff --git a/LightlessSync/UI/DownloadUi.cs b/LightlessSync/UI/DownloadUi.cs index 301f177..a520f0a 100644 --- a/LightlessSync/UI/DownloadUi.cs +++ b/LightlessSync/UI/DownloadUi.cs @@ -24,6 +24,9 @@ public class DownloadUi : WindowMediatorSubscriberBase private readonly ConcurrentDictionary _uploadingPlayers = new(); private readonly NotificationService _notificationService; private bool _notificationDismissed = true; + private int _lastDownloadStateHash = 0; + private DateTime _lastNotificationUpdate = DateTime.MinValue; + private const int MinUpdateIntervalMs = 1000; public DownloadUi(ILogger logger, DalamudUtilService dalamudUtilService, LightlessConfigService configService, PairProcessingLimiter pairProcessingLimiter, FileUploadManager fileTransferManager, LightlessMediator mediator, UiSharedService uiShared, @@ -128,16 +131,18 @@ public class DownloadUi : WindowMediatorSubscriberBase if (useNotifications) { - // Use notification system + // Use notification system - only update when data actually changes if (_currentDownloads.Any()) { - UpdateDownloadNotification(limiterSnapshot); + UpdateDownloadNotificationIfChanged(limiterSnapshot); _notificationDismissed = false; } else if (!_notificationDismissed) { _notificationService.DismissPairDownloadNotification(); _notificationDismissed = true; + _lastDownloadStateHash = 0; + _lastNotificationUpdate = DateTime.MinValue; } } else @@ -298,20 +303,34 @@ public class DownloadUi : WindowMediatorSubscriberBase }; } - private void UpdateDownloadNotification(PairProcessingLimiterSnapshot limiterSnapshot) + private void UpdateDownloadNotificationIfChanged(PairProcessingLimiterSnapshot limiterSnapshot) { - var downloadStatus = new List<(string playerName, float progress, string status)>(); + var downloadStatus = new List<(string playerName, float progress, string status)>(_currentDownloads.Count); + var hashCode = new HashCode(); - foreach (var item in _currentDownloads.ToList()) + foreach (var item in _currentDownloads) { - var dlSlot = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.WaitingForSlot); - var dlQueue = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.WaitingForQueue); - var dlProg = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.Downloading); - var dlDecomp = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.Decompressing); - var totalFiles = item.Value.Sum(c => c.Value.TotalFiles); - var transferredFiles = item.Value.Sum(c => c.Value.TransferredFiles); - var totalBytes = item.Value.Sum(c => c.Value.TotalBytes); - var transferredBytes = item.Value.Sum(c => c.Value.TransferredBytes); + var dlSlot = 0; + var dlQueue = 0; + var dlProg = 0; + var dlDecomp = 0; + long totalBytes = 0; + long transferredBytes = 0; + + // Single pass through the dictionary to count everything - avoid multiple LINQ iterations + foreach (var entry in item.Value) + { + var fileStatus = entry.Value; + switch (fileStatus.DownloadStatus) + { + case DownloadStatus.WaitingForSlot: dlSlot++; break; + case DownloadStatus.WaitingForQueue: dlQueue++; break; + case DownloadStatus.Downloading: dlProg++; break; + case DownloadStatus.Decompressing: dlDecomp++; break; + } + totalBytes += fileStatus.TotalBytes; + transferredBytes += fileStatus.TransferredBytes; + } var progress = totalBytes > 0 ? (float)transferredBytes / totalBytes : 0f; @@ -323,13 +342,30 @@ public class DownloadUi : WindowMediatorSubscriberBase else status = "completed"; downloadStatus.Add((item.Key.Name, progress, status)); + + // Build hash from meaningful state + hashCode.Add(item.Key.Name); + hashCode.Add(transferredBytes); + hashCode.Add(totalBytes); + hashCode.Add(status); } - // Pass queue waiting count separately, show notification if there are downloads or queue items var queueWaiting = limiterSnapshot.IsEnabled ? limiterSnapshot.Waiting : 0; - if (downloadStatus.Any() || queueWaiting > 0) + hashCode.Add(queueWaiting); + + var currentHash = hashCode.ToHashCode(); + var now = DateTime.UtcNow; + var timeSinceLastUpdate = (now - _lastNotificationUpdate).TotalMilliseconds; + + // Only update notification if state has changed AND at least 1 second has passed + if (currentHash != _lastDownloadStateHash && timeSinceLastUpdate >= MinUpdateIntervalMs) { - _notificationService.ShowPairDownloadNotification(downloadStatus, queueWaiting); + _lastDownloadStateHash = currentHash; + _lastNotificationUpdate = now; + if (downloadStatus.Count > 0 || queueWaiting > 0) + { + _notificationService.ShowPairDownloadNotification(downloadStatus, queueWaiting); + } } } From b43ceb9f7eab178f60ab263ee1bfa2e28cbe3c8e Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 12 Oct 2025 22:49:50 +0200 Subject: [PATCH 08/64] Changed syncshell profiles a bit. --- .../Services/LightlessProfileManager.cs | 42 ++- LightlessSync/UI/SyncshellAdminUI.cs | 265 +++++++++--------- 2 files changed, 164 insertions(+), 143 deletions(-) diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index 8da01b4..7bd222c 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -10,22 +10,26 @@ namespace LightlessSync.Services; public class LightlessProfileManager : MediatorSubscriberBase { + //Const strings for default values private const string _lightlessLogo = "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"; private const string _lightlessLogoLoading = "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"; private const string _lightlessLogoNsfw = "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"; private const string _lightlessSupporter = "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"; - private const string _noDescription = "-- User has no description set --"; + private const string _noUserDescription = "-- User has no description set --"; + private const string _noGroupDescription = "-- Group has no description set --"; + private const string _noTags = "-- Syncshell has no tags set --"; private const string _nsfw = "Profile not displayed - NSFW"; private readonly ApiController _apiController; private readonly LightlessConfigService _lightlessConfigService; private readonly ConcurrentDictionary _lightlessUserProfiles = new(UserDataComparer.Instance); private readonly ConcurrentDictionary _lightlessGroupProfiles = new(GroupDataComparer.Instance); - private readonly LightlessUserProfileData _defaultProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noDescription); + private readonly LightlessUserProfileData _defaultProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noUserDescription); private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, "Loading User Profile Data from server..."); private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Group Profile Data from server...", string.Empty); - private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noDescription, string.Empty); - private readonly LightlessUserProfileData _nsfwProfileData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfw); + private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, string.Empty); + private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfw); + public LightlessProfileManager(ILogger logger, LightlessConfigService lightlessConfigService, LightlessMediator mediator, ApiController apiController) : base(logger, mediator) @@ -54,6 +58,7 @@ public class LightlessProfileManager : MediatorSubscriberBase return (profile); } + public LightlessGroupProfileData GetLightlessGroupProfile(GroupData data) { if (!_lightlessGroupProfiles.TryGetValue(data, out var profile)) @@ -65,23 +70,28 @@ public class LightlessProfileManager : MediatorSubscriberBase return (profile); } + /// + /// Fetching the Profile data from the API + /// + /// User you want the profile from + /// New entry in the user profiles to fetch private async Task GetLightlessProfileFromService(UserData data) { try { _lightlessUserProfiles[data] = _loadingProfileUserData; var profile = await _apiController.UserGetProfile(new API.Dto.User.UserDto(data)).ConfigureAwait(false); - LightlessUserProfileData profileData = new(profile.Disabled, profile.IsNSFW ?? false, + LightlessUserProfileData profileUserData = new(profile.Disabled, profile.IsNSFW ?? false, string.IsNullOrEmpty(profile.ProfilePictureBase64) ? _lightlessLogo : profile.ProfilePictureBase64, !string.IsNullOrEmpty(data.Alias) && !string.Equals(data.Alias, data.UID, StringComparison.Ordinal) ? _lightlessSupporter : string.Empty, - string.IsNullOrEmpty(profile.Description) ? _noDescription : profile.Description); - if (profileData.IsNSFW && !_lightlessConfigService.Current.ProfilesAllowNsfw && !string.Equals(_apiController.UID, data.UID, StringComparison.Ordinal)) + string.IsNullOrEmpty(profile.Description) ? _noUserDescription : profile.Description); + if (profileUserData.IsNSFW && !_lightlessConfigService.Current.ProfilesAllowNsfw && !string.Equals(_apiController.UID, data.UID, StringComparison.Ordinal)) { - _lightlessUserProfiles[data] = _nsfwProfileData; + _lightlessUserProfiles[data] = _nsfwProfileUserData; } else { - _lightlessUserProfiles[data] = profileData; + _lightlessUserProfiles[data] = profileUserData; } } catch (Exception ex) @@ -92,18 +102,22 @@ public class LightlessProfileManager : MediatorSubscriberBase } } + /// + /// Fetching the Profile data from the API + /// + /// Group you want the profile from + /// New entry in the group profiles to fetch private async Task GetLightlessProfileFromService(GroupData data) { try { _lightlessGroupProfiles[data] = _loadingProfileGroupData; var profile = await _apiController.GroupGetProfile(new API.Dto.Group.GroupDto(data)).ConfigureAwait(false); - LightlessGroupProfileData profileData = new( - string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, - !string.IsNullOrEmpty(data.Alias) && !string.Equals(data.Alias, data.GID, StringComparison.Ordinal) ? _lightlessSupporter : string.Empty, - string.IsNullOrEmpty(profile.Description) ? _noDescription : profile.Description); - _lightlessGroupProfiles[data] = profileData; + _lightlessGroupProfiles[data] = new LightlessGroupProfileData( + Base64ProfilePicture: string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, + Description: string.IsNullOrEmpty(profile.Description) ? _noGroupDescription : profile.Description, + Tags: string.IsNullOrEmpty(profile.Tags) ? _noTags : profile.Tags); } catch (Exception ex) { diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 2904d3d..afcf872 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -32,6 +32,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private readonly LightlessProfileManager _lightlessProfileManager; private readonly FileDialogManager _fileDialogManager; private readonly UiSharedService _uiSharedService; + private LightlessGroupProfileData _profileData = null; private List _bannedUsers = []; private bool _adjustedForScollBarsLocalProfile = false; private bool _adjustedForScollBarsOnlineProfile = false; @@ -80,7 +81,6 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase GroupFullInfo = _pairManager.Groups[GroupFullInfo.Group]; using var id = ImRaii.PushId("syncshell_admin_" + GroupFullInfo.GID); - using (_uiSharedService.UidFont.Push()) _uiSharedService.UnderlinedBigText(GroupFullInfo.GroupAliasOrGID + " Administrative Panel", UIColors.Get("LightlessBlue")); @@ -199,152 +199,159 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase } private void DrawProfile() { - var profile = _lightlessProfileManager.GetLightlessGroupProfile(new GroupData(GroupFullInfo.Group.GID)); var profileTab = ImRaii.TabItem("Profile"); if (profileTab) { - _uiSharedService.MediumText("Current Profile (as saved on server)", UIColors.Get("LightlessPurple")); - ImGui.Dummy(new Vector2(5)); - - if (!_profileImage.SequenceEqual(profile.ImageData.Value)) + if (_uiSharedService.MediumTreeNode("Current Profile", UIColors.Get("LightlessPurple"))) { - _profileImage = profile.ImageData.Value; - _pfpTextureWrap?.Dispose(); - _pfpTextureWrap = _uiSharedService.LoadImage(_profileImage); - } - - if (!string.Equals(_profileDescription, profile.Description, StringComparison.OrdinalIgnoreCase)) - { - _profileDescription = profile.Description; - _descriptionText = _profileDescription; - } - - if (_pfpTextureWrap != null) - { - ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height)); - } - - var spacing = ImGui.GetStyle().ItemSpacing.X; - ImGuiHelpers.ScaledRelativeSameLine(256, spacing); - using (_uiSharedService.GameFont.Push()) - { - var descriptionTextSize = ImGui.CalcTextSize(profile.Description, wrapWidth: 256f); - var childFrame = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 256); - if (descriptionTextSize.Y > childFrame.Y) + _logger.LogInformation(GroupFullInfo.Group.GID); + _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); + if (_profileData != null) { - _adjustedForScollBarsOnlineProfile = true; - } - else - { - _adjustedForScollBarsOnlineProfile = false; - } - childFrame = childFrame with - { - X = childFrame.X + (_adjustedForScollBarsOnlineProfile ? ImGui.GetStyle().ScrollbarSize : 0), - }; - if (ImGui.BeginChildFrame(101, childFrame)) - { - UiSharedService.TextWrapped(profile.Description); - } - ImGui.EndChildFrame(); - } - _uiSharedService.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); - ImGui.EndTabItem(); - } + ImGui.Dummy(new Vector2(5)); - if (ImGui.BeginTabItem("Profile Settings")) - { - _uiSharedService.MediumText("Profile Settings", UIColors.Get("LightlessPurple")); - ImGui.Dummy(new Vector2(5)); - - if (_uiSharedService.IconTextButton(FontAwesomeIcon.FileUpload, "Upload new profile picture")) - { - _fileDialogManager.OpenFileDialog("Select new Profile picture", ".png", (success, file) => - { - if (!success) return; - _ = Task.Run(async () => + if (!_profileImage.SequenceEqual(_profileData.ImageData.Value)) { - var fileContent = File.ReadAllBytes(file); - using MemoryStream ms = new(fileContent); - var format = await Image.DetectFormatAsync(ms).ConfigureAwait(false); - if (!format.FileExtensions.Contains("png", StringComparer.OrdinalIgnoreCase)) - { - _showFileDialogError = true; - return; - } - using var image = Image.Load(fileContent); + _profileImage = _profileData.ImageData.Value; + _pfpTextureWrap?.Dispose(); + _pfpTextureWrap = _uiSharedService.LoadImage(_profileImage); + } - if (image.Width > 256 || image.Height > 256 || (fileContent.Length > 250 * 1024)) - { - _showFileDialogError = true; - return; - } + if (!string.Equals(_profileDescription, _profileData.Description, StringComparison.OrdinalIgnoreCase)) + { + _profileDescription = _profileData.Description; + _descriptionText = _profileDescription; + } - _showFileDialogError = false; - await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) - .ConfigureAwait(false); + if (_pfpTextureWrap != null) + { + ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height)); + } + + var spacing = ImGui.GetStyle().ItemSpacing.X; + ImGuiHelpers.ScaledRelativeSameLine(256, spacing); + using (_uiSharedService.GameFont.Push()) + { + var descriptionTextSize = ImGui.CalcTextSize(_profileData.Description, wrapWidth: 256f); + var childFrame = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 256); + if (descriptionTextSize.Y > childFrame.Y) + { + _adjustedForScollBarsOnlineProfile = true; + } + else + { + _adjustedForScollBarsOnlineProfile = false; + } + childFrame = childFrame with + { + X = childFrame.X + (_adjustedForScollBarsOnlineProfile ? ImGui.GetStyle().ScrollbarSize : 0), + }; + if (ImGui.BeginChildFrame(101, childFrame)) + { + UiSharedService.TextWrapped(_profileData.Description); + } + ImGui.EndChildFrame(); + ImGui.TreePop(); + } + } + } + + ImGui.Separator(); + + if (_uiSharedService.MediumTreeNode("Profile Settings", UIColors.Get("LightlessPurple"))) + { + ImGui.Dummy(new Vector2(5)); + + if (_uiSharedService.IconTextButton(FontAwesomeIcon.FileUpload, "Upload new profile picture")) + { + _fileDialogManager.OpenFileDialog("Select new Profile picture", ".png", (success, file) => + { + if (!success) return; + _ = Task.Run(async () => + { + var fileContent = File.ReadAllBytes(file); + using MemoryStream ms = new(fileContent); + var format = await Image.DetectFormatAsync(ms).ConfigureAwait(false); + if (!format.FileExtensions.Contains("png", StringComparer.OrdinalIgnoreCase)) + { + _showFileDialogError = true; + return; + } + using var image = Image.Load(fileContent); + + if (image.Width > 256 || image.Height > 256 || (fileContent.Length > 250 * 1024)) + { + _showFileDialogError = true; + return; + } + + _showFileDialogError = false; + await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) + .ConfigureAwait(false); + }); }); - }); - } - UiSharedService.AttachToolTip("Select and upload a new profile picture"); - ImGui.SameLine(); - if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) - { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); - } - UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); - if (_showFileDialogError) - { - UiSharedService.ColorTextWrapped("The profile picture must be a PNG file with a maximum height and width of 256px and 250KiB size", ImGuiColors.DalamudRed); - } - - _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); - var widthTextBox = 400; - var posX = ImGui.GetCursorPosX(); - ImGui.TextUnformatted($"Description {_descriptionText.Length}/1500"); - ImGui.SetCursorPosX(posX); - ImGuiHelpers.ScaledRelativeSameLine(widthTextBox, ImGui.GetStyle().ItemSpacing.X); - ImGui.TextUnformatted("Preview (approximate)"); - using (_uiSharedService.GameFont.Push()) - ImGui.InputTextMultiline("##description", ref _descriptionText, 1500, ImGuiHelpers.ScaledVector2(widthTextBox, 200)); - - ImGui.SameLine(); - - using (_uiSharedService.GameFont.Push()) - { - var descriptionTextSizeLocal = ImGui.CalcTextSize(_descriptionText, wrapWidth: 256f); - var childFrameLocal = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 200); - if (descriptionTextSizeLocal.Y > childFrameLocal.Y) - { - _adjustedForScollBarsLocalProfile = true; } - else + UiSharedService.AttachToolTip("Select and upload a new profile picture"); + ImGui.SameLine(); + if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) { - _adjustedForScollBarsLocalProfile = false; + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); } - childFrameLocal = childFrameLocal with + UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); + if (_showFileDialogError) { - X = childFrameLocal.X + (_adjustedForScollBarsLocalProfile ? ImGui.GetStyle().ScrollbarSize : 0), - }; - if (ImGui.BeginChildFrame(102, childFrameLocal)) - { - UiSharedService.TextWrapped(_descriptionText); + UiSharedService.ColorTextWrapped("The profile picture must be a PNG file with a maximum height and width of 256px and 250KiB size", ImGuiColors.DalamudRed); } - ImGui.EndChildFrame(); - } - if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) - { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: _descriptionText, Tags: null, PictureBase64: null)); + _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); + var widthTextBox = 400; + var posX = ImGui.GetCursorPosX(); + ImGui.TextUnformatted($"Description {_descriptionText.Length}/1500"); + ImGui.SetCursorPosX(posX); + ImGuiHelpers.ScaledRelativeSameLine(widthTextBox, ImGui.GetStyle().ItemSpacing.X); + ImGui.TextUnformatted("Preview (approximate)"); + using (_uiSharedService.GameFont.Push()) + ImGui.InputTextMultiline("##description", ref _descriptionText, 1500, ImGuiHelpers.ScaledVector2(widthTextBox, 200)); + + ImGui.SameLine(); + + using (_uiSharedService.GameFont.Push()) + { + var descriptionTextSizeLocal = ImGui.CalcTextSize(_descriptionText, wrapWidth: 256f); + var childFrameLocal = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 200); + if (descriptionTextSizeLocal.Y > childFrameLocal.Y) + { + _adjustedForScollBarsLocalProfile = true; + } + else + { + _adjustedForScollBarsLocalProfile = false; + } + childFrameLocal = childFrameLocal with + { + X = childFrameLocal.X + (_adjustedForScollBarsLocalProfile ? ImGui.GetStyle().ScrollbarSize : 0), + }; + if (ImGui.BeginChildFrame(102, childFrameLocal)) + { + UiSharedService.TextWrapped(_descriptionText); + } + ImGui.EndChildFrame(); + } + + if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) + { + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: _descriptionText, Tags: null, PictureBase64: null)); + } + UiSharedService.AttachToolTip("Sets your profile description text"); + ImGui.SameLine(); + if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) + { + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); + } + UiSharedService.AttachToolTip("Clears your profile description text"); + ImGui.TreePop(); } - UiSharedService.AttachToolTip("Sets your profile description text"); - ImGui.SameLine(); - if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) - { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); - } - UiSharedService.AttachToolTip("Clears your profile description text"); } profileTab.Dispose(); } From 118edb9deaeb8b2374b0a264af3dc16174a8e2b7 Mon Sep 17 00:00:00 2001 From: choco Date: Sun, 12 Oct 2025 23:11:18 +0200 Subject: [PATCH 09/64] notif overlay flex with 1 sec delay removal --- LightlessSync/UI/DownloadUi.cs | 10 ++-------- LightlessSync/UI/LightlessNotificationUI.cs | 6 +----- 2 files changed, 3 insertions(+), 13 deletions(-) diff --git a/LightlessSync/UI/DownloadUi.cs b/LightlessSync/UI/DownloadUi.cs index a520f0a..93cc623 100644 --- a/LightlessSync/UI/DownloadUi.cs +++ b/LightlessSync/UI/DownloadUi.cs @@ -25,8 +25,6 @@ public class DownloadUi : WindowMediatorSubscriberBase private readonly NotificationService _notificationService; private bool _notificationDismissed = true; private int _lastDownloadStateHash = 0; - private DateTime _lastNotificationUpdate = DateTime.MinValue; - private const int MinUpdateIntervalMs = 1000; public DownloadUi(ILogger logger, DalamudUtilService dalamudUtilService, LightlessConfigService configService, PairProcessingLimiter pairProcessingLimiter, FileUploadManager fileTransferManager, LightlessMediator mediator, UiSharedService uiShared, @@ -142,7 +140,6 @@ public class DownloadUi : WindowMediatorSubscriberBase _notificationService.DismissPairDownloadNotification(); _notificationDismissed = true; _lastDownloadStateHash = 0; - _lastNotificationUpdate = DateTime.MinValue; } } else @@ -354,14 +351,11 @@ public class DownloadUi : WindowMediatorSubscriberBase hashCode.Add(queueWaiting); var currentHash = hashCode.ToHashCode(); - var now = DateTime.UtcNow; - var timeSinceLastUpdate = (now - _lastNotificationUpdate).TotalMilliseconds; - // Only update notification if state has changed AND at least 1 second has passed - if (currentHash != _lastDownloadStateHash && timeSinceLastUpdate >= MinUpdateIntervalMs) + // Only update notification if state has actually changed + if (currentHash != _lastDownloadStateHash) { _lastDownloadStateHash = currentHash; - _lastNotificationUpdate = now; if (downloadStatus.Count > 0 || queueWaiting > 0) { _notificationService.ShowPairDownloadNotification(downloadStatus, queueWaiting); diff --git a/LightlessSync/UI/LightlessNotificationUI.cs b/LightlessSync/UI/LightlessNotificationUI.cs index 36fa508..7ced889 100644 --- a/LightlessSync/UI/LightlessNotificationUI.cs +++ b/LightlessSync/UI/LightlessNotificationUI.cs @@ -134,11 +134,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase var viewport = ImGui.GetMainViewport(); - // Set window to full viewport height - var width = _configService.Current.NotificationWidth; - Size = new Vector2(width, viewport.WorkSize.Y); - SizeCondition = ImGuiCond.Always; - + // Window auto-resizes based on content (AlwaysAutoResize flag) Position = CalculateWindowPosition(viewport); PositionCondition = ImGuiCond.Always; From bcb524df52f9b519943ae95f86e2dc22779a8cfd Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 13 Oct 2025 00:13:21 +0200 Subject: [PATCH 10/64] text auto flexing on dismiss removed --- LightlessSync/UI/LightlessNotificationUI.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessSync/UI/LightlessNotificationUI.cs b/LightlessSync/UI/LightlessNotificationUI.cs index 7ced889..cb62b51 100644 --- a/LightlessSync/UI/LightlessNotificationUI.cs +++ b/LightlessSync/UI/LightlessNotificationUI.cs @@ -300,7 +300,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase ImGui.SetCursorPos(originalCursorPos + slideOffset); var notificationHeight = CalculateNotificationHeight(notification); - var notificationWidth = _configService.Current.NotificationWidth - Math.Abs(slideOffset.X); + var notificationWidth = _configService.Current.NotificationWidth; ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, Vector2.Zero); From c447c33b7ae39671819d2ee426f7b2bd0ea070c5 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Mon, 13 Oct 2025 00:39:30 +0200 Subject: [PATCH 11/64] Fixed callbacks for cleaning up profiles. --- .../Services/LightlessProfileManager.cs | 16 +++++++++++++++- LightlessSync/UI/SyncshellAdminUI.cs | 8 ++++++++ .../SignalR/ApiController.Functions.Callbacks.cs | 7 +++++++ LightlessSync/WebAPI/SignalR/ApiController.cs | 5 ----- 4 files changed, 30 insertions(+), 6 deletions(-) diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index 7bd222c..74d2dea 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -44,7 +44,21 @@ public class LightlessProfileManager : MediatorSubscriberBase else _lightlessUserProfiles.Clear(); }); - Mediator.Subscribe(this, (_) => _lightlessUserProfiles.Clear()); + + Mediator.Subscribe(this, (msg) => + { + if (msg.GroupData != null) + _lightlessGroupProfiles.Remove(msg.GroupData, out _); + else + _lightlessGroupProfiles.Clear(); + }); + + Mediator.Subscribe(this, (_) => + { + _lightlessUserProfiles.Clear(); + _lightlessGroupProfiles.Clear(); + } + ); } public LightlessUserProfileData GetLightlessUserProfile(UserData data) diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index afcf872..cb5ecde 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -65,6 +65,14 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase _multiInvites = 30; _pwChangeSuccess = true; IsOpen = true; + Mediator.Subscribe(this, (msg) => + { + if (msg.GroupData == null || string.Equals(msg.GroupData.GID, GroupFullInfo.Group.GID, StringComparison.Ordinal)) + { + _pfpTextureWrap?.Dispose(); + _pfpTextureWrap = null; + } + }); SizeConstraints = new WindowSizeConstraints() { MinimumSize = new(700, 500), diff --git a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs index e9f3010..da07460 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs @@ -199,6 +199,13 @@ public partial class ApiController return Task.CompletedTask; } + public Task Client_GroupSendProfile(GroupProfileDto groupInfo) + { + Logger.LogDebug("Client_GroupSendProfile: {dto}", groupInfo); + ExecuteSafely(() => Mediator.Publish(new ClearProfileGroupDataMessage(groupInfo.Group))); + return Task.CompletedTask; + } + public Task Client_UserUpdateSelfPairPermissions(UserPermissionsDto dto) { Logger.LogDebug("Client_UserUpdateSelfPairPermissions: {dto}", dto); diff --git a/LightlessSync/WebAPI/SignalR/ApiController.cs b/LightlessSync/WebAPI/SignalR/ApiController.cs index c6680a2..5652194 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.cs @@ -607,10 +607,5 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL ServerState = state; } - - public Task Client_GroupSendProfile(GroupProfileDto groupInfo) - { - throw new NotImplementedException(); - } } #pragma warning restore MA0040 \ No newline at end of file From e80806ef9db7fc26436c27925e98d08d14b7a33b Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Mon, 13 Oct 2025 01:09:05 +0200 Subject: [PATCH 12/64] Changes some calls --- .../Services/LightlessProfileManager.cs | 24 ++-- LightlessSync/UI/SyncshellAdminUI.cs | 117 +++++++++--------- 2 files changed, 75 insertions(+), 66 deletions(-) diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index 74d2dea..e2367b0 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -4,29 +4,31 @@ using LightlessSync.LightlessConfiguration; using LightlessSync.Services.Mediator; using LightlessSync.WebAPI; using Microsoft.Extensions.Logging; +using Serilog.Core; using System.Collections.Concurrent; namespace LightlessSync.Services; public class LightlessProfileManager : MediatorSubscriberBase { - //Const strings for default values + //Const strings for default values meant in the profile screen. private const string _lightlessLogo = "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"; private const string _lightlessLogoLoading = "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"; private const string _lightlessLogoNsfw = "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"; private const string _lightlessSupporter = "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"; private const string _noUserDescription = "-- User has no description set --"; - private const string _noGroupDescription = "-- Group has no description set --"; + private const string _noGroupDescription = "-- Syncshell has no description set --"; private const string _noTags = "-- Syncshell has no tags set --"; private const string _nsfw = "Profile not displayed - NSFW"; private readonly ApiController _apiController; + private readonly ILogger _logger; private readonly LightlessConfigService _lightlessConfigService; private readonly ConcurrentDictionary _lightlessUserProfiles = new(UserDataComparer.Instance); private readonly ConcurrentDictionary _lightlessGroupProfiles = new(GroupDataComparer.Instance); private readonly LightlessUserProfileData _defaultProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noUserDescription); private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, "Loading User Profile Data from server..."); - private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Group Profile Data from server...", string.Empty); + private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Syncshell Profile Data from server...", string.Empty); private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, string.Empty); private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfw); @@ -34,6 +36,7 @@ public class LightlessProfileManager : MediatorSubscriberBase public LightlessProfileManager(ILogger logger, LightlessConfigService lightlessConfigService, LightlessMediator mediator, ApiController apiController) : base(logger, mediator) { + _logger = logger; _lightlessConfigService = lightlessConfigService; _apiController = apiController; @@ -65,6 +68,7 @@ public class LightlessProfileManager : MediatorSubscriberBase { if (!_lightlessUserProfiles.TryGetValue(data, out var profile)) { + _logger.LogInformation($"Getting data from {data.AliasOrUID}"); _ = Task.Run(() => GetLightlessProfileFromService(data)); return (_loadingProfileUserData); } @@ -77,6 +81,7 @@ public class LightlessProfileManager : MediatorSubscriberBase { if (!_lightlessGroupProfiles.TryGetValue(data, out var profile)) { + _logger.LogInformation($"Getting data from {data.GID}"); _ = Task.Run(() => GetLightlessProfileFromService(data)); return (_loadingProfileGroupData); } @@ -85,7 +90,7 @@ public class LightlessProfileManager : MediatorSubscriberBase } /// - /// Fetching the Profile data from the API + /// Fetching the user profile data from the API /// /// User you want the profile from /// New entry in the user profiles to fetch @@ -95,10 +100,12 @@ public class LightlessProfileManager : MediatorSubscriberBase { _lightlessUserProfiles[data] = _loadingProfileUserData; var profile = await _apiController.UserGetProfile(new API.Dto.User.UserDto(data)).ConfigureAwait(false); + LightlessUserProfileData profileUserData = new(profile.Disabled, profile.IsNSFW ?? false, string.IsNullOrEmpty(profile.ProfilePictureBase64) ? _lightlessLogo : profile.ProfilePictureBase64, !string.IsNullOrEmpty(data.Alias) && !string.Equals(data.Alias, data.UID, StringComparison.Ordinal) ? _lightlessSupporter : string.Empty, string.IsNullOrEmpty(profile.Description) ? _noUserDescription : profile.Description); + if (profileUserData.IsNSFW && !_lightlessConfigService.Current.ProfilesAllowNsfw && !string.Equals(_apiController.UID, data.UID, StringComparison.Ordinal)) { _lightlessUserProfiles[data] = _nsfwProfileUserData; @@ -117,7 +124,7 @@ public class LightlessProfileManager : MediatorSubscriberBase } /// - /// Fetching the Profile data from the API + /// Fetching the group profile data from the API /// /// Group you want the profile from /// New entry in the group profiles to fetch @@ -128,15 +135,16 @@ public class LightlessProfileManager : MediatorSubscriberBase _lightlessGroupProfiles[data] = _loadingProfileGroupData; var profile = await _apiController.GroupGetProfile(new API.Dto.Group.GroupDto(data)).ConfigureAwait(false); - _lightlessGroupProfiles[data] = new LightlessGroupProfileData( - Base64ProfilePicture: string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, + LightlessGroupProfileData profileGroupData = new(Base64ProfilePicture: string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, Description: string.IsNullOrEmpty(profile.Description) ? _noGroupDescription : profile.Description, Tags: string.IsNullOrEmpty(profile.Tags) ? _noTags : profile.Tags); + + _lightlessGroupProfiles[data] = profileGroupData; } catch (Exception ex) { // if fails save DefaultProfileData to dict - Logger.LogWarning(ex, "Failed to get Profile from service for group {group}", data); + Logger.LogWarning(ex, "Failed to get Profile from service for syncshell {group}", data); _lightlessGroupProfiles[data] = _defaultProfileGroupData; } } diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index cb5ecde..91d1300 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -47,6 +47,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private Task? _pruneTestTask; private Task? _pruneTask; private int _pruneDays = 14; + private bool renewProfile; public SyncshellAdminUI(ILogger logger, LightlessMediator mediator, ApiController apiController, UiSharedService uiSharedService, PairManager pairManager, GroupFullInfoDto groupFullInfo, PerformanceCollectorService performanceCollectorService, LightlessProfileManager lightlessProfileManager, FileDialogManager fileDialogManager) @@ -87,6 +88,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase if (!_isModerator && !_isOwner) return; GroupFullInfo = _pairManager.Groups[GroupFullInfo.Group]; + _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); using var id = ImRaii.PushId("syncshell_admin_" + GroupFullInfo.GID); using (_uiSharedService.UidFont.Push()) @@ -96,7 +98,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase var perm = GroupFullInfo.GroupPermissions; using var tabbar = ImRaii.TabBar("syncshell_tab_" + GroupFullInfo.GID); - + if (tabbar) { DrawInvites(perm); @@ -213,55 +215,50 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { if (_uiSharedService.MediumTreeNode("Current Profile", UIColors.Get("LightlessPurple"))) { - _logger.LogInformation(GroupFullInfo.Group.GID); - _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); - if (_profileData != null) + ImGui.Dummy(new Vector2(5)); + + if (!_profileImage.SequenceEqual(_profileData.ImageData.Value)) { - ImGui.Dummy(new Vector2(5)); + _profileImage = _profileData.ImageData.Value; + _pfpTextureWrap?.Dispose(); + _pfpTextureWrap = _uiSharedService.LoadImage(_profileImage); + } - if (!_profileImage.SequenceEqual(_profileData.ImageData.Value)) - { - _profileImage = _profileData.ImageData.Value; - _pfpTextureWrap?.Dispose(); - _pfpTextureWrap = _uiSharedService.LoadImage(_profileImage); - } + if (!string.Equals(_profileDescription, _profileData.Description, StringComparison.OrdinalIgnoreCase)) + { + _profileDescription = _profileData.Description; + _descriptionText = _profileDescription; + } - if (!string.Equals(_profileDescription, _profileData.Description, StringComparison.OrdinalIgnoreCase)) - { - _profileDescription = _profileData.Description; - _descriptionText = _profileDescription; - } + if (_pfpTextureWrap != null) + { + ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height)); + } - if (_pfpTextureWrap != null) + var spacing = ImGui.GetStyle().ItemSpacing.X; + ImGuiHelpers.ScaledRelativeSameLine(256, spacing); + using (_uiSharedService.GameFont.Push()) + { + var descriptionTextSize = ImGui.CalcTextSize(_profileData.Description, wrapWidth: 256f); + var childFrame = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 256); + if (descriptionTextSize.Y > childFrame.Y) { - ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height)); + _adjustedForScollBarsOnlineProfile = true; } - - var spacing = ImGui.GetStyle().ItemSpacing.X; - ImGuiHelpers.ScaledRelativeSameLine(256, spacing); - using (_uiSharedService.GameFont.Push()) + else { - var descriptionTextSize = ImGui.CalcTextSize(_profileData.Description, wrapWidth: 256f); - var childFrame = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 256); - if (descriptionTextSize.Y > childFrame.Y) - { - _adjustedForScollBarsOnlineProfile = true; - } - else - { - _adjustedForScollBarsOnlineProfile = false; - } - childFrame = childFrame with - { - X = childFrame.X + (_adjustedForScollBarsOnlineProfile ? ImGui.GetStyle().ScrollbarSize : 0), - }; - if (ImGui.BeginChildFrame(101, childFrame)) - { - UiSharedService.TextWrapped(_profileData.Description); - } - ImGui.EndChildFrame(); - ImGui.TreePop(); + _adjustedForScollBarsOnlineProfile = false; } + childFrame = childFrame with + { + X = childFrame.X + (_adjustedForScollBarsOnlineProfile ? ImGui.GetStyle().ScrollbarSize : 0), + }; + if (ImGui.BeginChildFrame(101, childFrame)) + { + UiSharedService.TextWrapped(_profileData.Description); + } + ImGui.EndChildFrame(); + ImGui.TreePop(); } } @@ -278,25 +275,28 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase if (!success) return; _ = Task.Run(async () => { - var fileContent = File.ReadAllBytes(file); - using MemoryStream ms = new(fileContent); - var format = await Image.DetectFormatAsync(ms).ConfigureAwait(false); - if (!format.FileExtensions.Contains("png", StringComparer.OrdinalIgnoreCase)) + var fileContent = await File.ReadAllBytesAsync(file).ConfigureAwait(false); + MemoryStream ms = new(fileContent); + await using (ms.ConfigureAwait(false)) { - _showFileDialogError = true; - return; - } - using var image = Image.Load(fileContent); + var format = await Image.DetectFormatAsync(ms).ConfigureAwait(false); + if (!format.FileExtensions.Contains("png", StringComparer.OrdinalIgnoreCase)) + { + _showFileDialogError = true; + return; + } + using var image = Image.Load(fileContent); - if (image.Width > 256 || image.Height > 256 || (fileContent.Length > 250 * 1024)) - { - _showFileDialogError = true; - return; - } + if (image.Width > 256 || image.Height > 256 || (fileContent.Length > 250 * 1024)) + { + _showFileDialogError = true; + return; + } - _showFileDialogError = false; - await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) - .ConfigureAwait(false); + _showFileDialogError = false; + await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) + .ConfigureAwait(false); + } }); }); } @@ -711,5 +711,6 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase public override void OnClose() { Mediator.Publish(new RemoveWindowMessage(this)); + _pfpTextureWrap?.Dispose(); } } \ No newline at end of file From a4eb840589d466d6be758770f9770708fa83d241 Mon Sep 17 00:00:00 2001 From: defnotken Date: Sun, 12 Oct 2025 22:59:50 -0500 Subject: [PATCH 13/64] add stuff --- LightlessSync/Services/LightlessProfileManager.cs | 4 +++- LightlessSync/UI/EditProfileUi.cs | 2 ++ LightlessSync/UI/SyncshellAdminUI.cs | 13 ++++++++++--- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index e2367b0..0b7b15b 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -8,9 +8,9 @@ using Serilog.Core; using System.Collections.Concurrent; namespace LightlessSync.Services; - public class LightlessProfileManager : MediatorSubscriberBase { + public LightlessGroupProfileData LoadingProfileGroupData => _loadingProfileGroupData; //Const strings for default values meant in the profile screen. private const string _lightlessLogo = "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"; private const string _lightlessLogoLoading = "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"; @@ -79,6 +79,8 @@ public class LightlessProfileManager : MediatorSubscriberBase public LightlessGroupProfileData GetLightlessGroupProfile(GroupData data) { + _logger.LogInformation("Requesting group profile for {data}", data); + _logger.LogInformation("Dis in cache? {}", _lightlessGroupProfiles.TryGetValue(data, out var test)); if (!_lightlessGroupProfiles.TryGetValue(data, out var profile)) { _logger.LogInformation($"Getting data from {data.GID}"); diff --git a/LightlessSync/UI/EditProfileUi.cs b/LightlessSync/UI/EditProfileUi.cs index 8c84571..a8513f3 100644 --- a/LightlessSync/UI/EditProfileUi.cs +++ b/LightlessSync/UI/EditProfileUi.cs @@ -91,6 +91,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase protected override void DrawInternal() { + _uiSharedService.UnderlinedBigText("Notes and Rules for Profiles", UIColors.Get("LightlessYellow")); ImGui.Dummy(new Vector2(5)); @@ -109,6 +110,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase ImGui.Dummy(new Vector2(3)); var profile = _lightlessProfileManager.GetLightlessUserProfile(new UserData(_apiController.UID)); + _logger.LogInformation("Profile fetched for drawing: {profile}", profile); if (ImGui.BeginTabBar("##EditProfileTabs")) { diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 91d1300..5f70dde 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -32,8 +32,9 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private readonly LightlessProfileManager _lightlessProfileManager; private readonly FileDialogManager _fileDialogManager; private readonly UiSharedService _uiSharedService; - private LightlessGroupProfileData _profileData = null; private List _bannedUsers = []; + private LightlessGroupProfileData? _profileData = null; + private GroupData? _lastProfileGroup = null; private bool _adjustedForScollBarsLocalProfile = false; private bool _adjustedForScollBarsOnlineProfile = false; private string _descriptionText = string.Empty; @@ -86,9 +87,15 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase protected override void DrawInternal() { if (!_isModerator && !_isOwner) return; - + //_logger.LogInformation("Drawing Syncshell Admin UI for {group}", GroupFullInfo.GroupAliasOrGID); GroupFullInfo = _pairManager.Groups[GroupFullInfo.Group]; - _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); + + + if (_lastProfileGroup == null || !_lastProfileGroup.Equals(GroupFullInfo.Group) || _profileData == null || ReferenceEquals(_profileData, _lightlessProfileManager.LoadingProfileGroupData)) + { + _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); + _lastProfileGroup = GroupFullInfo.Group; + } using var id = ImRaii.PushId("syncshell_admin_" + GroupFullInfo.GID); using (_uiSharedService.UidFont.Push()) From 3f2e4d6640a8919289c2a1bf792850e465b3860c Mon Sep 17 00:00:00 2001 From: choco Date: Tue, 14 Oct 2025 09:36:10 +0200 Subject: [PATCH 14/64] small service cleanup --- LightlessSync/UI/DownloadUi.cs | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/LightlessSync/UI/DownloadUi.cs b/LightlessSync/UI/DownloadUi.cs index 93cc623..1b1ec16 100644 --- a/LightlessSync/UI/DownloadUi.cs +++ b/LightlessSync/UI/DownloadUi.cs @@ -66,7 +66,7 @@ public class DownloadUi : WindowMediatorSubscriberBase _currentDownloads.TryRemove(msg.DownloadId, out _); if (!_currentDownloads.Any()) { - _notificationService.DismissPairDownloadNotification(); + Mediator.Publish(new LightlessNotificationDismissMessage("pair_download_progress")); } }); Mediator.Subscribe(this, (_) => IsOpen = false); @@ -117,7 +117,7 @@ public class DownloadUi : WindowMediatorSubscriberBase } catch { - // ignore errors thrown from UI + _logger.LogDebug("Error drawing upload progress"); } try @@ -129,7 +129,7 @@ public class DownloadUi : WindowMediatorSubscriberBase if (useNotifications) { - // Use notification system - only update when data actually changes + // Use notification system if (_currentDownloads.Any()) { UpdateDownloadNotificationIfChanged(limiterSnapshot); @@ -137,13 +137,14 @@ public class DownloadUi : WindowMediatorSubscriberBase } else if (!_notificationDismissed) { - _notificationService.DismissPairDownloadNotification(); + Mediator.Publish(new LightlessNotificationDismissMessage("pair_download_progress")); _notificationDismissed = true; _lastDownloadStateHash = 0; } } else { + // Use text overlay if (limiterSnapshot.IsEnabled) { var queueColor = limiterSnapshot.Waiting > 0 ? ImGuiColors.DalamudYellow : ImGuiColors.DalamudGrey; @@ -185,7 +186,7 @@ public class DownloadUi : WindowMediatorSubscriberBase } catch { - // ignore errors thrown from UI + _logger.LogDebug("Error drawing download progress"); } } @@ -257,7 +258,7 @@ public class DownloadUi : WindowMediatorSubscriberBase } catch { - // ignore errors thrown on UI + _logger.LogDebug("Error drawing upload progress"); } } } From f202818b55456ef2d0726dbd747a4febd8e79b6f Mon Sep 17 00:00:00 2001 From: choco Date: Tue, 14 Oct 2025 11:46:14 +0200 Subject: [PATCH 15/64] performance notifcation addition, with some regular bugfixes regarding the flexing of the notifications --- .../Configurations/LightlessConfig.cs | 7 +- .../Models/NotificationLocation.cs | 3 +- LightlessSync/Services/Mediator/Messages.cs | 2 + LightlessSync/Services/NotificationService.cs | 221 ++++++++++++++++-- .../Services/PlayerPerformanceService.cs | 34 ++- LightlessSync/UI/LightlessNotificationUI.cs | 113 ++++++--- LightlessSync/UI/SettingsUi.cs | 73 +++++- LightlessSync/UI/SyncshellFinderUI.cs | 2 +- LightlessSync/UI/UIColors.cs | 6 +- 9 files changed, 379 insertions(+), 82 deletions(-) diff --git a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs index bee94fd..9102d90 100644 --- a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs +++ b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs @@ -86,6 +86,7 @@ public class LightlessConfig : ILightlessConfiguration public NotificationLocation LightlessErrorNotification { get; set; } = NotificationLocation.ChatAndLightlessUi; public NotificationLocation LightlessPairRequestNotification { get; set; } = NotificationLocation.LightlessUi; public NotificationLocation LightlessDownloadNotification { get; set; } = NotificationLocation.TextOverlay; + public NotificationLocation LightlessPerformanceNotification { get; set; } = NotificationLocation.LightlessUi; // Basic Settings public float NotificationOpacity { get; set; } = 0.95f; @@ -112,16 +113,18 @@ public class LightlessConfig : ILightlessConfiguration public int ErrorNotificationDurationSeconds { get; set; } = 20; public int PairRequestDurationSeconds { get; set; } = 180; public int DownloadNotificationDurationSeconds { get; set; } = 300; + public int PerformanceNotificationDurationSeconds { get; set; } = 20; public uint CustomInfoSoundId { get; set; } = 2; // Se2 public uint CustomWarningSoundId { get; set; } = 16; // Se15 public uint CustomErrorSoundId { get; set; } = 16; // Se15 public uint PairRequestSoundId { get; set; } = 5; // Se5 - public uint DownloadSoundId { get; set; } = 15; // Se14 + public uint PerformanceSoundId { get; set; } = 16; // Se15 public bool DisableInfoSound { get; set; } = true; public bool DisableWarningSound { get; set; } = true; public bool DisableErrorSound { get; set; } = true; public bool DisablePairRequestSound { get; set; } = true; - public bool DisableDownloadSound { get; set; } = true; + public bool DisablePerformanceSound { get; set; } = true; + public bool ShowPerformanceNotificationActions { get; set; } = true; public bool UseFocusTarget { get; set; } = false; public bool overrideFriendColor { get; set; } = false; public bool overridePartyColor { get; set; } = false; diff --git a/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs b/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs index 73637ee..c0609c6 100644 --- a/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs +++ b/LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs @@ -17,7 +17,8 @@ public enum NotificationType Warning, Error, PairRequest, - Download + Download, + Performance } public enum NotificationCorner diff --git a/LightlessSync/Services/Mediator/Messages.cs b/LightlessSync/Services/Mediator/Messages.cs index 3396027..8d45ed6 100644 --- a/LightlessSync/Services/Mediator/Messages.cs +++ b/LightlessSync/Services/Mediator/Messages.cs @@ -50,6 +50,8 @@ public record TransientResourceChangedMessage(IntPtr Address) : MessageBase; public record HaltScanMessage(string Source) : MessageBase; public record NotificationMessage (string Title, string Message, NotificationType Type, TimeSpan? TimeShownOnScreen = null) : MessageBase; +public record PerformanceNotificationMessage + (string Title, string Message, UserData UserData, bool IsPaused, string PlayerName) : MessageBase; public record CreateCacheForObjectMessage(GameObjectHandler ObjectToCreateFor) : SameThreadMessage; public record ClearCacheForObjectMessage(GameObjectHandler ObjectToCreateFor) : SameThreadMessage; public record CharacterDataCreatedMessage(CharacterData CharacterData) : SameThreadMessage; diff --git a/LightlessSync/Services/NotificationService.cs b/LightlessSync/Services/NotificationService.cs index 3f3fdfb..c2f5ab6 100644 --- a/LightlessSync/Services/NotificationService.cs +++ b/LightlessSync/Services/NotificationService.cs @@ -10,9 +10,11 @@ using LightlessSync.UI.Models; using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; using FFXIVClientStructs.FFXIV.Client.UI; +using LightlessSync.API.Data; using NotificationType = LightlessSync.LightlessConfiguration.Models.NotificationType; namespace LightlessSync.Services; + public class NotificationService : DisposableMediatorSubscriberBase, IHostedService { private readonly ILogger _logger; @@ -44,6 +46,7 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ { Mediator.Subscribe(this, HandleNotificationMessage); Mediator.Subscribe(this, HandlePairRequestsUpdated); + Mediator.Subscribe(this, HandlePerformanceNotification); return Task.CompletedTask; } @@ -107,23 +110,35 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ public void ShowPairRequestNotification(string senderName, string senderId, Action onAccept, Action onDecline) { - var notification = new LightlessNotification + var location = GetNotificationLocation(NotificationType.PairRequest); + + // Show in chat if configured + if (location == NotificationLocation.Chat || location == NotificationLocation.ChatAndLightlessUi) { - Id = $"pair_request_{senderId}", - Title = "Pair Request Received", - Message = $"{senderName} wants to directly pair with you.", - Type = NotificationType.PairRequest, - Duration = TimeSpan.FromSeconds(_configService.Current.PairRequestDurationSeconds), - SoundEffectId = GetPairRequestSoundId(), - Actions = CreatePairRequestActions(onAccept, onDecline) - }; - - if (notification.SoundEffectId.HasValue) - { - PlayNotificationSound(notification.SoundEffectId.Value); + ShowChat(new NotificationMessage("Pair Request Received", $"{senderName} wants to directly pair with you.", NotificationType.PairRequest)); } + + // Show Lightless notification if configured + if (location == NotificationLocation.LightlessUi || location == NotificationLocation.ChatAndLightlessUi) + { + var notification = new LightlessNotification + { + Id = $"pair_request_{senderId}", + Title = "Pair Request Received", + Message = $"{senderName} wants to directly pair with you.", + Type = NotificationType.PairRequest, + Duration = TimeSpan.FromSeconds(_configService.Current.PairRequestDurationSeconds), + SoundEffectId = GetPairRequestSoundId(), + Actions = CreatePairRequestActions(onAccept, onDecline) + }; - Mediator.Publish(new LightlessNotificationMessage(notification)); + if (notification.SoundEffectId.HasValue) + { + PlayNotificationSound(notification.SoundEffectId.Value); + } + + Mediator.Publish(new LightlessNotificationMessage(notification)); + } } private uint? GetPairRequestSoundId() => @@ -356,6 +371,7 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ NotificationType.Error => TimeSpan.FromSeconds(_configService.Current.ErrorNotificationDurationSeconds), NotificationType.PairRequest => TimeSpan.FromSeconds(_configService.Current.PairRequestDurationSeconds), NotificationType.Download => TimeSpan.FromSeconds(_configService.Current.DownloadNotificationDurationSeconds), + NotificationType.Performance => TimeSpan.FromSeconds(_configService.Current.PerformanceNotificationDurationSeconds), _ => TimeSpan.FromSeconds(10) }; @@ -371,7 +387,8 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ NotificationType.Info => _configService.Current.DisableInfoSound, NotificationType.Warning => _configService.Current.DisableWarningSound, NotificationType.Error => _configService.Current.DisableErrorSound, - NotificationType.Download => _configService.Current.DisableDownloadSound, + NotificationType.Performance => _configService.Current.DisablePerformanceSound, + NotificationType.Download => true, // Download sounds always disabled _ => false }; @@ -380,7 +397,7 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ NotificationType.Info => _configService.Current.CustomInfoSoundId, NotificationType.Warning => _configService.Current.CustomWarningSoundId, NotificationType.Error => _configService.Current.CustomErrorSoundId, - NotificationType.Download => _configService.Current.DownloadSoundId, + NotificationType.Performance => _configService.Current.PerformanceSoundId, _ => NotificationSounds.GetDefaultSound(type) }; @@ -418,6 +435,7 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ NotificationType.Error => _configService.Current.LightlessErrorNotification, NotificationType.PairRequest => _configService.Current.LightlessPairRequestNotification, NotificationType.Download => _configService.Current.LightlessDownloadNotification, + NotificationType.Performance => _configService.Current.LightlessPerformanceNotification, _ => NotificationLocation.LightlessUi }; @@ -505,6 +523,18 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ case NotificationType.Error: PrintErrorChat(msg.Message); break; + + case NotificationType.PairRequest: + PrintPairRequestChat(msg.Title, msg.Message); + break; + + case NotificationType.Performance: + PrintPerformanceChat(msg.Title, msg.Message); + break; + + // Download notifications don't support chat output, will be a giga spam otherwise + case NotificationType.Download: + break; } } @@ -528,6 +558,22 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ _chatGui.Print(se.BuiltString); } + private void PrintPairRequestChat(string? title, string? message) + { + SeStringBuilder se = new SeStringBuilder().AddText("[Lightless Sync] ") + .AddUiForeground("Pair Request: ", 541).AddUiForegroundOff() + .AddText(title ?? message ?? string.Empty); + _chatGui.Print(se.BuiltString); + } + + private void PrintPerformanceChat(string? title, string? message) + { + SeStringBuilder se = new SeStringBuilder().AddText("[Lightless Sync] ") + .AddUiForeground("Performance: ", 508).AddUiForegroundOff() + .AddText(title ?? message ?? string.Empty); + _chatGui.Print(se.BuiltString); + } + private void HandlePairRequestsUpdated(PairRequestsUpdatedMessage _) { var activeRequests = _pairRequestService.GetActiveRequests(); @@ -557,5 +603,144 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ ); } } -} - \ No newline at end of file + + private void HandlePerformanceNotification(PerformanceNotificationMessage msg) + { + var location = GetNotificationLocation(NotificationType.Performance); + + // Show in chat if configured + if (location == NotificationLocation.Chat || location == NotificationLocation.ChatAndLightlessUi) + { + ShowChat(new NotificationMessage(msg.Title, msg.Message, NotificationType.Performance)); + } + + // Show Lightless notification if configured and action buttons are enabled + if ((location == NotificationLocation.LightlessUi || location == NotificationLocation.ChatAndLightlessUi) + && _configService.Current.UseLightlessNotifications + && _configService.Current.ShowPerformanceNotificationActions) + { + var actions = CreatePerformanceActions(msg.UserData, msg.IsPaused, msg.PlayerName); + var notification = new LightlessNotification + { + Title = msg.Title, + Message = msg.Message, + Type = NotificationType.Performance, + Duration = TimeSpan.FromSeconds(_configService.Current.PerformanceNotificationDurationSeconds), + Actions = actions, + SoundEffectId = GetSoundEffectId(NotificationType.Performance, null) + }; + + if (notification.SoundEffectId.HasValue) + { + PlayNotificationSound(notification.SoundEffectId.Value); + } + + Mediator.Publish(new LightlessNotificationMessage(notification)); + } + else if (location != NotificationLocation.Nowhere && location != NotificationLocation.Chat) + { + // Fall back to regular notification without action buttons + HandleNotificationMessage(new NotificationMessage(msg.Title, msg.Message, NotificationType.Performance)); + } + } + + private List CreatePerformanceActions(UserData userData, bool isPaused, string playerName) + { + var actions = new List(); + + if (isPaused) + { + actions.Add(new LightlessNotificationAction + { + Label = "Unpause", + Icon = FontAwesomeIcon.Play, + Color = UIColors.Get("LightlessGreen"), + IsPrimary = true, + OnClick = (notification) => + { + try + { + Mediator.Publish(new CyclePauseMessage(userData)); + DismissNotification(notification); + + var displayName = GetUserDisplayName(userData, playerName); + ShowNotification( + "Player Unpaused", + $"Successfully unpaused {displayName}", + NotificationType.Info, + TimeSpan.FromSeconds(3)); + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to unpause player {uid}", userData.UID); + var displayName = GetUserDisplayName(userData, playerName); + ShowNotification( + "Unpause Failed", + $"Failed to unpause {displayName}", + NotificationType.Error, + TimeSpan.FromSeconds(5)); + } + } + }); + } + else + { + actions.Add(new LightlessNotificationAction + { + Label = "Pause", + Icon = FontAwesomeIcon.Pause, + Color = UIColors.Get("LightlessOrange"), + IsPrimary = true, + OnClick = (notification) => + { + try + { + Mediator.Publish(new PauseMessage(userData)); + DismissNotification(notification); + + var displayName = GetUserDisplayName(userData, playerName); + ShowNotification( + "Player Paused", + $"Successfully paused {displayName}", + NotificationType.Info, + TimeSpan.FromSeconds(3)); + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to pause player {uid}", userData.UID); + var displayName = GetUserDisplayName(userData, playerName); + ShowNotification( + "Pause Failed", + $"Failed to pause {displayName}", + NotificationType.Error, + TimeSpan.FromSeconds(5)); + } + } + }); + } + + // Add dismiss button + actions.Add(new LightlessNotificationAction + { + Label = "Dismiss", + Icon = FontAwesomeIcon.Times, + Color = UIColors.Get("DimRed"), + IsPrimary = false, + OnClick = (notification) => + { + DismissNotification(notification); + } + }); + + return actions; + } + + private string GetUserDisplayName(UserData userData, string playerName) + { + if (!string.IsNullOrEmpty(userData.Alias) && !string.Equals(userData.Alias, userData.UID, StringComparison.Ordinal)) + { + return $"{playerName} ({userData.Alias})"; + } + return $"{playerName} ({userData.UID})"; + } +} \ No newline at end of file diff --git a/LightlessSync/Services/PlayerPerformanceService.cs b/LightlessSync/Services/PlayerPerformanceService.cs index ef43849..0cf7a72 100644 --- a/LightlessSync/Services/PlayerPerformanceService.cs +++ b/LightlessSync/Services/PlayerPerformanceService.cs @@ -93,8 +93,12 @@ public class PlayerPerformanceService $"triangle warning threshold ({triUsage}/{config.TrisWarningThresholdThousands * 1000} triangles)."; } - _mediator.Publish(new NotificationMessage($"{pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds performance threshold(s)", - warningText, LightlessConfiguration.Models.NotificationType.Warning)); + _mediator.Publish(new PerformanceNotificationMessage( + $"{pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds performance threshold(s)", + warningText, + pairHandler.Pair.UserData, + pairHandler.Pair.IsPaused, + pairHandler.Pair.PlayerName)); } return true; @@ -138,11 +142,16 @@ public class PlayerPerformanceService if (CheckForThreshold(config.AutoPausePlayersExceedingThresholds, config.TrisAutoPauseThresholdThousands * 1000, triUsage, config.AutoPausePlayersWithPreferredPermissionsExceedingThresholds, isPrefPerm)) { - _mediator.Publish(new NotificationMessage($"{pair.PlayerName} ({pair.UserData.AliasOrUID}) automatically paused", - $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured triangle auto pause threshold (" + + var message = $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured triangle auto pause threshold (" + $"{triUsage}/{config.TrisAutoPauseThresholdThousands * 1000} triangles)" + - $" and has been automatically paused.", - LightlessConfiguration.Models.NotificationType.Warning)); + $" and has been automatically paused."; + + _mediator.Publish(new PerformanceNotificationMessage( + $"{pair.PlayerName} ({pair.UserData.AliasOrUID}) automatically paused", + message, + pair.UserData, + true, + pair.PlayerName)); _mediator.Publish(new EventMessage(new Event(pair.PlayerName, pair.UserData, nameof(PlayerPerformanceService), EventSeverity.Warning, $"Exceeds triangle threshold: automatically paused ({triUsage}/{config.TrisAutoPauseThresholdThousands * 1000} triangles)"))); @@ -214,11 +223,16 @@ public class PlayerPerformanceService if (CheckForThreshold(config.AutoPausePlayersExceedingThresholds, config.VRAMSizeAutoPauseThresholdMiB * 1024 * 1024, vramUsage, config.AutoPausePlayersWithPreferredPermissionsExceedingThresholds, isPrefPerm)) { - _mediator.Publish(new NotificationMessage($"{pair.PlayerName} ({pair.UserData.AliasOrUID}) automatically paused", - $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured VRAM auto pause threshold (" + + var message = $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured VRAM auto pause threshold (" + $"{UiSharedService.ByteToString(vramUsage, addSuffix: true)}/{config.VRAMSizeAutoPauseThresholdMiB}MiB)" + - $" and has been automatically paused.", - LightlessConfiguration.Models.NotificationType.Warning)); + $" and has been automatically paused."; + + _mediator.Publish(new PerformanceNotificationMessage( + $"{pair.PlayerName} ({pair.UserData.AliasOrUID}) automatically paused", + message, + pair.UserData, + true, + pair.PlayerName)); _mediator.Publish(new PauseMessage(pair.UserData)); diff --git a/LightlessSync/UI/LightlessNotificationUI.cs b/LightlessSync/UI/LightlessNotificationUI.cs index cb62b51..2ac26b7 100644 --- a/LightlessSync/UI/LightlessNotificationUI.cs +++ b/LightlessSync/UI/LightlessNotificationUI.cs @@ -22,6 +22,10 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private const float WindowPaddingOffset = 6f; private const float SlideAnimationDistance = 100f; private const float OutAnimationSpeedMultiplier = 0.7f; + private const float ContentPaddingX = 10f; + private const float ContentPaddingY = 6f; + private const float TitleMessageSpacing = 4f; + private const float ActionButtonSpacing = 8f; private readonly List _notifications = new(); private readonly object _notificationLock = new(); @@ -462,81 +466,112 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private void DrawNotificationText(LightlessNotification notification, float alpha) { - var padding = new Vector2(10f, 6f); - var contentPos = new Vector2(padding.X, padding.Y); + var contentPos = new Vector2(ContentPaddingX, ContentPaddingY); var windowSize = ImGui.GetWindowSize(); - var contentSize = new Vector2(windowSize.X - padding.X, windowSize.Y - padding.Y * 2); + var contentWidth = CalculateContentWidth(windowSize.X); ImGui.SetCursorPos(contentPos); - var titleHeight = DrawTitle(notification, contentSize.X, alpha); - DrawMessage(notification, contentPos, contentSize.X, titleHeight, alpha); + var titleHeight = DrawTitle(notification, contentWidth, alpha); + DrawMessage(notification, contentPos, contentWidth, titleHeight, alpha); - if (notification.Actions.Count > 0) + if (HasActions(notification)) { - ImGui.SetCursorPosY(ImGui.GetCursorPosY() + ImGui.GetStyle().ItemSpacing.Y); - ImGui.SetCursorPosX(contentPos.X); - DrawNotificationActions(notification, contentSize.X, alpha); + PositionActionsAtBottom(windowSize.Y); + DrawNotificationActions(notification, contentWidth, alpha); } } + private float CalculateContentWidth(float windowWidth) => + windowWidth - (ContentPaddingX * 2); + + private bool HasActions(LightlessNotification notification) => + notification.Actions.Count > 0; + + private void PositionActionsAtBottom(float windowHeight) + { + var actionHeight = ImGui.GetFrameHeight(); + var bottomY = windowHeight - ContentPaddingY - actionHeight; + ImGui.SetCursorPosY(bottomY); + ImGui.SetCursorPosX(ContentPaddingX); + } + private float DrawTitle(LightlessNotification notification, float contentWidth, float alpha) { - using (ImRaii.PushColor(ImGuiCol.Text, new Vector4(1f, 1f, 1f, alpha))) + var titleColor = new Vector4(1f, 1f, 1f, alpha); + var titleText = FormatTitleText(notification); + + using (ImRaii.PushColor(ImGuiCol.Text, titleColor)) { - ImGui.PushTextWrapPos(ImGui.GetCursorPosX() + contentWidth); - var titleStartY = ImGui.GetCursorPosY(); - - var titleText = _configService.Current.ShowNotificationTimestamp - ? $"[{notification.CreatedAt.ToLocalTime():HH:mm:ss}] {notification.Title}" - : notification.Title; - - ImGui.TextWrapped(titleText); - var titleHeight = ImGui.GetCursorPosY() - titleStartY; - ImGui.PopTextWrapPos(); - return titleHeight; + return DrawWrappedText(titleText, contentWidth); } } + private string FormatTitleText(LightlessNotification notification) + { + if (!_configService.Current.ShowNotificationTimestamp) + return notification.Title; + + var timestamp = notification.CreatedAt.ToLocalTime().ToString("HH:mm:ss"); + return $"[{timestamp}] {notification.Title}"; + } + + private float DrawWrappedText(string text, float wrapWidth) + { + ImGui.PushTextWrapPos(ImGui.GetCursorPosX() + wrapWidth); + var startY = ImGui.GetCursorPosY(); + ImGui.TextWrapped(text); + var height = ImGui.GetCursorPosY() - startY; + ImGui.PopTextWrapPos(); + return height; + } + private void DrawMessage(LightlessNotification notification, Vector2 contentPos, float contentWidth, float titleHeight, float alpha) { if (string.IsNullOrEmpty(notification.Message)) return; - ImGui.SetCursorPos(contentPos + new Vector2(0f, titleHeight + 4f)); - ImGui.PushTextWrapPos(ImGui.GetCursorPosX() + contentWidth); - using (ImRaii.PushColor(ImGuiCol.Text, new Vector4(0.9f, 0.9f, 0.9f, alpha))) + var messagePos = contentPos + new Vector2(0f, titleHeight + TitleMessageSpacing); + var messageColor = new Vector4(0.9f, 0.9f, 0.9f, alpha); + + ImGui.SetCursorPos(messagePos); + + using (ImRaii.PushColor(ImGuiCol.Text, messageColor)) { - ImGui.TextWrapped(notification.Message); + DrawWrappedText(notification.Message, contentWidth); } - ImGui.PopTextWrapPos(); } private void DrawNotificationActions(LightlessNotification notification, float availableWidth, float alpha) { - var buttonSpacing = 8f; - var rightPadding = 10f; - var usableWidth = availableWidth - rightPadding; - var totalSpacing = (notification.Actions.Count - 1) * buttonSpacing; - var buttonWidth = (usableWidth - totalSpacing) / notification.Actions.Count; + var buttonWidth = CalculateActionButtonWidth(notification.Actions.Count, availableWidth); _logger.LogDebug("Drawing {ActionCount} notification actions, buttonWidth: {ButtonWidth}, availableWidth: {AvailableWidth}", notification.Actions.Count, buttonWidth, availableWidth); - var startCursorPos = ImGui.GetCursorPos(); + var startX = ImGui.GetCursorPosX(); for (int i = 0; i < notification.Actions.Count; i++) { - var action = notification.Actions[i]; - if (i > 0) { ImGui.SameLine(); - var currentX = startCursorPos.X + i * (buttonWidth + buttonSpacing); - ImGui.SetCursorPosX(currentX); + PositionActionButton(i, startX, buttonWidth); } - DrawActionButton(action, notification, alpha, buttonWidth); + DrawActionButton(notification.Actions[i], notification, alpha, buttonWidth); } } + + private float CalculateActionButtonWidth(int actionCount, float availableWidth) + { + var totalSpacing = (actionCount - 1) * ActionButtonSpacing; + return (availableWidth - totalSpacing) / actionCount; + } + + private void PositionActionButton(int index, float startX, float buttonWidth) + { + var xPosition = startX + index * (buttonWidth + ActionButtonSpacing); + ImGui.SetCursorPosX(xPosition); + } private void DrawActionButton(LightlessNotificationAction action, LightlessNotification notification, float alpha, float buttonWidth) { @@ -634,7 +669,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private float CalculateNotificationHeight(LightlessNotification notification) { - var contentWidth = _configService.Current.NotificationWidth - 35f; + var contentWidth = CalculateContentWidth(_configService.Current.NotificationWidth); var height = 12f; height += CalculateTitleHeight(notification, contentWidth); @@ -681,6 +716,8 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase NotificationType.Error => UIColors.Get("DimRed"), NotificationType.PairRequest => UIColors.Get("LightlessBlue"), NotificationType.Download => UIColors.Get("LightlessGreen"), + NotificationType.Performance => UIColors.Get("LightlessOrange"), + _ => UIColors.Get("LightlessPurple") }; } diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index 87df967..1272742 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -1990,7 +1990,7 @@ public class SettingsUi : WindowMediatorSubscriberBase ("LightlessBlue", "Secondary Blue", "Secondary title colors, visable pairs"), ("LightlessGreen", "Success Green", "Join buttons and success messages"), ("LightlessYellow", "Warning Yellow", "Warning colors"), - ("LightlessYellow2", "Warning Yellow (Alt)", "Warning colors"), + ("LightlessOrange", "Performance Orange", "Performance notifications and warnings"), ("PairBlue", "Syncshell Blue", "Syncshell headers, toggle highlights, and moderator actions"), ("DimRed", "Error Red", "Error and offline colors") }; @@ -3640,6 +3640,36 @@ public class SettingsUi : WindowMediatorSubscriberBase } UiSharedService.AttachToolTip("Test download progress notification"); + ImGui.TableNextRow(); + ImGui.TableSetColumnIndex(0); + ImGui.AlignTextToFramePadding(); + ImGui.TextUnformatted("Performance Notifications"); + ImGui.TableSetColumnIndex(1); + ImGui.SetNextItemWidth(-1); + _uiShared.DrawCombo("###enhanced_performance", lightlessLocations, GetNotificationLocationLabel, + (location) => + { + _configService.Current.LightlessPerformanceNotification = location; + _configService.Save(); + }, _configService.Current.LightlessPerformanceNotification); + ImGui.TableSetColumnIndex(2); + availableWidth = ImGui.GetContentRegionAvail().X; + using (ImRaii.PushFont(UiBuilder.IconFont)) + { + if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_performance", new Vector2(availableWidth, 0))) + { + var testUserData = new UserData("TEST123", "TestUser", false, false, false, null, null); + Mediator.Publish(new PerformanceNotificationMessage( + "Test Player (TestUser) exceeds performance threshold(s)", + "Player Test Player (TestUser) exceeds your configured VRAM warning threshold (500 MB/300 MB).", + testUserData, + false, + "Test Player" + )); + } + } + UiSharedService.AttachToolTip("Test performance notification"); + ImGui.EndTable(); } @@ -3974,6 +4004,20 @@ public class SettingsUi : WindowMediatorSubscriberBase if (ImGui.IsItemHovered()) ImGui.SetTooltip("Right click to reset to default (300)."); + int performanceDuration = _configService.Current.PerformanceNotificationDurationSeconds; + if (ImGui.SliderInt("Performance Duration (seconds)", ref performanceDuration, 5, 60)) + { + _configService.Current.PerformanceNotificationDurationSeconds = Math.Clamp(performanceDuration, 5, 60); + _configService.Save(); + } + if (ImGui.IsItemClicked(ImGuiMouseButton.Right)) + { + _configService.Current.PerformanceNotificationDurationSeconds = 20; + _configService.Save(); + } + if (ImGui.IsItemHovered()) + ImGui.SetTooltip("Right click to reset to default (20)."); + _uiShared.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); ImGui.TreePop(); } @@ -4041,6 +4085,22 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.TreePop(); } + if (_uiShared.MediumTreeNode("Performance Notifications", UIColors.Get("LightlessOrange"))) + { + var showPerformanceActions = _configService.Current.ShowPerformanceNotificationActions; + if (ImGui.Checkbox("Show action buttons on performance warnings", ref showPerformanceActions)) + { + _configService.Current.ShowPerformanceNotificationActions = showPerformanceActions; + _configService.Save(); + } + + _uiShared.DrawHelpText( + "When a player exceeds performance thresholds or is auto-paused, show Pause/Unpause buttons in the notification."); + + _uiShared.ColoredSeparator(UIColors.Get("LightlessOrange"), 1.5f); + ImGui.TreePop(); + } + if (_uiShared.MediumTreeNode("System Notifications", UIColors.Get("LightlessYellow"))) { var disableOptionalPluginWarnings = _configService.Current.DisableOptionalPluginWarnings; @@ -4074,8 +4134,7 @@ public class SettingsUi : WindowMediatorSubscriberBase { return new[] { - NotificationLocation.LightlessUi, NotificationLocation.ChatAndLightlessUi, - NotificationLocation.TextOverlay, NotificationLocation.Nowhere + NotificationLocation.LightlessUi, NotificationLocation.TextOverlay, NotificationLocation.Nowhere }; } @@ -4138,7 +4197,7 @@ public class SettingsUi : WindowMediatorSubscriberBase ("Warning", 1, _configService.Current.CustomWarningSoundId, _configService.Current.DisableWarningSound, 16u), ("Error", 2, _configService.Current.CustomErrorSoundId, _configService.Current.DisableErrorSound, 16u), ("Pair Request", 3, _configService.Current.PairRequestSoundId, _configService.Current.DisablePairRequestSound, 5u), - ("Download", 4, _configService.Current.DownloadSoundId, _configService.Current.DisableDownloadSound, 15u) + ("Performance", 4, _configService.Current.PerformanceSoundId, _configService.Current.DisablePerformanceSound, 16u) }; foreach (var (typeName, typeIndex, currentSoundId, isDisabled, defaultSoundId) in soundTypes) @@ -4168,7 +4227,7 @@ public class SettingsUi : WindowMediatorSubscriberBase case 1: _configService.Current.CustomWarningSoundId = newSoundId; break; case 2: _configService.Current.CustomErrorSoundId = newSoundId; break; case 3: _configService.Current.PairRequestSoundId = newSoundId; break; - case 4: _configService.Current.DownloadSoundId = newSoundId; break; + case 4: _configService.Current.PerformanceSoundId = newSoundId; break; } _configService.Save(); @@ -4222,7 +4281,7 @@ public class SettingsUi : WindowMediatorSubscriberBase case 1: _configService.Current.DisableWarningSound = newDisabled; break; case 2: _configService.Current.DisableErrorSound = newDisabled; break; case 3: _configService.Current.DisablePairRequestSound = newDisabled; break; - case 4: _configService.Current.DisableDownloadSound = newDisabled; break; + case 4: _configService.Current.DisablePerformanceSound = newDisabled; break; } _configService.Save(); } @@ -4248,7 +4307,7 @@ public class SettingsUi : WindowMediatorSubscriberBase case 1: _configService.Current.CustomWarningSoundId = defaultSoundId; break; case 2: _configService.Current.CustomErrorSoundId = defaultSoundId; break; case 3: _configService.Current.PairRequestSoundId = defaultSoundId; break; - case 4: _configService.Current.DownloadSoundId = defaultSoundId; break; + case 4: _configService.Current.PerformanceSoundId = defaultSoundId; break; } _configService.Save(); } diff --git a/LightlessSync/UI/SyncshellFinderUI.cs b/LightlessSync/UI/SyncshellFinderUI.cs index 971d40c..6cd6935 100644 --- a/LightlessSync/UI/SyncshellFinderUI.cs +++ b/LightlessSync/UI/SyncshellFinderUI.cs @@ -88,7 +88,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase ImGuiHelpers.ScaledDummy(0.5f); ImGui.PushStyleVar(ImGuiStyleVar.FrameRounding, 10.0f); - ImGui.PushStyleColor(ImGuiCol.Button, UIColors.Get("LightlessYellow2")); + ImGui.PushStyleColor(ImGuiCol.Button, UIColors.Get("PairBlue")); if (ImGui.Button("Open Lightfinder", new Vector2(200 * ImGuiHelpers.GlobalScale, 0))) { diff --git a/LightlessSync/UI/UIColors.cs b/LightlessSync/UI/UIColors.cs index 993573d..3c1eabd 100644 --- a/LightlessSync/UI/UIColors.cs +++ b/LightlessSync/UI/UIColors.cs @@ -11,21 +11,17 @@ namespace LightlessSync.UI { "LightlessPurple", "#ad8af5" }, { "LightlessPurpleActive", "#be9eff" }, { "LightlessPurpleDefault", "#9375d1" }, - { "ButtonDefault", "#323232" }, { "FullBlack", "#000000" }, - { "LightlessBlue", "#a6c2ff" }, { "LightlessYellow", "#ffe97a" }, - { "LightlessYellow2", "#cfbd63" }, { "LightlessGreen", "#7cd68a" }, + { "LightlessOrange", "#ffb366" }, { "PairBlue", "#88a2db" }, { "DimRed", "#d44444" }, - { "LightlessAdminText", "#ffd663" }, { "LightlessAdminGlow", "#b09343" }, { "LightlessModeratorText", "#94ffda" }, - { "LightlessModeratorGlow", "#599c84" }, { "Lightfinder", "#ad8af5" }, { "LightfinderEdge", "#000000" }, From d6a4595bb8a0d72f61cdf4793dbb2f8438e1b9eb Mon Sep 17 00:00:00 2001 From: choco Date: Tue, 14 Oct 2025 14:54:30 +0200 Subject: [PATCH 16/64] old debug line removals, better alignment performance notifs --- .../Services/PlayerPerformanceService.cs | 23 +++--- LightlessSync/UI/SettingsUi.cs | 2 +- LightlessSync/UI/TopTabMenu.cs | 76 ------------------- 3 files changed, 11 insertions(+), 90 deletions(-) diff --git a/LightlessSync/Services/PlayerPerformanceService.cs b/LightlessSync/Services/PlayerPerformanceService.cs index 0cf7a72..7db92e1 100644 --- a/LightlessSync/Services/PlayerPerformanceService.cs +++ b/LightlessSync/Services/PlayerPerformanceService.cs @@ -78,19 +78,18 @@ public class PlayerPerformanceService string warningText = string.Empty; if (exceedsTris && !exceedsVram) { - warningText = $"Player {pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds your configured triangle warning threshold (" + - $"{triUsage}/{config.TrisWarningThresholdThousands * 1000} triangles)."; + warningText = $"Player {pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds your configured triangle warning threshold\n" + + $"{triUsage}/{config.TrisWarningThresholdThousands * 1000} triangles"; } else if (!exceedsTris) { - warningText = $"Player {pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds your configured VRAM warning threshold (" + - $"{UiSharedService.ByteToString(vramUsage, true)}/{config.VRAMSizeWarningThresholdMiB} MiB)."; + warningText = $"Player {pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds your configured VRAM warning threshold\n" + + $"{UiSharedService.ByteToString(vramUsage, true)}/{config.VRAMSizeWarningThresholdMiB} MiB"; } else { - warningText = $"Player {pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds both VRAM warning threshold (" + - $"{UiSharedService.ByteToString(vramUsage, true)}/{config.VRAMSizeWarningThresholdMiB} MiB) and " + - $"triangle warning threshold ({triUsage}/{config.TrisWarningThresholdThousands * 1000} triangles)."; + warningText = $"Player {pairHandler.Pair.PlayerName} ({pairHandler.Pair.UserData.AliasOrUID}) exceeds both VRAM warning threshold and triangle warning threshold\n" + + $"{UiSharedService.ByteToString(vramUsage, true)}/{config.VRAMSizeWarningThresholdMiB} MiB and {triUsage}/{config.TrisWarningThresholdThousands * 1000} triangles"; } _mediator.Publish(new PerformanceNotificationMessage( @@ -142,9 +141,8 @@ public class PlayerPerformanceService if (CheckForThreshold(config.AutoPausePlayersExceedingThresholds, config.TrisAutoPauseThresholdThousands * 1000, triUsage, config.AutoPausePlayersWithPreferredPermissionsExceedingThresholds, isPrefPerm)) { - var message = $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured triangle auto pause threshold (" + - $"{triUsage}/{config.TrisAutoPauseThresholdThousands * 1000} triangles)" + - $" and has been automatically paused."; + var message = $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured triangle auto pause threshold and has been automatically paused\n" + + $"{triUsage}/{config.TrisAutoPauseThresholdThousands * 1000} triangles"; _mediator.Publish(new PerformanceNotificationMessage( $"{pair.PlayerName} ({pair.UserData.AliasOrUID}) automatically paused", @@ -223,9 +221,8 @@ public class PlayerPerformanceService if (CheckForThreshold(config.AutoPausePlayersExceedingThresholds, config.VRAMSizeAutoPauseThresholdMiB * 1024 * 1024, vramUsage, config.AutoPausePlayersWithPreferredPermissionsExceedingThresholds, isPrefPerm)) { - var message = $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured VRAM auto pause threshold (" + - $"{UiSharedService.ByteToString(vramUsage, addSuffix: true)}/{config.VRAMSizeAutoPauseThresholdMiB}MiB)" + - $" and has been automatically paused."; + var message = $"Player {pair.PlayerName} ({pair.UserData.AliasOrUID}) exceeded your configured VRAM auto pause threshold and has been automatically paused\n" + + $"{UiSharedService.ByteToString(vramUsage, addSuffix: true)}/{config.VRAMSizeAutoPauseThresholdMiB}MiB"; _mediator.Publish(new PerformanceNotificationMessage( $"{pair.PlayerName} ({pair.UserData.AliasOrUID}) automatically paused", diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index 1272742..d5520e0 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -3661,7 +3661,7 @@ public class SettingsUi : WindowMediatorSubscriberBase var testUserData = new UserData("TEST123", "TestUser", false, false, false, null, null); Mediator.Publish(new PerformanceNotificationMessage( "Test Player (TestUser) exceeds performance threshold(s)", - "Player Test Player (TestUser) exceeds your configured VRAM warning threshold (500 MB/300 MB).", + "Player Test Player (TestUser) exceeds your configured VRAM warning threshold\n500 MB/300 MB", testUserData, false, "Test Player" diff --git a/LightlessSync/UI/TopTabMenu.cs b/LightlessSync/UI/TopTabMenu.cs index 2a6a236..b4327c0 100644 --- a/LightlessSync/UI/TopTabMenu.cs +++ b/LightlessSync/UI/TopTabMenu.cs @@ -196,82 +196,6 @@ public class TopTabMenu if (TabSelection != SelectedTab.None) ImGuiHelpers.ScaledDummy(3f); - #if DEBUG - if (ImGui.Button("Test Pair Request")) - { - _lightlessNotificationService.ShowPairRequestNotification( - "Debug User", - "debug-user-id", - onAccept: () => - { - _lightlessMediator.Publish(new NotificationMessage( - "Pair Accepted", - "Debug pair request was accepted!", - NotificationType.Info, - TimeSpan.FromSeconds(3))); - }, - onDecline: () => - { - _lightlessMediator.Publish(new NotificationMessage( - "Pair Declined", - "Debug pair request was declined.", - NotificationType.Warning, - TimeSpan.FromSeconds(3))); - } - ); - } - - ImGui.SameLine(); - if (ImGui.Button("Test Info")) - { - _lightlessMediator.Publish(new NotificationMessage( - "Information", - "This is a test ifno notification with some longer text to see how it wraps. This is a test ifno notification with some longer text to see how it wraps. This is a test ifno notification with some longer text to see how it wraps. This is a test ifno notification with some longer text to see how it wraps.", - NotificationType.Info, - TimeSpan.FromSeconds(5))); - } - - ImGui.SameLine(); - if (ImGui.Button("Test Warning")) - { - _lightlessMediator.Publish(new NotificationMessage( - "Warning", - "This is a test warning notification.", - NotificationType.Warning, - TimeSpan.FromSeconds(7))); - } - - ImGui.SameLine(); - if (ImGui.Button("Test Error")) - { - _lightlessMediator.Publish(new NotificationMessage( - "Error", - "This is a test error notification erp police", - NotificationType.Error, - TimeSpan.FromSeconds(10))); - } - - if (ImGui.Button("Test Download Progress")) - { - var downloadStatus = new List<(string playerName, float progress, string status)> - { - ("Mauwmauw Nekochan", 0.85f, "downloading"), - ("Raelynn Kitsune", 0.34f, "downloading"), - ("Jaina Elraeth", 0.67f, "downloading"), - ("Vaelstra Bloodthorn", 0.19f, "downloading"), - ("Lydia Hera Moondrop", 0.86f, "downloading"), - ("C'liina Star", 1.0f, "completed") - }; - - _lightlessNotificationService.ShowPairDownloadNotification(downloadStatus); - } - ImGui.SameLine(); - if (ImGui.Button("Dismiss Download")) - { - _lightlessNotificationService.DismissPairDownloadNotification(); - } - #endif - DrawIncomingPairRequests(availableWidth); ImGui.Separator(); From cf27a6729657fdccb54f71b14cf6b67081191dca Mon Sep 17 00:00:00 2001 From: choco Date: Tue, 14 Oct 2025 15:07:46 +0200 Subject: [PATCH 17/64] optional action button toggle for pair request (default on) --- .../Configurations/LightlessConfig.cs | 1 + LightlessSync/Services/NotificationService.cs | 11 +++++++++-- LightlessSync/UI/SettingsUi.cs | 16 ++++++++++++++++ 3 files changed, 26 insertions(+), 2 deletions(-) diff --git a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs index 9102d90..bdf8542 100644 --- a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs +++ b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs @@ -125,6 +125,7 @@ public class LightlessConfig : ILightlessConfiguration public bool DisablePairRequestSound { get; set; } = true; public bool DisablePerformanceSound { get; set; } = true; public bool ShowPerformanceNotificationActions { get; set; } = true; + public bool ShowPairRequestNotificationActions { get; set; } = true; public bool UseFocusTarget { get; set; } = false; public bool overrideFriendColor { get; set; } = false; public bool overridePartyColor { get; set; } = false; diff --git a/LightlessSync/Services/NotificationService.cs b/LightlessSync/Services/NotificationService.cs index c2f5ab6..755e756 100644 --- a/LightlessSync/Services/NotificationService.cs +++ b/LightlessSync/Services/NotificationService.cs @@ -118,8 +118,10 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ ShowChat(new NotificationMessage("Pair Request Received", $"{senderName} wants to directly pair with you.", NotificationType.PairRequest)); } - // Show Lightless notification if configured - if (location == NotificationLocation.LightlessUi || location == NotificationLocation.ChatAndLightlessUi) + // Show Lightless notification if configured and action buttons are enabled + if ((location == NotificationLocation.LightlessUi || location == NotificationLocation.ChatAndLightlessUi) + && _configService.Current.UseLightlessNotifications + && _configService.Current.ShowPairRequestNotificationActions) { var notification = new LightlessNotification { @@ -139,6 +141,11 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ Mediator.Publish(new LightlessNotificationMessage(notification)); } + else if (location != NotificationLocation.Nowhere && location != NotificationLocation.Chat) + { + // Fall back to regular notification without action buttons + HandleNotificationMessage(new NotificationMessage("Pair Request Received", $"{senderName} wants to directly pair with you.", NotificationType.PairRequest)); + } } private uint? GetPairRequestSoundId() => diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index d5520e0..dd7ee84 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -4085,6 +4085,22 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.TreePop(); } + if (_uiShared.MediumTreeNode("Pair Request Notifications", UIColors.Get("PairBlue"))) + { + var showPairRequestActions = _configService.Current.ShowPairRequestNotificationActions; + if (ImGui.Checkbox("Show action buttons on pair requests", ref showPairRequestActions)) + { + _configService.Current.ShowPairRequestNotificationActions = showPairRequestActions; + _configService.Save(); + } + + _uiShared.DrawHelpText( + "When you receive a pair request, show Accept/Decline buttons in the notification."); + + _uiShared.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); + ImGui.TreePop(); + } + if (_uiShared.MediumTreeNode("Performance Notifications", UIColors.Get("LightlessOrange"))) { var showPerformanceActions = _configService.Current.ShowPerformanceNotificationActions; From 7d480b9e2cc064cb17b312a1439df968c10e19df Mon Sep 17 00:00:00 2001 From: defnotken Date: Tue, 14 Oct 2025 10:33:44 -0500 Subject: [PATCH 18/64] Defensive handling and NRE removal. --- LightlessSync/Services/NameplateHandler.cs | 8 +++++++- LightlessSync/UI/SyncshellFinderUI.cs | 2 -- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/LightlessSync/Services/NameplateHandler.cs b/LightlessSync/Services/NameplateHandler.cs index dc761bb..a28be5f 100644 --- a/LightlessSync/Services/NameplateHandler.cs +++ b/LightlessSync/Services/NameplateHandler.cs @@ -208,7 +208,13 @@ public unsafe class NameplateHandler : IMediatorSubscriber for (int i = 0; i < ui3DModule->NamePlateObjectInfoCount; ++i) { - var objectInfo = ui3DModule->NamePlateObjectInfoPointers[i].Value; + if (ui3DModule->NamePlateObjectInfoPointers.IsEmpty) continue; + + var objectInfoPtr = ui3DModule->NamePlateObjectInfoPointers[i]; + + if (objectInfoPtr == null) continue; + + var objectInfo = objectInfoPtr.Value; if (objectInfo == null || objectInfo->GameObject == null) continue; diff --git a/LightlessSync/UI/SyncshellFinderUI.cs b/LightlessSync/UI/SyncshellFinderUI.cs index 971d40c..46b7bfa 100644 --- a/LightlessSync/UI/SyncshellFinderUI.cs +++ b/LightlessSync/UI/SyncshellFinderUI.cs @@ -288,8 +288,6 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase return; } - var currentGids = _nearbySyncshells.Select(s => s.Group.GID).ToHashSet(StringComparer.Ordinal); - if (updatedList != null) { var previousGid = GetSelectedGid(); From 011cf7951bb6417c433466a3f32fdef73f064ecc Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Tue, 14 Oct 2025 20:45:05 +0200 Subject: [PATCH 19/64] Added more documentation, fixed some small issues with cache --- .../Services/LightlessProfileManager.cs | 38 ++++++++++-- LightlessSync/UI/JoinSyncshellUI.cs | 60 ++++++++++++++----- LightlessSync/UI/SyncshellAdminUI.cs | 24 ++++---- 3 files changed, 88 insertions(+), 34 deletions(-) diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index 0b7b15b..dde664b 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -19,7 +19,7 @@ public class LightlessProfileManager : MediatorSubscriberBase private const string _noUserDescription = "-- User has no description set --"; private const string _noGroupDescription = "-- Syncshell has no description set --"; private const string _noTags = "-- Syncshell has no tags set --"; - private const string _nsfw = "Profile not displayed - NSFW"; + private const string _nsfwDescription = "Profile not displayed - NSFW"; private readonly ApiController _apiController; private readonly ILogger _logger; private readonly LightlessConfigService _lightlessConfigService; @@ -30,7 +30,7 @@ public class LightlessProfileManager : MediatorSubscriberBase private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, "Loading User Profile Data from server..."); private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Syncshell Profile Data from server...", string.Empty); private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, string.Empty); - private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfw); + private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfwDescription); public LightlessProfileManager(ILogger logger, LightlessConfigService lightlessConfigService, @@ -43,32 +43,51 @@ public class LightlessProfileManager : MediatorSubscriberBase Mediator.Subscribe(this, (msg) => { if (msg.UserData != null) + { + _logger.LogTrace("Received Clear Profile for User profile {data}", msg.UserData.AliasOrUID); _lightlessUserProfiles.Remove(msg.UserData, out _); + } else + { + _logger.LogTrace("Received Clear Profile for all User profiles"); _lightlessUserProfiles.Clear(); + } }); Mediator.Subscribe(this, (msg) => { if (msg.GroupData != null) + { + _logger.LogTrace("Received Clear Profile for Group profile {data}", msg.GroupData.AliasOrGID); _lightlessGroupProfiles.Remove(msg.GroupData, out _); + } else + { + _logger.LogTrace("Received Clear Profile for all Group profiles"); _lightlessGroupProfiles.Clear(); + } + }); Mediator.Subscribe(this, (_) => { + _logger.LogTrace("Received Disconnect, Clearing Profiles"); _lightlessUserProfiles.Clear(); _lightlessGroupProfiles.Clear(); } ); } + /// + /// Fetches User Profile from cache or API + /// + /// User Data of given user + /// LightlessUserProfileData of given user public LightlessUserProfileData GetLightlessUserProfile(UserData data) { if (!_lightlessUserProfiles.TryGetValue(data, out var profile)) { - _logger.LogInformation($"Getting data from {data.AliasOrUID}"); + _logger.LogTrace("Requesting User profile for {data}", data); _ = Task.Run(() => GetLightlessProfileFromService(data)); return (_loadingProfileUserData); } @@ -77,13 +96,16 @@ public class LightlessProfileManager : MediatorSubscriberBase } + /// + /// Fetches Group Profile from cache or API + /// + /// Group Data of given group + /// LightlessGroupProfileData of given group public LightlessGroupProfileData GetLightlessGroupProfile(GroupData data) { - _logger.LogInformation("Requesting group profile for {data}", data); - _logger.LogInformation("Dis in cache? {}", _lightlessGroupProfiles.TryGetValue(data, out var test)); if (!_lightlessGroupProfiles.TryGetValue(data, out var profile)) { - _logger.LogInformation($"Getting data from {data.GID}"); + _logger.LogTrace("Requesting group profile for {data}", data); _ = Task.Run(() => GetLightlessProfileFromService(data)); return (_loadingProfileGroupData); } @@ -100,6 +122,7 @@ public class LightlessProfileManager : MediatorSubscriberBase { try { + _logger.LogTrace("Inputting loading data in _lightlessUserProfiles for User {data}", data.AliasOrUID); _lightlessUserProfiles[data] = _loadingProfileUserData; var profile = await _apiController.UserGetProfile(new API.Dto.User.UserDto(data)).ConfigureAwait(false); @@ -108,6 +131,7 @@ public class LightlessProfileManager : MediatorSubscriberBase !string.IsNullOrEmpty(data.Alias) && !string.Equals(data.Alias, data.UID, StringComparison.Ordinal) ? _lightlessSupporter : string.Empty, string.IsNullOrEmpty(profile.Description) ? _noUserDescription : profile.Description); + _logger.LogTrace("Replacing data in _lightlessUserProfiles for User {data}", data.AliasOrUID); if (profileUserData.IsNSFW && !_lightlessConfigService.Current.ProfilesAllowNsfw && !string.Equals(_apiController.UID, data.UID, StringComparison.Ordinal)) { _lightlessUserProfiles[data] = _nsfwProfileUserData; @@ -134,6 +158,7 @@ public class LightlessProfileManager : MediatorSubscriberBase { try { + _logger.LogTrace("Inputting loading data in _lightlessGroupProfiles for Group {data}", data.AliasOrGID); _lightlessGroupProfiles[data] = _loadingProfileGroupData; var profile = await _apiController.GroupGetProfile(new API.Dto.Group.GroupDto(data)).ConfigureAwait(false); @@ -141,6 +166,7 @@ public class LightlessProfileManager : MediatorSubscriberBase Description: string.IsNullOrEmpty(profile.Description) ? _noGroupDescription : profile.Description, Tags: string.IsNullOrEmpty(profile.Tags) ? _noTags : profile.Tags); + _logger.LogTrace("Replacing data in _lightlessGroupProfiles for Group {data}", data.AliasOrGID); _lightlessGroupProfiles[data] = profileGroupData; } catch (Exception ex) diff --git a/LightlessSync/UI/JoinSyncshellUI.cs b/LightlessSync/UI/JoinSyncshellUI.cs index b02a84e..e4f7132 100644 --- a/LightlessSync/UI/JoinSyncshellUI.cs +++ b/LightlessSync/UI/JoinSyncshellUI.cs @@ -1,5 +1,5 @@ using Dalamud.Bindings.ImGui; -using Dalamud.Interface.Colors; +using Dalamud.Interface.Textures.TextureWraps; using Dalamud.Interface.Utility; using Dalamud.Interface.Utility.Raii; using LightlessSync.API.Data.Enum; @@ -11,18 +11,26 @@ using LightlessSync.Services.Mediator; using LightlessSync.Utils; using LightlessSync.WebAPI; using Microsoft.Extensions.Logging; +using System.Numerics; namespace LightlessSync.UI; internal class JoinSyncshellUI : WindowMediatorSubscriberBase { + private const string _lightlessLogo = "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"; + private const string _defaultDescription = "This Syncshell has no description set"; + private const string _defaultTags = "No Syncshell tags"; private readonly ApiController _apiController; private readonly UiSharedService _uiSharedService; private string _desiredSyncshellToJoin = string.Empty; private GroupJoinInfoDto? _groupJoinInfo = null; + private GroupProfileDto? _groupProfile = null; + private string _joinTitle = "Join Syncshell"; + private string _previousSyncshell = string.Empty; private DefaultPermissionsDto _ownPermissions = null!; private string _previousPassword = string.Empty; private string _syncshellPassword = string.Empty; + private IDalamudTextureWrap? _pfpTextureWrap; public JoinSyncshellUI(ILogger logger, LightlessMediator mediator, UiSharedService uiSharedService, ApiController apiController, PerformanceCollectorService performanceCollectorService) @@ -43,56 +51,80 @@ internal class JoinSyncshellUI : WindowMediatorSubscriberBase public override void OnOpen() { + _pfpTextureWrap?.Dispose(); _desiredSyncshellToJoin = string.Empty; + _previousSyncshell = string.Empty; _syncshellPassword = string.Empty; _previousPassword = string.Empty; + _joinTitle = "Join Syncshell"; _groupJoinInfo = null; + _groupProfile = null; _ownPermissions = _apiController.DefaultPermissions.DeepClone()!; } protected override void DrawInternal() { using (_uiSharedService.UidFont.Push()) - ImGui.TextUnformatted(_groupJoinInfo == null || !_groupJoinInfo.Success ? "Join Syncshell" : "Finalize join Syncshell " + _groupJoinInfo.GroupAliasOrGID); + ImGui.TextUnformatted(_joinTitle); ImGui.Separator(); - if (_groupJoinInfo == null || !_groupJoinInfo.Success) + if (_groupProfile == null) { UiSharedService.TextWrapped("Here you can join existing Syncshells. " + "Please keep in mind that you cannot join more than " + _apiController.ServerInfo.MaxGroupsJoinedByUser + " syncshells on this server." + Environment.NewLine + "Joining a Syncshell will pair you implicitly with all existing users in the Syncshell." + Environment.NewLine + "All permissions to all users in the Syncshell will be set to the preferred Syncshell permissions on joining, excluding prior set preferred permissions."); ImGui.Separator(); - ImGui.TextUnformatted("Note: Syncshell ID and Password are case sensitive. LLS- is part of Syncshell IDs, unless using Vanity IDs."); + ImGui.TextUnformatted("Note: Syncshell ID are case sensitive. LLS- is part of Syncshell IDs, unless using Vanity IDs."); ImGui.AlignTextToFramePadding(); ImGui.TextUnformatted("Syncshell ID"); ImGui.SameLine(200); ImGui.InputTextWithHint("##syncshellId", "Full Syncshell ID", ref _desiredSyncshellToJoin, 20); - ImGui.AlignTextToFramePadding(); - ImGui.TextUnformatted("Syncshell Password"); - ImGui.SameLine(200); - ImGui.InputTextWithHint("##syncshellpw", "Password", ref _syncshellPassword, 50, ImGuiInputTextFlags.Password); - using (ImRaii.Disabled(string.IsNullOrEmpty(_desiredSyncshellToJoin) || string.IsNullOrEmpty(_syncshellPassword))) + using (ImRaii.Disabled(string.IsNullOrEmpty(_desiredSyncshellToJoin))) { if (_uiSharedService.IconTextButton(Dalamud.Interface.FontAwesomeIcon.Plus, "Join Syncshell")) { - _groupJoinInfo = _apiController.GroupJoin(new GroupPasswordDto(new API.Data.GroupData(_desiredSyncshellToJoin), _syncshellPassword)).Result; - _previousPassword = _syncshellPassword; - _syncshellPassword = string.Empty; + _groupProfile = _apiController.GroupGetProfile(new GroupDto(new API.Data.GroupData(_desiredSyncshellToJoin))).Result; + _previousSyncshell = _desiredSyncshellToJoin; + _logger.LogInformation(_groupProfile.PictureBase64); + _logger.LogInformation(_groupProfile.Group.ToString()); } } - if (_groupJoinInfo != null && !_groupJoinInfo.Success) + if (!string.IsNullOrEmpty(_previousSyncshell) && _groupProfile == null) { - UiSharedService.ColorTextWrapped("Failed to join the Syncshell. This is due to one of following reasons:" + Environment.NewLine + + UiSharedService.ColorTextWrapped("Failed to find the Syncshell. This is due to one of following reasons:" + Environment.NewLine + "- The Syncshell does not exist or the password is incorrect" + Environment.NewLine + "- You are already in that Syncshell or are banned from that Syncshell" + Environment.NewLine + "- The Syncshell is at capacity or has invites disabled" + Environment.NewLine, UIColors.Get("LightlessYellow")); } } + else if (_groupProfile != null && (_groupJoinInfo == null || !_groupJoinInfo.Success)) + { + _joinTitle = "Joining Syncshell : " + _groupProfile.GroupAliasOrGID; + + //Fetching default or profile data + ImGui.Dummy(new Vector2(5)); + byte[]? profilePicture = string.IsNullOrEmpty(_groupProfile.PictureBase64) + ? Convert.FromBase64String(_lightlessLogo) + : Convert.FromBase64String(_groupProfile.PictureBase64); + string? profileDescription = string.IsNullOrEmpty(_groupProfile.Description) ? _defaultDescription : _groupProfile.Description; + string? profileTags = string.IsNullOrEmpty(_groupProfile.Description) ? _defaultTags : _groupProfile.Tags; + + _pfpTextureWrap?.Dispose(); + _pfpTextureWrap = _uiSharedService.LoadImage(profilePicture); + + if (_pfpTextureWrap != null) + { + ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height)); + } + + //Make profile show of group + } else { + _joinTitle = "Finalizing Syncshell : " + _groupJoinInfo.GroupAliasOrGID; ImGui.TextUnformatted("You are about to join the Syncshell " + _groupJoinInfo.GroupAliasOrGID + " by " + _groupJoinInfo.OwnerAliasOrUID); ImGuiHelpers.ScaledDummy(2f); ImGui.TextUnformatted("This Syncshell staff has set the following suggested Syncshell permissions:"); diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 5f70dde..6faf08a 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -69,7 +69,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase IsOpen = true; Mediator.Subscribe(this, (msg) => { - if (msg.GroupData == null || string.Equals(msg.GroupData.GID, GroupFullInfo.Group.GID, StringComparison.Ordinal)) + if (msg.GroupData == null || string.Equals(msg.GroupData.AliasOrGID, GroupFullInfo.Group.AliasOrGID, StringComparison.Ordinal)) { _pfpTextureWrap?.Dispose(); _pfpTextureWrap = null; @@ -87,15 +87,11 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase protected override void DrawInternal() { if (!_isModerator && !_isOwner) return; - //_logger.LogInformation("Drawing Syncshell Admin UI for {group}", GroupFullInfo.GroupAliasOrGID); + + _logger.LogTrace("Drawing Syncshell Admin UI for {group}", GroupFullInfo.GroupAliasOrGID); GroupFullInfo = _pairManager.Groups[GroupFullInfo.Group]; - - if (_lastProfileGroup == null || !_lastProfileGroup.Equals(GroupFullInfo.Group) || _profileData == null || ReferenceEquals(_profileData, _lightlessProfileManager.LoadingProfileGroupData)) - { - _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); - _lastProfileGroup = GroupFullInfo.Group; - } + _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); using var id = ImRaii.PushId("syncshell_admin_" + GroupFullInfo.GID); using (_uiSharedService.UidFont.Push()) @@ -294,14 +290,14 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase } using var image = Image.Load(fileContent); - if (image.Width > 256 || image.Height > 256 || (fileContent.Length > 250 * 1024)) + if (image.Width > 512 || image.Height > 512 || (fileContent.Length > 2000 * 1024)) { _showFileDialogError = true; return; } _showFileDialogError = false; - await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) + await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) .ConfigureAwait(false); } }); @@ -311,7 +307,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null)); } UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); if (_showFileDialogError) @@ -356,13 +352,13 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: _descriptionText, Tags: null, PictureBase64: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: _descriptionText, Tags: null, PictureBase64: null)); } UiSharedService.AttachToolTip("Sets your profile description text"); ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.GID), Description: null, Tags: null, PictureBase64: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null)); } UiSharedService.AttachToolTip("Clears your profile description text"); ImGui.TreePop(); @@ -386,7 +382,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { var tableFlags = ImGuiTableFlags.RowBg | ImGuiTableFlags.SizingStretchProp; if (pairs.Count > 10) tableFlags |= ImGuiTableFlags.ScrollY; - using var table = ImRaii.Table("userList#" + GroupFullInfo.Group.GID, 3, tableFlags); + using var table = ImRaii.Table("userList#" + GroupFullInfo.Group.AliasOrGID, 3, tableFlags); if (table) { ImGui.TableSetupColumn("Alias/UID/Note", ImGuiTableColumnFlags.None, 4); From a66a43dda8a16b5d3c569e3e5bb6029b767db711 Mon Sep 17 00:00:00 2001 From: choco Date: Wed, 15 Oct 2025 13:29:32 +0200 Subject: [PATCH 20/64] patch notes setup, added some of the older patchnotes into a changelog.yaml --- .../Configurations/LightlessConfig.cs | 1 + LightlessSync/LightlessPlugin.cs | 18 + LightlessSync/LightlessSync.csproj | 7 +- LightlessSync/Plugin.cs | 1 + LightlessSync/UI/Changelog/changelog.yaml | 180 ++++++++++ LightlessSync/UI/Changelog/contributors.txt | 1 + LightlessSync/UI/Changelog/credits.txt | 2 + LightlessSync/UI/Changelog/supporters.txt | 1 + LightlessSync/UI/UpdateNotesUi.cs | 332 ++++++++++++++++++ 9 files changed, 542 insertions(+), 1 deletion(-) create mode 100644 LightlessSync/UI/Changelog/changelog.yaml create mode 100644 LightlessSync/UI/Changelog/contributors.txt create mode 100644 LightlessSync/UI/Changelog/credits.txt create mode 100644 LightlessSync/UI/Changelog/supporters.txt create mode 100644 LightlessSync/UI/UpdateNotesUi.cs diff --git a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs index bdf8542..d66e956 100644 --- a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs +++ b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs @@ -146,4 +146,5 @@ public class LightlessConfig : ILightlessConfiguration public DateTime BroadcastTtl { get; set; } = DateTime.MinValue; public bool SyncshellFinderEnabled { get; set; } = false; public string? SelectedFinderSyncshell { get; set; } = null; + public string LastSeenVersion { get; set; } = string.Empty; } diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index 66d2c2b..4f9b226 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -155,6 +155,24 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService _runtimeServiceScope.ServiceProvider.GetRequiredService(); _runtimeServiceScope.ServiceProvider.GetRequiredService(); + // TODO: move this to a better place + var ver = Assembly.GetExecutingAssembly().GetName().Version; + var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}"; + var lastSeen = _lightlessConfigService.Current.LastSeenVersion ?? string.Empty; + Logger?.LogDebug("Last seen version: {lastSeen}, current version: {currentVersion}", lastSeen, currentVersion); + if (string.IsNullOrEmpty(lastSeen)) + { + _lightlessConfigService.Current.LastSeenVersion = currentVersion; + _lightlessConfigService.Save(); + } + else if (!string.Equals(lastSeen, currentVersion, StringComparison.Ordinal)) + { + // TODO: actually check if setup is complete + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + _lightlessConfigService.Current.LastSeenVersion = currentVersion; + _lightlessConfigService.Save(); + } + #if !DEBUG if (_lightlessConfigService.Current.LogLevel != LogLevel.Information) { diff --git a/LightlessSync/LightlessSync.csproj b/LightlessSync/LightlessSync.csproj index 5b31c88..b51bcd7 100644 --- a/LightlessSync/LightlessSync.csproj +++ b/LightlessSync/LightlessSync.csproj @@ -1,4 +1,4 @@ - + @@ -46,6 +46,7 @@ runtime; build; native; contentfiles; analyzers; buildtransitive + @@ -64,6 +65,10 @@ PreserveNewest + + + + diff --git a/LightlessSync/Plugin.cs b/LightlessSync/Plugin.cs index bac9e29..9ec4bed 100644 --- a/LightlessSync/Plugin.cs +++ b/LightlessSync/Plugin.cs @@ -246,6 +246,7 @@ public sealed class Plugin : IDalamudPlugin collection.AddScoped(); collection.AddScoped(); collection.AddScoped(); + collection.AddScoped(); collection.AddScoped((s) => new EditProfileUi(s.GetRequiredService>(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), diff --git a/LightlessSync/UI/Changelog/changelog.yaml b/LightlessSync/UI/Changelog/changelog.yaml new file mode 100644 index 0000000..c28a2c3 --- /dev/null +++ b/LightlessSync/UI/Changelog/changelog.yaml @@ -0,0 +1,180 @@ +tagline: "Lightless Sync v1.12.3" +subline: "FILLER" +changelog: + - name: "v1.12.3" + tagline: "FILLER" + date: "October 15th 2025" + is_current: true + versions: + - number: "New Features" + icon: "" + items: + - "New in-game Patch Notes window." + - "Credits section to thank contributors and supporters." + - "Patch notes only show after updates, not during first-time setup." + - number: "Notifications" + icon: "" + items: + - "More customizable notification options." + - "Perfomance limiter shows as notifications." + - "All notifications can be configured or disabled in Settings → Notifications." + + - name: "v1.12.2" + tagline: "LightFinder fixes, Notifications overhaul" + date: "October 12th 2025" + is_current: false + versions: + - number: "LightFinder" + icon: "" + items: + - "Server-side improvements for LightFinder functionality." + - "Command changed from '/light lightfinder' to '/light finder'." + - "Option to enable LightFinder on connection (opt-in, refreshes every 3 hours)." + - "LightFinder indicator can now be shown on the server info bar." + - number: "Notifications" + icon: "" + items: + - "Completely reworked notification system with new UI." + - "Pair requests now show as notifications." + - "Download progress shows as notifications." + - "Customizable notification sounds, size, position, and duration." + - "All notifications can be configured or disabled in Settings → Notifications." + - number: "Bug Fixes" + icon: "" + items: + - "Fixed nameplate alignment issues with LightFinder and icons." + - "Icons now properly apply instead of swapping on choice." + - "Updated Discord URL." + - "File cache logic improvements." + + - name: "v1.12.1" + tagline: "LightFinder customization and download limiter" + date: "October 8th 2025" + is_current: false + versions: + - number: "New Features" + icon: "" + items: + - "LightFinder text can be modified to an icon with customizable positioning." + - "Option to hide your own indicator or paired player indicators." + - "Pair Download Limiter: Limit simultaneous downloads to 1-6 users to reduce network strain." + - "Added '/light lightfinder' command to open LightFinder UI." + - number: "Improvements" + icon: "" + items: + - "Right-click menu option for Send Pair Request can be disabled." + - "Syncshell finder improvements." + - "Download limiter settings available in Settings → Transfers." + + - name: "v1.12.0" + tagline: "LightFinder - Major feature release" + date: "October 5th 2025" + is_current: false + versions: + - number: "Major Features" + icon: "" + items: + - "Introduced LightFinder: Optional feature inspired by FFXIV's Party Finder." + - "Find fellow Lightless users and advertise your Syncshell to others." + - "When enabled, you're visible to other LightFinder users for 3 hours." + - "LightFinder tag displays above your nameplate when active." + - "Receive pair requests directly in UI without exchanging UIDs." + - "Syncshell Finder allows joining indexed Syncshells." + - "[L] Send Pair Request added to player context menus." + - number: "Vanity Features" + icon: "" + items: + - "Supporters can now customize their name color in the Lightless UI." + - "Color changes visible to all users." + - number: "General Improvements" + icon: "" + items: + - "Pairing nameplate color override can now override FC tags." + - "Added .kdb as whitelisted filetype for uploads." + - "Various UI fixes, updates, and improvements." + + - name: "v1.11.12" + tagline: "Syncshell grouping and performance options" + date: "September 16th 2025" + is_current: false + versions: + - number: "New Features" + icon: "" + items: + - "Ability to show grouped syncshells in main UI/all syncshells (default ON)." + - "Transfer ownership button available in Admin Panel user list." + - "Self-threshold warning now opens character analysis screen when clicked." + - number: "Performance" + icon: "" + items: + - "Auto-pause combat and auto-pause performance are now optional settings." + - "Both options are auto-enabled by default - disable at your own risk." + - number: "Bug Fixes" + icon: "" + items: + - "Reworked file caching to reduce errors for some users." + - "Fixed bug where exiting PvP could desync some users." + + - name: "v1.11.9" + tagline: "File cache improvements" + date: "September 13th 2025" + is_current: false + versions: + - number: "Bug Fixes" + icon: "" + items: + - "Identified and fixed potential file cache problems." + - "Improved cache error handling and stability." + + - name: "v1.11.8" + tagline: "Hotfix - UI and exception handling" + date: "September 12th 2025" + is_current: false + versions: + - number: "Bug Fixes" + icon: "" + items: + - "Attempted fix for NullReferenceException spam." + - "Fixed additional UI edge cases preventing loading for some users." + - "Fixed color bar UI issues." + + - name: "v1.11.7" + tagline: "Hotfix - UI loading and warnings" + date: "September 12th 2025" + is_current: false + versions: + - number: "Bug Fixes" + icon: "" + items: + - "Fixed UI not loading for some users." + - "Self warnings now behind 'Warn on loading in players exceeding performance thresholds' setting." + + - name: "v1.11.6" + tagline: "Admin panel rework and new features" + date: "September 11th 2025" + is_current: false + versions: + - number: "New Features" + icon: "" + items: + - "Reworked Syncshell Admin Page with improved styling." + - "Right-click on Server Top Bar button to disconnect from Lightless." + - "Shift+Left click on Server Top Bar button to open settings." + - "Added colors section in settings to change accent colors." + - "Added pin option from Dalamud in the UI." + - "Ability to pause syncing while in Instance/Duty." + - "Functionality to create syncshell folders." + - "Added self-threshold warning." + - number: "Bug Fixes" + icon: "" + items: + - "Fixed owners being visible in moderator list view." + - "Removed Pin/Remove/Ban buttons on Owners when viewing as moderator." + - "Fixed nameplate bug in PvP." + - "Added 1 or 3 day options for inactive check." + + - name: "Template" + tagline: "" + date: "October 15th 2025" + is_current: false + message: "Thank you for using Lightless Sync!\n\nThis update brings quality of life improvements and polish to the user experience.\nWe're committed to helping you share your character with others seamlessly.\n\nIf you have any suggestions or encounter any issues, please let us know on Discord or GitHub!\n\n- The Lightless Team" diff --git a/LightlessSync/UI/Changelog/contributors.txt b/LightlessSync/UI/Changelog/contributors.txt new file mode 100644 index 0000000..fabb456 --- /dev/null +++ b/LightlessSync/UI/Changelog/contributors.txt @@ -0,0 +1 @@ +[Add contributor names - GitHub handles, etc.] diff --git a/LightlessSync/UI/Changelog/credits.txt b/LightlessSync/UI/Changelog/credits.txt new file mode 100644 index 0000000..4e2fe79 --- /dev/null +++ b/LightlessSync/UI/Changelog/credits.txt @@ -0,0 +1,2 @@ +UI design inspired by Brio's update window (Etheirys/Brio). Thanks to their team for the great UX ideas. +Special thanks to the Dalamud team and the XIV modding ecosystem for tooling & APIs. diff --git a/LightlessSync/UI/Changelog/supporters.txt b/LightlessSync/UI/Changelog/supporters.txt new file mode 100644 index 0000000..f8a29df --- /dev/null +++ b/LightlessSync/UI/Changelog/supporters.txt @@ -0,0 +1 @@ +[Your Names Here] diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs new file mode 100644 index 0000000..57c8ef6 --- /dev/null +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -0,0 +1,332 @@ +using Dalamud.Bindings.ImGui; +using Dalamud.Interface.Utility; +using Dalamud.Interface.Utility.Raii; +using Dalamud.Utility; +using LightlessSync.LightlessConfiguration; +using LightlessSync.Services; +using LightlessSync.Services.Mediator; +using Microsoft.Extensions.Logging; +using System.IO; +using System.Numerics; +using System.Reflection; +using System.Text; +using YamlDotNet.Serialization; +using YamlDotNet.Serialization.NamingConventions; + +namespace LightlessSync.UI; + +public class UpdateNotesUi : WindowMediatorSubscriberBase +{ + private readonly LightlessConfigService _configService; + private readonly UiSharedService _uiShared; + + private readonly List _contributors = []; + private readonly List _credits = []; + private readonly List _supporters = []; + + private ChangelogFile _changelog = new(); + private bool _scrollToTop; + private int _selectedTab; + + public UpdateNotesUi(ILogger logger, + LightlessMediator mediator, + UiSharedService uiShared, + LightlessConfigService configService, + PerformanceCollectorService performanceCollectorService) + : base(logger, mediator, "Lightless Sync — Update Notes", performanceCollectorService) + { + _configService = configService; + _uiShared = uiShared; + + AllowClickthrough = false; + AllowPinning = false; + RespectCloseHotkey = true; + ShowCloseButton = true; + + Flags = ImGuiWindowFlags.NoSavedSettings | ImGuiWindowFlags.NoResize | ImGuiWindowFlags.NoCollapse; + + SizeConstraints = new WindowSizeConstraints() + { + MinimumSize = new Vector2(600, 500), + MaximumSize = new Vector2(900, 2000), + }; + + LoadEmbeddedResources(); + } + + public override void OnOpen() + { + _scrollToTop = true; + } + + protected override void DrawInternal() + { + if (_uiShared.IsInGpose) + return; + + DrawHeader(); + DrawLinkButtons(); + ImGuiHelpers.ScaledDummy(6); + DrawTabs(); + DrawCloseButton(); + } + + private void DrawHeader() + { + using (_uiShared.UidFont.Push()) + { + ImGui.TextUnformatted("Lightless Sync"); + } + + _uiShared.ColoredSeparator(UIColors.Get("LightlessBlue"), thickness: 2f); + + if (!string.IsNullOrEmpty(_changelog.Tagline)) + { + _uiShared.MediumText(_changelog.Tagline, UIColors.Get("LightlessBlue")); + if (!string.IsNullOrEmpty(_changelog.Subline)) + { + ImGui.SameLine(); + ImGui.TextColored(new Vector4(.75f, .75f, .85f, 1f), $" – {_changelog.Subline}"); + } + } + + ImGuiHelpers.ScaledDummy(5); + } + + private void DrawLinkButtons() + { + var segmentSize = ImGui.GetWindowSize().X / 4.2f; + var buttonSize = new Vector2(segmentSize, ImGui.GetTextLineHeight() * 1.6f); + + if (ImGui.Button("Discord", buttonSize)) + Util.OpenLink("https://discord.gg/dsbjcXMnhA"); + ImGui.SameLine(); + + if (ImGui.Button("GitHub", buttonSize)) + Util.OpenLink("https://github.com/Light-Public-Syncshells/LightlessSync"); + ImGui.SameLine(); + + if (ImGui.Button("Ko-fi", buttonSize)) + Util.OpenLink("https://ko-fi.com/lightlesssync"); + ImGui.SameLine(); + + if (ImGui.Button("More Links", buttonSize)) + Util.OpenLink("https://lightless.link"); + } + + private void DrawCloseButton() + { + var closeWidth = 300f * ImGuiHelpers.GlobalScale; + ImGui.SetCursorPosX((ImGui.GetWindowSize().X - closeWidth) / 2); + if (ImGui.Button("Close", new Vector2(closeWidth, 0))) + { + IsOpen = false; + } + } + + private void DrawTabs() + { + using var tabBar = ImRaii.TabBar("lightless_update_tabs"); + if (!tabBar) + return; + + using (var changelogTab = ImRaii.TabItem(" Changelog ")) + { + if (changelogTab) + { + _selectedTab = 0; + DrawChangelog(); + } + } + + using (var creditsTab = ImRaii.TabItem(" Supporters & Credits ")) + { + if (creditsTab) + { + _selectedTab = 1; + DrawCredits(); + } + } + } + + private void DrawChangelog() + { + using var child = ImRaii.Child("###ll_changelog", new Vector2(0, ImGui.GetContentRegionAvail().Y - 44), false); + if (!child) + return; + + if (_scrollToTop) + { + _scrollToTop = false; + ImGui.SetScrollHereY(0); + } + + foreach (var entry in _changelog.Changelog) + DrawChangelogEntry(entry); + + ImGui.Spacing(); + } + + private void DrawChangelogEntry(ChangelogEntry entry) + { + var currentColor = entry.IsCurrent == true + ? new Vector4(0.5f, 0.9f, 0.5f, 1.0f) + : new Vector4(0.75f, 0.75f, 0.85f, 1.0f); + + bool isOpen; + using (ImRaii.PushColor(ImGuiCol.Text, currentColor)) + { + isOpen = ImGui.CollapsingHeader($" {entry.Name} — {entry.Date} "); + } + + ImGui.SameLine(); + ImGui.TextColored(new Vector4(0.75f, 0.75f, 0.85f, 1.0f), $" — {entry.Tagline}"); + + if (!isOpen) + return; + + ImGuiHelpers.ScaledDummy(5); + + if (!string.IsNullOrEmpty(entry.Message)) + { + ImGui.TextWrapped(entry.Message); + ImGuiHelpers.ScaledDummy(5); + return; + } + + if (entry.Versions != null) + { + foreach (var version in entry.Versions) + { + DrawFeatureHeader(version.Number, new Vector4(0.5f, 0.9f, 0.5f, 1.0f)); + foreach (var item in version.Items) + ImGui.BulletText(item); + } + } + + ImGuiHelpers.ScaledDummy(5); + } + + private static void DrawFeatureHeader(string title, Vector4 accentColor) + { + var drawList = ImGui.GetWindowDrawList(); + var startPos = ImGui.GetCursorScreenPos(); + + var backgroundMin = startPos + new Vector2(-10, -5); + var backgroundMax = startPos + new Vector2(ImGui.GetContentRegionAvail().X + 10, 25); + drawList.AddRectFilled(backgroundMin, backgroundMax, ImGui.GetColorU32(new Vector4(0.12f, 0.12f, 0.15f, 0.6f)), 4f); + drawList.AddRectFilled(backgroundMin, backgroundMin + new Vector2(3, backgroundMax.Y - backgroundMin.Y), ImGui.GetColorU32(accentColor), 2f); + + ImGui.Spacing(); + ImGui.TextColored(accentColor, title); + ImGui.Spacing(); + } + + private void DrawCredits() + { + ImGui.TextUnformatted("Maintained & Developed by the Lightless Sync team."); + ImGui.TextUnformatted("Thank you to all supporters and contributors!"); + ImGuiHelpers.ScaledDummy(5); + + var availableRegion = ImGui.GetContentRegionAvail(); + var halfWidth = new Vector2( + availableRegion.X / 2f - ImGui.GetStyle().ItemSpacing.X / 2f, + availableRegion.Y - 120 * ImGuiHelpers.GlobalScale); + + using (var leftChild = ImRaii.Child("left_supporters", halfWidth)) + { + if (leftChild) + { + ImGui.TextUnformatted("Supporters (Ko-fi / Patreon)"); + _uiShared.RoundedSeparator(UIColors.Get("LightlessBlue"), thickness: 2f); + foreach (var supporter in _supporters) + ImGui.BulletText(supporter); + } + } + + ImGui.SameLine(); + + using (var rightChild = ImRaii.Child("right_contributors", halfWidth)) + { + if (rightChild) + { + ImGui.TextUnformatted("Contributors"); + _uiShared.RoundedSeparator(UIColors.Get("LightlessBlue"), thickness: 2f); + foreach (var contributor in _contributors) + ImGui.BulletText(contributor); + } + } + + ImGuiHelpers.ScaledDummy(8); + ImGui.TextUnformatted("Credits"); + _uiShared.RoundedSeparator(UIColors.Get("LightlessYellow"), thickness: 2f); + foreach (var credit in _credits) + ImGui.BulletText(credit); + } + + private void LoadEmbeddedResources() + { + try + { + var assembly = Assembly.GetExecutingAssembly(); + + ReadLines(assembly, "LightlessSync.UI.Changelog.supporters.txt", _supporters); + ReadLines(assembly, "LightlessSync.UI.Changelog.contributors.txt", _contributors); + ReadLines(assembly, "LightlessSync.UI.Changelog.credits.txt", _credits); + + using var changelogStream = assembly.GetManifestResourceStream("LightlessSync.UI.Changelog.changelog.yaml"); + if (changelogStream != null) + { + using var reader = new StreamReader(changelogStream, Encoding.UTF8, true, 128); + var yaml = reader.ReadToEnd(); + var deserializer = new DeserializerBuilder() + .WithNamingConvention(CamelCaseNamingConvention.Instance) + .IgnoreUnmatchedProperties() + .Build(); + _changelog = deserializer.Deserialize(yaml) ?? new(); + } + } + catch + { + // Ignore - window will gracefully render with defaults + } + } + + private static void ReadLines(Assembly assembly, string resourceName, List target) + { + using var stream = assembly.GetManifestResourceStream(resourceName); + if (stream == null) + return; + + using var reader = new StreamReader(stream, Encoding.UTF8, true, 128); + string? line; + while ((line = reader.ReadLine()) != null) + { + if (!string.IsNullOrWhiteSpace(line)) + target.Add(line.Trim()); + } + } + + private sealed record ChangelogFile + { + public string Tagline { get; init; } = string.Empty; + public string Subline { get; init; } = string.Empty; + public List Changelog { get; init; } = new(); + } + + private sealed record ChangelogEntry + { + public string Name { get; init; } = string.Empty; + public string Date { get; init; } = string.Empty; + public string Tagline { get; init; } = string.Empty; + public bool? IsCurrent { get; init; } + public string? Message { get; init; } + public List? Versions { get; init; } + } + + private sealed record ChangelogVersion + { + public string Number { get; init; } = string.Empty; + public List Items { get; init; } = new(); + } +} From 04c00af92eacfaa9db6fa16aa3d23318f4c68b67 Mon Sep 17 00:00:00 2001 From: choco Date: Wed, 15 Oct 2025 16:37:56 +0200 Subject: [PATCH 21/64] check if completed intro setup process --- LightlessSync/LightlessPlugin.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index 4f9b226..c431419 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -167,8 +167,10 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService } else if (!string.Equals(lastSeen, currentVersion, StringComparison.Ordinal)) { - // TODO: actually check if setup is complete - Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + if (_lightlessConfigService.Current.HasValidSetup() && _serverConfigurationManager.HasValidConfig()) + { + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + } _lightlessConfigService.Current.LastSeenVersion = currentVersion; _lightlessConfigService.Save(); } From d5c12e81c3b36472a842f38ae832110c2546e08d Mon Sep 17 00:00:00 2001 From: choco Date: Wed, 15 Oct 2025 22:59:08 +0200 Subject: [PATCH 22/64] banner with particles --- LightlessSync/LightlessPlugin.cs | 2 + LightlessSync/UI/UpdateNotesUi.cs | 742 ++++++++++++++++++++++++------ 2 files changed, 611 insertions(+), 133 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index c431419..dcc1990 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -160,6 +160,8 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}"; var lastSeen = _lightlessConfigService.Current.LastSeenVersion ?? string.Empty; Logger?.LogDebug("Last seen version: {lastSeen}, current version: {currentVersion}", lastSeen, currentVersion); + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + if (string.IsNullOrEmpty(lastSeen)) { _lightlessConfigService.Current.LastSeenVersion = currentVersion; diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index 57c8ef6..83ac903 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -12,6 +12,7 @@ using System.Reflection; using System.Text; using YamlDotNet.Serialization; using YamlDotNet.Serialization.NamingConventions; +using Dalamud.Interface; namespace LightlessSync.UI; @@ -27,6 +28,36 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase private ChangelogFile _changelog = new(); private bool _scrollToTop; private int _selectedTab; + + // Particle system for visual effects + private struct Particle + { + public Vector2 Position; + public Vector2 Velocity; + public float Life; + public float MaxLife; + public float Size; + public Vector4 Color; + public ParticleType Type; + public float Rotation; + public float RotationSpeed; + public List? Trail; + public bool IsLargeMoon; + } + + private enum ParticleType + { + Star, + Moon, + Sparkle, + FastFallingStar + } + + private readonly List _particles = []; + private float _particleTimer; + private readonly Random _particleRandom = new(); + private Particle? _largeMoon; + private float _largeMoonTimer; public UpdateNotesUi(ILogger logger, LightlessMediator mediator, @@ -43,12 +74,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase RespectCloseHotkey = true; ShowCloseButton = true; - Flags = ImGuiWindowFlags.NoSavedSettings | ImGuiWindowFlags.NoResize | ImGuiWindowFlags.NoCollapse; + Flags = ImGuiWindowFlags.NoSavedSettings | ImGuiWindowFlags.NoResize | ImGuiWindowFlags.NoCollapse | ImGuiWindowFlags.NoTitleBar; SizeConstraints = new WindowSizeConstraints() { - MinimumSize = new Vector2(600, 500), - MaximumSize = new Vector2(900, 2000), + MinimumSize = new Vector2(800, 700), + MaximumSize = new Vector2(800, 700), }; LoadEmbeddedResources(); @@ -65,118 +96,577 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase return; DrawHeader(); - DrawLinkButtons(); ImGuiHelpers.ScaledDummy(6); - DrawTabs(); + DrawChangelog(); DrawCloseButton(); } private void DrawHeader() { - using (_uiShared.UidFont.Push()) + var windowPos = ImGui.GetWindowPos(); + var windowPadding = ImGui.GetStyle().WindowPadding; + var headerWidth = (800f * ImGuiHelpers.GlobalScale) - (windowPadding.X * 2); + var headerHeight = 140f * ImGuiHelpers.GlobalScale; + + var headerStart = windowPos + new Vector2(windowPadding.X, windowPadding.Y); + var headerEnd = headerStart + new Vector2(headerWidth, headerHeight); + + DrawGradientBackground(headerStart, headerEnd); + DrawParticleEffects(headerStart, new Vector2(headerWidth, headerHeight)); + DrawHeaderText(headerStart); + DrawHeaderButtons(headerStart, headerWidth); + + ImGui.SetCursorPosY(windowPadding.Y + headerHeight + 5); + + // Version badge with icon + ImGui.SetCursorPosX(12); + using (ImRaii.PushFont(UiBuilder.IconFont)) { - ImGui.TextUnformatted("Lightless Sync"); + ImGui.TextColored(UIColors.Get("LightlessGreen"), FontAwesomeIcon.Star.ToIconString()); } - - _uiShared.ColoredSeparator(UIColors.Get("LightlessBlue"), thickness: 2f); - + ImGui.SameLine(); + + ImGui.TextColored(UIColors.Get("LightlessGreen"), "What's New"); + if (!string.IsNullOrEmpty(_changelog.Tagline)) { - _uiShared.MediumText(_changelog.Tagline, UIColors.Get("LightlessBlue")); + ImGui.SameLine(); + ImGui.SetCursorPosX(ImGui.GetCursorPosX() + 10); + ImGui.TextColored(new Vector4(0.75f, 0.75f, 0.85f, 1.0f), _changelog.Tagline); + if (!string.IsNullOrEmpty(_changelog.Subline)) { ImGui.SameLine(); - ImGui.TextColored(new Vector4(.75f, .75f, .85f, 1f), $" – {_changelog.Subline}"); + ImGui.TextColored(new Vector4(0.65f, 0.65f, 0.75f, 1.0f), $" – {_changelog.Subline}"); } } - - ImGuiHelpers.ScaledDummy(5); + + ImGui.Separator(); + ImGuiHelpers.ScaledDummy(3); } - - private void DrawLinkButtons() + + private void DrawGradientBackground(Vector2 headerStart, Vector2 headerEnd) { - var segmentSize = ImGui.GetWindowSize().X / 4.2f; - var buttonSize = new Vector2(segmentSize, ImGui.GetTextLineHeight() * 1.6f); - - if (ImGui.Button("Discord", buttonSize)) - Util.OpenLink("https://discord.gg/dsbjcXMnhA"); - ImGui.SameLine(); - - if (ImGui.Button("GitHub", buttonSize)) - Util.OpenLink("https://github.com/Light-Public-Syncshells/LightlessSync"); - ImGui.SameLine(); - - if (ImGui.Button("Ko-fi", buttonSize)) - Util.OpenLink("https://ko-fi.com/lightlesssync"); - ImGui.SameLine(); - - if (ImGui.Button("More Links", buttonSize)) - Util.OpenLink("https://lightless.link"); + var drawList = ImGui.GetWindowDrawList(); + + // Dark night sky background with stars pattern + var darkPurple = new Vector4(0.08f, 0.05f, 0.15f, 1.0f); + var deepPurple = new Vector4(0.12f, 0.08f, 0.20f, 1.0f); + + drawList.AddRectFilledMultiColor( + headerStart, + headerEnd, + ImGui.GetColorU32(darkPurple), + ImGui.GetColorU32(darkPurple), + ImGui.GetColorU32(deepPurple), + ImGui.GetColorU32(deepPurple) + ); + + // Add some static "distant stars" for depth + var random = new Random(42); // Fixed seed for consistent pattern + for (int i = 0; i < 50; i++) + { + var starPos = headerStart + new Vector2( + (float)random.NextDouble() * (headerEnd.X - headerStart.X), + (float)random.NextDouble() * (headerEnd.Y - headerStart.Y) + ); + var brightness = 0.3f + (float)random.NextDouble() * 0.4f; + drawList.AddCircleFilled(starPos, 1f, ImGui.GetColorU32(new Vector4(1f, 1f, 1f, brightness))); + } + + // Accent border at bottom with glow + drawList.AddLine( + new Vector2(headerStart.X, headerEnd.Y), + headerEnd, + ImGui.GetColorU32(UIColors.Get("LightlessPurple")), + 2f + ); } + + private void DrawHeaderText(Vector2 headerStart) + { + // Title text overlay - drawn after particles so it's on top + ImGui.SetCursorScreenPos(headerStart + new Vector2(20, 30)); + + using (_uiShared.UidFont.Push()) + { + ImGui.TextColored(new Vector4(0.95f, 0.95f, 0.95f, 1.0f), "Lightless Sync"); + } + + ImGui.SetCursorScreenPos(headerStart + new Vector2(20, 75)); + ImGui.TextColored(UIColors.Get("LightlessBlue"), "Update Notes"); + } + + private void DrawHeaderButtons(Vector2 headerStart, float headerWidth) + { + var buttonSize = _uiShared.GetIconButtonSize(FontAwesomeIcon.Globe); + var spacing = 8f * ImGuiHelpers.GlobalScale; + var rightPadding = 15f * ImGuiHelpers.GlobalScale; + var topPadding = 15f * ImGuiHelpers.GlobalScale; + + // Position for buttons in top right + var buttonY = headerStart.Y + topPadding; + var gitButtonX = headerStart.X + headerWidth - rightPadding - buttonSize.X; + var discordButtonX = gitButtonX - buttonSize.X - spacing; + + ImGui.SetCursorScreenPos(new Vector2(discordButtonX, buttonY)); + + using (ImRaii.PushColor(ImGuiCol.Button, new Vector4(0, 0, 0, 0))) + using (ImRaii.PushColor(ImGuiCol.ButtonHovered, UIColors.Get("LightlessPurple") with { W = 0.3f })) + using (ImRaii.PushColor(ImGuiCol.ButtonActive, UIColors.Get("LightlessPurpleActive") with { W = 0.5f })) + { + if (_uiShared.IconButton(FontAwesomeIcon.Comments)) + { + Util.OpenLink("https://discord.gg/dsbjcXMnhA"); + } + if (ImGui.IsItemHovered()) + { + ImGui.SetTooltip("Join our Discord"); + } + + ImGui.SetCursorScreenPos(new Vector2(gitButtonX, buttonY)); + if (_uiShared.IconButton(FontAwesomeIcon.Code)) + { + Util.OpenLink("https://git.lightless-sync.org/Lightless-Sync"); + } + if (ImGui.IsItemHovered()) + { + ImGui.SetTooltip("View on Git"); + } + } + } + + private void DrawParticleEffects(Vector2 bannerStart, Vector2 bannerSize) + { + var deltaTime = ImGui.GetIO().DeltaTime; + _particleTimer += deltaTime; + _largeMoonTimer += deltaTime; + + // Spawn new particles + if (_particleTimer > 0.3f && _particles.Count < 30) + { + SpawnParticle(bannerStart, bannerSize); + _particleTimer = 0f; + } + + // Spawn or update large moon + if (_largeMoon == null || _largeMoonTimer > 45f) + { + SpawnLargeMoon(bannerStart, bannerSize); + _largeMoonTimer = 0f; + } + + var drawList = ImGui.GetWindowDrawList(); + + // Update and draw large moon first (background layer) + if (_largeMoon != null) + { + var moon = _largeMoon.Value; + moon.Position += moon.Velocity * deltaTime; + moon.Life -= deltaTime; + + // Keep moon within banner bounds with padding + var padding = moon.Size + 10; + if (moon.Life <= 0 || + moon.Position.X < bannerStart.X - padding || + moon.Position.X > bannerStart.X + bannerSize.X + padding || + moon.Position.Y < bannerStart.Y - padding || + moon.Position.Y > bannerStart.Y + bannerSize.Y + padding) + { + _largeMoon = null; + } + else + { + float alpha = Math.Min(1f, moon.Life / moon.MaxLife); + var color = moon.Color with { W = moon.Color.W * alpha }; + DrawMoon(drawList, moon.Position, moon.Size, color); + _largeMoon = moon; + } + } + + // Update and draw regular particles + for (int i = _particles.Count - 1; i >= 0; i--) + { + var particle = _particles[i]; + + // Update trail for stars + if ((particle.Type == ParticleType.Star || particle.Type == ParticleType.FastFallingStar) && particle.Trail != null) + { + particle.Trail.Insert(0, particle.Position); + var maxTrailLength = particle.Type == ParticleType.FastFallingStar ? 15 : 8; + if (particle.Trail.Count > maxTrailLength) + particle.Trail.RemoveAt(particle.Trail.Count - 1); + } + + particle.Position += particle.Velocity * deltaTime; + particle.Life -= deltaTime; + particle.Rotation += particle.RotationSpeed * deltaTime; + + if (particle.Life <= 0 || + particle.Position.X > bannerStart.X + bannerSize.X + 50 || + particle.Position.X < bannerStart.X - 50 || + particle.Position.Y < bannerStart.Y - 50 || + particle.Position.Y > bannerStart.Y + bannerSize.Y + 50) + { + _particles.RemoveAt(i); + continue; + } + + float alpha = Math.Min(1f, particle.Life / particle.MaxLife); + var color = particle.Color with { W = particle.Color.W * alpha }; + + // Draw trail for stars + if ((particle.Type == ParticleType.Star || particle.Type == ParticleType.FastFallingStar) && particle.Trail != null && particle.Trail.Count > 1) + { + for (int t = 1; t < particle.Trail.Count; t++) + { + float trailAlpha = alpha * (1f - (t / (float)particle.Trail.Count)) * (particle.Type == ParticleType.FastFallingStar ? 0.7f : 0.5f); + var trailColor = color with { W = trailAlpha }; + float thickness = particle.Type == ParticleType.FastFallingStar ? 2.5f : 1.5f; + drawList.AddLine( + particle.Trail[t - 1], + particle.Trail[t], + ImGui.GetColorU32(trailColor), + thickness + ); + } + } + + // Draw based on particle type + switch (particle.Type) + { + case ParticleType.Star: + case ParticleType.FastFallingStar: + DrawStar(drawList, particle.Position, particle.Size, color, particle.Rotation); + break; + case ParticleType.Moon: + DrawMoon(drawList, particle.Position, particle.Size, color); + break; + case ParticleType.Sparkle: + DrawSparkle(drawList, particle.Position, particle.Size, color, particle.Rotation); + break; + } + + _particles[i] = particle; + } + } + + private void DrawStar(ImDrawListPtr drawList, Vector2 position, float size, Vector4 color, float rotation) + { + // Draw a 5-pointed star + var points = new Vector2[10]; + for (int i = 0; i < 10; i++) + { + float angle = (i * MathF.PI / 5) + rotation; + float radius = (i % 2 == 0) ? size : size * 0.4f; + points[i] = position + new Vector2(MathF.Cos(angle) * radius, MathF.Sin(angle) * radius); + } + + // Draw filled star + for (int i = 0; i < 5; i++) + { + drawList.AddTriangleFilled( + position, + points[i * 2], + points[(i * 2 + 2) % 10], + ImGui.GetColorU32(color) + ); + } + + // Glow effect + var glowColor = color with { W = color.W * 0.3f }; + drawList.AddCircleFilled(position, size * 1.5f, ImGui.GetColorU32(glowColor)); + } + + private void DrawMoon(ImDrawListPtr drawList, Vector2 position, float size, Vector4 color) + { + // Enhanced glow for larger moons + var glowRadius = size > 15f ? 2.5f : 1.8f; + var glowColor = color with { W = color.W * (size > 15f ? 0.15f : 0.25f) }; + drawList.AddCircleFilled(position, size * glowRadius, ImGui.GetColorU32(glowColor)); + + // Draw crescent moon + drawList.AddCircleFilled(position, size, ImGui.GetColorU32(color)); + + // Draw shadow circle to create crescent + var shadowColor = new Vector4(0.08f, 0.05f, 0.15f, 1.0f); + drawList.AddCircleFilled(position + new Vector2(size * 0.4f, 0), size * 0.8f, ImGui.GetColorU32(shadowColor)); + + // Additional glow layer for large moons + if (size > 15f) + { + var outerGlow = color with { W = color.W * 0.08f }; + drawList.AddCircleFilled(position, size * 3.5f, ImGui.GetColorU32(outerGlow)); + } + } + + private void DrawSparkle(ImDrawListPtr drawList, Vector2 position, float size, Vector4 color, float rotation) + { + // Draw a 4-pointed sparkle (plus shape) + var thickness = size * 0.3f; + + // Horizontal line + drawList.AddLine( + position + new Vector2(-size, 0), + position + new Vector2(size, 0), + ImGui.GetColorU32(color), + thickness + ); + + // Vertical line + drawList.AddLine( + position + new Vector2(0, -size), + position + new Vector2(0, size), + ImGui.GetColorU32(color), + thickness + ); + + // Center glow + drawList.AddCircleFilled(position, size * 0.4f, ImGui.GetColorU32(color)); + var glowColor = color with { W = color.W * 0.4f }; + drawList.AddCircleFilled(position, size * 1.2f, ImGui.GetColorU32(glowColor)); + } + + private void SpawnParticle(Vector2 bannerStart, Vector2 bannerSize) + { + var typeRoll = _particleRandom.Next(100); + var particleType = typeRoll switch + { + < 35 => ParticleType.Star, + < 50 => ParticleType.Moon, + < 65 => ParticleType.FastFallingStar, + _ => ParticleType.Sparkle + }; + + Vector2 position; + Vector2 velocity; + + // Stars: spawn from top, move diagonally down + if (particleType == ParticleType.Star) + { + // Spawn from top edge + position = new Vector2( + bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, + bannerStart.Y - 10 + ); + + // Move diagonally down (shooting star effect) + var angle = MathF.PI * 0.25f + (float)(_particleRandom.NextDouble() - 0.5) * 0.5f; // 45° ± variation + var speed = 30f + (float)_particleRandom.NextDouble() * 40f; + velocity = new Vector2(MathF.Cos(angle) * speed, MathF.Sin(angle) * speed); + } + // Fast falling stars: spawn from top, fall straight down very fast + else if (particleType == ParticleType.FastFallingStar) + { + // Spawn from top edge, random X position + position = new Vector2( + bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, + bannerStart.Y - 10 + ); + + // Fall almost straight down with slight horizontal drift + var horizontalDrift = -10f + (float)_particleRandom.NextDouble() * 20f; + var speed = 120f + (float)_particleRandom.NextDouble() * 80f; // Much faster! + velocity = new Vector2(horizontalDrift, speed); + } + // Moons: drift slowly across + else if (particleType == ParticleType.Moon) + { + // Spawn from left side + position = new Vector2( + bannerStart.X - 10, + bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y + ); + + // Drift slowly to the right with slight vertical movement + velocity = new Vector2( + 15f + (float)_particleRandom.NextDouble() * 10f, + -5f + (float)_particleRandom.NextDouble() * 10f + ); + } + // Sparkles: float gently + else + { + position = new Vector2( + bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, + bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y + ); + + velocity = new Vector2( + -5f + (float)_particleRandom.NextDouble() * 10f, + -5f + (float)_particleRandom.NextDouble() * 10f + ); + } + + var particle = new Particle + { + Position = position, + Velocity = velocity, + MaxLife = particleType switch + { + ParticleType.Star => 3f + (float)_particleRandom.NextDouble() * 2f, + ParticleType.Moon => 8f + (float)_particleRandom.NextDouble() * 4f, + ParticleType.FastFallingStar => 1.5f + (float)_particleRandom.NextDouble() * 1f, + _ => 6f + (float)_particleRandom.NextDouble() * 4f + }, + Size = particleType switch + { + ParticleType.Star => 2.5f + (float)_particleRandom.NextDouble() * 2f, + ParticleType.Moon => 3f + (float)_particleRandom.NextDouble() * 2f, + ParticleType.FastFallingStar => 3f + (float)_particleRandom.NextDouble() * 2f, + _ => 2f + (float)_particleRandom.NextDouble() * 2f + }, + Color = particleType switch + { + ParticleType.Star => new Vector4(1.0f, 1.0f, 0.9f, 0.9f), + ParticleType.Moon => UIColors.Get("LightlessBlue") with { W = 0.7f }, + ParticleType.FastFallingStar => new Vector4(1.0f, 0.95f, 0.85f, 1.0f), // Bright white-yellow + _ => UIColors.Get("LightlessPurple") with { W = 0.8f } + }, + Type = particleType, + Rotation = (float)_particleRandom.NextDouble() * MathF.PI * 2, + RotationSpeed = particleType == ParticleType.Star || particleType == ParticleType.FastFallingStar ? 2f : -0.5f + (float)_particleRandom.NextDouble() * 1f, + Trail = particleType == ParticleType.Star || particleType == ParticleType.FastFallingStar ? new List() : null, + IsLargeMoon = false + }; + + particle.Life = particle.MaxLife; + _particles.Add(particle); + } + + private void SpawnLargeMoon(Vector2 bannerStart, Vector2 bannerSize) + { + // Large moon travels across the banner like a celestial body + var spawnSide = _particleRandom.Next(4); + Vector2 position; + Vector2 velocity; + + switch (spawnSide) + { + case 0: + // Spawn from left, move to right + position = new Vector2( + bannerStart.X - 50, + bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y + ); + velocity = new Vector2( + 15f + (float)_particleRandom.NextDouble() * 10f, + -5f + (float)_particleRandom.NextDouble() * 10f + ); + break; + case 1: + // Spawn from top, move down and across + position = new Vector2( + bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, + bannerStart.Y - 50 + ); + velocity = new Vector2( + -5f + (float)_particleRandom.NextDouble() * 10f, + 10f + (float)_particleRandom.NextDouble() * 8f + ); + break; + case 2: + // Spawn from right, move to left + position = new Vector2( + bannerStart.X + bannerSize.X + 50, + bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y + ); + velocity = new Vector2( + -(15f + (float)_particleRandom.NextDouble() * 10f), + -5f + (float)_particleRandom.NextDouble() * 10f + ); + break; + default: + // Spawn from top-left corner, move diagonally + position = new Vector2( + bannerStart.X - 30, + bannerStart.Y - 30 + ); + velocity = new Vector2( + 12f + (float)_particleRandom.NextDouble() * 8f, + 12f + (float)_particleRandom.NextDouble() * 8f + ); + break; + } + + _largeMoon = new Particle + { + Position = position, + Velocity = velocity, + MaxLife = 40f, + Life = 40f, + Size = 25f + (float)_particleRandom.NextDouble() * 10f, + Color = UIColors.Get("LightlessBlue") with { W = 0.35f }, + Type = ParticleType.Moon, + Rotation = 0, + RotationSpeed = 0, + Trail = null, + IsLargeMoon = true + }; + } + private void DrawCloseButton() { - var closeWidth = 300f * ImGuiHelpers.GlobalScale; + ImGuiHelpers.ScaledDummy(5); + + var closeWidth = 200f * ImGuiHelpers.GlobalScale; + var closeHeight = 35f * ImGuiHelpers.GlobalScale; ImGui.SetCursorPosX((ImGui.GetWindowSize().X - closeWidth) / 2); - if (ImGui.Button("Close", new Vector2(closeWidth, 0))) + + using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 8f)) + using (ImRaii.PushColor(ImGuiCol.Button, UIColors.Get("LightlessPurple"))) + using (ImRaii.PushColor(ImGuiCol.ButtonHovered, UIColors.Get("LightlessPurpleActive"))) + using (ImRaii.PushColor(ImGuiCol.ButtonActive, UIColors.Get("ButtonDefault"))) { - IsOpen = false; - } - } - - private void DrawTabs() - { - using var tabBar = ImRaii.TabBar("lightless_update_tabs"); - if (!tabBar) - return; - - using (var changelogTab = ImRaii.TabItem(" Changelog ")) - { - if (changelogTab) + if (ImGui.Button("Got it!", new Vector2(closeWidth, closeHeight))) { - _selectedTab = 0; - DrawChangelog(); - } - } - - using (var creditsTab = ImRaii.TabItem(" Supporters & Credits ")) - { - if (creditsTab) - { - _selectedTab = 1; - DrawCredits(); + IsOpen = false; } } } - private void DrawChangelog() { - using var child = ImRaii.Child("###ll_changelog", new Vector2(0, ImGui.GetContentRegionAvail().Y - 44), false); - if (!child) - return; - - if (_scrollToTop) + using (ImRaii.PushStyle(ImGuiStyleVar.ChildRounding, 6f)) + using (var child = ImRaii.Child("###ll_changelog", new Vector2(0, ImGui.GetContentRegionAvail().Y - 60), false, ImGuiWindowFlags.AlwaysVerticalScrollbar)) { - _scrollToTop = false; - ImGui.SetScrollHereY(0); + if (!child) + return; + + if (_scrollToTop) + { + _scrollToTop = false; + ImGui.SetScrollHereY(0); + } + + ImGui.PushTextWrapPos(); + + foreach (var entry in _changelog.Changelog) + DrawChangelogEntry(entry); + + ImGui.PopTextWrapPos(); + ImGui.Spacing(); } - - foreach (var entry in _changelog.Changelog) - DrawChangelogEntry(entry); - - ImGui.Spacing(); } private void DrawChangelogEntry(ChangelogEntry entry) { var currentColor = entry.IsCurrent == true - ? new Vector4(0.5f, 0.9f, 0.5f, 1.0f) + ? UIColors.Get("LightlessGreen") : new Vector4(0.75f, 0.75f, 0.85f, 1.0f); bool isOpen; + var flags = entry.IsCurrent == true + ? ImGuiTreeNodeFlags.DefaultOpen + : ImGuiTreeNodeFlags.None; + + using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 4f)) + using (ImRaii.PushColor(ImGuiCol.Header, UIColors.Get("ButtonDefault"))) + using (ImRaii.PushColor(ImGuiCol.HeaderHovered, UIColors.Get("LightlessPurple"))) + using (ImRaii.PushColor(ImGuiCol.HeaderActive, UIColors.Get("LightlessPurpleActive"))) using (ImRaii.PushColor(ImGuiCol.Text, currentColor)) { - isOpen = ImGui.CollapsingHeader($" {entry.Name} — {entry.Date} "); + isOpen = ImGui.CollapsingHeader($" {entry.Name} — {entry.Date} ", flags); } ImGui.SameLine(); @@ -185,12 +675,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase if (!isOpen) return; - ImGuiHelpers.ScaledDummy(5); + ImGuiHelpers.ScaledDummy(8); if (!string.IsNullOrEmpty(entry.Message)) { ImGui.TextWrapped(entry.Message); - ImGuiHelpers.ScaledDummy(5); + ImGuiHelpers.ScaledDummy(8); return; } @@ -198,70 +688,56 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase { foreach (var version in entry.Versions) { - DrawFeatureHeader(version.Number, new Vector4(0.5f, 0.9f, 0.5f, 1.0f)); + DrawFeatureSection(version.Number, UIColors.Get("LightlessGreen")); + foreach (var item in version.Items) + { ImGui.BulletText(item); - } - } + } - ImGuiHelpers.ScaledDummy(5); - } - - private static void DrawFeatureHeader(string title, Vector4 accentColor) - { - var drawList = ImGui.GetWindowDrawList(); - var startPos = ImGui.GetCursorScreenPos(); - - var backgroundMin = startPos + new Vector2(-10, -5); - var backgroundMax = startPos + new Vector2(ImGui.GetContentRegionAvail().X + 10, 25); - drawList.AddRectFilled(backgroundMin, backgroundMax, ImGui.GetColorU32(new Vector4(0.12f, 0.12f, 0.15f, 0.6f)), 4f); - drawList.AddRectFilled(backgroundMin, backgroundMin + new Vector2(3, backgroundMax.Y - backgroundMin.Y), ImGui.GetColorU32(accentColor), 2f); - - ImGui.Spacing(); - ImGui.TextColored(accentColor, title); - ImGui.Spacing(); - } - - private void DrawCredits() - { - ImGui.TextUnformatted("Maintained & Developed by the Lightless Sync team."); - ImGui.TextUnformatted("Thank you to all supporters and contributors!"); - ImGuiHelpers.ScaledDummy(5); - - var availableRegion = ImGui.GetContentRegionAvail(); - var halfWidth = new Vector2( - availableRegion.X / 2f - ImGui.GetStyle().ItemSpacing.X / 2f, - availableRegion.Y - 120 * ImGuiHelpers.GlobalScale); - - using (var leftChild = ImRaii.Child("left_supporters", halfWidth)) - { - if (leftChild) - { - ImGui.TextUnformatted("Supporters (Ko-fi / Patreon)"); - _uiShared.RoundedSeparator(UIColors.Get("LightlessBlue"), thickness: 2f); - foreach (var supporter in _supporters) - ImGui.BulletText(supporter); - } - } - - ImGui.SameLine(); - - using (var rightChild = ImRaii.Child("right_contributors", halfWidth)) - { - if (rightChild) - { - ImGui.TextUnformatted("Contributors"); - _uiShared.RoundedSeparator(UIColors.Get("LightlessBlue"), thickness: 2f); - foreach (var contributor in _contributors) - ImGui.BulletText(contributor); + ImGuiHelpers.ScaledDummy(5); } } ImGuiHelpers.ScaledDummy(8); - ImGui.TextUnformatted("Credits"); - _uiShared.RoundedSeparator(UIColors.Get("LightlessYellow"), thickness: 2f); - foreach (var credit in _credits) - ImGui.BulletText(credit); + } + + private static void DrawFeatureSection(string title, Vector4 accentColor) + { + var drawList = ImGui.GetWindowDrawList(); + var startPos = ImGui.GetCursorScreenPos(); + var availableWidth = ImGui.GetContentRegionAvail().X; + + var backgroundMin = startPos + new Vector2(-8, -4); + var backgroundMax = startPos + new Vector2(availableWidth + 8, 28); + + // Background with subtle gradient + var bgColor = new Vector4(0.12f, 0.12f, 0.15f, 0.7f); + drawList.AddRectFilled(backgroundMin, backgroundMax, ImGui.GetColorU32(bgColor), 6f); + + // Accent line on left + drawList.AddRectFilled( + backgroundMin, + backgroundMin + new Vector2(4, backgroundMax.Y - backgroundMin.Y), + ImGui.GetColorU32(accentColor), + 3f + ); + + // Subtle glow effect + var glowColor = accentColor with { W = 0.15f }; + drawList.AddRect( + backgroundMin, + backgroundMax, + ImGui.GetColorU32(glowColor), + 6f, + ImDrawFlags.None, + 1.5f + ); + + ImGui.SetCursorPosX(ImGui.GetCursorPosX() + 8); + ImGui.Spacing(); + ImGui.TextColored(accentColor, title); + ImGui.Spacing(); } private void LoadEmbeddedResources() From 823dd39a9bd44d94365979ca9eeb28ebedde9c6e Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 01:29:38 +0200 Subject: [PATCH 23/64] improved particle animations, took some inspiration from brio and character + kinda pogged at their change log --- LightlessSync/LightlessSync.csproj | 3 - LightlessSync/UI/Changelog/changelog.yaml | 8 +- LightlessSync/UI/Changelog/contributors.txt | 1 - LightlessSync/UI/Changelog/credits.txt | 2 - LightlessSync/UI/Changelog/supporters.txt | 1 - LightlessSync/UI/UpdateNotesUi.cs | 566 +++++++------------- 6 files changed, 191 insertions(+), 390 deletions(-) delete mode 100644 LightlessSync/UI/Changelog/contributors.txt delete mode 100644 LightlessSync/UI/Changelog/credits.txt delete mode 100644 LightlessSync/UI/Changelog/supporters.txt diff --git a/LightlessSync/LightlessSync.csproj b/LightlessSync/LightlessSync.csproj index b51bcd7..daf6cfd 100644 --- a/LightlessSync/LightlessSync.csproj +++ b/LightlessSync/LightlessSync.csproj @@ -66,9 +66,6 @@ PreserveNewest - - - diff --git a/LightlessSync/UI/Changelog/changelog.yaml b/LightlessSync/UI/Changelog/changelog.yaml index c28a2c3..d3024c9 100644 --- a/LightlessSync/UI/Changelog/changelog.yaml +++ b/LightlessSync/UI/Changelog/changelog.yaml @@ -171,10 +171,4 @@ changelog: - "Fixed owners being visible in moderator list view." - "Removed Pin/Remove/Ban buttons on Owners when viewing as moderator." - "Fixed nameplate bug in PvP." - - "Added 1 or 3 day options for inactive check." - - - name: "Template" - tagline: "" - date: "October 15th 2025" - is_current: false - message: "Thank you for using Lightless Sync!\n\nThis update brings quality of life improvements and polish to the user experience.\nWe're committed to helping you share your character with others seamlessly.\n\nIf you have any suggestions or encounter any issues, please let us know on Discord or GitHub!\n\n- The Lightless Team" + - "Added 1 or 3 day options for inactive check." \ No newline at end of file diff --git a/LightlessSync/UI/Changelog/contributors.txt b/LightlessSync/UI/Changelog/contributors.txt deleted file mode 100644 index fabb456..0000000 --- a/LightlessSync/UI/Changelog/contributors.txt +++ /dev/null @@ -1 +0,0 @@ -[Add contributor names - GitHub handles, etc.] diff --git a/LightlessSync/UI/Changelog/credits.txt b/LightlessSync/UI/Changelog/credits.txt deleted file mode 100644 index 4e2fe79..0000000 --- a/LightlessSync/UI/Changelog/credits.txt +++ /dev/null @@ -1,2 +0,0 @@ -UI design inspired by Brio's update window (Etheirys/Brio). Thanks to their team for the great UX ideas. -Special thanks to the Dalamud team and the XIV modding ecosystem for tooling & APIs. diff --git a/LightlessSync/UI/Changelog/supporters.txt b/LightlessSync/UI/Changelog/supporters.txt deleted file mode 100644 index f8a29df..0000000 --- a/LightlessSync/UI/Changelog/supporters.txt +++ /dev/null @@ -1 +0,0 @@ -[Your Names Here] diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index 83ac903..37763d3 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -6,7 +6,6 @@ using LightlessSync.LightlessConfiguration; using LightlessSync.Services; using LightlessSync.Services.Mediator; using Microsoft.Extensions.Logging; -using System.IO; using System.Numerics; using System.Reflection; using System.Text; @@ -16,20 +15,15 @@ using Dalamud.Interface; namespace LightlessSync.UI; +// Inspiration taken from Brio and Character Select+ (goats) public class UpdateNotesUi : WindowMediatorSubscriberBase { - private readonly LightlessConfigService _configService; private readonly UiSharedService _uiShared; - private readonly List _contributors = []; - private readonly List _credits = []; - private readonly List _supporters = []; - private ChangelogFile _changelog = new(); private bool _scrollToTop; private int _selectedTab; - // Particle system for visual effects private struct Particle { public Vector2 Position; @@ -37,27 +31,29 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase public float Life; public float MaxLife; public float Size; - public Vector4 Color; public ParticleType Type; - public float Rotation; - public float RotationSpeed; public List? Trail; - public bool IsLargeMoon; + public float Twinkle; + public float Depth; + public float Hue; } private enum ParticleType { - Star, - Moon, - Sparkle, - FastFallingStar + TwinklingStar, + ShootingStar } private readonly List _particles = []; - private float _particleTimer; - private readonly Random _particleRandom = new(); - private Particle? _largeMoon; - private float _largeMoonTimer; + private float _particleSpawnTimer; + private readonly Random _random = new(); + + private const float HeaderHeight = 150f; + private const float ParticleSpawnInterval = 0.2f; + private const int MaxParticles = 50; + private const int MaxTrailLength = 50; + private const float EdgeFadeDistance = 30f; + private const float ExtendedParticleHeight = 40f; public UpdateNotesUi(ILogger logger, LightlessMediator mediator, @@ -66,7 +62,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase PerformanceCollectorService performanceCollectorService) : base(logger, mediator, "Lightless Sync — Update Notes", performanceCollectorService) { - _configService = configService; _uiShared = uiShared; AllowClickthrough = false; @@ -106,20 +101,20 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var windowPos = ImGui.GetWindowPos(); var windowPadding = ImGui.GetStyle().WindowPadding; var headerWidth = (800f * ImGuiHelpers.GlobalScale) - (windowPadding.X * 2); - var headerHeight = 140f * ImGuiHelpers.GlobalScale; var headerStart = windowPos + new Vector2(windowPadding.X, windowPadding.Y); - var headerEnd = headerStart + new Vector2(headerWidth, headerHeight); + var headerEnd = headerStart + new Vector2(headerWidth, HeaderHeight); + var headerSize = new Vector2(headerWidth, HeaderHeight); + + var extendedParticleSize = new Vector2(headerWidth, HeaderHeight + ExtendedParticleHeight); DrawGradientBackground(headerStart, headerEnd); - DrawParticleEffects(headerStart, new Vector2(headerWidth, headerHeight)); DrawHeaderText(headerStart); DrawHeaderButtons(headerStart, headerWidth); + DrawBottomGradient(headerStart, headerEnd, headerWidth); - ImGui.SetCursorPosY(windowPadding.Y + headerHeight + 5); - - // Version badge with icon - ImGui.SetCursorPosX(12); + ImGui.SetCursorPosY(windowPadding.Y + HeaderHeight + 5); + ImGui.SetCursorPosX(20); using (ImRaii.PushFont(UiBuilder.IconFont)) { ImGui.TextColored(UIColors.Get("LightlessGreen"), FontAwesomeIcon.Star.ToIconString()); @@ -140,16 +135,15 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ImGui.TextColored(new Vector4(0.65f, 0.65f, 0.75f, 1.0f), $" – {_changelog.Subline}"); } } - - ImGui.Separator(); ImGuiHelpers.ScaledDummy(3); + + DrawParticleEffects(headerStart, extendedParticleSize); } private void DrawGradientBackground(Vector2 headerStart, Vector2 headerEnd) { var drawList = ImGui.GetWindowDrawList(); - // Dark night sky background with stars pattern var darkPurple = new Vector4(0.08f, 0.05f, 0.15f, 1.0f); var deepPurple = new Vector4(0.12f, 0.08f, 0.20f, 1.0f); @@ -162,8 +156,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ImGui.GetColorU32(deepPurple) ); - // Add some static "distant stars" for depth - var random = new Random(42); // Fixed seed for consistent pattern + var random = new Random(42); for (int i = 0; i < 50; i++) { var starPos = headerStart + new Vector2( @@ -173,27 +166,44 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var brightness = 0.3f + (float)random.NextDouble() * 0.4f; drawList.AddCircleFilled(starPos, 1f, ImGui.GetColorU32(new Vector4(1f, 1f, 1f, brightness))); } + } + + private void DrawBottomGradient(Vector2 headerStart, Vector2 headerEnd, float width) + { + var drawList = ImGui.GetWindowDrawList(); + var gradientHeight = 60f; - // Accent border at bottom with glow - drawList.AddLine( - new Vector2(headerStart.X, headerEnd.Y), - headerEnd, - ImGui.GetColorU32(UIColors.Get("LightlessPurple")), - 2f - ); + for (int i = 0; i < gradientHeight; i++) + { + var progress = i / gradientHeight; + var smoothProgress = progress * progress; + var r = 0.12f + (0.0f - 0.12f) * smoothProgress; + var g = 0.08f + (0.0f - 0.08f) * smoothProgress; + var b = 0.20f + (0.0f - 0.20f) * smoothProgress; + var alpha = 1f - smoothProgress; + var gradientColor = new Vector4(r, g, b, alpha); + drawList.AddLine( + new Vector2(headerStart.X, headerEnd.Y + i), + new Vector2(headerStart.X + width, headerEnd.Y + i), + ImGui.GetColorU32(gradientColor), + 1f + ); + } } private void DrawHeaderText(Vector2 headerStart) { - // Title text overlay - drawn after particles so it's on top - ImGui.SetCursorScreenPos(headerStart + new Vector2(20, 30)); + var textX = 20f; + var textY = 30f; + + ImGui.SetCursorScreenPos(headerStart + new Vector2(textX, textY)); using (_uiShared.UidFont.Push()) { ImGui.TextColored(new Vector4(0.95f, 0.95f, 0.95f, 1.0f), "Lightless Sync"); } - ImGui.SetCursorScreenPos(headerStart + new Vector2(20, 75)); + ImGui.SetCursorScreenPos(headerStart + new Vector2(textX, textY + 45f)); ImGui.TextColored(UIColors.Get("LightlessBlue"), "Update Notes"); } @@ -203,8 +213,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var spacing = 8f * ImGuiHelpers.GlobalScale; var rightPadding = 15f * ImGuiHelpers.GlobalScale; var topPadding = 15f * ImGuiHelpers.GlobalScale; - - // Position for buttons in top right var buttonY = headerStart.Y + topPadding; var gitButtonX = headerStart.X + headerWidth - rightPadding - buttonSize.X; var discordButtonX = gitButtonX - buttonSize.X - spacing; @@ -239,372 +247,202 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase private void DrawParticleEffects(Vector2 bannerStart, Vector2 bannerSize) { var deltaTime = ImGui.GetIO().DeltaTime; - _particleTimer += deltaTime; - _largeMoonTimer += deltaTime; + _particleSpawnTimer += deltaTime; - // Spawn new particles - if (_particleTimer > 0.3f && _particles.Count < 30) + if (_particleSpawnTimer > ParticleSpawnInterval && _particles.Count < MaxParticles) { - SpawnParticle(bannerStart, bannerSize); - _particleTimer = 0f; + SpawnParticle(bannerSize); + _particleSpawnTimer = 0f; } - // Spawn or update large moon - if (_largeMoon == null || _largeMoonTimer > 45f) + if (_random.NextDouble() < 0.003) { - SpawnLargeMoon(bannerStart, bannerSize); - _largeMoonTimer = 0f; + SpawnShootingStar(bannerSize); } var drawList = ImGui.GetWindowDrawList(); - // Update and draw large moon first (background layer) - if (_largeMoon != null) - { - var moon = _largeMoon.Value; - moon.Position += moon.Velocity * deltaTime; - moon.Life -= deltaTime; - - // Keep moon within banner bounds with padding - var padding = moon.Size + 10; - if (moon.Life <= 0 || - moon.Position.X < bannerStart.X - padding || - moon.Position.X > bannerStart.X + bannerSize.X + padding || - moon.Position.Y < bannerStart.Y - padding || - moon.Position.Y > bannerStart.Y + bannerSize.Y + padding) - { - _largeMoon = null; - } - else - { - float alpha = Math.Min(1f, moon.Life / moon.MaxLife); - var color = moon.Color with { W = moon.Color.W * alpha }; - DrawMoon(drawList, moon.Position, moon.Size, color); - _largeMoon = moon; - } - } - - // Update and draw regular particles for (int i = _particles.Count - 1; i >= 0; i--) { var particle = _particles[i]; - // Update trail for stars - if ((particle.Type == ParticleType.Star || particle.Type == ParticleType.FastFallingStar) && particle.Trail != null) + var screenPos = bannerStart + particle.Position; + + if (particle.Type == ParticleType.ShootingStar && particle.Trail != null) { particle.Trail.Insert(0, particle.Position); - var maxTrailLength = particle.Type == ParticleType.FastFallingStar ? 15 : 8; - if (particle.Trail.Count > maxTrailLength) + if (particle.Trail.Count > MaxTrailLength) particle.Trail.RemoveAt(particle.Trail.Count - 1); } + if (particle.Type == ParticleType.TwinklingStar) + { + particle.Twinkle += 0.005f * particle.Depth; + } + particle.Position += particle.Velocity * deltaTime; particle.Life -= deltaTime; - particle.Rotation += particle.RotationSpeed * deltaTime; - if (particle.Life <= 0 || - particle.Position.X > bannerStart.X + bannerSize.X + 50 || - particle.Position.X < bannerStart.X - 50 || - particle.Position.Y < bannerStart.Y - 50 || - particle.Position.Y > bannerStart.Y + bannerSize.Y + 50) + var isOutOfBounds = particle.Position.X < -50 || particle.Position.X > bannerSize.X + 50 || + particle.Position.Y < -50 || particle.Position.Y > bannerSize.Y + 50; + + if (particle.Life <= 0 || (particle.Type != ParticleType.TwinklingStar && isOutOfBounds)) { _particles.RemoveAt(i); continue; } - float alpha = Math.Min(1f, particle.Life / particle.MaxLife); - var color = particle.Color with { W = particle.Color.W * alpha }; - - // Draw trail for stars - if ((particle.Type == ParticleType.Star || particle.Type == ParticleType.FastFallingStar) && particle.Trail != null && particle.Trail.Count > 1) + if (particle.Type == ParticleType.TwinklingStar) { + if (particle.Position.X < 0 || particle.Position.X > bannerSize.X) + particle.Velocity = particle.Velocity with { X = -particle.Velocity.X }; + if (particle.Position.Y < 0 || particle.Position.Y > bannerSize.Y) + particle.Velocity = particle.Velocity with { Y = -particle.Velocity.Y }; + } + + var fadeIn = Math.Min(1f, (particle.MaxLife - particle.Life) / 20f); + var fadeOut = Math.Min(1f, particle.Life / 20f); + var lifeFade = Math.Min(fadeIn, fadeOut); + + var edgeFadeX = Math.Min( + Math.Min(1f, (particle.Position.X + EdgeFadeDistance) / EdgeFadeDistance), + Math.Min(1f, (bannerSize.X - particle.Position.X + EdgeFadeDistance) / EdgeFadeDistance) + ); + var edgeFadeY = Math.Min( + Math.Min(1f, (particle.Position.Y + EdgeFadeDistance) / EdgeFadeDistance), + Math.Min(1f, (bannerSize.Y - particle.Position.Y + EdgeFadeDistance) / EdgeFadeDistance) + ); + var edgeFade = Math.Min(edgeFadeX, edgeFadeY); + + var baseAlpha = lifeFade * edgeFade; + var finalAlpha = particle.Type == ParticleType.TwinklingStar + ? baseAlpha * (0.6f + 0.4f * MathF.Sin(particle.Twinkle)) + : baseAlpha; + + if (particle.Type == ParticleType.ShootingStar && particle.Trail != null && particle.Trail.Count > 1) + { + var cyanColor = new Vector4(0.4f, 0.8f, 1.0f, 1.0f); + for (int t = 1; t < particle.Trail.Count; t++) { - float trailAlpha = alpha * (1f - (t / (float)particle.Trail.Count)) * (particle.Type == ParticleType.FastFallingStar ? 0.7f : 0.5f); - var trailColor = color with { W = trailAlpha }; - float thickness = particle.Type == ParticleType.FastFallingStar ? 2.5f : 1.5f; + var trailProgress = (float)t / particle.Trail.Count; + var trailAlpha = Math.Min(1f, (1f - trailProgress) * finalAlpha * 1.8f); + var trailWidth = (1f - trailProgress) * 3f + 1f; + + var glowAlpha = trailAlpha * 0.4f; drawList.AddLine( - particle.Trail[t - 1], - particle.Trail[t], - ImGui.GetColorU32(trailColor), - thickness + bannerStart + particle.Trail[t - 1], + bannerStart + particle.Trail[t], + ImGui.GetColorU32(cyanColor with { W = glowAlpha }), + trailWidth + 4f + ); + + drawList.AddLine( + bannerStart + particle.Trail[t - 1], + bannerStart + particle.Trail[t], + ImGui.GetColorU32(cyanColor with { W = trailAlpha }), + trailWidth ); } } - - // Draw based on particle type - switch (particle.Type) + else if (particle.Type == ParticleType.TwinklingStar) { - case ParticleType.Star: - case ParticleType.FastFallingStar: - DrawStar(drawList, particle.Position, particle.Size, color, particle.Rotation); - break; - case ParticleType.Moon: - DrawMoon(drawList, particle.Position, particle.Size, color); - break; - case ParticleType.Sparkle: - DrawSparkle(drawList, particle.Position, particle.Size, color, particle.Rotation); - break; + DrawTwinklingStar(drawList, screenPos, particle.Size, particle.Hue, finalAlpha, particle.Depth); } _particles[i] = particle; } } - private void DrawStar(ImDrawListPtr drawList, Vector2 position, float size, Vector4 color, float rotation) + private void DrawTwinklingStar(ImDrawListPtr drawList, Vector2 position, float size, float hue, float alpha, float depth) { - // Draw a 5-pointed star - var points = new Vector2[10]; - for (int i = 0; i < 10; i++) - { - float angle = (i * MathF.PI / 5) + rotation; - float radius = (i % 2 == 0) ? size : size * 0.4f; - points[i] = position + new Vector2(MathF.Cos(angle) * radius, MathF.Sin(angle) * radius); - } + var color = HslToRgb(hue, 1.0f, 0.85f); + color.W = alpha; - // Draw filled star - for (int i = 0; i < 5; i++) - { - drawList.AddTriangleFilled( - position, - points[i * 2], - points[(i * 2 + 2) % 10], - ImGui.GetColorU32(color) - ); - } - - // Glow effect - var glowColor = color with { W = color.W * 0.3f }; - drawList.AddCircleFilled(position, size * 1.5f, ImGui.GetColorU32(glowColor)); - } - - private void DrawMoon(ImDrawListPtr drawList, Vector2 position, float size, Vector4 color) - { - // Enhanced glow for larger moons - var glowRadius = size > 15f ? 2.5f : 1.8f; - var glowColor = color with { W = color.W * (size > 15f ? 0.15f : 0.25f) }; - drawList.AddCircleFilled(position, size * glowRadius, ImGui.GetColorU32(glowColor)); - - // Draw crescent moon drawList.AddCircleFilled(position, size, ImGui.GetColorU32(color)); - // Draw shadow circle to create crescent - var shadowColor = new Vector4(0.08f, 0.05f, 0.15f, 1.0f); - drawList.AddCircleFilled(position + new Vector2(size * 0.4f, 0), size * 0.8f, ImGui.GetColorU32(shadowColor)); - - // Additional glow layer for large moons - if (size > 15f) - { - var outerGlow = color with { W = color.W * 0.08f }; - drawList.AddCircleFilled(position, size * 3.5f, ImGui.GetColorU32(outerGlow)); - } + var glowColor = color with { W = alpha * 0.3f }; + drawList.AddCircleFilled(position, size * (1.2f + depth * 0.3f), ImGui.GetColorU32(glowColor)); } - private void DrawSparkle(ImDrawListPtr drawList, Vector2 position, float size, Vector4 color, float rotation) + private static Vector4 HslToRgb(float h, float s, float l) { - // Draw a 4-pointed sparkle (plus shape) - var thickness = size * 0.3f; + h = h / 360f; + float c = (1 - MathF.Abs(2 * l - 1)) * s; + float x = c * (1 - MathF.Abs((h * 6) % 2 - 1)); + float m = l - c / 2; - // Horizontal line - drawList.AddLine( - position + new Vector2(-size, 0), - position + new Vector2(size, 0), - ImGui.GetColorU32(color), - thickness - ); + float r, g, b; + if (h < 1f / 6f) { r = c; g = x; b = 0; } + else if (h < 2f / 6f) { r = x; g = c; b = 0; } + else if (h < 3f / 6f) { r = 0; g = c; b = x; } + else if (h < 4f / 6f) { r = 0; g = x; b = c; } + else if (h < 5f / 6f) { r = x; g = 0; b = c; } + else { r = c; g = 0; b = x; } - // Vertical line - drawList.AddLine( - position + new Vector2(0, -size), - position + new Vector2(0, size), - ImGui.GetColorU32(color), - thickness - ); - - // Center glow - drawList.AddCircleFilled(position, size * 0.4f, ImGui.GetColorU32(color)); - var glowColor = color with { W = color.W * 0.4f }; - drawList.AddCircleFilled(position, size * 1.2f, ImGui.GetColorU32(glowColor)); + return new Vector4(r + m, g + m, b + m, 1.0f); } - private void SpawnParticle(Vector2 bannerStart, Vector2 bannerSize) + + private void SpawnParticle(Vector2 bannerSize) { - var typeRoll = _particleRandom.Next(100); - var particleType = typeRoll switch - { - < 35 => ParticleType.Star, - < 50 => ParticleType.Moon, - < 65 => ParticleType.FastFallingStar, - _ => ParticleType.Sparkle - }; + var position = new Vector2( + (float)_random.NextDouble() * bannerSize.X, + (float)_random.NextDouble() * bannerSize.Y + ); - Vector2 position; - Vector2 velocity; + var depthLayers = new[] { 0.5f, 1.0f, 1.5f }; + var depth = depthLayers[_random.Next(depthLayers.Length)]; - // Stars: spawn from top, move diagonally down - if (particleType == ParticleType.Star) - { - // Spawn from top edge - position = new Vector2( - bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, - bannerStart.Y - 10 - ); - - // Move diagonally down (shooting star effect) - var angle = MathF.PI * 0.25f + (float)(_particleRandom.NextDouble() - 0.5) * 0.5f; // 45° ± variation - var speed = 30f + (float)_particleRandom.NextDouble() * 40f; - velocity = new Vector2(MathF.Cos(angle) * speed, MathF.Sin(angle) * speed); - } - // Fast falling stars: spawn from top, fall straight down very fast - else if (particleType == ParticleType.FastFallingStar) - { - // Spawn from top edge, random X position - position = new Vector2( - bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, - bannerStart.Y - 10 - ); - - // Fall almost straight down with slight horizontal drift - var horizontalDrift = -10f + (float)_particleRandom.NextDouble() * 20f; - var speed = 120f + (float)_particleRandom.NextDouble() * 80f; // Much faster! - velocity = new Vector2(horizontalDrift, speed); - } - // Moons: drift slowly across - else if (particleType == ParticleType.Moon) - { - // Spawn from left side - position = new Vector2( - bannerStart.X - 10, - bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y - ); - - // Drift slowly to the right with slight vertical movement - velocity = new Vector2( - 15f + (float)_particleRandom.NextDouble() * 10f, - -5f + (float)_particleRandom.NextDouble() * 10f - ); - } - // Sparkles: float gently - else - { - position = new Vector2( - bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, - bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y - ); - - velocity = new Vector2( - -5f + (float)_particleRandom.NextDouble() * 10f, - -5f + (float)_particleRandom.NextDouble() * 10f - ); - } + var velocity = new Vector2( + ((float)_random.NextDouble() - 0.5f) * 0.05f * depth, + ((float)_random.NextDouble() - 0.5f) * 0.05f * depth + ); - var particle = new Particle + var isBlue = _random.NextDouble() < 0.5; + var hue = isBlue ? 220f + (float)_random.NextDouble() * 30f : 270f + (float)_random.NextDouble() * 40f; + var size = (0.5f + (float)_random.NextDouble() * 2f) * depth; + var maxLife = 120f + (float)_random.NextDouble() * 60f; + + _particles.Add(new Particle { Position = position, Velocity = velocity, - MaxLife = particleType switch - { - ParticleType.Star => 3f + (float)_particleRandom.NextDouble() * 2f, - ParticleType.Moon => 8f + (float)_particleRandom.NextDouble() * 4f, - ParticleType.FastFallingStar => 1.5f + (float)_particleRandom.NextDouble() * 1f, - _ => 6f + (float)_particleRandom.NextDouble() * 4f - }, - Size = particleType switch - { - ParticleType.Star => 2.5f + (float)_particleRandom.NextDouble() * 2f, - ParticleType.Moon => 3f + (float)_particleRandom.NextDouble() * 2f, - ParticleType.FastFallingStar => 3f + (float)_particleRandom.NextDouble() * 2f, - _ => 2f + (float)_particleRandom.NextDouble() * 2f - }, - Color = particleType switch - { - ParticleType.Star => new Vector4(1.0f, 1.0f, 0.9f, 0.9f), - ParticleType.Moon => UIColors.Get("LightlessBlue") with { W = 0.7f }, - ParticleType.FastFallingStar => new Vector4(1.0f, 0.95f, 0.85f, 1.0f), // Bright white-yellow - _ => UIColors.Get("LightlessPurple") with { W = 0.8f } - }, - Type = particleType, - Rotation = (float)_particleRandom.NextDouble() * MathF.PI * 2, - RotationSpeed = particleType == ParticleType.Star || particleType == ParticleType.FastFallingStar ? 2f : -0.5f + (float)_particleRandom.NextDouble() * 1f, - Trail = particleType == ParticleType.Star || particleType == ParticleType.FastFallingStar ? new List() : null, - IsLargeMoon = false - }; - - particle.Life = particle.MaxLife; - _particles.Add(particle); - } - - private void SpawnLargeMoon(Vector2 bannerStart, Vector2 bannerSize) - { - // Large moon travels across the banner like a celestial body - var spawnSide = _particleRandom.Next(4); - Vector2 position; - Vector2 velocity; - - switch (spawnSide) - { - case 0: - // Spawn from left, move to right - position = new Vector2( - bannerStart.X - 50, - bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y - ); - velocity = new Vector2( - 15f + (float)_particleRandom.NextDouble() * 10f, - -5f + (float)_particleRandom.NextDouble() * 10f - ); - break; - case 1: - // Spawn from top, move down and across - position = new Vector2( - bannerStart.X + (float)_particleRandom.NextDouble() * bannerSize.X, - bannerStart.Y - 50 - ); - velocity = new Vector2( - -5f + (float)_particleRandom.NextDouble() * 10f, - 10f + (float)_particleRandom.NextDouble() * 8f - ); - break; - case 2: - // Spawn from right, move to left - position = new Vector2( - bannerStart.X + bannerSize.X + 50, - bannerStart.Y + (float)_particleRandom.NextDouble() * bannerSize.Y - ); - velocity = new Vector2( - -(15f + (float)_particleRandom.NextDouble() * 10f), - -5f + (float)_particleRandom.NextDouble() * 10f - ); - break; - default: - // Spawn from top-left corner, move diagonally - position = new Vector2( - bannerStart.X - 30, - bannerStart.Y - 30 - ); - velocity = new Vector2( - 12f + (float)_particleRandom.NextDouble() * 8f, - 12f + (float)_particleRandom.NextDouble() * 8f - ); - break; - } - - _largeMoon = new Particle - { - Position = position, - Velocity = velocity, - MaxLife = 40f, - Life = 40f, - Size = 25f + (float)_particleRandom.NextDouble() * 10f, - Color = UIColors.Get("LightlessBlue") with { W = 0.35f }, - Type = ParticleType.Moon, - Rotation = 0, - RotationSpeed = 0, + Life = maxLife, + MaxLife = maxLife, + Size = size, + Type = ParticleType.TwinklingStar, Trail = null, - IsLargeMoon = true - }; + Twinkle = (float)_random.NextDouble() * MathF.PI * 2, + Depth = depth, + Hue = hue + }); } - + + private void SpawnShootingStar(Vector2 bannerSize) + { + var maxLife = 80f + (float)_random.NextDouble() * 40f; + var startX = bannerSize.X * (0.3f + (float)_random.NextDouble() * 0.6f); + var startY = -10f; + + _particles.Add(new Particle + { + Position = new Vector2(startX, startY), + Velocity = new Vector2( + -50f - (float)_random.NextDouble() * 40f, + 30f + (float)_random.NextDouble() * 40f + ), + Life = maxLife, + MaxLife = maxLife, + Size = 2.5f, + Type = ParticleType.ShootingStar, + Trail = new List(), + Twinkle = 0, + Depth = 1.0f, + Hue = 270f + }); + } + private void DrawCloseButton() { @@ -653,7 +491,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase { var currentColor = entry.IsCurrent == true ? UIColors.Get("LightlessGreen") - : new Vector4(0.75f, 0.75f, 0.85f, 1.0f); + : new Vector4(0.95f, 0.95f, 1.0f, 1.0f); bool isOpen; var flags = entry.IsCurrent == true @@ -670,7 +508,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase } ImGui.SameLine(); - ImGui.TextColored(new Vector4(0.75f, 0.75f, 0.85f, 1.0f), $" — {entry.Tagline}"); + ImGui.TextColored(new Vector4(0.85f, 0.85f, 0.95f, 1.0f), $" — {entry.Tagline}"); if (!isOpen) return; @@ -711,11 +549,9 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var backgroundMin = startPos + new Vector2(-8, -4); var backgroundMax = startPos + new Vector2(availableWidth + 8, 28); - // Background with subtle gradient var bgColor = new Vector4(0.12f, 0.12f, 0.15f, 0.7f); drawList.AddRectFilled(backgroundMin, backgroundMax, ImGui.GetColorU32(bgColor), 6f); - // Accent line on left drawList.AddRectFilled( backgroundMin, backgroundMin + new Vector2(4, backgroundMax.Y - backgroundMin.Y), @@ -723,7 +559,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase 3f ); - // Subtle glow effect var glowColor = accentColor with { W = 0.15f }; drawList.AddRect( backgroundMin, @@ -745,11 +580,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase try { var assembly = Assembly.GetExecutingAssembly(); - - ReadLines(assembly, "LightlessSync.UI.Changelog.supporters.txt", _supporters); - ReadLines(assembly, "LightlessSync.UI.Changelog.contributors.txt", _contributors); - ReadLines(assembly, "LightlessSync.UI.Changelog.credits.txt", _credits); - using var changelogStream = assembly.GetManifestResourceStream("LightlessSync.UI.Changelog.changelog.yaml"); if (changelogStream != null) { @@ -767,22 +597,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase // Ignore - window will gracefully render with defaults } } - - private static void ReadLines(Assembly assembly, string resourceName, List target) - { - using var stream = assembly.GetManifestResourceStream(resourceName); - if (stream == null) - return; - - using var reader = new StreamReader(stream, Encoding.UTF8, true, 128); - string? line; - while ((line = reader.ReadLine()) != null) - { - if (!string.IsNullOrWhiteSpace(line)) - target.Add(line.Trim()); - } - } - private sealed record ChangelogFile { public string Tagline { get; init; } = string.Empty; From f77d109d00c7e61c3cf961e1adaa33fcf861d3f7 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 10:37:00 +0200 Subject: [PATCH 24/64] added changelog model and update notes UI with particle effects --- LightlessSync/UI/Models/Changelog.cs | 25 +++ LightlessSync/UI/UpdateNotesUi.cs | 246 ++++++++++++++------------- 2 files changed, 156 insertions(+), 115 deletions(-) create mode 100644 LightlessSync/UI/Models/Changelog.cs diff --git a/LightlessSync/UI/Models/Changelog.cs b/LightlessSync/UI/Models/Changelog.cs new file mode 100644 index 0000000..1a69756 --- /dev/null +++ b/LightlessSync/UI/Models/Changelog.cs @@ -0,0 +1,25 @@ +namespace LightlessSync.UI.Models +{ + public class ChangelogFile + { + public string Tagline { get; init; } = string.Empty; + public string Subline { get; init; } = string.Empty; + public List Changelog { get; init; } = new(); + } + + public class ChangelogEntry + { + public string Name { get; init; } = string.Empty; + public string Date { get; init; } = string.Empty; + public string Tagline { get; init; } = string.Empty; + public bool? IsCurrent { get; init; } + public string? Message { get; init; } + public List? Versions { get; init; } + } + + public class ChangelogVersion + { + public string Number { get; init; } = string.Empty; + public List Items { get; init; } = new(); + } +} \ No newline at end of file diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index 37763d3..558774f 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -12,6 +12,7 @@ using System.Text; using YamlDotNet.Serialization; using YamlDotNet.Serialization.NamingConventions; using Dalamud.Interface; +using LightlessSync.UI.Models; namespace LightlessSync.UI; @@ -23,7 +24,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase private ChangelogFile _changelog = new(); private bool _scrollToTop; private int _selectedTab; - + private struct Particle { public Vector2 Position; @@ -37,17 +38,17 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase public float Depth; public float Hue; } - + private enum ParticleType { TwinklingStar, ShootingStar } - + private readonly List _particles = []; private float _particleSpawnTimer; private readonly Random _random = new(); - + private const float HeaderHeight = 150f; private const float ParticleSpawnInterval = 0.2f; private const int MaxParticles = 50; @@ -69,12 +70,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase RespectCloseHotkey = true; ShowCloseButton = true; - Flags = ImGuiWindowFlags.NoSavedSettings | ImGuiWindowFlags.NoResize | ImGuiWindowFlags.NoCollapse | ImGuiWindowFlags.NoTitleBar; + Flags = ImGuiWindowFlags.NoSavedSettings | ImGuiWindowFlags.NoResize | ImGuiWindowFlags.NoCollapse | + ImGuiWindowFlags.NoTitleBar; SizeConstraints = new WindowSizeConstraints() { - MinimumSize = new Vector2(800, 700), - MaximumSize = new Vector2(800, 700), + MinimumSize = new Vector2(800, 700), MaximumSize = new Vector2(800, 700), }; LoadEmbeddedResources(); @@ -101,61 +102,63 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var windowPos = ImGui.GetWindowPos(); var windowPadding = ImGui.GetStyle().WindowPadding; var headerWidth = (800f * ImGuiHelpers.GlobalScale) - (windowPadding.X * 2); - + var headerStart = windowPos + new Vector2(windowPadding.X, windowPadding.Y); var headerEnd = headerStart + new Vector2(headerWidth, HeaderHeight); var headerSize = new Vector2(headerWidth, HeaderHeight); - + var extendedParticleSize = new Vector2(headerWidth, HeaderHeight + ExtendedParticleHeight); - + DrawGradientBackground(headerStart, headerEnd); DrawHeaderText(headerStart); DrawHeaderButtons(headerStart, headerWidth); DrawBottomGradient(headerStart, headerEnd, headerWidth); - + ImGui.SetCursorPosY(windowPadding.Y + HeaderHeight + 5); ImGui.SetCursorPosX(20); using (ImRaii.PushFont(UiBuilder.IconFont)) { ImGui.TextColored(UIColors.Get("LightlessGreen"), FontAwesomeIcon.Star.ToIconString()); } + ImGui.SameLine(); - + ImGui.TextColored(UIColors.Get("LightlessGreen"), "What's New"); - + if (!string.IsNullOrEmpty(_changelog.Tagline)) { ImGui.SameLine(); ImGui.SetCursorPosX(ImGui.GetCursorPosX() + 10); ImGui.TextColored(new Vector4(0.75f, 0.75f, 0.85f, 1.0f), _changelog.Tagline); - + if (!string.IsNullOrEmpty(_changelog.Subline)) { ImGui.SameLine(); ImGui.TextColored(new Vector4(0.65f, 0.65f, 0.75f, 1.0f), $" – {_changelog.Subline}"); } } + ImGuiHelpers.ScaledDummy(3); - + DrawParticleEffects(headerStart, extendedParticleSize); } - + private void DrawGradientBackground(Vector2 headerStart, Vector2 headerEnd) { var drawList = ImGui.GetWindowDrawList(); - + var darkPurple = new Vector4(0.08f, 0.05f, 0.15f, 1.0f); var deepPurple = new Vector4(0.12f, 0.08f, 0.20f, 1.0f); - + drawList.AddRectFilledMultiColor( - headerStart, - headerEnd, + headerStart, + headerEnd, ImGui.GetColorU32(darkPurple), ImGui.GetColorU32(darkPurple), ImGui.GetColorU32(deepPurple), ImGui.GetColorU32(deepPurple) ); - + var random = new Random(42); for (int i = 0; i < 50; i++) { @@ -167,12 +170,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase drawList.AddCircleFilled(starPos, 1f, ImGui.GetColorU32(new Vector4(1f, 1f, 1f, brightness))); } } - + private void DrawBottomGradient(Vector2 headerStart, Vector2 headerEnd, float width) { var drawList = ImGui.GetWindowDrawList(); var gradientHeight = 60f; - + for (int i = 0; i < gradientHeight; i++) { var progress = i / gradientHeight; @@ -190,23 +193,23 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ); } } - + private void DrawHeaderText(Vector2 headerStart) { var textX = 20f; var textY = 30f; - + ImGui.SetCursorScreenPos(headerStart + new Vector2(textX, textY)); - + using (_uiShared.UidFont.Push()) { ImGui.TextColored(new Vector4(0.95f, 0.95f, 0.95f, 1.0f), "Lightless Sync"); } - + ImGui.SetCursorScreenPos(headerStart + new Vector2(textX, textY + 45f)); ImGui.TextColored(UIColors.Get("LightlessBlue"), "Update Notes"); } - + private void DrawHeaderButtons(Vector2 headerStart, float headerWidth) { var buttonSize = _uiShared.GetIconButtonSize(FontAwesomeIcon.Globe); @@ -216,9 +219,9 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var buttonY = headerStart.Y + topPadding; var gitButtonX = headerStart.X + headerWidth - rightPadding - buttonSize.X; var discordButtonX = gitButtonX - buttonSize.X - spacing; - + ImGui.SetCursorScreenPos(new Vector2(discordButtonX, buttonY)); - + using (ImRaii.PushColor(ImGuiCol.Button, new Vector4(0, 0, 0, 0))) using (ImRaii.PushColor(ImGuiCol.ButtonHovered, UIColors.Get("LightlessPurple") with { W = 0.3f })) using (ImRaii.PushColor(ImGuiCol.ButtonActive, UIColors.Get("LightlessPurpleActive") with { W = 0.5f })) @@ -227,71 +230,73 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase { Util.OpenLink("https://discord.gg/dsbjcXMnhA"); } + if (ImGui.IsItemHovered()) { ImGui.SetTooltip("Join our Discord"); } - + ImGui.SetCursorScreenPos(new Vector2(gitButtonX, buttonY)); if (_uiShared.IconButton(FontAwesomeIcon.Code)) { Util.OpenLink("https://git.lightless-sync.org/Lightless-Sync"); } + if (ImGui.IsItemHovered()) { ImGui.SetTooltip("View on Git"); } } } - + private void DrawParticleEffects(Vector2 bannerStart, Vector2 bannerSize) { var deltaTime = ImGui.GetIO().DeltaTime; _particleSpawnTimer += deltaTime; - + if (_particleSpawnTimer > ParticleSpawnInterval && _particles.Count < MaxParticles) { SpawnParticle(bannerSize); _particleSpawnTimer = 0f; } - + if (_random.NextDouble() < 0.003) { SpawnShootingStar(bannerSize); } - + var drawList = ImGui.GetWindowDrawList(); - + for (int i = _particles.Count - 1; i >= 0; i--) { var particle = _particles[i]; - + var screenPos = bannerStart + particle.Position; - + if (particle.Type == ParticleType.ShootingStar && particle.Trail != null) { particle.Trail.Insert(0, particle.Position); if (particle.Trail.Count > MaxTrailLength) particle.Trail.RemoveAt(particle.Trail.Count - 1); } - + if (particle.Type == ParticleType.TwinklingStar) { particle.Twinkle += 0.005f * particle.Depth; } - + particle.Position += particle.Velocity * deltaTime; particle.Life -= deltaTime; - + var isOutOfBounds = particle.Position.X < -50 || particle.Position.X > bannerSize.X + 50 || particle.Position.Y < -50 || particle.Position.Y > bannerSize.Y + 50; - + if (particle.Life <= 0 || (particle.Type != ParticleType.TwinklingStar && isOutOfBounds)) { _particles.RemoveAt(i); continue; } - + if (particle.Type == ParticleType.TwinklingStar) { if (particle.Position.X < 0 || particle.Position.X > bannerSize.X) @@ -299,11 +304,11 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase if (particle.Position.Y < 0 || particle.Position.Y > bannerSize.Y) particle.Velocity = particle.Velocity with { Y = -particle.Velocity.Y }; } - + var fadeIn = Math.Min(1f, (particle.MaxLife - particle.Life) / 20f); var fadeOut = Math.Min(1f, particle.Life / 20f); var lifeFade = Math.Min(fadeIn, fadeOut); - + var edgeFadeX = Math.Min( Math.Min(1f, (particle.Position.X + EdgeFadeDistance) / EdgeFadeDistance), Math.Min(1f, (bannerSize.X - particle.Position.X + EdgeFadeDistance) / EdgeFadeDistance) @@ -313,22 +318,22 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase Math.Min(1f, (bannerSize.Y - particle.Position.Y + EdgeFadeDistance) / EdgeFadeDistance) ); var edgeFade = Math.Min(edgeFadeX, edgeFadeY); - + var baseAlpha = lifeFade * edgeFade; - var finalAlpha = particle.Type == ParticleType.TwinklingStar + var finalAlpha = particle.Type == ParticleType.TwinklingStar ? baseAlpha * (0.6f + 0.4f * MathF.Sin(particle.Twinkle)) : baseAlpha; - + if (particle.Type == ParticleType.ShootingStar && particle.Trail != null && particle.Trail.Count > 1) { var cyanColor = new Vector4(0.4f, 0.8f, 1.0f, 1.0f); - + for (int t = 1; t < particle.Trail.Count; t++) { var trailProgress = (float)t / particle.Trail.Count; var trailAlpha = Math.Min(1f, (1f - trailProgress) * finalAlpha * 1.8f); var trailWidth = (1f - trailProgress) * 3f + 1f; - + var glowAlpha = trailAlpha * 0.4f; drawList.AddLine( bannerStart + particle.Trail[t - 1], @@ -336,7 +341,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ImGui.GetColorU32(cyanColor with { W = glowAlpha }), trailWidth + 4f ); - + drawList.AddLine( bannerStart + particle.Trail[t - 1], bannerStart + particle.Trail[t], @@ -349,61 +354,92 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase { DrawTwinklingStar(drawList, screenPos, particle.Size, particle.Hue, finalAlpha, particle.Depth); } - + _particles[i] = particle; } } - - private void DrawTwinklingStar(ImDrawListPtr drawList, Vector2 position, float size, float hue, float alpha, float depth) + + private void DrawTwinklingStar(ImDrawListPtr drawList, Vector2 position, float size, float hue, float alpha, + float depth) { var color = HslToRgb(hue, 1.0f, 0.85f); color.W = alpha; - + drawList.AddCircleFilled(position, size, ImGui.GetColorU32(color)); - + var glowColor = color with { W = alpha * 0.3f }; drawList.AddCircleFilled(position, size * (1.2f + depth * 0.3f), ImGui.GetColorU32(glowColor)); } - + private static Vector4 HslToRgb(float h, float s, float l) { h = h / 360f; float c = (1 - MathF.Abs(2 * l - 1)) * s; float x = c * (1 - MathF.Abs((h * 6) % 2 - 1)); float m = l - c / 2; - + float r, g, b; - if (h < 1f / 6f) { r = c; g = x; b = 0; } - else if (h < 2f / 6f) { r = x; g = c; b = 0; } - else if (h < 3f / 6f) { r = 0; g = c; b = x; } - else if (h < 4f / 6f) { r = 0; g = x; b = c; } - else if (h < 5f / 6f) { r = x; g = 0; b = c; } - else { r = c; g = 0; b = x; } - + if (h < 1f / 6f) + { + r = c; + g = x; + b = 0; + } + else if (h < 2f / 6f) + { + r = x; + g = c; + b = 0; + } + else if (h < 3f / 6f) + { + r = 0; + g = c; + b = x; + } + else if (h < 4f / 6f) + { + r = 0; + g = x; + b = c; + } + else if (h < 5f / 6f) + { + r = x; + g = 0; + b = c; + } + else + { + r = c; + g = 0; + b = x; + } + return new Vector4(r + m, g + m, b + m, 1.0f); } - - + + private void SpawnParticle(Vector2 bannerSize) { var position = new Vector2( (float)_random.NextDouble() * bannerSize.X, (float)_random.NextDouble() * bannerSize.Y ); - + var depthLayers = new[] { 0.5f, 1.0f, 1.5f }; var depth = depthLayers[_random.Next(depthLayers.Length)]; - + var velocity = new Vector2( ((float)_random.NextDouble() - 0.5f) * 0.05f * depth, ((float)_random.NextDouble() - 0.5f) * 0.05f * depth ); - + var isBlue = _random.NextDouble() < 0.5; var hue = isBlue ? 220f + (float)_random.NextDouble() * 30f : 270f + (float)_random.NextDouble() * 40f; var size = (0.5f + (float)_random.NextDouble() * 2f) * depth; var maxLife = 120f + (float)_random.NextDouble() * 60f; - + _particles.Add(new Particle { Position = position, @@ -418,13 +454,13 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase Hue = hue }); } - + private void SpawnShootingStar(Vector2 bannerSize) { var maxLife = 80f + (float)_random.NextDouble() * 40f; var startX = bannerSize.X * (0.3f + (float)_random.NextDouble() * 0.6f); var startY = -10f; - + _particles.Add(new Particle { Position = new Vector2(startX, startY), @@ -442,16 +478,16 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase Hue = 270f }); } - + private void DrawCloseButton() { ImGuiHelpers.ScaledDummy(5); - + var closeWidth = 200f * ImGuiHelpers.GlobalScale; var closeHeight = 35f * ImGuiHelpers.GlobalScale; ImGui.SetCursorPosX((ImGui.GetWindowSize().X - closeWidth) / 2); - + using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 8f)) using (ImRaii.PushColor(ImGuiCol.Button, UIColors.Get("LightlessPurple"))) using (ImRaii.PushColor(ImGuiCol.ButtonHovered, UIColors.Get("LightlessPurpleActive"))) @@ -463,10 +499,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase } } } + private void DrawChangelog() { using (ImRaii.PushStyle(ImGuiStyleVar.ChildRounding, 6f)) - using (var child = ImRaii.Child("###ll_changelog", new Vector2(0, ImGui.GetContentRegionAvail().Y - 60), false, ImGuiWindowFlags.AlwaysVerticalScrollbar)) + using (var child = ImRaii.Child("###ll_changelog", new Vector2(0, ImGui.GetContentRegionAvail().Y - 60), false, + ImGuiWindowFlags.AlwaysVerticalScrollbar)) { if (!child) return; @@ -476,7 +514,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase _scrollToTop = false; ImGui.SetScrollHereY(0); } - + ImGui.PushTextWrapPos(); foreach (var entry in _changelog.Changelog) @@ -494,10 +532,10 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase : new Vector4(0.95f, 0.95f, 1.0f, 1.0f); bool isOpen; - var flags = entry.IsCurrent == true - ? ImGuiTreeNodeFlags.DefaultOpen + var flags = entry.IsCurrent == true + ? ImGuiTreeNodeFlags.DefaultOpen : ImGuiTreeNodeFlags.None; - + using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 4f)) using (ImRaii.PushColor(ImGuiCol.Header, UIColors.Get("ButtonDefault"))) using (ImRaii.PushColor(ImGuiCol.HeaderHovered, UIColors.Get("LightlessPurple"))) @@ -539,7 +577,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ImGuiHelpers.ScaledDummy(8); } - + private static void DrawFeatureSection(string title, Vector4 accentColor) { var drawList = ImGui.GetWindowDrawList(); @@ -548,24 +586,24 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var backgroundMin = startPos + new Vector2(-8, -4); var backgroundMax = startPos + new Vector2(availableWidth + 8, 28); - + var bgColor = new Vector4(0.12f, 0.12f, 0.15f, 0.7f); drawList.AddRectFilled(backgroundMin, backgroundMax, ImGui.GetColorU32(bgColor), 6f); - + drawList.AddRectFilled( - backgroundMin, - backgroundMin + new Vector2(4, backgroundMax.Y - backgroundMin.Y), - ImGui.GetColorU32(accentColor), + backgroundMin, + backgroundMin + new Vector2(4, backgroundMax.Y - backgroundMin.Y), + ImGui.GetColorU32(accentColor), 3f ); - + var glowColor = accentColor with { W = 0.15f }; drawList.AddRect( - backgroundMin, - backgroundMax, - ImGui.GetColorU32(glowColor), - 6f, - ImDrawFlags.None, + backgroundMin, + backgroundMax, + ImGui.GetColorU32(glowColor), + 6f, + ImDrawFlags.None, 1.5f ); @@ -597,26 +635,4 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase // Ignore - window will gracefully render with defaults } } - private sealed record ChangelogFile - { - public string Tagline { get; init; } = string.Empty; - public string Subline { get; init; } = string.Empty; - public List Changelog { get; init; } = new(); - } - - private sealed record ChangelogEntry - { - public string Name { get; init; } = string.Empty; - public string Date { get; init; } = string.Empty; - public string Tagline { get; init; } = string.Empty; - public bool? IsCurrent { get; init; } - public string? Message { get; init; } - public List? Versions { get; init; } - } - - private sealed record ChangelogVersion - { - public string Number { get; init; } = string.Empty; - public List Items { get; init; } = new(); - } } From 92b8d4a1cd25253e4e305d577497a2d6dff306a2 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 14:35:30 +0200 Subject: [PATCH 25/64] credits integration into the yaml and ui --- LightlessSync/UI/Changelog/changelog.yaml | 38 +++++++++- LightlessSync/UI/Models/Changelog.cs | 13 ++++ LightlessSync/UI/UpdateNotesUi.cs | 88 ++++++++++++++++++++++- 3 files changed, 137 insertions(+), 2 deletions(-) diff --git a/LightlessSync/UI/Changelog/changelog.yaml b/LightlessSync/UI/Changelog/changelog.yaml index d3024c9..a2af1f1 100644 --- a/LightlessSync/UI/Changelog/changelog.yaml +++ b/LightlessSync/UI/Changelog/changelog.yaml @@ -171,4 +171,40 @@ changelog: - "Fixed owners being visible in moderator list view." - "Removed Pin/Remove/Ban buttons on Owners when viewing as moderator." - "Fixed nameplate bug in PvP." - - "Added 1 or 3 day options for inactive check." \ No newline at end of file + - "Added 1 or 3 day options for inactive check." + +credits: + - category: "Development Team" + items: + - name: "Choco" + role: "Cringe Developer" + - name: "Additional Contributors" + role: "Community Contributors & Bug Reporters" + + - category: "Plugin Integration & IPC Support" + items: + - name: "Penumbra Team" + role: "Mod framework integration" + - name: "Glamourer Team" + role: "Customization system integration" + - name: "Customize+ Team" + role: "Body scaling integration" + - name: "Simple Heels Team" + role: "Height offset integration" + - name: "Honorific Team" + role: "Title system integration" + - name: "Moodles Team" + role: "Status effect integration" + - name: "PetNicknames Team" + role: "Pet naming integration" + - name: "Brio Team" + role: "GPose enhancement integration" + + - category: "Special Thanks" + items: + - name: "Dalamud & XIVLauncher Teams" + role: "Plugin framework and infrastructure" + - name: "Community Supporters" + role: "Testing, feedback, and financial support" + - name: "Beta Testers" + role: "Early testing and bug reporting" \ No newline at end of file diff --git a/LightlessSync/UI/Models/Changelog.cs b/LightlessSync/UI/Models/Changelog.cs index 1a69756..bf1a474 100644 --- a/LightlessSync/UI/Models/Changelog.cs +++ b/LightlessSync/UI/Models/Changelog.cs @@ -5,6 +5,7 @@ namespace LightlessSync.UI.Models public string Tagline { get; init; } = string.Empty; public string Subline { get; init; } = string.Empty; public List Changelog { get; init; } = new(); + public List? Credits { get; init; } } public class ChangelogEntry @@ -22,4 +23,16 @@ namespace LightlessSync.UI.Models public string Number { get; init; } = string.Empty; public List Items { get; init; } = new(); } + + public class CreditCategory + { + public string Category { get; init; } = string.Empty; + public List Items { get; init; } = new(); + } + + public class CreditItem + { + public string Name { get; init; } = string.Empty; + public string Role { get; init; } = string.Empty; + } } \ No newline at end of file diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index 558774f..8345987 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -93,7 +93,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase DrawHeader(); ImGuiHelpers.ScaledDummy(6); - DrawChangelog(); + DrawTabs(); DrawCloseButton(); } @@ -480,6 +480,92 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase } + private void DrawTabs() + { + using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 6f)) + using (ImRaii.PushColor(ImGuiCol.Tab, UIColors.Get("ButtonDefault"))) + using (ImRaii.PushColor(ImGuiCol.TabHovered, UIColors.Get("LightlessPurple"))) + using (ImRaii.PushColor(ImGuiCol.TabActive, UIColors.Get("LightlessPurpleActive"))) + { + using (var tabBar = ImRaii.TabBar("###ll_tabs", ImGuiTabBarFlags.None)) + { + if (!tabBar) + return; + + using (var changelogTab = ImRaii.TabItem("What's New")) + { + if (changelogTab) + { + _selectedTab = 0; + DrawChangelog(); + } + } + + if (_changelog.Credits != null && _changelog.Credits.Count > 0) + { + using (var creditsTab = ImRaii.TabItem("Credits")) + { + if (creditsTab) + { + _selectedTab = 1; + DrawCredits(); + } + } + } + } + } + } + + private void DrawCredits() + { + using (ImRaii.PushStyle(ImGuiStyleVar.ChildRounding, 6f)) + using (var child = ImRaii.Child("###ll_credits", new Vector2(0, ImGui.GetContentRegionAvail().Y - 60), false, + ImGuiWindowFlags.AlwaysVerticalScrollbar)) + { + if (!child) + return; + + ImGui.PushTextWrapPos(); + + if (_changelog.Credits != null) + { + foreach (var category in _changelog.Credits) + { + DrawCreditCategory(category); + ImGuiHelpers.ScaledDummy(10); + } + } + + ImGui.PopTextWrapPos(); + ImGui.Spacing(); + } + } + + private void DrawCreditCategory(CreditCategory category) + { + DrawFeatureSection(category.Category, UIColors.Get("LightlessBlue")); + + ImGui.Indent(15f); + + foreach (var item in category.Items) + { + using (ImRaii.PushColor(ImGuiCol.Text, new Vector4(0.95f, 0.95f, 1.0f, 1.0f))) + { + ImGui.TextWrapped($"• {item.Name}"); + } + + if (!string.IsNullOrEmpty(item.Role)) + { + ImGui.SameLine(); + ImGui.TextColored(new Vector4(0.7f, 0.7f, 0.8f, 1.0f), $" — {item.Role}"); + } + + ImGuiHelpers.ScaledDummy(3); + } + + ImGui.Unindent(15f); + } + private void DrawCloseButton() { ImGuiHelpers.ScaledDummy(5); From 280c80d89f32bcbed87e888582fb2d21833bcb06 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Thu, 16 Oct 2025 15:19:01 +0200 Subject: [PATCH 26/64] Changed the layout a bit, added nsfw --- LightlessSync/UI/SyncshellAdminUI.cs | 75 +++++++++++++++++++++++++--- 1 file changed, 69 insertions(+), 6 deletions(-) diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 6faf08a..141510b 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -13,11 +13,13 @@ using LightlessSync.API.Dto.User; using LightlessSync.PlayerData.Pairs; using LightlessSync.Services; using LightlessSync.Services.Mediator; +using LightlessSync.UI.Handlers; using LightlessSync.WebAPI; using Microsoft.Extensions.Logging; using SixLabors.ImageSharp; using SixLabors.ImageSharp.PixelFormats; using System.Globalization; +using System.Linq; using System.Numerics; namespace LightlessSync.UI; @@ -34,7 +36,6 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private readonly UiSharedService _uiSharedService; private List _bannedUsers = []; private LightlessGroupProfileData? _profileData = null; - private GroupData? _lastProfileGroup = null; private bool _adjustedForScollBarsLocalProfile = false; private bool _adjustedForScollBarsOnlineProfile = false; private string _descriptionText = string.Empty; @@ -48,7 +49,8 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private Task? _pruneTestTask; private Task? _pruneTask; private int _pruneDays = 14; - private bool renewProfile; + private readonly List _allowedTags = ["Apex", "Predator", "Tavern", "NSFW", "SFW"]; + private List _selectedTags = []; public SyncshellAdminUI(ILogger logger, LightlessMediator mediator, ApiController apiController, UiSharedService uiSharedService, PairManager pairManager, GroupFullInfoDto groupFullInfo, PerformanceCollectorService performanceCollectorService, LightlessProfileManager lightlessProfileManager, FileDialogManager fileDialogManager) @@ -92,6 +94,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase GroupFullInfo = _pairManager.Groups[GroupFullInfo.Group]; _profileData = _lightlessProfileManager.GetLightlessGroupProfile(GroupFullInfo.Group); + GetTagsFromProfile(); using var id = ImRaii.PushId("syncshell_admin_" + GroupFullInfo.GID); using (_uiSharedService.UidFont.Push()) @@ -109,7 +112,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase DrawManagement(); DrawPermission(perm); - + DrawProfile(); } } @@ -270,7 +273,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase if (_uiSharedService.MediumTreeNode("Profile Settings", UIColors.Get("LightlessPurple"))) { ImGui.Dummy(new Vector2(5)); - + ImGui.TextUnformatted($"Profile Picture:"); if (_uiSharedService.IconTextButton(FontAwesomeIcon.FileUpload, "Upload new profile picture")) { _fileDialogManager.OpenFileDialog("Select new Profile picture", ".png", (success, file) => @@ -314,8 +317,15 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { UiSharedService.ColorTextWrapped("The profile picture must be a PNG file with a maximum height and width of 256px and 250KiB size", ImGuiColors.DalamudRed); } + ImGui.Separator(); + ImGui.TextUnformatted($"Tags:"); + var childFrameLocal = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 200); - _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); + foreach (string tag in _allowedTags) + { + using (ImRaii.PushId($"tag-{tag}")) DrawTag(tag); + } + ImGui.Separator(); var widthTextBox = 400; var posX = ImGui.GetCursorPosX(); ImGui.TextUnformatted($"Description {_descriptionText.Length}/1500"); @@ -330,7 +340,6 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase using (_uiSharedService.GameFont.Push()) { var descriptionTextSizeLocal = ImGui.CalcTextSize(_descriptionText, wrapWidth: 256f); - var childFrameLocal = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 200); if (descriptionTextSizeLocal.Y > childFrameLocal.Y) { _adjustedForScollBarsLocalProfile = true; @@ -361,6 +370,14 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null)); } UiSharedService.AttachToolTip("Clears your profile description text"); + ImGui.Separator(); + ImGui.TextUnformatted($"Profile Options:"); + var isNsfw = false; + if (ImGui.Checkbox("Profile is NSFW", ref isNsfw)) + { + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, isNsfw, ProfilePictureBase64: null, Description: null)); + } + _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); ImGui.TreePop(); } } @@ -710,6 +727,52 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase } inviteTab.Dispose(); } + private void DrawTag(string tag) + { + var HasTag = _selectedTags.Contains(tag, StringComparer.Ordinal); + if (ImGui.Checkbox(tag, ref HasTag)) + { + if (HasTag) + { + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null)); + + _selectedTags.Add(tag); + } + else + { + _ = _selectedTags.Count > 0 + ? _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null)) + : _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: string.Empty, PictureBase64: null)); + + _selectedTags.Remove(tag); + } + } + } + + private void GetTagsFromProfile() + { + _selectedTags = []; + if (_profileData != null) + { + _selectedTags = StringToList(_profileData.Tags, ","); + } + } + + private static string ListToString(List list, string delimiter) + { + if (list == null || list.Count == 0) + return string.Empty; + + return string.Join(delimiter, list); + } + + public static List StringToList(string input, string delimiter) + { + if (string.IsNullOrEmpty(input)) + return []; + + return [.. input.Split([delimiter], StringSplitOptions.None)]; + } public override void OnClose() { From 6d01d47c2f883158e3346292ff45c41012e69fd4 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 22:13:40 +0200 Subject: [PATCH 27/64] broadcast notifications, action button for reconnecting once expired --- LightlessSync/Services/BroadcastService.cs | 84 +++++++++++++++++++++- 1 file changed, 81 insertions(+), 3 deletions(-) diff --git a/LightlessSync/Services/BroadcastService.cs b/LightlessSync/Services/BroadcastService.cs index 0cdd3c0..cad09dd 100644 --- a/LightlessSync/Services/BroadcastService.cs +++ b/LightlessSync/Services/BroadcastService.cs @@ -1,4 +1,8 @@ -using LightlessSync.API.Dto.Group; +using Dalamud.Interface; +using LightlessSync.LightlessConfiguration.Models; +using LightlessSync.UI; +using LightlessSync.UI.Models; +using LightlessSync.API.Dto.Group; using LightlessSync.API.Dto.User; using LightlessSync.LightlessConfiguration; using LightlessSync.Services.Mediator; @@ -140,6 +144,11 @@ public class BroadcastService : IHostedService, IMediatorSubscriber IsLightFinderAvailable = false; ApplyBroadcastDisabled(forcePublish: true); _logger.LogDebug("Cleared Lightfinder state due to disconnect."); + + _mediator.Publish(new NotificationMessage( + "Disconnected from Server", + "Your Lightfinder broadcast has been disabled due to disconnection.", + NotificationType.Warning)); } public Task StartAsync(CancellationToken cancellationToken) @@ -236,6 +245,11 @@ public class BroadcastService : IHostedService, IMediatorSubscriber { _logger.LogInformation("Auto-enabling Lightfinder broadcast after reconnect."); _mediator.Publish(new EnableBroadcastMessage(hashedCid, true)); + + _mediator.Publish(new NotificationMessage( + "Broadcast Auto-Enabled", + "Your Lightfinder broadcast has been automatically enabled.", + NotificationType.Info)); } } catch (OperationCanceledException) @@ -389,20 +403,29 @@ public class BroadcastService : IHostedService, IMediatorSubscriber - public async void ToggleBroadcast() + public async void ToggleBroadcast(bool bypassCooldown = false) { + if (!IsLightFinderAvailable) { _logger.LogWarning("ToggleBroadcast - Lightfinder is not available."); + _mediator.Publish(new NotificationMessage( + "Broadcast Unavailable", + "Lightfinder is not available on this server.", + NotificationType.Error)); return; } await RequireConnectionAsync(nameof(ToggleBroadcast), async () => { var cooldown = RemainingCooldown; - if (!_config.Current.BroadcastEnabled && cooldown is { } cd && cd > TimeSpan.Zero) + if (!bypassCooldown && !_config.Current.BroadcastEnabled && cooldown is { } cd && cd > TimeSpan.Zero) { _logger.LogWarning("Cooldown active. Must wait {Remaining}s before re-enabling.", cd.TotalSeconds); + _mediator.Publish(new NotificationMessage( + "Broadcast Cooldown", + $"Please wait {cd.TotalSeconds:F0} seconds before re-enabling broadcast.", + NotificationType.Warning)); return; } @@ -427,10 +450,19 @@ public class BroadcastService : IHostedService, IMediatorSubscriber _logger.LogDebug("Toggling broadcast. Server currently broadcasting: {ServerStatus}, setting to: {NewStatus}", isCurrentlyBroadcasting, newStatus); _mediator.Publish(new EnableBroadcastMessage(hashedCid, newStatus)); + + _mediator.Publish(new NotificationMessage( + newStatus ? "Broadcast Enabled" : "Broadcast Disabled", + newStatus ? "Your Lightfinder broadcast has been enabled." : "Your Lightfinder broadcast has been disabled.", + NotificationType.Info)); } catch (Exception ex) { _logger.LogError(ex, "Failed to determine current broadcast status for toggle"); + _mediator.Publish(new NotificationMessage( + "Broadcast Toggle Failed", + $"Failed to toggle broadcast: {ex.Message}", + NotificationType.Error)); } }).ConfigureAwait(false); } @@ -493,6 +525,7 @@ public class BroadcastService : IHostedService, IMediatorSubscriber { _logger.LogDebug("Broadcast TTL expired. Disabling broadcast locally."); ApplyBroadcastDisabled(forcePublish: true); + ShowBroadcastExpiredNotification(); } } else @@ -501,4 +534,49 @@ public class BroadcastService : IHostedService, IMediatorSubscriber } }).ConfigureAwait(false); } + + private void ShowBroadcastExpiredNotification() + { + var notification = new LightlessNotification + { + Id = "broadcast_expired", + Title = "Broadcast Expired", + Message = "Your Lightfinder broadcast has expired after 3 hours. Would you like to re-enable it?", + Type = NotificationType.PairRequest, + Duration = TimeSpan.FromSeconds(180), + Actions = new List + { + new() + { + Id = "re_enable", + Label = "Re-enable", + Icon = FontAwesomeIcon.Plus, + Color = UIColors.Get("PairBlue"), + IsPrimary = true, + OnClick = (n) => + { + _logger.LogInformation("Re-enabling broadcast from notification"); + ToggleBroadcast(bypassCooldown: true); + n.IsDismissed = true; + n.IsAnimatingOut = true; + } + }, + new() + { + Id = "close", + Label = "Close", + Icon = FontAwesomeIcon.Times, + Color = UIColors.Get("DimRed"), + OnClick = (n) => + { + _logger.LogInformation("Broadcast expiration notification dismissed"); + n.IsDismissed = true; + n.IsAnimatingOut = true; + } + } + } + }; + + _mediator.Publish(new LightlessNotificationMessage(notification)); + } } \ No newline at end of file From dccd2cdc36bdeb378e0dbfcfba40af02b67c2213 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 22:52:46 +0200 Subject: [PATCH 28/64] changelog cleanup, credits tab --- .../{UI => }/Changelog/changelog.yaml | 38 +--------- LightlessSync/Changelog/credits.yaml | 35 +++++++++ LightlessSync/LightlessSync.csproj | 3 +- LightlessSync/UI/Models/Changelog.cs | 5 ++ LightlessSync/UI/UpdateNotesUi.cs | 76 +++++++++++-------- 5 files changed, 86 insertions(+), 71 deletions(-) rename LightlessSync/{UI => }/Changelog/changelog.yaml (84%) create mode 100644 LightlessSync/Changelog/credits.yaml diff --git a/LightlessSync/UI/Changelog/changelog.yaml b/LightlessSync/Changelog/changelog.yaml similarity index 84% rename from LightlessSync/UI/Changelog/changelog.yaml rename to LightlessSync/Changelog/changelog.yaml index a2af1f1..98134a1 100644 --- a/LightlessSync/UI/Changelog/changelog.yaml +++ b/LightlessSync/Changelog/changelog.yaml @@ -161,7 +161,6 @@ changelog: - "Right-click on Server Top Bar button to disconnect from Lightless." - "Shift+Left click on Server Top Bar button to open settings." - "Added colors section in settings to change accent colors." - - "Added pin option from Dalamud in the UI." - "Ability to pause syncing while in Instance/Duty." - "Functionality to create syncshell folders." - "Added self-threshold warning." @@ -172,39 +171,4 @@ changelog: - "Removed Pin/Remove/Ban buttons on Owners when viewing as moderator." - "Fixed nameplate bug in PvP." - "Added 1 or 3 day options for inactive check." - -credits: - - category: "Development Team" - items: - - name: "Choco" - role: "Cringe Developer" - - name: "Additional Contributors" - role: "Community Contributors & Bug Reporters" - - - category: "Plugin Integration & IPC Support" - items: - - name: "Penumbra Team" - role: "Mod framework integration" - - name: "Glamourer Team" - role: "Customization system integration" - - name: "Customize+ Team" - role: "Body scaling integration" - - name: "Simple Heels Team" - role: "Height offset integration" - - name: "Honorific Team" - role: "Title system integration" - - name: "Moodles Team" - role: "Status effect integration" - - name: "PetNicknames Team" - role: "Pet naming integration" - - name: "Brio Team" - role: "GPose enhancement integration" - - - category: "Special Thanks" - items: - - name: "Dalamud & XIVLauncher Teams" - role: "Plugin framework and infrastructure" - - name: "Community Supporters" - role: "Testing, feedback, and financial support" - - name: "Beta Testers" - role: "Early testing and bug reporting" \ No newline at end of file + - "Fixed bug where some users could not see their own syncshell folders." \ No newline at end of file diff --git a/LightlessSync/Changelog/credits.yaml b/LightlessSync/Changelog/credits.yaml new file mode 100644 index 0000000..b3b3e8c --- /dev/null +++ b/LightlessSync/Changelog/credits.yaml @@ -0,0 +1,35 @@ +credits: + - category: "Development Team" + items: + - name: "Choco" + role: "Cringe Developer" + - name: "Additional Contributors" + role: "Community Contributors & Bug Reporters" + + - category: "Plugin Integration & IPC Support" + items: + - name: "Penumbra Team" + role: "Mod framework integration" + - name: "Glamourer Team" + role: "Customization system integration" + - name: "Customize+ Team" + role: "Body scaling integration" + - name: "Simple Heels Team" + role: "Height offset integration" + - name: "Honorific Team" + role: "Title system integration" + - name: "Moodles Team" + role: "Status effect integration" + - name: "PetNicknames Team" + role: "Pet naming integration" + - name: "Brio Team" + role: "GPose enhancement integration" + + - category: "Special Thanks" + items: + - name: "Dalamud & XIVLauncher Teams" + role: "Plugin framework and infrastructure" + - name: "Community Supporters" + role: "Testing, feedback, and financial support" + - name: "Beta Testers" + role: "Early testing and bug reporting" diff --git a/LightlessSync/LightlessSync.csproj b/LightlessSync/LightlessSync.csproj index daf6cfd..b4b5288 100644 --- a/LightlessSync/LightlessSync.csproj +++ b/LightlessSync/LightlessSync.csproj @@ -65,7 +65,8 @@ PreserveNewest - + + diff --git a/LightlessSync/UI/Models/Changelog.cs b/LightlessSync/UI/Models/Changelog.cs index bf1a474..23d26c4 100644 --- a/LightlessSync/UI/Models/Changelog.cs +++ b/LightlessSync/UI/Models/Changelog.cs @@ -35,4 +35,9 @@ namespace LightlessSync.UI.Models public string Name { get; init; } = string.Empty; public string Role { get; init; } = string.Empty; } + + public class CreditsFile + { + public List Credits { get; init; } = new(); + } } \ No newline at end of file diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index 8345987..f25c38a 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -22,6 +22,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase private readonly UiSharedService _uiShared; private ChangelogFile _changelog = new(); + private CreditsFile _credits = new(); private bool _scrollToTop; private int _selectedTab; @@ -492,7 +493,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase if (!tabBar) return; - using (var changelogTab = ImRaii.TabItem("What's New")) + using (var changelogTab = ImRaii.TabItem("Changelog")) { if (changelogTab) { @@ -501,7 +502,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase } } - if (_changelog.Credits != null && _changelog.Credits.Count > 0) + if (_credits.Credits != null && _credits.Credits.Count > 0) { using (var creditsTab = ImRaii.TabItem("Credits")) { @@ -527,9 +528,9 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ImGui.PushTextWrapPos(); - if (_changelog.Credits != null) + if (_credits.Credits != null) { - foreach (var category in _changelog.Credits) + foreach (var category in _credits.Credits) { DrawCreditCategory(category); ImGuiHelpers.ScaledDummy(10); @@ -545,25 +546,19 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase { DrawFeatureSection(category.Category, UIColors.Get("LightlessBlue")); - ImGui.Indent(15f); - foreach (var item in category.Items) { - using (ImRaii.PushColor(ImGuiCol.Text, new Vector4(0.95f, 0.95f, 1.0f, 1.0f))) - { - ImGui.TextWrapped($"• {item.Name}"); - } - if (!string.IsNullOrEmpty(item.Role)) { - ImGui.SameLine(); - ImGui.TextColored(new Vector4(0.7f, 0.7f, 0.8f, 1.0f), $" — {item.Role}"); + ImGui.BulletText($"{item.Name} — {item.Role}"); + } + else + { + ImGui.BulletText(item.Name); } - - ImGuiHelpers.ScaledDummy(3); } - ImGui.Unindent(15f); + ImGuiHelpers.ScaledDummy(5); } private void DrawCloseButton() @@ -604,7 +599,9 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ImGui.PushTextWrapPos(); foreach (var entry in _changelog.Changelog) + { DrawChangelogEntry(entry); + } ImGui.PopTextWrapPos(); ImGui.Spacing(); @@ -617,7 +614,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ? UIColors.Get("LightlessGreen") : new Vector4(0.95f, 0.95f, 1.0f, 1.0f); - bool isOpen; var flags = entry.IsCurrent == true ? ImGuiTreeNodeFlags.DefaultOpen : ImGuiTreeNodeFlags.None; @@ -628,15 +624,15 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase using (ImRaii.PushColor(ImGuiCol.HeaderActive, UIColors.Get("LightlessPurpleActive"))) using (ImRaii.PushColor(ImGuiCol.Text, currentColor)) { - isOpen = ImGui.CollapsingHeader($" {entry.Name} — {entry.Date} ", flags); + var isOpen = ImGui.CollapsingHeader($" {entry.Name} — {entry.Date} ", flags); + + ImGui.SameLine(); + ImGui.TextColored(new Vector4(0.85f, 0.85f, 0.95f, 1.0f), $" — {entry.Tagline}"); + + if (!isOpen) + return; } - ImGui.SameLine(); - ImGui.TextColored(new Vector4(0.85f, 0.85f, 0.95f, 1.0f), $" — {entry.Tagline}"); - - if (!isOpen) - return; - ImGuiHelpers.ScaledDummy(8); if (!string.IsNullOrEmpty(entry.Message)) @@ -660,8 +656,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase ImGuiHelpers.ScaledDummy(5); } } - - ImGuiHelpers.ScaledDummy(8); } private static void DrawFeatureSection(string title, Vector4 accentColor) @@ -693,10 +687,15 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase 1.5f ); + // Calculate vertical centering + var textSize = ImGui.CalcTextSize(title); + var boxHeight = backgroundMax.Y - backgroundMin.Y; + var verticalOffset = (boxHeight - textSize.Y) / 5f; + ImGui.SetCursorPosX(ImGui.GetCursorPosX() + 8); - ImGui.Spacing(); + ImGui.SetCursorPosY(ImGui.GetCursorPosY() + verticalOffset); ImGui.TextColored(accentColor, title); - ImGui.Spacing(); + ImGui.SetCursorPosY(backgroundMax.Y - startPos.Y + ImGui.GetCursorPosY()); } private void LoadEmbeddedResources() @@ -704,17 +703,28 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase try { var assembly = Assembly.GetExecutingAssembly(); - using var changelogStream = assembly.GetManifestResourceStream("LightlessSync.UI.Changelog.changelog.yaml"); + var deserializer = new DeserializerBuilder() + .WithNamingConvention(CamelCaseNamingConvention.Instance) + .IgnoreUnmatchedProperties() + .Build(); + + // Load changelog + using var changelogStream = assembly.GetManifestResourceStream("LightlessSync.Changelog.changelog.yaml"); if (changelogStream != null) { using var reader = new StreamReader(changelogStream, Encoding.UTF8, true, 128); var yaml = reader.ReadToEnd(); - var deserializer = new DeserializerBuilder() - .WithNamingConvention(CamelCaseNamingConvention.Instance) - .IgnoreUnmatchedProperties() - .Build(); _changelog = deserializer.Deserialize(yaml) ?? new(); } + + // Load credits + using var creditsStream = assembly.GetManifestResourceStream("LightlessSync.Changelog.credits.yaml"); + if (creditsStream != null) + { + using var reader = new StreamReader(creditsStream, Encoding.UTF8, true, 128); + var yaml = reader.ReadToEnd(); + _credits = deserializer.Deserialize(yaml) ?? new(); + } } catch { From 9170b5205c78d58880f2f33fccc2ec0250092dde Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 22:54:56 +0200 Subject: [PATCH 29/64] removed temp changelog on loading --- LightlessSync/LightlessPlugin.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index dcc1990..617cfe3 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -155,12 +155,12 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService _runtimeServiceScope.ServiceProvider.GetRequiredService(); _runtimeServiceScope.ServiceProvider.GetRequiredService(); - // TODO: move this to a better place var ver = Assembly.GetExecutingAssembly().GetName().Version; var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}"; var lastSeen = _lightlessConfigService.Current.LastSeenVersion ?? string.Empty; Logger?.LogDebug("Last seen version: {lastSeen}, current version: {currentVersion}", lastSeen, currentVersion); - Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + // for testing c: + // Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); if (string.IsNullOrEmpty(lastSeen)) { From 8fdff1eb18cd66be7f2320918f5dd05e3b156c93 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 23:03:32 +0200 Subject: [PATCH 30/64] SHOWING changelog everytime till the got it button is pressed, should reappear on version updates according to the current settings --- LightlessSync/LightlessPlugin.cs | 20 ++++++-------------- LightlessSync/UI/UpdateNotesUi.cs | 8 ++++++++ 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index 617cfe3..9dc0f99 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -159,22 +159,14 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}"; var lastSeen = _lightlessConfigService.Current.LastSeenVersion ?? string.Empty; Logger?.LogDebug("Last seen version: {lastSeen}, current version: {currentVersion}", lastSeen, currentVersion); - // for testing c: - // Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); - if (string.IsNullOrEmpty(lastSeen)) + // Show update notes if version has changed and user has valid setup + if (!string.IsNullOrEmpty(lastSeen) && + !string.Equals(lastSeen, currentVersion, StringComparison.Ordinal) && + _lightlessConfigService.Current.HasValidSetup() && + _serverConfigurationManager.HasValidConfig()) { - _lightlessConfigService.Current.LastSeenVersion = currentVersion; - _lightlessConfigService.Save(); - } - else if (!string.Equals(lastSeen, currentVersion, StringComparison.Ordinal)) - { - if (_lightlessConfigService.Current.HasValidSetup() && _serverConfigurationManager.HasValidConfig()) - { - Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); - } - _lightlessConfigService.Current.LastSeenVersion = currentVersion; - _lightlessConfigService.Save(); + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); } #if !DEBUG diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index f25c38a..ab35177 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -20,6 +20,7 @@ namespace LightlessSync.UI; public class UpdateNotesUi : WindowMediatorSubscriberBase { private readonly UiSharedService _uiShared; + private readonly LightlessConfigService _configService; private ChangelogFile _changelog = new(); private CreditsFile _credits = new(); @@ -65,6 +66,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase : base(logger, mediator, "Lightless Sync — Update Notes", performanceCollectorService) { _uiShared = uiShared; + _configService = configService; AllowClickthrough = false; AllowPinning = false; @@ -576,6 +578,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase { if (ImGui.Button("Got it!", new Vector2(closeWidth, closeHeight))) { + // Update last seen version when user acknowledges the update notes + var ver = Assembly.GetExecutingAssembly().GetName().Version; + var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}"; + _configService.Current.LastSeenVersion = currentVersion; + _configService.Save(); + IsOpen = false; } } From 2d094404df5279c138eb1e234824977b1e4468bd Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 23:21:14 +0200 Subject: [PATCH 31/64] proper version checker on plugin laoding --- LightlessSync/LightlessPlugin.cs | 36 +++++++++++++++++++------------- 1 file changed, 21 insertions(+), 15 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index 9dc0f99..327c4a6 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -9,6 +9,7 @@ using LightlessSync.UI; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; +using Serilog; using System.Reflection; namespace LightlessSync; @@ -101,6 +102,8 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService UIColors.Initialize(_lightlessConfigService); Mediator.StartQueueProcessing(); + + CheckVersion(); return Task.CompletedTask; } @@ -115,6 +118,24 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService return Task.CompletedTask; } + + private void CheckVersion() + { + var ver = Assembly.GetExecutingAssembly().GetName().Version; + var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}"; + var lastSeen = _lightlessConfigService.Current.LastSeenVersion ?? string.Empty; + Logger.LogInformation("Last seen version: {lastSeen}, current version: {currentVersion}", lastSeen, currentVersion); + Logger.LogInformation("User has valid setup: {hasValidSetup}", _lightlessConfigService.Current.HasValidSetup()); + Logger.LogInformation("Server has valid config: {hasValidConfig}", _serverConfigurationManager.HasValidConfig()); + // Show update notes if version has changed and user has valid setup + if (!string.IsNullOrEmpty(lastSeen) && + !string.Equals(lastSeen, currentVersion, StringComparison.Ordinal) && + _lightlessConfigService.Current.HasValidSetup() && + _serverConfigurationManager.HasValidConfig()) + { + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + } + } private void DalamudUtilOnLogIn() { @@ -154,21 +175,6 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService _runtimeServiceScope.ServiceProvider.GetRequiredService(); _runtimeServiceScope.ServiceProvider.GetRequiredService(); _runtimeServiceScope.ServiceProvider.GetRequiredService(); - - var ver = Assembly.GetExecutingAssembly().GetName().Version; - var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}"; - var lastSeen = _lightlessConfigService.Current.LastSeenVersion ?? string.Empty; - Logger?.LogDebug("Last seen version: {lastSeen}, current version: {currentVersion}", lastSeen, currentVersion); - - // Show update notes if version has changed and user has valid setup - if (!string.IsNullOrEmpty(lastSeen) && - !string.Equals(lastSeen, currentVersion, StringComparison.Ordinal) && - _lightlessConfigService.Current.HasValidSetup() && - _serverConfigurationManager.HasValidConfig()) - { - Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); - } - #if !DEBUG if (_lightlessConfigService.Current.LogLevel != LogLevel.Information) { From f1af6601cc87461f9063b0e97b3764248193f25a Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 23:30:06 +0200 Subject: [PATCH 32/64] removed null check --- LightlessSync/LightlessPlugin.cs | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index 327c4a6..06cb3ef 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -128,12 +128,19 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService Logger.LogInformation("User has valid setup: {hasValidSetup}", _lightlessConfigService.Current.HasValidSetup()); Logger.LogInformation("Server has valid config: {hasValidConfig}", _serverConfigurationManager.HasValidConfig()); // Show update notes if version has changed and user has valid setup - if (!string.IsNullOrEmpty(lastSeen) && - !string.Equals(lastSeen, currentVersion, StringComparison.Ordinal) && + if (!string.Equals(lastSeen, currentVersion, StringComparison.Ordinal) && _lightlessConfigService.Current.HasValidSetup() && _serverConfigurationManager.HasValidConfig()) { - Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + // Update the last seen version to current version + _lightlessConfigService.Current.LastSeenVersion = currentVersion; + _lightlessConfigService.Save(); + + // Only show update notes if this isn't the first run + if (!string.IsNullOrEmpty(lastSeen)) + { + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + } } } From ea8f8e389573d63bbb52e7d5ad21d39713bf2d51 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 23:34:10 +0200 Subject: [PATCH 33/64] last null check removal --- LightlessSync/LightlessPlugin.cs | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index 06cb3ef..5d74e01 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -132,15 +132,7 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService _lightlessConfigService.Current.HasValidSetup() && _serverConfigurationManager.HasValidConfig()) { - // Update the last seen version to current version - _lightlessConfigService.Current.LastSeenVersion = currentVersion; - _lightlessConfigService.Save(); - - // Only show update notes if this isn't the first run - if (!string.IsNullOrEmpty(lastSeen)) - { - Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); - } + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); } } From 8a3902ec2b38bd0643d0e712adb7759c99d4f461 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 16 Oct 2025 23:44:15 +0200 Subject: [PATCH 34/64] init change :) --- LightlessSync/LightlessPlugin.cs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/LightlessSync/LightlessPlugin.cs b/LightlessSync/LightlessPlugin.cs index 5d74e01..fe7e9a4 100644 --- a/LightlessSync/LightlessPlugin.cs +++ b/LightlessSync/LightlessPlugin.cs @@ -103,8 +103,6 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService UIColors.Initialize(_lightlessConfigService); Mediator.StartQueueProcessing(); - CheckVersion(); - return Task.CompletedTask; } @@ -128,6 +126,7 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService Logger.LogInformation("User has valid setup: {hasValidSetup}", _lightlessConfigService.Current.HasValidSetup()); Logger.LogInformation("Server has valid config: {hasValidConfig}", _serverConfigurationManager.HasValidConfig()); // Show update notes if version has changed and user has valid setup + if (!string.Equals(lastSeen, currentVersion, StringComparison.Ordinal) && _lightlessConfigService.Current.HasValidSetup() && _serverConfigurationManager.HasValidConfig()) @@ -174,6 +173,8 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService _runtimeServiceScope.ServiceProvider.GetRequiredService(); _runtimeServiceScope.ServiceProvider.GetRequiredService(); _runtimeServiceScope.ServiceProvider.GetRequiredService(); + CheckVersion(); + #if !DEBUG if (_lightlessConfigService.Current.LogLevel != LogLevel.Information) { From 47b7ecd5214e313f3eb0211efeaa2879143eca94 Mon Sep 17 00:00:00 2001 From: choco Date: Fri, 17 Oct 2025 15:36:50 +0200 Subject: [PATCH 35/64] forced current changelog version to be opened on default --- LightlessSync/Changelog/changelog.yaml | 11 ++------ LightlessSync/UI/UpdateNotesUi.cs | 35 ++++++++++++++++---------- 2 files changed, 24 insertions(+), 22 deletions(-) diff --git a/LightlessSync/Changelog/changelog.yaml b/LightlessSync/Changelog/changelog.yaml index 98134a1..2cdbf6a 100644 --- a/LightlessSync/Changelog/changelog.yaml +++ b/LightlessSync/Changelog/changelog.yaml @@ -4,7 +4,8 @@ changelog: - name: "v1.12.3" tagline: "FILLER" date: "October 15th 2025" - is_current: true + # be sure to set this every new version + isCurrent: true versions: - number: "New Features" icon: "" @@ -22,7 +23,6 @@ changelog: - name: "v1.12.2" tagline: "LightFinder fixes, Notifications overhaul" date: "October 12th 2025" - is_current: false versions: - number: "LightFinder" icon: "" @@ -50,7 +50,6 @@ changelog: - name: "v1.12.1" tagline: "LightFinder customization and download limiter" date: "October 8th 2025" - is_current: false versions: - number: "New Features" icon: "" @@ -69,7 +68,6 @@ changelog: - name: "v1.12.0" tagline: "LightFinder - Major feature release" date: "October 5th 2025" - is_current: false versions: - number: "Major Features" icon: "" @@ -96,7 +94,6 @@ changelog: - name: "v1.11.12" tagline: "Syncshell grouping and performance options" date: "September 16th 2025" - is_current: false versions: - number: "New Features" icon: "" @@ -118,7 +115,6 @@ changelog: - name: "v1.11.9" tagline: "File cache improvements" date: "September 13th 2025" - is_current: false versions: - number: "Bug Fixes" icon: "" @@ -129,7 +125,6 @@ changelog: - name: "v1.11.8" tagline: "Hotfix - UI and exception handling" date: "September 12th 2025" - is_current: false versions: - number: "Bug Fixes" icon: "" @@ -141,7 +136,6 @@ changelog: - name: "v1.11.7" tagline: "Hotfix - UI loading and warnings" date: "September 12th 2025" - is_current: false versions: - number: "Bug Fixes" icon: "" @@ -152,7 +146,6 @@ changelog: - name: "v1.11.6" tagline: "Admin panel rework and new features" date: "September 11th 2025" - is_current: false versions: - number: "New Features" icon: "" diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index ab35177..57dd173 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -26,6 +26,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase private CreditsFile _credits = new(); private bool _scrollToTop; private int _selectedTab; + private bool _hasInitializedCollapsingHeaders; private struct Particle { @@ -65,6 +66,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase PerformanceCollectorService performanceCollectorService) : base(logger, mediator, "Lightless Sync — Update Notes", performanceCollectorService) { + logger.LogInformation("UpdateNotesUi constructor called"); _uiShared = uiShared; _configService = configService; @@ -82,11 +84,13 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase }; LoadEmbeddedResources(); + logger.LogInformation("UpdateNotesUi constructor completed successfully"); } public override void OnOpen() { _scrollToTop = true; + _hasInitializedCollapsingHeaders = false; } protected override void DrawInternal() @@ -108,7 +112,6 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var headerStart = windowPos + new Vector2(windowPadding.X, windowPadding.Y); var headerEnd = headerStart + new Vector2(headerWidth, HeaderHeight); - var headerSize = new Vector2(headerWidth, HeaderHeight); var extendedParticleSize = new Vector2(headerWidth, HeaderHeight + ExtendedParticleHeight); @@ -610,6 +613,8 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase { DrawChangelogEntry(entry); } + + _hasInitializedCollapsingHeaders = true; ImGui.PopTextWrapPos(); ImGui.Spacing(); @@ -618,28 +623,32 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase private void DrawChangelogEntry(ChangelogEntry entry) { - var currentColor = entry.IsCurrent == true + var isCurrent = entry.IsCurrent ?? false; + + var currentColor = isCurrent ? UIColors.Get("LightlessGreen") : new Vector4(0.95f, 0.95f, 1.0f, 1.0f); - - var flags = entry.IsCurrent == true - ? ImGuiTreeNodeFlags.DefaultOpen - : ImGuiTreeNodeFlags.None; - + + var flags = isCurrent ? ImGuiTreeNodeFlags.DefaultOpen : ImGuiTreeNodeFlags.None; + + if (!_hasInitializedCollapsingHeaders) + { + ImGui.SetNextItemOpen(isCurrent, ImGuiCond.Always); + } + + bool isOpen; using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 4f)) using (ImRaii.PushColor(ImGuiCol.Header, UIColors.Get("ButtonDefault"))) - using (ImRaii.PushColor(ImGuiCol.HeaderHovered, UIColors.Get("LightlessPurple"))) - using (ImRaii.PushColor(ImGuiCol.HeaderActive, UIColors.Get("LightlessPurpleActive"))) using (ImRaii.PushColor(ImGuiCol.Text, currentColor)) { - var isOpen = ImGui.CollapsingHeader($" {entry.Name} — {entry.Date} ", flags); + isOpen = ImGui.CollapsingHeader($" {entry.Name} — {entry.Date} ", flags); ImGui.SameLine(); ImGui.TextColored(new Vector4(0.85f, 0.85f, 0.95f, 1.0f), $" — {entry.Tagline}"); - - if (!isOpen) - return; } + + if (!isOpen) + return; ImGuiHelpers.ScaledDummy(8); From 44177ab7bd03799fa388ee299d94e62ca1df1e4e Mon Sep 17 00:00:00 2001 From: choco Date: Fri, 17 Oct 2025 20:07:14 +0200 Subject: [PATCH 36/64] broadcast bypass toggle gone --- LightlessSync/Services/BroadcastService.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/LightlessSync/Services/BroadcastService.cs b/LightlessSync/Services/BroadcastService.cs index cad09dd..81e54d5 100644 --- a/LightlessSync/Services/BroadcastService.cs +++ b/LightlessSync/Services/BroadcastService.cs @@ -403,7 +403,7 @@ public class BroadcastService : IHostedService, IMediatorSubscriber - public async void ToggleBroadcast(bool bypassCooldown = false) + public async void ToggleBroadcast() { if (!IsLightFinderAvailable) @@ -419,7 +419,7 @@ public class BroadcastService : IHostedService, IMediatorSubscriber await RequireConnectionAsync(nameof(ToggleBroadcast), async () => { var cooldown = RemainingCooldown; - if (!bypassCooldown && !_config.Current.BroadcastEnabled && cooldown is { } cd && cd > TimeSpan.Zero) + if (!_config.Current.BroadcastEnabled && cooldown is { } cd && cd > TimeSpan.Zero) { _logger.LogWarning("Cooldown active. Must wait {Remaining}s before re-enabling.", cd.TotalSeconds); _mediator.Publish(new NotificationMessage( @@ -556,7 +556,7 @@ public class BroadcastService : IHostedService, IMediatorSubscriber OnClick = (n) => { _logger.LogInformation("Re-enabling broadcast from notification"); - ToggleBroadcast(bypassCooldown: true); + ToggleBroadcast(); n.IsDismissed = true; n.IsAnimatingOut = true; } From edb7232b172d7bda930aee82b8c252782a276a23 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 19 Oct 2025 16:55:42 +0200 Subject: [PATCH 37/64] Added nsfw in group profile editor. --- .../Services/LightlessGroupProfileData.cs | 2 +- .../Services/LightlessProfileManager.cs | 19 +++++++++++++++---- LightlessSync/UI/SyncshellAdminUI.cs | 18 +++++++++--------- .../SignalR/ApiController.Functions.Groups.cs | 2 +- 4 files changed, 26 insertions(+), 15 deletions(-) diff --git a/LightlessSync/Services/LightlessGroupProfileData.cs b/LightlessSync/Services/LightlessGroupProfileData.cs index 5a4c01a..2a42e0a 100644 --- a/LightlessSync/Services/LightlessGroupProfileData.cs +++ b/LightlessSync/Services/LightlessGroupProfileData.cs @@ -1,6 +1,6 @@ namespace LightlessSync.Services; -public record LightlessGroupProfileData(string Base64ProfilePicture, string Description, string Tags) +public record LightlessGroupProfileData(string Base64ProfilePicture, string Description, string Tags, bool IsNsfw, bool IsDisabled) { public Lazy ImageData { get; } = new Lazy(Convert.FromBase64String(Base64ProfilePicture)); } diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index dde664b..69ad8e7 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -20,6 +20,7 @@ public class LightlessProfileManager : MediatorSubscriberBase private const string _noGroupDescription = "-- Syncshell has no description set --"; private const string _noTags = "-- Syncshell has no tags set --"; private const string _nsfwDescription = "Profile not displayed - NSFW"; + private readonly ApiController _apiController; private readonly ILogger _logger; private readonly LightlessConfigService _lightlessConfigService; @@ -28,9 +29,10 @@ public class LightlessProfileManager : MediatorSubscriberBase private readonly LightlessUserProfileData _defaultProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noUserDescription); private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, "Loading User Profile Data from server..."); - private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Syncshell Profile Data from server...", string.Empty); - private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, string.Empty); - private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoNsfw, string.Empty, _nsfwDescription); + private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Syncshell Profile Data from server...", string.Empty, IsNsfw: false, IsDisabled: false); + private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, string.Empty, IsNsfw: false, IsDisabled: false); + private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: true, _lightlessLogoNsfw, string.Empty, _nsfwDescription); + private readonly LightlessGroupProfileData _nsfwProfileGroupData = new(_lightlessLogoNsfw, string.Empty, _nsfwDescription, IsNsfw: false, IsDisabled: false); public LightlessProfileManager(ILogger logger, LightlessConfigService lightlessConfigService, @@ -164,9 +166,18 @@ public class LightlessProfileManager : MediatorSubscriberBase LightlessGroupProfileData profileGroupData = new(Base64ProfilePicture: string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, Description: string.IsNullOrEmpty(profile.Description) ? _noGroupDescription : profile.Description, - Tags: string.IsNullOrEmpty(profile.Tags) ? _noTags : profile.Tags); + Tags: string.IsNullOrEmpty(profile.Tags) ? _noTags : profile.Tags, + profile.IsNsfw ?? false, profile.IsDisabled ?? false); _logger.LogTrace("Replacing data in _lightlessGroupProfiles for Group {data}", data.AliasOrGID); + if (profileGroupData.IsNsfw && !_lightlessConfigService.Current.ProfilesAllowNsfw) + { + _lightlessGroupProfiles[data] = _nsfwProfileGroupData; + } + else + { + _lightlessGroupProfiles[data] = profileGroupData; + } _lightlessGroupProfiles[data] = profileGroupData; } catch (Exception ex) diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 141510b..6391043 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -300,7 +300,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase } _showFileDialogError = false; - await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, Convert.ToBase64String(fileContent))) + await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, Convert.ToBase64String(fileContent), IsNsfw: null, IsDisabled: null)) .ConfigureAwait(false); } }); @@ -310,7 +310,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, IsNsfw: null, IsDisabled: null)); } UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); if (_showFileDialogError) @@ -361,21 +361,21 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: _descriptionText, Tags: null, PictureBase64: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: _descriptionText, Tags: null, PictureBase64: null, IsNsfw: null, IsDisabled: null)); } UiSharedService.AttachToolTip("Sets your profile description text"); ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, IsNsfw: null, IsDisabled: null)); } UiSharedService.AttachToolTip("Clears your profile description text"); ImGui.Separator(); ImGui.TextUnformatted($"Profile Options:"); - var isNsfw = false; + var isNsfw = _profileData.; if (ImGui.Checkbox("Profile is NSFW", ref isNsfw)) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, isNsfw, ProfilePictureBase64: null, Description: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, IsNsfw: isNsfw, IsDisabled: null)); } _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); ImGui.TreePop(); @@ -734,15 +734,15 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { if (HasTag) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)); _selectedTags.Add(tag); } else { _ = _selectedTags.Count > 0 - ? _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null)) - : _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: string.Empty, PictureBase64: null)); + ? _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)) + : _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: string.Empty, PictureBase64: null, IsNsfw: null, IsDisabled: null)); _selectedTags.Remove(tag); } diff --git a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs index 79de11e..95bb8e2 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs @@ -117,7 +117,7 @@ public partial class ApiController } public async Task GroupGetProfile(GroupDto dto) { - if (!IsConnected) return new GroupProfileDto(Group: dto.Group, Description: null, Tags: null, PictureBase64: null); + if (!IsConnected) return new GroupProfileDto(Group: dto.Group, Description: null, Tags: null, PictureBase64: null, IsNsfw: false, IsDisabled: false); return await _lightlessHub!.InvokeAsync(nameof(GroupGetProfile), dto).ConfigureAwait(false); } From 477f5aa6e715f1ff0bcb6b69fe998324f5fcf091 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 19 Oct 2025 18:41:02 +0200 Subject: [PATCH 38/64] Fixed some stuff --- LightlessSync/Services/LightlessProfileManager.cs | 12 +++++------- LightlessSync/UI/SyncshellAdminUI.cs | 13 ++++--------- .../SignalR/ApiController.Functions.Groups.cs | 4 ++-- 3 files changed, 11 insertions(+), 18 deletions(-) diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index 69ad8e7..161b224 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -18,9 +18,8 @@ public class LightlessProfileManager : MediatorSubscriberBase private const string _lightlessSupporter = "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"; private const string _noUserDescription = "-- User has no description set --"; private const string _noGroupDescription = "-- Syncshell has no description set --"; - private const string _noTags = "-- Syncshell has no tags set --"; private const string _nsfwDescription = "Profile not displayed - NSFW"; - + private const string _loadingData = "Loading Profile Data from server..."; private readonly ApiController _apiController; private readonly ILogger _logger; private readonly LightlessConfigService _lightlessConfigService; @@ -28,12 +27,11 @@ public class LightlessProfileManager : MediatorSubscriberBase private readonly ConcurrentDictionary _lightlessGroupProfiles = new(GroupDataComparer.Instance); private readonly LightlessUserProfileData _defaultProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noUserDescription); - private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, "Loading User Profile Data from server..."); - private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, "Loading Syncshell Profile Data from server...", string.Empty, IsNsfw: false, IsDisabled: false); + private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, _loadingData); + private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, _loadingData, string.Empty, IsNsfw: false, IsDisabled: false); private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, string.Empty, IsNsfw: false, IsDisabled: false); private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: true, _lightlessLogoNsfw, string.Empty, _nsfwDescription); - private readonly LightlessGroupProfileData _nsfwProfileGroupData = new(_lightlessLogoNsfw, string.Empty, _nsfwDescription, IsNsfw: false, IsDisabled: false); - + private readonly LightlessGroupProfileData _nsfwProfileGroupData = new(_lightlessLogoNsfw, _nsfwDescription, string.Empty, IsNsfw: false, IsDisabled: false); public LightlessProfileManager(ILogger logger, LightlessConfigService lightlessConfigService, LightlessMediator mediator, ApiController apiController) : base(logger, mediator) @@ -166,7 +164,7 @@ public class LightlessProfileManager : MediatorSubscriberBase LightlessGroupProfileData profileGroupData = new(Base64ProfilePicture: string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, Description: string.IsNullOrEmpty(profile.Description) ? _noGroupDescription : profile.Description, - Tags: string.IsNullOrEmpty(profile.Tags) ? _noTags : profile.Tags, + Tags: string.IsNullOrEmpty(profile.Tags) ? string.Empty : profile.Tags, profile.IsNsfw ?? false, profile.IsDisabled ?? false); _logger.LogTrace("Replacing data in _lightlessGroupProfiles for Group {data}", data.AliasOrGID); diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 6391043..ffb6443 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -49,7 +49,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private Task? _pruneTestTask; private Task? _pruneTask; private int _pruneDays = 14; - private readonly List _allowedTags = ["Apex", "Predator", "Tavern", "NSFW", "SFW"]; + private readonly List _allowedTags = ["SFW", "NSFW", "RP", "ERP", "Venues", "Gpose"]; private List _selectedTags = []; public SyncshellAdminUI(ILogger logger, LightlessMediator mediator, ApiController apiController, @@ -372,7 +372,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase UiSharedService.AttachToolTip("Clears your profile description text"); ImGui.Separator(); ImGui.TextUnformatted($"Profile Options:"); - var isNsfw = _profileData.; + var isNsfw = _profileData.IsNsfw; if (ImGui.Checkbox("Profile is NSFW", ref isNsfw)) { _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, IsNsfw: isNsfw, IsDisabled: null)); @@ -734,24 +734,19 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { if (HasTag) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)); - _selectedTags.Add(tag); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)); } else { - _ = _selectedTags.Count > 0 - ? _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)) - : _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: string.Empty, PictureBase64: null, IsNsfw: null, IsDisabled: null)); - _selectedTags.Remove(tag); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)); } } } private void GetTagsFromProfile() { - _selectedTags = []; if (_profileData != null) { _selectedTags = StringToList(_profileData.Tags, ","); diff --git a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs index 95bb8e2..2ffa15a 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs @@ -117,13 +117,14 @@ public partial class ApiController } public async Task GroupGetProfile(GroupDto dto) { + CheckConnection(); if (!IsConnected) return new GroupProfileDto(Group: dto.Group, Description: null, Tags: null, PictureBase64: null, IsNsfw: false, IsDisabled: false); return await _lightlessHub!.InvokeAsync(nameof(GroupGetProfile), dto).ConfigureAwait(false); } public async Task GroupSetProfile(GroupProfileDto dto) { - if (!IsConnected) return; + CheckConnection(); await _lightlessHub!.InvokeAsync(nameof(GroupSetProfile), dto).ConfigureAwait(false); } @@ -150,7 +151,6 @@ public partial class ApiController .ConfigureAwait(false); } - private void CheckConnection() { if (ServerState is not (ServerState.Connected or ServerState.Connecting or ServerState.Reconnecting)) throw new InvalidDataException("Not connected"); From d72cc207e195c7da6082cc503f9617e877689f33 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 19 Oct 2025 18:53:31 +0200 Subject: [PATCH 39/64] Made tags an array of integers instead of strings --- .../Services/LightlessGroupProfileData.cs | 2 +- .../Services/LightlessProfileManager.cs | 15 ++++--- LightlessSync/UI/JoinSyncshellUI.cs | 1 - LightlessSync/UI/ProfileTags.cs | 12 ++++++ LightlessSync/UI/SyncshellAdminUI.cs | 39 +++++++------------ 5 files changed, 36 insertions(+), 33 deletions(-) create mode 100644 LightlessSync/UI/ProfileTags.cs diff --git a/LightlessSync/Services/LightlessGroupProfileData.cs b/LightlessSync/Services/LightlessGroupProfileData.cs index 2a42e0a..1b27b40 100644 --- a/LightlessSync/Services/LightlessGroupProfileData.cs +++ b/LightlessSync/Services/LightlessGroupProfileData.cs @@ -1,6 +1,6 @@ namespace LightlessSync.Services; -public record LightlessGroupProfileData(string Base64ProfilePicture, string Description, string Tags, bool IsNsfw, bool IsDisabled) +public record LightlessGroupProfileData(string Base64ProfilePicture, string Description, int[] Tags, bool IsNsfw, bool IsDisabled) { public Lazy ImageData { get; } = new Lazy(Convert.FromBase64String(Base64ProfilePicture)); } diff --git a/LightlessSync/Services/LightlessProfileManager.cs b/LightlessSync/Services/LightlessProfileManager.cs index 161b224..00b610b 100644 --- a/LightlessSync/Services/LightlessProfileManager.cs +++ b/LightlessSync/Services/LightlessProfileManager.cs @@ -28,10 +28,10 @@ public class LightlessProfileManager : MediatorSubscriberBase private readonly LightlessUserProfileData _defaultProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogo, string.Empty, _noUserDescription); private readonly LightlessUserProfileData _loadingProfileUserData = new(IsFlagged: false, IsNSFW: false, _lightlessLogoLoading, string.Empty, _loadingData); - private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, _loadingData, string.Empty, IsNsfw: false, IsDisabled: false); - private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, string.Empty, IsNsfw: false, IsDisabled: false); + private readonly LightlessGroupProfileData _loadingProfileGroupData = new(_lightlessLogoLoading, _loadingData, [], IsNsfw: false, IsDisabled: false); + private readonly LightlessGroupProfileData _defaultProfileGroupData = new(_lightlessLogo, _noGroupDescription, [], IsNsfw: false, IsDisabled: false); private readonly LightlessUserProfileData _nsfwProfileUserData = new(IsFlagged: false, IsNSFW: true, _lightlessLogoNsfw, string.Empty, _nsfwDescription); - private readonly LightlessGroupProfileData _nsfwProfileGroupData = new(_lightlessLogoNsfw, _nsfwDescription, string.Empty, IsNsfw: false, IsDisabled: false); + private readonly LightlessGroupProfileData _nsfwProfileGroupData = new(_lightlessLogoNsfw, _nsfwDescription, [], IsNsfw: false, IsDisabled: false); public LightlessProfileManager(ILogger logger, LightlessConfigService lightlessConfigService, LightlessMediator mediator, ApiController apiController) : base(logger, mediator) @@ -162,10 +162,13 @@ public class LightlessProfileManager : MediatorSubscriberBase _lightlessGroupProfiles[data] = _loadingProfileGroupData; var profile = await _apiController.GroupGetProfile(new API.Dto.Group.GroupDto(data)).ConfigureAwait(false); - LightlessGroupProfileData profileGroupData = new(Base64ProfilePicture: string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, + LightlessGroupProfileData profileGroupData = new( + Base64ProfilePicture: string.IsNullOrEmpty(profile.PictureBase64) ? _lightlessLogo : profile.PictureBase64, Description: string.IsNullOrEmpty(profile.Description) ? _noGroupDescription : profile.Description, - Tags: string.IsNullOrEmpty(profile.Tags) ? string.Empty : profile.Tags, - profile.IsNsfw ?? false, profile.IsDisabled ?? false); + Tags: profile.Tags ?? [], + profile.IsNsfw ?? false, + profile.IsDisabled ?? false + ); _logger.LogTrace("Replacing data in _lightlessGroupProfiles for Group {data}", data.AliasOrGID); if (profileGroupData.IsNsfw && !_lightlessConfigService.Current.ProfilesAllowNsfw) diff --git a/LightlessSync/UI/JoinSyncshellUI.cs b/LightlessSync/UI/JoinSyncshellUI.cs index e4f7132..a500687 100644 --- a/LightlessSync/UI/JoinSyncshellUI.cs +++ b/LightlessSync/UI/JoinSyncshellUI.cs @@ -110,7 +110,6 @@ internal class JoinSyncshellUI : WindowMediatorSubscriberBase ? Convert.FromBase64String(_lightlessLogo) : Convert.FromBase64String(_groupProfile.PictureBase64); string? profileDescription = string.IsNullOrEmpty(_groupProfile.Description) ? _defaultDescription : _groupProfile.Description; - string? profileTags = string.IsNullOrEmpty(_groupProfile.Description) ? _defaultTags : _groupProfile.Tags; _pfpTextureWrap?.Dispose(); _pfpTextureWrap = _uiSharedService.LoadImage(profilePicture); diff --git a/LightlessSync/UI/ProfileTags.cs b/LightlessSync/UI/ProfileTags.cs new file mode 100644 index 0000000..9fe4d6c --- /dev/null +++ b/LightlessSync/UI/ProfileTags.cs @@ -0,0 +1,12 @@ +namespace LightlessSync.UI +{ + public enum ProfileTags + { + SFW = 0, + NSFW = 1, + RP = 2, + ERP = 3, + Venues = 4, + Gpose = 5 + } +} \ No newline at end of file diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index ffb6443..4c1feb8 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -49,8 +49,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase private Task? _pruneTestTask; private Task? _pruneTask; private int _pruneDays = 14; - private readonly List _allowedTags = ["SFW", "NSFW", "RP", "ERP", "Venues", "Gpose"]; - private List _selectedTags = []; + private List _selectedTags = []; public SyncshellAdminUI(ILogger logger, LightlessMediator mediator, ApiController apiController, UiSharedService uiSharedService, PairManager pairManager, GroupFullInfoDto groupFullInfo, PerformanceCollectorService performanceCollectorService, LightlessProfileManager lightlessProfileManager, FileDialogManager fileDialogManager) @@ -321,7 +320,11 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase ImGui.TextUnformatted($"Tags:"); var childFrameLocal = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 200); - foreach (string tag in _allowedTags) + var allCategoryIndexes = Enum.GetValues() + .Cast() + .ToList(); + + foreach(int tag in allCategoryIndexes) { using (ImRaii.PushId($"tag-{tag}")) DrawTag(tag); } @@ -727,20 +730,22 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase } inviteTab.Dispose(); } - private void DrawTag(string tag) + private void DrawTag(int tag) { - var HasTag = _selectedTags.Contains(tag, StringComparer.Ordinal); - if (ImGui.Checkbox(tag, ref HasTag)) + var HasTag = _selectedTags.Contains(tag); + var tagName = (ProfileTags)tag; + + if (ImGui.Checkbox(tagName.ToString(), ref HasTag)) { if (HasTag) { _selectedTags.Add(tag); - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: _selectedTags.ToArray(), PictureBase64: null, IsNsfw: null, IsDisabled: null)); } else { _selectedTags.Remove(tag); - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: ListToString(_selectedTags, ","), PictureBase64: null, IsNsfw: null, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: _selectedTags.ToArray(), PictureBase64: null, IsNsfw: null, IsDisabled: null)); } } } @@ -749,26 +754,10 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { if (_profileData != null) { - _selectedTags = StringToList(_profileData.Tags, ","); + _selectedTags = [.. _profileData.Tags]; } } - private static string ListToString(List list, string delimiter) - { - if (list == null || list.Count == 0) - return string.Empty; - - return string.Join(delimiter, list); - } - - public static List StringToList(string input, string delimiter) - { - if (string.IsNullOrEmpty(input)) - return []; - - return [.. input.Split([delimiter], StringSplitOptions.None)]; - } - public override void OnClose() { Mediator.Publish(new RemoveWindowMessage(this)); From 547db3a76b998ef427e7a27dd1b93d5f659d83c7 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 19 Oct 2025 21:10:07 +0200 Subject: [PATCH 40/64] Added tag calls for new api changes --- LightlessSync/UI/EditProfileUi.cs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/LightlessSync/UI/EditProfileUi.cs b/LightlessSync/UI/EditProfileUi.cs index a8513f3..44c314a 100644 --- a/LightlessSync/UI/EditProfileUi.cs +++ b/LightlessSync/UI/EditProfileUi.cs @@ -206,7 +206,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase } _showFileDialogError = false; - await _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, Convert.ToBase64String(fileContent), Description: null)) + await _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, Convert.ToBase64String(fileContent), Description: null, Tags: null)) .ConfigureAwait(false); }); }); @@ -215,7 +215,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, "", Description: null)); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, "", Description: null, Tags: null)); } UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); if (_showFileDialogError) @@ -225,7 +225,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase var isNsfw = profile.IsNSFW; if (ImGui.Checkbox("Profile is NSFW", ref isNsfw)) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, isNsfw, ProfilePictureBase64: null, Description: null)); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, isNsfw, ProfilePictureBase64: null, Description: null, Tags: null)); } _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); var widthTextBox = 400; @@ -264,13 +264,13 @@ public class EditProfileUi : WindowMediatorSubscriberBase if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, _descriptionText)); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, _descriptionText, Tags: null)); } UiSharedService.AttachToolTip("Sets your profile description text"); ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, "")); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, "", Tags: null)); } UiSharedService.AttachToolTip("Clears your profile description text"); From aa2b82838663fccdd3224bc874227a5359d2128e Mon Sep 17 00:00:00 2001 From: azyges <229218900+azyges@users.noreply.github.com> Date: Mon, 20 Oct 2025 04:20:11 +0900 Subject: [PATCH 41/64] init --- LightlessSync/FileCache/FileCacheManager.cs | 17 +- LightlessSync/FileCache/FileCompactor.cs | 114 +++- .../Configurations/LightlessConfig.cs | 1 + .../Factories/FileDownloadManagerFactory.cs | 29 +- .../Services/PairProcessingLimiter.cs | 61 +- LightlessSync/UI/SettingsUi.cs | 8 + LightlessSync/Utils/Crypto.cs | 10 +- .../WebAPI/Files/FileDownloadManager.cs | 524 +++++++++++++++--- .../WebAPI/Files/FileTransferOrchestrator.cs | 24 +- .../Files/Models/DownloadFileTransfer.cs | 1 + 10 files changed, 670 insertions(+), 119 deletions(-) diff --git a/LightlessSync/FileCache/FileCacheManager.cs b/LightlessSync/FileCache/FileCacheManager.cs index ed57656..972c4d9 100644 --- a/LightlessSync/FileCache/FileCacheManager.cs +++ b/LightlessSync/FileCache/FileCacheManager.cs @@ -27,6 +27,7 @@ public sealed class FileCacheManager : IHostedService private readonly Lock _fileWriteLock = new(); private readonly IpcManager _ipcManager; private readonly ILogger _logger; + private bool _csvHeaderEnsured; public string CacheFolder => _configService.Current.CacheFolder; public FileCacheManager(ILogger logger, IpcManager ipcManager, LightlessConfigService configService, LightlessMediator lightlessMediator) @@ -462,6 +463,7 @@ public sealed class FileCacheManager : IHostedService string[] existingLines = File.ReadAllLines(_csvPath); if (existingLines.Length > 0 && TryParseVersionHeader(existingLines[0], out var existingVersion) && existingVersion == FileCacheVersion) { + _csvHeaderEnsured = true; return; } @@ -481,6 +483,18 @@ public sealed class FileCacheManager : IHostedService } File.WriteAllText(_csvPath, rebuilt.ToString()); + _csvHeaderEnsured = true; + } + + private void EnsureCsvHeaderLockedCached() + { + if (_csvHeaderEnsured) + { + return; + } + + EnsureCsvHeaderLocked(); + _csvHeaderEnsured = true; } private void BackupUnsupportedCache(string suffix) @@ -540,10 +554,11 @@ public sealed class FileCacheManager : IHostedService if (!File.Exists(_csvPath)) { File.WriteAllLines(_csvPath, new[] { BuildVersionHeader(), entity.CsvEntry }); + _csvHeaderEnsured = true; } else { - EnsureCsvHeaderLocked(); + EnsureCsvHeaderLockedCached(); File.AppendAllLines(_csvPath, new[] { entity.CsvEntry }); } } diff --git a/LightlessSync/FileCache/FileCompactor.cs b/LightlessSync/FileCache/FileCompactor.cs index 737c1f0..1a35ad6 100644 --- a/LightlessSync/FileCache/FileCompactor.cs +++ b/LightlessSync/FileCache/FileCompactor.cs @@ -2,25 +2,33 @@ using LightlessSync.Services; using Microsoft.Extensions.Logging; using System.Runtime.InteropServices; +using System.Collections.Concurrent; +using System.Threading; +using System.Threading.Channels; +using System.Threading.Tasks; namespace LightlessSync.FileCache; -public sealed class FileCompactor +public sealed class FileCompactor : IDisposable { public const uint FSCTL_DELETE_EXTERNAL_BACKING = 0x90314U; public const ulong WOF_PROVIDER_FILE = 2UL; private readonly Dictionary _clusterSizes; - + private readonly ConcurrentDictionary _pendingCompactions; private readonly WOF_FILE_COMPRESSION_INFO_V1 _efInfo; private readonly ILogger _logger; private readonly LightlessConfigService _lightlessConfigService; private readonly DalamudUtilService _dalamudUtilService; + private readonly Channel _compactionQueue; + private readonly CancellationTokenSource _compactionCts = new(); + private readonly Task _compactionWorker; public FileCompactor(ILogger logger, LightlessConfigService lightlessConfigService, DalamudUtilService dalamudUtilService) { _clusterSizes = new(StringComparer.Ordinal); + _pendingCompactions = new(StringComparer.OrdinalIgnoreCase); _logger = logger; _lightlessConfigService = lightlessConfigService; _dalamudUtilService = dalamudUtilService; @@ -29,6 +37,18 @@ public sealed class FileCompactor Algorithm = CompressionAlgorithm.XPRESS8K, Flags = 0 }; + + _compactionQueue = Channel.CreateUnbounded(new UnboundedChannelOptions + { + SingleReader = true, + SingleWriter = false + }); + _compactionWorker = Task.Factory.StartNew( + () => ProcessQueueAsync(_compactionCts.Token), + _compactionCts.Token, + TaskCreationOptions.LongRunning, + TaskScheduler.Default) + .Unwrap(); } private enum CompressionAlgorithm @@ -87,7 +107,30 @@ public sealed class FileCompactor return; } - CompactFile(filePath); + EnqueueCompaction(filePath); + } + + public void Dispose() + { + _compactionQueue.Writer.TryComplete(); + _compactionCts.Cancel(); + try + { + if (!_compactionWorker.Wait(TimeSpan.FromSeconds(5))) + { + _logger.LogDebug("Compaction worker did not shut down within timeout"); + } + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + _logger.LogDebug(ex, "Error shutting down compaction worker"); + } + finally + { + _compactionCts.Dispose(); + } + + GC.SuppressFinalize(this); } [DllImport("kernel32.dll")] @@ -226,4 +269,67 @@ public sealed class FileCompactor public CompressionAlgorithm Algorithm; public ulong Flags; } -} \ No newline at end of file + + private void EnqueueCompaction(string filePath) + { + if (!_pendingCompactions.TryAdd(filePath, 0)) + { + return; + } + + if (!_compactionQueue.Writer.TryWrite(filePath)) + { + _pendingCompactions.TryRemove(filePath, out _); + _logger.LogDebug("Failed to enqueue compaction job for {file}", filePath); + } + } + + private async Task ProcessQueueAsync(CancellationToken token) + { + try + { + while (await _compactionQueue.Reader.WaitToReadAsync(token).ConfigureAwait(false)) + { + while (_compactionQueue.Reader.TryRead(out var filePath)) + { + try + { + if (token.IsCancellationRequested) + { + return; + } + + if (_dalamudUtilService.IsWine || !_lightlessConfigService.Current.UseCompactor) + { + continue; + } + + if (!File.Exists(filePath)) + { + _logger.LogTrace("Skipping compaction for missing file {file}", filePath); + continue; + } + + CompactFile(filePath); + } + catch (OperationCanceledException) + { + return; + } + catch (Exception ex) + { + _logger.LogWarning(ex, "Error compacting file {file}", filePath); + } + finally + { + _pendingCompactions.TryRemove(filePath, out _); + } + } + } + } + catch (OperationCanceledException) + { + // expected during shutdown + } + } +} diff --git a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs index bdf8542..203db7d 100644 --- a/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs +++ b/LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs @@ -67,6 +67,7 @@ public class LightlessConfig : ILightlessConfiguration public bool ShowUploading { get; set; } = true; public bool ShowUploadingBigText { get; set; } = true; public bool ShowVisibleUsersSeparately { get; set; } = true; + public bool EnableDirectDownloads { get; set; } = true; public int TimeSpanBetweenScansInSeconds { get; set; } = 30; public int TransferBarsHeight { get; set; } = 12; public bool TransferBarsShowText { get; set; } = true; diff --git a/LightlessSync/PlayerData/Factories/FileDownloadManagerFactory.cs b/LightlessSync/PlayerData/Factories/FileDownloadManagerFactory.cs index eea3ea6..231ded3 100644 --- a/LightlessSync/PlayerData/Factories/FileDownloadManagerFactory.cs +++ b/LightlessSync/PlayerData/Factories/FileDownloadManagerFactory.cs @@ -1,4 +1,6 @@ -using LightlessSync.FileCache; +using LightlessSync.FileCache; +using LightlessSync.LightlessConfiguration; +using LightlessSync.Services; using LightlessSync.Services.Mediator; using LightlessSync.WebAPI.Files; using Microsoft.Extensions.Logging; @@ -10,21 +12,38 @@ public class FileDownloadManagerFactory private readonly FileCacheManager _fileCacheManager; private readonly FileCompactor _fileCompactor; private readonly FileTransferOrchestrator _fileTransferOrchestrator; + private readonly PairProcessingLimiter _pairProcessingLimiter; private readonly ILoggerFactory _loggerFactory; private readonly LightlessMediator _lightlessMediator; + private readonly LightlessConfigService _configService; - public FileDownloadManagerFactory(ILoggerFactory loggerFactory, LightlessMediator lightlessMediator, FileTransferOrchestrator fileTransferOrchestrator, - FileCacheManager fileCacheManager, FileCompactor fileCompactor) + public FileDownloadManagerFactory( + ILoggerFactory loggerFactory, + LightlessMediator lightlessMediator, + FileTransferOrchestrator fileTransferOrchestrator, + FileCacheManager fileCacheManager, + FileCompactor fileCompactor, + PairProcessingLimiter pairProcessingLimiter, + LightlessConfigService configService) { _loggerFactory = loggerFactory; _lightlessMediator = lightlessMediator; _fileTransferOrchestrator = fileTransferOrchestrator; _fileCacheManager = fileCacheManager; _fileCompactor = fileCompactor; + _pairProcessingLimiter = pairProcessingLimiter; + _configService = configService; } public FileDownloadManager Create() { - return new FileDownloadManager(_loggerFactory.CreateLogger(), _lightlessMediator, _fileTransferOrchestrator, _fileCacheManager, _fileCompactor); + return new FileDownloadManager( + _loggerFactory.CreateLogger(), + _lightlessMediator, + _fileTransferOrchestrator, + _fileCacheManager, + _fileCompactor, + _pairProcessingLimiter, + _configService); } -} \ No newline at end of file +} diff --git a/LightlessSync/Services/PairProcessingLimiter.cs b/LightlessSync/Services/PairProcessingLimiter.cs index 0e75d28..239ba75 100644 --- a/LightlessSync/Services/PairProcessingLimiter.cs +++ b/LightlessSync/Services/PairProcessingLimiter.cs @@ -15,6 +15,7 @@ public sealed class PairProcessingLimiter : DisposableMediatorSubscriberBase private readonly SemaphoreSlim _semaphore; private int _currentLimit; private int _pendingReductions; + private int _pendingIncrements; private int _waiting; private int _inFlight; @@ -70,7 +71,7 @@ public sealed class PairProcessingLimiter : DisposableMediatorSubscriberBase if (!IsEnabled) { - _semaphore.Release(); + TryReleaseSemaphore(); return NoopReleaser.Instance; } @@ -90,18 +91,12 @@ public sealed class PairProcessingLimiter : DisposableMediatorSubscriberBase var releaseAmount = HardLimit - _semaphore.CurrentCount; if (releaseAmount > 0) { - try - { - _semaphore.Release(releaseAmount); - } - catch (SemaphoreFullException) - { - // ignore, already at max - } + TryReleaseSemaphore(releaseAmount); } _currentLimit = desiredLimit; _pendingReductions = 0; + _pendingIncrements = 0; return; } @@ -113,10 +108,13 @@ public sealed class PairProcessingLimiter : DisposableMediatorSubscriberBase if (desiredLimit > _currentLimit) { var increment = desiredLimit - _currentLimit; - var allowed = Math.Min(increment, HardLimit - _semaphore.CurrentCount); - if (allowed > 0) + _pendingIncrements += increment; + + var available = HardLimit - _semaphore.CurrentCount; + var toRelease = Math.Min(_pendingIncrements, available); + if (toRelease > 0 && TryReleaseSemaphore(toRelease)) { - _semaphore.Release(allowed); + _pendingIncrements -= toRelease; } } else @@ -133,6 +131,13 @@ public sealed class PairProcessingLimiter : DisposableMediatorSubscriberBase { _pendingReductions += remaining; } + + if (_pendingIncrements > 0) + { + var offset = Math.Min(_pendingIncrements, _pendingReductions); + _pendingIncrements -= offset; + _pendingReductions -= offset; + } } _currentLimit = desiredLimit; @@ -146,6 +151,25 @@ public sealed class PairProcessingLimiter : DisposableMediatorSubscriberBase return Math.Clamp(configured, 1, HardLimit); } + private bool TryReleaseSemaphore(int count = 1) + { + if (count <= 0) + { + return true; + } + + try + { + _semaphore.Release(count); + return true; + } + catch (SemaphoreFullException ex) + { + Logger.LogDebug(ex, "Attempted to release {count} pair processing slots but semaphore is already at the hard limit.", count); + return false; + } + } + private void ReleaseOne() { var inFlight = Interlocked.Decrement(ref _inFlight); @@ -166,9 +190,20 @@ public sealed class PairProcessingLimiter : DisposableMediatorSubscriberBase _pendingReductions--; return; } + + if (_pendingIncrements > 0) + { + if (!TryReleaseSemaphore()) + { + return; + } + + _pendingIncrements--; + return; + } } - _semaphore.Release(); + TryReleaseSemaphore(); } protected override void Dispose(bool disposing) diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index dd7ee84..6154ac7 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -591,6 +591,7 @@ public class SettingsUi : WindowMediatorSubscriberBase bool limitPairApplications = _configService.Current.EnablePairProcessingLimiter; bool useAlternativeUpload = _configService.Current.UseAlternativeFileUpload; int downloadSpeedLimit = _configService.Current.DownloadSpeedLimitInBytes; + bool enableDirectDownloads = _configService.Current.EnableDirectDownloads; ImGui.AlignTextToFramePadding(); ImGui.TextUnformatted("Global Download Speed Limit"); @@ -622,6 +623,13 @@ public class SettingsUi : WindowMediatorSubscriberBase ImGui.AlignTextToFramePadding(); ImGui.TextUnformatted("0 = No limit/infinite"); + if (ImGui.Checkbox("[BETA] Enable Lightspeed Downloads", ref enableDirectDownloads)) + { + _configService.Current.EnableDirectDownloads = enableDirectDownloads; + _configService.Save(); + } + _uiShared.DrawHelpText("Uses signed CDN links when available. Disable to force the legacy queued download flow."); + if (ImGui.SliderInt("Maximum Parallel Downloads", ref maxParallelDownloads, 1, 10)) { _configService.Current.ParallelDownloads = maxParallelDownloads; diff --git a/LightlessSync/Utils/Crypto.cs b/LightlessSync/Utils/Crypto.cs index 8ed6ecb..de04d26 100644 --- a/LightlessSync/Utils/Crypto.cs +++ b/LightlessSync/Utils/Crypto.cs @@ -1,4 +1,7 @@ -using System.Security.Cryptography; +using System; +using System.Collections.Generic; +using System.IO; +using System.Security.Cryptography; using System.Text; namespace LightlessSync.Utils; @@ -13,8 +16,9 @@ public static class Crypto public static string GetFileHash(this string filePath) { - using SHA1CryptoServiceProvider cryptoProvider = new(); - return BitConverter.ToString(cryptoProvider.ComputeHash(File.ReadAllBytes(filePath))).Replace("-", "", StringComparison.Ordinal); + using SHA1 sha1 = SHA1.Create(); + using FileStream stream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete); + return BitConverter.ToString(sha1.ComputeHash(stream)).Replace("-", "", StringComparison.Ordinal); } public static string GetHash256(this (string, ushort) playerToHash) diff --git a/LightlessSync/WebAPI/Files/FileDownloadManager.cs b/LightlessSync/WebAPI/Files/FileDownloadManager.cs index 3f48af2..cc82d04 100644 --- a/LightlessSync/WebAPI/Files/FileDownloadManager.cs +++ b/LightlessSync/WebAPI/Files/FileDownloadManager.cs @@ -5,12 +5,18 @@ using LightlessSync.API.Dto.Files; using LightlessSync.API.Routes; using LightlessSync.FileCache; using LightlessSync.PlayerData.Handlers; +using LightlessSync.Services; using LightlessSync.Services.Mediator; using LightlessSync.WebAPI.Files.Models; using Microsoft.Extensions.Logging; +using System; using System.Collections.Concurrent; +using System.IO; using System.Net; using System.Net.Http.Json; +using System.Threading; +using System.Threading.Tasks; +using LightlessSync.LightlessConfiguration; namespace LightlessSync.WebAPI.Files; @@ -20,17 +26,27 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase private readonly FileCompactor _fileCompactor; private readonly FileCacheManager _fileDbManager; private readonly FileTransferOrchestrator _orchestrator; + private readonly PairProcessingLimiter _pairProcessingLimiter; + private readonly LightlessConfigService _configService; private readonly ConcurrentDictionary _activeDownloadStreams; + private static readonly TimeSpan DownloadStallTimeout = TimeSpan.FromSeconds(30); + private volatile bool _disableDirectDownloads; + private int _consecutiveDirectDownloadFailures; + private bool _lastConfigDirectDownloadsState; public FileDownloadManager(ILogger logger, LightlessMediator mediator, FileTransferOrchestrator orchestrator, - FileCacheManager fileCacheManager, FileCompactor fileCompactor) : base(logger, mediator) + FileCacheManager fileCacheManager, FileCompactor fileCompactor, + PairProcessingLimiter pairProcessingLimiter, LightlessConfigService configService) : base(logger, mediator) { _downloadStatus = new Dictionary(StringComparer.Ordinal); _orchestrator = orchestrator; _fileDbManager = fileCacheManager; _fileCompactor = fileCompactor; + _pairProcessingLimiter = pairProcessingLimiter; + _configService = configService; _activeDownloadStreams = new(); + _lastConfigDirectDownloadsState = _configService.Current.EnableDirectDownloads; Mediator.Subscribe(this, (msg) => { @@ -50,6 +66,11 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase public bool IsDownloading => CurrentDownloads.Any(); + private bool ShouldUseDirectDownloads() + { + return _configService.Current.EnableDirectDownloads && !_disableDirectDownloads; + } + public static void MungeBuffer(Span buffer) { for (int i = 0; i < buffer.Length; ++i) @@ -156,39 +177,47 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase Logger.LogWarning("Download status missing for {group} when starting download", downloadGroup); } + var requestUrl = LightlessFiles.CacheGetFullPath(fileTransfer[0].DownloadUri, requestId); + + await DownloadFileThrottled(requestUrl, tempPath, progress, MungeBuffer, ct, withToken: true).ConfigureAwait(false); + } + + private delegate void DownloadDataCallback(Span data); + + private async Task DownloadFileThrottled(Uri requestUrl, string destinationFilename, IProgress progress, DownloadDataCallback? callback, CancellationToken ct, bool withToken) + { const int maxRetries = 3; int retryCount = 0; TimeSpan retryDelay = TimeSpan.FromSeconds(2); - - HttpResponseMessage response = null!; - var requestUrl = LightlessFiles.CacheGetFullPath(fileTransfer[0].DownloadUri, requestId); + HttpResponseMessage? response = null; while (true) { try { - Logger.LogDebug("Attempt {attempt} - Downloading {requestUrl} for request {id}", retryCount + 1, requestUrl, requestId); - - response = await _orchestrator.SendRequestAsync(HttpMethod.Get, requestUrl, ct, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false); + Logger.LogDebug("Attempt {attempt} - Downloading {requestUrl}", retryCount + 1, requestUrl); + response = await _orchestrator.SendRequestAsync(HttpMethod.Get, requestUrl, ct, HttpCompletionOption.ResponseHeadersRead, withToken).ConfigureAwait(false); response.EnsureSuccessStatusCode(); break; } catch (HttpRequestException ex) when (ex.InnerException is TimeoutException || ex.StatusCode == null) { + response?.Dispose(); retryCount++; Logger.LogWarning(ex, "Timeout during download of {requestUrl}. Attempt {attempt} of {maxRetries}", requestUrl, retryCount, maxRetries); if (retryCount >= maxRetries || ct.IsCancellationRequested) { - Logger.LogError($"Max retries reached or cancelled. Failing download for {requestUrl}"); + Logger.LogError("Max retries reached or cancelled. Failing download for {requestUrl}", requestUrl); throw; } - await Task.Delay(retryDelay, ct).ConfigureAwait(false); // Wait before retrying + await Task.Delay(retryDelay, ct).ConfigureAwait(false); } catch (HttpRequestException ex) { + response?.Dispose(); Logger.LogWarning(ex, "Error during download of {requestUrl}, HttpStatusCode: {code}", requestUrl, ex.StatusCode); if (ex.StatusCode is HttpStatusCode.NotFound or HttpStatusCode.Unauthorized) @@ -196,42 +225,80 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase throw new InvalidDataException($"Http error {ex.StatusCode} (cancelled: {ct.IsCancellationRequested}): {requestUrl}", ex); } - throw; + throw; } } + ThrottledStream? stream = null; FileStream? fileStream = null; try { - fileStream = File.Create(tempPath); + fileStream = File.Create(destinationFilename); await using (fileStream.ConfigureAwait(false)) { - var bufferSize = response.Content.Headers.ContentLength > 1024 * 1024 ? 65536 : 8196; + var bufferSize = response!.Content.Headers.ContentLength > 1024 * 1024 ? 65536 : 8196; var buffer = new byte[bufferSize]; - var bytesRead = 0; var limit = _orchestrator.DownloadLimitPerSlot(); - Logger.LogTrace("Starting Download of {id} with a speed limit of {limit} to {tempPath}", requestId, limit, tempPath); + Logger.LogTrace("Starting Download with a speed limit of {limit} to {destination}", limit, destinationFilename); stream = new(await response.Content.ReadAsStreamAsync(ct).ConfigureAwait(false), limit); - _activeDownloadStreams.TryAdd(stream, 0); - while ((bytesRead = await stream.ReadAsync(buffer, ct).ConfigureAwait(false)) > 0) + while (true) { ct.ThrowIfCancellationRequested(); + int bytesRead; + try + { + var readTask = stream.ReadAsync(buffer.AsMemory(0, buffer.Length), ct).AsTask(); + while (!readTask.IsCompleted) + { + var completedTask = await Task.WhenAny(readTask, Task.Delay(DownloadStallTimeout)).ConfigureAwait(false); + if (completedTask == readTask) + { + break; + } - MungeBuffer(buffer.AsSpan(0, bytesRead)); + ct.ThrowIfCancellationRequested(); + + var snapshot = _pairProcessingLimiter.GetSnapshot(); + if (snapshot.Waiting > 0) + { + throw new TimeoutException($"No data received for {DownloadStallTimeout.TotalSeconds} seconds while downloading {requestUrl} (waiting: {snapshot.Waiting})"); + } + + Logger.LogTrace("Download stalled for {requestUrl} but no queued pairs, continuing to wait", requestUrl); + } + + bytesRead = await readTask.ConfigureAwait(false); + } + catch (OperationCanceledException) + { + throw; + } + + if (bytesRead == 0) + { + break; + } + + callback?.Invoke(buffer.AsSpan(0, bytesRead)); await fileStream.WriteAsync(buffer.AsMemory(0, bytesRead), ct).ConfigureAwait(false); progress.Report(bytesRead); } - Logger.LogDebug("{requestUrl} downloaded to {tempPath}", requestUrl, tempPath); + Logger.LogDebug("{requestUrl} downloaded to {destination}", requestUrl, destinationFilename); } } + catch (TimeoutException ex) + { + Logger.LogWarning(ex, "Detected stalled download for {requestUrl}, aborting transfer", requestUrl); + throw; + } catch (OperationCanceledException) { throw; @@ -240,18 +307,18 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase { try { - fileStream?.Close(); + fileStream?.Close(); - if (!string.IsNullOrEmpty(tempPath) && File.Exists(tempPath)) + if (!string.IsNullOrEmpty(destinationFilename) && File.Exists(destinationFilename)) { - File.Delete(tempPath); + File.Delete(destinationFilename); } } catch { - // Ignore errors during cleanup + // ignore cleanup errors } - throw; + throw; } finally { @@ -260,6 +327,134 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase _activeDownloadStreams.TryRemove(stream, out _); await stream.DisposeAsync().ConfigureAwait(false); } + + response?.Dispose(); + } + } + + private async Task DecompressBlockFileAsync(string downloadStatusKey, string blockFilePath, List fileReplacement, string downloadLabel) + { + if (_downloadStatus.TryGetValue(downloadStatusKey, out var status)) + { + status.TransferredFiles = 1; + status.DownloadStatus = DownloadStatus.Decompressing; + } + + FileStream? fileBlockStream = null; + try + { + fileBlockStream = File.OpenRead(blockFilePath); + while (fileBlockStream.Position < fileBlockStream.Length) + { + (string fileHash, long fileLengthBytes) = ReadBlockFileHeader(fileBlockStream); + + try + { + var fileExtension = fileReplacement.First(f => string.Equals(f.Hash, fileHash, StringComparison.OrdinalIgnoreCase)).GamePaths[0].Split(".")[^1]; + var filePath = _fileDbManager.GetCacheFilePath(fileHash, fileExtension); + Logger.LogDebug("{dlName}: Decompressing {file}:{le} => {dest}", downloadLabel, fileHash, fileLengthBytes, filePath); + + byte[] compressedFileContent = new byte[fileLengthBytes]; + var readBytes = await fileBlockStream.ReadAsync(compressedFileContent, CancellationToken.None).ConfigureAwait(false); + if (readBytes != fileLengthBytes) + { + throw new EndOfStreamException(); + } + MungeBuffer(compressedFileContent); + + var decompressedFile = LZ4Wrapper.Unwrap(compressedFileContent); + await _fileCompactor.WriteAllBytesAsync(filePath, decompressedFile, CancellationToken.None).ConfigureAwait(false); + + PersistFileToStorage(fileHash, filePath); + } + catch (EndOfStreamException) + { + Logger.LogWarning("{dlName}: Failure to extract file {fileHash}, stream ended prematurely", downloadLabel, fileHash); + } + catch (Exception e) + { + Logger.LogWarning(e, "{dlName}: Error during decompression", downloadLabel); + } + } + } + catch (EndOfStreamException) + { + Logger.LogDebug("{dlName}: Failure to extract file header data, stream ended", downloadLabel); + } + catch (Exception ex) + { + Logger.LogError(ex, "{dlName}: Error during block file read", downloadLabel); + } + finally + { + if (fileBlockStream != null) + await fileBlockStream.DisposeAsync().ConfigureAwait(false); + } + } + + private async Task PerformDirectDownloadFallbackAsync(DownloadFileTransfer directDownload, List fileReplacement, + IProgress progress, CancellationToken token, bool slotAlreadyAcquired) + { + if (string.IsNullOrEmpty(directDownload.DirectDownloadUrl)) + { + throw new InvalidOperationException("Direct download fallback requested without a direct download URL."); + } + + var downloadKey = directDownload.DirectDownloadUrl!; + bool slotAcquiredHere = false; + string? blockFile = null; + + try + { + if (!slotAlreadyAcquired) + { + if (_downloadStatus.TryGetValue(downloadKey, out var tracker)) + { + tracker.DownloadStatus = DownloadStatus.WaitingForSlot; + } + + await _orchestrator.WaitForDownloadSlotAsync(token).ConfigureAwait(false); + slotAcquiredHere = true; + } + + if (_downloadStatus.TryGetValue(downloadKey, out var queueTracker)) + { + queueTracker.DownloadStatus = DownloadStatus.WaitingForQueue; + } + + var requestIdResponse = await _orchestrator.SendRequestAsync(HttpMethod.Post, LightlessFiles.RequestEnqueueFullPath(directDownload.DownloadUri), + new[] { directDownload.Hash }, token).ConfigureAwait(false); + var requestId = Guid.Parse((await requestIdResponse.Content.ReadAsStringAsync().ConfigureAwait(false)).Trim('"')); + + blockFile = _fileDbManager.GetCacheFilePath(requestId.ToString("N"), "blk"); + + await DownloadAndMungeFileHttpClient(downloadKey, requestId, [directDownload], blockFile, progress, token).ConfigureAwait(false); + + if (!File.Exists(blockFile)) + { + throw new FileNotFoundException("Block file missing after direct download fallback.", blockFile); + } + + await DecompressBlockFileAsync(downloadKey, blockFile, fileReplacement, $"fallback-{directDownload.Hash}").ConfigureAwait(false); + } + finally + { + if (slotAcquiredHere) + { + _orchestrator.ReleaseDownloadSlot(); + } + + if (!string.IsNullOrEmpty(blockFile)) + { + try + { + File.Delete(blockFile); + } + catch + { + // ignore cleanup errors + } + } } } @@ -307,30 +502,76 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase private async Task DownloadFilesInternal(GameObjectHandler gameObjectHandler, List fileReplacement, CancellationToken ct) { - var downloadGroups = CurrentDownloads.GroupBy(f => f.DownloadUri.Host + ":" + f.DownloadUri.Port, StringComparer.Ordinal); + var objectName = gameObjectHandler?.Name ?? "Unknown"; - foreach (var downloadGroup in downloadGroups) + var configAllowsDirect = _configService.Current.EnableDirectDownloads; + if (configAllowsDirect != _lastConfigDirectDownloadsState) { - _downloadStatus[downloadGroup.Key] = new FileDownloadStatus() + _lastConfigDirectDownloadsState = configAllowsDirect; + if (configAllowsDirect) + { + _disableDirectDownloads = false; + _consecutiveDirectDownloadFailures = 0; + } + } + + var allowDirectDownloads = ShouldUseDirectDownloads(); + + var directDownloads = new List(); + var batchDownloads = new List(); + + foreach (var download in CurrentDownloads) + { + if (!string.IsNullOrEmpty(download.DirectDownloadUrl) && allowDirectDownloads) + { + directDownloads.Add(download); + } + else + { + batchDownloads.Add(download); + } + } + + var downloadBatches = batchDownloads.GroupBy(f => f.DownloadUri.Host + ":" + f.DownloadUri.Port, StringComparer.Ordinal).ToArray(); + + foreach (var directDownload in directDownloads) + { + _downloadStatus[directDownload.DirectDownloadUrl!] = new FileDownloadStatus() { DownloadStatus = DownloadStatus.Initializing, - TotalBytes = downloadGroup.Sum(c => c.Total), + TotalBytes = directDownload.Total, TotalFiles = 1, TransferredBytes = 0, TransferredFiles = 0 }; } + foreach (var downloadBatch in downloadBatches) + { + _downloadStatus[downloadBatch.Key] = new FileDownloadStatus() + { + DownloadStatus = DownloadStatus.Initializing, + TotalBytes = downloadBatch.Sum(c => c.Total), + TotalFiles = 1, + TransferredBytes = 0, + TransferredFiles = 0 + }; + } + + if (directDownloads.Count > 0 || downloadBatches.Length > 0) + { + Logger.LogWarning("Downloading {direct} files directly, and {batchtotal} in {batches} batches.", directDownloads.Count, batchDownloads.Count, downloadBatches.Length); + } + Mediator.Publish(new DownloadStartedMessage(gameObjectHandler, _downloadStatus)); - await Parallel.ForEachAsync(downloadGroups, new ParallelOptions() + Task batchDownloadsTask = downloadBatches.Length == 0 ? Task.CompletedTask : Parallel.ForEachAsync(downloadBatches, new ParallelOptions() { - MaxDegreeOfParallelism = downloadGroups.Count(), + MaxDegreeOfParallelism = downloadBatches.Length, CancellationToken = ct, }, async (fileGroup, token) => { - // let server predownload files var requestIdResponse = await _orchestrator.SendRequestAsync(HttpMethod.Post, LightlessFiles.RequestEnqueueFullPath(fileGroup.First().DownloadUri), fileGroup.Select(c => c.Hash), token).ConfigureAwait(false); Logger.LogDebug("Sent request for {n} files on server {uri} with result {result}", fileGroup.Count(), fileGroup.First().DownloadUri, @@ -353,7 +594,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase downloadStatus.DownloadStatus = DownloadStatus.WaitingForSlot; await _orchestrator.WaitForDownloadSlotAsync(token).ConfigureAwait(false); downloadStatus.DownloadStatus = DownloadStatus.WaitingForQueue; - Progress progress = new((bytesDownloaded) => + var progress = CreateInlineProgress((bytesDownloaded) => { try { @@ -371,7 +612,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase } catch (OperationCanceledException) { - Logger.LogDebug("{dlName}: Detected cancellation of download, partially extracting files for {id}", fi.Name, gameObjectHandler); + Logger.LogDebug("{dlName}: Detected cancellation of download, partially extracting files for {id}", fi.Name, objectName); } catch (Exception ex) { @@ -382,72 +623,167 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase return; } - FileStream? fileBlockStream = null; try { - if (_downloadStatus.TryGetValue(fileGroup.Key, out var status)) - { - status.TransferredFiles = 1; - status.DownloadStatus = DownloadStatus.Decompressing; - } if (!File.Exists(blockFile)) { Logger.LogWarning("{dlName}: Block file missing before extraction, skipping", fi.Name); return; } - fileBlockStream = File.OpenRead(blockFile); - while (fileBlockStream.Position < fileBlockStream.Length) - { - (string fileHash, long fileLengthBytes) = ReadBlockFileHeader(fileBlockStream); - - try - { - var fileExtension = fileReplacement.First(f => string.Equals(f.Hash, fileHash, StringComparison.OrdinalIgnoreCase)).GamePaths[0].Split(".")[^1]; - var filePath = _fileDbManager.GetCacheFilePath(fileHash, fileExtension); - Logger.LogDebug("{dlName}: Decompressing {file}:{le} => {dest}", fi.Name, fileHash, fileLengthBytes, filePath); - - byte[] compressedFileContent = new byte[fileLengthBytes]; - var readBytes = await fileBlockStream.ReadAsync(compressedFileContent, CancellationToken.None).ConfigureAwait(false); - if (readBytes != fileLengthBytes) - { - throw new EndOfStreamException(); - } - MungeBuffer(compressedFileContent); - - var decompressedFile = LZ4Wrapper.Unwrap(compressedFileContent); - await _fileCompactor.WriteAllBytesAsync(filePath, decompressedFile, CancellationToken.None).ConfigureAwait(false); - - PersistFileToStorage(fileHash, filePath); - } - catch (EndOfStreamException) - { - Logger.LogWarning("{dlName}: Failure to extract file {fileHash}, stream ended prematurely", fi.Name, fileHash); - } - catch (Exception e) - { - Logger.LogWarning(e, "{dlName}: Error during decompression", fi.Name); - } - } - } - catch (EndOfStreamException) - { - Logger.LogDebug("{dlName}: Failure to extract file header data, stream ended", fi.Name); - } - catch (Exception ex) - { - Logger.LogError(ex, "{dlName}: Error during block file read", fi.Name); + await DecompressBlockFileAsync(fileGroup.Key, blockFile, fileReplacement, fi.Name).ConfigureAwait(false); } finally { _orchestrator.ReleaseDownloadSlot(); - if (fileBlockStream != null) - await fileBlockStream.DisposeAsync().ConfigureAwait(false); File.Delete(blockFile); } - }).ConfigureAwait(false); + }); - Logger.LogDebug("Download end: {id}", gameObjectHandler); + Task directDownloadsTask = directDownloads.Count == 0 ? Task.CompletedTask : Parallel.ForEachAsync(directDownloads, new ParallelOptions() + { + MaxDegreeOfParallelism = directDownloads.Count, + CancellationToken = ct, + }, + async (directDownload, token) => + { + if (!_downloadStatus.TryGetValue(directDownload.DirectDownloadUrl!, out var downloadTracker)) + { + Logger.LogWarning("Download status missing for direct URL {url}", directDownload.DirectDownloadUrl); + return; + } + + var progress = CreateInlineProgress((bytesDownloaded) => + { + try + { + if (_downloadStatus.TryGetValue(directDownload.DirectDownloadUrl!, out FileDownloadStatus? value)) + { + value.TransferredBytes += bytesDownloaded; + } + } + catch (Exception ex) + { + Logger.LogWarning(ex, "Could not set download progress"); + } + }); + + if (!ShouldUseDirectDownloads()) + { + await PerformDirectDownloadFallbackAsync(directDownload, fileReplacement, progress, token, slotAlreadyAcquired: false).ConfigureAwait(false); + return; + } + + var tempFilename = _fileDbManager.GetCacheFilePath(directDownload.Hash, "bin"); + var slotAcquired = false; + + + try + { + downloadTracker.DownloadStatus = DownloadStatus.WaitingForSlot; + await _orchestrator.WaitForDownloadSlotAsync(token).ConfigureAwait(false); + slotAcquired = true; + + downloadTracker.DownloadStatus = DownloadStatus.Downloading; + Logger.LogDebug("Beginning direct download of {hash} from {url}", directDownload.Hash, directDownload.DirectDownloadUrl); + await DownloadFileThrottled(new Uri(directDownload.DirectDownloadUrl!), tempFilename, progress, null, token, withToken: false).ConfigureAwait(false); + + Interlocked.Exchange(ref _consecutiveDirectDownloadFailures, 0); + + downloadTracker.DownloadStatus = DownloadStatus.Decompressing; + + try + { + var replacement = fileReplacement.FirstOrDefault(f => string.Equals(f.Hash, directDownload.Hash, StringComparison.OrdinalIgnoreCase)); + if (replacement == null || replacement.GamePaths.Length == 0) + { + Logger.LogWarning("{hash}: No replacement data found for direct download.", directDownload.Hash); + return; + } + + var fileExtension = replacement.GamePaths[0].Split(".")[^1]; + var finalFilename = _fileDbManager.GetCacheFilePath(directDownload.Hash, fileExtension); + Logger.LogDebug("Decompressing direct download {hash} from {compressedFile} to {finalFile}", directDownload.Hash, tempFilename, finalFilename); + byte[] compressedBytes = await File.ReadAllBytesAsync(tempFilename).ConfigureAwait(false); + var decompressedBytes = LZ4Wrapper.Unwrap(compressedBytes); + await _fileCompactor.WriteAllBytesAsync(finalFilename, decompressedBytes, CancellationToken.None).ConfigureAwait(false); + PersistFileToStorage(directDownload.Hash, finalFilename); + + downloadTracker.TransferredFiles = 1; + Logger.LogDebug("Finished direct download of {hash}.", directDownload.Hash); + } + catch (Exception ex) + { + Logger.LogError(ex, "Exception downloading {hash} from {url}", directDownload.Hash, directDownload.DirectDownloadUrl); + } + } + catch (OperationCanceledException ex) + { + Logger.LogDebug("{hash}: Detected cancellation of direct download, discarding file.", directDownload.Hash); + Logger.LogError(ex, "{hash}: Error during direct download.", directDownload.Hash); + ClearDownload(); + return; + } + catch (Exception ex) + { + var expectedDirectDownloadFailure = ex is InvalidDataException; + var failureCount = 0; + + if (expectedDirectDownloadFailure) + { + Logger.LogInformation(ex, "{hash}: Direct download unavailable, attempting queued fallback.", directDownload.Hash); + } + else + { + failureCount = Interlocked.Increment(ref _consecutiveDirectDownloadFailures); + Logger.LogWarning(ex, "{hash}: Direct download failed, attempting queued fallback.", directDownload.Hash); + } + + try + { + downloadTracker.DownloadStatus = DownloadStatus.WaitingForQueue; + await PerformDirectDownloadFallbackAsync(directDownload, fileReplacement, progress, token, slotAcquired).ConfigureAwait(false); + + if (!expectedDirectDownloadFailure && failureCount >= 3 && !_disableDirectDownloads) + { + _disableDirectDownloads = true; + Logger.LogWarning("Disabling direct downloads for this session after {count} consecutive failures.", failureCount); + } + } + catch (Exception fallbackEx) + { + if (slotAcquired) + { + _orchestrator.ReleaseDownloadSlot(); + slotAcquired = false; + } + + Logger.LogError(fallbackEx, "{hash}: Error during direct download fallback.", directDownload.Hash); + ClearDownload(); + return; + } + } + finally + { + if (slotAcquired) + { + _orchestrator.ReleaseDownloadSlot(); + } + + try + { + File.Delete(tempFilename); + } + catch + { + // ignore + } + } + }); + + await Task.WhenAll(batchDownloadsTask, directDownloadsTask).ConfigureAwait(false); + + Logger.LogDebug("Download end: {id}", objectName); ClearDownload(); } @@ -554,4 +890,24 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase _orchestrator.ClearDownloadRequest(requestId); } } -} \ No newline at end of file + + private static IProgress CreateInlineProgress(Action callback) + { + return new InlineProgress(callback); + } + + private sealed class InlineProgress : IProgress + { + private readonly Action _callback; + + public InlineProgress(Action callback) + { + _callback = callback ?? throw new ArgumentNullException(nameof(callback)); + } + + public void Report(long value) + { + _callback(value); + } + } +} diff --git a/LightlessSync/WebAPI/Files/FileTransferOrchestrator.cs b/LightlessSync/WebAPI/Files/FileTransferOrchestrator.cs index 690ea79..de84a81 100644 --- a/LightlessSync/WebAPI/Files/FileTransferOrchestrator.cs +++ b/LightlessSync/WebAPI/Files/FileTransferOrchestrator.cs @@ -81,27 +81,30 @@ public class FileTransferOrchestrator : DisposableMediatorSubscriberBase } public async Task SendRequestAsync(HttpMethod method, Uri uri, - CancellationToken? ct = null, HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead) + CancellationToken? ct = null, HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead, + bool withToken = true) { using var requestMessage = new HttpRequestMessage(method, uri); - return await SendRequestInternalAsync(requestMessage, ct, httpCompletionOption).ConfigureAwait(false); + return await SendRequestInternalAsync(requestMessage, ct, httpCompletionOption, withToken).ConfigureAwait(false); } - public async Task SendRequestAsync(HttpMethod method, Uri uri, T content, CancellationToken ct) where T : class + public async Task SendRequestAsync(HttpMethod method, Uri uri, T content, CancellationToken ct, + bool withToken = true) where T : class { using var requestMessage = new HttpRequestMessage(method, uri); if (content is not ByteArrayContent) requestMessage.Content = JsonContent.Create(content); else requestMessage.Content = content as ByteArrayContent; - return await SendRequestInternalAsync(requestMessage, ct).ConfigureAwait(false); + return await SendRequestInternalAsync(requestMessage, ct, withToken: withToken).ConfigureAwait(false); } - public async Task SendRequestStreamAsync(HttpMethod method, Uri uri, ProgressableStreamContent content, CancellationToken ct) + public async Task SendRequestStreamAsync(HttpMethod method, Uri uri, ProgressableStreamContent content, + CancellationToken ct, bool withToken = true) { using var requestMessage = new HttpRequestMessage(method, uri); requestMessage.Content = content; - return await SendRequestInternalAsync(requestMessage, ct).ConfigureAwait(false); + return await SendRequestInternalAsync(requestMessage, ct, withToken: withToken).ConfigureAwait(false); } public async Task WaitForDownloadSlotAsync(CancellationToken token) @@ -144,10 +147,13 @@ public class FileTransferOrchestrator : DisposableMediatorSubscriberBase } private async Task SendRequestInternalAsync(HttpRequestMessage requestMessage, - CancellationToken? ct = null, HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead) + CancellationToken? ct = null, HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead, bool withToken = true) { - var token = await _tokenProvider.GetToken().ConfigureAwait(false); - requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token); + if (withToken) + { + var token = await _tokenProvider.GetToken().ConfigureAwait(false); + requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token); + } if (requestMessage.Content != null && requestMessage.Content is not StreamContent && requestMessage.Content is not ByteArrayContent) { diff --git a/LightlessSync/WebAPI/Files/Models/DownloadFileTransfer.cs b/LightlessSync/WebAPI/Files/Models/DownloadFileTransfer.cs index effb461..d0e9fd4 100644 --- a/LightlessSync/WebAPI/Files/Models/DownloadFileTransfer.cs +++ b/LightlessSync/WebAPI/Files/Models/DownloadFileTransfer.cs @@ -18,6 +18,7 @@ public class DownloadFileTransfer : FileTransfer } get => Dto.Size; } + public string? DirectDownloadUrl => ((DownloadFileDto)TransferDto).CDNDownloadUrl; public long TotalRaw => Dto.RawSize; private DownloadFileDto Dto => (DownloadFileDto)TransferDto; From 217c160ec7802cd9d0ad962885e177b7e40da84b Mon Sep 17 00:00:00 2001 From: defnotken Date: Sun, 19 Oct 2025 14:43:40 -0500 Subject: [PATCH 42/64] update submodule --- LightlessAPI | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessAPI b/LightlessAPI index 44fbe10..0bc7abb 160000 --- a/LightlessAPI +++ b/LightlessAPI @@ -1 +1 @@ -Subproject commit 44fbe1045872fcae4df45e43625a9ff1a79bc2ef +Subproject commit 0bc7abb274548bcde36c65ef1cf9f1a143d6492c From 68ba5f4b069b92b1baf93be1472cc46fb0d350fd Mon Sep 17 00:00:00 2001 From: defnotken Date: Sun, 19 Oct 2025 14:47:30 -0500 Subject: [PATCH 43/64] dev build --- LightlessSync/LightlessSync.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessSync/LightlessSync.csproj b/LightlessSync/LightlessSync.csproj index 5b31c88..5deca64 100644 --- a/LightlessSync/LightlessSync.csproj +++ b/LightlessSync/LightlessSync.csproj @@ -3,7 +3,7 @@ - 1.12.3 + 1.12.2.5 https://github.com/Light-Public-Syncshells/LightlessClient From 2cba1ccfe0ce4538cfd1015bec1accb174db5dfa Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 19 Oct 2025 21:56:03 +0200 Subject: [PATCH 44/64] reverted join, added apicontroller stuff --- LightlessSync/UI/JoinSyncshellUI.cs | 59 +++++-------------- .../SignalR/ApIController.Functions.Users.cs | 2 +- LightlessSync/WebAPI/SignalR/ApiController.cs | 5 ++ 3 files changed, 20 insertions(+), 46 deletions(-) diff --git a/LightlessSync/UI/JoinSyncshellUI.cs b/LightlessSync/UI/JoinSyncshellUI.cs index a500687..b02a84e 100644 --- a/LightlessSync/UI/JoinSyncshellUI.cs +++ b/LightlessSync/UI/JoinSyncshellUI.cs @@ -1,5 +1,5 @@ using Dalamud.Bindings.ImGui; -using Dalamud.Interface.Textures.TextureWraps; +using Dalamud.Interface.Colors; using Dalamud.Interface.Utility; using Dalamud.Interface.Utility.Raii; using LightlessSync.API.Data.Enum; @@ -11,26 +11,18 @@ using LightlessSync.Services.Mediator; using LightlessSync.Utils; using LightlessSync.WebAPI; using Microsoft.Extensions.Logging; -using System.Numerics; namespace LightlessSync.UI; internal class JoinSyncshellUI : WindowMediatorSubscriberBase { - private const string _lightlessLogo = "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"; - private const string _defaultDescription = "This Syncshell has no description set"; - private const string _defaultTags = "No Syncshell tags"; private readonly ApiController _apiController; private readonly UiSharedService _uiSharedService; private string _desiredSyncshellToJoin = string.Empty; private GroupJoinInfoDto? _groupJoinInfo = null; - private GroupProfileDto? _groupProfile = null; - private string _joinTitle = "Join Syncshell"; - private string _previousSyncshell = string.Empty; private DefaultPermissionsDto _ownPermissions = null!; private string _previousPassword = string.Empty; private string _syncshellPassword = string.Empty; - private IDalamudTextureWrap? _pfpTextureWrap; public JoinSyncshellUI(ILogger logger, LightlessMediator mediator, UiSharedService uiSharedService, ApiController apiController, PerformanceCollectorService performanceCollectorService) @@ -51,79 +43,56 @@ internal class JoinSyncshellUI : WindowMediatorSubscriberBase public override void OnOpen() { - _pfpTextureWrap?.Dispose(); _desiredSyncshellToJoin = string.Empty; - _previousSyncshell = string.Empty; _syncshellPassword = string.Empty; _previousPassword = string.Empty; - _joinTitle = "Join Syncshell"; _groupJoinInfo = null; - _groupProfile = null; _ownPermissions = _apiController.DefaultPermissions.DeepClone()!; } protected override void DrawInternal() { using (_uiSharedService.UidFont.Push()) - ImGui.TextUnformatted(_joinTitle); + ImGui.TextUnformatted(_groupJoinInfo == null || !_groupJoinInfo.Success ? "Join Syncshell" : "Finalize join Syncshell " + _groupJoinInfo.GroupAliasOrGID); ImGui.Separator(); - if (_groupProfile == null) + if (_groupJoinInfo == null || !_groupJoinInfo.Success) { UiSharedService.TextWrapped("Here you can join existing Syncshells. " + "Please keep in mind that you cannot join more than " + _apiController.ServerInfo.MaxGroupsJoinedByUser + " syncshells on this server." + Environment.NewLine + "Joining a Syncshell will pair you implicitly with all existing users in the Syncshell." + Environment.NewLine + "All permissions to all users in the Syncshell will be set to the preferred Syncshell permissions on joining, excluding prior set preferred permissions."); ImGui.Separator(); - ImGui.TextUnformatted("Note: Syncshell ID are case sensitive. LLS- is part of Syncshell IDs, unless using Vanity IDs."); + ImGui.TextUnformatted("Note: Syncshell ID and Password are case sensitive. LLS- is part of Syncshell IDs, unless using Vanity IDs."); ImGui.AlignTextToFramePadding(); ImGui.TextUnformatted("Syncshell ID"); ImGui.SameLine(200); ImGui.InputTextWithHint("##syncshellId", "Full Syncshell ID", ref _desiredSyncshellToJoin, 20); - using (ImRaii.Disabled(string.IsNullOrEmpty(_desiredSyncshellToJoin))) + ImGui.AlignTextToFramePadding(); + ImGui.TextUnformatted("Syncshell Password"); + ImGui.SameLine(200); + ImGui.InputTextWithHint("##syncshellpw", "Password", ref _syncshellPassword, 50, ImGuiInputTextFlags.Password); + using (ImRaii.Disabled(string.IsNullOrEmpty(_desiredSyncshellToJoin) || string.IsNullOrEmpty(_syncshellPassword))) { if (_uiSharedService.IconTextButton(Dalamud.Interface.FontAwesomeIcon.Plus, "Join Syncshell")) { - _groupProfile = _apiController.GroupGetProfile(new GroupDto(new API.Data.GroupData(_desiredSyncshellToJoin))).Result; - _previousSyncshell = _desiredSyncshellToJoin; - _logger.LogInformation(_groupProfile.PictureBase64); - _logger.LogInformation(_groupProfile.Group.ToString()); + _groupJoinInfo = _apiController.GroupJoin(new GroupPasswordDto(new API.Data.GroupData(_desiredSyncshellToJoin), _syncshellPassword)).Result; + _previousPassword = _syncshellPassword; + _syncshellPassword = string.Empty; } } - if (!string.IsNullOrEmpty(_previousSyncshell) && _groupProfile == null) + if (_groupJoinInfo != null && !_groupJoinInfo.Success) { - UiSharedService.ColorTextWrapped("Failed to find the Syncshell. This is due to one of following reasons:" + Environment.NewLine + + UiSharedService.ColorTextWrapped("Failed to join the Syncshell. This is due to one of following reasons:" + Environment.NewLine + "- The Syncshell does not exist or the password is incorrect" + Environment.NewLine + "- You are already in that Syncshell or are banned from that Syncshell" + Environment.NewLine + "- The Syncshell is at capacity or has invites disabled" + Environment.NewLine, UIColors.Get("LightlessYellow")); } } - else if (_groupProfile != null && (_groupJoinInfo == null || !_groupJoinInfo.Success)) - { - _joinTitle = "Joining Syncshell : " + _groupProfile.GroupAliasOrGID; - - //Fetching default or profile data - ImGui.Dummy(new Vector2(5)); - byte[]? profilePicture = string.IsNullOrEmpty(_groupProfile.PictureBase64) - ? Convert.FromBase64String(_lightlessLogo) - : Convert.FromBase64String(_groupProfile.PictureBase64); - string? profileDescription = string.IsNullOrEmpty(_groupProfile.Description) ? _defaultDescription : _groupProfile.Description; - - _pfpTextureWrap?.Dispose(); - _pfpTextureWrap = _uiSharedService.LoadImage(profilePicture); - - if (_pfpTextureWrap != null) - { - ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height)); - } - - //Make profile show of group - } else { - _joinTitle = "Finalizing Syncshell : " + _groupJoinInfo.GroupAliasOrGID; ImGui.TextUnformatted("You are about to join the Syncshell " + _groupJoinInfo.GroupAliasOrGID + " by " + _groupJoinInfo.OwnerAliasOrUID); ImGuiHelpers.ScaledDummy(2f); ImGui.TextUnformatted("This Syncshell staff has set the following suggested Syncshell permissions:"); diff --git a/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs b/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs index bbac3a6..582fbe1 100644 --- a/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs +++ b/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs @@ -84,7 +84,7 @@ public partial class ApiController public async Task UserGetProfile(UserDto dto) { - if (!IsConnected) return new UserProfileDto(dto.User, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, Description: null); + if (!IsConnected) return new UserProfileDto(dto.User, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, Description: null, Tags: null); return await _lightlessHub!.InvokeAsync(nameof(UserGetProfile), dto).ConfigureAwait(false); } diff --git a/LightlessSync/WebAPI/SignalR/ApiController.cs b/LightlessSync/WebAPI/SignalR/ApiController.cs index 5652194..56ab36e 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.cs @@ -607,5 +607,10 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL ServerState = state; } + + public Task UserGetLightfinderProfile(string hashedCid) + { + throw new NotImplementedException(); + } } #pragma warning restore MA0040 \ No newline at end of file From 7d4e097be8d63e5c81ce443f93fcb89dda5e25b1 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 19 Oct 2025 21:58:12 +0200 Subject: [PATCH 45/64] Added nsfw on syncshell profile. --- LightlessSync/UI/SyncshellAdminUI.cs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 4c1feb8..d019366 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -359,6 +359,10 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { UiSharedService.TextWrapped(_descriptionText); } + var nsfw = profile.IsNSFW; + ImGui.BeginDisabled(); + ImGui.Checkbox("Is NSFW", ref nsfw); + ImGui.EndDisabled(); ImGui.EndChildFrame(); } From e8760a8937506fc1f9d609c74d5c483b54c097b6 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Sun, 19 Oct 2025 21:59:04 +0200 Subject: [PATCH 46/64] Fixed nsfwf --- LightlessSync/UI/SyncshellAdminUI.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index d019366..80f4f7e 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -265,6 +265,10 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase ImGui.EndChildFrame(); ImGui.TreePop(); } + var nsfw = _profileData.IsNsfw; + ImGui.BeginDisabled(); + ImGui.Checkbox("Is NSFW", ref nsfw); + ImGui.EndDisabled(); } ImGui.Separator(); @@ -359,10 +363,6 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase { UiSharedService.TextWrapped(_descriptionText); } - var nsfw = profile.IsNSFW; - ImGui.BeginDisabled(); - ImGui.Checkbox("Is NSFW", ref nsfw); - ImGui.EndDisabled(); ImGui.EndChildFrame(); } From a98afdda0173e87b0fe90954d0837ace993ec262 Mon Sep 17 00:00:00 2001 From: defnotken Date: Sun, 19 Oct 2025 15:15:30 -0500 Subject: [PATCH 47/64] Updating changelog. --- LightlessSync/Changelog/changelog.yaml | 19 ++++++++++--- LightlessSync/Changelog/credits.yaml | 39 ++++++++++++++++++++++++-- LightlessSync/packages.lock.json | 6 ++++ 3 files changed, 57 insertions(+), 7 deletions(-) diff --git a/LightlessSync/Changelog/changelog.yaml b/LightlessSync/Changelog/changelog.yaml index 2cdbf6a..db2397d 100644 --- a/LightlessSync/Changelog/changelog.yaml +++ b/LightlessSync/Changelog/changelog.yaml @@ -1,25 +1,36 @@ tagline: "Lightless Sync v1.12.3" -subline: "FILLER" +subline: "LightSpeed, Welcome Screen, and More!" changelog: - name: "v1.12.3" - tagline: "FILLER" + tagline: "LightSpeed, Welcome Screen, and More!" date: "October 15th 2025" # be sure to set this every new version isCurrent: true versions: - - number: "New Features" + - number: "LightSpeed" + icon: "" + items: + - "New way to download that will download mods directly from the file server" + - "LightSpeed is in BETA and should be faster than the batch downloading" + - number: "Welcome Screen + Additional Features" icon: "" items: - "New in-game Patch Notes window." - "Credits section to thank contributors and supporters." - "Patch notes only show after updates, not during first-time setup." + - "Syncshell Rework stared: Profiles have been added (more features using this will come later)." - number: "Notifications" icon: "" items: - "More customizable notification options." - "Perfomance limiter shows as notifications." - "All notifications can be configured or disabled in Settings → Notifications." - + - number: "Bugfixes" + icon: "" + items: + - "Added more safety checks to nameplates" + - "Removed a line in SyncshellUI potentially causing NullPointers" + - "Additional safety checks in PlayerData.Factory" - name: "v1.12.2" tagline: "LightFinder fixes, Notifications overhaul" date: "October 12th 2025" diff --git a/LightlessSync/Changelog/credits.yaml b/LightlessSync/Changelog/credits.yaml index b3b3e8c..b04b1e6 100644 --- a/LightlessSync/Changelog/credits.yaml +++ b/LightlessSync/Changelog/credits.yaml @@ -1,11 +1,44 @@ credits: - category: "Development Team" items: + - name: "Abel" + role: "Developer" + - name: "Cake" + role: "Developer" + - name: "Celine" + role: "Developer" - name: "Choco" - role: "Cringe Developer" + role: "Developer" + - name: "Kenny" + role: "Developer" + - name: "Zura" + role: "Developer" - name: "Additional Contributors" role: "Community Contributors & Bug Reporters" - + + - category: "Moderation Team" + items: + - name: "Crow" + role: "Moderator" + - name: "Faith" + role: "Moderator" + - name: "Kiwiwiwi" + role: "Moderator" + - name: "Kruwu" + role: "Moderator" + - name: "Lexi" + role: "Moderator" + - name: "Maya" + role: "Moderator" + - name: "Metaknight" + role: "Moderator" + - name: "Minmoose" + role: "Moderator" + - name: "Nihal" + role: "Moderator" + - name: "Tani" + role: "Moderator" + - category: "Plugin Integration & IPC Support" items: - name: "Penumbra Team" @@ -24,7 +57,7 @@ credits: role: "Pet naming integration" - name: "Brio Team" role: "GPose enhancement integration" - + - category: "Special Thanks" items: - name: "Dalamud & XIVLauncher Teams" diff --git a/LightlessSync/packages.lock.json b/LightlessSync/packages.lock.json index 5c2c7d1..a7576db 100644 --- a/LightlessSync/packages.lock.json +++ b/LightlessSync/packages.lock.json @@ -133,6 +133,12 @@ "Microsoft.IdentityModel.Tokens": "8.7.0" } }, + "YamlDotNet": { + "type": "Direct", + "requested": "[16.3.0, )", + "resolved": "16.3.0", + "contentHash": "SgMOdxbz8X65z8hraIs6hOEdnkH6hESTAIUa7viEngHOYaH+6q5XJmwr1+yb9vJpNQ19hCQY69xbFsLtXpobQA==" + }, "K4os.Compression.LZ4": { "type": "Transitive", "resolved": "1.3.8", From 7f8872cbe05e8f2a865c75e5be9520131cf0d981 Mon Sep 17 00:00:00 2001 From: choco Date: Sun, 19 Oct 2025 22:43:45 +0200 Subject: [PATCH 48/64] added open changelog button to settings title menu --- LightlessSync/UI/SettingsUi.cs | 34 +++++++++++++++++++++++++++++++ LightlessSync/UI/UpdateNotesUi.cs | 5 +++++ 2 files changed, 39 insertions(+) diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index dd7ee84..6575f2a 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -140,6 +140,25 @@ public class SettingsUi : WindowMediatorSubscriberBase MinimumSize = new Vector2(800, 400), MaximumSize = new Vector2(800, 2000), }; + TitleBarButtons = new() + { + new TitleBarButton() + { + Icon = FontAwesomeIcon.FileAlt, + Click = (msg) => + { + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + }, + IconOffset = new(2, 1), + ShowTooltip = () => + { + ImGui.BeginTooltip(); + ImGui.Text("View Update Notes"); + ImGui.EndTooltip(); + } + } + }; + Mediator.Subscribe(this, (_) => Toggle()); Mediator.Subscribe(this, (_) => { @@ -2333,6 +2352,21 @@ public class SettingsUi : WindowMediatorSubscriberBase } ImGui.Separator(); + + if (_uiShared.MediumTreeNode("Information", UIColors.Get("LightlessPurple"))) + { + if (_uiShared.IconTextButton(FontAwesomeIcon.FileAlt, "View Update Notes")) + { + Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); + } + + _uiShared.DrawHelpText("View the changelog and update notes for Lightless Sync."); + + _uiShared.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); + ImGui.TreePop(); + } + + ImGui.Separator(); } diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index 57dd173..f7544e1 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -589,6 +589,11 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase IsOpen = false; } + + if (ImGui.IsItemHovered()) + { + ImGui.SetTooltip("You can view this window again in the settings (title menu)"); + } } } From b513e0555b5a7aaf3b700759e9bc7d9a2bd96be7 Mon Sep 17 00:00:00 2001 From: choco Date: Sun, 19 Oct 2025 22:46:36 +0200 Subject: [PATCH 49/64] temp menu removal --- LightlessSync/UI/SettingsUi.cs | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index 46f091d..3b87baa 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -2358,24 +2358,7 @@ public class SettingsUi : WindowMediatorSubscriberBase _uiShared.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); ImGui.TreePop(); } - ImGui.Separator(); - - if (_uiShared.MediumTreeNode("Information", UIColors.Get("LightlessPurple"))) - { - if (_uiShared.IconTextButton(FontAwesomeIcon.FileAlt, "View Update Notes")) - { - Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi))); - } - - _uiShared.DrawHelpText("View the changelog and update notes for Lightless Sync."); - - _uiShared.ColoredSeparator(UIColors.Get("LightlessPurple"), 1.5f); - ImGui.TreePop(); - } - - ImGui.Separator(); - } private void DrawPerformance() From 268fd471fef70af49328a818decdfcc2c14f2097 Mon Sep 17 00:00:00 2001 From: defnotken Date: Sun, 19 Oct 2025 15:50:02 -0500 Subject: [PATCH 50/64] welcome screen fix bump --- LightlessSync/LightlessSync.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessSync/LightlessSync.csproj b/LightlessSync/LightlessSync.csproj index 3033575..42fb61b 100644 --- a/LightlessSync/LightlessSync.csproj +++ b/LightlessSync/LightlessSync.csproj @@ -3,7 +3,7 @@ - 1.12.2.5 + 1.12.2.6 https://github.com/Light-Public-Syncshells/LightlessClient From 0cb71e5444a0c3a030618e861ef0aa0cdfdf2e90 Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 20 Oct 2025 14:00:54 +0200 Subject: [PATCH 51/64] service cleanups, containing logic directly now --- CONTRIBUTING.md | 1086 +++++++++++++++++ DEVELOPMENT.md | 111 ++ LightlessSync/Plugin.cs | 3 +- LightlessSync/Services/Mediator/Messages.cs | 2 + LightlessSync/Services/NotificationService.cs | 95 +- LightlessSync/Services/PairRequestService.cs | 7 +- LightlessSync/Services/UiService.cs | 3 +- LightlessSync/UI/DownloadUi.cs | 6 +- LightlessSync/UI/SettingsUi.cs | 31 +- .../ApiController.Functions.Callbacks.cs | 18 +- 10 files changed, 1274 insertions(+), 88 deletions(-) create mode 100644 CONTRIBUTING.md create mode 100644 DEVELOPMENT.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..4d9b8a8 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,1086 @@ +# Lightless Sync Development Guidelines + +This document outlines the coding standards, architectural patterns, and best practices for contributing to the Lightless Sync project. + +## Table of Contents + +1. [Project Structure](#project-structure) +2. [Coding Standards](#coding-standards) +3. [Architecture Patterns](#architecture-patterns) +4. [Dependency Injection](#dependency-injection) +5. [Mediator Pattern](#mediator-pattern) +6. [Service Development](#service-development) +7. [UI Development](#ui-development) +8. [Dalamud Integration](#dalamud-integration) +9. [Performance Considerations](#performance-considerations) +10. [Testing](#testing) +11. [Common Patterns](#common-patterns) + +--- + +## Project Structure + +### Directory Organization + +``` +LightlessSync/ +├── Changelog/ # Version history and update notes +├── FileCache/ # File caching and management +├── Interop/ # Game interop and IPC with other plugins +│ └── Ipc/ # IPC callers for external plugins +├── LightlessConfiguration/ # Configuration management +├── PlayerData/ # Player data handling and pairs +│ ├── Factories/ +│ ├── Handlers/ +│ ├── Pairs/ +│ └── Services/ +├── Services/ # Core business logic services +│ ├── CharaData/ # Character data management +│ ├── Events/ # Event aggregation +│ ├── Mediator/ # Mediator pattern implementation +│ └── ServerConfiguration/ +├── UI/ # ImGui-based user interfaces +│ ├── Components/ # Reusable UI components +│ ├── Handlers/ # UI event handlers +│ └── Models/ # UI data models +├── Utils/ # Utility classes +└── WebAPI/ # SignalR and HTTP client logic + ├── Files/ # File transfer operations + └── SignalR/ # SignalR hub connections +``` + +### File Organization Rules + +- **One primary class per file**: File name must match the primary type name +- **Partial classes**: Use for large classes (e.g., `CharaDataManager.cs`, `CharaDataManager.Upload.cs`) +- **Nested types**: Keep in the same file unless they grow large enough to warrant separation +- **Interfaces**: Prefix with `I` (e.g., `IIpcCaller`, `IMediatorSubscriber`) + +--- + +## Coding Standards + +### General C# Conventions + +Follow the `.editorconfig` settings: + +```ini +# Indentation +indent_size = 4 +tab_width = 4 +end_of_line = crlf + +# Naming +- Interfaces: IPascalCase (begins with I) +- Types: PascalCase +- Methods: PascalCase +- Properties: PascalCase +- Private fields: _camelCase (underscore prefix) +- Local variables: camelCase +- Parameters: camelCase +- Constants: PascalCase or UPPER_CASE +``` + +### Code Style Preferences + +#### Namespaces +```csharp +// Use block-scoped namespaces (not file-scoped) +namespace LightlessSync.Services; + +public class MyService +{ + // ... +} +``` + +#### Braces +```csharp +// Always use braces for control statements +if (condition) +{ + DoSomething(); +} + +// Even for single-line statements +if (condition) +{ + return; +} +``` + +#### Expression-Bodied Members +```csharp +// Prefer expression bodies for properties and accessors +public string Name { get; init; } = string.Empty; +public bool IsEnabled => _config.Current.Enabled; + +// Avoid for methods, constructors, and operators +public void DoWork() +{ + // Full method body +} +``` + +#### Object Initialization +```csharp +// Prefer object initializers +var notification = new LightlessNotification +{ + Id = "example", + Title = "Example", + Message = "This is an example", + Type = NotificationType.Info +}; + +// Prefer collection initializers +var list = new List { "item1", "item2", "item3" }; +``` + +#### Null Handling +```csharp +// Prefer null coalescing +var value = possiblyNull ?? defaultValue; + +// Prefer null propagation +var length = text?.Length ?? 0; + +// Prefer pattern matching for null checks +if (value is null) +{ + return; +} + +// Use nullable reference types +public string? OptionalValue { get; set; } +public string RequiredValue { get; set; } = string.Empty; +``` + +#### Modern C# Features +```csharp +// Use target-typed new expressions when type is apparent +List items = new(); +Dictionary map = new(); + +// Use primary constructors sparingly (prefer traditional constructors for clarity) +// AVOID: public class MyService(ILogger logger) : IService + +// Use record types for DTOs and immutable data +public record UserData(string Name, string Id); +public record struct PairRequestEntry(string HashedCid, string MessageTemplate, DateTime ReceivedAt); + +// Use pattern matching +if (obj is MyType { Property: "value" } typedObj) +{ + // Use typedObj +} +``` + +--- + +## Architecture Patterns + +### Mediator Pattern (Core Communication) + +The Lightless Sync uses a **custom mediator pattern** for decoupled communication between components. + +#### Key Components + +1. **LightlessMediator**: Central message bus +2. **MessageBase**: Base class for all messages +3. **IMediatorSubscriber**: Interface for subscribers +4. **MediatorSubscriberBase**: Base class with auto-cleanup + +#### Creating Messages + +```csharp +// In Services/Mediator/Messages.cs +public record MyCustomMessage(string Data, int Value) : MessageBase; + +// For messages that need to stay on the same thread +public record SynchronousMessage : MessageBase +{ + public override bool KeepThreadContext => true; +} +``` + +#### Subscribing to Messages + +```csharp +public class MyService : DisposableMediatorSubscriberBase, IHostedService +{ + public MyService(ILogger logger, LightlessMediator mediator) + : base(logger, mediator) + { + } + + public Task StartAsync(CancellationToken cancellationToken) + { + // Subscribe to messages + Mediator.Subscribe(this, HandleMyMessage); + Mediator.Subscribe(this, HandleAnotherMessage); + return Task.CompletedTask; + } + + private void HandleMyMessage(MyCustomMessage message) + { + Logger.LogDebug("Received: {Data}, {Value}", message.Data, message.Value); + // Handle the message + } + + public Task StopAsync(CancellationToken cancellationToken) + { + // Cleanup is automatic with DisposableMediatorSubscriberBase + return Task.CompletedTask; + } +} +``` + +#### Publishing Messages + +```csharp +// Publish to all subscribers +Mediator.Publish(new MyCustomMessage("test", 42)); + +// Publish from non-mediator classes +_mediator.Publish(new NotificationMessage( + "Title", + "Message", + NotificationType.Info)); +``` + +#### Message Guidelines + +- **Use records** for messages (immutable and concise) +- **Keep messages simple**: Only carry data, no logic +- **Name clearly**: `Message` (e.g., `PairRequestReceivedMessage`) +- **Thread-safe data**: Messages are processed asynchronously unless `KeepThreadContext = true` +- **Avoid circular dependencies**: Messages should flow in one direction + +--- + +## Dependency Injection + +### Service Registration (Plugin.cs) + +```csharp +// In Plugin.cs constructor: +.ConfigureServices(collection => +{ + // Singleton services (shared state, long-lived) + collection.AddSingleton(); + collection.AddSingleton(); + collection.AddSingleton(); + + // Scoped services (per-resolution scope) + collection.AddScoped(); + collection.AddScoped(); + + // Hosted services (background services with lifecycle) + collection.AddHostedService(p => p.GetRequiredService()); + collection.AddHostedService(p => p.GetRequiredService()); + + // Lazy dependencies (avoid circular dependencies) + collection.AddSingleton(s => new Lazy(() => s.GetRequiredService())); + + // Factory pattern + collection.AddSingleton(); +}) +``` + +### Service Patterns + +#### Standard Service +```csharp +public class MyService +{ + private readonly ILogger _logger; + private readonly SomeDependency _dependency; + + public MyService( + ILogger logger, + SomeDependency dependency) + { + _logger = logger; + _dependency = dependency; + } + + public void DoWork() + { + _logger.LogInformation("Working..."); + _dependency.PerformAction(); + } +} +``` + +#### Hosted Service (Background Service) +```csharp +public class MyHostedService : IHostedService, IMediatorSubscriber +{ + private readonly ILogger _logger; + private readonly LightlessMediator _mediator; + + public LightlessMediator Mediator => _mediator; + + public MyHostedService( + ILogger logger, + LightlessMediator mediator) + { + _logger = logger; + _mediator = mediator; + } + + public Task StartAsync(CancellationToken cancellationToken) + { + _logger.LogInformation("Starting {Service}", nameof(MyHostedService)); + + // Subscribe to mediator messages + _mediator.Subscribe(this, HandleSomeMessage); + + // Initialize resources + return Task.CompletedTask; + } + + public Task StopAsync(CancellationToken cancellationToken) + { + _logger.LogInformation("Stopping {Service}", nameof(MyHostedService)); + + // Cleanup + _mediator.UnsubscribeAll(this); + + return Task.CompletedTask; + } + + private void HandleSomeMessage(SomeMessage msg) + { + // Handle message + } +} +``` + +#### Mediator Subscriber Service +```csharp +public sealed class MyService : DisposableMediatorSubscriberBase +{ + private readonly SomeDependency _dependency; + + public MyService( + ILogger logger, + LightlessMediator mediator, + SomeDependency dependency) + : base(logger, mediator) + { + _dependency = dependency; + + // Subscribe in constructor or in separate Init method + Mediator.Subscribe(this, HandleMessage); + } + + private void HandleMessage(SomeMessage msg) + { + Logger.LogDebug("Handling message: {Msg}", msg); + // Process message + } + + // Dispose is handled by base class +} +``` + +--- + +## Service Development + +### Service Responsibilities + +Services should follow **Single Responsibility Principle**: + +- **NotificationService**: Handles all in-game notifications +- **BroadcastService**: Manages Lightfinder broadcast state +- **PairRequestService**: Manages incoming pair requests +- **DalamudUtilService**: Utility methods for Dalamud framework operations + +### Service Guidelines + +1. **Logging**: Always use `ILogger` with appropriate log levels +2. **Error Handling**: Wrap risky operations in try-catch, log exceptions +3. **Async/Await**: Use `ConfigureAwait(false)` for non-UI operations +4. **Thread Safety**: Use locks, `ConcurrentDictionary`, or `SemaphoreSlim` for shared state +5. **Disposal**: Implement `IDisposable` or inherit from `DisposableMediatorSubscriberBase` + +### Example Service Template + +```csharp +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.Logging; + +namespace LightlessSync.Services; + +public sealed class TemplateService : DisposableMediatorSubscriberBase, IHostedService +{ + private readonly ILogger _logger; + private readonly SomeDependency _dependency; + private readonly SemaphoreSlim _lock = new(1); + + public TemplateService( + ILogger logger, + LightlessMediator mediator, + SomeDependency dependency) + : base(logger, mediator) + { + _logger = logger; + _dependency = dependency; + } + + public Task StartAsync(CancellationToken cancellationToken) + { + _logger.LogInformation("Starting {Service}", nameof(TemplateService)); + + Mediator.Subscribe(this, HandleSomeMessage); + + return Task.CompletedTask; + } + + public Task StopAsync(CancellationToken cancellationToken) + { + _logger.LogInformation("Stopping {Service}", nameof(TemplateService)); + + _lock.Dispose(); + + return Task.CompletedTask; + } + + private async void HandleSomeMessage(SomeMessage msg) + { + await _lock.WaitAsync().ConfigureAwait(false); + try + { + _logger.LogDebug("Processing message: {Msg}", msg); + + // Do work + await _dependency.ProcessAsync(msg).ConfigureAwait(false); + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to process message"); + } + finally + { + _lock.Release(); + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + _lock?.Dispose(); + } + + base.Dispose(disposing); + } +} +``` + +--- + +## UI Development + +### UI Base Classes + +All UI windows inherit from `WindowMediatorSubscriberBase`: + +```csharp +public class MyWindow : WindowMediatorSubscriberBase +{ + private readonly UiSharedService _uiShared; + + public MyWindow( + ILogger logger, + LightlessMediator mediator, + UiSharedService uiShared, + PerformanceCollectorService performanceCollector) + : base(logger, mediator, "My Window Title", performanceCollector) + { + _uiShared = uiShared; + + // Window configuration + Flags = ImGuiWindowFlags.NoScrollbar | ImGuiWindowFlags.NoScrollWithMouse; + SizeConstraints = new WindowSizeConstraints + { + MinimumSize = new Vector2(600, 400), + MaximumSize = new Vector2(800, 600) + }; + } + + protected override void DrawInternal() + { + // ImGui drawing code here + ImGui.Text("Hello, World!"); + } +} +``` + +### UI Guidelines + +1. **Separation of Concerns**: UI should only handle rendering and user input +2. **Use UiSharedService**: Centralized UI utilities (icons, buttons, styling) +3. **Performance**: Use `PerformanceCollectorService` to track rendering performance +4. **Disposal**: Windows are scoped; don't store state that needs to persist +5. **Mediator**: Use mediator to communicate with services +6. **ImGui Best Practices**: + - Use `ImRaii` for push/pop operations + - Always pair `Begin`/`End` calls + - Use `ImGuiHelpers.ScaledDummy()` for responsive spacing + - Check `IsOpen` property for visibility + +### ImGui Patterns + +```csharp +// Using ImRaii for automatic cleanup +using (ImRaii.PushColor(ImGuiCol.Button, UIColors.Get("LightlessGreen"))) +using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 6f)) +{ + if (ImGui.Button("Styled Button")) + { + // Handle click + } +} + +// Tab bars +using (var tabBar = ImRaii.TabBar("###my_tabs")) +{ + if (!tabBar) return; + + using (var tab1 = ImRaii.TabItem("Tab 1")) + { + if (tab1) + { + ImGui.Text("Tab 1 content"); + } + } + + using (var tab2 = ImRaii.TabItem("Tab 2")) + { + if (tab2) + { + ImGui.Text("Tab 2 content"); + } + } +} + +// Child windows for scrolling regions +using (var child = ImRaii.Child("###content", new Vector2(0, -40), false, + ImGuiWindowFlags.AlwaysVerticalScrollbar)) +{ + if (!child) return; + + // Scrollable content here +} +``` + +--- + +## Dalamud Integration + +### Dalamud Services + +Dalamud provides various services accessible through constructor injection: + +```csharp +// Common Dalamud services: +IClientState clientState // Player and world state +IFramework framework // Game framework events +IObjectTable objectTable // Game objects (players, NPCs, etc.) +IChatGui chatGui // Chat window access +ICommandManager commandManager // Command registration +IDataManager gameData // Game data sheets +IPluginLog pluginLog // Logging +INotificationManager notificationManager // Toast notifications +IGameGui gameGui // Game UI access +ITextureProvider textureProvider // Icon/texture loading +``` + +### Framework Threading + +**CRITICAL**: Dalamud operates on the **game's main thread**. + +```csharp +// Safe: Already on framework thread +private void OnFrameworkUpdate(IFramework framework) +{ + // Can safely access game state + var player = _clientState.LocalPlayer; +} + +// Unsafe: Called from background thread +private async Task BackgroundWork() +{ + // DO NOT access game state here! + + // Use DalamudUtilService to run on framework thread + await _dalamudUtil.RunOnFrameworkThread(() => + { + // Now safe to access game state + var player = _clientState.LocalPlayer; + }); +} +``` + +### Game Object Access + +```csharp +// Always check for null +var player = _clientState.LocalPlayer; +if (player == null) +{ + return; +} + +// Iterating game objects +foreach (var obj in _objectTable) +{ + if (obj is IPlayerCharacter pc) + { + // Handle player character + } +} + +// Finding specific objects +var target = _targetManager.Target; +if (target is IPlayerCharacter targetPlayer) +{ + // Handle targeted player +} +``` + +### IPC with Other Plugins + +Use the IPC pattern for communicating with other Dalamud plugins: + +```csharp +public sealed class IpcCallerExample : DisposableMediatorSubscriberBase, IIpcCaller +{ + private readonly IDalamudPluginInterface _pi; + private readonly ICallGateSubscriber _apiVersion; + + public string Name => "ExamplePlugin"; + public bool Available { get; private set; } + + public IpcCallerExample( + ILogger logger, + IDalamudPluginInterface pluginInterface, + LightlessMediator mediator) + : base(logger, mediator) + { + _pi = pluginInterface; + + try + { + _apiVersion = _pi.GetIpcSubscriber("ExamplePlugin.GetApiVersion"); + CheckAvailability(); + } + catch (Exception ex) + { + Logger.LogWarning(ex, "Failed to initialize IPC for ExamplePlugin"); + } + } + + private void CheckAvailability() + { + try + { + var version = _apiVersion.InvokeFunc(); + Available = version >= 1; + Logger.LogInformation("ExamplePlugin available, version: {Version}", version); + } + catch + { + Available = false; + } + } + + public void DoSomething() + { + if (!Available) + { + Logger.LogWarning("ExamplePlugin not available"); + return; + } + + // Call IPC methods + } +} +``` + +--- + +## Performance Considerations + +### Framework Updates + +The game runs at ~60 FPS. Avoid heavy operations in framework updates: + +```csharp +Mediator.Subscribe(this, OnTick); + +private void OnTick(PriorityFrameworkUpdateMessage _) +{ + // Throttle expensive operations + if ((DateTime.UtcNow - _lastCheck).TotalSeconds < 1) + { + return; + } + _lastCheck = DateTime.UtcNow; + + // Do lightweight work only +} +``` + +### Async Operations + +```csharp +// Good: Non-blocking async +public async Task FetchDataAsync() +{ + var result = await _httpClient.GetAsync(url).ConfigureAwait(false); + return await result.Content.ReadFromJsonAsync().ConfigureAwait(false); +} + +// Bad: Blocking async +public Data FetchDataBlocking() +{ + return FetchDataAsync().GetAwaiter().GetResult(); // Blocks thread! +} +``` + +### Collection Performance + +```csharp +// Good: Thread-safe concurrent collections +private readonly ConcurrentDictionary _cache = new(); + +// Good: Lock-protected regular collections +private readonly List _items = new(); +private readonly object _itemsLock = new(); + +public void AddItem(Item item) +{ + lock (_itemsLock) + { + _items.Add(item); + } +} + +// Good: SemaphoreSlim for async locks +private readonly SemaphoreSlim _asyncLock = new(1); + +public async Task ProcessAsync() +{ + await _asyncLock.WaitAsync().ConfigureAwait(false); + try + { + // Critical section + } + finally + { + _asyncLock.Release(); + } +} +``` + +### Memory Management + +```csharp +// Dispose pattern for unmanaged resources +public class ResourceManager : IDisposable +{ + private bool _disposed; + private readonly SemaphoreSlim _semaphore = new(1); + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (_disposed) return; + + if (disposing) + { + // Dispose managed resources + _semaphore?.Dispose(); + } + + // Free unmanaged resources + + _disposed = true; + } +} +``` + +--- + +## Testing + +### Unit Testing + +```csharp +[TestClass] +public class MyServiceTests +{ + private Mock> _mockLogger; + private Mock _mockMediator; + private MyService _service; + + [TestInitialize] + public void Setup() + { + _mockLogger = new Mock>(); + _mockMediator = new Mock(); + _service = new MyService(_mockLogger.Object, _mockMediator.Object); + } + + [TestMethod] + public void DoWork_WithValidInput_ReturnsExpectedResult() + { + // Arrange + var input = "test"; + + // Act + var result = _service.DoWork(input); + + // Assert + Assert.AreEqual("expected", result); + } +} +``` + +### Integration Testing + +Test with real Dalamud services in a controlled environment: + +```csharp +// Create test harness that mimics Dalamud environment +public class DalamudTestHarness +{ + public IClientState ClientState { get; } + public IFramework Framework { get; } + // ... other services + + public void SimulateFrameworkUpdate() + { + // Trigger framework update event + } +} +``` + +--- + +## Common Patterns + +### Notification Pattern + +```csharp +// Simple notification +Mediator.Publish(new NotificationMessage( + "Title", + "Message body", + NotificationType.Info)); + +// Rich notification with actions +var notification = new LightlessNotification +{ + Id = "unique_id", + Title = "Action Required", + Message = "Do you want to proceed?", + Type = NotificationType.Warning, + Duration = TimeSpan.FromSeconds(10), + Actions = new List + { + new() + { + Id = "confirm", + Label = "Confirm", + Icon = FontAwesomeIcon.Check, + Color = UIColors.Get("LightlessGreen"), + IsPrimary = true, + OnClick = (n) => + { + _logger.LogInformation("User confirmed"); + DoAction(); + n.IsDismissed = true; + } + }, + new() + { + Id = "cancel", + Label = "Cancel", + Icon = FontAwesomeIcon.Times, + OnClick = (n) => n.IsDismissed = true + } + } +}; + +Mediator.Publish(new LightlessNotificationMessage(notification)); +``` + +### Configuration Pattern + +```csharp +public class MyConfigService : ConfigurationServiceBase +{ + public MyConfigService(string configDirectory) + : base(Path.Combine(configDirectory, "myconfig.json")) + { + } +} + +// Usage +_configService.Current.SomeSetting = newValue; +_configService.Save(); +``` + +### Factory Pattern + +```csharp +public class GameObjectHandlerFactory +{ + private readonly DalamudUtilService _dalamudUtil; + private readonly LightlessMediator _mediator; + + public GameObjectHandlerFactory( + DalamudUtilService dalamudUtil, + LightlessMediator mediator) + { + _dalamudUtil = dalamudUtil; + _mediator = mediator; + } + + public GameObjectHandler Create(IntPtr address, string identifier) + { + return new GameObjectHandler( + _dalamudUtil, + _mediator, + () => address, + identifier); + } +} +``` + +--- + +## Error Handling + +### Logging Guidelines + +```csharp +// Debug: Verbose information for debugging +_logger.LogDebug("Processing request {RequestId}", requestId); + +// Information: General informational messages +_logger.LogInformation("User {UserId} connected", userId); + +// Warning: Recoverable issues +_logger.LogWarning("Cache miss for {Key}, will fetch from server", key); + +// Error: Errors that need attention +_logger.LogError(ex, "Failed to process message {MessageId}", messageId); + +// Critical: Application-breaking errors +_logger.LogCritical(ex, "Database connection failed"); +``` + +### Exception Handling + +```csharp +public async Task DoWorkAsync() +{ + try + { + // Risky operation + return await PerformOperationAsync().ConfigureAwait(false); + } + catch (HttpRequestException ex) + { + _logger.LogError(ex, "Network error during operation"); + // Show user-friendly notification + Mediator.Publish(new NotificationMessage( + "Network Error", + "Failed to connect to server. Please check your connection.", + NotificationType.Error)); + return Result.Failure; + } + catch (Exception ex) + { + _logger.LogError(ex, "Unexpected error during operation"); + throw; // Re-throw unexpected exceptions + } +} +``` + +--- + +## Best Practices Summary + +### DO ✅ + +- Use `DisposableMediatorSubscriberBase` for services that subscribe to mediator +- Use `IHostedService` for background services +- Always inject `ILogger` for logging +- Use `ConfigureAwait(false)` for async operations not requiring UI thread +- Dispose of resources properly (SemaphoreSlim, HttpClient, etc.) +- Check for null when accessing Dalamud game objects +- Use thread-safe collections for shared state +- Keep UI logic separate from business logic +- Use mediator for cross-component communication +- Write unit tests for business logic +- Document public APIs with XML comments + +### DON'T ❌ + +- Don't access game objects from background threads without `RunOnFrameworkThread` +- Don't block async methods with `.Result` or `.Wait()` +- Don't store UI state in services (services are often singletons) +- Don't use `async void` except for event handlers +- Don't catch `Exception` without re-throwing or logging +- Don't create circular dependencies between services +- Don't perform heavy operations in framework updates +- Don't forget to unsubscribe from mediator messages +- Don't hardcode file paths (use `IDalamudPluginInterface.ConfigDirectory`) +- Don't use primary constructors (prefer traditional for clarity) + +--- + +## Code Review Checklist + +Before submitting a pull request, ensure: + +- [ ] Code follows naming conventions +- [ ] All new services are registered in `Plugin.cs` +- [ ] Mediator messages are defined in `Messages.cs` +- [ ] Logging is appropriate and informative +- [ ] Thread safety is considered for shared state +- [ ] Disposable resources are properly disposed +- [ ] Async operations use `ConfigureAwait(false)` +- [ ] UI code is separated from business logic +- [ ] No direct game object access from background threads +- [ ] Error handling is comprehensive +- [ ] Performance impact is considered +- [ ] Comments explain "why", not "what" +- [ ] No compiler warnings +- [ ] Tests pass (if applicable) + +--- + +## Resources + +- [Dalamud Documentation](https://dalamud.dev) +- [ImGui.NET Documentation](https://github.com/mellinoe/ImGui.NET) +- [C# Coding Conventions](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions) +- [.NET API Guidelines](https://github.com/dotnet/runtime/blob/main/docs/coding-guidelines/api-guidelines) + +--- + +**Happy Coding!** 🚀 diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md new file mode 100644 index 0000000..32c892c --- /dev/null +++ b/DEVELOPMENT.md @@ -0,0 +1,111 @@ +# Development Setup for macOS + +This document explains how to set up the Lightless Sync development environment on macOS. + +## Problem: "Cannot resolve symbol 'Dalamud'" + +When developing Dalamud plugins on macOS, you may encounter the error: +``` +Cannot resolve symbol 'Dalamud' +Dalamud.NET.Sdk: Dalamud installation not found at /Users/.../Library/Application Support/XIV on Mac/dalamud/Hooks/dev/ +``` + +This happens because the Dalamud.NET.Sdk expects to find Dalamud assemblies at a specific path, but they don't exist if you don't have XIV on Mac or Dalamud installed. + +## Solution + +### Automated Setup (Recommended) + +Run the setup script to download the required Dalamud assemblies: + +```bash +./setup-dalamud.sh +``` + +This script will: +1. Create a development directory at `~/.dalamud/dev` +2. Download the latest Dalamud assemblies from the official distribution +3. Extract them to the development directory + +### Manual Setup + +If you prefer to set up manually: + +1. **Create the Dalamud directory:** + ```bash + mkdir -p ~/.dalamud/dev + ``` + +2. **Download Dalamud assemblies:** + ```bash + curl -L -o /tmp/dalamud.zip https://goatcorp.github.io/dalamud-distrib/latest.zip + unzip /tmp/dalamud.zip -d ~/.dalamud/dev + ``` + +3. **Set the DALAMUD_HOME environment variable (optional):** + ```bash + export DALAMUD_HOME="$HOME/.dalamud/dev" + ``` + +## How It Works + +The project includes a `Directory.Build.props` file that automatically configures the `DALAMUD_HOME` path to use `~/.dalamud/dev` if it exists. This overrides the default XIV on Mac path. + +The Dalamud.NET.Sdk will then use this path to find the required assemblies for compilation and IntelliSense. + +## Building the Project + +After setup, you can build the project normally: + +```bash +dotnet restore +dotnet build +``` + +## IDE Configuration + +### JetBrains Rider / IntelliJ IDEA + +After running the setup script, you may need to: +1. Invalidate caches and restart: **File → Invalidate Caches → Invalidate and Restart** +2. Reload the solution: **Right-click on solution → Reload All Projects** + +The IDE should now resolve all Dalamud symbols correctly. + +## Troubleshooting + +### Build still fails with "Dalamud installation not found" + +1. Verify the assemblies were downloaded: + ```bash + ls -la ~/.dalamud/dev/Dalamud.dll + ``` + +2. Check that `Directory.Build.props` exists in the project root + +3. Try cleaning and rebuilding: + ```bash + dotnet clean + dotnet build + ``` + +### IDE still shows "Cannot resolve symbol 'Dalamud'" + +1. Ensure the build succeeds first (run `dotnet build`) +2. Restart your IDE +3. Try invalidating caches (Rider/IntelliJ) +4. Check that the project references are loaded correctly + +## Files Modified + +- `Directory.Build.props` - Configures DALAMUD_HOME path +- `LightlessSync/LightlessSync.csproj` - Removed duplicate DalamudPackager reference +- `PenumbraAPI/Penumbra.Api.csproj` - Added DalamudLibPath configuration +- `setup-dalamud.sh` - Setup script to download Dalamud assemblies + +## Additional Notes + +- The Dalamud assemblies are only needed for development/compilation +- You don't need a running FFXIV or XIV on Mac installation to develop plugins +- The assemblies are downloaded from the official Dalamud distribution +- Updates to Dalamud may require re-running the setup script diff --git a/LightlessSync/Plugin.cs b/LightlessSync/Plugin.cs index 9ec4bed..54a879e 100644 --- a/LightlessSync/Plugin.cs +++ b/LightlessSync/Plugin.cs @@ -269,8 +269,7 @@ public sealed class Plugin : IDalamudPlugin s.GetRequiredService(), s.GetServices(), s.GetRequiredService(), s.GetRequiredService(), - s.GetRequiredService(), - s.GetRequiredService())); + s.GetRequiredService())); collection.AddScoped((s) => new CommandManagerService(commandManager, s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService())); diff --git a/LightlessSync/Services/Mediator/Messages.cs b/LightlessSync/Services/Mediator/Messages.cs index 8a724b4..79434c2 100644 --- a/LightlessSync/Services/Mediator/Messages.cs +++ b/LightlessSync/Services/Mediator/Messages.cs @@ -108,7 +108,9 @@ public record OpenCharaDataHubWithFilterMessage(UserData UserData) : MessageBase public record EnableBroadcastMessage(string HashedCid, bool Enabled) : MessageBase; public record BroadcastStatusChangedMessage(bool Enabled, TimeSpan? Ttl) : MessageBase; public record SyncshellBroadcastsUpdatedMessage : MessageBase; +public record PairRequestReceivedMessage(string HashedCid, string Message) : MessageBase; public record PairRequestsUpdatedMessage : MessageBase; +public record PairDownloadStatusMessage(List<(string PlayerName, float Progress, string Status)> DownloadStatus, int QueueWaiting) : MessageBase; public record VisibilityChange : MessageBase; #pragma warning restore S2094 #pragma warning restore MA0048 // File name must match type name \ No newline at end of file diff --git a/LightlessSync/Services/NotificationService.cs b/LightlessSync/Services/NotificationService.cs index 755e756..56da126 100644 --- a/LightlessSync/Services/NotificationService.cs +++ b/LightlessSync/Services/NotificationService.cs @@ -45,7 +45,9 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ public Task StartAsync(CancellationToken cancellationToken) { Mediator.Subscribe(this, HandleNotificationMessage); + Mediator.Subscribe(this, HandlePairRequestReceived); Mediator.Subscribe(this, HandlePairRequestsUpdated); + Mediator.Subscribe(this, HandlePairDownloadStatus); Mediator.Subscribe(this, HandlePerformanceNotification); return Task.CompletedTask; } @@ -293,33 +295,8 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ return actions; } - public void ShowPairDownloadNotification(List<(string playerName, float progress, string status)> downloadStatus, - int queueWaiting = 0) - { - var userDownloads = downloadStatus.Where(x => x.playerName != "Pair Queue").ToList(); - var totalProgress = userDownloads.Count > 0 ? userDownloads.Average(x => x.progress) : 0f; - var message = BuildPairDownloadMessage(userDownloads, queueWaiting); - var notification = new LightlessNotification - { - Id = "pair_download_progress", - Title = "Downloading Pair Data", - Message = message, - Type = NotificationType.Download, - Duration = TimeSpan.FromSeconds(_configService.Current.DownloadNotificationDurationSeconds), - ShowProgress = true, - Progress = totalProgress - }; - - Mediator.Publish(new LightlessNotificationMessage(notification)); - - if (AreAllDownloadsCompleted(userDownloads)) - { - DismissPairDownloadNotification(); - } - } - - private string BuildPairDownloadMessage(List<(string playerName, float progress, string status)> userDownloads, + private string BuildPairDownloadMessage(List<(string PlayerName, float Progress, string Status)> userDownloads, int queueWaiting) { var messageParts = new List(); @@ -331,7 +308,7 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ if (userDownloads.Count > 0) { - var completedCount = userDownloads.Count(x => x.progress >= 1.0f); + var completedCount = userDownloads.Count(x => x.Progress >= 1.0f); messageParts.Add($"Progress: {completedCount}/{userDownloads.Count} completed"); } @@ -344,29 +321,29 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ return string.Join("\n", messageParts); } - private string BuildActiveDownloadLines(List<(string playerName, float progress, string status)> userDownloads) + private string BuildActiveDownloadLines(List<(string PlayerName, float Progress, string Status)> userDownloads) { var activeDownloads = userDownloads - .Where(x => x.progress < 1.0f) + .Where(x => x.Progress < 1.0f) .Take(_configService.Current.MaxConcurrentPairApplications); if (!activeDownloads.Any()) return string.Empty; - return string.Join("\n", activeDownloads.Select(x => $"• {x.playerName}: {FormatDownloadStatus(x)}")); + return string.Join("\n", activeDownloads.Select(x => $"• {x.PlayerName}: {FormatDownloadStatus(x)}")); } - private string FormatDownloadStatus((string playerName, float progress, string status) download) => - download.status switch + private string FormatDownloadStatus((string PlayerName, float Progress, string Status) download) => + download.Status switch { - "downloading" => $"{download.progress:P0}", + "downloading" => $"{download.Progress:P0}", "decompressing" => "decompressing", "queued" => "queued", "waiting" => "waiting for slot", - _ => download.status + _ => download.Status }; - private bool AreAllDownloadsCompleted(List<(string playerName, float progress, string status)> userDownloads) => - userDownloads.Any() && userDownloads.All(x => x.progress >= 1.0f); + private bool AreAllDownloadsCompleted(List<(string PlayerName, float Progress, string Status)> userDownloads) => + userDownloads.Any() && userDownloads.All(x => x.Progress >= 1.0f); public void DismissPairDownloadNotification() => Mediator.Publish(new LightlessNotificationDismissMessage("pair_download_progress")); @@ -581,12 +558,25 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ _chatGui.Print(se.BuiltString); } + private void HandlePairRequestReceived(PairRequestReceivedMessage msg) + { + var request = _pairRequestService.RegisterIncomingRequest(msg.HashedCid, msg.Message); + var senderName = string.IsNullOrEmpty(request.DisplayName) ? "Unknown User" : request.DisplayName; + + _shownPairRequestNotifications.Add(request.HashedCid); + ShowPairRequestNotification( + senderName, + request.HashedCid, + onAccept: () => _pairRequestService.AcceptPairRequest(request.HashedCid, senderName), + onDecline: () => _pairRequestService.DeclinePairRequest(request.HashedCid)); + } + private void HandlePairRequestsUpdated(PairRequestsUpdatedMessage _) { var activeRequests = _pairRequestService.GetActiveRequests(); var activeRequestIds = activeRequests.Select(r => r.HashedCid).ToHashSet(); - // Dismiss notifications for requests that are no longer active + // Dismiss notifications for requests that are no longer active (expired) var notificationsToRemove = _shownPairRequestNotifications .Where(hashedCid => !activeRequestIds.Contains(hashedCid)) .ToList(); @@ -597,17 +587,30 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ Mediator.Publish(new LightlessNotificationDismissMessage(notificationId)); _shownPairRequestNotifications.Remove(hashedCid); } + } - // Show/update notifications for all active requests - foreach (var request in activeRequests) + private void HandlePairDownloadStatus(PairDownloadStatusMessage msg) + { + var userDownloads = msg.DownloadStatus.Where(x => x.PlayerName != "Pair Queue").ToList(); + var totalProgress = userDownloads.Count > 0 ? userDownloads.Average(x => x.Progress) : 0f; + var message = BuildPairDownloadMessage(userDownloads, msg.QueueWaiting); + + var notification = new LightlessNotification { - _shownPairRequestNotifications.Add(request.HashedCid); - ShowPairRequestNotification( - request.DisplayName, - request.HashedCid, - () => _pairRequestService.AcceptPairRequest(request.HashedCid, request.DisplayName), - () => _pairRequestService.DeclinePairRequest(request.HashedCid) - ); + Id = "pair_download_progress", + Title = "Downloading Pair Data", + Message = message, + Type = NotificationType.Download, + Duration = TimeSpan.FromSeconds(_configService.Current.DownloadNotificationDurationSeconds), + ShowProgress = true, + Progress = totalProgress + }; + + Mediator.Publish(new LightlessNotificationMessage(notification)); + + if (AreAllDownloadsCompleted(userDownloads)) + { + Mediator.Publish(new LightlessNotificationDismissMessage("pair_download_progress")); } } diff --git a/LightlessSync/Services/PairRequestService.cs b/LightlessSync/Services/PairRequestService.cs index 92294e2..f2ee64f 100644 --- a/LightlessSync/Services/PairRequestService.cs +++ b/LightlessSync/Services/PairRequestService.cs @@ -19,7 +19,12 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase private static readonly TimeSpan Expiration = TimeSpan.FromMinutes(5); - public PairRequestService(ILogger logger, LightlessMediator mediator, DalamudUtilService dalamudUtil, PairManager pairManager, Lazy apiController) + public PairRequestService( + ILogger logger, + LightlessMediator mediator, + DalamudUtilService dalamudUtil, + PairManager pairManager, + Lazy apiController) : base(logger, mediator) { _dalamudUtil = dalamudUtil; diff --git a/LightlessSync/Services/UiService.cs b/LightlessSync/Services/UiService.cs index 3740114..f08b1fc 100644 --- a/LightlessSync/Services/UiService.cs +++ b/LightlessSync/Services/UiService.cs @@ -23,8 +23,7 @@ public sealed class UiService : DisposableMediatorSubscriberBase LightlessConfigService lightlessConfigService, WindowSystem windowSystem, IEnumerable windows, UiFactory uiFactory, FileDialogManager fileDialogManager, - LightlessMediator lightlessMediator, - NotificationService notificationService) : base(logger, lightlessMediator) + LightlessMediator lightlessMediator) : base(logger, lightlessMediator) { _logger = logger; _logger.LogTrace("Creating {type}", GetType().Name); diff --git a/LightlessSync/UI/DownloadUi.cs b/LightlessSync/UI/DownloadUi.cs index 1b1ec16..a592e43 100644 --- a/LightlessSync/UI/DownloadUi.cs +++ b/LightlessSync/UI/DownloadUi.cs @@ -22,13 +22,12 @@ public class DownloadUi : WindowMediatorSubscriberBase private readonly UiSharedService _uiShared; private readonly PairProcessingLimiter _pairProcessingLimiter; private readonly ConcurrentDictionary _uploadingPlayers = new(); - private readonly NotificationService _notificationService; private bool _notificationDismissed = true; private int _lastDownloadStateHash = 0; public DownloadUi(ILogger logger, DalamudUtilService dalamudUtilService, LightlessConfigService configService, PairProcessingLimiter pairProcessingLimiter, FileUploadManager fileTransferManager, LightlessMediator mediator, UiSharedService uiShared, - PerformanceCollectorService performanceCollectorService, NotificationService notificationService) + PerformanceCollectorService performanceCollectorService) : base(logger, mediator, "Lightless Sync Downloads", performanceCollectorService) { _dalamudUtilService = dalamudUtilService; @@ -36,7 +35,6 @@ public class DownloadUi : WindowMediatorSubscriberBase _pairProcessingLimiter = pairProcessingLimiter; _fileTransferManager = fileTransferManager; _uiShared = uiShared; - _notificationService = notificationService; SizeConstraints = new WindowSizeConstraints() { @@ -359,7 +357,7 @@ public class DownloadUi : WindowMediatorSubscriberBase _lastDownloadStateHash = currentHash; if (downloadStatus.Count > 0 || queueWaiting > 0) { - _notificationService.ShowPairDownloadNotification(downloadStatus, queueWaiting); + Mediator.Publish(new PairDownloadStatusMessage(downloadStatus, queueWaiting)); } } } diff --git a/LightlessSync/UI/SettingsUi.cs b/LightlessSync/UI/SettingsUi.cs index 3b87baa..febc142 100644 --- a/LightlessSync/UI/SettingsUi.cs +++ b/LightlessSync/UI/SettingsUi.cs @@ -63,7 +63,6 @@ public class SettingsUi : WindowMediatorSubscriberBase private readonly IProgress<(int, int, FileCacheEntity)> _validationProgress; private readonly NameplateService _nameplateService; private readonly NameplateHandler _nameplateHandler; - private readonly NotificationService _lightlessNotificationService; private (int, int, FileCacheEntity) _currentProgress; private bool _deleteAccountPopupModalShown = false; private bool _deleteFilesPopupModalShown = false; @@ -107,8 +106,7 @@ public class SettingsUi : WindowMediatorSubscriberBase IpcManager ipcManager, CacheMonitor cacheMonitor, DalamudUtilService dalamudUtilService, HttpClient httpClient, NameplateService nameplateService, - NameplateHandler nameplateHandler, - NotificationService lightlessNotificationService) : base(logger, mediator, "Lightless Sync Settings", + NameplateHandler nameplateHandler) : base(logger, mediator, "Lightless Sync Settings", performanceCollector) { _configService = configService; @@ -130,7 +128,6 @@ public class SettingsUi : WindowMediatorSubscriberBase _uiShared = uiShared; _nameplateService = nameplateService; _nameplateHandler = nameplateHandler; - _lightlessNotificationService = lightlessNotificationService; AllowClickthrough = false; AllowPinning = true; _validationProgress = new Progress<(int, int, FileCacheEntity)>(v => _currentProgress = v); @@ -3616,20 +3613,7 @@ public class SettingsUi : WindowMediatorSubscriberBase { if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_pair", new Vector2(availableWidth, 0))) { - _lightlessNotificationService.ShowPairRequestNotification( - "Test User", - "test-uid-123", - () => - { - Mediator.Publish(new NotificationMessage("Accepted", "You accepted the test pair request.", - NotificationType.Info)); - }, - () => - { - Mediator.Publish(new NotificationMessage("Declined", "You declined the test pair request.", - NotificationType.Info)); - } - ); + Mediator.Publish(new PairRequestReceivedMessage("test-uid-123", "Test User wants to pair with you.")); } } UiSharedService.AttachToolTip("Test pair request notification"); @@ -3652,15 +3636,14 @@ public class SettingsUi : WindowMediatorSubscriberBase { if (ImGui.Button($"{FontAwesomeIcon.Play.ToIconString()}##test_download", new Vector2(availableWidth, 0))) { - _lightlessNotificationService.ShowPairDownloadNotification( - new List<(string playerName, float progress, string status)> - { + Mediator.Publish(new PairDownloadStatusMessage( + [ ("Player One", 0.35f, "downloading"), ("Player Two", 0.75f, "downloading"), ("Player Three", 1.0f, "downloading") - }, - queueWaiting: 2 - ); + ], + 2 + )); } } UiSharedService.AttachToolTip("Test download progress notification"); diff --git a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs index da07460..8323fc3 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Callbacks.cs @@ -107,17 +107,17 @@ public partial class ApiController } public Task Client_ReceiveBroadcastPairRequest(UserPairNotificationDto dto) { - if (dto == null) + Logger.LogDebug("Client_ReceiveBroadcastPairRequest: {dto}", dto); + + if (dto is null) + { return Task.CompletedTask; + } - var request = _pairRequestService.RegisterIncomingRequest(dto.myHashedCid, dto.message ?? string.Empty); - var senderName = string.IsNullOrEmpty(request.DisplayName) ? "Unknown User" : request.DisplayName; - - _lightlessNotificationService.ShowPairRequestNotification( - senderName, - request.HashedCid, - onAccept: () => _pairRequestService.AcceptPairRequest(request.HashedCid, senderName), - onDecline: () => _pairRequestService.DeclinePairRequest(request.HashedCid)); + ExecuteSafely(() => + { + Mediator.Publish(new PairRequestReceivedMessage(dto.myHashedCid, dto.message ?? string.Empty)); + }); return Task.CompletedTask; } From 923f118a47591cc132a19f94c803d0026996babb Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 20 Oct 2025 14:05:45 +0200 Subject: [PATCH 52/64] Delete DEVELOPMENT.md --- DEVELOPMENT.md | 111 ------------------------------------------------- 1 file changed, 111 deletions(-) delete mode 100644 DEVELOPMENT.md diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md deleted file mode 100644 index 32c892c..0000000 --- a/DEVELOPMENT.md +++ /dev/null @@ -1,111 +0,0 @@ -# Development Setup for macOS - -This document explains how to set up the Lightless Sync development environment on macOS. - -## Problem: "Cannot resolve symbol 'Dalamud'" - -When developing Dalamud plugins on macOS, you may encounter the error: -``` -Cannot resolve symbol 'Dalamud' -Dalamud.NET.Sdk: Dalamud installation not found at /Users/.../Library/Application Support/XIV on Mac/dalamud/Hooks/dev/ -``` - -This happens because the Dalamud.NET.Sdk expects to find Dalamud assemblies at a specific path, but they don't exist if you don't have XIV on Mac or Dalamud installed. - -## Solution - -### Automated Setup (Recommended) - -Run the setup script to download the required Dalamud assemblies: - -```bash -./setup-dalamud.sh -``` - -This script will: -1. Create a development directory at `~/.dalamud/dev` -2. Download the latest Dalamud assemblies from the official distribution -3. Extract them to the development directory - -### Manual Setup - -If you prefer to set up manually: - -1. **Create the Dalamud directory:** - ```bash - mkdir -p ~/.dalamud/dev - ``` - -2. **Download Dalamud assemblies:** - ```bash - curl -L -o /tmp/dalamud.zip https://goatcorp.github.io/dalamud-distrib/latest.zip - unzip /tmp/dalamud.zip -d ~/.dalamud/dev - ``` - -3. **Set the DALAMUD_HOME environment variable (optional):** - ```bash - export DALAMUD_HOME="$HOME/.dalamud/dev" - ``` - -## How It Works - -The project includes a `Directory.Build.props` file that automatically configures the `DALAMUD_HOME` path to use `~/.dalamud/dev` if it exists. This overrides the default XIV on Mac path. - -The Dalamud.NET.Sdk will then use this path to find the required assemblies for compilation and IntelliSense. - -## Building the Project - -After setup, you can build the project normally: - -```bash -dotnet restore -dotnet build -``` - -## IDE Configuration - -### JetBrains Rider / IntelliJ IDEA - -After running the setup script, you may need to: -1. Invalidate caches and restart: **File → Invalidate Caches → Invalidate and Restart** -2. Reload the solution: **Right-click on solution → Reload All Projects** - -The IDE should now resolve all Dalamud symbols correctly. - -## Troubleshooting - -### Build still fails with "Dalamud installation not found" - -1. Verify the assemblies were downloaded: - ```bash - ls -la ~/.dalamud/dev/Dalamud.dll - ``` - -2. Check that `Directory.Build.props` exists in the project root - -3. Try cleaning and rebuilding: - ```bash - dotnet clean - dotnet build - ``` - -### IDE still shows "Cannot resolve symbol 'Dalamud'" - -1. Ensure the build succeeds first (run `dotnet build`) -2. Restart your IDE -3. Try invalidating caches (Rider/IntelliJ) -4. Check that the project references are loaded correctly - -## Files Modified - -- `Directory.Build.props` - Configures DALAMUD_HOME path -- `LightlessSync/LightlessSync.csproj` - Removed duplicate DalamudPackager reference -- `PenumbraAPI/Penumbra.Api.csproj` - Added DalamudLibPath configuration -- `setup-dalamud.sh` - Setup script to download Dalamud assemblies - -## Additional Notes - -- The Dalamud assemblies are only needed for development/compilation -- You don't need a running FFXIV or XIV on Mac installation to develop plugins -- The assemblies are downloaded from the official Dalamud distribution -- Updates to Dalamud may require re-running the setup script From f5458c7f97309e0d027c3d5b3b7dda66faa84c19 Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 20 Oct 2025 14:05:51 +0200 Subject: [PATCH 53/64] Delete CONTRIBUTING.md --- CONTRIBUTING.md | 1086 ----------------------------------------------- 1 file changed, 1086 deletions(-) delete mode 100644 CONTRIBUTING.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md deleted file mode 100644 index 4d9b8a8..0000000 --- a/CONTRIBUTING.md +++ /dev/null @@ -1,1086 +0,0 @@ -# Lightless Sync Development Guidelines - -This document outlines the coding standards, architectural patterns, and best practices for contributing to the Lightless Sync project. - -## Table of Contents - -1. [Project Structure](#project-structure) -2. [Coding Standards](#coding-standards) -3. [Architecture Patterns](#architecture-patterns) -4. [Dependency Injection](#dependency-injection) -5. [Mediator Pattern](#mediator-pattern) -6. [Service Development](#service-development) -7. [UI Development](#ui-development) -8. [Dalamud Integration](#dalamud-integration) -9. [Performance Considerations](#performance-considerations) -10. [Testing](#testing) -11. [Common Patterns](#common-patterns) - ---- - -## Project Structure - -### Directory Organization - -``` -LightlessSync/ -├── Changelog/ # Version history and update notes -├── FileCache/ # File caching and management -├── Interop/ # Game interop and IPC with other plugins -│ └── Ipc/ # IPC callers for external plugins -├── LightlessConfiguration/ # Configuration management -├── PlayerData/ # Player data handling and pairs -│ ├── Factories/ -│ ├── Handlers/ -│ ├── Pairs/ -│ └── Services/ -├── Services/ # Core business logic services -│ ├── CharaData/ # Character data management -│ ├── Events/ # Event aggregation -│ ├── Mediator/ # Mediator pattern implementation -│ └── ServerConfiguration/ -├── UI/ # ImGui-based user interfaces -│ ├── Components/ # Reusable UI components -│ ├── Handlers/ # UI event handlers -│ └── Models/ # UI data models -├── Utils/ # Utility classes -└── WebAPI/ # SignalR and HTTP client logic - ├── Files/ # File transfer operations - └── SignalR/ # SignalR hub connections -``` - -### File Organization Rules - -- **One primary class per file**: File name must match the primary type name -- **Partial classes**: Use for large classes (e.g., `CharaDataManager.cs`, `CharaDataManager.Upload.cs`) -- **Nested types**: Keep in the same file unless they grow large enough to warrant separation -- **Interfaces**: Prefix with `I` (e.g., `IIpcCaller`, `IMediatorSubscriber`) - ---- - -## Coding Standards - -### General C# Conventions - -Follow the `.editorconfig` settings: - -```ini -# Indentation -indent_size = 4 -tab_width = 4 -end_of_line = crlf - -# Naming -- Interfaces: IPascalCase (begins with I) -- Types: PascalCase -- Methods: PascalCase -- Properties: PascalCase -- Private fields: _camelCase (underscore prefix) -- Local variables: camelCase -- Parameters: camelCase -- Constants: PascalCase or UPPER_CASE -``` - -### Code Style Preferences - -#### Namespaces -```csharp -// Use block-scoped namespaces (not file-scoped) -namespace LightlessSync.Services; - -public class MyService -{ - // ... -} -``` - -#### Braces -```csharp -// Always use braces for control statements -if (condition) -{ - DoSomething(); -} - -// Even for single-line statements -if (condition) -{ - return; -} -``` - -#### Expression-Bodied Members -```csharp -// Prefer expression bodies for properties and accessors -public string Name { get; init; } = string.Empty; -public bool IsEnabled => _config.Current.Enabled; - -// Avoid for methods, constructors, and operators -public void DoWork() -{ - // Full method body -} -``` - -#### Object Initialization -```csharp -// Prefer object initializers -var notification = new LightlessNotification -{ - Id = "example", - Title = "Example", - Message = "This is an example", - Type = NotificationType.Info -}; - -// Prefer collection initializers -var list = new List { "item1", "item2", "item3" }; -``` - -#### Null Handling -```csharp -// Prefer null coalescing -var value = possiblyNull ?? defaultValue; - -// Prefer null propagation -var length = text?.Length ?? 0; - -// Prefer pattern matching for null checks -if (value is null) -{ - return; -} - -// Use nullable reference types -public string? OptionalValue { get; set; } -public string RequiredValue { get; set; } = string.Empty; -``` - -#### Modern C# Features -```csharp -// Use target-typed new expressions when type is apparent -List items = new(); -Dictionary map = new(); - -// Use primary constructors sparingly (prefer traditional constructors for clarity) -// AVOID: public class MyService(ILogger logger) : IService - -// Use record types for DTOs and immutable data -public record UserData(string Name, string Id); -public record struct PairRequestEntry(string HashedCid, string MessageTemplate, DateTime ReceivedAt); - -// Use pattern matching -if (obj is MyType { Property: "value" } typedObj) -{ - // Use typedObj -} -``` - ---- - -## Architecture Patterns - -### Mediator Pattern (Core Communication) - -The Lightless Sync uses a **custom mediator pattern** for decoupled communication between components. - -#### Key Components - -1. **LightlessMediator**: Central message bus -2. **MessageBase**: Base class for all messages -3. **IMediatorSubscriber**: Interface for subscribers -4. **MediatorSubscriberBase**: Base class with auto-cleanup - -#### Creating Messages - -```csharp -// In Services/Mediator/Messages.cs -public record MyCustomMessage(string Data, int Value) : MessageBase; - -// For messages that need to stay on the same thread -public record SynchronousMessage : MessageBase -{ - public override bool KeepThreadContext => true; -} -``` - -#### Subscribing to Messages - -```csharp -public class MyService : DisposableMediatorSubscriberBase, IHostedService -{ - public MyService(ILogger logger, LightlessMediator mediator) - : base(logger, mediator) - { - } - - public Task StartAsync(CancellationToken cancellationToken) - { - // Subscribe to messages - Mediator.Subscribe(this, HandleMyMessage); - Mediator.Subscribe(this, HandleAnotherMessage); - return Task.CompletedTask; - } - - private void HandleMyMessage(MyCustomMessage message) - { - Logger.LogDebug("Received: {Data}, {Value}", message.Data, message.Value); - // Handle the message - } - - public Task StopAsync(CancellationToken cancellationToken) - { - // Cleanup is automatic with DisposableMediatorSubscriberBase - return Task.CompletedTask; - } -} -``` - -#### Publishing Messages - -```csharp -// Publish to all subscribers -Mediator.Publish(new MyCustomMessage("test", 42)); - -// Publish from non-mediator classes -_mediator.Publish(new NotificationMessage( - "Title", - "Message", - NotificationType.Info)); -``` - -#### Message Guidelines - -- **Use records** for messages (immutable and concise) -- **Keep messages simple**: Only carry data, no logic -- **Name clearly**: `Message` (e.g., `PairRequestReceivedMessage`) -- **Thread-safe data**: Messages are processed asynchronously unless `KeepThreadContext = true` -- **Avoid circular dependencies**: Messages should flow in one direction - ---- - -## Dependency Injection - -### Service Registration (Plugin.cs) - -```csharp -// In Plugin.cs constructor: -.ConfigureServices(collection => -{ - // Singleton services (shared state, long-lived) - collection.AddSingleton(); - collection.AddSingleton(); - collection.AddSingleton(); - - // Scoped services (per-resolution scope) - collection.AddScoped(); - collection.AddScoped(); - - // Hosted services (background services with lifecycle) - collection.AddHostedService(p => p.GetRequiredService()); - collection.AddHostedService(p => p.GetRequiredService()); - - // Lazy dependencies (avoid circular dependencies) - collection.AddSingleton(s => new Lazy(() => s.GetRequiredService())); - - // Factory pattern - collection.AddSingleton(); -}) -``` - -### Service Patterns - -#### Standard Service -```csharp -public class MyService -{ - private readonly ILogger _logger; - private readonly SomeDependency _dependency; - - public MyService( - ILogger logger, - SomeDependency dependency) - { - _logger = logger; - _dependency = dependency; - } - - public void DoWork() - { - _logger.LogInformation("Working..."); - _dependency.PerformAction(); - } -} -``` - -#### Hosted Service (Background Service) -```csharp -public class MyHostedService : IHostedService, IMediatorSubscriber -{ - private readonly ILogger _logger; - private readonly LightlessMediator _mediator; - - public LightlessMediator Mediator => _mediator; - - public MyHostedService( - ILogger logger, - LightlessMediator mediator) - { - _logger = logger; - _mediator = mediator; - } - - public Task StartAsync(CancellationToken cancellationToken) - { - _logger.LogInformation("Starting {Service}", nameof(MyHostedService)); - - // Subscribe to mediator messages - _mediator.Subscribe(this, HandleSomeMessage); - - // Initialize resources - return Task.CompletedTask; - } - - public Task StopAsync(CancellationToken cancellationToken) - { - _logger.LogInformation("Stopping {Service}", nameof(MyHostedService)); - - // Cleanup - _mediator.UnsubscribeAll(this); - - return Task.CompletedTask; - } - - private void HandleSomeMessage(SomeMessage msg) - { - // Handle message - } -} -``` - -#### Mediator Subscriber Service -```csharp -public sealed class MyService : DisposableMediatorSubscriberBase -{ - private readonly SomeDependency _dependency; - - public MyService( - ILogger logger, - LightlessMediator mediator, - SomeDependency dependency) - : base(logger, mediator) - { - _dependency = dependency; - - // Subscribe in constructor or in separate Init method - Mediator.Subscribe(this, HandleMessage); - } - - private void HandleMessage(SomeMessage msg) - { - Logger.LogDebug("Handling message: {Msg}", msg); - // Process message - } - - // Dispose is handled by base class -} -``` - ---- - -## Service Development - -### Service Responsibilities - -Services should follow **Single Responsibility Principle**: - -- **NotificationService**: Handles all in-game notifications -- **BroadcastService**: Manages Lightfinder broadcast state -- **PairRequestService**: Manages incoming pair requests -- **DalamudUtilService**: Utility methods for Dalamud framework operations - -### Service Guidelines - -1. **Logging**: Always use `ILogger` with appropriate log levels -2. **Error Handling**: Wrap risky operations in try-catch, log exceptions -3. **Async/Await**: Use `ConfigureAwait(false)` for non-UI operations -4. **Thread Safety**: Use locks, `ConcurrentDictionary`, or `SemaphoreSlim` for shared state -5. **Disposal**: Implement `IDisposable` or inherit from `DisposableMediatorSubscriberBase` - -### Example Service Template - -```csharp -using Microsoft.Extensions.Hosting; -using Microsoft.Extensions.Logging; - -namespace LightlessSync.Services; - -public sealed class TemplateService : DisposableMediatorSubscriberBase, IHostedService -{ - private readonly ILogger _logger; - private readonly SomeDependency _dependency; - private readonly SemaphoreSlim _lock = new(1); - - public TemplateService( - ILogger logger, - LightlessMediator mediator, - SomeDependency dependency) - : base(logger, mediator) - { - _logger = logger; - _dependency = dependency; - } - - public Task StartAsync(CancellationToken cancellationToken) - { - _logger.LogInformation("Starting {Service}", nameof(TemplateService)); - - Mediator.Subscribe(this, HandleSomeMessage); - - return Task.CompletedTask; - } - - public Task StopAsync(CancellationToken cancellationToken) - { - _logger.LogInformation("Stopping {Service}", nameof(TemplateService)); - - _lock.Dispose(); - - return Task.CompletedTask; - } - - private async void HandleSomeMessage(SomeMessage msg) - { - await _lock.WaitAsync().ConfigureAwait(false); - try - { - _logger.LogDebug("Processing message: {Msg}", msg); - - // Do work - await _dependency.ProcessAsync(msg).ConfigureAwait(false); - } - catch (Exception ex) - { - _logger.LogError(ex, "Failed to process message"); - } - finally - { - _lock.Release(); - } - } - - protected override void Dispose(bool disposing) - { - if (disposing) - { - _lock?.Dispose(); - } - - base.Dispose(disposing); - } -} -``` - ---- - -## UI Development - -### UI Base Classes - -All UI windows inherit from `WindowMediatorSubscriberBase`: - -```csharp -public class MyWindow : WindowMediatorSubscriberBase -{ - private readonly UiSharedService _uiShared; - - public MyWindow( - ILogger logger, - LightlessMediator mediator, - UiSharedService uiShared, - PerformanceCollectorService performanceCollector) - : base(logger, mediator, "My Window Title", performanceCollector) - { - _uiShared = uiShared; - - // Window configuration - Flags = ImGuiWindowFlags.NoScrollbar | ImGuiWindowFlags.NoScrollWithMouse; - SizeConstraints = new WindowSizeConstraints - { - MinimumSize = new Vector2(600, 400), - MaximumSize = new Vector2(800, 600) - }; - } - - protected override void DrawInternal() - { - // ImGui drawing code here - ImGui.Text("Hello, World!"); - } -} -``` - -### UI Guidelines - -1. **Separation of Concerns**: UI should only handle rendering and user input -2. **Use UiSharedService**: Centralized UI utilities (icons, buttons, styling) -3. **Performance**: Use `PerformanceCollectorService` to track rendering performance -4. **Disposal**: Windows are scoped; don't store state that needs to persist -5. **Mediator**: Use mediator to communicate with services -6. **ImGui Best Practices**: - - Use `ImRaii` for push/pop operations - - Always pair `Begin`/`End` calls - - Use `ImGuiHelpers.ScaledDummy()` for responsive spacing - - Check `IsOpen` property for visibility - -### ImGui Patterns - -```csharp -// Using ImRaii for automatic cleanup -using (ImRaii.PushColor(ImGuiCol.Button, UIColors.Get("LightlessGreen"))) -using (ImRaii.PushStyle(ImGuiStyleVar.FrameRounding, 6f)) -{ - if (ImGui.Button("Styled Button")) - { - // Handle click - } -} - -// Tab bars -using (var tabBar = ImRaii.TabBar("###my_tabs")) -{ - if (!tabBar) return; - - using (var tab1 = ImRaii.TabItem("Tab 1")) - { - if (tab1) - { - ImGui.Text("Tab 1 content"); - } - } - - using (var tab2 = ImRaii.TabItem("Tab 2")) - { - if (tab2) - { - ImGui.Text("Tab 2 content"); - } - } -} - -// Child windows for scrolling regions -using (var child = ImRaii.Child("###content", new Vector2(0, -40), false, - ImGuiWindowFlags.AlwaysVerticalScrollbar)) -{ - if (!child) return; - - // Scrollable content here -} -``` - ---- - -## Dalamud Integration - -### Dalamud Services - -Dalamud provides various services accessible through constructor injection: - -```csharp -// Common Dalamud services: -IClientState clientState // Player and world state -IFramework framework // Game framework events -IObjectTable objectTable // Game objects (players, NPCs, etc.) -IChatGui chatGui // Chat window access -ICommandManager commandManager // Command registration -IDataManager gameData // Game data sheets -IPluginLog pluginLog // Logging -INotificationManager notificationManager // Toast notifications -IGameGui gameGui // Game UI access -ITextureProvider textureProvider // Icon/texture loading -``` - -### Framework Threading - -**CRITICAL**: Dalamud operates on the **game's main thread**. - -```csharp -// Safe: Already on framework thread -private void OnFrameworkUpdate(IFramework framework) -{ - // Can safely access game state - var player = _clientState.LocalPlayer; -} - -// Unsafe: Called from background thread -private async Task BackgroundWork() -{ - // DO NOT access game state here! - - // Use DalamudUtilService to run on framework thread - await _dalamudUtil.RunOnFrameworkThread(() => - { - // Now safe to access game state - var player = _clientState.LocalPlayer; - }); -} -``` - -### Game Object Access - -```csharp -// Always check for null -var player = _clientState.LocalPlayer; -if (player == null) -{ - return; -} - -// Iterating game objects -foreach (var obj in _objectTable) -{ - if (obj is IPlayerCharacter pc) - { - // Handle player character - } -} - -// Finding specific objects -var target = _targetManager.Target; -if (target is IPlayerCharacter targetPlayer) -{ - // Handle targeted player -} -``` - -### IPC with Other Plugins - -Use the IPC pattern for communicating with other Dalamud plugins: - -```csharp -public sealed class IpcCallerExample : DisposableMediatorSubscriberBase, IIpcCaller -{ - private readonly IDalamudPluginInterface _pi; - private readonly ICallGateSubscriber _apiVersion; - - public string Name => "ExamplePlugin"; - public bool Available { get; private set; } - - public IpcCallerExample( - ILogger logger, - IDalamudPluginInterface pluginInterface, - LightlessMediator mediator) - : base(logger, mediator) - { - _pi = pluginInterface; - - try - { - _apiVersion = _pi.GetIpcSubscriber("ExamplePlugin.GetApiVersion"); - CheckAvailability(); - } - catch (Exception ex) - { - Logger.LogWarning(ex, "Failed to initialize IPC for ExamplePlugin"); - } - } - - private void CheckAvailability() - { - try - { - var version = _apiVersion.InvokeFunc(); - Available = version >= 1; - Logger.LogInformation("ExamplePlugin available, version: {Version}", version); - } - catch - { - Available = false; - } - } - - public void DoSomething() - { - if (!Available) - { - Logger.LogWarning("ExamplePlugin not available"); - return; - } - - // Call IPC methods - } -} -``` - ---- - -## Performance Considerations - -### Framework Updates - -The game runs at ~60 FPS. Avoid heavy operations in framework updates: - -```csharp -Mediator.Subscribe(this, OnTick); - -private void OnTick(PriorityFrameworkUpdateMessage _) -{ - // Throttle expensive operations - if ((DateTime.UtcNow - _lastCheck).TotalSeconds < 1) - { - return; - } - _lastCheck = DateTime.UtcNow; - - // Do lightweight work only -} -``` - -### Async Operations - -```csharp -// Good: Non-blocking async -public async Task FetchDataAsync() -{ - var result = await _httpClient.GetAsync(url).ConfigureAwait(false); - return await result.Content.ReadFromJsonAsync().ConfigureAwait(false); -} - -// Bad: Blocking async -public Data FetchDataBlocking() -{ - return FetchDataAsync().GetAwaiter().GetResult(); // Blocks thread! -} -``` - -### Collection Performance - -```csharp -// Good: Thread-safe concurrent collections -private readonly ConcurrentDictionary _cache = new(); - -// Good: Lock-protected regular collections -private readonly List _items = new(); -private readonly object _itemsLock = new(); - -public void AddItem(Item item) -{ - lock (_itemsLock) - { - _items.Add(item); - } -} - -// Good: SemaphoreSlim for async locks -private readonly SemaphoreSlim _asyncLock = new(1); - -public async Task ProcessAsync() -{ - await _asyncLock.WaitAsync().ConfigureAwait(false); - try - { - // Critical section - } - finally - { - _asyncLock.Release(); - } -} -``` - -### Memory Management - -```csharp -// Dispose pattern for unmanaged resources -public class ResourceManager : IDisposable -{ - private bool _disposed; - private readonly SemaphoreSlim _semaphore = new(1); - - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); - } - - protected virtual void Dispose(bool disposing) - { - if (_disposed) return; - - if (disposing) - { - // Dispose managed resources - _semaphore?.Dispose(); - } - - // Free unmanaged resources - - _disposed = true; - } -} -``` - ---- - -## Testing - -### Unit Testing - -```csharp -[TestClass] -public class MyServiceTests -{ - private Mock> _mockLogger; - private Mock _mockMediator; - private MyService _service; - - [TestInitialize] - public void Setup() - { - _mockLogger = new Mock>(); - _mockMediator = new Mock(); - _service = new MyService(_mockLogger.Object, _mockMediator.Object); - } - - [TestMethod] - public void DoWork_WithValidInput_ReturnsExpectedResult() - { - // Arrange - var input = "test"; - - // Act - var result = _service.DoWork(input); - - // Assert - Assert.AreEqual("expected", result); - } -} -``` - -### Integration Testing - -Test with real Dalamud services in a controlled environment: - -```csharp -// Create test harness that mimics Dalamud environment -public class DalamudTestHarness -{ - public IClientState ClientState { get; } - public IFramework Framework { get; } - // ... other services - - public void SimulateFrameworkUpdate() - { - // Trigger framework update event - } -} -``` - ---- - -## Common Patterns - -### Notification Pattern - -```csharp -// Simple notification -Mediator.Publish(new NotificationMessage( - "Title", - "Message body", - NotificationType.Info)); - -// Rich notification with actions -var notification = new LightlessNotification -{ - Id = "unique_id", - Title = "Action Required", - Message = "Do you want to proceed?", - Type = NotificationType.Warning, - Duration = TimeSpan.FromSeconds(10), - Actions = new List - { - new() - { - Id = "confirm", - Label = "Confirm", - Icon = FontAwesomeIcon.Check, - Color = UIColors.Get("LightlessGreen"), - IsPrimary = true, - OnClick = (n) => - { - _logger.LogInformation("User confirmed"); - DoAction(); - n.IsDismissed = true; - } - }, - new() - { - Id = "cancel", - Label = "Cancel", - Icon = FontAwesomeIcon.Times, - OnClick = (n) => n.IsDismissed = true - } - } -}; - -Mediator.Publish(new LightlessNotificationMessage(notification)); -``` - -### Configuration Pattern - -```csharp -public class MyConfigService : ConfigurationServiceBase -{ - public MyConfigService(string configDirectory) - : base(Path.Combine(configDirectory, "myconfig.json")) - { - } -} - -// Usage -_configService.Current.SomeSetting = newValue; -_configService.Save(); -``` - -### Factory Pattern - -```csharp -public class GameObjectHandlerFactory -{ - private readonly DalamudUtilService _dalamudUtil; - private readonly LightlessMediator _mediator; - - public GameObjectHandlerFactory( - DalamudUtilService dalamudUtil, - LightlessMediator mediator) - { - _dalamudUtil = dalamudUtil; - _mediator = mediator; - } - - public GameObjectHandler Create(IntPtr address, string identifier) - { - return new GameObjectHandler( - _dalamudUtil, - _mediator, - () => address, - identifier); - } -} -``` - ---- - -## Error Handling - -### Logging Guidelines - -```csharp -// Debug: Verbose information for debugging -_logger.LogDebug("Processing request {RequestId}", requestId); - -// Information: General informational messages -_logger.LogInformation("User {UserId} connected", userId); - -// Warning: Recoverable issues -_logger.LogWarning("Cache miss for {Key}, will fetch from server", key); - -// Error: Errors that need attention -_logger.LogError(ex, "Failed to process message {MessageId}", messageId); - -// Critical: Application-breaking errors -_logger.LogCritical(ex, "Database connection failed"); -``` - -### Exception Handling - -```csharp -public async Task DoWorkAsync() -{ - try - { - // Risky operation - return await PerformOperationAsync().ConfigureAwait(false); - } - catch (HttpRequestException ex) - { - _logger.LogError(ex, "Network error during operation"); - // Show user-friendly notification - Mediator.Publish(new NotificationMessage( - "Network Error", - "Failed to connect to server. Please check your connection.", - NotificationType.Error)); - return Result.Failure; - } - catch (Exception ex) - { - _logger.LogError(ex, "Unexpected error during operation"); - throw; // Re-throw unexpected exceptions - } -} -``` - ---- - -## Best Practices Summary - -### DO ✅ - -- Use `DisposableMediatorSubscriberBase` for services that subscribe to mediator -- Use `IHostedService` for background services -- Always inject `ILogger` for logging -- Use `ConfigureAwait(false)` for async operations not requiring UI thread -- Dispose of resources properly (SemaphoreSlim, HttpClient, etc.) -- Check for null when accessing Dalamud game objects -- Use thread-safe collections for shared state -- Keep UI logic separate from business logic -- Use mediator for cross-component communication -- Write unit tests for business logic -- Document public APIs with XML comments - -### DON'T ❌ - -- Don't access game objects from background threads without `RunOnFrameworkThread` -- Don't block async methods with `.Result` or `.Wait()` -- Don't store UI state in services (services are often singletons) -- Don't use `async void` except for event handlers -- Don't catch `Exception` without re-throwing or logging -- Don't create circular dependencies between services -- Don't perform heavy operations in framework updates -- Don't forget to unsubscribe from mediator messages -- Don't hardcode file paths (use `IDalamudPluginInterface.ConfigDirectory`) -- Don't use primary constructors (prefer traditional for clarity) - ---- - -## Code Review Checklist - -Before submitting a pull request, ensure: - -- [ ] Code follows naming conventions -- [ ] All new services are registered in `Plugin.cs` -- [ ] Mediator messages are defined in `Messages.cs` -- [ ] Logging is appropriate and informative -- [ ] Thread safety is considered for shared state -- [ ] Disposable resources are properly disposed -- [ ] Async operations use `ConfigureAwait(false)` -- [ ] UI code is separated from business logic -- [ ] No direct game object access from background threads -- [ ] Error handling is comprehensive -- [ ] Performance impact is considered -- [ ] Comments explain "why", not "what" -- [ ] No compiler warnings -- [ ] Tests pass (if applicable) - ---- - -## Resources - -- [Dalamud Documentation](https://dalamud.dev) -- [ImGui.NET Documentation](https://github.com/mellinoe/ImGui.NET) -- [C# Coding Conventions](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions) -- [.NET API Guidelines](https://github.com/dotnet/runtime/blob/main/docs/coding-guidelines/api-guidelines) - ---- - -**Happy Coding!** 🚀 From b4dd0ee0e1546173939191a9dcd7f6351613e9ac Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 20 Oct 2025 14:32:21 +0200 Subject: [PATCH 54/64] type cleanup --- LightlessSync/Plugin.cs | 6 +-- LightlessSync/UI/LightlessNotificationUI.cs | 46 ++++++++++----------- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/LightlessSync/Plugin.cs b/LightlessSync/Plugin.cs index 54a879e..01a4de4 100644 --- a/LightlessSync/Plugin.cs +++ b/LightlessSync/Plugin.cs @@ -255,9 +255,9 @@ public sealed class Plugin : IDalamudPlugin collection.AddScoped((s) => new BroadcastUI(s.GetRequiredService>(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService())); collection.AddScoped((s) => new SyncshellFinderUI(s.GetRequiredService>(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService())); collection.AddScoped(); - collection.AddScoped((s) => - new LightlessNotificationUI( - s.GetRequiredService>(), + collection.AddScoped((s) => + new LightlessNotificationUi( + s.GetRequiredService>(), s.GetRequiredService(), s.GetRequiredService(), s.GetRequiredService())); diff --git a/LightlessSync/UI/LightlessNotificationUI.cs b/LightlessSync/UI/LightlessNotificationUI.cs index 2ac26b7..3d2d748 100644 --- a/LightlessSync/UI/LightlessNotificationUI.cs +++ b/LightlessSync/UI/LightlessNotificationUI.cs @@ -15,17 +15,17 @@ using Dalamud.Bindings.ImGui; namespace LightlessSync.UI; -public class LightlessNotificationUI : WindowMediatorSubscriberBase +public class LightlessNotificationUi : WindowMediatorSubscriberBase { - private const float NotificationMinHeight = 60f; - private const float NotificationMaxHeight = 250f; - private const float WindowPaddingOffset = 6f; - private const float SlideAnimationDistance = 100f; - private const float OutAnimationSpeedMultiplier = 0.7f; - private const float ContentPaddingX = 10f; - private const float ContentPaddingY = 6f; - private const float TitleMessageSpacing = 4f; - private const float ActionButtonSpacing = 8f; + private const float _notificationMinHeight = 60f; + private const float _notificationMaxHeight = 250f; + private const float _windowPaddingOffset = 6f; + private const float _slideAnimationDistance = 100f; + private const float _outAnimationSpeedMultiplier = 0.7f; + private const float _contentPaddingX = 10f; + private const float _contentPaddingY = 6f; + private const float _titleMessageSpacing = 4f; + private const float _actionButtonSpacing = 8f; private readonly List _notifications = new(); private readonly object _notificationLock = new(); @@ -33,7 +33,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private readonly Dictionary _notificationYOffsets = new(); private readonly Dictionary _notificationTargetYOffsets = new(); - public LightlessNotificationUI(ILogger logger, LightlessMediator mediator, PerformanceCollectorService performanceCollector, LightlessConfigService configService) + public LightlessNotificationUi(ILogger logger, LightlessMediator mediator, PerformanceCollectorService performanceCollector, LightlessConfigService configService) : base(logger, mediator, "Lightless Notifications##LightlessNotifications", performanceCollector) { _configService = configService; @@ -155,8 +155,8 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase var width = _configService.Current.NotificationWidth; float posX = corner == NotificationCorner.Left - ? viewport.WorkPos.X + offsetX - WindowPaddingOffset - : viewport.WorkPos.X + viewport.WorkSize.X - width - offsetX - WindowPaddingOffset; + ? viewport.WorkPos.X + offsetX - _windowPaddingOffset + : viewport.WorkPos.X + viewport.WorkSize.X - width - offsetX - _windowPaddingOffset; return new Vector2(posX, viewport.WorkPos.Y); } @@ -274,7 +274,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase else if (notification.IsAnimatingOut && notification.AnimationProgress > 0f) { notification.AnimationProgress = Math.Max(0f, - notification.AnimationProgress - deltaTime * _configService.Current.NotificationAnimationSpeed * OutAnimationSpeedMultiplier); + notification.AnimationProgress - deltaTime * _configService.Current.NotificationAnimationSpeed * _outAnimationSpeedMultiplier); } else if (!notification.IsAnimatingOut && !notification.IsDismissed) { @@ -289,7 +289,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private Vector2 CalculateSlideOffset(float alpha) { - var distance = (1f - alpha) * SlideAnimationDistance; + var distance = (1f - alpha) * _slideAnimationDistance; var corner = _configService.Current.NotificationCorner; return corner == NotificationCorner.Left ? new Vector2(-distance, 0) : new Vector2(distance, 0); } @@ -466,7 +466,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private void DrawNotificationText(LightlessNotification notification, float alpha) { - var contentPos = new Vector2(ContentPaddingX, ContentPaddingY); + var contentPos = new Vector2(_contentPaddingX, _contentPaddingY); var windowSize = ImGui.GetWindowSize(); var contentWidth = CalculateContentWidth(windowSize.X); @@ -483,7 +483,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase } private float CalculateContentWidth(float windowWidth) => - windowWidth - (ContentPaddingX * 2); + windowWidth - (_contentPaddingX * 2); private bool HasActions(LightlessNotification notification) => notification.Actions.Count > 0; @@ -491,9 +491,9 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private void PositionActionsAtBottom(float windowHeight) { var actionHeight = ImGui.GetFrameHeight(); - var bottomY = windowHeight - ContentPaddingY - actionHeight; + var bottomY = windowHeight - _contentPaddingY - actionHeight; ImGui.SetCursorPosY(bottomY); - ImGui.SetCursorPosX(ContentPaddingX); + ImGui.SetCursorPosX(_contentPaddingX); } private float DrawTitle(LightlessNotification notification, float contentWidth, float alpha) @@ -530,7 +530,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase { if (string.IsNullOrEmpty(notification.Message)) return; - var messagePos = contentPos + new Vector2(0f, titleHeight + TitleMessageSpacing); + var messagePos = contentPos + new Vector2(0f, titleHeight + _titleMessageSpacing); var messageColor = new Vector4(0.9f, 0.9f, 0.9f, alpha); ImGui.SetCursorPos(messagePos); @@ -563,13 +563,13 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase private float CalculateActionButtonWidth(int actionCount, float availableWidth) { - var totalSpacing = (actionCount - 1) * ActionButtonSpacing; + var totalSpacing = (actionCount - 1) * _actionButtonSpacing; return (availableWidth - totalSpacing) / actionCount; } private void PositionActionButton(int index, float startX, float buttonWidth) { - var xPosition = startX + index * (buttonWidth + ActionButtonSpacing); + var xPosition = startX + index * (buttonWidth + _actionButtonSpacing); ImGui.SetCursorPosX(xPosition); } @@ -687,7 +687,7 @@ public class LightlessNotificationUI : WindowMediatorSubscriberBase height += 12f; } - return Math.Clamp(height, NotificationMinHeight, NotificationMaxHeight); + return Math.Clamp(height, _notificationMinHeight, _notificationMaxHeight); } private float CalculateTitleHeight(LightlessNotification notification, float contentWidth) From 4f5ef8ff4b0b6811f9c2cf1e31f4bceb7d9d3854 Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 20 Oct 2025 14:51:10 +0200 Subject: [PATCH 55/64] type cleanup --- LightlessSync/UI/UpdateNotesUi.cs | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/LightlessSync/UI/UpdateNotesUi.cs b/LightlessSync/UI/UpdateNotesUi.cs index f7544e1..bc60ab5 100644 --- a/LightlessSync/UI/UpdateNotesUi.cs +++ b/LightlessSync/UI/UpdateNotesUi.cs @@ -52,12 +52,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase private float _particleSpawnTimer; private readonly Random _random = new(); - private const float HeaderHeight = 150f; - private const float ParticleSpawnInterval = 0.2f; - private const int MaxParticles = 50; - private const int MaxTrailLength = 50; - private const float EdgeFadeDistance = 30f; - private const float ExtendedParticleHeight = 40f; + private const float _headerHeight = 150f; + private const float _particleSpawnInterval = 0.2f; + private const int _maxParticles = 50; + private const int _maxTrailLength = 50; + private const float _edgeFadeDistance = 30f; + private const float _extendedParticleHeight = 40f; public UpdateNotesUi(ILogger logger, LightlessMediator mediator, @@ -111,16 +111,16 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var headerWidth = (800f * ImGuiHelpers.GlobalScale) - (windowPadding.X * 2); var headerStart = windowPos + new Vector2(windowPadding.X, windowPadding.Y); - var headerEnd = headerStart + new Vector2(headerWidth, HeaderHeight); + var headerEnd = headerStart + new Vector2(headerWidth, _headerHeight); - var extendedParticleSize = new Vector2(headerWidth, HeaderHeight + ExtendedParticleHeight); + var extendedParticleSize = new Vector2(headerWidth, _headerHeight + _extendedParticleHeight); DrawGradientBackground(headerStart, headerEnd); DrawHeaderText(headerStart); DrawHeaderButtons(headerStart, headerWidth); DrawBottomGradient(headerStart, headerEnd, headerWidth); - ImGui.SetCursorPosY(windowPadding.Y + HeaderHeight + 5); + ImGui.SetCursorPosY(windowPadding.Y + _headerHeight + 5); ImGui.SetCursorPosX(20); using (ImRaii.PushFont(UiBuilder.IconFont)) { @@ -260,7 +260,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var deltaTime = ImGui.GetIO().DeltaTime; _particleSpawnTimer += deltaTime; - if (_particleSpawnTimer > ParticleSpawnInterval && _particles.Count < MaxParticles) + if (_particleSpawnTimer > _particleSpawnInterval && _particles.Count < _maxParticles) { SpawnParticle(bannerSize); _particleSpawnTimer = 0f; @@ -282,7 +282,7 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase if (particle.Type == ParticleType.ShootingStar && particle.Trail != null) { particle.Trail.Insert(0, particle.Position); - if (particle.Trail.Count > MaxTrailLength) + if (particle.Trail.Count > _maxTrailLength) particle.Trail.RemoveAt(particle.Trail.Count - 1); } @@ -316,12 +316,12 @@ public class UpdateNotesUi : WindowMediatorSubscriberBase var lifeFade = Math.Min(fadeIn, fadeOut); var edgeFadeX = Math.Min( - Math.Min(1f, (particle.Position.X + EdgeFadeDistance) / EdgeFadeDistance), - Math.Min(1f, (bannerSize.X - particle.Position.X + EdgeFadeDistance) / EdgeFadeDistance) + Math.Min(1f, (particle.Position.X + _edgeFadeDistance) / _edgeFadeDistance), + Math.Min(1f, (bannerSize.X - particle.Position.X + _edgeFadeDistance) / _edgeFadeDistance) ); var edgeFadeY = Math.Min( - Math.Min(1f, (particle.Position.Y + EdgeFadeDistance) / EdgeFadeDistance), - Math.Min(1f, (bannerSize.Y - particle.Position.Y + EdgeFadeDistance) / EdgeFadeDistance) + Math.Min(1f, (particle.Position.Y + _edgeFadeDistance) / _edgeFadeDistance), + Math.Min(1f, (bannerSize.Y - particle.Position.Y + _edgeFadeDistance) / _edgeFadeDistance) ); var edgeFade = Math.Min(edgeFadeX, edgeFadeY); From 147baa4c1bd5c8fac31989b71f70bd15e02774cc Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 20 Oct 2025 21:16:30 +0200 Subject: [PATCH 56/64] api cleanup, decline message on notification decline --- LightlessSync/Services/NotificationService.cs | 2 +- LightlessSync/Services/PairRequestService.cs | 6 +++++- LightlessSync/WebAPI/SignalR/ApiController.cs | 2 -- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/LightlessSync/Services/NotificationService.cs b/LightlessSync/Services/NotificationService.cs index 56da126..9e20064 100644 --- a/LightlessSync/Services/NotificationService.cs +++ b/LightlessSync/Services/NotificationService.cs @@ -568,7 +568,7 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ senderName, request.HashedCid, onAccept: () => _pairRequestService.AcceptPairRequest(request.HashedCid, senderName), - onDecline: () => _pairRequestService.DeclinePairRequest(request.HashedCid)); + onDecline: () => _pairRequestService.DeclinePairRequest(request.HashedCid, senderName)); } private void HandlePairRequestsUpdated(PairRequestsUpdatedMessage _) diff --git a/LightlessSync/Services/PairRequestService.cs b/LightlessSync/Services/PairRequestService.cs index f2ee64f..7190825 100644 --- a/LightlessSync/Services/PairRequestService.cs +++ b/LightlessSync/Services/PairRequestService.cs @@ -220,9 +220,13 @@ public sealed class PairRequestService : DisposableMediatorSubscriberBase }); } - public void DeclinePairRequest(string hashedCid) + public void DeclinePairRequest(string hashedCid, string displayName) { RemoveRequest(hashedCid); + Mediator.Publish(new NotificationMessage("Pair request declined", + "Declined " + displayName + "'s pending pair request.", + NotificationType.Info, + TimeSpan.FromSeconds(3))); Logger.LogDebug("Declined pair request from {HashedCid}", hashedCid); } diff --git a/LightlessSync/WebAPI/SignalR/ApiController.cs b/LightlessSync/WebAPI/SignalR/ApiController.cs index 56ab36e..15aef29 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.cs @@ -32,7 +32,6 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL private readonly ServerConfigurationManager _serverManager; private readonly TokenProvider _tokenProvider; private readonly LightlessConfigService _lightlessConfigService; - private readonly NotificationService _lightlessNotificationService; private CancellationTokenSource _connectionCancellationTokenSource; private ConnectionDto? _connectionDto; private bool _doNotNotifyOnNextInfo = false; @@ -54,7 +53,6 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL _serverManager = serverManager; _tokenProvider = tokenProvider; _lightlessConfigService = lightlessConfigService; - _lightlessNotificationService = lightlessNotificationService; _connectionCancellationTokenSource = new CancellationTokenSource(); Mediator.Subscribe(this, (_) => DalamudUtilOnLogIn()); From ee20b6fa5f9808b0112570073dccae080936a942 Mon Sep 17 00:00:00 2001 From: choco Date: Mon, 20 Oct 2025 21:25:28 +0200 Subject: [PATCH 57/64] version 1.12.3 --- LightlessSync/LightlessSync.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessSync/LightlessSync.csproj b/LightlessSync/LightlessSync.csproj index 42fb61b..b4b5288 100644 --- a/LightlessSync/LightlessSync.csproj +++ b/LightlessSync/LightlessSync.csproj @@ -3,7 +3,7 @@ - 1.12.2.6 + 1.12.3 https://github.com/Light-Public-Syncshells/LightlessClient From a32ac02c6d00a4178266b6f84e234f50ca04fe98 Mon Sep 17 00:00:00 2001 From: choco Date: Tue, 21 Oct 2025 09:59:30 +0200 Subject: [PATCH 58/64] download notification stuck fix --- LightlessSync/Services/NotificationService.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessSync/Services/NotificationService.cs b/LightlessSync/Services/NotificationService.cs index 9e20064..72f4a16 100644 --- a/LightlessSync/Services/NotificationService.cs +++ b/LightlessSync/Services/NotificationService.cs @@ -608,7 +608,7 @@ public class NotificationService : DisposableMediatorSubscriberBase, IHostedServ Mediator.Publish(new LightlessNotificationMessage(notification)); - if (AreAllDownloadsCompleted(userDownloads)) + if (userDownloads.Count == 0 || AreAllDownloadsCompleted(userDownloads)) { Mediator.Publish(new LightlessNotificationDismissMessage("pair_download_progress")); } From 7aadbcec10719d28fdee25a4b7ddd0dab9d9eaa4 Mon Sep 17 00:00:00 2001 From: defnotken Date: Tue, 21 Oct 2025 11:22:19 -0500 Subject: [PATCH 59/64] Wording changes --- LightlessSync/Changelog/changelog.yaml | 1 + LightlessSync/Changelog/credits.yaml | 12 ++++++------ LightlessSync/UI/EditProfileUi.cs | 2 +- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/LightlessSync/Changelog/changelog.yaml b/LightlessSync/Changelog/changelog.yaml index db2397d..7055a90 100644 --- a/LightlessSync/Changelog/changelog.yaml +++ b/LightlessSync/Changelog/changelog.yaml @@ -25,6 +25,7 @@ changelog: - "More customizable notification options." - "Perfomance limiter shows as notifications." - "All notifications can be configured or disabled in Settings → Notifications." + - "Cleaning up notifications implementation" - number: "Bugfixes" icon: "" items: diff --git a/LightlessSync/Changelog/credits.yaml b/LightlessSync/Changelog/credits.yaml index b04b1e6..d685978 100644 --- a/LightlessSync/Changelog/credits.yaml +++ b/LightlessSync/Changelog/credits.yaml @@ -51,12 +51,12 @@ credits: role: "Height offset integration" - name: "Honorific Team" role: "Title system integration" - - name: "Moodles Team" - role: "Status effect integration" - - name: "PetNicknames Team" - role: "Pet naming integration" - - name: "Brio Team" - role: "GPose enhancement integration" + - name: "Glyceri" + role: "Moodles - Status effect integration" + - name: "Glyceri" + role: "PetNicknames - Pet naming integration" + - name: "Minmoose" + role: "Brio - GPose enhancement integration" - category: "Special Thanks" items: diff --git a/LightlessSync/UI/EditProfileUi.cs b/LightlessSync/UI/EditProfileUi.cs index 44c314a..3dd8725 100644 --- a/LightlessSync/UI/EditProfileUi.cs +++ b/LightlessSync/UI/EditProfileUi.cs @@ -281,7 +281,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase { _uiSharedService.MediumText("Supporter Vanity Settings", UIColors.Get("LightlessPurple")); ImGui.Dummy(new Vector2(4)); - _uiSharedService.DrawNoteLine("# ", UIColors.Get("LightlessPurple"), "Must be a supporter through Patreon/Ko-fi to access these settings."); + _uiSharedService.DrawNoteLine("# ", UIColors.Get("LightlessPurple"), "Must be a supporter through Patreon/Ko-fi to access these settings. If you have the vanity role, you must interact with the Discord bot first."); var hasVanity = _apiController.HasVanity; From 1a89c2caeef874c00b816faea4bbd31fedfa248c Mon Sep 17 00:00:00 2001 From: azyges <229218900+azyges@users.noreply.github.com> Date: Wed, 22 Oct 2025 03:20:13 +0900 Subject: [PATCH 60/64] some caching stuff and bug fixes --- LightlessSync/Services/CharacterAnalyzer.cs | 58 +++++- LightlessSync/UI/CompactUI.cs | 144 +++++++------- LightlessSync/UI/Components/DrawUserPair.cs | 187 ++++++++++++++---- LightlessSync/UI/Handlers/IdDisplayHandler.cs | 2 +- LightlessSync/Utils/SeStringUtils.cs | 44 ++++- 5 files changed, 316 insertions(+), 119 deletions(-) diff --git a/LightlessSync/Services/CharacterAnalyzer.cs b/LightlessSync/Services/CharacterAnalyzer.cs index c35fd01..27235f6 100644 --- a/LightlessSync/Services/CharacterAnalyzer.cs +++ b/LightlessSync/Services/CharacterAnalyzer.cs @@ -6,7 +6,11 @@ using LightlessSync.UI; using LightlessSync.Utils; using Lumina.Data.Files; using Microsoft.Extensions.Logging; - +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; namespace LightlessSync.Services; public sealed class CharacterAnalyzer : MediatorSubscriberBase, IDisposable @@ -16,6 +20,7 @@ public sealed class CharacterAnalyzer : MediatorSubscriberBase, IDisposable private CancellationTokenSource? _analysisCts; private CancellationTokenSource _baseAnalysisCts = new(); private string _lastDataHash = string.Empty; + private CharacterAnalysisSummary _latestSummary = CharacterAnalysisSummary.Empty; public CharacterAnalyzer(ILogger logger, LightlessMediator mediator, FileCacheManager fileCacheManager, XivDataAnalyzer modelAnalyzer) : base(logger, mediator) @@ -34,6 +39,7 @@ public sealed class CharacterAnalyzer : MediatorSubscriberBase, IDisposable public bool IsAnalysisRunning => _analysisCts != null; public int TotalFiles { get; internal set; } internal Dictionary> LastAnalysis { get; } = []; + public CharacterAnalysisSummary LatestSummary => _latestSummary; public void CancelAnalyze() { @@ -80,6 +86,8 @@ public sealed class CharacterAnalyzer : MediatorSubscriberBase, IDisposable } } + RecalculateSummary(); + Mediator.Publish(new CharacterDataAnalyzedMessage()); _analysisCts.CancelDispose(); @@ -137,11 +145,39 @@ public sealed class CharacterAnalyzer : MediatorSubscriberBase, IDisposable LastAnalysis[obj.Key] = data; } + RecalculateSummary(); + Mediator.Publish(new CharacterDataAnalyzedMessage()); _lastDataHash = charaData.DataHash.Value; } + private void RecalculateSummary() + { + var builder = ImmutableDictionary.CreateBuilder(); + + foreach (var (objectKind, entries) in LastAnalysis) + { + long totalTriangles = 0; + long texOriginalBytes = 0; + long texCompressedBytes = 0; + + foreach (var entry in entries.Values) + { + totalTriangles += entry.Triangles; + if (string.Equals(entry.FileType, "tex", StringComparison.OrdinalIgnoreCase)) + { + texOriginalBytes += entry.OriginalSize; + texCompressedBytes += entry.CompressedSize; + } + } + + builder[objectKind] = new CharacterAnalysisObjectSummary(entries.Count, totalTriangles, texOriginalBytes, texCompressedBytes); + } + + _latestSummary = new CharacterAnalysisSummary(builder.ToImmutable()); + } + private void PrintAnalysis() { if (LastAnalysis.Count == 0) return; @@ -232,4 +268,24 @@ public sealed class CharacterAnalyzer : MediatorSubscriberBase, IDisposable } }); } +} + +public readonly record struct CharacterAnalysisObjectSummary(int EntryCount, long TotalTriangles, long TexOriginalBytes, long TexCompressedBytes) +{ + public bool HasEntries => EntryCount > 0; +} + +public sealed class CharacterAnalysisSummary +{ + public static CharacterAnalysisSummary Empty { get; } = + new(ImmutableDictionary.Empty); + + internal CharacterAnalysisSummary(IImmutableDictionary objects) + { + Objects = objects; + } + + public IImmutableDictionary Objects { get; } + + public bool HasData => Objects.Any(kvp => kvp.Value.HasEntries); } \ No newline at end of file diff --git a/LightlessSync/UI/CompactUI.cs b/LightlessSync/UI/CompactUI.cs index c264681..0700de3 100644 --- a/LightlessSync/UI/CompactUI.cs +++ b/LightlessSync/UI/CompactUI.cs @@ -56,7 +56,6 @@ public class CompactUi : WindowMediatorSubscriberBase private readonly BroadcastService _broadcastService; private List _drawFolders; - private Dictionary>? _cachedAnalysis; private Pair? _lastAddedUser; private string _lastAddedUserComment = string.Empty; private Vector2 _lastPosition = Vector2.One; @@ -382,15 +381,26 @@ public class CompactUi : WindowMediatorSubscriberBase _uiSharedService.IconText(FontAwesomeIcon.Upload); ImGui.SameLine(35 * ImGuiHelpers.GlobalScale); - if (currentUploads.Any()) + if (currentUploads.Count > 0) { - var totalUploads = currentUploads.Count; + int totalUploads = currentUploads.Count; + int doneUploads = 0; + long totalUploaded = 0; + long totalToUpload = 0; - var doneUploads = currentUploads.Count(c => c.IsTransferred); - var activeUploads = currentUploads.Count(c => !c.IsTransferred); + foreach (var upload in currentUploads) + { + if (upload.IsTransferred) + { + doneUploads++; + } + + totalUploaded += upload.Transferred; + totalToUpload += upload.Total; + } + + int activeUploads = totalUploads - doneUploads; var uploadSlotLimit = Math.Clamp(_configService.Current.ParallelUploads, 1, 8); - var totalUploaded = currentUploads.Sum(c => c.Transferred); - var totalToUpload = currentUploads.Sum(c => c.Total); ImGui.TextUnformatted($"{doneUploads}/{totalUploads} (slots {activeUploads}/{uploadSlotLimit})"); var uploadText = $"({UiSharedService.ByteToString(totalUploaded)}/{UiSharedService.ByteToString(totalToUpload)})"; @@ -405,17 +415,17 @@ public class CompactUi : WindowMediatorSubscriberBase ImGui.TextUnformatted("No uploads in progress"); } - var currentDownloads = BuildCurrentDownloadSnapshot(); + var downloadSummary = GetDownloadSummary(); ImGui.AlignTextToFramePadding(); _uiSharedService.IconText(FontAwesomeIcon.Download); ImGui.SameLine(35 * ImGuiHelpers.GlobalScale); - if (currentDownloads.Any()) + if (downloadSummary.HasDownloads) { - var totalDownloads = currentDownloads.Sum(c => c.TotalFiles); - var doneDownloads = currentDownloads.Sum(c => c.TransferredFiles); - var totalDownloaded = currentDownloads.Sum(c => c.TransferredBytes); - var totalToDownload = currentDownloads.Sum(c => c.TotalBytes); + var totalDownloads = downloadSummary.TotalFiles; + var doneDownloads = downloadSummary.TransferredFiles; + var totalDownloaded = downloadSummary.TransferredBytes; + var totalToDownload = downloadSummary.TotalBytes; ImGui.TextUnformatted($"{doneDownloads}/{totalDownloads}"); var downloadText = @@ -433,27 +443,35 @@ public class CompactUi : WindowMediatorSubscriberBase } - private List BuildCurrentDownloadSnapshot() + private DownloadSummary GetDownloadSummary() { - List snapshot = new(); + long totalBytes = 0; + long transferredBytes = 0; + int totalFiles = 0; + int transferredFiles = 0; foreach (var kvp in _currentDownloads.ToArray()) { - var value = kvp.Value; - if (value == null || value.Count == 0) + if (kvp.Value is not { Count: > 0 } statuses) + { continue; - - try - { - snapshot.AddRange(value.Values.ToArray()); } - catch (System.ArgumentException) + + foreach (var status in statuses.Values) { - // skibidi + totalBytes += status.TotalBytes; + transferredBytes += status.TransferredBytes; + totalFiles += status.TotalFiles; + transferredFiles += status.TransferredFiles; } } - return snapshot; + return new DownloadSummary(totalFiles, transferredFiles, transferredBytes, totalBytes); + } + + private readonly record struct DownloadSummary(int TotalFiles, int TransferredFiles, long TransferredBytes, long TotalBytes) + { + public bool HasDownloads => TotalFiles > 0 || TotalBytes > 0; } private void DrawUIDHeader() @@ -480,7 +498,7 @@ public class CompactUi : WindowMediatorSubscriberBase } //Getting information of character and triangles threshold to show overlimit status in UID bar. - _cachedAnalysis = _characterAnalyzer.LastAnalysis.DeepClone(); + var analysisSummary = _characterAnalyzer.LatestSummary; Vector2 uidTextSize, iconSize; using (_uiSharedService.UidFont.Push()) @@ -509,6 +527,7 @@ public class CompactUi : WindowMediatorSubscriberBase if (ImGui.IsItemHovered()) { ImGui.BeginTooltip(); + ImGui.PushTextWrapPos(ImGui.GetFontSize() * 32f); ImGui.PushStyleColor(ImGuiCol.Text, UIColors.Get("PairBlue")); ImGui.Text("Lightfinder"); @@ -556,6 +575,7 @@ public class CompactUi : WindowMediatorSubscriberBase ImGui.PopStyleColor(); } + ImGui.PopTextWrapPos(); ImGui.EndTooltip(); } @@ -574,7 +594,7 @@ public class CompactUi : WindowMediatorSubscriberBase var seString = SeStringUtils.BuildFormattedPlayerName(uidText, vanityTextColor, vanityGlowColor); var cursorPos = ImGui.GetCursorScreenPos(); var fontPtr = ImGui.GetFont(); - SeStringUtils.RenderSeStringWithHitbox(seString, cursorPos, fontPtr); + SeStringUtils.RenderSeStringWithHitbox(seString, cursorPos, fontPtr, "uid-header"); } else { @@ -591,56 +611,40 @@ public class CompactUi : WindowMediatorSubscriberBase UiSharedService.AttachToolTip("Click to copy"); - if (_cachedAnalysis != null && _apiController.ServerState is ServerState.Connected) + if (_apiController.ServerState is ServerState.Connected && analysisSummary.HasData) { - var firstEntry = _cachedAnalysis.FirstOrDefault(); - var valueDict = firstEntry.Value; - if (valueDict != null && valueDict.Count > 0) + var objectSummary = analysisSummary.Objects.Values.FirstOrDefault(summary => summary.HasEntries); + if (objectSummary.HasEntries) { - var groupedfiles = valueDict - .Select(v => v.Value) - .Where(v => v != null) - .GroupBy(f => f.FileType, StringComparer.Ordinal) - .OrderBy(k => k.Key, StringComparer.Ordinal) - .ToList(); + var actualVramUsage = objectSummary.TexOriginalBytes; + var actualTriCount = objectSummary.TotalTriangles; - var actualTriCount = valueDict - .Select(v => v.Value) - .Where(v => v != null) - .Sum(f => f.Triangles); + var isOverVRAMUsage = _playerPerformanceConfig.Current.VRAMSizeWarningThresholdMiB * 1024 * 1024 < actualVramUsage; + var isOverTriHold = actualTriCount > (_playerPerformanceConfig.Current.TrisWarningThresholdThousands * 1000); - if (groupedfiles != null) + if ((isOverTriHold || isOverVRAMUsage) && _playerPerformanceConfig.Current.WarnOnExceedingThresholds) { - //Checking of VRAM threshhold - var texGroup = groupedfiles.SingleOrDefault(v => string.Equals(v.Key, "tex", StringComparison.Ordinal)); - var actualVramUsage = texGroup != null ? texGroup.Sum(f => f.OriginalSize) : 0L; - var isOverVRAMUsage = _playerPerformanceConfig.Current.VRAMSizeWarningThresholdMiB * 1024 * 1024 < actualVramUsage; - var isOverTriHold = actualTriCount > (_playerPerformanceConfig.Current.TrisWarningThresholdThousands * 1000); + ImGui.SameLine(); + ImGui.SetCursorPosY(cursorY + 15f); + _uiSharedService.IconText(FontAwesomeIcon.ExclamationTriangle, UIColors.Get("LightlessYellow")); - if ((isOverTriHold || isOverVRAMUsage) && _playerPerformanceConfig.Current.WarnOnExceedingThresholds) + string warningMessage = ""; + if (isOverTriHold) { - ImGui.SameLine(); - ImGui.SetCursorPosY(cursorY + 15f); - _uiSharedService.IconText(FontAwesomeIcon.ExclamationTriangle, UIColors.Get("LightlessYellow")); + warningMessage += $"You exceed your own triangles threshold by " + + $"{actualTriCount - _playerPerformanceConfig.Current.TrisWarningThresholdThousands * 1000} triangles."; + warningMessage += Environment.NewLine; - string warningMessage = ""; - if (isOverTriHold) - { - warningMessage += $"You exceed your own triangles threshold by " + - $"{actualTriCount - _playerPerformanceConfig.Current.TrisWarningThresholdThousands * 1000} triangles."; - warningMessage += Environment.NewLine; - - } - if (isOverVRAMUsage) - { - warningMessage += $"You exceed your own VRAM threshold by " + - $"{UiSharedService.ByteToString(actualVramUsage - (_playerPerformanceConfig.Current.VRAMSizeWarningThresholdMiB * 1024 * 1024))}."; - } - UiSharedService.AttachToolTip(warningMessage); - if (ImGui.IsItemClicked()) - { - _lightlessMediator.Publish(new UiToggleMessage(typeof(DataAnalysisUi))); - } + } + if (isOverVRAMUsage) + { + warningMessage += $"You exceed your own VRAM threshold by " + + $"{UiSharedService.ByteToString(actualVramUsage - (_playerPerformanceConfig.Current.VRAMSizeWarningThresholdMiB * 1024 * 1024))}."; + } + UiSharedService.AttachToolTip(warningMessage); + if (ImGui.IsItemClicked()) + { + _lightlessMediator.Publish(new UiToggleMessage(typeof(DataAnalysisUi))); } } } @@ -663,7 +667,7 @@ public class CompactUi : WindowMediatorSubscriberBase var seString = SeStringUtils.BuildFormattedPlayerName(_apiController.UID, vanityTextColor, vanityGlowColor); var cursorPos = ImGui.GetCursorScreenPos(); var fontPtr = ImGui.GetFont(); - SeStringUtils.RenderSeStringWithHitbox(seString, cursorPos, fontPtr); + SeStringUtils.RenderSeStringWithHitbox(seString, cursorPos, fontPtr, "uid-footer"); } else { @@ -921,4 +925,4 @@ public class CompactUi : WindowMediatorSubscriberBase _wasOpen = IsOpen; IsOpen = false; } -} \ No newline at end of file +} diff --git a/LightlessSync/UI/Components/DrawUserPair.cs b/LightlessSync/UI/Components/DrawUserPair.cs index fa5022e..4c4c1d4 100644 --- a/LightlessSync/UI/Components/DrawUserPair.cs +++ b/LightlessSync/UI/Components/DrawUserPair.cs @@ -2,6 +2,7 @@ using Dalamud.Interface; using Dalamud.Interface.Utility; using Dalamud.Interface.Utility.Raii; +using LightlessSync.API.Data.Enum; using LightlessSync.API.Data.Extensions; using LightlessSync.API.Dto.Group; using LightlessSync.API.Dto.User; @@ -13,6 +14,9 @@ using LightlessSync.Services.ServerConfiguration; using LightlessSync.UI.Handlers; using LightlessSync.Utils; using LightlessSync.WebAPI; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Text; namespace LightlessSync.UI.Components; @@ -32,6 +36,8 @@ public class DrawUserPair private readonly CharaDataManager _charaDataManager; private float _menuWidth = -1; private bool _wasHovered = false; + private TooltipSnapshot _tooltipSnapshot = TooltipSnapshot.Empty; + private string _cachedTooltip = string.Empty; public DrawUserPair(string id, Pair entry, List syncedGroups, GroupFullInfoDto? currentGroup, @@ -190,15 +196,12 @@ public class DrawUserPair private void DrawLeftSide() { - string userPairText = string.Empty; - ImGui.AlignTextToFramePadding(); if (_pair.IsPaused) { using var _ = ImRaii.PushColor(ImGuiCol.Text, UIColors.Get("LightlessYellow")); _uiSharedService.IconText(FontAwesomeIcon.PauseCircle); - userPairText = _pair.UserData.AliasOrUID + " is paused"; } else if (!_pair.IsOnline) { @@ -207,12 +210,10 @@ public class DrawUserPair ? FontAwesomeIcon.ArrowsLeftRight : (_pair.IndividualPairStatus == API.Data.Enum.IndividualPairStatus.Bidirectional ? FontAwesomeIcon.User : FontAwesomeIcon.Users)); - userPairText = _pair.UserData.AliasOrUID + " is offline"; } else if (_pair.IsVisible) { _uiSharedService.IconText(FontAwesomeIcon.Eye, UIColors.Get("LightlessBlue")); - userPairText = _pair.UserData.AliasOrUID + " is visible: " + _pair.PlayerName + Environment.NewLine + "Click to target this player"; if (ImGui.IsItemClicked()) { _mediator.Publish(new TargetPairMessage(_pair)); @@ -223,46 +224,9 @@ public class DrawUserPair using var _ = ImRaii.PushColor(ImGuiCol.Text, UIColors.Get("PairBlue")); _uiSharedService.IconText(_pair.IndividualPairStatus == API.Data.Enum.IndividualPairStatus.Bidirectional ? FontAwesomeIcon.User : FontAwesomeIcon.Users); - userPairText = _pair.UserData.AliasOrUID + " is online"; } - if (_pair.IndividualPairStatus == API.Data.Enum.IndividualPairStatus.OneSided) - { - userPairText += UiSharedService.TooltipSeparator + "User has not added you back"; - } - else if (_pair.IndividualPairStatus == API.Data.Enum.IndividualPairStatus.Bidirectional) - { - userPairText += UiSharedService.TooltipSeparator + "You are directly Paired"; - } - - if (_pair.LastAppliedDataBytes >= 0) - { - userPairText += UiSharedService.TooltipSeparator; - userPairText += ((!_pair.IsPaired) ? "(Last) " : string.Empty) + "Mods Info" + Environment.NewLine; - userPairText += "Files Size: " + UiSharedService.ByteToString(_pair.LastAppliedDataBytes, true); - if (_pair.LastAppliedApproximateVRAMBytes >= 0) - { - userPairText += Environment.NewLine + "Approx. VRAM Usage: " + UiSharedService.ByteToString(_pair.LastAppliedApproximateVRAMBytes, true); - } - if (_pair.LastAppliedDataTris >= 0) - { - userPairText += Environment.NewLine + "Approx. Triangle Count (excl. Vanilla): " - + (_pair.LastAppliedDataTris > 1000 ? (_pair.LastAppliedDataTris / 1000d).ToString("0.0'k'") : _pair.LastAppliedDataTris); - } - } - - if (_syncedGroups.Any()) - { - userPairText += UiSharedService.TooltipSeparator + string.Join(Environment.NewLine, - _syncedGroups.Select(g => - { - var groupNote = _serverConfigurationManager.GetNoteForGid(g.GID); - var groupString = string.IsNullOrEmpty(groupNote) ? g.GroupAliasOrGID : $"{groupNote} ({g.GroupAliasOrGID})"; - return "Paired through " + groupString; - })); - } - - UiSharedService.AttachToolTip(userPairText); + UiSharedService.AttachToolTip(GetUserTooltip()); if (_performanceConfigService.Current.ShowPerformanceIndicator && !_performanceConfigService.Current.UIDsToIgnore @@ -327,6 +291,143 @@ public class DrawUserPair _displayHandler.DrawPairText(_id, _pair, leftSide, () => rightSide - leftSide); } + private string GetUserTooltip() + { + List? groupDisplays = null; + if (_syncedGroups.Count > 0) + { + groupDisplays = new List(_syncedGroups.Count); + foreach (var group in _syncedGroups) + { + var groupNote = _serverConfigurationManager.GetNoteForGid(group.GID); + groupDisplays.Add(string.IsNullOrEmpty(groupNote) ? group.GroupAliasOrGID : $"{groupNote} ({group.GroupAliasOrGID})"); + } + } + + var snapshot = new TooltipSnapshot( + _pair.IsPaused, + _pair.IsOnline, + _pair.IsVisible, + _pair.IndividualPairStatus, + _pair.UserData.AliasOrUID, + _pair.PlayerName ?? string.Empty, + _pair.LastAppliedDataBytes, + _pair.LastAppliedApproximateVRAMBytes, + _pair.LastAppliedDataTris, + _pair.IsPaired, + groupDisplays is null ? ImmutableArray.Empty : ImmutableArray.CreateRange(groupDisplays)); + + if (!_tooltipSnapshot.Equals(snapshot)) + { + _cachedTooltip = BuildTooltip(snapshot); + _tooltipSnapshot = snapshot; + } + + return _cachedTooltip; + } + + private static string BuildTooltip(in TooltipSnapshot snapshot) + { + var builder = new StringBuilder(256); + + if (snapshot.IsPaused) + { + builder.Append(snapshot.AliasOrUid); + builder.Append(" is paused"); + } + else if (!snapshot.IsOnline) + { + builder.Append(snapshot.AliasOrUid); + builder.Append(" is offline"); + } + else if (snapshot.IsVisible) + { + builder.Append(snapshot.AliasOrUid); + builder.Append(" is visible: "); + builder.Append(snapshot.PlayerName); + builder.Append(Environment.NewLine); + builder.Append("Click to target this player"); + } + else + { + builder.Append(snapshot.AliasOrUid); + builder.Append(" is online"); + } + + if (snapshot.PairStatus == IndividualPairStatus.OneSided) + { + builder.Append(UiSharedService.TooltipSeparator); + builder.Append("User has not added you back"); + } + else if (snapshot.PairStatus == IndividualPairStatus.Bidirectional) + { + builder.Append(UiSharedService.TooltipSeparator); + builder.Append("You are directly Paired"); + } + + if (snapshot.LastAppliedDataBytes >= 0) + { + builder.Append(UiSharedService.TooltipSeparator); + if (!snapshot.IsPaired) + { + builder.Append("(Last) "); + } + builder.Append("Mods Info"); + builder.Append(Environment.NewLine); + builder.Append("Files Size: "); + builder.Append(UiSharedService.ByteToString(snapshot.LastAppliedDataBytes, true)); + + if (snapshot.LastAppliedApproximateVRAMBytes >= 0) + { + builder.Append(Environment.NewLine); + builder.Append("Approx. VRAM Usage: "); + builder.Append(UiSharedService.ByteToString(snapshot.LastAppliedApproximateVRAMBytes, true)); + } + + if (snapshot.LastAppliedDataTris >= 0) + { + builder.Append(Environment.NewLine); + builder.Append("Approx. Triangle Count (excl. Vanilla): "); + builder.Append(snapshot.LastAppliedDataTris > 1000 + ? (snapshot.LastAppliedDataTris / 1000d).ToString("0.0'k'") + : snapshot.LastAppliedDataTris); + } + } + + if (!snapshot.GroupDisplays.IsEmpty) + { + builder.Append(UiSharedService.TooltipSeparator); + for (int i = 0; i < snapshot.GroupDisplays.Length; i++) + { + if (i > 0) + { + builder.Append(Environment.NewLine); + } + builder.Append("Paired through "); + builder.Append(snapshot.GroupDisplays[i]); + } + } + + return builder.ToString(); + } + + private readonly record struct TooltipSnapshot( + bool IsPaused, + bool IsOnline, + bool IsVisible, + IndividualPairStatus PairStatus, + string AliasOrUid, + string PlayerName, + long LastAppliedDataBytes, + long LastAppliedApproximateVRAMBytes, + long LastAppliedDataTris, + bool IsPaired, + ImmutableArray GroupDisplays) + { + public static TooltipSnapshot Empty { get; } = + new(false, false, false, IndividualPairStatus.None, string.Empty, string.Empty, -1, -1, -1, false, ImmutableArray.Empty); + } + private void DrawPairedClientMenu() { DrawIndividualMenu(); diff --git a/LightlessSync/UI/Handlers/IdDisplayHandler.cs b/LightlessSync/UI/Handlers/IdDisplayHandler.cs index 01f0df6..4d362a9 100644 --- a/LightlessSync/UI/Handlers/IdDisplayHandler.cs +++ b/LightlessSync/UI/Handlers/IdDisplayHandler.cs @@ -157,7 +157,7 @@ public class IdDisplayHandler Vector2 textSize; using (ImRaii.PushFont(font, textIsUid)) { - SeStringUtils.RenderSeStringWithHitbox(seString, rowStart, font); + SeStringUtils.RenderSeStringWithHitbox(seString, rowStart, font, pair.UserData.UID); itemMin = ImGui.GetItemRectMin(); itemMax = ImGui.GetItemRectMax(); //textSize = itemMax - itemMin; diff --git a/LightlessSync/Utils/SeStringUtils.cs b/LightlessSync/Utils/SeStringUtils.cs index a19a343..7507515 100644 --- a/LightlessSync/Utils/SeStringUtils.cs +++ b/LightlessSync/Utils/SeStringUtils.cs @@ -7,6 +7,7 @@ using Dalamud.Interface.Utility; using Lumina.Text; using System; using System.Numerics; +using System.Threading; using DalamudSeString = Dalamud.Game.Text.SeStringHandling.SeString; using DalamudSeStringBuilder = Dalamud.Game.Text.SeStringHandling.SeStringBuilder; using LuminaSeStringBuilder = Lumina.Text.SeStringBuilder; @@ -15,6 +16,9 @@ namespace LightlessSync.Utils; public static class SeStringUtils { + private static int _seStringHitboxCounter; + private static int _iconHitboxCounter; + public static DalamudSeString BuildFormattedPlayerName(string text, Vector4? textColor, Vector4? glowColor) { var b = new DalamudSeStringBuilder(); @@ -119,7 +123,7 @@ public static class SeStringUtils ImGui.Dummy(new Vector2(0f, textSize.Y)); } - public static Vector2 RenderSeStringWithHitbox(DalamudSeString seString, Vector2 position, ImFontPtr? font = null) + public static Vector2 RenderSeStringWithHitbox(DalamudSeString seString, Vector2 position, ImFontPtr? font = null, string? id = null) { var drawList = ImGui.GetWindowDrawList(); @@ -137,12 +141,28 @@ public static class SeStringUtils var textSize = ImGui.CalcTextSize(seString.TextValue); ImGui.SetCursorScreenPos(position); - ImGui.InvisibleButton($"##hitbox_{Guid.NewGuid()}", textSize); + if (id is not null) + { + ImGui.PushID(id); + } + else + { + ImGui.PushID(Interlocked.Increment(ref _seStringHitboxCounter)); + } + + try + { + ImGui.InvisibleButton("##hitbox", textSize); + } + finally + { + ImGui.PopID(); + } return textSize; } - public static Vector2 RenderIconWithHitbox(int iconId, Vector2 position, ImFontPtr? font = null) + public static Vector2 RenderIconWithHitbox(int iconId, Vector2 position, ImFontPtr? font = null, string? id = null) { var drawList = ImGui.GetWindowDrawList(); @@ -158,7 +178,23 @@ public static class SeStringUtils var drawResult = ImGuiHelpers.CompileSeStringWrapped(iconMacro, drawParams); ImGui.SetCursorScreenPos(position); - ImGui.InvisibleButton($"##iconHitbox_{Guid.NewGuid()}", drawResult.Size); + if (id is not null) + { + ImGui.PushID(id); + } + else + { + ImGui.PushID(Interlocked.Increment(ref _iconHitboxCounter)); + } + + try + { + ImGui.InvisibleButton("##iconHitbox", drawResult.Size); + } + finally + { + ImGui.PopID(); + } return drawResult.Size; } From 6bb00c50d81cfdf21ac9ab1c4b0a021081845064 Mon Sep 17 00:00:00 2001 From: azyges <229218900+azyges@users.noreply.github.com> Date: Wed, 22 Oct 2025 03:33:51 +0900 Subject: [PATCH 61/64] improve logging fallback --- .../WebAPI/Files/FileDownloadManager.cs | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/LightlessSync/WebAPI/Files/FileDownloadManager.cs b/LightlessSync/WebAPI/Files/FileDownloadManager.cs index cc82d04..b8f81f2 100644 --- a/LightlessSync/WebAPI/Files/FileDownloadManager.cs +++ b/LightlessSync/WebAPI/Files/FileDownloadManager.cs @@ -215,6 +215,26 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase await Task.Delay(retryDelay, ct).ConfigureAwait(false); } + catch (TaskCanceledException ex) when (!ct.IsCancellationRequested) + { + response?.Dispose(); + retryCount++; + + Logger.LogWarning(ex, "Cancellation/timeout during download of {requestUrl}. Attempt {attempt} of {maxRetries}", requestUrl, retryCount, maxRetries); + + if (retryCount >= maxRetries) + { + Logger.LogError("Max retries reached for {requestUrl} after TaskCanceledException", requestUrl); + throw; + } + + await Task.Delay(retryDelay, ct).ConfigureAwait(false); + } + catch (OperationCanceledException) when (ct.IsCancellationRequested) + { + response?.Dispose(); + throw; + } catch (HttpRequestException ex) { response?.Dispose(); From 764bb8bae2b0b0931e51c0cc8422128a637db2e7 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Tue, 21 Oct 2025 22:38:12 +0200 Subject: [PATCH 62/64] API changes --- LightlessSync/UI/EditProfileUi.cs | 10 +++++----- LightlessSync/UI/SyncshellAdminUI.cs | 14 +++++++------- .../SignalR/ApIController.Functions.Users.cs | 2 +- .../SignalR/ApiController.Functions.Groups.cs | 2 +- 4 files changed, 14 insertions(+), 14 deletions(-) diff --git a/LightlessSync/UI/EditProfileUi.cs b/LightlessSync/UI/EditProfileUi.cs index 44c314a..696c2e8 100644 --- a/LightlessSync/UI/EditProfileUi.cs +++ b/LightlessSync/UI/EditProfileUi.cs @@ -206,7 +206,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase } _showFileDialogError = false; - await _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, Convert.ToBase64String(fileContent), Description: null, Tags: null)) + await _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, Convert.ToBase64String(fileContent), BannerPictureBase64: null, Description: null, Tags: null)) .ConfigureAwait(false); }); }); @@ -215,7 +215,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, "", Description: null, Tags: null)); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, "", Description: null, BannerPictureBase64: null, Tags: null)); } UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); if (_showFileDialogError) @@ -225,7 +225,7 @@ public class EditProfileUi : WindowMediatorSubscriberBase var isNsfw = profile.IsNSFW; if (ImGui.Checkbox("Profile is NSFW", ref isNsfw)) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, isNsfw, ProfilePictureBase64: null, Description: null, Tags: null)); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, isNsfw, ProfilePictureBase64: null, Description: null, BannerPictureBase64: null, Tags: null)); } _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); var widthTextBox = 400; @@ -264,13 +264,13 @@ public class EditProfileUi : WindowMediatorSubscriberBase if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, _descriptionText, Tags: null)); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, _descriptionText, Tags: null)); } UiSharedService.AttachToolTip("Sets your profile description text"); ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) { - _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, "", Tags: null)); + _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, "", Tags: null)); } UiSharedService.AttachToolTip("Clears your profile description text"); diff --git a/LightlessSync/UI/SyncshellAdminUI.cs b/LightlessSync/UI/SyncshellAdminUI.cs index 80f4f7e..be8e1d4 100644 --- a/LightlessSync/UI/SyncshellAdminUI.cs +++ b/LightlessSync/UI/SyncshellAdminUI.cs @@ -303,7 +303,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase } _showFileDialogError = false; - await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, Convert.ToBase64String(fileContent), IsNsfw: null, IsDisabled: null)) + await _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, Convert.ToBase64String(fileContent), BannerBase64: null, IsNsfw: null, IsDisabled: null)) .ConfigureAwait(false); } }); @@ -313,7 +313,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, IsNsfw: null, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: null, IsDisabled: null)); } UiSharedService.AttachToolTip("Clear your currently uploaded profile picture"); if (_showFileDialogError) @@ -368,13 +368,13 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: _descriptionText, Tags: null, PictureBase64: null, IsNsfw: null, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: _descriptionText, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: null, IsDisabled: null)); } UiSharedService.AttachToolTip("Sets your profile description text"); ImGui.SameLine(); if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description")) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, IsNsfw: null, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: null, IsDisabled: null)); } UiSharedService.AttachToolTip("Clears your profile description text"); ImGui.Separator(); @@ -382,7 +382,7 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase var isNsfw = _profileData.IsNsfw; if (ImGui.Checkbox("Profile is NSFW", ref isNsfw)) { - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, IsNsfw: isNsfw, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: isNsfw, IsDisabled: null)); } _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON"); ImGui.TreePop(); @@ -744,12 +744,12 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase if (HasTag) { _selectedTags.Add(tag); - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: _selectedTags.ToArray(), PictureBase64: null, IsNsfw: null, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: _selectedTags.ToArray(), PictureBase64: null, BannerBase64: null, IsNsfw: null, IsDisabled: null)); } else { _selectedTags.Remove(tag); - _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: _selectedTags.ToArray(), PictureBase64: null, IsNsfw: null, IsDisabled: null)); + _ = _apiController.GroupSetProfile(new GroupProfileDto(new GroupData(GroupFullInfo.Group.AliasOrGID), Description: null, Tags: _selectedTags.ToArray(), PictureBase64: null, BannerBase64: null, IsNsfw: null, IsDisabled: null)); } } } diff --git a/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs b/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs index 582fbe1..a4c78f8 100644 --- a/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs +++ b/LightlessSync/WebAPI/SignalR/ApIController.Functions.Users.cs @@ -84,7 +84,7 @@ public partial class ApiController public async Task UserGetProfile(UserDto dto) { - if (!IsConnected) return new UserProfileDto(dto.User, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, Description: null, Tags: null); + if (!IsConnected) return new UserProfileDto(dto.User, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, Description: null, BannerPictureBase64: null, Tags: null); return await _lightlessHub!.InvokeAsync(nameof(UserGetProfile), dto).ConfigureAwait(false); } diff --git a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs index 2ffa15a..d212f6c 100644 --- a/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs +++ b/LightlessSync/WebAPI/SignalR/ApiController.Functions.Groups.cs @@ -118,7 +118,7 @@ public partial class ApiController public async Task GroupGetProfile(GroupDto dto) { CheckConnection(); - if (!IsConnected) return new GroupProfileDto(Group: dto.Group, Description: null, Tags: null, PictureBase64: null, IsNsfw: false, IsDisabled: false); + if (!IsConnected) return new GroupProfileDto(Group: dto.Group, Description: null, Tags: null, PictureBase64: null, IsNsfw: false, BannerBase64: null, IsDisabled: false); return await _lightlessHub!.InvokeAsync(nameof(GroupGetProfile), dto).ConfigureAwait(false); } From 487156e4f978e325107ccfa8221f910da08cfa31 Mon Sep 17 00:00:00 2001 From: CakeAndBanana Date: Tue, 21 Oct 2025 22:48:26 +0200 Subject: [PATCH 63/64] Submodule update --- LightlessAPI | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LightlessAPI b/LightlessAPI index 0bc7abb..bb92cd4 160000 --- a/LightlessAPI +++ b/LightlessAPI @@ -1 +1 @@ -Subproject commit 0bc7abb274548bcde36c65ef1cf9f1a143d6492c +Subproject commit bb92cd477d76f24fd28200ade00076bc77fe299d From 8aad714918bc21e9820034c3a96aebbc2c9f0fa3 Mon Sep 17 00:00:00 2001 From: choco Date: Thu, 23 Oct 2025 00:40:54 +0200 Subject: [PATCH 64/64] removed wrong ondisconnect notification --- LightlessSync/Services/BroadcastService.cs | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/LightlessSync/Services/BroadcastService.cs b/LightlessSync/Services/BroadcastService.cs index 81e54d5..cca9af6 100644 --- a/LightlessSync/Services/BroadcastService.cs +++ b/LightlessSync/Services/BroadcastService.cs @@ -144,11 +144,7 @@ public class BroadcastService : IHostedService, IMediatorSubscriber IsLightFinderAvailable = false; ApplyBroadcastDisabled(forcePublish: true); _logger.LogDebug("Cleared Lightfinder state due to disconnect."); - - _mediator.Publish(new NotificationMessage( - "Disconnected from Server", - "Your Lightfinder broadcast has been disabled due to disconnection.", - NotificationType.Warning)); + } public Task StartAsync(CancellationToken cancellationToken)