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

idk

Browse Source
This commit is contained in:
rootdarkarchon
2023-05-02 02:00:23 +02:00
parent 2b777f94f1
commit 3086d82b40
7 changed files with 92 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
MareSynchronos/PlayerData/Handlers/GameObjectHandler.cs
View File

@@ -84,8 +84,6 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase
public IntPtr Address { get; set; }
public unsafe Character* Character => (Character*)Address;
public Lazy<Dalamud.Game.ClientState.Objects.Types.GameObject?> GameObjectLazy { get; private set; }
public string Name { get; private set; }
public ObjectKind ObjectKind { get; }
@@ -101,22 +99,33 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase
return await _dalamudUtil.RunOnFrameworkThread(_getAddress.Invoke).ConfigureAwait(true);
}
public async Task<Dalamud.Game.ClientState.Objects.Types.GameObject?> GetGameObject()
{
return await _dalamudUtil.CreateGameObject(Address).ConfigureAwait(true);
}
public bool IsBeingDrawn()
{
var curPtr = _getAddress();
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, CurPtr: {ptr}", this, curPtr.ToString("X"));
if (curPtr == IntPtr.Zero)
{
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, CurPtr is ZERO, returning", this);
Address = IntPtr.Zero;
DrawObjectAddress = IntPtr.Zero;
return false;
}
var drawObj = GetDrawObj(curPtr);
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, DrawObjPtr: {ptr}", this, drawObj.ToString("X"));
return IsBeingDrawn(drawObj, curPtr);
}
public async Task<bool> IsBeingDrawnRunOnFramework()
{
return await _dalamudUtil.RunOnFrameworkThread(() =>
{
var curPtr = _getAddress.Invoke();
if (curPtr == IntPtr.Zero)
{
Address = IntPtr.Zero;
DrawObjectAddress = IntPtr.Zero;
return false;
}
var drawObj = GetDrawObj(curPtr);
return IsBeingDrawn(drawObj, curPtr);
}).ConfigureAwait(false);
return await _dalamudUtil.RunOnFrameworkThread(IsBeingDrawn).ConfigureAwait(false);
}
public override string ToString()
@@ -137,23 +146,24 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase
{
if (_haltProcessing) return;
var curPtr = CurrentAddress().GetAwaiter().GetResult();
bool drawObjDiff = false;
try
var prevAddr = Address;
var prevDrawObj = DrawObjectAddress;
Address = _getAddress();
if (Address != IntPtr.Zero)
{
if (curPtr != IntPtr.Zero)
{
var drawObjAddr = (IntPtr)((GameObject*)curPtr)->DrawObject;
drawObjDiff = drawObjAddr != DrawObjectAddress;
DrawObjectAddress = drawObjAddr;
}
var drawObjAddr = (IntPtr)((GameObject*)Address)->DrawObject;
DrawObjectAddress = drawObjAddr;
}
catch (Exception ex)
else
{
Logger.LogError(ex, "Error during checking for draw object for {name}", this);
DrawObjectAddress = IntPtr.Zero;
}
if (curPtr != IntPtr.Zero && DrawObjectAddress != IntPtr.Zero)
bool drawObjDiff = DrawObjectAddress != prevDrawObj;
bool addrDiff = Address != prevAddr;
if (Address != IntPtr.Zero && DrawObjectAddress != IntPtr.Zero)
{
if (_clearCts != null)
{
@@ -161,13 +171,7 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase
_clearCts?.Cancel();
_clearCts = null;
}
bool addrDiff = Address != curPtr;
Address = curPtr;
if (addrDiff)
{
GameObjectLazy = new(() => _dalamudUtil.CreateGameObject(curPtr).GetAwaiter().GetResult());
}
var chara = (Character*)curPtr;
var chara = (Character*)Address;
var name = new ByteString(chara->GameObject.Name).ToString();
bool nameChange = !string.Equals(name, Name, StringComparison.Ordinal);
Name = name;
@@ -181,19 +185,15 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase
var customizeDiff = CompareAndUpdateCustomizeData(chara->CustomizeData);
if ((addrDiff || equipDiff || customizeDiff || drawObjDiff || nameChange) && _isOwnedObject)
if ((addrDiff || drawObjDiff || equipDiff || customizeDiff || nameChange) && _isOwnedObject)
{
Logger.LogTrace("[{this}] Changed", this);
Logger.LogDebug("[{this}] Sending CreateCacheObjectMessage", this);
Logger.LogDebug("[{this}] Changed, Sending CreateCacheObjectMessage", this);
Mediator.Publish(new CreateCacheForObjectMessage(this));
}
}
else if (Address != IntPtr.Zero || DrawObjectAddress != IntPtr.Zero)
else if (addrDiff || drawObjDiff)
{
Address = IntPtr.Zero;
DrawObjectAddress = IntPtr.Zero;
Logger.LogTrace("[{this}] Changed -> Null", this);
Logger.LogTrace("[{this}] Changed", this);
if (_isOwnedObject && ObjectKind != ObjectKind.Player)
{
_clearCts?.Cancel();
@@ -264,18 +264,29 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase
private unsafe IntPtr GetDrawObj(nint curPtr)
{
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, Getting new DrawObject", this);
return (IntPtr)((GameObject*)curPtr)->DrawObject;
}
private unsafe bool IsBeingDrawn(IntPtr drawObj, IntPtr curPtr)
{
Logger.LogTrace("IsBeingDrawn for {kind} ptr {curPtr} : {drawObj}", ObjectKind, curPtr.ToString("X"), drawObj.ToString("X"));
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, Checking IsBeingDrawn for Ptr {curPtr} : DrawObj {drawObj}", this, curPtr.ToString("X"), drawObj.ToString("X"));
if (ObjectKind == ObjectKind.Player)
{
return drawObj == IntPtr.Zero
|| (((CharacterBase*)drawObj)->HasModelInSlotLoaded != 0)
|| (((CharacterBase*)drawObj)->HasModelFilesInSlotLoaded != 0)
|| (((GameObject*)curPtr)->RenderFlags & 0b100000000000) == 0b100000000000;
var drawObjZero = drawObj == IntPtr.Zero;
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, Condition IsDrawObjZero: {cond}", this, drawObjZero);
if (drawObjZero) return true;
var renderFlags = (((GameObject*)curPtr)->RenderFlags) != 0x0;
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, Condition RenderFlags: {cond}", this, renderFlags);
if (renderFlags) return true;
var modelInSlotLoaded = (((CharacterBase*)drawObj)->HasModelInSlotLoaded != 0);
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, Condition ModelInSlotLoaded: {cond}", this, modelInSlotLoaded);
if (modelInSlotLoaded) return true;
var modelFilesInSlotLoaded = (((CharacterBase*)drawObj)->HasModelFilesInSlotLoaded != 0);
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, Condition ModelFilesInSlotLoaded: {cond}", this, modelFilesInSlotLoaded);
if (modelFilesInSlotLoaded) return true;
Logger.LogTrace("[{this}] IsBeingDrawnRunOnFramework, Is not being drawn", this);
return false;
}
return drawObj == IntPtr.Zero

24
MareSynchronos/PlayerData/Pairs/CachedPlayer.cs
View File

@@ -115,7 +115,7 @@ public sealed class CachedPlayer : DisposableMediatorSubscriberBase
Logger.LogDebug("Downloading and applying character for {name}", this);
DownloadAndApplyCharacter(characterData, charaDataToUpdate);
DownloadAndApplyCharacter(characterData.DeepClone(), charaDataToUpdate);
_cachedData = characterData;
}
@@ -203,10 +203,12 @@ public sealed class CachedPlayer : DisposableMediatorSubscriberBase
private async Task ApplyBaseData(Guid applicationId, Dictionary<string, string> moddedPaths, string manipulationData, CancellationToken token)
{
await _ipcManager.PenumbraRemoveTemporaryCollection(Logger, applicationId, PlayerName!).ConfigureAwait(false);
await _ipcManager.PenumbraRemoveTemporaryCollection(Logger, applicationId, PlayerName!).ConfigureAwait(true);
token.ThrowIfCancellationRequested();
var objTableIndex = await _dalamudUtil.RunOnFrameworkThread(() => _charaHandler!.GameObjectLazy!.Value.ObjectTableIndex()).ConfigureAwait(false);
await _ipcManager.PenumbraSetTemporaryMods(Logger, applicationId, PlayerName!, objTableIndex, moddedPaths, manipulationData).ConfigureAwait(false);
var gameObj = await _charaHandler!.GetGameObject().ConfigureAwait(true);
if (gameObj == null) return;
var objTableIndex = await _dalamudUtil.RunOnFrameworkThread(() => gameObj.ObjectTableIndex()).ConfigureAwait(true);
await _ipcManager.PenumbraSetTemporaryMods(Logger, applicationId, PlayerName!, objTableIndex, moddedPaths, manipulationData).ConfigureAwait(true);
token.ThrowIfCancellationRequested();
}
@@ -443,16 +445,26 @@ public sealed class CachedPlayer : DisposableMediatorSubscriberBase
try
{
_applicationId = Guid.NewGuid();
Logger.LogDebug("[{applicationId}] Starting application task", _applicationId);
Logger.LogDebug("[{applicationId}] Starting application task for {this}", _applicationId, this);
Logger.LogDebug("[{applicationId}] Waiting for initial draw for for {handler}", _applicationId, _charaHandler);
await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, _charaHandler!, _applicationId, 30000, token).ConfigureAwait(false);
token.ThrowIfCancellationRequested();
var applyBaseData = new Action(() => ApplyBaseData(_applicationId, moddedPaths, charaData.ManipulationData, token).ConfigureAwait(true).GetAwaiter().GetResult());
if (updateModdedPaths && (moddedPaths.Any() || !string.IsNullOrEmpty(charaData.ManipulationData)))
{
await ApplyBaseData(_applicationId, moddedPaths, charaData.ManipulationData, token).ConfigureAwait(false);
while (!await _dalamudUtil.RunOnFrameworkThread(() =>
{
if (_charaHandler!.IsBeingDrawn()) return false;
applyBaseData();
return true;
}).ConfigureAwait(false))
{
await Task.Delay(250, token).ConfigureAwait(false);
}
}
token.ThrowIfCancellationRequested();