KnackAtNite
3565bcd7f9
Add QuickTransfer source, pluginmaster feed, MIT license, and GitHub Actions release workflow.
1985 lines
75 KiB
C#
1985 lines
75 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using Dalamud.Configuration;
|
|
using Dalamud.Game.ClientState.Keys;
|
|
using Dalamud.Game.Command;
|
|
using Dalamud.Game.Gui.ContextMenu;
|
|
using Dalamud.Hooking;
|
|
using Dalamud.Interface.Windowing;
|
|
using Dalamud.IoC;
|
|
using Dalamud.Plugin;
|
|
using Dalamud.Plugin.Services;
|
|
using Dalamud.Utility.Signatures;
|
|
using Dalamud.Game.Addon.Lifecycle;
|
|
using Dalamud.Game.Addon.Lifecycle.AddonArgTypes;
|
|
using FFXIVClientStructs.FFXIV.Client.Game;
|
|
using FFXIVClientStructs.FFXIV.Client.UI;
|
|
using FFXIVClientStructs.FFXIV.Client.UI.Agent;
|
|
using FFXIVClientStructs.FFXIV.Component.GUI;
|
|
using Lumina.Excel.Sheets;
|
|
using AtkValueType = FFXIVClientStructs.FFXIV.Component.GUI.ValueType;
|
|
|
|
namespace QuickTransfer;
|
|
|
|
[Serializable]
|
|
public sealed class Configuration : IPluginConfiguration
|
|
{
|
|
public int Version { get; set; } = 2;
|
|
|
|
public bool Enabled { get; set; } = true;
|
|
public bool DebugMode { get; set; } = false;
|
|
public int TransferCooldownMs { get; set; } = 200;
|
|
|
|
public bool EnableCompanyChest { get; set; } = true;
|
|
public bool AutoConfirmCompanyChestQuantity { get; set; } = true;
|
|
public int CompanyChestCompartments { get; set; } = 3; // 3..5 (default game starts at 3)
|
|
|
|
public void Save() => Plugin.PluginInterface.SavePluginConfig(this);
|
|
}
|
|
|
|
public sealed unsafe class Plugin : IDalamudPlugin
|
|
{
|
|
[PluginService] internal static IDalamudPluginInterface PluginInterface { get; private set; } = null!;
|
|
[PluginService] internal static ICommandManager CommandManager { get; private set; } = null!;
|
|
[PluginService] internal static IPluginLog Log { get; private set; } = null!;
|
|
[PluginService] internal static IGameGui GameGui { get; private set; } = null!;
|
|
[PluginService] internal static IFramework Framework { get; private set; } = null!;
|
|
[PluginService] internal static IKeyState KeyState { get; private set; } = null!;
|
|
[PluginService] internal static IDataManager DataManager { get; private set; } = null!;
|
|
[PluginService] internal static IGameInteropProvider InteropProvider { get; private set; } = null!;
|
|
[PluginService] internal static IContextMenu ContextMenu { get; private set; } = null!;
|
|
[PluginService] internal static IAddonLifecycle AddonLifecycle { get; private set; } = null!;
|
|
|
|
private const string CommandName = "/qt";
|
|
|
|
public Configuration Configuration { get; }
|
|
|
|
private readonly WindowSystem windowSystem = new("QuickTransfer");
|
|
private readonly QuickTransferWindow configWindow;
|
|
|
|
private long lastActionTickMs;
|
|
private (nint AgentPtr, nint AddonPtr, long EnqueuedAtMs, ModifierMode Mode)? pendingDeferredMenuClick;
|
|
private (string AddonName, long EnqueuedAtMs, ModifierMode Mode)? pendingDeferredDefaultMenu;
|
|
private long pendingCompanyChestNumericConfirmUntilMs;
|
|
private int pendingCompanyChestNumericConfirmAttempts;
|
|
private long pendingCloseContextMenuAtMs;
|
|
private bool pendingCompanyChestNumericArmed;
|
|
private bool pendingCompanyChestNumericValueSet;
|
|
private long pendingCompanyChestNumericValueSetAtMs;
|
|
private uint pendingCompanyChestNumericDesired;
|
|
private enum PendingNumericKind { None, Store, Remove }
|
|
private PendingNumericKind pendingNumericKind;
|
|
|
|
private long lastShiftSeenMs;
|
|
private long lastCtrlSeenMs;
|
|
|
|
// For stack moves that open InputNumeric, the native operation state must stay alive.
|
|
// If it's stack-allocated, the resulting InputNumeric buttons can become "dead".
|
|
private nint pendingMoveOutValuePtr;
|
|
private long pendingMoveOutValueFreeAtMs;
|
|
private nint pendingMoveAtkValuesPtr;
|
|
private long pendingMoveCreatedAtMs;
|
|
private bool pendingMoveSawInputNumeric;
|
|
private static readonly Dictionary<uint, uint> StackSizeCache = new();
|
|
|
|
private struct CompanyChestDepositState
|
|
{
|
|
public bool Active;
|
|
public FFXIVClientStructs.FFXIV.Client.Game.InventoryType SourceType;
|
|
public uint SourceSlot;
|
|
public uint ItemId;
|
|
public bool IsHq;
|
|
public long NextAttemptAtMs;
|
|
public long ExpiresAtMs;
|
|
public int Steps;
|
|
public uint LastQty;
|
|
public long WaitForQtyChangeUntilMs;
|
|
}
|
|
|
|
private CompanyChestDepositState companyChestDeposit;
|
|
|
|
private enum ModifierMode
|
|
{
|
|
Shift,
|
|
Ctrl,
|
|
}
|
|
|
|
private delegate void OpenForItemSlotDelegate(
|
|
AgentInventoryContext* agent,
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType inventoryType,
|
|
int slot,
|
|
int a4,
|
|
uint addonId);
|
|
|
|
// Inventory/armoury uses this; saddlebags often do not, so we also use IContextMenu fallback.
|
|
[Signature("83 B9 ?? ?? ?? ?? ?? 7E ?? 39 91", DetourName = nameof(OpenForItemSlotDetour))]
|
|
private Hook<OpenForItemSlotDelegate>? openForItemSlotHook = null;
|
|
|
|
private delegate byte AtkUnitBaseCloseDelegate(AtkUnitBase* unitBase, byte a2);
|
|
|
|
[Signature("40 53 48 83 EC 50 81 A1", Fallibility = Fallibility.Fallible)]
|
|
private AtkUnitBaseCloseDelegate? atkUnitBaseClose = null;
|
|
|
|
// NOTE: For inventory transfers (including Free Company Chest), use the client callback handler:
|
|
// RaptureAtkModule::HandleItemMove(AtkValue* returnValue, AtkValue* values, uint valueCount)
|
|
// This is exposed directly by FFXIVClientStructs as a member function, so we do not signature-scan it ourselves.
|
|
|
|
private enum AutoContextAction
|
|
{
|
|
AddAllToSaddlebag,
|
|
RemoveAllFromSaddlebag,
|
|
PlaceInArmouryChest,
|
|
ReturnToInventory,
|
|
EntrustToRetainer,
|
|
RetrieveFromRetainer,
|
|
RemoveFromCompanyChest,
|
|
}
|
|
|
|
private static readonly string[] ArmouryAddonNames =
|
|
[
|
|
// Common internal names used by the Armoury Chest window across patches.
|
|
"ArmouryBoard",
|
|
"ArmoryBoard",
|
|
"Armoury",
|
|
"Armory",
|
|
"ArmouryChest",
|
|
"ArmoryChest",
|
|
];
|
|
|
|
private const string FreeCompanyChestAddonName = "FreeCompanyChest";
|
|
private const string InputNumericAddonName = "InputNumeric";
|
|
private const string ContextMenuAddonName = "ContextMenu";
|
|
|
|
private bool suppressContextMenu;
|
|
private bool suppressInputNumeric;
|
|
|
|
private FFXIVClientStructs.FFXIV.Client.Game.InventoryType[] GetCompanyChestInventoryTypes()
|
|
{
|
|
// Don't hardcode enum names; discover them by name at runtime so we don't break across patches/structs.
|
|
// Limit to the configured number of item compartments (default 3; can be upgraded to 5).
|
|
var max = Math.Clamp(Configuration.CompanyChestCompartments, 3, 5);
|
|
return Enum.GetValues<FFXIVClientStructs.FFXIV.Client.Game.InventoryType>()
|
|
.Where(IsCompanyChestType)
|
|
.OrderBy(v => (int)v)
|
|
.Take(max)
|
|
.ToArray();
|
|
}
|
|
|
|
public Plugin()
|
|
{
|
|
Configuration = PluginInterface.GetPluginConfig() as Configuration ?? new Configuration();
|
|
|
|
configWindow = new QuickTransferWindow(Configuration);
|
|
windowSystem.AddWindow(configWindow);
|
|
|
|
CommandManager.AddHandler(CommandName, new CommandInfo(OnCommand)
|
|
{
|
|
HelpMessage = "Open QuickTransfer settings",
|
|
});
|
|
|
|
PluginInterface.UiBuilder.Draw += windowSystem.Draw;
|
|
PluginInterface.UiBuilder.OpenConfigUi += OpenConfigUi;
|
|
|
|
InteropProvider.InitializeFromAttributes(this);
|
|
openForItemSlotHook?.Enable();
|
|
|
|
// Saddlebags can bypass OpenForItemSlot, so use a safe deferred click via context menu events.
|
|
ContextMenu.OnMenuOpened += OnContextMenuOpened;
|
|
Framework.Update += OnFrameworkUpdate;
|
|
|
|
// Pre-setup hook for InputNumeric so we can override the default quantity BEFORE the dialog is created.
|
|
// Register without a name-filter so we can confirm it fires on this client build.
|
|
AddonLifecycle.RegisterListener(AddonEvent.PreSetup, OnInputNumericPreSetup);
|
|
AddonLifecycle.RegisterListener(AddonEvent.PreDraw, OnAddonPreDraw);
|
|
|
|
Log.Information($"Loaded {PluginInterface.Manifest.Name}.");
|
|
Log.Information($"[QuickTransfer] DebugMode={Configuration.DebugMode}, Enabled={Configuration.Enabled}");
|
|
if (Configuration.DebugMode)
|
|
{
|
|
try
|
|
{
|
|
var matches = Enum.GetNames<FFXIVClientStructs.FFXIV.Client.Game.InventoryType>()
|
|
.Where(n => n.Contains("FreeCompany", StringComparison.OrdinalIgnoreCase) ||
|
|
n.Contains("Company", StringComparison.OrdinalIgnoreCase) ||
|
|
n.Contains("Chest", StringComparison.OrdinalIgnoreCase))
|
|
.ToArray();
|
|
Log.Information($"[QuickTransfer] InventoryType names containing Company/Chest: {string.Join(", ", matches)}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Warning(ex, "[QuickTransfer] Failed to enumerate InventoryType names (debug).");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Framework.Update -= OnFrameworkUpdate;
|
|
ContextMenu.OnMenuOpened -= OnContextMenuOpened;
|
|
AddonLifecycle.UnregisterListener(AddonEvent.PreSetup, OnInputNumericPreSetup);
|
|
AddonLifecycle.UnregisterListener(AddonEvent.PreDraw, OnAddonPreDraw);
|
|
|
|
openForItemSlotHook?.Disable();
|
|
openForItemSlotHook?.Dispose();
|
|
|
|
PluginInterface.UiBuilder.Draw -= windowSystem.Draw;
|
|
PluginInterface.UiBuilder.OpenConfigUi -= OpenConfigUi;
|
|
|
|
windowSystem.RemoveAllWindows();
|
|
configWindow.Dispose();
|
|
|
|
CommandManager.RemoveHandler(CommandName);
|
|
}
|
|
|
|
private void OnCommand(string command, string args) => OpenConfigUi();
|
|
|
|
private void OpenConfigUi() => configWindow.IsOpen = true;
|
|
|
|
private void OpenForItemSlotDetour(
|
|
AgentInventoryContext* agent,
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType inventoryType,
|
|
int slot,
|
|
int a4,
|
|
uint addonId)
|
|
{
|
|
openForItemSlotHook?.Original(agent, inventoryType, slot, a4, addonId);
|
|
|
|
if (!Configuration.Enabled)
|
|
return;
|
|
|
|
// Modifier: Ctrl+RClick (special) or Shift+RClick (default).
|
|
// Ctrl takes priority if both are held. Use a short "latch" so quick taps still work.
|
|
var mode = GetModifierModeLatched(Environment.TickCount64);
|
|
|
|
if (mode == null)
|
|
return;
|
|
|
|
var saddlebagOpen = IsSaddlebagOpen();
|
|
var retainerOpen = IsRetainerOpen();
|
|
var companyChestOpen = IsCompanyChestOpen();
|
|
var specialOpen = saddlebagOpen || retainerOpen || companyChestOpen;
|
|
|
|
// Ctrl is only enabled while a "special" container is open (Saddlebag or Retainer),
|
|
// so Shift/Ctrl can be used to disambiguate behaviors.
|
|
if (mode == ModifierMode.Ctrl && !specialOpen)
|
|
return;
|
|
|
|
// Never run Ctrl-mode from saddlebag slots.
|
|
if (mode == ModifierMode.Ctrl && IsSaddlebagType(inventoryType))
|
|
return;
|
|
|
|
// Never run Ctrl-mode from retainer slots.
|
|
if (mode == ModifierMode.Ctrl && IsRetainerType(inventoryType))
|
|
return;
|
|
|
|
// Never run Ctrl-mode from Company Chest slots.
|
|
if (mode == ModifierMode.Ctrl && IsCompanyChestType(inventoryType))
|
|
return;
|
|
|
|
var now = Environment.TickCount64;
|
|
if (now - lastActionTickMs < Configuration.TransferCooldownMs)
|
|
return;
|
|
|
|
if (mode == ModifierMode.Shift && companyChestOpen && Configuration.EnableCompanyChest)
|
|
{
|
|
// If a quantity dialog is already open, don't start another move.
|
|
if (TryGetVisibleAddon(InputNumericAddonName, out _))
|
|
return;
|
|
|
|
// Deposit: Inventory -> Company Chest (UI-driven move).
|
|
// This is handled as a small state machine so stacks can top-off existing stacks and spill into new stacks.
|
|
if (IsPlayerInventoryType(inventoryType) && StartCompanyChestDeposit(inventoryType, (uint)slot))
|
|
{
|
|
lastActionTickMs = now;
|
|
TryCloseCurrentContextMenu(agent);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (TryAutoSelectAndClose(agent, mode.Value, out var chosenText, out var chosenIndex))
|
|
{
|
|
lastActionTickMs = now;
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] ({mode} + RClick) Selected context action '{chosenText}' (idx={chosenIndex}) via OpenForItemSlot.");
|
|
}
|
|
else if (Configuration.DebugMode && mode == ModifierMode.Ctrl)
|
|
{
|
|
Log.Information("[QuickTransfer] (Ctrl + RClick) No matching armoury action found in context menu.");
|
|
DebugDumpContextMenu(agent, maxItems: 24);
|
|
}
|
|
}
|
|
|
|
private void OnContextMenuOpened(IMenuOpenedArgs args)
|
|
{
|
|
if (!Configuration.Enabled)
|
|
return;
|
|
|
|
var now = Environment.TickCount64;
|
|
var mode = GetModifierModeLatched(now);
|
|
|
|
if (mode == null)
|
|
return;
|
|
|
|
var saddlebagOpen = IsSaddlebagOpen();
|
|
var retainerOpen = IsRetainerOpen();
|
|
var companyChestOpen = IsCompanyChestOpen();
|
|
var specialOpen = saddlebagOpen || retainerOpen || companyChestOpen;
|
|
|
|
if (mode == ModifierMode.Ctrl && !specialOpen)
|
|
return;
|
|
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] OnMenuOpened: AddonName='{args.AddonName}', MenuType={args.MenuType}, AgentPtr=0x{args.AgentPtr.ToInt64():X}, AddonPtr=0x{args.AddonPtr.ToInt64():X}");
|
|
|
|
// Free Company Chest uses MenuType.Default (not Inventory).
|
|
if (args.MenuType == ContextMenuType.Default &&
|
|
mode == ModifierMode.Shift &&
|
|
Configuration.EnableCompanyChest &&
|
|
string.Equals(args.AddonName, FreeCompanyChestAddonName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
pendingDeferredDefaultMenu = (args.AddonName ?? string.Empty, now, mode.Value);
|
|
return;
|
|
}
|
|
|
|
// Only deal with inventory context menus otherwise.
|
|
if (args.MenuType != ContextMenuType.Inventory)
|
|
return;
|
|
|
|
if (args.AgentPtr == IntPtr.Zero || args.AddonPtr == IntPtr.Zero)
|
|
return;
|
|
|
|
// IMPORTANT: Do not click inside the open event (re-entrancy risk).
|
|
pendingDeferredMenuClick = ((nint)args.AgentPtr, (nint)args.AddonPtr, Environment.TickCount64, mode.Value);
|
|
}
|
|
|
|
private void OnFrameworkUpdate(IFramework framework)
|
|
{
|
|
if (!Configuration.Enabled)
|
|
return;
|
|
|
|
var now = Environment.TickCount64;
|
|
|
|
// Modifier latch (helps cases where the user taps Shift/Ctrl quickly).
|
|
if (KeyState[VirtualKey.SHIFT])
|
|
lastShiftSeenMs = now;
|
|
if (KeyState[VirtualKey.CONTROL])
|
|
lastCtrlSeenMs = now;
|
|
|
|
// Company Chest quantity prompt auto-confirm (best effort).
|
|
if (Configuration.EnableCompanyChest &&
|
|
Configuration.AutoConfirmCompanyChestQuantity &&
|
|
pendingCompanyChestNumericConfirmUntilMs > 0 &&
|
|
now <= pendingCompanyChestNumericConfirmUntilMs)
|
|
{
|
|
if (TryGetVisibleAddon(InputNumericAddonName, out var inputNumeric))
|
|
{
|
|
suppressInputNumeric = true;
|
|
// Phase 1: set max (and wait a frame so the component commits the value internally).
|
|
if (!pendingCompanyChestNumericValueSet)
|
|
{
|
|
if (!TrySetInputNumericToMax(inputNumeric, pendingNumericKind))
|
|
{
|
|
// Prompt doesn't match expectation; stop (prevents confirming wrong dialogs).
|
|
pendingCompanyChestNumericConfirmUntilMs = 0;
|
|
pendingCompanyChestNumericArmed = false;
|
|
pendingNumericKind = PendingNumericKind.None;
|
|
}
|
|
else
|
|
{
|
|
pendingCompanyChestNumericValueSet = true;
|
|
pendingCompanyChestNumericValueSetAtMs = now;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Phase 2: confirm after a short delay (next frame / ~50ms).
|
|
if (now - pendingCompanyChestNumericValueSetAtMs < 50)
|
|
return;
|
|
|
|
// Re-check prompt + re-apply max right before confirming (cheap + safer).
|
|
if (!TrySetInputNumericToMax(inputNumeric, pendingNumericKind))
|
|
{
|
|
pendingCompanyChestNumericConfirmUntilMs = 0;
|
|
pendingCompanyChestNumericArmed = false;
|
|
pendingNumericKind = PendingNumericKind.None;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (pendingCompanyChestNumericConfirmAttempts == 0)
|
|
{
|
|
// IMPORTANT:
|
|
// For InputNumeric, FireCallbackInt(value) is interpreted as the quantity being confirmed on this client build.
|
|
// Passing "2" causes exactly the observed behavior: moving 2 every time.
|
|
var toConfirm = pendingCompanyChestNumericDesired;
|
|
if (toConfirm == 0)
|
|
toConfirm = 1;
|
|
inputNumeric->FireCallbackInt((int)toConfirm);
|
|
pendingCompanyChestNumericConfirmAttempts = 1;
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] Auto-confirmed InputNumeric (Company Chest) attempt 1 (FireCallbackInt={toConfirm}).");
|
|
|
|
// Clear state after issuing confirm; the dialog should close itself.
|
|
pendingCompanyChestNumericConfirmUntilMs = 0;
|
|
pendingCompanyChestNumericArmed = false;
|
|
pendingNumericKind = PendingNumericKind.None;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
pendingCompanyChestNumericDesired = 0;
|
|
suppressInputNumeric = false;
|
|
}
|
|
else
|
|
{
|
|
pendingCompanyChestNumericConfirmUntilMs = 0;
|
|
pendingCompanyChestNumericArmed = false;
|
|
pendingNumericKind = PendingNumericKind.None;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
pendingCompanyChestNumericDesired = 0;
|
|
suppressInputNumeric = false;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
pendingCompanyChestNumericConfirmUntilMs = 0;
|
|
pendingCompanyChestNumericArmed = false;
|
|
pendingNumericKind = PendingNumericKind.None;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
pendingCompanyChestNumericDesired = 0;
|
|
suppressInputNumeric = false;
|
|
Log.Warning(ex, "[QuickTransfer] Failed to auto-confirm InputNumeric.");
|
|
}
|
|
}
|
|
}
|
|
else if (pendingCompanyChestNumericConfirmUntilMs > 0 && now > pendingCompanyChestNumericConfirmUntilMs)
|
|
{
|
|
pendingCompanyChestNumericConfirmUntilMs = 0;
|
|
pendingCompanyChestNumericArmed = false;
|
|
pendingNumericKind = PendingNumericKind.None;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
pendingCompanyChestNumericDesired = 0;
|
|
suppressInputNumeric = false;
|
|
}
|
|
|
|
// If we have a pending "move outValue" buffer for InputNumeric-driven moves, free it once the dialog is gone,
|
|
// or when the timeout expires.
|
|
if (pendingMoveOutValuePtr != 0 || pendingMoveAtkValuesPtr != 0)
|
|
{
|
|
var inputVisible = TryGetVisibleAddon(InputNumericAddonName, out _);
|
|
if (inputVisible)
|
|
pendingMoveSawInputNumeric = true;
|
|
|
|
// Important: InputNumeric often appears on a subsequent frame.
|
|
// Do NOT free the buffers immediately just because it's not visible yet.
|
|
var graceExpired = pendingMoveCreatedAtMs > 0 && now - pendingMoveCreatedAtMs >= 1500;
|
|
if ((pendingMoveSawInputNumeric && !inputVisible) || now >= pendingMoveOutValueFreeAtMs || (!inputVisible && graceExpired))
|
|
{
|
|
try { if (pendingMoveOutValuePtr != 0) Marshal.FreeHGlobal(pendingMoveOutValuePtr); } catch { /* ignore */ }
|
|
try { if (pendingMoveAtkValuesPtr != 0) Marshal.FreeHGlobal(pendingMoveAtkValuesPtr); } catch { /* ignore */ }
|
|
pendingMoveOutValuePtr = 0;
|
|
pendingMoveOutValueFreeAtMs = 0;
|
|
pendingMoveAtkValuesPtr = 0;
|
|
pendingMoveCreatedAtMs = 0;
|
|
pendingMoveSawInputNumeric = false;
|
|
}
|
|
}
|
|
|
|
// Company Chest deposit state machine (Inventory -> FC Chest).
|
|
if (Configuration.EnableCompanyChest)
|
|
ProcessCompanyChestDeposit(now);
|
|
|
|
// Delay-close the context menu slightly; closing immediately can cancel some default-menu actions.
|
|
if (pendingCloseContextMenuAtMs > 0 && now >= pendingCloseContextMenuAtMs)
|
|
{
|
|
pendingCloseContextMenuAtMs = 0;
|
|
try
|
|
{
|
|
var cm = (AtkUnitBase*)GameGui.GetAddonByName("ContextMenu", 1).Address;
|
|
if (cm != null)
|
|
{
|
|
try { cm->Hide(false, true, 0); } catch { /* ignore */ }
|
|
try { atkUnitBaseClose?.Invoke(cm, 0); } catch { /* ignore */ }
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
// Handle deferred "default" context menus (e.g., FreeCompanyChest).
|
|
var pendingDefault = pendingDeferredDefaultMenu;
|
|
if (pendingDefault != null)
|
|
{
|
|
pendingDeferredDefaultMenu = null;
|
|
|
|
if (now - pendingDefault.Value.EnqueuedAtMs <= 1500 &&
|
|
pendingDefault.Value.Mode == ModifierMode.Shift &&
|
|
pendingDefault.Value.AddonName.Equals(FreeCompanyChestAddonName, StringComparison.OrdinalIgnoreCase) &&
|
|
Configuration.EnableCompanyChest)
|
|
{
|
|
suppressContextMenu = true;
|
|
if (TrySelectRemoveFromCompanyChestContextMenu())
|
|
{
|
|
lastActionTickMs = now;
|
|
pendingCompanyChestNumericConfirmUntilMs = Configuration.AutoConfirmCompanyChestQuantity ? now + 1500 : 0;
|
|
pendingCompanyChestNumericConfirmAttempts = 0;
|
|
pendingCompanyChestNumericArmed = true;
|
|
pendingNumericKind = PendingNumericKind.Remove;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
pendingCompanyChestNumericDesired = 0;
|
|
}
|
|
// Keep suppression on while the remove dialog is being handled.
|
|
}
|
|
}
|
|
|
|
var pending = pendingDeferredMenuClick;
|
|
if (pending == null)
|
|
return;
|
|
|
|
// Consume (only try once).
|
|
pendingDeferredMenuClick = null;
|
|
|
|
if (now - pending.Value.EnqueuedAtMs > 1500)
|
|
return;
|
|
|
|
// If we already acted this tick/window via OpenForItemSlot, don't deref pointers.
|
|
if (now - lastActionTickMs < Configuration.TransferCooldownMs)
|
|
return;
|
|
|
|
try
|
|
{
|
|
var agent = (AgentInventoryContext*)pending.Value.AgentPtr;
|
|
var addon = (AtkUnitBase*)pending.Value.AddonPtr;
|
|
|
|
if (TryAutoSelectAndClose(agent, addon, pending.Value.Mode, out var chosenText, out var chosenIndex))
|
|
{
|
|
lastActionTickMs = now;
|
|
suppressContextMenu = true;
|
|
if (Configuration.EnableCompanyChest &&
|
|
pending.Value.Mode == ModifierMode.Shift &&
|
|
chosenText.Length > 0 &&
|
|
ContextLabelMatches(AutoContextAction.RemoveFromCompanyChest, chosenText))
|
|
{
|
|
pendingCompanyChestNumericConfirmUntilMs = Configuration.AutoConfirmCompanyChestQuantity ? now + 1500 : 0;
|
|
pendingCompanyChestNumericConfirmAttempts = 0;
|
|
pendingCompanyChestNumericArmed = true;
|
|
pendingNumericKind = PendingNumericKind.Remove;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
pendingCompanyChestNumericDesired = 0;
|
|
}
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] ({pending.Value.Mode} + RClick) Selected context action '{chosenText}' (idx={chosenIndex}) via deferred OnMenuOpened.");
|
|
}
|
|
else if (Configuration.DebugMode && pending.Value.Mode == ModifierMode.Ctrl)
|
|
{
|
|
Log.Information("[QuickTransfer] (Ctrl + RClick) Deferred menu opened but no matching 'Place in Armoury Chest' action was found.");
|
|
DebugDumpContextMenu(agent, maxItems: 24);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Warning(ex, "[QuickTransfer] Deferred menu select failed.");
|
|
}
|
|
}
|
|
|
|
private void OnAddonPreDraw(AddonEvent type, AddonArgs args)
|
|
{
|
|
try
|
|
{
|
|
var name = args.AddonName ?? string.Empty;
|
|
|
|
if (suppressContextMenu && string.Equals(name, ContextMenuAddonName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var addon = (AtkUnitBase*)args.Addon.Address;
|
|
MakeAddonInvisible(addon);
|
|
}
|
|
|
|
if (suppressInputNumeric && string.Equals(name, InputNumericAddonName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var addon = (AtkUnitBase*)args.Addon.Address;
|
|
MakeAddonInvisible(addon);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
private static void MakeAddonInvisible(AtkUnitBase* addon)
|
|
{
|
|
if (addon == null)
|
|
return;
|
|
var root = addon->RootNode;
|
|
if (root == null)
|
|
return;
|
|
|
|
// Keep it logically visible/interactive, but force it fully transparent before it draws.
|
|
root->Color.A = 0;
|
|
root->Alpha_2 = 0;
|
|
}
|
|
|
|
private void OnInputNumericPreSetup(AddonEvent type, AddonArgs args)
|
|
{
|
|
try
|
|
{
|
|
if (!Configuration.EnableCompanyChest)
|
|
return;
|
|
|
|
if (!pendingCompanyChestNumericArmed)
|
|
return;
|
|
|
|
if (!string.Equals(args.AddonName, InputNumericAddonName, StringComparison.OrdinalIgnoreCase))
|
|
return;
|
|
|
|
// Only touch this dialog if the Company Chest is open (avoid affecting unrelated InputNumeric uses).
|
|
if (!IsCompanyChestOpen())
|
|
return;
|
|
|
|
if (args is not AddonSetupArgs setup)
|
|
return;
|
|
|
|
var values = (AtkValue*)setup.AtkValues;
|
|
var count = (int)setup.AtkValueCount;
|
|
if (values == null || count < 7)
|
|
return;
|
|
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] InputNumeric PreSetup (armed): AtkValueCount={count}");
|
|
|
|
// Guard against cross-confirmation: only touch the prompt we intended (store/remove).
|
|
if (pendingNumericKind != PendingNumericKind.None)
|
|
{
|
|
var prompt = values[6].Type is AtkValueType.String or AtkValueType.ManagedString ? ReadAtkValueString(values[6]) : string.Empty;
|
|
if (pendingNumericKind == PendingNumericKind.Store && !prompt.Contains("store", StringComparison.OrdinalIgnoreCase))
|
|
return;
|
|
if (pendingNumericKind == PendingNumericKind.Remove && !prompt.Contains("remove", StringComparison.OrdinalIgnoreCase))
|
|
return;
|
|
}
|
|
|
|
// Standard InputNumeric layout (also used by SimpleTweaks):
|
|
// [2]=min (UInt), [3]=max (UInt), [4]=default (UInt), [6]=prompt text (String)
|
|
if (values[2].Type != AtkValueType.UInt || values[3].Type != AtkValueType.UInt || values[4].Type != AtkValueType.UInt)
|
|
{
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] InputNumeric PreSetup: unexpected types: [2]={values[2].Type}, [3]={values[3].Type}, [4]={values[4].Type}");
|
|
return;
|
|
}
|
|
|
|
var min = values[2].UInt;
|
|
var max = values[3].UInt;
|
|
var desired = max < min ? min : max;
|
|
|
|
// Log current/default if present.
|
|
if (Configuration.DebugMode)
|
|
{
|
|
var curStr = (count > 5 && values[5].Type == AtkValueType.UInt) ? values[5].UInt.ToString() : "n/a";
|
|
Log.Information($"[QuickTransfer] InputNumeric PreSetup: min={min}, max={max}, default={values[4].UInt}, current={curStr}");
|
|
}
|
|
|
|
values[4].UInt = desired; // default
|
|
if (count > 5)
|
|
{
|
|
if (values[5].Type == AtkValueType.UInt)
|
|
values[5].UInt = desired; // some layouts have current (UInt)
|
|
else if (values[5].Type is AtkValueType.String or AtkValueType.ManagedString or AtkValueType.String8)
|
|
WriteUtf8InPlace(values[5].String, desired.ToString()); // some builds use String current
|
|
}
|
|
|
|
if (Configuration.DebugMode)
|
|
{
|
|
var prompt = values[6].Type is AtkValueType.String or AtkValueType.ManagedString ? ReadAtkValueString(values[6]) : string.Empty;
|
|
Log.Information($"[QuickTransfer] InputNumeric PreSetup: prompt='{prompt}', min={min}, max={max}, setDefault={desired}");
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Warning(ex, "[QuickTransfer] InputNumeric PreSetup failed.");
|
|
}
|
|
}
|
|
|
|
private bool TryAutoSelectAndClose(AgentInventoryContext* agent, ModifierMode mode, out string chosenText, out int chosenIndex)
|
|
{
|
|
chosenText = string.Empty;
|
|
chosenIndex = -1;
|
|
|
|
var agentAddonId = agent->AgentInterface.GetAddonId();
|
|
if (agentAddonId == 0)
|
|
return false;
|
|
|
|
var addon = GetAddonById(agentAddonId);
|
|
if (addon == null)
|
|
{
|
|
var cm = GameGui.GetAddonByName("ContextMenu", 1);
|
|
addon = (AtkUnitBase*)cm.Address;
|
|
}
|
|
|
|
if (addon == null)
|
|
return false;
|
|
|
|
return TryAutoSelectAndClose(agent, addon, mode, out chosenText, out chosenIndex);
|
|
}
|
|
|
|
private bool TryAutoSelectAndClose(AgentInventoryContext* agent, AtkUnitBase* contextMenuAddon, ModifierMode mode, out string chosenText, out int chosenIndex)
|
|
{
|
|
chosenText = string.Empty;
|
|
chosenIndex = -1;
|
|
|
|
// Single-pass: decode each label once, record first match per action.
|
|
var foundAny = false;
|
|
|
|
int removeIdx = -1, addIdx = -1, placeIdx = -1, returnIdx = -1, entrustIdx = -1, retrieveIdx = -1, companyRemoveIdx = -1;
|
|
string? removeTxt = null, addTxt = null, placeTxt = null, returnTxt = null, entrustTxt = null, retrieveTxt = null, companyRemoveTxt = null;
|
|
|
|
var max = Math.Min(agent->ContextItemCount, 64);
|
|
for (var i = 0; i < max; i++)
|
|
{
|
|
var param = agent->EventParams[agent->ContexItemStartIndex + i];
|
|
if (param.Type is not (AtkValueType.String or AtkValueType.ManagedString))
|
|
continue;
|
|
|
|
var text = ReadAtkValueString(param);
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
continue;
|
|
|
|
foundAny = true;
|
|
|
|
// Priority matters: we want the first matching index for each action.
|
|
if (removeIdx < 0 && ContextLabelMatches(AutoContextAction.RemoveAllFromSaddlebag, text))
|
|
{
|
|
removeIdx = i;
|
|
removeTxt = text;
|
|
continue;
|
|
}
|
|
|
|
if (companyRemoveIdx < 0 && ContextLabelMatches(AutoContextAction.RemoveFromCompanyChest, text))
|
|
{
|
|
companyRemoveIdx = i;
|
|
companyRemoveTxt = text;
|
|
continue;
|
|
}
|
|
|
|
if (addIdx < 0 && ContextLabelMatches(AutoContextAction.AddAllToSaddlebag, text))
|
|
{
|
|
addIdx = i;
|
|
addTxt = text;
|
|
continue;
|
|
}
|
|
|
|
if (placeIdx < 0 && ContextLabelMatches(AutoContextAction.PlaceInArmouryChest, text))
|
|
{
|
|
placeIdx = i;
|
|
placeTxt = text;
|
|
continue;
|
|
}
|
|
|
|
if (returnIdx < 0 && ContextLabelMatches(AutoContextAction.ReturnToInventory, text))
|
|
{
|
|
returnIdx = i;
|
|
returnTxt = text;
|
|
continue;
|
|
}
|
|
|
|
if (entrustIdx < 0 && ContextLabelMatches(AutoContextAction.EntrustToRetainer, text))
|
|
{
|
|
entrustIdx = i;
|
|
entrustTxt = text;
|
|
continue;
|
|
}
|
|
|
|
if (retrieveIdx < 0 && ContextLabelMatches(AutoContextAction.RetrieveFromRetainer, text))
|
|
{
|
|
retrieveIdx = i;
|
|
retrieveTxt = text;
|
|
}
|
|
}
|
|
|
|
if (!foundAny)
|
|
return false;
|
|
|
|
var saddlebagOpen = IsSaddlebagOpen();
|
|
var retainerOpen = IsRetainerOpen();
|
|
var companyChestOpen = IsCompanyChestOpen();
|
|
|
|
// Choose the best action that exists in the menu.
|
|
//
|
|
// When Company Chest is open:
|
|
// - Shift mode: remove from chest (withdraw)
|
|
// - Ctrl mode: armoury actions (Inventory <-> Armoury) are allowed (like other "special" containers)
|
|
//
|
|
// When Retainer is open:
|
|
// - Shift mode: retainer actions (Entrust/Retrieve), and if Saddlebags are also open, retainer<->saddlebag.
|
|
//
|
|
// When Saddlebags are open (no retainer):
|
|
// - Shift mode: saddlebag actions (Add/Remove)
|
|
//
|
|
// Ctrl mode (only enabled when Retainer OR Saddlebags are open):
|
|
// - Armoury actions (Inventory <-> Armoury): Return/Place
|
|
//
|
|
// No Retainer/Saddlebags:
|
|
// - Shift mode: allow armoury transfers (Place/Return).
|
|
(int idx, string? txt) chosen;
|
|
if (mode == ModifierMode.Shift && companyChestOpen && Configuration.EnableCompanyChest)
|
|
{
|
|
chosen = companyRemoveIdx >= 0 ? (companyRemoveIdx, companyRemoveTxt) : (-1, (string?)null);
|
|
}
|
|
else if (mode == ModifierMode.Ctrl)
|
|
{
|
|
chosen = returnIdx >= 0 ? (returnIdx, returnTxt) :
|
|
placeIdx >= 0 ? (placeIdx, placeTxt) :
|
|
(-1, (string?)null);
|
|
}
|
|
else if (retainerOpen)
|
|
{
|
|
if (saddlebagOpen)
|
|
{
|
|
// Retainer <-> Saddlebag:
|
|
// - Retainer item: Add All to Saddlebag
|
|
// - Saddlebag item: Entrust to Retainer
|
|
chosen = addIdx >= 0 ? (addIdx, addTxt) :
|
|
entrustIdx >= 0 ? (entrustIdx, entrustTxt) :
|
|
// last-resort fallback
|
|
removeIdx >= 0 ? (removeIdx, removeTxt) :
|
|
(-1, (string?)null);
|
|
}
|
|
else
|
|
{
|
|
// Retainer <-> Player (Inventory/Armoury):
|
|
// - Retainer item: Retrieve from Retainer
|
|
// - Player item: Entrust to Retainer
|
|
chosen = retrieveIdx >= 0 ? (retrieveIdx, retrieveTxt) :
|
|
entrustIdx >= 0 ? (entrustIdx, entrustTxt) :
|
|
(-1, (string?)null);
|
|
}
|
|
}
|
|
else if (saddlebagOpen)
|
|
{
|
|
chosen = removeIdx >= 0 ? (removeIdx, removeTxt) :
|
|
addIdx >= 0 ? (addIdx, addTxt) :
|
|
(-1, (string?)null);
|
|
}
|
|
else
|
|
{
|
|
chosen = placeIdx >= 0 ? (placeIdx, placeTxt) :
|
|
returnIdx >= 0 ? (returnIdx, returnTxt) :
|
|
(-1, (string?)null);
|
|
}
|
|
|
|
if (chosen.idx < 0 || string.IsNullOrWhiteSpace(chosen.txt))
|
|
return false;
|
|
|
|
GenerateCallback(contextMenuAddon, 0, chosen.idx, 0U, 0, 0);
|
|
CloseContextMenuAddon(agent, contextMenuAddon);
|
|
|
|
chosenText = chosen.txt!;
|
|
chosenIndex = chosen.idx;
|
|
return true;
|
|
}
|
|
|
|
private bool StartCompanyChestDeposit(FFXIVClientStructs.FFXIV.Client.Game.InventoryType sourceType, uint sourceSlot)
|
|
{
|
|
try
|
|
{
|
|
if (!Configuration.EnableCompanyChest)
|
|
return false;
|
|
if (RaptureAtkModule.Instance() == null)
|
|
return false;
|
|
if (!IsCompanyChestOpen())
|
|
return false;
|
|
if (!IsPlayerInventoryType(sourceType))
|
|
return false;
|
|
|
|
if (!TryGetItemInfo(sourceType, (int)sourceSlot, out var itemId, out var isHq, out var qty))
|
|
return false;
|
|
|
|
var now = Environment.TickCount64;
|
|
companyChestDeposit = new CompanyChestDepositState
|
|
{
|
|
Active = true,
|
|
SourceType = sourceType,
|
|
SourceSlot = sourceSlot,
|
|
ItemId = itemId,
|
|
IsHq = isHq,
|
|
NextAttemptAtMs = now,
|
|
ExpiresAtMs = now + 12000,
|
|
Steps = 0,
|
|
LastQty = qty,
|
|
WaitForQtyChangeUntilMs = 0,
|
|
};
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void ProcessCompanyChestDeposit(long now)
|
|
{
|
|
if (!companyChestDeposit.Active)
|
|
return;
|
|
|
|
// Stop if conditions no longer apply.
|
|
if (!Configuration.EnableCompanyChest || RaptureAtkModule.Instance() == null || !IsCompanyChestOpen())
|
|
{
|
|
companyChestDeposit.Active = false;
|
|
return;
|
|
}
|
|
|
|
if (now >= companyChestDeposit.ExpiresAtMs || companyChestDeposit.Steps >= 40)
|
|
{
|
|
companyChestDeposit.Active = false;
|
|
return;
|
|
}
|
|
|
|
// If we just issued a move, wait for the source stack quantity to change (or for the dialog to appear).
|
|
// This prevents spamming the same move over and over when the game hasn't applied it yet.
|
|
if (companyChestDeposit.WaitForQtyChangeUntilMs > 0 && now <= companyChestDeposit.WaitForQtyChangeUntilMs)
|
|
{
|
|
if (TryGetVisibleAddon(InputNumericAddonName, out _))
|
|
return;
|
|
|
|
if (TryGetItemInfo(companyChestDeposit.SourceType, (int)companyChestDeposit.SourceSlot, out var _, out var _, out var qNow) &&
|
|
qNow != companyChestDeposit.LastQty)
|
|
{
|
|
companyChestDeposit.LastQty = qNow;
|
|
companyChestDeposit.WaitForQtyChangeUntilMs = 0;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Don't issue a new move while the quantity dialog is open.
|
|
if (TryGetVisibleAddon(InputNumericAddonName, out _))
|
|
return;
|
|
|
|
if (now < companyChestDeposit.NextAttemptAtMs)
|
|
return;
|
|
|
|
if (!TryGetItemInfo(companyChestDeposit.SourceType, (int)companyChestDeposit.SourceSlot, out var itemId, out var isHq, out var qty) ||
|
|
itemId == 0 ||
|
|
qty == 0)
|
|
{
|
|
companyChestDeposit.Active = false;
|
|
return;
|
|
}
|
|
|
|
// If the slot changed (user moved/split), stop to avoid moving the wrong thing.
|
|
if (itemId != companyChestDeposit.ItemId || isHq != companyChestDeposit.IsHq)
|
|
{
|
|
companyChestDeposit.Active = false;
|
|
return;
|
|
}
|
|
|
|
var pages = GetCompanyChestInventoryTypes();
|
|
if (pages.Length == 0)
|
|
{
|
|
companyChestDeposit.Active = false;
|
|
return;
|
|
}
|
|
|
|
var maxStack = GetItemStackSize(itemId);
|
|
var needsQuantityConfirm = qty > 1 && maxStack > 1;
|
|
|
|
// Prefer stacking into an existing stack; otherwise use the first empty slot.
|
|
if (!TryFindCompanyChestBestStackSlot(pages, itemId, isHq, maxStack, out var destType, out var destSlot) &&
|
|
!TryFindCompanyChestFirstEmptySlot(pages, out destType, out destSlot))
|
|
{
|
|
companyChestDeposit.Active = false;
|
|
return;
|
|
}
|
|
|
|
if (!TryCompanyChestMoveItem(companyChestDeposit.SourceType, companyChestDeposit.SourceSlot, destType, destSlot, needsQuantityConfirm))
|
|
{
|
|
companyChestDeposit.Active = false;
|
|
return;
|
|
}
|
|
|
|
companyChestDeposit.Steps++;
|
|
companyChestDeposit.NextAttemptAtMs = now + (needsQuantityConfirm ? 600 : 350);
|
|
companyChestDeposit.LastQty = qty;
|
|
companyChestDeposit.WaitForQtyChangeUntilMs = now + (needsQuantityConfirm ? 2000 : 1200);
|
|
|
|
if (Configuration.AutoConfirmCompanyChestQuantity && needsQuantityConfirm)
|
|
{
|
|
pendingCompanyChestNumericConfirmUntilMs = now + 1500;
|
|
pendingCompanyChestNumericConfirmAttempts = 0;
|
|
pendingCompanyChestNumericArmed = true;
|
|
pendingNumericKind = PendingNumericKind.Store;
|
|
pendingCompanyChestNumericValueSet = false;
|
|
pendingCompanyChestNumericValueSetAtMs = 0;
|
|
pendingCompanyChestNumericDesired = 0;
|
|
}
|
|
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] (Shift+RClick) Company Chest deposit step {companyChestDeposit.Steps}: {companyChestDeposit.SourceType} slot={companyChestDeposit.SourceSlot} -> {destType} slot={destSlot} (qty={qty}, stackMax={maxStack}).");
|
|
}
|
|
|
|
private bool TryCompanyChestMoveItem(
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType sourceType,
|
|
uint sourceSlot,
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType destType,
|
|
uint destSlot,
|
|
bool keepAliveForInputNumeric)
|
|
{
|
|
var module = RaptureAtkModule.Instance();
|
|
if (module == null)
|
|
return false;
|
|
|
|
// IMPORTANT:
|
|
// HandleItemMove expects InventoryType values (e.g. Inventory1=0, FreeCompanyPage1=20000),
|
|
// not "container ids" like 48/57.
|
|
var srcInvType = (uint)sourceType;
|
|
var dstInvType = (uint)destType;
|
|
|
|
nint localValuesAlloc = 0;
|
|
nint localRetAlloc = 0;
|
|
try
|
|
{
|
|
AtkValue* values;
|
|
AtkValue* ret;
|
|
if (keepAliveForInputNumeric)
|
|
{
|
|
// Keep alive across the InputNumeric dialog.
|
|
if (pendingMoveOutValuePtr != 0)
|
|
{
|
|
try { Marshal.FreeHGlobal(pendingMoveOutValuePtr); } catch { /* ignore */ }
|
|
pendingMoveOutValuePtr = 0;
|
|
}
|
|
if (pendingMoveAtkValuesPtr != 0)
|
|
{
|
|
try { Marshal.FreeHGlobal(pendingMoveAtkValuesPtr); } catch { /* ignore */ }
|
|
pendingMoveAtkValuesPtr = 0;
|
|
}
|
|
|
|
pendingMoveOutValuePtr = Marshal.AllocHGlobal(sizeof(AtkValue));
|
|
pendingMoveAtkValuesPtr = Marshal.AllocHGlobal(sizeof(AtkValue) * 4);
|
|
pendingMoveCreatedAtMs = Environment.TickCount64;
|
|
pendingMoveSawInputNumeric = false;
|
|
pendingMoveOutValueFreeAtMs = pendingMoveCreatedAtMs + 8000;
|
|
|
|
ret = (AtkValue*)pendingMoveOutValuePtr;
|
|
values = (AtkValue*)pendingMoveAtkValuesPtr;
|
|
}
|
|
else
|
|
{
|
|
localRetAlloc = Marshal.AllocHGlobal(sizeof(AtkValue));
|
|
localValuesAlloc = Marshal.AllocHGlobal(sizeof(AtkValue) * 4);
|
|
ret = (AtkValue*)localRetAlloc;
|
|
values = (AtkValue*)localValuesAlloc;
|
|
}
|
|
|
|
ret->Type = AtkValueType.Int;
|
|
ret->Int = 0;
|
|
|
|
for (var i = 0; i < 4; i++) values[i].Type = AtkValueType.UInt;
|
|
values[0].UInt = srcInvType;
|
|
values[1].UInt = sourceSlot;
|
|
values[2].UInt = dstInvType;
|
|
values[3].UInt = destSlot;
|
|
|
|
module->HandleItemMove(ret, values, 4);
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Warning(ex, "[QuickTransfer] Company Chest HandleItemMove failed.");
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
if (localRetAlloc != 0) { try { Marshal.FreeHGlobal(localRetAlloc); } catch { /* ignore */ } }
|
|
if (localValuesAlloc != 0) { try { Marshal.FreeHGlobal(localValuesAlloc); } catch { /* ignore */ } }
|
|
}
|
|
}
|
|
|
|
private static bool TryFindCompanyChestFirstEmptySlot(
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType[] pages,
|
|
out FFXIVClientStructs.FFXIV.Client.Game.InventoryType destType,
|
|
out uint destSlot)
|
|
{
|
|
destType = default;
|
|
destSlot = 0;
|
|
|
|
if (pages.Length == 0)
|
|
return false;
|
|
|
|
var inv = InventoryManager.Instance();
|
|
if (inv == null)
|
|
return false;
|
|
|
|
const int slotCap = 80;
|
|
foreach (var t in pages)
|
|
{
|
|
for (var i = 0; i < slotCap; i++)
|
|
{
|
|
var item = inv->GetInventorySlot(t, i);
|
|
if (item == null)
|
|
break;
|
|
if (item->ItemId == 0)
|
|
{
|
|
destType = t;
|
|
destSlot = (uint)i;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool TryFindCompanyChestBestStackSlot(
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType[] pages,
|
|
uint itemId,
|
|
bool isHq,
|
|
uint maxStack,
|
|
out FFXIVClientStructs.FFXIV.Client.Game.InventoryType destType,
|
|
out uint destSlot)
|
|
{
|
|
destType = default;
|
|
destSlot = 0;
|
|
|
|
if (pages.Length == 0 || itemId == 0 || maxStack <= 1)
|
|
return false;
|
|
|
|
var inv = InventoryManager.Instance();
|
|
if (inv == null)
|
|
return false;
|
|
|
|
const int slotCap = 80;
|
|
var bestFree = 0;
|
|
foreach (var t in pages)
|
|
{
|
|
for (var i = 0; i < slotCap; i++)
|
|
{
|
|
var it = inv->GetInventorySlot(t, i);
|
|
if (it == null)
|
|
break;
|
|
|
|
if (it->ItemId != itemId)
|
|
continue;
|
|
|
|
var hq = it->Flags.HasFlag(InventoryItem.ItemFlags.HighQuality);
|
|
if (hq != isHq)
|
|
continue;
|
|
|
|
var qty = it->Quantity;
|
|
if (qty <= 0)
|
|
continue;
|
|
|
|
var free = (int)maxStack - qty;
|
|
if (free <= 0)
|
|
continue;
|
|
|
|
if (free > bestFree)
|
|
{
|
|
bestFree = free;
|
|
destType = t;
|
|
destSlot = (uint)i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bestFree > 0;
|
|
}
|
|
|
|
private bool TrySetInputNumericToMax(AtkUnitBase* inputNumeric, PendingNumericKind kind)
|
|
{
|
|
try
|
|
{
|
|
if (inputNumeric == null)
|
|
return false;
|
|
if (inputNumeric->AtkValues == null || inputNumeric->AtkValuesCount < 7)
|
|
return false;
|
|
|
|
var minValue = inputNumeric->AtkValues + 2;
|
|
var maxValue = inputNumeric->AtkValues + 3;
|
|
var defaultValue = inputNumeric->AtkValues + 4;
|
|
var currentValue = inputNumeric->AtkValuesCount > 5 ? (inputNumeric->AtkValues + 5) : null;
|
|
var promptVal = inputNumeric->AtkValues + 6;
|
|
var prompt = promptVal->Type is AtkValueType.String or AtkValueType.ManagedString ? ReadAtkValueString(*promptVal) : string.Empty;
|
|
|
|
// Guard: only confirm prompts we expect.
|
|
if (kind == PendingNumericKind.Store && !prompt.Contains("store", StringComparison.OrdinalIgnoreCase))
|
|
return false;
|
|
if (kind == PendingNumericKind.Remove && !prompt.Contains("remove", StringComparison.OrdinalIgnoreCase))
|
|
return false;
|
|
|
|
if (minValue->Type != AtkValueType.UInt || maxValue->Type != AtkValueType.UInt || defaultValue->Type != AtkValueType.UInt)
|
|
return false;
|
|
|
|
// Set default = max (clamped).
|
|
var min = minValue->UInt;
|
|
var max = maxValue->UInt;
|
|
var desired = max < min ? min : max;
|
|
pendingCompanyChestNumericDesired = desired;
|
|
|
|
var beforeDefault = defaultValue->UInt;
|
|
var beforeCurrentUInt = (currentValue != null && currentValue->Type == AtkValueType.UInt) ? currentValue->UInt : 0U;
|
|
var beforeCurrentStr = (currentValue != null && currentValue->Type is (AtkValueType.String or AtkValueType.ManagedString or AtkValueType.String8))
|
|
? ReadAtkValueString(*currentValue)
|
|
: string.Empty;
|
|
|
|
// Many InputNumeric uses have both "default" and "current" values; set both so OK uses max.
|
|
defaultValue->UInt = desired;
|
|
if (currentValue != null)
|
|
{
|
|
if (currentValue->Type == AtkValueType.UInt)
|
|
{
|
|
currentValue->UInt = desired;
|
|
}
|
|
else if (currentValue->Type is (AtkValueType.String or AtkValueType.ManagedString or AtkValueType.String8))
|
|
{
|
|
// This dialog uses a String "current quantity" slot on your client build.
|
|
// Overwrite the existing buffer in-place (max is <= 999 so this is safe).
|
|
var s = desired.ToString();
|
|
WriteUtf8InPlace(currentValue->String, s);
|
|
}
|
|
}
|
|
|
|
// Critical: Some builds don't actually use AtkValues for the editable quantity; they use the NumericInput component's Raw/Evaluated strings.
|
|
// Set that too, if present, so the OK action applies "desired" instead of a stale value (e.g. 2).
|
|
TrySetInputNumericComponentValue(inputNumeric, desired);
|
|
|
|
if (Configuration.DebugMode)
|
|
{
|
|
var curType = currentValue != null ? currentValue->Type.ToString() : "n/a";
|
|
var afterCurrentUInt = (currentValue != null && currentValue->Type == AtkValueType.UInt) ? currentValue->UInt : 0U;
|
|
var afterCurrentStr = (currentValue != null && currentValue->Type is (AtkValueType.String or AtkValueType.ManagedString or AtkValueType.String8))
|
|
? ReadAtkValueString(*currentValue)
|
|
: string.Empty;
|
|
Log.Information($"[QuickTransfer] InputNumeric(Update): prompt='{prompt}', min={min}, max={max}, default {beforeDefault}->{defaultValue->UInt}, currentUInt {beforeCurrentUInt}->{afterCurrentUInt}, currentStr '{beforeCurrentStr}'->'{afterCurrentStr}' (idx5 type {curType})");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static void TrySetInputNumericComponentValue(AtkUnitBase* inputNumeric, uint desired)
|
|
{
|
|
try
|
|
{
|
|
if (inputNumeric == null)
|
|
return;
|
|
if (inputNumeric->UldManager.NodeList == null)
|
|
return;
|
|
|
|
var desiredStr = desired.ToString();
|
|
|
|
for (var i = 0; i < inputNumeric->UldManager.NodeListCount; i++)
|
|
{
|
|
var node = inputNumeric->UldManager.NodeList[i];
|
|
if (node == null)
|
|
continue;
|
|
|
|
if ((int)node->Type < 1000)
|
|
continue;
|
|
|
|
var compNode = (AtkComponentNode*)node;
|
|
var comp = compNode->Component;
|
|
if (comp == null)
|
|
continue;
|
|
|
|
if (comp->GetComponentType() != ComponentType.NumericInput)
|
|
continue;
|
|
|
|
var ni = (AtkComponentNumericInput*)comp;
|
|
|
|
// RawString / EvaluatedString are Utf8String.
|
|
WriteUtf8StringInPlace(&ni->RawString, desiredStr);
|
|
WriteUtf8StringInPlace(&ni->EvaluatedString, desiredStr);
|
|
|
|
// The authoritative value used by OK is the numeric input's internal Value.
|
|
// Setting strings alone can leave the internal Value at its old value (commonly 2).
|
|
ni->SetValue((int)desired);
|
|
|
|
// Update cursor to end.
|
|
ni->CursorPos = (ushort)desiredStr.Length;
|
|
ni->SelectionStart = ni->CursorPos;
|
|
ni->SelectionEnd = ni->CursorPos;
|
|
|
|
// Only need first numeric input.
|
|
return;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
private static void WriteUtf8StringInPlace(FFXIVClientStructs.FFXIV.Client.System.String.Utf8String* s, string value)
|
|
{
|
|
if (s == null)
|
|
return;
|
|
|
|
WriteUtf8InPlace(s->StringPtr, value);
|
|
s->StringLength = value.Length;
|
|
s->BufUsed = value.Length + 1;
|
|
}
|
|
|
|
private static void WriteUtf8InPlace(byte* dst, string value)
|
|
{
|
|
if (dst == null)
|
|
return;
|
|
|
|
var bytes = Encoding.UTF8.GetBytes(value);
|
|
// write bytes + null terminator
|
|
for (var i = 0; i < bytes.Length; i++)
|
|
dst[i] = bytes[i];
|
|
dst[bytes.Length] = 0;
|
|
}
|
|
|
|
private bool TrySelectRemoveFromCompanyChestContextMenu()
|
|
{
|
|
try
|
|
{
|
|
var ctxAddr = GameGui.GetAddonByName("ContextMenu", 1).Address;
|
|
if (ctxAddr == nint.Zero)
|
|
return false;
|
|
|
|
var ctxMenu = (AddonContextMenu*)ctxAddr;
|
|
if (ctxMenu == null)
|
|
return false;
|
|
|
|
// Find the list component and pick the row whose label is "Remove".
|
|
// FreeCompanyChest uses a Default context menu, so the AgentInventoryContext index-based selection does not apply.
|
|
for (uint listId = 1; listId <= 6; listId++)
|
|
{
|
|
var list = ctxMenu->GetComponentListById(listId);
|
|
if (list == null)
|
|
continue;
|
|
|
|
var itemCount = list->GetItemCount();
|
|
if (itemCount <= 0 || itemCount > 64)
|
|
continue;
|
|
|
|
for (var i = 0; i < itemCount; i++)
|
|
{
|
|
var labelPtr = list->GetItemLabel(i);
|
|
if (labelPtr == null)
|
|
continue;
|
|
|
|
var label = Marshal.PtrToStringUTF8(new IntPtr(labelPtr))?.TrimEnd('\0') ?? string.Empty;
|
|
if (string.IsNullOrWhiteSpace(label))
|
|
continue;
|
|
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] ContextMenu listId={listId} row={i} label='{label}'");
|
|
|
|
if (!label.Equals("Remove", StringComparison.OrdinalIgnoreCase))
|
|
continue;
|
|
|
|
// Trigger via callback payload (matches the inventory context menu pattern).
|
|
GenerateCallback((AtkUnitBase*)ctxMenu, 0, i, 0U, 0, 0);
|
|
|
|
// Close slightly later (immediate close can cancel the action).
|
|
pendingCloseContextMenuAtMs = Environment.TickCount64 + 50;
|
|
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] Triggered Company Chest 'Remove' (listId={listId}, row={i}).");
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Fallback: keep old string-scan (helpful for debugging), but don't attempt a blind click.
|
|
return ContextMenuContainsString((AtkUnitBase*)ctxMenu, "Remove");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Warning(ex, "[QuickTransfer] Failed to select Remove from Company Chest context menu.");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private bool ContextMenuContainsString(AtkUnitBase* ctxAddon, string needle)
|
|
{
|
|
try
|
|
{
|
|
if (ctxAddon == null || ctxAddon->AtkValues == null || ctxAddon->AtkValuesCount <= 0)
|
|
return false;
|
|
|
|
var count = Math.Min((int)ctxAddon->AtkValuesCount, 128);
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] ContextMenu AtkValuesCount={ctxAddon->AtkValuesCount} (scanning {count}).");
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
var v = ctxAddon->AtkValues[i];
|
|
if (v.Type is not (AtkValueType.String or AtkValueType.ManagedString or AtkValueType.String8))
|
|
continue;
|
|
|
|
var s = ReadAtkValueString(v);
|
|
if (string.IsNullOrWhiteSpace(s))
|
|
continue;
|
|
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] ContextMenu AtkValue[{i}] = '{s}'");
|
|
|
|
if (s.Contains(needle, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (Configuration.DebugMode)
|
|
Log.Information($"[QuickTransfer] ContextMenu contains '{needle}' (found '{s}' at AtkValue[{i}]).");
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// (removed) GetMoveContainerId:
|
|
// Company Chest transfers must use InventoryType values directly with RaptureAtkModule.HandleItemMove.
|
|
private static bool TryFindFirstCompanyChestEmptySlot(
|
|
out FFXIVClientStructs.FFXIV.Client.Game.InventoryType destType,
|
|
out uint destSlot)
|
|
{
|
|
destType = default;
|
|
destSlot = 0;
|
|
|
|
// This method is static; use all known pages as a fallback, callers should prefer GetCompanyChestInventoryTypes().
|
|
var invTypes = Enum.GetValues<FFXIVClientStructs.FFXIV.Client.Game.InventoryType>()
|
|
.Where(IsCompanyChestType)
|
|
.OrderBy(v => (int)v)
|
|
.ToArray();
|
|
if (invTypes.Length == 0)
|
|
return false;
|
|
|
|
var inv = InventoryManager.Instance();
|
|
if (inv == null)
|
|
return false;
|
|
|
|
// Most FC chest tabs are 50 slots; we keep a conservative cap.
|
|
const int slotCap = 80;
|
|
|
|
foreach (var t in invTypes)
|
|
{
|
|
for (var i = 0; i < slotCap; i++)
|
|
{
|
|
var item = inv->GetInventorySlot(t, i);
|
|
if (item == null)
|
|
break;
|
|
|
|
if (item->ItemId == 0)
|
|
{
|
|
destType = t;
|
|
destSlot = (uint)i;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool TryFindCompanyChestExistingStackSlot(
|
|
uint itemId,
|
|
bool isHq,
|
|
uint maxStack,
|
|
out FFXIVClientStructs.FFXIV.Client.Game.InventoryType destType,
|
|
out uint destSlot)
|
|
{
|
|
destType = default;
|
|
destSlot = 0;
|
|
|
|
var invTypes = Enum.GetValues<FFXIVClientStructs.FFXIV.Client.Game.InventoryType>()
|
|
.Where(IsCompanyChestType)
|
|
.OrderBy(v => (int)v)
|
|
.ToArray();
|
|
if (invTypes.Length == 0)
|
|
return false;
|
|
|
|
var inv = InventoryManager.Instance();
|
|
if (inv == null)
|
|
return false;
|
|
|
|
const int slotCap = 80;
|
|
var bestFree = 0;
|
|
foreach (var t in invTypes)
|
|
{
|
|
for (var i = 0; i < slotCap; i++)
|
|
{
|
|
var it = inv->GetInventorySlot(t, i);
|
|
if (it == null)
|
|
break;
|
|
|
|
if (it->ItemId != itemId)
|
|
continue;
|
|
|
|
var hq = it->Flags.HasFlag(InventoryItem.ItemFlags.HighQuality);
|
|
if (hq != isHq)
|
|
continue;
|
|
|
|
if (maxStack <= 1)
|
|
continue;
|
|
|
|
var qty = it->Quantity;
|
|
if (qty <= 0)
|
|
continue;
|
|
|
|
var free = (int)maxStack - qty;
|
|
if (free <= 0)
|
|
continue;
|
|
|
|
// Pick the stack with the most free space, to reduce "moves 1 then repeats" behavior.
|
|
if (free > bestFree)
|
|
{
|
|
bestFree = free;
|
|
destType = t;
|
|
destSlot = (uint)i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bestFree > 0;
|
|
}
|
|
|
|
private static uint GetItemStackSize(uint itemId)
|
|
{
|
|
try
|
|
{
|
|
// If item isn't known/stackable, return 1.
|
|
if (itemId == 0)
|
|
return 1;
|
|
|
|
lock (StackSizeCache)
|
|
{
|
|
if (StackSizeCache.TryGetValue(itemId, out var cached))
|
|
return cached;
|
|
}
|
|
|
|
var sheet = DataManager.GetExcelSheet<Item>();
|
|
if (sheet == null)
|
|
return 999;
|
|
|
|
// Item row IDs are base IDs; InventoryItem.ItemId is expected to already be base.
|
|
var row = sheet.GetRow(itemId);
|
|
if (row.RowId == 0)
|
|
return 999;
|
|
|
|
// In modern Lumina sheets, Item.StackSize exists.
|
|
var s = row.StackSize;
|
|
var result = s <= 0 ? 1U : (uint)s;
|
|
lock (StackSizeCache)
|
|
StackSizeCache[itemId] = result;
|
|
return result;
|
|
}
|
|
catch
|
|
{
|
|
// Fallback: most stackables are 999, and non-stackables will hit maxStack <= 1 cases anyway.
|
|
return 999;
|
|
}
|
|
}
|
|
|
|
private static bool TryGetItemInfo(
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType type,
|
|
int slot,
|
|
out uint itemId,
|
|
out bool isHq,
|
|
out uint quantity)
|
|
{
|
|
itemId = 0;
|
|
isHq = false;
|
|
quantity = 0;
|
|
|
|
var inv = InventoryManager.Instance();
|
|
if (inv == null)
|
|
return false;
|
|
|
|
var it = inv->GetInventorySlot(type, slot);
|
|
if (it == null)
|
|
return false;
|
|
|
|
itemId = it->ItemId;
|
|
isHq = it->Flags.HasFlag(InventoryItem.ItemFlags.HighQuality);
|
|
quantity = (uint)it->Quantity;
|
|
return itemId != 0;
|
|
}
|
|
|
|
private ModifierMode? GetModifierModeLatched(long nowMs)
|
|
{
|
|
const int latchWindowMs = 180;
|
|
if (KeyState[VirtualKey.CONTROL] || nowMs - lastCtrlSeenMs <= latchWindowMs)
|
|
return ModifierMode.Ctrl;
|
|
if (KeyState[VirtualKey.SHIFT] || nowMs - lastShiftSeenMs <= latchWindowMs)
|
|
return ModifierMode.Shift;
|
|
return null;
|
|
}
|
|
|
|
private void TryCloseCurrentContextMenu(AgentInventoryContext* agent)
|
|
{
|
|
try
|
|
{
|
|
var agentAddonId = agent->AgentInterface.GetAddonId();
|
|
if (agentAddonId != 0)
|
|
{
|
|
var addon = GetAddonById(agentAddonId);
|
|
if (addon != null)
|
|
{
|
|
CloseContextMenuAddon(agent, addon);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
|
|
// Fallback attempt.
|
|
try
|
|
{
|
|
var cm = GameGui.GetAddonByName("ContextMenu", 1);
|
|
if (!cm.IsNull)
|
|
CloseContextMenuAddon(agent, (AtkUnitBase*)cm.Address);
|
|
}
|
|
catch
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
private void DebugDumpContextMenu(AgentInventoryContext* agent, int maxItems)
|
|
{
|
|
try
|
|
{
|
|
var max = Math.Min(Math.Min(agent->ContextItemCount, 64), maxItems);
|
|
for (var i = 0; i < max; i++)
|
|
{
|
|
var param = agent->EventParams[agent->ContexItemStartIndex + i];
|
|
if (param.Type is not (AtkValueType.String or AtkValueType.ManagedString))
|
|
continue;
|
|
|
|
var text = ReadAtkValueString(param);
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
continue;
|
|
|
|
Log.Information($"[QuickTransfer] Menu idx={i}: '{text}'");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Warning(ex, "[QuickTransfer] Failed to dump context menu.");
|
|
}
|
|
}
|
|
|
|
private static bool IsPlayerInventoryType(FFXIVClientStructs.FFXIV.Client.Game.InventoryType inventoryType)
|
|
=> inventoryType is
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.Inventory1 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.Inventory2 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.Inventory3 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.Inventory4;
|
|
|
|
private static bool IsArmouryType(FFXIVClientStructs.FFXIV.Client.Game.InventoryType inventoryType)
|
|
=> inventoryType is
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryMainHand or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryOffHand or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryHead or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryBody or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryHands or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryLegs or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryFeets or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryEar or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryNeck or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryWrist or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.ArmoryRings;
|
|
|
|
private static bool IsAddonVisible(string addonName, int index = 1)
|
|
{
|
|
var addon = GameGui.GetAddonByName(addonName, index);
|
|
return !addon.IsNull && addon.IsVisible;
|
|
}
|
|
|
|
private static bool IsAddonVisibleAnyIndex(string addonName, int maxIndex = 6)
|
|
{
|
|
for (var i = 1; i <= maxIndex; i++)
|
|
{
|
|
if (IsAddonVisible(addonName, i))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool IsAnyAddonVisible(IEnumerable<string> addonNames, int index = 1)
|
|
{
|
|
foreach (var name in addonNames)
|
|
{
|
|
if (IsAddonVisible(name, index))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool IsAnyAddonVisibleAnyIndex(IEnumerable<string> addonNames, int maxIndex = 6)
|
|
{
|
|
foreach (var name in addonNames)
|
|
{
|
|
if (IsAddonVisibleAnyIndex(name, maxIndex))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool IsInventoryAndSaddlebagOpen()
|
|
{
|
|
var inventoryOpen = IsAddonVisibleAnyIndex("Inventory");
|
|
var saddlebagOpen = IsAddonVisibleAnyIndex("InventoryBuddy") || IsAddonVisibleAnyIndex("InventoryBuddy2");
|
|
return inventoryOpen && saddlebagOpen;
|
|
}
|
|
|
|
private static bool IsSaddlebagOpen()
|
|
=> IsAddonVisibleAnyIndex("InventoryBuddy") || IsAddonVisibleAnyIndex("InventoryBuddy2");
|
|
|
|
private static bool IsSaddlebagType(FFXIVClientStructs.FFXIV.Client.Game.InventoryType inventoryType)
|
|
=> inventoryType is
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.SaddleBag1 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.SaddleBag2;
|
|
|
|
private static bool IsRetainerOpen()
|
|
{
|
|
// Common retainer inventory addons.
|
|
// (SimpleTweaks checks "RetainerGrid0" for retainer inventory visibility.)
|
|
return IsAddonVisibleAnyIndex("RetainerGrid0") ||
|
|
IsAddonVisibleAnyIndex("RetainerSellList") ||
|
|
IsAddonVisibleAnyIndex("RetainerGrid");
|
|
}
|
|
|
|
private static bool IsRetainerType(FFXIVClientStructs.FFXIV.Client.Game.InventoryType inventoryType)
|
|
=> inventoryType is
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.RetainerPage1 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.RetainerPage2 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.RetainerPage3 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.RetainerPage4 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.RetainerPage5 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.RetainerPage6 or
|
|
FFXIVClientStructs.FFXIV.Client.Game.InventoryType.RetainerPage7;
|
|
|
|
private static bool IsCompanyChestOpen()
|
|
=> IsAddonVisibleAnyIndex(FreeCompanyChestAddonName);
|
|
|
|
private static bool IsCompanyChestType(FFXIVClientStructs.FFXIV.Client.Game.InventoryType inventoryType)
|
|
{
|
|
var name = Enum.GetName(typeof(FFXIVClientStructs.FFXIV.Client.Game.InventoryType), inventoryType);
|
|
if (string.IsNullOrEmpty(name))
|
|
return false;
|
|
|
|
// We only want the *item compartments*, not crystals/gil/etc.
|
|
// Observed names: FreeCompanyPage1..FreeCompanyPage5
|
|
return name.StartsWith("FreeCompanyPage", StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
private static bool TryGetVisibleAddon(string addonName, out AtkUnitBase* addon, int maxIndex = 6)
|
|
{
|
|
addon = null;
|
|
for (var i = 1; i <= maxIndex; i++)
|
|
{
|
|
var a = GameGui.GetAddonByName(addonName, i);
|
|
if (!a.IsNull && a.IsVisible)
|
|
{
|
|
addon = (AtkUnitBase*)a.Address;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void CloseContextMenuAddon(AgentInventoryContext* agent, AtkUnitBase* contextMenuAddon)
|
|
{
|
|
try { agent->AgentInterface.Hide(); } catch { /* ignore */ }
|
|
try { contextMenuAddon->Hide(false, true, 0); } catch { /* ignore */ }
|
|
try { atkUnitBaseClose?.Invoke(contextMenuAddon, 0); } catch { /* ignore */ }
|
|
}
|
|
|
|
private static bool ContextLabelMatches(AutoContextAction desiredAction, string menuText)
|
|
{
|
|
var t = menuText.Trim();
|
|
static bool Has(string s, string needle) => s.Contains(needle, StringComparison.OrdinalIgnoreCase);
|
|
|
|
return desiredAction switch
|
|
{
|
|
AutoContextAction.AddAllToSaddlebag =>
|
|
t.Equals("Add All to Saddlebag", StringComparison.OrdinalIgnoreCase) ||
|
|
(Has(t, "Add All") && Has(t, "Saddlebag")),
|
|
|
|
AutoContextAction.RemoveAllFromSaddlebag =>
|
|
t.Equals("Remove All from Saddlebag", StringComparison.OrdinalIgnoreCase) ||
|
|
(Has(t, "Remove All") && Has(t, "Saddlebag")) ||
|
|
(Has(t, "Remove") && Has(t, "Saddlebag")) ||
|
|
t.Equals("Remove All", StringComparison.OrdinalIgnoreCase) ||
|
|
((Has(t, "Retrieve") || Has(t, "Take out") || Has(t, "Take Out")) && Has(t, "Saddlebag")),
|
|
|
|
AutoContextAction.PlaceInArmouryChest =>
|
|
t.Equals("Place in Armoury Chest", StringComparison.OrdinalIgnoreCase) ||
|
|
(Has(t, "Place") && (Has(t, "Armoury") || Has(t, "Armory")) && Has(t, "Chest")),
|
|
|
|
AutoContextAction.ReturnToInventory =>
|
|
t.Equals("Return to Inventory", StringComparison.OrdinalIgnoreCase) ||
|
|
(Has(t, "Return") && Has(t, "Inventory")),
|
|
|
|
AutoContextAction.EntrustToRetainer =>
|
|
t.Equals("Entrust to Retainer", StringComparison.OrdinalIgnoreCase) ||
|
|
(Has(t, "Entrust") && Has(t, "Retainer")),
|
|
|
|
AutoContextAction.RetrieveFromRetainer =>
|
|
t.Equals("Retrieve from Retainer", StringComparison.OrdinalIgnoreCase) ||
|
|
(Has(t, "Retrieve") && Has(t, "Retainer")),
|
|
|
|
AutoContextAction.RemoveFromCompanyChest =>
|
|
t.Equals("Remove", StringComparison.OrdinalIgnoreCase) ||
|
|
(Has(t, "Remove") && (Has(t, "Company") || Has(t, "Chest"))) ||
|
|
(Has(t, "Withdraw") && (Has(t, "Company") || Has(t, "Chest"))),
|
|
|
|
_ => false,
|
|
};
|
|
}
|
|
|
|
private static string ReadAtkValueString(AtkValue v)
|
|
{
|
|
if (v.String == null)
|
|
return string.Empty;
|
|
|
|
try
|
|
{
|
|
// SimpleTweaks-style decoding.
|
|
return Marshal.PtrToStringUTF8(new IntPtr(v.String))?.TrimEnd('\0') ?? string.Empty;
|
|
}
|
|
catch
|
|
{
|
|
return ReadUtf8(v.String);
|
|
}
|
|
}
|
|
|
|
private static string ReadUtf8(byte* ptr)
|
|
{
|
|
if (ptr == null)
|
|
return string.Empty;
|
|
|
|
var len = 0;
|
|
while (ptr[len] != 0)
|
|
len++;
|
|
|
|
return len <= 0 ? string.Empty : Encoding.UTF8.GetString(ptr, len);
|
|
}
|
|
|
|
private const int UnitListCount = 18;
|
|
|
|
private static AtkUnitBase* GetAddonById(uint id)
|
|
{
|
|
var unitManagers = &AtkStage.Instance()->RaptureAtkUnitManager->AtkUnitManager.DepthLayerOneList;
|
|
for (var i = 0; i < UnitListCount; i++)
|
|
{
|
|
var unitManager = &unitManagers[i];
|
|
for (var j = 0; j < Math.Min(unitManager->Count, unitManager->Entries.Length); j++)
|
|
{
|
|
var unitBase = unitManager->Entries[j].Value;
|
|
if (unitBase != null && unitBase->Id == id)
|
|
return unitBase;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static AtkValue* CreateAtkValueArray(params object[] values)
|
|
{
|
|
var atkValues = (AtkValue*)Marshal.AllocHGlobal(values.Length * sizeof(AtkValue));
|
|
if (atkValues == null)
|
|
return null;
|
|
|
|
try
|
|
{
|
|
for (var i = 0; i < values.Length; i++)
|
|
{
|
|
var v = values[i];
|
|
switch (v)
|
|
{
|
|
case uint u:
|
|
atkValues[i].Type = AtkValueType.UInt;
|
|
atkValues[i].UInt = u;
|
|
break;
|
|
case int n:
|
|
atkValues[i].Type = AtkValueType.Int;
|
|
atkValues[i].Int = n;
|
|
break;
|
|
case float f:
|
|
atkValues[i].Type = AtkValueType.Float;
|
|
atkValues[i].Float = f;
|
|
break;
|
|
case bool b:
|
|
atkValues[i].Type = AtkValueType.Bool;
|
|
atkValues[i].Byte = (byte)(b ? 1 : 0);
|
|
break;
|
|
case string s:
|
|
{
|
|
atkValues[i].Type = AtkValueType.String;
|
|
var bytes = Encoding.UTF8.GetBytes(s);
|
|
var alloc = Marshal.AllocHGlobal(bytes.Length + 1);
|
|
Marshal.Copy(bytes, 0, alloc, bytes.Length);
|
|
Marshal.WriteByte(alloc, bytes.Length, 0);
|
|
atkValues[i].String = (byte*)alloc;
|
|
break;
|
|
}
|
|
default:
|
|
throw new ArgumentException($"Unsupported AtkValue type {v.GetType()}");
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Marshal.FreeHGlobal(new IntPtr(atkValues));
|
|
return null;
|
|
}
|
|
|
|
return atkValues;
|
|
}
|
|
|
|
private static void GenerateCallback(AtkUnitBase* unitBase, params object[] values)
|
|
{
|
|
var atkValues = CreateAtkValueArray(values);
|
|
if (atkValues == null)
|
|
return;
|
|
|
|
try
|
|
{
|
|
unitBase->FireCallback((uint)values.Length, atkValues);
|
|
}
|
|
finally
|
|
{
|
|
for (var i = 0; i < values.Length; i++)
|
|
{
|
|
if (atkValues[i].Type == AtkValueType.String)
|
|
Marshal.FreeHGlobal(new IntPtr(atkValues[i].String));
|
|
}
|
|
|
|
Marshal.FreeHGlobal(new IntPtr(atkValues));
|
|
}
|
|
}
|
|
}
|
|
|