lastComboMove/lastComboActionID Clarification

[vitharr137]

I've been digging through the Struct and attempting to find where the parameters for lastComboActionID are derived from, to try to build the potential to track any previously used actionID rather than just weaponskill (and oddly spell? it seems to work with BLM as well)

Is there any way to return the previously used Ability?

[MKhayle]

I was thinking about using it for the All-In-One Generation Legacies features but there's almost always an alternative to find out this info like that #310 (comment)

And the final implementation ended up being 69c85e4

[vitharr137]

I don't know how to do it, but I believe if there was a way to write the result of ActionManager.Instance()->QueuedActionId to a variable when it's not null, that would give a stable-ish way to see what the last used Ability was. It does not work for Weaponskills, it has to be something able to be queued, which seems to only be Ability OGCDs

[kaedys]

Does QueuedActionId also return results when the action isn't actually queued, but just cast when already off GCD or not otherwise animation locked?

[vitharr137]

Sadly it doesn't seem to, no. I'll keep looking

Interesting odd note: QueuedActionID knows what the original actionID being replaced by the plugin is that was being pressed. I use a few inaccessible actionIDs in the testing classes I work with, and was confused about the odd icons I was seeing get returned by the QueuedActionID icon until I realized it was giving me back Anatman's old icon rather than what it 'looked like' I was pressing via the IconReplacer

[vitharr137]

The only other lead I have at the moment is another addon named RotationSolver that appears to be using the Lumina sheets directly in this code:

using Action = Lumina.Excel.GeneratedSheets.Action;
    internal static unsafe void AddActionRec(Action act)
    {
        if (!Player.Available) return;

        var id = (ActionID)act.RowId;

        //Record
        switch (act.GetActionCate())
        {
            case ActionCate.Spell:
            case ActionCate.Weaponskill:
                LastAction = LastGCD = id;
                break;
            case ActionCate.Ability:
                LastAction = LastAbility = id;
                break;
            default:
                return;
        }

        if (_actions.Count >= QUEUECAPACITY)
        {
            _actions.Dequeue();
        }

        _timeLastActionUsed = DateTime.Now;
        _actions.Enqueue(new ActionRec(_timeLastActionUsed, act));
    }

And ActionTimeline itself leans on that original addon for the ActionCate definitions in their lines in TimelineManager.cs for searching the Lumina sheets:

using FFXIVClientStructs.FFXIV.Client.Game;
using Lumina.Excel.GeneratedSheets;
using RotationSolver.Basic.Data;
using Action = Lumina.Excel.GeneratedSheets.Action;
using Status = Lumina.Excel.GeneratedSheets.Status;
    public unsafe float GCD
    {
        get
        {
            var cdGrp = ActionManager.Instance()->GetRecastGroupDetail(GCDCooldownGroup - 1);
            return cdGrp->Total;
        }
    }

    private static TimelineItemType GetActionType(uint actionId, ActionType type)
    {
        switch (type)
        {
            case ActionType.Action:
                var action = Svc.Data.GetExcelSheet<Action>()?.GetRow(actionId);
                if (action == null) break;

                if (actionId == 3) return TimelineItemType.OGCD; //Sprint

                var actionCate = (ActionCate)(action.ActionCategory.Value?.RowId ?? 0);

                var isRealGcd = action.CooldownGroup == GCDCooldownGroup || action.AdditionalCooldownGroup == GCDCooldownGroup;
                return actionCate == ActionCate.AutoAttack
                    ? TimelineItemType.AutoAttack
                    : !isRealGcd && actionCate == ActionCate.Ability ? TimelineItemType.OGCD
                    : TimelineItemType.GCD;

            case ActionType.Item:
                var item = Svc.Data.GetExcelSheet<Item>()?.GetRow(actionId);
                return item?.CastTimes > 0 ? TimelineItemType.GCD : TimelineItemType.OGCD;
        }

        return TimelineItemType.GCD;
    }

[vitharr137]

DeathRecap's CombatEventCapture.cs also seems to use the Lumina sheets only for their actionID parsing to capture ability-based heals and damage timelines

[Grammernatzi]

So I feel if you wanted to detect the last move used no matter what, you'd want to look at how the ActionTimeline plugin (or whatever it is) does it. I haven't bothered with this yet but I can see how it would be really useful. I ended up using something similar from another plugin I forgot to track whether actions were grayed out so that things played nicer when leveling on alts (and it also ended up being useful for tracking when a lot of actions could be used).

[Grammernatzi]

I just want to point out that CanUseAction does have a downside: it only checks if actions are grayed out, regardless of context. The issue with this is that casting grays out actions, so it can be kind of messy with casters. It works pretty well otherwise, though.

[kaedys]

Nevermind! So, it turns out you need to use the transformed ID, not the base one. You can't check CanUseAction(Tsubame), you need to check CanUseAction(Kaeshi: Setsugekka) instead. Which is...an annoying thing, and rather starkly limits it's utility, unfortunately.

Edit: as an example, instead of simply checking if Tsubame is usable, you have to check for all 4 possible abilities that can go on that button (Kaeshi Setsugekka, Kaeshi Goken, Tendo Kaeshi Setsugekka, and Tendo Kaeshi Goken)

[kaedys]

Haha, nope, nevermind, found a way around that:

            if (CanUseAction(OriginalHook(SAM.TsubameGaeshi)))
                return OriginalHook(SAM.TsubameGaeshi);

This works exactly how I was hoping it would.

[kaedys]

And feature complete and tested. Now I can't forget to use Tsubame, because it replaces all of my combo buttons when available. @MKhayle this is lit.

[MKhayle]

I'll add this with the rework, handy indeed