mirror of
https://github.com/brues-code/pfUI.git
synced 2026-09-22 07:36:56 +00:00
Meow
3fbce5be8f
* Removed SuperWoW dependency (UNIT_CASTEVENT removed) * Replaced SPELLCAST_START/STOP/FAILED/INTERRUPTED/DELAYED with Nampower equivalents (SPELL_START_SELF, SPELL_GO_SELF, SPELL_FAILED_SELF, SPELL_DELAYED_SELF) * Replaced CHAT_MSG_SPELL_SELF_BUFF text parsing with SPELL_HEAL_BY_SELF for accurate heal amounts including crit detection * Routed SPELL_START_SELF/OTHER, SPELL_GO_SELF/OTHER, SPELL_FAILED_OTHER through existing libdebuff hook system to avoid duplicate event registration * Added 60-second resurrection timer: symbol persists after successful cast even if caster attempts and cancels a second cast * Added GUID->Name cache for reliable target resolution when casting resurrection on dead players (UnitExists returns nil for corpses) * Auto-enables NP_EnableSpellHealEvents CVar required for SPELL_HEAL_BY_SELF
1266 lines
45 KiB
Lua
1266 lines
45 KiB
Lua
-- load pfUI environment
|
|
setfenv(1, pfUI:GetEnvironment())
|
|
|
|
--[[ libpredict ]]--
|
|
-- A pfUI library that detects, receives and sends heal and resurrection predictions.
|
|
-- Healing predictions are done by caching the last known "normal" heal value of the
|
|
-- spell when last being used. Those chaches are cleared when new talents are detected.
|
|
-- The API provides function calls similar to later WoW expansions such as:
|
|
-- UnitGetIncomingHeals(unit)
|
|
-- UnitHasIncomingResurrection(unit)
|
|
--
|
|
-- The library is able to receive and send compatible messages to HealComm
|
|
-- including resurrections. It has an option to disable the sending of those
|
|
-- messages in case HealComm is already active.
|
|
--
|
|
-- HOT TRACKING INTEGRATION (NEW):
|
|
-- With Nampower enabled, HoT tracking now primarily uses libdebuff's AURA_CAST
|
|
-- event system for accurate server-side buff/debuff tracking with full rank
|
|
-- protection. GetHotDuration() first checks libdebuff, then falls back to the
|
|
-- legacy prediction system for backwards compatibility with non-Nampower clients.
|
|
-- This provides:
|
|
-- - Accurate duration from server (no prediction needed)
|
|
-- - Automatic rank protection (lower ranks won't overwrite higher ranks)
|
|
-- - Support for multiple casters of same HoT on one target
|
|
-- - Zero event overhead (libdebuff already tracks all auras)
|
|
|
|
-- return instantly when another libpredict is already active
|
|
if pfUI.api.libpredict then return end
|
|
|
|
-- Check if libdebuff integration is available
|
|
local libdebuff_available = (pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast) and true or false
|
|
|
|
-- Check if Nampower is available for SPELL_FAILED events
|
|
|
|
local senttarget
|
|
local heals, ress, events, hots = {}, {}, {}, {}
|
|
local spell_queue = { "DUMMY", "DUMMYRank 9", "TARGET" }
|
|
local player = UnitName("player")
|
|
local cache, gear_string = {}, ""
|
|
local rejuvDuration, renewDuration = 12, 15 --default durations
|
|
local ressGuidToName = {} -- [casterGuid] = casterName, for SPELL_FAILED_OTHER cleanup
|
|
local healGuidToName = {} -- [casterGuid] = casterName, for SPELL_FAILED_OTHER cleanup
|
|
local ress_timers = {} -- [target][sender] = expiry_timestamp (60s Rez-Fenster)
|
|
local RESS_TIMEOUT = 60 -- Vanilla: Rez-Angebot läuft nach 60s ab
|
|
|
|
local PRAYER_OF_HEALING
|
|
do -- Prayer of Healing
|
|
local locales = {
|
|
["deDE"] = "Gebet der Heilung",
|
|
["enUS"] = "Prayer of Healing",
|
|
["esES"] = "Rezo de curación",
|
|
["frFR"] = "Prière de soins",
|
|
["koKR"] = "치유의 기원",
|
|
["ruRU"] = "Молитва исцеления",
|
|
["zhCN"] = "治疗祷言",
|
|
}
|
|
|
|
PRAYER_OF_HEALING = locales[GetLocale()] or locales["enUS"]
|
|
end
|
|
|
|
local REJUVENATION
|
|
do -- Rejuvenation
|
|
local locales = {
|
|
["deDE"] = "Verjüngung",
|
|
["enUS"] = "Rejuvenation",
|
|
["esES"] = "Rejuvenecimiento",
|
|
["frFR"] = "Récupération",
|
|
["koKR"] = "회복",
|
|
["ruRU"] = "Омоложение",
|
|
["zhCN"] = "回春术",
|
|
}
|
|
|
|
REJUVENATION = locales[GetLocale()] or locales["enUS"]
|
|
end
|
|
|
|
local RENEW
|
|
do -- Renew
|
|
local locales = {
|
|
["deDE"] = "Erneuerung",
|
|
["enUS"] = "Renew",
|
|
["esES"] = "Renovar",
|
|
["frFR"] = "Rénovation",
|
|
["koKR"] = "소생",
|
|
["ruRU"] = "Обновление",
|
|
["zhCN"] = "恢复",
|
|
}
|
|
|
|
RENEW = locales[GetLocale()] or locales["enUS"]
|
|
end
|
|
|
|
local REGROWTH
|
|
do -- Regrowth
|
|
local locales = {
|
|
["deDE"] = "Nachwachsen",
|
|
["enUS"] = "Regrowth",
|
|
["esES"] = "Recrecimiento",
|
|
["frFR"] = "Rétablissement",
|
|
["koKR"] = "재생",
|
|
["ruRU"] = "Восстановление",
|
|
["zhCN"] = "愈合",
|
|
}
|
|
|
|
REGROWTH = locales[GetLocale()] or locales["enUS"]
|
|
end
|
|
|
|
|
|
-- Spell IDs für SPELL_GO_SELF callback (Nampower) - Instant HoT Detection
|
|
local SPELL_IDS = {
|
|
-- Rejuvenation (alle Ränge)
|
|
[774] = "Reju", [1058] = "Reju", [1430] = "Reju", [2090] = "Reju", [2091] = "Reju",
|
|
[3627] = "Reju", [8910] = "Reju", [9839] = "Reju", [9840] = "Reju", [9841] = "Reju",
|
|
[25299] = "Reju", [26981] = "Reju", [26982] = "Reju",
|
|
-- Renew (alle Ränge)
|
|
[139] = "Renew", [6074] = "Renew", [6075] = "Renew", [6076] = "Renew", [6077] = "Renew",
|
|
[6078] = "Renew", [10927] = "Renew", [10928] = "Renew", [10929] = "Renew", [25315] = "Renew",
|
|
[25221] = "Renew", [25222] = "Renew",
|
|
}
|
|
|
|
local libpredict = CreateFrame("Frame")
|
|
libpredict:RegisterEvent("UNIT_HEALTH")
|
|
libpredict:RegisterEvent("CHAT_MSG_ADDON")
|
|
libpredict:RegisterEvent("PLAYER_TARGET_CHANGED")
|
|
libpredict:RegisterEvent("PLAYER_LOGOUT")
|
|
|
|
libpredict:SetScript("OnEvent", function()
|
|
-- Handle shutdown to prevent crash 132
|
|
if event == "PLAYER_LOGOUT" then
|
|
this:UnregisterAllEvents()
|
|
this:SetScript("OnEvent", nil)
|
|
return
|
|
end
|
|
|
|
if event == "CHAT_MSG_ADDON" and (arg1 == "HealComm" or arg1 == "CTRA") then
|
|
this:ParseChatMessage(arg4, arg2, arg1)
|
|
elseif event == "UNIT_HEALTH" then
|
|
local name = UnitName(arg1)
|
|
if name and ress[name] and not UnitIsDeadOrGhost(arg1) then
|
|
ress[name] = nil
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- GUID->Name Cache für tote Spieler (UnitExists gibt nil für Tote)
|
|
local guidNameCache = {} -- [guid] = name
|
|
|
|
local function resolveNameFromGuid(guid)
|
|
if not guid then return nil end
|
|
if guidNameCache[guid] then return guidNameCache[guid] end
|
|
local unit = UnitExists(guid)
|
|
local name = unit and type(unit) == "string" and UnitName(unit) or nil
|
|
if name then guidNameCache[guid] = name end
|
|
return name
|
|
end
|
|
|
|
-- Register with libdebuff hooks
|
|
local function cacheRaidNames()
|
|
-- Alle Raid/Party Mitglieder cachen solange sie noch auffindbar sind
|
|
for i = 1, GetNumRaidMembers() do
|
|
local unit = "raid" .. i
|
|
if UnitExists(unit) then
|
|
local _, guid = UnitExists(unit)
|
|
local name = UnitName(unit)
|
|
if guid and name then guidNameCache[guid] = name end
|
|
end
|
|
end
|
|
for i = 1, GetNumPartyMembers() do
|
|
local unit = "party" .. i
|
|
if UnitExists(unit) then
|
|
local _, guid = UnitExists(unit)
|
|
local name = UnitName(unit)
|
|
if guid and name then guidNameCache[guid] = name end
|
|
end
|
|
end
|
|
-- Spieler selbst
|
|
local _, pguid = UnitExists("player")
|
|
if pguid then guidNameCache[pguid] = UnitName("player") end
|
|
end
|
|
|
|
local function isRezSpell(spellId)
|
|
if not L["resurrections"] then return false end
|
|
local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
|
|
return spellName and L["resurrections"][spellName]
|
|
end
|
|
|
|
-- Cache beim Betreten der Welt aufbauen
|
|
libpredict:RegisterEvent("PLAYER_ENTERING_WORLD")
|
|
libpredict:RegisterEvent("RAID_ROSTER_UPDATE")
|
|
libpredict:RegisterEvent("PARTY_MEMBERS_CHANGED")
|
|
local origOnEvent = libpredict:GetScript("OnEvent")
|
|
libpredict:SetScript("OnEvent", function()
|
|
if event == "PLAYER_ENTERING_WORLD" or event == "RAID_ROSTER_UPDATE" or event == "PARTY_MEMBERS_CHANGED" then
|
|
cacheRaidNames()
|
|
end
|
|
if origOnEvent then origOnEvent() end
|
|
end)
|
|
|
|
-- SPELL_START_SELF: eigener Cast gestartet (Rez + Heals)
|
|
-- Signature: fn(spellId, casterGuid, targetGuid, castTime)
|
|
pfUI.libdebuff_spell_start_self_hooks = pfUI.libdebuff_spell_start_self_hooks or {}
|
|
pfUI.libdebuff_spell_start_self_hooks["libpredict"] = function(spellId, casterGuid, targetGuid, castTime)
|
|
cacheRaidNames()
|
|
local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
|
|
if not spellName then return end
|
|
|
|
local target = resolveNameFromGuid(targetGuid) or senttarget or spell_queue[3]
|
|
|
|
|
|
-- Rez
|
|
if isRezSpell(spellId) then
|
|
if player and target then
|
|
libpredict:Ress(player, target, casterGuid)
|
|
libpredict.sender:SendHealCommMsg("Resurrection/" .. target .. "/start/")
|
|
libpredict.sender:SendResCommMsg("RES " .. target)
|
|
libpredict.sender.resurrecting = true
|
|
end
|
|
return
|
|
end
|
|
|
|
-- Heal prediction
|
|
if spell_queue[1] == spellName and cache[spell_queue[2]] then
|
|
local amount = cache[spell_queue[2]][1]
|
|
local casttime = castTime
|
|
|
|
if spellName == REGROWTH then
|
|
local fullSpell = spell_queue[2]
|
|
local _, _, rankStr = fullSpell and string.find(fullSpell, "Rank (%d+)")
|
|
local rankNum = rankStr and tonumber(rankStr) or nil
|
|
if libpredict.sender.regrowth_timer then
|
|
libpredict.sender.regrowth_target_next = target
|
|
libpredict.sender.regrowth_rank_next = rankNum
|
|
else
|
|
libpredict.sender.regrowth_target = target
|
|
libpredict.sender.regrowth_rank = rankNum
|
|
end
|
|
end
|
|
|
|
if spellName == PRAYER_OF_HEALING then
|
|
for i = 1, 4 do
|
|
if CheckInteractDistance("party"..i, 4) then
|
|
local pname = UnitName("party"..i)
|
|
libpredict:Heal(player, pname, amount, casttime)
|
|
libpredict.sender:SendHealCommMsg("Heal/" .. pname .. "/" .. amount .. "/" .. casttime .. "/")
|
|
libpredict.sender.healing = true
|
|
end
|
|
end
|
|
end
|
|
|
|
libpredict:Heal(player, target, amount, casttime)
|
|
libpredict.sender:SendHealCommMsg("Heal/" .. (target or "") .. "/" .. amount .. "/" .. casttime .. "/")
|
|
libpredict.sender.healing = true
|
|
end
|
|
|
|
-- current_cast für onCastFailed() setzen
|
|
libpredict.sender.current_cast = spellName
|
|
libpredict.sender.current_cast_target = target
|
|
end
|
|
|
|
-- SPELL_START_OTHER: fremder Rez-Cast gestartet
|
|
-- Signature: fn(spellId, casterGuid, targetGuid, castTime)
|
|
pfUI.libdebuff_spell_start_other_hooks = pfUI.libdebuff_spell_start_other_hooks or {}
|
|
pfUI.libdebuff_spell_start_other_hooks["libpredict"] = function(spellId, casterGuid, targetGuid, castTime)
|
|
if not isRezSpell(spellId) then return end
|
|
local casterName = resolveNameFromGuid(casterGuid)
|
|
local targetName = resolveNameFromGuid(targetGuid)
|
|
if casterName and targetName then
|
|
libpredict:Ress(casterName, targetName, casterGuid)
|
|
end
|
|
end
|
|
|
|
-- SPELL_GO_SELF: eigener Cast gelandet - HoTs + eigener Rez Timer
|
|
-- Signature: fn(spellId, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
|
|
pfUI.libdebuff_spell_go_hooks = pfUI.libdebuff_spell_go_hooks or {}
|
|
pfUI.libdebuff_spell_go_hooks["libpredict"] = function(spellId, a1, a2, a3, a4, a5, a6, a7)
|
|
-- Instant HoTs
|
|
local hotType = SPELL_IDS[spellId]
|
|
if hotType then
|
|
local targetGuid = a4
|
|
local targetName = resolveNameFromGuid(targetGuid)
|
|
if targetName then
|
|
local duration
|
|
if hotType == "Reju" then duration = rejuvDuration or 12
|
|
elseif hotType == "Renew" then duration = renewDuration or 15
|
|
end
|
|
local rank = 0
|
|
if GetSpellRecField then
|
|
local rankStr = GetSpellRecField(spellId, "rank")
|
|
if rankStr and rankStr ~= "" then
|
|
rank = tonumber((string.gsub(rankStr, "Rank ", ""))) or 0
|
|
end
|
|
end
|
|
local playerName = UnitName("player")
|
|
libpredict:Hot(playerName, targetName, hotType, duration, nil, "SPELL_GO_SELF", rank)
|
|
local rankStr = tostring(rank)
|
|
if libpredict.sender and libpredict.sender.SendHealCommMsg then
|
|
libpredict.sender:SendHealCommMsg(hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/")
|
|
elseif GetNumRaidMembers() > 0 then
|
|
SendAddonMessage("HealComm", hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/", "RAID")
|
|
elseif GetNumPartyMembers() > 0 then
|
|
SendAddonMessage("HealComm", hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/", "PARTY")
|
|
end
|
|
end
|
|
end
|
|
-- Eigener Rez gelandet: Timer setzen
|
|
if isRezSpell(spellId) then
|
|
local targetGuid = a4
|
|
local targetName = resolveNameFromGuid(targetGuid)
|
|
local playerName = UnitName("player")
|
|
if playerName and targetName then
|
|
libpredict:RessSetTimer(playerName, targetName)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
-- SPELL_GO_OTHER: fremder Rez gelandet - Timer setzen
|
|
-- Signature: fn(spellId, casterGuid, targetGuid)
|
|
pfUI.libdebuff_spell_go_other_hooks = pfUI.libdebuff_spell_go_other_hooks or {}
|
|
pfUI.libdebuff_spell_go_other_hooks["libpredict"] = function(spellId, casterGuid, targetGuid)
|
|
if not isRezSpell(spellId) then return end
|
|
local casterName = resolveNameFromGuid(casterGuid)
|
|
local targetName = resolveNameFromGuid(targetGuid)
|
|
if casterName and targetName then
|
|
libpredict:RessSetTimer(casterName, targetName)
|
|
end
|
|
end
|
|
|
|
-- SPELL_FAILED_OTHER: abgebrochene Resses/Heals entfernen
|
|
-- Signature: fn(casterGuid, spellId)
|
|
pfUI.libdebuff_spell_failed_other_hooks = pfUI.libdebuff_spell_failed_other_hooks or {}
|
|
pfUI.libdebuff_spell_failed_other_hooks["libpredict"] = function(casterGuid, spellId)
|
|
if not casterGuid then return end
|
|
local ressName = ressGuidToName[casterGuid]
|
|
if ressName then
|
|
libpredict:RessStop(ressName)
|
|
end
|
|
local healName = healGuidToName[casterGuid]
|
|
if healName then libpredict:HealStop(healName) end
|
|
end
|
|
|
|
libpredict:SetScript("OnUpdate", function()
|
|
-- throttle cleanup - no need to check every frame
|
|
local now = pfUI.uf.now or GetTime()
|
|
if (this.tick or 0) > now then return end
|
|
this.tick = now + pfUI.throttle:Get("libpredict") -- Default: Normal (10 FPS)
|
|
|
|
-- update on timeout events
|
|
for timestamp, targets in pairs(events) do
|
|
if now >= timestamp then
|
|
events[timestamp] = nil
|
|
end
|
|
end
|
|
|
|
-- Rez-Timeout: Angebot nach 60s entfernen wenn Spieler nicht annimmt
|
|
for target, senders in pairs(ress_timers) do
|
|
for sender, expiry in pairs(senders) do
|
|
if now >= expiry then
|
|
senders[sender] = nil
|
|
if ress[target] then ress[target][sender] = nil end
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
function libpredict:ParseComm(sender, msg)
|
|
local msgtype, target, heal, time, rank
|
|
|
|
if msg == "HealStop" or msg == "Healstop" or msg == "GrpHealstop" then
|
|
msgtype = "Stop"
|
|
-- DEBUG: Log when HealStop received
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[libpredict RX]|r HealStop from " .. tostring(sender))
|
|
end
|
|
elseif msg == "Resurrection/stop/" then
|
|
msgtype = "RessStop"
|
|
elseif msg then
|
|
local msgobj = {strsplit("/", msg)}
|
|
|
|
if msgobj and msgobj[1] and msgobj[2] then
|
|
-- legacy healcomm object
|
|
if msgobj[1] == "GrpHealdelay" or msgobj[1] == "Healdelay" then
|
|
msgtype, time = "Delay", msgobj[2]
|
|
end
|
|
|
|
if msgobj[1] and msgobj[1] == "Resurrection" and msgobj[2] then
|
|
msgtype, target = "Ress", msgobj[2]
|
|
end
|
|
|
|
if msgobj[1] == "Heal" and msgobj[2] then
|
|
msgtype, target, heal, time = "Heal", msgobj[2], msgobj[3], msgobj[4]
|
|
end
|
|
|
|
if msgobj[1] == "GrpHeal" and msgobj[2] then
|
|
msgtype, target, heal, time = "Heal", {}, msgobj[2], msgobj[3]
|
|
for i=4,8 do
|
|
if msgobj[i] then table.insert(target, msgobj[i]) end
|
|
end
|
|
end
|
|
|
|
if msgobj[1] == "Reju" or msgobj[1] == "Renew" or msgobj[1] == "Regr" then --hots
|
|
msgtype, target, heal, time = "Hot", msgobj[2], msgobj[1], msgobj[3]
|
|
-- NEW: Parse rank (optional, backwards compatible)
|
|
-- Format: "Reju/Target/12/10/" where msgobj[3]=duration, msgobj[4]=rank
|
|
-- "0" = unknown rank (for clients without rank extraction)
|
|
local rankStr = msgobj[4]
|
|
if rankStr and rankStr ~= "" and rankStr ~= "/" and rankStr ~= "0" then
|
|
rank = tonumber(rankStr)
|
|
end
|
|
end
|
|
elseif select and UnitCastingInfo then
|
|
-- latest healcomm
|
|
msgtype = tonumber(string.sub(msg, 1, 3))
|
|
if not msgtype then return end
|
|
|
|
if msgtype == 0 then
|
|
msgtype = "Heal"
|
|
heal = tonumber(string.sub(msg, 4, 8))
|
|
target = string.sub(msg,9, -1)
|
|
|
|
local starttime = select(5, UnitCastingInfo(sender))
|
|
local endtime = select(6, UnitCastingInfo(sender))
|
|
if not starttime or not endtime then return end
|
|
time = endtime - starttime
|
|
elseif msgtype == 1 then
|
|
msgtype = "Stop"
|
|
elseif msgtype == 2 then
|
|
msgtype = "Heal"
|
|
heal = tonumber(string.sub(msg,4, 8))
|
|
target = {strsplit(":", string.sub(msg,9, -1))}
|
|
local starttime = select(5, UnitCastingInfo(sender))
|
|
local endtime = select(6, UnitCastingInfo(sender))
|
|
if not starttime or not endtime then return end
|
|
time = endtime - starttime
|
|
end
|
|
end
|
|
end
|
|
|
|
return msgtype, target, heal, time, rank
|
|
end
|
|
|
|
-- Duplikat-Erkennung für HoT Nachrichten
|
|
local recentHots = {}
|
|
local DUPLICATE_WINDOW = 0.5 -- Ignoriere gleiche Nachricht innerhalb 0.5s
|
|
|
|
function libpredict:ParseChatMessage(sender, msg, comm)
|
|
local msgtype, target, heal, time, rank
|
|
|
|
if comm == "HealComm" then
|
|
msgtype, target, heal, time, rank = libpredict:ParseComm(sender, msg)
|
|
elseif comm == "CTRA" then
|
|
local _, _, cmd, ctratarget = string.find(msg, "(%a+)%s?([^#]*)")
|
|
if cmd and ctratarget and cmd == "RES" and ctratarget ~= "" and ctratarget ~= UNKNOWN then
|
|
msgtype = "Ress"
|
|
target = ctratarget
|
|
end
|
|
end
|
|
|
|
if msgtype == "Stop" and sender then
|
|
libpredict:HealStop(sender)
|
|
return
|
|
elseif ( msg == "RessStop" or msg == "RESNO" ) and sender then
|
|
libpredict:RessStop(sender)
|
|
return
|
|
elseif msgtype == "Delay" and time then
|
|
libpredict:HealDelay(sender, time)
|
|
elseif msgtype == "Heal" and target and heal and time then
|
|
if type(target) == "table" then
|
|
for _, name in pairs(target) do
|
|
libpredict:Heal(sender, name, heal, time)
|
|
end
|
|
else
|
|
libpredict:Heal(sender, target, heal, time)
|
|
end
|
|
elseif msgtype == "Ress" then
|
|
-- HealComm: nur für fremde Spieler (eigene Resses via SPELL_START_SELF hook)
|
|
local playerName = UnitName("player")
|
|
if sender ~= playerName then
|
|
local senderGuid
|
|
for i = 1, GetNumRaidMembers() do
|
|
local unit = "raid" .. i
|
|
if UnitName(unit) == sender then
|
|
local _, guid = UnitExists(unit)
|
|
senderGuid = guid
|
|
break
|
|
end
|
|
end
|
|
if not senderGuid then
|
|
for i = 1, GetNumPartyMembers() do
|
|
local unit = "party" .. i
|
|
if UnitName(unit) == sender then
|
|
local _, guid = UnitExists(unit)
|
|
senderGuid = guid
|
|
break
|
|
end
|
|
end
|
|
end
|
|
libpredict:Ress(sender, target, senderGuid)
|
|
end
|
|
elseif msgtype == "Hot" then
|
|
-- Duplikat-Check: gleicher sender+target+spell innerhalb DUPLICATE_WINDOW ignorieren
|
|
local now = pfUI.uf.now or GetTime()
|
|
local key = sender .. target .. heal
|
|
if recentHots[key] and (now - recentHots[key]) < DUPLICATE_WINDOW then
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cffff0000[DUPLICATE IGNORED]|r " .. key)
|
|
end
|
|
return
|
|
end
|
|
recentHots[key] = now
|
|
|
|
-- Cleanup alte Einträge (alle 10s)
|
|
if not libpredict.lastCleanup or (now - libpredict.lastCleanup) > 10 then
|
|
for k, v in pairs(recentHots) do
|
|
if (now - v) > DUPLICATE_WINDOW then
|
|
recentHots[k] = nil
|
|
end
|
|
end
|
|
libpredict.lastCleanup = now
|
|
end
|
|
|
|
-- Für eigene HoTs: Korrigiere die startTime
|
|
if sender == UnitName("player") then
|
|
local existing = hots[target] and hots[target][heal]
|
|
|
|
-- Wenn bereits ein aktiver Timer existiert, nicht überschreiben
|
|
if existing and (existing.start + existing.duration) > now then
|
|
return
|
|
end
|
|
|
|
-- Kompensiere HealComm Verzögerung
|
|
local delay = (heal == "Regr") and 0.3 or 0
|
|
local correctedStart = now - delay
|
|
|
|
libpredict:Hot(sender, target, heal, time, correctedStart, "ParseComm-Self", rank)
|
|
return
|
|
end
|
|
libpredict:Hot(sender, target, heal, time, nil, "ParseComm", rank)
|
|
end
|
|
end
|
|
|
|
function libpredict:AddEvent(time, target)
|
|
events[time] = events[time] or {}
|
|
table.insert(events[time], target)
|
|
end
|
|
|
|
function libpredict:Heal(sender, target, amount, duration, senderGuid)
|
|
if not sender or not target or not amount or not duration then
|
|
return
|
|
end
|
|
|
|
local now = pfUI.uf.now or GetTime()
|
|
local timeout = duration/1000 + now
|
|
heals[target] = heals[target] or {}
|
|
heals[target][sender] = { amount, timeout }
|
|
if senderGuid then healGuidToName[senderGuid] = sender end
|
|
libpredict:AddEvent(timeout, target)
|
|
end
|
|
|
|
-- Debug flag
|
|
libpredict.debug = false
|
|
|
|
function libpredict:Hot(sender, target, spell, duration, startTime, source, rank)
|
|
hots[target] = hots[target] or {}
|
|
hots[target][spell] = hots[target][spell] or {}
|
|
|
|
-- Korrigiere Regrowth Duration (Server gibt 21 zurück, sollte aber 20 sein)
|
|
if spell == "Regr" then
|
|
duration = 20
|
|
end
|
|
|
|
-- Sicherstellen dass duration eine Zahl ist
|
|
duration = tonumber(duration) or duration
|
|
|
|
-- Rank protection: Don't overwrite higher rank HoT with lower rank
|
|
local existing = hots[target][spell]
|
|
if existing and existing.rank and rank then
|
|
local existingRank = tonumber(existing.rank) or 0
|
|
local newRank = tonumber(rank) or 0
|
|
|
|
local now = pfUI.uf.now or GetTime()
|
|
local existingTimeleft = (existing.start + existing.duration) - now
|
|
|
|
-- If existing HoT is still active and has higher rank, don't overwrite
|
|
if existingTimeleft > 0 and newRank > 0 and newRank < existingRank then
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cffff0000[Hot RANK BLOCK]|r %s Rank %d cannot overwrite Rank %d on %s",
|
|
spell, newRank, existingRank, target))
|
|
end
|
|
return -- Don't overwrite!
|
|
end
|
|
end
|
|
|
|
local now = pfUI.uf.now or GetTime()
|
|
hots[target][spell].duration = duration
|
|
hots[target][spell].start = startTime or now
|
|
hots[target][spell].rank = rank -- Store rank for protection
|
|
|
|
-- Debug
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc[Hot]|r src=" .. (source or "?") ..
|
|
" | sender=" .. (sender or "nil") ..
|
|
" | target=" .. (target or "nil") ..
|
|
" | spell=" .. (spell or "nil") ..
|
|
" | dur=" .. tostring(duration) .. " (" .. type(duration) .. ")" ..
|
|
" | rank=" .. tostring(rank or "?"))
|
|
end
|
|
|
|
-- update aura events of relevant unitframes
|
|
if pfUI and pfUI.uf and pfUI.uf.frames then
|
|
for _, frame in pairs(pfUI.uf.frames) do
|
|
if frame.namecache == target then
|
|
frame.update_aura = true
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(" |cff00ff00-> Frame update triggered for " .. (frame:GetName() or "?") .. "|r")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function libpredict:HealStop(sender)
|
|
for ttarget, t in pairs(heals) do
|
|
for tsender in pairs(heals[ttarget]) do
|
|
if sender == tsender then
|
|
heals[ttarget][tsender] = nil
|
|
end
|
|
end
|
|
end
|
|
-- cleanup reverse lookup
|
|
for guid, name in pairs(healGuidToName) do
|
|
if name == sender then healGuidToName[guid] = nil end
|
|
end
|
|
end
|
|
|
|
function libpredict:HealDelay(sender, delay)
|
|
local delay = delay/1000
|
|
for target, t in pairs(heals) do
|
|
for tsender, amount in pairs(heals[target]) do
|
|
if sender == tsender then
|
|
amount[2] = amount[2] + delay
|
|
libpredict:AddEvent(amount[2], target)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function libpredict:Ress(sender, target, senderGuid)
|
|
ress[target] = ress[target] or {}
|
|
ress[target][sender] = true
|
|
if senderGuid then ressGuidToName[senderGuid] = sender end
|
|
-- kein Timer hier - Timer wird erst gesetzt wenn Cast wirklich durchgeht
|
|
end
|
|
|
|
function libpredict:RessSetTimer(sender, target)
|
|
ress_timers[target] = ress_timers[target] or {}
|
|
local existing = ress_timers[target][sender]
|
|
if not existing or GetTime() >= existing then
|
|
ress_timers[target][sender] = GetTime() + RESS_TIMEOUT
|
|
else
|
|
end
|
|
end
|
|
|
|
function libpredict:RessStop(sender)
|
|
local now = GetTime()
|
|
for ttarget, t in pairs(ress) do
|
|
for tsender in pairs(ress[ttarget]) do
|
|
if sender == tsender then
|
|
local expiry = ress_timers[ttarget] and ress_timers[ttarget][tsender]
|
|
if not expiry or now >= expiry then
|
|
ress[ttarget][tsender] = nil
|
|
if ress_timers[ttarget] then ress_timers[ttarget][tsender] = nil end
|
|
else
|
|
end
|
|
end
|
|
end
|
|
end
|
|
for guid, name in pairs(ressGuidToName) do
|
|
if name == sender then ressGuidToName[guid] = nil end
|
|
end
|
|
end
|
|
|
|
function libpredict:UnitGetIncomingHeals(unit)
|
|
if not unit then return 0 end
|
|
local name = UnitName(unit)
|
|
if not name then return 0 end
|
|
if UnitIsDeadOrGhost(unit) then return 0 end
|
|
|
|
local sumheal = 0
|
|
if not heals[name] then
|
|
return sumheal
|
|
else
|
|
local now = pfUI.uf.now or GetTime()
|
|
for sender, amount in pairs(heals[name]) do
|
|
if amount[2] <= now then
|
|
heals[name][sender] = nil
|
|
else
|
|
sumheal = sumheal + amount[1]
|
|
end
|
|
end
|
|
end
|
|
return sumheal
|
|
end
|
|
|
|
function libpredict:UnitHasIncomingResurrection(unit)
|
|
if not unit then return nil end
|
|
local name = UnitName(unit)
|
|
if not name then return nil end
|
|
|
|
if not ress[name] then
|
|
return nil
|
|
else
|
|
for sender, val in pairs(ress[name]) do
|
|
if val == true then
|
|
return val
|
|
end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local realm = GetRealmName()
|
|
local resetcache = CreateFrame("Frame")
|
|
local hotsetbonus = libtipscan:GetScanner("hotsetbonus")
|
|
resetcache:RegisterEvent("PLAYER_ENTERING_WORLD")
|
|
resetcache:RegisterEvent("LEARNED_SPELL_IN_TAB")
|
|
resetcache:RegisterEvent("CHARACTER_POINTS_CHANGED")
|
|
resetcache:RegisterEvent("UNIT_INVENTORY_CHANGED")
|
|
resetcache:SetScript("OnEvent", function()
|
|
if event == "PLAYER_ENTERING_WORLD" then
|
|
-- load and initialize previous caches of spell amounts
|
|
pfUI_cache["prediction"] = pfUI_cache["prediction"] or {}
|
|
pfUI_cache["prediction"][realm] = pfUI_cache["prediction"][realm] or {}
|
|
pfUI_cache["prediction"][realm][player] = pfUI_cache["prediction"][realm][player] or {}
|
|
pfUI_cache["prediction"][realm][player]["heals"] = pfUI_cache["prediction"][realm][player]["heals"] or {}
|
|
cache = pfUI_cache["prediction"][realm][player]["heals"]
|
|
end
|
|
|
|
if event == "UNIT_INVENTORY_CHANGED" or "PLAYER_ENTERING_WORLD" then
|
|
-- skip non-player events
|
|
if arg1 and arg1 ~= "player" then return end
|
|
|
|
local gear = ""
|
|
for id = 1, 18 do
|
|
gear = gear .. (GetInventoryItemLink("player",id) or "")
|
|
end
|
|
|
|
-- abort when inventory didn't change
|
|
if gear == gear_string then return end
|
|
gear_string = gear
|
|
|
|
local setBonusCounter
|
|
setBonusCounter = 0
|
|
for i=1,10 do --there is no need to check slots above 10
|
|
hotsetbonus:SetInventoryItem("player", i)
|
|
if hotsetbonus:Find(L["healduration"]["Rejuvenation"]) then setBonusCounter = setBonusCounter + 1 end
|
|
end
|
|
rejuvDuration = setBonusCounter == 8 and 15 or 12
|
|
setBonusCounter = 0
|
|
for i =1,10 do
|
|
hotsetbonus:SetInventoryItem("player", i)
|
|
if hotsetbonus:Find(L["healduration"]["Renew"]) then setBonusCounter = setBonusCounter + 1 end
|
|
end
|
|
renewDuration = setBonusCounter == 5 and 18 or 15
|
|
end
|
|
|
|
-- flag all cached heals for renewal
|
|
for k in pairs(cache) do
|
|
if type(cache[k]) == "number" or type(cache[k]) == "string" then
|
|
-- migrate old data
|
|
local oldval = cache[k]
|
|
cache[k] = { [1] = oldval }
|
|
end
|
|
|
|
-- flag for reset
|
|
cache[k][2] = true
|
|
end
|
|
end)
|
|
|
|
local function UpdateCache(spell, heal, crit)
|
|
local heal = heal and tonumber(heal)
|
|
if not spell or not heal then return end
|
|
|
|
if not cache[spell] or cache[spell][2] then
|
|
-- skills or equipment changed, save whatever is detected
|
|
cache[spell] = cache[spell] or {}
|
|
cache[spell][1] = crit and heal*2/3 or heal
|
|
cache[spell][2] = crit
|
|
elseif not crit and cache[spell][1] < heal then
|
|
-- safe the best heal we can get
|
|
cache[spell][1] = heal
|
|
cache[spell][2] = nil
|
|
end
|
|
end
|
|
|
|
-- Cooldown für lokale Instant-HoT Hooks (verhindert Spam bei Click-to-Cast)
|
|
local instantHotCooldown = {}
|
|
local INSTANT_HOT_COOLDOWN = 1.0 -- 1 Sekunde Cooldown (GCD ist 1.5s)
|
|
|
|
-- Pending HoTs Queue - wird nach Delay verifiziert
|
|
local pendingHots = {}
|
|
|
|
-- Hilfsfunktion: Prüfe ob Buff auf Unit vorhanden ist
|
|
local function UnitHasBuff(unit, buffName)
|
|
for i = 1, 32 do
|
|
local name = UnitBuff(unit, i)
|
|
if not name then break end
|
|
if name == buffName then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Gather Data by User Actions
|
|
hooksecurefunc("CastSpell", function(id, bookType)
|
|
if not libpredict.sender.enabled then return end
|
|
local effect, rank = libspell.GetSpellInfo(id, bookType)
|
|
if not effect then return end
|
|
spell_queue[1] = effect
|
|
spell_queue[2] = effect.. ( rank or "" )
|
|
spell_queue[3] = UnitName("target") and UnitCanAssist("player", "target") and UnitName("target") or UnitName("player")
|
|
|
|
-- Extract rank number
|
|
local rankNum = nil
|
|
if rank and rank ~= "" then
|
|
rankNum = tonumber((string.gsub(rank, "Rank ", ""))) or nil
|
|
end
|
|
|
|
-- Instant-HoTs: libdebuff/Nampower via GetHotDuration, Hook-Methode als Fallback
|
|
|
|
if effect == REJUVENATION then
|
|
local target = spell_queue[3]
|
|
local now = pfUI.uf.now or GetTime()
|
|
local key = "Reju" .. target
|
|
|
|
-- Cooldown-Check
|
|
if instantHotCooldown[key] and (now - instantHotCooldown[key]) < INSTANT_HOT_COOLDOWN then
|
|
return
|
|
end
|
|
instantHotCooldown[key] = now
|
|
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[CastSpell REJU INSTANT]|r target=%s rank=%s (Fallback)", target, tostring(rankNum or "?")))
|
|
end
|
|
libpredict:Hot(player, target, "Reju", rejuvDuration, nil, "CastSpell-Instant", rankNum)
|
|
local rankStr = rankNum and tostring(rankNum) or "0"
|
|
libpredict.sender:SendHealCommMsg("Reju/"..target.."/"..rejuvDuration.."/"..rankStr.."/")
|
|
elseif effect == RENEW then
|
|
local target = spell_queue[3]
|
|
local now = pfUI.uf.now or GetTime()
|
|
local key = "Renew" .. target
|
|
|
|
-- Cooldown-Check
|
|
if instantHotCooldown[key] and (now - instantHotCooldown[key]) < INSTANT_HOT_COOLDOWN then
|
|
return
|
|
end
|
|
instantHotCooldown[key] = now
|
|
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[CastSpell RENEW INSTANT]|r target=%s rank=%s (Fallback)", target, tostring(rankNum or "?")))
|
|
end
|
|
libpredict:Hot(player, target, "Renew", renewDuration, nil, "CastSpell-Instant", rankNum)
|
|
local rankStr = rankNum and tostring(rankNum) or "0"
|
|
libpredict.sender:SendHealCommMsg("Renew/"..target.."/"..renewDuration.."/"..rankStr.."/")
|
|
end
|
|
end)
|
|
|
|
hooksecurefunc("CastSpellByName", function(effect, target)
|
|
if not libpredict.sender.enabled then return end
|
|
local effect, rank = libspell.GetSpellInfo(effect)
|
|
if not effect then return end
|
|
local mouseover = pfUI and pfUI.uf and pfUI.uf.mouseover and pfUI.uf.mouseover.unit
|
|
mouseover = mouseover and UnitCanAssist("player", mouseover) and UnitName(mouseover)
|
|
|
|
local default = UnitName("target") and UnitCanAssist("player", "target") and UnitName("target") or UnitName("player")
|
|
|
|
target = target and type(target) == "string" and UnitName(target) or target
|
|
target = target and target == true and UnitName("player") or target
|
|
target = target and target == 1 and UnitName("player") or target
|
|
|
|
-- Extract rank number
|
|
local rankNum = nil
|
|
if rank and rank ~= "" then
|
|
rankNum = tonumber((string.gsub(rank, "Rank ", ""))) or nil
|
|
end
|
|
|
|
-- Nur spell_queue überschreiben wenn kein Cast läuft
|
|
-- (verhindert dass Instant-Spam während Regrowth-Cast die Queue zerstört)
|
|
if not libpredict.sender.current_cast then
|
|
spell_queue[1] = effect
|
|
spell_queue[2] = effect.. ( rank or "" )
|
|
spell_queue[3] = target or mouseover or default
|
|
end
|
|
|
|
-- Instant-HoTs: libdebuff/Nampower via GetHotDuration, Hook-Methode als Fallback
|
|
|
|
if effect == REJUVENATION then
|
|
local hotTarget = target or mouseover or default
|
|
local now = pfUI.uf.now or GetTime()
|
|
local key = "Reju" .. hotTarget
|
|
|
|
-- Cooldown-Check
|
|
if instantHotCooldown[key] and (now - instantHotCooldown[key]) < INSTANT_HOT_COOLDOWN then
|
|
return
|
|
end
|
|
instantHotCooldown[key] = now
|
|
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[CastSpellByName REJU INSTANT]|r target=%s rank=%s (Fallback)", hotTarget, tostring(rankNum or "?")))
|
|
end
|
|
libpredict:Hot(player, hotTarget, "Reju", rejuvDuration, nil, "CastSpellByName-Instant", rankNum)
|
|
local rankStr = rankNum and tostring(rankNum) or "0"
|
|
libpredict.sender:SendHealCommMsg("Reju/"..hotTarget.."/"..rejuvDuration.."/"..rankStr.."/")
|
|
elseif effect == RENEW then
|
|
local hotTarget = target or mouseover or default
|
|
local now = pfUI.uf.now or GetTime()
|
|
local key = "Renew" .. hotTarget
|
|
|
|
-- Cooldown-Check
|
|
if instantHotCooldown[key] and (now - instantHotCooldown[key]) < INSTANT_HOT_COOLDOWN then
|
|
return
|
|
end
|
|
instantHotCooldown[key] = now
|
|
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[CastSpellByName RENEW INSTANT]|r target=%s rank=%s (Fallback)", hotTarget, tostring(rankNum or "?")))
|
|
end
|
|
libpredict:Hot(player, hotTarget, "Renew", renewDuration, nil, "CastSpellByName-Instant", rankNum)
|
|
local rankStr = rankNum and tostring(rankNum) or "0"
|
|
libpredict.sender:SendHealCommMsg("Renew/"..hotTarget.."/"..renewDuration.."/"..rankStr.."/")
|
|
end
|
|
end)
|
|
|
|
local scanner = libtipscan:GetScanner("prediction")
|
|
hooksecurefunc("UseAction", function(slot, target, selfcast)
|
|
if not libpredict.sender.enabled then return end
|
|
if GetActionText(slot) or not IsCurrentAction(slot) then return end
|
|
scanner:SetAction(slot)
|
|
local effect, rank = scanner:Line(1)
|
|
if not effect then return end
|
|
spell_queue[1] = effect
|
|
spell_queue[2] = effect.. ( rank or "" )
|
|
spell_queue[3] = selfcast and UnitName("player") or UnitName("target") and UnitCanAssist("player", "target") and UnitName("target") or UnitName("player")
|
|
|
|
-- Extract rank number
|
|
local rankNum = nil
|
|
if rank and rank ~= "" then
|
|
rankNum = tonumber((string.gsub(rank, "Rank ", ""))) or nil
|
|
end
|
|
|
|
-- Instant-HoTs: libdebuff/Nampower via GetHotDuration, Hook-Methode als Fallback
|
|
|
|
if effect == REJUVENATION then
|
|
local hotTarget = spell_queue[3]
|
|
local now = pfUI.uf.now or GetTime()
|
|
local key = "Reju" .. hotTarget
|
|
|
|
-- Cooldown-Check
|
|
if instantHotCooldown[key] and (now - instantHotCooldown[key]) < INSTANT_HOT_COOLDOWN then
|
|
return
|
|
end
|
|
instantHotCooldown[key] = now
|
|
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[UseAction REJU INSTANT]|r target=%s rank=%s (Fallback)", hotTarget, tostring(rankNum or "?")))
|
|
end
|
|
libpredict:Hot(player, hotTarget, "Reju", rejuvDuration, nil, "UseAction-Instant", rankNum)
|
|
local rankStr = rankNum and tostring(rankNum) or "0"
|
|
libpredict.sender:SendHealCommMsg("Reju/"..hotTarget.."/"..rejuvDuration.."/"..rankStr.."/")
|
|
elseif effect == RENEW then
|
|
local hotTarget = spell_queue[3]
|
|
local now = pfUI.uf.now or GetTime()
|
|
local key = "Renew" .. hotTarget
|
|
|
|
-- Cooldown-Check
|
|
if instantHotCooldown[key] and (now - instantHotCooldown[key]) < INSTANT_HOT_COOLDOWN then
|
|
return
|
|
end
|
|
instantHotCooldown[key] = now
|
|
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[UseAction RENEW INSTANT]|r target=%s rank=%s (Fallback)", hotTarget, tostring(rankNum or "?")))
|
|
end
|
|
libpredict:Hot(player, hotTarget, "Renew", renewDuration, nil, "UseAction-Instant", rankNum)
|
|
local rankStr = rankNum and tostring(rankNum) or "0"
|
|
libpredict.sender:SendHealCommMsg("Renew/"..hotTarget.."/"..renewDuration.."/"..rankStr.."/")
|
|
end
|
|
end)
|
|
|
|
libpredict.sender = CreateFrame("Frame", "pfPredictionSender", UIParent)
|
|
libpredict.sender.enabled = true
|
|
libpredict.sender.SendHealCommMsg = function(self, msg)
|
|
-- Smart channel selection: Only send to relevant channel to avoid duplicates
|
|
if GetNumRaidMembers() > 0 then
|
|
-- In raid: Only send to RAID (includes all raid members)
|
|
SendAddonMessage("HealComm", msg, "RAID")
|
|
elseif GetNumPartyMembers() > 0 then
|
|
-- In party: Only send to PARTY
|
|
SendAddonMessage("HealComm", msg, "PARTY")
|
|
end
|
|
-- Note: BATTLEGROUND channel not used (no reliable way to detect BG in Vanilla)
|
|
-- BG groups are handled by RAID channel
|
|
end
|
|
libpredict.sender.SendResCommMsg = function(self, msg)
|
|
-- Smart channel selection: Only send to relevant channel to avoid duplicates
|
|
if GetNumRaidMembers() > 0 then
|
|
-- In raid: Only send to RAID (includes all raid members)
|
|
SendAddonMessage("CTRA", msg, "RAID")
|
|
elseif GetNumPartyMembers() > 0 then
|
|
-- In party: Only send to PARTY
|
|
SendAddonMessage("CTRA", msg, "PARTY")
|
|
end
|
|
-- Note: BATTLEGROUND channel not used (no reliable way to detect BG in Vanilla)
|
|
-- BG groups are handled by RAID channel
|
|
end
|
|
|
|
libpredict.sender:SetScript("OnUpdate", function()
|
|
-- trigger delayed regrowth timers
|
|
local now = pfUI.uf.now or GetTime()
|
|
if this.regrowth_timer and now > this.regrowth_timer then
|
|
local target = this.regrowth_target or player
|
|
local duration = 20
|
|
local startTime = this.regrowth_start
|
|
local rank = this.regrowth_rank
|
|
|
|
libpredict:Hot(player, target, "Regr", duration, startTime, "OnUpdate", rank)
|
|
local rankStr = rank and tostring(rank) or "0"
|
|
libpredict.sender:SendHealCommMsg("Regr/"..target.."/"..duration.."/"..rankStr.."/")
|
|
|
|
-- Übernehme nächsten Regrowth falls vorhanden
|
|
this.regrowth_target = this.regrowth_target_next
|
|
this.regrowth_start = this.regrowth_start_next
|
|
this.regrowth_rank = this.regrowth_rank_next
|
|
this.regrowth_target_next = nil
|
|
this.regrowth_start_next = nil
|
|
this.regrowth_rank_next = nil
|
|
this.regrowth_timer = nil
|
|
end
|
|
end)
|
|
|
|
-- Nampower events (SPELL_START_SELF / SPELL_GO_SELF via libdebuff hooks)
|
|
libpredict.sender:RegisterEvent("SPELL_FAILED_SELF")
|
|
libpredict.sender:RegisterEvent("SPELL_DELAYED_SELF")
|
|
libpredict.sender:RegisterEvent("SPELL_HEAL_BY_SELF")
|
|
|
|
-- force cache updates
|
|
libpredict.sender:RegisterEvent("UNIT_INVENTORY_CHANGED")
|
|
libpredict.sender:RegisterEvent("SKILL_LINES_CHANGED")
|
|
|
|
-- Shared cleanup helper for failed/interrupted casts
|
|
local function onCastFailed()
|
|
local s = libpredict.sender
|
|
if s.healing then
|
|
libpredict:HealStop(UnitName("player"))
|
|
s:SendHealCommMsg("Healstop")
|
|
s.healing = nil
|
|
elseif s.resurrecting then
|
|
local target = s.current_cast_target or senttarget or spell_queue[3]
|
|
libpredict:RessStop(UnitName("player"))
|
|
s:SendHealCommMsg("Resurrection/stop/")
|
|
s:SendResCommMsg("RESNO " .. (target or ""))
|
|
s.resurrecting = nil
|
|
end
|
|
if s.current_cast == REGROWTH then
|
|
s.regrowth_timer = nil
|
|
s.regrowth_start = nil
|
|
s.regrowth_target_next = nil
|
|
s.regrowth_start_next = nil
|
|
end
|
|
s.current_cast = nil
|
|
s.current_cast_target = nil
|
|
end
|
|
|
|
libpredict.sender:SetScript("OnEvent", function()
|
|
-- ============================================================
|
|
-- NAMPOWER PATH
|
|
-- ============================================================
|
|
if event == "SPELL_HEAL_BY_SELF" then
|
|
-- arg1=targetGuid, arg2=casterGuid, arg3=spellId, arg4=amount, arg5=critical, arg6=periodic
|
|
local spellId = arg3
|
|
local amount = arg4
|
|
local isCrit = arg5 == 1
|
|
local isPeriodic = arg6 == 1
|
|
local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
|
|
if spellName and spell_queue[1] == spellName then
|
|
UpdateCache(spell_queue[2], amount, isCrit)
|
|
end
|
|
|
|
elseif event == "SPELL_START_SELF" then
|
|
-- arg2=spellId, arg4=targetGuid, arg6=castTime
|
|
local spellId = arg2
|
|
local castTime = arg6
|
|
local spellName = GetSpellRecField and GetSpellRecField(spellId, "name")
|
|
if not spellName then return end
|
|
|
|
-- target: via guidNameCache (tote Spieler), fallback spell_queue
|
|
local targetGuid = arg4
|
|
local target = resolveNameFromGuid(targetGuid) or senttarget or spell_queue[3]
|
|
|
|
this.current_cast = spellName
|
|
this.current_cast_target = target
|
|
|
|
-- Rez: HealComm senden (Ress() bereits via libdebuff_spell_start_self_hooks)
|
|
if L["resurrections"][spellName] then
|
|
libpredict.sender:SendHealCommMsg("Resurrection/" .. (target or "") .. "/start/")
|
|
libpredict.sender:SendResCommMsg("RES " .. (target or ""))
|
|
libpredict.sender.resurrecting = true
|
|
return
|
|
end
|
|
|
|
-- Heal prediction
|
|
if spell_queue[1] == spellName and cache[spell_queue[2]] then
|
|
local amount = cache[spell_queue[2]][1]
|
|
local casttime = castTime
|
|
|
|
if spellName == REGROWTH then
|
|
local fullSpell = spell_queue[2]
|
|
local _, _, rankStr = fullSpell and string.find(fullSpell, "Rank (%d+)")
|
|
local rankNum = rankStr and tonumber(rankStr) or nil
|
|
if this.regrowth_timer then
|
|
this.regrowth_target_next = target
|
|
this.regrowth_rank_next = rankNum
|
|
else
|
|
this.regrowth_target = target
|
|
this.regrowth_rank = rankNum
|
|
end
|
|
end
|
|
|
|
if spellName == PRAYER_OF_HEALING then
|
|
for i = 1, 4 do
|
|
if CheckInteractDistance("party"..i, 4) then
|
|
local pname = UnitName("party"..i)
|
|
libpredict:Heal(player, pname, amount, casttime)
|
|
libpredict.sender:SendHealCommMsg("Heal/" .. pname .. "/" .. amount .. "/" .. casttime .. "/")
|
|
libpredict.sender.healing = true
|
|
end
|
|
end
|
|
end
|
|
|
|
libpredict:Heal(player, target, amount, casttime)
|
|
libpredict.sender:SendHealCommMsg("Heal/" .. (target or "") .. "/" .. amount .. "/" .. casttime .. "/")
|
|
libpredict.sender.healing = true
|
|
end
|
|
|
|
elseif event == "SPELL_GO_SELF" then
|
|
-- arg2=spellId
|
|
libpredict:HealStop(player)
|
|
local spellName = GetSpellRecField and GetSpellRecField(arg2, "name")
|
|
if spellName == REGROWTH then
|
|
local now = pfUI.uf.now or GetTime()
|
|
if this.regrowth_timer then
|
|
this.regrowth_start_next = now
|
|
else
|
|
this.regrowth_start = now
|
|
end
|
|
this.regrowth_timer = now + 0.1
|
|
end
|
|
this.current_cast = nil
|
|
this.current_cast_target = nil
|
|
|
|
elseif event == "SPELL_FAILED_SELF" then
|
|
onCastFailed()
|
|
|
|
elseif event == "SPELL_DELAYED_SELF" then
|
|
-- arg1=casterGuid, arg2=delayMs
|
|
if libpredict.sender.healing then
|
|
libpredict:HealDelay(player, arg2)
|
|
libpredict.sender:SendHealCommMsg("Healdelay/" .. arg2 .. "/")
|
|
end
|
|
|
|
end
|
|
end)
|
|
|
|
function libpredict:GetHotDuration(unit, spell)
|
|
if unit == UNKNOWNOBJECT or unit == UNKOWNBEING then return end
|
|
|
|
-- NEW: Try libdebuff first (Nampower AURA_CAST events)
|
|
if pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast then
|
|
local _, guid = UnitExists(unit) -- FIX: Get GUID, not exists boolean!
|
|
if guid then
|
|
-- Get the best (highest rank) aura cast for this spell
|
|
local spellName = spell
|
|
|
|
-- Map short spell codes to full names
|
|
if spell == "Reju" then
|
|
spellName = REJUVENATION
|
|
elseif spell == "Regr" then
|
|
spellName = REGROWTH
|
|
elseif spell == "Renew" then
|
|
spellName = RENEW
|
|
end
|
|
|
|
local start, duration, timeleft, rank, casterGuid = pfUI.api.libdebuff:GetBestAuraCast(guid, spellName)
|
|
|
|
if start and duration and timeleft then
|
|
-- SUCCESS: libdebuff has accurate server-side data!
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[GetHotDuration]|r %s on %s via libdebuff: dur=%.1fs timeleft=%.1fs rank=%d",
|
|
spell, unit, duration, timeleft, rank or 0))
|
|
end
|
|
return start, duration, timeleft
|
|
end
|
|
end
|
|
end
|
|
|
|
-- FALLBACK: Use old prediction system (for non-Nampower clients or no AURA_CAST data)
|
|
local start, duration, timeleft
|
|
local now = pfUI.uf.now or GetTime()
|
|
|
|
local unitName = UnitName(unit)
|
|
local unitdata = hots[unitName]
|
|
|
|
if unitdata and unitdata[spell] then
|
|
local spellData = unitdata[spell]
|
|
if spellData.start and spellData.duration then
|
|
local endTime = spellData.start + spellData.duration
|
|
if endTime > now - 1 then
|
|
start = spellData.start
|
|
duration = spellData.duration
|
|
timeleft = endTime - now
|
|
|
|
if libpredict.debug then
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cffff9900[GetHotDuration]|r %s on %s via prediction: dur=%.1fs timeleft=%.1fs",
|
|
spell, unit, duration, timeleft))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return start, duration, timeleft
|
|
end
|
|
|
|
-- Debug command: /hotdebug - Show HoT tracking status
|
|
_G.SLASH_HOTDEBUG1 = "/hotdebug"
|
|
_G.SlashCmdList.HOTDEBUG = function()
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff========================================|r")
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[HoT Tracking Debug]|r")
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff========================================|r")
|
|
|
|
-- Check libdebuff availability
|
|
local libdebuff_now = (pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast) and true or false
|
|
|
|
if libdebuff_now then
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ff00[PRIMARY]|r libdebuff integration: ACTIVE")
|
|
DEFAULT_CHAT_FRAME:AddMessage(" Using AURA_CAST events for server-side tracking")
|
|
DEFAULT_CHAT_FRAME:AddMessage(" Rank protection: ENABLED")
|
|
else
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cffff9900[PRIMARY]|r libdebuff integration: NOT AVAILABLE")
|
|
DEFAULT_CHAT_FRAME:AddMessage(" Reason: Nampower not enabled or libdebuff outdated")
|
|
end
|
|
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[FALLBACK]|r Legacy prediction system: ACTIVE")
|
|
DEFAULT_CHAT_FRAME:AddMessage(" Using Hook-Methode + HealComm messages")
|
|
|
|
-- Show active HoTs in tracking
|
|
local hotCount = 0
|
|
for target, spells in pairs(hots) do
|
|
for spell, data in pairs(spells) do
|
|
hotCount = hotCount + 1
|
|
end
|
|
end
|
|
|
|
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ffff[TRACKED]|r %d HoTs in legacy system", hotCount))
|
|
|
|
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff========================================|r")
|
|
DEFAULT_CHAT_FRAME:AddMessage("Tip: /libpredict.debug = true for verbose logging")
|
|
end
|
|
|
|
pfUI.api.libpredict = libpredict |