469 lines
18 KiB
C#
469 lines
18 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading.Tasks;
|
|
using Dalamud.Game;
|
|
using Dalamud.Game.ClientState;
|
|
using Dalamud.Game.ClientState.Objects;
|
|
using Dalamud.Game.ClientState.Objects.Types;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Logging;
|
|
using Pal.Client.Configuration;
|
|
using Pal.Client.Database;
|
|
using Pal.Client.DependencyInjection;
|
|
using Pal.Client.Net;
|
|
using Pal.Client.Rendering;
|
|
using Pal.Client.Scheduled;
|
|
using Pal.Common;
|
|
|
|
namespace Pal.Client.Floors
|
|
{
|
|
internal sealed class FrameworkService : IDisposable
|
|
{
|
|
private readonly IServiceProvider _serviceProvider;
|
|
private readonly ILogger<FrameworkService> _logger;
|
|
private readonly Framework _framework;
|
|
private readonly ConfigurationManager _configurationManager;
|
|
private readonly IPalacePalConfiguration _configuration;
|
|
private readonly ClientState _clientState;
|
|
private readonly TerritoryState _territoryState;
|
|
private readonly FloorService _floorService;
|
|
private readonly DebugState _debugState;
|
|
private readonly RenderAdapter _renderAdapter;
|
|
private readonly ObjectTable _objectTable;
|
|
private readonly RemoteApi _remoteApi;
|
|
|
|
internal Queue<IQueueOnFrameworkThread> EarlyEventQueue { get; } = new();
|
|
internal Queue<IQueueOnFrameworkThread> LateEventQueue { get; } = new();
|
|
internal ConcurrentQueue<nint> NextUpdateObjects { get; } = new();
|
|
|
|
public FrameworkService(
|
|
IServiceProvider serviceProvider,
|
|
ILogger<FrameworkService> logger,
|
|
Framework framework,
|
|
ConfigurationManager configurationManager,
|
|
IPalacePalConfiguration configuration,
|
|
ClientState clientState,
|
|
TerritoryState territoryState,
|
|
FloorService floorService,
|
|
DebugState debugState,
|
|
RenderAdapter renderAdapter,
|
|
ObjectTable objectTable,
|
|
RemoteApi remoteApi)
|
|
{
|
|
_serviceProvider = serviceProvider;
|
|
_logger = logger;
|
|
_framework = framework;
|
|
_configurationManager = configurationManager;
|
|
_configuration = configuration;
|
|
_clientState = clientState;
|
|
_territoryState = territoryState;
|
|
_floorService = floorService;
|
|
_debugState = debugState;
|
|
_renderAdapter = renderAdapter;
|
|
_objectTable = objectTable;
|
|
_remoteApi = remoteApi;
|
|
|
|
_framework.Update += OnUpdate;
|
|
_configurationManager.Saved += OnSaved;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_framework.Update -= OnUpdate;
|
|
_configurationManager.Saved -= OnSaved;
|
|
}
|
|
|
|
private void OnSaved(object? sender, IPalacePalConfiguration? config)
|
|
=> EarlyEventQueue.Enqueue(new QueuedConfigUpdate());
|
|
|
|
private void OnUpdate(Framework framework)
|
|
{
|
|
if (_configuration.FirstUse)
|
|
return;
|
|
|
|
try
|
|
{
|
|
bool recreateLayout = false;
|
|
|
|
while (EarlyEventQueue.TryDequeue(out IQueueOnFrameworkThread? queued))
|
|
HandleQueued(queued, ref recreateLayout);
|
|
|
|
if (_territoryState.LastTerritory != _clientState.TerritoryType)
|
|
{
|
|
MemoryTerritory? oldTerritory = _floorService.GetTerritoryIfReady(_territoryState.LastTerritory);
|
|
if (oldTerritory != null)
|
|
oldTerritory.SyncState = ESyncState.NotAttempted;
|
|
|
|
_territoryState.LastTerritory = _clientState.TerritoryType;
|
|
NextUpdateObjects.Clear();
|
|
|
|
_floorService.ChangeTerritory(_territoryState.LastTerritory);
|
|
_territoryState.PomanderOfSight = PomanderState.Inactive;
|
|
_territoryState.PomanderOfIntuition = PomanderState.Inactive;
|
|
recreateLayout = true;
|
|
_debugState.Reset();
|
|
}
|
|
|
|
if (!_territoryState.IsInDeepDungeon() || !_floorService.IsReady(_territoryState.LastTerritory))
|
|
return;
|
|
|
|
if (_renderAdapter.RequireRedraw)
|
|
{
|
|
recreateLayout = true;
|
|
_renderAdapter.RequireRedraw = false;
|
|
}
|
|
|
|
ETerritoryType territoryType = (ETerritoryType)_territoryState.LastTerritory;
|
|
MemoryTerritory memoryTerritory = _floorService.GetTerritoryIfReady(territoryType)!;
|
|
if (_configuration.Mode == EMode.Online && memoryTerritory.SyncState == ESyncState.NotAttempted)
|
|
{
|
|
memoryTerritory.SyncState = ESyncState.Started;
|
|
Task.Run(async () => await DownloadLocationsForTerritory(_territoryState.LastTerritory));
|
|
}
|
|
|
|
while (LateEventQueue.TryDequeue(out IQueueOnFrameworkThread? queued))
|
|
HandleQueued(queued, ref recreateLayout);
|
|
|
|
(IReadOnlyList<PersistentLocation> visiblePersistentMarkers,
|
|
IReadOnlyList<EphemeralLocation> visibleEphemeralMarkers) =
|
|
GetRelevantGameObjects();
|
|
|
|
HandlePersistentLocations(territoryType, visiblePersistentMarkers, recreateLayout);
|
|
|
|
if (_floorService.MergeEphemeralLocations(visibleEphemeralMarkers, recreateLayout))
|
|
RecreateEphemeralLayout();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_debugState.SetFromException(e);
|
|
}
|
|
}
|
|
|
|
#region Render Markers
|
|
|
|
private void HandlePersistentLocations(ETerritoryType territoryType,
|
|
IReadOnlyList<PersistentLocation> visiblePersistentMarkers,
|
|
bool recreateLayout)
|
|
{
|
|
bool recreatePersistentLocations = _floorService.MergePersistentLocations(
|
|
territoryType,
|
|
visiblePersistentMarkers,
|
|
recreateLayout,
|
|
out List<PersistentLocation> locationsToSync);
|
|
recreatePersistentLocations |= CheckLocationsForPomanders(visiblePersistentMarkers);
|
|
if (locationsToSync.Count > 0)
|
|
{
|
|
Task.Run(async () =>
|
|
await SyncSeenMarkersForTerritory(_territoryState.LastTerritory, locationsToSync));
|
|
}
|
|
|
|
UploadLocations();
|
|
|
|
if (recreatePersistentLocations)
|
|
RecreatePersistentLayout(visiblePersistentMarkers);
|
|
}
|
|
|
|
private bool CheckLocationsForPomanders(IReadOnlyList<PersistentLocation> visibleLocations)
|
|
{
|
|
MemoryTerritory? memoryTerritory = _floorService.GetTerritoryIfReady(_territoryState.LastTerritory);
|
|
if (memoryTerritory is { Locations.Count: > 0 } &&
|
|
(_configuration.DeepDungeons.Traps.OnlyVisibleAfterPomander ||
|
|
_configuration.DeepDungeons.HoardCoffers.OnlyVisibleAfterPomander))
|
|
{
|
|
try
|
|
{
|
|
foreach (var location in memoryTerritory.Locations)
|
|
{
|
|
uint desiredColor = DetermineColor(location, visibleLocations);
|
|
if (location.RenderElement == null || !location.RenderElement.IsValid)
|
|
return true;
|
|
|
|
if (location.RenderElement.Color != desiredColor)
|
|
location.RenderElement.Color = desiredColor;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_debugState.SetFromException(e);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void UploadLocations()
|
|
{
|
|
MemoryTerritory? memoryTerritory = _floorService.GetTerritoryIfReady(_territoryState.LastTerritory);
|
|
if (memoryTerritory == null || memoryTerritory.SyncState != ESyncState.Complete)
|
|
return;
|
|
|
|
List<PersistentLocation> locationsToUpload = memoryTerritory.Locations
|
|
.Where(loc => loc.NetworkId == null && loc.UploadRequested == false)
|
|
.ToList();
|
|
if (locationsToUpload.Count > 0)
|
|
{
|
|
foreach (var location in locationsToUpload)
|
|
location.UploadRequested = true;
|
|
|
|
Task.Run(async () =>
|
|
await UploadLocationsForTerritory(_territoryState.LastTerritory, locationsToUpload));
|
|
}
|
|
}
|
|
|
|
private void RecreatePersistentLayout(IReadOnlyList<PersistentLocation> visibleMarkers)
|
|
{
|
|
_renderAdapter.ResetLayer(ELayer.TrapHoard);
|
|
|
|
MemoryTerritory? memoryTerritory = _floorService.GetTerritoryIfReady(_territoryState.LastTerritory);
|
|
if (memoryTerritory == null)
|
|
return;
|
|
|
|
List<IRenderElement> elements = new();
|
|
foreach (var location in memoryTerritory.Locations)
|
|
{
|
|
if (location.Type == MemoryLocation.EType.Trap)
|
|
{
|
|
CreateRenderElement(location, elements, DetermineColor(location, visibleMarkers),
|
|
_configuration.DeepDungeons.Traps);
|
|
}
|
|
else if (location.Type == MemoryLocation.EType.Hoard)
|
|
{
|
|
CreateRenderElement(location, elements, DetermineColor(location, visibleMarkers),
|
|
_configuration.DeepDungeons.HoardCoffers);
|
|
}
|
|
}
|
|
|
|
if (elements.Count == 0)
|
|
return;
|
|
|
|
_renderAdapter.SetLayer(ELayer.TrapHoard, elements);
|
|
}
|
|
|
|
private void RecreateEphemeralLayout()
|
|
{
|
|
_renderAdapter.ResetLayer(ELayer.RegularCoffers);
|
|
|
|
List<IRenderElement> elements = new();
|
|
foreach (var location in _floorService.EphemeralLocations)
|
|
{
|
|
if (location.Type == MemoryLocation.EType.SilverCoffer &&
|
|
_configuration.DeepDungeons.SilverCoffers.Show)
|
|
{
|
|
CreateRenderElement(location, elements, DetermineColor(location),
|
|
_configuration.DeepDungeons.SilverCoffers);
|
|
}
|
|
else if (location.Type == MemoryLocation.EType.GoldCoffer &&
|
|
_configuration.DeepDungeons.GoldCoffers.Show)
|
|
{
|
|
CreateRenderElement(location, elements, DetermineColor(location),
|
|
_configuration.DeepDungeons.GoldCoffers);
|
|
}
|
|
}
|
|
|
|
if (elements.Count == 0)
|
|
return;
|
|
|
|
_renderAdapter.SetLayer(ELayer.RegularCoffers, elements);
|
|
}
|
|
|
|
private uint DetermineColor(PersistentLocation location, IReadOnlyList<PersistentLocation> visibleLocations)
|
|
{
|
|
switch (location.Type)
|
|
{
|
|
case MemoryLocation.EType.Trap
|
|
when _territoryState.PomanderOfSight == PomanderState.Inactive ||
|
|
!_configuration.DeepDungeons.Traps.OnlyVisibleAfterPomander ||
|
|
visibleLocations.Any(x => x == location):
|
|
return _configuration.DeepDungeons.Traps.Color;
|
|
case MemoryLocation.EType.Hoard
|
|
when _territoryState.PomanderOfIntuition == PomanderState.Inactive ||
|
|
!_configuration.DeepDungeons.HoardCoffers.OnlyVisibleAfterPomander ||
|
|
visibleLocations.Any(x => x == location):
|
|
return _configuration.DeepDungeons.HoardCoffers.Color;
|
|
default:
|
|
return RenderData.ColorInvisible;
|
|
}
|
|
}
|
|
|
|
private uint DetermineColor(EphemeralLocation location)
|
|
{
|
|
return location.Type switch
|
|
{
|
|
MemoryLocation.EType.SilverCoffer => _configuration.DeepDungeons.SilverCoffers.Color,
|
|
MemoryLocation.EType.GoldCoffer => _configuration.DeepDungeons.GoldCoffers.Color,
|
|
_ => RenderData.ColorInvisible
|
|
};
|
|
}
|
|
|
|
private void CreateRenderElement(MemoryLocation location, List<IRenderElement> elements, uint color,
|
|
MarkerConfiguration config)
|
|
{
|
|
if (!config.Show)
|
|
return;
|
|
|
|
var element = _renderAdapter.CreateElement(location.Type, location.Position, color, config.Fill);
|
|
location.RenderElement = element;
|
|
elements.Add(element);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Up-/Download
|
|
|
|
private async Task DownloadLocationsForTerritory(ushort territoryId)
|
|
{
|
|
try
|
|
{
|
|
_logger.LogInformation("Downloading territory {Territory} from server", (ETerritoryType)territoryId);
|
|
var (success, downloadedMarkers) = await _remoteApi.DownloadRemoteMarkers(territoryId);
|
|
LateEventQueue.Enqueue(new QueuedSyncResponse
|
|
{
|
|
Type = SyncType.Download,
|
|
TerritoryType = territoryId,
|
|
Success = success,
|
|
Locations = downloadedMarkers
|
|
});
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_debugState.SetFromException(e);
|
|
}
|
|
}
|
|
|
|
private async Task UploadLocationsForTerritory(ushort territoryId, List<PersistentLocation> locationsToUpload)
|
|
{
|
|
try
|
|
{
|
|
_logger.LogInformation("Uploading {Count} locations for territory {Territory} to server",
|
|
locationsToUpload.Count, (ETerritoryType)territoryId);
|
|
var (success, uploadedLocations) = await _remoteApi.UploadLocations(territoryId, locationsToUpload);
|
|
LateEventQueue.Enqueue(new QueuedSyncResponse
|
|
{
|
|
Type = SyncType.Upload,
|
|
TerritoryType = territoryId,
|
|
Success = success,
|
|
Locations = uploadedLocations
|
|
});
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_debugState.SetFromException(e);
|
|
}
|
|
}
|
|
|
|
private async Task SyncSeenMarkersForTerritory(ushort territoryId,
|
|
IReadOnlyList<PersistentLocation> locationsToUpdate)
|
|
{
|
|
try
|
|
{
|
|
_logger.LogInformation("Syncing {Count} seen locations for territory {Territory} to server",
|
|
locationsToUpdate.Count, (ETerritoryType)territoryId);
|
|
var success = await _remoteApi.MarkAsSeen(territoryId, locationsToUpdate);
|
|
LateEventQueue.Enqueue(new QueuedSyncResponse
|
|
{
|
|
Type = SyncType.MarkSeen,
|
|
TerritoryType = territoryId,
|
|
Success = success,
|
|
Locations = locationsToUpdate,
|
|
});
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_debugState.SetFromException(e);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private (IReadOnlyList<PersistentLocation>, IReadOnlyList<EphemeralLocation>) GetRelevantGameObjects()
|
|
{
|
|
List<PersistentLocation> persistentLocations = new();
|
|
List<EphemeralLocation> ephemeralLocations = new();
|
|
for (int i = 246; i < _objectTable.Length; i++)
|
|
{
|
|
GameObject? obj = _objectTable[i];
|
|
if (obj == null)
|
|
continue;
|
|
|
|
switch ((uint)Marshal.ReadInt32(obj.Address + 128))
|
|
{
|
|
case 2007182:
|
|
case 2007183:
|
|
case 2007184:
|
|
case 2007185:
|
|
case 2007186:
|
|
case 2009504:
|
|
case 2013284:
|
|
persistentLocations.Add(new PersistentLocation
|
|
{
|
|
Type = MemoryLocation.EType.Trap,
|
|
Position = obj.Position,
|
|
Seen = true,
|
|
Source = ClientLocation.ESource.SeenLocally,
|
|
});
|
|
break;
|
|
|
|
case 2007542:
|
|
case 2007543:
|
|
persistentLocations.Add(new PersistentLocation
|
|
{
|
|
Type = MemoryLocation.EType.Hoard,
|
|
Position = obj.Position,
|
|
Seen = true,
|
|
Source = ClientLocation.ESource.SeenLocally,
|
|
});
|
|
break;
|
|
|
|
case 2007357:
|
|
ephemeralLocations.Add(new EphemeralLocation
|
|
{
|
|
Type = MemoryLocation.EType.SilverCoffer,
|
|
Position = obj.Position,
|
|
Seen = true,
|
|
});
|
|
break;
|
|
|
|
case 2007358:
|
|
ephemeralLocations.Add(new EphemeralLocation
|
|
{
|
|
Type = MemoryLocation.EType.GoldCoffer,
|
|
Position = obj.Position,
|
|
Seen = true
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (NextUpdateObjects.TryDequeue(out nint address))
|
|
{
|
|
var obj = _objectTable.FirstOrDefault(x => x.Address == address);
|
|
if (obj != null && obj.Position.Length() > 0.1)
|
|
{
|
|
persistentLocations.Add(new PersistentLocation
|
|
{
|
|
Type = MemoryLocation.EType.Trap,
|
|
Position = obj.Position,
|
|
Seen = true,
|
|
Source = ClientLocation.ESource.ExplodedLocally,
|
|
|
|
});
|
|
}
|
|
}
|
|
|
|
return (persistentLocations, ephemeralLocations);
|
|
}
|
|
|
|
private void HandleQueued(IQueueOnFrameworkThread queued, ref bool recreateLayout)
|
|
{
|
|
Type handlerType = typeof(IQueueOnFrameworkThread.Handler<>).MakeGenericType(queued.GetType());
|
|
var handler = (IQueueOnFrameworkThread.IHandler)_serviceProvider.GetRequiredService(handlerType);
|
|
|
|
handler.RunIfCompatible(queued, ref recreateLayout);
|
|
}
|
|
}
|
|
}
|