Determine Player GCD

[Evolutious]

Hi @PrincessRTFM, it has been a minute; hope you are doing well. Question; do you know if it is possible to determine the player's GCD in seconds in your version of XIVCombo?

[vitharr137]

Hello! How funny, we're both looking for similar grails. I have an open issue regarding the implementation of it as I haven't found a clean method for it yet, but I do have a working hacked in way to do it that requires running calculations if that'll help you in the mean time until one is found. Please note I don't have the programming expertise to turn this into an actual method, so it's done in line in each of the various class modules.

First you'll need to track the Speed (this is for Skill Speed, the index for Spell Speed would be 46) using these two:

using FFXIVClientStructs.FFXIV.Client.Game.UI;

public unsafe class MNKGCD
{
    public static unsafe int MNKSkillSpeed()
    {
        UIState* uiState = UIState.Instance();
        return uiState->PlayerState.Attributes[45];
    }
}

Then in each class you want to track the GCD in, these are the pieces to include (this is for Monk that has a haste multiplier, so that would not be needed on others, but something like Samurai needs to track it via the buff rather than the level)

int[,] levelSubAndDiv = new int[,] {
    { 56, 56 }, { 57, 57 }, { 60, 60 }, { 62, 62 }, { 65, 65 }, { 68, 68 }, { 70, 70 }, { 73, 73 }, { 76, 76 }, { 78, 78 },
    { 82, 82 }, { 85, 85 }, { 89, 89 }, { 93, 93 }, { 96, 96 }, { 100, 100 }, { 104, 104 }, { 109, 109 }, { 113, 113 }, { 116, 116 },
    { 122, 122 }, { 127, 127 }, { 133, 133 }, { 138, 138 }, { 144, 144 }, { 150, 150 }, { 155, 155 }, { 162, 162 }, { 168, 168 }, { 173, 173 },
    { 181, 181 }, { 188, 188 }, { 194, 194 }, { 202, 202 }, { 209, 209 }, { 215, 215 }, { 223, 223 }, { 229, 229 }, { 236, 236 }, { 244, 244 },
    { 253, 253 }, { 263, 263 }, { 272, 272 }, { 283, 283 }, { 292, 292 }, { 302, 302 }, { 311, 311 }, { 322, 322 }, { 331, 331 }, { 341, 341 },
    { 342, 366 }, { 344, 392 }, { 345, 418 }, { 346, 444 }, { 347, 470 }, { 349, 496 }, { 350, 522 }, { 351, 548 }, { 352, 574 }, { 354, 600 },
    { 355, 630 }, { 356, 660 }, { 357, 690 }, { 358, 720 }, { 359, 750 }, { 360, 780 }, { 361, 810 }, { 362, 840 }, { 363, 870 }, { 364, 900 },
    { 365, 940 }, { 366, 980 }, { 367, 1020 }, { 368, 1060 }, { 370, 1100 }, { 372, 1140 }, { 374, 1180 }, { 376, 1220 }, { 378, 1260 }, { 380, 1300 },
    { 382, 1360 }, { 384, 1420 }, { 386, 1480 }, { 388, 1540 }, { 390, 1600 }, { 392, 1660 }, { 394, 1720 }, { 396, 1780 }, { 398, 1840 }, { 400, 1900 }
};
float greasedLightningModifier;
if (level < 20)
    greasedLightningModifier = 0.95f;
else if (level < 40)
    greasedLightningModifier = 0.90f;
else if (level < 76)
    greasedLightningModifier = 0.85f;
else
    greasedLightningModifier = 0.80f;
int skillSpeed = MNKGCD.MNKSkillSpeed();
int baseBootshineCD = 2500;
float gcd = (baseBootshineCD * greasedLightningModifier * (1000 + (130 * (levelSubAndDiv[level - 1, 0] - skillSpeed) / levelSubAndDiv[level - 1, 1])) / 10000 / 100);

levelSubAndDiv is from AkhMorning Level Scaling and is setup to be parsed with the level in the final GCD float calculation, and greasedLightningModifier is for the MNK specific haste. That function can either be removed for classes that doesn't need it, or adjusted for something like SAM to be tracking the buff Fuka (and it's upgrade via Traits). So far this function has worked for me, but I am definitely hoping for an easier solution if one can be found.

[Evolutious]

I was looking at another mod (Character Panel Refined) and they are basically doing the same thing as you, btw. Looks like this is likely the best way to do this for now.

[Evolutious]

Scratch that; i got it worked out. thanks!

[VariableVixen]

I'll be honest, I don't enormously like hardcoding that much data, but if this is just the accepted way of doing it, I wouldn't mind adding a convenience property if someone can provide the necessary components for a generic implementation. It'd need to work on all (combat) jobs, though.

[Evolutious]

I'll be honest, I don't enormously like hardcoding that much data, but if this is just the accepted way of doing it, I wouldn't mind adding a convenience property if someone can provide the necessary components for a generic implementation. It'd need to work on all (combat) jobs, though.

Look at the very last section of this discussion thread. I put what i ended up doing in the end to minimize the amount of code required. What I have there is literally all that is required (and where I put it)

[VariableVixen]

The massive table is more what I was talking about, but as long as there isn't another stat squish it should stay constant, I'd expect.

[Evolutious]

What is an easy way for me to print a variable to the in-game chat window? for example, print(MNKGCD.MNKSkillSpeed())

[vitharr137]

Sadly that one I'm not sure about, I'm still barely learning C# and have really stumbled through that code above

[VariableVixen]

The in-game chatlog? Easily, but that's not a good way to debug values in this plugin. The problem is that the replacer functions are called every single tick the game does its own updates, so you're looking at probably at least one call per frame. Instead, you want to use Service.Logger. It's modelled after PluginLog but it has some internal handling to not spam the debug log (/xllog) every call. Get to the point you need to dump a message on, and either use a debug build to access the debugging menu in the settings window, or run /pcombo debug in order to take a one-call snapshot of debugging messages.

[Evolutious]

I appreciate the advise; this is all working perfectly for my needs; basically, I changed the DiscipledFist buff track and Demolish debuff track from being a static or variable (with your slider) value to be a dynamic variable that is a multiplier of the player's GCD since it takes 3 GCDs to repeat the 1/2/3 rotation to get back to being able to refresh them ;)

[vitharr137]

Sorry I missed the questions above, but it sounds like you're walking the same steps I did, that was exactly what I was solving with my adjustments. Glad it's working out! It was such an excellent tool for PLD as well until the changes in 6.3. I hope there's an answer to do this smoother, and I think what I've found is it's technically named 'recast' in the game's code, so I'm hunting through those to see if any work.

[vitharr137]

In case it's use to you in your repo, here's my updates (though from a different grammar than PrincessRTFM's) to the Single Target rotation that fixes some of the issues I was running into, namely tracking the upkeep through the Perfect Balance window properly, and it's not perfect for level sync'd content yet, but if any of the variables help with your quest have at 'em:

internal class MonkUltimaCD : CustomCombo
{
    protected internal override CustomComboPreset Preset { get; } = CustomComboPreset.MonkUltimaCD;

    protected override uint Invoke(uint actionID, uint lastComboMove, float comboTime, byte level)
    {
        var gauge = GetJobGauge<MNKGauge>();
        var beast1 = gauge.BeastChakra[0];
        var beast2 = gauge.BeastChakra[1];
        var beast3 = gauge.BeastChakra[2];
        var disciplined = FindEffect(MNK.Buffs.DisciplinedFist);
        var demolish = FindTargetEffect(MNK.Debuffs.Demolish);
        var rof = FindEffect(MNK.Buffs.RiddleOfFire);
        var pb = FindEffect(MNK.Buffs.PerfectBalance);
        int[,] levelSubAndDiv = new int[,]
        {
            { 56, 56 }, { 57, 57 }, { 60, 60 }, { 62, 62 }, { 65, 65 }, { 68, 68 }, { 70, 70 }, { 73, 73 }, { 76, 76 }, { 78, 78 },
            { 82, 82 }, { 85, 85 }, { 89, 89 }, { 93, 93 }, { 96, 96 }, { 100, 100 }, { 104, 104 }, { 109, 109 }, { 113, 113 }, { 116, 116 },
            { 122, 122 }, { 127, 127 }, { 133, 133 }, { 138, 138 }, { 144, 144 }, { 150, 150 }, { 155, 155 }, { 162, 162 }, { 168, 168 }, { 173, 173 },
            { 181, 181 }, { 188, 188 }, { 194, 194 }, { 202, 202 }, { 209, 209 }, { 215, 215 }, { 223, 223 }, { 229, 229 }, { 236, 236 }, { 244, 244 },
            { 253, 253 }, { 263, 263 }, { 272, 272 }, { 283, 283 }, { 292, 292 }, { 302, 302 }, { 311, 311 }, { 322, 322 }, { 331, 331 }, { 341, 341 },
            { 342, 366 }, { 344, 392 }, { 345, 418 }, { 346, 444 }, { 347, 470 }, { 349, 496 }, { 350, 522 }, { 351, 548 }, { 352, 574 }, { 354, 600 },
            { 355, 630 }, { 356, 660 }, { 357, 690 }, { 358, 720 }, { 359, 750 }, { 360, 780 }, { 361, 810 }, { 362, 840 }, { 363, 870 }, { 364, 900 },
            { 365, 940 }, { 366, 980 }, { 367, 1020 }, { 368, 1060 }, { 370, 1100 }, { 372, 1140 }, { 374, 1180 }, { 376, 1220 }, { 378, 1260 }, { 380, 1300 },
            { 382, 1360 }, { 384, 1420 }, { 386, 1480 }, { 388, 1540 }, { 390, 1600 }, { 392, 1660 }, { 394, 1720 }, { 396, 1780 }, { 398, 1840 }, { 400, 1900 },
        };
        float greasedLightningModifier;
        if (level < 20)
            greasedLightningModifier = 0.95f;
        else if (level < 40)
            greasedLightningModifier = 0.90f;
        else if (level < 76)
            greasedLightningModifier = 0.85f;
        else
            greasedLightningModifier = 0.80f;
        int skillSpeed = MNKGCD.MNKSkillSpeed();
        int baseBootshineCD = 2500;
        float gcd = (baseBootshineCD * greasedLightningModifier * (1000 + (130 * (levelSubAndDiv[level - 1, 0] - skillSpeed) / levelSubAndDiv[level - 1, 1])) / 10000 / 100);
        float rofcd = GetCooldown(MNK.RiddleOfFire).CooldownRemaining;
        float firegcds = IsOnCooldown(MNK.RiddleOfFire) ? rofcd / gcd : 0;
        float rotate = gcd * 3;
        float disciplinedFistLunar = gcd * 7;
        float demolishLunar = gcd * 8;
        float demolishSolar = gcd * 2;
        float perfectBalanceWindow = gcd * 3;
        float perfectBalanceUpkeep;
        if (beast3 != BeastChakra.NONE)
            perfectBalanceUpkeep = GetCooldown(MNK.Bootshine).CooldownRemaining;
        else if (beast2 != BeastChakra.NONE)
            perfectBalanceUpkeep = GetCooldown(MNK.Bootshine).CooldownRemaining + gcd;
        else if (beast1 != BeastChakra.NONE)
            perfectBalanceUpkeep = GetCooldown(MNK.Bootshine).CooldownRemaining + (gcd * 2);
        else
            perfectBalanceUpkeep = gcd * 3;
        float disciplinedFistBlitzRefresh = perfectBalanceUpkeep + (gcd * 2);
        float demolishBlitzRefresh = perfectBalanceUpkeep + (gcd * 3);
        float disciplinedFistLunarPrep = gcd * 7;
        float demolishLunarPrep = gcd * 8;
        var clip = GetCooldown(MNK.Bootshine).CooldownRemaining >= 0.51f;
        var weave = GetCooldown(MNK.Bootshine).CooldownRemaining <= gcd;
        var buffer = GetCooldown(MNK.Bootshine).CooldownRemaining <= 0.73f;
        if (actionID == MNK.MasterfulBlitz)
        {
            if (
                !HasCondition(ConditionFlag.InCombat)
                && level >= MNK.Levels.Meditation
                && OriginalHook(MNK.Meditation) == MNK.Meditation)
            {
                return MNK.Meditation;
            }

            if (
                !HasCondition(ConditionFlag.InCombat)
                && level >= MNK.Levels.FormShift
                && !HasEffect(MNK.Buffs.FormlessFist))
            {
                return MNK.FormShift;
            }

            if (
                level >= MNK.Levels.RiddleOfFire
                && HasCondition(ConditionFlag.InCombat)
                && (disciplined is not null || HasEffect(MNK.Buffs.PerfectBalance))
                && IsOffCooldown(MNK.RiddleOfFire)
                && weave
                && clip
                && buffer)
            {
                return MNK.RiddleOfFire;
            }

            if (
                HasCondition(ConditionFlag.InCombat)
                && level >= MNK.Levels.Brotherhood
                && IsOnCooldown(MNK.RiddleOfFire)
                && (HasEffect(MNK.Buffs.RaptorForm) || HasEffect(MNK.Buffs.PerfectBalance) || (rof is not null && HasEffect(MNK.Buffs.FormlessFist)))
                && IsOffCooldown(MNK.Brotherhood)
                && weave
                && clip)
            {
                return MNK.Brotherhood;
            }

            if (
                level >= MNK.Levels.Meditation
                && OriginalHook(MNK.Meditation) != MNK.Meditation
                && LocalPlayer?.TargetObject is not null
                && HasCondition(ConditionFlag.InCombat)
                && (disciplined is not null || level < MNK.Levels.TwinSnakes)
                && (IsOnCooldown(MNK.RiddleOfFire) || level < MNK.Levels.RiddleOfFire)
                && clip
                && weave)
            {
                return OriginalHook(MNK.SteelPeak);
            }

            if (
                level >= MNK.Levels.MasterfulBlitz
                && OriginalHook(MNK.MasterfulBlitz) != MNK.MasterfulBlitz)
            {
                return OriginalHook(MNK.MasterfulBlitz);
            }

            if (
                HasCondition(ConditionFlag.InCombat)
                && level >= MNK.Levels.RiddleOfWind
                && IsOnCooldown(MNK.Brotherhood)
                && IsOnCooldown(MNK.RiddleOfFire)
                && (HasEffect(MNK.Buffs.PerfectBalance) || !IsOffCooldown(MNK.PerfectBalance))
                && IsOffCooldown(MNK.RiddleOfWind)
                && clip
                && weave)
            {
                return MNK.RiddleOfWind;
            }

            if (
                level >= MNK.Levels.PerfectBalance
                && !HasEffect(MNK.Buffs.PerfectBalance)
                && HasEffect(MNK.Buffs.RaptorForm)
                && GetCooldown(MNK.PerfectBalance).RemainingCharges >= 1
                && level < MNK.Levels.MasterfulBlitz
                && disciplined is not null
                && demolish is not null
                && disciplined.RemainingTime > perfectBalanceWindow
                && demolish.RemainingTime > perfectBalanceWindow
                && weave
                && clip)
            {
                return MNK.PerfectBalance;
            }

            if (
                level >= MNK.Levels.PerfectBalance
                && !HasEffect(MNK.Buffs.PerfectBalance)
                && (IsOnCooldown(MNK.Brotherhood) || level < MNK.Levels.Brotherhood)
                && level >= MNK.Levels.MasterfulBlitz
                && HasEffect(MNK.Buffs.RaptorForm)
                && GetCooldown(MNK.PerfectBalance).RemainingCharges >= 1
                && (firegcds <= 2 || (rof is not null && (rof.RemainingTime >= perfectBalanceUpkeep)) || level < MNK.Levels.RiddleOfFire)
                && (!gauge.Nadi.HasFlag(Nadi.SOLAR) || ((disciplined is not null && (disciplined.RemainingTime >= perfectBalanceUpkeep)) && (demolish is not null && (demolish.RemainingTime >= perfectBalanceUpkeep))))
                && weave
                && clip)
            {
                return MNK.PerfectBalance;
            }

            if (
                level >= MNK.Levels.Meditation
                && LocalPlayer?.TargetObject is null
                && !HasEffect(MNK.Buffs.PerfectBalance)
                && OriginalHook(MNK.Meditation) == MNK.Meditation)
            {
                return MNK.Meditation;
            }

            if (
                level >= MNK.Levels.FormShift
                && LocalPlayer?.TargetObject is null
                && !HasEffect(MNK.Buffs.PerfectBalance)
                && !HasEffect(MNK.Buffs.FormlessFist))
            {
                return MNK.FormShift;
            }

            if (
                level >= MNK.Levels.TwinSnakes
                && HasEffect(MNK.Buffs.RaptorForm)
                && !HasEffect(MNK.Buffs.PerfectBalance)
                && ((gauge.Nadi.HasFlag(Nadi.SOLAR)
                    && ((level >= MNK.Levels.RiddleOfFire && firegcds <= 3) || (level < MNK.Levels.RiddleOfFire && GetCooldown(MNK.PerfectBalance).ChargeCooldownRemaining <= rotate))
                    && (disciplined is null || disciplined.RemainingTime < disciplinedFistLunar))
                    || (!gauge.Nadi.HasFlag(Nadi.SOLAR) && (disciplined is null || disciplined.RemainingTime < rotate))))
            {
                return MNK.TwinSnakes;
            }

            if (
                level >= MNK.Levels.Demolish
                && HasEffect(MNK.Buffs.CoerlForm)
                && !HasEffect(MNK.Buffs.PerfectBalance)
                && ((gauge.Nadi.HasFlag(Nadi.SOLAR)
                    && ((level >= MNK.Levels.RiddleOfFire && firegcds <= 3) || (level < MNK.Levels.RiddleOfFire && GetCooldown(MNK.PerfectBalance).ChargeCooldownRemaining <= rotate))
                    && (demolish is null || demolish.RemainingTime < demolishLunar))
                    || (!gauge.Nadi.HasFlag(Nadi.SOLAR) && (demolish is null || demolish.RemainingTime < demolishSolar))))
            {
                return MNK.Demolish;
            }

            if (HasEffect(MNK.Buffs.PerfectBalance))
            {
                if (
                (!gauge.BeastChakra.Contains(BeastChakra.RAPTOR) && !gauge.BeastChakra.Contains(BeastChakra.COEURL))
                && (!gauge.Nadi.HasFlag(Nadi.LUNAR) || (gauge.Nadi.HasFlag(Nadi.LUNAR) && gauge.Nadi.HasFlag(Nadi.SOLAR)) || level < MNK.Levels.MasterfulBlitz)
                && (disciplined is not null && (disciplined.RemainingTime > perfectBalanceUpkeep))
                && (demolish is not null && (demolish.RemainingTime > perfectBalanceUpkeep)))
                {
                    if (!HasEffect(MNK.Buffs.LeadenFist) && level >= MNK.Levels.DragonKick)
                    {
                        return MNK.DragonKick;
                    }

                    if (HasEffect(MNK.Buffs.LeadenFist))
                    {
                        return MNK.Bootshine;
                    }
                }

                if (
                level >= MNK.Levels.MasterfulBlitz
                && !gauge.Nadi.HasFlag(Nadi.SOLAR)
                && ((beast1 == BeastChakra.NONE && beast2 == BeastChakra.NONE) || (beast1 != beast2))
                && (
                    (disciplined is null || demolish is null)
                    || gauge.Nadi.HasFlag(Nadi.LUNAR)
                    || (!gauge.Nadi.HasFlag(Nadi.LUNAR) && (disciplined.RemainingTime <= disciplinedFistLunarPrep || demolish.RemainingTime <= demolishLunarPrep))))
                {
                    if (
                        !gauge.Nadi.HasFlag(Nadi.LUNAR)
                        && (GetCooldown(MNK.PerfectBalance).RemainingCharges >= 1 || GetCooldown(MNK.PerfectBalance).ChargeCooldownRemaining <= (gcd * 5)))
                    {
                        if (beast1 == BeastChakra.OPOOPO && beast2 == BeastChakra.COEURL)
                        {
                            return MNK.TwinSnakes;
                        }

                        if (beast1 == BeastChakra.OPOOPO && beast2 == BeastChakra.NONE)
                        {
                            return MNK.Demolish;
                        }

                        if (beast1 == BeastChakra.NONE)
                        {
                            if (!HasEffect(MNK.Buffs.LeadenFist))
                            {
                                return MNK.DragonKick;
                            }

                            if (HasEffect(MNK.Buffs.LeadenFist))
                            {
                                return MNK.Bootshine;
                            }
                        }
                    }

                    if (
                        (beast1 != BeastChakra.RAPTOR && beast2 != BeastChakra.RAPTOR)
                        && (disciplined is null || disciplined.RemainingTime <= disciplinedFistBlitzRefresh))
                    {
                        return MNK.TwinSnakes;
                    }

                    if (
                        (beast1 != BeastChakra.COEURL && beast2 != BeastChakra.COEURL)
                        && (demolish is null || demolish.RemainingTime <= demolishBlitzRefresh))
                    {
                        return MNK.Demolish;
                    }

                    if (beast1 != BeastChakra.OPOOPO && beast2 != BeastChakra.OPOOPO)
                    {
                        if (!HasEffect(MNK.Buffs.LeadenFist))
                        {
                            return MNK.DragonKick;
                        }

                        if (HasEffect(MNK.Buffs.LeadenFist))
                        {
                            return MNK.Bootshine;
                        }
                    }

                    if (
                        (beast1 != BeastChakra.RAPTOR && beast2 != BeastChakra.RAPTOR)
                        && (disciplined is not null && disciplined.RemainingTime > disciplinedFistBlitzRefresh))
                    {
                        return MNK.TrueStrike;
                    }

                    if (
                        (beast1 != BeastChakra.COEURL && beast2 != BeastChakra.COEURL)
                        && (demolish is not null && demolish.RemainingTime > demolishBlitzRefresh))
                    {
                        return MNK.SnapPunch;
                    }
                }

                if (gauge.Nadi.HasFlag(Nadi.SOLAR) && !(gcd <= 1.94f))
                {
                    return HasEffect(MNK.Buffs.LeadenFist)
                            ? MNK.Bootshine
                            : MNK.DragonKick;
                }
            }

            if (!HasEffect(MNK.Buffs.PerfectBalance))
            {
                if (HasEffect(MNK.Buffs.FormlessFist) || HasEffect(MNK.Buffs.OpoOpoForm))
                {
                    if (!HasEffect(MNK.Buffs.LeadenFist) && level >= MNK.Levels.DragonKick)
                    {
                        return MNK.DragonKick;
                    }

                    if (HasEffect(MNK.Buffs.LeadenFist) || level < MNK.Levels.DragonKick)
                    {
                        return MNK.Bootshine;
                    }
                }

                if (!HasEffect(MNK.Buffs.FormlessFist) && HasEffect(MNK.Buffs.RaptorForm))
                {
                    if (level < MNK.Levels.TrueStrike)
                    {
                        return MNK.Bootshine;
                    }

                    if (
                        level >= MNK.Levels.TwinSnakes
                        && (disciplined is null || disciplined.RemainingTime < rotate))
                    {
                        return MNK.TwinSnakes;
                    }

                    return MNK.TrueStrike;
                }

                if (!HasEffect(MNK.Buffs.FormlessFist) && HasEffect(MNK.Buffs.CoerlForm))
                {
                    if (level < MNK.Levels.SnapPunch)
                    {
                        return MNK.Bootshine;
                    }

                    if (
                        level >= MNK.Levels.Demolish
                        && (demolish is null || demolish.RemainingTime < rotate))
                    {
                        return MNK.Demolish;
                    }

                    return MNK.SnapPunch;
                }

                if (level >= MNK.Levels.DragonKick)
                {
                    return MNK.DragonKick;
                }

                if (level < MNK.Levels.DragonKick)
                {
                    return MNK.Bootshine;
                }
            }

            if (level < MNK.Levels.MasterfulBlitz
                && HasCondition(ConditionFlag.InCombat)
                && !HasEffect(MNK.Buffs.PerfectBalance)
                && !HasEffect(MNK.Buffs.FormlessFist)
                && !HasEffect(MNK.Buffs.CoerlForm)
                && !HasEffect(MNK.Buffs.RaptorForm)
                && !HasEffect(MNK.Buffs.OpoOpoForm))
            {
                return level < MNK.Levels.DragonKick
                        ? MNK.Bootshine
                        : HasEffect(MNK.Buffs.LeadenFist)
                            ? MNK.Bootshine
                            : MNK.DragonKick;
            }
        }

        return actionID;
    }
}

[howlingc]

Character Panel Refined uses a Math solution for calculating the GCD from skill speed. Maybe a possible alternative to the static array.

https://github.com/Kouzukii/ffxiv-characterstatus-refined/blob/97730a79cf4a2e70b67e868edf25f9d3573235f0/CharacterPanelRefined/Equations.cs#L82

[vitharr137]

I'll take a look through that now, it would be nice to not have to update it manually again

Looks like they have a table in LevelModifiers.cs that they update as well, the hunt continues!

[Evolutious]

I did a bit more dressing on this and I ended up moving the entire GCD calculation to CustomCombo under its own function that i can then call very easily from my combo classes using double gcd = PlayerGlobalCooldown(byte level, int speed, float modifier). This at least gets a ton of extra code out of the overall configuration.

This is added to CustomCombo under #region Player details/stats (for organizational purposes)

protected static double PlayerGlobalCooldown(byte level, int speed, float modifier) {
	int[,] levelSubAndDiv = new int[,] {
		{ 56, 56 }, { 57, 57 }, { 60, 60 }, { 62, 62 }, { 65, 65 }, { 68, 68 }, { 70, 70 }, { 73, 73 }, { 76, 76 }, { 78, 78 },
		{ 82, 82 }, { 85, 85 }, { 89, 89 }, { 93, 93 }, { 96, 96 }, { 100, 100 }, { 104, 104 }, { 109, 109 }, { 113, 113 }, { 116, 116 },
		{ 122, 122 }, { 127, 127 }, { 133, 133 }, { 138, 138 }, { 144, 144 }, { 150, 150 }, { 155, 155 }, { 162, 162 }, { 168, 168 }, { 173, 173 },
		{ 181, 181 }, { 188, 188 }, { 194, 194 }, { 202, 202 }, { 209, 209 }, { 215, 215 }, { 223, 223 }, { 229, 229 }, { 236, 236 }, { 244, 244 },
		{ 253, 253 }, { 263, 263 }, { 272, 272 }, { 283, 283 }, { 292, 292 }, { 302, 302 }, { 311, 311 }, { 322, 322 }, { 331, 331 }, { 341, 341 },
		{ 342, 366 }, { 344, 392 }, { 345, 418 }, { 346, 444 }, { 347, 470 }, { 349, 496 }, { 350, 522 }, { 351, 548 }, { 352, 574 }, { 354, 600 },
		{ 355, 630 }, { 356, 660 }, { 357, 690 }, { 358, 720 }, { 359, 750 }, { 360, 780 }, { 361, 810 }, { 362, 840 }, { 363, 870 }, { 364, 900 },
		{ 365, 940 }, { 366, 980 }, { 367, 1020 }, { 368, 1060 }, { 370, 1100 }, { 372, 1140 }, { 374, 1180 }, { 376, 1220 }, { 378, 1260 }, { 380, 1300 },
		{ 382, 1360 }, { 384, 1420 }, { 386, 1480 }, { 388, 1540 }, { 390, 1600 }, { 392, 1660 }, { 394, 1720 }, { 396, 1780 }, { 398, 1840 }, { 400, 1900 }
	};
	int baseWeaponskillCD = 2500;
	float gcd = baseWeaponskillCD * modifier * (1000 + (130 * (levelSubAndDiv[level - 1, 0] - speed) / levelSubAndDiv[level - 1, 1])) / 10000 / 100;
	return gcd;
}
public static unsafe int SkillSpeed() {
	UIState* uiState = UIState.Instance();
	return uiState->PlayerState.Attributes[45];
}
public static unsafe int SpellSpeed() {
	UIState* uiState = UIState.Instance();
	return uiState->PlayerState.Attributes[46];
}

So for my MNK combo, I have this in each combo class where I need the gcd

	float gcdModifier = (level < MNK.Levels.EnhancedGreasedLightning)
		? 0.95f
		: (level < MNK.Levels.EnhancedGreasedLightning2) ? 0.90f : (level < MNK.Levels.EnhancedGreasedLightning3) ? 0.85f : 0.80f;
	double gcd = PlayerGlobalCooldown(level, SkillSpeed(), gcdModifier);

or in my SAM combo:

	float gcdModifier = (!SelfHasEffect(SAM.Buffs.Fuka))
		? 1.00f
		: (level < SAM.Levels.EnhancedFugetsuandFuka) ? 0.90f : 0.87f;
	double gcd = PlayerGlobalCooldown(level, SkillSpeed(), gcdModifier);

Then I just reference gcd within the combo.

[vitharr137]

This is fantastic, thank you for the update! I'm poking around the job traits to see who may be left out, looks like there's a few buffs on various classes such as:

NIN: Huton, 15% for 60s
BRD: Army's Paeon Repertoire stacks 4% up to 4 stacks (unsure duration)
BRD: Army's Muse stacks at 1, 2, 4, or 12% for 10s
BLM: Ley Lines (requires Spell Speed calc) 15% while buff is up
WHM: Presence of Mind (requires Spell Speed calc) 20% for 15s
AST: Astrodyne (requires Spell Speed calc) Harmony of Body 10% for 15s

That should be all of them aside from overall Haste, which I can't find a good formula that's been updated on. Here's to finding the actual live parse of the recast time someday!

[vitharr137]

One small addition I did make to your code was adjusting the baseWeaponskillCD integer to instead be called in the function like so:

protected static double PlayerGlobalCooldown(int actionCD, byte level, int speed, float modifier)

This allowed me to specify different cast timers such as any spell that has a 1 second cast time (set as 1000 like so: PlayerGlobalCooldown(1000, level, SpellSpeed(), gcdModifier); ) which appears to work perfectly, as the same function that manages the recast time also manages the cast time.

[vitharr137]

Seems like the function I was looking into was the right one, and I'm wondering if you can do a bit more of your magic like you did to my early mathvomit function on this one:

int gcd2 = ActionManager.GetAdjustedRecastTime(ActionType.Spell, MNK.Bootshine);

Edit: Testing with classes like Bard with scaling haste buffs on their abilities confirms the proper functionality, it is dynamic.

Edit 2: I am now using this code as a calculation for seconds based GCDs, and it appears to not need any other setup

using FFXIVClientStructs.FFXIV.Client.Game;

double gcd = ActionManager.GetAdjustedRecastTime(ActionType.Spell, BRD.HeavyShot) / 1000f;

Things I don't know about this code, which looks like this:

[MemberFunction("E8 ?? ?? ?? ?? 8B D6 41 8B CF", IsStatic = true)]
public static partial int GetAdjustedRecastTime(ActionType actionType, uint actionID, byte a3 = 1);

What the different ActionTypes attach to, or what the byte a3 does in general, but this appears to return the milliseconds total of the cooldown without changing mid global

[Evolutious]

Great find! There is not much I can see that can be optimized in that (other than changing BRD.HeavyShot to actionID, but that is more semantics) so looks like you got a winner here!