1206 lines
53 KiB
Lua
1206 lines
53 KiB
Lua
local GetSpellInfo = GetSpellInfo
|
|
local CreateFrame = CreateFrame
|
|
local GetTime = GetTime
|
|
local select, lower, ceil, tremove, tinsert, pairs, ipairs, tostring, random = select, string.lower, ceil, tremove, tinsert, pairs, ipairs, tostring, math.random
|
|
local AURA_TYPE_DEBUFF, AURA_TYPE_BUFF = AURA_TYPE_DEBUFF, AURA_TYPE_BUFF
|
|
local auraTypes = {AURA_TYPE_BUFF, AURA_TYPE_DEBUFF}
|
|
|
|
---------------------------
|
|
-- Module init
|
|
---------------------------
|
|
|
|
local Gladdy = LibStub("Gladdy")
|
|
local LibClassAuras = LibStub("LibClassAuras-1.0")
|
|
local L = Gladdy.L
|
|
local defaultTrackedDebuffs = select(2, Gladdy:GetAuras(AURA_TYPE_DEBUFF))
|
|
local defaultTrackedBuffs = select(2, Gladdy:GetAuras(AURA_TYPE_BUFF))
|
|
local BuffsDebuffs = Gladdy:NewModule("Buffs and Debuffs", nil, {
|
|
buffsEnabled = true,
|
|
buffsShowAuraDebuffs = false,
|
|
buffsAlpha = 1,
|
|
buffsIconSize = 30,
|
|
buffsWidthFactor = 1,
|
|
buffsIconZoomed = false,
|
|
buffsIconPadding = 1,
|
|
buffsBuffsAlpha = 1,
|
|
buffsBuffsIconSize = 30,
|
|
buffsBuffsWidthFactor = 1,
|
|
buffsBuffsIconZoomed = false,
|
|
buffsBuffsIconPadding = 1,
|
|
buffsDisableCircle = false,
|
|
buffsCooldownAlpha = 1,
|
|
buffsFont = "DorisPP",
|
|
buffsFontScale = 1,
|
|
buffsFontColor = {r = 1, g = 1, b = 0, a = 1},
|
|
buffsDynamicColor = true,
|
|
buffsCooldownGrowDirection = "RIGHT",
|
|
buffsXOffset = 0,
|
|
buffsYOffset = 0,
|
|
buffsBuffsCooldownGrowDirection = "RIGHT",
|
|
buffsBuffsXOffset = 0,
|
|
buffsBuffsYOffset = 0,
|
|
buffsBorderStyle = "Interface\\AddOns\\Gladdy\\Images\\Border_squared_blp",
|
|
buffsBorderColor = {r = 1, g = 1, b = 1, a = 1},
|
|
buffsBorderColorsEnabled = true,
|
|
trackedDebuffs = defaultTrackedDebuffs,
|
|
trackedBuffs = defaultTrackedBuffs,
|
|
buffsBorderColorEnrage = Gladdy:GetDispelTypeColors()["enrage"],
|
|
buffsBorderColorCurse = Gladdy:GetDispelTypeColors()["curse"],
|
|
buffsBorderColorMagic = Gladdy:GetDispelTypeColors()["magic"],
|
|
buffsBorderColorPoison = Gladdy:GetDispelTypeColors()["poison"],
|
|
buffsBorderColorPhysical = Gladdy:GetDispelTypeColors()["none"],
|
|
buffsBorderColorImmune = Gladdy:GetDispelTypeColors()["immune"],
|
|
buffsBorderColorDisease = Gladdy:GetDispelTypeColors()["disease"],
|
|
buffsBorderColorForm = Gladdy:GetDispelTypeColors()["form"],
|
|
buffsBorderColorAura = Gladdy:GetDispelTypeColors()["aura"],
|
|
buffFrameStrata = "MEDIUM",
|
|
buffsFrameLevel = 9,
|
|
})
|
|
|
|
local dispelTypeToOptionValueTable
|
|
local function dispelTypeToOptionValue(dispelType)
|
|
if Gladdy.db.buffsBorderColorsEnabled then
|
|
dispelType = dispelType and lower(dispelType) or "physical"
|
|
if not dispelTypeToOptionValueTable[dispelType] then
|
|
dispelType = "physical"
|
|
end
|
|
return dispelTypeToOptionValueTable[dispelType].r,
|
|
dispelTypeToOptionValueTable[dispelType].g,
|
|
dispelTypeToOptionValueTable[dispelType].b,
|
|
dispelTypeToOptionValueTable[dispelType].a
|
|
else
|
|
return Gladdy:SetColor(Gladdy.db.buffsBorderColor)
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:OnEvent(event, ...)
|
|
self[event](self, ...)
|
|
end
|
|
|
|
function BuffsDebuffs:Initialize()
|
|
self.frames = {}
|
|
self.spells = {}
|
|
self.icons = {}
|
|
self.trackedCC = {}
|
|
self.framePool = {}
|
|
if Gladdy.db.buffsEnabled then
|
|
self:RegisterMessages(
|
|
"JOINED_ARENA",
|
|
"UNIT_DESTROYED",
|
|
"UNIT_DEATH",
|
|
"AURA_FADE",
|
|
"AURA_GAIN",
|
|
"AURA_GAIN_LIMIT")
|
|
self:SetScript("OnEvent", BuffsDebuffs.OnEvent)
|
|
end
|
|
dispelTypeToOptionValueTable = {
|
|
none = Gladdy.db.buffsBorderColorPhysical,
|
|
magic = Gladdy.db.buffsBorderColorMagic,
|
|
curse = Gladdy.db.buffsBorderColorCurse,
|
|
disease = Gladdy.db.buffsBorderColorDisease,
|
|
poison = Gladdy.db.buffsBorderColorPoison,
|
|
stealth = Gladdy.db.buffsBorderColorPhysical,
|
|
invisibility = Gladdy.db.buffsBorderColorPhysical,
|
|
physical = Gladdy.db.buffsBorderColorPhysical,
|
|
immune = Gladdy.db.buffsBorderColorImmune,
|
|
form = Gladdy.db.buffsBorderColorForm,
|
|
enrage = Gladdy.db.buffsBorderColorEnrage,
|
|
}
|
|
|
|
end
|
|
|
|
function BuffsDebuffs:JOINED_ARENA()
|
|
if Gladdy.db.buffsEnabled then
|
|
for i=1, Gladdy.curBracket do
|
|
local unit = "arena" .. i
|
|
if not self.frames[unit].auras then
|
|
self.frames[unit].auras = {[AURA_TYPE_DEBUFF] = {}, [AURA_TYPE_BUFF] = {}}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:ResetUnit(unit)
|
|
if not self.frames[unit] then return end
|
|
for _, auraType in ipairs(auraTypes) do
|
|
local i = #self.frames[unit].auras[auraType]
|
|
while (#self.frames[unit].auras[auraType] > 0) do
|
|
self.frames[unit].auras[auraType][i]:Hide()
|
|
tinsert(self.framePool, tremove(self.frames[unit].auras[auraType], i))
|
|
i = i - 1
|
|
end
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:UNIT_DESTROYED(unit)
|
|
BuffsDebuffs:ResetUnit(unit)
|
|
end
|
|
|
|
function BuffsDebuffs:UNIT_DEATH(unit)
|
|
BuffsDebuffs:ResetUnit(unit)
|
|
end
|
|
|
|
function BuffsDebuffs:Reset()
|
|
for i=1,#self.framePool do
|
|
self.framePool[i]:Hide()
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:Test(unit)
|
|
if Gladdy.db.buffsEnabled then
|
|
local dispelTypes = { "physical", "magic", "curse", "poison", "disease", "immune", "enrage"}
|
|
|
|
BuffsDebuffs:AURA_FADE(unit, AURA_TYPE_DEBUFF)
|
|
BuffsDebuffs:AURA_FADE(unit, AURA_TYPE_BUFF)
|
|
--BuffsDebuffs:AURA_GAIN(unit, AURA_TYPE_BUFF, 1243, select(1, GetSpellInfo(1243)), select(3, GetSpellInfo(1243)), 10, GetTime() + 10, 1, "physical")
|
|
--self:AURA_GAIN(unit, AURA_TYPE_DEBUFF, 31117, select(1, GetSpellInfo(31117)), select(3, GetSpellInfo(31117)), 10, GetTime() + 10, 1, "physical")
|
|
local i = 1
|
|
for spellID, enabled in pairs(Gladdy.db.trackedDebuffs) do
|
|
if i > 4 then
|
|
break
|
|
end
|
|
if enabled then
|
|
BuffsDebuffs:AddOrRefreshAura(unit, spellID, AURA_TYPE_DEBUFF, 15, 15, random(1,5), dispelTypes[random(1,#dispelTypes)], select(3, GetSpellInfo(spellID)), i)
|
|
i = i + 1
|
|
end
|
|
end
|
|
i = 1
|
|
for spellID, enabled in pairs(Gladdy.db.trackedBuffs) do
|
|
if i > 4 then
|
|
break
|
|
end
|
|
if enabled then
|
|
BuffsDebuffs:AddOrRefreshAura(unit, spellID, AURA_TYPE_BUFF, 15, 15, random(1,5), dispelTypes[random(1,#dispelTypes)], select(3, GetSpellInfo(spellID)), i)
|
|
i = i + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------
|
|
-- Aura handlers
|
|
---------------------------
|
|
|
|
function BuffsDebuffs:AURA_FADE(unit, auraType)
|
|
if (not self.frames[unit] or not Gladdy.db.buffsEnabled) then
|
|
return
|
|
end
|
|
if auraType == AURA_TYPE_DEBUFF then
|
|
self.frames[unit].numDebuffs = 0
|
|
else
|
|
self.frames[unit].numBuffs = 0
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:AURA_GAIN_LIMIT(unit, auraType, limit)
|
|
if (not self.frames[unit] or not Gladdy.db.buffsEnabled) then
|
|
return
|
|
end
|
|
local numAura
|
|
if auraType == AURA_TYPE_DEBUFF then
|
|
numAura = self.frames[unit].numDebuffs
|
|
else
|
|
numAura = self.frames[unit].numBuffs
|
|
end
|
|
for i=numAura + 1, #self.frames[unit].auras[auraType] do
|
|
self.frames[unit].auras[auraType][i]:Hide()
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:AURA_GAIN(unit, auraType, spellID, spellName, texture, duration, expirationTime, count, dispelType)
|
|
if (not self.frames[unit] or not Gladdy.db.buffsEnabled) then
|
|
return
|
|
end
|
|
local auraFrame = self.frames[unit]
|
|
spellName = LibClassAuras.GetAltName(spellID) or spellName
|
|
local aura = Gladdy:GetImportantAuras()[spellName] and Gladdy.db.auraListDefault[tostring(Gladdy:GetImportantAuras()[spellName].spellID)].enabled
|
|
if aura and Gladdy.db.buffsShowAuraDebuffs then
|
|
aura = false
|
|
end
|
|
local auraNames = LibClassAuras.GetSpellNameToId(auraType)
|
|
local spellId
|
|
local isTracked = false
|
|
if auraNames[spellName] then
|
|
for _, spellInfo in ipairs(auraNames[spellName]) do
|
|
spellId = spellInfo.id[1]
|
|
if (Gladdy.db.trackedBuffs[tostring(spellId)] or Gladdy.db.trackedDebuffs[tostring(spellId)]) then
|
|
isTracked = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if not aura and spellID and expirationTime and isTracked then
|
|
local index
|
|
if auraType == AURA_TYPE_DEBUFF then
|
|
auraFrame.numDebuffs = auraFrame.numDebuffs + 1
|
|
index = auraFrame.numDebuffs
|
|
else
|
|
auraFrame.numBuffs = auraFrame.numBuffs + 1
|
|
index = auraFrame.numBuffs
|
|
end
|
|
BuffsDebuffs:AddOrRefreshAura(unit,spellID, auraType, duration, expirationTime - GetTime(), count, dispelType, texture, index)
|
|
end
|
|
end
|
|
|
|
---------------------------
|
|
-- Frame init
|
|
---------------------------
|
|
|
|
function BuffsDebuffs:CreateFrame(unit)
|
|
local debuffFrame = CreateFrame("Frame", "GladdyDebuffs" .. unit, Gladdy.buttons[unit])
|
|
debuffFrame:SetFrameStrata(Gladdy.db.buffFrameStrata)
|
|
debuffFrame:SetFrameLevel(Gladdy.db.buffsFrameLevel)
|
|
debuffFrame:SetMovable(true)
|
|
debuffFrame:SetHeight(Gladdy.db.buffsIconSize)
|
|
debuffFrame:SetWidth(1)
|
|
debuffFrame.unit = unit
|
|
local buffFrame = CreateFrame("Frame", "GladdyBuffs" .. unit, Gladdy.buttons[unit])
|
|
buffFrame:SetFrameStrata(Gladdy.db.buffFrameStrata)
|
|
buffFrame:SetFrameLevel(Gladdy.db.buffsFrameLevel)
|
|
buffFrame:SetMovable(true)
|
|
buffFrame:SetHeight(Gladdy.db.buffsIconSize)
|
|
buffFrame:SetWidth(1)
|
|
buffFrame.unit = unit
|
|
self.frames[unit] = {}
|
|
self.frames[unit].buffFrame = buffFrame
|
|
self.frames[unit].debuffFrame = debuffFrame
|
|
self.frames[unit].auras = {[AURA_TYPE_DEBUFF] = {}, [AURA_TYPE_BUFF] = {}}
|
|
end
|
|
|
|
local function setAuraSize(aura, auraType)
|
|
if auraType == AURA_TYPE_DEBUFF then
|
|
aura:SetWidth(Gladdy.db.buffsIconSize * Gladdy.db.buffsWidthFactor)
|
|
aura:SetHeight(Gladdy.db.buffsIconSize)
|
|
aura:SetAlpha(Gladdy.db.buffsAlpha)
|
|
else
|
|
aura:SetWidth(Gladdy.db.buffsBuffsIconSize * Gladdy.db.buffsBuffsWidthFactor)
|
|
aura:SetHeight(Gladdy.db.buffsBuffsIconSize)
|
|
aura:SetAlpha(Gladdy.db.buffsBuffsAlpha)
|
|
end
|
|
aura.cooldowncircle:SetWidth(aura:GetWidth() - aura:GetWidth()/16)
|
|
aura.cooldowncircle:SetHeight(aura:GetHeight() - aura:GetHeight()/16)
|
|
aura.cooldowncircle:ClearAllPoints()
|
|
aura.cooldowncircle:SetPoint("CENTER", aura, "CENTER")
|
|
end
|
|
|
|
local function styleIcon(aura, auraType)
|
|
setAuraSize(aura, auraType)
|
|
if (Gladdy.db.buffsDisableCircle) then
|
|
aura.cooldowncircle:SetAlpha(0)
|
|
else
|
|
aura.cooldowncircle:SetAlpha(Gladdy.db.buffsCooldownAlpha)
|
|
end
|
|
|
|
local zoomedOption, testAgain
|
|
if auraType == AURA_TYPE_BUFF then
|
|
zoomedOption = Gladdy.db.buffsBuffsIconZoomed
|
|
else
|
|
zoomedOption = Gladdy.db.buffsIconZoomed
|
|
end
|
|
|
|
if zoomedOption then
|
|
if aura.texture.masked then
|
|
aura.texture:SetMask("")
|
|
aura.texture:SetTexCoord(0.1,0.9,0.1,0.9)
|
|
aura.texture.masked = nil
|
|
end
|
|
else
|
|
if not aura.texture.masked then
|
|
aura.texture:SetMask("")
|
|
aura.texture:SetTexCoord(0,1,0,1)
|
|
aura.texture:SetMask("Interface\\AddOns\\Gladdy\\Images\\mask")
|
|
aura.texture.masked = true
|
|
if Gladdy.frame.testing then
|
|
testAgain = true
|
|
end
|
|
end
|
|
end
|
|
|
|
aura:SetFrameStrata(Gladdy.db.buffFrameStrata)
|
|
aura:SetFrameLevel(Gladdy.db.buffsFrameLevel)
|
|
aura.cooldowncircle:SetFrameLevel(Gladdy.db.buffsFrameLevel + 1)
|
|
aura.overlay:SetFrameLevel(Gladdy.db.buffsFrameLevel + 2)
|
|
|
|
aura.border:SetTexture(Gladdy.db.buffsBorderStyle)
|
|
aura.border:SetVertexColor(dispelTypeToOptionValue(aura.dispelType))
|
|
aura.cooldown:SetFont(Gladdy:SMFetch("font", "buffsFont"), (Gladdy.db.buffsIconSize/2 - 1) * Gladdy.db.buffsFontScale, "OUTLINE")
|
|
aura.cooldown:SetTextColor(Gladdy.db.buffsFontColor.r, Gladdy.db.buffsFontColor.g, Gladdy.db.buffsFontColor.b, Gladdy.db.buffsFontColor.a)
|
|
aura.stacks:SetFont(Gladdy:SMFetch("font", "buffsFont"), (Gladdy.db.buffsIconSize/3 - 1) * Gladdy.db.buffsFontScale, "OUTLINE")
|
|
aura.stacks:SetTextColor(Gladdy.db.buffsFontColor.r, Gladdy.db.buffsFontColor.g, Gladdy.db.buffsFontColor.b, 1)
|
|
|
|
return testAgain
|
|
end
|
|
|
|
function BuffsDebuffs:UpdateFrameOnce()
|
|
if Gladdy.db.buffsEnabled then
|
|
self:RegisterMessages(
|
|
"JOINED_ARENA",
|
|
"UNIT_DESTROYED",
|
|
"UNIT_DEATH",
|
|
"AURA_FADE",
|
|
"AURA_GAIN",
|
|
"AURA_GAIN_LIMIT")
|
|
self:SetScript("OnEvent", BuffsDebuffs.OnEvent)
|
|
else
|
|
self:UnregisterAllMessages()
|
|
self:SetScript("OnEvent", nil)
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:UpdateFrame(unit)
|
|
--DEBUFFS
|
|
self.frames[unit].debuffFrame:SetHeight(Gladdy.db.buffsIconSize)
|
|
Gladdy:SetPosition(self.frames[unit].debuffFrame, unit, "buffsXOffset", "buffsYOffset", BuffsDebuffs:LegacySetPositionDebuffs(unit), BuffsDebuffs)
|
|
if (unit == "arena1") then
|
|
Gladdy:CreateMover(self.frames[unit].debuffFrame, "buffsXOffset", "buffsYOffset", L["Debuffs"],
|
|
{"TOPRIGHT", "TOPRIGHT"},
|
|
Gladdy.db.buffsIconSize * Gladdy.db.buffsWidthFactor, Gladdy.db.buffsIconSize,
|
|
0, 0, "buffsEnabled")
|
|
end
|
|
|
|
--BUFFS
|
|
self.frames[unit].buffFrame:SetHeight(Gladdy.db.buffsBuffsIconSize)
|
|
Gladdy:SetPosition(self.frames[unit].buffFrame, unit, "buffsBuffsXOffset", "buffsBuffsYOffset", BuffsDebuffs:LegacySetPositionBuffs(unit), BuffsDebuffs)
|
|
if (unit == "arena1") then
|
|
Gladdy:CreateMover(self.frames[unit].buffFrame, "buffsBuffsXOffset", "buffsBuffsYOffset", L["Buffs"],
|
|
{"TOPRIGHT", "TOPRIGHT"},
|
|
Gladdy.db.buffsBuffsIconSize * Gladdy.db.buffsBuffsWidthFactor, Gladdy.db.buffsBuffsIconSize,
|
|
0, 0, "buffsEnabled")
|
|
end
|
|
|
|
local testBuffsAgain, testDebuffsAgain
|
|
|
|
for i=1, #self.frames[unit].auras[AURA_TYPE_BUFF] do
|
|
testBuffsAgain = styleIcon(self.frames[unit].auras[AURA_TYPE_BUFF][i], AURA_TYPE_BUFF)
|
|
end
|
|
for i=1, #self.frames[unit].auras[AURA_TYPE_DEBUFF] do
|
|
testDebuffsAgain = styleIcon(self.frames[unit].auras[AURA_TYPE_DEBUFF][i], AURA_TYPE_DEBUFF)
|
|
end
|
|
for i=1, #self.framePool do
|
|
styleIcon(self.framePool[i])
|
|
end
|
|
self:UpdateAurasOnUnit(unit)
|
|
|
|
if Gladdy.frame.testing and (testBuffsAgain or testDebuffsAgain) then
|
|
self:ResetUnit(unit)
|
|
self:Test(unit)
|
|
end
|
|
end
|
|
|
|
---------------------------
|
|
-- Frame handlers
|
|
---------------------------
|
|
|
|
function BuffsDebuffs:UpdateAurasOnUnit(unit)
|
|
for i=1, #self.frames[unit].auras[AURA_TYPE_BUFF] do
|
|
if i == 1 then
|
|
self.frames[unit].auras[AURA_TYPE_BUFF][i]:ClearAllPoints()
|
|
self.frames[unit].auras[AURA_TYPE_BUFF][i]:SetPoint("RIGHT", self.frames[unit].buffFrame, "LEFT")
|
|
else
|
|
if Gladdy.db.buffsBuffsCooldownGrowDirection == "LEFT" then
|
|
self.frames[unit].auras[AURA_TYPE_BUFF][i]:ClearAllPoints()
|
|
self.frames[unit].auras[AURA_TYPE_BUFF][i]:SetPoint("RIGHT", self.frames[unit].auras[AURA_TYPE_BUFF][i - 1], "LEFT", -Gladdy.db.buffsBuffsIconPadding, 0)
|
|
else
|
|
self.frames[unit].auras[AURA_TYPE_BUFF][i]:ClearAllPoints()
|
|
self.frames[unit].auras[AURA_TYPE_BUFF][i]:SetPoint("LEFT", self.frames[unit].auras[AURA_TYPE_BUFF][i - 1], "RIGHT", Gladdy.db.buffsBuffsIconPadding, 0)
|
|
end
|
|
end
|
|
end
|
|
for i=1, #self.frames[unit].auras[AURA_TYPE_DEBUFF] do
|
|
if i == 1 then
|
|
self.frames[unit].auras[AURA_TYPE_DEBUFF][i]:ClearAllPoints()
|
|
self.frames[unit].auras[AURA_TYPE_DEBUFF][i]:SetPoint("RIGHT", self.frames[unit].debuffFrame, "LEFT")
|
|
else
|
|
if Gladdy.db.buffsCooldownGrowDirection == "LEFT" then
|
|
self.frames[unit].auras[AURA_TYPE_DEBUFF][i]:ClearAllPoints()
|
|
self.frames[unit].auras[AURA_TYPE_DEBUFF][i]:SetPoint("RIGHT", self.frames[unit].auras[AURA_TYPE_DEBUFF][i - 1], "LEFT", -Gladdy.db.buffsIconPadding, 0)
|
|
else
|
|
self.frames[unit].auras[AURA_TYPE_DEBUFF][i]:ClearAllPoints()
|
|
self.frames[unit].auras[AURA_TYPE_DEBUFF][i]:SetPoint("LEFT", self.frames[unit].auras[AURA_TYPE_DEBUFF][i - 1], "RIGHT", Gladdy.db.buffsIconPadding, 0)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function iconTimer(auraFrame, elapsed)
|
|
if auraFrame.endtime ~= "undefined" then
|
|
local timeLeftMilliSec = auraFrame.endtime - GetTime()
|
|
local timeLeftSec = ceil(timeLeftMilliSec)
|
|
auraFrame.timeLeft = timeLeftMilliSec
|
|
if Gladdy.db.buffsDynamicColor then
|
|
if timeLeftSec >= 60 then
|
|
auraFrame.cooldown:SetTextColor(0.7, 1, 0, Gladdy.db.buffsFontColor.a)
|
|
elseif timeLeftSec < 60 and timeLeftSec >= 11 then
|
|
auraFrame.cooldown:SetTextColor(0.7, 1, 0, Gladdy.db.buffsFontColor.a)
|
|
elseif timeLeftSec <= 10 and timeLeftSec >= 5 then
|
|
auraFrame.cooldown:SetTextColor(1, 0.7, 0, Gladdy.db.buffsFontColor.a)
|
|
elseif timeLeftSec <= 4 and timeLeftSec >= 3 then
|
|
auraFrame.cooldown:SetTextColor(1, 0, 0, Gladdy.db.buffsFontColor.a)
|
|
elseif timeLeftMilliSec <= 3 and timeLeftMilliSec > 0 then
|
|
auraFrame.cooldown:SetTextColor(1, 0, 0, Gladdy.db.buffsFontColor.a)
|
|
end
|
|
end
|
|
if timeLeftMilliSec < 0 then
|
|
auraFrame:Hide()
|
|
end
|
|
Gladdy:FormatTimer(auraFrame.cooldown, timeLeftMilliSec, timeLeftMilliSec <= 3)
|
|
else
|
|
auraFrame.cooldown:SetText("")
|
|
end
|
|
end
|
|
|
|
function BuffsDebuffs:AddAura(unit, spellID, auraType, duration, timeLeft, stacks, dispelType, icon, index)
|
|
local aura
|
|
if not self.frames[unit].auras[auraType][index] then
|
|
if #self.framePool > 0 then
|
|
aura = tremove(self.framePool, #self.framePool)
|
|
styleIcon(aura)
|
|
else
|
|
aura = CreateFrame("Frame")
|
|
aura:EnableMouse(false)
|
|
aura:SetFrameStrata(Gladdy.db.buffFrameStrata)
|
|
aura:SetFrameLevel(Gladdy.db.buffsFrameLevel)
|
|
aura.texture = aura:CreateTexture(nil, "BACKGROUND")
|
|
aura.texture:SetMask("Interface\\AddOns\\Gladdy\\Images\\mask")
|
|
aura.texture.masked = true
|
|
aura.texture:SetAllPoints(aura)
|
|
aura.cooldowncircle = CreateFrame("Cooldown", nil, aura, "CooldownFrameTemplate")
|
|
aura.cooldowncircle:SetFrameLevel(Gladdy.db.buffsFrameLevel + 1)
|
|
aura.cooldowncircle.noCooldownCount = true -- disable OmniCC
|
|
aura.cooldowncircle:SetAllPoints(aura)
|
|
aura.cooldowncircle:SetReverse(true)
|
|
aura.cooldowncircle:SetHideCountdownNumbers(true)
|
|
aura.overlay = CreateFrame("Frame", nil, aura)
|
|
aura.overlay:SetFrameLevel(Gladdy.db.buffsFrameLevel + 2)
|
|
aura.overlay:SetAllPoints(aura)
|
|
aura.border = aura.overlay:CreateTexture(nil, "OVERLAY")
|
|
aura.border:SetAllPoints(aura)
|
|
aura.cooldown = aura.overlay:CreateFontString(nil, "OVERLAY")
|
|
aura.cooldown:SetAllPoints(aura)
|
|
aura.stacks = aura.overlay:CreateFontString(nil, "OVERLAY")
|
|
aura.stacks:SetPoint("BOTTOMRIGHT", aura, "BOTTOMRIGHT", 0, 3)
|
|
styleIcon(aura)
|
|
aura:SetScript("OnUpdate", iconTimer)
|
|
end
|
|
self.frames[unit].auras[auraType][index] = aura
|
|
self:UpdateAurasOnUnit(unit)
|
|
aura:SetParent(auraType == AURA_TYPE_DEBUFF and self.frames[unit].debuffFrame or self.frames[unit].buffFrame)
|
|
else
|
|
aura = self.frames[unit].auras[auraType][index]
|
|
end
|
|
|
|
setAuraSize(aura, auraType)
|
|
aura.stacks:SetText(stacks > 1 and stacks or "")
|
|
aura.texture:SetTexture(icon)
|
|
aura.startTime = GetTime() - (duration - timeLeft)
|
|
if duration == 0 then
|
|
aura.endtime = "undefined"
|
|
aura.cooldowncircle:Hide()
|
|
else
|
|
aura.endtime = GetTime() + timeLeft
|
|
aura.cooldowncircle:SetCooldown(GetTime() - (duration - timeLeft), duration)
|
|
aura.cooldowncircle:Show()
|
|
end
|
|
aura.spellID = spellID
|
|
aura.type = auraType
|
|
aura.unit = unit
|
|
aura.dispelType = dispelType
|
|
aura.border:SetVertexColor(dispelTypeToOptionValue(dispelType))
|
|
aura:Show()
|
|
end
|
|
|
|
function BuffsDebuffs:AddOrRefreshAura(unit, spellID, auraType, duration, timeLeft, stacks, dispelType, icon, index)
|
|
if self.frames[unit].auras[auraType][index] and self.frames[unit].auras[auraType][index].spellID == spellID then -- refresh
|
|
if duration == 0 then
|
|
self.frames[unit].auras[auraType][index].endtime = "undefined"
|
|
self.frames[unit].auras[auraType][index].cooldowncircle:Hide()
|
|
else
|
|
self.frames[unit].auras[auraType][index].endtime = GetTime() + timeLeft
|
|
self.frames[unit].auras[auraType][index].cooldowncircle:SetCooldown(GetTime() - (duration - timeLeft), duration)
|
|
self.frames[unit].auras[auraType][index].cooldowncircle:Show()
|
|
end
|
|
self.frames[unit].auras[auraType][index].stacks:SetText(stacks > 1 and stacks or "")
|
|
self.frames[unit].auras[auraType][index]:Show()
|
|
self:UpdateAurasOnUnit(unit)
|
|
return
|
|
end
|
|
--add
|
|
self:AddAura(unit, spellID, auraType, duration, timeLeft, stacks, dispelType, icon, index)
|
|
self:UpdateAurasOnUnit(unit)
|
|
end
|
|
|
|
------------
|
|
-- OPTIONS
|
|
------------
|
|
|
|
function BuffsDebuffs:GetOptions()
|
|
return {
|
|
headerBuffs = {
|
|
type = "header",
|
|
name = L["Buffs and Debuffs"],
|
|
order = 2,
|
|
},
|
|
buffsEnabled = Gladdy:option({
|
|
type = "toggle",
|
|
name = L["Enabled"],
|
|
desc = L["Enabled Buffs and Debuffs module"],
|
|
order = 3,
|
|
}),
|
|
buffsShowAuraDebuffs = Gladdy:option({
|
|
type = "toggle",
|
|
name = L["Show CC"],
|
|
desc = L["Shows all debuffs, which are displayed on the ClassIcon as well"],
|
|
order = 4,
|
|
disabled = function() return not Gladdy.db.buffsEnabled end,
|
|
}),
|
|
group = {
|
|
type = "group",
|
|
childGroups = "tree",
|
|
name = L["Frame"],
|
|
order = 5,
|
|
disabled = function() return not Gladdy.db.buffsEnabled end,
|
|
args = {
|
|
buffs = {
|
|
type = "group",
|
|
name = L["Buffs"],
|
|
order = 1,
|
|
args = {
|
|
size = {
|
|
type = "group",
|
|
name = L["Icon"],
|
|
order = 1,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Icon"],
|
|
order = 1,
|
|
},
|
|
buffsBuffsIconZoomed = Gladdy:option({
|
|
type = "toggle",
|
|
name = L["Zoomed Icon"],
|
|
desc = L["Zoomes the icon to remove borders"],
|
|
order = 2,
|
|
width = "full",
|
|
}),
|
|
buffsBuffsIconSize = Gladdy:option({
|
|
type = "range",
|
|
name = L["Icon Size"],
|
|
desc = L["Size of the DR Icons"],
|
|
order = 6,
|
|
min = 5,
|
|
max = 50,
|
|
step = 1,
|
|
width = "full",
|
|
}),
|
|
buffsBuffsWidthFactor = Gladdy:option({
|
|
type = "range",
|
|
name = L["Icon Width Factor"],
|
|
desc = L["Stretches the icon"],
|
|
order = 7,
|
|
min = 0.5,
|
|
max = 2,
|
|
step = 0.05,
|
|
width = "full",
|
|
}),
|
|
buffsBuffsIconPadding = Gladdy:option({
|
|
type = "range",
|
|
name = L["Icon Padding"],
|
|
desc = L["Space between Icons"],
|
|
order = 8,
|
|
min = 0,
|
|
max = 10,
|
|
step = 0.1,
|
|
width = "full",
|
|
}),
|
|
},
|
|
},
|
|
position = {
|
|
type = "group",
|
|
name = L["Position"],
|
|
order = 3,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Position"],
|
|
order = 5,
|
|
},
|
|
buffsBuffsCooldownGrowDirection = Gladdy:option({
|
|
type = "select",
|
|
name = L["Grow Direction"],
|
|
desc = L["Grow Direction of the aura icons"],
|
|
order = 21,
|
|
values = {
|
|
["LEFT"] = L["Left"],
|
|
["RIGHT"] = L["Right"],
|
|
},
|
|
}),
|
|
buffsBuffsXOffset = Gladdy:option({
|
|
type = "range",
|
|
name = L["Horizontal offset"],
|
|
order = 22,
|
|
min = -400,
|
|
max = 400,
|
|
step = 0.1,
|
|
width = "full",
|
|
}),
|
|
buffsBuffsYOffset = Gladdy:option({
|
|
type = "range",
|
|
name = L["Vertical offset"],
|
|
order = 23,
|
|
min = -400,
|
|
max = 400,
|
|
step = 0.1,
|
|
width = "full",
|
|
}),
|
|
},
|
|
},
|
|
alpha = {
|
|
type = "group",
|
|
name = L["Alpha"],
|
|
order = 2,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Alpha"],
|
|
order = 1,
|
|
},
|
|
buffsBuffsAlpha = Gladdy:option({
|
|
type = "range",
|
|
name = L["Alpha"],
|
|
order = 2,
|
|
min = 0,
|
|
max = 1,
|
|
step = 0.05,
|
|
width = "full",
|
|
}),
|
|
}
|
|
}
|
|
}
|
|
},
|
|
debuffs = {
|
|
type = "group",
|
|
name = L["Debuffs"],
|
|
order = 2,
|
|
args = {
|
|
size = {
|
|
type = "group",
|
|
name = L["Icon"],
|
|
order = 1,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Icon"],
|
|
order = 1,
|
|
},
|
|
buffsIconZoomed = Gladdy:option({
|
|
type = "toggle",
|
|
name = L["Zoomed Icon"],
|
|
desc = L["Zoomes the icon to remove borders"],
|
|
order = 2,
|
|
width = "full",
|
|
}),
|
|
buffsIconSize = Gladdy:option({
|
|
type = "range",
|
|
name = L["Icon Size"],
|
|
desc = L["Size of the DR Icons"],
|
|
order = 6,
|
|
min = 5,
|
|
max = 50,
|
|
step = 1,
|
|
width = "full",
|
|
}),
|
|
buffsWidthFactor = Gladdy:option({
|
|
type = "range",
|
|
name = L["Icon Width Factor"],
|
|
desc = L["Stretches the icon"],
|
|
order = 7,
|
|
min = 0.5,
|
|
max = 2,
|
|
step = 0.05,
|
|
width = "full",
|
|
}),
|
|
buffsIconPadding = Gladdy:option({
|
|
type = "range",
|
|
name = L["Icon Padding"],
|
|
desc = L["Space between Icons"],
|
|
order = 8,
|
|
min = 0,
|
|
max = 10,
|
|
step = 0.1,
|
|
width = "full",
|
|
}),
|
|
},
|
|
},
|
|
position = {
|
|
type = "group",
|
|
name = L["Position"],
|
|
order = 3,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Position"],
|
|
order = 5,
|
|
},
|
|
buffsCooldownGrowDirection = Gladdy:option({
|
|
type = "select",
|
|
name = L["Grow Direction"],
|
|
desc = L["Grow Direction of the aura icons"],
|
|
order = 21,
|
|
values = {
|
|
["LEFT"] = L["Left"],
|
|
["RIGHT"] = L["Right"],
|
|
},
|
|
}),
|
|
buffsXOffset = Gladdy:option({
|
|
type = "range",
|
|
name = L["Horizontal offset"],
|
|
order = 22,
|
|
min = -400,
|
|
max = 400,
|
|
step = 0.1,
|
|
width = "full",
|
|
}),
|
|
buffsYOffset = Gladdy:option({
|
|
type = "range",
|
|
name = L["Vertical offset"],
|
|
order = 23,
|
|
min = -400,
|
|
max = 400,
|
|
step = 0.1,
|
|
width = "full",
|
|
}),
|
|
},
|
|
},
|
|
alpha = {
|
|
type = "group",
|
|
name = L["Alpha"],
|
|
order = 2,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Alpha"],
|
|
order = 1,
|
|
},
|
|
buffsAlpha = Gladdy:option({
|
|
type = "range",
|
|
name = L["Alpha"],
|
|
order = 2,
|
|
min = 0,
|
|
max = 1,
|
|
step = 0.05,
|
|
width = "full",
|
|
}),
|
|
}
|
|
}
|
|
},
|
|
},
|
|
cooldown = {
|
|
type = "group",
|
|
name = L["Cooldown"],
|
|
order = 3,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Cooldown"],
|
|
order = 5,
|
|
},
|
|
buffsDisableCircle = Gladdy:option({
|
|
type = "toggle",
|
|
name = L["No Cooldown Circle"],
|
|
order = 9,
|
|
width = "full",
|
|
}),
|
|
buffsCooldownAlpha = Gladdy:option({
|
|
type = "range",
|
|
name = L["Cooldown circle alpha"],
|
|
min = 0,
|
|
max = 1,
|
|
step = 0.1,
|
|
order = 10,
|
|
width = "full",
|
|
}),
|
|
buffsCooldownNumberAlpha = {
|
|
type = "range",
|
|
name = L["Cooldown number alpha"],
|
|
min = 0,
|
|
max = 1,
|
|
step = 0.1,
|
|
order = 11,
|
|
width = "full",
|
|
set = function(info, value)
|
|
Gladdy.db.buffsFontColor.a = value
|
|
Gladdy:UpdateFrame()
|
|
end,
|
|
get = function(info)
|
|
return Gladdy.db.buffsFontColor.a
|
|
end,
|
|
},
|
|
},
|
|
},
|
|
font = {
|
|
type = "group",
|
|
name = L["Font"],
|
|
order = 4,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Font"],
|
|
order = 5,
|
|
},
|
|
buffsFont = Gladdy:option({
|
|
type = "select",
|
|
name = L["Font"],
|
|
desc = L["Font of the cooldown"],
|
|
order = 12,
|
|
dialogControl = "LSM30_Font",
|
|
values = AceGUIWidgetLSMlists.font,
|
|
}),
|
|
buffsFontScale = Gladdy:option({
|
|
type = "range",
|
|
name = L["Font scale"],
|
|
desc = L["Scale of the text"],
|
|
order = 13,
|
|
min = 0.1,
|
|
max = 2,
|
|
step = 0.1,
|
|
width = "full",
|
|
}),
|
|
buffsDynamicColor = Gladdy:option({
|
|
type = "toggle",
|
|
name = L["Dynamic Timer Color"],
|
|
desc = L["Show dynamic color on cooldown numbers"],
|
|
order = 14,
|
|
}),
|
|
buffsFontColor = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Font color"],
|
|
desc = L["Color of the cooldown timer and stacks"],
|
|
order = 15,
|
|
hasAlpha = true,
|
|
}),
|
|
},
|
|
},
|
|
border = {
|
|
type = "group",
|
|
name = L["Border"],
|
|
order = 5,
|
|
args = {
|
|
header = {
|
|
type = "header",
|
|
name = L["Border"],
|
|
order = 5,
|
|
},
|
|
buffsBorderStyle = Gladdy:option({
|
|
type = "select",
|
|
name = L["Border style"],
|
|
order = 31,
|
|
values = Gladdy:GetIconStyles()
|
|
}),
|
|
headerBorder = {
|
|
type = "header",
|
|
name = L["Spell School Colors"],
|
|
order = 40,
|
|
},
|
|
buffsBorderColorsEnabled = Gladdy:option({
|
|
type = "toggle",
|
|
name = L["Spell School Colors Enabled"],
|
|
desc = L["Show border colors by spell school"],
|
|
order = 41,
|
|
width = "full",
|
|
}),
|
|
buffsBorderColorCurse = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Curse"],
|
|
desc = L["Color of the border"],
|
|
order = 42,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorMagic = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Magic"],
|
|
desc = L["Color of the border"],
|
|
order = 43,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorPoison = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Poison"],
|
|
desc = L["Color of the border"],
|
|
order = 44,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorPhysical = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Physical"],
|
|
desc = L["Color of the border"],
|
|
order = 45,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorImmune = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Immune"],
|
|
desc = L["Color of the border"],
|
|
order = 46,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorDisease = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Disease"],
|
|
desc = L["Color of the border"],
|
|
order = 47,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorAura = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Aura"],
|
|
desc = L["Color of the border"],
|
|
order = 48,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorForm = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Form"],
|
|
desc = L["Color of the border"],
|
|
order = 49,
|
|
hasAlpha = true,
|
|
}),
|
|
buffsBorderColorEnrage = Gladdy:colorOption({
|
|
type = "color",
|
|
name = L["Enrage"],
|
|
desc = L["Color of the border"],
|
|
order = 50,
|
|
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,
|
|
},
|
|
buffFrameStrata = Gladdy:option({
|
|
type = "select",
|
|
name = L["Frame Strata"],
|
|
order = 2,
|
|
values = Gladdy.frameStrata,
|
|
sorting = Gladdy.frameStrataSorting,
|
|
width = "full",
|
|
}),
|
|
buffsFrameLevel = Gladdy:option({
|
|
type = "range",
|
|
name = L["Frame Level"],
|
|
min = 0,
|
|
max = 500,
|
|
step = 1,
|
|
order = 3,
|
|
width = "full",
|
|
}),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
debuffList = {
|
|
name = L["Debuff Lists"],
|
|
type = "group",
|
|
order = 11,
|
|
disabled = function() return not Gladdy.db.buffsEnabled end,
|
|
childGroups = "tree",
|
|
args = select(1, Gladdy:GetAuras(AURA_TYPE_DEBUFF)),
|
|
set = function(info, state)
|
|
local optionKey = info[#info]
|
|
Gladdy.dbi.profile.trackedDebuffs[optionKey] = state
|
|
end,
|
|
get = function(info)
|
|
local optionKey = info[#info]
|
|
return Gladdy.dbi.profile.trackedDebuffs[optionKey]
|
|
end,
|
|
},
|
|
buffList = {
|
|
name = L["Buff Lists"],
|
|
type = "group",
|
|
order = 12,
|
|
disabled = function() return not Gladdy.db.buffsEnabled end,
|
|
childGroups = "tree",
|
|
args = select(1, Gladdy:GetAuras(AURA_TYPE_BUFF)),
|
|
set = function(info, state)
|
|
local optionKey = info[#info]
|
|
Gladdy.dbi.profile.trackedBuffs[optionKey] = state
|
|
end,
|
|
get = function(info)
|
|
local optionKey = info[#info]
|
|
return Gladdy.dbi.profile.trackedBuffs[optionKey]
|
|
end,
|
|
},
|
|
}
|
|
end
|
|
|
|
---------------------------
|
|
|
|
-- LAGACY HANDLER
|
|
|
|
---------------------------
|
|
|
|
function BuffsDebuffs:LegacySetPositionDebuffs(unit)
|
|
if Gladdy.db.newLayout then
|
|
return Gladdy.db.newLayout
|
|
end
|
|
self.frames[unit].debuffFrame: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 verticalMargin = -(Gladdy.db.powerBarHeight)/2
|
|
local offset = 0
|
|
if (Gladdy.db.buffsCooldownGrowDirection == "RIGHT") then
|
|
offset = Gladdy.db.buffsIconSize * Gladdy.db.buffsWidthFactor
|
|
end
|
|
local pos = Gladdy.db.buffsCooldownPos
|
|
|
|
if pos == "TOP" then
|
|
verticalMargin = horizontalMargin + 1
|
|
if Gladdy.db.cooldownYPos == "TOP" and Gladdy.db.cooldown then
|
|
verticalMargin = verticalMargin + Gladdy.db.cooldownSize
|
|
end
|
|
if Gladdy.db.buffsCooldownGrowDirection == "LEFT" then
|
|
self.frames[unit].debuffFrame:SetPoint("BOTTOMLEFT", Gladdy.buttons[unit].healthBar, "TOPRIGHT", Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset + verticalMargin)
|
|
else
|
|
self.frames[unit].debuffFrame:SetPoint("BOTTOMRIGHT", Gladdy.buttons[unit].healthBar, "TOPLEFT", Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset + verticalMargin)
|
|
end
|
|
elseif pos == "BOTTOM" then
|
|
verticalMargin = horizontalMargin + 1
|
|
if Gladdy.db.cooldownYPos == "BOTTOM" and Gladdy.db.cooldown then
|
|
verticalMargin = verticalMargin + Gladdy.db.cooldownSize
|
|
end
|
|
if Gladdy.db.buffsCooldownGrowDirection == "LEFT" then
|
|
self.frames[unit].debuffFrame:SetPoint("TOPLEFT", Gladdy.buttons[unit].healthBar, "BOTTOMRIGHT", Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset -verticalMargin - powerBarHeight)
|
|
else
|
|
self.frames[unit].debuffFrame:SetPoint("TOPRIGHT", Gladdy.buttons[unit].healthBar, "BOTTOMLEFT", Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset -verticalMargin - powerBarHeight)
|
|
end
|
|
elseif pos == "LEFT" then
|
|
horizontalMargin = horizontalMargin - 1 + Gladdy.db.padding
|
|
local anchor = Gladdy:GetAnchor(unit, "LEFT")
|
|
if anchor == Gladdy.buttons[unit].healthBar then
|
|
self.frames[unit].debuffFrame:SetPoint("RIGHT", anchor, "LEFT", -horizontalMargin + Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset)
|
|
else
|
|
self.frames[unit].debuffFrame:SetPoint("RIGHT", anchor, "LEFT", -Gladdy.db.padding + Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset)
|
|
end
|
|
elseif pos == "RIGHT" then
|
|
horizontalMargin = horizontalMargin - 1 + Gladdy.db.padding
|
|
local anchor = Gladdy:GetAnchor(unit, "RIGHT")
|
|
if anchor == Gladdy.buttons[unit].healthBar then
|
|
self.frames[unit].debuffFrame:SetPoint("LEFT", anchor, "RIGHT", horizontalMargin + Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset)
|
|
else
|
|
self.frames[unit].debuffFrame:SetPoint("LEFT", anchor, "RIGHT", horizontalMargin + Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsYOffset)
|
|
end
|
|
end
|
|
return Gladdy.db.newLayout
|
|
end
|
|
|
|
function BuffsDebuffs:LegacySetPositionBuffs(unit)
|
|
if Gladdy.db.newLayout then
|
|
return Gladdy.db.newLayout
|
|
end
|
|
self.frames[unit].buffFrame:ClearAllPoints()
|
|
local horizontalMargin = (Gladdy.db.highlightInset and 0 or Gladdy.db.highlightBorderSize)
|
|
local verticalMargin = -(Gladdy.db.powerBarHeight)/2
|
|
local powerBarHeight = Gladdy.db.powerBarEnabled and (Gladdy.db.powerBarHeight + 1) or 0
|
|
local offset = 0
|
|
if (Gladdy.db.buffsBuffsCooldownGrowDirection == "RIGHT") then
|
|
offset = Gladdy.db.buffsBuffsIconSize * Gladdy.db.buffsBuffsWidthFactor
|
|
end
|
|
|
|
local pos = Gladdy.db.buffsBuffsCooldownPos
|
|
|
|
if pos == "TOP" then
|
|
verticalMargin = horizontalMargin + 1
|
|
if Gladdy.db.cooldownYPos == "TOP" and Gladdy.db.cooldown then
|
|
verticalMargin = verticalMargin + Gladdy.db.cooldownSize
|
|
end
|
|
if Gladdy.db.buffsBuffsCooldownGrowDirection == "LEFT" then
|
|
self.frames[unit].buffFrame:SetPoint("BOTTOMLEFT", Gladdy.buttons[unit].healthBar, "TOPRIGHT", Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsBuffsYOffset + verticalMargin)
|
|
else
|
|
self.frames[unit].buffFrame:SetPoint("BOTTOMRIGHT", Gladdy.buttons[unit].healthBar, "TOPLEFT", Gladdy.db.buffsXOffset + offset, Gladdy.db.buffsBuffsYOffset + verticalMargin)
|
|
end
|
|
elseif pos == "BOTTOM" then
|
|
verticalMargin = horizontalMargin + 1
|
|
if Gladdy.db.cooldownYPos == "BOTTOM" and Gladdy.db.cooldown then
|
|
verticalMargin = verticalMargin + Gladdy.db.cooldownSize
|
|
end
|
|
if Gladdy.db.buffsBuffsCooldownGrowDirection == "LEFT" then
|
|
self.frames[unit].buffFrame:SetPoint("TOPLEFT", Gladdy.buttons[unit].healthBar, "BOTTOMRIGHT", Gladdy.db.buffsBuffsXOffset + offset, Gladdy.db.buffsBuffsYOffset -verticalMargin - powerBarHeight)
|
|
else
|
|
self.frames[unit].buffFrame:SetPoint("TOPRIGHT", Gladdy.buttons[unit].healthBar, "BOTTOMLEFT", Gladdy.db.buffsBuffsXOffset + offset, Gladdy.db.buffsBuffsYOffset -verticalMargin - powerBarHeight)
|
|
end
|
|
elseif pos == "LEFT" then
|
|
horizontalMargin = horizontalMargin - 1 + Gladdy.db.padding
|
|
if (Gladdy.db.trinketPos == "LEFT" and Gladdy.db.trinketEnabled) then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.trinketSize * Gladdy.db.trinketWidthFactor) + Gladdy.db.padding
|
|
if (Gladdy.db.classIconPos == "LEFT") then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.classIconSize * Gladdy.db.classIconWidthFactor) + Gladdy.db.padding
|
|
end
|
|
elseif (Gladdy.db.classIconPos == "LEFT") then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.classIconSize * Gladdy.db.classIconWidthFactor) + Gladdy.db.padding
|
|
if (Gladdy.db.trinketPos == "LEFT" and Gladdy.db.trinketEnabled) then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.trinketSize * Gladdy.db.trinketWidthFactor) + Gladdy.db.padding
|
|
end
|
|
end
|
|
if (Gladdy.db.drCooldownPos == "LEFT" and Gladdy.db.drEnabled) then
|
|
verticalMargin = verticalMargin + Gladdy.db.drIconSize/2 + Gladdy.db.padding/2
|
|
end
|
|
if (Gladdy.db.castBarPos == "LEFT") then
|
|
verticalMargin = verticalMargin -
|
|
(((Gladdy.db.castBarHeight < Gladdy.db.castBarIconSize) and Gladdy.db.castBarIconSize
|
|
or Gladdy.db.castBarHeight)/2 + Gladdy.db.padding/2)
|
|
end
|
|
if (Gladdy.db.cooldownYPos == "LEFT" and Gladdy.db.cooldown) then
|
|
verticalMargin = verticalMargin + (Gladdy.db.buffsBuffsIconSize/2 + Gladdy.db.padding/2)
|
|
end
|
|
--self.frames[unit].buffFrame:SetPoint("RIGHT", Gladdy.buttons[unit].healthBar, "LEFT", -horizontalMargin + Gladdy.db.buffsBuffsXOffset, Gladdy.db.buffsBuffsYOffset + verticalMargin)
|
|
|
|
local anchor = Gladdy:GetAnchor(unit, "LEFT")
|
|
horizontalMargin = (Gladdy.db.highlightInset and 0 or Gladdy.db.highlightBorderSize) - 1 + Gladdy.db.padding
|
|
if anchor == Gladdy.buttons[unit].healthBar then
|
|
self.frames[unit].buffFrame:SetPoint("RIGHT", anchor, "LEFT", -horizontalMargin + Gladdy.db.buffsBuffsXOffset + offset, Gladdy.db.buffsBuffsYOffset)
|
|
else
|
|
self.frames[unit].buffFrame:SetPoint("RIGHT", anchor, "LEFT", -Gladdy.db.padding + Gladdy.db.buffsBuffsXOffset + offset, Gladdy.db.buffsBuffsYOffset)
|
|
end
|
|
|
|
elseif pos == "RIGHT" then
|
|
horizontalMargin = horizontalMargin - 1 + Gladdy.db.padding
|
|
if (Gladdy.db.trinketPos == "RIGHT" and Gladdy.db.trinketEnabled) then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.trinketSize * Gladdy.db.trinketWidthFactor) + Gladdy.db.padding
|
|
if (Gladdy.db.classIconPos == "RIGHT") then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.classIconSize * Gladdy.db.classIconWidthFactor) + Gladdy.db.padding
|
|
end
|
|
elseif (Gladdy.db.classIconPos == "RIGHT") then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.classIconSize * Gladdy.db.classIconWidthFactor) + Gladdy.db.padding
|
|
if (Gladdy.db.trinketPos == "RIGHT" and Gladdy.db.trinketEnabled) then
|
|
horizontalMargin = horizontalMargin + (Gladdy.db.trinketSize * Gladdy.db.trinketWidthFactor) + Gladdy.db.padding
|
|
end
|
|
end
|
|
if (Gladdy.db.drCooldownPos == "RIGHT" and Gladdy.db.drEnabled) then
|
|
verticalMargin = verticalMargin + Gladdy.db.drIconSize/2 + Gladdy.db.padding/2
|
|
end
|
|
if (Gladdy.db.castBarPos == "RIGHT") then
|
|
verticalMargin = verticalMargin -
|
|
(((Gladdy.db.castBarHeight < Gladdy.db.castBarIconSize) and Gladdy.db.castBarIconSize
|
|
or Gladdy.db.castBarHeight)/2 + Gladdy.db.padding/2)
|
|
end
|
|
if (Gladdy.db.cooldownYPos == "RIGHT" and Gladdy.db.cooldown) then
|
|
verticalMargin = verticalMargin + (Gladdy.db.buffsBuffsIconSize/2 + Gladdy.db.padding/2)
|
|
end
|
|
--self.frames[unit].buffFrame:SetPoint("LEFT", Gladdy.buttons[unit].healthBar, "RIGHT", horizontalMargin + Gladdy.db.buffsBuffsXOffset, Gladdy.db.buffsBuffsYOffset + verticalMargin)
|
|
|
|
local anchor = Gladdy:GetAnchor(unit, "RIGHT")
|
|
horizontalMargin = (Gladdy.db.highlightInset and 0 or Gladdy.db.highlightBorderSize) - 1 + Gladdy.db.padding
|
|
if anchor == Gladdy.buttons[unit].healthBar then
|
|
self.frames[unit].buffFrame:SetPoint("LEFT", anchor, "RIGHT", horizontalMargin + Gladdy.db.buffsBuffsXOffset + offset, Gladdy.db.buffsBuffsYOffset)
|
|
else
|
|
self.frames[unit].buffFrame:SetPoint("LEFT", anchor, "RIGHT", Gladdy.db.padding + Gladdy.db.buffsBuffsXOffset + offset, Gladdy.db.buffsBuffsYOffset)
|
|
end
|
|
end
|
|
return Gladdy.db.newLayout
|
|
end |