mirror of
https://github.com/TheRealFayz/SHPlates.git
synced 2026-11-16 04:20:34 +00:00
- Plates hidden by your settings no longer push the shown ones around, so your target's plate stays put in a crowd of hidden plates - The game's own name text under a plate no longer flashes when a plate moves to another unit Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ko9hUfnYSmUd92vt8kp7JL
1618 lines
61 KiB
Lua
1618 lines
61 KiB
Lua
-------------------------------------------------------------------------------
|
|
-- SHPlates: Core
|
|
-- Port of the Tidy Plates engine to the 1.12 client.
|
|
--
|
|
-- What changed versus 3.3.5:
|
|
-- * Vanilla plates are Buttons with regions border, glow, name, level,
|
|
-- levelicon (skull), raidicon and ONE child (the health bar). There is no
|
|
-- cast bar and no threat glow on the plate itself.
|
|
-- * Unit identity comes from SuperWoW (plate:GetName(1) returns the GUID).
|
|
-- That GUID is used as a unit token for class, elite, combat and target.
|
|
-- * Casts come from UNIT_CASTEVENT (see Data.lua) for every plate, not just
|
|
-- the target. Aggro comes from Data.GetThreatSituation.
|
|
-- * Lua 5.0: no '#', no select, no '...' varargs, script handlers use 'this'.
|
|
--
|
|
-- The theme API is unchanged: SetStyle, SetScale, SetAlpha, SetHealthbarColor,
|
|
-- SetThreatColor, SetCastbarColor, SetSpecialText, SetSpecialText2,
|
|
-- SetSpecialArt, OnInitialize, OnUpdate, OnContextUpdate.
|
|
-------------------------------------------------------------------------------
|
|
|
|
local C = SHPlates.Compat
|
|
local Data = SHPlates.Data
|
|
local wipe, InCombat = C.wipe, C.InCombat
|
|
local pairs, tostring, GetTime = pairs, tostring, GetTime
|
|
local CreateStatusbar = SHPlates.CreateStatusbar
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- I. Variables and Simple Functions
|
|
-------------------------------------------------------------------------------
|
|
local activetheme = {}
|
|
local realtheme = {} -- the theme in use; activetheme can briefly be the designer sample's
|
|
local numChildren = -1
|
|
local echoUpdateList = {}
|
|
local echoSelf = {}
|
|
local ForEachPlate
|
|
local EMPTY_TEXTURE = SHPlates.MEDIA .. "Empty"
|
|
local useAutoHide = false
|
|
local inCombat, HasTarget = false, false
|
|
local targetGUID, targetName
|
|
local Plates, PlatesVisible = {}, {}
|
|
local GUID = {}
|
|
|
|
-- Show or hide everything a plate draws, part by part. The 1.12 client only
|
|
-- passes a frame's opacity down to the children that exist when it is set,
|
|
-- so widgets a theme creates later (mana bar, class icon...) would stay
|
|
-- visible on a hidden plate. Parts are fully on or off; the plate frame
|
|
-- itself carries the in-between opacity (non-target fading).
|
|
local function SetPartsAlpha(ext, alpha)
|
|
local a = (alpha and alpha > 0) and 1 or 0
|
|
local b = ext.bars
|
|
if b then
|
|
if b.healthbar then b.healthbar:SetAlpha(a) end
|
|
if b.castbar then b.castbar:SetAlpha(a) end
|
|
end
|
|
if ext.iconFrame then ext.iconFrame:SetAlpha(a) end
|
|
if ext.widgets then
|
|
for _, w in pairs(ext.widgets) do
|
|
if type(w) == "table" and w.SetAlpha then w:SetAlpha(a) end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- How far a plate's health bar is from what the GUID's unit really has (0-1)
|
|
local function HealthMismatch(plate, guid)
|
|
local ext = plate.extended
|
|
local bar = ext and ext.bars and ext.bars.health
|
|
if not bar then return 0 end
|
|
local _, barMax = bar:GetMinMaxValues()
|
|
local realMax = UnitHealthMax(guid)
|
|
if not (barMax and barMax > 0 and realMax and realMax > 0) then return 0 end
|
|
return math.abs((bar:GetValue() or 0) / barMax - (UnitHealth(guid) or 0) / realMax)
|
|
end
|
|
|
|
-- The plate's GUID, unless another visible plate holds the same one and fits
|
|
-- it better. The client can leave a recycled plate holding the previous mob's
|
|
-- GUID; in a pack of same-named mobs the name check can't catch that, and two
|
|
-- plates would read one mob (its debuffs showing on both). Health decides.
|
|
local function ResolveGUID(plate, plateName)
|
|
local guid = C.PlateGUID(plate, plateName)
|
|
if not guid then return nil end
|
|
local other = GUID[guid]
|
|
if other and other ~= plate and other:IsShown() then
|
|
if HealthMismatch(plate, guid) >= HealthMismatch(other, guid) then return nil end
|
|
end
|
|
return guid
|
|
end
|
|
local nameplate, extended, bars, regions, visual
|
|
local unit, unitcache, style, stylename
|
|
local lastMouseover, currentTarget, unitchanged
|
|
local forceStyleUpdate = false
|
|
|
|
local overlapMode = false -- "Allow overlapping nameplates"
|
|
|
|
-- Vanilla stacks plates using the size of the Blizzard frame. For overlap,
|
|
-- that frame shrinks to 1x1. Either way it stops taking the mouse; our own
|
|
-- click frame (extended.clicker) takes the clicks and forwards them to it.
|
|
-- Settings live in each template's vars (Grey/Tank, Neon/DPS...): the one
|
|
-- being drawn right now first, then the template defaults, then the global
|
|
-- settings (pfUI switch, learned casts and so on)
|
|
local function Opt(key)
|
|
local vars = activetheme and activetheme.vars
|
|
local v = vars and vars[key]
|
|
if v == nil and SHPlates.TEMPLATE_DEFAULTS then v = SHPlates.TEMPLATE_DEFAULTS[key] end
|
|
if v == nil and SHPlatesDB then v = SHPlatesDB[key] end
|
|
return v
|
|
end
|
|
SHPlates.TOpt = Opt
|
|
|
|
local CLASS_COLORS = {
|
|
WARRIOR = { .78, .61, .43 }, MAGE = { .41, .80, .94 }, ROGUE = { 1, .96, .41 },
|
|
DRUID = { 1, .49, .04 }, HUNTER = { .67, .83, .45 }, SHAMAN = { 0, .44, .87 },
|
|
PRIEST = { 1, 1, 1 }, WARLOCK = { .58, .51, .79 }, PALADIN = { .96, .55, .73 },
|
|
}
|
|
SHPlates.CLASS_COLORS = CLASS_COLORS
|
|
|
|
local CRITTER_TYPES = { ["Critter"] = true, ["Kleintier"] = true, ["Bestiole"] = true, ["Alimaña"] = true }
|
|
|
|
-- Neutral mobs that joined the fight (same idea as GudaPlates): once a neutral
|
|
-- mob has gone after you or your group it stays "hostile" until it dies or
|
|
-- the fight is over. Without this it flickers back to hidden whenever it
|
|
-- briefly has no target (stuns, fear, switching targets, chasing a pet).
|
|
local angryNeutrals = {}
|
|
local function RememberAngry(guid) angryNeutrals[guid] = true end
|
|
local function IsAngryNeutral(guid)
|
|
if not (guid and angryNeutrals[guid]) then return false end
|
|
if UnitIsDead(guid) or not UnitExists(guid) then angryNeutrals[guid] = nil; return false end
|
|
return true
|
|
end
|
|
SHPlates.IsAngryNeutral = IsAngryNeutral
|
|
|
|
-- Global (theme independent) visibility rules from the General page
|
|
local function IsFilteredOut(u)
|
|
if u.isTarget then return false end
|
|
if Opt("hideFriendly") and u.reaction == "FRIENDLY" then return true end
|
|
if Opt("hideCritters") and u.isCritter then return true end
|
|
return false
|
|
end
|
|
|
|
SHPlates.IsFilteredOut = IsFilteredOut
|
|
|
|
-- Size of the client's plate frame, which is what it spaces plates by.
|
|
-- Stacking: our full size (worked out in UpdateStackingSize). Overlap, and
|
|
-- hidden plates in stacking mode: a single point. A hidden plate that kept
|
|
-- its full size still pushed the shown ones around, so in a crowd of hidden
|
|
-- friendly players your target's plate kept jumping from spot to spot.
|
|
local function ApplyFrameSize(plate)
|
|
local ext = plate.extended
|
|
local w, h = ext.stackW, ext.stackH
|
|
if overlapMode or ext:GetAlpha() == 0 then w, h = 1, 1
|
|
elseif not w then return end
|
|
if math.abs(plate:GetWidth() - w) > .5 or math.abs(plate:GetHeight() - h) > .5 then
|
|
plate:SetWidth(w); plate:SetHeight(h)
|
|
end
|
|
end
|
|
|
|
-- Our click frame always takes the clicks: the plate is drawn up off the
|
|
-- client's frame (see UpdateStyle), so that frame no longer sits under it.
|
|
local function ApplyPlateMouse(plate, clickable)
|
|
if Opt("clickThrough") then clickable = false end
|
|
-- a spell waiting for a ground target needs the click to reach the world
|
|
if SpellIsTargeting and SpellIsTargeting() then clickable = false end
|
|
local ext = plate.extended
|
|
ApplyFrameSize(plate)
|
|
plate:EnableMouse(false)
|
|
ext.clicker:EnableMouse(clickable)
|
|
end
|
|
|
|
-- Stacking: the game spaces plates using the Blizzard frame's size, so in
|
|
-- stacking mode that frame covers everything SHPlates draws (frame size times
|
|
-- the current scale), not just Tidy Plates' smaller click hitbox.
|
|
local function UpdateStackingSize(plate)
|
|
local ext = plate.extended
|
|
if overlapMode then return end
|
|
local st = ext.style
|
|
if not (st and st.frame and st.hitbox) then return end
|
|
local scale = ext:GetScale() or 1
|
|
local w = math.max(st.hitbox.width or 0, st.frame.width or 0) * scale
|
|
local h = math.max(st.hitbox.height or 0, st.frame.height or 0) * scale
|
|
ext.stackW, ext.stackH = w, h
|
|
ApplyFrameSize(plate)
|
|
end
|
|
|
|
local POLL_INTERVAL = .2 -- full data refresh of visible plates
|
|
local pollTimer = 0
|
|
|
|
SHPlates.GUID = GUID
|
|
SHPlates.VisibleNameplates = PlatesVisible
|
|
SHPlates.AllNameplates = Plates
|
|
|
|
local function IsPlateShown(plate) if plate:IsShown() then return true end end
|
|
|
|
-- A unit's cast: by GUID with SuperWoW, by name from the combat log without
|
|
local previewCast = { spell = "Shadow Bolt", icon = "Interface\\Icons\\Spell_Shadow_ShadowBolt" }
|
|
local function GetUnitCast(u)
|
|
if u.isPreview then
|
|
local now = GetTime()
|
|
if not previewCast.finish or now >= previewCast.finish - .1 then
|
|
previewCast.start = now; previewCast.finish = now + 3
|
|
end
|
|
return previewCast
|
|
end
|
|
if u.guid then return Data.GetCast(u.guid) end
|
|
return SHPlates.CastLog and SHPlates.CastLog.Get(u.name)
|
|
end
|
|
local function SetSelfEcho(plate, func) if func then echoSelf[plate] = func end end
|
|
local function SetEchoUpdate(func) if func then echoUpdateList[func] = true end end
|
|
|
|
local RaidIconNames = { "STAR", "CIRCLE", "DIAMOND", "TRIANGLE", "MOON", "SQUARE", "CROSS", "SKULL" }
|
|
local RaidIconIndex = {}
|
|
for i = 1, 8 do RaidIconIndex[RaidIconNames[i]] = i end
|
|
|
|
local function RaidIconCoords(index)
|
|
local left = math.mod(index - 1, 4) * .25
|
|
local top = math.floor((index - 1) / 4) * .25
|
|
return left, left + .25, top, top + .25
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- II. Frame/Layer Appearance Functions
|
|
-------------------------------------------------------------------------------
|
|
local function SetObjectShape(object, width, height)
|
|
if width then object:SetWidth(width) end
|
|
if height then object:SetHeight(height) end
|
|
end
|
|
local function SetObjectFont(object, font, size, flags)
|
|
if flags == "NONE" then flags = "" end
|
|
object:SetFont(font, size, flags or "")
|
|
end
|
|
local function SetObjectJustify(object, horz, vert)
|
|
object:SetJustifyH(horz or "CENTER")
|
|
if vert == "CENTER" then vert = "MIDDLE" end
|
|
object:SetJustifyV(vert or "MIDDLE")
|
|
end
|
|
local function SetObjectShadow(object, shadow)
|
|
if shadow then object:SetShadowColor(0, 0, 0, 1); object:SetShadowOffset(1, -1)
|
|
else object:SetShadowColor(0, 0, 0, 0) end
|
|
end
|
|
local function SetObjectAnchor(object, anchor, anchorTo, x, y)
|
|
object:ClearAllPoints()
|
|
object:SetPoint(anchor or "CENTER", anchorTo, anchor or "CENTER", x or 0, y or 0)
|
|
end
|
|
local function SetObjectTexture(object, texture) object:SetTexture(texture); object:SetTexCoord(0, 1, 0, 1) end
|
|
local function SetObjectBartexture(object, texture, orientation)
|
|
object:SetStatusBarTexture(texture)
|
|
object:SetOrientation(orientation)
|
|
end
|
|
|
|
local function SetFontGroupObject(object, objectstyle)
|
|
SetObjectFont(object, objectstyle.typeface, objectstyle.size, objectstyle.flags)
|
|
SetObjectJustify(object, objectstyle.align, objectstyle.vertical)
|
|
SetObjectShadow(object, objectstyle.shadow)
|
|
end
|
|
|
|
local function SetAnchorGroupObject(object, objectstyle, anchorTo)
|
|
SetObjectShape(object, objectstyle.width, objectstyle.height)
|
|
SetObjectAnchor(object, objectstyle.anchor, anchorTo, objectstyle.x, objectstyle.y)
|
|
end
|
|
|
|
local function SetBarGroupObject(object, objectstyle, anchorTo)
|
|
SetObjectShape(object, objectstyle.width, objectstyle.height)
|
|
SetObjectAnchor(object, objectstyle.anchor, anchorTo, objectstyle.x, objectstyle.y)
|
|
SetObjectBartexture(object, objectstyle.texture, objectstyle.orientation)
|
|
object:UpdateSize()
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- III. Nameplate Style
|
|
-------------------------------------------------------------------------------
|
|
local UpdateStyle
|
|
do
|
|
local fontgroup = { "name", "level", "specialText", "specialText2" }
|
|
local bargroup = { "castbar", "healthbar" }
|
|
|
|
-- Size and Style tab: every piece is placed by the theme's numbers, then
|
|
-- stretched around the health bar's center, so borders and bars stay lined
|
|
-- up. Text and icons keep their size and only move with the bar.
|
|
-- bar : health border, threat border, health bar (size * width/height)
|
|
-- cast : cast bar and its borders (width also follows the plate)
|
|
-- icon / text : position only (text boxes get wider with the bar)
|
|
local KIND = {
|
|
healthborder = "bar", threatborder = "bar", healthbar = "bar",
|
|
castborder = "cast", castnostop = "cast", castbar = "cast", spellicon = "spell", spellbacking = "spell",
|
|
name = "text", level = "text", specialText = "text", specialText2 = "text",
|
|
specialArt = "icon", raidicon = "icon", dangerskull = "icon", eliteicon = "icon",
|
|
}
|
|
local LAYOUT_ORDER = { "healthborder", "threatborder", "castborder", "castnostop",
|
|
"name", "specialText", "specialText2", "level",
|
|
"specialArt", "spellbacking", "spellicon", "raidicon", "dangerskull", "eliteicon", "castbar", "healthbar" }
|
|
local AX = { LEFT = -1, RIGHT = 1, TOPLEFT = -1, BOTTOMLEFT = -1, TOPRIGHT = 1, BOTTOMRIGHT = 1 }
|
|
local AY = { TOP = 1, BOTTOM = -1, TOPLEFT = 1, TOPRIGHT = 1, BOTTOMLEFT = -1, BOTTOMRIGHT = -1 }
|
|
local ALIGN = { "LEFT", "CENTER", "RIGHT" }
|
|
|
|
-- current stretch factors (one table: Lua 5.0 allows only 32 upvalues)
|
|
local F = { ids = {} }
|
|
|
|
-- point of an element relative to the frame's center, before stretching
|
|
local function Point(s)
|
|
local a = s.anchor or "CENTER"
|
|
return (AX[a] or 0) * F.fw / 2 + (s.x or 0), (AY[a] or 0) * F.fh / 2 + (s.y or 0)
|
|
end
|
|
|
|
-- Designer tab: which saved offset moves which piece
|
|
local function Offset(key)
|
|
local off = F.off
|
|
if not off then return 0, 0 end
|
|
local id = F.ids[key]
|
|
local o = id and off[id]
|
|
local x, y = o and o.x or 0, o and o.y or 0
|
|
if (key == "spellicon" or key == "spellbacking") and off.spellicon then x, y = x + off.spellicon.x, y + off.spellicon.y end
|
|
return x, y
|
|
end
|
|
|
|
local function Place(object, s, anchorTo, kind, key)
|
|
local a = s.anchor or "CENTER"
|
|
local px, py = Point(s)
|
|
px = px * F.hw
|
|
py = F.cy + (py - F.cy) * F.hh
|
|
local w, h = s.width, s.height
|
|
if kind == "bar" then
|
|
if w then w = w * F.hw end
|
|
if h then h = h * F.hh end
|
|
elseif kind == "cast" then
|
|
if w then w = w * F.hw * F.cw end
|
|
if h then h = h * F.ch end
|
|
elseif kind == "spell" then
|
|
px = F.castX + (px - F.castX) * F.cw
|
|
py = F.castY + (py - F.castY) * F.ch
|
|
elseif kind == "text" then
|
|
if w then w = w * F.hw end
|
|
end
|
|
local dx, dy = Offset(key)
|
|
SetObjectShape(object, w, h)
|
|
object:ClearAllPoints()
|
|
object:SetPoint(a, anchorTo, a, px + dx - (AX[a] or 0) * F.fw * F.hw / 2, py + dy - (AY[a] or 0) * F.fh * F.hh / 2)
|
|
end
|
|
|
|
-- widgets keep the spot their theme gave them, plus the designer offset
|
|
local WIDGET_IDS = { debuffs = { "AuraIcon", "WidgetDebuff" }, class = { "ClassWidget" }, note = { "NoteWidget" },
|
|
wheel = { "WidgetWheel" }, tanked = { "WidgetTanked" } }
|
|
local function OffsetWidgets(widgets)
|
|
if not widgets then return end
|
|
-- the threat line moves itself (it lifts over the combo bar), so it
|
|
-- takes the offset through its own anchor
|
|
local tug = widgets.WidgetTug
|
|
if tug and tug.SetDesignOffset then
|
|
local o = F.off and F.off.tug
|
|
tug:SetDesignOffset(o and o.x or 0, o and o.y or 0)
|
|
o = F.off and F.off.holder
|
|
if tug.SetTextDesignOffset then tug:SetTextDesignOffset(o and o.x or 0, o and o.y or 0) end
|
|
end
|
|
for id, keys in pairs(WIDGET_IDS) do
|
|
for i = 1, table.getn(keys) do
|
|
local w = widgets[keys[i]]
|
|
if w and w.GetPoint then
|
|
if not w._base then
|
|
local a, rel, ra, x, y = w:GetPoint(1)
|
|
if a then w._base = { a, rel, ra, x or 0, y or 0 } end
|
|
end
|
|
local b = w._base
|
|
if b then
|
|
local o = F.off and F.off[id]
|
|
w:ClearAllPoints()
|
|
w:SetPoint(b[1], b[2], b[3], b[4] + (o and o.x or 0), b[5] + (o and o.y or 0))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function UpdateStyle()
|
|
local styleOptions = style.options
|
|
local objectstyle, objectname
|
|
local friendly = unit.reaction == "FRIENDLY"
|
|
F.hw = Opt(friendly and "friendlyWidth" or "barWidth") or 1
|
|
F.hh = Opt(friendly and "friendlyHeight" or "barHeight") or 1
|
|
F.cw, F.ch = Opt("castWidth") or 1, Opt("castHeight") or 1
|
|
-- theme sizes already include the enemy/neutral text size: friendly
|
|
-- plates swap it for their own
|
|
local fontOffset = friendly and ((Opt("friendlyFontOffset") or 0) - (Opt("fontSizeOffset") or 0)) or 0
|
|
F.off = SHPlates.GetLayout(activetheme)
|
|
local ids, hk = F.ids, activetheme.healthTextKey
|
|
ids.name, ids.level, ids.dangerskull, ids.raidicon = "name", "level", "level", "raid"
|
|
ids.eliteicon = "elite"
|
|
ids.castbar, ids.castborder, ids.castnostop, ids.spellicon = "cast", "cast", "cast", "cast"
|
|
ids.spellbacking = "cast"
|
|
ids.specialText, ids.specialText2 = nil, nil
|
|
if hk then
|
|
ids[hk] = "health"
|
|
ids[hk == "specialText" and "specialText2" or "specialText"] = "spell"
|
|
end
|
|
F.fw, F.fh = style.frame.width or 101, style.frame.height or 45
|
|
local _
|
|
_, F.cy = Point(style.healthborder)
|
|
F.castX, F.castY = Point(style.castbar)
|
|
F.castX = F.castX * F.hw
|
|
F.castY = F.cy + (F.castY - F.cy) * F.hh
|
|
|
|
-- Hitbox (vanilla has no combat protection on plates)
|
|
objectstyle = style.hitbox
|
|
SetObjectShape(extended.clicker, objectstyle.width and objectstyle.width * F.hw, objectstyle.height and objectstyle.height * F.hh)
|
|
if overlapMode then SetObjectShape(nameplate, 1, 1)
|
|
else extended.stackW = nil; UpdateStackingSize(nameplate) end
|
|
-- Frame
|
|
objectstyle = style.frame
|
|
SetObjectShape(extended, F.fw * F.hw, F.fh * F.hh)
|
|
-- The client pins the TOP of its plate frame over the unit, and
|
|
-- stacking mode stretches that frame downward. Hanging off its top
|
|
-- edge keeps the plate at the same height in both modes (centered on
|
|
-- the frame, stacked plates sat half a frame lower, over the mob).
|
|
-- "Height above the unit" lifts it further. The Designer's sample
|
|
-- stays centered in its box.
|
|
extended:ClearAllPoints()
|
|
if nameplate.shpPreview then
|
|
extended:SetPoint(objectstyle.anchor or "CENTER", nameplate, "CENTER", objectstyle.x or 0, objectstyle.y or 0)
|
|
else
|
|
extended:SetPoint(objectstyle.anchor or "CENTER", nameplate, "TOP", objectstyle.x or 0,
|
|
(objectstyle.y or 0) + (Opt("plateOffset") or 0))
|
|
end
|
|
-- the click frame sits where the hitbox always did relative to the art
|
|
extended.clicker:ClearAllPoints()
|
|
extended.clicker:SetPoint("CENTER", extended, "CENTER", -(objectstyle.x or 0), -(objectstyle.y or 0))
|
|
for i = 1, table.getn(LAYOUT_ORDER) do
|
|
objectname = LAYOUT_ORDER[i]
|
|
local object = visual[objectname] or bars[objectname]
|
|
Place(object, style[objectname], extended, KIND[objectname], objectname)
|
|
end
|
|
for i = 1, 2 do
|
|
objectname = bargroup[i]
|
|
objectstyle = style[objectname]
|
|
SetObjectBartexture(bars[objectname], objectstyle.texture, objectstyle.orientation)
|
|
bars[objectname]:UpdateSize()
|
|
end
|
|
SetObjectTexture(visual.castborder, style.castborder.texture)
|
|
SetObjectTexture(visual.castnostop, style.castnostop.texture)
|
|
for i = 1, 4 do
|
|
objectname = fontgroup[i]
|
|
objectstyle = style[objectname]
|
|
-- the spell name follows the cast bar's own text size
|
|
local extra = (F.ids[objectname] == "spell") and (Opt("castFontOffset") or 0) or 0
|
|
SetObjectFont(visual[objectname], objectstyle.typeface, math.max(4, (objectstyle.size or 9) + fontOffset + extra), objectstyle.flags)
|
|
SetObjectJustify(visual[objectname], objectstyle.align, objectstyle.vertical)
|
|
SetObjectShadow(visual[objectname], objectstyle.shadow)
|
|
end
|
|
-- Health text: position and color
|
|
local htext = activetheme.healthTextKey and visual[activetheme.healthTextKey]
|
|
if htext then
|
|
local align = ALIGN[(Opt("healthTextAlign") or 1) - 1]
|
|
if align then
|
|
-- span the bar so left and right line up with its ends
|
|
htext:SetWidth(style.healthbar.width * F.hw - 6)
|
|
htext:SetJustifyH(align)
|
|
end
|
|
local c = Opt("healthTextColorOn") and Opt("healthTextColor")
|
|
if c then htext:SetTextColor(c.r, c.g, c.b) else htext:SetTextColor(1, 1, 1) end
|
|
end
|
|
local nc = Opt("nameColorOn") and Opt("nameColor")
|
|
if nc then visual.name:SetTextColor(nc.r, nc.g, nc.b) else visual.name:SetTextColor(1, 1, 1) end
|
|
-- Mouseover highlight follows the health border
|
|
visual.highlight:SetTexture(style.healthborder.glowtexture)
|
|
visual.highlight:ClearAllPoints()
|
|
visual.highlight:SetAllPoints(visual.healthborder)
|
|
-- The selection box widget stretches with the bar too
|
|
local box = extended.widgets and extended.widgets.targetbox
|
|
if box then
|
|
box._w = box._w or box:GetWidth()
|
|
box._h = box._h or box:GetHeight()
|
|
box:SetWidth(box._w * F.hw); box:SetHeight(box._h * F.hh)
|
|
end
|
|
-- Show/Hide
|
|
if styleOptions.showName then visual.name:Show() else visual.name:Hide() end
|
|
if styleOptions.showSpecialText then visual.specialText:Show() else visual.specialText:Hide() end
|
|
if styleOptions.showSpecialText2 then visual.specialText2:Show() else visual.specialText2:Hide() end
|
|
if styleOptions.showSpecialArt then visual.specialArt:Show() else visual.specialArt:Hide() end
|
|
if styleOptions.showSpellIcon and not Opt("hideSpellIcon") then visual.spellicon:Show() else visual.spellicon:Hide() end
|
|
-- the icon's backing (Neon's glowing square) goes wherever the icon goes
|
|
local backing = style.spellbacking and style.spellbacking.texture
|
|
if backing then visual.spellbacking:SetTexture(backing) end
|
|
if backing and visual.spellicon:IsShown() then visual.spellbacking:Show() else visual.spellbacking:Hide() end
|
|
-- "Hide unit levels" (Display tab) wins over every theme
|
|
if styleOptions.showLevel and (not Opt("hideLevel")) and (not unit.isBoss) then visual.level:Show() else visual.level:Hide() end
|
|
if unit.isBoss and styleOptions.showDangerSkull then visual.dangerskull:Show() else visual.dangerskull:Hide() end
|
|
local star = style.eliteicon and style.eliteicon.texture
|
|
if star then visual.eliteicon:SetTexture(star) end
|
|
if star and unit.isElite then visual.eliteicon:Show() else visual.eliteicon:Hide() end
|
|
OffsetWidgets(extended.widgets)
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- IV. Indicators
|
|
-------------------------------------------------------------------------------
|
|
local UpdateIndicator_CustomScaleText, UpdateIndicator_HealthBar, UpdateIndicator_Standard
|
|
local UpdateIndicator_All, UpdateIndicator_CustomAlpha, UpdateIndicator_Level, UpdateIndicator_ThreatGlow
|
|
local UpdateIndicator_RaidIcon, UpdateIndicator_EliteIcon, UpdateIndicator_UnitColor, UpdateIndicator_Name
|
|
do
|
|
local threatborder, alpha, forcealpha, scale
|
|
alpha = 1
|
|
|
|
local function ApplyHealthColor()
|
|
-- Tapped and stunned colors win over everything (as in GudaPlates)
|
|
if unit.isTapped and Opt("tappedColorOn") ~= false then
|
|
local c = Opt("tappedColor") or { r = .5, g = .5, b = .5 }
|
|
bars.healthbar:SetStatusBarColor(c.r, c.g, c.b)
|
|
elseif unit.isStunned and Opt("stunColorOn") ~= false then
|
|
local c = Opt("stunColor") or { r = .376, g = .027, b = .431 }
|
|
bars.healthbar:SetStatusBarColor(c.r, c.g, c.b)
|
|
elseif activetheme.SetHealthbarColor then
|
|
bars.healthbar:SetStatusBarColor(activetheme.SetHealthbarColor(unit))
|
|
else bars.healthbar:SetStatusBarColor(unit.red, unit.green, unit.blue) end
|
|
end
|
|
|
|
function UpdateIndicator_HealthBar()
|
|
ApplyHealthColor()
|
|
bars.healthbar:SetMinMaxValues(0, unit.healthmax or 1)
|
|
bars.healthbar:SetValue(unit.health or 0)
|
|
end
|
|
|
|
function UpdateIndicator_Name()
|
|
visual.name:SetText(unit.name)
|
|
end
|
|
|
|
function UpdateIndicator_Level()
|
|
visual.level:SetText(unit.level)
|
|
visual.level:SetTextColor(unit.levelcolorRed or 1, unit.levelcolorGreen or 1, unit.levelcolorBlue or 1)
|
|
end
|
|
|
|
function UpdateIndicator_ThreatGlow()
|
|
local styleOptions = style.options
|
|
threatborder = visual.threatborder
|
|
if activetheme.SetThreatColor then
|
|
threatborder:Show()
|
|
threatborder:SetVertexColor(activetheme.SetThreatColor(unit))
|
|
else
|
|
if inCombat and styleOptions.showAggroGlow and unit.reaction ~= "FRIENDLY" and unit.type == "NPC" then
|
|
local color = style.threatcolor[unit.threatSituation]
|
|
threatborder:Show()
|
|
threatborder:SetVertexColor(color.r, color.g, color.b, (color.a or 1))
|
|
else threatborder:Hide() end
|
|
end
|
|
end
|
|
|
|
function UpdateIndicator_RaidIcon()
|
|
-- Blizzard's own icon, moved onto our bar: the client shows, hides and
|
|
-- crops it itself, so leave it alone
|
|
local localIndex = SHPlates.Marks and SHPlates.Marks.Get(unit.guid)
|
|
if extended.usesBlizzardRaidIcon then
|
|
-- solo (local) marks the client doesn't draw: use our own copy
|
|
local own = visual.raidiconOwn
|
|
if localIndex and not regions.raidicon:IsShown() then
|
|
own:SetTexCoord(RaidIconCoords(localIndex)); own:Show()
|
|
else own:Hide() end
|
|
return
|
|
end
|
|
local index = (unit.raidIcon and RaidIconIndex[unit.raidIcon]) or localIndex
|
|
if index then
|
|
visual.raidicon:Show()
|
|
visual.raidicon:SetTexCoord(RaidIconCoords(index))
|
|
else visual.raidicon:Hide() end
|
|
end
|
|
|
|
function UpdateIndicator_EliteIcon()
|
|
threatborder = visual.threatborder
|
|
if unit.isElite then
|
|
visual.healthborder:SetTexture(style.healthborder.elitetexture)
|
|
threatborder:SetTexture(style.threatborder.elitetexture)
|
|
if style.eliteicon and style.eliteicon.texture then visual.eliteicon:Show() end
|
|
else
|
|
visual.healthborder:SetTexture(style.healthborder.texture)
|
|
threatborder:SetTexture(style.threatborder.texture)
|
|
visual.eliteicon:Hide()
|
|
end
|
|
end
|
|
|
|
function UpdateIndicator_UnitColor()
|
|
ApplyHealthColor()
|
|
end
|
|
|
|
function UpdateIndicator_Standard()
|
|
if IsPlateShown(nameplate) then
|
|
if unitcache.name ~= unit.name then UpdateIndicator_Name() end
|
|
if unitcache.level ~= unit.level or unitcache.levelcolorRed ~= unit.levelcolorRed then UpdateIndicator_Level() end
|
|
UpdateIndicator_ThreatGlow()
|
|
UpdateIndicator_RaidIcon()
|
|
if unitcache.isElite ~= unit.isElite then UpdateIndicator_EliteIcon() end
|
|
if (unitcache.red ~= unit.red) or (unitcache.green ~= unit.green) or (unitcache.blue ~= unit.blue) then
|
|
UpdateIndicator_UnitColor() end
|
|
end
|
|
end
|
|
|
|
function UpdateIndicator_CustomAlpha()
|
|
alpha = 1
|
|
if activetheme.SetAlpha then
|
|
alpha, forcealpha = activetheme.SetAlpha(unit)
|
|
if forcealpha then alpha = (alpha or 1)
|
|
else alpha = (alpha or 1) * (unit.alpha or 1) end
|
|
else alpha = unit.alpha or 1 end
|
|
if IsFilteredOut(unit) or extended.fastHidden then alpha = 0 end
|
|
extended:SetAlpha(alpha)
|
|
SetPartsAlpha(extended, alpha)
|
|
-- Fully transparent plates should not eat clicks either
|
|
ApplyPlateMouse(nameplate, alpha > 0)
|
|
end
|
|
|
|
function UpdateIndicator_CustomScaleText()
|
|
local styleOptions = style.options
|
|
if alpha > 0 then
|
|
if activetheme.SetScale then
|
|
scale = activetheme.SetScale(unit)
|
|
if scale then extended:SetScale(scale) end
|
|
UpdateStackingSize(nameplate)
|
|
end
|
|
if styleOptions.showSpecialText and activetheme.SetSpecialText then
|
|
visual.specialText:SetText(activetheme.SetSpecialText(unit)) end
|
|
if styleOptions.showSpecialText2 and activetheme.SetSpecialText2 then
|
|
visual.specialText2:SetText(activetheme.SetSpecialText2(unit)) end
|
|
if styleOptions.showSpecialArt and activetheme.SetSpecialArt then
|
|
visual.specialArt:SetTexture(activetheme.SetSpecialArt(unit)) end
|
|
ApplyHealthColor()
|
|
end
|
|
end
|
|
|
|
function UpdateIndicator_All()
|
|
UpdateIndicator_CustomAlpha()
|
|
UpdateIndicator_CustomScaleText()
|
|
UpdateIndicator_Standard()
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- V. Data Gather
|
|
-------------------------------------------------------------------------------
|
|
local OnNewNameplate, OnShowNameplate, OnHideNameplate, OnUpdateNameplate, OnResetNameplate
|
|
local OnStartCast, OnStopCast, OnMouseoverNameplate, OnLeaveNameplate
|
|
local OnUpdateHealth, OnUpdateLevel, OnUpdateRaidIcon, OnUpdateReaction, OnEchoNewNameplate
|
|
local UpdateReferences
|
|
do
|
|
local function UpdateUnitCache() for key, value in pairs(unit) do unitcache[key] = value end end
|
|
|
|
function UpdateReferences(plate)
|
|
activetheme = plate.previewTheme or realtheme
|
|
unitchanged = false
|
|
nameplate = plate
|
|
extended = plate.extended
|
|
bars = extended.bars
|
|
regions = extended.regions
|
|
unit = extended.unit
|
|
unitcache = extended.unitcache
|
|
visual = extended.visual
|
|
style = extended.style
|
|
end
|
|
|
|
-- Vanilla health bar colors (no class colors on 1.12 plates)
|
|
local function GetUnitReaction(red, green, blue)
|
|
if red < .01 and blue < .01 and green > .99 then return "FRIENDLY", "NPC"
|
|
elseif red < .01 and blue > .99 and green < .01 then return "FRIENDLY", "PLAYER"
|
|
elseif red > .99 and blue < .01 and green > .99 then return "NEUTRAL", "NPC"
|
|
elseif red > .99 and blue < .01 and green < .01 then return "HOSTILE", "NPC"
|
|
else return "HOSTILE", "PLAYER" end
|
|
end
|
|
|
|
local function GetUnitCombatStatus(r, g, b) return (r > .5 and g < .5) end
|
|
|
|
local function ReadRaidIcon()
|
|
local guid = unit.guid
|
|
if guid then
|
|
-- SuperWoW: GUID as unit token...
|
|
if GetRaidTargetIndex then
|
|
local ok, index = pcall(GetRaidTargetIndex, guid)
|
|
if ok and index and RaidIconNames[index] then return RaidIconNames[index] end
|
|
end
|
|
-- ...or the "mark1".."mark8" unit tokens
|
|
for i = 1, 8 do
|
|
local exists, markGUID = UnitExists("mark" .. i)
|
|
if exists and markGUID == guid then return RaidIconNames[i] end
|
|
end
|
|
end
|
|
-- Blizzard's own icon on the plate
|
|
local icon = regions.raidicon
|
|
if icon and icon:IsShown() and icon.GetTexCoord then
|
|
local ux, uy = icon:GetTexCoord()
|
|
if ux and uy then
|
|
local col = math.floor(ux * 4 + .5)
|
|
local row = math.floor(uy * 4 + .5)
|
|
return RaidIconNames[row * 4 + col + 1]
|
|
end
|
|
end
|
|
-- solo mark set with a SHPlates keybind
|
|
local li = SHPlates.Marks and SHPlates.Marks.Get(unit.guid)
|
|
if li then return RaidIconNames[li] end
|
|
return nil
|
|
end
|
|
|
|
local function HideBlizzardRegions()
|
|
regions.border:SetAlpha(0)
|
|
regions.glow:SetAlpha(0)
|
|
regions.levelicon:SetAlpha(0)
|
|
if not extended.usesBlizzardRaidIcon then regions.raidicon:SetAlpha(0) end
|
|
-- anything else on the Blizzard plate (in case a client or addon
|
|
-- reordered or added regions)
|
|
local extra = extended.blizzRegions
|
|
for i = 1, table.getn(extra) do
|
|
local region = extra[i]
|
|
if region ~= visual.raidicon and region.GetObjectType and region:GetObjectType() == "Texture" then
|
|
region:SetAlpha(0)
|
|
end
|
|
end
|
|
-- Alpha alone isn't enough: the client puts the name back when it
|
|
-- moves a plate to another unit, and it showed until our next update.
|
|
-- A near-zero width (what pfUI does) stays put. GetText still works.
|
|
if regions.name.SetAlpha then regions.name:SetAlpha(0) end
|
|
regions.name:SetWidth(.001)
|
|
if regions.level.SetAlpha then regions.level:SetAlpha(0) end
|
|
regions.level:SetWidth(.001)
|
|
-- Only once per show: re-setting the bar texture can briefly reset its
|
|
-- color, which made neutral (yellow) mobs read as hostile and flicker
|
|
if not extended.healthTexHidden then
|
|
bars.health:SetStatusBarTexture(EMPTY_TEXTURE)
|
|
extended.healthTexHidden = true
|
|
end
|
|
bars.health:SetAlpha(0)
|
|
end
|
|
|
|
-- Reaction: SuperWoW's UnitReaction when we have a GUID (bar colors in
|
|
-- vanilla also change for tapped or fighting mobs), bar color otherwise
|
|
local function ReadReaction()
|
|
local r, g, b = bars.health:GetStatusBarColor()
|
|
local white = r and r > .99 and g > .99 and b > .99
|
|
if r and not white then
|
|
unit.red, unit.green, unit.blue = r, g, b
|
|
unit.reaction, unit.type = GetUnitReaction(r, g, b)
|
|
elseif not unit.reaction then
|
|
unit.red, unit.green, unit.blue = r or 1, g or 0, b or 0
|
|
unit.reaction, unit.type = "HOSTILE", "NPC"
|
|
end
|
|
local guid = unit.guid
|
|
if guid then
|
|
if UnitIsPlayer(guid) then
|
|
-- Players: friend or foe is "can I attack them", not faction.
|
|
-- On cross-faction servers the other faction reads as neutral
|
|
-- even when you can't touch them; they're only enemies when
|
|
-- PvP makes them attackable.
|
|
unit.type = "PLAYER"
|
|
if UnitCanAttack("player", guid) then
|
|
unit.reaction = "HOSTILE"
|
|
else
|
|
unit.reaction = "FRIENDLY"
|
|
unit.red, unit.green, unit.blue = 0, 0, 1 -- vanilla's friendly player blue
|
|
end
|
|
return
|
|
end
|
|
unit.type = "NPC"
|
|
local rx = UnitReaction and UnitReaction(guid, "player")
|
|
if rx then
|
|
if rx >= 5 then unit.reaction = "FRIENDLY"
|
|
elseif rx == 4 then
|
|
-- a neutral mob fighting you or your group counts as hostile,
|
|
-- just like its bar turns red in vanilla
|
|
local holder = UnitExists(guid .. "target") and UnitName(guid .. "target")
|
|
if UnitAffectingCombat(guid) and holder and Data.InGroup(holder) then
|
|
RememberAngry(guid)
|
|
unit.reaction = "HOSTILE"
|
|
elseif IsAngryNeutral(guid) then
|
|
unit.reaction = "HOSTILE"
|
|
else
|
|
unit.reaction = "NEUTRAL"
|
|
end
|
|
else unit.reaction = "HOSTILE" end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function GatherData_GUID(plate)
|
|
local guid = ResolveGUID(plate, regions.name:GetText())
|
|
if guid ~= unit.guid then
|
|
if unit.guid and GUID[unit.guid] == plate then GUID[unit.guid] = nil end
|
|
unit.guid = guid
|
|
if guid then GUID[guid] = plate end
|
|
unit.partyID = nil
|
|
if activetheme.OnContextUpdate then activetheme.OnContextUpdate(unit) end
|
|
end
|
|
return guid
|
|
end
|
|
|
|
local function GatherData_Target()
|
|
if unit.guid and targetGUID then
|
|
unit.isTarget = (unit.guid == targetGUID)
|
|
elseif HasTarget and not C.HasSuperWoW then
|
|
-- Without SuperWoW: best effort by name. With SuperWoW a plate whose
|
|
-- GUID isn't confirmed yet is NOT the target: matching by name
|
|
-- would make every same-named mob in a pack "the target" and copy
|
|
-- the target's debuffs, combo points and threat onto all of them.
|
|
unit.isTarget = (unit.name == targetName)
|
|
else
|
|
unit.isTarget = false
|
|
end
|
|
if unit.isTarget then currentTarget = nameplate
|
|
elseif currentTarget == nameplate then currentTarget = nil end
|
|
end
|
|
|
|
local function GatherData_Static()
|
|
unit.name = regions.name:GetText()
|
|
unit.isBoss = regions.levelicon:IsShown() and true or false
|
|
unit.isDangerous = unit.isBoss
|
|
end
|
|
|
|
local function GatherData_BasicInfo()
|
|
local guid = unit.guid
|
|
unit.name = regions.name:GetText()
|
|
unit.isBoss = regions.levelicon:IsShown() and true or false
|
|
if unit.isBoss then unit.level = "??"
|
|
else unit.level = regions.level:GetText() end
|
|
unit.levelcolorRed, unit.levelcolorGreen, unit.levelcolorBlue = regions.level:GetTextColor()
|
|
|
|
local health, low, high = bars.health:GetValue(), bars.health:GetMinMaxValues()
|
|
unit.health = health or 0
|
|
unit.healthmax = high or 1
|
|
if guid then
|
|
local maxhp = UnitHealthMax(guid)
|
|
if maxhp and maxhp > unit.healthmax then
|
|
unit.health, unit.healthmax = UnitHealth(guid), maxhp
|
|
end
|
|
end
|
|
|
|
ReadReaction()
|
|
unit.class = "UNKNOWN"
|
|
unit.isElite = false
|
|
if guid then
|
|
if UnitIsPlayer(guid) then
|
|
unit.type = "PLAYER"
|
|
local _, class = UnitClass(guid)
|
|
unit.class = class or "UNKNOWN"
|
|
unit.partyID = Data.roster[unit.name]
|
|
else
|
|
unit.type = "NPC"
|
|
end
|
|
local classification = UnitClassification(guid)
|
|
unit.isElite = (classification == "elite" or classification == "rareelite" or classification == "worldboss")
|
|
unit.isInCombat = UnitAffectingCombat(guid) and true or false
|
|
unit.isDead = UnitIsDead(guid) and true or false
|
|
else
|
|
unit.isInCombat = GetUnitCombatStatus(regions.name:GetTextColor())
|
|
end
|
|
unit.InCombatLockdown = inCombat
|
|
unit.raidIcon = ReadRaidIcon()
|
|
unit.isMarked = unit.raidIcon ~= nil
|
|
unit.threatSituation = Data.GetThreatSituation(unit)
|
|
|
|
-- Extras (GudaPlates-style): tapped, stunned, critter, class colors,
|
|
-- who has aggro, power
|
|
unit.isTapped, unit.isStunned, unit.isCritter, unit.isPvP = false, false, false, false
|
|
unit.aggroHolder, unit.holderIsTank, unit.losingAggro = nil, false, false
|
|
unit.power, unit.powermax, unit.powerType = nil, nil, nil
|
|
if guid then
|
|
unit.isTapped = (UnitIsTapped(guid) and not UnitIsTappedByPlayer(guid)) and true or false
|
|
if unit.isTapped then
|
|
-- tapped by someone in our group is fine
|
|
local holder = UnitExists(guid .. "target") and UnitName(guid .. "target")
|
|
if holder and Data.InGroup(holder) then unit.isTapped = false end
|
|
end
|
|
if Opt("stunColorOn") ~= false and unit.reaction ~= "FRIENDLY" then unit.isStunned = Data.IsStunned(guid) end
|
|
unit.isCritter = CRITTER_TYPES[UnitCreatureType(guid) or ""] and true or false
|
|
unit.isPvP = UnitIsPVP(guid) and true or false
|
|
unit.power, unit.powermax = UnitMana(guid), UnitManaMax(guid)
|
|
unit.powerType = UnitPowerType(guid)
|
|
elseif SHPlates.Critters then
|
|
-- no GUID: critters are known by name (learned or the starter list)
|
|
unit.isCritter = SHPlates.Critters.IsCritterName(unit.name)
|
|
end
|
|
if unit.reaction ~= "FRIENDLY" and unit.type == "NPC" and inCombat then
|
|
unit.aggroHolder = Data.GetAggroHolder(unit)
|
|
unit.holderIsTank = (unit.aggroHolder and unit.aggroHolder ~= UnitName("player")
|
|
and Data.IsRaidTank(unit.aggroHolder)) and true or false
|
|
unit.losingAggro = Data.IsLosingAggro(unit)
|
|
end
|
|
-- class colors for players (vanilla paints every enemy player red)
|
|
if unit.type == "PLAYER" and CLASS_COLORS[unit.class] then
|
|
local enemy = unit.reaction ~= "FRIENDLY"
|
|
local want = (enemy and Opt("classColorEnemies") ~= false) or ((not enemy) and Opt("classColorFriends"))
|
|
if enemy and unit.isPvP and Opt("noClassColorPvP") then want = false end
|
|
if want then
|
|
local c = CLASS_COLORS[unit.class]
|
|
unit.red, unit.green, unit.blue = c[1], c[2], c[3]
|
|
end
|
|
end
|
|
end
|
|
|
|
local function GatherData_Cast()
|
|
local cast = GetUnitCast(unit)
|
|
if cast then
|
|
unit.isCasting = true
|
|
unit.spellName = cast.spell
|
|
unit.spellIcon = cast.icon
|
|
unit.isChanneling = cast.channel
|
|
unit.spellId = cast.spellId
|
|
unit.notInterruptible = SHPlates.Interrupts.IsUninterruptible(unit.name, cast.spellId)
|
|
else
|
|
unit.isCasting = false
|
|
unit.spellName = nil
|
|
unit.spellIcon = nil
|
|
unit.isChanneling = nil
|
|
unit.spellId = nil
|
|
unit.notInterruptible = nil
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------------
|
|
-- Graphical updates
|
|
---------------------------------------------------------------------------
|
|
local function UpdateStubbornRegions()
|
|
HideBlizzardRegions()
|
|
end
|
|
|
|
local function CheckNameplateStyle()
|
|
if activetheme.SetStyle then
|
|
stylename = activetheme.SetStyle(unit); extended.style = activetheme[stylename]
|
|
else
|
|
extended.style = activetheme
|
|
-- friendly plates can have their own size (Size and Style tab)
|
|
stylename = tostring(activetheme) .. (unit.reaction == "FRIENDLY" and "F" or "E")
|
|
end
|
|
style = extended.style
|
|
if extended.stylename ~= stylename or forceStyleUpdate then
|
|
UpdateStyle()
|
|
extended.stylename = stylename
|
|
end
|
|
end
|
|
|
|
local function RefreshCastbar()
|
|
local castbar = bars.castbar
|
|
local cast = GetUnitCast(unit)
|
|
-- "Hide cast bars" (Display tab) applies to every theme
|
|
if cast and not Opt("hideCastbars") then
|
|
local r, g, b, a
|
|
local cc = Opt("castColorOn") and Opt("castColor")
|
|
if cc then r, g, b, a = cc.r, cc.g, cc.b, 1
|
|
elseif activetheme.SetCastbarColor then r, g, b, a = activetheme.SetCastbarColor(unit)
|
|
else r, g, b, a = 1, .8, 0, 1 end
|
|
castbar:SetStatusBarColor(r, g, b, a or 1)
|
|
castbar.cast = cast
|
|
castbar:SetMinMaxValues(cast.start, cast.finish)
|
|
castbar:SetValue(GetTime())
|
|
visual.spellicon:SetTexture(cast.icon)
|
|
local nostop = unit.notInterruptible and style.options.showNostopSpell
|
|
if nostop then
|
|
visual.castnostop:Show(); visual.castborder:Hide()
|
|
else visual.castnostop:Hide(); visual.castborder:Show() end
|
|
local sb = style.spellbacking
|
|
if sb and sb.texture then
|
|
visual.spellbacking:SetTexture((nostop and sb.nostoptexture) or sb.texture)
|
|
end
|
|
castbar:Show()
|
|
else
|
|
castbar.cast = nil
|
|
castbar:Hide()
|
|
end
|
|
end
|
|
|
|
local function ProcessUnitChanges()
|
|
for key, value in pairs(unit) do
|
|
if unitcache[key] ~= value then unitchanged = true; break end
|
|
end
|
|
if unitchanged then
|
|
CheckNameplateStyle()
|
|
UpdateIndicator_All()
|
|
UpdateIndicator_HealthBar()
|
|
else
|
|
-- transparency also depends on things outside the unit (whether you
|
|
-- have a target, option changes): keep it current every refresh
|
|
UpdateIndicator_CustomAlpha()
|
|
end
|
|
if activetheme.OnUpdate then activetheme.OnUpdate(extended, unit) end
|
|
UpdateUnitCache()
|
|
end
|
|
|
|
---------------------------------------------------------------------------
|
|
-- Setup
|
|
---------------------------------------------------------------------------
|
|
local function PrepareNameplate(plate)
|
|
extended.healthTexHidden = nil
|
|
HideBlizzardRegions()
|
|
GatherData_GUID(plate)
|
|
GatherData_Static()
|
|
unit.alpha = 1
|
|
unit.isTarget = false
|
|
unit.isMouseover = false
|
|
extended.unitcache = wipe(extended.unitcache)
|
|
unitcache = extended.unitcache
|
|
extended.stylename = ""
|
|
unit.isCasting = false
|
|
bars.castbar:Hide()
|
|
visual.highlight:Hide()
|
|
extended.mouseShown = nil
|
|
if activetheme.OnInitialize then activetheme.OnInitialize(extended) end
|
|
-- widgets made just now start fully visible: match the plate
|
|
SetPartsAlpha(extended, extended:GetAlpha())
|
|
end
|
|
|
|
local function FullGather(plate)
|
|
GatherData_BasicInfo()
|
|
GatherData_Target()
|
|
if nameplate.shpPreview then
|
|
-- the designer's sample plate: shown as your target, with a class,
|
|
-- a mob note and debuffs so every piece can be placed
|
|
unit.isPreview = true
|
|
unit.isTarget = true
|
|
unit.class = "MAGE"
|
|
unit.isElite = true
|
|
unit.previewNote = "Mob note"
|
|
end
|
|
GatherData_Cast()
|
|
ProcessUnitChanges()
|
|
RefreshCastbar()
|
|
end
|
|
|
|
---------------------------------------------------------------------------
|
|
-- Entry points
|
|
---------------------------------------------------------------------------
|
|
function OnHideNameplate(plate)
|
|
UpdateReferences(plate)
|
|
if unit.guid and GUID[unit.guid] == plate then GUID[unit.guid] = nil end
|
|
visual.highlight:Hide()
|
|
bars.castbar:Hide()
|
|
bars.castbar.cast = nil
|
|
PlatesVisible[plate] = nil
|
|
wipe(extended.unit)
|
|
wipe(extended.unitcache)
|
|
if plate == currentTarget then currentTarget = nil end
|
|
if plate == lastMouseover then lastMouseover = nil end
|
|
end
|
|
|
|
function OnEchoNewNameplate(plate)
|
|
if not plate:IsShown() then return end
|
|
UpdateReferences(plate)
|
|
FullGather(plate)
|
|
end
|
|
|
|
function OnShowNameplate(plate)
|
|
PlatesVisible[plate] = true
|
|
UpdateReferences(plate)
|
|
PrepareNameplate(plate)
|
|
FullGather(plate)
|
|
SetSelfEcho(plate, OnUpdateNameplate)
|
|
end
|
|
|
|
function OnNewNameplate(plate)
|
|
local health = bars.health
|
|
C.HookScript(plate, "OnShow", function() OnShowNameplate(plate) end)
|
|
C.HookScript(plate, "OnHide", function() OnHideNameplate(plate) end)
|
|
C.HookScript(health, "OnValueChanged", function() OnUpdateHealth(plate) end)
|
|
if plate:IsShown() then
|
|
OnShowNameplate(plate)
|
|
end
|
|
end
|
|
|
|
function OnUpdateNameplate(plate)
|
|
if not plate:IsShown() then return end
|
|
UpdateReferences(plate)
|
|
local oldguid = unit.guid
|
|
local guid = ResolveGUID(plate, regions.name:GetText())
|
|
if guid ~= oldguid then
|
|
-- Vanilla can recycle a visible plate for another unit
|
|
PrepareNameplate(plate)
|
|
end
|
|
UpdateStubbornRegions()
|
|
FullGather(plate)
|
|
end
|
|
|
|
function OnUpdateLevel(plate)
|
|
if not IsPlateShown(plate) then return end
|
|
UpdateReferences(plate)
|
|
if unit.isBoss then unit.level = "??"
|
|
else unit.level = regions.level:GetText() end
|
|
UpdateIndicator_Level()
|
|
end
|
|
|
|
function OnUpdateRaidIcon(plate)
|
|
if not IsPlateShown(plate) then return end
|
|
UpdateReferences(plate)
|
|
unit.raidIcon = ReadRaidIcon()
|
|
unit.isMarked = unit.raidIcon ~= nil
|
|
UpdateIndicator_RaidIcon()
|
|
if activetheme.OnUpdate then activetheme.OnUpdate(extended, unit) end
|
|
end
|
|
|
|
function OnUpdateReaction(plate)
|
|
if not IsPlateShown(plate) then return end
|
|
UpdateReferences(plate)
|
|
ReadReaction()
|
|
UpdateIndicator_UnitColor()
|
|
UpdateIndicator_CustomScaleText()
|
|
end
|
|
|
|
function OnLeaveNameplate(plate)
|
|
plate.extended.unit.isMouseover = false
|
|
plate.extended.visual.highlight:Hide()
|
|
end
|
|
|
|
function OnMouseoverNameplate(plate)
|
|
if not IsPlateShown(plate) then return end
|
|
UpdateReferences(plate)
|
|
unit.isMouseover = true
|
|
visual.highlight:Show()
|
|
visual.highlight:SetAlpha(extended:GetAlpha())
|
|
UpdateIndicator_CustomScaleText()
|
|
if activetheme.OnUpdate then activetheme.OnUpdate(extended, unit) end
|
|
end
|
|
|
|
function OnUpdateHealth(plate)
|
|
if not IsPlateShown(plate) or not PlatesVisible[plate] then return end
|
|
UpdateReferences(plate)
|
|
local health, low, high = bars.health:GetValue(), bars.health:GetMinMaxValues()
|
|
unit.health = health or 0
|
|
unit.healthmax = high or 1
|
|
if unit.guid then
|
|
local maxhp = UnitHealthMax(unit.guid)
|
|
if maxhp and maxhp > unit.healthmax then
|
|
unit.health, unit.healthmax = UnitHealth(unit.guid), maxhp
|
|
end
|
|
end
|
|
UpdateIndicator_HealthBar()
|
|
UpdateIndicator_CustomAlpha()
|
|
UpdateIndicator_CustomScaleText()
|
|
end
|
|
|
|
function OnStartCast(plate)
|
|
if not IsPlateShown(plate) then return end
|
|
UpdateReferences(plate)
|
|
GatherData_Cast()
|
|
RefreshCastbar()
|
|
UpdateIndicator_CustomScaleText()
|
|
if activetheme.OnUpdate then activetheme.OnUpdate(extended, unit) end
|
|
end
|
|
|
|
function OnStopCast(plate)
|
|
if not IsPlateShown(plate) then return end
|
|
UpdateReferences(plate)
|
|
unit.isCasting = false
|
|
unit.spellName = nil
|
|
bars.castbar.cast = nil
|
|
bars.castbar:Hide()
|
|
UpdateIndicator_CustomScaleText()
|
|
SetSelfEcho(plate, OnUpdateNameplate)
|
|
end
|
|
|
|
function OnResetNameplate(plate)
|
|
local ext = plate.extended
|
|
ext.unitcache = wipe(ext.unitcache)
|
|
ext.stylename = ""
|
|
OnShowNameplate(plate)
|
|
end
|
|
end
|
|
|
|
-- Cast notifications from Data.lua
|
|
function SHPlates.OnCastChanged(guid)
|
|
local plate = GUID[guid]
|
|
if not plate or not PlatesVisible[plate] then return end
|
|
if Data.GetCast(guid) then OnStartCast(plate) else OnStopCast(plate) end
|
|
end
|
|
|
|
-- Combat log casts (no SuperWoW): every plate with that name, no GUID
|
|
function SHPlates.OnCastChangedByName(name)
|
|
local casting = SHPlates.CastLog.Get(name) and true or false
|
|
for plate in pairs(PlatesVisible) do
|
|
local u = plate.extended and plate.extended.unit
|
|
if u and not u.guid and u.name == name then
|
|
if casting then OnStartCast(plate) else OnStopCast(plate) end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Aura notifications: just refresh that plate's widgets soon
|
|
function SHPlates.OnAuraChanged(guid)
|
|
local plate = GUID[guid]
|
|
if plate and PlatesVisible[plate] then
|
|
plate.extended.auraDirty = true
|
|
SetSelfEcho(plate, OnUpdateNameplate)
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- VI. Nameplate Extension
|
|
-------------------------------------------------------------------------------
|
|
local ApplyPlateExtension
|
|
do
|
|
local function CastbarOnUpdate(castbar)
|
|
local cast = castbar.cast
|
|
if not cast then castbar:Hide(); return end
|
|
local now = GetTime()
|
|
if now >= cast.finish and castbar.plate and castbar.plate.shpPreview then
|
|
-- the designer's sample plate casts forever
|
|
cast.start = now; cast.finish = now + 3
|
|
castbar:SetMinMaxValues(cast.start, cast.finish)
|
|
elseif now >= cast.finish then
|
|
castbar.cast = nil
|
|
castbar:Hide()
|
|
if castbar.plate then OnStopCast(castbar.plate) end
|
|
return
|
|
end
|
|
if cast.channel then
|
|
castbar:SetValue(cast.finish - (now - cast.start))
|
|
else
|
|
castbar:SetValue(now)
|
|
end
|
|
end
|
|
|
|
function ApplyPlateExtension(plate)
|
|
Plates[plate] = true
|
|
plate.extended = CreateFrame("Frame", nil, plate)
|
|
local ext = plate.extended
|
|
ext:SetPoint("CENTER", plate, "CENTER", 0, 0)
|
|
ext:SetFrameLevel(plate:GetFrameLevel() + 1)
|
|
ext.style, ext.unit, ext.unitcache, ext.stylecache, ext.widgets = {}, {}, {}, {}, {}
|
|
ext.regions, ext.bars, ext.visual = {}, {}, {}
|
|
ext.stylename = ""
|
|
ext.plate = plate
|
|
|
|
local r = ext.regions
|
|
local b = ext.bars
|
|
local pf = plate.nameplate
|
|
if pf and pf.original then
|
|
-- pfUI already took this plate over (it re-parents the raid icon,
|
|
-- so GetRegions no longer has all six): use its references
|
|
if SHPlates.Conflicts then SHPlates.Conflicts.ReleasePlate(plate) end
|
|
local o = pf.original
|
|
b.health = o.healthbar or plate:GetChildren()
|
|
r.border, r.glow, r.name, r.level, r.levelicon = o.border, o.glow, o.name, o.level, o.levelicon
|
|
r.raidicon = pf.raidicon
|
|
else
|
|
if SHPlates.Conflicts then SHPlates.Conflicts.ReleaseShaguPlate(plate) end
|
|
b.health = plate:GetChildren()
|
|
-- Vanilla region order
|
|
r.border, r.glow, r.name, r.level, r.levelicon, r.raidicon = plate:GetRegions()
|
|
end
|
|
-- Never leave a hole if another addon moved a region away
|
|
if not r.border then r.border = ext:CreateTexture(nil, "BACKGROUND") end
|
|
if not r.glow then r.glow = ext:CreateTexture(nil, "BACKGROUND"); r.glow:Hide() end
|
|
if not r.levelicon then r.levelicon = ext:CreateTexture(nil, "BACKGROUND"); r.levelicon:Hide() end
|
|
if not r.raidicon then r.raidicon = ext:CreateTexture(nil, "BACKGROUND"); r.raidicon:Hide() end
|
|
if not r.name then r.name = ext:CreateFontString(nil, "BACKGROUND") end
|
|
if not r.level then r.level = ext:CreateFontString(nil, "BACKGROUND") end
|
|
|
|
-- Statusbars
|
|
local level = ext:GetFrameLevel()
|
|
b.healthbar = CreateStatusbar(ext)
|
|
b.castbar = CreateStatusbar(ext)
|
|
b.healthbar:SetFrameLevel(level)
|
|
b.castbar:SetFrameLevel(level)
|
|
b.castbar:Hide()
|
|
b.castbar:SetStatusBarColor(1, .8, 0)
|
|
b.castbar.plate = plate
|
|
b.castbar:SetScript("OnUpdate", function() CastbarOnUpdate(b.castbar) end)
|
|
|
|
-- Visual regions
|
|
local v = ext.visual
|
|
v.specialArt = ext:CreateTexture(nil, "OVERLAY")
|
|
v.specialText = b.healthbar:CreateFontString(nil, "OVERLAY")
|
|
v.specialText2 = b.healthbar:CreateFontString(nil, "OVERLAY")
|
|
v.healthborder = b.healthbar:CreateTexture(nil, "ARTWORK")
|
|
v.threatborder = b.healthbar:CreateTexture(nil, "OVERLAY")
|
|
v.highlight = b.healthbar:CreateTexture(nil, "OVERLAY")
|
|
v.highlight:SetBlendMode("ADD")
|
|
v.highlight:Hide()
|
|
v.castborder = b.castbar:CreateTexture(nil, "ARTWORK")
|
|
v.castnostop = b.castbar:CreateTexture(nil, "ARTWORK")
|
|
v.spellbacking = b.castbar:CreateTexture(nil, "ARTWORK") -- after the borders, so it draws over them
|
|
v.spellbacking:Hide()
|
|
v.spellicon = b.castbar:CreateTexture(nil, "OVERLAY")
|
|
-- Icons live on their own frame above the bar, so the glowing aggro
|
|
-- border (same draw layer on the bar) can't cover them
|
|
local icons = CreateFrame("Frame", nil, b.healthbar)
|
|
icons:SetAllPoints(ext)
|
|
icons:SetFrameLevel(b.healthbar:GetFrameLevel() + 3)
|
|
ext.iconFrame = icons
|
|
v.dangerskull = icons:CreateTexture(nil, "OVERLAY")
|
|
v.raidicon = icons:CreateTexture(nil, "OVERLAY")
|
|
v.eliteicon = icons:CreateTexture(nil, "OVERLAY")
|
|
-- OVERLAY like the level: on ARTWORK it shared a layer with the health
|
|
-- border, and Grey's border could end up drawn over the name
|
|
v.name = ext:CreateFontString(nil, "OVERLAY")
|
|
|
|
-- Click frame (takes the clicks and forwards them to the plate)
|
|
local clicker = CreateFrame("Button", nil, ext)
|
|
clicker:SetPoint("CENTER", plate, "CENTER", 0, 0)
|
|
clicker:SetWidth(100); clicker:SetHeight(30)
|
|
clicker:SetFrameLevel(level + 5)
|
|
clicker:RegisterForClicks("LeftButtonUp", "RightButtonUp")
|
|
clicker:EnableMouse(false)
|
|
clicker:SetScript("OnClick", function() plate:Click() end)
|
|
clicker:SetScript("OnEnter", function()
|
|
ext.hover = true
|
|
if SetMouseoverUnit and ext.unit.guid then pcall(SetMouseoverUnit, ext.unit.guid) end
|
|
end)
|
|
clicker:SetScript("OnLeave", function() ext.hover = nil end)
|
|
ext.clicker = clicker
|
|
v.level = ext:CreateFontString(nil, "OVERLAY")
|
|
|
|
v.raidicon:SetTexture("Interface\\TargetingFrame\\UI-RaidTargetingIcons")
|
|
-- textures start out visible: keep these hidden until data says otherwise
|
|
v.raidicon:Hide()
|
|
-- Prefer Blizzard's raid icon, re-parented onto our bar (what pfUI and
|
|
-- GudaPlates do): the client already knows the mark and keeps it current.
|
|
local blizzIcon = r.raidicon
|
|
if blizzIcon and blizzIcon.SetParent and blizzIcon.GetTexture and blizzIcon:GetTexture() ~= nil
|
|
and pcall(blizzIcon.SetParent, blizzIcon, icons) then
|
|
if blizzIcon.SetDrawLayer then blizzIcon:SetDrawLayer("OVERLAY") end
|
|
if pf then blizzIcon:SetTexture("Interface\\TargetingFrame\\UI-RaidTargetingIcons") end
|
|
blizzIcon:SetAlpha(1)
|
|
v.raidiconOwn = v.raidicon
|
|
v.raidiconOwn:SetAllPoints(blizzIcon)
|
|
v.raidicon = blizzIcon
|
|
ext.usesBlizzardRaidIcon = true
|
|
end
|
|
v.dangerskull:Hide()
|
|
v.eliteicon:Hide()
|
|
ext.blizzRegions = { plate:GetRegions() }
|
|
if pf and pf.raidicon then table.insert(ext.blizzRegions, pf.raidicon) end
|
|
v.dangerskull:SetTexture("Interface\\TargetingFrame\\UI-TargetingFrame-Skull")
|
|
|
|
UpdateReferences(plate)
|
|
OnNewNameplate(plate)
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- VII. World Update
|
|
-------------------------------------------------------------------------------
|
|
-------------------------------------------------------------------------------
|
|
-- Fast hide (mirrors GudaPlates): checked for every plate EVERY FRAME, before
|
|
-- anything else, straight from the client's own data, so friendly, neutral and
|
|
-- critter plates never get a chance to show.
|
|
-- critter : SuperWoW creature type, else neutral + level 1 + under 100 HP
|
|
-- hostile : never hidden here
|
|
-- neutral : hidden (theme option) unless it's your target or in combat
|
|
-- friendly : hidden (General option) unless it's your target
|
|
-------------------------------------------------------------------------------
|
|
local CRITTERS = { ["Critter"] = true, ["Kleintier"] = true, ["Bestiole"] = true, ["Alimaña"] = true,
|
|
["Animale"] = true, ["Bicho"] = true, ["Существо"] = true }
|
|
|
|
local function ShouldFastHide(p)
|
|
local ext = p.extended
|
|
local health = ext.bars.health
|
|
local name = ext.regions.name:GetText()
|
|
local guid = C.PlateGUID(p, name)
|
|
if guid and UnitIsUnit(guid, "target") then return false end
|
|
if not guid and UnitExists("target") and name == UnitName("target") then return false end
|
|
-- players: attackable ones always show, everyone else is friendly
|
|
if guid and UnitIsPlayer(guid) then
|
|
if UnitCanAttack("player", guid) then return false end
|
|
return Opt("hideFriendly") and true or false
|
|
end
|
|
|
|
local r, g, b = health:GetStatusBarColor()
|
|
if not r then return false end
|
|
local hostile = r > .9 and g < .2 and b < .2
|
|
local neutral = r > .9 and g > .9 and b < .2
|
|
|
|
-- critters
|
|
if Opt("hideCritters") then
|
|
if guid then
|
|
if CRITTERS[UnitCreatureType(guid) or ""] then return true end
|
|
elseif SHPlates.Critters and SHPlates.Critters.IsCritterName(name) then
|
|
return true
|
|
elseif neutral then
|
|
local _, hpmax = health:GetMinMaxValues()
|
|
if ext.regions.level:GetText() == "1" and hpmax and hpmax > 0 and hpmax < 100 then return true end
|
|
end
|
|
end
|
|
if hostile then return false end
|
|
|
|
if neutral then
|
|
local vars = realtheme.vars
|
|
if not (vars and vars.OpacityHideNeutral) then return false end
|
|
if guid then return not (UnitAffectingCombat(guid) or IsAngryNeutral(guid)) end
|
|
-- no SuperWoW: the aggro glow means it's fighting
|
|
return not ext.regions.glow:IsShown()
|
|
end
|
|
|
|
-- friendly
|
|
return Opt("hideFriendly") and true or false
|
|
end
|
|
SHPlates.ShouldFastHide = ShouldFastHide
|
|
|
|
local OnUpdate
|
|
do
|
|
local BORDER = "Interface\\Tooltips\\Nameplate-Border"
|
|
|
|
local function IsFrameNameplate(frame)
|
|
if frame.extended then return false end
|
|
-- a plate pfUI already processed (it blanks the border texture)
|
|
if frame.nameplate and frame.nameplate.original and frame.nameplate.original.healthbar then return true end
|
|
-- a plate ShaguTweaks rebuilt (its regions moved to frame.new): move them back first
|
|
if frame.new and frame.new.plate == frame and SHPlates.Conflicts then SHPlates.Conflicts.ReleaseShaguPlate(frame) end
|
|
local objtype = frame:GetObjectType()
|
|
if objtype ~= "Button" and objtype ~= "Frame" then return false end
|
|
local region = frame:GetRegions()
|
|
return region and region.GetObjectType and region:GetObjectType() == "Texture"
|
|
and region:GetTexture() == BORDER
|
|
end
|
|
|
|
local function ScanWorldFrame()
|
|
local children = { WorldFrame:GetChildren() }
|
|
for index = 1, table.getn(children) do
|
|
local frame = children[index]
|
|
if not Plates[frame] and IsFrameNameplate(frame) then
|
|
ApplyPlateExtension(frame)
|
|
end
|
|
end
|
|
end
|
|
|
|
function ForEachPlate(functionToRun)
|
|
for plate in pairs(PlatesVisible) do
|
|
if plate:IsShown() and plate.extended:IsShown() then
|
|
functionToRun(plate)
|
|
end
|
|
end
|
|
end
|
|
|
|
local existMouseover, func, plate
|
|
local rescanTimer = 0
|
|
|
|
function OnUpdate()
|
|
local elapsed = arg1 or 0
|
|
existMouseover = false
|
|
-- the Designer's sample may have left its own template active
|
|
activetheme = realtheme
|
|
|
|
-- Mouseover changes (the Blizzard glow region is the source of truth)
|
|
for p in pairs(PlatesVisible) do
|
|
-- the client resets plate sizes, so enforce ours every frame
|
|
-- (pfUI does the same)
|
|
ApplyFrameSize(p)
|
|
local ext = p.extended
|
|
local hide = ShouldFastHide(p)
|
|
if hide then
|
|
if not ext.fastHidden or ext:GetAlpha() > 0 then
|
|
ext.fastHidden = true
|
|
ext:SetAlpha(0)
|
|
SetPartsAlpha(ext, 0)
|
|
ApplyPlateMouse(p, false)
|
|
end
|
|
elseif ext.fastHidden then
|
|
ext.fastHidden = nil
|
|
SetSelfEcho(p, OnUpdateNameplate) -- let the theme set its alpha again
|
|
end
|
|
if p.extended.hover or p.extended.regions.glow:IsShown() then
|
|
existMouseover = true
|
|
if lastMouseover ~= p then
|
|
if lastMouseover then OnLeaveNameplate(lastMouseover) end
|
|
lastMouseover = p
|
|
OnMouseoverNameplate(p)
|
|
end
|
|
end
|
|
end
|
|
if not existMouseover and lastMouseover then
|
|
OnLeaveNameplate(lastMouseover)
|
|
lastMouseover = nil
|
|
end
|
|
|
|
-- Update queue
|
|
if echoUpdateList[OnResetNameplate] then
|
|
ForEachPlate(OnResetNameplate)
|
|
wipe(echoUpdateList)
|
|
wipe(echoSelf)
|
|
else
|
|
for f in pairs(echoUpdateList) do
|
|
echoUpdateList[f] = nil
|
|
ForEachPlate(f)
|
|
end
|
|
for p, f in pairs(echoSelf) do
|
|
echoSelf[p] = nil
|
|
if p:IsShown() then f(p) end
|
|
end
|
|
end
|
|
|
|
-- Periodic refresh (replaces 3.3.5's threat events)
|
|
pollTimer = pollTimer + elapsed
|
|
if pollTimer >= POLL_INTERVAL then
|
|
pollTimer = 0
|
|
-- report errors in chat once (many 1.12 UIs hide Lua errors)
|
|
local ok, err = pcall(ForEachPlate, OnUpdateNameplate)
|
|
if not ok then
|
|
SHPlates.lastError = err
|
|
if not SHPlates.reportedErrors then SHPlates.reportedErrors = {} end
|
|
if not SHPlates.reportedErrors[err] then
|
|
SHPlates.reportedErrors[err] = true
|
|
C.print("|cffff4040error:|r " .. tostring(err))
|
|
end
|
|
end
|
|
end
|
|
|
|
-- New plates
|
|
rescanTimer = rescanTimer + elapsed
|
|
local cur = WorldFrame:GetNumChildren()
|
|
if cur ~= numChildren or rescanTimer > 1 then
|
|
numChildren = cur
|
|
rescanTimer = 0
|
|
ScanWorldFrame()
|
|
end
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- VIII. Event Handlers
|
|
-------------------------------------------------------------------------------
|
|
do
|
|
local events = {}
|
|
local PlateHandler = CreateFrame("Frame", "SHPlatesPlateHandler", WorldFrame)
|
|
PlateHandler:SetFrameStrata("TOOLTIP")
|
|
|
|
local function UpdateTarget()
|
|
HasTarget = UnitExists("target") and true or false
|
|
targetGUID = C.GUID("target")
|
|
targetName = HasTarget and UnitName("target") or nil
|
|
if not HasTarget then currentTarget = nil end
|
|
end
|
|
|
|
function events.PLAYER_ENTERING_WORLD()
|
|
inCombat = InCombat()
|
|
UpdateTarget()
|
|
numChildren = -1
|
|
PlateHandler:SetScript("OnUpdate", OnUpdate)
|
|
end
|
|
function events.PLAYER_REGEN_ENABLED()
|
|
inCombat = false
|
|
for guid in pairs(angryNeutrals) do
|
|
if not (UnitExists(guid) and UnitAffectingCombat(guid)) then angryNeutrals[guid] = nil end
|
|
end
|
|
SetEchoUpdate(OnUpdateNameplate)
|
|
if useAutoHide and HideNameplates then HideNameplates() end
|
|
end
|
|
function events.PLAYER_REGEN_DISABLED()
|
|
inCombat = true
|
|
SetEchoUpdate(OnUpdateNameplate)
|
|
if useAutoHide and ShowNameplates then ShowNameplates() end
|
|
end
|
|
function events.PLAYER_TARGET_CHANGED()
|
|
UpdateTarget()
|
|
SetEchoUpdate(OnUpdateNameplate)
|
|
end
|
|
function events.RAID_TARGET_UPDATE() ForEachPlate(OnUpdateRaidIcon); SetEchoUpdate(OnUpdateNameplate) end
|
|
function events.UNIT_LEVEL() ForEachPlate(OnUpdateLevel) end
|
|
function events.PLAYER_CONTROL_LOST() ForEachPlate(OnUpdateReaction) end
|
|
function events.PLAYER_CONTROL_GAINED() ForEachPlate(OnUpdateReaction) end
|
|
function events.UNIT_FACTION() ForEachPlate(OnUpdateReaction) end
|
|
function events.UNIT_AURA()
|
|
if arg1 == "target" and currentTarget then
|
|
currentTarget.extended.auraDirty = true
|
|
SetSelfEcho(currentTarget, OnUpdateNameplate)
|
|
end
|
|
end
|
|
|
|
PlateHandler:SetScript("OnEvent", function()
|
|
if SHPlates.disabled then return end -- GudaPlates is running (see Guard.lua)
|
|
local handler = events[event]
|
|
if handler then handler() end
|
|
end)
|
|
for eventname in pairs(events) do PlateHandler:RegisterEvent(eventname) end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- IX. External Commands
|
|
-------------------------------------------------------------------------------
|
|
function SHPlates:ForceUpdate() forceStyleUpdate = true; SetEchoUpdate(OnResetNameplate) end
|
|
function SHPlates:Update() SetEchoUpdate(OnUpdateNameplate) end
|
|
function SHPlates:UseAutoHide(option)
|
|
useAutoHide = option
|
|
if useAutoHide and (not InCombat()) and HideNameplates then HideNameplates() end
|
|
end
|
|
function SHPlates:ActivateTheme(theme)
|
|
if theme and type(theme) == "table" then activetheme = theme; realtheme = theme end
|
|
end
|
|
function SHPlates:GetActiveTheme() return realtheme end
|
|
function SHPlates:GetPlateByGUID(guid) return GUID[guid] end
|
|
function SHPlates:SetOverlap(enabled)
|
|
overlapMode = enabled and true or false
|
|
for plate in pairs(Plates) do ApplyPlateMouse(plate, true) end
|
|
SHPlates:ForceUpdate()
|
|
end
|
|
|
|
-- After a forced reset, styles are re-applied once
|
|
local resetFrame = CreateFrame("Frame")
|
|
resetFrame:SetScript("OnUpdate", function()
|
|
if forceStyleUpdate and not echoUpdateList[OnResetNameplate] then forceStyleUpdate = false end
|
|
end)
|
|
|
|
SHPlates:ActivateTheme(SHPlates.defaultTheme)
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Designer support
|
|
-------------------------------------------------------------------------------
|
|
-- Saved piece offsets for a theme mode, e.g. SHPlatesDB.layout["Grey/DPS"]
|
|
function SHPlates.GetLayout(theme, create)
|
|
local db = SHPlatesDB
|
|
if not (db and theme and theme.family) then return nil end
|
|
local key = theme.family .. "/" .. (theme.mode or "")
|
|
if type(db.layout) ~= "table" then
|
|
if not create then return nil end
|
|
db.layout = {}
|
|
end
|
|
local t = db.layout[key]
|
|
if not t and create then t = {}; db.layout[key] = t end
|
|
return t
|
|
end
|
|
|
|
-- A fake vanilla plate (built by the designer) that SHPlates styles like any other
|
|
function SHPlates.AdoptPreviewPlate(frame)
|
|
frame.shpPreview = true
|
|
if not Plates[frame] then ApplyPlateExtension(frame) end
|
|
end
|
|
|
|
-- Restyle one plate right away (the designer's sample while dragging)
|
|
function SHPlates.RestylePlate(plate)
|
|
local ext = plate and plate.extended
|
|
if not ext then return end
|
|
wipe(ext.unitcache)
|
|
ext.stylename = ""
|
|
SetSelfEcho(plate, OnUpdateNameplate)
|
|
end
|