475 lines
20 KiB
C#
475 lines
20 KiB
C#
using Dalamud.Game;
|
|
using Dalamud.Game.ClientState;
|
|
using Dalamud.Game.ClientState.Objects;
|
|
using Dalamud.Logging;
|
|
using FFXIVClientStructs.FFXIV.Client.Game.Object;
|
|
using MareSynchronos.Factories;
|
|
using MareSynchronos.Models;
|
|
using MareSynchronos.Utils;
|
|
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 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 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)
|
|
{
|
|
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);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_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.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);
|
|
if (_apiController.IsConnected)
|
|
{
|
|
ApiController_Connected(null, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
private void ApiController_Connected(object? sender, EventArgs args)
|
|
{
|
|
PluginLog.Debug(nameof(ApiController_Connected));
|
|
PluginLog.Debug("MyHashedName:" + Crypto.GetHash256(GetPlayerName() + _clientState.LocalPlayer!.HomeWorld.Id));
|
|
_lastSentHash = string.Empty;
|
|
var apiTask = _apiController.SendCharacterName(Crypto.GetHash256(GetPlayerName() + _clientState.LocalPlayer!.HomeWorld.Id));
|
|
|
|
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;
|
|
_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;
|
|
_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)
|
|
{
|
|
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 } });
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
await Task.Delay(50);
|
|
}
|
|
|
|
var json = JsonConvert.SerializeObject(cache, Formatting.Indented);
|
|
|
|
cache.CacheHash = Crypto.GetHash(json);
|
|
});
|
|
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
|
|
private unsafe void PlayerChanged(string name)
|
|
{
|
|
//if (sender == null) return;
|
|
PluginLog.Debug("Player changed: " + name);
|
|
if (_playerChangedTask is { IsCompleted: false })
|
|
{
|
|
PluginLog.Warning("PlayerChanged Task still running");
|
|
return;
|
|
}
|
|
|
|
_playerChangedTask = Task.Run(() =>
|
|
{
|
|
WaitWhileCharacterIsDrawing(_clientState.LocalPlayer!.Address);
|
|
|
|
var characterCacheTask = CreateFullCharacterCache();
|
|
Task.WaitAll(characterCacheTask);
|
|
|
|
var cacheDto = characterCacheTask.Result.ToCharacterCacheDto();
|
|
if (cacheDto.Hash == _lastSentHash)
|
|
{
|
|
PluginLog.Debug("Not sending data, already sent");
|
|
return;
|
|
}
|
|
Task.WaitAll(_apiController.SendCharacterData(cacheDto, 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
|
|
{
|
|
// fix for redraw from anamnesis
|
|
while (_clientState.LocalPlayer == null)
|
|
{
|
|
Thread.Sleep(100);
|
|
}
|
|
if (actor.Name.ToString() == _clientState.LocalPlayer!.Name.ToString())
|
|
{
|
|
PluginLog.Debug("Watcher: PlayerChanged");
|
|
PlayerChanged(actor.Name.ToString());
|
|
}
|
|
else
|
|
{
|
|
PluginLog.Debug("PlayerChanged: " + actor.Name.ToString());
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
PluginLog.Error(ex, "Actor was null or broken " + actor);
|
|
}
|
|
}
|
|
}
|
|
}
|