426 lines
17 KiB
C#
426 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Numerics;
|
|
using System.Runtime.InteropServices;
|
|
using Dalamud.Game.ClientState.Conditions;
|
|
using Dalamud.Game.ClientState.Objects.SubKinds;
|
|
using Dalamud.Game.ClientState.Objects.Types;
|
|
using Dalamud.Game.Text.SeStringHandling;
|
|
using Dalamud.Plugin.Services;
|
|
using LLib;
|
|
using Lumina.Excel.Sheets;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Logging;
|
|
using Questionable.Controller.Steps.Common;
|
|
using Questionable.Functions;
|
|
using Questionable.Model;
|
|
using Questionable.Model.Questing;
|
|
using SmartNav.Data;
|
|
using SmartNav.Model;
|
|
using SmartNav.Model.Converter;
|
|
|
|
namespace Questionable.Controller.Steps.Movement;
|
|
|
|
internal sealed class MoveExecutor : TaskExecutor<MoveTask>, IToastAware, ITaskExecutor
|
|
{
|
|
private const float DescendDrop = 100f;
|
|
|
|
private readonly string _cannotExecuteAtThisTime;
|
|
|
|
private readonly MovementController _movementController;
|
|
|
|
private readonly GameFunctions _gameFunctions;
|
|
|
|
private readonly ILogger<MoveExecutor> _logger;
|
|
|
|
private readonly IClientState _clientState;
|
|
|
|
private readonly IObjectTable _objectTable;
|
|
|
|
private readonly ICondition _condition;
|
|
|
|
private readonly Questionable.Controller.Steps.Common.Mount.MountEvaluator _mountEvaluator;
|
|
|
|
private readonly IServiceProvider _serviceProvider;
|
|
|
|
private readonly AetheryteData _aetheryteData;
|
|
|
|
private readonly Configuration _configuration;
|
|
|
|
private System.Action? _startAction;
|
|
|
|
private Vector3 _destination;
|
|
|
|
private bool _canRestart;
|
|
|
|
private bool _descendAttempted;
|
|
|
|
private bool _adjustedToObject;
|
|
|
|
private (Questionable.Controller.Steps.Common.Mount.MountExecutor Executor, Questionable.Controller.Steps.Common.Mount.MountTask Task)? _mountBeforeMovement;
|
|
|
|
private (Questionable.Controller.Steps.Common.Mount.UnmountExecutor Executor, Questionable.Controller.Steps.Common.Mount.UnmountTask Task)? _unmountBeforeMovement;
|
|
|
|
private (Questionable.Controller.Steps.Common.Mount.MountExecutor Executor, Questionable.Controller.Steps.Common.Mount.MountTask Task)? _mountDuringMovement;
|
|
|
|
public MoveExecutor(MovementController movementController, GameFunctions gameFunctions, AetheryteData aetheryteData, Configuration configuration, ILogger<MoveExecutor> logger, IClientState clientState, IObjectTable objectTable, ICondition condition, IDataManager dataManager, Questionable.Controller.Steps.Common.Mount.MountEvaluator mountEvaluator, IServiceProvider serviceProvider)
|
|
{
|
|
_movementController = movementController;
|
|
_gameFunctions = gameFunctions;
|
|
_aetheryteData = aetheryteData;
|
|
_configuration = configuration;
|
|
_logger = logger;
|
|
_clientState = clientState;
|
|
_objectTable = objectTable;
|
|
_condition = condition;
|
|
_serviceProvider = serviceProvider;
|
|
_mountEvaluator = mountEvaluator;
|
|
_cannotExecuteAtThisTime = dataManager.GetString(579u, (LogMessage x) => x.Text);
|
|
}
|
|
|
|
private void PrepareMovementIfNeeded()
|
|
{
|
|
if (!_gameFunctions.IsFlyingUnlocked(base.Task.TerritoryId))
|
|
{
|
|
base.Task = base.Task with
|
|
{
|
|
Fly = false,
|
|
Land = false
|
|
};
|
|
}
|
|
if (!base.Task.DisableNavmesh)
|
|
{
|
|
_startAction = delegate
|
|
{
|
|
_movementController.NavigateTo(EMovementType.Quest, base.Task.DataId, _destination, base.Task.Fly, base.Task.Sprint ?? (!_mountDuringMovement.HasValue), base.Task.StopDistance, base.Task.IgnoreDistanceToObject ? new float?(float.MaxValue) : ((float?)null), base.Task.Land, base.Task.SmartNavRouted);
|
|
};
|
|
return;
|
|
}
|
|
_startAction = delegate
|
|
{
|
|
MovementController movementController = _movementController;
|
|
uint? dataId = base.Task.DataId;
|
|
int num = 1;
|
|
List<Vector3> list = new List<Vector3>(num);
|
|
CollectionsMarshal.SetCount(list, num);
|
|
CollectionsMarshal.AsSpan(list)[0] = _destination;
|
|
movementController.NavigateTo(EMovementType.Quest, dataId, list, base.Task.Fly, base.Task.Sprint ?? (!_mountDuringMovement.HasValue), base.Task.StopDistance, base.Task.IgnoreDistanceToObject ? new float?(float.MaxValue) : ((float?)null), base.Task.Land);
|
|
};
|
|
}
|
|
|
|
protected override bool Start()
|
|
{
|
|
if (_clientState.TerritoryType != base.Task.TerritoryId)
|
|
{
|
|
_logger.LogDebug("Skipping movement - already in territory {Current} (task expects {Expected})", _clientState.TerritoryType, base.Task.TerritoryId);
|
|
return false;
|
|
}
|
|
_canRestart = base.Task.RestartNavigation;
|
|
_destination = base.Task.Destination;
|
|
if (_aetheryteData.Locations.Any((KeyValuePair<EAetheryteLocation, Vector3> kvp) => AetheryteConverter.IsLargeAetheryte(kvp.Key) && Vector3.Distance(kvp.Value, _destination) < 1f))
|
|
{
|
|
float num = 7f;
|
|
if ((base.Task.StopDistance ?? 3f) < num)
|
|
{
|
|
base.Task = base.Task with
|
|
{
|
|
StopDistance = num
|
|
};
|
|
}
|
|
}
|
|
float num2 = base.Task.StopDistance ?? 3f;
|
|
Vector3? vector = _objectTable.LocalPlayer?.Position;
|
|
float num3 = ((!vector.HasValue) ? float.MaxValue : Vector3.Distance(vector.Value, _destination));
|
|
if (num3 > num2)
|
|
{
|
|
PrepareMovementIfNeeded();
|
|
}
|
|
if (base.Task.MountRequired)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.MountTask mountTask = new Questionable.Controller.Steps.Common.Mount.MountTask(base.Task.TerritoryId, Questionable.Controller.Steps.Common.Mount.EMountIf.Always);
|
|
_mountBeforeMovement = (_serviceProvider.GetRequiredService<Questionable.Controller.Steps.Common.Mount.MountExecutor>(), mountTask);
|
|
if (!_mountBeforeMovement.Value.Executor.Start(mountTask))
|
|
{
|
|
_mountBeforeMovement = null;
|
|
}
|
|
}
|
|
else if (base.Task.DismountRequired)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.UnmountTask unmountTask = new Questionable.Controller.Steps.Common.Mount.UnmountTask();
|
|
_unmountBeforeMovement = (_serviceProvider.GetRequiredService<Questionable.Controller.Steps.Common.Mount.UnmountExecutor>(), unmountTask);
|
|
if (!_unmountBeforeMovement.Value.Executor.Start(unmountTask))
|
|
{
|
|
_unmountBeforeMovement = null;
|
|
}
|
|
}
|
|
else if (base.Task.Mount == true)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.MountTask mountTask2 = new Questionable.Controller.Steps.Common.Mount.MountTask(base.Task.TerritoryId, Questionable.Controller.Steps.Common.Mount.EMountIf.Always);
|
|
_mountBeforeMovement = (_serviceProvider.GetRequiredService<Questionable.Controller.Steps.Common.Mount.MountExecutor>(), mountTask2);
|
|
if (!_mountBeforeMovement.Value.Executor.Start(mountTask2))
|
|
{
|
|
_mountBeforeMovement = null;
|
|
}
|
|
}
|
|
else if (base.Task.Mount == false)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.UnmountTask unmountTask2 = new Questionable.Controller.Steps.Common.Mount.UnmountTask();
|
|
_unmountBeforeMovement = (_serviceProvider.GetRequiredService<Questionable.Controller.Steps.Common.Mount.UnmountExecutor>(), unmountTask2);
|
|
if (!_unmountBeforeMovement.Value.Executor.Start(unmountTask2))
|
|
{
|
|
_unmountBeforeMovement = null;
|
|
}
|
|
}
|
|
else if (!base.Task.DisableNavmesh)
|
|
{
|
|
bool flag = _gameFunctions.IsFlyingUnlocked(base.Task.TerritoryId);
|
|
if (!base.Task.SmartNavRouted && !base.Task.Fly && flag && num3 > _configuration.Navigation.MountFlyDistance)
|
|
{
|
|
base.Task = base.Task with
|
|
{
|
|
Fly = true,
|
|
Land = true
|
|
};
|
|
}
|
|
float num4 = (base.Task.Fly ? _configuration.Navigation.MountFlyDistance : _configuration.Navigation.MountGroundDistance);
|
|
Questionable.Controller.Steps.Common.Mount.EMountIf mountIf = ((!(num3 > num4)) ? Questionable.Controller.Steps.Common.Mount.EMountIf.AwayFromPosition : Questionable.Controller.Steps.Common.Mount.EMountIf.Always);
|
|
Questionable.Controller.Steps.Common.Mount.MountTask mountTask3 = new Questionable.Controller.Steps.Common.Mount.MountTask(base.Task.TerritoryId, mountIf, _destination);
|
|
long retryAtMs = 0L;
|
|
(Questionable.Controller.Steps.Common.Mount.MountExecutor, Questionable.Controller.Steps.Common.Mount.MountTask)? tuple;
|
|
if (!_condition[ConditionFlag.Mounted] && _mountEvaluator.EvaluateMountState(mountTask3, dryRun: true, ref retryAtMs) != Questionable.Controller.Steps.Common.Mount.MountResult.DontMount)
|
|
{
|
|
tuple = (_serviceProvider.GetRequiredService<Questionable.Controller.Steps.Common.Mount.MountExecutor>(), mountTask3);
|
|
tuple.Value.Item1.Start(mountTask3);
|
|
}
|
|
else
|
|
{
|
|
tuple = null;
|
|
}
|
|
if (base.Task.Fly)
|
|
{
|
|
_mountBeforeMovement = tuple;
|
|
if (!tuple.HasValue && !_condition[ConditionFlag.Mounted])
|
|
{
|
|
_logger.LogDebug("Not mounting for short flight movement; navigating on foot instead");
|
|
base.Task = base.Task with
|
|
{
|
|
Fly = false,
|
|
Land = false
|
|
};
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_mountDuringMovement = tuple;
|
|
}
|
|
}
|
|
if (!_mountBeforeMovement.HasValue && !_unmountBeforeMovement.HasValue && _startAction != null)
|
|
{
|
|
_startAction();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override ETaskResult Update()
|
|
{
|
|
ETaskResult? eTaskResult = UpdateMountState();
|
|
if (eTaskResult.HasValue)
|
|
{
|
|
return eTaskResult.GetValueOrDefault();
|
|
}
|
|
if (_startAction == null)
|
|
{
|
|
return ETaskResult.TaskComplete;
|
|
}
|
|
if (_movementController.IsPathfinding || _movementController.IsPathRunning)
|
|
{
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
if (!_movementController.HasBeenMovingForAtLeast(2000))
|
|
{
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
IPlayerCharacter localPlayer = _objectTable.LocalPlayer;
|
|
float num = base.Task.StopDistance ?? 3f;
|
|
if (base.Task.Fly && base.Task.Land && _canRestart && localPlayer != null && _clientState.TerritoryType == base.Task.TerritoryId && Vector3.Distance(localPlayer.Position, _destination) > num)
|
|
{
|
|
if (_condition[ConditionFlag.InFlight])
|
|
{
|
|
if (_descendAttempted)
|
|
{
|
|
_logger.LogWarning("Still airborne after descending, treating as unreachable");
|
|
throw new MovementController.PathfindingFailedException("Still airborne after descending, cannot close gap on foot");
|
|
}
|
|
if (!_movementController.IsNavmeshReady)
|
|
{
|
|
_logger.LogDebug("Airborne outside stop distance, waiting for navmesh to descend");
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
Vector3 position = localPlayer.Position;
|
|
position.Y = localPlayer.Position.Y - 100f;
|
|
Vector3 vector = position;
|
|
_descendAttempted = true;
|
|
_logger.LogDebug("Outside stop distance but still airborne, descending to {Target}", vector.ToString("G", CultureInfo.InvariantCulture));
|
|
MovementController movementController = _movementController;
|
|
uint? dataId = base.Task.DataId;
|
|
int num2 = 1;
|
|
List<Vector3> list = new List<Vector3>(num2);
|
|
CollectionsMarshal.SetCount(list, num2);
|
|
CollectionsMarshal.AsSpan(list)[0] = vector;
|
|
movementController.NavigateTo(EMovementType.Landing, dataId, list, fly: true, sprint: false, null);
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
_canRestart = false;
|
|
_logger.LogDebug("Landed outside stop distance, closing gap on foot");
|
|
MovementController movementController2 = _movementController;
|
|
uint? dataId2 = base.Task.DataId;
|
|
Vector3 destination = _destination;
|
|
float? stopDistance = base.Task.StopDistance;
|
|
bool smartNavRouted = base.Task.SmartNavRouted;
|
|
movementController2.NavigateTo(EMovementType.Quest, dataId2, destination, fly: false, sprint: false, stopDistance, null, land: false, smartNavRouted);
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
if (base.Task.DataId.HasValue && !_adjustedToObject && localPlayer != null && !_condition[ConditionFlag.InFlight] && _clientState.TerritoryType == base.Task.TerritoryId)
|
|
{
|
|
IGameObject gameObject = _gameFunctions.FindObjectByDataId(base.Task.DataId.Value, null, warnIfMissing: false);
|
|
if (gameObject != null)
|
|
{
|
|
float num3 = Vector3.Distance(localPlayer.Position, gameObject.Position);
|
|
if (num3 > num)
|
|
{
|
|
_adjustedToObject = true;
|
|
_logger.LogDebug("Adjusting to actual object position ({Distance:F1}y away)", num3);
|
|
_movementController.NavigateTo(EMovementType.Quest, base.Task.DataId, gameObject.Position, fly: false, sprint: false, base.Task.StopDistance);
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
}
|
|
}
|
|
if (_canRestart && localPlayer != null && Vector3.Distance(localPlayer.Position, _destination) > num + 5f)
|
|
{
|
|
_canRestart = false;
|
|
if (_clientState.TerritoryType == base.Task.TerritoryId)
|
|
{
|
|
_logger.LogInformation("Looks like movement was interrupted, re-attempting to move");
|
|
_startAction();
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
if (base.Task.AllowZoneTransition)
|
|
{
|
|
_logger.LogDebug("Zone transition during boundary crossing (now in {Current}, expected {Expected}), completing task", _clientState.TerritoryType, base.Task.TerritoryId);
|
|
return ETaskResult.TaskComplete;
|
|
}
|
|
_logger.LogWarning("Movement interrupted by zone transition (now in {Current}, task expected {Expected})", _clientState.TerritoryType, base.Task.TerritoryId);
|
|
throw new MovementController.PathfindingFailedException($"Zone transition during movement: now in territory {_clientState.TerritoryType}, expected {base.Task.TerritoryId}");
|
|
}
|
|
if (base.Task.SmartNavRouted && !_adjustedToObject && localPlayer != null && _clientState.TerritoryType == base.Task.TerritoryId && Vector3.Distance(localPlayer.Position, _destination) > num + 5f)
|
|
{
|
|
float num4 = Vector3.Distance(localPlayer.Position, _destination);
|
|
_logger.LogWarning("SmartNav movement ended {Distance:F1}y from target (stop distance {StopDistance:F1}y), treating as unreachable", num4, num);
|
|
throw new MovementController.PathfindingFailedException($"SmartNav movement ended {num4:F1}y from target (stop distance {num:F1}y)");
|
|
}
|
|
return ETaskResult.TaskComplete;
|
|
}
|
|
|
|
private ETaskResult? UpdateMountState()
|
|
{
|
|
(Questionable.Controller.Steps.Common.Mount.MountExecutor, Questionable.Controller.Steps.Common.Mount.MountTask)? mountBeforeMovement = _mountBeforeMovement;
|
|
if (mountBeforeMovement.HasValue)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.MountExecutor item = mountBeforeMovement.GetValueOrDefault().Item1;
|
|
if (item != null)
|
|
{
|
|
if (item.Update() == ETaskResult.TaskComplete)
|
|
{
|
|
_logger.LogDebug("MountBeforeMovement complete");
|
|
_mountBeforeMovement = null;
|
|
_startAction?.Invoke();
|
|
return null;
|
|
}
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
}
|
|
(Questionable.Controller.Steps.Common.Mount.UnmountExecutor, Questionable.Controller.Steps.Common.Mount.UnmountTask)? unmountBeforeMovement = _unmountBeforeMovement;
|
|
if (unmountBeforeMovement.HasValue)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.UnmountExecutor item2 = unmountBeforeMovement.GetValueOrDefault().Item1;
|
|
if (item2 != null)
|
|
{
|
|
if (item2.Update() == ETaskResult.TaskComplete)
|
|
{
|
|
_logger.LogDebug("UnmountBeforeMovement complete");
|
|
_unmountBeforeMovement = null;
|
|
_startAction?.Invoke();
|
|
return null;
|
|
}
|
|
return ETaskResult.StillRunning;
|
|
}
|
|
}
|
|
mountBeforeMovement = _mountDuringMovement;
|
|
if (mountBeforeMovement.HasValue)
|
|
{
|
|
(Questionable.Controller.Steps.Common.Mount.MountExecutor, Questionable.Controller.Steps.Common.Mount.MountTask) valueOrDefault = mountBeforeMovement.GetValueOrDefault();
|
|
var (mountExecutor, _) = valueOrDefault;
|
|
if (mountExecutor != null)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.MountTask item3 = valueOrDefault.Item2;
|
|
if ((object)item3 != null)
|
|
{
|
|
if (mountExecutor.Update() == ETaskResult.TaskComplete)
|
|
{
|
|
_logger.LogDebug("MountDuringMovement complete (mounted)");
|
|
_mountDuringMovement = null;
|
|
return null;
|
|
}
|
|
long retryAtMs = 0L;
|
|
if (_mountEvaluator.EvaluateMountState(item3, dryRun: true, ref retryAtMs) == Questionable.Controller.Steps.Common.Mount.MountResult.DontMount)
|
|
{
|
|
_logger.LogDebug("MountDuringMovement implicitly complete (shouldn't mount anymore)");
|
|
_mountDuringMovement = null;
|
|
return null;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public override bool WasInterrupted()
|
|
{
|
|
long retryAtMs = 0L;
|
|
if (base.Task.Fly && _condition[ConditionFlag.InCombat] && !_condition[ConditionFlag.Mounted])
|
|
{
|
|
(Questionable.Controller.Steps.Common.Mount.MountExecutor, Questionable.Controller.Steps.Common.Mount.MountTask)? mountBeforeMovement = _mountBeforeMovement;
|
|
if (mountBeforeMovement.HasValue)
|
|
{
|
|
Questionable.Controller.Steps.Common.Mount.MountTask item = mountBeforeMovement.GetValueOrDefault().Item2;
|
|
if ((object)item != null && _mountEvaluator.EvaluateMountState(item, dryRun: true, ref retryAtMs) == Questionable.Controller.Steps.Common.Mount.MountResult.WhenOutOfCombat)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return base.WasInterrupted();
|
|
}
|
|
|
|
public override bool ShouldInterruptOnDamage()
|
|
{
|
|
if (!_mountBeforeMovement.HasValue)
|
|
{
|
|
return ShouldResolveCombatBeforeNextInteraction();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool ShouldResolveCombatBeforeNextInteraction()
|
|
{
|
|
return base.Task.InteractionType == EInteractionType.Jump;
|
|
}
|
|
|
|
public bool OnErrorToast(SeString message)
|
|
{
|
|
return GameFunctions.GameStringEquals(_cannotExecuteAtThisTime, message.TextValue);
|
|
}
|
|
}
|