1051 lines
39 KiB
C#
1051 lines
39 KiB
C#
using Dalamud.Game.ClientState.Conditions;
|
|
using Dalamud.Game.ClientState.Objects;
|
|
using Dalamud.Game.ClientState.Objects.SubKinds;
|
|
using Dalamud.Game.ClientState.Objects.Types;
|
|
using Dalamud.Plugin.Services;
|
|
using Dalamud.Utility;
|
|
using FFXIVClientStructs.FFXIV.Client.Game;
|
|
using FFXIVClientStructs.FFXIV.Client.Game.Character;
|
|
using FFXIVClientStructs.FFXIV.Client.Game.Control;
|
|
using FFXIVClientStructs.FFXIV.Client.Graphics.Scene;
|
|
using FFXIVClientStructs.FFXIV.Client.UI.Agent;
|
|
using LightlessSync.API.Dto.CharaData;
|
|
using LightlessSync.Interop;
|
|
using LightlessSync.LightlessConfiguration;
|
|
using LightlessSync.PlayerData.Factories;
|
|
using LightlessSync.PlayerData.Handlers;
|
|
using LightlessSync.PlayerData.Pairs;
|
|
using LightlessSync.Services.ActorTracking;
|
|
using LightlessSync.Services.Mediator;
|
|
using LightlessSync.Utils;
|
|
using Lumina.Excel.Sheets;
|
|
using Microsoft.Extensions.Hosting;
|
|
using Microsoft.Extensions.Logging;
|
|
using System.Numerics;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using DalamudObjectKind = Dalamud.Game.ClientState.Objects.Enums.ObjectKind;
|
|
using GameObject = FFXIVClientStructs.FFXIV.Client.Game.Object.GameObject;
|
|
|
|
namespace LightlessSync.Services;
|
|
|
|
public class DalamudUtilService : IHostedService, IMediatorSubscriber
|
|
{
|
|
private readonly List<uint> _classJobIdsIgnoredForPets = [30];
|
|
private readonly IClientState _clientState;
|
|
private readonly ICondition _condition;
|
|
private readonly IDataManager _gameData;
|
|
private readonly IGameConfig _gameConfig;
|
|
private readonly BlockedCharacterHandler _blockedCharacterHandler;
|
|
private readonly IFramework _framework;
|
|
private readonly IGameGui _gameGui;
|
|
private readonly ILogger<DalamudUtilService> _logger;
|
|
private readonly IObjectTable _objectTable;
|
|
private readonly ActorObjectService _actorObjectService;
|
|
private readonly ITargetManager _targetManager;
|
|
private readonly PerformanceCollectorService _performanceCollector;
|
|
private readonly LightlessConfigService _configService;
|
|
private readonly PlayerPerformanceConfigService _playerPerformanceConfigService;
|
|
private readonly Lazy<PairFactory> _pairFactory;
|
|
private PairUniqueIdentifier? _FocusPairIdent;
|
|
private IGameObject? _FocusOriginalTarget;
|
|
private uint? _classJobId = 0;
|
|
private DateTime _delayedFrameworkUpdateCheck = DateTime.UtcNow;
|
|
private string _lastGlobalBlockPlayer = string.Empty;
|
|
private string _lastGlobalBlockReason = string.Empty;
|
|
private ushort _lastZone = 0;
|
|
private ushort _lastWorldId = 0;
|
|
private bool _sentBetweenAreas = false;
|
|
private Lazy<ulong> _cid;
|
|
|
|
public DalamudUtilService(ILogger<DalamudUtilService> logger, IClientState clientState, IObjectTable objectTable, IFramework framework,
|
|
IGameGui gameGui, ICondition condition, IDataManager gameData, ITargetManager targetManager, IGameConfig gameConfig,
|
|
ActorObjectService actorObjectService, BlockedCharacterHandler blockedCharacterHandler, LightlessMediator mediator, PerformanceCollectorService performanceCollector,
|
|
LightlessConfigService configService, PlayerPerformanceConfigService playerPerformanceConfigService, Lazy<PairFactory> pairFactory)
|
|
{
|
|
_logger = logger;
|
|
_clientState = clientState;
|
|
_objectTable = objectTable;
|
|
_framework = framework;
|
|
_gameGui = gameGui;
|
|
_condition = condition;
|
|
_gameData = gameData;
|
|
_gameConfig = gameConfig;
|
|
_actorObjectService = actorObjectService;
|
|
_targetManager = targetManager;
|
|
_blockedCharacterHandler = blockedCharacterHandler;
|
|
Mediator = mediator;
|
|
_performanceCollector = performanceCollector;
|
|
_configService = configService;
|
|
_playerPerformanceConfigService = playerPerformanceConfigService;
|
|
_pairFactory = pairFactory;
|
|
WorldData = new(() =>
|
|
{
|
|
return gameData.GetExcelSheet<Lumina.Excel.Sheets.World>(Dalamud.Game.ClientLanguage.English)!
|
|
.Where(w => !w.Name.IsEmpty && w.DataCenter.RowId != 0 && (w.IsPublic || char.IsUpper(w.Name.ToString()[0])))
|
|
.ToDictionary(w => (ushort)w.RowId, w => w.Name.ToString());
|
|
});
|
|
JobData = new(() =>
|
|
{
|
|
return gameData.GetExcelSheet<ClassJob>(Dalamud.Game.ClientLanguage.English)!
|
|
.ToDictionary(k => k.RowId, k => k.NameEnglish.ToString());
|
|
});
|
|
TerritoryData = new(() =>
|
|
{
|
|
return gameData.GetExcelSheet<TerritoryType>(Dalamud.Game.ClientLanguage.English)!
|
|
.Where(w => w.RowId != 0)
|
|
.ToDictionary(w => w.RowId, w =>
|
|
{
|
|
StringBuilder sb = new();
|
|
sb.Append(w.PlaceNameRegion.Value.Name);
|
|
if (w.PlaceName.ValueNullable != null)
|
|
{
|
|
sb.Append(" - ");
|
|
sb.Append(w.PlaceName.Value.Name);
|
|
}
|
|
return sb.ToString();
|
|
});
|
|
});
|
|
MapData = new(() =>
|
|
{
|
|
return gameData.GetExcelSheet<Map>(Dalamud.Game.ClientLanguage.English)!
|
|
.Where(w => w.RowId != 0)
|
|
.ToDictionary(w => w.RowId, w =>
|
|
{
|
|
StringBuilder sb = new();
|
|
sb.Append(w.PlaceNameRegion.Value.Name);
|
|
if (w.PlaceName.ValueNullable != null)
|
|
{
|
|
sb.Append(" - ");
|
|
sb.Append(w.PlaceName.Value.Name);
|
|
}
|
|
if (w.PlaceNameSub.ValueNullable != null && !string.IsNullOrEmpty(w.PlaceNameSub.Value.Name.ToString()))
|
|
{
|
|
sb.Append(" - ");
|
|
sb.Append(w.PlaceNameSub.Value.Name);
|
|
}
|
|
return (w, sb.ToString());
|
|
});
|
|
});
|
|
mediator.Subscribe<TargetPairMessage>(this, (msg) =>
|
|
{
|
|
if (clientState.IsPvP) return;
|
|
if (!ResolvePairAddress(msg.Pair, out var pair, out var addr)) return;
|
|
var useFocusTarget = _configService.Current.UseFocusTarget;
|
|
_ = RunOnFrameworkThread(() =>
|
|
{
|
|
var gameObject = CreateGameObject(addr);
|
|
if (gameObject is null) return;
|
|
if (useFocusTarget)
|
|
{
|
|
_targetManager.FocusTarget = gameObject;
|
|
if (_FocusPairIdent.HasValue && _FocusPairIdent.Value.Equals(pair.UniqueIdent))
|
|
{
|
|
_FocusOriginalTarget = _targetManager.FocusTarget;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_targetManager.Target = gameObject;
|
|
}
|
|
}).ConfigureAwait(false);
|
|
});
|
|
IsWine = Util.IsWine();
|
|
_cid = RebuildCID();
|
|
}
|
|
|
|
private Lazy<ulong> RebuildCID() => new(GetCID);
|
|
|
|
public bool IsWine { get; init; }
|
|
private bool ResolvePairAddress(Pair pair, out Pair resolvedPair, out nint address)
|
|
{
|
|
resolvedPair = _pairFactory.Value.Create(pair.UniqueIdent) ?? pair;
|
|
address = nint.Zero;
|
|
var name = resolvedPair.PlayerName;
|
|
if (string.IsNullOrEmpty(name)) return false;
|
|
if (!_actorObjectService.TryGetPlayerByName(name, out var descriptor))
|
|
return false;
|
|
address = descriptor.Address;
|
|
return address != nint.Zero;
|
|
}
|
|
|
|
public void FocusVisiblePair(Pair pair)
|
|
{
|
|
if (_clientState.IsPvP) return;
|
|
if (!ResolvePairAddress(pair, out var resolvedPair, out var address)) return;
|
|
_ = RunOnFrameworkThread(() => FocusPairUnsafe(address, resolvedPair.UniqueIdent));
|
|
}
|
|
|
|
public void ReleaseVisiblePairFocus()
|
|
{
|
|
_ = RunOnFrameworkThread(ReleaseFocusUnsafe);
|
|
}
|
|
|
|
private void FocusPairUnsafe(nint address, PairUniqueIdentifier pairIdent)
|
|
{
|
|
var target = CreateGameObject(address);
|
|
if (target is null) return;
|
|
|
|
if (!_FocusPairIdent.HasValue)
|
|
{
|
|
_FocusOriginalTarget = _targetManager.FocusTarget;
|
|
}
|
|
|
|
_targetManager.FocusTarget = target;
|
|
_FocusPairIdent = pairIdent;
|
|
}
|
|
|
|
private void ReleaseFocusUnsafe()
|
|
{
|
|
if (!_FocusPairIdent.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var previous = _FocusOriginalTarget;
|
|
if (previous != null && !IsObjectPresent(previous))
|
|
{
|
|
previous = null;
|
|
}
|
|
|
|
_targetManager.FocusTarget = previous;
|
|
_FocusPairIdent = null;
|
|
_FocusOriginalTarget = null;
|
|
}
|
|
|
|
public unsafe GameObject* GposeTarget
|
|
{
|
|
get => TargetSystem.Instance()->GPoseTarget;
|
|
set => TargetSystem.Instance()->GPoseTarget = value;
|
|
}
|
|
|
|
private unsafe bool HasGposeTarget => GposeTarget != null;
|
|
private unsafe int GPoseTargetIdx => !HasGposeTarget ? -1 : GposeTarget->ObjectIndex;
|
|
|
|
public async Task<IGameObject?> GetGposeTargetGameObjectAsync()
|
|
{
|
|
if (!HasGposeTarget)
|
|
return null;
|
|
|
|
return await _framework.RunOnFrameworkThread(() => _objectTable[GPoseTargetIdx]).ConfigureAwait(true);
|
|
}
|
|
public bool IsAnythingDrawing { get; private set; } = false;
|
|
public bool IsInCutscene { get; private set; } = false;
|
|
public bool IsInGpose { get; private set; } = false;
|
|
public bool IsLoggedIn { get; private set; }
|
|
public bool IsOnFrameworkThread => _framework.IsInFrameworkUpdateThread;
|
|
public bool IsZoning => _condition[ConditionFlag.BetweenAreas] || _condition[ConditionFlag.BetweenAreas51];
|
|
public bool IsInCombat { get; private set; } = false;
|
|
public bool IsPerforming { get; private set; } = false;
|
|
public bool IsInInstance { get; private set; } = false;
|
|
public bool HasModifiedGameFiles => _gameData.HasModifiedGameDataFiles;
|
|
public uint ClassJobId => _classJobId!.Value;
|
|
public Lazy<Dictionary<uint, string>> JobData { get; private set; }
|
|
public Lazy<Dictionary<ushort, string>> WorldData { get; private set; }
|
|
public Lazy<Dictionary<uint, string>> TerritoryData { get; private set; }
|
|
public Lazy<Dictionary<uint, (Map Map, string MapName)>> MapData { get; private set; }
|
|
public bool IsLodEnabled { get; private set; }
|
|
public LightlessMediator Mediator { get; }
|
|
|
|
public IGameObject? CreateGameObject(IntPtr reference)
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable.CreateObjectReference(reference);
|
|
}
|
|
|
|
public async Task<IGameObject?> CreateGameObjectAsync(IntPtr reference)
|
|
{
|
|
return await RunOnFrameworkThread(() => _objectTable.CreateObjectReference(reference)).ConfigureAwait(false);
|
|
}
|
|
|
|
public void EnsureIsOnFramework()
|
|
{
|
|
if (!_framework.IsInFrameworkUpdateThread) throw new InvalidOperationException("Can only be run on Framework");
|
|
}
|
|
|
|
public ICharacter? GetCharacterFromObjectTableByIndex(int index)
|
|
{
|
|
EnsureIsOnFramework();
|
|
var objTableObj = _objectTable[index];
|
|
if (objTableObj!.ObjectKind != DalamudObjectKind.Player) return null;
|
|
return (ICharacter)objTableObj;
|
|
}
|
|
|
|
public unsafe IntPtr GetCompanionPtr(IntPtr? playerPointer = null)
|
|
{
|
|
EnsureIsOnFramework();
|
|
var mgr = CharacterManager.Instance();
|
|
playerPointer ??= GetPlayerPtr();
|
|
if (playerPointer == IntPtr.Zero || (IntPtr)mgr == IntPtr.Zero) return IntPtr.Zero;
|
|
return (IntPtr)mgr->LookupBuddyByOwnerObject((BattleChara*)playerPointer);
|
|
}
|
|
|
|
public async Task<IntPtr> GetCompanionAsync(IntPtr? playerPointer = null)
|
|
{
|
|
return await RunOnFrameworkThread(() => GetCompanionPtr(playerPointer)).ConfigureAwait(false);
|
|
}
|
|
|
|
public async Task<ICharacter?> GetGposeCharacterFromObjectTableByNameAsync(string name, bool onlyGposeCharacters = false)
|
|
{
|
|
return await RunOnFrameworkThread(() => GetGposeCharacterFromObjectTableByName(name, onlyGposeCharacters)).ConfigureAwait(false);
|
|
}
|
|
|
|
public ICharacter? GetGposeCharacterFromObjectTableByName(string name, bool onlyGposeCharacters = false)
|
|
{
|
|
EnsureIsOnFramework();
|
|
return (ICharacter?)_objectTable
|
|
.FirstOrDefault(i => (!onlyGposeCharacters || i.ObjectIndex >= 200) && string.Equals(i.Name.ToString(), name, StringComparison.Ordinal));
|
|
}
|
|
|
|
public IEnumerable<ICharacter?> GetGposeCharactersFromObjectTable()
|
|
{
|
|
foreach (var actor in _actorObjectService.PlayerDescriptors
|
|
.Where(a => a.ObjectKind == DalamudObjectKind.Player && a.ObjectIndex > 200))
|
|
{
|
|
var character = _objectTable.CreateObjectReference(actor.Address) as ICharacter;
|
|
if (character != null)
|
|
yield return character;
|
|
}
|
|
}
|
|
|
|
public bool GetIsPlayerPresent()
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable.LocalPlayer != null && _objectTable.LocalPlayer.IsValid();
|
|
}
|
|
|
|
public async Task<bool> GetIsPlayerPresentAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetIsPlayerPresent).ConfigureAwait(false);
|
|
}
|
|
|
|
public unsafe IntPtr GetMinionOrMountPtr(IntPtr? playerPointer = null)
|
|
{
|
|
EnsureIsOnFramework();
|
|
playerPointer ??= GetPlayerPtr();
|
|
if (playerPointer == IntPtr.Zero) return IntPtr.Zero;
|
|
|
|
var playerAddress = playerPointer.Value;
|
|
var ownerEntityId = ((Character*)playerAddress)->EntityId;
|
|
if (ownerEntityId == 0) return IntPtr.Zero;
|
|
|
|
if (playerAddress == _actorObjectService.LocalPlayerAddress)
|
|
{
|
|
var localOwned = _actorObjectService.LocalMinionOrMountAddress;
|
|
if (localOwned != nint.Zero)
|
|
{
|
|
return localOwned;
|
|
}
|
|
}
|
|
|
|
var ownedObject = FindOwnedObject(ownerEntityId, playerAddress, static kind =>
|
|
kind == DalamudObjectKind.MountType || kind == DalamudObjectKind.Companion);
|
|
if (ownedObject != nint.Zero)
|
|
{
|
|
return ownedObject;
|
|
}
|
|
|
|
return _objectTable.GetObjectAddress(((GameObject*)playerAddress)->ObjectIndex + 1);
|
|
}
|
|
|
|
public async Task<IntPtr> GetMinionOrMountAsync(IntPtr? playerPointer = null)
|
|
{
|
|
return await RunOnFrameworkThread(() => GetMinionOrMountPtr(playerPointer)).ConfigureAwait(false);
|
|
}
|
|
|
|
public unsafe IntPtr GetPetPtr(IntPtr? playerPointer = null)
|
|
{
|
|
EnsureIsOnFramework();
|
|
if (_classJobIdsIgnoredForPets.Contains(_classJobId ?? 0)) return IntPtr.Zero;
|
|
var mgr = CharacterManager.Instance();
|
|
playerPointer ??= GetPlayerPtr();
|
|
if (playerPointer == IntPtr.Zero || (IntPtr)mgr == IntPtr.Zero) return IntPtr.Zero;
|
|
return (IntPtr)mgr->LookupPetByOwnerObject((BattleChara*)playerPointer);
|
|
}
|
|
|
|
public async Task<IntPtr> GetPetAsync(IntPtr? playerPointer = null)
|
|
{
|
|
return await RunOnFrameworkThread(() => GetPetPtr(playerPointer)).ConfigureAwait(false);
|
|
}
|
|
|
|
private unsafe nint FindOwnedObject(uint ownerEntityId, nint ownerAddress, Func<DalamudObjectKind, bool> matchesKind)
|
|
{
|
|
if (ownerEntityId == 0)
|
|
{
|
|
return nint.Zero;
|
|
}
|
|
|
|
foreach (var obj in _objectTable)
|
|
{
|
|
if (obj is null || obj.Address == nint.Zero || obj.Address == ownerAddress)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!matchesKind(obj.ObjectKind))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var candidate = (GameObject*)obj.Address;
|
|
if (ResolveOwnerId(candidate) == ownerEntityId)
|
|
{
|
|
return obj.Address;
|
|
}
|
|
}
|
|
|
|
return nint.Zero;
|
|
}
|
|
|
|
private static unsafe uint ResolveOwnerId(GameObject* gameObject)
|
|
{
|
|
if (gameObject == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (gameObject->OwnerId != 0)
|
|
{
|
|
return gameObject->OwnerId;
|
|
}
|
|
|
|
var character = (Character*)gameObject;
|
|
if (character == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (character->CompanionOwnerId != 0)
|
|
{
|
|
return character->CompanionOwnerId;
|
|
}
|
|
|
|
var parent = character->GetParentCharacter();
|
|
return parent != null ? parent->EntityId : 0;
|
|
}
|
|
|
|
public async Task<IPlayerCharacter> GetPlayerCharacterAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetPlayerCharacter).ConfigureAwait(false);
|
|
}
|
|
|
|
public IPlayerCharacter GetPlayerCharacter()
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable.LocalPlayer!;
|
|
}
|
|
|
|
public IntPtr GetPlayerCharacterFromCachedTableByIdent(string characterName)
|
|
{
|
|
if (_actorObjectService.TryGetValidatedActorByHash(characterName, out var actor))
|
|
return actor.Address;
|
|
return IntPtr.Zero;
|
|
}
|
|
|
|
public string GetPlayerName()
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable.LocalPlayer?.Name.ToString() ?? "--";
|
|
}
|
|
|
|
public async Task<string> GetPlayerNameAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetPlayerName).ConfigureAwait(false);
|
|
}
|
|
|
|
public async Task<ulong> GetCIDAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetCID).ConfigureAwait(false);
|
|
}
|
|
|
|
public unsafe ulong GetCID()
|
|
{
|
|
EnsureIsOnFramework();
|
|
var playerChar = GetPlayerCharacter();
|
|
return ((BattleChara*)playerChar.Address)->Character.ContentId;
|
|
}
|
|
|
|
public async Task<string> GetPlayerNameHashedAsync()
|
|
{
|
|
return await RunOnFrameworkThread(() => _cid.Value.ToString().GetHash256()).ConfigureAwait(false);
|
|
}
|
|
|
|
public static unsafe bool TryGetHashedCID(IPlayerCharacter? playerCharacter, out string hashedCid)
|
|
{
|
|
hashedCid = string.Empty;
|
|
if (playerCharacter == null)
|
|
return false;
|
|
|
|
var address = playerCharacter.Address;
|
|
if (address == nint.Zero)
|
|
return false;
|
|
|
|
var cid = ((BattleChara*)address)->Character.ContentId;
|
|
if (cid == 0)
|
|
return false;
|
|
|
|
hashedCid = cid.ToString().GetHash256();
|
|
return true;
|
|
}
|
|
|
|
public unsafe static string GetHashedCIDFromPlayerPointer(nint ptr)
|
|
{
|
|
return ((BattleChara*)ptr)->Character.ContentId.ToString().GetHash256();
|
|
}
|
|
|
|
public IntPtr GetPlayerPtr()
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable.LocalPlayer?.Address ?? IntPtr.Zero;
|
|
}
|
|
|
|
public async Task<IntPtr> GetPlayerPointerAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetPlayerPtr).ConfigureAwait(false);
|
|
}
|
|
|
|
public uint GetHomeWorldId()
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable.LocalPlayer?.HomeWorld.RowId ?? 0;
|
|
}
|
|
|
|
public uint GetWorldId()
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable.LocalPlayer!.CurrentWorld.RowId;
|
|
}
|
|
|
|
public unsafe LocationInfo GetMapData()
|
|
{
|
|
EnsureIsOnFramework();
|
|
var agentMap = AgentMap.Instance();
|
|
var houseMan = HousingManager.Instance();
|
|
uint serverId = 0;
|
|
if (_objectTable.LocalPlayer == null) serverId = 0;
|
|
else serverId = _objectTable.LocalPlayer.CurrentWorld.RowId;
|
|
uint mapId = agentMap == null ? 0 : agentMap->CurrentMapId;
|
|
uint territoryId = agentMap == null ? 0 : agentMap->CurrentTerritoryId;
|
|
uint divisionId = houseMan == null ? 0 : (uint)(houseMan->GetCurrentDivision());
|
|
uint wardId = houseMan == null ? 0 : (uint)(houseMan->GetCurrentWard() + 1);
|
|
uint houseId = 0;
|
|
var tempHouseId = houseMan == null ? 0 : (houseMan->GetCurrentPlot());
|
|
if (!houseMan->IsInside()) tempHouseId = 0;
|
|
if (tempHouseId < -1)
|
|
{
|
|
divisionId = tempHouseId == -127 ? 2 : (uint)1;
|
|
tempHouseId = 100;
|
|
}
|
|
if (tempHouseId == -1) tempHouseId = 0;
|
|
houseId = (uint)tempHouseId;
|
|
if (houseId != 0)
|
|
{
|
|
territoryId = HousingManager.GetOriginalHouseTerritoryTypeId();
|
|
}
|
|
uint roomId = houseMan == null ? 0 : (uint)(houseMan->GetCurrentRoom());
|
|
|
|
return new LocationInfo()
|
|
{
|
|
ServerId = serverId,
|
|
MapId = mapId,
|
|
TerritoryId = territoryId,
|
|
DivisionId = divisionId,
|
|
WardId = wardId,
|
|
HouseId = houseId,
|
|
RoomId = roomId
|
|
};
|
|
}
|
|
|
|
public unsafe void SetMarkerAndOpenMap(Vector3 position, Map map)
|
|
{
|
|
EnsureIsOnFramework();
|
|
var agentMap = AgentMap.Instance();
|
|
if (agentMap == null) return;
|
|
agentMap->OpenMapByMapId(map.RowId);
|
|
agentMap->SetFlagMapMarker(map.TerritoryType.RowId, map.RowId, position);
|
|
}
|
|
|
|
public async Task<LocationInfo> GetMapDataAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetMapData).ConfigureAwait(false);
|
|
}
|
|
|
|
public async Task<uint> GetWorldIdAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetWorldId).ConfigureAwait(false);
|
|
}
|
|
|
|
public async Task<uint> GetHomeWorldIdAsync()
|
|
{
|
|
return await RunOnFrameworkThread(GetHomeWorldId).ConfigureAwait(false);
|
|
}
|
|
|
|
public unsafe bool IsGameObjectPresent(IntPtr key)
|
|
{
|
|
return _objectTable.Any(f => f.Address == key);
|
|
}
|
|
|
|
public bool IsObjectPresent(IGameObject? obj)
|
|
{
|
|
EnsureIsOnFramework();
|
|
return obj != null && obj.IsValid();
|
|
}
|
|
|
|
public async Task<bool> IsObjectPresentAsync(IGameObject? obj)
|
|
{
|
|
return await RunOnFrameworkThread(() => IsObjectPresent(obj)).ConfigureAwait(false);
|
|
}
|
|
|
|
public IPlayerCharacter? GetPlayerByNameAndWorld(string name, ushort homeWorldId)
|
|
{
|
|
EnsureIsOnFramework();
|
|
return _objectTable
|
|
.OfType<IPlayerCharacter>()
|
|
.FirstOrDefault(p =>
|
|
string.Equals(p.Name.TextValue, name, StringComparison.Ordinal) &&
|
|
p.HomeWorld.RowId == homeWorldId);
|
|
}
|
|
|
|
public async Task RunOnFrameworkThread(System.Action act, [CallerMemberName] string callerMember = "", [CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = 0)
|
|
{
|
|
var fileName = Path.GetFileNameWithoutExtension(callerFilePath);
|
|
await _performanceCollector.LogPerformance(this, $"RunOnFramework:Act/{fileName}>{callerMember}:{callerLineNumber}", async () =>
|
|
{
|
|
if (_framework.IsInFrameworkUpdateThread)
|
|
{
|
|
act();
|
|
return;
|
|
}
|
|
|
|
await _framework.RunOnFrameworkThread(act).ConfigureAwait(false);
|
|
}).ConfigureAwait(false);
|
|
}
|
|
|
|
public async Task<T> RunOnFrameworkThread<T>(Func<T> func, [CallerMemberName] string callerMember = "", [CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = 0)
|
|
{
|
|
var fileName = Path.GetFileNameWithoutExtension(callerFilePath);
|
|
return await _performanceCollector.LogPerformance(this, $"RunOnFramework:Func<{typeof(T)}>/{fileName}>{callerMember}:{callerLineNumber}", async () =>
|
|
{
|
|
if (_framework.IsInFrameworkUpdateThread)
|
|
{
|
|
return func.Invoke();
|
|
}
|
|
|
|
return await _framework.RunOnFrameworkThread(func).ConfigureAwait(false);
|
|
}).ConfigureAwait(false);
|
|
}
|
|
|
|
public Task StartAsync(CancellationToken cancellationToken)
|
|
{
|
|
_logger.LogInformation("Starting DalamudUtilService");
|
|
_framework.Update += FrameworkOnUpdate;
|
|
if (IsLoggedIn)
|
|
{
|
|
_classJobId = _objectTable.LocalPlayer!.ClassJob.RowId;
|
|
}
|
|
|
|
_logger.LogInformation("Started DalamudUtilService");
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task StopAsync(CancellationToken cancellationToken)
|
|
{
|
|
_logger.LogTrace("Stopping {type}", GetType());
|
|
|
|
Mediator.UnsubscribeAll(this);
|
|
_framework.Update -= FrameworkOnUpdate;
|
|
if (_FocusPairIdent.HasValue)
|
|
{
|
|
if (_framework.IsInFrameworkUpdateThread)
|
|
{
|
|
ReleaseFocusUnsafe();
|
|
}
|
|
else
|
|
{
|
|
_ = RunOnFrameworkThread(ReleaseFocusUnsafe);
|
|
}
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public async Task WaitWhileCharacterIsDrawing(ILogger logger, GameObjectHandler handler, Guid redrawId, int timeOut = 5000, CancellationToken? ct = null)
|
|
{
|
|
if (!_clientState.IsLoggedIn) return;
|
|
|
|
if (ct == null)
|
|
ct = CancellationToken.None;
|
|
|
|
const int tick = 250;
|
|
int curWaitTime = 0;
|
|
try
|
|
{
|
|
logger.LogTrace("[{redrawId}] Starting wait for {handler} to draw", redrawId, handler);
|
|
await Task.Delay(tick, ct.Value).ConfigureAwait(true);
|
|
curWaitTime += tick;
|
|
|
|
while ((!ct.Value.IsCancellationRequested)
|
|
&& curWaitTime < timeOut
|
|
&& await handler.IsBeingDrawnRunOnFrameworkAsync().ConfigureAwait(false)) // 0b100000000000 is "still rendering" or something
|
|
{
|
|
logger.LogTrace("[{redrawId}] Waiting for {handler} to finish drawing", redrawId, handler);
|
|
curWaitTime += tick;
|
|
await Task.Delay(tick, ct.Value).ConfigureAwait(true);
|
|
}
|
|
|
|
logger.LogTrace("[{redrawId}] Finished drawing after {curWaitTime}ms", redrawId, curWaitTime);
|
|
}
|
|
catch (AccessViolationException ex)
|
|
{
|
|
logger.LogWarning(ex, "Error accessing {handler}, object does not exist anymore?", handler);
|
|
}
|
|
}
|
|
|
|
public unsafe void WaitWhileGposeCharacterIsDrawing(IntPtr characterAddress, int timeOut = 5000)
|
|
{
|
|
Thread.Sleep(500);
|
|
var obj = (GameObject*)characterAddress;
|
|
const int tick = 250;
|
|
int curWaitTime = 0;
|
|
_logger.LogTrace("RenderFlags: {flags}", obj->RenderFlags.ToString("X"));
|
|
while (obj->RenderFlags != 0x00 && curWaitTime < timeOut)
|
|
{
|
|
_logger.LogTrace($"Waiting for gpose actor to finish drawing");
|
|
curWaitTime += tick;
|
|
Thread.Sleep(tick);
|
|
}
|
|
Thread.Sleep(tick * 2);
|
|
}
|
|
|
|
public Vector2 WorldToScreen(IGameObject? obj)
|
|
{
|
|
if (obj == null) return Vector2.Zero;
|
|
return _gameGui.WorldToScreen(obj.Position, out var screenPos) ? screenPos : Vector2.Zero;
|
|
}
|
|
|
|
internal (string Name, nint Address) FindPlayerByNameHash(string ident)
|
|
{
|
|
if (_actorObjectService.TryGetValidatedActorByHash(ident, out var descriptor))
|
|
{
|
|
return (descriptor.Name, descriptor.Address);
|
|
}
|
|
|
|
return default;
|
|
}
|
|
|
|
public string? GetWorldNameFromPlayerAddress(nint address)
|
|
{
|
|
if (address == nint.Zero) return null;
|
|
|
|
EnsureIsOnFramework();
|
|
var playerCharacter = _objectTable.OfType<IPlayerCharacter>().FirstOrDefault(p => p.Address == address);
|
|
if (playerCharacter == null) return null;
|
|
|
|
var worldId = (ushort)playerCharacter.HomeWorld.RowId;
|
|
return WorldData.Value.TryGetValue(worldId, out var worldName) ? worldName : null;
|
|
}
|
|
|
|
private unsafe void CheckCharacterForDrawing(nint address, string characterName)
|
|
{
|
|
var gameObj = (GameObject*)address;
|
|
var drawObj = gameObj->DrawObject;
|
|
bool isDrawing = false;
|
|
bool isDrawingChanged = false;
|
|
if ((nint)drawObj != IntPtr.Zero)
|
|
{
|
|
isDrawing = (ushort)gameObj->RenderFlags == 0b100000000000;
|
|
if (!isDrawing)
|
|
{
|
|
isDrawing = ((CharacterBase*)drawObj)->HasModelInSlotLoaded != 0;
|
|
if (!isDrawing)
|
|
{
|
|
isDrawing = ((CharacterBase*)drawObj)->HasModelFilesInSlotLoaded != 0;
|
|
if (isDrawing && !string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
|
|
&& !string.Equals(_lastGlobalBlockReason, "HasModelFilesInSlotLoaded", StringComparison.Ordinal))
|
|
{
|
|
_lastGlobalBlockPlayer = characterName;
|
|
_lastGlobalBlockReason = "HasModelFilesInSlotLoaded";
|
|
isDrawingChanged = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
|
|
&& !string.Equals(_lastGlobalBlockReason, "HasModelInSlotLoaded", StringComparison.Ordinal))
|
|
{
|
|
_lastGlobalBlockPlayer = characterName;
|
|
_lastGlobalBlockReason = "HasModelInSlotLoaded";
|
|
isDrawingChanged = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
|
|
&& !string.Equals(_lastGlobalBlockReason, "RenderFlags", StringComparison.Ordinal))
|
|
{
|
|
_lastGlobalBlockPlayer = characterName;
|
|
_lastGlobalBlockReason = "RenderFlags";
|
|
isDrawingChanged = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isDrawingChanged)
|
|
{
|
|
_logger.LogTrace("Global draw block: START => {name} ({reason})", characterName, _lastGlobalBlockReason);
|
|
}
|
|
|
|
IsAnythingDrawing |= isDrawing;
|
|
}
|
|
|
|
private void FrameworkOnUpdate(IFramework framework)
|
|
{
|
|
_performanceCollector.LogPerformance(this, $"FrameworkOnUpdate", FrameworkOnUpdateInternal);
|
|
}
|
|
|
|
private unsafe void FrameworkOnUpdateInternal()
|
|
{
|
|
if ((_objectTable.LocalPlayer?.IsDead ?? false) && _condition[ConditionFlag.BoundByDuty])
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool isNormalFrameworkUpdate = DateTime.UtcNow < _delayedFrameworkUpdateCheck.AddSeconds(1);
|
|
|
|
_performanceCollector.LogPerformance(this, $"FrameworkOnUpdateInternal+{(isNormalFrameworkUpdate ? "Regular" : "Delayed")}", () =>
|
|
{
|
|
IsAnythingDrawing = false;
|
|
_performanceCollector.LogPerformance(this, $"TrackedActorsToState",
|
|
() =>
|
|
{
|
|
_actorObjectService.RefreshTrackedActors();
|
|
|
|
var playerDescriptors = _actorObjectService.PlayerCharacterDescriptors;
|
|
for (var i = 0; i < playerDescriptors.Count; i++)
|
|
{
|
|
var actor = playerDescriptors[i];
|
|
|
|
var playerAddress = actor.Address;
|
|
if (playerAddress == nint.Zero)
|
|
continue;
|
|
|
|
if (actor.ObjectIndex >= 200)
|
|
continue;
|
|
|
|
if (_blockedCharacterHandler.IsCharacterBlocked(playerAddress, out bool firstTime) && firstTime)
|
|
{
|
|
_logger.LogTrace("Skipping character {addr}, blocked/muted", playerAddress.ToString("X"));
|
|
continue;
|
|
}
|
|
|
|
if (!IsAnythingDrawing)
|
|
{
|
|
var gameObj = (GameObject*)playerAddress;
|
|
var currentName = gameObj != null ? gameObj->NameString ?? string.Empty : string.Empty;
|
|
var charaName = string.IsNullOrEmpty(currentName) ? actor.Name : currentName;
|
|
CheckCharacterForDrawing(playerAddress, charaName);
|
|
if (IsAnythingDrawing)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
if (!IsAnythingDrawing && !string.IsNullOrEmpty(_lastGlobalBlockPlayer))
|
|
{
|
|
_logger.LogTrace("Global draw block: END => {name}", _lastGlobalBlockPlayer);
|
|
_lastGlobalBlockPlayer = string.Empty;
|
|
_lastGlobalBlockReason = string.Empty;
|
|
}
|
|
|
|
// Checks on conditions
|
|
var shouldBeInGpose = _clientState.IsGPosing;
|
|
var shouldBeInCombat = _condition[ConditionFlag.InCombat] && !IsInInstance && _playerPerformanceConfigService.Current.PauseInCombat;
|
|
var shouldBePerforming = _condition[ConditionFlag.Performing] && _playerPerformanceConfigService.Current.PauseWhilePerforming;
|
|
var shouldBeInInstance = _condition[ConditionFlag.BoundByDuty] && _playerPerformanceConfigService.Current.PauseInInstanceDuty;
|
|
var shouldBeInCutscene = _condition[ConditionFlag.WatchingCutscene];
|
|
|
|
// Gpose
|
|
HandleStateTransition(() => IsInGpose, v => IsInGpose = v, shouldBeInGpose, "Gpose",
|
|
onEnter: () =>
|
|
{
|
|
Mediator.Publish(new GposeStartMessage());
|
|
},
|
|
onExit: () =>
|
|
{
|
|
Mediator.Publish(new GposeEndMessage());
|
|
});
|
|
|
|
// Combat
|
|
HandleStateTransition(() => IsInCombat, v => IsInCombat = v, shouldBeInCombat, "Combat",
|
|
onEnter: () =>
|
|
{
|
|
Mediator.Publish(new CombatStartMessage());
|
|
Mediator.Publish(new HaltScanMessage(nameof(IsInCombat)));
|
|
},
|
|
onExit: () =>
|
|
{
|
|
Mediator.Publish(new CombatEndMessage());
|
|
Mediator.Publish(new ResumeScanMessage(nameof(IsInCombat)));
|
|
});
|
|
|
|
// Performance
|
|
HandleStateTransition(() => IsPerforming, v => IsPerforming = v, shouldBePerforming, "Performance",
|
|
onEnter: () =>
|
|
{
|
|
Mediator.Publish(new PerformanceStartMessage());
|
|
Mediator.Publish(new HaltScanMessage(nameof(IsPerforming)));
|
|
},
|
|
onExit: () =>
|
|
{
|
|
Mediator.Publish(new PerformanceEndMessage());
|
|
Mediator.Publish(new ResumeScanMessage(nameof(IsPerforming)));
|
|
});
|
|
|
|
// Instance / Duty
|
|
HandleStateTransition(() => IsInInstance, v => IsInInstance = v, shouldBeInInstance, "Instance",
|
|
onEnter: () =>
|
|
{
|
|
Mediator.Publish(new InstanceOrDutyStartMessage());
|
|
Mediator.Publish(new HaltScanMessage(nameof(IsInInstance)));
|
|
},
|
|
onExit: () =>
|
|
{
|
|
Mediator.Publish(new InstanceOrDutyEndMessage());
|
|
Mediator.Publish(new ResumeScanMessage(nameof(IsInInstance)));
|
|
});
|
|
|
|
// Cutscene
|
|
HandleStateTransition(() => IsInCutscene,v => IsInCutscene = v, shouldBeInCutscene, "Cutscene",
|
|
onEnter: () =>
|
|
{
|
|
Mediator.Publish(new CutsceneStartMessage());
|
|
Mediator.Publish(new HaltScanMessage(nameof(IsInCutscene)));
|
|
},
|
|
onExit: () =>
|
|
{
|
|
Mediator.Publish(new CutsceneEndMessage());
|
|
Mediator.Publish(new ResumeScanMessage(nameof(IsInCutscene)));
|
|
});
|
|
|
|
if (IsInCutscene)
|
|
{
|
|
Mediator.Publish(new CutsceneFrameworkUpdateMessage());
|
|
return;
|
|
}
|
|
|
|
if (_condition[ConditionFlag.BetweenAreas] || _condition[ConditionFlag.BetweenAreas51])
|
|
{
|
|
var zone = _clientState.TerritoryType;
|
|
if (_lastZone != zone)
|
|
{
|
|
_lastZone = zone;
|
|
if (!_sentBetweenAreas)
|
|
{
|
|
_logger.LogDebug("Zone switch start");
|
|
_sentBetweenAreas = true;
|
|
Mediator.Publish(new ZoneSwitchStartMessage());
|
|
Mediator.Publish(new HaltScanMessage(nameof(ConditionFlag.BetweenAreas)));
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (_sentBetweenAreas)
|
|
{
|
|
_logger.LogDebug("Zone switch end");
|
|
_sentBetweenAreas = false;
|
|
Mediator.Publish(new ZoneSwitchEndMessage());
|
|
Mediator.Publish(new ResumeScanMessage(nameof(ConditionFlag.BetweenAreas)));
|
|
}
|
|
|
|
var localPlayer = _objectTable.LocalPlayer;
|
|
if (localPlayer != null)
|
|
{
|
|
_classJobId = localPlayer.ClassJob.RowId;
|
|
|
|
var currentWorldId = (ushort)localPlayer.CurrentWorld.RowId;
|
|
if (currentWorldId != _lastWorldId)
|
|
{
|
|
var previousWorldId = _lastWorldId;
|
|
_lastWorldId = currentWorldId;
|
|
Mediator.Publish(new WorldChangedMessage(previousWorldId, currentWorldId));
|
|
}
|
|
}
|
|
else if (_lastWorldId != 0)
|
|
{
|
|
_lastWorldId = 0;
|
|
}
|
|
|
|
if (!IsInCombat || !IsPerforming || !IsInInstance)
|
|
Mediator.Publish(new FrameworkUpdateMessage());
|
|
|
|
Mediator.Publish(new PriorityFrameworkUpdateMessage());
|
|
|
|
if (isNormalFrameworkUpdate)
|
|
return;
|
|
|
|
if (localPlayer != null && !IsLoggedIn)
|
|
{
|
|
_logger.LogDebug("Logged in");
|
|
IsLoggedIn = true;
|
|
_lastZone = _clientState.TerritoryType;
|
|
_lastWorldId = (ushort)localPlayer.CurrentWorld.RowId;
|
|
_cid = RebuildCID();
|
|
Mediator.Publish(new DalamudLoginMessage());
|
|
}
|
|
else if (localPlayer == null && IsLoggedIn)
|
|
{
|
|
_logger.LogDebug("Logged out");
|
|
IsLoggedIn = false;
|
|
_lastWorldId = 0;
|
|
Mediator.Publish(new DalamudLogoutMessage());
|
|
}
|
|
|
|
if (_gameConfig != null
|
|
&& _gameConfig.TryGet(Dalamud.Game.Config.SystemConfigOption.LodType_DX11, out bool lodEnabled))
|
|
{
|
|
IsLodEnabled = lodEnabled;
|
|
}
|
|
|
|
if (IsInCombat || IsPerforming || IsInInstance)
|
|
Mediator.Publish(new FrameworkUpdateMessage());
|
|
|
|
Mediator.Publish(new DelayedFrameworkUpdateMessage());
|
|
|
|
_delayedFrameworkUpdateCheck = DateTime.UtcNow;
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handler for the transition of different states of game
|
|
/// </summary>
|
|
/// <param name="getState">Get state of condition</param>
|
|
/// <param name="setState">Set state of condition</param>
|
|
/// <param name="shouldBeActive">Correction of the state of the condition</param>
|
|
/// <param name="stateName">Condition name</param>
|
|
/// <param name="onEnter">Function for on entering the state</param>
|
|
/// <param name="onExit">Function for on leaving the state</param>
|
|
private void HandleStateTransition(Func<bool> getState, Action<bool> setState, bool shouldBeActive, string stateName, System.Action onEnter, System.Action onExit)
|
|
{
|
|
var isActive = getState();
|
|
|
|
if (shouldBeActive && !isActive)
|
|
{
|
|
_logger.LogDebug("{stateName} start", stateName);
|
|
setState(true);
|
|
onEnter();
|
|
}
|
|
else if (!shouldBeActive && isActive)
|
|
{
|
|
_logger.LogDebug("{stateName} end", stateName);
|
|
setState(false);
|
|
onExit();
|
|
}
|
|
}
|
|
}
|