Gladdy-TBC/Modules/Cooldowns.lua

1195 lines
49 KiB
Lua
Raw Normal View History

local type, pairs, ipairs, ceil, tonumber, mod, tostring, upper, select, tinsert, tremove = type, pairs, ipairs, ceil, tonumber, mod, tostring, string.upper, select, tinsert, tremove
2022-03-03 23:37:42 +01:00
local tbl_sort = table.sort
2021-05-17 16:49:54 +02:00
local GetTime = GetTime
local CreateFrame = CreateFrame
local GetSpellInfo = GetSpellInfo
2022-07-31 06:04:50 +02:00
local AURA_TYPE_BUFF = AURA_TYPE_BUFF
2021-05-17 16:49:54 +02:00
local Gladdy = LibStub("Gladdy")
2022-07-31 06:04:50 +02:00
local LCG = LibStub("LibCustomGlow-1.0")
2021-05-17 16:49:54 +02:00
local L = Gladdy.L
2022-03-03 23:37:42 +01:00
local function tableLength(tbl)
local getN = 0
for n in pairs(tbl) do
getN = getN + 1
end
return getN
end
2021-05-18 16:39:43 +02:00
local function getDefaultCooldown()
local cooldowns = {}
2022-03-03 23:37:42 +01:00
local cooldownsOrder = {}
for class,spellTable in pairs(Gladdy:GetCooldownList()) do
if not spellTable.class and not cooldownsOrder[class] then
cooldownsOrder[class] = {}
end
for spellId,val in pairs(spellTable) do
2021-07-29 15:53:34 +02:00
local spellName = GetSpellInfo(spellId)
2021-05-18 16:39:43 +02:00
if spellName then
cooldowns[tostring(spellId)] = true
2022-03-03 23:37:42 +01:00
if type(val) == "table" and val.class then
if val.class and not cooldownsOrder[val.class] then
cooldownsOrder[val.class] = {}
end
if not cooldownsOrder[val.class][tostring(spellId)] then
cooldownsOrder[val.class][tostring(spellId)] = tableLength(cooldownsOrder[val.class]) + 1
end
else
if not cooldownsOrder[class][tostring(spellId)] then
cooldownsOrder[class][tostring(spellId)] = tableLength(cooldownsOrder[class]) + 1
end
end
2021-05-18 16:39:43 +02:00
else
2022-01-11 00:29:30 +01:00
Gladdy:Debug("ERROR", "spellid does not exist " .. spellId)
2021-05-18 16:39:43 +02:00
end
end
end
2022-03-03 23:37:42 +01:00
return cooldowns, cooldownsOrder
2021-05-18 16:39:43 +02:00
end
2021-05-17 16:49:54 +02:00
local Cooldowns = Gladdy:NewModule("Cooldowns", nil, {
cooldownFont = "DorisPP",
cooldownFontScale = 1,
cooldownFontColor = { r = 1, g = 1, b = 0, a = 1 },
cooldown = true,
2022-01-11 00:29:17 +01:00
cooldownYGrowDirection = "UP",
cooldownXGrowDirection = "RIGHT",
2021-05-17 16:49:54 +02:00
cooldownYOffset = 0,
cooldownXOffset = 0,
cooldownSize = 30,
cooldownIconGlow = true,
cooldownIconZoomed = false,
cooldownIconDesaturateOnCooldown = false,
cooldownIconAlphaOnCooldown = 1,
2021-05-17 16:49:54 +02:00
cooldownWidthFactor = 1,
cooldownIconPadding = 1,
cooldownMaxIconsPerLine = 10,
cooldownBorderStyle = "Interface\\AddOns\\Gladdy\\Images\\Border_Gloss",
cooldownBorderColor = { r = 1, g = 1, b = 1, a = 1 },
cooldownDisableCircle = false,
2021-05-18 16:39:43 +02:00
cooldownCooldownAlpha = 1,
2022-01-11 00:29:17 +01:00
cooldownCooldowns = getDefaultCooldown(),
2022-03-03 23:37:42 +01:00
cooldownCooldownsOrder = select(2, getDefaultCooldown()),
cooldownFrameStrata = "MEDIUM",
cooldownFrameLevel = 3,
2022-03-03 23:37:42 +01:00
cooldownGroup = false,
cooldownGroupDirection = "DOWN"
2021-05-17 16:49:54 +02:00
})
function Cooldowns:Initialize()
2022-03-03 23:37:42 +01:00
self.frames = {}
2021-05-17 16:49:54 +02:00
self.cooldownSpellIds = {}
self.spellTextures = {}
self.iconCache = {}
2021-07-29 15:53:34 +02:00
for _,spellTable in pairs(Gladdy:GetCooldownList()) do
2022-03-03 23:37:42 +01:00
for spellId,val in pairs(spellTable) do
2021-07-29 15:53:34 +02:00
local spellName, _, texture = GetSpellInfo(spellId)
2022-03-03 23:37:42 +01:00
if type(val) == "table" and val.icon then
texture = val.icon
end
2021-05-17 16:49:54 +02:00
if spellName then
2021-07-29 15:53:34 +02:00
self.cooldownSpellIds[spellName] = spellId
self.spellTextures[spellId] = texture
2021-05-17 16:49:54 +02:00
else
2022-01-11 00:29:30 +01:00
Gladdy:Debug("ERROR", "spellid does not exist " .. spellId)
2021-05-17 16:49:54 +02:00
end
end
end
self:RegisterMessage("ENEMY_SPOTTED")
self:RegisterMessage("UNIT_SPEC")
2021-05-17 16:49:54 +02:00
self:RegisterMessage("UNIT_DEATH")
2021-05-18 16:39:43 +02:00
self:RegisterMessage("UNIT_DESTROYED")
2022-07-31 06:04:50 +02:00
self:RegisterMessage("AURA_GAIN")
2021-05-17 16:49:54 +02:00
end
---------------------
-- Frame
---------------------
2021-05-17 16:49:54 +02:00
function Cooldowns:CreateFrame(unit)
local button = Gladdy.buttons[unit]
-- Cooldown frame
local spellCooldownFrame = CreateFrame("Frame", nil, button)
2021-05-19 19:30:32 +02:00
spellCooldownFrame:EnableMouse(false)
2021-09-24 15:51:24 +02:00
spellCooldownFrame:SetMovable(true)
spellCooldownFrame:SetFrameStrata(Gladdy.db.cooldownFrameStrata)
spellCooldownFrame:SetFrameLevel(Gladdy.db.cooldownFrameLevel)
spellCooldownFrame.icons = {}
button.spellCooldownFrame = spellCooldownFrame
2022-03-03 23:37:42 +01:00
self.frames[unit] = spellCooldownFrame
end
function Cooldowns:CreateIcon() -- returns iconFrame
local icon
if (#self.iconCache > 0) then
icon = tremove(self.iconCache, #self.iconCache)
else
icon = CreateFrame("Frame")
2021-05-17 16:49:54 +02:00
icon:EnableMouse(false)
2021-05-17 16:49:54 +02:00
icon.texture = icon:CreateTexture(nil, "BACKGROUND")
2021-05-19 14:57:29 +02:00
icon.texture:SetMask("Interface\\AddOns\\Gladdy\\Images\\mask")
icon.texture.masked = true
2021-05-17 16:49:54 +02:00
icon.texture:SetAllPoints(icon)
icon.cooldown = CreateFrame("Cooldown", nil, icon, "CooldownFrameTemplate")
icon.cooldown.noCooldownCount = true
icon.cooldown:SetReverse(false)
icon.cooldown:SetHideCountdownNumbers(true)
icon.cooldownFrame = CreateFrame("Frame", nil, icon)
icon.cooldownFrame:ClearAllPoints()
icon.cooldownFrame:SetAllPoints(icon)
icon.border = icon.cooldownFrame:CreateTexture(nil, "OVERLAY")
icon.border:SetAllPoints(icon)
icon.cooldownFont = icon.cooldownFrame:CreateFontString(nil, "OVERLAY")
icon.cooldownFont:SetAllPoints(icon)
self:UpdateIcon(icon)
end
return icon
end
function Cooldowns:UpdateIcon(icon)
icon:SetFrameStrata(Gladdy.db.cooldownFrameStrata)
icon:SetFrameLevel(Gladdy.db.cooldownFrameLevel)
icon.cooldown:SetFrameStrata(Gladdy.db.cooldownFrameStrata)
icon.cooldown:SetFrameLevel(Gladdy.db.cooldownFrameLevel + 1)
icon.cooldownFrame:SetFrameStrata(Gladdy.db.cooldownFrameStrata)
icon.cooldownFrame:SetFrameLevel(Gladdy.db.cooldownFrameLevel + 2)
icon:SetHeight(Gladdy.db.cooldownSize)
icon:SetWidth(Gladdy.db.cooldownSize * Gladdy.db.cooldownWidthFactor)
icon.cooldownFont:SetFont(Gladdy:SMFetch("font", "cooldownFont"), Gladdy.db.cooldownSize / 2 * Gladdy.db.cooldownFontScale, "OUTLINE")
icon.cooldownFont:SetTextColor(Gladdy:SetColor(Gladdy.db.cooldownFontColor))
if Gladdy.db.cooldownIconZoomed then
icon.cooldown:SetWidth(icon:GetWidth())
icon.cooldown:SetHeight(icon:GetHeight())
else
icon.cooldown:SetWidth(icon:GetWidth() - icon:GetWidth()/16)
icon.cooldown:SetHeight(icon:GetHeight() - icon:GetHeight()/16)
end
icon.cooldown:ClearAllPoints()
icon.cooldown:SetPoint("CENTER", icon, "CENTER")
icon.cooldown:SetAlpha(Gladdy.db.cooldownCooldownAlpha)
icon.cooldownFont:SetFont(Gladdy:SMFetch("font", "cooldownFont"), (icon:GetWidth()/2 - 1) * Gladdy.db.cooldownFontScale, "OUTLINE")
icon.cooldownFont:SetTextColor(Gladdy:SetColor(Gladdy.db.cooldownFontColor))
icon.border:SetTexture(Gladdy.db.cooldownBorderStyle)
icon.border:SetVertexColor(Gladdy:SetColor(Gladdy.db.cooldownBorderColor))
if Gladdy.db.cooldownIconZoomed then
if icon.texture.masked then
icon.texture:SetMask(nil)
icon.texture:SetTexCoord(0.1,0.9,0.1,0.9)
icon.texture.masked = nil
end
else
if not icon.texture.masked then
icon.texture:SetMask(nil)
icon.texture:SetTexCoord(0,1,0,1)
icon.texture:SetMask("Interface\\AddOns\\Gladdy\\Images\\mask")
icon.texture.masked = true
end
end
if Gladdy.db.cooldownIconDesaturateOnCooldown and icon.active then
icon.texture:SetDesaturated(true)
else
icon.texture:SetDesaturated(false)
end
if Gladdy.db.cooldownIconAlphaOnCooldown < 1 and icon.active then
icon.texture:SetAlpha(Gladdy.db.cooldownIconAlphaOnCooldown)
else
icon.texture:SetAlpha(1)
end
end
function Cooldowns:IconsSetPoint(button)
2022-03-03 23:37:42 +01:00
local orderedIcons = {}
for _,icon in pairs(button.spellCooldownFrame.icons) do
tinsert(orderedIcons, icon)
end
tbl_sort(orderedIcons, function(a, b)
return Gladdy.db.cooldownCooldownsOrder[button.class][tostring(a.spellId)] < Gladdy.db.cooldownCooldownsOrder[button.class][tostring(b.spellId)]
end)
for i,icon in ipairs(orderedIcons) do
icon:SetParent(button.spellCooldownFrame)
icon:ClearAllPoints()
if (Gladdy.db.cooldownXGrowDirection == "LEFT") then
if (i == 1) then
icon:SetPoint("LEFT", button.spellCooldownFrame, "LEFT", 0, 0)
elseif (mod(i-1,Gladdy.db.cooldownMaxIconsPerLine) == 0) then
if (Gladdy.db.cooldownYGrowDirection == "DOWN") then
2022-03-03 23:37:42 +01:00
icon:SetPoint("TOP", orderedIcons[i-Gladdy.db.cooldownMaxIconsPerLine], "BOTTOM", 0, -Gladdy.db.cooldownIconPadding)
else
2022-03-03 23:37:42 +01:00
icon:SetPoint("BOTTOM", orderedIcons[i-Gladdy.db.cooldownMaxIconsPerLine], "TOP", 0, Gladdy.db.cooldownIconPadding)
end
else
2022-03-03 23:37:42 +01:00
icon:SetPoint("RIGHT", orderedIcons[i-1], "LEFT", -Gladdy.db.cooldownIconPadding, 0)
end
end
if (Gladdy.db.cooldownXGrowDirection == "RIGHT") then
if (i == 1) then
icon:SetPoint("LEFT", button.spellCooldownFrame, "LEFT", 0, 0)
elseif (mod(i-1,Gladdy.db.cooldownMaxIconsPerLine) == 0) then
if (Gladdy.db.cooldownYGrowDirection == "DOWN") then
2022-03-03 23:37:42 +01:00
icon:SetPoint("TOP", orderedIcons[i-Gladdy.db.cooldownMaxIconsPerLine], "BOTTOM", 0, -Gladdy.db.cooldownIconPadding)
else
2022-03-03 23:37:42 +01:00
icon:SetPoint("BOTTOM", orderedIcons[i-Gladdy.db.cooldownMaxIconsPerLine], "TOP", 0, Gladdy.db.cooldownIconPadding)
end
else
2022-03-03 23:37:42 +01:00
icon:SetPoint("LEFT", orderedIcons[i-1], "RIGHT", Gladdy.db.cooldownIconPadding, 0)
end
end
end
end
function Cooldowns:UpdateFrameOnce()
for _,icon in ipairs(self.iconCache) do
Cooldowns:UpdateIcon(icon)
2021-05-17 16:49:54 +02:00
end
end
function Cooldowns:UpdateFrame(unit)
local button = Gladdy.buttons[unit]
-- Cooldown frame
local testAgain = false
2021-05-17 16:49:54 +02:00
if (Gladdy.db.cooldown) then
button.spellCooldownFrame:SetHeight(Gladdy.db.cooldownSize)
button.spellCooldownFrame:SetWidth(1)
button.spellCooldownFrame:SetFrameStrata(Gladdy.db.cooldownFrameStrata)
button.spellCooldownFrame:SetFrameLevel(Gladdy.db.cooldownFrameLevel)
2022-01-11 00:29:17 +01:00
Gladdy:SetPosition(button.spellCooldownFrame, unit, "cooldownXOffset", "cooldownYOffset", Cooldowns:LegacySetPosition(button, unit), Cooldowns)
2021-09-24 15:51:24 +02:00
if (unit == "arena1") then
2022-01-11 00:29:17 +01:00
Gladdy:CreateMover(button.spellCooldownFrame,"cooldownXOffset", "cooldownYOffset", L["Cooldown"],
{"TOPLEFT", "TOPLEFT"},
2022-01-13 23:11:33 +01:00
Gladdy.db.cooldownSize * Gladdy.db.cooldownWidthFactor, Gladdy.db.cooldownSize, 0, 0, "cooldown")
2021-09-24 15:51:24 +02:00
end
2022-03-03 23:37:42 +01:00
if (Gladdy.db.cooldownGroup) then
--TODO fix overlapping
2022-03-03 23:37:42 +01:00
if (unit ~= "arena1") then
local previousUnit = "arena" .. string.gsub(unit, "arena", "") - 1
self.frames[unit]:ClearAllPoints()
self.frames[unit]:SetPoint("TOP", self.frames[previousUnit], "BOTTOM", 0, -Gladdy.db.cooldownIconPadding)
end
end
2021-05-17 16:49:54 +02:00
-- Update each cooldown icon
for _,icon in pairs(button.spellCooldownFrame.icons) do
testAgain = icon.texture.masked
self:UpdateIcon(icon)
if icon.texture.masked ~= testAgain then
testAgain = true
else
testAgain = false
end
2021-05-17 16:49:54 +02:00
end
self:IconsSetPoint(button)
2021-05-17 16:49:54 +02:00
button.spellCooldownFrame:Show()
else
button.spellCooldownFrame:Hide()
end
if testAgain and Gladdy.frame.testing then
Cooldowns:ResetUnit(unit)
Cooldowns:ENEMY_SPOTTED(unit)
Cooldowns:UNIT_SPEC(unit)
Cooldowns:Test(unit)
end
end
function Cooldowns:ResetUnit(unit)
local button = Gladdy.buttons[unit]
if not button then
return
end
for i=#button.spellCooldownFrame.icons,1,-1 do
self:ClearIcon(button, i)
2021-05-17 16:49:54 +02:00
end
end
function Cooldowns:ClearIcon(button, index, spellId, icon)
if index then
icon = tremove(button.spellCooldownFrame.icons, index)
else
for i=#button.spellCooldownFrame.icons,1,-1 do
if icon then
if button.spellCooldownFrame.icons[i] == icon then
icon = tremove(button.spellCooldownFrame.icons, index)
end
end
if not icon and spellId then
if button.spellCooldownFrame.icons[i].spellId == spellId then
icon = tremove(button.spellCooldownFrame.icons, index)
end
end
end
end
icon:ClearAllPoints()
icon:SetParent(nil)
icon:Hide()
icon.spellId = nil
icon.active = false
icon.cooldown:Hide()
icon.cooldownFont:SetText("")
icon:SetScript("OnUpdate", nil)
2022-07-31 06:04:50 +02:00
LCG:ButtonGlow_Stop(icon)
tinsert(self.iconCache, icon)
end
---------------------
-- Test
---------------------
2021-05-17 16:49:54 +02:00
function Cooldowns:Test(unit)
2022-03-03 23:37:42 +01:00
if Gladdy.frame.testing then
self:UpdateTestCooldowns(unit)
2021-06-16 14:10:09 +02:00
end
2022-07-31 21:47:08 +02:00
Cooldowns:AURA_GAIN(_, AURA_TYPE_BUFF, "22812", "Barkskin", _, 20, _, _, _, _, unit, true) -- unit, auraType, spellID, spellName, texture, duration, expirationTime
2021-05-17 16:49:54 +02:00
end
function Cooldowns:UpdateTestCooldowns(unit)
local button = Gladdy.buttons[unit]
2022-03-25 00:02:25 +01:00
local orderedIcons = {}
2022-03-25 00:02:25 +01:00
for _,icon in pairs(button.spellCooldownFrame.icons) do
tinsert(orderedIcons, icon)
2022-01-27 01:30:28 +01:00
end
2022-03-25 00:02:25 +01:00
tbl_sort(orderedIcons, function(a, b)
return Gladdy.db.cooldownCooldownsOrder[button.class][tostring(a.spellId)] < Gladdy.db.cooldownCooldownsOrder[button.class][tostring(b.spellId)]
end)
for _,icon in ipairs(orderedIcons) do
self:CooldownUsed(unit, button.class, icon.spellId)
2021-05-17 16:49:54 +02:00
end
end
---------------------
-- Events
---------------------
2021-05-17 16:49:54 +02:00
function Cooldowns:ENEMY_SPOTTED(unit)
2022-01-27 01:30:28 +01:00
if (not Gladdy.buttons[unit]) then
return
end
2021-05-17 16:49:54 +02:00
self:UpdateCooldowns(Gladdy.buttons[unit])
end
function Cooldowns:UNIT_SPEC(unit)
2022-01-27 01:30:28 +01:00
if (not Gladdy.buttons[unit]) then
return
end
self:UpdateCooldowns(Gladdy.buttons[unit])
2021-05-17 16:49:54 +02:00
end
function Cooldowns:UNIT_DESTROYED(unit)
2022-07-31 06:04:50 +02:00
self:ResetUnit(unit)
end
--[[
/run local a=LibStub("Gladdy").modules["Cooldowns"] a:AURA_GAIN("arena1",22812)
/run local a=LibStub("Gladdy").modules["Cooldowns"] a:AURA_FADE("arena1",22812)
--]]
function Cooldowns:AURA_GAIN(_, auraType, spellID, spellName, _, duration, _, _, _, _, unitCaster, test)
2022-07-31 21:47:08 +02:00
local arenaUnit = test and unitCaster or Gladdy:GetArenaUnit(unitCaster, true)
2022-07-31 06:04:50 +02:00
if not Gladdy.db.cooldownIconGlow or not arenaUnit or not Gladdy.buttons[arenaUnit] or auraType ~= AURA_TYPE_BUFF then
return
end
local cooldownFrame = Gladdy.buttons[arenaUnit].spellCooldownFrame
local spellId = Cooldowns.cooldownSpellIds[spellName] -- don't use spellId from combatlog, in case of different spellrank
if spellID == 16188 or spellID == 17116 then -- Nature's Swiftness (same name for druid and shaman)
spellId = spellID
end
for _,icon in pairs(cooldownFrame.icons) do
if (icon.spellId == spellId) then
if icon._ButtonGlow and not icon._ButtonGlow.animIn:IsPlaying() or not icon._ButtonGlow then
LCG.ButtonGlow_Start(icon, nil, 0.15)
C_Timer.NewTimer(duration, function() LCG.ButtonGlow_Stop(icon) end)
end
end
end
end
2022-07-31 06:04:50 +02:00
function Cooldowns:AURA_FADE(unit, spellID)
if not Gladdy.buttons[unit] then
return
end
local cooldownFrame = Gladdy.buttons[unit].spellCooldownFrame
for _,icon in pairs(cooldownFrame.icons) do
if (icon.spellId == spellID) then
LCG.ButtonGlow_Stop(icon)
end
end
end
---------------------
-- Cooldown Start/Ready
---------------------
2022-01-12 16:18:34 +01:00
function Cooldowns:CooldownStart(button, spellId, duration, start)
2021-05-17 16:49:54 +02:00
-- starts timer frame
if not duration or duration == nil or type(duration) ~= "number" then
return
end
for _,icon in pairs(button.spellCooldownFrame.icons) do
if (icon.spellId == spellId) then
icon.active = true
icon.timeLeft = start and start - GetTime() + duration or duration
if (not Gladdy.db.cooldownDisableCircle) then icon.cooldown:SetCooldown(start or GetTime(), duration) end
if Gladdy.db.cooldownIconDesaturateOnCooldown then
icon.texture:SetDesaturated(true)
end
if Gladdy.db.cooldownIconAlphaOnCooldown < 1 then
icon.texture:SetAlpha(Gladdy.db.cooldownIconAlphaOnCooldown)
end
--if math.random(1, 30 ) > 10 then LCG.ButtonGlow_Start(icon, nil, 0.15) end
icon:SetScript("OnUpdate", function(self, elapsed)
2021-05-17 16:49:54 +02:00
self.timeLeft = self.timeLeft - elapsed
local timeLeft = ceil(self.timeLeft)
if timeLeft >= 540 then
2021-09-14 23:55:17 +02:00
self.cooldownFont:SetFont(Gladdy:SMFetch("font", "cooldownFont"), Gladdy.db.cooldownSize / 3.1 * Gladdy.db.cooldownFontScale, "OUTLINE")
2021-05-17 16:49:54 +02:00
elseif timeLeft < 540 and timeLeft >= 60 then
2021-09-14 23:55:17 +02:00
self.cooldownFont:SetFont(Gladdy:SMFetch("font", "cooldownFont"), Gladdy.db.cooldownSize / 2.15 * Gladdy.db.cooldownFontScale, "OUTLINE")
2021-05-17 16:49:54 +02:00
elseif timeLeft < 60 and timeLeft > 0 then
2021-09-14 23:55:17 +02:00
self.cooldownFont:SetFont(Gladdy:SMFetch("font", "cooldownFont"), Gladdy.db.cooldownSize / 2.15 * Gladdy.db.cooldownFontScale, "OUTLINE")
2021-05-17 16:49:54 +02:00
end
Gladdy:FormatTimer(self.cooldownFont, self.timeLeft, self.timeLeft < 0)
2021-05-17 16:49:54 +02:00
if (self.timeLeft <= 0) then
Cooldowns:CooldownReady(button, spellId, icon)
2021-05-17 16:49:54 +02:00
end
if (self.timeLeft <= 0) then
Cooldowns:CooldownReady(button, spellId, icon)
2021-05-17 16:49:54 +02:00
end
end)
--C_VoiceChat.SpeakText(2, GetSpellInfo(spellId), 3, 4, 100)
2021-05-17 16:49:54 +02:00
end
end
end
local function resetIcon(icon)
if Gladdy.db.cooldownIconDesaturateOnCooldown then
icon.texture:SetDesaturated(false)
end
if Gladdy.db.cooldownIconAlphaOnCooldown < 1 then
icon.texture:SetAlpha(1)
end
icon.active = false
icon.cooldown:Hide()
icon.cooldownFont:SetText("")
icon:SetScript("OnUpdate", nil)
--LCG.ButtonGlow_Stop(icon)
end
2021-05-17 16:49:54 +02:00
function Cooldowns:CooldownReady(button, spellId, frame)
if (frame == false) then
for _,icon in pairs(button.spellCooldownFrame.icons) do
if (icon.spellId == spellId) then
resetIcon(icon)
2021-05-17 16:49:54 +02:00
end
end
else
resetIcon(frame)
2021-05-17 16:49:54 +02:00
end
end
function Cooldowns:CooldownUsed(unit, unitClass, spellId, expirationTimeInSeconds)
2021-05-17 16:49:54 +02:00
local button = Gladdy.buttons[unit]
if not button then
return
end
-- if (self.db.cooldownList[spellId] == false) then return end
2021-05-18 16:39:43 +02:00
local cooldown = Gladdy:GetCooldownList()[unitClass][spellId]
2021-05-17 16:49:54 +02:00
local cd = cooldown
if (type(cooldown) == "table") then
-- return if the spec doesn't have a cooldown for this spell
--if (arenaSpecs[unit] ~= nil and cooldown.notSpec ~= nil and arenaSpecs[unit] == cooldown.notSpec) then return end
if (button.spec ~= nil and cooldown.notSpec ~= nil and button.spec == cooldown.notSpec) then
return
end
-- check if we need to reset other cooldowns because of this spell
if (cooldown.resetCD ~= nil) then
2021-07-29 15:53:34 +02:00
for spellID,_ in pairs(cooldown.resetCD) do
self:CooldownReady(button, spellID, false)
2021-05-17 16:49:54 +02:00
end
end
-- check if there is a special cooldown for the units spec
--if (arenaSpecs[unit] ~= nil and cooldown[arenaSpecs[unit]] ~= nil) then
if (button.spec ~= nil and cooldown[button.spec] ~= nil) then
cd = cooldown[button.spec]
else
cd = cooldown.cd
end
-- check if there is a shared cooldown with an other spell
if (cooldown.sharedCD ~= nil) then
local sharedCD = cooldown.sharedCD.cd and cooldown.sharedCD.cd or cd
2021-07-29 15:53:34 +02:00
for spellID,_ in pairs(cooldown.sharedCD) do
if (spellID ~= "cd") then
local skip = false
for _,icon in pairs(button.spellCooldownFrame.icons) do
if (icon.spellId == spellID and icon.active and icon.timeLeft > sharedCD) then
skip = true
break
end
end
if not skip then
self:CooldownStart(button, spellID, sharedCD)
end
2021-05-17 16:49:54 +02:00
end
end
end
end
if (Gladdy.db.cooldown) then
-- start cooldown
2022-01-12 16:18:34 +01:00
self:CooldownStart(button, spellId, cd, expirationTimeInSeconds and (GetTime() + expirationTimeInSeconds - cd) or nil)
2021-05-17 16:49:54 +02:00
end
--[[ announcement
if (self.db.cooldownAnnounce or self.db.cooldownAnnounceList[spellId] or self.db.cooldownAnnounceList[unitClass]) then
self:SendAnnouncement(string.format(L["COOLDOWN USED: %s (%s) used %s - %s sec. cooldown"], UnitName(unit), UnitClass(unit), spellName, cd), RAID_CLASS_COLORS[UnitClass(unit)], self.db.cooldownAnnounceList[spellId] and self.db.cooldownAnnounceList[spellId] or self.db.announceType)
end]]
--[[ sound file
if (db.cooldownSoundList[spellId] ~= nil and db.cooldownSoundList[spellId] ~= "disabled") then
PlaySoundFile(LSM:Fetch(LSM.MediaType.SOUND, db.cooldownSoundList[spellId]))
end ]]
end
---------------------
2022-01-27 01:30:28 +01:00
-- Update Cooldowns
---------------------
function Cooldowns:AddCooldown(spellID, value, button)
-- see if we have shared cooldowns without a cooldown defined
-- e.g. hunter traps have shared cooldowns, so only display one trap instead all of them
local sharedCD = false
if (type(value) == "table" and value.sharedCD ~= nil and value.sharedCD.cd == nil) then
for spellId, _ in pairs(value.sharedCD) do
for _,icon in pairs(button.spellCooldownFrame.icons) do
if (icon.spellId == spellId) then
sharedCD = true
2022-03-03 23:37:42 +01:00
break
end
end
end
end
for _,icon in pairs(button.spellCooldownFrame.icons) do
if (icon and icon.spellId == spellID) then
sharedCD = true
2022-03-03 23:37:42 +01:00
break
end
end
if (not sharedCD) then
local icon = self:CreateIcon()
icon:Show()
icon.spellId = spellID
icon.texture:SetTexture(self.spellTextures[spellID])
tinsert(button.spellCooldownFrame.icons, icon)
self:IconsSetPoint(button)
2022-07-31 21:47:08 +02:00
Gladdy:Debug("INFO", "Cooldowns:AddCooldown", button.unit, GetSpellInfo(spellID))
end
end
function Cooldowns:UpdateCooldowns(button)
local class = button.class
local race = button.race
local spec = button.spec
if not class or not race then
return
end
for k, v in pairs(Gladdy:GetCooldownList()[class]) do
if Gladdy.db.cooldownCooldowns[tostring(k)] then
if (type(v) ~= "table" or (type(v) == "table" and v.spec == nil)) then
Cooldowns:AddCooldown(k, v, button)
end
if (type(v) == "table" and v.spec ~= nil and v.spec == spec) then
Cooldowns:AddCooldown(k, v, button)
end
end
end
2022-03-03 23:37:42 +01:00
for k, v in pairs(Gladdy:GetCooldownList()[race]) do
if Gladdy.db.cooldownCooldowns[tostring(k)] then
if (type(v) ~= "table" or (type(v) == "table" and v.spec == nil)) then
Cooldowns:AddCooldown(k, v, button)
end
if (type(v) == "table" and v.spec ~= nil and v.spec == spec) then
Cooldowns:AddCooldown(k, v, button)
end
end
end
end
---------------------
-- Options
---------------------
2021-05-17 16:49:54 +02:00
function Cooldowns:GetOptions()
return {
headerCooldown = {
type = "header",
name = L["Cooldown"],
order = 2,
},
cooldown = Gladdy:option({
type = "toggle",
2021-05-24 12:41:21 +02:00
name = L["Enabled"],
2021-05-17 16:49:54 +02:00
desc = L["Enabled cooldown module"],
order = 2,
}),
cooldownGroup = Gladdy:option({
type = "toggle",
name = L["Group"] .. " " .. L["Cooldown"],
order = 3,
disabled = function() return not Gladdy.db.cooldown end,
}),
2021-05-17 16:49:54 +02:00
group = {
type = "group",
childGroups = "tree",
2021-05-24 12:41:21 +02:00
name = L["Frame"],
2021-05-17 16:49:54 +02:00
order = 3,
2022-03-03 23:37:42 +01:00
disabled = function() return not Gladdy.db.cooldown end,
2021-05-17 16:49:54 +02:00
args = {
icon = {
type = "group",
name = L["Icon"],
order = 1,
args = {
headerIcon = {
type = "header",
name = L["Icon"],
order = 2,
},
cooldownIconZoomed = Gladdy:option({
type = "toggle",
name = L["Zoomed Icon"],
desc = L["Zoomes the icon to remove borders"],
order = 4,
width = "full",
}),
2021-05-17 16:49:54 +02:00
cooldownSize = Gladdy:option({
type = "range",
name = L["Cooldown size"],
desc = L["Size of each cd icon"],
2022-07-31 06:04:50 +02:00
order = 5,
2021-05-17 16:49:54 +02:00
min = 5,
2021-05-22 13:41:31 +02:00
max = 50,
2021-06-15 09:06:05 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
cooldownWidthFactor = Gladdy:option({
type = "range",
name = L["Icon Width Factor"],
desc = L["Stretches the icon"],
2022-07-31 06:04:50 +02:00
order = 6,
2021-05-17 16:49:54 +02:00
min = 0.5,
max = 2,
step = 0.05,
2021-06-15 09:06:05 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
cooldownIconPadding = Gladdy:option({
type = "range",
name = L["Icon Padding"],
desc = L["Space between Icons"],
2022-07-31 06:04:50 +02:00
order = 7,
2021-05-17 16:49:54 +02:00
min = 0,
max = 10,
step = 0.1,
2021-06-15 09:06:05 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
},
},
cooldown = {
type = "group",
name = L["Cooldown"],
order = 2,
args = {
header = {
type = "header",
name = L["Cooldown"],
order = 2,
},
cooldownIconGlow = Gladdy:option({
type = "toggle",
name = L["Glow Icon"],
desc = L["Glow the icon when cooldown active"],
order = 3,
width = "full",
}),
cooldownIconDesaturateOnCooldown = Gladdy:option({
type = "toggle",
name = L["Desaturate Icon"],
order = 4,
width = "full",
}),
cooldownIconAlphaOnCooldown = Gladdy:option({
type = "range",
name = L["Cooldown alpha on CD"],
desc = L["Alpha of the icon when cooldown active"],
desc = L["changes "],
order = 5,
min = 0,
max = 1,
step = 0.1,
width = "full",
}),
headerCircle = {
type = "header",
name = L["Cooldowncircle"],
order = 6,
},
2021-05-17 16:49:54 +02:00
cooldownDisableCircle = Gladdy:option({
type = "toggle",
name = L["No Cooldown Circle"],
order = 8,
2021-05-24 12:41:21 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
cooldownCooldownAlpha = Gladdy:option({
type = "range",
name = L["Cooldown circle alpha"],
min = 0,
max = 1,
step = 0.1,
order = 9,
2021-06-15 09:06:05 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
2021-09-18 15:00:34 +02:00
cooldownCooldownNumberAlpha = {
type = "range",
name = L["Cooldown number alpha"],
min = 0,
max = 1,
step = 0.1,
order = 10,
width = "full",
set = function(info, value)
Gladdy.db.cooldownFontColor.a = value
Gladdy:UpdateFrame()
end,
get = function(info)
return Gladdy.db.cooldownFontColor.a
end,
},
2021-05-17 16:49:54 +02:00
},
},
font = {
type = "group",
name = L["Font"],
order = 3,
args = {
header = {
type = "header",
name = L["Font"],
order = 2,
},
cooldownFont = Gladdy:option({
type = "select",
name = L["Font"],
desc = L["Font of the cooldown"],
order = 11,
dialogControl = "LSM30_Font",
values = AceGUIWidgetLSMlists.font,
}),
cooldownFontScale = Gladdy:option({
type = "range",
name = L["Font scale"],
desc = L["Scale of the font"],
order = 12,
min = 0.1,
max = 2,
step = 0.1,
2021-06-15 09:06:05 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
cooldownFontColor = Gladdy:colorOption({
type = "color",
name = L["Font color"],
desc = L["Color of the text"],
order = 13,
hasAlpha = true,
}),
},
},
position = {
type = "group",
name = L["Position"],
order = 5,
2021-05-17 16:49:54 +02:00
args = {
header = {
type = "header",
name = L["Position"],
order = 2,
},
2022-01-11 00:29:17 +01:00
cooldownYGrowDirection = Gladdy:option({
2021-05-17 16:49:54 +02:00
type = "select",
2022-01-11 00:29:17 +01:00
name = L["Vertical Grow Direction"],
desc = L["Vertical Grow Direction of the cooldown icons"],
2021-05-17 16:49:54 +02:00
order = 3,
values = {
2022-01-11 00:29:17 +01:00
["UP"] = L["Up"],
["DOWN"] = L["Down"],
2021-05-17 16:49:54 +02:00
},
}),
2022-01-11 00:29:17 +01:00
cooldownXGrowDirection = Gladdy:option({
2021-05-17 16:49:54 +02:00
type = "select",
2022-01-11 00:29:17 +01:00
name = L["Horizontal Grow Direction"],
desc = L["Horizontal Grow Direction of the cooldown icons"],
2021-05-17 16:49:54 +02:00
order = 4,
values = {
2022-01-11 00:29:17 +01:00
["LEFT"] = L["Left"],
["RIGHT"] = L["Right"],
2021-05-17 16:49:54 +02:00
},
}),
2022-01-11 00:29:17 +01:00
cooldownMaxIconsPerLine = Gladdy:option({
type = "range",
name = L["Max Icons per row"],
order = 5,
min = 3,
max = 14,
step = 1,
width = "full",
}),
2021-05-17 16:49:54 +02:00
headerOffset = {
type = "header",
name = L["Offset"],
2022-01-11 00:29:17 +01:00
order = 10,
2021-05-17 16:49:54 +02:00
},
cooldownXOffset = Gladdy:option({
type = "range",
name = L["Horizontal offset"],
2022-01-11 00:29:17 +01:00
order = 11,
2021-05-17 16:49:54 +02:00
min = -400,
max = 400,
step = 0.1,
2021-06-15 09:06:05 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
cooldownYOffset = Gladdy:option({
type = "range",
name = L["Vertical offset"],
2022-01-11 00:29:17 +01:00
order = 12,
2021-05-17 16:49:54 +02:00
min = -400,
max = 400,
step = 0.1,
2021-06-15 09:06:05 +02:00
width = "full",
2021-05-17 16:49:54 +02:00
}),
},
},
border = {
type = "group",
name = L["Border"],
order = 4,
2021-05-17 16:49:54 +02:00
args = {
header = {
type = "header",
name = L["Border"],
order = 2,
},
cooldownBorderStyle = Gladdy:option({
type = "select",
name = L["Border style"],
order = 31,
values = Gladdy:GetIconStyles()
}),
cooldownBorderColor = Gladdy:colorOption({
type = "color",
name = L["Border color"],
desc = L["Color of the border"],
order = 32,
hasAlpha = true,
}),
},
},
frameStrata = {
type = "group",
name = L["Frame Strata and Level"],
order = 6,
args = {
headerAuraLevel = {
type = "header",
name = L["Frame Strata and Level"],
order = 1,
},
cooldownFrameStrata = Gladdy:option({
type = "select",
name = L["Frame Strata"],
order = 2,
values = Gladdy.frameStrata,
sorting = Gladdy.frameStrataSorting,
width = "full",
}),
cooldownFrameLevel = Gladdy:option({
type = "range",
name = L["Frame Level"],
min = 0,
max = 500,
step = 1,
order = 3,
width = "full",
}),
},
},
2021-05-17 16:49:54 +02:00
},
},
2021-05-18 16:39:43 +02:00
cooldowns = {
type = "group",
childGroups = "tree",
2021-05-24 12:41:21 +02:00
name = L["Cooldowns"],
2021-05-18 16:39:43 +02:00
order = 4,
2022-03-03 23:37:42 +01:00
disabled = function() return not Gladdy.db.cooldown end,
2021-05-18 16:39:43 +02:00
args = Cooldowns:GetCooldownOptions(),
},
2021-05-17 16:49:54 +02:00
}
end
2022-03-03 23:37:42 +01:00
2021-05-18 16:39:43 +02:00
function Cooldowns:GetCooldownOptions()
local group = {}
local p = 1
for i,class in ipairs(Gladdy.CLASSES) do
group[class] = {
type = "group",
name = LOCALIZED_CLASS_NAMES_MALE[class],
order = i,
icon = "Interface\\Glues\\CharacterCreate\\UI-CharacterCreate-Classes",
iconCoords = CLASS_ICON_TCOORDS[class],
args = {}
}
2022-03-03 23:37:42 +01:00
local tblLength = tableLength(Gladdy.db.cooldownCooldownsOrder[class])
2021-05-18 16:39:43 +02:00
for spellId,cooldown in pairs(Gladdy:GetCooldownList()[class]) do
group[class].args[tostring(spellId)] = {
2022-03-03 23:37:42 +01:00
name = "",
type = "group",
inline = true,
order = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)],
args = {
toggle = {
type = "toggle",
name = select(1, GetSpellInfo(spellId)) .. (type(cooldown) == "table" and cooldown.spec and (" - " .. cooldown.spec) or ""),
order = 1,
width = 1.1,
image = select(3, GetSpellInfo(spellId)),
get = function()
return Gladdy.db.cooldownCooldowns[tostring(spellId)]
end,
set = function(_, value)
Gladdy.db.cooldownCooldowns[tostring(spellId)] = value
for unit in pairs(Gladdy.buttons) do
Cooldowns:ResetUnit(unit)
Cooldowns:UpdateCooldowns(Gladdy.buttons[unit])
2022-03-03 23:37:42 +01:00
Cooldowns:Test(unit)
end
Gladdy:UpdateFrame()
end
},
uparrow = {
type = "execute",
name = "",
order = 2,
width = 0.1,
image = "Interface\\Addons\\Gladdy\\Images\\uparrow",
imageWidth = 15,
imageHeight = 15,
2022-03-03 23:37:42 +01:00
func = function()
if (Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] > 1) then
local current = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
local next
for k,v in pairs(Gladdy.db.cooldownCooldownsOrder[class]) do
if v == current - 1 then
next = k
end
end
Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] - 1
Gladdy.db.cooldownCooldownsOrder[class][next] = Gladdy.db.cooldownCooldownsOrder[class][next] + 1
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[tostring(spellId)].order = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[next].order = Gladdy.db.cooldownCooldownsOrder[class][next]
Gladdy:UpdateFrame()
end
end,
},
downarrow = {
type = "execute",
name = "",
order = 3,
width = 0.1,
image = "Interface\\Addons\\Gladdy\\Images\\downarrow",
imageWidth = 15,
imageHeight = 15,
2022-03-03 23:37:42 +01:00
func = function()
if (Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] < tblLength) then
local current = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
local next
for k,v in pairs(Gladdy.db.cooldownCooldownsOrder[class]) do
if v == current + 1 then
next = k
end
end
Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] + 1
Gladdy.db.cooldownCooldownsOrder[class][next] = Gladdy.db.cooldownCooldownsOrder[class][next] - 1
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[tostring(spellId)].order = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[next].order = Gladdy.db.cooldownCooldownsOrder[class][next]
Gladdy:UpdateFrame()
end
end,
}
}
2021-05-18 16:39:43 +02:00
}
end
p = p + i
end
for i,race in ipairs(Gladdy.RACES) do
for spellId,cooldown in pairs(Gladdy:GetCooldownList()[race]) do
2022-03-03 23:37:42 +01:00
local tblLength = tableLength(Gladdy.db.cooldownCooldownsOrder[cooldown.class])
local class = cooldown.class
group[class].args[tostring(spellId)] = {
name = "",
type = "group",
inline = true,
order = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)],
args = {
toggle = {
type = "toggle",
name = select(1, GetSpellInfo(spellId)) .. (type(cooldown) == "table" and cooldown.spec and (" - " .. cooldown.spec) or ""),
order = 1,
width = 1.1,
image = select(3, GetSpellInfo(spellId)),
get = function()
return Gladdy.db.cooldownCooldowns[tostring(spellId)]
end,
set = function(_, value)
Gladdy.db.cooldownCooldowns[tostring(spellId)] = value
Gladdy:UpdateFrame()
end
},
uparrow = {
type = "execute",
name = "",
order = 2,
width = 0.1,
image = "Interface\\Addons\\Gladdy\\Images\\uparrow",
imageWidth = 20,
imageHeight = 20,
func = function()
if (Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] > 1) then
local current = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
local next
for k,v in pairs(Gladdy.db.cooldownCooldownsOrder[class]) do
if v == current - 1 then
next = k
end
end
Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] - 1
Gladdy.db.cooldownCooldownsOrder[class][next] = Gladdy.db.cooldownCooldownsOrder[class][next] + 1
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[tostring(spellId)].order = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[next].order = Gladdy.db.cooldownCooldownsOrder[class][next]
Gladdy:UpdateFrame()
end
end,
},
downarrow = {
type = "execute",
name = "",
order = 3,
width = 0.1,
image = "Interface\\Addons\\Gladdy\\Images\\downarrow",
imageWidth = 20,
imageHeight = 20,
func = function()
if (Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] < tblLength) then
local current = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
local next
for k,v in pairs(Gladdy.db.cooldownCooldownsOrder[class]) do
if v == current + 1 then
next = k
end
end
Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)] + 1
Gladdy.db.cooldownCooldownsOrder[class][next] = Gladdy.db.cooldownCooldownsOrder[class][next] - 1
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[tostring(spellId)].order = Gladdy.db.cooldownCooldownsOrder[class][tostring(spellId)]
Gladdy.options.args["Cooldowns"].args.cooldowns.args[class].args[next].order = Gladdy.db.cooldownCooldownsOrder[class][next]
Gladdy:UpdateFrame()
end
end,
}
}
2021-05-18 16:39:43 +02:00
}
end
end
return group
end
2022-01-11 00:29:17 +01:00
---------------------------
-- LAGACY HANDLER
---------------------------
function Cooldowns:LegacySetPosition(button, unit)
if Gladdy.db.newLayout then
return Gladdy.db.newLayout
end
button.spellCooldownFrame:ClearAllPoints()
local powerBarHeight = Gladdy.db.powerBarEnabled and (Gladdy.db.powerBarHeight + 1) or 0
local horizontalMargin = (Gladdy.db.highlightInset and 0 or Gladdy.db.highlightBorderSize)
local offset = 0
if (Gladdy.db.cooldownXPos == "RIGHT") then
offset = -(Gladdy.db.cooldownSize * Gladdy.db.cooldownWidthFactor)
end
if Gladdy.db.cooldownYPos == "TOP" then
Gladdy.db.cooldownYGrowDirection = "UP"
if Gladdy.db.cooldownXPos == "RIGHT" then
Gladdy.db.cooldownXGrowDirection = "LEFT"
button.spellCooldownFrame:SetPoint("BOTTOMRIGHT", button.healthBar, "TOPRIGHT", Gladdy.db.cooldownXOffset + offset, horizontalMargin + Gladdy.db.cooldownYOffset)
else
Gladdy.db.cooldownXGrowDirection = "RIGHT"
button.spellCooldownFrame:SetPoint("BOTTOMLEFT", button.healthBar, "TOPLEFT", Gladdy.db.cooldownXOffset + offset, horizontalMargin + Gladdy.db.cooldownYOffset)
end
elseif Gladdy.db.cooldownYPos == "BOTTOM" then
Gladdy.db.cooldownYGrowDirection = "DOWN"
if Gladdy.db.cooldownXPos == "RIGHT" then
Gladdy.db.cooldownXGrowDirection = "LEFT"
button.spellCooldownFrame:SetPoint("TOPRIGHT", button.healthBar, "BOTTOMRIGHT", Gladdy.db.cooldownXOffset + offset, -horizontalMargin + Gladdy.db.cooldownYOffset - powerBarHeight)
else
Gladdy.db.cooldownXGrowDirection = "RIGHT"
button.spellCooldownFrame:SetPoint("TOPLEFT", button.healthBar, "BOTTOMLEFT", Gladdy.db.cooldownXOffset + offset, -horizontalMargin + Gladdy.db.cooldownYOffset - powerBarHeight)
end
elseif Gladdy.db.cooldownYPos == "LEFT" then
Gladdy.db.cooldownYGrowDirection = "DOWN"
local anchor = Gladdy:GetAnchor(unit, "LEFT")
if anchor == Gladdy.buttons[unit].healthBar then
Gladdy.db.cooldownXGrowDirection = "LEFT"
button.spellCooldownFrame:SetPoint("RIGHT", anchor, "LEFT", -(horizontalMargin + Gladdy.db.padding) + Gladdy.db.cooldownXOffset + offset, Gladdy.db.cooldownYOffset)
else
Gladdy.db.cooldownXGrowDirection = "LEFT"
button.spellCooldownFrame:SetPoint("RIGHT", anchor, "LEFT", -Gladdy.db.padding + Gladdy.db.cooldownXOffset + offset, Gladdy.db.cooldownYOffset)
end
elseif Gladdy.db.cooldownYPos == "RIGHT" then
Gladdy.db.cooldownYGrowDirection = "DOWN"
local anchor = Gladdy:GetAnchor(unit, "RIGHT")
if anchor == Gladdy.buttons[unit].healthBar then
Gladdy.db.cooldownXGrowDirection = "RIGHT"
button.spellCooldownFrame:SetPoint("LEFT", anchor, "RIGHT", horizontalMargin + Gladdy.db.padding + Gladdy.db.cooldownXOffset + offset, Gladdy.db.cooldownYOffset)
else
Gladdy.db.cooldownXGrowDirection = "RIGHT"
button.spellCooldownFrame:SetPoint("LEFT", anchor, "RIGHT", Gladdy.db.padding + Gladdy.db.cooldownXOffset + offset, Gladdy.db.cooldownYOffset)
end
end
LibStub("AceConfigRegistry-3.0"):NotifyChange("Gladdy")
return Gladdy.db.newLayout
2021-05-18 16:39:43 +02:00
end