You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3393 lines
120 KiB
3393 lines
120 KiB
|
|
--lua locals
|
|
local _cstr = string.format
|
|
local _math_floor = math.floor
|
|
local tinsert = table.insert
|
|
local ipairs = ipairs
|
|
local pairs = pairs
|
|
local min = math.min
|
|
local unpack = unpack
|
|
local type = type
|
|
|
|
--api locals
|
|
local _GetSpellInfo = Details.getspellinfo
|
|
local GameTooltip = GameTooltip
|
|
local IsInRaid = IsInRaid
|
|
local IsInGroup = IsInGroup
|
|
local GetNumGroupMembers = GetNumGroupMembers
|
|
local _UnitAura = UnitAura
|
|
local UnitGUID = UnitGUID
|
|
local _UnitName = UnitName
|
|
local format = _G.format
|
|
|
|
local UnitIsUnit = UnitIsUnit
|
|
|
|
local _string_replace = Details.string.replace --details api
|
|
|
|
local _detalhes = _G.Details
|
|
local Details = _detalhes
|
|
local AceLocale = LibStub("AceLocale-3.0")
|
|
local Loc = AceLocale:GetLocale ( "Details" )
|
|
local detailsFramework = DetailsFramework
|
|
local addonName, Details222 = ...
|
|
|
|
local gump = _detalhes.gump
|
|
local _
|
|
local container_habilidades = _detalhes.container_habilidades
|
|
local atributo_misc = _detalhes.atributo_misc
|
|
|
|
local container_misc = _detalhes.container_type.CONTAINER_MISC_CLASS
|
|
|
|
local modo_GROUP = _detalhes.modos.group
|
|
local modo_ALL = _detalhes.modos.all
|
|
|
|
local class_type = _detalhes.atributos.misc
|
|
|
|
local ToKFunctions = _detalhes.ToKFunctions
|
|
local UsingCustomLeftText = false
|
|
local UsingCustomRightText = false
|
|
|
|
local TooltipMaximizedMethod = 1
|
|
|
|
local breakdownWindowFrame = Details.BreakdownWindowFrame
|
|
local keyName
|
|
|
|
local headerColor = "yellow"
|
|
|
|
function _detalhes.SortIfHaveKey(table1, table2)
|
|
if (table1[keyName] and table2[keyName]) then
|
|
return table1[keyName] > table2[keyName]
|
|
|
|
elseif (table1[keyName] and not table2[keyName]) then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
function _detalhes.SortGroupIfHaveKey(table1, table2)
|
|
if (table1.grupo and table2.grupo) then
|
|
if (table1[keyName] and table2[keyName]) then
|
|
return table1[keyName] > table2[keyName]
|
|
|
|
elseif (table1[keyName] and not table2[keyName]) then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
|
|
elseif (table1.grupo and not table2.grupo) then
|
|
return true
|
|
|
|
elseif (not table1.grupo and table2.grupo) then
|
|
return false
|
|
|
|
else
|
|
if (table1[keyName] and table2[keyName]) then
|
|
return table1[keyName] > table2[keyName]
|
|
|
|
elseif (table1[keyName] and not table2[keyName]) then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
|
|
function _detalhes.SortGroupMisc(container, keyName2)
|
|
keyName = keyName2
|
|
return table.sort(container, _detalhes.SortKeyGroupMisc)
|
|
end
|
|
|
|
function _detalhes.SortKeyGroupMisc(table1, table2)
|
|
if (table1.grupo and table2.grupo) then
|
|
return table1[keyName] > table2[keyName]
|
|
|
|
elseif (table1.grupo and not table2.grupo) then
|
|
return true
|
|
elseif (not table1.grupo and table2.grupo) then
|
|
return false
|
|
|
|
else
|
|
return table1[keyName] > table2[keyName]
|
|
end
|
|
end
|
|
|
|
function _detalhes.SortKeySimpleMisc(table1, table2)
|
|
return table1[keyName] > table2[keyName]
|
|
end
|
|
|
|
function _detalhes:ContainerSortMisc(container, amount, keyName2)
|
|
keyName = keyName2
|
|
table.sort(container, _detalhes.SortKeySimpleMisc)
|
|
|
|
if (amount) then
|
|
for i = amount, 1, -1 do
|
|
if (container[i][keyName] < 1) then
|
|
amount = amount-1
|
|
else
|
|
break
|
|
end
|
|
end
|
|
|
|
return amount
|
|
end
|
|
end
|
|
|
|
---attempt to get the amount of casts of a spell
|
|
---@param combat table the combat object
|
|
---@param actorName string name of the actor
|
|
---@param spellName string
|
|
function Details:GetSpellCastAmount(combat, actorName, spellName) --[[exported]]
|
|
return combat:GetSpellCastAmount(actorName, spellName)
|
|
end
|
|
|
|
function atributo_misc:NovaTabela(serial, nome, link)
|
|
local newUtilityActor = {
|
|
last_event = 0,
|
|
tipo = class_type,
|
|
pets = {}
|
|
}
|
|
|
|
setmetatable(newUtilityActor, atributo_misc)
|
|
|
|
detailsFramework:Mixin(newUtilityActor, Details222.Mixins.ActorMixin)
|
|
|
|
return newUtilityActor
|
|
end
|
|
|
|
function atributo_misc:CreateBuffTargetObject()
|
|
return {
|
|
uptime = 0,
|
|
actived = false,
|
|
activedamt = 0,
|
|
refreshamt = 0,
|
|
appliedamt = 0,
|
|
}
|
|
end
|
|
|
|
local statusBarBackgroundTable_ForDeathTooltip = {
|
|
value = 100,
|
|
texture = [[Interface\AddOns\Details\images\bar_serenity]],
|
|
color = {DetailsFramework:GetDefaultBackdropColor()}
|
|
}
|
|
|
|
--expose in case someone want to customize the death tooltip background
|
|
Details.StatusBarBackgroundTable_ForDeathTooltip = statusBarBackgroundTable_ForDeathTooltip
|
|
|
|
function Details.ShowDeathTooltip(instance, lineFrame, combatObject, deathTable)
|
|
local events = deathTable[1]
|
|
local timeOfDeath = deathTable[2]
|
|
local maxHP = max(deathTable[5], 0.001)
|
|
local battleress = false
|
|
local lastcooldown = false
|
|
local gameCooltip = GameCooltip
|
|
|
|
local showSpark = Details.death_tooltip_spark
|
|
local barTypeColors = Details.death_log_colors
|
|
local statusbarTexture = Details.death_tooltip_texture
|
|
local tooltipWidth = Details.death_tooltip_width
|
|
|
|
local damageSourceColor = "FFFFFFFF" --FFC6B0D9
|
|
local healingSourceColor = "FF988EA0" --FFC6B0D9
|
|
|
|
local damageAmountColor = "FFFFFFFF"
|
|
local healingAmountColor = "FF988EA0"
|
|
|
|
local lineHeight = Details.deathlog_line_height
|
|
|
|
gameCooltip:Reset()
|
|
gameCooltip:SetType("tooltipbar")
|
|
|
|
gameCooltip:AddLine(Loc ["STRING_REPORT_LEFTCLICK"], nil, 1, unpack(Details.click_to_report_color))
|
|
gameCooltip:AddIcon([[Interface\TUTORIALFRAME\UI-TUTORIAL-FRAME]], 1, 1, 12, 16, 0.015625, 0.13671875, 0.4375, 0.59765625)
|
|
|
|
--death parser
|
|
for i, event in ipairs(events) do
|
|
local currentHP = event[5]
|
|
local healthPercent = floor(currentHP / maxHP * 100)
|
|
if (healthPercent > 100) then
|
|
healthPercent = 100
|
|
end
|
|
|
|
local evType = event[1]
|
|
local spellName, _, spellIcon = _GetSpellInfo(event[2])
|
|
local amount = event[3]
|
|
local eventTime = event[4]
|
|
local source = Details:GetOnlyName(event[6] or "")
|
|
|
|
if (eventTime + 12 > timeOfDeath) then
|
|
if (type(evType) == "boolean") then
|
|
--is damage or heal?
|
|
if (evType) then --bool true
|
|
--damage
|
|
local overkill = event[10] or 0
|
|
local critical = event[11] and (" " .. TEXT_MODE_A_STRING_RESULT_CRITICAL) or "" -- (Critical)
|
|
local crushing = event[12] and (" " .. TEXT_MODE_A_STRING_RESULT_CRUSHING) or "" -- (Crushing)
|
|
local critOrCrush = critical .. crushing
|
|
|
|
if (overkill > 0) then
|
|
--deprecated as the parser now removes the overkill damage from total damage
|
|
--this should now sum the overkill from [10] with the damage from [3]
|
|
--check the type of overkill that should be shown
|
|
--if show_totalhitdamage_on_overkill is true it'll show the total damage of the hit
|
|
--if false it shows the total damage of the hit minus the overkill
|
|
--if (not Details.show_totalhitdamage_on_overkill) then
|
|
-- amount = amount - overkill
|
|
--end
|
|
|
|
overkill = " (" .. Details:ToK(overkill) .. " |cFFFF8800overkill|r)"
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s |cFFFFFF00" .. spellName .. "|r (|c" .. damageSourceColor .. source .. "|r)", "|c" .. damageAmountColor .. "-" .. Details:ToK(amount) .. critOrCrush .. overkill .. " (" .. healthPercent .. "%)", 1, "white", "white")
|
|
else
|
|
overkill = ""
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s " .. spellName .. " (|c" .. damageSourceColor .. source .. "|r)", "|c" .. damageAmountColor .. "-" .. Details:ToK(amount) .. critOrCrush .. overkill .. " (" .. healthPercent .. "%)", 1, "white", "white")
|
|
end
|
|
|
|
gameCooltip:AddIcon(spellIcon, nil, nil, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
|
|
if (event[9]) then
|
|
--friendly fire
|
|
gameCooltip:AddStatusBar(healthPercent, 1, barTypeColors.friendlyfire, showSpark, statusBarBackgroundTable_ForDeathTooltip)
|
|
else
|
|
--from a enemy
|
|
gameCooltip:AddStatusBar(healthPercent, 1, barTypeColors.damage, showSpark, statusBarBackgroundTable_ForDeathTooltip)
|
|
end
|
|
else
|
|
--heal
|
|
if (amount > Details.deathlog_healingdone_min) then
|
|
if (combatObject.is_arena) then
|
|
if (amount > Details.deathlog_healingdone_min_arena) then
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s " .. spellName .. " (|c" .. healingSourceColor .. source .. "|r)", "|c" .. healingAmountColor .. "+" .. Details:ToK(amount) .. " (" .. healthPercent .. "%)", 1, "white", "white")
|
|
gameCooltip:AddIcon(spellIcon, nil, nil, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
gameCooltip:AddStatusBar(healthPercent, 1, barTypeColors.heal, showSpark, statusBarBackgroundTable_ForDeathTooltip)
|
|
end
|
|
else
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s " .. spellName .. " (|c" .. healingSourceColor .. source .. "|r)", (event[11] and ("x" .. event[11] .. " ") or "") .. "|c" .. healingAmountColor .. "+" .. Details:ToK(amount) .. " (" .. healthPercent .. "%)", 1, "white", "white")
|
|
gameCooltip:AddIcon(spellIcon, nil, nil, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
gameCooltip:AddStatusBar(healthPercent, 1, barTypeColors.heal, showSpark, statusBarBackgroundTable_ForDeathTooltip)
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif (type(evType) == "number") then
|
|
if (evType == 1) then
|
|
--cooldown
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s " .. spellName .. " (" .. source .. ")", "cooldown (" .. healthPercent .. "%)", 1, "white", "white")
|
|
gameCooltip:AddIcon(spellIcon, nil, nil, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
gameCooltip:AddStatusBar(100, 1, barTypeColors.cooldown, showSpark)
|
|
|
|
elseif (evType == 2 and not battleress) then
|
|
--battle ress
|
|
battleress = event
|
|
|
|
elseif (evType == 3) then
|
|
--last cooldown used
|
|
lastcooldown = event
|
|
|
|
elseif (evType == 4) then
|
|
--debuff
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s " .. spellName .. " (" .. source .. ")", "x" .. amount .. " " .. AURA_TYPE_DEBUFF .. " (" .. healthPercent .. "%)", 1, "white", "white")
|
|
gameCooltip:AddIcon(spellIcon, nil, nil, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
gameCooltip:AddStatusBar(100, 1, barTypeColors.debuff, showSpark)
|
|
|
|
elseif (evType == 5) then
|
|
--buff
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s " .. spellName .. " (" .. source .. ")", "x" .. amount .. " " .. AURA_TYPE_BUFF .. " (" .. healthPercent .. "%)", 1, "white", "white")
|
|
gameCooltip:AddIcon(spellIcon, nil, nil, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
gameCooltip:AddStatusBar(100, 1, barTypeColors.buff, showSpark)
|
|
|
|
elseif (evType == 6) then
|
|
--enemy cast
|
|
gameCooltip:AddLine("" .. format("%.1f", eventTime - timeOfDeath) .. "s " .. spellName .. " (" .. source .. ")", "x" .. amount .. "", 1, "white", "white")
|
|
gameCooltip:AddIcon(spellIcon, nil, nil, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
local r, g, b, a = DetailsFramework:ParseColors("honeydew")
|
|
gameCooltip:AddStatusBar(100, 1, {r, g, b, 0.6}, showSpark)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
gameCooltip:AddLine(deathTable[6] .. " " .. Loc["STRING_TIME_OF_DEATH"] , "-- -- -- ", 1, "white")
|
|
gameCooltip:AddIcon("Interface\\AddOns\\Details\\images\\small_icons", 1, 1, nil, nil, .75, 1, 0, 1)
|
|
gameCooltip:AddStatusBar(0, 1, .5, .5, .5, .5, false, {value = 100, color = {.5, .5, .5, 1}, specialSpark = false, texture = [[Interface\AddOns\Details\images\bar4_vidro]]})
|
|
|
|
if (battleress) then
|
|
local spellName, _, spellIcon = _GetSpellInfo(battleress[2])
|
|
gameCooltip:AddLine("+" .. format("%.1f", battleress[4] - timeOfDeath) .. "s " .. spellName .. " (" .. battleress[6] .. ")", "", 1, "white")
|
|
gameCooltip:AddIcon("Interface\\Glues\\CharacterSelect\\Glues-AddOn-Icons", 1, 1, lineHeight, lineHeight, .75, 1, 0, 1)
|
|
gameCooltip:AddStatusBar(0, 1, .5, .5, .5, .5, false, {value = 100, color = {.5, .5, .5, 1}, specialSpark = false, texture = [[Interface\AddOns\Details\images\bar4_vidro]]})
|
|
end
|
|
|
|
if (lastcooldown) then
|
|
if (lastcooldown[3] == 1) then
|
|
local spellName, _, spellIcon = _GetSpellInfo(lastcooldown[2])
|
|
gameCooltip:AddLine(format("%.1f", lastcooldown[4] - timeOfDeath) .. "s " .. spellName .. " (" .. Loc ["STRING_LAST_COOLDOWN"] .. ")")
|
|
gameCooltip:AddIcon(spellIcon, 1, 1, lineHeight, lineHeight, .1, .9, .1, .9)
|
|
else
|
|
gameCooltip:AddLine(Loc ["STRING_NOLAST_COOLDOWN"])
|
|
gameCooltip:AddIcon([[Interface\CHARACTERFRAME\UI-Player-PlayTimeUnhealthy]], 1, 1, 18, 18)
|
|
end
|
|
|
|
gameCooltip:AddStatusBar(0, 1, 1, 1, 1, 1, false, {value = 100, color = {.3, .3, .3, 1}, specialSpark = false, texture = [[Interface\AddOns\Details\images\bar_serenity]]})
|
|
end
|
|
|
|
--set the font and size of the text as defined in the options panel
|
|
gameCooltip:SetOption("TextSize", Details.tooltip.fontsize)
|
|
gameCooltip:SetOption("TextFont", Details.tooltip.fontface)
|
|
|
|
--move the left and right texts more close to the tooltip border
|
|
gameCooltip:SetOption("LeftPadding", -4)
|
|
gameCooltip:SetOption("RightPadding", 7)
|
|
|
|
--space between each line, positive values make the lines be closer
|
|
gameCooltip:SetOption("LinePadding", -2)
|
|
|
|
--move each line in the Y axis (vertical offsett)
|
|
gameCooltip:SetOption("LineYOffset", 0)
|
|
|
|
--tooltip width
|
|
gameCooltip:SetOption("FixedWidth", (type(tooltipWidth) == "number" and tooltipWidth) or 300)
|
|
|
|
--progress bar texture
|
|
gameCooltip:SetOption("StatusBarTexture", statusbarTexture)
|
|
|
|
return true
|
|
end
|
|
|
|
function Details:ToolTipDead(instance, deathTable, barFrame)
|
|
local gameCooltip = GameCooltip
|
|
|
|
local builtTooltip = Details.ShowDeathTooltipFunction(instance, barFrame, instance:GetShowingCombat(), deathTable)
|
|
if (builtTooltip) then
|
|
local myPoint = Details.tooltip.anchor_point
|
|
local anchorPoint = Details.tooltip.anchor_relative
|
|
local xOffset = Details.tooltip.anchor_offset[1]
|
|
local yOffset = Details.tooltip.anchor_offset[2]
|
|
|
|
if (Details.tooltip.anchored_to == 1) then
|
|
gameCooltip:SetHost(barFrame, myPoint, anchorPoint, xOffset, yOffset)
|
|
else
|
|
gameCooltip:SetHost(DetailsTooltipAnchor, myPoint, anchorPoint, xOffset, yOffset)
|
|
end
|
|
|
|
gameCooltip:ShowCooltip()
|
|
end
|
|
end
|
|
|
|
local function RefreshBarraMorte (morte, barra, instancia)
|
|
atributo_misc:UpdateDeathRow (morte, morte.minha_barra, barra.colocacao, instancia)
|
|
end
|
|
|
|
--object death:
|
|
--[1] tabela [2] time [3] nome [4] classe [5] maxhealth [6] time of death
|
|
--[1] true damage/ false heal [2] spellid [3] amount [4] time [5] current health [6] source
|
|
|
|
local report_table = {}
|
|
local ReportSingleDeathFunc = function(IsCurrent, IsReverse, AmtLines)
|
|
AmtLines = AmtLines + 1
|
|
|
|
local t = {}
|
|
for i = 1, min (#report_table, AmtLines) do
|
|
local table = report_table [i]
|
|
t [#t+1] = table [1] .. table [4] .. table [2] .. table [3]
|
|
end
|
|
|
|
local title = tremove(t, 1)
|
|
t = _detalhes.table.reverse (t)
|
|
tinsert(t, 1, title)
|
|
|
|
_detalhes:SendReportLines (t)
|
|
end
|
|
|
|
function atributo_misc:ReportSingleDeadLine (morte, instancia)
|
|
local barra = instancia.barras [morte.minha_barra]
|
|
|
|
local max_health = morte [5]
|
|
local time_of_death = morte [2]
|
|
|
|
do
|
|
if (not _detalhes.fontstring_len) then
|
|
_detalhes.fontstring_len = _detalhes.listener:CreateFontString(nil, "background", "GameFontNormal")
|
|
end
|
|
local _, fontSize = FCF_GetChatWindowInfo (1)
|
|
if (fontSize < 1) then
|
|
fontSize = 10
|
|
end
|
|
local fonte, _, flags = _detalhes.fontstring_len:GetFont()
|
|
_detalhes.fontstring_len:SetFont(fonte, fontSize, flags)
|
|
_detalhes.fontstring_len:SetText("thisisspacement")
|
|
end
|
|
local default_len = _detalhes.fontstring_len:GetStringWidth()
|
|
|
|
Details:Destroy(report_table)
|
|
local report_array = report_table
|
|
report_array[1] = {"Details! " .. Loc ["STRING_REPORT_SINGLE_DEATH"] .. " " .. morte [3] .. " " .. Loc ["STRING_ACTORFRAME_REPORTAT"] .. " " .. morte [6], "", "", ""}
|
|
|
|
for index, evento in ipairs(_detalhes.table.reverse (morte [1])) do
|
|
if (evento [1] and type(evento [1]) == "boolean") then --damage
|
|
if (evento [3]) then
|
|
local elapsed = _cstr ("%.1f", evento [4] - time_of_death) .."s"
|
|
local spellname, _, spellicon = _GetSpellInfo(evento [2])
|
|
local spelllink
|
|
|
|
if (evento [2] == 1) then
|
|
spelllink = GetSpellLink(6603)
|
|
elseif (evento [2] > 10) then
|
|
spelllink = GetSpellLink(evento [2])
|
|
else
|
|
spelllink = spellname
|
|
end
|
|
|
|
local source = _detalhes:GetOnlyName(evento [6])
|
|
local amount = evento [3]
|
|
local hp = _math_floor(evento [5] / max_health * 100)
|
|
if (hp > 100) then
|
|
hp = 100
|
|
end
|
|
|
|
tinsert(report_array, {elapsed .. " ", spelllink, " (" .. source .. ")", "-" .. _detalhes:ToK (amount) .. " (" .. hp .. "%) "})
|
|
end
|
|
|
|
elseif (not evento [1] and type(evento [1]) == "boolean") then --heal
|
|
|
|
local amount = evento [3]
|
|
|
|
if (amount > _detalhes.deathlog_healingdone_min) then
|
|
local elapsed = _cstr ("%.1f", evento [4] - time_of_death) .."s"
|
|
local spelllink = GetSpellLink(evento [2])
|
|
local source = _detalhes:GetOnlyName(evento [6])
|
|
local spellname, _, spellicon = _GetSpellInfo(evento [2])
|
|
|
|
local hp = _math_floor(evento [5] / max_health * 100)
|
|
if (hp > 100) then
|
|
hp = 100
|
|
end
|
|
|
|
if (_detalhes.report_heal_links) then
|
|
tinsert(report_array, {elapsed .. " ", spelllink, " (" .. source .. ")", "+" .. _detalhes:ToK (amount) .. " (" .. hp .. "%) "})
|
|
else
|
|
tinsert(report_array, {elapsed .. " ", spellname, " (" .. source .. ")", "+" .. _detalhes:ToK (amount) .. " (" .. hp .. "%) "})
|
|
end
|
|
end
|
|
|
|
elseif (type(evento [1]) == "number" and evento [1] == 4) then --debuff
|
|
|
|
local elapsed = _cstr ("%.1f", evento [4] - time_of_death) .."s"
|
|
local spelllink = GetSpellLink(evento [2])
|
|
local source = _detalhes:GetOnlyName(evento [6])
|
|
local spellname, _, spellicon = _GetSpellInfo(evento [2])
|
|
local stacks = evento [3]
|
|
local hp = _math_floor(evento [5] / max_health * 100)
|
|
if (hp > 100) then
|
|
hp = 100
|
|
end
|
|
|
|
tinsert(report_array, {elapsed .. " ", "x" .. stacks .. "" .. spelllink, " (" .. source .. ")", "(" .. hp .. "%) "})
|
|
end
|
|
end
|
|
|
|
_detalhes:SendReportWindow (ReportSingleDeathFunc, nil, nil, true)
|
|
end
|
|
|
|
function atributo_misc:ReportSingleCooldownLine (misc_actor, instancia)
|
|
local reportar
|
|
|
|
if (instancia.segmento == -1) then --overall
|
|
reportar = {"Details!: " .. misc_actor.nome .. " - " .. Loc ["STRING_OVERALL"] .. " " .. Loc ["STRING_ATTRIBUTE_MISC_DEFENSIVE_COOLDOWNS"]}
|
|
else
|
|
reportar = {"Details!: " .. misc_actor.nome .. " - " .. Loc ["STRING_ATTRIBUTE_MISC_DEFENSIVE_COOLDOWNS"]}
|
|
end
|
|
|
|
local meu_total = _math_floor(misc_actor.cooldowns_defensive)
|
|
local cooldowns = misc_actor.cooldowns_defensive_spells._ActorTable
|
|
local cooldowns_used = {}
|
|
|
|
for spellid, spell in pairs(cooldowns) do
|
|
cooldowns_used [#cooldowns_used+1] = {spellid, spell.counter, spell}
|
|
end
|
|
table.sort (cooldowns_used, _detalhes.Sort2)
|
|
|
|
for i, spell in ipairs(cooldowns_used) do
|
|
|
|
local spelllink = GetSpellLink(spell [1])
|
|
reportar [#reportar+1] = spelllink .. ": " .. spell [2]
|
|
|
|
for target_name, amount in pairs(spell[3].targets) do
|
|
if (target_name ~= misc_actor.nome and target_name ~= Loc ["STRING_RAID_WIDE"] and amount > 0) then
|
|
reportar [#reportar+1] = " -" .. target_name .. ": " .. amount
|
|
end
|
|
end
|
|
|
|
end
|
|
return _detalhes:Reportar (reportar, {_no_current = true, _no_inverse = true, _custom = true})
|
|
end
|
|
|
|
local buff_format_name = function(spellid)
|
|
if (type(spellid) == "string") then
|
|
return spellid
|
|
end
|
|
return _detalhes:GetSpellLink(spellid)
|
|
end
|
|
|
|
local buff_format_amount = function(t)
|
|
local total, percent = unpack(t)
|
|
local m, s = _math_floor(total / 60), _math_floor(total % 60)
|
|
return _cstr ("%.1f", percent) .. "% (" .. m .. "m " .. s .. "s)"
|
|
end
|
|
|
|
local sort_buff_report = function(t1, t2)
|
|
return t1[2][1] > t2[2][1]
|
|
end
|
|
|
|
function atributo_misc:ReportSingleBuffUptimeLine (misc_actor, instance)
|
|
local report_table = {"Details!: " .. misc_actor.nome .. " - " .. Loc ["STRING_ATTRIBUTE_MISC_BUFF_UPTIME"]}
|
|
|
|
local buffs = {}
|
|
local combat_time = instance.showing:GetCombatTime()
|
|
|
|
for spellid, spell in pairs(misc_actor.buff_uptime_spells._ActorTable) do
|
|
local percent = spell.uptime / combat_time * 100
|
|
if (percent < 99.5) then
|
|
buffs [#buffs+1] = {spellid, {spell.uptime, percent}}
|
|
end
|
|
end
|
|
|
|
table.sort (buffs, sort_buff_report)
|
|
_detalhes:FormatReportLines (report_table, buffs, buff_format_name, buff_format_amount)
|
|
return _detalhes:Reportar (report_table, {_no_current = true, _no_inverse = true, _custom = true})
|
|
end
|
|
|
|
function atributo_misc:ReportSingleDebuffUptimeLine (misc_actor, instance)
|
|
local report_table = {"Details!: " .. misc_actor.nome .. " - " .. Loc ["STRING_ATTRIBUTE_MISC_DEBUFF_UPTIME"]}
|
|
|
|
local debuffs = {}
|
|
local combat_time = instance.showing:GetCombatTime()
|
|
|
|
for spellid, spell in pairs(misc_actor.debuff_uptime_spells._ActorTable) do
|
|
local percent = spell.uptime / combat_time * 100
|
|
debuffs [#debuffs+1] = {spellid, {spell.uptime, percent}}
|
|
end
|
|
|
|
table.sort (debuffs, sort_buff_report)
|
|
_detalhes:FormatReportLines (report_table, debuffs, buff_format_name, buff_format_amount)
|
|
|
|
return _detalhes:Reportar (report_table, {_no_current = true, _no_inverse = true, _custom = true})
|
|
end
|
|
|
|
---update a row in an instance (window) showing death logs
|
|
---@param morte table
|
|
---@param whichRowLine number
|
|
---@param rankPosition number
|
|
---@param instance table
|
|
function atributo_misc:UpdateDeathRow(morte, whichRowLine, rankPosition, instance) --todo: change this function name
|
|
morte["dead"] = true
|
|
local thisRow = instance.barras[whichRowLine]
|
|
|
|
if (not thisRow) then
|
|
print("DEBUG: problema com <instancia.esta_barra> "..whichRowLine.." "..rankPosition)
|
|
return
|
|
end
|
|
|
|
thisRow.minha_tabela = morte
|
|
|
|
morte.nome = morte[3] --void an issue while resizing the window
|
|
morte.minha_barra = whichRowLine
|
|
thisRow.colocacao = rankPosition
|
|
|
|
if (not getmetatable(morte)) then
|
|
setmetatable(morte, {__call = RefreshBarraMorte})
|
|
morte._custom = true
|
|
end
|
|
|
|
thisRow.lineText1:SetText(rankPosition .. ". " .. morte[3]:gsub(("%-.*"), ""))
|
|
thisRow.lineText2:SetText("")
|
|
thisRow.lineText3:SetText("")
|
|
thisRow.lineText4:SetText(morte[6])
|
|
|
|
thisRow:SetValue(100)
|
|
if (thisRow.hidden or thisRow.fading_in or thisRow.faded) then
|
|
Details.FadeHandler.Fader(thisRow, "out")
|
|
end
|
|
|
|
--seta a cor da barra e a cor do texto caso eles esteja mostrando com a cor da classe
|
|
local r, g, b, a = unpack(_detalhes.class_colors[morte[4]])
|
|
_detalhes:SetBarColors(thisRow, instance, r, g, b, a)
|
|
|
|
if (instance.row_info.use_spec_icons) then
|
|
local nome = morte[3]
|
|
local spec = instance.showing (1, nome) and instance.showing (1, nome).spec or (instance.showing (2, nome) and instance.showing (2, nome).spec)
|
|
if (spec and spec ~= 0) then
|
|
thisRow.icone_classe:SetTexture(instance.row_info.spec_file)
|
|
thisRow.icone_classe:SetTexCoord(unpack(_detalhes.class_specs_coords[spec]))
|
|
else
|
|
if (CLASS_ICON_TCOORDS [morte[4]]) then
|
|
thisRow.icone_classe:SetTexture(instance.row_info.icon_file)
|
|
thisRow.icone_classe:SetTexCoord(unpack(CLASS_ICON_TCOORDS [morte[4]]))
|
|
else
|
|
local texture, l, r, t, b = Details:GetUnknownClassIcon()
|
|
thisRow.icone_classe:SetTexture(texture)
|
|
thisRow.icone_classe:SetTexCoord(l, r, t, b)
|
|
end
|
|
end
|
|
else
|
|
if (CLASS_ICON_TCOORDS [morte[4]]) then
|
|
thisRow.icone_classe:SetTexture(instance.row_info.icon_file)
|
|
thisRow.icone_classe:SetTexCoord(unpack(CLASS_ICON_TCOORDS [morte[4]]))
|
|
else
|
|
local texture, l, r, t, b = Details:GetUnknownClassIcon()
|
|
thisRow.icone_classe:SetTexture(texture)
|
|
thisRow.icone_classe:SetTexCoord(l, r, t, b)
|
|
end
|
|
end
|
|
|
|
thisRow.icone_classe:SetVertexColor(1, 1, 1)
|
|
|
|
if (thisRow.mouse_over and not instance.baseframe.isMoving) then --precisa atualizar o tooltip
|
|
gump:UpdateTooltip (whichRowLine, thisRow, instance)
|
|
end
|
|
|
|
thisRow.lineText1:SetSize(thisRow:GetWidth() - thisRow.lineText4:GetStringWidth() - 20, 15)
|
|
end
|
|
|
|
function atributo_misc:RefreshWindow(instance, combatObject, bIsForceRefresh, bIsExport)
|
|
---@type actorcontainer
|
|
local utilityActorContainer = combatObject[class_type]
|
|
|
|
if (#utilityActorContainer._ActorTable < 1) then --n�o h� barras para mostrar
|
|
return _detalhes:HideBarsNotInUse(instance, utilityActorContainer), "", 0, 0
|
|
end
|
|
|
|
local total = 0
|
|
instance.top = 0
|
|
|
|
--the main attribute is utility, the sub attribute is the type of utility (cc break, ress, etc)
|
|
local subAttribute = instance.sub_atributo
|
|
local conteudo = utilityActorContainer._ActorTable
|
|
local amount = #conteudo
|
|
local modo = instance.modo
|
|
|
|
if (bIsExport) then
|
|
if (type(bIsExport) == "boolean") then
|
|
if (subAttribute == 1) then --CC BREAKS
|
|
keyName = "cc_break"
|
|
elseif (subAttribute == 2) then --RESS
|
|
keyName = "ress"
|
|
elseif (subAttribute == 3) then --INTERRUPT
|
|
keyName = "interrupt"
|
|
elseif (subAttribute == 4) then --DISPELLS
|
|
keyName = "dispell"
|
|
elseif (subAttribute == 5) then --DEATHS
|
|
keyName = "dead"
|
|
elseif (subAttribute == 6) then --DEFENSIVE COOLDOWNS
|
|
keyName = "cooldowns_defensive"
|
|
elseif (subAttribute == 7) then --BUFF UPTIME
|
|
keyName = "buff_uptime"
|
|
elseif (subAttribute == 8) then --DEBUFF UPTIME
|
|
keyName = "debuff_uptime"
|
|
end
|
|
else
|
|
keyName = bIsExport.key
|
|
modo = bIsExport.modo
|
|
end
|
|
|
|
elseif (instance.atributo == 5) then --custom
|
|
keyName = "custom"
|
|
total = combatObject.totals [instance.customName]
|
|
|
|
else
|
|
|
|
--pega qual a sub key que ser� usada
|
|
if (subAttribute == 1) then --CC BREAKS
|
|
keyName = "cc_break"
|
|
elseif (subAttribute == 2) then --RESS
|
|
keyName = "ress"
|
|
elseif (subAttribute == 3) then --INTERRUPT
|
|
keyName = "interrupt"
|
|
elseif (subAttribute == 4) then --DISPELLS
|
|
keyName = "dispell"
|
|
elseif (subAttribute == 5) then --DEATHS
|
|
keyName = "dead"
|
|
elseif (subAttribute == 6) then --DEFENSIVE COOLDOWNS
|
|
keyName = "cooldowns_defensive"
|
|
elseif (subAttribute == 7) then --BUFF UPTIME
|
|
keyName = "buff_uptime"
|
|
elseif (subAttribute == 8) then --DEBUFF UPTIME
|
|
keyName = "debuff_uptime"
|
|
end
|
|
end
|
|
|
|
if (keyName == "dead") then
|
|
local allDeathsInTheCombat = combatObject.last_events_tables
|
|
instance.top = 1
|
|
total = #allDeathsInTheCombat
|
|
|
|
if (bIsExport) then
|
|
return allDeathsInTheCombat
|
|
end
|
|
|
|
if (total < 1) then
|
|
instance:EsconderScrollBar()
|
|
return _detalhes:EndRefresh(instance, total, combatObject, utilityActorContainer)
|
|
end
|
|
|
|
instance:RefreshScrollBar(total)
|
|
|
|
local whichRowLine = 1
|
|
|
|
local bIsRaidCombat = combatObject:GetCombatType() == DETAILS_SEGMENTTYPE_RAID_BOSS
|
|
local bIsMythicDungeonOverall = combatObject:IsMythicDungeonOverall()
|
|
local bIsOverallData = instance:GetSegmentId() == DETAILS_SEGMENTID_OVERALL
|
|
|
|
local bReverseDeathLog = false
|
|
if (bIsRaidCombat and Details.combat_log.inverse_deathlog_raid) then
|
|
bReverseDeathLog = true
|
|
|
|
elseif (bIsMythicDungeonOverall and Details.combat_log.inverse_deathlog_mplus) then
|
|
bReverseDeathLog = true
|
|
|
|
elseif (bIsOverallData and Details.combat_log.inverse_deathlog_overalldata) then
|
|
bReverseDeathLog = true
|
|
end
|
|
|
|
if (bReverseDeathLog) then
|
|
--reverse the table
|
|
local tempTable = {}
|
|
for i = #allDeathsInTheCombat, 1, -1 do
|
|
tempTable[#tempTable+1] = allDeathsInTheCombat[i]
|
|
end
|
|
|
|
--update only the lines shown
|
|
for i = instance.barraS[1], instance.barraS[2], 1 do
|
|
if (tempTable[i]) then
|
|
atributo_misc:UpdateDeathRow(tempTable[i], whichRowLine, i, instance)
|
|
whichRowLine = whichRowLine+1
|
|
end
|
|
end
|
|
else
|
|
--update only the lines shown
|
|
for i = instance.barraS[1], instance.barraS[2], 1 do
|
|
if (allDeathsInTheCombat[i]) then
|
|
atributo_misc:UpdateDeathRow(allDeathsInTheCombat[i], whichRowLine, i, instance)
|
|
whichRowLine = whichRowLine+1
|
|
end
|
|
end
|
|
end
|
|
|
|
return _detalhes:EndRefresh(instance, total, combatObject, utilityActorContainer)
|
|
else
|
|
if (instance.atributo == 5) then --custom
|
|
table.sort(conteudo, Details.SortIfHaveKey)
|
|
|
|
--strip results with zero
|
|
for i = amount, 1, -1 do
|
|
if (not conteudo[i][keyName] or conteudo[i][keyName] < 1) then
|
|
amount = amount - 1
|
|
else
|
|
break
|
|
end
|
|
end
|
|
|
|
--get the total done from the combat total data
|
|
total = combatObject.totals[class_type][keyName]
|
|
instance.top = conteudo[1][keyName]
|
|
|
|
elseif (modo == modo_ALL) then --mostrando ALL
|
|
table.sort(conteudo, Details.SortIfHaveKey)
|
|
|
|
--strip results with zero
|
|
for i = amount, 1, -1 do
|
|
if (not conteudo[i][keyName] or conteudo[i][keyName] < 1) then
|
|
amount = amount - 1
|
|
else
|
|
break
|
|
end
|
|
end
|
|
|
|
--get the total done from the combat total data
|
|
total = combatObject.totals[class_type][keyName]
|
|
instance.top = conteudo[1][keyName]
|
|
|
|
elseif (modo == modo_GROUP) then
|
|
table.sort(conteudo, Details.SortGroupIfHaveKey)
|
|
|
|
for index, player in ipairs(conteudo) do
|
|
if (player.grupo) then --is a player and is in the player group
|
|
--stop when the amount is zero
|
|
if (not player[keyName] or player[keyName] < 1) then
|
|
amount = index - 1
|
|
break
|
|
elseif (index == 1) then --esse IF aqui, precisa mesmo ser aqui? n�o daria pra pega-lo com uma chave [1] nad grupo == true?
|
|
instance.top = conteudo[1][keyName]
|
|
end
|
|
|
|
total = total + player[keyName]
|
|
else
|
|
amount = index-1
|
|
break
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
--refresh the container map
|
|
utilityActorContainer:remapear()
|
|
|
|
if (bIsExport) then
|
|
return total, keyName, instance.top, amount
|
|
end
|
|
|
|
--check if there's nothing to show
|
|
if (amount < 1) then
|
|
instance:EsconderScrollBar() --precisaria esconder a scroll bar
|
|
return Details:EndRefresh(instance, total, combatObject, utilityActorContainer)
|
|
end
|
|
|
|
instance:RefreshScrollBar(amount)
|
|
|
|
local whichRowLine = 1
|
|
local barras_container = instance.barras
|
|
local percentage_type = instance.row_info.percent_type
|
|
local bars_show_data = instance.row_info.textR_show_data
|
|
local bars_brackets = instance:GetBarBracket()
|
|
local bars_separator = instance:GetBarSeparator()
|
|
local bUseAnimations = _detalhes.is_using_row_animations and (not instance.baseframe.isStretching and not bIsForceRefresh)
|
|
|
|
if (total == 0) then
|
|
total = 0.00000001
|
|
end
|
|
|
|
UsingCustomLeftText = instance.row_info.textL_enable_custom_text
|
|
UsingCustomRightText = instance.row_info.textR_enable_custom_text
|
|
|
|
if (instance.bars_sort_direction == 1) then --top to bottom
|
|
for i = instance.barraS[1], instance.barraS[2], 1 do --vai atualizar s� o range que esta sendo mostrado
|
|
conteudo[i]:RefreshLine(instance, barras_container, whichRowLine, i, total, subAttribute, bIsForceRefresh, keyName, nil, percentage_type, bUseAnimations, bars_show_data, bars_brackets, bars_separator)
|
|
whichRowLine = whichRowLine+1
|
|
end
|
|
|
|
elseif (instance.bars_sort_direction == 2) then --bottom to top
|
|
for i = instance.barraS[2], instance.barraS[1], -1 do --vai atualizar s� o range que esta sendo mostrado
|
|
if (conteudo[i]) then
|
|
conteudo[i]:RefreshLine(instance, barras_container, whichRowLine, i, total, subAttribute, bIsForceRefresh, keyName, nil, percentage_type, bUseAnimations, bars_show_data, bars_brackets, bars_separator)
|
|
whichRowLine = whichRowLine+1
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
if (bUseAnimations) then
|
|
instance:PerformAnimations(whichRowLine-1)
|
|
end
|
|
|
|
if (instance.atributo == 5) then --custom
|
|
--zerar o .custom dos_ Actors
|
|
for index, player in ipairs(conteudo) do
|
|
if (player.custom > 0) then
|
|
player.custom = 0
|
|
else
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
--beta, hidar barras n�o usadas durante um refresh for�ado
|
|
if (bIsForceRefresh) then
|
|
if (instance.modo == 2) then --group
|
|
for i = whichRowLine, instance.rows_fit_in_window do
|
|
Details.FadeHandler.Fader(instance.barras [i], "in", Details.fade_speed)
|
|
end
|
|
end
|
|
end
|
|
|
|
return _detalhes:EndRefresh (instance, total, combatObject, utilityActorContainer) --retorna a tabela que precisa ganhar o refresh
|
|
|
|
end
|
|
|
|
local actor_class_color_r, actor_class_color_g, actor_class_color_b
|
|
|
|
function atributo_misc:RefreshLine(instancia, barras_container, whichRowLine, lugar, total, sub_atributo, forcar, keyName, is_dead, percentage_type, use_animations, bars_show_data, bars_brackets, bars_separator)
|
|
|
|
local esta_barra = instancia.barras[whichRowLine] --pega a refer�ncia da barra na janela
|
|
|
|
if (not esta_barra) then
|
|
print("DEBUG: problema com <instancia.esta_barra> "..whichRowLine.." "..lugar)
|
|
return
|
|
end
|
|
|
|
local tabela_anterior = esta_barra.minha_tabela
|
|
|
|
esta_barra.minha_tabela = self
|
|
esta_barra.colocacao = lugar
|
|
|
|
self.minha_barra = esta_barra
|
|
self.colocacao = lugar
|
|
|
|
local meu_total = _math_floor(self [keyName] or 0) --total
|
|
if (not meu_total) then
|
|
return
|
|
end
|
|
|
|
--local porcentagem = meu_total / total * 100
|
|
local porcentagem = ""
|
|
if (not percentage_type or percentage_type == 1) then
|
|
porcentagem = _cstr ("%.1f", meu_total / total * 100)
|
|
elseif (percentage_type == 2) then
|
|
porcentagem = _cstr ("%.1f", meu_total / instancia.top * 100)
|
|
end
|
|
|
|
local esta_porcentagem = _math_floor((meu_total/instancia.top) * 100)
|
|
|
|
if (not bars_show_data [1]) then
|
|
meu_total = ""
|
|
end
|
|
if (not bars_show_data [3]) then
|
|
porcentagem = ""
|
|
else
|
|
porcentagem = porcentagem .. "%"
|
|
end
|
|
|
|
local rightText = meu_total .. bars_brackets[1] .. porcentagem .. bars_brackets[2]
|
|
if (UsingCustomRightText) then
|
|
esta_barra.lineText4:SetText(_string_replace (instancia.row_info.textR_custom_text, meu_total, "", porcentagem, self, instancia.showing, instancia, rightText))
|
|
else
|
|
if (instancia.use_multi_fontstrings) then
|
|
instancia:SetInLineTexts(esta_barra, "", meu_total, porcentagem)
|
|
else
|
|
esta_barra.lineText4:SetText(rightText)
|
|
end
|
|
end
|
|
|
|
if (esta_barra.mouse_over and not instancia.baseframe.isMoving) then --precisa atualizar o tooltip
|
|
gump:UpdateTooltip (whichRowLine, esta_barra, instancia)
|
|
end
|
|
|
|
actor_class_color_r, actor_class_color_g, actor_class_color_b = self:GetBarColor()
|
|
|
|
return self:RefreshBarra2 (esta_barra, instancia, tabela_anterior, forcar, esta_porcentagem, whichRowLine, barras_container, use_animations)
|
|
end
|
|
|
|
function atributo_misc:RefreshBarra2 (esta_barra, instancia, tabela_anterior, forcar, esta_porcentagem, whichRowLine, barras_container, use_animations)
|
|
|
|
--primeiro colocado
|
|
if (esta_barra.colocacao == 1) then
|
|
if (not tabela_anterior or tabela_anterior ~= esta_barra.minha_tabela or forcar) then
|
|
esta_barra:SetValue(100)
|
|
|
|
if (esta_barra.hidden or esta_barra.fading_in or esta_barra.faded) then
|
|
Details.FadeHandler.Fader(esta_barra, "out")
|
|
end
|
|
|
|
return self:RefreshBarra(esta_barra, instancia)
|
|
else
|
|
return
|
|
end
|
|
else
|
|
|
|
if (esta_barra.hidden or esta_barra.fading_in or esta_barra.faded) then
|
|
|
|
if (use_animations) then
|
|
esta_barra.animacao_fim = esta_porcentagem
|
|
else
|
|
esta_barra:SetValue(esta_porcentagem)
|
|
esta_barra.animacao_ignorar = true
|
|
end
|
|
|
|
Details.FadeHandler.Fader(esta_barra, "out")
|
|
|
|
if (instancia.row_info.texture_class_colors) then
|
|
esta_barra.textura:SetVertexColor(actor_class_color_r, actor_class_color_g, actor_class_color_b)
|
|
end
|
|
if (instancia.row_info.texture_background_class_color) then
|
|
esta_barra.background:SetVertexColor(actor_class_color_r, actor_class_color_g, actor_class_color_b)
|
|
end
|
|
|
|
return self:RefreshBarra(esta_barra, instancia)
|
|
|
|
else
|
|
--agora esta comparando se a tabela da barra � diferente da tabela na atualiza��o anterior
|
|
if (not tabela_anterior or tabela_anterior ~= esta_barra.minha_tabela or forcar) then --aqui diz se a barra do jogador mudou de posi��o ou se ela apenas ser� atualizada
|
|
|
|
if (use_animations) then
|
|
esta_barra.animacao_fim = esta_porcentagem
|
|
else
|
|
esta_barra:SetValue(esta_porcentagem)
|
|
esta_barra.animacao_ignorar = true
|
|
end
|
|
|
|
esta_barra.last_value = esta_porcentagem --reseta o ultimo valor da barra
|
|
|
|
return self:RefreshBarra(esta_barra, instancia)
|
|
|
|
elseif (esta_porcentagem ~= esta_barra.last_value) then --continua mostrando a mesma tabela ent�o compara a porcentagem
|
|
--apenas atualizar
|
|
if (use_animations) then
|
|
esta_barra.animacao_fim = esta_porcentagem
|
|
else
|
|
esta_barra:SetValue(esta_porcentagem)
|
|
end
|
|
esta_barra.last_value = esta_porcentagem
|
|
|
|
return self:RefreshBarra(esta_barra, instancia)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
function atributo_misc:RefreshBarra(esta_barra, instancia, from_resize)
|
|
local class, enemy, arena_enemy, arena_ally = self.classe, self.enemy, self.arena_enemy, self.arena_ally
|
|
|
|
if (from_resize) then
|
|
actor_class_color_r, actor_class_color_g, actor_class_color_b = self:GetBarColor()
|
|
end
|
|
|
|
--icon
|
|
self:SetClassIcon (esta_barra.icone_classe, instancia, class)
|
|
|
|
if(esta_barra.mouse_over) then
|
|
local classIcon = esta_barra:GetClassIcon()
|
|
esta_barra.iconHighlight:SetTexture(classIcon:GetTexture())
|
|
esta_barra.iconHighlight:SetTexCoord(classIcon:GetTexCoord())
|
|
esta_barra.iconHighlight:SetVertexColor(classIcon:GetVertexColor())
|
|
end
|
|
--texture color
|
|
self:SetBarColors(esta_barra, instancia, actor_class_color_r, actor_class_color_g, actor_class_color_b)
|
|
--left text
|
|
self:SetBarLeftText (esta_barra, instancia, enemy, arena_enemy, arena_ally, UsingCustomLeftText)
|
|
|
|
esta_barra.lineText1:SetSize(esta_barra:GetWidth() - esta_barra.lineText4:GetStringWidth() - 20, 15)
|
|
end
|
|
|
|
--------------------------------------------- // TOOLTIPS // ---------------------------------------------
|
|
|
|
--~tooltips
|
|
function atributo_misc:ToolTip(instance, numero, barFrame, keydown)
|
|
GameTooltip:ClearLines()
|
|
GameTooltip:AddLine(barFrame.colocacao .. ". " .. self.nome)
|
|
|
|
if (instance.sub_atributo == 3) then --interrupt
|
|
return self:ToolTipInterrupt(instance, numero, barFrame, keydown)
|
|
|
|
elseif (instance.sub_atributo == 1) then --cc_break
|
|
return self:ToolTipCC(instance, numero, barFrame, keydown)
|
|
|
|
elseif (instance.sub_atributo == 2) then --ress
|
|
return self:ToolTipRess(instance, numero, barFrame, keydown)
|
|
|
|
elseif (instance.sub_atributo == 4) then --dispell
|
|
return self:ToolTipDispell(instance, numero, barFrame, keydown)
|
|
|
|
elseif (instance.sub_atributo == 5) then --mortes
|
|
return self:ToolTipDead(instance, numero, barFrame, keydown)
|
|
|
|
elseif (instance.sub_atributo == 6) then --defensive cooldowns
|
|
return self:ToolTipDefensiveCooldowns(instance, numero, barFrame, keydown)
|
|
|
|
elseif (instance.sub_atributo == 7) then --buff uptime
|
|
return self:ToolTipBuffUptime(instance, barFrame)
|
|
|
|
elseif (instance.sub_atributo == 8) then --debuff uptime
|
|
return self:ToolTipDebuffUptime(instance, numero, barFrame, keydown)
|
|
end
|
|
end
|
|
|
|
--tooltip locals
|
|
local r, g, b
|
|
local barAlha = .6
|
|
|
|
function atributo_misc:ToolTipDead(instancia, numero, barra)
|
|
--is this even called?
|
|
local last_dead = self.dead_log [#self.dead_log]
|
|
Details:Msg("utility class called ToolTipDead, a deprecated function.")
|
|
end
|
|
|
|
function atributo_misc:ToolTipCC (instancia, numero, barra)
|
|
|
|
local owner = self.owner
|
|
if (owner and owner.classe) then
|
|
r, g, b = unpack(_detalhes.class_colors [owner.classe])
|
|
else
|
|
r, g, b = unpack(_detalhes.class_colors [self.classe])
|
|
end
|
|
|
|
local meu_total = self ["cc_break"]
|
|
local habilidades = self.cc_break_spells._ActorTable
|
|
|
|
--habilidade usada para tirar o CC
|
|
local icon_size = _detalhes.tooltip.icon_size
|
|
local icon_border = _detalhes.tooltip.icon_border_texcoord
|
|
local lineHeight = _detalhes.tooltip.line_height
|
|
local icon_border = _detalhes.tooltip.icon_border_texcoord
|
|
|
|
for _spellid, _tabela in pairs(habilidades) do
|
|
|
|
--quantidade
|
|
local nome_magia, _, icone_magia = _GetSpellInfo(_spellid)
|
|
GameCooltip:AddLine(nome_magia, _tabela.cc_break .. " (" .. _cstr ("%.1f", _tabela.cc_break / meu_total * 100) .. "%)")
|
|
GameCooltip:AddIcon (icone_magia, nil, nil, lineHeight, lineHeight, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
--o que quebrou
|
|
local quebrou_oque = _tabela.cc_break_oque
|
|
for spellid_quebrada, amt_quebrada in pairs(_tabela.cc_break_oque) do
|
|
local nome_magia, _, icone_magia = _GetSpellInfo(spellid_quebrada)
|
|
GameCooltip:AddLine(nome_magia, amt_quebrada .. " ")
|
|
GameCooltip:AddIcon ([[Interface\Buttons\UI-GroupLoot-Pass-Down]], nil, 1, 14, 14)
|
|
GameCooltip:AddIcon (icone_magia, nil, 2, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
GameCooltip:AddStatusBar (100, 1, 1, 0, 0, .2)
|
|
end
|
|
|
|
--em quem quebrou
|
|
for target_name, amount in pairs(_tabela.targets) do
|
|
GameCooltip:AddLine(target_name .. ": ", amount .. " ")
|
|
|
|
local classe = _detalhes:GetClass(target_name)
|
|
GameCooltip:AddIcon ([[Interface\AddOns\Details\images\espadas]], nil, 1, lineHeight, lineHeight)
|
|
if (classe) then
|
|
GameCooltip:AddIcon ([[Interface\AddOns\Details\images\classes_small]], nil, 2, lineHeight, lineHeight, unpack(_detalhes.class_coords [classe]))
|
|
else
|
|
GameCooltip:AddIcon ("Interface\\LFGFRAME\\LFGROLE_BW", nil, 2, lineHeight, lineHeight, .25, .5, 0, 1)
|
|
end
|
|
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
end
|
|
end
|
|
|
|
|
|
return true
|
|
end
|
|
|
|
function atributo_misc:ToolTipDispell(instancia, numero, barra)
|
|
local owner = self.owner
|
|
if (owner and owner.classe) then
|
|
r, g, b = unpack(_detalhes.class_colors[owner.classe])
|
|
else
|
|
r, g, b = unpack(_detalhes.class_colors[self.classe])
|
|
end
|
|
|
|
local totalDispels = math.floor(self["dispell"])
|
|
local habilidades = self.dispell_spells._ActorTable
|
|
|
|
--habilidade usada para dispelar
|
|
local spellsUsedToDispel = {}
|
|
for spellId, spellTable in pairs(habilidades) do
|
|
if (spellTable.dispell) then
|
|
spellsUsedToDispel[#spellsUsedToDispel+1] = {spellId, math.floor(spellTable.dispell)}
|
|
else
|
|
Details:Msg("D! table.dispell is invalid. spellId:", spellId)
|
|
end
|
|
end
|
|
table.sort (spellsUsedToDispel, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText(Loc ["STRING_SPELLS"], headerColor, #spellsUsedToDispel, [[Interface\ICONS\Spell_Arcane_ArcaneTorrent]], 0.078125, 0.9375, 0.078125, 0.953125)
|
|
_detalhes:AddTooltipHeaderStatusbar(r, g, b, barAlha)
|
|
|
|
local icon_size = _detalhes.tooltip.icon_size
|
|
local icon_border = _detalhes.tooltip.icon_border_texcoord
|
|
|
|
if (#spellsUsedToDispel > 0) then
|
|
for i = 1, math.min(25, #spellsUsedToDispel) do
|
|
local spellInfo = spellsUsedToDispel[i]
|
|
local spellId = spellInfo[1]
|
|
local amountDispels = spellInfo[2]
|
|
local spellName, _, spellicon = _GetSpellInfo(spellId)
|
|
GameCooltip:AddLine(spellName, amountDispels .. " (" .. string.format("%.1f", amountDispels / totalDispels * 100) .. "%)")
|
|
GameCooltip:AddIcon(spellicon, nil, nil, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
end
|
|
else
|
|
GameTooltip:AddLine(Loc ["STRING_NO_SPELL"])
|
|
end
|
|
|
|
--quais habilidades foram dispaladas
|
|
local dispelledSpells = {}
|
|
for spellId, amount in pairs(self.dispell_oque) do
|
|
dispelledSpells[#dispelledSpells+1] = {spellId, amount}
|
|
end
|
|
table.sort(dispelledSpells, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText(Loc ["STRING_DISPELLED"], headerColor, #dispelledSpells, [[Interface\ICONS\Spell_Arcane_ManaTap]], 0.078125, 0.9375, 0.078125, 0.953125)
|
|
_detalhes:AddTooltipHeaderStatusbar(r, g, b, barAlha)
|
|
|
|
if (#dispelledSpells > 0) then
|
|
for i = 1, math.min(25, #dispelledSpells) do
|
|
local spellInfo = dispelledSpells[i]
|
|
local spellId = spellInfo[1]
|
|
local amountDispels = spellInfo[2]
|
|
local spellName, _, spellIcon = _GetSpellInfo(spellId)
|
|
GameCooltip:AddLine(spellName, amountDispels .. " (" .. string.format("%.1f", amountDispels / totalDispels * 100) .. "%)")
|
|
GameCooltip:AddIcon (spellIcon, nil, nil, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
end
|
|
end
|
|
|
|
--alvos dispelados
|
|
|
|
local alvos_dispelados = {}
|
|
for target_name, amount in pairs(self.dispell_targets) do
|
|
alvos_dispelados [#alvos_dispelados + 1] = {target_name, _math_floor(amount), amount / totalDispels * 100}
|
|
end
|
|
table.sort (alvos_dispelados, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_TARGETS"], headerColor, #alvos_dispelados, [[Interface\ICONS\ACHIEVEMENT_GUILDPERK_EVERYONES A HERO_RANK2]], 0.078125, 0.9375, 0.078125, 0.953125)
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
for i = 1, min (25, #alvos_dispelados) do
|
|
if (alvos_dispelados[i][2] < 1) then
|
|
break
|
|
end
|
|
|
|
GameCooltip:AddLine(alvos_dispelados[i][1], _detalhes:comma_value (alvos_dispelados[i][2]) .." (".._cstr ("%.1f", alvos_dispelados[i][3]).."%)")
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
|
|
local targetActor = instancia.showing[4]:PegarCombatente (_, alvos_dispelados[i][1])
|
|
|
|
if (targetActor) then
|
|
local classe = targetActor.classe
|
|
if (not classe) then
|
|
classe = "UNKNOW"
|
|
end
|
|
if (classe == "UNKNOW") then
|
|
GameCooltip:AddIcon ("Interface\\LFGFRAME\\LFGROLE_BW", nil, nil, 14, 14, .25, .5, 0, 1)
|
|
else
|
|
GameCooltip:AddIcon ("Interface\\AddOns\\Details\\images\\classes_small", nil, nil, 14, 14, unpack(_detalhes.class_coords [classe]))
|
|
end
|
|
end
|
|
end
|
|
|
|
--Pet
|
|
local meus_pets = self.pets
|
|
if (#meus_pets > 0) then --teve ajudantes
|
|
|
|
local quantidade = {} --armazena a quantidade de pets iguais
|
|
local interrupts = {} --armazena as habilidades
|
|
local alvos = {} --armazena os alvos
|
|
local totais = {} --armazena o dano total de cada objeto
|
|
|
|
for index, nome in ipairs(meus_pets) do
|
|
if (not quantidade [nome]) then
|
|
quantidade [nome] = 1
|
|
|
|
local my_self = instancia.showing[class_type]:PegarCombatente (nil, nome)
|
|
if (my_self and my_self.dispell) then
|
|
totais [#totais+1] = {nome, my_self.dispell}
|
|
end
|
|
else
|
|
quantidade [nome] = quantidade [nome]+1
|
|
end
|
|
end
|
|
|
|
local _quantidade = 0
|
|
local added_logo = false
|
|
|
|
table.sort (totais, _detalhes.Sort2)
|
|
|
|
local ismaximized = false
|
|
if (keydown == "alt" or TooltipMaximizedMethod == 2 or TooltipMaximizedMethod == 5) then
|
|
ismaximized = true
|
|
end
|
|
|
|
for index, _table in ipairs(totais) do
|
|
|
|
if (_table [2] > 0 and (index < 3 or ismaximized)) then
|
|
|
|
if (not added_logo) then
|
|
added_logo = true
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_PETS"], headerColor, #totais, [[Interface\COMMON\friendship-heart]], 0.21875, 0.78125, 0.09375, 0.6875)
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
end
|
|
|
|
local n = _table [1]:gsub(("%s%<.*"), "")
|
|
GameCooltip:AddLine(n, _table [2] .. " (" .. _math_floor(_table [2]/self.dispell*100) .. "%)")
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
GameCooltip:AddIcon ([[Interface\AddOns\Details\images\classes_small]], 1, 1, 14, 14, 0.25, 0.49609375, 0.75, 1)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
local UnitReaction = UnitReaction
|
|
local UnitDebuff = UnitDebuff
|
|
|
|
function _detalhes:CloseEnemyDebuffsUptime()
|
|
local combat = _detalhes.tabela_vigente
|
|
local misc_container = combat [4]._ActorTable
|
|
|
|
for _, actor in ipairs(misc_container) do
|
|
if (actor.boss_debuff) then
|
|
for target_name, target in ipairs(actor.debuff_uptime_targets) do
|
|
if (target.actived and target.actived_at) then
|
|
target.uptime = target.uptime + _detalhes._tempo - target.actived_at
|
|
actor.debuff_uptime = actor.debuff_uptime + _detalhes._tempo - target.actived_at
|
|
target.actived = false
|
|
target.actived_at = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return
|
|
end
|
|
|
|
function _detalhes:CatchRaidDebuffUptime (in_or_out) -- "DEBUFF_UPTIME_IN"
|
|
|
|
if (in_or_out == "DEBUFF_UPTIME_OUT") then
|
|
local combat = _detalhes.tabela_vigente
|
|
local misc_container = combat [4]._ActorTable --error attempt to index a new value
|
|
|
|
for _, actor in ipairs(misc_container) do
|
|
if (actor.debuff_uptime) then
|
|
for spellid, spell in pairs(actor.debuff_uptime_spells._ActorTable) do
|
|
if (spell.actived and spell.actived_at) then
|
|
spell.uptime = spell.uptime + _detalhes._tempo - spell.actived_at
|
|
actor.debuff_uptime = actor.debuff_uptime + _detalhes._tempo - spell.actived_at
|
|
spell.actived = false
|
|
spell.actived_at = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return
|
|
end
|
|
|
|
local cacheGetTime = GetTime()
|
|
|
|
if (IsInRaid()) then
|
|
|
|
local checked = {}
|
|
|
|
for raidIndex = 1, GetNumGroupMembers() do
|
|
|
|
local target = "raid"..raidIndex.."target"
|
|
local his_target = UnitGUID(target)
|
|
|
|
if (his_target and not checked [his_target]) then
|
|
local rect = UnitReaction (target, "player")
|
|
if (rect and rect <= 4) then
|
|
|
|
checked [his_target] = true
|
|
|
|
for debuffIndex = 1, 41 do
|
|
local name, _, _, _, _, _, _, unitCaster, _, _, spellid = UnitDebuff (target, debuffIndex)
|
|
if (name and unitCaster) then
|
|
local playerGUID = UnitGUID(unitCaster)
|
|
if (playerGUID) then
|
|
|
|
local playerName, realmName = _UnitName (unitCaster)
|
|
if (realmName and realmName ~= "") then
|
|
playerName = playerName .. "-" .. realmName
|
|
end
|
|
|
|
_detalhes.parser:add_debuff_uptime (nil, cacheGetTime, playerGUID, playerName, 0x00000417, his_target, _UnitName (target), 0x842, nil, spellid, name, in_or_out)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif (IsInGroup()) then
|
|
|
|
local checked = {}
|
|
|
|
for raidIndex = 1, GetNumGroupMembers()-1 do
|
|
local his_target = UnitGUID("party"..raidIndex.."target")
|
|
local rect = UnitReaction ("party"..raidIndex.."target", "player")
|
|
if (his_target and not checked [his_target] and rect and rect <= 4) then
|
|
|
|
checked [his_target] = true
|
|
|
|
for debuffIndex = 1, 40 do
|
|
local name, _, _, _, _, _, _, unitCaster, _, _, spellid = UnitDebuff ("party"..raidIndex.."target", debuffIndex)
|
|
if (name and unitCaster) then
|
|
local playerName, realmName = _UnitName (unitCaster)
|
|
local playerGUID = UnitGUID(unitCaster)
|
|
if (playerGUID) then
|
|
if (realmName and realmName ~= "") then
|
|
playerName = playerName .. "-" .. realmName
|
|
end
|
|
|
|
_detalhes.parser:add_debuff_uptime (nil, GetTime(), playerGUID, playerName, 0x00000417, his_target, _UnitName ("party"..raidIndex.."target"), 0x842, nil, spellid, name, in_or_out)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local his_target = UnitGUID("playertarget")
|
|
local rect = UnitReaction ("playertarget", "player")
|
|
if (his_target and not checked [his_target] and rect and rect <= 4) then
|
|
for debuffIndex = 1, 40 do
|
|
local name, _, _, _, _, _, _, unitCaster, _, _, spellid = UnitDebuff ("playertarget", debuffIndex)
|
|
if (name and unitCaster) then
|
|
local playerName, realmName = _UnitName (unitCaster)
|
|
local playerGUID = UnitGUID(unitCaster)
|
|
if (playerGUID) then
|
|
if (realmName and realmName ~= "") then
|
|
playerName = playerName .. "-" .. realmName
|
|
end
|
|
_detalhes.parser:add_debuff_uptime (nil, GetTime(), playerGUID, playerName, 0x00000417, his_target, _UnitName ("playertarget"), 0x842, nil, spellid, name, in_or_out)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
else
|
|
local his_target = UnitGUID("playertarget")
|
|
if (his_target) then
|
|
local reaction = UnitReaction ("playertarget", "player")
|
|
if (reaction and reaction <= 4) then
|
|
for debuffIndex = 1, 40 do
|
|
local name, _, _, _, _, _, _, unitCaster, _, _, spellid = UnitDebuff ("playertarget", debuffIndex)
|
|
if (name and unitCaster) then
|
|
local playerName, realmName = _UnitName (unitCaster)
|
|
local playerGUID = UnitGUID(unitCaster)
|
|
if (playerGUID) then
|
|
if (realmName and realmName ~= "") then
|
|
playerName = playerName .. "-" .. realmName
|
|
end
|
|
_detalhes.parser:add_debuff_uptime (nil, GetTime(), playerGUID, playerName, 0x00000417, his_target, _UnitName ("playertarget"), 0x842, nil, spellid, name, in_or_out)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--this shouldn't be hardcoded
|
|
local runes_id = {
|
|
[175457] = true, -- focus
|
|
[175456] = true, --hyper
|
|
[175439] = true, --stout
|
|
}
|
|
|
|
--called from control on leave / enter combat
|
|
function _detalhes:CatchRaidBuffUptime (in_or_out)
|
|
|
|
if (IsInRaid()) then
|
|
|
|
local pot_usage = {}
|
|
local focus_augmentation = {}
|
|
|
|
--raid groups
|
|
local cacheGetTime = GetTime()
|
|
|
|
for raidIndex = 1, GetNumGroupMembers() do
|
|
local RaidIndex = "raid" .. raidIndex
|
|
local playerGUID = UnitGUID(RaidIndex)
|
|
|
|
if (playerGUID) then
|
|
|
|
local playerName, realmName = _UnitName (RaidIndex)
|
|
if (realmName and realmName ~= "") then
|
|
playerName = playerName .. "-" .. realmName
|
|
end
|
|
|
|
for buffIndex = 1, 41 do
|
|
local name, _, _, _, _, _, unitCaster, _, _, spellid = _UnitAura (RaidIndex, buffIndex, nil, "HELPFUL")
|
|
if (name and unitCaster and UnitExists(unitCaster) and UnitExists(RaidIndex) and UnitIsUnit(unitCaster, RaidIndex)) then
|
|
_detalhes.parser:add_buff_uptime (nil, cacheGetTime, playerGUID, playerName, 0x00000514, playerGUID, playerName, 0x00000514, 0x0, spellid, name, in_or_out)
|
|
|
|
if (in_or_out == "BUFF_UPTIME_IN") then
|
|
if (_detalhes.PotionList [spellid]) then
|
|
pot_usage [playerName] = spellid
|
|
|
|
elseif (runes_id [spellid]) then
|
|
focus_augmentation [playerName] = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if (in_or_out == "BUFF_UPTIME_IN") then
|
|
local string_output = "pre-potion: " --localize-me
|
|
|
|
for playername, potspellid in pairs(pot_usage) do
|
|
local name, _, icon = _GetSpellInfo(potspellid)
|
|
local _, class = UnitClass(playername)
|
|
local class_color = ""
|
|
if (class and RAID_CLASS_COLORS [class]) then
|
|
class_color = RAID_CLASS_COLORS [class].colorStr
|
|
end
|
|
string_output = string_output .. "|c" .. class_color .. playername .. "|r |T" .. icon .. ":14:14:0:0:64:64:0:64:0:64|t "
|
|
end
|
|
|
|
_detalhes.pre_pot_used = string_output
|
|
|
|
_detalhes:SendEvent("COMBAT_PREPOTION_UPDATED", nil, pot_usage, focus_augmentation)
|
|
end
|
|
|
|
elseif (IsInGroup()) then
|
|
|
|
local pot_usage = {}
|
|
local focus_augmentation = {}
|
|
|
|
--party members
|
|
for groupIndex = 1, GetNumGroupMembers() - 1 do
|
|
for buffIndex = 1, 41 do
|
|
local name, _, _, _, _, _, unitCaster, _, _, spellid = _UnitAura ("party"..groupIndex, buffIndex, nil, "HELPFUL")
|
|
if (name and unitCaster and UnitExists(unitCaster) and UnitExists("party" .. groupIndex) and UnitIsUnit(unitCaster, "party" .. groupIndex)) then
|
|
|
|
local playerName, realmName = _UnitName ("party"..groupIndex)
|
|
local playerGUID = UnitGUID("party"..groupIndex)
|
|
|
|
if (playerGUID) then
|
|
if (realmName and realmName ~= "") then
|
|
playerName = playerName .. "-" .. realmName
|
|
end
|
|
|
|
if (in_or_out == "BUFF_UPTIME_IN") then
|
|
if (_detalhes.PotionList [spellid]) then
|
|
pot_usage [playerName] = spellid
|
|
|
|
elseif (runes_id [spellid]) then
|
|
focus_augmentation [playerName] = true
|
|
end
|
|
end
|
|
|
|
_detalhes.parser:add_buff_uptime (nil, GetTime(), playerGUID, playerName, 0x00000417, playerGUID, playerName, 0x00000417, 0x0, spellid, name, in_or_out)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--player it self
|
|
for buffIndex = 1, 41 do
|
|
local name, _, _, _, _, _, unitCaster, _, _, spellid = _UnitAura ("player", buffIndex, nil, "HELPFUL")
|
|
if (name and unitCaster and UnitExists(unitCaster) and UnitIsUnit(unitCaster, "player")) then
|
|
local playerName = _UnitName ("player")
|
|
local playerGUID = UnitGUID("player")
|
|
if (playerGUID) then
|
|
if (in_or_out == "BUFF_UPTIME_IN") then
|
|
if (_detalhes.PotionList [spellid]) then
|
|
pot_usage [playerName] = spellid
|
|
elseif (runes_id [spellid]) then
|
|
focus_augmentation [playerName] = true
|
|
end
|
|
end
|
|
|
|
_detalhes.parser:add_buff_uptime (nil, GetTime(), playerGUID, playerName, 0x00000417, playerGUID, playerName, 0x00000417, 0x0, spellid, name, in_or_out)
|
|
end
|
|
end
|
|
end
|
|
|
|
if (in_or_out == "BUFF_UPTIME_IN") then
|
|
local string_output = "pre-potion: "
|
|
|
|
for playername, potspellid in pairs(pot_usage) do
|
|
local name, _, icon = _GetSpellInfo(potspellid)
|
|
local _, class = UnitClass(playername)
|
|
local class_color = ""
|
|
if (class and RAID_CLASS_COLORS [class]) then
|
|
class_color = RAID_CLASS_COLORS [class].colorStr
|
|
end
|
|
string_output = string_output .. "|c" .. class_color .. playername .. "|r |T" .. icon .. ":14:14:0:0:64:64:0:64:0:64|t "
|
|
end
|
|
|
|
_detalhes.pre_pot_used = string_output
|
|
_detalhes:SendEvent("COMBAT_PREPOTION_UPDATED", nil, pot_usage, focus_augmentation)
|
|
end
|
|
|
|
else
|
|
|
|
local pot_usage = {}
|
|
local focus_augmentation = {}
|
|
|
|
for buffIndex = 1, 41 do
|
|
local name, _, _, _, _, _, unitCaster, _, _, spellid = _UnitAura ("player", buffIndex, nil, "HELPFUL")
|
|
if (name and unitCaster and UnitExists(unitCaster) and UnitIsUnit(unitCaster, "player")) then
|
|
local playerName = _UnitName ("player")
|
|
local playerGUID = UnitGUID("player")
|
|
|
|
if (playerGUID) then
|
|
if (in_or_out == "BUFF_UPTIME_IN") then
|
|
if (_detalhes.PotionList [spellid]) then
|
|
pot_usage [playerName] = spellid
|
|
elseif (runes_id [spellid]) then
|
|
focus_augmentation [playerName] = true
|
|
end
|
|
end
|
|
_detalhes.parser:add_buff_uptime (nil, GetTime(), playerGUID, playerName, 0x00000417, playerGUID, playerName, 0x00000417, 0x0, spellid, name, in_or_out)
|
|
end
|
|
end
|
|
end
|
|
|
|
--[
|
|
if (in_or_out == "BUFF_UPTIME_IN") then
|
|
local string_output = "pre-potion: "
|
|
for playername, potspellid in pairs(pot_usage) do
|
|
local name, _, icon = _GetSpellInfo(potspellid)
|
|
local _, class = UnitClass(playername)
|
|
local class_color = ""
|
|
if (class and RAID_CLASS_COLORS [class]) then
|
|
class_color = RAID_CLASS_COLORS [class].colorStr
|
|
end
|
|
string_output = string_output .. "|c" .. class_color .. playername .. "|r |T" .. icon .. ":14:14:0:0:64:64:0:64:0:64|t "
|
|
end
|
|
|
|
_detalhes.pre_pot_used = string_output
|
|
_detalhes:SendEvent("COMBAT_PREPOTION_UPDATED", nil, pot_usage, focus_augmentation)
|
|
end
|
|
|
|
--]]
|
|
-- _detalhes:Msg(string_output)
|
|
|
|
end
|
|
end
|
|
|
|
local Sort2Reverse = function(a, b)
|
|
return a[2] < b[2]
|
|
end
|
|
|
|
function atributo_misc:ToolTipDebuffUptime (instancia, numero, barra)
|
|
|
|
local owner = self.owner
|
|
if (owner and owner.classe) then
|
|
r, g, b = unpack(_detalhes.class_colors [owner.classe])
|
|
else
|
|
r, g, b = unpack(_detalhes.class_colors [self.classe])
|
|
end
|
|
|
|
local meu_total = self ["debuff_uptime"]
|
|
local minha_tabela = self.debuff_uptime_spells._ActorTable
|
|
|
|
--habilidade usada para interromper
|
|
local debuffs_usados = {}
|
|
|
|
local _combat_time = instancia.showing:GetCombatTime()
|
|
|
|
for _spellid, _tabela in pairs(minha_tabela) do
|
|
debuffs_usados [#debuffs_usados+1] = {_spellid, _tabela.uptime}
|
|
end
|
|
table.sort (debuffs_usados, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_SPELLS"], headerColor, #debuffs_usados, _detalhes.tooltip_spell_icon.file, unpack(_detalhes.tooltip_spell_icon.coords))
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
local icon_size = _detalhes.tooltip.icon_size
|
|
local icon_border = _detalhes.tooltip.icon_border_texcoord
|
|
|
|
if (#debuffs_usados > 0) then
|
|
for i = 1, min (30, #debuffs_usados) do
|
|
local esta_habilidade = debuffs_usados[i]
|
|
|
|
if (esta_habilidade[2] > 0) then
|
|
local nome_magia, _, icone_magia = _GetSpellInfo(esta_habilidade[1])
|
|
|
|
local minutos, segundos = _math_floor(esta_habilidade[2]/60), _math_floor(esta_habilidade[2]%60)
|
|
if (esta_habilidade[2] >= _combat_time) then
|
|
--GameCooltip:AddLine(nome_magia, minutos .. "m " .. segundos .. "s" .. " (" .. _cstr ("%.1f", esta_habilidade[2] / _combat_time * 100) .. "%)", nil, "gray", "gray")
|
|
--GameCooltip:AddStatusBar (100, nil, 1, 0, 1, .3, false)
|
|
elseif (minutos > 0) then
|
|
GameCooltip:AddLine(nome_magia, minutos .. "m " .. segundos .. "s" .. " (" .. _cstr ("%.1f", esta_habilidade[2] / _combat_time * 100) .. "%)")
|
|
_detalhes:AddTooltipBackgroundStatusbar (false, esta_habilidade[2] / _combat_time * 100)
|
|
else
|
|
GameCooltip:AddLine(nome_magia, segundos .. "s" .. " (" .. _cstr ("%.1f", esta_habilidade[2] / _combat_time * 100) .. "%)")
|
|
_detalhes:AddTooltipBackgroundStatusbar (false, esta_habilidade[2] / _combat_time * 100)
|
|
end
|
|
|
|
GameCooltip:AddIcon (icone_magia, nil, nil, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
end
|
|
end
|
|
else
|
|
GameCooltip:AddLine(Loc ["STRING_NO_SPELL"])
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
function atributo_misc:ToolTipBuffUptime(instance, barFrame)
|
|
---@cast instance instance
|
|
|
|
local owner = self.owner
|
|
if (owner and owner.classe) then
|
|
r, g, b = unpack(Details.class_colors[owner.classe])
|
|
else
|
|
r, g, b = unpack(Details.class_colors[self.classe])
|
|
end
|
|
|
|
local combatTime = instance:GetCombat():GetCombatTime()
|
|
local buffUptimeSpells = self:GetSpellContainer("buff")
|
|
local buffUptimeTable = {}
|
|
|
|
if (buffUptimeSpells) then
|
|
for spellId, spellTable in buffUptimeSpells:ListSpells() do
|
|
if (not Details.BuffUptimeSpellsToIgnore[spellId]) then
|
|
local uptime = spellTable.uptime or 0
|
|
if (uptime > 0) then
|
|
buffUptimeTable[#buffUptimeTable+1] = {spellId, uptime}
|
|
end
|
|
end
|
|
end
|
|
|
|
--check if this player has a augmentation buff container
|
|
local augmentedBuffContainer = self.received_buffs_spells
|
|
if (augmentedBuffContainer) then
|
|
for sourceNameSpellId, spellTable in augmentedBuffContainer:ListSpells() do
|
|
local sourceName, spellId = strsplit("@", sourceNameSpellId)
|
|
spellId = tonumber(spellId)
|
|
local spellName, _, spellIcon = Details.GetSpellInfo(spellId)
|
|
|
|
if (spellName) then
|
|
sourceName = detailsFramework:RemoveRealmName(sourceName)
|
|
local uptime = spellTable.uptime or 0
|
|
buffUptimeTable[#buffUptimeTable+1] = {spellId, uptime, sourceName}
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort(buffUptimeTable, Details.Sort2)
|
|
|
|
Details:AddTooltipSpellHeaderText(Loc ["STRING_SPELLS"], headerColor, #buffUptimeTable, Details.tooltip_spell_icon.file, unpack(Details.tooltip_spell_icon.coords))
|
|
Details:AddTooltipHeaderStatusbar(r, g, b, barAlha)
|
|
|
|
local iconSizeInfo = Details.tooltip.icon_size
|
|
local iconBorderInfo = Details.tooltip.icon_border_texcoord
|
|
|
|
if (#buffUptimeTable > 0) then
|
|
for i = 1, min(30, #buffUptimeTable) do
|
|
local uptimeTable = buffUptimeTable[i]
|
|
|
|
local spellId = uptimeTable[1]
|
|
local uptime = uptimeTable[2]
|
|
local sourceName = uptimeTable[3]
|
|
|
|
local uptimePercent = uptime / combatTime * 100
|
|
|
|
if (uptime > 0 and uptimePercent < 99.5) then
|
|
local spellName, _, spellIcon = _GetSpellInfo(spellId)
|
|
|
|
if (sourceName) then
|
|
spellName = spellName .. " [" .. sourceName .. "]"
|
|
end
|
|
|
|
if (uptime <= combatTime) then
|
|
local minutes, seconds = math.floor(uptime / 60), math.floor(uptime % 60)
|
|
if (minutes > 0) then
|
|
GameCooltip:AddLine(spellName, minutes .. "m " .. seconds .. "s" .. " (" .. format("%.1f", uptimePercent) .. "%)")
|
|
Details:AddTooltipBackgroundStatusbar(false, uptimePercent, true, sourceName and "green")
|
|
else
|
|
GameCooltip:AddLine(spellName, seconds .. "s" .. " (" .. format("%.1f", uptimePercent) .. "%)")
|
|
Details:AddTooltipBackgroundStatusbar(false, uptimePercent, true, sourceName and "green")
|
|
end
|
|
|
|
GameCooltip:AddIcon(spellIcon, nil, nil, iconSizeInfo.W, iconSizeInfo.H, iconBorderInfo.L, iconBorderInfo.R, iconBorderInfo.T, iconBorderInfo.B)
|
|
end
|
|
end
|
|
end
|
|
else
|
|
GameCooltip:AddLine(Loc ["STRING_NO_SPELL"])
|
|
end
|
|
else
|
|
Details:AddTooltipSpellHeaderText(Loc ["STRING_SPELLS"], headerColor, #buffUptimeTable, Details.tooltip_spell_icon.file, unpack(Details.tooltip_spell_icon.coords))
|
|
Details:AddTooltipHeaderStatusbar(r, g, b, barAlha)
|
|
GameCooltip:AddLine(Loc ["STRING_NO_SPELL"])
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
function atributo_misc:ToolTipDefensiveCooldowns (instancia, numero, barra)
|
|
|
|
local owner = self.owner
|
|
if (owner and owner.classe) then
|
|
r, g, b = unpack(_detalhes.class_colors [owner.classe])
|
|
else
|
|
r, g, b = unpack(_detalhes.class_colors [self.classe])
|
|
end
|
|
|
|
local meu_total = _math_floor(self ["cooldowns_defensive"])
|
|
local minha_tabela = self.cooldowns_defensive_spells._ActorTable
|
|
|
|
--spells
|
|
local cooldowns_usados = {}
|
|
|
|
for _spellid, _tabela in pairs(minha_tabela) do
|
|
cooldowns_usados [#cooldowns_usados+1] = {_spellid, _tabela.counter}
|
|
end
|
|
table.sort (cooldowns_usados, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_SPELLS"], headerColor, #cooldowns_usados, _detalhes.tooltip_spell_icon.file, unpack(_detalhes.tooltip_spell_icon.coords))
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
local icon_size = _detalhes.tooltip.icon_size
|
|
local icon_border = _detalhes.tooltip.icon_border_texcoord
|
|
local lineHeight = _detalhes.tooltip.line_height
|
|
|
|
if (#cooldowns_usados > 0) then
|
|
for i = 1, min (25, #cooldowns_usados) do
|
|
local esta_habilidade = cooldowns_usados[i]
|
|
local nome_magia, _, icone_magia = _GetSpellInfo(esta_habilidade[1])
|
|
GameCooltip:AddLine(nome_magia, esta_habilidade[2].." (".._cstr("%.1f", esta_habilidade[2]/meu_total*100).."%)")
|
|
GameCooltip:AddIcon (icone_magia, nil, nil, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
end
|
|
else
|
|
GameCooltip:AddLine(Loc ["STRING_NO_SPELL"])
|
|
end
|
|
|
|
--targets
|
|
local meus_alvos = self.cooldowns_defensive_targets
|
|
local alvos = {}
|
|
|
|
for target_name, amount in pairs(meus_alvos) do
|
|
alvos [#alvos+1] = {target_name, amount}
|
|
end
|
|
table.sort (alvos, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_TARGETS"], headerColor, #alvos, _detalhes.tooltip_target_icon.file, unpack(_detalhes.tooltip_target_icon.coords))
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
if (#alvos > 0) then
|
|
for i = 1, min (25, #alvos) do
|
|
GameCooltip:AddLine(_detalhes:GetOnlyName(alvos[i][1]) .. ": ", alvos[i][2], 1, "white", "white")
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
|
|
GameCooltip:AddIcon ("Interface\\Icons\\PALADIN_HOLY", nil, nil, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
|
|
local targetActor = instancia.showing[4]:PegarCombatente (_, alvos[i][1])
|
|
if (targetActor) then
|
|
local classe = targetActor.classe
|
|
if (not classe) then
|
|
classe = "UNKNOW"
|
|
end
|
|
if (classe == "UNKNOW") then
|
|
GameCooltip:AddIcon ("Interface\\LFGFRAME\\LFGROLE_BW", nil, nil, 14, 14, .25, .5, 0, 1)
|
|
else
|
|
local specID = _detalhes:GetSpec(alvos[i][1])
|
|
if (specID) then
|
|
local texture, l, r, t, b = _detalhes:GetSpecIcon (specID, false)
|
|
GameCooltip:AddIcon (texture, 1, 1, lineHeight, lineHeight, l, r, t, b)
|
|
else
|
|
GameCooltip:AddIcon ("Interface\\AddOns\\Details\\images\\classes_small", nil, nil, 14, 14, unpack(_detalhes.class_coords [classe]))
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
function atributo_misc:ToolTipRess (instancia, numero, barra)
|
|
|
|
local owner = self.owner
|
|
if (owner and owner.classe) then
|
|
r, g, b = unpack(_detalhes.class_colors [owner.classe])
|
|
else
|
|
r, g, b = unpack(_detalhes.class_colors [self.classe])
|
|
end
|
|
|
|
local meu_total = self ["ress"]
|
|
local minha_tabela = self.ress_spells._ActorTable
|
|
local lineHeight = _detalhes.tooltip.line_height
|
|
local icon_border = _detalhes.tooltip.icon_border_texcoord
|
|
|
|
--habilidade usada para interromper
|
|
local meus_ress = {}
|
|
|
|
for _spellid, _tabela in pairs(minha_tabela) do
|
|
meus_ress [#meus_ress+1] = {_spellid, _tabela.ress}
|
|
end
|
|
table.sort (meus_ress, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_SPELLS"], headerColor, #meus_ress, _detalhes.tooltip_spell_icon.file, unpack(_detalhes.tooltip_spell_icon.coords))
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
if (#meus_ress > 0) then
|
|
for i = 1, min (3, #meus_ress) do
|
|
local esta_habilidade = meus_ress[i]
|
|
local nome_magia, _, icone_magia = _GetSpellInfo(esta_habilidade[1])
|
|
GameCooltip:AddLine(nome_magia, esta_habilidade[2] .. " (" .. _cstr ("%.1f", floor(esta_habilidade[2]) / floor(meu_total) * 100).."%)")
|
|
GameCooltip:AddIcon (icone_magia, nil, nil, lineHeight, lineHeight, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
end
|
|
else
|
|
GameCooltip:AddLine(Loc ["STRING_NO_SPELL"])
|
|
end
|
|
|
|
--quem foi que o cara reviveu
|
|
local meus_alvos = self.ress_targets
|
|
local alvos = {}
|
|
|
|
for target_name, amount in pairs(meus_alvos) do
|
|
alvos [#alvos+1] = {target_name, amount}
|
|
end
|
|
table.sort (alvos, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_TARGETS"], headerColor, #alvos, _detalhes.tooltip_target_icon.file, unpack(_detalhes.tooltip_target_icon.coords))
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
if (#alvos > 0) then
|
|
for i = 1, min (3, #alvos) do
|
|
GameCooltip:AddLine(alvos[i][1], alvos[i][2])
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
|
|
local targetActor = instancia.showing[4]:PegarCombatente (_, alvos[i][1])
|
|
if (targetActor) then
|
|
local classe = targetActor.classe
|
|
if (not classe) then
|
|
classe = "UNKNOW"
|
|
end
|
|
if (classe == "UNKNOW") then
|
|
GameCooltip:AddIcon ("Interface\\LFGFRAME\\LFGROLE_BW", nil, nil, lineHeight, lineHeight, .25, .5, 0, 1)
|
|
else
|
|
local specID = _detalhes:GetSpec(alvos[i][1])
|
|
if (specID) then
|
|
local texture, l, r, t, b = _detalhes:GetSpecIcon (specID, false)
|
|
GameCooltip:AddIcon (texture, 1, 1, lineHeight, lineHeight, l, r, t, b)
|
|
else
|
|
GameCooltip:AddIcon ("Interface\\AddOns\\Details\\images\\classes_small", nil, nil, lineHeight, lineHeight, unpack(_detalhes.class_coords [classe]))
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
function atributo_misc:ToolTipInterrupt (instancia, numero, barra)
|
|
|
|
local owner = self.owner
|
|
if (owner and owner.classe) then
|
|
r, g, b = unpack(_detalhes.class_colors [owner.classe])
|
|
else
|
|
r, g, b = unpack(_detalhes.class_colors [self.classe])
|
|
end
|
|
|
|
local meu_total = self ["interrupt"]
|
|
local minha_tabela = self.interrupt_spells._ActorTable
|
|
|
|
local icon_size = _detalhes.tooltip.icon_size
|
|
local icon_border = _detalhes.tooltip.icon_border_texcoord
|
|
local lineHeight = _detalhes.tooltip.line_height
|
|
|
|
--habilidade usada para interromper
|
|
local meus_interrupts = {}
|
|
|
|
for _spellid, _tabela in pairs(minha_tabela) do
|
|
meus_interrupts [#meus_interrupts+1] = {_spellid, _tabela.counter}
|
|
end
|
|
table.sort (meus_interrupts, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_SPELLS"], headerColor, #meus_interrupts, _detalhes.tooltip_spell_icon.file, unpack(_detalhes.tooltip_spell_icon.coords))
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
if (#meus_interrupts > 0) then
|
|
for i = 1, min (25, #meus_interrupts) do
|
|
local esta_habilidade = meus_interrupts[i]
|
|
local nome_magia, _, icone_magia = _GetSpellInfo(esta_habilidade[1])
|
|
GameCooltip:AddLine(nome_magia, esta_habilidade[2].." (".._cstr("%.1f", floor(esta_habilidade[2])/floor(meu_total)*100).."%)")
|
|
GameCooltip:AddIcon (icone_magia, nil, nil, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
end
|
|
else
|
|
GameTooltip:AddLine(Loc ["STRING_NO_SPELL"])
|
|
end
|
|
|
|
--quais habilidades foram interrompidas
|
|
local habilidades_interrompidas = {}
|
|
|
|
for _spellid, amt in pairs(self.interrompeu_oque) do
|
|
habilidades_interrompidas [#habilidades_interrompidas+1] = {_spellid, amt}
|
|
end
|
|
table.sort (habilidades_interrompidas, _detalhes.Sort2)
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_SPELL_INTERRUPTED"] .. ":", headerColor, #habilidades_interrompidas, _detalhes.tooltip_target_icon.file, unpack(_detalhes.tooltip_target_icon.coords))
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
|
|
if (#habilidades_interrompidas > 0) then
|
|
for i = 1, min (25, #habilidades_interrompidas) do
|
|
local esta_habilidade = habilidades_interrompidas[i]
|
|
local nome_magia, _, icone_magia = _GetSpellInfo(esta_habilidade[1])
|
|
GameCooltip:AddLine(nome_magia, esta_habilidade[2].." (".._cstr("%.1f", floor(esta_habilidade[2])/floor(meu_total)*100).."%)")
|
|
GameCooltip:AddIcon (icone_magia, nil, nil, icon_size.W, icon_size.H, icon_border.L, icon_border.R, icon_border.T, icon_border.B)
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
end
|
|
end
|
|
|
|
--Pet
|
|
local meus_pets = self.pets
|
|
if (#meus_pets > 0) then --teve ajudantes
|
|
|
|
local quantidade = {} --armazena a quantidade de pets iguais
|
|
local interrupts = {} --armazena as habilidades
|
|
local alvos = {} --armazena os alvos
|
|
local totais = {} --armazena o dano total de cada objeto
|
|
|
|
for index, nome in ipairs(meus_pets) do
|
|
if (not quantidade [nome]) then
|
|
quantidade [nome] = 1
|
|
|
|
local my_self = instancia.showing[class_type]:PegarCombatente (nil, nome)
|
|
if (my_self and my_self.interrupt) then
|
|
totais [#totais+1] = {nome, my_self.interrupt}
|
|
end
|
|
else
|
|
quantidade [nome] = quantidade [nome]+1
|
|
end
|
|
end
|
|
|
|
local _quantidade = 0
|
|
local added_logo = false
|
|
|
|
table.sort (totais, _detalhes.Sort2)
|
|
|
|
local ismaximized = false
|
|
if (keydown == "alt" or TooltipMaximizedMethod == 2 or TooltipMaximizedMethod == 5) then
|
|
ismaximized = true
|
|
end
|
|
|
|
for index, _table in ipairs(totais) do
|
|
|
|
if (_table [2] > 0 and (index < 3 or ismaximized)) then
|
|
|
|
if (not added_logo) then
|
|
added_logo = true
|
|
|
|
_detalhes:AddTooltipSpellHeaderText (Loc ["STRING_PETS"], headerColor, #totais, [[Interface\COMMON\friendship-heart]], 0.21875, 0.78125, 0.09375, 0.6875)
|
|
_detalhes:AddTooltipHeaderStatusbar (r, g, b, barAlha)
|
|
end
|
|
|
|
local n = _table [1]:gsub(("%s%<.*"), "")
|
|
GameCooltip:AddLine(n, _table [2] .. " (" .. _math_floor(_table [2]/self.interrupt*100) .. "%)")
|
|
_detalhes:AddTooltipBackgroundStatusbar()
|
|
GameCooltip:AddIcon ([[Interface\AddOns\Details\images\classes_small]], 1, 1, 14, 14, 0.25, 0.49609375, 0.75, 1)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
--------------------------------------------- // JANELA DETALHES // ---------------------------------------------
|
|
|
|
|
|
---------DETALHES BIFURCA��O
|
|
function atributo_misc:MontaInfo()
|
|
if (breakdownWindowFrame.sub_atributo == 3) then --interrupt
|
|
return self:MontaInfoInterrupt()
|
|
end
|
|
end
|
|
|
|
---------DETALHES bloco da direita BIFURCA��O
|
|
function atributo_misc:MontaDetalhes (spellid, barra)
|
|
if (breakdownWindowFrame.sub_atributo == 3) then --interrupt
|
|
return self:MontaDetalhesInterrupt (spellid, barra)
|
|
end
|
|
end
|
|
|
|
------ Interrupt
|
|
function atributo_misc:MontaInfoInterrupt()
|
|
|
|
local meu_total = self ["interrupt"]
|
|
|
|
if (not self.interrupt_spells) then
|
|
return
|
|
end
|
|
|
|
local minha_tabela = self.interrupt_spells._ActorTable
|
|
|
|
local barras = breakdownWindowFrame.barras1
|
|
local instancia = breakdownWindowFrame.instancia
|
|
|
|
local meus_interrupts = {}
|
|
|
|
--player
|
|
for _spellid, _tabela in pairs(minha_tabela) do --da foreach em cada spellid do container
|
|
local nome, _, icone = _GetSpellInfo(_spellid)
|
|
tinsert(meus_interrupts, {_spellid, _tabela.counter, _tabela.counter/meu_total*100, nome, icone})
|
|
end
|
|
--pet
|
|
local ActorPets = self.pets
|
|
local class_color = "FFDDDDDD"
|
|
for _, PetName in ipairs(ActorPets) do
|
|
local PetActor = instancia.showing (class_type, PetName)
|
|
if (PetActor and PetActor.interrupt and PetActor.interrupt > 0) then
|
|
local PetSkillsContainer = PetActor.interrupt_spells._ActorTable
|
|
for _spellid, _skill in pairs(PetSkillsContainer) do --da foreach em cada spellid do container
|
|
local nome, _, icone = _GetSpellInfo(_spellid)
|
|
tinsert(meus_interrupts, {_spellid, _skill.counter, _skill.counter/meu_total*100, nome .. " (|c" .. class_color .. PetName:gsub((" <.*"), "") .. "|r)", icone, PetActor})
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort (meus_interrupts, _detalhes.Sort2)
|
|
|
|
local amt = #meus_interrupts
|
|
gump:JI_AtualizaContainerBarras (amt)
|
|
|
|
local max_ = meus_interrupts [1][2] --dano que a primeiro magia vez
|
|
|
|
local barra
|
|
for index, tabela in ipairs(meus_interrupts) do
|
|
|
|
barra = barras [index]
|
|
|
|
if (not barra) then --se a barra n�o existir, criar ela ent�o
|
|
barra = gump:CriaNovaBarraInfo1 (instancia, index)
|
|
|
|
barra.textura:SetStatusBarColor(1, 1, 1, 1) --isso aqui � a parte da sele��o e descele��o
|
|
barra.on_focus = false --isso aqui � a parte da sele��o e descele��o
|
|
end
|
|
|
|
--isso aqui � tudo da sele��o e descele��o das barras
|
|
|
|
if (not breakdownWindowFrame.mostrando_mouse_over) then
|
|
if (tabela[1] == self.detalhes) then --tabela [1] = spellid = spellid que esta na caixa da direita
|
|
if (not barra.on_focus) then --se a barra n�o tiver no foco
|
|
barra.textura:SetStatusBarColor(129/255, 125/255, 69/255, 1)
|
|
barra.on_focus = true
|
|
if (not breakdownWindowFrame.mostrando) then
|
|
breakdownWindowFrame.mostrando = barra
|
|
end
|
|
end
|
|
else
|
|
if (barra.on_focus) then
|
|
barra.textura:SetStatusBarColor(1, 1, 1, 1) --volta a cor antiga
|
|
barra:SetAlpha(.9) --volta a alfa antiga
|
|
barra.on_focus = false
|
|
end
|
|
end
|
|
end
|
|
|
|
if (index == 1) then
|
|
barra.textura:SetValue(100)
|
|
else
|
|
barra.textura:SetValue(tabela[2]/max_*100) --muito mais rapido...
|
|
end
|
|
|
|
barra.lineText1:SetText(index..instancia.divisores.colocacao..tabela[4]) --seta o texto da esqueda
|
|
barra.lineText4:SetText(tabela[2] .." ".. instancia.divisores.abre .._cstr("%.1f", tabela[3]) .."%".. instancia.divisores.fecha) --seta o texto da direita
|
|
|
|
barra.icone:SetTexture(tabela[5])
|
|
|
|
barra.minha_tabela = self --grava o jogador na barrinho... � estranho pq todas as barras v�o ter o mesmo valor do jogador
|
|
barra.show = tabela[1] --grava o spellid na barra
|
|
barra:Show() --mostra a barra
|
|
|
|
if (self.detalhes and self.detalhes == barra.show) then
|
|
self:MontaDetalhes (self.detalhes, barra) --poderia deixar isso pro final e montar uma tail call??
|
|
end
|
|
end
|
|
|
|
--Alvos do interrupt
|
|
local meus_alvos = {}
|
|
for target_name, amount in pairs(self.interrupt_targets) do
|
|
meus_alvos [#meus_alvos+1] = {target_name, amount}
|
|
end
|
|
table.sort (meus_alvos, _detalhes.Sort2)
|
|
|
|
local amt_alvos = #meus_alvos
|
|
if (amt_alvos < 1) then
|
|
return
|
|
end
|
|
gump:JI_AtualizaContainerAlvos (amt_alvos)
|
|
|
|
local max_alvos = meus_alvos[1][2]
|
|
|
|
local barra
|
|
for index, tabela in ipairs(meus_alvos) do
|
|
|
|
barra = breakdownWindowFrame.barras2 [index]
|
|
|
|
if (not barra) then
|
|
barra = gump:CriaNovaBarraInfo2 (instancia, index)
|
|
barra.textura:SetStatusBarColor(1, 1, 1, 1)
|
|
end
|
|
|
|
if (index == 1) then
|
|
barra.textura:SetValue(100)
|
|
else
|
|
barra.textura:SetValue(tabela[2]/max_alvos*100)
|
|
end
|
|
|
|
barra.lineText1:SetText(index..instancia.divisores.colocacao..tabela[1]) --seta o texto da esqueda
|
|
barra.lineText4:SetText(tabela[2] .." ".. instancia.divisores.abre .._cstr("%.1f", tabela[2]/meu_total*100) .. instancia.divisores.fecha) --seta o texto da direita
|
|
|
|
if (barra.mouse_over) then --atualizar o tooltip
|
|
if (barra.isAlvo) then
|
|
GameTooltip:Hide()
|
|
GameTooltip:SetOwner(barra, "ANCHOR_TOPRIGHT")
|
|
if (not barra.minha_tabela:MontaTooltipAlvos (barra, index)) then
|
|
return
|
|
end
|
|
GameTooltip:Show()
|
|
end
|
|
end
|
|
|
|
barra.minha_tabela = self --grava o jogador na tabela
|
|
barra.nome_inimigo = tabela [1] --salva o nome do inimigo na barra --isso � necess�rio?
|
|
|
|
barra:Show()
|
|
end
|
|
|
|
end
|
|
|
|
|
|
------ Detalhe Info Interrupt
|
|
function atributo_misc:MontaDetalhesInterrupt (spellid, barra)
|
|
|
|
local esta_magia = self.interrupt_spells._ActorTable [spellid]
|
|
if (not esta_magia) then
|
|
return
|
|
end
|
|
|
|
--icone direito superior
|
|
local nome, _, icone = _GetSpellInfo(spellid)
|
|
local infospell = {nome, nil, icone}
|
|
|
|
Details.BreakdownWindowFrame.spell_icone:SetTexture(infospell[3])
|
|
|
|
local total = self.interrupt
|
|
local meu_total = esta_magia.counter
|
|
|
|
local index = 1
|
|
|
|
local data = {}
|
|
|
|
local barras = breakdownWindowFrame.barras3
|
|
local instancia = breakdownWindowFrame.instancia
|
|
|
|
local habilidades_alvos = {}
|
|
for spellid, amt in pairs(esta_magia.interrompeu_oque) do
|
|
habilidades_alvos [#habilidades_alvos+1] = {spellid, amt}
|
|
end
|
|
table.sort (habilidades_alvos, _detalhes.Sort2)
|
|
local max_ = habilidades_alvos[1][2]
|
|
|
|
local lastIndex = 1
|
|
local barra
|
|
for index, tabela in ipairs(habilidades_alvos) do
|
|
lastIndex = index
|
|
barra = barras [index]
|
|
|
|
if (not barra) then --se a barra n�o existir, criar ela ent�o
|
|
barra = gump:CriaNovaBarraInfo3 (instancia, index)
|
|
barra.textura:SetStatusBarColor(1, 1, 1, 1) --isso aqui � a parte da sele��o e descele��o
|
|
end
|
|
|
|
barra.show = tabela[1]
|
|
|
|
if (index == 1) then
|
|
barra.textura:SetValue(100)
|
|
else
|
|
barra.textura:SetValue(tabela[2]/max_*100) --muito mais rapido...
|
|
end
|
|
|
|
local nome, _, icone = _GetSpellInfo(tabela[1])
|
|
|
|
barra.lineText1:SetText(index..instancia.divisores.colocacao..nome) --seta o texto da esqueda
|
|
barra.lineText4:SetText(tabela[2] .." ".. instancia.divisores.abre .._cstr("%.1f", tabela[2]/total*100) .."%".. instancia.divisores.fecha) --seta o texto da direita
|
|
|
|
barra.icone:SetTexture(icone)
|
|
|
|
barra:Show() --mostra a barra
|
|
|
|
if (index == 15) then
|
|
break
|
|
end
|
|
end
|
|
|
|
for i = lastIndex+1, #barras do
|
|
barras[i]:Hide()
|
|
end
|
|
|
|
end
|
|
|
|
|
|
function atributo_misc:MontaTooltipAlvos (esta_barra, index)
|
|
|
|
local inimigo = esta_barra.nome_inimigo
|
|
|
|
local container
|
|
if (breakdownWindowFrame.instancia.sub_atributo == 3) then --interrupt
|
|
container = self.interrupt_spells._ActorTable
|
|
end
|
|
|
|
local habilidades = {}
|
|
local total = self.interrupt
|
|
|
|
for spellid, tabela in pairs(container) do
|
|
--tabela = classe_damage_habilidade
|
|
local alvos = tabela.targets
|
|
for target_name, amount in ipairs(alvos) do
|
|
--tabela = classe_target
|
|
if (target_name == inimigo) then
|
|
habilidades [#habilidades+1] = {spellid, amount}
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort (habilidades, _detalhes.Sort2)
|
|
|
|
GameTooltip:AddLine(index..". "..inimigo)
|
|
GameTooltip:AddLine(Loc ["STRING_SPELL_INTERRUPTED"] .. ":")
|
|
GameTooltip:AddLine(" ")
|
|
|
|
for index, tabela in ipairs(habilidades) do
|
|
local nome, rank, icone = _GetSpellInfo(tabela[1])
|
|
if (index < 8) then
|
|
GameTooltip:AddDoubleLine (index..". |T"..icone..":0|t "..nome, tabela[2].." (".._cstr("%.1f", tabela[2]/total*100).."%)", 1, 1, 1, 1, 1, 1)
|
|
else
|
|
GameTooltip:AddDoubleLine (index..". "..nome, tabela[2].." (".._cstr("%.1f", tabela[2]/total*100).."%)", .65, .65, .65, .65, .65, .65)
|
|
end
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
--controla se o dps do jogador esta travado ou destravado
|
|
function atributo_misc:GetOrChangeActivityStatus (iniciar)
|
|
return false --retorna se o dps esta aberto ou fechado para este jogador
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
--core functions
|
|
|
|
--atualize a funcao de abreviacao
|
|
function atributo_misc:UpdateSelectedToKFunction()
|
|
SelectedToKFunction = ToKFunctions [_detalhes.ps_abbreviation]
|
|
FormatTooltipNumber = ToKFunctions [_detalhes.tooltip.abbreviation]
|
|
TooltipMaximizedMethod = _detalhes.tooltip.maximize_method
|
|
headerColor = _detalhes.tooltip.header_text_color
|
|
end
|
|
|
|
|
|
local sub_list = {"cc_break", "ress", "interrupt", "cooldowns_defensive", "dispell", "dead"}
|
|
|
|
--subtract total from a combat table
|
|
function atributo_misc:subtract_total (combat_table)
|
|
for _, sub_attribute in ipairs(sub_list) do
|
|
if (self [sub_attribute]) then
|
|
combat_table.totals [class_type][sub_attribute] = combat_table.totals [class_type][sub_attribute] - self [sub_attribute]
|
|
if (self.grupo) then
|
|
combat_table.totals_grupo [class_type][sub_attribute] = combat_table.totals_grupo [class_type][sub_attribute] - self [sub_attribute]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
function atributo_misc:add_total (combat_table)
|
|
for _, sub_attribute in ipairs(sub_list) do
|
|
if (self [sub_attribute]) then
|
|
combat_table.totals [class_type][sub_attribute] = combat_table.totals [class_type][sub_attribute] + self [sub_attribute]
|
|
if (self.grupo) then
|
|
combat_table.totals_grupo [class_type][sub_attribute] = combat_table.totals_grupo [class_type][sub_attribute] + self [sub_attribute]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local refresh_alvos = function(container1, container2)
|
|
for target_name, amount in pairs(container2) do
|
|
container1 [target_name] = container1 [target_name] or 0
|
|
end
|
|
end
|
|
local refresh_habilidades = function(container1, container2)
|
|
for spellid, habilidade in pairs(container2._ActorTable) do
|
|
local habilidade_shadow = container1:PegaHabilidade(spellid, true, nil, true)
|
|
refresh_alvos(habilidade_shadow.targets , habilidade.targets)
|
|
end
|
|
end
|
|
|
|
function atributo_misc:r_onlyrefresh_shadow (actor)
|
|
|
|
local overall_misc = _detalhes.tabela_overall [4]
|
|
local shadow = overall_misc._ActorTable [overall_misc._NameIndexTable [actor.nome]]
|
|
|
|
if (not actor.nome) then
|
|
actor.nome = "unknown"
|
|
end
|
|
|
|
if (not shadow) then
|
|
shadow = overall_misc:PegarCombatente (actor.serial, actor.nome, actor.flag_original, true)
|
|
|
|
shadow.classe = actor.classe
|
|
shadow:SetSpecId(actor.spec)
|
|
shadow.grupo = actor.grupo
|
|
shadow.pvp = actor.pvp
|
|
shadow.isTank = actor.isTank
|
|
shadow.boss = actor.boss
|
|
shadow.boss_fight_component = actor.boss_fight_component
|
|
shadow.fight_component = actor.fight_component
|
|
|
|
end
|
|
|
|
_detalhes.refresh:r_atributo_misc (actor, shadow)
|
|
|
|
--cc done
|
|
if (actor.cc_done) then
|
|
refresh_alvos(shadow.cc_done_targets, actor.cc_done_targets)
|
|
refresh_habilidades(shadow.cc_done_spells, actor.cc_done_spells)
|
|
end
|
|
|
|
--cooldowns
|
|
if (actor.cooldowns_defensive) then
|
|
refresh_alvos (shadow.cooldowns_defensive_targets, actor.cooldowns_defensive_targets)
|
|
refresh_habilidades (shadow.cooldowns_defensive_spells, actor.cooldowns_defensive_spells)
|
|
end
|
|
|
|
--buff uptime
|
|
if (actor.buff_uptime) then
|
|
refresh_alvos (shadow.buff_uptime_targets, actor.buff_uptime_targets)
|
|
refresh_habilidades (shadow.buff_uptime_spells, actor.buff_uptime_spells)
|
|
|
|
if (actor.received_buffs_spells) then
|
|
if (not shadow.received_buffs_spells) then
|
|
shadow.received_buffs_spells = container_habilidades:NovoContainer(_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
refresh_habilidades(shadow.received_buffs_spells, actor.received_buffs_spells)
|
|
end
|
|
end
|
|
|
|
--debuff uptime
|
|
if (actor.debuff_uptime) then
|
|
refresh_habilidades (shadow.debuff_uptime_spells, actor.debuff_uptime_spells)
|
|
if (actor.boss_debuff) then
|
|
--
|
|
else
|
|
refresh_alvos (shadow.debuff_uptime_targets, actor.debuff_uptime_targets)
|
|
end
|
|
|
|
end
|
|
|
|
--interrupt
|
|
if (actor.interrupt) then
|
|
refresh_alvos (shadow.interrupt_targets, actor.interrupt_targets)
|
|
refresh_habilidades (shadow.interrupt_spells, actor.interrupt_spells)
|
|
for spellid, habilidade in pairs(actor.interrupt_spells._ActorTable) do
|
|
local habilidade_shadow = shadow.interrupt_spells:PegaHabilidade (spellid, true, nil, true)
|
|
habilidade_shadow.interrompeu_oque = habilidade_shadow.interrompeu_oque or {}
|
|
end
|
|
end
|
|
|
|
--ress
|
|
if (actor.ress) then
|
|
refresh_alvos (shadow.ress_targets, actor.ress_targets)
|
|
refresh_habilidades (shadow.ress_spells, actor.ress_spells)
|
|
end
|
|
|
|
--dispell
|
|
if (actor.dispell) then
|
|
refresh_alvos (shadow.dispell_targets, actor.dispell_targets)
|
|
refresh_habilidades (shadow.dispell_spells, actor.dispell_spells)
|
|
for spellid, habilidade in pairs(actor.dispell_spells._ActorTable) do
|
|
local habilidade_shadow = shadow.dispell_spells:PegaHabilidade (spellid, true, nil, true)
|
|
habilidade_shadow.dispell_oque = habilidade_shadow.dispell_oque or {}
|
|
end
|
|
end
|
|
|
|
--cc break
|
|
if (actor.cc_break) then
|
|
refresh_alvos (shadow.cc_break_targets, actor.cc_break_targets)
|
|
refresh_habilidades (shadow.cc_break_spells, actor.cc_break_spells)
|
|
for spellid, habilidade in pairs(actor.cc_break_spells._ActorTable) do
|
|
local habilidade_shadow = shadow.cc_break_spells:PegaHabilidade (spellid, true, nil, true)
|
|
habilidade_shadow.cc_break_oque = habilidade_shadow.cc_break_oque or {}
|
|
end
|
|
end
|
|
|
|
return shadow
|
|
end
|
|
|
|
local sumKeyValues = function(habilidade, habilidade_tabela1)
|
|
for key, value in pairs(habilidade) do
|
|
if (type(value) == "number") then
|
|
if (key ~= "id" and key ~= "spellschool") then
|
|
habilidade_tabela1[key] = (habilidade_tabela1[key] or 0) + value
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local sumTargetValues = function(container1, container2)
|
|
for targetName, amount in pairs(container2) do
|
|
container1[targetName] = (container1[targetName] or 0) + amount
|
|
end
|
|
end
|
|
|
|
local sumSpellTableKeyValues = function(container1, container2)
|
|
for spellId, spellTable in pairs(container2._ActorTable) do
|
|
local spellTable1 = container1:PegaHabilidade(spellId, true, nil, false)
|
|
sumTargetValues(spellTable1.targets, spellTable.targets)
|
|
sumKeyValues(spellTable, spellTable1)
|
|
end
|
|
end
|
|
|
|
function atributo_misc:r_connect_shadow(actor, no_refresh, combat_object)
|
|
local host_combat = combat_object or _detalhes.tabela_overall
|
|
|
|
--criar uma shadow desse ator se ainda n�o tiver uma
|
|
local overall_misc = host_combat[4]
|
|
local shadow = overall_misc._ActorTable[overall_misc._NameIndexTable[actor.nome]]
|
|
|
|
if (not actor.nome) then
|
|
actor.nome = "unknown"
|
|
end
|
|
|
|
if (not shadow) then
|
|
shadow = overall_misc:PegarCombatente(actor.serial, actor.nome, actor.flag_original, true)
|
|
|
|
shadow.classe = actor.classe
|
|
shadow:SetSpecId(actor.spec)
|
|
shadow.grupo = actor.grupo
|
|
shadow.pvp = actor.pvp
|
|
shadow.isTank = actor.isTank
|
|
shadow.boss = actor.boss
|
|
shadow.boss_fight_component = actor.boss_fight_component
|
|
shadow.fight_component = actor.fight_component
|
|
end
|
|
|
|
--aplica a meta e indexes
|
|
if (not no_refresh) then
|
|
_detalhes.refresh:r_atributo_misc(actor, shadow)
|
|
end
|
|
|
|
--pets (add unique pet names)
|
|
for _, petName in ipairs(actor.pets) do
|
|
DetailsFramework.table.addunique(shadow.pets, petName)
|
|
end
|
|
|
|
if (actor.cc_done) then
|
|
if (not shadow.cc_done_targets) then
|
|
shadow.cc_done = _detalhes:GetOrderNumber()
|
|
shadow.cc_done_targets = {}
|
|
shadow.cc_done_spells = container_habilidades:NovoContainer(_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
|
|
shadow.cc_done = shadow.cc_done + actor.cc_done
|
|
|
|
sumTargetValues(shadow.cc_done_targets, actor.cc_done_targets)
|
|
sumSpellTableKeyValues(shadow.cc_done_spells, actor.cc_done_spells)
|
|
end
|
|
|
|
if (actor.cooldowns_defensive) then
|
|
if (not shadow.cooldowns_defensive_targets) then
|
|
shadow.cooldowns_defensive = _detalhes:GetOrderNumber(actor.nome)
|
|
shadow.cooldowns_defensive_targets = {}
|
|
shadow.cooldowns_defensive_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
|
|
shadow.cooldowns_defensive = shadow.cooldowns_defensive + actor.cooldowns_defensive
|
|
host_combat.totals[4].cooldowns_defensive = host_combat.totals[4].cooldowns_defensive + actor.cooldowns_defensive
|
|
if (actor.grupo) then
|
|
host_combat.totals_grupo[4].cooldowns_defensive = host_combat.totals_grupo[4].cooldowns_defensive + actor.cooldowns_defensive
|
|
end
|
|
|
|
sumTargetValues (shadow.cooldowns_defensive_targets, actor.cooldowns_defensive_targets)
|
|
sumSpellTableKeyValues (shadow.cooldowns_defensive_spells, actor.cooldowns_defensive_spells)
|
|
end
|
|
|
|
if (actor.buff_uptime) then
|
|
if (not shadow.buff_uptime_targets) then
|
|
shadow.buff_uptime = 0
|
|
shadow.buff_uptime_targets = {}
|
|
shadow.buff_uptime_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
|
|
if (actor.received_buffs_spells) then
|
|
if (not shadow.received_buffs_spells) then
|
|
shadow.received_buffs_spells = container_habilidades:NovoContainer(_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
sumSpellTableKeyValues(shadow.received_buffs_spells, actor.received_buffs_spells)
|
|
end
|
|
|
|
shadow.buff_uptime = shadow.buff_uptime + actor.buff_uptime
|
|
sumTargetValues (shadow.buff_uptime_targets, actor.buff_uptime_targets)
|
|
sumSpellTableKeyValues (shadow.buff_uptime_spells, actor.buff_uptime_spells)
|
|
end
|
|
|
|
|
|
if (actor.debuff_uptime) then
|
|
if (not shadow.debuff_uptime_targets) then
|
|
shadow.debuff_uptime = 0
|
|
if (actor.boss_debuff) then
|
|
shadow.debuff_uptime_targets = {}
|
|
shadow.boss_debuff = true
|
|
shadow.damage_twin = actor.damage_twin
|
|
shadow.spellschool = actor.spellschool
|
|
shadow.damage_spellid = actor.damage_spellid
|
|
shadow.debuff_uptime = 0
|
|
else
|
|
shadow.debuff_uptime_targets = {}
|
|
end
|
|
shadow.debuff_uptime_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
|
|
shadow.debuff_uptime = shadow.debuff_uptime + actor.debuff_uptime
|
|
|
|
for target_name, amount in pairs(actor.debuff_uptime_targets) do
|
|
if (type(amount) == "table") then --boss debuff
|
|
local t = shadow.debuff_uptime_targets [target_name]
|
|
if (not t) then
|
|
shadow.debuff_uptime_targets [target_name] = atributo_misc:CreateBuffTargetObject()
|
|
t = shadow.debuff_uptime_targets [target_name]
|
|
end
|
|
t.uptime = t.uptime + amount.uptime
|
|
t.activedamt = t.activedamt + amount.activedamt
|
|
t.refreshamt = t.refreshamt + amount.refreshamt
|
|
t.appliedamt = t.appliedamt + amount.appliedamt
|
|
else
|
|
shadow.debuff_uptime_targets [target_name] = (shadow.debuff_uptime_targets [target_name] or 0) + amount
|
|
end
|
|
end
|
|
|
|
sumSpellTableKeyValues (shadow.debuff_uptime_spells, actor.debuff_uptime_spells)
|
|
end
|
|
|
|
--interrupt
|
|
if (actor.interrupt) then
|
|
if (not shadow.interrupt_targets) then
|
|
shadow.interrupt = 0
|
|
shadow.interrupt_targets = {}
|
|
shadow.interrupt_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS) --cria o container das habilidades usadas para interromper
|
|
shadow.interrompeu_oque = {}
|
|
end
|
|
|
|
shadow.interrupt = shadow.interrupt + actor.interrupt
|
|
host_combat.totals[4].interrupt = host_combat.totals[4].interrupt + actor.interrupt
|
|
if (actor.grupo) then
|
|
host_combat.totals_grupo[4].interrupt = host_combat.totals_grupo[4].interrupt + actor.interrupt
|
|
end
|
|
|
|
sumTargetValues (shadow.interrupt_targets, actor.interrupt_targets)
|
|
sumSpellTableKeyValues (shadow.interrupt_spells, actor.interrupt_spells)
|
|
|
|
for spellid, habilidade in pairs(actor.interrupt_spells._ActorTable) do
|
|
local habilidade_shadow = shadow.interrupt_spells:PegaHabilidade (spellid, true, nil, true)
|
|
|
|
habilidade_shadow.interrompeu_oque = habilidade_shadow.interrompeu_oque or {}
|
|
|
|
for _spellid, amount in pairs(habilidade.interrompeu_oque) do
|
|
habilidade_shadow.interrompeu_oque [_spellid] = (habilidade_shadow.interrompeu_oque [_spellid] or 0) + amount
|
|
end
|
|
end
|
|
for spellid, amount in pairs(actor.interrompeu_oque) do
|
|
shadow.interrompeu_oque [spellid] = (shadow.interrompeu_oque [spellid] or 0) + amount
|
|
end
|
|
end
|
|
|
|
--ress
|
|
if (actor.ress) then
|
|
if (not shadow.ress_targets) then
|
|
shadow.ress = 0
|
|
shadow.ress_targets = {}
|
|
shadow.ress_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
|
|
shadow.ress = shadow.ress + actor.ress
|
|
host_combat.totals[4].ress = host_combat.totals[4].ress + actor.ress
|
|
if (actor.grupo) then
|
|
host_combat.totals_grupo[4].ress = host_combat.totals_grupo[4].ress + actor.ress
|
|
end
|
|
|
|
sumTargetValues (shadow.ress_targets, actor.ress_targets)
|
|
sumSpellTableKeyValues (shadow.ress_spells, actor.ress_spells)
|
|
end
|
|
|
|
--dispell
|
|
if (actor.dispell) then
|
|
if (not shadow.dispell_targets) then
|
|
shadow.dispell = 0
|
|
shadow.dispell_targets = {}
|
|
shadow.dispell_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
shadow.dispell_oque = {}
|
|
end
|
|
|
|
shadow.dispell = shadow.dispell + actor.dispell
|
|
host_combat.totals[4].dispell = host_combat.totals[4].dispell + actor.dispell
|
|
if (actor.grupo) then
|
|
host_combat.totals_grupo[4].dispell = host_combat.totals_grupo[4].dispell + actor.dispell
|
|
end
|
|
|
|
sumTargetValues (shadow.dispell_targets, actor.dispell_targets)
|
|
sumSpellTableKeyValues (shadow.dispell_spells, actor.dispell_spells)
|
|
|
|
for spellid, habilidade in pairs(actor.dispell_spells._ActorTable) do
|
|
local habilidade_shadow = shadow.dispell_spells:PegaHabilidade (spellid, true, nil, true)
|
|
habilidade_shadow.dispell_oque = habilidade_shadow.dispell_oque or {}
|
|
for _spellid, amount in pairs(habilidade.dispell_oque) do
|
|
habilidade_shadow.dispell_oque [_spellid] = (habilidade_shadow.dispell_oque [_spellid] or 0) + amount
|
|
end
|
|
end
|
|
|
|
for spellid, amount in pairs(actor.dispell_oque) do
|
|
shadow.dispell_oque [spellid] = (shadow.dispell_oque [spellid] or 0) + amount
|
|
end
|
|
end
|
|
|
|
if (actor.cc_break) then
|
|
if (not shadow.cc_break) then
|
|
shadow.cc_break = 0
|
|
shadow.cc_break_targets = {}
|
|
shadow.cc_break_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS) --cria o container das habilidades usadas para interromper
|
|
shadow.cc_break_oque = {}
|
|
end
|
|
|
|
shadow.cc_break = shadow.cc_break + actor.cc_break
|
|
host_combat.totals[4].cc_break = host_combat.totals[4].cc_break + actor.cc_break
|
|
if (actor.grupo) then
|
|
host_combat.totals_grupo[4].cc_break = host_combat.totals_grupo[4].cc_break + actor.cc_break
|
|
end
|
|
|
|
sumTargetValues (shadow.cc_break_targets, actor.cc_break_targets)
|
|
sumSpellTableKeyValues (shadow.cc_break_spells, actor.cc_break_spells)
|
|
|
|
for spellid, habilidade in pairs(actor.cc_break_spells._ActorTable) do
|
|
local habilidade_shadow = shadow.cc_break_spells:PegaHabilidade (spellid, true, nil, true)
|
|
habilidade_shadow.cc_break_oque = habilidade_shadow.cc_break_oque or {}
|
|
for _spellid, amount in pairs(habilidade.cc_break_oque) do
|
|
habilidade_shadow.cc_break_oque [_spellid] = (habilidade_shadow.cc_break_oque [_spellid] or 0) + amount
|
|
end
|
|
end
|
|
for spellid, amount in pairs(actor.cc_break_oque) do
|
|
shadow.cc_break_oque [spellid] = (shadow.cc_break_oque [spellid] or 0) + amount
|
|
end
|
|
end
|
|
|
|
return shadow
|
|
|
|
end
|
|
|
|
function _detalhes.refresh:r_atributo_misc(thisActor, shadow)
|
|
setmetatable(thisActor, _detalhes.atributo_misc)
|
|
detailsFramework:Mixin(thisActor, Details222.Mixins.ActorMixin)
|
|
|
|
thisActor.__index = _detalhes.atributo_misc
|
|
|
|
--refresh cc done
|
|
if (thisActor.cc_done) then
|
|
if (shadow and not shadow.cc_done_targets) then
|
|
shadow.cc_done = 0
|
|
shadow.cc_done_targets = {}
|
|
shadow.cc_done_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
_detalhes.refresh:r_container_habilidades (thisActor.cc_done_spells, shadow and shadow.cc_done_spells)
|
|
end
|
|
|
|
--refresh interrupts
|
|
if (thisActor.interrupt_targets) then
|
|
if (shadow and not shadow.interrupt_targets) then
|
|
shadow.interrupt = 0
|
|
shadow.interrupt_targets = {}
|
|
shadow.interrupt_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
shadow.interrompeu_oque = {}
|
|
end
|
|
_detalhes.refresh:r_container_habilidades (thisActor.interrupt_spells, shadow and shadow.interrupt_spells)
|
|
end
|
|
|
|
--refresh buff uptime
|
|
if (thisActor.buff_uptime_targets) then
|
|
if (shadow and not shadow.buff_uptime_targets) then
|
|
shadow.buff_uptime = 0
|
|
shadow.buff_uptime_targets = {}
|
|
shadow.buff_uptime_spells = container_habilidades:NovoContainer(_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
|
|
if (thisActor.received_buffs_spells) then
|
|
shadow.received_buffs_spells = container_habilidades:NovoContainer(_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
end
|
|
|
|
_detalhes.refresh:r_container_habilidades(thisActor.buff_uptime_spells, shadow and shadow.buff_uptime_spells)
|
|
|
|
if (thisActor.received_buffs_spells) then
|
|
_detalhes.refresh:r_container_habilidades(thisActor.received_buffs_spells, shadow and shadow.received_buffs_spells)
|
|
end
|
|
end
|
|
|
|
--refresh buff uptime
|
|
if (thisActor.debuff_uptime_targets) then
|
|
if (shadow and not shadow.debuff_uptime_targets) then
|
|
shadow.debuff_uptime = 0
|
|
if (thisActor.boss_debuff) then
|
|
shadow.debuff_uptime_targets = {}
|
|
shadow.boss_debuff = true
|
|
shadow.damage_twin = thisActor.damage_twin
|
|
shadow.spellschool = thisActor.spellschool
|
|
shadow.damage_spellid = thisActor.damage_spellid
|
|
shadow.debuff_uptime = 0
|
|
else
|
|
shadow.debuff_uptime_targets = {}
|
|
end
|
|
shadow.debuff_uptime_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
_detalhes.refresh:r_container_habilidades (thisActor.debuff_uptime_spells, shadow and shadow.debuff_uptime_spells)
|
|
end
|
|
|
|
--refresh cooldowns defensive
|
|
if (thisActor.cooldowns_defensive_targets) then
|
|
if (shadow and not shadow.cooldowns_defensive_targets) then
|
|
shadow.cooldowns_defensive = 0
|
|
shadow.cooldowns_defensive_targets = {}
|
|
shadow.cooldowns_defensive_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
_detalhes.refresh:r_container_habilidades (thisActor.cooldowns_defensive_spells, shadow and shadow.cooldowns_defensive_spells)
|
|
end
|
|
|
|
--refresh ressers
|
|
if (thisActor.ress_targets) then
|
|
if (shadow and not shadow.ress_targets) then
|
|
shadow.ress = 0
|
|
shadow.ress_targets = {}
|
|
shadow.ress_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
end
|
|
_detalhes.refresh:r_container_habilidades (thisActor.ress_spells, shadow and shadow.ress_spells)
|
|
end
|
|
|
|
--refresh dispells
|
|
if (thisActor.dispell_targets) then
|
|
if (shadow and not shadow.dispell_targets) then
|
|
shadow.dispell = 0
|
|
shadow.dispell_targets = {}
|
|
shadow.dispell_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS) --cria o container das habilidades usadas para interromper
|
|
shadow.dispell_oque = {}
|
|
end
|
|
_detalhes.refresh:r_container_habilidades (thisActor.dispell_spells, shadow and shadow.dispell_spells)
|
|
end
|
|
|
|
--refresh cc_breaks
|
|
if (thisActor.cc_break_targets) then
|
|
if (shadow and not shadow.cc_break) then
|
|
shadow.cc_break = 0
|
|
shadow.cc_break_targets = {}
|
|
shadow.cc_break_spells = container_habilidades:NovoContainer (_detalhes.container_type.CONTAINER_MISC_CLASS)
|
|
shadow.cc_break_oque = {}
|
|
end
|
|
_detalhes.refresh:r_container_habilidades (thisActor.cc_break_spells, shadow and shadow.cc_break_spells)
|
|
end
|
|
end
|
|
|
|
function _detalhes.clear:c_atributo_misc (este_jogador)
|
|
este_jogador.__index = nil
|
|
este_jogador.links = nil
|
|
este_jogador.minha_barra = nil
|
|
|
|
if (este_jogador.cc_done_targets) then
|
|
_detalhes.clear:c_container_habilidades (este_jogador.cc_done_spells)
|
|
end
|
|
|
|
if (este_jogador.interrupt_targets) then
|
|
_detalhes.clear:c_container_habilidades (este_jogador.interrupt_spells)
|
|
end
|
|
|
|
if (este_jogador.cooldowns_defensive_targets) then
|
|
_detalhes.clear:c_container_habilidades (este_jogador.cooldowns_defensive_spells)
|
|
end
|
|
|
|
if (este_jogador.buff_uptime_targets) then
|
|
_detalhes.clear:c_container_habilidades(este_jogador.buff_uptime_spells)
|
|
|
|
if (este_jogador.received_buffs_spells) then
|
|
_detalhes.clear:c_container_habilidades(este_jogador.received_buffs_spells)
|
|
end
|
|
end
|
|
|
|
if (este_jogador.debuff_uptime_targets) then
|
|
_detalhes.clear:c_container_habilidades (este_jogador.debuff_uptime_spells)
|
|
end
|
|
|
|
if (este_jogador.ress_targets) then
|
|
_detalhes.clear:c_container_habilidades (este_jogador.ress_spells)
|
|
end
|
|
|
|
if (este_jogador.cc_break_targets) then
|
|
_detalhes.clear:c_container_habilidades (este_jogador.cc_break_spells)
|
|
end
|
|
|
|
if (este_jogador.dispell_targets) then
|
|
_detalhes.clear:c_container_habilidades (este_jogador.dispell_spells)
|
|
end
|
|
|
|
end
|
|
|
|
atributo_misc.__add = function(tabela1, tabela2)
|
|
if (tabela2.cc_done) then
|
|
tabela1.cc_done = tabela1.cc_done + tabela2.cc_done
|
|
|
|
for targetName, amount in pairs(tabela2.cc_done_targets) do
|
|
tabela1.cc_done_targets[targetName] = (tabela1.cc_done_targets[targetName] or 0) + amount
|
|
end
|
|
|
|
for spellId, spellTable in pairs(tabela2.cc_done_spells._ActorTable) do
|
|
local spellTable1 = tabela1.cc_done_spells:PegaHabilidade(spellId, true, nil, false)
|
|
|
|
for target_name, amount in pairs(spellTable.targets) do
|
|
spellTable1.targets[target_name] = (spellTable1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues(spellTable, spellTable1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.interrupt) then
|
|
if (not tabela1.interrupt) then
|
|
tabela1.interrupt = 0
|
|
tabela1.interrupt_targets = {}
|
|
tabela1.interrupt_spells = container_habilidades:NovoContainer(container_misc)
|
|
tabela1.interrompeu_oque = {}
|
|
end
|
|
|
|
--total de interrupts
|
|
tabela1.interrupt = tabela1.interrupt + tabela2.interrupt
|
|
|
|
--soma o interrompeu o que
|
|
for spellid, amount in pairs(tabela2.interrompeu_oque) do
|
|
tabela1.interrompeu_oque[spellid] = (tabela1.interrompeu_oque [spellid] or 0) + amount
|
|
end
|
|
|
|
--soma os containers de alvos
|
|
for target_name, amount in pairs(tabela2.interrupt_targets) do
|
|
tabela1.interrupt_targets[target_name] = (tabela1.interrupt_targets[target_name] or 0) + amount
|
|
end
|
|
|
|
--soma o container de habilidades
|
|
for spellid, habilidade in pairs(tabela2.interrupt_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.interrupt_spells:PegaHabilidade(spellid, true, nil, false)
|
|
|
|
habilidade_tabela1.interrompeu_oque = habilidade_tabela1.interrompeu_oque or {}
|
|
for _spellid, amount in pairs(habilidade.interrompeu_oque) do
|
|
habilidade_tabela1.interrompeu_oque[_spellid] = (habilidade_tabela1.interrompeu_oque[_spellid] or 0) + amount
|
|
end
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues (habilidade, habilidade_tabela1)
|
|
end
|
|
|
|
end
|
|
|
|
if (tabela2.buff_uptime) then
|
|
if (not tabela1.buff_uptime) then
|
|
tabela1.buff_uptime = 0
|
|
tabela1.buff_uptime_targets = {}
|
|
tabela1.buff_uptime_spells = container_habilidades:NovoContainer(container_misc)
|
|
end
|
|
|
|
if (tabela2.received_buffs_spells) then
|
|
if (not tabela1.received_buffs_spells) then
|
|
tabela1.received_buffs_spells = container_habilidades:NovoContainer(container_misc)
|
|
end
|
|
|
|
for spellId, spellTable in pairs(tabela2.received_buffs_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.received_buffs_spells:PegaHabilidade(spellId, true, nil, false)
|
|
|
|
for target_name, amount in pairs(spellTable.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues(spellTable, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
tabela1.buff_uptime = tabela1.buff_uptime + tabela2.buff_uptime
|
|
|
|
for target_name, amount in pairs(tabela2.buff_uptime_targets) do
|
|
tabela1.buff_uptime_targets[target_name] = (tabela1.buff_uptime_targets[target_name] or 0) + amount
|
|
end
|
|
|
|
for spellId, spellTable in pairs(tabela2.buff_uptime_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.buff_uptime_spells:PegaHabilidade(spellId, true, nil, false)
|
|
|
|
for target_name, amount in pairs(spellTable.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues(spellTable, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.debuff_uptime) then
|
|
if (not tabela1.debuff_uptime) then
|
|
if (tabela2.boss_debuff) then
|
|
tabela1.debuff_uptime_targets = {}
|
|
tabela1.boss_debuff = true
|
|
tabela1.damage_twin = tabela2.damage_twin
|
|
tabela1.spellschool = tabela2.spellschool
|
|
tabela1.damage_spellid = tabela2.damage_spellid
|
|
else
|
|
tabela1.debuff_uptime_targets = {}
|
|
end
|
|
|
|
tabela1.debuff_uptime = 0
|
|
tabela1.debuff_uptime_spells = container_habilidades:NovoContainer (container_misc)
|
|
end
|
|
|
|
tabela1.debuff_uptime = tabela1.debuff_uptime + tabela2.debuff_uptime
|
|
|
|
for target_name, amount in pairs(tabela2.debuff_uptime_targets) do
|
|
if (type(amount) == "table") then --boss debuff
|
|
local t = tabela1.debuff_uptime_targets[target_name]
|
|
if (not t) then
|
|
tabela1.debuff_uptime_targets[target_name] = atributo_misc:CreateBuffTargetObject()
|
|
t = tabela1.debuff_uptime_targets[target_name]
|
|
end
|
|
t.uptime = t.uptime + amount.uptime
|
|
t.activedamt = t.activedamt + amount.activedamt
|
|
t.refreshamt = t.refreshamt + amount.refreshamt
|
|
t.appliedamt = t.appliedamt + amount.appliedamt
|
|
else
|
|
tabela1.debuff_uptime_targets[target_name] = (tabela1.debuff_uptime_targets[target_name] or 0) + amount
|
|
end
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.debuff_uptime_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.debuff_uptime_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues (habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.cooldowns_defensive) then
|
|
if (not tabela1.cooldowns_defensive) then
|
|
tabela1.cooldowns_defensive = 0
|
|
tabela1.cooldowns_defensive_targets = {}
|
|
tabela1.cooldowns_defensive_spells = container_habilidades:NovoContainer (container_misc)
|
|
end
|
|
|
|
tabela1.cooldowns_defensive = tabela1.cooldowns_defensive + tabela2.cooldowns_defensive
|
|
|
|
for target_name, amount in pairs(tabela2.cooldowns_defensive_targets) do
|
|
tabela1.cooldowns_defensive_targets[target_name] = (tabela1.cooldowns_defensive_targets[target_name] or 0) + amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.cooldowns_defensive_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.cooldowns_defensive_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues (habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.ress) then
|
|
if (not tabela1.ress) then
|
|
tabela1.ress = 0
|
|
tabela1.ress_targets = {}
|
|
tabela1.ress_spells = container_habilidades:NovoContainer (container_misc)
|
|
end
|
|
|
|
tabela1.ress = tabela1.ress + tabela2.ress
|
|
|
|
for target_name, amount in pairs(tabela2.ress_targets) do
|
|
tabela1.ress_targets[target_name] = (tabela1.ress_targets[target_name] or 0) + amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.ress_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.ress_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues (habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.dispell) then
|
|
|
|
if (not tabela1.dispell) then
|
|
tabela1.dispell = 0
|
|
tabela1.dispell_targets = {}
|
|
tabela1.dispell_spells = container_habilidades:NovoContainer (container_misc)
|
|
tabela1.dispell_oque = {}
|
|
end
|
|
|
|
tabela1.dispell = tabela1.dispell + tabela2.dispell
|
|
|
|
for target_name, amount in pairs(tabela2.dispell_targets) do
|
|
tabela1.dispell_targets[target_name] = (tabela1.dispell_targets[target_name] or 0) + amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.dispell_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.dispell_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
habilidade_tabela1.dispell_oque = habilidade_tabela1.dispell_oque or {}
|
|
|
|
for _spellid, amount in pairs(habilidade.dispell_oque) do
|
|
habilidade_tabela1.dispell_oque[_spellid] = (habilidade_tabela1.dispell_oque[_spellid] or 0) + amount
|
|
end
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues (habilidade, habilidade_tabela1)
|
|
end
|
|
|
|
for spellid, amount in pairs(tabela2.dispell_oque) do
|
|
tabela1.dispell_oque[spellid] = (tabela1.dispell_oque[spellid] or 0) + amount
|
|
end
|
|
|
|
end
|
|
|
|
if (tabela2.cc_break) then
|
|
if (not tabela1.cc_break) then
|
|
tabela1.cc_break = 0
|
|
tabela1.cc_break_targets = {}
|
|
tabela1.cc_break_spells = container_habilidades:NovoContainer (container_misc)
|
|
tabela1.cc_break_oque = {}
|
|
end
|
|
|
|
tabela1.cc_break = tabela1.cc_break + tabela2.cc_break
|
|
|
|
for target_name, amount in pairs(tabela2.cc_break_targets) do
|
|
tabela1.cc_break_targets[target_name] = (tabela1.cc_break_targets[target_name] or 0) + amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.cc_break_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.cc_break_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
habilidade_tabela1.cc_break_oque = habilidade_tabela1.cc_break_oque or {}
|
|
for _spellid, amount in pairs(habilidade.cc_break_oque) do
|
|
habilidade_tabela1.cc_break_oque[_spellid] = (habilidade_tabela1.cc_break_oque[_spellid] or 0) + amount
|
|
end
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) + amount
|
|
end
|
|
|
|
sumKeyValues (habilidade, habilidade_tabela1)
|
|
end
|
|
|
|
for spellid, amount in pairs(tabela2.cc_break_oque) do
|
|
tabela1.cc_break_oque[spellid] = (tabela1.cc_break_oque[spellid] or 0) + amount
|
|
end
|
|
end
|
|
|
|
return tabela1
|
|
end
|
|
|
|
local subtractKeyValues = function(habilidade, habilidade_tabela1)
|
|
for key, value in pairs(habilidade) do
|
|
if (type(value) == "number") then
|
|
if (key ~= "id" and key ~= "spellschool") then
|
|
habilidade_tabela1[key] = (habilidade_tabela1[key] or 0) - value
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
atributo_misc.__sub = function(tabela1, tabela2)
|
|
if (tabela2.cc_done) then
|
|
tabela1.cc_done = tabela1.cc_done - tabela2.cc_done
|
|
|
|
for target_name, amount in pairs(tabela2.cc_done_targets) do
|
|
tabela1.cc_done_targets[target_name] = (tabela1.cc_done_targets[target_name] or 0) - amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.cc_done_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.cc_done_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.interrupt) then
|
|
--total de interrupts
|
|
tabela1.interrupt = tabela1.interrupt - tabela2.interrupt
|
|
|
|
--soma o interrompeu o que
|
|
for spellid, amount in pairs(tabela2.interrompeu_oque) do
|
|
tabela1.interrompeu_oque[spellid] = (tabela1.interrompeu_oque[spellid] or 0) - amount
|
|
end
|
|
|
|
--soma os containers de alvos
|
|
for target_name, amount in pairs(tabela2.interrupt_targets) do
|
|
tabela1.interrupt_targets[target_name] = (tabela1.interrupt_targets[target_name] or 0) - amount
|
|
end
|
|
|
|
--soma o container de habilidades
|
|
for spellid, habilidade in pairs(tabela2.interrupt_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.interrupt_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
habilidade_tabela1.interrompeu_oque = habilidade_tabela1.interrompeu_oque or {}
|
|
for _spellid, amount in pairs(habilidade.interrompeu_oque) do
|
|
habilidade_tabela1.interrompeu_oque[_spellid] = (habilidade_tabela1.interrompeu_oque[_spellid] or 0) - amount
|
|
end
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.buff_uptime) then
|
|
tabela1.buff_uptime = tabela1.buff_uptime - tabela2.buff_uptime
|
|
|
|
for target_name, amount in pairs(tabela2.buff_uptime_targets) do
|
|
tabela1.buff_uptime_targets[target_name] = (tabela1.buff_uptime_targets[target_name] or 0) - amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.buff_uptime_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.buff_uptime_spells:PegaHabilidade(spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
|
|
if (tabela2.received_buffs_spells) then
|
|
for spellId, spellTable in pairs(tabela2.received_buffs_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.received_buffs_spells:PegaHabilidade(spellId, true, nil, false)
|
|
subtractKeyValues(spellTable, habilidade_tabela1)
|
|
end
|
|
end
|
|
end
|
|
|
|
if (tabela2.debuff_uptime) then
|
|
tabela1.debuff_uptime = tabela1.debuff_uptime - tabela2.debuff_uptime
|
|
|
|
for target_name, amount in pairs(tabela2.debuff_uptime_targets) do
|
|
if (type(amount) == "table") then --boss debuff
|
|
local t = tabela1.debuff_uptime_targets[target_name]
|
|
if (not t) then
|
|
tabela1.debuff_uptime_targets[target_name] = atributo_misc:CreateBuffTargetObject()
|
|
t = tabela1.debuff_uptime_targets[target_name]
|
|
end
|
|
t.uptime = t.uptime - amount.uptime
|
|
t.activedamt = t.activedamt - amount.activedamt
|
|
t.refreshamt = t.refreshamt - amount.refreshamt
|
|
t.appliedamt = t.appliedamt - amount.appliedamt
|
|
else
|
|
tabela2.debuff_uptime_targets[target_name] = (tabela2.debuff_uptime_targets[target_name] or 0) - amount
|
|
end
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.debuff_uptime_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.debuff_uptime_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.cooldowns_defensive) then
|
|
tabela1.cooldowns_defensive = tabela1.cooldowns_defensive - tabela2.cooldowns_defensive
|
|
|
|
for target_name, amount in pairs(tabela2.cooldowns_defensive_targets) do
|
|
tabela1.cooldowns_defensive_targets[target_name] = (tabela1.cooldowns_defensive_targets[target_name] or 0) - amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.cooldowns_defensive_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.cooldowns_defensive_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.ress) then
|
|
tabela1.ress = tabela1.ress - tabela2.ress
|
|
|
|
for target_name, amount in pairs(tabela2.ress_targets) do
|
|
tabela1.ress_targets[target_name] = (tabela1.ress_targets[target_name] or 0) - amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.ress_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.ress_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
end
|
|
|
|
if (tabela2.dispell) then
|
|
tabela1.dispell = tabela1.dispell - tabela2.dispell
|
|
|
|
for target_name, amount in pairs(tabela2.dispell_targets) do
|
|
tabela1.dispell_targets[target_name] = (tabela1.dispell_targets[target_name] or 0) - amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.dispell_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.dispell_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
habilidade_tabela1.dispell_oque = habilidade_tabela1.dispell_oque or {}
|
|
|
|
for _spellid, amount in pairs(habilidade.dispell_oque) do
|
|
habilidade_tabela1.dispell_oque[_spellid] = (habilidade_tabela1.dispell_oque[_spellid] or 0) - amount
|
|
end
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
|
|
for spellid, amount in pairs(tabela2.dispell_oque) do
|
|
tabela1.dispell_oque[spellid] = (tabela1.dispell_oque[spellid] or 0) - amount
|
|
end
|
|
end
|
|
|
|
if (tabela2.cc_break) then
|
|
tabela1.cc_break = tabela1.cc_break - tabela2.cc_break
|
|
|
|
for target_name, amount in pairs(tabela2.cc_break_targets) do
|
|
tabela1.cc_break_targets[target_name] = (tabela1.cc_break_targets[target_name] or 0) - amount
|
|
end
|
|
|
|
for spellid, habilidade in pairs(tabela2.cc_break_spells._ActorTable) do
|
|
local habilidade_tabela1 = tabela1.cc_break_spells:PegaHabilidade (spellid, true, nil, false)
|
|
|
|
habilidade_tabela1.cc_break_oque = habilidade_tabela1.cc_break_oque or {}
|
|
for _spellid, amount in pairs(habilidade.cc_break_oque) do
|
|
habilidade_tabela1.cc_break_oque[_spellid] = (habilidade_tabela1.cc_break_oque[_spellid] or 0) - amount
|
|
end
|
|
|
|
for target_name, amount in pairs(habilidade.targets) do
|
|
habilidade_tabela1.targets[target_name] = (habilidade_tabela1.targets[target_name] or 0) - amount
|
|
end
|
|
|
|
subtractKeyValues(habilidade, habilidade_tabela1)
|
|
end
|
|
|
|
for spellid, amount in pairs(tabela2.cc_break_oque) do
|
|
tabela1.cc_break_oque[spellid] = (tabela1.cc_break_oque[spellid] or 0) - amount
|
|
end
|
|
end
|
|
|
|
return tabela1
|
|
end
|
|
|