vanilla-wow-addons – Rev 1

Subversion Repositories:
Rev:
local dewdrop = AceLibrary("Dewdrop-2.0")
local tablet = AceLibrary("Tablet-2.0")
local L = AceLibrary("AceLocale-2.2"):new("RegenFu")


RegenFu = AceLibrary("AceAddon-2.0"):new("FuBarPlugin-2.0", "AceEvent-2.0", "AceConsole-2.0", "AceDB-2.0", "AceDebug-2.0", "CandyBar-2.0")


local barTextures = { smooth = "Interface\\Addons\\FuBar_RegenFu\\Textures\\smooth.tga" }
local barIcon = "Interface\\Addons\\FuBar_RegenFu\\Textures\\5.tga"

RegenFu.optionsTable = {
        type = 'group',
        args = {
                showHP = {
                        order = 1,
                        type = 'toggle',
                        name = L["MENU_SHOW_HP"],
                        desc = L["MENU_SHOW_HP"],
                        set = "ToggleShowHP",
                        get = "IsShowHP",
                },
                showMP = {
                        order = 2,
                        type = 'toggle',
                        name = L["MENU_SHOW_MP"],
                        desc = L["MENU_SHOW_MP"],
                        set = "ToggleShowMP",
                        get = "IsShowMP",
                },
                showFSRT = {
                        order = 3,
                        type = 'toggle',
                        name = L["Show FSRT"],
                        desc = L["Show FSRT"],
                        set = "ToggleShowFSRT",
                        get = "IsShowFSRT",
                },        
                fsrtGroup1 = {
                        type = 'header',
                        order = 10,
                },
                showPercent = {
                        order = 11,
                        type = 'toggle',
                        name = L["MENU_SHOW_PERCENT"],
                        desc = L["MENU_SHOW_PERCENT"],
                        set = "ToggleShowPercent",
                        get = "IsShowPercent",
                },
                showCurrent = {
                        order = 12,
                        type = 'toggle',
                        name = L["MENU_SHOW_CURRENT"],
                        desc = L["MENU_SHOW_CURRENT"],
                        set = "ToggleShowCurrent",
                        get = "IsShowCurrent",
                },
                showFightRegen = {
                        order = 13,
                        type = 'toggle',
                        name = L["Show In Combat Regen Total"],
                        desc = L["Show In Combat Regen Total"],
                        set = "ToggleShowFightRegen",
                        get = "IsShowFightRegen",
                },

                hideLabel = {
                        order = 14,
                        type = 'toggle',
                        name = L["MENU_HIDE_LABEL"],
                        desc = L["MENU_HIDE_LABEL"],
                        set = "ToggleHideLabel",
                        get = "IsHideLabel",
                },
                fsrtGroup2 = {
                        type = 'header',
                        order = 20,
                        hidden = "IsHideFSRT",                  
                },

                icr = {
                    type = 'range',
                    desc = L["Percent Regen While Casting"],
                    name = L["Percent Regen While Casting"],
                        get  = "GetICR",
                        set  = "SetICR",
                    min = 0,
                    max = 1, 
                    step = 0.05, 
                    isPercent = true,
                        order = 21,
                        hidden = "IsHideFSRT",                          
                },

                mps = {
                    type = 'range',
                    desc = L["Mana Regen Forumula (Spirit/<value>)"],
                    name = L["Mana Regen Forumula (Spirit/<value>)"],
                        get  = "GetMPS",
                        set  = "SetMPS",
                        min = 4,
                    max = 5, 
                    step = 0.5, 
                        order = 22,
                        hidden = "IsHideFSRT",
                },

                mpi = {
                        type = "text",
                        usage = "<number>",
                        name = L["Mana Per Int"],
                        desc = L["Mana Per Int"],
                        get  = "GetMPI",
                        set  = "SetMPI",
                        validate = function(v)
                        return tonumber(v) ~= nil
                end,
                        order = 23,
                        hidden = "IsHideFSRT",
                },

                fsrtGroup3 = {
                        type = 'header',
                        order = 30,
                        hidden = "IsHideFSRT",                  
                },
                
                
                showFSRB = {
                        type = "toggle",
                        name = L["FSR Countdown Bar"],
                        desc = L["FSR Countdown Bar"],
                        set = "ShowFSRBar",
                        get = function() return RegenFu.db.char.showFSRBar end,
                        order = 31,
                        hidden = "IsHideFSRT",
                },

                fsrtGroup4 = {
                        type = 'header',
                        order = 40,
                        hidden = "IsHideFSRT",                  
                },
                
                
                reset = {
                        type = "execute",
                        name = L["Reset FSR Data"],
                        desc = L["Reset FSR Data"],
                        func = "ResetFSRT",
                        order = 41,
                        hidden = "IsHideFSRT",
                },
        },      
}


RegenFu:RegisterDB("FuBar_RegenDB", "FuBar_RegenPerCharDB")
RegenFu:RegisterDefaults('char', {
    mpi = 1.0/15,
    icr = 0,    
})
RegenFu:RegisterDefaults('class', {
    mps = 0.0,
})
RegenFu:RegisterDefaults('profile', {  
        showHP = true,
    showCurrent = false,
    showPercent = false, 
    showFightRegen = false, 
    hideLabel = false, 
})




        -- Methods
function RegenFu:IsShowHP()
        return self.db.profile.showHP;
end
        
function RegenFu:IsShowMP()
        return self.db.char.showMP;
end

function RegenFu:IsShowFSRT()
        return self.db.char.showFSRT;
end
        
function RegenFu:IsHideFSRT()
        return not self:IsShowFSRT()
end
        
function RegenFu:IsShowCurrent()
        return self.db.profile.showCurrent;
end
        
function RegenFu:IsShowPercent()
        return self.db.profile.showPercent;
end

function RegenFu:IsShowFightRegen()
        return self.db.profile.showFightRegen;
end             
        
function RegenFu:IsHideLabel()
        return self.db.profile.hideLabel;
end
        
function RegenFu:ToggleShowHP()
        self.db.profile.showHP = not self.db.profile.showHP;
        self:UpdateSettings();
end
        
function RegenFu:ToggleShowMP()
        self.db.char.showMP = not self.db.char.showMP;
        self:UpdateSettings();
end

function RegenFu:ToggleShowFSRT()
        self.db.char.showFSRT = not self.db.char.showFSRT;
        self:UpdateSettings();
end

function RegenFu:ToggleShowCurrent()
        self.db.profile.showCurrent = not self.db.profile.showCurrent;
        self:UpdateSettings();
end
                
function RegenFu:ToggleShowPercent()
        self.db.profile.showPercent = not self.db.profile.showPercent;
        self:Update();
end
        
function RegenFu:ToggleHideLabel()
        self.db.profile.hideLabel = not self.db.profile.hideLabel;
        self:Update();
end

function RegenFu:ToggleShowFightRegen()
        self.db.profile.showFightRegen = not self.db.profile.showFightRegen;
        self:Update();
end


function RegenFu:ResetFSRT()
        self.vars.combatDurationTotal = 0
        self.vars.timeInFSRTotal = 0
        self:Update()
end

function RegenFu:ResetLastCombatStats()
        self.vars.combatDurationLast = 0
        self.vars.timeInFSRLast = 0
        
        self.vars.regenMPDuringCombat = 0;
        self.vars.regenHPDuringCombat = 0;
        self.vars.usedMPDuringCombat = 0;
        
        self:Update()   
end

function RegenFu:GetCombatDuration()
        return self.vars.combatDurationLast
end

function RegenFu:SetCombatDuration(dur)
        self.vars.combatDurationTotal = self.vars.combatDurationTotal + ( dur- self.vars.combatDurationLast)
        self.vars.combatDurationLast = dur
end

function RegenFu:GetFSRDuration()
        return self.vars.timeInFSRLast
end

function RegenFu:SetFSRDuration(dur)
        self.vars.timeInFSRTotal = self.vars.timeInFSRTotal + ( dur- self.vars.timeInFSRLast)
        self.vars.timeInFSRLast = dur
end

function RegenFu:GetICR()
        return self.db.char.icr
end
function RegenFu:SetICR(val)
        self.db.char.icr = val
        self:Update()
end

function RegenFu:GetMPS()
        return 1.0 / self.db.class.mps
end
function RegenFu:SetMPS(val)
        self.db.class.mps = 1.0 / val
        self:Update()
end


function RegenFu:GetMPI()
        return 1.0 / self.db.char.mpi 
end
function RegenFu:SetMPI(val)
        self.db.char.mpi = 1.0 / val
        self:Update()
end

function RegenFu:ShowFSRBar(val)
        local n,l = L["FSR"]
        local c = "blue"
        local a = 0.8
        local t = barTextures["smooth"]

        self.db.char.showFSRBar = val

        if (val) then
                self:RegisterCandyBar(n, 5, l, barIcon, c) 
                self:SetCandyBarTexture(n, t)
                bwf = self:GetFrame()
                self:SetCandyBarWidth(n, bwf:GetWidth()) 
                if bwf:GetBottom() > 0 then 
                        self:SetCandyBarPoint(n, "TOPLEFT", bwf, "BOTTOMLEFT")
                else
                        self:SetCandyBarPoint(n, "BOTTOMLEFT", bwf, "TOPLEFT")
                end
                                        
        else
                self:StopCandyBar(n)
                self:UnregisterCandyBar(n)
        end     
end


RegenFu.OnMenuRequest = RegenFu.optionsTable

        
function RegenFu:OnInitialize()
        self:SetDebugging(self.db.profile.debug)
        
        self:RegisterChatCommand( L["AceConsole-commands"], RegenFu.optionsTable )
        


        self.vars = {
                currHealth = 0,
                currMana = 0,
                regenHP = 0,
                regenMP = 0,
                checkedManaState = 0,
                maxHPRate = 0,
                minHPRate = 9999,
                maxMPRate = 0,
                minMPRate = 9999,
                regenCombatTrack = 0,
                regenMPDuringCombat = 0,
                regenHPDuringCombat = 0,
        
        timeTillRegen = 0,
                usedMPDuringCombat = 0,
        combatDurationLast = 0,
        combatDurationTotal = 0,
        timeInFSRLast = 0,
        timeInFSRTotal = 0,
        lastUpdate = time(),
        secondEventID = 0;
        }
        
        self.data = {}
        
end

function RegenFu:OnEnable()
        self:RegisterEvent("UNIT_HEALTH");
        self:RegisterEvent("UNIT_MANA");
        self:RegisterEvent("PLAYER_ENTERING_WORLD");
        self:RegisterEvent("PLAYER_REGEN_DISABLED");
        self:RegisterEvent("PLAYER_REGEN_ENABLED");
        

        self:Setup()
        self:ShowFSRBar(self.db.char.showFSRBar)
    self.vars.secondEventID = self:ScheduleRepeatingEvent(self.OnUpdateInternal, 0.5, self)
end

function RegenFu:OnDisable()
    self:CancelScheduledEvent(self.vars.secondEventID)
end    
    
                
function RegenFu:PLAYER_ENTERING_WORLD()
        if self.vars.regenCombatTrack == 1 and not UnitAffectingCombat("player")  then
                self.vars.regenCombatTrack = 0
        end
        self:Update()
end
        
function RegenFu:Setup()
        local _, class = UnitClass("player");
        self:Debug("Setup() - "..class)
        
        if self.db.char.showMP == nil then
                if UnitManaMax("player") == 0 then
                        self.db.char.showMP = false
                        self.db.char.showFSRT = false
                        self.db.char.showFSRBar = false
                else 
                        self.db.char.showMP = true
                        self.db.char.showFSRT = true
                        self.db.char.showFSRBar = false         
                end

                if      ( class == "PRIEST" ) or ( class == "DRUID" ) then
                        self.db.char.showFSRT = true
                        self.db.char.showFSRBar = true
                end                                     
        end
            

        if self.db.class.mps == 0.0 then 
                if ( class == "PRIEST" ) or ( class == "MAGE" ) then
                        self.db.class.mps = 0.25;
                else
                        self.db.class.mps = 0.2;
                end    
        end    
end     
        
        
function RegenFu:PLAYER_REGEN_DISABLED()
        self.vars.regenCombatTrack = 1;

    self:ResetLastCombatStats()
end

function RegenFu:PLAYER_REGEN_ENABLED()
        self.vars.regenCombatTrack = 0; 
        self:Update()
end

function RegenFu:UNIT_HEALTH()
        if self:IsShowHP() then
                local currHealth = UnitHealth("player");
                if ( currHealth > self.vars.currHealth and self.vars.currHealth  ~= 0 ) then
                        self.vars.regenHP  = currHealth - self.vars.currHealth ;
                        
                        if ( self.vars.regenCombatTrack == 1) then
                                self.vars.regenHPDuringCombat = self.vars.regenHPDuringCombat + self.vars.regenHP;
                        end 
                        
                        if (self.vars.regenHP > self.vars.maxHPRate) then 
                                self.vars.maxHPRate = self.vars.regenHP ;
                        end
                        if (self.vars.regenHP < self.vars.minHPRate or self.vars.minHPRate == 9999) then 
                                self.vars.minHPRate = self.vars.regenHP;
                        end                             
                end
                self.vars.currHealth = currHealth;
                self:Update();
        end
end

function RegenFu:UNIT_MANA(unit)
        if ( unit == "player" ) and ( UnitPowerType("player") == 0 ) then
                if self:IsShowMP() or self:IsShowFSRT() then
                        local currMana = UnitMana("player");
                        if ( currMana  > self.vars.currMana and self.vars.currMana ~= 0 ) then
                                self.vars.regenMP  = currMana - self.vars.currMana  ;
        
                                if ( self.vars.regenCombatTrack == 1) then
                                        self.vars.regenMPDuringCombat = self.vars.regenMPDuringCombat + self.vars.regenMP;
                                end 
        
                                if (self.vars.regenMP > self.vars.maxMPRate) then 
                                        self.vars.maxMPRate = self.vars.regenMP;
                                end
                                if (self.vars.regenMP < self.vars.minMPRate or self.vars.minMPRate == 9999) then 
                                        self.vars.minMPRate = self.vars.regenMP;
                                end      
                        else
                                self.vars.timeTillRegen = 5;
                                if self:IsCandyBarRegistered(L["FSR"]) then
                                        local bwf = self:GetFrame()
                                        self:SetCandyBarWidth(L["FSR"], bwf:GetWidth()) 
                                        self:StartCandyBar(L["FSR"], false) 
                                end
--                      self.vars.regenMP = 0;
        
                                if (self.vars.regenCombatTrack == 1) then
                                        self.vars.usedMPDuringCombat = self.vars.usedMPDuringCombat + currMana - self.vars.currMana;
                                end
                        end            
                        
                        self.vars.currMana = currMana;
                        self:Update();
                end
        end
end

function RegenFu:OnUpdateInternal()
        local tm = time()
        local elapsed = tm - self.vars.lastUpdate 
        self.vars.lastUpdate = tm
--      self.timeSinceUpdate = self.timeSinceUpdate + elapsed;

        local update = nil
        
        if self.vars.timeTillRegen > 0 then
                self.vars.timeTillRegen = self.vars.timeTillRegen - elapsed;
                update = true
        end

        if (UnitMana("player") < UnitManaMax("player")) and self.vars.regenCombatTrack == 1 then
                self:SetCombatDuration(self:GetCombatDuration() + elapsed)

                if self.vars.timeTillRegen > 0 then
                        self:SetFSRDuration(self:GetFSRDuration() + elapsed)
                end
                
                update = true
        end

        if (update) then
           self:Update()
        end
end


function RegenFu:OnDataUpdate()
    self.data.regenHP = self.vars.regenHP
    self.data.regenMP = self.vars.regenMP
    self.data.regenHPCombat = self.vars.regenHPDuringCombat
    self.data.regenMPCombat = self.vars.regenMPDuringCombat
    
    self.data.maxHPRate = self.vars.maxHPRate
    self.data.minHPRate = self.vars.minHPRate
    self.data.maxMPRate = self.vars.maxMPRate
    self.data.minMPRate = self.vars.minMPRate
    
    self.data.usedMPCombat = self.vars.usedMPDuringCombat

    self.data.combatDurationTotal = self.vars.combatDurationTotal
    self.data.combatDurationLast = self.vars.combatDurationLast
    self.data.timeTillRegen = self.vars.timeTillRegen

    self.data.inCombat = self.vars.regenCombatTrack

    self.data.fsrpLast = self.vars.timeInFSRLast / (self.data.combatDurationLast + 0.001);
    self.data.fsrpTotal = self.vars.timeInFSRTotal / (self.data.combatDurationTotal + 0.001);

    self.data.playerHP = UnitHealth("player")
    self.data.playerMaxHP = UnitHealthMax("player")
    self.data.playerMP = UnitMana("player")
    self.data.playerMaxMP = UnitManaMax("player")

    self.data.regenMPPercent = (self.data.regenMP/self.data.playerMaxMP)*100
    self.data.regenHPPercent = (self.data.regenHP/self.data.playerMaxHP)*100
    self.data.regenHPPercentCombat = (self.data.regenHPCombat/self.data.playerMaxHP)*100
    self.data.regenMPPercentCombat  = (self.data.regenMPCombat/self.data.playerMaxMP)*100


        if self.data.minHPRate == 9999 then self.data.minHPRate = 0 end
        if self.data.minMPRate == 9999 then self.data.minMPRate = 0 end 

        if self.data.playerHP == self.data.playerMaxHP then
                self.data.regenHP = 0;
        end

        if self.data.playerMP == self.data.playerMaxMP then
                self.data.regenMP = 0;
        end     
end


function RegenFu:OnTextUpdate()
        local labelTextHP = "";
        local valueTextHP = "";
        local labelTextMP = "";
        local valueTextMP = "";
    local labelTextFSRT = ""
    local valueTextFSRT = ""
        
    -- safety in case both are off, then cant ever turn em on
        if ( not self:IsShowHP() and not self:IsShowMP() ) then
                self:ToggleShowHP();
        end
        
        if ( self:IsShowHP() ) then
                if not self:IsHideLabel() then
                        labelTextHP = L.HP_LABEL;
                end
                
                if self:IsShowPercent() then
                        valueTextHP = string.format("%.2f%%", self.data.regenHPPercent);
                else
                        valueTextHP = string.format("%d", self.data.regenHP);   
                end     

                if self:IsShowFightRegen() and self.data.inCombat == 1 then 
                        valueTextHP = string.format("|cff00ff00%s|r / |cff00ff00%s|r", valueTextHP, self.data.regenHPCombat);
                else
                        valueTextHP = string.format("|cff00ff00%s|r", valueTextHP);
                end

                if self:IsShowCurrent() then
                        valueTextHP = string.format("|cff00ff00%s|r/|cff00ff00%s|r(%s)", 
                  self.data.playerHP, self.data.playerMaxHP, valueTextHP);
                end
                
        end
        
        if ( self:IsShowMP() ) then
                if not self:IsHideLabel() then
                        labelTextMP = L.MP_LABEL;
                end
                
                if self:IsShowPercent() then
                        valueTextMP = string.format("%.2f%%", self.data.regenMPPercent);
                else
                        valueTextMP = string.format("%d", self.data.regenMP);   
                end
                
                if self:IsShowFightRegen() and self.data.inCombat == 1 then 
                        valueTextMP = string.format("|cff3399ff%s|r / |cff3399ff%s|r", valueTextMP, self.data.regenMPCombat);
                else
                        valueTextMP = string.format("|cff3399ff%s|r", valueTextMP);
                end
        
                if self:IsShowCurrent() then
                        valueTextMP = string.format("|cff3399ff%s|r/|cff3399ff%s|r(%s)", 
               self.data.playerMP, self.data.playerMaxMP, valueTextMP)
                end

        end

        if ( self:IsShowFSRT() ) then
                if not self:IsHideLabel() then
                        labelTextFSRT = L.FSR_LABEL
                end
                        valueTextFSRT = string.format("%d%%", self.data.fsrpTotal*100)
        end
        self:SetText(labelTextHP..valueTextHP.." "..labelTextMP..valueTextMP.." "..labelTextFSRT..valueTextFSRT);
        
        if self:IsCandyBarRegistered(L["FSR"]) then
                local bwf = self:GetFrame()
                self:SetCandyBarWidth(L["FSR"], bwf:GetWidth()) 
                self:Debug(bwf:GetBottom(), GetScreenHeight())
                if bwf:GetBottom() > 0 then 
                        self:SetCandyBarPoint(L["FSR"], "TOPLEFT", bwf, "BOTTOMLEFT")
                else
                        self:SetCandyBarPoint(L["FSR"], "BOTTOMLEFT", bwf, "TOPLEFT")
                end
        end     
end
        
function RegenFu:OnTooltipUpdate()
        local cat
        
        if self:IsShowHP() then
                cat = tablet:AddCategory(
                        'columns', 2,
                        'child_textR', 1,
                        'child_textG', 1,
                        'child_textB', 0,
                        'child_text2R', 0,
                        'child_text2G', 1,
                        'child_text2B', 0
                );

                cat:AddLine(
                        'text', L.TOOLTIP1_LEFT, 
                        'text2', string.format("%s |cffffffff/|r %s |cffffffff(|r|cffff0000%s|cffffffff)|r", 
               self.data.playerHP, self.data.playerMaxHP, self.data.playerMaxHP-self.data.playerHP )
                );
           local cat_ratiosH = cat:AddCategory(
                        'columns', 2,
                        'child_textR', 0.60,
                        'child_textG', 0.60,
                        'child_textB', 0,
                        'child_text2R', 0,
                        'child_text2G', 1,
                        'child_text2B', 0,
                        'hideBlankLine', true,
                        'child_indentation', 10
        )

                cat_ratiosH:AddLine(
                        'text', L.TOOLTIP3_LEFT, 
                        'text2', self.data.maxHPRate
                );
                cat_ratiosH:AddLine(
                        'text', L.TOOLTIP4_LEFT, 
                        'text2', self.data.minHPRate
                );
                cat_ratiosH:AddLine(
                        'text', L.TOOLTIP8_LEFT, 
                        'text2', string.format("%s (%.2f%%)", 
                self.data.regenHPCombat, self.data.regenHPPercentCombat )
                );                      
        end
        
        if self:IsShowMP() then
                cat = tablet:AddCategory(
                        'columns', 2,
                        'child_textR', 1,
                        'child_textG', 1,
                        'child_textB', 0,
                        'child_text2R', 0.2,
                        'child_text2G', 0.4,
                        'child_text2B', 1
                );

                cat:AddLine(
                        'text', L.TOOLTIP2_LEFT, 
                        'text2', string.format("%s |cffffffff/|r %s |cffffffff(|r|cffff0000%s|cffffffff)|r", 
                 self.data.playerMP, self.data.playerMaxMP, self.data.playerMaxMP-self.data.playerMP)
                );
                
           local cat_ratiosM = cat:AddCategory(
                        'columns', 2,
                        'child_textR', 0.60,
                        'child_textG', 0.60,
                        'child_textB', 0,
                        'child_text2R', 0.2,
                        'child_text2G', 0.4,
                        'child_text2B', 1,
                        'hideBlankLine', true,
                        'child_indentation', 10
        )
                        cat_ratiosM:AddLine(
                                'text', L.TOOLTIP5_LEFT, 
                                'text2', self.data.maxMPRate
                        );
                        cat_ratiosM:AddLine(
                                'text', L.TOOLTIP6_LEFT, 
                                'text2', self.data.minMPRate
                        );
                        cat_ratiosM:AddLine(
                                'text', L.TOOLTIP7_LEFT, 
                                'text2', string.format("%s (%.2f%%)", 
                         self.data.regenMPCombat, self.data.regenMPPercentCombat)
                        );
                        cat_ratiosM:AddLine(
                                'text', L.TOOLTIP9_LEFT, 
                                'text2', string.format("%s MP/5s", 
                         self:GetCombatDuration() > 0 and math.floor((self.data.regenMPCombat/self:GetCombatDuration())*5) or 0)
                        );
                                
        end             
    
        if self:IsShowFSRT() then
--              usedMPDuringCombat = 0,
--        combatDuration = 0,
--        timeInFSR = 0,

        
        local fsrp = self.data.fsrpLast
        local str = string.format("%0.2f", 2/(5*self.db.class.mps*(1 - fsrp + self.db.char.icr*fsrp)));
        
        local combatTag
        local timeFormat
        
        if self.data.inCombat == 1 then 
                combatTag = L["(This Fight)"]
                timeFormat = string.format("|cff00ff00%s|r", self:FormatDurationString(self.data.combatDurationLast))
        else  
                combatTag = L["(Last Fight)"]      
                timeFormat = self:FormatDurationString(self.data.combatDurationLast)    
        end
        
        local cat = tablet:AddCategory(
                        'columns', 2,
                        'child_textR', 1,
                        'child_textG', 1,
                        'child_textB', 0,
                        'child_text2R', 0.2,
                        'child_text2G', 0.4,
                        'child_text2B', 1
        )
        cat:AddLine(
            'text', L["Time Spent In Regen"].." "..combatTag,
            'text2', timeFormat
        )
        
                local cat_ratios = cat:AddCategory(
                                'columns', 2,
                                'child_textR', 0.60,
                                'child_textG', 0.60,
                                'child_textB', 0,
                                'child_text2R', 0.2,
                                'child_text2G', 0.4,
                                'child_text2B', 1,
                                'hideBlankLine', true,
                                'child_indentation', 10
                )
                cat_ratios:AddLine(
                    'text', L["% Of That Time In FSR"], 
                    'text2', string.format("%0.1f%%", fsrp*100)
                )
                cat_ratios:AddLine(
                    'text', L["Spirit Needed To Equal 1mp5"], 
                    'text2', str
                )
                cat_ratios:AddLine(
                    'text', L["Int Needed To Equal 1mp5"], 
                    'text2', string.format("%0.2f", self.data.combatDurationLast/5*self.db.char.mpi)
                )
                

                fsrp = self.data.fsrpTotal
        str = string.format("%0.2f", 2/(5*self.db.class.mps*(1 - fsrp + self.db.char.icr*fsrp)));
                
        local cat2 = tablet:AddCategory(
                'columns', 2,
                'child_textR', 1,
                'child_textG', 1,
                'child_textB', 0,
                'child_text2R', 0.2,
                'child_text2G', 0.4,
                'child_text2B', 1
        )
        cat2:AddLine(
            'text', L["Total Regen Time Observed"],
            'text2', self:FormatDurationString(self.data.combatDurationTotal)
        )
                local cat_ratios2 = cat2:AddCategory(
                                'columns', 2,
                                'child_textR', 0.60,
                                'child_textG', 0.60,
                                'child_textB', 0,
                                'child_text2R', 0.2,
                                'child_text2G', 0.4,
                                'child_text2B', 1,
                                'hideBlankLine', true,
                                'child_indentation', 10
            )        
        cat_ratios2:AddLine(
            'text', L["% Of That Time In FSR"], 
            'text2', string.format("%0.1f%%", fsrp*100)
        )
        cat_ratios2:AddLine(
            'text', L["Spirit Needed To Equal 1mp5"], 
            'text2', str
        )
    end
end
        
        
function RegenFu:FormatDurationString(duration)
        return string.format("%d:%04.1f" , floor(duration/60), floor(mod(duration*10, 600))/10)
end
        
        
function RegenFu:UpdateSettings()
        -- safety in case both are off, then cant ever turn em on
        if ( not self:IsShowHP() and not self:IsShowMP() ) then
                self:ToggleShowHP();
        end
        self:Update();
end
function RegenFu:OnProfileEnable(oldName, _, copyFrom)
        self:Debug("OnProfileEnable()")
        self:Setup()
        
        local function func()
                self:Update()
        end
        self:ScheduleEvent(func, 0.01)
end

Generated by GNU Enscript 1.6.5.90.