919 lines
38 KiB
Lua
919 lines
38 KiB
Lua
-- AnySCT sct.lua -- floating combat text for the listed targetSCTs, styled after the client's own
|
|
-- world damage numbers.
|
|
--
|
|
-- Where a line appears is decided by AnySCT_Plates.Select (plates.lua): over the mob's nameplate
|
|
-- (top centre), clamped to the screen when the plate is off screen, or at the fixed anchor
|
|
-- AnySCTAnchor. Plate lines follow the plate every tick; anchor lines scroll from the anchor.
|
|
--
|
|
-- Engine: a fixed FontString pool and ONE shared OnUpdate that exists only while a line is in
|
|
-- flight (idle cost zero). Nothing is allocated per tick. This file only draws its own frames and
|
|
-- never touches Blizzard's CombatText, SHOW_COMBAT_TEXT or another SCT addon.
|
|
|
|
AnySCT_SCT = {}
|
|
local S = AnySCT_SCT
|
|
|
|
-- ONE table for every visual / motion parameter; the animation code reads only from here.
|
|
-- Values are measured engine parameters of the 1.12.1 client's own world text; colours and size match
|
|
-- the client's pet text. Retune by changing values here.
|
|
AnySCT_STYLE = {
|
|
font = "CLIENT", -- key of S.FONTS, or "CLIENT" = global DAMAGE_TEXT_FONT (pfUI honoured)
|
|
lifetime = 1.5, -- seconds, every text
|
|
fadeIn = 0.15, -- alpha 0 -> 1 over this many seconds
|
|
fadeOutNumber = 0.76, -- fade-out start (seconds); alpha reaches 0 at the lifetime
|
|
fadeOutCrit = 1.0,
|
|
fadeOutWord = 1.0, -- Miss / Dodge / Parry / Block ...
|
|
fadeOutAbsorb = 0.09, -- "Absorb" is a quick flicker
|
|
riseHeight = 120, -- px a normal text rises (engine: 2 world units; screen distance varies)
|
|
critRiseFactor = 0, -- crits do not rise, they pop in place
|
|
sizeScale = 0.018333, -- text pixel size = scale x screen diagonal (1024x768 -> 23 px)
|
|
critSizeScale = 0.0275, -- crits (1024x768 -> 35 px)
|
|
shadow = 0.002, -- shadow offset, fraction of the viewport per axis (down-right)
|
|
spread = 0, -- random horizontal px per line (the engine stacks instead)
|
|
maxLines = 60, -- total lines on screen (several mobs with bursts)
|
|
maxPerTarget = 16, -- lines per mob: lifetime 1.5 s x 9 hits/s = 14 live lines, none recycled early
|
|
colorMelee = { 1.0, 0.518, 0.0 }, -- 0xFFFF8400
|
|
colorSpell = { 1.0, 0.871, 0.0 }, -- 0xFFFFDE00
|
|
-- crit size factor keyframes {fraction of the lifetime, factor on the crit size}; linear in
|
|
-- between, last value held. {{0,1},{1,1}} turns the pop off.
|
|
critKeyframes = { { 0, 0.1 }, { 0.1, 2.0 }, { 0.2, 1.0 }, { 1, 1.0 } },
|
|
colorHeal = { 0.1, 1.0, 0.1 }, -- heals on a listed targetSCT
|
|
glancingScale = 0.75, -- only with the colour scheme on
|
|
}
|
|
local STYLE = AnySCT_STYLE
|
|
|
|
-- Option defaults follow the style table (core.lua loads first and owns the defaults table).
|
|
if AnySCT_DEFAULTS then
|
|
AnySCT_DEFAULTS.colorMelee = STYLE.colorMelee
|
|
AnySCT_DEFAULTS.colorSpell = STYLE.colorSpell
|
|
AnySCT_DEFAULTS.colorHeal = STYLE.colorHeal
|
|
AnySCT_DEFAULTS.riseHeight = STYLE.riseHeight
|
|
AnySCT_DEFAULTS.jitter = STYLE.spread
|
|
AnySCT_DEFAULTS.maxLines = STYLE.maxLines
|
|
AnySCT_DEFAULTS.maxLinesPerTarget = STYLE.maxPerTarget
|
|
AnySCT_DEFAULTS.font = STYLE.font
|
|
end
|
|
|
|
-- Piecewise-linear curve value at t. Pure, allocation-free.
|
|
function S.KeyScale(kf, t)
|
|
local n = table.getn(kf)
|
|
if t <= kf[1][1] then return kf[1][2] end
|
|
for i = 2, n do
|
|
local b = kf[i]
|
|
if t <= b[1] then
|
|
local a = kf[i - 1]
|
|
local span = b[1] - a[1]
|
|
if span <= 0 then return b[2] end
|
|
return a[2] + (b[2] - a[2]) * ((t - a[1]) / span)
|
|
end
|
|
end
|
|
return kf[n][2]
|
|
end
|
|
|
|
function S.CurveActive(kf)
|
|
for i = 1, table.getn(kf) do
|
|
if kf[i][2] ~= 1 then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function S.CurveAnimated(kf)
|
|
for i = 2, table.getn(kf) do
|
|
if kf[i][2] ~= kf[1][2] then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Text pixel size in UI units: scale x diagonal x factor. (pixels = units x effective scale, and
|
|
-- the diagonal in pixels = the UI-unit diagonal x effective scale, so the scale cancels.)
|
|
function S.TextSize(scale, factor, sw, sh)
|
|
return scale * factor * math.sqrt(sw * sw + sh * sh)
|
|
end
|
|
|
|
S.COLORS = {
|
|
heal = STYLE.colorHeal,
|
|
pet = STYLE.colorMelee,
|
|
spell = STYLE.colorSpell,
|
|
hit = { 1.00, 1.00, 1.00 },
|
|
crit = { 1.00, 0.90, 0.15 },
|
|
glancing = { 0.62, 0.62, 0.62 },
|
|
crushing = { 1.00, 0.55, 0.10 },
|
|
miss = { 1.00, 0.25, 0.25 },
|
|
dodge = { 1.00, 0.25, 0.25 },
|
|
parry = { 1.00, 0.25, 0.25 },
|
|
block = { 0.35, 0.55, 1.00 },
|
|
absorb = { 0.75, 0.40, 1.00 },
|
|
resist = { 0.75, 0.40, 1.00 },
|
|
immune = { 0.75, 0.40, 1.00 },
|
|
evade = { 0.75, 0.40, 1.00 },
|
|
deflect = { 0.75, 0.40, 1.00 },
|
|
}
|
|
|
|
-- Text colour r, g, b. Precedence:
|
|
-- 1. heal colour (ckey "heal")
|
|
-- 2. the listed source's own colour (option colorPerTarget on and res.srcRgb set); the same colour
|
|
-- for numbers, words and spells, whatever the colour scheme says
|
|
-- 3. ckey "pet" / "spell" (colour scheme off): the class colour of the source when the option is on
|
|
-- and the class is known (pets and totems carry their owner's), else the configured melee /
|
|
-- spell colour
|
|
-- 4. every other key: a per-kind colour of the colourize scheme.
|
|
function S.PickColour(res, opt, ckey)
|
|
if ckey == "heal" then
|
|
local h = opt.colorHeal or S.COLORS.heal
|
|
return h[1], h[2], h[3]
|
|
end
|
|
if opt.colorPerTarget and res.srcRgb then
|
|
local c = res.srcRgb
|
|
return c[1], c[2], c[3]
|
|
end
|
|
if ckey == "pet" or ckey == "spell" then
|
|
if opt.classColours and res.class and RAID_CLASS_COLORS then
|
|
local rc = RAID_CLASS_COLORS[res.class]
|
|
if rc then return rc.r, rc.g, rc.b end
|
|
end
|
|
local c = (ckey == "spell") and opt.colorSpell or opt.colorMelee
|
|
if c then return c[1], c[2], c[3] end
|
|
end
|
|
local c = S.COLORS[ckey] or S.COLORS.pet
|
|
return c[1], c[2], c[3]
|
|
end
|
|
|
|
-- Pure: GO / WAIT label text. srcName / mobName are optional prefixes.
|
|
-- GO +4210 (buffer = threat distance to pulling aggro)
|
|
-- WAIT 1250 / 3000 (buffer / required buffer)
|
|
function S.ThreatText(status, buffer, need, srcName, mobName)
|
|
local b = math.floor((buffer or 0) + 0.5)
|
|
local t
|
|
if status == "GO" then
|
|
t = "GO +" .. b
|
|
else
|
|
t = "WAIT " .. b .. " / " .. math.floor((need or 0) + 0.5)
|
|
end
|
|
if srcName then t = srcName .. " " .. t end
|
|
if mobName then t = mobName .. ": " .. t end
|
|
return t
|
|
end
|
|
|
|
S.WORDS = {
|
|
miss = "Miss", dodge = "Dodge", parry = "Parry", block = "Block", absorb = "Absorb",
|
|
resist = "Resist", immune = "Immune", evade = "Evade", deflect = "Deflect",
|
|
}
|
|
|
|
S.FONTS = {
|
|
FRIZQT = "Fonts\\FRIZQT__.TTF",
|
|
SKURRI = "Fonts\\skurri.ttf",
|
|
ARIALN = "Fonts\\ARIALN.TTF",
|
|
}
|
|
|
|
function S.FontPath(choice)
|
|
if choice == "CLIENT" then
|
|
if type(DAMAGE_TEXT_FONT) == "string" then return DAMAGE_TEXT_FONT end
|
|
return S.FONTS.FRIZQT
|
|
end
|
|
return S.FONTS[choice] or S.FONTS.FRIZQT
|
|
end
|
|
|
|
-- Pure: result + options + display mode -> text, colour key, isWord, size multiplier, suffix.
|
|
-- Numbers are bare. Mode 3 (fixed anchor) always names the mob: the position no longer identifies it.
|
|
function S.Format(res, opt, mode)
|
|
local kind = res.kind
|
|
local word = S.WORDS[kind]
|
|
local amount = res.amount or 0
|
|
local text
|
|
local isWord = false
|
|
if word and (amount <= 0 or opt.colourize) then
|
|
isWord = true
|
|
if amount > 0 then text = word .. " " .. amount else text = word end
|
|
else
|
|
text = tostring(amount)
|
|
end
|
|
if opt.markGlancing and (kind == "glancing" or kind == "crushing") then
|
|
text = text .. " " .. kind
|
|
end
|
|
local mul = 1
|
|
if kind == "glancing" and opt.colourize then mul = STYLE.glancingScale end
|
|
local suffix
|
|
if kind == "heal" then
|
|
text = "+" .. text
|
|
if opt.healShowHealer and res.healer then suffix = res.healer end
|
|
elseif opt.showSpellName and res.spell then
|
|
suffix = res.spell
|
|
end
|
|
-- the listed source's name comes first: Source - Spell - Victim (never on heals: the text is over it)
|
|
if kind ~= "heal" and res.source then
|
|
local sm = opt.sourceNameMode
|
|
if sm == "always" or (sm == "multi" and res.srcMulti) then
|
|
local nm = res.source
|
|
if res.srcPet then nm = nm .. " (" .. res.srcPet .. ")" end
|
|
if suffix then suffix = nm .. " - " .. suffix else suffix = nm end
|
|
end
|
|
end
|
|
if res.mobName and (opt.mobNameMode == "always" or (mode == 3 and opt.mobNameMode == "anchor")) then
|
|
if suffix then suffix = suffix .. " - " .. res.mobName else suffix = res.mobName end
|
|
end
|
|
local colourKey = (res.spell or res.spellId) and "spell" or "pet"
|
|
if kind == "heal" then colourKey = "heal"
|
|
elseif opt.colourize then colourKey = kind end
|
|
return text, colourKey, isWord, mul, suffix
|
|
end
|
|
|
|
-- Demo threat preview: the buffer climbs from ~300 to 1.3x the required lead over the burst (f 0..1).
|
|
function S.DemoThreat(f, need)
|
|
need = need or 1500
|
|
local start = (need > 300) and 300 or need * 0.2
|
|
if f < 0 then f = 0 elseif f > 1 then f = 1 end
|
|
local b = start + (need * 1.3 - start) * f
|
|
return (b >= need) and "GO" or "WAIT", b, need
|
|
end
|
|
-- Demo timeline: see S.BuildDemo. Event tables are reused on every run (no allocation while it plays).
|
|
-- Fixed-anchor box and the GO / WAIT label sitting inside it (rough glyph width: 0.62 x size per char).
|
|
S.ANCHOR_W, S.ANCHOR_H, S.ANCHOR_LABEL_SIZE, S.PLATE_LABEL_SIZE = 200, 30, 12, 14
|
|
function S.EstTextWidth(text, size) return string.len(text) * size * 0.62 end
|
|
-- Where anchor-mode damage lines start so they clear the box (and the list label above it).
|
|
function S.AnchorLineOffset(showLabel) return showLabel and 16 or 2 end
|
|
-- ---- merging identical attacks ---------------------------------------------------------------
|
|
-- Is the result a word (Miss / Dodge / ...)? Same rule as S.Format.
|
|
function S.IsWordResult(res, opt)
|
|
return (S.WORDS[res.kind] ~= nil) and (((res.amount or 0) <= 0) or (opt.colourize and true or false))
|
|
end
|
|
|
|
-- Result class that must match to merge: normal hits (glancing / crushing too) and crits stay apart.
|
|
function S.MergeClass(res)
|
|
local k = res.kind
|
|
if k == "crit" or res.crit then return "crit" end
|
|
if k == "hit" or k == "glancing" or k == "crushing" then return "hit" end
|
|
return k
|
|
end
|
|
|
|
-- Does line slot s (fields mKey, mWord, mCls, mSrc, mSpell, mHealer, mPet, t) absorb this result?
|
|
-- key = the place/victim key of the line (guid, name or "anchor"); words ignore the spell.
|
|
function S.MergeMatches(s, res, key, isWord, window)
|
|
if not s.active or s.mKey ~= key or s.mWord ~= isWord or s.t > window then return false end
|
|
if s.mCls ~= S.MergeClass(res) or s.mSrc ~= res.source or s.mPet ~= res.srcPet then return false end
|
|
if isWord then return true end
|
|
return s.mSpell == (res.spellId or res.spell) and s.mHealer == res.healer
|
|
end
|
|
|
|
function S.MergeLabel(text, count, showCount)
|
|
if showCount and count > 1 then return text .. " x" .. count end
|
|
return text
|
|
end
|
|
|
|
S.DEMO_BURST_LEN = 2.5
|
|
|
|
-- Demo source: the first listed targetSCT (name, class, own colour); without one a generic shaman tank.
|
|
S.DEMO_FALLBACK_NAME = "Shemp" -- leak-gate: allow
|
|
S.DEMO_VICTIM = "Training Dummy"
|
|
function S.DemoSource(st)
|
|
local e = st and st.order and st.byName and st.byName[st.order[1]]
|
|
if e then
|
|
return e.name, e.class, e.rgb, table.getn(st.order) > 1
|
|
end
|
|
return S.DEMO_FALLBACK_NAME, "SHAMAN", { 0, 0.44, 0.87 }, false
|
|
end
|
|
|
|
-- Burst skill sets per class. Entry: { spell (nil = white hit, "@kind" = miss word), weight, typical
|
|
-- amount, upper typical amount, typical crit amount, crit % , windfury-style extra hits }.
|
|
-- SHAMAN: shares and amounts from recorded tanking fights in dungeons and raids, last 30 days
|
|
-- (Stormstrike and Earth Shock are boosted so the preview shows them; crit rates are raised to
|
|
-- make a few crits visible). Every other class: plausible level-60 tank numbers, ESTIMATES.
|
|
S.DEMO_SETS = {
|
|
SHAMAN = {
|
|
{ "Fire Strike", 51, 2, 2, 3, 10 }, { "Lightning Strike", 15, 3, 3, 5, 12 },
|
|
{ "Tidal Wave", 10, 29, 31, 43, 10 }, { nil, 9, 97, 118, 216, 22, 2 },
|
|
{ "Engulfing Shadows", 6, 100, 100, 100, 0 }, { "Ancient Accord", 3, 100, 110, 150, 6 },
|
|
{ "Thundercall", 2, 39, 56, 56, 0 }, { "Earth Shock", 8, 666, 760, 992, 15 },
|
|
{ "Stormstrike", 10, 117, 140, 241, 30 }, { "Flame Shock", 2, 85, 100, 458, 5 },
|
|
{ "@miss", 1 }, { "@dodge", 1 }, { "@parry", 1 }, { "@block", 1 }, { "@resist", 1 },
|
|
},
|
|
WARRIOR = {
|
|
{ nil, 28, 150, 190, 320, 25 }, { "Heroic Strike", 20, 280, 340, 560, 25 },
|
|
{ "Revenge", 14, 350, 420, 700, 25 }, { "Shield Slam", 14, 480, 560, 900, 25 },
|
|
{ "Sunder Armor", 10, 60, 60, 60, 0 }, { "@miss", 1 }, { "@dodge", 1 }, { "@parry", 1 }, { "@block", 1 },
|
|
},
|
|
DRUID = {
|
|
{ nil, 24, 120, 150, 260, 25 }, { "Maul", 22, 260, 320, 520, 25 }, { "Swipe", 30, 90, 110, 190, 25 },
|
|
{ "Lacerate", 12, 70, 70, 70, 0 }, { "@miss", 1 }, { "@dodge", 1 }, { "@parry", 1 }, { "@block", 1 },
|
|
},
|
|
PALADIN = {
|
|
{ nil, 28, 140, 175, 300, 25 }, { "Holy Shield", 18, 100, 120, 200, 0 },
|
|
{ "Consecration", 16, 70, 70, 70, 0 }, { "Seal of Righteousness", 22, 90, 110, 190, 25 },
|
|
{ "Hammer of the Righteous", 8, 320, 380, 640, 25 }, { "@miss", 1 }, { "@dodge", 1 }, { "@parry", 1 }, { "@block", 1 },
|
|
},
|
|
}
|
|
function S.DemoSet(class)
|
|
return S.DEMO_SETS[class or ""] or S.DEMO_SETS.WARRIOR
|
|
end
|
|
|
|
-- Timeline: a 2.5 s burst starting at once, of ~9 slots/s picked from the class set
|
|
-- by weight (deterministic credit round robin, so rare skills still show up). Each entry: t, f (0..1
|
|
-- through the burst, nil before it), sn (spell name or nil), res (event table, reused every run).
|
|
function S.BuildDemo(class)
|
|
local set = S.DemoSet(class)
|
|
local list, n = {}, 0
|
|
local t0
|
|
local function add(t, kind, amount, sn)
|
|
n = n + 1
|
|
list[n] = { t = t, sn = sn, res = { kind = kind, amount = amount } }
|
|
if t0 then list[n].f = (t - t0) / S.DEMO_BURST_LEN end
|
|
end
|
|
t0 = 0
|
|
local total = 0
|
|
local credit, uses, critAcc = {}, {}, {}
|
|
for i = 1, table.getn(set) do
|
|
total = total + set[i][2]
|
|
credit[i], uses[i], critAcc[i] = 0, 0, 60
|
|
end
|
|
local count = 22
|
|
-- every word of the set is guaranteed to appear once, spread over the burst
|
|
local forced, words = {}, {}
|
|
for i = 1, table.getn(set) do
|
|
if set[i][1] and string.sub(set[i][1], 1, 1) == "@" then table.insert(words, i) end
|
|
end
|
|
local nw = table.getn(words)
|
|
for j = 1, nw do forced[3 + math.floor((j - 1) * (count - 4) / nw)] = words[j] end
|
|
for slot = 1, count do
|
|
local t = t0 + (slot - 1) * S.DEMO_BURST_LEN / count
|
|
local best = 1
|
|
for i = 1, table.getn(set) do
|
|
credit[i] = credit[i] + set[i][2]
|
|
if credit[i] > credit[best] then best = i end
|
|
end
|
|
credit[best] = credit[best] - total
|
|
if forced[slot] then best = forced[slot] end
|
|
local d = set[best]
|
|
uses[best] = uses[best] + 1
|
|
local word = d[1] and string.sub(d[1], 1, 1) == "@" and string.sub(d[1], 2)
|
|
if word then
|
|
add(t, word, 0)
|
|
else
|
|
local crit = false
|
|
local rate = d[6] or 0
|
|
if rate > 0 then
|
|
critAcc[best] = critAcc[best] + rate
|
|
if critAcc[best] >= 100 then critAcc[best] = critAcc[best] - 100; crit = true end
|
|
end
|
|
local amount = crit and d[5] or ((math.mod(uses[best], 2) == 1) and d[3] or d[4])
|
|
add(t, crit and "crit" or "hit", amount, d[1])
|
|
if not d[1] and d[7] and uses[best] == 2 then -- an extra attack in the same frame
|
|
for _ = 1, d[7] do add(t, "hit", d[3], nil) end
|
|
end
|
|
end
|
|
end
|
|
return list, n, list[n].t + 1.5
|
|
end
|
|
|
|
if CreateFrame then
|
|
local W = AnySCT_W
|
|
local C = AnySCT_Core
|
|
local P = AnySCT_Plates
|
|
|
|
local POOL_MAX = 100 -- slot tables only; FontStrings are created on first use (ensureFs)
|
|
local critAnimated = S.CurveAnimated(STYLE.critKeyframes)
|
|
local critActive = S.CurveActive(STYLE.critKeyframes)
|
|
local GAP = 3 -- px between the plate top and the text
|
|
|
|
local anchor, float, listLabel
|
|
local moveMode = false
|
|
local activeCount = 0
|
|
|
|
local slots = {}
|
|
local freeStack, freeTop = {}, 0
|
|
for i = 1, POOL_MAX do
|
|
slots[i] = { active = false, fs = nil, sfx = nil, t = 0, dur = 1.5, rise = 120, dir = 1,
|
|
dx = 0, push = 0, base = 24, crit = false, key = nil, fadeOut = 1,
|
|
plate = nil, guidNorm = nil, lastX = nil, lastY = nil, lastW = 0, lastH = 0 }
|
|
freeTop = freeTop + 1
|
|
freeStack[freeTop] = i
|
|
end
|
|
|
|
local function opt(key) return C.Opt(key) end
|
|
|
|
local function setFont(fs, size)
|
|
fs:SetFont(S.FontPath(opt("font")), size) -- no outline: the engine text uses a shadow
|
|
end
|
|
|
|
local function applyMoveVisuals()
|
|
if moveMode then
|
|
anchor:EnableMouse(true)
|
|
anchor:SetBackdropColor(0.05, 0.08, 0.12, 0.8)
|
|
anchor:SetBackdropBorderColor(0.9, 0.78, 0.49, 1)
|
|
else
|
|
anchor:EnableMouse(false)
|
|
anchor:SetBackdropColor(0, 0, 0, 0)
|
|
anchor:SetBackdropBorderColor(0, 0, 0, 0)
|
|
end
|
|
end
|
|
|
|
local dragging = false
|
|
|
|
-- UIParent's rect in the same coordinate system as the anchor's (see C.AnchorPosFromCenter).
|
|
function S.ScreenRect()
|
|
local l, b, r, t = UIParent:GetLeft(), UIParent:GetBottom(), UIParent:GetRight(), UIParent:GetTop()
|
|
if not (l and b and r and t) then
|
|
l, b, r, t = 0, 0, UIParent:GetWidth(), UIParent:GetHeight()
|
|
end
|
|
return l, b, r, t
|
|
end
|
|
|
|
function S.IsDragging() return dragging end
|
|
|
|
local function placeAnchor()
|
|
local pos = opt("pos") or AnySCT_DEFAULTS.pos
|
|
anchor:ClearAllPoints()
|
|
anchor:SetPoint(pos.point or "CENTER", UIParent, pos.point or "CENTER", pos.x, pos.y)
|
|
end
|
|
|
|
local onUpdate, followUpdate
|
|
|
|
local function build()
|
|
if anchor then return anchor end
|
|
-- container of every floating line; SetClampedToScreen is a second safety net
|
|
float = CreateFrame("Frame", "AnySCTFloat", UIParent)
|
|
float:SetAllPoints(UIParent)
|
|
float:SetFrameStrata("HIGH")
|
|
float:EnableMouse(false)
|
|
float:SetClampedToScreen(true)
|
|
|
|
local a = CreateFrame("Frame", "AnySCTAnchor", UIParent)
|
|
a:SetWidth(S.ANCHOR_W)
|
|
a:SetHeight(S.ANCHOR_H)
|
|
a:SetFrameStrata("HIGH")
|
|
a:SetFrameLevel(10)
|
|
a:SetMovable(true)
|
|
a:EnableMouse(false)
|
|
a:SetClampedToScreen(true)
|
|
a:RegisterForDrag("LeftButton")
|
|
a:SetBackdrop(W.SOLID_BACKDROP)
|
|
a:SetScript("OnDragStart", function()
|
|
if moveMode then
|
|
dragging = true
|
|
this:StartMoving()
|
|
end
|
|
end)
|
|
a:SetScript("OnDragStop", function()
|
|
this:StopMovingOrSizing()
|
|
dragging = false
|
|
local cx, cy = this:GetCenter()
|
|
if not cx then return end
|
|
local l, b, r, t = S.ScreenRect()
|
|
C.SetOpt("pos", C.AnchorPosFromCenter(cx, cy, (l + r) / 2, (b + t) / 2))
|
|
end)
|
|
anchor = a
|
|
|
|
listLabel = a:CreateFontString("AnySCTLabel", "OVERLAY")
|
|
W.ApplyFont(listLabel, 11, "OUTLINE")
|
|
listLabel:SetPoint("BOTTOM", a, "TOP", 0, 2)
|
|
placeAnchor()
|
|
a:Show()
|
|
applyMoveVisuals()
|
|
S.UpdateLabel()
|
|
return a
|
|
end
|
|
S.Build = build
|
|
|
|
function S.UpdateLabel()
|
|
if not anchor then return end
|
|
if not opt("showLabel") then listLabel:Hide() return end
|
|
listLabel:Show()
|
|
local st = C.state
|
|
if table.getn(st.order) == 0 then
|
|
listLabel:SetText("targetSCTs: none")
|
|
listLabel:SetTextColor(0.55, 0.55, 0.55)
|
|
else
|
|
listLabel:SetText("targetSCTs: " .. table.concat(st.order, ", "))
|
|
listLabel:SetTextColor(1, 1, 1)
|
|
end
|
|
end
|
|
|
|
-- ---- pool ---------------------------------------------------------------------------------
|
|
local function ensureFs(i)
|
|
local s = slots[i]
|
|
if s.fs then return end
|
|
s.fs = float:CreateFontString("AnySCTNum" .. i, "OVERLAY")
|
|
s.sfx = float:CreateFontString("AnySCTSfx" .. i, "OVERLAY")
|
|
end
|
|
|
|
-- Free slot; at a cap (total maxLines, or maxLinesPerTarget lines of one mob) the oldest
|
|
-- matching line is recycled. key identifies the mob (guid, name, or "anchor").
|
|
local function acquire(key)
|
|
local maxLines = opt("maxLines") or STYLE.maxLines
|
|
if maxLines > POOL_MAX then maxLines = POOL_MAX end
|
|
local perTarget = opt("maxLinesPerTarget") or STYLE.maxPerTarget
|
|
local same = 0
|
|
for i = 1, POOL_MAX do
|
|
if slots[i].active and slots[i].key == key then same = same + 1 end
|
|
end
|
|
if same < perTarget and freeTop > 0 and activeCount < maxLines then
|
|
local i = freeStack[freeTop]
|
|
freeStack[freeTop] = nil
|
|
freeTop = freeTop - 1
|
|
activeCount = activeCount + 1
|
|
return i
|
|
end
|
|
local oldest, oldestT = 1, -1
|
|
for i = 1, POOL_MAX do
|
|
local sl = slots[i]
|
|
if sl.active and (same < perTarget or sl.key == key) and sl.t > oldestT then
|
|
oldestT = sl.t; oldest = i
|
|
end
|
|
end
|
|
return oldest
|
|
end
|
|
|
|
local function release(i)
|
|
freeTop = freeTop + 1
|
|
freeStack[freeTop] = i
|
|
activeCount = activeCount - 1
|
|
end
|
|
|
|
onUpdate = function()
|
|
local dt = arg1
|
|
local any = false
|
|
local margin = opt("edgeMargin") or 40
|
|
local xo, yo = opt("xOffset") or 0, opt("yOffset") or 0
|
|
local needScan = false
|
|
for i = 1, POOL_MAX do
|
|
local s = slots[i]
|
|
if s.active then
|
|
s.t = s.t + dt
|
|
if s.t >= s.dur then
|
|
s.active = false
|
|
s.fs:Hide()
|
|
s.sfx:Hide()
|
|
release(i)
|
|
else
|
|
any = true
|
|
local t = s.t
|
|
local a = 1
|
|
if t < STYLE.fadeIn then a = t / STYLE.fadeIn end
|
|
if t > s.fadeOut then a = a * (s.dur - t) / (s.dur - s.fadeOut) end
|
|
local rise = s.rise
|
|
if s.crit then
|
|
rise = rise * STYLE.critRiseFactor
|
|
if critAnimated then
|
|
s.fs:SetTextHeight(s.base * S.KeyScale(STYLE.critKeyframes, t / s.dur))
|
|
end
|
|
end
|
|
local off = (t / s.dur * rise + s.push) * s.dir
|
|
s.fs:ClearAllPoints()
|
|
if s.plate then
|
|
needScan = true
|
|
P.FollowLine(s)
|
|
local x, y = s.lastX + xo + s.dx, s.lastY + GAP + yo + off
|
|
if not (s.lastX >= margin and s.lastX <= s.lastW - margin
|
|
and s.lastY >= margin and s.lastY <= s.lastH - margin) then
|
|
x, y = AnySCT_ClampToScreen(x, y, s.lastW, s.lastH, margin)
|
|
end
|
|
-- a tall stack of a burst never leaves the screen at the top
|
|
if y > s.lastH - margin then y = s.lastH - margin end
|
|
s.fs:SetPoint("BOTTOM", UIParent, "BOTTOMLEFT", x, y)
|
|
else
|
|
if s.dir < 0 then
|
|
s.fs:SetPoint("TOP", anchor, "BOTTOM", s.dx, off - 2)
|
|
else
|
|
s.fs:SetPoint("BOTTOM", anchor, "TOP", s.dx, off + S.AnchorLineOffset(opt("showLabel")))
|
|
end
|
|
end
|
|
s.fs:SetAlpha(a)
|
|
s.fs:SetShadowColor(0, 0, 0, a)
|
|
s.sfx:SetAlpha(a)
|
|
end
|
|
end
|
|
end
|
|
if needScan then P.Scan(false) end -- 0.2 s cadence, keeps the scan generation moving
|
|
if not any then float:SetScript("OnUpdate", nil) end
|
|
end
|
|
|
|
-- Spawn one line. mode/plate/px.. come from P.Select (mode 3 = fixed anchor).
|
|
local function spawn(res, mode, plate, px, py, pw, ph)
|
|
local o = C.Opts()
|
|
local key = res.mobGuid or res.mobName or "anchor"
|
|
if mode == 3 then key = "anchor" end
|
|
local isWord0 = S.IsWordResult(res, o)
|
|
if o.mergeHits ~= false then
|
|
local window = o.mergeWindow or 0.4
|
|
for j = 1, POOL_MAX do
|
|
local m = slots[j]
|
|
if m.active and S.MergeMatches(m, res, key, isWord0, window) then
|
|
-- fold into the live line: same position and fade, only the text changes
|
|
if not isWord0 then
|
|
m.mSum = m.mSum + (res.amount or 0)
|
|
m.mCount = m.mCount + 1
|
|
local a0 = res.amount
|
|
res.amount = m.mSum
|
|
local text = S.Format(res, o, mode)
|
|
res.amount = a0
|
|
text = S.MergeLabel(text, m.mCount, o.mergeCount)
|
|
if text ~= m.mText then
|
|
m.mText = text
|
|
m.fs:SetText(text)
|
|
end
|
|
end
|
|
C.Ledger(res, "merged")
|
|
return
|
|
end
|
|
end
|
|
end
|
|
local i = acquire(key)
|
|
local s = slots[i]
|
|
s.mKey, s.mWord, s.mCls, s.mSrc, s.mPet = key, isWord0, S.MergeClass(res), res.source, res.srcPet
|
|
s.mSpell, s.mHealer = res.spellId or res.spell, res.healer
|
|
s.mSum, s.mCount = res.amount or 0, 1
|
|
C.Ledger(res, s.active and "shown+recycled" or "shown")
|
|
s.key = key
|
|
ensureFs(i)
|
|
local text, ckey, isWord, mul, suffix = S.Format(res, o, mode)
|
|
local fs, sfx = s.fs, s.sfx
|
|
|
|
local sw, sh = GetScreenWidth(), GetScreenHeight()
|
|
s.crit = (res.kind == "crit") or (res.crit and true or false)
|
|
local scale = s.crit and STYLE.critSizeScale or STYLE.sizeScale
|
|
local factor = isWord and (o.wordFactor or 1) or (o.sizeFactor or 1)
|
|
local base = S.TextSize(scale, factor, sw, sh)
|
|
s.base = base * mul
|
|
|
|
-- older lines of the same mob move one text height away
|
|
for j = 1, POOL_MAX do
|
|
if slots[j].active and slots[j].key == key then slots[j].push = slots[j].push + s.base end
|
|
end
|
|
|
|
s.active = true
|
|
s.t = 0
|
|
s.push = 0
|
|
s.dur = STYLE.lifetime
|
|
s.rise = o.riseHeight or STYLE.riseHeight
|
|
s.dir = (o.direction == "down") and -1 or 1
|
|
local jt = o.jitter or 0
|
|
if jt > 0 then s.dx = math.random(-jt, jt) else s.dx = 0 end
|
|
if isWord then
|
|
s.fadeOut = (res.kind == "absorb") and STYLE.fadeOutAbsorb or STYLE.fadeOutWord
|
|
elseif s.crit then
|
|
s.fadeOut = STYLE.fadeOutCrit
|
|
else
|
|
s.fadeOut = STYLE.fadeOutNumber
|
|
end
|
|
if mode == 3 then
|
|
s.plate, s.guidNorm, s.valid = nil, nil, false
|
|
else
|
|
s.plate = plate
|
|
s.guidNorm = res.mobGuid and C.NormGuid(res.mobGuid) or nil
|
|
s.lastX, s.lastY, s.lastW, s.lastH = px, py, pw, ph
|
|
s.gen, s.valid = P.gen, true
|
|
end
|
|
|
|
local dxs, dys = STYLE.shadow * sw, STYLE.shadow * sh
|
|
setFont(fs, s.base)
|
|
if s.crit and critActive then
|
|
fs:SetTextHeight(s.base * S.KeyScale(STYLE.critKeyframes, 0))
|
|
else
|
|
fs:SetTextHeight(s.base)
|
|
end
|
|
fs:SetShadowOffset(dxs, -dys)
|
|
local cr, cg, cb = S.PickColour(res, o, ckey)
|
|
fs:SetTextColor(cr, cg, cb)
|
|
fs:SetText(text)
|
|
s.mText = text
|
|
fs:SetAlpha(0)
|
|
fs:SetShadowColor(0, 0, 0, 0)
|
|
fs:Show()
|
|
|
|
if suffix then
|
|
sfx:SetFont(S.FontPath(o.font), math.max(10, math.floor(s.base * 0.3)))
|
|
sfx:SetShadowOffset(dxs, -dys)
|
|
sfx:SetShadowColor(0, 0, 0, 1)
|
|
sfx:SetTextColor(cr, cg, cb)
|
|
sfx:SetText(suffix)
|
|
sfx:ClearAllPoints()
|
|
sfx:SetPoint("TOP", fs, "BOTTOM", 0, 0)
|
|
sfx:SetAlpha(0)
|
|
sfx:Show()
|
|
else
|
|
sfx:Hide()
|
|
end
|
|
float:SetScript("OnUpdate", onUpdate)
|
|
end
|
|
|
|
function S.Show(res)
|
|
if not res then return end
|
|
build()
|
|
local o = C.Opts()
|
|
local plate
|
|
if o.placement ~= "anchor" and (res.mobGuid or res.mobName) then
|
|
plate = P.Find(res.mobGuid, res.mobName, res.mobUnit)
|
|
end
|
|
local mode, px, py, pw, ph, also = P.Places(plate, o)
|
|
if C.debug then
|
|
C.Dbg("place " .. tostring(res.mobName) .. ": " .. (plate and "plate found" or "no plate")
|
|
.. ", mode " .. tostring(mode) .. (mode == 0 and " (hidden by option)" or ""))
|
|
end
|
|
if mode == 0 then
|
|
C.Ledger(res, "dropped:placement")
|
|
return
|
|
end
|
|
spawn(res, mode, plate, px, py, pw, ph)
|
|
if also then spawn(res, 3) end -- "Nameplate + anchor": a second, separately capped stack
|
|
end
|
|
|
|
function S.OptionChanged(key)
|
|
if not anchor then return end
|
|
if (key == "all" or key == "pos") and not dragging then placeAnchor() end
|
|
S.UpdateLabel()
|
|
end
|
|
|
|
-- ---- GO / WAIT threat label ------------------------------------------------------------------
|
|
-- ONE label over the nameplate of the PLAYER's target. core.lua decides status and numbers
|
|
-- (C.ThreatDecide); this only draws. The follow OnUpdate is attached only while the label is shown.
|
|
local TL = { fs = nil, shown = false, plate = nil, status = nil, text = nil, lastText = nil,
|
|
lastMode = 0, lastName = nil, mobName = nil, guid = nil }
|
|
local TL2 = { fs = nil, lastText = nil, lastMode = 0, lastName = nil } -- anchor copy ("both")
|
|
local followFrame
|
|
local findAcc = 0
|
|
|
|
-- status nil hides the label.
|
|
function S.SetThreat(status, buffer, need, srcName)
|
|
if not anchor then return end
|
|
if not status then
|
|
if TL.shown then
|
|
TL.shown = false
|
|
if TL.fs then TL.fs:Hide() end
|
|
if TL2.fs then TL2.fs:Hide() end
|
|
end
|
|
if followFrame then followFrame:SetScript("OnUpdate", nil) end
|
|
return
|
|
end
|
|
if not TL.fs then
|
|
TL.fs = float:CreateFontString("AnySCTThreatLabel", "OVERLAY")
|
|
TL.fs:SetFont(S.FontPath(opt("font")), 14, "OUTLINE")
|
|
end
|
|
TL.status = status
|
|
TL.text = S.ThreatText(status, buffer, need, srcName, nil)
|
|
TL.shown = true
|
|
findAcc = 1 -- look the plate up on the next frame
|
|
if not followFrame then followFrame = CreateFrame("Frame", "AnySCTFollowFrame", UIParent) end
|
|
followFrame:SetScript("OnUpdate", followUpdate)
|
|
end
|
|
|
|
-- Draw the label fs (state record L) for a placement mode; text and font change only on change.
|
|
local function drawLabel(L, fs, mode, px, py, pw, ph, margin, lift)
|
|
local size = (mode == 3) and S.ANCHOR_LABEL_SIZE or S.PLATE_LABEL_SIZE
|
|
if size ~= L.size then
|
|
L.size = size
|
|
fs:SetFont(S.FontPath(opt("font")), size, "OUTLINE")
|
|
L.lastText = nil
|
|
end
|
|
local name = (mode == 3) and TL.mobName or nil
|
|
if TL.text ~= L.lastText or mode ~= L.lastMode or name ~= L.lastName then
|
|
L.lastText, L.lastMode, L.lastName = TL.text, mode, name
|
|
fs:SetText(name and (name .. ": " .. TL.text) or TL.text)
|
|
if TL.status == "GO" then fs:SetTextColor(0.2, 1, 0.2) else fs:SetTextColor(1, 0.6, 0.1) end
|
|
end
|
|
fs:ClearAllPoints()
|
|
if mode == 3 then
|
|
fs:SetPoint("CENTER", anchor, "CENTER", 0, 0)
|
|
else
|
|
local x, y = px, py + lift
|
|
if mode == 2 then x, y = AnySCT_ClampToScreen(x, y, pw, ph, margin) end
|
|
fs:SetPoint("BOTTOM", UIParent, "BOTTOMLEFT", x, y)
|
|
end
|
|
fs:Show()
|
|
end
|
|
|
|
followUpdate = function()
|
|
if not TL.shown then return end
|
|
findAcc = findAcc + arg1
|
|
local o = C.Opts()
|
|
if findAcc >= 0.5 then
|
|
findAcc = 0
|
|
TL.plate = nil
|
|
TL.mobName = UnitName("target")
|
|
TL.guid = C.ResolveGuid("target")
|
|
if o.placement ~= "anchor" and not TL.forceAnchor then TL.plate = P.Find(TL.guid, TL.mobName, "target") end
|
|
end
|
|
local margin = o.edgeMargin or 40
|
|
local lift = S.TextSize(STYLE.sizeScale, o.sizeFactor or 1, GetScreenWidth(), GetScreenHeight()) + 6
|
|
local mode, px, py, pw, ph, also = P.Places(TL.plate, o)
|
|
if mode == 0 then
|
|
TL.fs:Hide()
|
|
if TL2.fs then TL2.fs:Hide() end
|
|
return
|
|
end
|
|
drawLabel(TL, TL.fs, mode, px, py, pw, ph, margin, lift)
|
|
if also then
|
|
if not TL2.fs then
|
|
TL2.fs = float:CreateFontString("AnySCTThreatLabel2", "OVERLAY")
|
|
TL2.fs:SetFont(S.FontPath(opt("font")), S.ANCHOR_LABEL_SIZE, "OUTLINE")
|
|
end
|
|
drawLabel(TL2, TL2.fs, 3, nil, nil, nil, nil, margin, lift)
|
|
elseif TL2.fs then
|
|
TL2.fs:Hide()
|
|
end
|
|
end
|
|
|
|
-- ---- demo / move / memory ------------------------------------------------------------------
|
|
-- Fixed sequence for side-by-side comparison with the player's own real numbers, then the burst.
|
|
local demoCache = {}
|
|
local DEMO, DEMO_N, DEMO_END
|
|
local demoIdx, demoT, demoTicker, demoAtAnchor = 1, 0, nil, false
|
|
local dSrc, dClass, dRgb, dMulti, dVictim = nil, nil, nil, false, nil
|
|
|
|
local function demoOnUpdate()
|
|
demoT = demoT + arg1
|
|
local showName = opt("showSpellName")
|
|
while demoIdx <= DEMO_N and DEMO[demoIdx].t <= demoT do
|
|
local e = DEMO[demoIdx]
|
|
local res = e.res
|
|
demoIdx = demoIdx + 1
|
|
-- same fields a real event carries (C.Emit), so every display setting applies
|
|
res.source, res.srcRgb, res.srcMulti, res.class = dSrc, dRgb, dMulti, dClass
|
|
res.spell = (e.sn and showName) and e.sn or nil
|
|
res.spellId = e.sn and 1 or nil
|
|
res.mobGuid, res.mobName, res.mobUnit = nil, dVictim, nil
|
|
if not demoAtAnchor and UnitExists("target") then
|
|
res.mobGuid = C.ResolveGuid("target")
|
|
res.mobName = UnitName("target")
|
|
res.mobUnit = "target"
|
|
S.Show(res)
|
|
else
|
|
spawn(res, 3)
|
|
end
|
|
if e.f then
|
|
-- the GO / WAIT preview rides the burst (real label code path, even with threatGo off)
|
|
local status, buf, need = S.DemoThreat(e.f, opt("threatGoLead"))
|
|
S.SetThreat(status, buf, need, C.ThreatSrcName and C.ThreatSrcName(dSrc))
|
|
end
|
|
end
|
|
if demoT >= DEMO_END then
|
|
TL.forceAnchor = false
|
|
S.SetThreat(nil)
|
|
this:SetScript("OnUpdate", nil)
|
|
end
|
|
end
|
|
|
|
-- /asct demo plays at the nameplate of the current target (the same placement rules as real
|
|
-- events); without a target, or with atAnchor, at the fixed anchor. A second call restarts it.
|
|
function S.Demo(atAnchor)
|
|
build()
|
|
demoIdx, demoT = 1, 0
|
|
demoAtAnchor = atAnchor and true or false
|
|
dSrc, dClass, dRgb, dMulti = S.DemoSource(C.state)
|
|
dVictim = UnitExists("target") and UnitName("target") or S.DEMO_VICTIM
|
|
local key = S.DEMO_SETS[dClass or ""] and dClass or "WARRIOR"
|
|
if not demoCache[key] then
|
|
local l, n, e = S.BuildDemo(key)
|
|
demoCache[key] = { l, n, e }
|
|
end
|
|
DEMO, DEMO_N, DEMO_END = demoCache[key][1], demoCache[key][2], demoCache[key][3]
|
|
TL.forceAnchor = demoAtAnchor
|
|
S.SetThreat(nil)
|
|
if not demoTicker then demoTicker = CreateFrame("Frame", "AnySCTDemoFrame", UIParent) end
|
|
demoTicker:SetScript("OnUpdate", demoOnUpdate)
|
|
end
|
|
|
|
function S.FontStringCount()
|
|
local n = 1 -- the targetSCT list label
|
|
for i = 1, POOL_MAX do
|
|
if slots[i].fs then n = n + 2 end
|
|
end
|
|
if TL.fs then n = n + 1 end
|
|
return n
|
|
end
|
|
|
|
-- /asct mem: gcinfo() is KB in use. Phase 1: 10 s idle. Phase 2: a demo burst.
|
|
local memFrame, memPhase, memT, memStart = nil, 0, 0, 0
|
|
function S.Mem()
|
|
build()
|
|
if not memFrame then memFrame = CreateFrame("Frame", "AnySCTMemFrame", UIParent) end
|
|
C.Print("memory now " .. gcinfo() .. " KB, " .. S.FontStringCount() .. " FontStrings; measuring 10 s idle ...")
|
|
memPhase, memT, memStart = 1, 0, gcinfo()
|
|
memFrame:SetScript("OnUpdate", function()
|
|
memT = memT + arg1
|
|
if memPhase == 1 and memT >= 10 then
|
|
C.Print("idle 10 s: " .. (gcinfo() - memStart) .. " KB change; starting demo burst ...")
|
|
memPhase, memT, memStart = 2, 0, gcinfo()
|
|
S.Demo(true)
|
|
elseif memPhase == 2 and memT >= 7 then
|
|
C.Print("demo burst: " .. (gcinfo() - memStart) .. " KB change; now " .. gcinfo()
|
|
.. " KB, " .. S.FontStringCount() .. " FontStrings")
|
|
memPhase = 0
|
|
this:SetScript("OnUpdate", nil)
|
|
end
|
|
end)
|
|
end
|
|
|
|
function S.SetMoveMode(on)
|
|
build()
|
|
moveMode = on and true or false
|
|
applyMoveVisuals()
|
|
if moveMode then
|
|
S.Demo(true)
|
|
C.Print("anchor unlocked: drag the box, then /anysct lock")
|
|
else
|
|
C.Print("anchor locked")
|
|
end
|
|
if AnySCT_Options and AnySCT_Options.refresh then AnySCT_Options.refresh() end
|
|
end
|
|
|
|
function S.IsMoveMode() return moveMode end
|
|
function S.ToggleMove() S.SetMoveMode(not moveMode) end
|
|
end
|