1317 lines
50 KiB
C#
1317 lines
50 KiB
C#
using System;
|
|
using AcDream.Core.Combat;
|
|
using AcDream.Core.Items;
|
|
using AcDream.Runtime.Gameplay;
|
|
|
|
namespace AcDream.App.UI;
|
|
|
|
/// <summary>Result of offering a primary click to active item-target mode.</summary>
|
|
public enum ItemPrimaryClickResult
|
|
{
|
|
NotActive,
|
|
ConsumedSuccess,
|
|
ConsumedRejected,
|
|
}
|
|
|
|
public readonly record struct PendingBackpackPlacement(
|
|
ulong Token,
|
|
uint ItemId,
|
|
uint ContainerId,
|
|
int Placement,
|
|
ClientObject? ItemIdentity);
|
|
|
|
/// <summary>
|
|
/// Shared retail item interaction orchestrator. UI widgets route item clicks,
|
|
/// target acquisition, and drag-out drops here instead of duplicating
|
|
/// ItemHolder::UseObject fragments in each panel.
|
|
/// </summary>
|
|
public sealed class ItemInteractionController : IDisposable
|
|
{
|
|
internal const string InventoryRequestBusyMessage =
|
|
"You can only move or use one item at a time";
|
|
private const long RetailDoubleClickMs = 500;
|
|
|
|
private readonly ClientObjectTable _objects;
|
|
private readonly Func<uint> _playerGuid;
|
|
private readonly Func<long> _nowMs;
|
|
private readonly Action<uint>? _sendUse;
|
|
private readonly Action<uint>? _sendExamine;
|
|
private readonly Action<uint, uint>? _sendUseWithTarget;
|
|
private readonly Action<uint, uint>? _sendWield;
|
|
private readonly Action<uint>? _sendDrop;
|
|
private readonly Action<uint, uint>? _sendSplitToWorld;
|
|
private readonly Action<uint, uint, int>? _sendPutItemInContainer;
|
|
private readonly Action<uint, uint, uint, uint>? _sendSplitToContainer;
|
|
private readonly Action<uint, uint, uint>? _sendGive;
|
|
private readonly Action<string>? _toast;
|
|
private readonly Func<bool> _readyForInventoryRequest;
|
|
private readonly Func<uint> _activeVendorId;
|
|
private readonly Func<uint> _groundObjectId;
|
|
private readonly Func<bool> _playerOnGround;
|
|
private readonly Func<bool> _inNonCombatMode;
|
|
private readonly Func<uint, bool> _isComponentPack;
|
|
private readonly Action<uint, uint, int>? _placeInBackpack;
|
|
private readonly Func<uint> _backpackContainerId;
|
|
private readonly Action<uint>? _requestExternalContainer;
|
|
private readonly Action<ItemPolicyAction>? _auxiliaryAction;
|
|
private readonly InteractionState _interactionState;
|
|
private readonly Func<uint> _selectedObjectId;
|
|
private readonly StackSplitQuantityState? _stackSplitQuantity;
|
|
private readonly Func<bool> _dragOnPlayerOpensSecureTrade;
|
|
private readonly Action<string>? _systemMessage;
|
|
private readonly AutoWieldController _autoWield;
|
|
private readonly Action<uint, ItemUseRequestReservation>? _requestUse;
|
|
private readonly RuntimeInteractionTransactionState _runtimeTransactions;
|
|
private readonly InventoryTransactionState _transactions;
|
|
|
|
private uint _consumedPrimaryClickTarget;
|
|
private long _consumedPrimaryClickMs = long.MinValue / 2;
|
|
private PendingBackpackPlacement? _pendingBackpackPlacement;
|
|
private bool _disposed;
|
|
|
|
public ItemInteractionController(
|
|
ClientObjectTable objects,
|
|
RuntimeInteractionTransactionState runtimeTransactions,
|
|
InteractionState interactionState,
|
|
Func<uint> playerGuid,
|
|
Action<uint>? sendUse,
|
|
Action<uint, uint>? sendUseWithTarget,
|
|
Action<uint, uint>? sendWield,
|
|
Action<uint>? sendDrop,
|
|
Action<uint>? sendExamine = null,
|
|
Func<long>? nowMs = null,
|
|
Action<string>? toast = null,
|
|
Func<bool>? readyForInventoryRequest = null,
|
|
Func<uint>? activeVendorId = null,
|
|
Func<uint>? groundObjectId = null,
|
|
Func<bool>? playerOnGround = null,
|
|
Func<bool>? inNonCombatMode = null,
|
|
Func<uint, bool>? isComponentPack = null,
|
|
Action<uint, uint, int>? placeInBackpack = null,
|
|
Func<uint>? backpackContainerId = null,
|
|
Action<ItemPolicyAction>? auxiliaryAction = null,
|
|
Action<uint, uint>? sendSplitToWorld = null,
|
|
Func<uint>? selectedObjectId = null,
|
|
StackSplitQuantityState? stackSplitQuantity = null,
|
|
Action<uint, uint, int>? sendPutItemInContainer = null,
|
|
Action<uint, uint, uint>? sendGive = null,
|
|
Func<bool>? dragOnPlayerOpensSecureTrade = null,
|
|
Action<string>? systemMessage = null,
|
|
Action<uint, uint, uint, uint>? sendSplitToContainer = null,
|
|
Action<uint>? requestExternalContainer = null,
|
|
CombatState? combatState = null,
|
|
Action<CombatMode>? sendChangeCombatMode = null,
|
|
Action<uint, ItemUseRequestReservation>? requestUse = null)
|
|
{
|
|
_objects = objects ?? throw new ArgumentNullException(nameof(objects));
|
|
_playerGuid = playerGuid ?? throw new ArgumentNullException(nameof(playerGuid));
|
|
_sendUse = sendUse;
|
|
_sendExamine = sendExamine;
|
|
_sendUseWithTarget = sendUseWithTarget;
|
|
_sendWield = sendWield;
|
|
_sendDrop = sendDrop;
|
|
_sendSplitToWorld = sendSplitToWorld;
|
|
_sendPutItemInContainer = sendPutItemInContainer;
|
|
_sendSplitToContainer = sendSplitToContainer;
|
|
_sendGive = sendGive;
|
|
_nowMs = nowMs ?? (() => Environment.TickCount64);
|
|
_toast = toast;
|
|
_readyForInventoryRequest = readyForInventoryRequest ?? (() => true);
|
|
_activeVendorId = activeVendorId ?? (() => 0u);
|
|
_groundObjectId = groundObjectId ?? (() => 0u);
|
|
_playerOnGround = playerOnGround ?? (() => true);
|
|
_inNonCombatMode = inNonCombatMode ?? (() => false);
|
|
_isComponentPack = isComponentPack ?? (_ => false);
|
|
_placeInBackpack = placeInBackpack;
|
|
_backpackContainerId = backpackContainerId ?? _playerGuid;
|
|
_requestExternalContainer = requestExternalContainer;
|
|
_auxiliaryAction = auxiliaryAction;
|
|
_selectedObjectId = selectedObjectId ?? (() => 0u);
|
|
_stackSplitQuantity = stackSplitQuantity;
|
|
_dragOnPlayerOpensSecureTrade = dragOnPlayerOpensSecureTrade ?? (() => true);
|
|
_systemMessage = systemMessage;
|
|
_requestUse = requestUse;
|
|
_interactionState = interactionState
|
|
?? throw new ArgumentNullException(nameof(interactionState));
|
|
_runtimeTransactions = runtimeTransactions
|
|
?? throw new ArgumentNullException(nameof(runtimeTransactions));
|
|
_transactions = _runtimeTransactions.Inventory;
|
|
if (!ReferenceEquals(_transactions.Objects, _objects))
|
|
{
|
|
throw new ArgumentException(
|
|
"The inventory transaction owner must borrow the controller's exact object table.",
|
|
nameof(runtimeTransactions));
|
|
}
|
|
_autoWield = new AutoWieldController(
|
|
_objects,
|
|
_playerGuid,
|
|
_sendWield,
|
|
sendPutItemInContainer,
|
|
_toast,
|
|
_systemMessage,
|
|
combatState,
|
|
sendChangeCombatMode);
|
|
_interactionState.Changed += OnInteractionModeChanged;
|
|
_transactions.StateChanged += OnTransactionStateChanged;
|
|
_transactions.RequestCompleted += OnInventoryRequestCompleted;
|
|
_transactions.ObjectTableCleared += OnInventoryObjectsCleared;
|
|
}
|
|
|
|
public event Action? StateChanged;
|
|
|
|
/// <summary>
|
|
/// Retail <c>CM_Item::SendNotice_ShowPendingInPlayer</c>: the inventory
|
|
/// panel inserts a waiting projection before the pickup request is sent.
|
|
/// The destination and placement are the same values sent on the wire.
|
|
/// </summary>
|
|
public event Action<PendingBackpackPlacement>? PendingBackpackPlacementRequested;
|
|
|
|
/// <summary>
|
|
/// Withdraws a waiting pickup projection when the approach is rejected or
|
|
/// cancelled before a request reaches the server.
|
|
/// </summary>
|
|
public event Action<PendingBackpackPlacement>? PendingBackpackPlacementCancelled;
|
|
|
|
/// <summary>
|
|
/// Resolves the exact waiting projection after an authoritative response.
|
|
/// The token prevents a late response for a recycled GUID from erasing a
|
|
/// newer incarnation's projection in the inventory panel.
|
|
/// </summary>
|
|
public event Action<PendingBackpackPlacement>? PendingBackpackPlacementResolved;
|
|
|
|
/// <summary>
|
|
/// Publishes the exact split-to-world request after its wire send has
|
|
/// succeeded. Retail <c>ACCWeenieObject::UIAttemptSplitTo3D @
|
|
/// 0x0058D850</c> retains the source class, selected amount, and request
|
|
/// time so the subsequently created ground stack can be recognized.
|
|
/// </summary>
|
|
public event Action<WorldDropDispatch>? WorldDropDispatched;
|
|
|
|
public uint PlayerGuid => _playerGuid();
|
|
|
|
public InteractionState InteractionState => _interactionState;
|
|
public RuntimeInteractionTransactionState RuntimeTransactions =>
|
|
_runtimeTransactions;
|
|
|
|
public int BusyCount => _transactions.BusyCount;
|
|
public uint CurrentAppraisalId =>
|
|
_runtimeTransactions.CurrentAppraisalId;
|
|
|
|
public bool CanMakeInventoryRequest =>
|
|
BaseCanMakeInventoryRequest && !_transactions.HasPendingRequest;
|
|
|
|
private bool BaseCanMakeInventoryRequest =>
|
|
_readyForInventoryRequest()
|
|
&& _transactions.BusyCount == 0
|
|
&& !_autoWield.IsBusy;
|
|
|
|
/// <summary>
|
|
/// Retail <c>ACCWeenieObject::IsPlayerReadyToMakeInventoryRequest</c>.
|
|
/// The destination ItemList's separate <c>m_pendingItem</c> rejection is
|
|
/// reported by <see cref="ReportPendingBackpackPlacementConflict"/>.
|
|
/// </summary>
|
|
public bool EnsureInventoryRequestReady()
|
|
{
|
|
if (CanMakeInventoryRequest)
|
|
return true;
|
|
|
|
if (_transactions.HasPendingRequest
|
|
|| _transactions.BusyCount != 0
|
|
|| _autoWield.IsBusy)
|
|
_systemMessage?.Invoke(InventoryRequestBusyMessage);
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retail <c>UIElement_ItemList::AcceptDragObject</c>'s local
|
|
/// <c>m_pendingItem</c> branch. This wording belongs only to the destination
|
|
/// list which already displays the waiting projection.
|
|
/// </summary>
|
|
public void ReportPendingBackpackPlacementConflict()
|
|
{
|
|
if (_pendingBackpackPlacement is not { } pending)
|
|
return;
|
|
string? itemName = _objects.Get(pending.ItemId)?.Name;
|
|
string name = string.IsNullOrWhiteSpace(itemName) ? "that item" : itemName;
|
|
_systemMessage?.Invoke($"Already attempting to place {name} here");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dispatches one retail inventory request. A provisional global
|
|
/// <c>ACCWeenieObject::prevRequest</c> owner closes callback reentrancy,
|
|
/// then becomes dispatched immediately after a successful wire send.
|
|
/// The callback returns false when it could not dispatch anything.
|
|
/// Retail: <c>RecordRequest @ 0x0058C220</c>, UIAttempt family
|
|
/// <c>0x0058D590..0x0058D850</c>.
|
|
/// </summary>
|
|
public bool TryDispatchInventoryRequest(
|
|
InventoryRequestKind kind,
|
|
uint itemId,
|
|
Func<bool> dispatch,
|
|
ulong reservationToken = 0u)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(dispatch);
|
|
if (itemId == 0u)
|
|
return false;
|
|
|
|
if (reservationToken != 0u)
|
|
{
|
|
try
|
|
{
|
|
return _transactions.TryDispatch(
|
|
kind,
|
|
itemId,
|
|
dispatch,
|
|
reservationToken);
|
|
}
|
|
catch
|
|
{
|
|
CancelPendingBackpackPlacement(itemId, reservationToken);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
if (!EnsureInventoryRequestReady())
|
|
return false;
|
|
return _transactions.TryDispatch(kind, itemId, dispatch);
|
|
}
|
|
|
|
public bool TryGetPendingInventoryRequest(out PendingInventoryRequest pending)
|
|
=> _transactions.TryGetPending(out pending);
|
|
|
|
/// <summary>
|
|
/// Increments retail's shared <c>ClientUISystem</c> busy reference after a
|
|
/// request issued by another retained controller has been sent. The
|
|
/// corresponding UseDone releases it. Retail spell casts complete through
|
|
/// Item__UseDone too; AttackDone belongs only to the combat attack owner.
|
|
/// </summary>
|
|
public void IncrementBusyCount()
|
|
=> _runtimeTransactions.IncrementBusyCount();
|
|
|
|
/// <summary>
|
|
/// Raised for retail confirmation/auxiliary actions whose retained panel is
|
|
/// owned outside this controller (PK/NPK altar, volatile rare, trade, salvage).
|
|
/// </summary>
|
|
public event Action<ItemPolicyAction>? PolicyActionRequested;
|
|
|
|
public uint PendingSourceItem
|
|
=> _interactionState.Current is { Kind: InteractionModeKind.UseItemOnTarget } mode
|
|
? mode.SourceObjectId
|
|
: 0u;
|
|
|
|
public bool IsTargetModeActive
|
|
=> _interactionState.Current.Kind == InteractionModeKind.UseItemOnTarget;
|
|
|
|
public bool IsAnyTargetModeActive
|
|
=> _interactionState.Current.Kind != InteractionModeKind.None;
|
|
|
|
public bool IsPendingSource(uint itemGuid)
|
|
=> itemGuid != 0 && itemGuid == PendingSourceItem;
|
|
|
|
/// <summary>
|
|
/// Retail <c>ACCWeenieObject::IsOwnedByPlayer</c> projection shared with
|
|
/// toolbar shortcut creation.
|
|
/// </summary>
|
|
public bool IsOwnedByPlayer(uint itemGuid)
|
|
=> _objects.IsOwnedByObject(itemGuid, _playerGuid());
|
|
|
|
public bool IsCurrentTargetCompatible(uint targetGuid)
|
|
{
|
|
if (!IsTargetModeActive || targetGuid == 0) return false;
|
|
|
|
var source = _objects.Get(PendingSourceItem);
|
|
return source?.Useability is not null
|
|
&& TargetCompatible(source, targetGuid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The single target-mode interception point for world and retained item
|
|
/// clicks. A rejected target is still consumed and must never fall through
|
|
/// to selection, container opening, or ordinary item activation.
|
|
/// </summary>
|
|
public ItemPrimaryClickResult OfferPrimaryClick(uint targetGuid)
|
|
{
|
|
InteractionModeKind mode = _interactionState.Current.Kind;
|
|
if (mode == InteractionModeKind.None)
|
|
{
|
|
long now = _nowMs();
|
|
if (targetGuid != 0
|
|
&& targetGuid == _consumedPrimaryClickTarget
|
|
&& now - _consumedPrimaryClickMs <= RetailDoubleClickMs)
|
|
return ItemPrimaryClickResult.ConsumedRejected;
|
|
_consumedPrimaryClickTarget = 0;
|
|
return ItemPrimaryClickResult.NotActive;
|
|
}
|
|
|
|
bool accepted;
|
|
switch (mode)
|
|
{
|
|
case InteractionModeKind.Use:
|
|
ClearTargetMode();
|
|
accepted = ActivateItem(targetGuid);
|
|
break;
|
|
case InteractionModeKind.Examine:
|
|
ClearTargetMode();
|
|
accepted = targetGuid != 0 && _sendExamine is not null;
|
|
if (accepted)
|
|
RequestAppraisal(targetGuid);
|
|
break;
|
|
case InteractionModeKind.UseItemOnTarget:
|
|
accepted = AcquireTarget(targetGuid);
|
|
break;
|
|
default:
|
|
throw new InvalidOperationException($"Unknown interaction mode {mode}.");
|
|
}
|
|
_consumedPrimaryClickTarget = targetGuid;
|
|
_consumedPrimaryClickMs = _nowMs();
|
|
return accepted
|
|
? ItemPrimaryClickResult.ConsumedSuccess
|
|
: ItemPrimaryClickResult.ConsumedRejected;
|
|
}
|
|
|
|
public ItemPrimaryClickResult OfferSelfPrimaryClick()
|
|
=> OfferPrimaryClick(_playerGuid());
|
|
|
|
/// <summary>
|
|
/// Retail toolbar Use button: use the current selection immediately, or arm
|
|
/// one-shot <c>TARGET_MODE_USE</c> when no object is selected.
|
|
/// Retail reference: <c>gmToolbarUI::ListenToElementMessage @ 0x004BEE90</c>.
|
|
/// </summary>
|
|
public bool UseSelectedOrEnterMode(uint selectedObjectId)
|
|
{
|
|
if (selectedObjectId != 0)
|
|
return ActivateItem(selectedObjectId);
|
|
return _interactionState.EnterUse();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retail toolbar Examine button: appraise the current selection immediately,
|
|
/// or arm one-shot <c>TARGET_MODE_EXAMINE</c> when no object is selected.
|
|
/// Retail reference: <c>gmToolbarUI::ListenToElementMessage @ 0x004BEE90</c>.
|
|
/// </summary>
|
|
public bool ExamineSelectedOrEnterMode(uint selectedObjectId)
|
|
{
|
|
if (selectedObjectId == 0)
|
|
return _interactionState.EnterExamine();
|
|
if (_sendExamine is null)
|
|
return false;
|
|
RequestAppraisal(selectedObjectId);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retail <c>gmExaminationUI::RecvNotice_ExamineObject @ 0x004AB7B0</c>.
|
|
/// One shared UI-busy reference covers the currently pending appraisal,
|
|
/// even when another examine request replaces its GUID before a response.
|
|
/// </summary>
|
|
private void RequestAppraisal(uint objectId)
|
|
{
|
|
if (objectId == 0 || _sendExamine is null)
|
|
return;
|
|
_runtimeTransactions.TryRequestAppraisal(objectId, _sendExamine);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Accepts only the pending or current appraisal, matching
|
|
/// <c>gmExaminationUI::SetAppraiseInfo @ 0x004ADAE0</c>.
|
|
/// </summary>
|
|
public AppraisalResponseAcceptance AcceptAppraisalResponse(uint objectId)
|
|
{
|
|
bool ownedBusyReference = _transactions.BusyCount > 0;
|
|
RuntimeAppraisalResponseAcceptance acceptance =
|
|
_runtimeTransactions.AcceptAppraisalResponse(objectId);
|
|
if (acceptance.FirstResponse && !ownedBusyReference)
|
|
StateChanged?.Invoke();
|
|
return new AppraisalResponseAcceptance(
|
|
acceptance.Accepted,
|
|
acceptance.FirstResponse);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retail combat-time creature/player refresh sends CM_Item directly and
|
|
/// therefore does not acquire a second UI-busy reference.
|
|
/// </summary>
|
|
public bool RefreshCurrentAppraisal()
|
|
{
|
|
if (_sendExamine is null)
|
|
return false;
|
|
return _runtimeTransactions.RefreshCurrentAppraisal(_sendExamine);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases only the object-appraisal transaction before the local spell
|
|
/// examination subview takes ownership of the shared floaty window.
|
|
///
|
|
/// Retail <c>gmExaminationUI::ExamineSpell @ 0x004B6900</c> decrements the
|
|
/// appraisal busy reference when a response is pending, clears both pending
|
|
/// and current object ids, and sends <c>CM_Item::Event_Appraise(0)</c>. It
|
|
/// does not clear unrelated use/inventory busy references.
|
|
/// </summary>
|
|
public void CancelObjectAppraisalForSpell()
|
|
{
|
|
if (_sendExamine is null)
|
|
return;
|
|
bool ownedBusyReference = _transactions.BusyCount > 0;
|
|
if (_runtimeTransactions.CancelObjectAppraisalForSpell(_sendExamine)
|
|
&& !ownedBusyReference)
|
|
{
|
|
StateChanged?.Invoke();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Projects retail <c>gmToolbarUI::HandleSelectionChanged @ 0x004BF380</c>
|
|
/// from the live selected object's public description. This is deliberately
|
|
/// a read-only query; activation still flows through <see cref="ActivateItem"/>.
|
|
/// </summary>
|
|
public bool IsToolbarUseEnabled(uint selectedObjectId)
|
|
{
|
|
if (selectedObjectId == 0
|
|
|| _objects.Get(selectedObjectId) is not { } item)
|
|
return false;
|
|
|
|
return ItemInteractionPolicy.IsToolbarUseEnabled(
|
|
item.Type,
|
|
item.CombatUse ?? 0,
|
|
item.Useability ?? ItemUseability.Undef);
|
|
}
|
|
|
|
public bool ActivateItem(uint itemGuid)
|
|
{
|
|
if (itemGuid == 0) return false;
|
|
|
|
if (IsTargetModeActive)
|
|
return OfferPrimaryClick(itemGuid) == ItemPrimaryClickResult.ConsumedSuccess;
|
|
|
|
var item = _objects.Get(itemGuid);
|
|
if (item is null) return false;
|
|
|
|
if (!ConsumeUseThrottle())
|
|
return true;
|
|
if (!EnsureInventoryRequestReady())
|
|
return false;
|
|
|
|
var input = new ItemUsePolicyInput(
|
|
Snapshot(item),
|
|
_playerGuid(),
|
|
_groundObjectId(),
|
|
CanMakeInventoryRequest,
|
|
_activeVendorId(),
|
|
BypassClassification: false,
|
|
UseCurrentSelection: false,
|
|
SelectedTarget: null,
|
|
ConfirmVolatileRareUses: true,
|
|
InNonCombatMode: _inNonCombatMode());
|
|
var decision = ItemInteractionPolicy.DecideUse(input);
|
|
return ExecuteUseActions(decision.Actions);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retail keyboard pickup entry point. <c>CPlayerSystem::PlaceInBackpack</c>
|
|
/// publishes the waiting destination slot before issuing the move request,
|
|
/// exactly like double-click pickup through ItemHolder.
|
|
/// </summary>
|
|
public bool PlaceWorldItemInBackpack(uint itemGuid)
|
|
{
|
|
if (itemGuid == 0u || _placeInBackpack is null)
|
|
return false;
|
|
|
|
uint containerId = _backpackContainerId();
|
|
if (containerId == 0u)
|
|
containerId = _playerGuid();
|
|
const int placement = 0;
|
|
if (!TryBeginPendingBackpackPlacement(
|
|
itemGuid,
|
|
containerId,
|
|
placement,
|
|
out _))
|
|
{
|
|
// Retail permits only one inventory request at a time. Consume the
|
|
// input without replacing a pending projection or issuing a wire
|
|
// request while another inventory transaction owns the gate.
|
|
return true;
|
|
}
|
|
// This callback may install a retail MoveToObject approach instead of
|
|
// sending immediately. SelectionInteractionController promotes the
|
|
// reservation to Dispatched only when it actually emits the wire move.
|
|
_placeInBackpack(itemGuid, containerId, placement);
|
|
return true;
|
|
}
|
|
|
|
public bool TryBeginPendingBackpackPlacement(
|
|
uint itemGuid,
|
|
uint containerId,
|
|
int placement,
|
|
out PendingBackpackPlacement pending)
|
|
=> TryBeginPendingBackpackPlacement(
|
|
itemGuid,
|
|
containerId,
|
|
placement,
|
|
InventoryRequestKind.Pickup,
|
|
out pending);
|
|
|
|
private bool TryBeginPendingBackpackPlacement(
|
|
uint itemGuid,
|
|
uint containerId,
|
|
int placement,
|
|
InventoryRequestKind kind,
|
|
out PendingBackpackPlacement pending)
|
|
{
|
|
if (itemGuid == 0u || containerId == 0u)
|
|
{
|
|
pending = default;
|
|
return false;
|
|
}
|
|
|
|
if (_pendingBackpackPlacement is { } existing)
|
|
{
|
|
ReportPendingBackpackPlacementConflict();
|
|
pending = existing;
|
|
return false;
|
|
}
|
|
if (!EnsureInventoryRequestReady())
|
|
{
|
|
pending = default;
|
|
return false;
|
|
}
|
|
|
|
PendingBackpackPlacement candidate = default;
|
|
bool reserved;
|
|
PendingInventoryRequest published;
|
|
try
|
|
{
|
|
reserved = _transactions.TryReserve(
|
|
kind,
|
|
itemGuid,
|
|
out published,
|
|
request =>
|
|
{
|
|
candidate = new PendingBackpackPlacement(
|
|
request.Token,
|
|
itemGuid,
|
|
containerId,
|
|
placement,
|
|
request.ItemIdentity);
|
|
_pendingBackpackPlacement = candidate;
|
|
List<Exception> failures = [];
|
|
DispatchAll(
|
|
PendingBackpackPlacementRequested,
|
|
candidate,
|
|
failures);
|
|
if (failures.Count != 0)
|
|
{
|
|
throw new AggregateException(
|
|
"One or more pending-placement observers failed.",
|
|
failures);
|
|
}
|
|
});
|
|
}
|
|
catch (Exception failure)
|
|
{
|
|
if (candidate.Token == 0u)
|
|
throw;
|
|
|
|
_pendingBackpackPlacement = null;
|
|
_transactions.CancelBeforeDispatch(candidate.Token);
|
|
List<Exception> failures = [failure];
|
|
DispatchAll(
|
|
PendingBackpackPlacementCancelled,
|
|
candidate,
|
|
failures);
|
|
throw new AggregateException(
|
|
"Pending backpack placement publication failed.",
|
|
failures);
|
|
}
|
|
pending = candidate;
|
|
if (!reserved
|
|
|| _pendingBackpackPlacement != candidate
|
|
|| published.Token != candidate.Token
|
|
|| published.ItemId != itemGuid
|
|
|| published.Kind != kind
|
|
|| published.Dispatched)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Publishes retail's destination waiting projection, dispatches the move,
|
|
/// then records the global request. Failed dispatch withdraws only the
|
|
/// projection created by this call.
|
|
/// </summary>
|
|
public bool TryDispatchPendingBackpackPlacement(
|
|
uint itemGuid,
|
|
uint containerId,
|
|
int placement,
|
|
InventoryRequestKind kind,
|
|
Func<bool> dispatch)
|
|
{
|
|
// Callers such as gmToolbarUI check the global prevRequest before they
|
|
// ask CPlayerSystem to publish ShowPendingInPlayer. This preserves the
|
|
// generic busy wording when both states happen to be present.
|
|
if (!EnsureInventoryRequestReady())
|
|
return false;
|
|
if (!TryBeginPendingBackpackPlacement(
|
|
itemGuid,
|
|
containerId,
|
|
placement,
|
|
kind,
|
|
out PendingBackpackPlacement pending))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (_pendingBackpackPlacement != pending
|
|
|| !_transactions.TryGetPending(out PendingInventoryRequest reserved)
|
|
|| reserved.Token != pending.Token
|
|
|| reserved.ItemId != pending.ItemId
|
|
|| reserved.Kind != kind
|
|
|| reserved.Dispatched)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (TryDispatchInventoryRequest(
|
|
kind,
|
|
itemGuid,
|
|
dispatch,
|
|
pending.Token))
|
|
return true;
|
|
|
|
CancelPendingBackpackPlacement(itemGuid, pending.Token);
|
|
return false;
|
|
}
|
|
|
|
public bool TryGetPendingBackpackPlacement(
|
|
uint itemGuid,
|
|
out PendingBackpackPlacement pending)
|
|
{
|
|
if (_pendingBackpackPlacement is { } current
|
|
&& current.ItemId == itemGuid)
|
|
{
|
|
pending = current;
|
|
return true;
|
|
}
|
|
|
|
pending = default;
|
|
return false;
|
|
}
|
|
|
|
public void CancelPendingBackpackPlacement(uint itemGuid = 0u, ulong token = 0u)
|
|
{
|
|
if (_pendingBackpackPlacement is not { } pending
|
|
|| (itemGuid != 0u && pending.ItemId != itemGuid)
|
|
|| (token != 0u && pending.Token != token))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_pendingBackpackPlacement = null;
|
|
_transactions.CancelBeforeDispatch(pending.Token);
|
|
List<Exception> failures = [];
|
|
DispatchAll(PendingBackpackPlacementCancelled, pending, failures);
|
|
if (failures.Count != 0)
|
|
{
|
|
throw new AggregateException(
|
|
"One or more pending-placement cancellation observers failed.",
|
|
failures);
|
|
}
|
|
}
|
|
|
|
internal bool TryCaptureObjectIdentity(uint objectId, out ClientObject item)
|
|
{
|
|
item = _objects.Get(objectId)!;
|
|
return item is not null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns whether the object is a member of retail's current
|
|
/// <c>ClientUISystem::groundObject</c>. Such objects are container
|
|
/// contents, not independently projected world objects, so
|
|
/// <c>CPlayerSystem::PlaceInBackpack @ 0x0055D8C0</c> sends their
|
|
/// container transfer directly without a 3-D approach lookup.
|
|
/// </summary>
|
|
internal bool IsInCurrentGroundObject(uint objectId)
|
|
{
|
|
uint groundObjectId = _groundObjectId();
|
|
return groundObjectId != 0u
|
|
&& _objects.Get(objectId) is { } item
|
|
&& item.ContainerId == groundObjectId;
|
|
}
|
|
|
|
internal bool IsCurrentObjectIdentity(uint objectId, ClientObject item)
|
|
=> ReferenceEquals(_objects.Get(objectId), item);
|
|
|
|
/// <summary>
|
|
/// Retail paperdoll drop entry point. The paperdoll resolves the exact
|
|
/// target side/location; this shared interaction owner performs AutoWield's
|
|
/// confirmed blocker transaction before sending GetAndWieldItem.
|
|
/// </summary>
|
|
public bool WieldFromPaperdoll(uint itemGuid, EquipMask targetMask)
|
|
{
|
|
if (itemGuid == 0u || targetMask == EquipMask.None)
|
|
return false;
|
|
if (_objects.Get(itemGuid) is not { } item)
|
|
return false;
|
|
if (!EnsureInventoryRequestReady())
|
|
return false;
|
|
return _autoWield.TryWield(item, targetMask);
|
|
}
|
|
|
|
/// <summary>User combat-mode input supersedes AutoWield's retained mode.</summary>
|
|
public void NotifyExplicitCombatModeRequest()
|
|
=> _autoWield.NotifyExplicitCombatModeRequest();
|
|
|
|
public bool AcquireTarget(uint targetGuid)
|
|
{
|
|
if (!IsTargetModeActive || targetGuid == 0) return false;
|
|
|
|
uint sourceGuid = PendingSourceItem;
|
|
ClearTargetMode();
|
|
|
|
var source = _objects.Get(sourceGuid);
|
|
if (source?.Useability is not { } useability)
|
|
return false;
|
|
|
|
bool compatible = TargetCompatible(source, targetGuid);
|
|
var target = _objects.Get(targetGuid);
|
|
Console.WriteLine(
|
|
$"[use-target] src=0x{sourceGuid:X8} use=0x{useability:X8} ttypeMask=0x{source.TargetType ?? 0u:X8}"
|
|
+ $" tgt=0x{targetGuid:X8} tgtKind={(target is null ? "none" : $"0x{(uint)target.Type:X8}")}"
|
|
+ $" -> {(compatible ? "SEND UseWithTarget" : "refused")}");
|
|
if (!compatible)
|
|
return false;
|
|
|
|
if (!EnsureInventoryRequestReady())
|
|
return false;
|
|
_runtimeTransactions.TryDispatchTargetedUse(
|
|
sourceGuid,
|
|
targetGuid,
|
|
_sendUseWithTarget,
|
|
incrementBusy: true);
|
|
return true;
|
|
}
|
|
|
|
public bool AcquireSelfTarget()
|
|
=> IsTargetModeActive && AcquireTarget(_playerGuid());
|
|
|
|
/// <summary>
|
|
/// Completes the positive branch of retail
|
|
/// <c>ClientUISystem::UsageCallback @ 0x00565B20</c>. Confirmation policy has
|
|
/// already consumed the original activation, so acceptance sends the retained
|
|
/// object id and enters the same busy state as an ordinary use.
|
|
/// </summary>
|
|
public bool ExecuteConfirmedUse(uint objectId)
|
|
{
|
|
if (objectId == 0u || (_requestUse is null && _sendUse is null))
|
|
return false;
|
|
if (!EnsureInventoryRequestReady())
|
|
return false;
|
|
if (_requestUse is not null)
|
|
{
|
|
ItemUseRequestReservation reservation = BeginUseRequestReservation();
|
|
try
|
|
{
|
|
_requestUse(objectId, reservation);
|
|
}
|
|
catch
|
|
{
|
|
reservation.CancelBeforeDispatch();
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_sendUse!(objectId);
|
|
_runtimeTransactions.IncrementBusyCount();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void CancelTargetMode()
|
|
{
|
|
if (!IsAnyTargetModeActive) return;
|
|
ClearTargetMode();
|
|
}
|
|
|
|
public bool DropToWorld(ItemDragPayload payload)
|
|
=> PlaceIn3D(payload, targetGuid: 0u);
|
|
|
|
/// <summary>
|
|
/// Retail inventory drag released into SmartBox. The release target is the
|
|
/// world object under the cursor, or zero for empty ground. This is the live
|
|
/// adapter for <c>ItemHolder::AttemptPlaceIn3D @ 0x00588600</c>.
|
|
/// </summary>
|
|
public bool PlaceIn3D(ItemDragPayload payload, uint targetGuid)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(payload);
|
|
|
|
if (payload.SourceKind == ItemDragSource.ShortcutBar)
|
|
return false;
|
|
if (payload.ObjId == 0 || _objects.Get(payload.ObjId) is not { } item)
|
|
return false;
|
|
if (!EnsureInventoryRequestReady())
|
|
return false;
|
|
|
|
uint fullStack = (uint)Math.Max(1, item.StackSize);
|
|
int splitSize = (int)(_stackSplitQuantity?.GetObjectSplitSize(
|
|
item.ObjectId, _selectedObjectId(), fullStack) ?? fullStack);
|
|
ClientObject? target = targetGuid == 0u ? null : _objects.Get(targetGuid);
|
|
var decision = ItemInteractionPolicy.DecidePlacement(new ItemPlacementPolicyInput(
|
|
Snapshot(item),
|
|
_playerGuid(),
|
|
_groundObjectId(),
|
|
CanMakeInventoryRequest,
|
|
TargetId: targetGuid,
|
|
Target: target is null ? null : Snapshot(target),
|
|
AllowGroundFallback: true,
|
|
MergeAccepted: false,
|
|
DragOnPlayerOpensSecureTrade: _dragOnPlayerOpensSecureTrade(),
|
|
PlayerOnGround: _playerOnGround(),
|
|
SplitSize: splitSize));
|
|
ExecutePlacementActions(decision.Actions);
|
|
return decision.ReturnValue;
|
|
}
|
|
|
|
private bool ExecuteUseActions(System.Collections.Generic.IReadOnlyList<ItemPolicyAction> actions)
|
|
{
|
|
uint openedOrUsed = 0;
|
|
bool acted = false;
|
|
bool busyOwnedByUseReservation = false;
|
|
foreach (var action in actions)
|
|
{
|
|
switch (action.Kind)
|
|
{
|
|
case ItemPolicyActionKind.PlaceInBackpack:
|
|
acted |= PlaceWorldItemInBackpack(action.ObjectId);
|
|
break;
|
|
case ItemPolicyActionKind.WieldRight:
|
|
case ItemPolicyActionKind.WieldLeft:
|
|
case ItemPolicyActionKind.AutoSort:
|
|
if (_objects.Get(action.ObjectId) is { } item)
|
|
acted |= _autoWield.TryWield(item);
|
|
break;
|
|
case ItemPolicyActionKind.OpenContainedContainer:
|
|
case ItemPolicyActionKind.SendUse:
|
|
// Retail's wire Use and local OpenContainedContainer notice are
|
|
// distinct. acdream currently represents both with SendUse, so
|
|
// coalesce the pair to one packet.
|
|
if (openedOrUsed != action.ObjectId)
|
|
{
|
|
if (_requestUse is not null)
|
|
{
|
|
ItemUseRequestReservation reservation =
|
|
BeginUseRequestReservation();
|
|
try
|
|
{
|
|
_requestUse(action.ObjectId, reservation);
|
|
}
|
|
catch
|
|
{
|
|
reservation.CancelBeforeDispatch();
|
|
throw;
|
|
}
|
|
busyOwnedByUseReservation = true;
|
|
}
|
|
else
|
|
{
|
|
_sendUse?.Invoke(action.ObjectId);
|
|
}
|
|
openedOrUsed = action.ObjectId;
|
|
acted |= _requestUse is not null || _sendUse is not null;
|
|
}
|
|
break;
|
|
case ItemPolicyActionKind.SendUseWithTarget:
|
|
acted |= _runtimeTransactions.TryDispatchTargetedUse(
|
|
action.ObjectId,
|
|
action.TargetId,
|
|
_sendUseWithTarget,
|
|
incrementBusy: false);
|
|
break;
|
|
case ItemPolicyActionKind.SetGroundObject:
|
|
_requestExternalContainer?.Invoke(action.ObjectId);
|
|
acted |= _requestExternalContainer is not null;
|
|
break;
|
|
case ItemPolicyActionKind.EnterTargetMode:
|
|
EnterTargetMode(action.ObjectId);
|
|
acted = true;
|
|
break;
|
|
case ItemPolicyActionKind.IncrementBusy:
|
|
if (busyOwnedByUseReservation)
|
|
{
|
|
busyOwnedByUseReservation = false;
|
|
}
|
|
else
|
|
{
|
|
_runtimeTransactions.IncrementBusyCount();
|
|
}
|
|
break;
|
|
case ItemPolicyActionKind.Reject:
|
|
if (!string.IsNullOrWhiteSpace(action.Message))
|
|
_toast?.Invoke(action.Message);
|
|
break;
|
|
default:
|
|
_auxiliaryAction?.Invoke(action);
|
|
PolicyActionRequested?.Invoke(action);
|
|
bool handled = _auxiliaryAction is not null || PolicyActionRequested is not null;
|
|
if (!handled)
|
|
_toast?.Invoke(PolicyActionMessage(action));
|
|
acted |= handled || _toast is not null;
|
|
break;
|
|
}
|
|
}
|
|
return acted;
|
|
}
|
|
|
|
private ItemUseRequestReservation BeginUseRequestReservation()
|
|
=> _runtimeTransactions.BeginUseRequestReservation();
|
|
|
|
private void ExecutePlacementActions(System.Collections.Generic.IReadOnlyList<ItemPolicyAction> actions)
|
|
{
|
|
foreach (var action in actions)
|
|
{
|
|
switch (action.Kind)
|
|
{
|
|
case ItemPolicyActionKind.DropToWorld:
|
|
TryDispatchInventoryRequest(
|
|
InventoryRequestKind.DropToWorld,
|
|
action.ObjectId,
|
|
() =>
|
|
{
|
|
if (_sendDrop is null
|
|
|| !_objects.MoveItemOptimistic(
|
|
action.ObjectId,
|
|
newContainerId: 0u,
|
|
newSlot: -1))
|
|
{
|
|
return false;
|
|
}
|
|
_sendDrop(action.ObjectId);
|
|
return true;
|
|
});
|
|
break;
|
|
case ItemPolicyActionKind.SplitToWorld:
|
|
// UIAttemptSplitTo3D leaves the original object in its container;
|
|
// the server assigns the split-off ground stack a new guid.
|
|
TryDispatchInventoryRequest(
|
|
InventoryRequestKind.SplitToWorld,
|
|
action.ObjectId,
|
|
() =>
|
|
{
|
|
if (_sendSplitToWorld is null)
|
|
return false;
|
|
_sendSplitToWorld(action.ObjectId, (uint)action.Amount);
|
|
if (_transactions.TryGetPending(out PendingInventoryRequest pending)
|
|
&& pending.Kind is InventoryRequestKind.SplitToWorld
|
|
&& pending.ItemId == action.ObjectId)
|
|
{
|
|
WorldDropDispatched?.Invoke(new WorldDropDispatch(
|
|
pending,
|
|
(uint)action.Amount));
|
|
}
|
|
return true;
|
|
});
|
|
break;
|
|
case ItemPolicyActionKind.GiveToTarget:
|
|
// UIAttemptGive @ 0x0058D620 sends the request and leaves
|
|
// the source untouched until the authoritative server
|
|
// InventoryRemoveObject / SetStackSize response arrives.
|
|
TryDispatchInventoryRequest(
|
|
InventoryRequestKind.Give,
|
|
action.ObjectId,
|
|
() =>
|
|
{
|
|
if (_sendGive is null)
|
|
return false;
|
|
_sendGive(
|
|
action.TargetId,
|
|
action.ObjectId,
|
|
(uint)Math.Max(1, action.Amount));
|
|
return true;
|
|
});
|
|
break;
|
|
case ItemPolicyActionKind.PlaceInContainer:
|
|
{
|
|
uint fullStack = (uint)Math.Max(
|
|
1,
|
|
_objects.Get(action.ObjectId)?.StackSize ?? action.Amount);
|
|
uint amount = (uint)Math.Max(1, action.Amount);
|
|
InventoryRequestKind kind = amount < fullStack
|
|
? InventoryRequestKind.SplitToContainer
|
|
: InventoryRequestKind.PutInContainer;
|
|
TryDispatchInventoryRequest(
|
|
kind,
|
|
action.ObjectId,
|
|
() =>
|
|
{
|
|
if (amount < fullStack)
|
|
{
|
|
if (_sendSplitToContainer is null)
|
|
return false;
|
|
_sendSplitToContainer(
|
|
action.ObjectId,
|
|
action.TargetId,
|
|
0u,
|
|
amount);
|
|
}
|
|
else
|
|
{
|
|
if (_sendPutItemInContainer is null)
|
|
return false;
|
|
_sendPutItemInContainer(
|
|
action.ObjectId,
|
|
action.TargetId,
|
|
0);
|
|
}
|
|
return true;
|
|
});
|
|
break;
|
|
}
|
|
case ItemPolicyActionKind.Reject:
|
|
if (!string.IsNullOrWhiteSpace(action.Message))
|
|
_toast?.Invoke(action.Message);
|
|
break;
|
|
default:
|
|
_auxiliaryAction?.Invoke(action);
|
|
PolicyActionRequested?.Invoke(action);
|
|
if (_auxiliaryAction is null && PolicyActionRequested is null)
|
|
_toast?.Invoke(PolicyActionMessage(action));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EnterTargetMode(uint sourceGuid)
|
|
{
|
|
_consumedPrimaryClickTarget = 0;
|
|
_interactionState.EnterUseItemOnTarget(sourceGuid);
|
|
var name = _objects.Get(sourceGuid)?.Name;
|
|
if (!string.IsNullOrWhiteSpace(name))
|
|
_toast?.Invoke($"Choose a target for the {name}");
|
|
}
|
|
|
|
private void ClearTargetMode()
|
|
{
|
|
_interactionState.Clear();
|
|
}
|
|
|
|
private static string PolicyActionMessage(ItemPolicyAction action)
|
|
=> action.Kind switch
|
|
{
|
|
ItemPolicyActionKind.ConfirmPlayerKillerSwitch =>
|
|
"Confirm using this Player Killer altar before continuing.",
|
|
ItemPolicyActionKind.ConfirmNonPlayerKillerSwitch =>
|
|
"Confirm using this Non-Player Killer altar before continuing.",
|
|
ItemPolicyActionKind.ConfirmVolatileRare =>
|
|
"Confirm using this volatile rare before continuing.",
|
|
ItemPolicyActionKind.OpenSecureTrade or ItemPolicyActionKind.StartSecureTrade =>
|
|
"Secure trade is not open.",
|
|
ItemPolicyActionKind.OpenSalvage => "Open the salvage panel to use that item.",
|
|
_ => "That item action is not available here.",
|
|
};
|
|
|
|
private void OnInteractionModeChanged(InteractionModeTransition _)
|
|
{
|
|
List<Exception> failures = [];
|
|
DispatchAll(StateChanged, failures);
|
|
if (failures.Count != 0)
|
|
throw new AggregateException(
|
|
"One or more item-interaction observers failed.",
|
|
failures);
|
|
}
|
|
|
|
private void OnTransactionStateChanged()
|
|
{
|
|
List<Exception> failures = [];
|
|
DispatchAll(StateChanged, failures);
|
|
if (failures.Count != 0)
|
|
{
|
|
throw new AggregateException(
|
|
"One or more item-interaction observers failed.",
|
|
failures);
|
|
}
|
|
}
|
|
|
|
private void OnInventoryRequestCompleted(PendingInventoryRequest request)
|
|
{
|
|
if (_pendingBackpackPlacement is { } placement
|
|
&& placement.Token == request.Token
|
|
&& placement.ItemId == request.ItemId)
|
|
{
|
|
_pendingBackpackPlacement = null;
|
|
List<Exception> failures = [];
|
|
DispatchAll(PendingBackpackPlacementResolved, placement, failures);
|
|
if (failures.Count != 0)
|
|
{
|
|
throw new AggregateException(
|
|
"One or more pending-placement resolution observers failed.",
|
|
failures);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnInventoryObjectsCleared()
|
|
{
|
|
_pendingBackpackPlacement = null;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (_disposed) return;
|
|
_disposed = true;
|
|
_interactionState.Changed -= OnInteractionModeChanged;
|
|
_transactions.ObjectTableCleared -= OnInventoryObjectsCleared;
|
|
_transactions.RequestCompleted -= OnInventoryRequestCompleted;
|
|
_transactions.StateChanged -= OnTransactionStateChanged;
|
|
WorldDropDispatched = null;
|
|
_autoWield.Dispose();
|
|
}
|
|
|
|
/// <summary>Retail UseDone (0x01C7) releases one UI busy reference.</summary>
|
|
public void CompleteUse(uint error)
|
|
=> _runtimeTransactions.CompleteUse(error);
|
|
|
|
/// <summary>Session teardown drops every outstanding client UI busy reference.</summary>
|
|
public void ClearBusy()
|
|
=> _transactions.ClearBusy();
|
|
|
|
/// <summary>
|
|
/// Ends all session-scoped ItemHolder state. Target modes, click
|
|
/// suppression, and use throttles must not survive a reconnect where the
|
|
/// same numeric GUID can identify a different object.
|
|
/// </summary>
|
|
public void ResetSession()
|
|
{
|
|
PendingBackpackPlacement? pendingPlacement = _pendingBackpackPlacement;
|
|
_pendingBackpackPlacement = null;
|
|
// Runtime owns the transaction reset. This controller preserves the
|
|
// pre-J4 single UI notification emitted by InteractionState below.
|
|
_transactions.StateChanged -= OnTransactionStateChanged;
|
|
try
|
|
{
|
|
_runtimeTransactions.ResetSession();
|
|
}
|
|
finally
|
|
{
|
|
if (!_disposed)
|
|
_transactions.StateChanged += OnTransactionStateChanged;
|
|
}
|
|
_consumedPrimaryClickTarget = 0u;
|
|
_consumedPrimaryClickMs = long.MinValue / 2;
|
|
|
|
List<Exception> failures = [];
|
|
try { _interactionState.ResetSession(); }
|
|
catch (Exception error) { failures.Add(error); }
|
|
|
|
if (pendingPlacement is { } pending)
|
|
DispatchAll(PendingBackpackPlacementCancelled, pending, failures);
|
|
|
|
if (failures.Count != 0)
|
|
throw new AggregateException(
|
|
"One or more item-interaction reset observers failed.",
|
|
failures);
|
|
}
|
|
|
|
public readonly record struct AppraisalResponseAcceptance(
|
|
bool Accepted,
|
|
bool FirstResponse);
|
|
|
|
private static void DispatchAll(Action? listeners, List<Exception> failures)
|
|
{
|
|
if (listeners is null)
|
|
return;
|
|
foreach (Action listener in listeners.GetInvocationList())
|
|
{
|
|
try { listener(); }
|
|
catch (Exception error) { failures.Add(error); }
|
|
}
|
|
}
|
|
|
|
private static void DispatchAll<T>(
|
|
Action<T>? listeners,
|
|
T value,
|
|
List<Exception> failures)
|
|
{
|
|
if (listeners is null)
|
|
return;
|
|
foreach (Action<T> listener in listeners.GetInvocationList())
|
|
{
|
|
try { listener(value); }
|
|
catch (Exception error) { failures.Add(error); }
|
|
}
|
|
}
|
|
|
|
private bool ConsumeUseThrottle()
|
|
=> _runtimeTransactions.TryConsumeUseThrottle(_nowMs());
|
|
|
|
private static bool IsContainer(ClientObject item)
|
|
=> item.ContainerTypeHint != 0
|
|
|| item.Type.HasFlag(ItemType.Container)
|
|
|| item.ItemsCapacity > 0;
|
|
|
|
private ItemPolicyObject Snapshot(ClientObject item)
|
|
{
|
|
var flags = (PublicWeenieFlags)(item.PublicWeenieBitfield ?? 0u);
|
|
if (item.ObjectId == _playerGuid())
|
|
flags |= PublicWeenieFlags.Player;
|
|
|
|
bool owned = item.ObjectId == _playerGuid()
|
|
|| IsCarriedByPlayer(item)
|
|
|| IsEquippedByPlayer(item);
|
|
int stackSize = Math.Max(1, item.StackSize);
|
|
return new ItemPolicyObject(
|
|
item.ObjectId,
|
|
item.Type,
|
|
flags,
|
|
item.ContainerId,
|
|
item.WielderId,
|
|
item.ValidLocations,
|
|
item.CurrentlyEquippedLocation,
|
|
item.CombatUse ?? 0,
|
|
item.ItemsCapacity,
|
|
item.ContainersCapacity,
|
|
item.Useability ?? 0u,
|
|
item.TargetType ?? 0u,
|
|
owned,
|
|
IsContainer(item),
|
|
item.IsComponentPack || _isComponentPack(item.WeenieClassId),
|
|
item.TradeState,
|
|
stackSize,
|
|
stackSize,
|
|
IsIn3DView: item.ContainerId == 0 && item.WielderId == 0
|
|
&& item.ObjectId != _playerGuid());
|
|
}
|
|
|
|
/// <summary>
|
|
/// App adapter for Core's pure port of
|
|
/// <c>ItemHolder::IsTargetCompatibleWithTargetingObject @ 0x00588070</c>.
|
|
/// </summary>
|
|
private bool TargetCompatible(ClientObject source, uint targetGuid)
|
|
{
|
|
var target = _objects.Get(targetGuid);
|
|
if (target is null)
|
|
return false; // retail: GetWeenieObject(target) null → incompatible
|
|
return ItemInteractionPolicy.IsTargetCompatible(
|
|
Snapshot(source), Snapshot(target), _playerGuid());
|
|
}
|
|
|
|
private bool IsEquippedByPlayer(ClientObject item)
|
|
{
|
|
uint player = _playerGuid();
|
|
return item.CurrentlyEquippedLocation != EquipMask.None
|
|
&& (item.WielderId == player || item.ContainerId == player);
|
|
}
|
|
|
|
private bool IsCarriedByPlayer(ClientObject item)
|
|
{
|
|
uint player = _playerGuid();
|
|
uint container = item.ContainerId;
|
|
for (int hops = 0; container != 0 && hops < 8; hops++)
|
|
{
|
|
if (container == player) return true;
|
|
container = _objects.Get(container)?.ContainerId ?? 0u;
|
|
}
|
|
return false;
|
|
}
|
|
}
|