mirror of
https://github.com/parnic/ice-hud.git
synced 2025-06-15 22:30:13 -05:00
9b063bed63
I don't have beta access so I can't test this yet, but this should catch everything in the Deprecated_11_0_0 file in wow's official ui source as well as some stuff not mentioned but reported by users.
787 lines
24 KiB
Lua
787 lines
24 KiB
Lua
local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
|
|
IceCastBar = IceCore_CreateClass(IceBarElement)
|
|
|
|
local IceHUD = _G.IceHUD
|
|
|
|
IceCastBar.Actions = { None = 0, Cast = 1, Channel = 2, Instant = 3, Success = 4, Failure = 5, ReverseChannel = 6 }
|
|
|
|
IceCastBar.prototype.action = nil
|
|
IceCastBar.prototype.actionStartTime = nil
|
|
IceCastBar.prototype.actionDuration = nil
|
|
IceCastBar.prototype.actionMessage = nil
|
|
IceCastBar.prototype.unit = nil
|
|
IceCastBar.prototype.current = nil
|
|
|
|
local SPELL_POWER_MANA = SPELL_POWER_MANA
|
|
if Enum and Enum.PowerType then
|
|
SPELL_POWER_MANA = Enum.PowerType.Mana
|
|
end
|
|
|
|
local UnitCastingInfo, UnitChannelInfo = UnitCastingInfo, UnitChannelInfo
|
|
if not UnitCastingInfo then
|
|
UnitCastingInfo = CastingInfo
|
|
UnitChannelInfo = ChannelInfo
|
|
end
|
|
|
|
local GetSpellName = GetSpellInfo
|
|
if C_Spell and C_Spell.GetSpellName then
|
|
GetSpellName = C_Spell.GetSpellName
|
|
end
|
|
|
|
local GetSpellInfo = GetSpellInfo
|
|
if not GetSpellInfo and C_Spell and C_Spell.GetSpellInfo then
|
|
GetSpellInfo = function(spellID)
|
|
if not spellID then
|
|
return nil
|
|
end
|
|
|
|
local spellInfo = C_Spell.GetSpellInfo(spellID)
|
|
if spellInfo then
|
|
return spellInfo.name, nil, spellInfo.iconID, spellInfo.castTime, spellInfo.minRange, spellInfo.maxRange, spellInfo.spellID, spellInfo.originalIconID
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Fulzamoth 2019-09-27 : Use LibClassicCasterino if it's there so we can use TargetCast
|
|
-- module in Classic WoW
|
|
if IceHUD.WowClassic then
|
|
LibClassicCasterino = LibStub("LibClassicCasterino", true)
|
|
if LibClassicCasterino then
|
|
UnitCastingInfo = function(unit)
|
|
return LibClassicCasterino:UnitCastingInfo(unit)
|
|
end
|
|
UnitChannelInfo = function(unit)
|
|
return LibClassicCasterino:UnitChannelInfo(unit)
|
|
end
|
|
end
|
|
end
|
|
-- end Fulzamoth change
|
|
|
|
local AuraIconWidth = 20
|
|
local AuraIconHeight = 20
|
|
|
|
-- Constructor --
|
|
function IceCastBar.prototype:init(name)
|
|
IceCastBar.super.prototype.init(self, name)
|
|
|
|
self:SetDefaultColor("CastCasting", 242, 242, 10)
|
|
self:SetDefaultColor("CastChanneling", 242, 242, 10)
|
|
self:SetDefaultColor("CastSuccess", 242, 242, 70)
|
|
self:SetDefaultColor("CastFail", 1, 0, 0)
|
|
if GetUnitEmpowerMinHoldTime then
|
|
self:SetDefaultColor("EmpowerStage0", 165, 165, 165)
|
|
self:SetDefaultColor("EmpowerStage1", 242, 42, 10)
|
|
self:SetDefaultColor("EmpowerStage2", 242, 142, 10)
|
|
self:SetDefaultColor("EmpowerStage3", 242, 242, 10)
|
|
self:SetDefaultColor("EmpowerStage4", 242, 242, 242)
|
|
end
|
|
self.unit = "player"
|
|
|
|
self.delay = 0
|
|
self.action = IceCastBar.Actions.None
|
|
end
|
|
|
|
|
|
-- 'Public' methods -----------------------------------------------------------
|
|
|
|
function IceCastBar.prototype:Enable(core)
|
|
IceCastBar.super.prototype.Enable(self, core)
|
|
|
|
-- Fulzamoth 2019-09-27 : LibClassicCasterino support
|
|
-- Setup callback to the library, and route events to
|
|
-- IceHUD's handler functions.
|
|
if LibClassicCasterino then
|
|
local CastbarEventHandler = function(event, ...) -- unitTarget, castGUID, spellID
|
|
if (event == "UNIT_SPELLCAST_START") then
|
|
return IceCastBar.prototype.SpellCastStart(self, event, ...)
|
|
elseif (event == "UNIT_SPELLCAST_DELAYED") then
|
|
return IceCastBar.prototype.SpellCastDelayed(self, event, ...)
|
|
elseif (event == "UNIT_SPELLCAST_STOP") then
|
|
return IceCastBar.prototype.SpellCastStop(self, event, ...)
|
|
elseif (event == "UNIT_SPELLCAST_FAILED") then
|
|
return IceCastBar.prototype.SpellCastFailed(self, event, ...)
|
|
elseif (event == "UNIT_SPELLCAST_INTERRUPTED") then
|
|
return IceCastBar.prototype.SpellCastInterrupted(self, event, ...)
|
|
elseif (event == "UNIT_SPELLCAST_CHANNEL_START") then
|
|
return IceCastBar.prototype.SpellCastChannelStart(self, event, ...)
|
|
elseif (event == "UNIT_SPELLCAST_CHANNEL_UPDATE") then
|
|
return IceCastBar.prototype.SpellCastChannelUpdate(self, event, ...)
|
|
elseif (event == "UNIT_SPELLCAST_CHANNEL_STOP") then
|
|
return IceCastBar.prototype.SpellCastChannelStop(self, event, ...)
|
|
end
|
|
end
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_START", CastbarEventHandler)
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_DELAYED", CastbarEventHandler) -- only for player
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_STOP", CastbarEventHandler)
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_FAILED", CastbarEventHandler)
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_INTERRUPTED", CastbarEventHandler)
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_CHANNEL_START", CastbarEventHandler)
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_CHANNEL_UPDATE", CastbarEventHandler) -- only for player
|
|
LibClassicCasterino.RegisterCallback(self,"UNIT_SPELLCAST_CHANNEL_STOP", CastbarEventHandler)
|
|
else -- No LibClassicCasterino, or we're not on Classic, so use IceHUD's normal event handlers.
|
|
|
|
self:RegisterEvent("UNIT_SPELLCAST_SENT", "SpellCastSent") -- "player", spell, rank, target
|
|
self:RegisterEvent("CURRENT_SPELL_CAST_CHANGED", "SpellCastChanged")
|
|
self:RegisterEvent("UNIT_SPELLCAST_START", "SpellCastStart") -- unit, spell, rank
|
|
self:RegisterEvent("UNIT_SPELLCAST_STOP", "SpellCastStop") -- unit, spell, rank
|
|
|
|
self:RegisterEvent("UNIT_SPELLCAST_FAILED", "SpellCastFailed") -- unit, spell, rank
|
|
self:RegisterEvent("UNIT_SPELLCAST_INTERRUPTED", "SpellCastInterrupted") -- unit, spell, rank
|
|
|
|
self:RegisterEvent("UNIT_SPELLCAST_DELAYED", "SpellCastDelayed") -- unit, spell, rank
|
|
self:RegisterEvent("UNIT_SPELLCAST_SUCCEEDED", "SpellCastSucceeded") -- "player", spell, rank
|
|
|
|
self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_START", "SpellCastChannelStart") -- unit, spell, rank
|
|
self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_UPDATE", "SpellCastChannelUpdate") -- unit, spell, rank
|
|
self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_STOP", "SpellCastChannelStop") -- unit, spell, rank
|
|
|
|
if GetUnitEmpowerHoldAtMaxTime then
|
|
self:RegisterEvent("UNIT_SPELLCAST_EMPOWER_START", "SpellCastChannelStart")
|
|
self:RegisterEvent("UNIT_SPELLCAST_EMPOWER_UPDATE", "SpellCastChannelUpdate")
|
|
self:RegisterEvent("UNIT_SPELLCAST_EMPOWER_STOP", "SpellCastChannelStop")
|
|
end
|
|
|
|
end
|
|
self:Show(false)
|
|
end
|
|
|
|
function IceCastBar.prototype:GetDefaultSettings()
|
|
local settings = IceCastBar.super.prototype.GetDefaultSettings(self)
|
|
|
|
settings["showSpellRank"] = true
|
|
settings["showCastTime"] = true
|
|
settings["displayAuraIcon"] = false
|
|
settings["auraIconXOffset"] = 40
|
|
settings["auraIconYOffset"] = 0
|
|
settings["auraIconScale"] = 1
|
|
settings["reverseChannel"] = true
|
|
|
|
return settings
|
|
end
|
|
|
|
function IceCastBar.prototype:GetOptions()
|
|
local opts = IceCastBar.super.prototype.GetOptions(self)
|
|
|
|
opts["showCastTime"] =
|
|
{
|
|
type = 'toggle',
|
|
name = L["Show spell cast time"],
|
|
desc = L["Whether or not to show the remaining cast time of a spell being cast."],
|
|
get = function()
|
|
return self.moduleSettings.showCastTime
|
|
end,
|
|
set = function(info, value)
|
|
self.moduleSettings.showCastTime = value
|
|
end,
|
|
disabled = function()
|
|
return not self.moduleSettings.enabled
|
|
end,
|
|
order = 39.998
|
|
}
|
|
if IceHUD.SpellFunctionsReturnRank then
|
|
opts["showSpellRank"] =
|
|
{
|
|
type = 'toggle',
|
|
name = L["Show spell rank"],
|
|
desc = L["Whether or not to show the rank of a spell being cast."],
|
|
get = function()
|
|
return self.moduleSettings.showSpellRank
|
|
end,
|
|
set = function(info, value)
|
|
self.moduleSettings.showSpellRank = value
|
|
end,
|
|
disabled = function()
|
|
return not self.moduleSettings.enabled
|
|
end,
|
|
order = 39.999
|
|
}
|
|
end
|
|
opts["iconSettings"] = {
|
|
type = 'group',
|
|
name = "|c"..self.configColor..L["Icon Settings"].."|r",
|
|
args = {
|
|
displayAuraIcon = {
|
|
type = 'toggle',
|
|
name = L["Display aura icon"],
|
|
desc = L["Whether or not to display an icon for the aura that this bar is tracking"],
|
|
get = function()
|
|
return self.moduleSettings.displayAuraIcon
|
|
end,
|
|
set = function(info, v)
|
|
self.moduleSettings.displayAuraIcon = v
|
|
if self.barFrame.icon then
|
|
if v then
|
|
self.barFrame.icon:Show()
|
|
else
|
|
self.barFrame.icon:Hide()
|
|
end
|
|
end
|
|
end,
|
|
disabled = function()
|
|
return not self.moduleSettings.enabled
|
|
end,
|
|
order = 51,
|
|
},
|
|
|
|
auraIconXOffset = {
|
|
type = 'range',
|
|
min = -250,
|
|
max = 250,
|
|
step = 1,
|
|
name = L["Aura icon horizontal offset"],
|
|
desc = L["Adjust the horizontal position of the aura icon"],
|
|
get = function()
|
|
return self.moduleSettings.auraIconXOffset
|
|
end,
|
|
set = function(info, v)
|
|
self.moduleSettings.auraIconXOffset = v
|
|
self:PositionIcons()
|
|
end,
|
|
disabled = function()
|
|
return not self.moduleSettings.enabled or not self.moduleSettings.displayAuraIcon
|
|
end,
|
|
order = 52,
|
|
},
|
|
|
|
auraIconYOffset = {
|
|
type = 'range',
|
|
min = -250,
|
|
max = 250,
|
|
step = 1,
|
|
name = L["Aura icon vertical offset"],
|
|
desc = L["Adjust the vertical position of the aura icon"],
|
|
get = function()
|
|
return self.moduleSettings.auraIconYOffset
|
|
end,
|
|
set = function(info, v)
|
|
self.moduleSettings.auraIconYOffset = v
|
|
self:PositionIcons()
|
|
end,
|
|
disabled = function()
|
|
return not self.moduleSettings.enabled or not self.moduleSettings.displayAuraIcon
|
|
end,
|
|
order = 53,
|
|
},
|
|
|
|
auraIconScale = {
|
|
type = 'range',
|
|
min = 0.1,
|
|
max = 3.0,
|
|
step = 0.05,
|
|
name = L["Aura icon scale"],
|
|
desc = L["Adjusts the size of the aura icon for this bar"],
|
|
get = function()
|
|
return self.moduleSettings.auraIconScale
|
|
end,
|
|
set = function(info, v)
|
|
self.moduleSettings.auraIconScale = v
|
|
self:PositionIcons()
|
|
end,
|
|
disabled = function()
|
|
return not self.moduleSettings.enabled or not self.moduleSettings.displayAuraIcon
|
|
end,
|
|
order = 54,
|
|
},
|
|
},
|
|
}
|
|
|
|
opts["reverseChannel"] = {
|
|
type = 'toggle',
|
|
name = L["Reverse channeling"],
|
|
desc = L["Whether or not to reverse the direction of the cast bar when a spell is being channeled. For example, if a normal cast causes this bar to fill up, then checking this option will cause a channeled spell to empty the bar instead."],
|
|
get = function()
|
|
return self.moduleSettings.reverseChannel
|
|
end,
|
|
set = function(info, v)
|
|
self.moduleSettings.reverseChannel = v
|
|
end,
|
|
disabled = function()
|
|
return not self.moduleSettings.enabled
|
|
end,
|
|
order = 32.5,
|
|
}
|
|
|
|
return opts
|
|
end
|
|
|
|
function IceCastBar.prototype:IsFull(scale)
|
|
local retval = IceCastBar.super.prototype.IsFull(self, scale)
|
|
if retval then
|
|
if self.action and self.action ~= IceCastBar.Actions.None then
|
|
return false
|
|
end
|
|
end
|
|
return retval
|
|
end
|
|
|
|
-- 'Protected' methods --------------------------------------------------------
|
|
|
|
-- OVERRIDE
|
|
function IceCastBar.prototype:CreateFrame()
|
|
IceCastBar.super.prototype.CreateFrame(self)
|
|
|
|
self.frame.bottomUpperText:SetWidth(self.settings.gap + 30)
|
|
|
|
if not self.barFrame.icon then
|
|
self.barFrame.icon = self.masterFrame:CreateTexture(nil, "OVERLAY")
|
|
-- default texture so that 'config mode' can work without activating the bar first
|
|
self.barFrame.icon:SetTexture("Interface\\Icons\\Spell_Frost_Frost")
|
|
-- this cuts off the border around the buff icon
|
|
self.barFrame.icon:SetTexCoord(0.1, 0.9, 0.1, 0.9)
|
|
end
|
|
self:PositionIcons()
|
|
end
|
|
|
|
function IceCastBar.prototype:PositionIcons()
|
|
if not self.barFrame or not self.barFrame.icon then
|
|
return
|
|
end
|
|
|
|
self.barFrame.icon:ClearAllPoints()
|
|
self.barFrame.icon:SetPoint("TOPLEFT", self.frame, "TOPLEFT", self.moduleSettings.auraIconXOffset, self.moduleSettings.auraIconYOffset)
|
|
self.barFrame.icon:SetWidth(AuraIconWidth * self.moduleSettings.auraIconScale)
|
|
self.barFrame.icon:SetHeight(AuraIconHeight * self.moduleSettings.auraIconScale)
|
|
end
|
|
|
|
function IceCastBar.prototype:GetRemainingCastTime()
|
|
return self.actionStartTime + self.actionDuration - GetTime()
|
|
end
|
|
|
|
function IceCastBar.prototype:GetCurrentCastDurationMs()
|
|
return (GetTime() - (self.actionStartTime or GetTime())) * 1000
|
|
end
|
|
|
|
-- OnUpdate handler
|
|
function IceCastBar.prototype:MyOnUpdate()
|
|
-- safety catch
|
|
if (self.action == IceCastBar.Actions.None) then
|
|
--IceHUD:Debug("Stopping action ", self.action)
|
|
self:StopBar()
|
|
return
|
|
end
|
|
|
|
self:Update()
|
|
self:SetTextAlpha()
|
|
|
|
-- handle casting and channeling
|
|
if (self.action == IceCastBar.Actions.Cast or self.action == IceCastBar.Actions.Channel or self.action == IceCastBar.Actions.ReverseChannel) then
|
|
local remainingTime = self:GetRemainingCastTime()
|
|
local scale = 1 - (self.actionDuration ~= 0 and remainingTime / self.actionDuration or 0)
|
|
|
|
if self.action == IceCastBar.Actions.ReverseChannel then
|
|
scale = self.actionDuration ~= 0 and remainingTime / self.actionDuration or 0
|
|
end
|
|
|
|
self:UpdateBar(IceHUD:Clamp(scale, 0, 1), self:GetCurrentCastingColor())
|
|
|
|
if (remainingTime <= 0) then
|
|
self:StopBar()
|
|
end
|
|
|
|
local timeString = self.moduleSettings.showCastTime and string.format("%.1fs ", remainingTime) or ""
|
|
local empowerString = self.NumStages ~= nil and (L["Stage %d"]):format(self:GetCurrentStage()) or ""
|
|
local line1 = timeString .. (self.actionMessage or "")
|
|
if self.moduleSettings.empowerStageTextDisplay == "TOPLINE" then
|
|
line1 = line1 .. " " .. empowerString
|
|
end
|
|
if self.moduleSettings.empowerStageTextDisplay == "BOTTOMLINE" then
|
|
self:SetBottomText2(empowerString)
|
|
end
|
|
self:SetBottomText1(line1)
|
|
|
|
return
|
|
end
|
|
|
|
|
|
-- stop bar if casting or channeling is done (in theory this should not be needed)
|
|
if (self.action == IceCastBar.Actions.Cast or self.action == IceCastBar.Actions.Channel or self.action == IceCastBar.Actions.ReverseChannel) then
|
|
self:StopBar()
|
|
return
|
|
end
|
|
|
|
|
|
-- handle bar flashes
|
|
if (self.action == IceCastBar.Actions.Instant or
|
|
self.action == IceCastBar.Actions.Success or
|
|
self.action == IceCastBar.Actions.Failure)
|
|
then
|
|
local scale
|
|
if self.actionStartTime then
|
|
scale = GetTime() - self.actionStartTime
|
|
end
|
|
|
|
if scale and (scale > 1) then
|
|
self:StopBar()
|
|
return
|
|
end
|
|
|
|
self:UpdateBar(1, self:GetCurrentCastingColor())
|
|
|
|
if scale then
|
|
if (self.action == IceCastBar.Actions.Failure) then
|
|
self:FlashBar("CastFail", 1-scale, self.actionMessage, "CastFail")
|
|
else
|
|
self:FlashBar("CastSuccess", 1-scale, self.actionMessage)
|
|
end
|
|
end
|
|
return
|
|
end
|
|
|
|
-- something went wrong
|
|
IceHUD:Debug("OnUpdate error ", self.action, " -- ", self.actionStartTime, self.actionDuration, self.actionMessage)
|
|
self:StopBar()
|
|
end
|
|
|
|
function IceCastBar.prototype:GetStageDuration(stage)
|
|
if not GetUnitEmpowerMinHoldTime then
|
|
return 0
|
|
end
|
|
|
|
if stage == 0 then
|
|
return GetUnitEmpowerMinHoldTime(self.unit)
|
|
end
|
|
|
|
return GetUnitEmpowerStageDuration(self.unit, stage);
|
|
end
|
|
|
|
function IceCastBar.prototype:GetDurationUpToStage(stage)
|
|
if stage == nil or stage < 0 then
|
|
return 0
|
|
end
|
|
|
|
local total = 0
|
|
for i=0,stage-1 do
|
|
total = total + self:GetStageDuration(i)
|
|
end
|
|
|
|
return total
|
|
end
|
|
|
|
function IceCastBar.prototype:GetCurrentStage()
|
|
if not GetUnitEmpowerMinHoldTime then
|
|
return 0
|
|
end
|
|
|
|
local castDuration = self:GetCurrentCastDurationMs()
|
|
for i=1,self.NumStages do
|
|
if castDuration < self:GetDurationUpToStage(i) then
|
|
return i - 1
|
|
end
|
|
end
|
|
|
|
return self.NumStages
|
|
end
|
|
|
|
function IceCastBar.prototype:IsCastingEmpowerSpell()
|
|
return self.NumStages ~= nil
|
|
end
|
|
|
|
function IceCastBar.prototype:GetCurrentCastingColor()
|
|
if self:IsCastingEmpowerSpell() then
|
|
return ("EmpowerStage%d"):format(self:GetCurrentStage())
|
|
end
|
|
|
|
if self.action == IceCastBar.Actions.Channel or self.action == IceCastBar.Actions.ReverseChannel then
|
|
return "CastChanneling"
|
|
end
|
|
|
|
return "CastCasting"
|
|
end
|
|
|
|
function IceCastBar.prototype:FlashBar(color, alpha, text, textColor)
|
|
if self.moduleSettings.flashInstants == "Never" then
|
|
return
|
|
end
|
|
|
|
if alpha then
|
|
self.frame:SetAlpha(alpha)
|
|
end
|
|
|
|
local r, g, b = self.settings.backgroundColor.r, self.settings.backgroundColor.g, self.settings.backgroundColor.b
|
|
if (self.settings.backgroundToggle) then
|
|
r, g, b = self:GetColor(color)
|
|
end
|
|
|
|
self.frame.bg:SetVertexColor(r, g, b, 0.3)
|
|
self.barFrame.bar:SetVertexColor(self:GetColor(color, 0.8))
|
|
|
|
self:SetScale(1)
|
|
self:SetBottomText1(text, textColor or "Text")
|
|
end
|
|
|
|
|
|
function IceCastBar.prototype:StartBar(action, message, spellId)
|
|
local spell, rank, displayName, icon, startTime, endTime, isTradeSkill, numStages
|
|
if IceHUD.SpellFunctionsReturnRank then
|
|
spell, rank, displayName, icon, startTime, endTime, isTradeSkill = UnitCastingInfo(self.unit)
|
|
else
|
|
spell, displayName, icon, startTime, endTime, isTradeSkill = UnitCastingInfo(self.unit)
|
|
end
|
|
if not (spell) then
|
|
if IceHUD.SpellFunctionsReturnRank then
|
|
spell, rank, displayName, icon, startTime, endTime = UnitChannelInfo(self.unit)
|
|
else
|
|
spell, displayName, icon, startTime, endTime, isTradeSkill, _, _, _, numStages = UnitChannelInfo(self.unit)
|
|
end
|
|
end
|
|
|
|
if spellId and not spell then
|
|
spell, rank, icon = GetSpellInfo(spellId)
|
|
end
|
|
|
|
local isChargeSpell = numStages and numStages > 0
|
|
if isChargeSpell then
|
|
self.NumStages = numStages
|
|
endTime = endTime + GetUnitEmpowerHoldAtMaxTime(self.unit)
|
|
action = IceCastBar.Actions.ReverseChannel
|
|
else
|
|
self.NumStages = nil
|
|
end
|
|
|
|
if self.moduleSettings.reverseChannel then
|
|
if action == IceCastBar.Actions.Channel then
|
|
action = IceCastBar.Actions.ReverseChannel
|
|
elseif action == IceCastBar.Actions.ReverseChannel then
|
|
action = IceCastBar.Actions.Channel
|
|
end
|
|
end
|
|
|
|
-- Fulzamoth 2019-09-27 : LibClassicCasterino won't return spell info on target's failed or interrupted cast
|
|
if LibClassicCasterino and not spell then
|
|
self:StopBar()
|
|
elseif not spell then
|
|
return
|
|
end
|
|
|
|
if icon ~= nil then
|
|
self.barFrame.icon:SetTexture(icon)
|
|
end
|
|
|
|
if IceHUD.IceCore:IsInConfigMode() or self.moduleSettings.displayAuraIcon then
|
|
self.barFrame.icon:Show()
|
|
else
|
|
self.barFrame.icon:Hide()
|
|
end
|
|
|
|
self.action = action
|
|
self.actionStartTime = GetTime()
|
|
self.actionMessage = message
|
|
|
|
if (startTime and endTime) then
|
|
self.actionDuration = (endTime - startTime) / 1000
|
|
|
|
-- set start time here in case we start to monitor a cast that is underway already
|
|
self.actionStartTime = startTime / 1000
|
|
else
|
|
self.actionDuration = 1 -- instants/failures
|
|
end
|
|
|
|
if not (message) and spell then
|
|
self.actionMessage = spell .. (self.moduleSettings.showSpellRank and self:GetShortRank(rank) or "")
|
|
end
|
|
|
|
self:Show(true)
|
|
self:ConditionalSetupUpdate()
|
|
end
|
|
|
|
|
|
function IceCastBar.prototype:StopBar()
|
|
self.action = IceCastBar.Actions.None
|
|
self.actionStartTime = nil
|
|
self.actionDuration = nil
|
|
|
|
self:SetBottomText1()
|
|
self:SetBottomText2()
|
|
self:SetScale(0)
|
|
self:Show(false)
|
|
end
|
|
|
|
function IceCastBar.prototype:GetShortRank(rank)
|
|
if IceHUD.SpellFunctionsReturnRank and rank then
|
|
local _, _, sRank = string.find(rank, "(%d+)")
|
|
if (sRank) then
|
|
return " (" .. sRank .. ")"
|
|
end
|
|
end
|
|
return ""
|
|
end
|
|
|
|
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- NORMAL SPELLS --
|
|
-------------------------------------------------------------------------------
|
|
|
|
function IceCastBar.prototype:SpellCastSent(event, unit, target, castGuid, spellId)
|
|
if (unit ~= self.unit) then return end
|
|
IceHUD:Debug("SpellCastSent", unit, target, castGuid, spellId)
|
|
end
|
|
|
|
function IceCastBar.prototype:SpellCastChanged(event, cancelled)
|
|
IceHUD:Debug("SpellCastChanged", cancelled)
|
|
end
|
|
|
|
function IceCastBar.prototype:SpellCastStart(event, unit, castGuid, spellId)
|
|
if (unit ~= self.unit) then return end
|
|
IceHUD:Debug("SpellCastStart", unit, castGuid, spellId)
|
|
--UnitCastingInfo(unit)
|
|
|
|
self:StartBar(IceCastBar.Actions.Cast, nil, spellId)
|
|
self.current = castGuid
|
|
end
|
|
|
|
function IceCastBar.prototype:SpellCastStop(event, unit, castGuid, spellId)
|
|
if (unit ~= self.unit) then return end
|
|
IceHUD:Debug("SpellCastStop", unit, castGuid, spellId)
|
|
|
|
-- ignore if not coming from current spell
|
|
if (self.current and castGuid and self.current ~= castGuid) then
|
|
return
|
|
end
|
|
|
|
if (self.action ~= IceCastBar.Actions.Success and
|
|
self.action ~= IceCastBar.Actions.Failure and
|
|
self.action ~= IceCastBar.Actions.Channel and
|
|
self.action ~= IceCastBar.Actions.ReverseChannel)
|
|
then
|
|
self:StopBar()
|
|
end
|
|
|
|
self.current = nil
|
|
end
|
|
|
|
|
|
function IceCastBar.prototype:SpellCastFailed(event, unit, castGuid, spellId)
|
|
if (unit ~= self.unit) then return end
|
|
IceHUD:Debug("SpellCastFailed", unit, castGuid, spellId)
|
|
|
|
-- ignore if not coming from current spell
|
|
if (self.current and castGuid and self.current ~= castGuid) then
|
|
return
|
|
end
|
|
|
|
-- channeled spells will call ChannelStop, not cast failed
|
|
if self.action == IceCastBar.Actions.Channel or self.action == IceCastBar.Actions.ReverseChannel then
|
|
return
|
|
end
|
|
|
|
self.current = nil
|
|
|
|
-- determine if we want to show failed casts
|
|
if (self.moduleSettings.flashFailures == "Never") then
|
|
return
|
|
elseif (self.moduleSettings.flashFailures == "Caster") then
|
|
if (UnitPowerType("player") ~= SPELL_POWER_MANA) then
|
|
return
|
|
end
|
|
end
|
|
|
|
self:StartBar(IceCastBar.Actions.Failure, "Failed", nil, spellId)
|
|
end
|
|
|
|
function IceCastBar.prototype:SpellCastInterrupted(event, unit, castGuid, spellId)
|
|
if (unit ~= self.unit) then return end
|
|
IceHUD:Debug("SpellCastInterrupted", unit, castGuid, spellId)
|
|
|
|
-- ignore if not coming from current spell
|
|
if (self.current and castGuid and self.current ~= castGuid) then
|
|
return
|
|
end
|
|
|
|
self.current = nil
|
|
|
|
self:StartBar(IceCastBar.Actions.Failure, "Interrupted", spellId)
|
|
end
|
|
|
|
function IceCastBar.prototype:SpellCastDelayed(event, unit, castGuid, spellId)
|
|
if (unit ~= self.unit) then return end
|
|
--IceHUD:Debug("SpellCastDelayed", unit, UnitCastingInfo(unit))
|
|
|
|
local endTime = select(IceHUD.SpellFunctionsReturnRank and 6 or 5, UnitCastingInfo(self.unit))
|
|
|
|
if (endTime and self.actionStartTime) then
|
|
-- apparently this check is needed, got nils during a horrible lag spike
|
|
self.actionDuration = endTime/1000 - self.actionStartTime
|
|
end
|
|
end
|
|
|
|
|
|
function IceCastBar.prototype:SpellCastSucceeded(event, unit, castGuid, spellId)
|
|
if (unit ~= self.unit) then return end
|
|
--IceHUD:Debug("SpellCastSucceeded", unit, castGuid, spellId)
|
|
|
|
-- never show on channeled (why on earth does this event even fire when channeling starts?)
|
|
if (self.action == IceCastBar.Actions.Channel or self.action == IceCastBar.Actions.ReverseChannel) then
|
|
return
|
|
end
|
|
|
|
-- ignore if not coming from current spell
|
|
if (self.current and self.current ~= castGuid) then
|
|
return
|
|
end
|
|
|
|
local spell = GetSpellName(spellId)
|
|
|
|
-- show after normal successfull cast
|
|
if (self.action == IceCastBar.Actions.Cast) then
|
|
self:StartBar(IceCastBar.Actions.Success, spell, spellId)
|
|
return
|
|
end
|
|
|
|
-- determine if we want to show instant casts
|
|
if (self.moduleSettings.flashInstants == "Never") then
|
|
return
|
|
elseif (self.moduleSettings.flashInstants == "Caster") then
|
|
if (UnitPowerType("player") ~= SPELL_POWER_MANA) then
|
|
return
|
|
end
|
|
end
|
|
|
|
-- handle special spells that are used for quests or other things that don't apply to the player
|
|
if self.unit == "player" and not IsPlayerSpell(spellId) then
|
|
return
|
|
end
|
|
|
|
self:StartBar(IceCastBar.Actions.Success, spell, spellId)
|
|
end
|
|
|
|
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- CHANNELING SPELLS --
|
|
-------------------------------------------------------------------------------
|
|
|
|
function IceCastBar.prototype:SpellCastChannelStart(event, unit)
|
|
if (unit ~= self.unit) then return end
|
|
--IceHUD:Debug("SpellCastChannelStart", unit)
|
|
|
|
self:StartBar(IceCastBar.Actions.Channel)
|
|
end
|
|
|
|
function IceCastBar.prototype:SpellCastChannelUpdate(event, unit)
|
|
if (unit ~= self.unit or not self.actionStartTime) then return end
|
|
--IceHUD:Debug("SpellCastChannelUpdate", unit, UnitChannelInfo(unit))
|
|
|
|
local spell, rank, displayName, icon, startTime, endTime
|
|
if IceHUD.SpellFunctionsReturnRank then
|
|
spell, rank, displayName, icon, startTime, endTime = UnitChannelInfo(unit)
|
|
else
|
|
spell, displayName, icon, startTime, endTime = UnitChannelInfo(unit)
|
|
end
|
|
if not spell then
|
|
self.actionDuration = 0
|
|
else
|
|
self.actionDuration = endTime/1000 - self.actionStartTime
|
|
end
|
|
end
|
|
|
|
function IceCastBar.prototype:SpellCastChannelStop(event, unit)
|
|
if (unit ~= self.unit) then return end
|
|
--IceHUD:Debug("SpellCastChannelStop", unit)
|
|
|
|
self:StopBar()
|
|
end
|
|
|
|
|
|
|