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.
602 lines
30 KiB
602 lines
30 KiB
|
|
local addonName, Details222 = ...
|
|
local Details = Details
|
|
local _
|
|
|
|
---@type detailsframework
|
|
local detailsFramework = DetailsFramework
|
|
|
|
local CONST_SPELLID_EBONMIGHT = 395152
|
|
local CONST_SPELLID_SS = 413984
|
|
local CONST_SPELLID_PRESCIENCE = 410089
|
|
local CONST_SPELLID_EONS_BREATH = 409560
|
|
local CONST_SPELLID_TANK_SHIELD = 360827
|
|
local CONST_SPELLID_INFERNOBLESS = 410263
|
|
|
|
local UnitExists = UnitExists
|
|
local UnitIsUnit = UnitIsUnit
|
|
local GetSpellInfo = Details222.GetSpellInfo
|
|
local UnitAuraBySpellName = C_UnitAuras.GetAuraDataBySpellName
|
|
|
|
local augmentationFunctions = Details222.SpecHelpers[1473]
|
|
local augmentationCache = Details222.SpecHelpers[1473].augmentation_cache
|
|
|
|
local playerRealmName = GetRealmName()
|
|
|
|
local getAmountOfBuffsAppliedBySpellId = function(spellId)
|
|
local amountBuffs = 0
|
|
local spellName = GetSpellInfo(spellId)
|
|
|
|
for i, unitId in ipairs(Details222.UnitIdCache.Party) do
|
|
if (UnitExists(unitId)) then
|
|
if UnitAuraBySpellName(unitId, spellName) then
|
|
amountBuffs = amountBuffs + 1
|
|
end
|
|
else
|
|
break
|
|
end
|
|
end
|
|
|
|
return amountBuffs
|
|
end
|
|
|
|
local eventListener = Details:CreateEventListener()
|
|
--eventListener:RegisterEvent("COMBAT_PLAYER_ENTER")
|
|
eventListener:RegisterEvent("COMBAT_PLAYER_LEAVING", function(eventName, combatObject)
|
|
--check if the expansion the player is playing has the augmentation evokers
|
|
if (not detailsFramework.ExpansionHasAugEvoker()) then
|
|
return
|
|
end
|
|
|
|
--close the time on the current amount of prescience stacks the evoker have
|
|
---@type combat
|
|
local combat = Details:GetCurrentCombat()
|
|
|
|
local amountOfAugEvokers = 0
|
|
|
|
---@type actorcontainer
|
|
local damageContainer = combat:GetContainer(DETAILS_ATTRIBUTE_DAMAGE)
|
|
---@type actor[]
|
|
local players = {}
|
|
---@type actor
|
|
local augEvokerObject
|
|
|
|
for index, actorObject in damageContainer:ListActors() do
|
|
--check the specId to know if the actor has the augmentation specId
|
|
if (actorObject.spec == 1473) then
|
|
amountOfAugEvokers = amountOfAugEvokers + 1
|
|
players[#players+1] = actorObject
|
|
augEvokerObject = actorObject
|
|
|
|
elseif (actorObject:IsPlayer()) then
|
|
players[#players+1] = actorObject
|
|
end
|
|
end
|
|
|
|
--print("players", #players, "amountOfAugEvokers:", amountOfAugEvokers, augEvokerObject and augEvokerObject:Name() or "nil")
|
|
|
|
if (amountOfAugEvokers == 1 and augEvokerObject) then
|
|
local breathOfEonsDamage = 0
|
|
local infernoBlessingDamage = 0
|
|
local fateMirrorDamage = 0
|
|
local blisteringScalesDamage = 0
|
|
|
|
for i = 1, #players do
|
|
---@actor
|
|
local playerObject = players[i]
|
|
local spellContainer = playerObject:GetSpellContainer("spell")
|
|
|
|
local breathOfEons = spellContainer:GetSpell(CONST_SPELLID_EONS_BREATH)
|
|
local infornoBlessing = spellContainer:GetSpell(CONST_SPELLID_INFERNOBLESS)
|
|
local blisteringScales = spellContainer:GetSpell(CONST_SPELLID_TANK_SHIELD)
|
|
local fateMirror = spellContainer:GetSpell(CONST_SPELLID_SS)
|
|
|
|
if (breathOfEons and breathOfEons.total >= 1) then
|
|
breathOfEonsDamage = breathOfEonsDamage + breathOfEons.total
|
|
end
|
|
|
|
if (infornoBlessing and infornoBlessing.total >= 1) then
|
|
infernoBlessingDamage = infernoBlessingDamage + infornoBlessing.total
|
|
end
|
|
|
|
if (blisteringScales and blisteringScales.total >= 1) then
|
|
blisteringScalesDamage = blisteringScalesDamage + blisteringScales.total
|
|
end
|
|
|
|
if (fateMirror and fateMirror.total >= 1) then
|
|
fateMirrorDamage = fateMirrorDamage + fateMirror.total
|
|
end
|
|
end
|
|
|
|
local augmentedSpellContainer = augEvokerObject.augmentedSpellsContainer
|
|
|
|
if (breathOfEonsDamage > 0) then
|
|
local bCanCreateSpellIfMissing = true
|
|
local breathOfEonsSpell = augmentedSpellContainer:GetOrCreateSpell(CONST_SPELLID_EONS_BREATH, bCanCreateSpellIfMissing, "SPELL_DAMAGE")
|
|
breathOfEonsSpell.total = breathOfEonsDamage
|
|
end
|
|
|
|
if (infernoBlessingDamage > 0) then
|
|
local bCanCreateSpellIfMissing = true
|
|
local infernoBlessingSpell = augmentedSpellContainer:GetOrCreateSpell(CONST_SPELLID_INFERNOBLESS, bCanCreateSpellIfMissing, "SPELL_DAMAGE")
|
|
infernoBlessingSpell.total = infernoBlessingDamage
|
|
end
|
|
|
|
if (blisteringScalesDamage > 0) then
|
|
local bCanCreateSpellIfMissing = true
|
|
local blisteringScalesSpell = augmentedSpellContainer:GetOrCreateSpell(CONST_SPELLID_TANK_SHIELD, bCanCreateSpellIfMissing, "SPELL_DAMAGE")
|
|
blisteringScalesSpell.total = blisteringScalesDamage
|
|
end
|
|
|
|
if (fateMirrorDamage > 0) then
|
|
local bCanCreateSpellIfMissing = true
|
|
local fateMirrorSpell = augmentedSpellContainer:GetOrCreateSpell(CONST_SPELLID_SS, bCanCreateSpellIfMissing, "SPELL_DAMAGE")
|
|
fateMirrorSpell.total = fateMirrorDamage
|
|
end
|
|
end
|
|
|
|
--[=[
|
|
---@type actorcontainer
|
|
local damageContainer = combat:GetContainer(DETAILS_ATTRIBUTE_MISC)
|
|
--print(1, "COMBAT_PLAYER_LEAVING", next(augmentationCache.prescience_stacks))
|
|
for actorName, stackInfo in pairs(augmentationCache.prescience_stacks) do
|
|
local actorObject = damageContainer:GetActor(actorName)
|
|
local currentAmountOfApplications = stackInfo.currentStacks
|
|
if (currentAmountOfApplications >= 1 and currentAmountOfApplications <= 5) then
|
|
--close the time the evoker had this amount of stacks
|
|
local timeOfTheLastEvent = stackInfo.latestStackUpdateTime
|
|
local timeNow = GetTime()
|
|
local timeDiff = timeNow - timeOfTheLastEvent
|
|
if (timeDiff > 0) then
|
|
stackInfo.stackTime[currentAmountOfApplications] = stackInfo.stackTime[currentAmountOfApplications] + timeDiff
|
|
end
|
|
end
|
|
|
|
actorObject.prescience_stack_data_by_timeline = DetailsFramework.table.copy({}, stackInfo.stackTime)
|
|
end
|
|
--]=]
|
|
end)
|
|
|
|
---@class details_evoker_presciencetimeline : table
|
|
---@field currentStacks number amount of stacks the evoker has at the moment
|
|
---@field stackTime table<number, number, number, number, number> amountof time the evoker had the amount of stacks, one stack if the first index, 5 stacks if the last index
|
|
---@field latestStackUpdateTime number GetTime() of the latest stack amount update, this is used to calculate the time the evoker had each amount of stacks
|
|
|
|
local latestPrescienceEvent = 0
|
|
local latestAuraInstanceId = 0
|
|
function augmentationFunctions.OnAugmentationBuffUpdate(eventName, ...)
|
|
---@combat
|
|
local currentCombat = Details:GetCurrentCombat()
|
|
|
|
--test #1: calculate the amount of stack in real time
|
|
if (eventName == "AURA_UPDATE" and Details.in_combat) then
|
|
local targetGUID, auraInfo, eventType = ...
|
|
local spellId = auraInfo.spellId
|
|
|
|
if (spellId == CONST_SPELLID_PRESCIENCE) then
|
|
--[=[
|
|
if (latestPrescienceEvent ~= GetTime()) then
|
|
latestPrescienceEvent = GetTime()
|
|
latestAuraInstanceId = auraInfo.instanceId
|
|
else
|
|
if (latestAuraInstanceId == auraInfo.instanceId) then
|
|
return
|
|
end
|
|
latestPrescienceEvent = GetTime()
|
|
latestAuraInstanceId = auraInfo.instanceId
|
|
end
|
|
|
|
if ((currentCombat and currentCombat.is_challenge) or Details.debug) then
|
|
local sourceUnitId = auraInfo.sourceUnit
|
|
local sourceGUID = UnitGUID(sourceUnitId)
|
|
local sourceName = Details:GetFullName(sourceUnitId)
|
|
|
|
local evokerUtilityObject = currentCombat:GetContainer(DETAILS_ATTRIBUTE_MISC):GetOrCreateActor(sourceGUID, sourceName, 0x514, true)
|
|
|
|
if (evokerUtilityObject) then
|
|
local stackInfo = evokerUtilityObject.prescience_stack_data2
|
|
if (not stackInfo) then
|
|
stackInfo = {
|
|
currentStacks = 0,
|
|
stackTime = {0, 0, 0, 0, 0},
|
|
latestStackUpdateTime = GetTime()
|
|
}
|
|
evokerUtilityObject.prescience_stack_data2 = stackInfo
|
|
end
|
|
|
|
if (eventType == "BUFF_UPTIME_IN") then
|
|
local currentAmountOfApplications = stackInfo.currentStacks
|
|
--print("in", currentAmountOfApplications, GetTime())
|
|
if (currentAmountOfApplications > 0) then
|
|
--the the time the evoker had this amount of stacks
|
|
local timeOfTheLastEvent = stackInfo.latestStackUpdateTime
|
|
local timeNow = GetTime()
|
|
local timeDiff = timeNow - timeOfTheLastEvent
|
|
if (timeDiff > 0) then
|
|
stackInfo.stackTime[currentAmountOfApplications] = stackInfo.stackTime[currentAmountOfApplications] + timeDiff
|
|
end
|
|
end
|
|
|
|
stackInfo.latestStackUpdateTime = GetTime()
|
|
stackInfo.currentStacks = stackInfo.currentStacks + 1
|
|
|
|
elseif (eventType == "BUFF_UPTIME_OUT") then
|
|
local currentAmountOfApplications = stackInfo.currentStacks
|
|
--print("out", currentAmountOfApplications)
|
|
if (currentAmountOfApplications > 0) then
|
|
--the the time the evoker had this amount of stacks
|
|
local timeOfTheLastEvent = stackInfo.latestStackUpdateTime
|
|
local timeNow = GetTime()
|
|
local timeDiff = timeNow - timeOfTheLastEvent
|
|
if (timeDiff > 0) then
|
|
stackInfo.stackTime[currentAmountOfApplications] = stackInfo.stackTime[currentAmountOfApplications] + timeDiff
|
|
end
|
|
end
|
|
|
|
stackInfo.latestStackUpdateTime = GetTime()
|
|
stackInfo.currentStacks = stackInfo.currentStacks - 1
|
|
end
|
|
end
|
|
end
|
|
--]=]
|
|
end
|
|
|
|
--test #2: calculate the amount of stacks post combat using a list of events (timeline)
|
|
--note to self: I'm not working with real time data, these are past events, GetTime() and time() will always return the same value
|
|
elseif (eventName == "TIMELINE_READY") then --not in use
|
|
--if true then return end
|
|
--timelineTable is an indexed table with all the timeline events
|
|
--[=[
|
|
---@type details_auratimeline[]
|
|
local timelineTable = ...
|
|
|
|
__details_debug.prescience_timeline = __details_debug.prescience_timeline or {}
|
|
__details_debug.prescience_timeline[#__details_debug.prescience_timeline+1] = timelineTable
|
|
|
|
--amount of time the evoker had the amount of stacks
|
|
--[evokerName] = details_evoker_presciencetimeline
|
|
---@type table<string, details_evoker_presciencetimeline>
|
|
local prescienceStacksByEvoker = {}
|
|
|
|
for i = 1, #timelineTable do
|
|
---@type details_auratimeline
|
|
local auraEvent = timelineTable[i]
|
|
if (auraEvent.spellId == CONST_SPELLID_PRESCIENCE) then
|
|
local evokerName = auraEvent.sourceName
|
|
---@type details_evoker_presciencetimeline
|
|
local evokerPrescienceStackInfo = prescienceStacksByEvoker[evokerName]
|
|
|
|
if (auraEvent.event == "BUFF_UPTIME_IN") then
|
|
if (not evokerPrescienceStackInfo) then
|
|
evokerPrescienceStackInfo = {
|
|
currentStacks = 0,
|
|
stackTime = {0, 0, 0, 0, 0},
|
|
latestStackUpdateTime = 0
|
|
}
|
|
prescienceStacksByEvoker[evokerName] = evokerPrescienceStackInfo
|
|
end
|
|
|
|
local currentAmountOfStacks = evokerPrescienceStackInfo.currentStacks
|
|
|
|
--the evoker gained a stack, so we need to add the time he had the previous amount of stacks
|
|
if (currentAmountOfStacks > 0) then
|
|
local timeWithThisAmountOfStacks = evokerPrescienceStackInfo.stackTime[currentAmountOfStacks]
|
|
if (timeWithThisAmountOfStacks) then
|
|
local appliedTime = auraEvent.appliedTime
|
|
local timeDiff = appliedTime - evokerPrescienceStackInfo.latestStackUpdateTime
|
|
if (timeDiff > 0) then
|
|
evokerPrescienceStackInfo.stackTime[currentAmountOfStacks] = timeWithThisAmountOfStacks + timeDiff
|
|
end
|
|
end
|
|
end
|
|
|
|
evokerPrescienceStackInfo.latestStackUpdateTime = auraEvent.appliedTime
|
|
evokerPrescienceStackInfo.currentStacks = currentAmountOfStacks + 1
|
|
|
|
elseif (auraEvent.event == "BUFF_UPTIME_OUT") then
|
|
if (evokerPrescienceStackInfo) then
|
|
--the evoker lost a stack, so we need to add the time he had the previous amount of stacks
|
|
local currentAmountOfStacks = evokerPrescienceStackInfo.currentStacks
|
|
local timeWithThisAmountOfStacks = evokerPrescienceStackInfo.stackTime[currentAmountOfStacks]
|
|
|
|
auraEvent.addTimeLineTable.closed = true
|
|
|
|
if (timeWithThisAmountOfStacks) then
|
|
local timeNow = auraEvent.removedTime
|
|
local timeDiff = timeNow - evokerPrescienceStackInfo.latestStackUpdateTime
|
|
if (timeDiff > 0) then
|
|
evokerPrescienceStackInfo.stackTime[currentAmountOfStacks] = timeWithThisAmountOfStacks + timeDiff
|
|
end
|
|
end
|
|
|
|
evokerPrescienceStackInfo.currentStacks = evokerPrescienceStackInfo.currentStacks - 1
|
|
evokerPrescienceStackInfo.latestStackUpdateTime = auraEvent.removedTime
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--iterate again and print the tables with the key 'closed' that are not set to true
|
|
local nonClosedTables = {}
|
|
for i = 1, #timelineTable do
|
|
---@type details_auratimeline
|
|
local auraEvent = timelineTable[i]
|
|
if (auraEvent.spellId == CONST_SPELLID_PRESCIENCE) then
|
|
if (auraEvent.event == "BUFF_UPTIME_IN") then
|
|
if (not auraEvent.closed) then
|
|
nonClosedTables[#nonClosedTables+1] = auraEvent
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
Details222.DebugMsg("|cFFFFFF00Non Closed Tables:", #nonClosedTables)
|
|
|
|
for evokerName, evokerPrescienceStackInfo in pairs(prescienceStacksByEvoker) do --table 'prescience_stack_data_by_timeline' not found, something wrong here
|
|
local evokerUtilityObject = currentCombat:GetContainer(DETAILS_ATTRIBUTE_MISC):GetActor(evokerName)
|
|
if (evokerUtilityObject) then
|
|
evokerUtilityObject.prescience_stack_data_by_timeline = DetailsFramework.table.copy({}, evokerPrescienceStackInfo.stackTime)
|
|
end
|
|
end
|
|
--]=]
|
|
end
|
|
end
|
|
|
|
function augmentationFunctions.BuffIn(token, time, sourceSerial, sourceName, sourceFlags, targetSerial, targetName, targetFlags, targetFlags2, spellId, spellName, spellschool, auraType, amount)
|
|
if (not Details.in_combat) then --when the player enter and leave combat, it tracks which players had buffs applied
|
|
return
|
|
end
|
|
|
|
if (spellId == 395152) then --ebom might on third parties
|
|
local auraName, texture, count, auraType, duration, expirationTime, sourceUnit, isStealable, nameplateShowPersonal, _, canApplyAura, isBossAura, isFromPlayerOrPlayerPet, nameplateShowAll, timeMod, v1, v2, v3, v4, v5 = Details:FindBuffCastedByUnitName(targetName, spellId, sourceName)
|
|
local attributeGained = v2
|
|
|
|
--unit already have the buff from this evoker
|
|
if (type(attributeGained) == "number") then
|
|
if (augmentationCache.ebon_might[targetSerial]) then
|
|
for index, evokerInfo in ipairs(augmentationCache.ebon_might[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
evokerInfo[4] = attributeGained
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
augmentationCache.ebon_might[targetSerial] = augmentationCache.ebon_might[targetSerial] or {}
|
|
local evokerInfo = {sourceSerial, sourceName, sourceFlags, attributeGained}
|
|
table.insert(augmentationCache.ebon_might[targetSerial], evokerInfo)
|
|
end
|
|
|
|
elseif (spellId == 413984) then --ss
|
|
if (UnitExists(targetName) and targetName ~= Details.playername) then
|
|
local auraName, texture, count, auraType, duration, expirationTime, sourceUnit, isStealable, nameplateShowPersonal, spellId, canApplyAura, isBossAura, isFromPlayerOrPlayerPet, nameplateShowAll, timeMod, v1, v2, v3, v4, v5 = Details:FindBuffCastedByUnitName(targetName, spellId, sourceName)
|
|
local versaGained = v1
|
|
if (type(versaGained) == "number") then
|
|
augmentationCache.ss[targetSerial] = augmentationCache.ss[targetSerial] or {}
|
|
local ssInfo = {sourceSerial, sourceName, sourceFlags, versaGained}
|
|
table.insert(augmentationCache.ss[targetSerial], ssInfo)
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 410089) then --prescience
|
|
--added Prescience to a player (targetName)
|
|
augmentationCache.prescience[targetSerial] = augmentationCache.prescience[targetSerial] or {}
|
|
local evokerInfo = {sourceSerial, sourceName, sourceFlags, amount}
|
|
table.insert(augmentationCache.prescience[targetSerial], evokerInfo)
|
|
|
|
---@combat
|
|
local currentCombat = Details:GetCurrentCombat()
|
|
local evokerUtilityObject = currentCombat:GetContainer(DETAILS_ATTRIBUTE_MISC):GetOrCreateActor(sourceSerial, sourceName, sourceFlags, true)
|
|
local stackInfo = evokerUtilityObject.cleu_prescience_time
|
|
if (not stackInfo) then
|
|
stackInfo = {
|
|
currentStacks = 0,
|
|
stackTime = {0, 0, 0, 0, 0},
|
|
latestStackUpdateTime = GetTime()
|
|
}
|
|
evokerUtilityObject.cleu_prescience_time = stackInfo
|
|
end
|
|
|
|
local prescienceApplied = getAmountOfBuffsAppliedBySpellId(CONST_SPELLID_PRESCIENCE)
|
|
|
|
if (prescienceApplied > 0) then
|
|
local currentAmountOfApplications = stackInfo.currentStacks
|
|
if (currentAmountOfApplications >= 1 and currentAmountOfApplications <= 5) then
|
|
--the the time the evoker had this amount of stacks
|
|
local timeOfTheLastEvent = stackInfo.latestStackUpdateTime
|
|
local timeNow = GetTime()
|
|
local timeDiff = timeNow - timeOfTheLastEvent
|
|
if (timeDiff > 0) then
|
|
stackInfo.stackTime[currentAmountOfApplications] = stackInfo.stackTime[currentAmountOfApplications] + timeDiff
|
|
end
|
|
end
|
|
|
|
stackInfo.latestStackUpdateTime = GetTime()
|
|
stackInfo.currentStacks = prescienceApplied
|
|
end
|
|
|
|
elseif (spellId == 409560) then --eons breath
|
|
local unitIDAffected = Details:FindUnitIDByUnitSerial(targetSerial)
|
|
if (unitIDAffected) then
|
|
local duration, expirationTime = Details:FindDebuffDuration(unitIDAffected, spellId, Details:Ambiguate(sourceName))
|
|
if (duration) then
|
|
local breathTargets = augmentationCache.breath_targets[targetSerial]
|
|
if (not breathTargets) then
|
|
augmentationCache.breath_targets[targetSerial] = {}
|
|
breathTargets = augmentationCache.breath_targets[targetSerial]
|
|
end
|
|
|
|
--evoker serial, evoker name, evoker flags, target unitID, unixtime, duration, expirationTime (GetTime + duration)
|
|
local eonsBreathInfo = {sourceSerial, sourceName, sourceFlags, unitIDAffected, time, duration, expirationTime}
|
|
table.insert(breathTargets, eonsBreathInfo)
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 360827) then --tank shield
|
|
augmentationCache.shield[targetSerial] = augmentationCache.shield[targetSerial] or {}
|
|
local evokerInfo = {sourceSerial, sourceName, sourceFlags, amount}
|
|
table.insert(augmentationCache.shield[targetSerial], evokerInfo)
|
|
|
|
elseif (spellId == 410263) then --inferno bless
|
|
augmentationCache.infernobless[targetSerial] = augmentationCache.infernobless[targetSerial] or {}
|
|
local evokerInfo = {sourceSerial, sourceName, sourceFlags}
|
|
table.insert(augmentationCache.infernobless[targetSerial], evokerInfo)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
function augmentationFunctions.BuffRefresh(token, time, sourceSerial, sourceName, sourceFlags, targetSerial, targetName, targetFlags, targetFlags2, spellId, spellName, spellschool, tipo, amount)
|
|
if (spellId == 395152) then
|
|
if (augmentationCache.ebon_might[targetSerial]) then
|
|
for index, evokerInfo in ipairs(augmentationCache.ebon_might[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
local auraName, texture, count, auraType, duration, expirationTime, sourceUnit, isStealable, nameplateShowPersonal, auraSpellId, canApplyAura, isBossAura, isFromPlayerOrPlayerPet, nameplateShowAll, timeMod, v1, v2, v3, v4, v5 = Details:FindBuffCastedByUnitName(targetName, spellId, sourceName)
|
|
local attributeGained = v2
|
|
|
|
if (type(attributeGained) == "number") then
|
|
evokerInfo[4] = attributeGained
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
local auraName, texture, count, auraType, duration, expirationTime, sourceUnit, isStealable, nameplateShowPersonal, auraSpellId, canApplyAura, isBossAura, isFromPlayerOrPlayerPet, nameplateShowAll, timeMod, v1, v2, v3, v4, v5 = Details:FindBuffCastedByUnitName(targetName, spellId, sourceName)
|
|
local attributeGained = v2
|
|
if (type(attributeGained) == "number") then
|
|
Details222.DebugMsg("Ebon Might Refreshed!, but the evoker was not found in the cache (1), adding:", sourceName, sourceSerial, targetName, targetSerial)
|
|
table.insert(augmentationCache.ebon_might[targetSerial], {sourceSerial, sourceName, sourceFlags, attributeGained})
|
|
end
|
|
else
|
|
local auraName, texture, count, auraType, duration, expirationTime, sourceUnit, isStealable, nameplateShowPersonal, auraSpellId, canApplyAura, isBossAura, isFromPlayerOrPlayerPet, nameplateShowAll, timeMod, v1, v2, v3, v4, v5 = Details:FindBuffCastedByUnitName(targetName, spellId, sourceName)
|
|
local attributeGained = v2
|
|
if (type(attributeGained) == "number") then
|
|
Details222.DebugMsg("Ebon Might Refreshed!, but the evoker was not found in the cache (2), adding:", sourceName, sourceSerial, targetName, targetSerial)
|
|
augmentationCache.ebon_might[targetSerial] = {} --This is needed because the cache was nil
|
|
table.insert(augmentationCache.ebon_might[targetSerial], {sourceSerial, sourceName, sourceFlags, attributeGained})
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 413984) then --ss
|
|
if (UnitExists(targetName) and targetName ~= Details.playername) then
|
|
local auraName, texture, count, auraType, duration, expirationTime, sourceUnit, isStealable, nameplateShowPersonal, spellId, canApplyAura, isBossAura, isFromPlayerOrPlayerPet, nameplateShowAll, timeMod, v1, v2, v3, v4, v5 = Details:FindBuffCastedByUnitName (targetName, spellId, sourceName)
|
|
local versaGained = v1
|
|
|
|
if (type(versaGained) == "number") then
|
|
local bFound = false
|
|
augmentationCache.ss[targetSerial] = augmentationCache.ss[targetSerial] or {}
|
|
|
|
for index, evokerInfo in ipairs(augmentationCache.ss[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
evokerInfo[4] = versaGained
|
|
bFound = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if (not bFound) then
|
|
table.insert(augmentationCache.ss[targetSerial], {sourceSerial, sourceName, sourceFlags, versaGained})
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 410089) then
|
|
local bFound = false
|
|
augmentationCache.prescience[targetSerial] = augmentationCache.prescience[targetSerial] or {}
|
|
|
|
for index, evokerInfo in ipairs(augmentationCache.prescience[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
evokerInfo[4] = amount
|
|
bFound = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if (not bFound) then
|
|
table.insert(augmentationCache.prescience[targetSerial], {sourceSerial, sourceName, sourceFlags, amount})
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
function augmentationFunctions.BuffOut(token, time, sourceSerial, sourceName, sourceFlags, targetSerial, targetName, targetFlags, targetFlags2, spellId, spellName, spellSchool, tipo, amount)
|
|
if (not Details.in_combat) then --when the player enter and leave combat, it tracks which players had buffs applied
|
|
--return
|
|
end
|
|
|
|
if (spellId == 395152) then --ebon might
|
|
if (augmentationCache.ebon_might[targetSerial]) then
|
|
for index, evokerInfo in ipairs(augmentationCache.ebon_might[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
table.remove(augmentationCache.ebon_might[targetSerial], index)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 413984) then --ss
|
|
if (augmentationCache.ss[targetSerial]) then
|
|
for index, evokerInfo in ipairs(augmentationCache.ss[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
table.remove(augmentationCache.ss[targetSerial], index)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 410089) then --prescience
|
|
if (augmentationCache.prescience[targetSerial]) then
|
|
for index, evokerInfo in ipairs(augmentationCache.prescience[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
table.remove(augmentationCache.prescience[targetSerial], index)
|
|
break
|
|
end
|
|
end
|
|
|
|
---@combat
|
|
local currentCombat = Details:GetCurrentCombat()
|
|
local evokerUtilityObject = currentCombat:GetContainer(DETAILS_ATTRIBUTE_MISC):GetOrCreateActor(sourceSerial, sourceName, sourceFlags, true)
|
|
local stackInfo = evokerUtilityObject.cleu_prescience_time
|
|
|
|
if (stackInfo) then
|
|
local prescienceApplied = getAmountOfBuffsAppliedBySpellId(CONST_SPELLID_PRESCIENCE)
|
|
if (prescienceApplied >= 0) then
|
|
local currentAmountOfApplications = stackInfo.currentStacks
|
|
if (currentAmountOfApplications >= 1 and currentAmountOfApplications <= 5) then
|
|
--the the time the evoker had this amount of stacks
|
|
local timeOfTheLastEvent = stackInfo.latestStackUpdateTime
|
|
local timeNow = GetTime()
|
|
local timeDiff = timeNow - timeOfTheLastEvent
|
|
if (timeDiff > 0) then
|
|
stackInfo.stackTime[currentAmountOfApplications] = stackInfo.stackTime[currentAmountOfApplications] + timeDiff
|
|
end
|
|
end
|
|
|
|
stackInfo.latestStackUpdateTime = GetTime()
|
|
stackInfo.currentStacks = prescienceApplied
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 360827) then
|
|
if (augmentationCache.shield[targetSerial]) then
|
|
for index, evokerInfo in ipairs(augmentationCache.shield[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
table.remove(augmentationCache.shield[targetSerial], index)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif (spellId == 410263) then
|
|
if (augmentationCache.infernobless[targetSerial]) then
|
|
for index, evokerInfo in ipairs(augmentationCache.infernobless[targetSerial]) do
|
|
if (evokerInfo[1] == sourceSerial) then
|
|
table.remove(augmentationCache.infernobless[targetSerial], index)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|