t0w0bi/ClubPenguinClient
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

major refactoring, maybe some bugfixes, idk

Browse Source
This commit is contained in:
Stanley Dimant
2022-06-24 00:47:47 +02:00
parent 0fe3f1cf25
commit 2dcd02d170
22 changed files with 997 additions and 949 deletions
Download Patch File Download Diff File Expand all files Collapse all files

250
MareSynchronos/Managers/CharacterCacheManager.cs Normal file
View File

@@ -0,0 +1,250 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Game;
using Dalamud.Game.ClientState;
using Dalamud.Game.ClientState.Objects;
using Dalamud.Game.ClientState.Objects.SubKinds;
using Dalamud.Logging;
using MareSynchronos.API;
using MareSynchronos.FileCacheDB;
using MareSynchronos.Models;
using MareSynchronos.Utils;
using MareSynchronos.WebAPI;
using Microsoft.EntityFrameworkCore;
namespace MareSynchronos.Managers;
public class CharacterCacheManager : IDisposable
{
private readonly ApiController _apiController;
private readonly ClientState _clientState;
private readonly DalamudUtil _dalamudUtil;
private readonly Framework _framework;
private readonly IpcManager _ipcManager;
private readonly ObjectTable _objectTable;
private readonly List<CachedPlayer> _onlineCachedPlayers = new();
private readonly List<string> _localVisiblePlayers = new();
private DateTime _lastPlayerObjectCheck = DateTime.Now;
public CharacterCacheManager(ClientState clientState, Framework framework, ObjectTable objectTable, ApiController apiController, DalamudUtil dalamudUtil, IpcManager ipcManager)
{
Logger.Debug("Creating " + nameof(CharacterCacheManager));
_clientState = clientState;
_framework = framework;
_objectTable = objectTable;
_apiController = apiController;
_dalamudUtil = dalamudUtil;
_ipcManager = ipcManager;
}
public void AddInitialPairs(List<string> apiTaskResult)
{
_onlineCachedPlayers.AddRange(apiTaskResult.Select(a => new CachedPlayer(a)));
Logger.Debug("Online and paired users: " + string.Join(",", _onlineCachedPlayers));
}
public void Dispose()
{
Logger.Debug("Disposing " + nameof(CharacterCacheManager));
_apiController.CharacterReceived -= ApiControllerOnCharacterReceived;
_apiController.PairedClientOnline -= ApiControllerOnPairedClientOnline;
_apiController.PairedClientOffline -= ApiControllerOnPairedClientOffline;
_apiController.PairedWithOther -= ApiControllerOnPairedWithOther;
_apiController.UnpairedFromOther -= ApiControllerOnUnpairedFromOther;
_framework.Update -= FrameworkOnUpdate;
foreach (var character in _onlineCachedPlayers.ToList())
{
RestoreCharacter(character);
}
}
public void Initialize()
{
_apiController.CharacterReceived += ApiControllerOnCharacterReceived;
_apiController.PairedClientOnline += ApiControllerOnPairedClientOnline;
_apiController.PairedClientOffline += ApiControllerOnPairedClientOffline;
_apiController.PairedWithOther += ApiControllerOnPairedWithOther;
_apiController.UnpairedFromOther += ApiControllerOnUnpairedFromOther;
_framework.Update += FrameworkOnUpdate;
}
public async Task UpdatePlayersFromService(Dictionary<string, int> playerJobIds)
{
await _apiController.GetCharacterData(playerJobIds);
}
private void ApiControllerOnCharacterReceived(object? sender, CharacterReceivedEventArgs e)
{
Logger.Debug("Received hash for " + e.CharacterNameHash);
string otherPlayerName;
var localPlayers = _dalamudUtil.GetLocalPlayers();
if (localPlayers.ContainsKey(e.CharacterNameHash))
{
_onlineCachedPlayers.Single(p => p.PlayerNameHash == e.CharacterNameHash).PlayerName = localPlayers[e.CharacterNameHash].Name.ToString();
otherPlayerName = localPlayers[e.CharacterNameHash].Name.ToString();
}
else
{
Logger.Debug("Found no local player for " + e.CharacterNameHash);
return;
}
_onlineCachedPlayers.Single(p => p.PlayerNameHash == e.CharacterNameHash)
.CharacterCache[e.CharacterData.JobId] = e.CharacterData;
List<FileReplacementDto> toDownloadReplacements;
using (var db = new FileCacheContext())
{
Logger.Debug("Checking for files to download for player " + otherPlayerName);
Logger.Debug("Received total " + e.CharacterData.FileReplacements.Count + " file replacement data");
Logger.Debug("Hash for data is " + e.CharacterData.Hash);
toDownloadReplacements =
e.CharacterData.FileReplacements.Where(f => !db.FileCaches.Any(c => c.Hash == f.Hash))
.ToList();
}
Logger.Debug("Downloading missing files for player " + otherPlayerName);
// todo: make this cancellable
Task.Run(async () =>
{
await _apiController.DownloadFiles(toDownloadReplacements);
Logger.Debug("Assigned hash to visible player: " + otherPlayerName);
_ipcManager.PenumbraRemoveTemporaryCollection(otherPlayerName);
var tempCollection = _ipcManager.PenumbraCreateTemporaryCollection(otherPlayerName);
Dictionary<string, string> moddedPaths = new();
try
{
using var db = new FileCacheContext();
foreach (var item in e.CharacterData.FileReplacements)
{
foreach (var gamePath in item.GamePaths)
{
var fileCache = db.FileCaches.FirstOrDefault(f => f.Hash == item.Hash);
if (fileCache != null)
{
moddedPaths.Add(gamePath, fileCache.Filepath);
}
}
}
}
catch (Exception ex)
{
PluginLog.Error(ex, "Something went wrong during calculation replacements");
}
_dalamudUtil.WaitWhileCharacterIsDrawing(localPlayers[e.CharacterNameHash].Address);
_ipcManager.PenumbraSetTemporaryMods(tempCollection, moddedPaths, e.CharacterData.ManipulationData);
_ipcManager.GlamourerApplyCharacterCustomization(e.CharacterData.GlamourerData, otherPlayerName);
});
}
private void ApiControllerOnPairedClientOffline(object? sender, EventArgs e)
{
Logger.Debug("Player offline: " + sender!);
_onlineCachedPlayers.RemoveAll(p => p.PlayerNameHash == ((string)sender!));
}
private void ApiControllerOnPairedClientOnline(object? sender, EventArgs e)
{
Logger.Debug("Player online: " + sender!);
_onlineCachedPlayers.Add(new CachedPlayer((string)sender!));
}
private void ApiControllerOnPairedWithOther(object? sender, EventArgs e)
{
var characterHash = (string?)sender;
if (string.IsNullOrEmpty(characterHash)) return;
var players = _dalamudUtil.GetLocalPlayers();
if (!players.ContainsKey(characterHash)) return;
Logger.Debug("Getting data for " + characterHash);
_ = _apiController.GetCharacterData(new Dictionary<string, int> { { characterHash, (int)players[characterHash].ClassJob.Id } });
}
private void ApiControllerOnUnpairedFromOther(object? sender, EventArgs e)
{
var characterHash = (string?)sender;
if (string.IsNullOrEmpty(characterHash)) return;
RestoreCharacter(_onlineCachedPlayers.Single(p => p.PlayerNameHash == (string)sender!));
}
private void FrameworkOnUpdate(Framework framework)
{
try
{
if (_clientState.LocalPlayer == null) return;
if (DateTime.Now < _lastPlayerObjectCheck.AddSeconds(2)) return;
_localVisiblePlayers.Clear();
foreach (var obj in _objectTable)
{
if (obj.ObjectKind != Dalamud.Game.ClientState.Objects.Enums.ObjectKind.Player) continue;
var playerName = obj.Name.ToString();
if (playerName == _dalamudUtil.PlayerName) continue;
var pObj = (PlayerCharacter)obj;
_localVisiblePlayers.Add(pObj.Name.ToString());
if (_onlineCachedPlayers.Any(p => p.PlayerName == pObj.Name.ToString()))
{
_onlineCachedPlayers.Single(p => p.PlayerName == pObj.Name.ToString()).IsVisible = true;
continue;
}
var hashedName = Crypto.GetHash256(pObj.Name.ToString() + pObj.HomeWorld.Id.ToString());
if (_onlineCachedPlayers.All(p => p.PlayerNameHash != hashedName)) continue;
var cachedPlayer = _onlineCachedPlayers.Single(p => p.PlayerNameHash == hashedName);
if (string.IsNullOrEmpty(cachedPlayer.PlayerName))
{
cachedPlayer.PlayerName = pObj.Name.ToString();
}
cachedPlayer.PlayerCharacter = pObj;
cachedPlayer.IsVisible = true;
}
foreach (var item in _onlineCachedPlayers.Where(p => !string.IsNullOrEmpty(p.PlayerName) && !_localVisiblePlayers.Contains(p.PlayerName!)))
{
item.IsVisible = false;
}
foreach (var item in _onlineCachedPlayers.Where(p => !string.IsNullOrEmpty(p.PlayerName) && !p.IsVisible && p.WasVisible))
{
Logger.Debug("Player not visible anymore: " + item.PlayerName);
RestoreCharacter(item);
}
var newVisiblePlayers = _onlineCachedPlayers.Where(p => p.IsVisible && !p.WasVisible).ToList();
if (newVisiblePlayers.Any())
{
Logger.Debug("Getting data for new players: " + string.Join(Environment.NewLine, newVisiblePlayers));
Task.Run(async () => await UpdatePlayersFromService(newVisiblePlayers
.ToDictionary(k => k.PlayerNameHash, k => (int)k.PlayerCharacter!.ClassJob.Id)));
}
_lastPlayerObjectCheck = DateTime.Now;
}
catch (Exception ex)
{
PluginLog.Error(ex, "error");
}
}
private void RestoreCharacter(CachedPlayer character)
{
if (string.IsNullOrEmpty(character.PlayerName)) return;
Logger.Debug("Restoring state for " + character.PlayerName);
_ipcManager.PenumbraRemoveTemporaryCollection(character.PlayerName);
_ipcManager.GlamourerRevertCharacterCustomization(character.PlayerName);
character.Reset();
}
}

433
MareSynchronos/Managers/CharacterManager.cs
View File

@@ -1,8 +1,5 @@
using Dalamud.Game;
using Dalamud.Game.ClientState;
using Dalamud.Game.ClientState.Objects;
using Dalamud.Game.ClientState.Objects;
using Dalamud.Logging;
using FFXIVClientStructs.FFXIV.Client.Game.Object;
using MareSynchronos.Factories;
using MareSynchronos.Models;
using MareSynchronos.Utils;
@@ -10,293 +7,91 @@ using MareSynchronos.WebAPI;
using Newtonsoft.Json;
using Penumbra.PlayerWatch;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Game.ClientState.Objects.SubKinds;
using MareSynchronos.API;
using MareSynchronos.FileCacheDB;
namespace MareSynchronos.Managers
{
public class CachedPlayer
{
public string? PlayerName { get; set; }
public string? PlayerNameHash { get; set; }
public int JobId { get; set; }
public Dictionary<int, CharacterCacheDto>? CharacterCache { get; set; }
public PlayerCharacter? PlayerCharacter { get; set; }
}
public class CharacterManager : IDisposable
{
private readonly ApiController _apiController;
readonly Dictionary<string, string> _cachedLocalPlayers = new();
private readonly Dictionary<(string, int), CharacterCacheDto> _characterCache = new();
private readonly ClientState _clientState;
private readonly Framework _framework;
private readonly CharacterCacheManager _characterCacheManager;
private readonly CharacterDataFactory _characterDataFactory;
private readonly DalamudUtil _dalamudUtil;
private readonly IpcManager _ipcManager;
private readonly ObjectTable _objectTable;
private readonly Configuration _pluginConfiguration;
private readonly CharacterCacheFactory _characterCacheFactory;
private readonly IPlayerWatcher _watcher;
private DateTime _lastPlayerObjectCheck = DateTime.Now;
private string _lastSentHash = string.Empty;
private Task? _playerChangedTask = null;
private Task? _playerChangedTask;
private List<CachedPlayer> _onlineCachedPlayers = new();
private Dictionary<string, string> _onlinePairedUsers = new();
public CharacterManager(ClientState clientState, Framework framework, ApiController apiController, ObjectTable objectTable, IpcManager ipcManager,
Configuration pluginConfiguration, CharacterCacheFactory characterCacheFactory)
public CharacterManager(ApiController apiController, ObjectTable objectTable, IpcManager ipcManager,
CharacterDataFactory characterDataFactory, CharacterCacheManager characterCacheManager, DalamudUtil dalamudUtil, IPlayerWatcher watcher)
{
this._clientState = clientState;
this._framework = framework;
this._apiController = apiController;
this._objectTable = objectTable;
this._ipcManager = ipcManager;
_pluginConfiguration = pluginConfiguration;
_characterCacheFactory = characterCacheFactory;
_watcher = PlayerWatchFactory.Create(framework, clientState, objectTable);
Logger.Debug("Creating " + nameof(CharacterManager));
_apiController = apiController;
_objectTable = objectTable;
_ipcManager = ipcManager;
_characterDataFactory = characterDataFactory;
_characterCacheManager = characterCacheManager;
_dalamudUtil = dalamudUtil;
_watcher = watcher;
}
public void Dispose()
{
Logger.Debug("Disposing " + nameof(CharacterManager));
_ipcManager.PenumbraRedrawEvent -= IpcManager_PenumbraRedrawEvent;
_framework.Update -= Framework_Update;
_clientState.TerritoryChanged -= ClientState_TerritoryChanged;
_apiController.Connected -= ApiController_Connected;
_apiController.Disconnected -= ApiController_Disconnected;
_apiController.CharacterReceived -= ApiControllerOnCharacterReceived;
_apiController.UnpairedFromOther -= ApiControllerOnUnpairedFromOther;
_apiController.PairedWithOther -= ApiControllerOnPairedWithOther;
_apiController.PairedClientOffline -= ApiControllerOnPairedClientOffline;
_watcher.Disable();
_watcher.PlayerChanged -= Watcher_PlayerChanged;
_watcher?.Dispose();
foreach (var character in _onlinePairedUsers)
{
RestoreCharacter(character);
}
}
public async Task UpdatePlayersFromService(Dictionary<string, PlayerCharacter> currentLocalPlayers)
{
PluginLog.Debug("Updating local players from service");
currentLocalPlayers = currentLocalPlayers.Where(k => _onlinePairedUsers.ContainsKey(k.Key))
.ToDictionary(k => k.Key, k => k.Value);
await _apiController.GetCharacterData(currentLocalPlayers
.ToDictionary(
k => k.Key,
k => (int)k.Value.ClassJob.Id));
}
internal void StartWatchingPlayer()
{
_watcher.AddPlayerToWatch(GetPlayerName());
_watcher.AddPlayerToWatch(_dalamudUtil.PlayerName);
_watcher.PlayerChanged += Watcher_PlayerChanged;
_watcher.Enable();
_apiController.Connected += ApiController_Connected;
_apiController.Disconnected += ApiController_Disconnected;
_apiController.CharacterReceived += ApiControllerOnCharacterReceived;
_apiController.UnpairedFromOther += ApiControllerOnUnpairedFromOther;
_apiController.PairedWithOther += ApiControllerOnPairedWithOther;
_apiController.PairedClientOffline += ApiControllerOnPairedClientOffline;
_apiController.PairedClientOnline += ApiControllerOnPairedClientOnline;
PluginLog.Debug("Watching Player, ApiController is Connected: " + _apiController.IsConnected);
Logger.Debug("Watching Player, ApiController is Connected: " + _apiController.IsConnected);
if (_apiController.IsConnected)
{
ApiController_Connected(null, EventArgs.Empty);
}
_ipcManager.PenumbraRedraw(_dalamudUtil.PlayerName);
}
private void ApiController_Connected(object? sender, EventArgs args)
{
PluginLog.Debug(nameof(ApiController_Connected));
PluginLog.Debug("MyHashedName:" + Crypto.GetHash256(GetPlayerName() + _clientState.LocalPlayer!.HomeWorld.Id));
var apiTask = _apiController.SendCharacterName(_dalamudUtil.PlayerNameHashed);
_lastSentHash = string.Empty;
var apiTask = _apiController.SendCharacterName(Crypto.GetHash256(GetPlayerName() + _clientState.LocalPlayer!.HomeWorld.Id));
_characterCacheManager.Initialize();
Task.WaitAll(apiTask);
_onlinePairedUsers = apiTask.Result.ToDictionary(k => k, k => string.Empty);
var assignTask = AssignLocalPlayersData();
Task.WaitAll(assignTask);
PluginLog.Debug("Online and paired users: " + string.Join(",", _onlinePairedUsers));
_framework.Update += Framework_Update;
_characterCacheManager.AddInitialPairs(apiTask.Result);
_ipcManager.PenumbraRedrawEvent += IpcManager_PenumbraRedrawEvent;
_clientState.TerritoryChanged += ClientState_TerritoryChanged;
}
private void ApiController_Disconnected(object? sender, EventArgs args)
{
PluginLog.Debug(nameof(ApiController_Disconnected));
_framework.Update -= Framework_Update;
_characterCacheManager.Dispose();
Logger.Debug(nameof(ApiController_Disconnected));
_ipcManager.PenumbraRedrawEvent -= IpcManager_PenumbraRedrawEvent;
_clientState.TerritoryChanged -= ClientState_TerritoryChanged;
foreach (var character in _onlinePairedUsers)
{
RestoreCharacter(character);
}
_onlinePairedUsers.Clear();
_lastSentHash = string.Empty;
}
private void ApiControllerOnPairedWithOther(object? sender, EventArgs e)
private async Task<CharacterData> CreateFullCharacterCache()
{
var characterHash = (string?)sender;
if (string.IsNullOrEmpty(characterHash)) return;
var players = GetLocalPlayers();
if (players.ContainsKey(characterHash))
{
PluginLog.Debug("Removed pairing, restoring data for " + characterHash);
_ = _apiController.GetCharacterData(new Dictionary<string, int> { { characterHash, (int)players[characterHash].ClassJob.Id } });
}
}
var cache = _characterDataFactory.BuildCharacterData();
private void ApiControllerOnCharacterReceived(object? sender, CharacterReceivedEventArgs e)
{
PluginLog.Debug("Received hash for " + e.CharacterNameHash);
string otherPlayerName;
var localPlayers = GetLocalPlayers();
if (localPlayers.ContainsKey(e.CharacterNameHash))
{
_onlinePairedUsers[e.CharacterNameHash] = localPlayers[e.CharacterNameHash].Name.ToString();
otherPlayerName = _onlinePairedUsers[e.CharacterNameHash];
}
else
{
PluginLog.Debug("Found no local player for " + e.CharacterNameHash);
return;
}
_characterCache[(e.CharacterNameHash, e.CharacterData.JobId)] = e.CharacterData;
List<FileReplacementDto> toDownloadReplacements;
using (var db = new FileCacheContext())
{
PluginLog.Debug("Checking for files to download for player " + otherPlayerName);
PluginLog.Debug("Received total " + e.CharacterData.FileReplacements.Count + " file replacement data");
PluginLog.Debug("Hash for data is " + e.CharacterData.Hash);
toDownloadReplacements =
e.CharacterData.FileReplacements.Where(f => !db.FileCaches.Any(c => c.Hash == f.Hash))
.ToList();
}
PluginLog.Debug("Downloading missing files for player " + otherPlayerName);
// todo: make this cancellable
var downloadTask = _apiController.DownloadFiles(toDownloadReplacements, _pluginConfiguration.CacheFolder);
while (!downloadTask.IsCompleted)
{
Thread.Sleep(100);
}
PluginLog.Debug("Assigned hash to visible player: " + otherPlayerName);
_ipcManager.PenumbraRemoveTemporaryCollection(otherPlayerName);
var tempCollection = _ipcManager.PenumbraCreateTemporaryCollection(otherPlayerName);
Dictionary<string, string> moddedPaths = new();
try
{
using var db = new FileCacheContext();
foreach (var item in e.CharacterData.FileReplacements)
{
foreach (var gamePath in item.GamePaths)
{
var fileCache = db.FileCaches.FirstOrDefault(f => f.Hash == item.Hash);
if (fileCache != null)
{
moddedPaths.Add(gamePath, fileCache.Filepath);
}
}
}
}
catch (Exception ex)
{
PluginLog.Error(ex, "Something went wrong during calculation replacements");
}
WaitWhileCharacterIsDrawing(localPlayers[e.CharacterNameHash].Address);
_ipcManager.PenumbraSetTemporaryMods(tempCollection, moddedPaths, e.CharacterData.ManipulationData);
_ipcManager.GlamourerApplyCharacterCustomization(e.CharacterData.GlamourerData, otherPlayerName);
}
private void ApiControllerOnUnpairedFromOther(object? sender, EventArgs e)
{
var characterHash = (string?)sender;
if (string.IsNullOrEmpty(characterHash)) return;
RestoreCharacter(new KeyValuePair<string, string>(characterHash, _onlinePairedUsers[characterHash]));
}
private void RestoreCharacter(KeyValuePair<string, string> character)
{
if (string.IsNullOrEmpty(character.Value)) return;
foreach (var entry in _characterCache.Where(c => c.Key.Item1 == character.Key))
{
_characterCache.Remove(entry.Key);
}
RestorePreviousCharacter(character.Value);
PluginLog.Debug("Removed from pairing, restoring state for " + character.Value);
_ipcManager.PenumbraRemoveTemporaryCollection(character.Value);
_ipcManager.GlamourerRevertCharacterCustomization(character.Value);
}
private void ApiControllerOnPairedClientOffline(object? sender, EventArgs e)
{
PluginLog.Debug("Player offline: " + sender!);
_onlinePairedUsers.Remove((string)sender!);
}
private void ApiControllerOnPairedClientOnline(object? sender, EventArgs e)
{
PluginLog.Debug("Player online: " + sender!);
_onlinePairedUsers.Add((string)sender!, string.Empty);
}
private async Task AssignLocalPlayersData()
{
PluginLog.Debug("Temp assigning local players from cache");
var currentLocalPlayers = GetLocalPlayers();
foreach (var player in _characterCache)
{
if (currentLocalPlayers.ContainsKey(player.Key.Item1))
{
await Task.Run(() => ApiControllerOnCharacterReceived(null, new CharacterReceivedEventArgs(player.Key.Item1, player.Value)));
}
}
await UpdatePlayersFromService(currentLocalPlayers);
}
private void ClientState_TerritoryChanged(object? sender, ushort e)
{
_ = Task.Run(async () =>
{
while (_clientState.LocalPlayer == null)
{
await Task.Delay(250);
}
await AssignLocalPlayersData();
});
}
private async Task<CharacterCache> CreateFullCharacterCache()
{
var cache = _characterCacheFactory.BuildCharacterCache();
cache.GlamourerString = _ipcManager.GlamourerGetCharacterCustomization()!;
cache.ManipulationString = _ipcManager.PenumbraGetMetaManipulations(_clientState.LocalPlayer!.Name.ToString());
cache.JobId = _clientState.LocalPlayer!.ClassJob.Id;
await Task.Run(async () =>
{
while (!cache.IsReady)
@@ -312,163 +107,75 @@ namespace MareSynchronos.Managers
return cache;
}
private unsafe void Framework_Update(Framework framework)
{
try
{
if (_clientState.LocalPlayer == null) return;
if (DateTime.Now < _lastPlayerObjectCheck.AddSeconds(2)) return;
List<string> localPlayersList = new();
Dictionary<string, PlayerCharacter> newPlayers = new();
foreach (var obj in _objectTable)
{
if (obj.ObjectKind != Dalamud.Game.ClientState.Objects.Enums.ObjectKind.Player) continue;
string playerName = obj.Name.ToString();
if (playerName == GetPlayerName()) continue;
var pObj = (PlayerCharacter)obj;
var hashedName = Crypto.GetHash256(pObj.Name.ToString() + pObj.HomeWorld.Id.ToString());
if (!_onlinePairedUsers.ContainsKey(hashedName)) continue;
_onlinePairedUsers[hashedName] = pObj.Name.ToString();
localPlayersList.Add(hashedName);
if (!_cachedLocalPlayers.ContainsKey(hashedName)) newPlayers[hashedName] = pObj;
_cachedLocalPlayers[hashedName] = pObj.Name.ToString();
}
foreach (var item in _cachedLocalPlayers.ToList().Where(item => !localPlayersList.Contains(item.Key)))
{
foreach (var cachedPlayerNameJobId in _characterCache.Keys.ToList().Where(cachedPlayerNameJobId => cachedPlayerNameJobId.Item1 == item.Key))
{
PluginLog.Debug("Player not visible anymore: " + cachedPlayerNameJobId.Item1);
RestorePreviousCharacter(_cachedLocalPlayers[cachedPlayerNameJobId.Item1]);
_characterCache.Remove(cachedPlayerNameJobId);
}
_cachedLocalPlayers.Remove(item.Key);
}
if (newPlayers.Any())
{
PluginLog.Debug("Getting data for new players: " + string.Join(Environment.NewLine, newPlayers));
_ = UpdatePlayersFromService(newPlayers);
}
_lastPlayerObjectCheck = DateTime.Now;
}
catch (Exception ex)
{
PluginLog.Error(ex, "error");
}
}
private Dictionary<string, PlayerCharacter> GetLocalPlayers()
{
Dictionary<string, PlayerCharacter> allLocalPlayers = new();
foreach (var obj in _objectTable)
{
if (obj.ObjectKind != Dalamud.Game.ClientState.Objects.Enums.ObjectKind.Player) continue;
string playerName = obj.Name.ToString();
if (playerName == GetPlayerName()) continue;
var playerObject = (PlayerCharacter)obj;
allLocalPlayers[Crypto.GetHash256(playerObject.Name.ToString() + playerObject.HomeWorld.Id.ToString())] = playerObject;
}
return allLocalPlayers;
}
private string GetPlayerName()
{
return _clientState.LocalPlayer!.Name.ToString();
}
private void IpcManager_PenumbraRedrawEvent(object? objectTableIndex, EventArgs e)
{
var objTableObj = _objectTable[(int)objectTableIndex!];
if (objTableObj!.ObjectKind == Dalamud.Game.ClientState.Objects.Enums.ObjectKind.Player)
{
if (objTableObj.Name.ToString() == GetPlayerName())
{
PluginLog.Debug("Penumbra Redraw Event");
PlayerChanged(GetPlayerName());
}
}
if (objTableObj!.ObjectKind != Dalamud.Game.ClientState.Objects.Enums.ObjectKind.Player) return;
if (objTableObj.Name.ToString() != _dalamudUtil.PlayerName) return;
Logger.Debug("Penumbra Redraw Event");
PlayerChanged(_dalamudUtil.PlayerName);
}
private unsafe void PlayerChanged(string name)
private void PlayerChanged(string name)
{
//if (sender == null) return;
PluginLog.Debug("Player changed: " + name);
Logger.Debug("Player changed: " + name);
if (_playerChangedTask is { IsCompleted: false })
{
PluginLog.Warning("PlayerChanged Task still running");
return;
}
_playerChangedTask = Task.Run(() =>
_playerChangedTask = Task.Run(async () =>
{
WaitWhileCharacterIsDrawing(_clientState.LocalPlayer!.Address);
Stopwatch st = Stopwatch.StartNew();
_dalamudUtil.WaitWhileSelfIsDrawing();
var characterCacheTask = CreateFullCharacterCache();
Task.WaitAll(characterCacheTask);
var characterCacheTask = await CreateFullCharacterCache();
var cacheDto = characterCacheTask.Result.ToCharacterCacheDto();
var cacheDto = characterCacheTask.ToCharacterCacheDto();
st.Stop();
Logger.Debug("Elapsed time PlayerChangedTask: " + st.Elapsed);
if (cacheDto.Hash == _lastSentHash)
{
PluginLog.Debug("Not sending data, already sent");
Logger.Debug("Not sending data, already sent");
return;
}
Task.WaitAll(_apiController.SendCharacterData(cacheDto, GetLocalPlayers().Select(d => d.Key).ToList()));
await _apiController.SendCharacterData(cacheDto, _dalamudUtil.GetLocalPlayers().Select(d => d.Key).ToList());
_lastSentHash = cacheDto.Hash;
});
}
public unsafe void WaitWhileCharacterIsDrawing(IntPtr characterAddress)
{
var obj = (GameObject*)characterAddress;
while ((obj->RenderFlags & 0b100000000000) == 0b100000000000) // 0b100000000000 is "still rendering" or something
{
//PluginLog.Debug("Waiting for character to finish drawing");
Thread.Sleep(100);
}
// wait half a second just in case
Thread.Sleep(500);
}
private void RestorePreviousCharacter(string playerName)
{
PluginLog.Debug("Restoring state for " + playerName);
_ipcManager.PenumbraRemoveTemporaryCollection(playerName);
_ipcManager.GlamourerRevertCharacterCustomization(playerName);
}
private void Watcher_PlayerChanged(Dalamud.Game.ClientState.Objects.Types.Character actor)
{
try
Logger.Debug("Watcher Player Changed");
Task.Run(() =>
{
// fix for redraw from anamnesis
while (_clientState.LocalPlayer == null)
try
{
Thread.Sleep(100);
// fix for redraw from anamnesis
while (!_dalamudUtil.IsPlayerPresent)
{
Logger.Debug("Waiting Until Player is Present");
Thread.Sleep(100);
}
if (actor.Name.ToString() == _dalamudUtil.PlayerName)
{
Logger.Debug("Watcher: PlayerChanged");
PlayerChanged(actor.Name.ToString());
}
else
{
Logger.Debug("PlayerChanged: " + actor.Name.ToString());
}
}
if (actor.Name.ToString() == _clientState.LocalPlayer!.Name.ToString())
catch (Exception ex)
{
PluginLog.Debug("Watcher: PlayerChanged");
PlayerChanged(actor.Name.ToString());
PluginLog.Error(ex, "Actor was null or broken " + actor);
}
else
{
PluginLog.Debug("PlayerChanged: " + actor.Name.ToString());
}
}
catch(Exception ex)
{
PluginLog.Error(ex, "Actor was null or broken " + actor);
}
});
}
}
}

17
MareSynchronos/Managers/FileCacheManager.cs
View File

@@ -4,12 +4,12 @@ using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Logging;
using MareSynchronos.Factories;
using MareSynchronos.FileCacheDB;
using MareSynchronos.Utils;
namespace MareSynchronos.Managers
{
@@ -25,6 +25,8 @@ namespace MareSynchronos.Managers
private Stopwatch? _timerStopWatch;
public FileCacheManager(FileCacheFactory fileCacheFactory, IpcManager ipcManager, Configuration pluginConfiguration)
{
Logger.Debug("Creating " + nameof(FileCacheManager));
_fileCacheFactory = fileCacheFactory;
_ipcManager = ipcManager;
_pluginConfiguration = pluginConfiguration;
@@ -47,7 +49,8 @@ namespace MareSynchronos.Managers
public void Dispose()
{
PluginLog.Debug("Disposing File Cache Manager");
Logger.Debug("Disposing " + nameof(FileCacheManager));
_scanScheduler?.Stop();
_scanCancellationTokenSource?.Cancel();
}
@@ -62,7 +65,7 @@ namespace MareSynchronos.Managers
{
_scanCancellationTokenSource = new CancellationTokenSource();
var penumbraDir = _ipcManager.PenumbraModDirectory()!;
PluginLog.Debug("Getting files from " + penumbraDir);
Logger.Debug("Getting files from " + penumbraDir);
var scannedFiles = new ConcurrentDictionary<string, bool>(
Directory.EnumerateFiles(penumbraDir, "*.*", SearchOption.AllDirectories)
.Select(s => s.ToLowerInvariant())
@@ -80,7 +83,7 @@ namespace MareSynchronos.Managers
var fileCachesToDelete = new ConcurrentBag<FileCache>();
var fileCachesToAdd = new ConcurrentBag<FileCache>();
PluginLog.Debug("Getting file list from Database");
Logger.Debug("Getting file list from Database");
// scan files from database
Parallel.ForEach(fileCaches, new ParallelOptions()
{
@@ -140,7 +143,7 @@ namespace MareSynchronos.Managers
}
}
PluginLog.Debug("Scan complete");
Logger.Debug("Scan complete");
TotalFiles = 0;
CurrentFileProgress = 0;
@@ -160,7 +163,7 @@ namespace MareSynchronos.Managers
private void StartScheduler()
{
PluginLog.Debug("Scheduling next scan for in " + MinutesForScan + " minutes");
Logger.Debug("Scheduling next scan for in " + MinutesForScan + " minutes");
_scanScheduler = new System.Timers.Timer(TimeSpan.FromMinutes(MinutesForScan).TotalMilliseconds)
{
AutoReset = false,
@@ -176,7 +179,7 @@ namespace MareSynchronos.Managers
return;
}
PluginLog.Debug("Initiating periodic scan for mod changes");
Logger.Debug("Initiating periodic scan for mod changes");
Task.Run(() => _scanTask = StartFileScan(_scanCancellationTokenSource!.Token));
_timerStopWatch = Stopwatch.StartNew();
};

256
MareSynchronos/Managers/IpcManager.cs
View File

@@ -2,75 +2,78 @@
using Dalamud.Plugin;
using Dalamud.Plugin.Ipc;
using System;
using System.Buffers.Text;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.IO;
using System.IO.Compression;
using System.Reflection.Metadata;
using System.Text;
using Newtonsoft.Json;
using MareSynchronos.Utils;
namespace MareSynchronos.Managers
{
public class IpcManager : IDisposable
{
private readonly DalamudPluginInterface _pluginInterface;
private readonly ICallGateSubscriber<object> _penumbraInit;
private readonly ICallGateSubscriber<string, string, string>? _penumbraResolvePath;
private readonly ICallGateSubscriber<string>? _penumbraResolveModDir;
private readonly ICallGateSubscriber<string>? _glamourerGetCharacterCustomization;
private readonly ICallGateSubscriber<string, string, object>? _glamourerApplyCharacterCustomization;
private readonly ICallGateSubscriber<int> _penumbraApiVersion;
private readonly ICallGateSubscriber<int> _glamourerApiVersion;
private readonly ICallGateSubscriber<string, string, object>? _glamourerApplyCharacterCustomization;
private readonly ICallGateSubscriber<string>? _glamourerGetCharacterCustomization;
private readonly ICallGateSubscriber<string, object> _glamourerRevertCustomization;
private readonly ICallGateSubscriber<int> _penumbraApiVersion;
private readonly ICallGateSubscriber<string, string, bool, (int, string)> _penumbraCreateTemporaryCollection;
private readonly ICallGateSubscriber<string, string> _penumbraGetMetaManipulations;
private readonly ICallGateSubscriber<object> _penumbraInit;
private readonly ICallGateSubscriber<IntPtr, int, object?> _penumbraObjectIsRedrawn;
private readonly ICallGateSubscriber<string, int, object>? _penumbraRedraw;
private readonly ICallGateSubscriber<string, int> _penumbraRemoveTemporaryCollection;
private readonly ICallGateSubscriber<string>? _penumbraResolveModDir;
private readonly ICallGateSubscriber<string, string, string>? _penumbraResolvePath;
private readonly ICallGateSubscriber<string, string, string[]>? _penumbraReverseResolvePath;
private readonly ICallGateSubscriber<string, object> _glamourerRevertCustomization;
private readonly ICallGateSubscriber<string, string> _penumbraGetMetaManipulations;
private readonly ICallGateSubscriber<string, string, Dictionary<string, string>, string, int, int>
_penumbraSetTemporaryMod;
private readonly ICallGateSubscriber<string, string, bool, (int, string)> _penumbraCreateTemporaryCollection;
private readonly ICallGateSubscriber<string, int> _penumbraRemoveTemporaryCollection;
public bool Initialized { get; private set; } = false;
public event EventHandler? PenumbraRedrawEvent;
public IpcManager(DalamudPluginInterface pi)
{
_pluginInterface = pi;
Logger.Debug("Creating " + nameof(IpcManager));
_penumbraInit = _pluginInterface.GetIpcSubscriber<object>("Penumbra.Initialized");
_penumbraResolvePath = _pluginInterface.GetIpcSubscriber<string, string, string>("Penumbra.ResolveCharacterPath");
_penumbraResolveModDir = _pluginInterface.GetIpcSubscriber<string>("Penumbra.GetModDirectory");
_penumbraRedraw = _pluginInterface.GetIpcSubscriber<string, int, object>("Penumbra.RedrawObjectByName");
_glamourerGetCharacterCustomization = _pluginInterface.GetIpcSubscriber<string>("Glamourer.GetCharacterCustomization");
_glamourerApplyCharacterCustomization = _pluginInterface.GetIpcSubscriber<string, string, object>("Glamourer.ApplyCharacterCustomization");
_penumbraReverseResolvePath = _pluginInterface.GetIpcSubscriber<string, string, string[]>("Penumbra.ReverseResolvePath");
_penumbraApiVersion = _pluginInterface.GetIpcSubscriber<int>("Penumbra.ApiVersion");
_glamourerApiVersion = _pluginInterface.GetIpcSubscriber<int>("Glamourer.ApiVersion");
_glamourerRevertCustomization = _pluginInterface.GetIpcSubscriber<string, object>("Glamourer.RevertCharacterCustomization");
_penumbraObjectIsRedrawn = _pluginInterface.GetIpcSubscriber<IntPtr, int, object?>("Penumbra.GameObjectRedrawn");
_penumbraInit = pi.GetIpcSubscriber<object>("Penumbra.Initialized");
_penumbraResolvePath = pi.GetIpcSubscriber<string, string, string>("Penumbra.ResolveCharacterPath");
_penumbraResolveModDir = pi.GetIpcSubscriber<string>("Penumbra.GetModDirectory");
_penumbraRedraw = pi.GetIpcSubscriber<string, int, object>("Penumbra.RedrawObjectByName");
_glamourerGetCharacterCustomization = pi.GetIpcSubscriber<string>("Glamourer.GetCharacterCustomization");
_glamourerApplyCharacterCustomization = pi.GetIpcSubscriber<string, string, object>("Glamourer.ApplyCharacterCustomization");
_penumbraReverseResolvePath = pi.GetIpcSubscriber<string, string, string[]>("Penumbra.ReverseResolvePath");
_penumbraApiVersion = pi.GetIpcSubscriber<int>("Penumbra.ApiVersion");
_glamourerApiVersion = pi.GetIpcSubscriber<int>("Glamourer.ApiVersion");
_glamourerRevertCustomization = pi.GetIpcSubscriber<string, object>("Glamourer.RevertCharacterCustomization");
_penumbraObjectIsRedrawn = pi.GetIpcSubscriber<IntPtr, int, object?>("Penumbra.GameObjectRedrawn");
_penumbraGetMetaManipulations =
_pluginInterface.GetIpcSubscriber<string, string>("Penumbra.GetMetaManipulations");
pi.GetIpcSubscriber<string, string>("Penumbra.GetMetaManipulations");
_penumbraObjectIsRedrawn.Subscribe(RedrawEvent);
_penumbraInit.Subscribe(RedrawSelf);
_penumbraSetTemporaryMod =
_pluginInterface
pi
.GetIpcSubscriber<string, string, Dictionary<string, string>, string, int,
int>("Penumbra.AddTemporaryMod");
_penumbraCreateTemporaryCollection =
_pluginInterface.GetIpcSubscriber<string, string, bool, (int, string)>("Penumbra.CreateTemporaryCollection");
pi.GetIpcSubscriber<string, string, bool, (int, string)>("Penumbra.CreateTemporaryCollection");
_penumbraRemoveTemporaryCollection =
_pluginInterface.GetIpcSubscriber<string, int>("Penumbra.RemoveTemporaryCollection");
pi.GetIpcSubscriber<string, int>("Penumbra.RemoveTemporaryCollection");
Initialized = true;
}
public event EventHandler? PenumbraRedrawEvent;
public bool Initialized { get; private set; } = false;
public bool CheckGlamourerApi()
{
try
{
return _glamourerApiVersion.InvokeFunc() >= 0;
}
catch
{
return false;
}
}
public bool CheckPenumbraApi()
{
try
@@ -82,17 +85,88 @@ namespace MareSynchronos.Managers
return false;
}
}
public bool CheckGlamourerApi()
public void Dispose()
{
try
{
return _glamourerApiVersion.InvokeFunc() >= 0;
}
catch
{
return false;
}
Logger.Debug("Disposing " + nameof(IpcManager));
Uninitialize();
}
public void GlamourerApplyCharacterCustomization(string customization, string characterName)
{
if (!CheckGlamourerApi()) return;
Logger.Debug("GlamourerString: " + customization);
_glamourerApplyCharacterCustomization!.InvokeAction(customization, characterName);
}
public string? GlamourerGetCharacterCustomization()
{
if (!CheckGlamourerApi()) return null;
return _glamourerGetCharacterCustomization!.InvokeFunc();
}
public void GlamourerRevertCharacterCustomization(string characterName)
{
if (!CheckGlamourerApi()) return;
_glamourerRevertCustomization!.InvokeAction(characterName);
}
public string PenumbraCreateTemporaryCollection(string characterName)
{
if (!CheckPenumbraApi()) return string.Empty;
Logger.Debug("Creating temp collection for " + characterName);
return _penumbraCreateTemporaryCollection.InvokeFunc("MareSynchronos", characterName, true).Item2;
}
public string PenumbraGetMetaManipulations(string characterName)
{
if (!CheckPenumbraApi()) return string.Empty;
return _penumbraGetMetaManipulations.InvokeFunc(characterName);
}
public string? PenumbraModDirectory()
{
if (!CheckPenumbraApi()) return null;
return _penumbraResolveModDir!.InvokeFunc();
}
public void PenumbraRedraw(string actorName)
{
if (!CheckPenumbraApi()) return;
_penumbraRedraw!.InvokeAction(actorName, 0);
}
public void PenumbraRemoveTemporaryCollection(string characterName)
{
if (!CheckPenumbraApi()) return;
Logger.Debug("Removing temp collection for " + characterName);
_penumbraRemoveTemporaryCollection.InvokeFunc(characterName);
}
public string? PenumbraResolvePath(string path, string characterName)
{
if (!CheckPenumbraApi()) return null;
var resolvedPath = _penumbraResolvePath!.InvokeFunc(path, characterName);
PluginLog.Verbose("Resolving " + path + Environment.NewLine + "=>" + string.Join(", ", resolvedPath));
return resolvedPath;
}
public string[] PenumbraReverseResolvePath(string path, string characterName)
{
if (!CheckPenumbraApi()) return new[] { path };
var resolvedPaths = _penumbraReverseResolvePath!.InvokeFunc(path, characterName);
PluginLog.Verbose("ReverseResolving " + path + Environment.NewLine + "=>" + string.Join(", ", resolvedPaths));
return resolvedPaths;
}
public void PenumbraSetTemporaryMods(string collectionName, Dictionary<string, string> modPaths, string manipulationData)
{
if (!CheckPenumbraApi()) return;
Logger.Debug("Assigning temp mods for " + collectionName);
Logger.Debug("ManipulationString: " + manipulationData);
var ret = _penumbraSetTemporaryMod.InvokeFunc("MareSynchronos", collectionName, modPaths, manipulationData, 0);
Logger.Debug("Penumbra Ret: " + ret.ToString());
}
private void RedrawEvent(IntPtr objectAddress, int objectTableIndex)
@@ -110,89 +184,7 @@ namespace MareSynchronos.Managers
_penumbraInit.Unsubscribe(RedrawSelf);
_penumbraObjectIsRedrawn.Unsubscribe(RedrawEvent);
Initialized = false;
PluginLog.Debug("IPC Manager disposed");
}
public string[] PenumbraReverseResolvePath(string path, string characterName)
{
if (!CheckPenumbraApi()) return new[] { path };
var resolvedPaths = _penumbraReverseResolvePath!.InvokeFunc(path, characterName);
PluginLog.Verbose("ReverseResolving " + path + Environment.NewLine + "=>" + string.Join(", ", resolvedPaths));
return resolvedPaths;
}
public string? PenumbraResolvePath(string path, string characterName)
{
if (!CheckPenumbraApi()) return null;
var resolvedPath = _penumbraResolvePath!.InvokeFunc(path, characterName);
PluginLog.Verbose("Resolving " + path + Environment.NewLine + "=>" + string.Join(", ", resolvedPath));
return resolvedPath;
}
public string? PenumbraModDirectory()
{
if (!CheckPenumbraApi()) return null;
return _penumbraResolveModDir!.InvokeFunc();
}
public string? GlamourerGetCharacterCustomization()
{
if (!CheckGlamourerApi()) return null;
return _glamourerGetCharacterCustomization!.InvokeFunc();
}
public void GlamourerApplyCharacterCustomization(string customization, string characterName)
{
if (!CheckGlamourerApi()) return;
PluginLog.Debug("GlamourerString: " + customization);
_glamourerApplyCharacterCustomization!.InvokeAction(customization, characterName);
}
public void GlamourerRevertCharacterCustomization(string characterName)
{
if (!CheckGlamourerApi()) return;
_glamourerRevertCustomization!.InvokeAction(characterName);
}
public void PenumbraRedraw(string actorName)
{
if (!CheckPenumbraApi()) return;
_penumbraRedraw!.InvokeAction(actorName, 0);
}
public string PenumbraCreateTemporaryCollection(string characterName)
{
if (!CheckPenumbraApi()) return string.Empty;
PluginLog.Debug("Creating temp collection for " + characterName);
return _penumbraCreateTemporaryCollection.InvokeFunc("MareSynchronos", characterName, true).Item2;
}
public void PenumbraRemoveTemporaryCollection(string characterName)
{
if (!CheckPenumbraApi()) return;
PluginLog.Debug("Removing temp collection for " + characterName);
_penumbraRemoveTemporaryCollection.InvokeFunc(characterName);
}
public void PenumbraSetTemporaryMods(string collectionName, Dictionary<string, string> modPaths, string manipulationData)
{
if (!CheckPenumbraApi()) return;
PluginLog.Debug("Assigning temp mods for " + collectionName);
PluginLog.Debug("ManipulationString: " + manipulationData);
var ret = _penumbraSetTemporaryMod.InvokeFunc("MareSynchronos", collectionName, modPaths, manipulationData, 0);
PluginLog.Debug("Penumbra Ret: " + ret.ToString());
}
public string PenumbraGetMetaManipulations(string characterName)
{
if (!CheckPenumbraApi()) return string.Empty;
return _penumbraGetMetaManipulations.InvokeFunc(characterName);
}
public void Dispose()
{
Uninitialize();
Logger.Debug("IPC Manager disposed");
}
}
}